diff --git a/.agents/agent-knowledge.md b/.agents/agent-knowledge.md
index 3536ffe9..a8919797 100644
--- a/.agents/agent-knowledge.md
+++ b/.agents/agent-knowledge.md
@@ -1,5 +1,79 @@
 # GalNet Agent Knowledge
 
+- [模态背景静态标题](lessons/L-20261029-10-disabled-title-foreground.md)：禁用背景容器会改变标题继承的前景画刷；静态标题显式绑定 TextPrimary，弹窗验证须挂载真实主页并检查 Color/Opacity，不能只截空背景。
+
+- 2026-10-29 CI 发布门禁：release.yml 的 validate-source 在 tag push 后先 fetch master，Test-ReleaseRef.ps1 校验规范版本 tag、checkout HEAD 和 origin/master 祖先归属；build 依赖门禁，publish 只允许 tag push 且 build 成功。主分支普通 push 只跑 CI，手动运行只生成候选。Test-ReleaseGuards.ps1 的 17 项用例覆盖真实临时 Git 图和模拟七 ZIP 上传；Push 在创建 draft 前检查七 ZIP。见 docs/manual/release-packaging.md。
+
+- 2026-10-29 内置文档封装：新 galpak v3 固定 pak/game.pak 入口，含 content v3、installation 索引、settings、Gallery、characters、layout 六文档；localization.pak 每文化一个平铺文本条目。使用独立 document GPAK catalog，不加入资源覆盖。新安装 I18n/<culture> 仅外置覆盖；作者与 content v2 旧安装仍用 I18n/External。导出/安装保留 I18n、ResourcePatches、StoryPatches/<buildId> 空目录，ZIP 显式保存；兼容 v1/v2 galpak 和 content v2 读取。只读 CLI game inspect 供脚本读取 packed/legacy 描述；Sample profile 身份从 game.pak 读取 projectId。见 docs/spec/file-formats.md、docs/spec/i18n.md、features/F-20261029-02-packed-game-documents。
+- [损坏内容与启动探测](lessons/L-20261029-08-invalid-data-startup-fallback.md)：InvalidDataException 不派生 IOException；profile 身份探测显式回退，正式内容加载仍报错。
+
+- [自包含平台程序集](lessons/L-20261029-07-self-contained-platform-assemblies.md)：自包含 lib 混放 framework 与业务 DLL；契约依赖收集按 runtimepack deps 识别平台归属，不能按 corelib 同目录排除 Core/Builtins。
+
+- 2026-10-29 桌面发行布局：应用根只留入口 EXE 和目录；SDK apphost 直接指向 lib/<app>.dll，运行时与原生依赖都在 lib，清单/说明/许可在 docs。Sample 默认加载同级 pak，用户 profile 按内容 projectId 的摘要定位；玩家关闭普通参数，EnableLaunchArguments 默认跟随 EnableGameDebugging，开发发行加 -SampleFlavor Developer。galpak 统一 pak/ 外层、内部路径相对内容根；安装显式目标不追加第二层 pak。见 docs/manual/release-packaging.md、docs/spec/file-formats.md 与 features/F-20261029-01-desktop-package-layout。
+- [原生退出确认](lessons/L-20261029-06-native-exit-confirmation.md)：WM_CLOSE 只打开确认遮罩；测试须在自有 HWND 确认退出，再验证零退出码和落盘，不能用强杀替代。
+
+- [预览效果像素边界](lessons/L-20261029-04-bounded-scene-capture.md)：外层缩图不限制 CPU 效果纹理；逻辑尺寸与像素尺寸分开，正式截图仍保持完整分辨率。
+- [存档缩略图通知](lessons/L-20261029-05-save-thumbnail-notifications.md)：整表一次 Reset，保存单槽 Replace，其他行与 Bitmap 复用；异步 I/O 不会消除重复解码卡顿。
+
+- [PowerShell 宿主 API 兼容](lessons/L-20261029-03-powershell-runtime-api-compatibility.md)：Windows PowerShell 5.1 使用 .NET Framework；现代 System.IO.Path API 不能假定存在，需在 powershell.exe 与 pwsh 分别验证。
+
+- [窗口装饰与玩家配色](lessons/L-20261029-02-window-decoration-theme-resources.md)：Ursa 2.1 关闭按钮在独立 WindowDrawnDecorations；窗口共享调色板资源，完整 Fluent 样式保留在播放器根。Headless 不生成平台装饰，资源断言不能替代原生截图。
+
+- [持久字段与保存基线](lessons/L-20261029-01-content-baseline-field-completeness.md)：新增字段必须进入手写相等比较；仅改 Group.storyPackage 应 dirty，局部保存其他配置不能抹掉它。
+
+- 2026-10-28 内容打包：项目唯一 Graph，graph/group 为保留 ID 资源；GPAK v3、content v2、save v5。本体闭包先行，各剧情包只减本体；默认 128 MiB 未压缩软阈值（用户后续调大），整片缓冲不保证内存上限。资源矩阵定义在 settings 的 galnet.resourceOverrides，矩阵修改经项目事务即时持久化且撤销/重做落盘，独立导出不 Save All，运行 priority/hash 降序显式映射、会话冻结。图集旧档按覆盖来源重新解析选择意图。文本/人物整体在本体，存档保守要求准备时全部剧情包；Gallery 补丁延期。见 docs/manual/content-packaging.md、features/F-20261028-01-content-packaging/summary.md。
+
+- [可选参数与二进制 API](lessons/L-20261028-04-optional-parameter-binary-api.md)：新增可选参数仍改变 CLR 签名；公开契约保留旧签名转发，并用旧 consumer 装载当前 Core 验证。
+
+- [内部快照内容身份](lessons/L-20261028-03-internal-snapshot-content-identity.md)：新增存档身份须覆盖调试 replay、缓存和精简工厂；用非空构建身份验证，不放宽外部恢复门禁。
+
+- [PAK 索引与 payload 验证](lessons/L-20261028-02-pak-index-payload-verification.md)：MetadataIndex 不校验普通 payload；独立覆盖包准备需逐项验证，当前文件 hash 排序不能代替已知校验和。
+
+- [原生发布载荷](lessons/L-20261028-01-native-publish-payload.md)：RID/托管符号开关不能保证 native NuGet 内容自动裁掉多余架构与 PDB；在 manifest 前过滤最终应用载荷，并验收所需 x64 native 文件仍在。
+
+- 本地 CI 入口为 `scripts/ci/Invoke-CI.ps1`（默认 All，可 Coverage），Actions 调用同一脚本；SDK 精确固定为 global.json 版本。`scripts/release/Release.ps1` 生成并验收 5 个聚合 NuGet 与 Windows x64 R2R 的 Editor、纯/整合 Sample、Contracts 四 ZIP；包归属见 packaging/packages.json，操作见 docs/manual/release-packaging.md。桌面 Sample AOT 尚未通过严格链接，不能从 Headless 自检推导支持；F-20261027-04 的 summary 保留未完成项。
+
+- [Solution fixture 配置](lessons/L-20261027-11-solution-fixture-configuration.md)：solution 外引用工程可能回到 Debug，测试却读取 Release；契约 fixture 已加入 GalNet.slnx，验证构建日志和实际输出配置。
+- [源生成 init 默认值](lessons/L-20261027-12-generated-init-defaults.md)：音轨/Bus 精简 JSON 会丢失 init 属性初始化值；显式 JsonConstructor 可选参数保留容量/增益默认值，不放宽校验或改成可变 DTO。
+
+- [开放 shader 参数](lessons/L-20261027-10-open-shader-parameters.md)：已知 shader 的额外参数是合法、不解释的 JSON，保留且不 warning；声明字段仍校验，未知 shader 与封闭契约仍诊断。
+
+- [属性逻辑路径与 wire 边界](lessons/L-20261027-06-property-wire-boundaries.md)：JSON Pointer 不能穿过 JSON 字符串；引用识别、比较、复制与回写须同时迁移类型化路径。JsonArray 递归修改返回原节点时不能再次挂载该实例。
+
+- [数值模板与作者草稿](lessons/L-20261027-05-numeric-template-drafts.md)：NumericUpDown 的模板/Value 初始化不能成为作者输入；借用主题时由字段上下文拥有原始文字与提交，TextBox.PropertyChanged 同步捕获，验证挂载无草稿及输入后立即 Enter。
+
+- 2026-10-27 Group Problems 按作者历史/相关依赖自动检查内存工作版，代次阻止旧结果发布，合法待提交不计条目错误。Editor numeric 默认保留文字的上下框，显式 numericupdown/numerictext 与 slider+精确输入；long/ulong/decimal 保留文本。前导小数点仅在类型化数字编辑入口规范化，JSON 源码仍严格。规范见 docs/spec/editor-groups.md、control.md；证据见 features/F-20261023-01-editor-uiux/follow-up-group-diagnostics-numeric-20261027.md。
+
+- 2026-10-27 音频创作：类型 ComboBox/目录参数表单，apply 隐藏自动身份，stop/update 选择剧情位置之前的直接挂载实例；显式 all 与参数 patch 更新已实现。复用 Scene 作者语义、Graph/前缀分析和项目查询，AudioEffect 域按 scope/target/instance 限定，AudioEffects/AudioComplete/AudioRevision 独立于视觉候选。见 docs/spec/editor-scene-targets.md、docs/manual/audio-mixing.md、features/F-20261027-01-audio-mixer/authoring-summary.md；既有 Timeline Flyout 测试保留。
+
+- [构建完成后再启动 no-build 测试](lessons/L-20261027-04-build-before-no-build-tests.md)：session_id 表示仍在运行；同一输出根的构建/测试重叠会锁定 DLL 并可能验证旧产物，必须确认 build exit_code=0 后再启动测试。
+
+- [Timeline 停止与事件收尾](lessons/L-20261027-03-timeline-stop-event-cleanup.md)：完成轨道不等于执行末帧事件；停止需等待完整收尾，循环初始化/迭代/结束清理分别处理，初始化期间的停止也必须生效。
+
+- 2026-10-27 音频 PCM：实例拥有 gain/淡入淡出/结束处理，Track 管理顺序/随机和循环队列，Bus 实际汇总后执行共享效果。Media.Audio 为跨平台混音/DSP，Media.Miniaudio 为 Windows x64 设备/解码；LibVLC 仅保留视频/Gallery。默认项目 section v2（audioBuses/busId），音频状态 tracks/seffects v2、channels v1；SEffect scope/targetId 与真实滤波/混响见 docs/manual/audio-mixing.md。实现和验收限制见 features/F-20261027-01-audio-mixer/summary.md。
+
+- [分数延迟环绕边界](lessons/L-20261027-02-fractional-audio-delay-wrap.md)：float 负分数位置加长度后可能舍入到长度本身；使用 double 并复核上边界，默认参数与非默认参数均验证。
+
+- 2026-10-27 默认视觉库：模板部署为项目 shader 资产，defaultVisualPrograms 仅用于创作填充；预设保存显式 program/blurProgram GUID 并编译为 timeline.play。CPU/GPU 层链注入当前 layerZ，texture 参数租约归效果实例。project visuals install 显式补入且不覆盖已有绑定/占用路径。见 docs/manual/default-visuals.md 和 features/F-20261026-03-default-visual-library；[采样像素与视觉 QA](lessons/L-20261027-01-shader-sampling-visual-qa.md)。
+
+- 2026-10-26 Sample 扩展边界：默认会话通过 IAvaloniaPlayerSettings/IPlayerStartup 消费项目偏好；默认页面 VM 可扩展、DI 使用 TryAdd。AttachPlayer/AttachRun 接入项目借用绑定并优先异步释放。外部剧情变量走 Engine.SetVariablesAsync/UpdateVariablesAsync，同步提交显式 scope 值并合入稳定快照；业务模块自行定义复杂状态恢复。AvaloniaPlayerLocalization 归 Avalonia.GameHost，中立 JSON 查询归 GameHost，Sample 不再共享 GameLocalizationProvider 源文件。见 features/F-20261026-02-sample-extensibility 与 docs/manual/customize-avalonia-sample.md。
+
+- [Ready 与宿主活动状态](lessons/L-20261026-06-ready-is-not-session-end.md)：Ready 是恢复/Seek 的中间准备状态，默认宿主保留已有 IsPlaying，不应触发返回标题。
+
+- [原生 Sample 窗口与显式用例验证](lessons/L-20261026-05-native-sample-window-validation.md)：Process.MainWindowHandle 可能选择无标题 native helper；仅对自有 PID 的明确 Sample 窗口发 Close，并核对显式测试实际执行数。
+
+- [配置 schema 与 JSON 字段身份](lessons/L-20261026-04-configuration-json-casing.md)：精确 ID 校验后须同样按大小写精确解码 DTO，避免未知大小写字段覆盖已验证值；原始未知字段继续保留。
+
+- [查询事实与写入上下文](lessons/L-20261026-03-query-result-and-write-context.md)：候选结果版本不能代替写入方身份/基线版本；异步准备按局部作者依赖与资源代次续租，相关变化再撤销不能复活旧选择。
+
+- [作者代次与视图生命周期](lessons/L-20261026-02-author-incarnation-view-lifetime.md)：作者删除/换类型使旧绑定失效；页面关闭只释放表单，不推进作者 incarnation，项目草稿须跨页面继续共享并可保存。
+
+- [基线对照恢复与增量时间戳](lessons/L-20261026-01-baseline-restore-timestamps.md)：恢复源码备份可能保留早于基线 DLL 的时间戳，候选验证需独立输出、Rebuild 或显式失效增量构建，并核对源字节。
+
+- [空本地化引用边界一致性](lessons/L-20261025-10-empty-localization-references.md)：作者索引、启动加载和运行解析都将空引用按空文本处理；空对象/数组不触发 opaque，非空未知结构仍保留诊断。
+
+- [资源结构与缓冲重基](lessons/L-20261025-01-variant-buffer-structural-rebase.md)：ManagedContent 的写盘内容来自项目文档 Data；移动时内部 folder 要分别重基工作版和保存版，Undo/Redo 保留之后保存的其他配置。
+
 - [必填字符串与 schema 默认值](lessons/L-20261024-01-required-string-defaults.md)：Required 字段有默认值仍会被 Normalize 补齐；要求显式提供且空串合法时不声明 schema 默认，并显式 AllowNull=false。DTO 构造函数赋值不导出为 schema 默认。
 
 - [契约与 Git 构建元数据](lessons/L-20261023-02-contract-git-metadata.md)：SDK 的 InformationalVersion 可包含 commit；严格 DLL 哈希需要稳定非功能元数据，并用不同 SourceRevisionId 重建比较验证。
@@ -38,7 +112,7 @@
 
 ## 项目事实（已从仓库文档确认）
 
-- 宿主分层已落地：GameHost 提供 GameSession/IGameRun/GameRun、PlayerSession、PlayerPreferences/PlayerStartup；Avalonia.GameHost 提供默认页面会话、运行绑定、展示组合、资源预加载和设置/输入/窗口适配。Sample 仅保留项目配置、启动适配、本地化和调试。中立应用接口在 Presentation.Abstractions.Application，共享音频后端在 Media.LibVlc；项目删除与 ProjectTools.Windows 已移除。见 docs/spec/architecture.md。
+- 宿主分层已落地：GameHost 提供 GameSession/IGameRun/GameRun、PlayerSession、PlayerPreferences/PlayerStartup；Avalonia.GameHost 提供默认页面会话、运行绑定、展示组合、资源预加载和设置/输入/窗口适配。Sample 仅保留项目配置、启动适配、本地化和调试。中立应用接口在 Presentation.Abstractions.Application，共享音频混音/DSP 在 Media.Audio，Windows 适配在 Media.Miniaudio；项目删除与 ProjectTools.Windows 已移除。见 docs/spec/architecture.md。
 
 - 解决方案入口是 `GalNet.slnx`。
 - `docs/spec/` 描述已经实现的稳定事实；`docs/manual/` 描述二次开发路径；`features/` 保留实现过程和历史。
@@ -46,17 +120,22 @@
 - Entry 契约与执行已分离：IEntryModule 只含 schema/composite，IPrimitiveModule 按领域共享状态并贡献完整指令 ID；GameRegistration 独立注册，AddBuiltins 为完整内置运行入口；独立 GalNet.Contracts.Builtins 只依赖 Core，CreateAllModules 返回 14 个组件模块，包含 custom.invoke 的固定双字符串 schema。可选 schema、部分内置实现或全自定义；仅完整 ID 排他。同前缀和 schema 模块名可重复。音频用 AudioRuntime + IAudioPlaybackHost 组合，不强制继承。见 docs/spec/runtime.md、docs/spec/entry-types.md 和 docs/manual/。
 - 当前 GameSnapshot 版本为 4，不兼容旧版；持久数据在注册式 GameState 表中，快照为 StateId → version/JSON payload；读档先验证，再取消旧 scope 并替换整个状态根。Engine 不拥有执行 view，宿主先释放 Engine，再异步释放 view 与后端。
 - Engine 提供终态 StopAsync 和 StateChanged，覆盖玩家推进、Choice 与阻塞实例自然完成；GameHost 仅协调应用会话，不复制 Engine 执行机制。AvaloniaGamePresenters 只组合端口，AvaloniaGamePresentation 管理平台资源。见 docs/spec/runtime.md 和 docs/spec/architecture.md。
-- Presentation.Defaults 已删除，空 NullGameView 位于展示抽象的 View 命名空间；当前程序集布局见 docs/spec/architecture.md。GameContent.Settings 包含项目设置，项目/安装加载器与两个 Sample 已接通自定义音频轨道配置。
+- Presentation.Defaults 已删除，空 NullGameView 位于展示抽象的 View 命名空间；当前程序集布局见 docs/spec/architecture.md。GameContent.Configuration 保存版本化 section 文档；默认作者模型位于可选 Contracts.Builtins，项目/安装加载器通过 GameContentLoadOptions 接收 schema 与文化代码投影。
 - 旧的 `GalNet.Control` 与 `GalNet.Control.Abstraction` 已完成迁移并删除；当前共享 Avalonia 游戏页面唯一入口是 `GalNet.Avalonia.GameView`，页面架构见 `docs/spec/control.md`。
 - 持久条目先在 `GameState.Update` 中修改唯一数据记录，再通知展示层；模块通过 PrimitiveRegistry.State/Restore/ValidateState 声明状态、恢复依赖和校验，宿主使用展示抽象 StateRestoreSession 统一恢复、等待和逆序清理。旧 SceneState/Active* 镜像与 Builtins 中央 replay 已删除。
 - 视觉扩展应通过展示抽象和渲染端口接入；不要把平台类型或渲染资源泄漏进 Core/Runtime。
 - 新增 feature 的长期实现意图记录在其自身 feature 目录；只有已验证的稳定事实才合并到 docs/spec/。
 
 - 玩家变量桥接实现为 Runtime.Variables.PlayerVariableService，存储通过 IPlayerVariableStore 注入；Variable.Clone 保留 Uid，VariableValue 不可变，可共享。Runtime loader/SaveManager 不执行文件 I/O。见 docs/spec/architecture.md。
-- Runtime.I18n.GameTextResolver 提供 culture-first、父文化与默认文化回退，只依赖宿主查询委托；DynamicLocalization/JSON 适配留在 Sample 的 GameLocalizationProvider。见 docs/spec/i18n.md。
+- Runtime.I18n.GameTextResolver 提供 culture-first、父文化与默认文化回退，只依赖宿主查询委托；中立 JSON 文本源归 GameHost.Content，DynamicLocalization 适配归 Avalonia.GameHost.AvaloniaPlayerLocalization。见 docs/spec/i18n.md。
 - Assets 的 AssetFileMaterializer 经 IAssetManager acquire 字节实体化媒体；Core 的 AssetFileLease 持有文件租约。Sample 将同一实例供音频/视频/Gallery 使用，最后租约释放才删除文件。见 docs/spec/assets.md。
 - 已读进度 MarkRead 只写 Runtime ReadProgressIndex；文件实现默认 2 秒批量提交，失败保留 dirty revision 并重试。Engine StopAsync、Sample 存档和进度对象销毁均等待 flush，失败向调用者传播；后台失败可读 LastPersistenceError。见 docs/spec/runtime.md。
 
+- 核心重构当前边界：Runtime 仅引用 Core；场景/音频/Gallery/差分图片契约与纯算法归 Contracts.Builtins，音频执行与按 GameState 根隔离的场景管理归 Primitives.Builtins。Core 的 keySpace 身份索引按状态注册选择，不认识场景类型。GameContent/加载配置与 Gallery 玩家组合归 GameHost。见 docs/spec/architecture.md。
+- 项目模型与运行输入：ProjectConfiguration 提供版本化 section/普通 DTO，Editor 通用表单、命令、历史、保存、导出和安装使用项目 schema，未知 JSON 保留。宿主通过 SelectProjectOptions 显式投影，Engine 只消费 PlaybackOptions，音频只消费 AudioConfiguration/AudioMixOptions，文本直接接收速度。变量声明只保存在作者 Graph。见 docs/manual/new-presentation-layer.md。
+- AudioConfiguration/AudioMixOptions 位于 Contracts.Builtins.Audio，允许任意 Bus/Track 及空/未路由 Track；混音为 master/bus/track，快进保留由显式 PreserveDuringCatchUp 控制。Sample/模板显式选择三 Bus 示例，默认模块不注入固定轨道。
+- EntryDefinition.DynamicParameters 是唯一参数源，Parameters/Defaults/Options 副本及旧 ABI 适配已删除；具体编辑器投影位于 Editor.Abstraction.Schemas，Effect/SEffect 基础约束共用 ValueValidation，领域 stage/scope 继续分别拥有。
+
 ## 文档分层
 
 - `features/<feature-id>/`：一次实现的需求、设计、阶段计划、审核和人类可读总结。
@@ -267,3 +346,40 @@
 - [外部调试子进程监控生命周期](lessons/L-20261024-03-external-debug-child-monitor-lifetime.md)：断开调试不能等待未终止的外部进程退出；Editor 存活时仍需排空重定向输出并隔离旧会话事件。candidate，待运行复现。
 - [异步构建的同步前缀](lessons/L-20261024-04-sync-build-work-ui-thread.md)：Task API 首个 await 前的验证、扫描与编译仍会阻塞调用线程；先在 UI 线程捕获安全快照，再后台运行纯构建工作。candidate，待大项目运行复现。
 - [动画帧颜色与主题](lessons/L-20261024-05-animated-brush-measurement.md)：中间帧比较须纳入 Brush.Opacity，并显式使用实际 ThemeVariant；只看 Color 或默认资源会误报跳色。
+
+- [Benchmark 条件引用与还原图](lessons/L-20261025-02-benchmark-restore-graph.md)：Benchmark 使用独立 bin/benchmark、obj/benchmark 和锁文件；切换条件依赖后不能跳过 restore，以实际运行验证 deps。
+
+- [Avalonia benchmark 退出码](lessons/L-20261025-03-avalonia-benchmark-exitcode.md)：窗口生命周期可覆盖提前设置的 Environment.ExitCode；宿主返回后的 finally 重申失败，脚本同时验证退出码与 Ready。
+- CPU 启动事件：Benchmark=true 启用独立 GalNet.Diagnostics 与方法内 #if BENCHMARK 埋点，普通宿主无诊断依赖；scripts/benchmark-startup.ps1 自动采集 Editor/Sample，契约和用法见 docs/spec/cpu-benchmark.md、docs/manual/cpu-benchmark.md。
+
+- [角色姓名文本与身份](lessons/L-20261025-04-character-name-key-identity.md)：DisplayNameKey 允许共享，角色草稿按 ID 与姓名文本组合区分；仅始终唯一的姓名文本可辅助跟随改名，提交仍检查原基线。
+- 2026-10-25 Editor 面板：变量以项目级 VariablePanelState 保存作用域选择与 UID 草稿，角色用 CharacterPanelState 隔离共享姓名身份；视图和 transient VM 正常释放，Save All 仍只保存两者已应用声明。本地化筛选保留单元格身份，冻结上下文保持单套虚拟化行；见 features/F-20261023-01-editor-uiux/phase-ui-20261025.md。
+
+- [启动固定快照交错对照](lessons/L-20261025-05-paired-startup-baselines.md)：机器缓存/负载可使同一 exe 跨轮大幅漂移；固定 SHA256、AB/BA 配对和同一 ready 口径，不用单次 smoke 宣称收益。
+- Editor 启动在 MainWindow 构造完成时准备欢迎页；Loaded 不再重置导航。20 对交错实验确认小幅收益，主题与 Acrylic 探测均回退；见 features/F-20261025-01-cpu-startup-benchmark/experiments.md。
+
+- [ReadyToRun 与契约身份](lessons/L-20261025-06-r2r-contract-identity.md)：发布转换必须排除严格契约闭包并验证原始字节。Editor/Sample 的 WindowsReadyToRun 配置隔离 bin/obj/lock；仅发布程序获得预编译收益，见 docs/manual/ready-to-run.md。
+- 启动调用栈：scripts/profile-startup.ps1 显式打开 Benchmark 的 GalNet-CPU EventPipe 镜像，scripts/analyze-startup-trace.cs 对齐 JIT/采样；采样只做诊断，收益仍用无采样固定快照交错比较。
+
+- [TraceEvent 事件保留](lessons/L-20261025-07-traceevent-retained-events.md)：迭代器复用事件对象；立即提取字段，或 Clone 后再保留。原生启动诊断使用 scripts/profile-startup-native.ps1 和 analyze-startup-native.cs，拒绝已有 WPR 会话和丢事件 trace，见 docs/manual/cpu-benchmark.md。
+
+- Editor 正常 Main 在 Avalonia 初始化前启动两个 Task.Run：设置读取与本地化数据准备；完成后交给 UI/DI，文化/主题/控件仍在 UI 线程，设计器保留同步回退。20 对复核改善约 4.1%；WGL 探测未达收益门槛，默认 ANGLE 保持，见 features/F-20261025-01-cpu-startup-benchmark/parallel-native.md。
+
+- 2026-10-25 本地化资源表实测修订：正文/摘要左上对齐；输入本地保留，失焦/Ctrl+Enter/Save All 提交，不逐字刷新项目。表头与正文明确靠左，隐藏语言使表格窄于视口仍对齐。语言移除保留翻译文件且可撤销，列宽与可见性保留在项目会话；见 features/F-20261023-01-editor-uiux/follow-up-localization-20261025.md。
+
+- [变窄表格的表头左边界](lessons/L-20261025-08-localization-header-alignment.md)：显式宽度的表头与正文都指定 Left；真实布局覆盖内容从宽于视口变成窄于视口。
+
+- [同步捕获待提交输入](lessons/L-20261025-09-textchanging-local-input.md)：Avalonia TextChanged 在渲染后异步触发；TextChanging 同步更新本地输入，作者提交仍只在失焦/明确保存边界进行。
+
+- [静态引用不完整警告](lessons/L-20261025-11-static-reference-warning.md)：References 正常带 references.partial warning；消费方按 error/实际引用拒绝，并保留 ReferencesComplete=false，不能用诊断总数判失败。
+- 外部项目创作：CLI project.apply 使用期望哈希和原生文件清单，同事务发布 Graph/Group/资源/本地化；产品 Skill 在 skills/galnet-project-authoring，随 CLI 分发。Editor 通用热重载采纳干净项目，在同一 scope 推进所有基线并清除旧历史；本地草稿冲突保留，Contracts DLL 仍需重开。见 features/F-20261025-02-external-project-authoring/summary.md 与 docs/manual/external-project-authoring.md。
+
+- 2026-10-26 引擎核心重构已完整验收：P0–P6、R1–R8 verified，1789 项普通与 10 项原生测试通过；完整构建/locked restore/格式通过。当前架构事实见前述及 docs/spec，分阶段提交与原始失败证据见 features/F-20261026-01-engine-core-simplification/summary.md。性能专项按用户要求延期。
+
+- [原生音频 UTF-8 ABI](lessons/L-20261027-06-native-audio-utf8-abi.md)：Windows miniaudio 窄字符 fopen 使用 ANSI；统一 UTF-8 ABI 后内部转宽字符，托管/原生同步升级。跨平台构建与 AOT 限制见 docs/manual/cross-platform-backends.md。
+
+- [完整 MSVC 工具集选择](lessons/L-20261027-07-complete-msvc-toolsets.md)：按目标架构检查编译器、头文件和 CRT，再显式选择并存工具集；Windows ARM64 原生库已用 14.44 交叉编译并核对 PE/ABI，x64 保持 14.51。
+- [NativeAOT 与编译工具隔离](lessons/L-20261027-08-aot-build-tool-isolation.md)：标准 PublishAot 不能污染 netstandard 源生成器，restore 图和开发锁需隔离；复用 Headless Sample 自检，见 docs/manual/native-aot.md。
+- [源生成 extension data](lessons/L-20261027-09-sourcegen-extension-data.md)：GalleryAnnotation 的 init 字典触发构造绑定限制，改用 set 并验证未知字段往返。
+
+- 2026-10-29 默认播放器对白历史/重播/已读颜色：历史正文只在实际保存时进入 GameSnapshot.Attachments，host.dialogue.history 状态只保留计数；同 Group、同 rawId 的相邻 audio.play 与文本按本次执行关联，重播使用独立后端 voice，任何有效继续均停止。阅读前导不能成为半句稳定快照，见 [阅读前导快照边界](lessons/L-20261029-09-reading-preamble-checkpoints.md)、docs/spec/control.md、runtime.md 和 features/F-20261029-03-dialogue-history。
diff --git a/.agents/lessons/L-20260922-01-dotnet-build-sandbox.md b/.agents/lessons/L-20260922-01-dotnet-build-sandbox.md
index 7dabc98b..50834f2f 100644
--- a/.agents/lessons/L-20260922-01-dotnet-build-sandbox.md
+++ b/.agents/lessons/L-20260922-01-dotnet-build-sandbox.md
@@ -31,3 +31,7 @@ Codex 受限 workspace 中的 GalNet .NET/Avalonia 构建与测试。
 
 - `features/F-20260922-01-entry-instance-runtime/phase-plan.md`
 - 成功验证命令：`dotnet build test/GeneralTest/GeneralTest.csproj --no-restore -m:1 -v:minimal -p:UseSharedCompilation=false`
+
+## 2026-10-26 补充：还原也应限制 MSBuild 并发
+
+F-20261026-01 的 R4a 隔离还原使用默认 dotnet restore 调度时没有输出诊断即退出 1，并遗留 380 个同一父进程启动的 MSBuild /nodemode:1 /nodeReuse:true worker。具体退出根因尚未确认，不把它归因于业务代码。通过进程父 ID、命令行和启动时间确认归属后，只清理本次遗留 worker；保留用户 Editor 与其他进程。相同 locked/artifacts 参数加 --disable-parallel -m:1 /nr:false 后还原成功。还原与构建均优先使用串行、不复用节点的验证参数；命令返回 running session 时须等待实际结束，不能把一次等待超时视为结束后启动下一构建。
diff --git a/.agents/lessons/L-20261014-05-headless-session-publication-race.md b/.agents/lessons/L-20261014-05-headless-session-publication-race.md
index a6ba0672..f0f2f1e0 100644
--- a/.agents/lessons/L-20261014-05-headless-session-publication-race.md
+++ b/.agents/lessons/L-20261014-05-headless-session-publication-race.md
@@ -8,3 +8,9 @@
 两次 Presentation 全回归各出现一次 DisposeAsync NullReferenceException，分别发生在不同测试，产品断言均通过。Avalonia 12.0.5 的 HeadlessUnitTestSession.StartNew 在 Task.Run 回调里用闭包 task 构造会话，而外部 task 赋值尚可能未完成；DisposeAsync 等待此引用时会空引用。源码：https://github.com/AvaloniaUI/Avalonia/blob/12.0.5/src/Headless/Avalonia.Headless/HeadlessUnitTestSession.cs。
 
 Presentation 测试改用官方 GetOrStartForAssembly 配合 AvaloniaTestApplication 特性，由框架缓存会话，测试不逐项释放缓存 worker。默认 PerTest 隔离仍使每次 Dispatch 重新建立和释放应用 scope。测试必须自己关闭窗口并释放产品资源；不能捕获并吞掉任意产品异常或用成功重试掩盖断言失败。此调整避免反复创建/释放会话，不修改第三方源码，也不声称修复其内部启动竞态。
+
+2026-10-26 引擎重构 R4a：Editor 隔离全回归中的 TimelineKeyDetailsBatchEditInterpolationTangentsUnitsAndPresetsThroughMountedControls 在 HeadlessUnitTestSession.DisposeAsync 发生一次空引用（调用点为测试 await using 收尾）。定向 1 项与完整 Editor 323 项重跑通过，未修改 Timeline 产品代码；原日志 r4a-editor-tests.log 与重跑日志 r4a-timeline-recheck.log/r4a-editor-recheck.log 保留。该现象与上述已知竞态的失败位置一致，不把一次成功重跑表述为框架问题已修复。
+
+2026-10-26 R6/R8：Editor 全回归再次在 CharacterNestedListFieldUsesSemanticEditorAndRenameUpdatesStoredWirePath 的 DisposeAsync 复现相同空引用，319 项通过；该用例独立复核通过。R8 将 Editor 与剩余 Integration 的 StartNew/逐项 Dispose 改为官方 GetOrStartForAssembly，复用各自既有 application builder，保留每项 Dispatch、窗口关闭与产品资源释放。不捕获该空引用、不删除功能断言；完整复核结果见 feature R8。
+
+R8 最终完整复核：Editor 320、Integration 128 项全部通过；缓存 worker 的改动保留了普通用例的完整执行，没有跳过或捕获框架失败。
diff --git a/.agents/lessons/L-20261022-02-selector-preparation-generation.md b/.agents/lessons/L-20261022-02-selector-preparation-generation.md
index e3b85142..f70bded8 100644
--- a/.agents/lessons/L-20261022-02-selector-preparation-generation.md
+++ b/.agents/lessons/L-20261022-02-selector-preparation-generation.md
@@ -14,3 +14,8 @@
 
 适用：异步准备资源后再呈现候选的字段、Timeline 或类似选择 lease。
 禁止：无条件接受等待后的当前快照；只在预热后验证选择；仅因预期的后台准备推进结果版本而永久禁用本次选择。
+
+
+GC4 后续（2026-10-26）：托管选择器现在按查询局部作者依赖版本和资源代次检查准备请求，允许无关作者修改保留请求；写入方上下文另有版本，详见 [查询事实与写入上下文](L-20261026-03-query-result-and-write-context.md)。原始整作者快照身份是当时的保守实现，不是永久要求全局失效。
+
+2026-10-28 远端 CI 跟进：首次远端运行 40559879643 在上述冷图集用例的初始 Select 失败。项目/条目创作会自动 QueuePreparation，测试若在插入条目之后才设置资源 Gate，先前启动的读取仍可在查询快照与选择之间完成。测试应在创建项目/服务之前安装 Gate，并断言显式释放前 PrepareAsync 未完成，不能用机器速度推断“冷启动”。
diff --git a/.agents/lessons/L-20261024-01-required-string-defaults.md b/.agents/lessons/L-20261024-01-required-string-defaults.md
index 6aa85c7d..667cb9dc 100644
--- a/.agents/lessons/L-20261024-01-required-string-defaults.md
+++ b/.agents/lessons/L-20261024-01-required-string-defaults.md
@@ -12,3 +12,5 @@
 证据：CustomActionTests.Contract_rejects_invalid_arguments_before_handler_creation 初轮缺 argument 的用例失败，调整 DTO 声明后通过；显式 null 也有拒绝回归。编译入口额外断言两个字段 IsRequired、AllowNull=false、DefaultValue=null。
 
 适用范围：可接受空串但不接受缺省/null 的 DTO 字段。不要把 Required=true 等同于“即使有默认值也必须显式提供”，也不要为了局部字段语义修改全局 Normalize 的默认值规则。关联：docs/spec/entry-types.md、docs/manual/custom-actions.md。
+
+复现补充：F-20261026-01 引擎重构 R3 自定义音频中，将 TrackId 从固定 bgm/vocal 改为 Required 时，保留空串属性初始化值同样导致省略参数仍通过。统一改为构造函数初始化，并对全部普通音频/语音 schema 断言 DefaultValue=null、缺省/null 拒绝；不要仅改 Required 标记。
diff --git a/.agents/lessons/L-20261025-01-variant-buffer-structural-rebase.md b/.agents/lessons/L-20261025-01-variant-buffer-structural-rebase.md
new file mode 100644
index 00000000..ab861fd3
--- /dev/null
+++ b/.agents/lessons/L-20261025-01-variant-buffer-structural-rebase.md
@@ -0,0 +1,15 @@
+# 资源结构重写必须覆盖已跟踪缓冲
+
+状态：confirmed
+日期：2026-10-25
+来源：资源 ID、选择器缓存与文件移动同步修复
+
+现象：移动 `.variants` 或其图片目录时，文件事务已计算新 folder，但打开过的描述文件由 ProjectContentSession 的 ManagedContent 写出；仅修改事务备份不能改变实际写出的缓冲内容。
+
+根因：ProjectFileOperation 的非托管 Copies 会跳过 ManagedContent；ProjectContentSession 从保存版 EditorFileDocument.Data 写出文件。原 FileChange.Apply 只移动 Path，没有对工作版和保存版的 Data 分别重基。
+
+正确做法：在结构变更的 Apply 内根据当前文档位置和当前 folder 重算路径，分别转换工作内容与最近保存内容；验证也覆盖两份转换后的文档。Undo/Redo 从当时的配置重算，不能恢复首次捕获的整份 JSON，否则会回退之后保存的 default 或 dimensions。
+
+验证：ResourceIdentityTests.cs 中 OpenVariantBufferRebasesFolderAndPreservesSavedAndUnsavedChanges 的描述移动/图片目录移动两例均通过，覆盖打开的 Inspector、未保存 default、磁盘保存基线、Save 后 Undo/Redo。关联规范：docs/spec/editor-files.md。
+
+适用：文件结构操作会重写内部关系，且文件可进入项目文本缓冲的场景。禁止仅改路径/磁盘备份或以未打开文件的测试替代缓冲生命周期验证。
diff --git a/.agents/lessons/L-20261025-02-benchmark-restore-graph.md b/.agents/lessons/L-20261025-02-benchmark-restore-graph.md
new file mode 100644
index 00000000..487fd623
--- /dev/null
+++ b/.agents/lessons/L-20261025-02-benchmark-restore-graph.md
@@ -0,0 +1,9 @@
+# 条件引用必须匹配 restore 图
+
+状态：candidate
+来源：features/F-20261025-01-cpu-startup-benchmark
+
+现象：Benchmark=true 的 Editor 编译通过，但启动在 Main 抛 FileNotFoundException: GalNet.Diagnostics；输出目录缺 DLL，deps/assets 也不含它。
+已确认的直接原因：编译器看见了条件 ProjectReference，运行时依赖清单却来自不含该引用的还原结果。工作区存在普通模式构建，无法仅凭日志断言哪次 restore 覆盖了 assets。
+正确做法：切换影响依赖图的属性时允许 restore，不能用 --no-restore 证明运行时成功。Benchmark 单独使用 bin/benchmark、obj/benchmark 和独立锁文件；固定路径 Content 也必须读取同模式产物。修改 BaseIntermediateOutputPath 时继续排除整个 obj/bin，避免把另一模式生成代码编入源码。
+不要只凭编译成功交付条件依赖构建；实际启动并验证 trace。不要归因于尚未证实的其他进程。
diff --git a/.agents/lessons/L-20261025-03-avalonia-benchmark-exitcode.md b/.agents/lessons/L-20261025-03-avalonia-benchmark-exitcode.md
new file mode 100644
index 00000000..bd7ee7c7
--- /dev/null
+++ b/.agents/lessons/L-20261025-03-avalonia-benchmark-exitcode.md
@@ -0,0 +1,8 @@
+# Avalonia 生命周期结束后重申 benchmark 失败退出码
+
+状态：confirmed
+来源：features/F-20261025-01-cpu-startup-benchmark
+
+现象：Sample 初始化失败时 trace 正确记录 Startup.Failed，Complete 中也设置 Environment.ExitCode=1，但关闭窗口后子进程仍返回 0。脚本通过检查 Ready 缺失才拒绝了该运行。
+修正：StartupBenchmark 保留 Failed 状态，宿主在 StartWithClassicDesktopLifetime 返回后的 finally 中重申退出码。无效游戏内容的最终集成检查确认进程返回 1，失败 trace 保留，脚本不生成成功摘要。
+规则：不要依赖窗口仍运行时设置的 Environment.ExitCode；桌面宿主可能在生命周期结束时覆盖它。脚本同时验证退出码和协议完成标记，不能仅以其中之一判断成功。
diff --git a/.agents/lessons/L-20261025-04-character-name-key-identity.md b/.agents/lessons/L-20261025-04-character-name-key-identity.md
new file mode 100644
index 00000000..5904cb73
--- /dev/null
+++ b/.agents/lessons/L-20261025-04-character-name-key-identity.md
@@ -0,0 +1,15 @@
+# 姓名文本 key 不能替代角色身份
+
+状态：confirmed
+日期：2026-10-25
+来源：features/F-20261023-01-editor-uiux/phase-ui-20261025.md
+
+现象：若角色草稿和选择只按 DisplayNameKey 缓存，两个共享姓名文本的角色会互相取得草稿；删除一个角色后还可能选中另一个角色。
+
+根因：CharacterCatalog 只校验角色 ID 唯一，允许多个角色使用同一 DisplayNameKey。GUI 新建默认生成不同姓名文本 key，不代表所有合法作者数据都具有该唯一性。
+
+验证：源码 CharacterCatalog 的唯一约束与 CharactersSharingANameTextNeverShareDraftsOrAcquireADeletedCharactersSelection 回归共同覆盖；角色 ID 改名跟随与旧基线拒绝另有连续性回归。
+
+正确做法：按角色 ID 与姓名文本 key 组合区分草稿。仅在会话中始终未出现共享的姓名文本 key 上允许推断 ID 改名；一旦出现共享，不凭文本 key 合并身份。重基缓存键时保留原声明基线，使外部修改后的提交仍接受冲突检查。
+
+适用：角色表、引用选择、搜索投影与项目级草稿。禁止将文本 key、显示名或行号当作普遍唯一的作者对象身份。文本共享与作者对象身份是不同契约。
diff --git a/.agents/lessons/L-20261025-05-paired-startup-baselines.md b/.agents/lessons/L-20261025-05-paired-startup-baselines.md
new file mode 100644
index 00000000..7997f7d2
--- /dev/null
+++ b/.agents/lessons/L-20261025-05-paired-startup-baselines.md
@@ -0,0 +1,9 @@
+# 启动优化使用固定二进制交错对照
+
+状态：confirmed
+来源：features/F-20261025-01-cpu-startup-benchmark/experiments.md
+
+证据：同一个提前准备欢迎页的 exe 快照，在主题探测中作为基线 median 1907.65ms，在后续 Acrylic 探测中作为基线 median 1473.09ms；这段变化没有基线源码优化。前后顺序跑两批、或拿最后一次 smoke 与早期基线相比，会把缓存和机器负载漂移归功于代码。
+做法：固定可运行快照和程序集 SHA256，两版各预热，再 AB/BA 配对交错，使用同一个 ready 定义；一次改变一个因素，边缘结果补反向验证，提前规定保留门槛。编译和重负载测试不与测量并行。
+验证：提前准备欢迎页 20 对 median 1938.59→1834.01ms，14 对更快，行为检查通过后提交。主题与 Acrylic 探测未达门槛，逐字节恢复原 XAML。原始 trace 和 metadata 在 artifacts/benchmarks，结论保存在 feature 文档。
+禁止：跨轮拼接绝对时间当作优化趋势；只凭单次最快值提交；更改 ready 定义后宣称启动变快。
diff --git a/.agents/lessons/L-20261025-06-r2r-contract-identity.md b/.agents/lessons/L-20261025-06-r2r-contract-identity.md
new file mode 100644
index 00000000..2cfb64f9
--- /dev/null
+++ b/.agents/lessons/L-20261025-06-r2r-contract-identity.md
@@ -0,0 +1,18 @@
+# ReadyToRun 与严格契约字节身份
+
+状态：confirmed
+
+现象：ReadyToRun 发布会转换输入 IL 程序集；即使反射/schema 语义相同，发布 DLL 的 SHA256 也可能变化。
+
+根因：本仓契约采用严格二进制身份，Core、Contracts.Builtins 及 GalNet.Project.Contracts 参与契约闭包；预编译是二进制重写，不能当作透明复制。
+
+发现方式：F-20261025-01 的同源码 IL/R2R 发布对照，比较 SHA256 与 PE ManagedNativeHeaderDirectory；最终两个非 Benchmark 发布再次核对编译输入与发布输出，并实际加载 Editor 默认契约 45 项。
+
+正确做法：PublishReadyToRun=true 时通过 PublishReadyToRunExclude 排除上述三个 DLL。必须验证实际部署字节与编译输入一致、native header 为空，并执行真实契约加载/宿主启动；其他程序集可正常 R2R。命名发布配置的 RID restore 使用隔离 bin/obj/lock，相关原则见 L-20261025-02。
+
+适用范围：R2R 或其他会重写程序集的发布转换；新增契约闭包依赖需重新核对排除项。
+
+禁止做法：为发布加速放宽严格契约哈希；仅检查编译通过或 schema 语义相同就宣称身份安全；把 Benchmark 与普通构建的契约哈希跨模式比较。
+
+来源：features/F-20261025-01-cpu-startup-benchmark/runtime-profile.md。
+正式操作：docs/manual/ready-to-run.md。
diff --git a/.agents/lessons/L-20261025-07-traceevent-retained-events.md b/.agents/lessons/L-20261025-07-traceevent-retained-events.md
new file mode 100644
index 00000000..c0eb3f38
--- /dev/null
+++ b/.agents/lessons/L-20261025-07-traceevent-retained-events.md
@@ -0,0 +1,17 @@
+# 保留 TraceEvent 迭代结果必须 Clone
+
+状态：confirmed
+
+现象：原生 ETL 内已收到 17 个 GalNet-CPU 标记，直接把 log.Events.Where(...).ToArray() 的事件保存后，却无法找到 Editor.RunAvalonia，或读取到后续事件的 payload。
+
+根因：TraceEvent 迭代器复用事件对象。延后读取保留下来的引用，不能保证它仍对应当次事件。
+
+发现方式：F-20261025-01 的 native-editor-02 无丢事件 trace；改成逐项 Clone 后，同一 ETL 成功对齐阶段并获取 383 个目标区间主线程 CPU 样本，重复分析及 Editor/Sample 实测通过。
+
+正确做法：立即在 foreach 内消费并提取不可变字段；确实需要保存 TraceEvent（含 CallStack/EventIndex）供后续筛选时，先 Select(item => item.Clone())。当前 scripts/analyze-startup-native.cs 使用后一种方式。
+
+适用范围：TraceEvent/TraceLog 迭代器事件的延后处理；scripts/analyze-startup-trace.cs 原有逐项消费方式不需要改成全量保留。
+
+禁止做法：把 ToArray/ToList 当作事件快照；因延后读取失败就判定 provider 没发标记，或凭空补齐时间轴。
+
+来源：features/F-20261025-01-cpu-startup-benchmark/parallel-native.md。
diff --git a/.agents/lessons/L-20261025-08-localization-header-alignment.md b/.agents/lessons/L-20261025-08-localization-header-alignment.md
new file mode 100644
index 00000000..5b3d8e1f
--- /dev/null
+++ b/.agents/lessons/L-20261025-08-localization-header-alignment.md
@@ -0,0 +1,12 @@
+# 横向表格变窄时必须明确共用左边界
+
+状态：confirmed
+来源：features/F-20261023-01-editor-uiux/follow-up-localization-20261025.md
+
+现象：本地化表格在所有语言显示时对齐，隐藏部分语言后表头与正文错位。真实挂载测试在隐藏中间语言后测得正文左边界 362 DIP、表头 483 DIP，相差 121 DIP。
+
+根因：表头 Grid 指定 Width，但保持默认 HorizontalAlignment；内容宽度变得小于 ScrollViewer 视口时，表头居中，而 ListBox 显式靠左。宽表场景掩盖了差异，与单元格语言顺序无关。
+
+修正：表头与正文都显式 HorizontalAlignment=Left，并使用同一组列宽。只验证语言数据或列数不能发现实际布局错位。
+
+验证：I18nVisibleLanguageHeadersStayAlignedWhenTableBecomesNarrowerThanViewport 在修复前失败，修复后通过；覆盖横向滚动后隐藏中间列、仅剩源语言及恢复语言，直接比较真实表头/单元格的 X 与宽度。不要只测表格宽于视口的初始状态。
diff --git a/.agents/lessons/L-20261025-09-textchanging-local-input.md b/.agents/lessons/L-20261025-09-textchanging-local-input.md
new file mode 100644
index 00000000..85735e0c
--- /dev/null
+++ b/.agents/lessons/L-20261025-09-textchanging-local-input.md
@@ -0,0 +1,10 @@
+# 失焦提交仍需同步捕获本地输入
+
+状态：confirmed
+来源：features/F-20261023-01-editor-uiux/follow-up-localization-20261025.md
+
+项目安装的 Avalonia 12.0.5 XML 文档明确：TextBox.TextChanged 在新文本渲染后异步发生；TextChanging 在 Text 属性更新后、渲染前同步发生。用 TextChanged 作为本地待提交模型的唯一入口，可能让紧随文字变更的 Escape 或 Save All 看到旧模型。
+
+本地化表格改为 TextChanging 只同步单元格本地文字，不调用作者写入；失焦/Ctrl+Enter/Save All 才提交。保留 PreeditText 组合输入保护，提交失败仍保留输入，模型回填时按相等值过滤防止重入。已经送入历史的异步提交与后来新输入分开处理，Escape 只取消后者。
+
+验证入口：I18nMountedTableCommitsOnBlurProtectsCompositionAndRetainsViewState 在 TextBox.Text 赋值后不等待渲染直接 Save All，检查保存值与焦点；另覆盖组字、Esc 和失焦提交。该挂载测试已通过；最终完整回归结果见本轮实施记录。
diff --git a/.agents/lessons/L-20261025-10-empty-localization-references.md b/.agents/lessons/L-20261025-10-empty-localization-references.md
new file mode 100644
index 00000000..3eebfa82
--- /dev/null
+++ b/.agents/lessons/L-20261025-10-empty-localization-references.md
@@ -0,0 +1,16 @@
+# 空本地化引用需要在作者索引、加载和解析边界保持一致
+
+状态：confirmed
+来源：2026-10-25 角色引用分析与空对话启动问题，用户明确要求空内容按空字符串处理；未创建独立 feature。
+
+现象：作者索引已经忽略精确空字符串，但 GameLocalizationLoader.Require 把空 content 当成缺失 key，启动报 missing required localization key ''。同时 layer.show 的默认 transform={} 因字段声明为 JsonElement 而产生 field.opaque，阻止角色改 ID。
+
+根因：作者引用覆盖分析与运行内容校验各自实现空值规则；没有引用的空结构也进入了无法遍历 schema 的兜底诊断。
+
+正确做法：缺省、null、空串及纯空白引用不要求翻译；GameTextResolver 直接返回空字符串，不查询翻译来源。空 speaker 不查角色 catalog。作者索引跳过空对象/数组，未知字段和无 schema 类型只有存在非空值时才报告覆盖不完整；非空未知结构仍保留诊断。显式空译文是合法定义，不能当作缺译。
+
+验证：LocalizationReferenceIndexTests 覆盖 layer.show 空 transform 与未知空字段；GameLocalizationLoadingTests 覆盖 dialogue.text、nvl.append 和 Choice 的空引用加载；GameTextResolverTests 验证空引用不调用来源；GameTextLocalizationTests 验证对话与 NVL 展示空文本。
+
+适用范围：游戏本地化引用和引用分析中的空字段；不放宽角色声明的唯一身份、JSON 语法、必填字段或非空错误引用。禁止只在 UI 隐藏诊断、只修改索引却遗漏启动加载器，或把所有非空不透明字段都视为可安全重写。
+
+关联文档：docs/spec/editor-game-localization.md、docs/spec/i18n.md。
diff --git a/.agents/lessons/L-20261025-11-static-reference-warning.md b/.agents/lessons/L-20261025-11-static-reference-warning.md
new file mode 100644
index 00000000..959d84f4
--- /dev/null
+++ b/.agents/lessons/L-20261025-11-static-reference-warning.md
@@ -0,0 +1,15 @@
+# 静态引用扫描的正常警告不等于应用失败
+
+状态：confirmed
+日期：2026-10-25
+来源：F-20261025-02-external-project-authoring / P2
+
+现象：批量删除资源并在同一批次移除 UI JSON 引用后，ProjectApplyTests.ResourceDeletionRequiresRemainingJsonReferencesToBeUpdatedInTheSameBatch 仍返回失败。
+
+根因：ProjectQueryService.References 始终附带 references.partial warning，说明自定义 C# 和运行表达式未被完整分析。以 diagnostics.Count != 0 判定失败，会把无剩余静态候选、但明确不完整的有效扫描也拒绝。
+
+正确做法：应用成败按 Severity=error 和实际匹配引用判断；保留 warning，并明确 ReferencesComplete=false，不把零静态候选写成全局零引用。当前 ProjectApplyService 返回合并诊断并使用错误级别判定。
+
+验证：修正后的 Editor.Shared 全部 417 项及最终批次/热重载 19 项通过；同批清除 UI 引用后资源删除成功，留下引用时拒绝。
+
+适用：消费 References 或其他允许 partial/Complete=false 的查询结果。不要直接用诊断总数代替错误数量，也不要吞掉不完整性说明。
diff --git a/.agents/lessons/L-20261026-01-baseline-restore-timestamps.md b/.agents/lessons/L-20261026-01-baseline-restore-timestamps.md
new file mode 100644
index 00000000..32327407
--- /dev/null
+++ b/.agents/lessons/L-20261026-01-baseline-restore-timestamps.md
@@ -0,0 +1,15 @@
+# 基线对照后恢复源码必须使增量构建失效
+
+状态：confirmed
+日期：2026-10-26
+来源：F-20261015-02-editor-authoring-workspace / GC1
+
+现象：隔离快照先成功编译新 AuthorChanges API，再替换旧服务源码重现一个基线失败。恢复备份的候选源码后，测试编译报告 UndoRedoHistory 没有 AuthorChanges；磁盘上的候选源码明明已有该成员。
+
+根因：File.Copy 恢复了备份的旧时间戳，而基线 DLL 的生成时间更晚。MSBuild 增量检查复用了基线 DLL。源码字节恢复不等于构建图已经失效。
+
+发现方式：gc1-baseline-character.trx 独立复现原有角色引用测试失败；随后 editor-final.log 出现 CS1061，核对恢复源码与 DLL 时序后确认不一致。对快照内候选文件显式 SetLastWriteTimeUtc 或执行 Rebuild 后才能继续验证。
+
+正确做法：基线与候选优先使用独立源/输出目录。若复用快照进行对照，恢复候选后必须 Rebuild，或刷新所有被替换源码的时间戳并核对生成结果；验证最后核对主工作区与快照的源字节一致。不要修改主工作区源码来迎合旧 DLL。
+
+适用：复制源码备份进行回归对照、测试旧实现、热切换隔离验证快照。不能把仅恢复文件或一次 no-build 成功当作当前候选证据。构建日志、首次失败和恢复方式留在阶段记录。
diff --git a/.agents/lessons/L-20261026-02-author-incarnation-view-lifetime.md b/.agents/lessons/L-20261026-02-author-incarnation-view-lifetime.md
new file mode 100644
index 00000000..4b397e1d
--- /dev/null
+++ b/.agents/lessons/L-20261026-02-author-incarnation-view-lifetime.md
@@ -0,0 +1,17 @@
+---
+status: confirmed
+created: 2026-10-26
+feature: F-20261015-02-editor-authoring-workspace
+---
+
+# 作者 incarnation 不随表单释放推进
+
+现象：GC3 为草稿增加显式 incarnation 后，完整 Editor 回归中 Common/Inspector 共享输入变回源值，关闭所有页面后的本地化草稿保存报源冲突。
+
+根因：把 incarnation 推进放进 `InvalidateParameterFields()`；该方法同时被 Group 页面 Dispose 使用。释放表单租约不等于作者对象消失，原作者内容仍存在，但草稿读源被错误标成 obsolete。
+
+正确做法：`InvalidateAuthorBindings()` 只在删除/移动出原 Group 或换类型时推进作者代次，再释放参数表单；页面关闭只释放参数表单。新表单重用同一作者代次的项目输入，旧控件仍因自身 lease 释放而失去提交权。删除和 Undo 后的新绑定使用新代次，不能恢复旧控件。
+
+禁止用视图生命周期、表单重建次数或对象 RuntimeHelpers 哈希冒充作者身份。覆盖的回归必须同时包括删除/Undo 拒绝旧 lease，以及关闭页面/重开字段/所有视图关闭后的保存；只测第一类会漏掉这次问题。
+
+发现及验证：GC3 初轮完整 Editor 313 通过、5 失败，其中两项为上述生命周期回归；拆分后定向 12 项通过。证据在 `artifacts/group-consistency-gc3/` 的 full 与 focused-repair 日志/TRX，来源见 feature 的 phase-group-consistency.md。
diff --git a/.agents/lessons/L-20261026-02-detached-run-cancellation.md b/.agents/lessons/L-20261026-02-detached-run-cancellation.md
new file mode 100644
index 00000000..941c6523
--- /dev/null
+++ b/.agents/lessons/L-20261026-02-detached-run-cancellation.md
@@ -0,0 +1,20 @@
+# 旧运行取消回调异常不能截断恢复提交
+
+状态：confirmed
+来源 Feature：[引擎核心精简](../../features/F-20261026-01-engine-core-simplification/summary.md)
+
+## 现象与根因
+
+CancellationTokenSource.Cancel 会先发布取消，再执行已注册回调；回调抛错时 Cancel 会抛 AggregateException。Engine 恢复若直接依次 ClearActive、Cancel、Restore，旧回调异常会在状态替换前截断执行，留下已清空活动实例但旧 scope 已取消的半份运行。
+
+## 正确做法
+
+先完整准备和验证候选，再让旧 scope 失效。对已经脱离执行的旧 scope，隔离并诊断取消回调异常，保证 source 释放和新状态提交继续进行。该规则不适用于保存/进度落盘失败或必要的新呈现恢复失败，这些仍需向调用方报告。
+
+运行 scope 的变量/结束操作，应在捕获的旧状态同步边界内检查取消；恢复提交也经过旧状态边界，避免检查通过后跨代写入。
+
+## 验证与适用范围
+
+GameEngineLifecycleTests.ObsoleteCancellationCallbackFailureCannotLeaveRestorationHalfApplied 已复现并验证：首个 scope 的取消回调抛 IOException，合法恢复仍回到 Ready，随后能重新执行。适用于 Engine 读档、旧 Choice 清理和相同的运行替换边界。
+
+不要把所有 OperationCanceledException 或任意执行异常一概吞掉，也不要把验证失败后的旧运行先销毁。
diff --git a/.agents/lessons/L-20261026-03-forced-restore-package-hash.md b/.agents/lessons/L-20261026-03-forced-restore-package-hash.md
new file mode 100644
index 00000000..7ff5027b
--- /dev/null
+++ b/.agents/lessons/L-20261026-03-forced-restore-package-hash.md
@@ -0,0 +1,22 @@
+# 强制重算锁图不能替代包哈希验证
+
+状态：confirmed
+来源 Feature：[引擎核心重构 R1](../../features/F-20261026-01-engine-core-simplification/phase-plan.md)
+关联：[删除项目后检查锁图](L-20261010-03-lock-graph-after-project-removal.md)
+
+## 现象与证据
+
+R1 移除 Runtime 对 Presentation.Abstractions 的引用后，按既有流程对受影响根执行 dotnet restore --force-evaluate。Browser 使用本地包源返回成功，但其 Microsoft.NET.Sdk.WebAssembly.Pack 10.0.12 的 contentHash 从仓库既有值改为本地包的另一值；第三方版本没有改变。
+
+在本机 .NET SDK 10.0.401 下，即使同时指定 --locked-mode，--force-evaluate 仍重写了该哈希并返回成功。恢复仓库原哈希后，使用 --locked-mode --force（不含 --force-evaluate）再次从相同本地源还原，明确复现 NU1403。日志位于忽略产物 artifacts/engine-core-audit/r1-browser-restore.log、r1-browser-locked.log。
+
+## 原因与正确做法
+
+强制重算用于生成新锁图；它接受当前解析结果并可能重新生成包身份，不能证明这些字节符合旧锁文件。包来源/字节差异的起因尚未确认，不能直接将其归因为恶意包或损坏。
+
+1. 有意变更项目依赖时，强制重算后审查整个锁文件差异。
+2. 本次仅移除项目依赖，第三方版本、哈希和目标框架键均应保持原值；撤回无关生成变化，而非把本地包哈希提交为修复。
+3. 生成与验证分开：再执行不带 force-evaluate 的 locked restore；需要失效还原缓存时使用 --force。
+4. 独立报告包验证或运行时包缺失，不能因为构建已成功或重算返回零就宣称发布验证通过。
+
+适用范围：已有锁文件的项目引用调整和本地源/离线还原。不要手写项目依赖图、关闭哈希验证或改写包缓存来绕过错误；需要升级第三方包时另行核实来源和版本。
diff --git a/.agents/lessons/L-20261026-03-query-result-and-write-context.md b/.agents/lessons/L-20261026-03-query-result-and-write-context.md
new file mode 100644
index 00000000..ac869c5b
--- /dev/null
+++ b/.agents/lessons/L-20261026-03-query-result-and-write-context.md
@@ -0,0 +1,21 @@
+# 查询结果与写入上下文必须分别验证
+
+- 状态：confirmed
+- 日期：2026-10-26
+- 来源：F-20261015-02-editor-authoring-workspace，GC4
+
+## 现象与根因
+
+将场景选择 lease 从全项目 Revision 改为结果版本后，首轮 Editor 回归的六个转场用例发现：选择器写入当前条目的目标参数后，条目前方候选完全相同，旧选择仍能 Resolve。候选相等只证明读取事实相等，不能证明原写入位置和基线仍有效。相同 JSON 替换 DTO 也有同样的身份问题。
+
+## 正确做法
+
+分开维护查询事实版本与写入方上下文版本。前者比较目标、能力、数值、存在性和完整性；后者比较写入方作者对象身份、类型和参数基线。每个成功提交主动核对已借出的查询，相关变化后再 Undo 也不得复活旧版本。展示变化和无关作者编辑不能代替实际依赖变化。
+
+后台资源准备另保留查询局部的作者依赖版本与资源代次：同一请求准备完成可换发结果，资源刷新、相关作者改变或项目关闭后的迟到结果不可续租。
+
+## 验证与适用范围
+
+初轮证据：artifacts/group-consistency-gc4/results/gc4-editor-first.trx；修复后完整 Editor 322 项通过，写入上下文补充 9 项、资源准备相关 22 项通过。新增测试覆盖相同 JSON 替换 DTO、相关改变再 Undo、无关后文编辑保留 Timeline 输入。
+
+适用于依赖缓存的 Picker、Timeline、异步表单和其他先读后写的编辑器意图。禁止只用“候选相同”允许任意旧操作，也禁止用全局作者版本替代局部依赖来取消所有输入。
diff --git a/.agents/lessons/L-20261026-04-configuration-json-casing.md b/.agents/lessons/L-20261026-04-configuration-json-casing.md
new file mode 100644
index 00000000..4e05afef
--- /dev/null
+++ b/.agents/lessons/L-20261026-04-configuration-json-casing.md
@@ -0,0 +1,16 @@
+# schema 检查与 DTO 解码必须使用同一字段身份规则
+
+状态：confirmed
+来源：F-20261026-01 引擎核心重构 R4b
+
+现象：section 按字段 ID 精确校验 count，但 JsonSerializerDefaults.Web 默认不区分大小写。输入 {"count":4,"Count":0} 能先通过 count 的最小值校验，再在 DTO 解码时让 Count=0 覆盖已验证值；未知字段也因此变成已知字段的写入入口。
+
+根因：schema 查询使用 Ordinal 精确匹配，DTO 解码却使用 Web 的 PropertyNameCaseInsensitive=true，两个阶段对字段身份的定义不一致。
+
+正确做法：配置 DTO 的 JSON 解码显式使用 PropertyNameCaseInsensitive=false；原始未声明字段继续保留，不解释成另一个已知字段。领域成员的 descriptor JSON options 与 DTO JSON options 也采用相同规则。
+
+验证：ProjectConfigurationTests.UnknownFieldCasingDoesNotBypassDeclaredFieldValidation 覆盖 count/Count 共存、类型化修改后已知值仍有效、未知字段原样保留；r4b-final-tests.log 的 Core 166 项通过。
+
+适用范围：在按精确字段 ID 校验之后反序列化为 CLR DTO 的配置、命令或内容边界。不要通过大小写不敏感解码绕过 schema，也不要为修复字段身份问题直接删除不认识的作者数据。
+
+关联：docs/spec/file-formats.md；features/F-20261026-01-engine-core-simplification/summary.md。
diff --git a/.agents/lessons/L-20261026-05-native-sample-window-validation.md b/.agents/lessons/L-20261026-05-native-sample-window-validation.md
new file mode 100644
index 00000000..5ef48508
--- /dev/null
+++ b/.agents/lessons/L-20261026-05-native-sample-window-validation.md
@@ -0,0 +1,17 @@
+# 原生 Sample 验证必须定位实际窗口并检查显式用例数
+
+状态：confirmed
+来源：F-20261026-01-engine-core-simplification / R8
+
+## 现象与证据
+
+ExternalSampleDebugTests 的三个用例可运行、编辑、Seek/Step、停止和重启，却在 CloseMainWindow 后超时，且没有宿主 shutdown 日志。r8-native-diagnostic 记录 Process.MainWindowTitle 为空；EnumWindows 显示同一 PID 有两个无标题可见窗口和一个 GalNet Avalonia 标题窗口。向后者发送 WM_CLOSE 后，三个用例均正常清理和零码退出，清理日志约 100 ms。
+
+## 正确做法
+
+- Windows 原生集成测试按自己启动的 PID、可见性与明确 Sample 标题定位唯一主窗口，再发送关闭消息；其他平台沿标准关闭接口。辅助代码只放测试层，不能广播关闭或操作其他进程。
+- 关闭超时时共享读写读取活动日志，不能让 FileShare 异常覆盖原始失败。
+- NUnit 显式测试单独以对应方法/fixture 过滤，并核对 TRX 的实际执行数量。本轮混合普通和显式方法的 OR 过滤只运行了两个普通用例；退出码不能证明显式用例已执行。
+- Native 截图默认写 Pictures；沙箱拒绝该路径时，复验应申请执行这一个受控测试所需的权限，不能把截图缺失归因于渲染，也不为测试给产品增加全局路径后门。
+
+证据：artifacts/engine-core-audit/r8-native-diagnostic.log、r8-results/ExternalSampleConnectsAtTitleStartsEditsSeeksStopsAndRejectsOldRuns.trx。测试辅助为 NativeSampleWindow。
diff --git a/.agents/lessons/L-20261026-06-ready-is-not-session-end.md b/.agents/lessons/L-20261026-06-ready-is-not-session-end.md
new file mode 100644
index 00000000..ee3d35ff
--- /dev/null
+++ b/.agents/lessons/L-20261026-06-ready-is-not-session-end.md
@@ -0,0 +1,14 @@
+# Engine Ready 不是宿主会话终止
+
+状态：confirmed
+来源：F-20261026-01-engine-core-simplification / R8
+
+## 现象与根因
+
+原生打包差分图片验证在 Seek 后出现返回标题页和 debug run 身份改变。Engine 恢复先发布 Ready、随后回放重新进入 Running；AvaloniaGameRun 把除 Running 外的所有状态映射为 IsPlaying=false，GameShell 据此排队返回标题。该中间状态不是停止，UI 队列可能在 Running 映射之前执行导航。
+
+## 正确处理
+
+默认宿主对 Ready 保持已有会话活动状态：首次准备仍为未开始，活动运行中的恢复/Seek 仍为活动。Running 与 Completed/Faulted/Stopped 再更新活动标志。不要删除 Engine 的 Ready 通知，也不要让通用内核拥有页面策略；不要用固定延时掩盖导航竞态。
+
+修正后真实打包 Sample 的五个呈现检查点、不同图片哈希和正常关闭通过。证据：artifacts/engine-core-audit/r8-packaged-native-verified.log（修正前）与 r8-packaged-native-final.log/trx（修正后）。对应状态映射位于 AvaloniaGameRun，当前规则同步 docs/spec/runtime.md。
diff --git a/.agents/lessons/L-20261027-01-shader-sampling-visual-qa.md b/.agents/lessons/L-20261027-01-shader-sampling-visual-qa.md
new file mode 100644
index 00000000..f5b1d842
--- /dev/null
+++ b/.agents/lessons/L-20261027-01-shader-sampling-visual-qa.md
@@ -0,0 +1,21 @@
+# Shader 采样需要像素与视觉双重验证
+
+状态：confirmed
+来源：features/F-20261026-03-default-visual-library
+
+## 现象与复现
+
+DepthBlur 的稀疏 5×5 网格采样在教室背景预览中出现重复图像条纹。SpeedLines 的定向线宽改细后，在 128×128、density=64 时所有像素 alpha=0，尽管 shader 编译完全成功。
+
+## 已验证的原因
+
+固定网格间隔过大使边缘与纹理产生可见重复采样。定向线在该分辨率下的 lane 坐标采样点固定落在细线范围之外，导致整条线消失；只检查编译或单个高分辨率截图不能发现这个问题。
+
+## 做法
+
+- 在低分辨率上验证动态程序图层存在非零与零 alpha，并比较两个逻辑时间的像素差异。
+- 线宽过细时，按 density / 画布短边估计像素覆盖范围，为线边界提供抗锯齿宽度。
+- 大半径模糊避免稀疏规则网格；本例改为中心加 48 个黄金角圆盘采样，消除了网格重影，但不据此承诺任意半径的性能。
+- 生成真实项目素材的 CPU contact sheet 并查看；仍须区分 CPU 验证与真实 GPU 验收。
+
+证据：DefaultVisualRenderingTests 的 128×128 动态像素断言，以及显式 WriteDefaultVisualPreview 产生的 artifacts/visual-library-preview.png。修正后相关 27 项效果测试与 257 项展示层普通测试通过。
diff --git a/.agents/lessons/L-20261027-02-fractional-audio-delay-wrap.md b/.agents/lessons/L-20261027-02-fractional-audio-delay-wrap.md
new file mode 100644
index 00000000..548d8593
--- /dev/null
+++ b/.agents/lessons/L-20261027-02-fractional-audio-delay-wrap.md
@@ -0,0 +1,11 @@
+# 分数延迟的浮点环绕边界
+
+状态：confirmed。来源：F-20261027-01-audio-mixer，PcmMixerTests 的混响顺序和稳态处理用例。
+
+现象：部分 roomSize（包括默认 0.5）在混响延迟读取中出现 IndexOutOfRangeException，而另一组房间参数正常。
+
+根因：float 计算得到接近 0 的负读位置，加缓冲长度后可能舍入成恰好等于缓冲长度；只检查负数不能保证数组索引落在区间内。
+
+正确做法：分数位置用 double 计算，环绕后仍检查上边界；线性插值的第二个索引同样按长度环绕。不要在 native 音频回调外层吞异常后把持续静音误判为正常输出。
+
+验证：真实混响默认参数、非默认参数、有序效果和连续处理/零分配测试均覆盖该路径。记录来自测试失败后修正，不把“只跑一个 impulse 参数”当成完整边界验证。
diff --git a/.agents/lessons/L-20261027-03-timeline-stop-event-cleanup.md b/.agents/lessons/L-20261027-03-timeline-stop-event-cleanup.md
new file mode 100644
index 00000000..0e0573b5
--- /dev/null
+++ b/.agents/lessons/L-20261027-03-timeline-stop-event-cleanup.md
@@ -0,0 +1,20 @@
+# Timeline 停止必须同时完成属性轨道和事件收尾
+
+状态：confirmed
+来源：features/F-20261027-02-sustained-visual-presets
+
+## 现象与根因
+
+animation.stop / CompleteImmediately 原先只通知 presenter 跳到末帧并移除播放状态。AvaloniaAnimationPresenter 的提前完成分支仅采样轨道，不调用 beforeFrame，因此末帧 effect.stop/layer.hide 没有送达展示层。集中线虽已透明，Effect 与载体图层仍可能存在。定时和持续预设的提前停止回归均覆盖了此路径。
+
+## 正确做法
+
+由中立 Timeline 实例在正常完成/主动完成后补发剩余非 burst 事件，并让停止 Entry 等待 PresentationCompletion。循环的初始化、迭代事件、播放结束清理需区分；不能把初始化和清理跟随每次循环重放。首帧初始化进行中收到停止请求时，必须在启动 presenter 前再次检查停止状态。
+
+点击跳过和脚本停止可以交错。不能在 presenter 任务结束时提前移除播放身份，让随后到达的停止指令绕过仍在执行的 skip 清理；使用稳定的完成信号，等呈现退出和事件清理全部结束后一起释放身份。Stop_during_click_skip_waits_for_the_same_cleanup 在修复前得到 stopping.IsCompleted=true，修复后必须在 Effect 清理门释放前保持 false。
+
+循环 presenter 单独返回 Completed 不是提交末值的充分证据；没有明确停止请求时不能改变恢复后的循环初始值。scope 取消、CatchUp 分离、被替换不能借用正常完成的清理路径。
+
+## 验证
+
+SustainedVisualPresetTests 验证提前停止的 Effect/图层清理、异步初始化交错、清理等待、恢复、循环与同标识重用；既有 PersistentPresentationReplayRestartsEffectsAndParticlesWithSavedAnimationValues 验证宿主直接结束呈现不篡改恢复初值。
diff --git a/.agents/lessons/L-20261027-04-build-before-no-build-tests.md b/.agents/lessons/L-20261027-04-build-before-no-build-tests.md
new file mode 100644
index 00000000..8f88f5ba
--- /dev/null
+++ b/.agents/lessons/L-20261027-04-build-before-no-build-tests.md
@@ -0,0 +1,17 @@
+# 同一输出根的构建和测试必须串行
+
+状态：confirmed
+日期：2026-10-27
+来源：F-20261027-01-audio-mixer / 音频效果创作
+
+现象：隔离构建尚未结束时启动 --no-build 的 Editor/Editor.Shared 测试，SDK 在 Copy 阶段出现 MSB3026/MSB3027/MSB3021。被占用路径均为同一 artifacts/audio-isolated/bin 下的测试依赖 DLL；正常运行的 Editor 不是这次占用来源。
+
+根因：write_stdin 返回 session_id 表示构建仍在运行，不是已成功完成。测试提前加载了该输出目录的程序集，Windows 阻止构建覆盖；同时测试可能读取旧程序集，结果不能作为新源码验证证据。
+
+发现方式：artifacts/audio-authoring-overlap-build.log 记录了重复复制重试和 30 个锁定错误；两个测试进程退出后，同源码的解决方案构建在约 6 秒内以 0 错误通过。
+
+正确做法：明确收到 build 的 exit_code=0 后，再复制同次构建的契约产物并启动 --no-build 测试。独立测试进程可以并行，同一输出根的构建和测试不能重叠。保存源码指纹并在验证结束复核；重叠产生的日志保留但不作为最终验收。
+
+适用：Windows 输出目录、隔离 artifacts、多项目构建和任何需要复用已有 DLL 的验证。禁止把 yielded/session_id 结果当作编译完成，也不要通过停止用户正在运行的 Editor 来修复自己测试进程造成的锁定。
+
+相关：[隔离契约产物](L-20261019-03-isolated-contract-artifacts.md)。
diff --git a/.agents/lessons/L-20261027-05-numeric-template-drafts.md b/.agents/lessons/L-20261027-05-numeric-template-drafts.md
new file mode 100644
index 00000000..4432b7c4
--- /dev/null
+++ b/.agents/lessons/L-20261027-05-numeric-template-drafts.md
@@ -0,0 +1,15 @@
+# 数值控件的模板初始化不能成为作者输入
+
+状态：confirmed
+日期：2026-10-27
+来源：F-20261023-01-editor-uiux / follow-up-group-diagnostics-numeric-20261027
+
+现象：把保留草稿的数字 TextBox 换成 NumericUpDown、只覆盖 OnTextChanged 和 OnLostFocus，虽然 `.22` 可写入，却在挂载表单时产生空草稿。结构化列表/DTO 操作后保存出现源冲突，项目设置已提交值被初始草稿覆盖，外部文件刷新被误判为本地修改。
+
+根因：原生 NumericUpDown 的模板挂载还会通过 Value/内部输入框同步文字；只抑制 TextProperty 的工厂初始化或改写格式化回调不足以隔离这些通知。Avalonia TextChanged 事件又晚于立即的 Enter 提交，不能用它捕获同一消息中的最新文字。
+
+发现与证据：首次 Editor 全回归 15 项失败；加入挂载后 PendingCount=0 断言复现。改为借用原生主题、由字段编辑器直接拥有模板 TextBox/ButtonSpinner 事件后，结构化列表、DTO patch、设置、外部刷新等聚焦回归通过。输入使用 TextBox.PropertyChanged 同步捕获，显式刷新用同步标记保护。
+
+规则：作者数字文字和提交权属于 FieldEditorContext/FieldDraftState。模板初始化、换主题、默认值显示和外部刷新不得制造草稿；不能用 NumericUpDown.Value 的自动转换/钳制回写作者 JSON。保留原生外观时需确认实际输入、按钮及键盘行为，验证初始无草稿、同消息输入后 Enter、规范回显、Undo 和关闭后保存。
+
+不要仅凭源码赋值或单个合法数字测试判定控件可用，也不要靠清空项目草稿来掩盖初始化副作用。
diff --git a/.agents/lessons/L-20261027-06-native-audio-utf8-abi.md b/.agents/lessons/L-20261027-06-native-audio-utf8-abi.md
new file mode 100644
index 00000000..e9d61aab
--- /dev/null
+++ b/.agents/lessons/L-20261027-06-native-audio-utf8-abi.md
@@ -0,0 +1,23 @@
+# 原生音频的 UTF-8 ABI 与 Windows 文件打开
+
+状态：confirmed
+日期：2026-10-27
+来源：跨平台引擎后端适配（独立实现，未建立 feature 工作流）
+
+## 现象与根因
+
+把 C ABI 路径统一为 UTF-8 后，不能直接用 Windows 下 miniaudio 的 ma_decoder_init_file / ma_fopen 代替原来的宽字符入口。已固定的 miniaudio 0.11.23 在 Windows 的窄字符 ma_fopen 内调用 fopen_s，使用本机 ANSI 代码页，不保证按 UTF-8 解释路径；跨平台 API 的同名窄字符串入口不等于统一编码语义。
+
+## 发现与证据
+
+检查 src/Infrastructure/GalNet.Media.Miniaudio/native/miniaudio.h 的 ma_fopen 实现确认上述行为。本轮将边界统一为 UTF-8，在 Windows 通过 MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS) 转换，再调用 ma_decoder_init_file_w / _wfopen；其他系统使用窄字符路径。Unicode WAV 与 Vorbis 解码回归通过；真实设备回调、暂停重建设备和释放测试通过。
+
+## 正确做法
+
+- 在 C ABI 明确字符串编码，平台内部再转换；保留中文路径的真实解码测试。
+- 路径编码和回调签名变化时提升原生 ABI，并同时部署托管适配器和原生库。通过版本入口拒绝混用；不能只替换托管 DLL。
+- AOT 回调使用静态 UnmanagedCallersOnly 入口和显式上下文。原生设备销毁等待回调退出后，才释放 GCHandle；系统暂停不释放声音租约或修改剧情 Pause。
+
+## 范围与禁止做法
+
+适用于原生媒体库的字符串互操作和回调生命周期。不要把 CMake 编译成功当作移动设备验收，也不要把静态回调改造当作全引擎 AOT 支持。当前反射 JSON/metadata 的 IL 警告仍存在，详见 docs/manual/cross-platform-backends.md。
diff --git a/.agents/lessons/L-20261027-06-property-wire-boundaries.md b/.agents/lessons/L-20261027-06-property-wire-boundaries.md
new file mode 100644
index 00000000..0f3e0a99
--- /dev/null
+++ b/.agents/lessons/L-20261027-06-property-wire-boundaries.md
@@ -0,0 +1,17 @@
+# 属性逻辑路径不能替代实际 JSON Pointer
+
+状态：confirmed
+日期：2026-10-27
+来源：F-20261027-03-recursive-properties
+
+现象：给 JsonElement 字段补上嵌套结构后，检查器能够识别 JSON 字符串内部的多个引用，但旧的角色比较/替换和文本复制只使用 JsonPointer。多个内部引用共享外层字符串位置，会发生位置键冲突或将整个字符串替换为一个引用值。
+
+根因：JSON Pointer 无法穿过字符串编码边界。结构内逻辑路径和实际 wire 位置是两种信息；只迁移只读分析，遗漏写入及复制消费者，会把原来的覆盖不足变成错误写入。
+
+正确做法：类型化路径保留 Member、Index、MapKey 与 JsonString 边界；对外 Pointer 在编码边界终止，内部位置使用完整逻辑路径。引用比较/去重使用逻辑位置，回写使用类型化路径的纯 Rewrite，并保留原编码、未知成员和精确数值。宿主仍检查作者身份与事务。
+
+验证：RecursivePropertyTests 的编码对象替换；LocalizationReferenceIndexTests.MultipleReferencesInsideAnEncodedArrayHaveDistinctLocationsAndRewriteTheirOwnLeaves 验证同一外层 Pointer 的两条引用独立回写且保留大整数；Editor 全回归覆盖角色和嵌套文本复制。
+
+额外实现陷阱：System.Text.Json.Nodes.JsonArray 不能将已经属于该数组的节点再次赋回同一位置。递归修改子节点后，如果返回的仍是原实例，应保留它而不是重新挂载。初次引用回写测试实际暴露 NodeAlreadyHasParent；比较引用后才执行替换可避免该问题。
+
+禁止仅为消除 opaque 警告就宣称全部引用消费者已支持新结构；必须同时检查定位、身份比较、修改、复制与归档路径。
diff --git a/.agents/lessons/L-20261027-07-complete-msvc-toolsets.md b/.agents/lessons/L-20261027-07-complete-msvc-toolsets.md
new file mode 100644
index 00000000..0ac3a7fe
--- /dev/null
+++ b/.agents/lessons/L-20261027-07-complete-msvc-toolsets.md
@@ -0,0 +1,21 @@
+# Windows 原生构建选择完整的目标工具集
+
+状态：confirmed
+日期：2026-10-27
+来源：跨平台后端 ARM64 构建复验（独立实现）
+
+## 现象与根因
+
+用户补装了 ARM64 MSVC 14.44，原生音频构建仍报告缺少 ARM64 libcmt.lib。默认 vcvarsall 选择 14.51；该版本只有 ARM64 的部分 Clang 辅助库，完整的 ARM64 编译器、头文件和 CRT 位于并存的 14.44。默认工具集不完整不等于机器上没有可用工具集。ATL/MFC 的 ARM64 安装目录也不能证明编译工具和 CRT 已装齐。
+
+## 发现与正确做法
+
+检查实际 lib/arm64/libcmt.lib 和 bin/Hostx64/arm64/cl.exe；不要只看目录存在或安装器显示的 ARM64 关键词。按目标架构筛选同时具有编译器、头文件、静态运行库的工具集，按版本排序后通过 vcvarsall -vcvars_ver=<完整版本> 显式选择。不同目标架构可以使用不同工具集。
+
+## 验证
+
+native/build.ps1 的 ARM64 构建选择 MSVC 14.44.35207 并链接成功，PE Machine 为 0xAA64，8 个 gn_* ABI 导出齐全；x64 构建仍选择 14.51.36231，PE Machine 为 0x8664。此结果证明交叉编译与产物身份，不代表 ARM64 实机播放通过。
+
+## 适用范围与禁止做法
+
+适用于多版本 MSVC 并存的原生构建。不要在未检查并存版本前反复要求用户安装组件，也不要为迎合默认工具集混用不同版本的头文件和 CRT。当前接入事实见 docs/manual/cross-platform-backends.md。
diff --git a/.agents/lessons/L-20261027-08-aot-build-tool-isolation.md b/.agents/lessons/L-20261027-08-aot-build-tool-isolation.md
new file mode 100644
index 00000000..99f7307f
--- /dev/null
+++ b/.agents/lessons/L-20261027-08-aot-build-tool-isolation.md
@@ -0,0 +1,17 @@
+# NativeAOT 发布属性与编译工具隔离
+
+- 状态：confirmed
+- 日期：2026-10-27
+- 适用范围：以 ProjectReference 挂载 netstandard 源生成器的 NativeAOT 宿主
+- 来源：引擎 AOT 实现与用户要求复用 Headless Sample
+- 文档：docs/manual/native-aot.md
+
+## 现象与根因
+
+全局 `-p:PublishAot=true` 会沿 restore 项目图进入 GalNet.SchemaGenerator，使 netstandard2.0 项目触发 NETSDK1207。仅在 ProjectReference 上配置 GlobalPropertiesToRemove 能控制构建引用，不能单独解决本仓库此 restore 路径。独立 AOT 项目并非所需修复。
+
+## 正确做法与验证
+
+编译工具项目显式通过 TreatAsLocalProperty 接管 PublishAot、SelfContained、RuntimeIdentifier，并将其分别设为 false、false、空。玩家仍使用标准 PublishAot 选项。实际 Headless NativeAOT 发布并运行通过，dynamicCode=False、reflectionJson=False，最终 ILLink/ILC 警告按错误处理。
+
+RID/ILCompiler 恢复图另外隔离至 .galnet，设置 RestorePackagesWithLockFile=false 和单独 NuGetLockFilePath；已有开发 lock 文件时仅前者不足以避免恢复图冲突。禁止为了发布修改或删除普通开发锁文件，禁止吞掉最终链接警告。
diff --git a/.agents/lessons/L-20261027-09-sourcegen-extension-data.md b/.agents/lessons/L-20261027-09-sourcegen-extension-data.md
new file mode 100644
index 00000000..4467a90a
--- /dev/null
+++ b/.agents/lessons/L-20261027-09-sourcegen-extension-data.md
@@ -0,0 +1,17 @@
+# 源生成 JSON 与 init extension data
+
+- 状态：confirmed
+- 日期：2026-10-27
+- 适用范围：System.Text.Json 源生成 metadata，含 JsonExtensionData 的 DTO
+- 来源：引擎 AOT 实现，GalleryAnnotation 未知字段保留回归
+- 文档：docs/manual/native-aot.md、docs/spec/assets.md
+
+## 现象与根因
+
+GalleryAnnotation.ExtensionData 使用 init 时，源生成器为该类型生成初始化构造函数并试图绑定 extension data，触发不受支持的构造参数绑定。普通反射路径未暴露这一差异，原有未知字段保留测试在切换生成 metadata 后失败。
+
+## 正确做法与验证
+
+该可变字典属性使用 set，保持 JsonExtensionData 和 wire 不变。原有 Gallery 测试通过；禁用反射 JSON 的 NativeAOT 自检再验证未知 annotation 字段写出、读回。对类似 DTO 不应只验证已知字段，也不要只以成功编译判定生成 codec 可用。
+
+本规则针对已复现的 extension data 形状，不推广为所有 init 属性均不支持源生成。
diff --git a/.agents/lessons/L-20261027-10-open-shader-parameters.md b/.agents/lessons/L-20261027-10-open-shader-parameters.md
new file mode 100644
index 00000000..7fce5877
--- /dev/null
+++ b/.agents/lessons/L-20261027-10-open-shader-parameters.md
@@ -0,0 +1,20 @@
+# Shader 扩展参数与封闭 DTO 的边界
+
+状态：confirmed
+来源：features/F-20261027-03-recursive-properties/follow-up-open-shader-parameters.md
+
+## 现象与根因
+
+切换 shader 后保留 angle 等旧参数时，扫描曾将其报告为 field.unknown；用户确认这类参数合法，不应 warning。扫描把 shader 参数目录误当成封闭 DTO，而渲染器 ShaderProgramTextureEffect 仅枚举 descriptor.Parameters 绑定 uniform/texture，额外数据不被消费。
+
+## 正确做法
+
+已知 shader 的参数对象显式声明为开放对象，附加成员是没有子引用语义的原子 JSON。保留任意合法附加值，不生成漏分析 warning，不猜测其中的文本/角色 key。已声明字段仍校验类型/范围，重复成员仍诊断，未知 shader 仍报告无法确定结构。该规则也适用于 shader 预设和 Timeline 效果事件。
+
+## 适用范围与禁止做法
+
+规则来自领域消费者对扩展数据的明确忽略语义；不可全局关闭未知 DTO/未知 schema 的诊断，也不可自动套用到仍有封闭校验的音效或 legacy catalog。不能把“不写作者数据”等同于“必须给作者 warning”，也不能把一条合法扩展的 warning 解释为用户需要手工清理。
+
+## 发现与验证
+
+用户提供 Bloom 参数对象 angle/strength/softKnee/radius/threshold 并明确纠正。源码核对 TextureEffects.cs 的 descriptor 参数枚举；Core 开放对象回归验证附加对象/数组/空键、已知字段校验、重复成员、局部 patch 与别名边界。相关正式规范：docs/spec/entry-types.md、docs/spec/editor-game-localization.md。
diff --git a/.agents/lessons/L-20261027-11-solution-fixture-configuration.md b/.agents/lessons/L-20261027-11-solution-fixture-configuration.md
new file mode 100644
index 00000000..7161b092
--- /dev/null
+++ b/.agents/lessons/L-20261027-11-solution-fixture-configuration.md
@@ -0,0 +1,9 @@
+# Solution 构建必须覆盖测试读取的 fixture 配置
+
+状态：confirmed。来源：F-20261027-04-tagged-release。
+
+- 现象：Release 全量构建成功，契约配置流水线有三项失败；测试读取的 SchemaA Release DLL 时间仍是旧版本，缺少 developer.options。
+- 证据：out/ci/tagged-release-candidate/build.log 显示 solution 外的 SchemaA/SchemaB 引用实际构建到 bin/Debug；测试按自身 Release 编译常量读取 bin/Release。
+- 修正：将全部 fixture 项目纳入 GalNet.slnx，让 solution 为引用工程传递相同配置；fixture-build.log 确认输出 Release，ProjectContractPipelineTests 8 项通过。
+- 适用：测试或 CLI 从普通 bin 路径加载程序集、包含 ReferenceOutputAssembly=false 的契约 fixture。
+- 禁止：依赖开发机残留 DLL，或通过复制旧产物/跳过失败用例让 CI 通过。
diff --git a/.agents/lessons/L-20261027-12-generated-init-defaults.md b/.agents/lessons/L-20261027-12-generated-init-defaults.md
new file mode 100644
index 00000000..303acbf5
--- /dev/null
+++ b/.agents/lessons/L-20261027-12-generated-init-defaults.md
@@ -0,0 +1,9 @@
+# 源生成 JSON 的 init-only 默认值
+
+状态：confirmed。来源：F-20261027-04-tagged-release。
+
+- 现象：精简作者 JSON 只声明音轨 id，生成元数据反序列化后 MaxVoices、DefaultGain 均为 0，导致合法音轨配置被拒绝；Bus gain 也变为 0。
+- 根因：init-only 成员通过生成器的构造绑定初始化，省略字段的默认绑定值覆盖 CLR 属性初始化器。反射路径的行为不能作为源生成路径证据。
+- 验证：GeneratedMetadataPreservesDefaultsForOmittedAudioFields 同时断言音轨容量/增益与 Bus 增益，先失败，显式带可选默认值的 JsonConstructor 后通过。
+- 修正：保留 public 无参构造与 record/init 不可变语义，增加 JsonConstructor 及明确的字段默认值。
+- 禁止：将 DTO 全部改成可写属性破坏已有所有权保证，或放宽音轨容量校验掩盖默认值丢失。
diff --git a/.agents/lessons/L-20261028-01-native-publish-payload.md b/.agents/lessons/L-20261028-01-native-publish-payload.md
new file mode 100644
index 00000000..0cab15cb
--- /dev/null
+++ b/.agents/lessons/L-20261028-01-native-publish-payload.md
@@ -0,0 +1,10 @@
+# 原生 NuGet 内容不一定遵守发布 RID 与符号开关
+
+- 状态：confirmed
+- 来源：F-20261027-04-tagged-release，用户追问发行体积。
+- 现象：win-x64 自包含发布仍带 VLC win-x86 / win-arm64，合计约 178 MiB；Editor 的 Skia/HarfBuzz 原生 PDB 约 100 MiB。
+- 根因：原生依赖通过 NuGet 内容/构建规则复制多架构和符号文件，不能从 `-r win-x64` 或托管符号复制设置推导最终产物只含目标架构、没有 PDB。
+- 发现：对真实 ZIP 解压后的文件按路径、扩展名和字节统计，而非仅检查 csproj 属性。
+- 做法：在最终应用载荷生成 manifest/hash 之前过滤 PDB 与明确不支持的 VLC 架构；发布验收同时拒绝多余文件并确认 x64 VLC 核心/codec 仍在。禁止按 DLL 扩展名一律删除或在 hash 封存后修改 ZIP。
+- 边界：只调整应用发行载荷，构建目录可继续保留符号；x64 插件仍需按实际音视频能力验收后才能进一步裁减。
+- 文档：docs/manual/release-packaging.md。
diff --git a/.agents/lessons/L-20261028-02-pak-index-payload-verification.md b/.agents/lessons/L-20261028-02-pak-index-payload-verification.md
new file mode 100644
index 00000000..5c9c6feb
--- /dev/null
+++ b/.agents/lessons/L-20261028-02-pak-index-payload-verification.md
@@ -0,0 +1,15 @@
+# PAK metadata 索引不等于 payload 完整性验证
+
+状态：confirmed，2026-10-28。
+
+现象：P4 覆盖包集成测试翻转普通 sprite payload 的一个字节，安装准备仍成功，直到资源读取才检查出哈希错误。
+
+根因：Archive.Deserialize 验证控制描述、索引、范围等；普通资源的解压长度和 payload 哈希由 GetAsset 校验。MetadataIndex 仅返回表项，不触发解码。覆盖包的全文件 hash 用于优先级排序，是针对当前文件计算的值，不能替代已知期望校验和。
+
+正确做法：无外部可信期望哈希的独立覆盖包，在准备时逐个 GetAsset 并验证 payload；基础/剧情包还需与清单的已知全文件哈希比较。不要将“可反序列化索引”写成“所有内容校验通过”。
+
+验证：StoryPackageExportTests.ResourcePatchExportsBeforeBaseAndSessionsFreezeTheSelectedOverrideSet，损坏覆盖包必须在 CreateAssetProviders 阶段抛 InvalidDataException。
+
+适用：PAK 安装、导入、资源索引和任何以 metadata-only 优化装载的流程。
+
+来源：features/F-20261028-01-content-packaging/phase-4.md；docs/spec/assets.md。
diff --git a/.agents/lessons/L-20261028-03-internal-snapshot-content-identity.md b/.agents/lessons/L-20261028-03-internal-snapshot-content-identity.md
new file mode 100644
index 00000000..178b032d
--- /dev/null
+++ b/.agents/lessons/L-20261028-03-internal-snapshot-content-identity.md
@@ -0,0 +1,15 @@
+# 内部重建快照也要保留内容身份
+
+状态：confirmed，2026-10-28。
+
+现象：打包原生 Sample 可正常启动，但调试 Seek 在 RestoreFromCoreAsync 报“不同内容构建或缺少剧情包”。开发目录没有复现，因为开发 ContentBuildId 为空。
+
+根因：给存档增加 ContentBuildId/StoryPackages 后，普通稳定快照已加身份，调试 replay 仍手写 new GameSnapshot，只复制节点、状态和变量。Sample 的精简调试存档也有同样遗漏。
+
+正确做法：区分外部恢复输入和当前引擎生成的内部快照。内部 replay 基线由当前引擎 StampContent，精简外部副本保留源身份；不要放宽外部存档兼容校验。新增快照字段时搜索所有手写复制、缓存和替代工厂，并使用非空构建身份测试。
+
+验证：Debug 配置下显式 Packaged_variants_render_in_native_sample_and_close_cleanly 通过；Runtime DebugSessionTests 增加当前/缓存/隔离 Seek 与未标记外档拒绝回归，SampleDebugSnapshotFactoryTests 增加身份复制断言。
+
+适用：调试、回放、回滚、存档精简及跨模块快照工厂。
+
+来源：features/F-20261028-01-content-packaging/phase-6.md；docs/spec/runtime.md。
diff --git a/.agents/lessons/L-20261028-04-optional-parameter-binary-api.md b/.agents/lessons/L-20261028-04-optional-parameter-binary-api.md
new file mode 100644
index 00000000..da3d6a87
--- /dev/null
+++ b/.agents/lessons/L-20261028-04-optional-parameter-binary-api.md
@@ -0,0 +1,15 @@
+# 可选参数也会改变公开方法的 CLR 签名
+
+状态：confirmed，2026-10-28。
+
+现象：FieldDescriptor 新增可选 resourceTypeId 后，当前源码可编译，但既有 SchemaGenerator 二进制兼容测试抛 MissingMethodException。
+
+根因：C# 可选参数只影响调用方源码的默认值补齐，不能保留旧 CLR 构造函数签名。旧契约 DLL 仍调用原八参数构造函数。
+
+正确做法：保留旧签名的转发重载，再提供新签名；保留不会造成源调用歧义的参数规则。用旧 API 独立编译 consumer，再让它装载当前 Core 验证，不以重新编译当前源码替代二进制兼容证据。
+
+验证：FieldSchemaGeneratorTests.AConsumerCompiledAgainstTheOldDescriptorApiLoadsAgainstCurrentCore，以及最终 SchemaGenerator 全套 20/20 通过。
+
+适用：Core/Contracts 的公开构造函数、插件契约、公开扩展方法和宿主加载的预编译模块。格式版本升级不自动授权破坏无关 CLR API。
+
+来源：features/F-20261028-01-content-packaging/phase-6.md。
diff --git a/.agents/lessons/L-20261029-01-content-baseline-field-completeness.md b/.agents/lessons/L-20261029-01-content-baseline-field-completeness.md
new file mode 100644
index 00000000..b4764fe5
--- /dev/null
+++ b/.agents/lessons/L-20261029-01-content-baseline-field-completeness.md
@@ -0,0 +1,13 @@
+# 新持久字段必须进入手写保存基线比较
+
+状态：confirmed，2026-10-29。
+
+现象：资源补丁即时保存回归中，未保存的 Group.storyPackage 仍在工作版，磁盘保持原值，但 ContentSession.IsDirty 错误为 false。
+
+根因：DTO、克隆和重载已保留 StoryPackage，ProjectContentBaseline.Node 的手写相等比较却没有该字段。完整构建和保存/撤销回归不能自动覆盖“只改该字段”的 dirty 判断。
+
+正确做法：增加持久字段时搜索序列化、克隆、重载、等价判断、恢复与发布基线；验证单独修改字段使会话 dirty，局部发布其他内容后仍 dirty，磁盘没有被顺带保存。不以强制 Save All 掩盖漏项。
+
+验证：ResourcePatchesPersistWithoutSavingOtherContentAndExportDoesNotCommitDrafts，包名工作版与磁盘不同时 IsDirty=true，资源补丁节保存及导出均保留差异。
+
+来源：features/F-20261028-01-content-packaging/follow-up-panel-20261028.md；ProjectContentBaseline.Node。
diff --git a/.agents/lessons/L-20261029-02-window-decoration-theme-resources.md b/.agents/lessons/L-20261029-02-window-decoration-theme-resources.md
new file mode 100644
index 00000000..ae10bdd0
--- /dev/null
+++ b/.agents/lessons/L-20261029-02-window-decoration-theme-resources.md
@@ -0,0 +1,13 @@
+# 窗口装饰颜色与播放器内容样式的边界
+
+状态：confirmed
+日期：2026-10-29
+来源：Sample UI 调整（独立修复，无 feature 记录）
+
+- 现象：播放器内容使用 Mono 浅色，系统/宿主主题可能仍是深色；标题栏关闭按钮颜色与背景混在一起。为 UrsaWindow 内容模板下的 Button 写选择器不能命中独立装饰层。
+- 原因：Ursa 2.1/Avalonia 12 的关闭按钮属于 WindowDrawnDecorations，不是 UrsaWindow 内容模板的后代。当前 Headless 平台不会生成平台窗口装饰，GetVisualDescendants 只返回内容控件，不能用“找不到关闭按钮”推断原生 UI 没有按钮。
+- 正确做法：在窗口资源层将 CaptionButtonForeground、关闭按钮悬停/按下颜色、TitleBarBackground 等真实装饰资源映射到玩家调色板。完整播放器 Fluent 样式仍放在播放器根；窗口只共享调色板，避免改变宿主窗口控件主题。
+- 验证：SampleWindowThemeTests 检查实际装饰资源与玩家前景色一致，并验证退出遮罩的取消焦点、Escape 和结果。窗口装饰的像素与系统交互仍需原生桌面验证；Headless 资源断言不替代原生截图。
+- 禁止：把 Window 内容树中的 Button 选择器当成所有窗口装饰按钮的覆盖；为了取到标题栏控件而给整个 Window 挂上播放器 FluentTheme。
+- 依据：Ursa.Avalonia v2.1.0 的 UrsaWindow.axaml（独立 KEY_URSAWINDOW_DRAWN_DECORATIONS）；本次 artifacts/sample-ui-tests/sample-window.trx 与 artifacts/sample-ui-captures/Sample-ExitConfirmation.png。
+- 正式文档：docs/spec/control.md、docs/manual/customize-avalonia-sample.md。
diff --git a/.agents/lessons/L-20261029-03-powershell-runtime-api-compatibility.md b/.agents/lessons/L-20261029-03-powershell-runtime-api-compatibility.md
new file mode 100644
index 00000000..6f3d960a
--- /dev/null
+++ b/.agents/lessons/L-20261029-03-powershell-runtime-api-compatibility.md
@@ -0,0 +1,12 @@
+# PowerShell 脚本必须验证实际宿主的 .NET API
+
+状态：confirmed
+日期：2026-10-29
+来源：用户反馈 Sample 启动脚本在 Windows PowerShell 报 MethodNotFound（独立修复）
+
+- 现象：run-avalonia-sample.ps1 调用 System.IO.Path.TrimEndingDirectorySeparator 失败；Headless 脚本使用同一表达式。
+- 根因：该方法存在于现代 .NET，但 Windows PowerShell 5.1 运行于 .NET Framework，不提供它。开发环境默认 pwsh 的成功不能证明系统 powershell.exe 兼容。
+- 正确做法：无显式高版本宿主要求的简单路径处理使用两者共有的 API。本次改为 String.TrimEnd(char[])；项目路径已转绝对路径，仅在与固定 GameTestCase 路径比较时去除末尾分隔符，不用于文件删除或根目录重写。
+- 验证：Windows PowerShell 5.1.26100.9444 与 PowerShell 7 各运行两个原样复制的 Sample 脚本，覆盖默认、反斜杠结尾、斜杠结尾、大小写、自定义项目、SkipBuild，共 24 项通过。外部构建/部署/启动被记录桩替代，只验证实际宿主下的路径及调用控制流，不声称重新验收播放器。
+- 禁止：仅做 PowerShell 语法解析或仅用 pwsh 执行，就宣称 Windows PowerShell 兼容；通过要求用户换 shell 掩盖普通脚本新引入的 API 不兼容。
+- 证据：artifacts/powershell-sample-compat/；相关脚本 scripts/samples/run-avalonia-sample.ps1、run-headless-sample.ps1。
diff --git a/.agents/lessons/L-20261029-04-bounded-scene-capture.md b/.agents/lessons/L-20261029-04-bounded-scene-capture.md
new file mode 100644
index 00000000..ab15128e
--- /dev/null
+++ b/.agents/lessons/L-20261029-04-bounded-scene-capture.md
@@ -0,0 +1,17 @@
+# L-20261029-04：缩小场景预览时也要限制效果处理像素
+
+- 状态：confirmed
+- 来源：2026-10-29 Sample 保存与截图卡顿跟进（独立修复）
+- 关联：docs/spec/control.md，SceneLayerHost，SceneRenderPipeline
+
+## 现象与根因
+
+只把 RenderTargetBitmap 或 Image 缩小，仍可能在 UI 线程内运行完整逻辑分辨率的 CPU 效果链。场景自定义绘制操作内部自行分配纹理，外层缩放不约束它的像素预算。
+
+## 正确做法
+
+捕获入口分别传入逻辑尺寸和像素尺寸；图层原生大小、X/Y、粒子坐标继续用原逻辑空间，绘制画布缩放到输出像素空间。层效果与场景效果的中间纹理都使用预览像素尺寸。正式截图保留原分辨率，PNG 编码在渲染后移到后台。同一截图弹窗的两种界面包含状态可以分别缓存。
+
+## 验证与禁止做法
+
+SceneLayerHostTests.Bounded_snapshot_preserves_native_texture_coordinates_and_bounds_effect_work 验证非零位置的 Native 图片和效果源纹理尺寸；ScreenshotEntryTests.BoundedCaptureIncludesControlsPreservesSceneAndLeavesFullExportUnchanged 验证界面叠层、后台编码和后续完整导出。禁止仅凭小图片的输出尺寸宣称渲染计算已缩小；禁止把低分辨率预览用于正式导出。
diff --git a/.agents/lessons/L-20261029-05-save-thumbnail-notifications.md b/.agents/lessons/L-20261029-05-save-thumbnail-notifications.md
new file mode 100644
index 00000000..4904946b
--- /dev/null
+++ b/.agents/lessons/L-20261029-05-save-thumbnail-notifications.md
@@ -0,0 +1,15 @@
+# L-20261029-05：存档列表通知不能反复重建已解码缩略图
+
+- 状态：confirmed
+- 来源：2026-10-29 Sample 保存卡顿跟进（独立修复）
+- 关联：docs/spec/control.md，AvaloniaGameSession，SaveSlotsPageViewModel
+
+## 现象与根因
+
+整表 Clear 后逐项 Add，每次 CollectionChanged 都重建全部行并重新解码图片，60 个槽位会产生二次方增长的重复工作。异步磁盘写入无法避免随后 UI 线程的图片解码卡顿。
+
+## 正确做法与验证
+
+整表准备好后发送一次 Reset；单槽保存使用 Replace，VM 只替换对应行并释放旧图，改名仅更新名称。保存前后只查询目标元数据，自定义存储通过可选 ISaveSlotInfoSource 实现，原 ISaveService 保持兼容。缩略图生成和旧图解码均限制尺寸。
+
+GameThemeTests.Saving_one_slot_preserves_the_other_rows_and_decoded_previews 验证其他行与 Bitmap 身份保持不变；FileSaveServiceTests.SingleSlotLookupMatchesListMetadataForOccupiedEmptyAndCorruptSlots 验证单槽查询语义。禁止在每次集合通知中无条件 Clear/Rebuild 带解码资源的全部行。
diff --git a/.agents/lessons/L-20261029-06-native-exit-confirmation.md b/.agents/lessons/L-20261029-06-native-exit-confirmation.md
new file mode 100644
index 00000000..454deb17
--- /dev/null
+++ b/.agents/lessons/L-20261029-06-native-exit-confirmation.md
@@ -0,0 +1,9 @@
+# 原生 Sample 关闭测试须完成退出确认
+
+- 状态：confirmed
+- 来源：F-20261029-01-desktop-package-layout。
+- 现象：开发发行包已通过调试连接、开始、变量修改、定位和停止，原生测试仍在退出处超时；finally 的临时目录清理 IOException 可掩盖原始超时。
+- 根因：MainWindow 的退出遮罩默认聚焦 Cancel；仅向自有窗口发送 WM_CLOSE 不会完成关闭，不能据此推断发行包的释放链有问题。
+- 做法：NativeSampleWindow 先按 PID 与明确标题选取唯一自有窗口，再排队 WM_CLOSE、Tab、Enter，完成真实确认；继续断言零退出码和玩家变量已落盘。输入只发给该 HWND，不切换用户前台窗口。
+- 验证：未确认时三种原生场景均失败；补充确认后，同一开发 ZIP 三种场景全部通过，另两种真实整合内容加载也通过。见 out/package-layout/tests/published-native-confirmed.trx。
+- 边界：这是测试适配，不在玩家代码中跳过确认，也不通过强杀进程宣称正常退出验收成功。失败清理异常需要保留原始诊断。
diff --git a/.agents/lessons/L-20261029-07-self-contained-platform-assemblies.md b/.agents/lessons/L-20261029-07-self-contained-platform-assemblies.md
new file mode 100644
index 00000000..3ee74d4a
--- /dev/null
+++ b/.agents/lessons/L-20261029-07-self-contained-platform-assemblies.md
@@ -0,0 +1,18 @@
+# 自包含部署的业务 DLL 不能按 corelib 目录排除
+
+状态：confirmed
+来源 Feature：F-20261029-04-new-project-application
+
+## 现象与根因
+
+识别契约依赖闭包时，若把 TRUSTED_PLATFORM_ASSEMBLIES 中与 System.Private.CoreLib 同目录的条目全部视为平台程序集，框架依赖部署可以工作，自包含部署却会把同目录的 GalNet.Core、Contracts.Builtins 等业务依赖一起排除。目录位置不表示程序集归属。
+
+## 发现与证据
+
+当前自包含发行的 lib 同时包含 framework 与应用 DLL；GalNet.Editor.deps.json 的 targets 含 runtimepack.Microsoft.NETCore.App.Runtime.win-x64/10.0.12，其 runtime 节点单独列出平台资产。用自包含 ContractSmoke 实际调用 ProjectContractSource，SchemaA 依赖闭包保留 Core、Builtins、SchemaDependency，读取真实 Sample Debug 输出只得到 Core、Builtins、Project.Contracts 三个 DLL，保持原始字节且释放临时目录。
+
+## 正确做法与边界
+
+自包含部署从运行时 deps 清单的 runtimepack.Microsoft.NETCore.App.Runtime.* runtime 资产识别平台程序集；框架依赖部署才使用独立框架目录中的 TPA 条目。不得直接按自包含 lib 目录排除程序集，也不得把全部 TPA 当作纯 BCL。此规则用于依赖收集；已有 ProjectSchemaContext 的平台回退逻辑未在本 feature 中修改，不据此宣称它的所有部署边界已修复。
+
+证据：out/new-project-app-smoke/published/ContractSmoke.exe；实现：src/Editor/GalNet.Editor.Shared/Services/ProjectContractSource.cs；设计与总结：features/F-20261029-04-new-project-application/。
diff --git a/.agents/lessons/L-20261029-08-invalid-data-startup-fallback.md b/.agents/lessons/L-20261029-08-invalid-data-startup-fallback.md
new file mode 100644
index 00000000..df89b022
--- /dev/null
+++ b/.agents/lessons/L-20261029-08-invalid-data-startup-fallback.md
@@ -0,0 +1,12 @@
+# 安装内容损坏异常与启动 profile 回退
+
+状态：confirmed
+日期：2026-10-29
+来源：features/F-20261029-02-packed-game-documents
+
+- 现象：新增 game.pak 身份读取后，profile 定位先于日志和启动窗口执行，损坏包可能提前终止程序。
+- 根因：`System.IO.InvalidDataException` 的基类是 `SystemException`，不是 `IOException`；原来针对文件与 JSON 的 catch 不会包含 GPAK 验证失败。
+- 发现：复核 Sample 启动顺序，并在实际 PowerShell 宿主查询异常 BaseType 确认。
+- 正确做法：只在允许缺失身份的 profile 探测边界显式处理 InvalidDataException，暂用路径摘要；正式内容加载继续拒绝损坏包，由启动窗口报告错误。
+- 禁止：把内容加载校验本身改成静默回退，或认为所有 System.IO 命名空间异常都会被 IOException 捕获。
+- 回归：PackedDocumentTests.CorruptedPackedDocumentsAreRejectedWithoutLegacyFallback 同时验证 profile 探测不抛出与内容加载仍拒绝；isolated-integration.trx 中 game.pak/localization.pak 两用例通过。
diff --git a/.agents/lessons/L-20261029-09-reading-preamble-checkpoints.md b/.agents/lessons/L-20261029-09-reading-preamble-checkpoints.md
new file mode 100644
index 00000000..05b3b198
--- /dev/null
+++ b/.agents/lessons/L-20261029-09-reading-preamble-checkpoints.md
@@ -0,0 +1,22 @@
+# 阅读复合条目的存档边界应覆盖语音前导
+
+状态：confirmed
+来源：F-20261029-03-dialogue-history
+
+## 现象和根因
+
+带语音对白编译为非流程阻塞 audio.play 和阻塞 dialogue.text。Engine 原先在音频后发布稳定快照，EntryIndex 指向文本；读档只重执行文本，不能通过本次执行恢复同源语音关联，而且恢复的音频缺少原语的自动等待所有权。
+
+## 正确做法
+
+复用 readingBoundaryId，从前导原语开始至阅读原语完成前保持此前稳定快照。阅读原语进入后由原有阻塞状态继续保护；CatchUp 完整执行后才能发布新稳定点。宿主历史按快照中的小游标截取正文，当前句读档重执行不重复。
+
+展示完成的异步 continuation 不保证先于玩家下一次推进执行；历史游标还须在 OnCheckpointCreating（Engine 执行门内）同步提交。不能只依赖后台观察 PresentationCompletion。CheckpointFlushesPresentedTextEvenIfItsPresentationContinuationHasNotRun 用延迟的呈现完成任务覆盖该交错。
+
+## 证据
+
+DialogueHistoryTests.EngineCheckpointRestartsTheWholeVoicedLineAndKeepsHistoryWithoutDuplicates：显示带语音当前句时保存仍为整句入口，读档重新执行音频/文本并保留语音引用；进入下一句后只保存此前历史前缀。Runtime 124 项和现有自动等待集成用例通过。
+
+## 边界
+
+不要只序列化一个历史语音字段掩盖半句快照问题，也不要从当前正在响的音频推断文本关系。Core/Runtime 仅处理阅读边界，不识别具体音频或对白类型。
diff --git a/.agents/lessons/L-20261029-10-disabled-title-foreground.md b/.agents/lessons/L-20261029-10-disabled-title-foreground.md
new file mode 100644
index 00000000..65540a92
--- /dev/null
+++ b/.agents/lessons/L-20261029-10-disabled-title-foreground.md
@@ -0,0 +1,11 @@
+# 模态遮罩下的静态标题前景色
+
+- 状态：confirmed
+- 日期：2026-10-29
+- 来源：用户反馈退出确认出现后主页标题消失；独立 Sample UI 修复。
+- 现象：退出确认将 PlayerContent.IsEnabled 设为 false。主页 GameTitle 没有显式 Foreground，继承内容容器的禁用文字色，再叠加遮罩后标题显著变淡；标题字符串与可见性没有改变。
+- 根因：容器禁用会改变后代继承的前景画刷。之前的弹窗截图没有执行主页导航或 CompleteStartup，背景为空，未覆盖实际主页。
+- 做法：Classic/Minimal/Paper 静态标题显式绑定 TextPrimary；保留背景禁用及输入保护。弹窗测试挂载真实主页，比较打开前后标题画刷的 Color 与 Opacity，不能只检查标题字符串或 IsVisible。
+- 验证：修复前实际挂载回归失败（标题颜色由 #FF181D25 变为 #FF1C1F23，截图显著变淡）；修复后 SampleWindowThemeTests 通过，三布局×三配色的 9 项挂载测试通过。前后截图在 out/exit-title/。
+- 边界：静态标题保留正常色；可操作控件的禁用反馈不在此规则范围。不要为保留标题而解除背景输入禁用，也不要用空背景截图证明主页仍可见。
+- 正式文档：docs/spec/control.md、docs/manual/customize-avalonia-sample.md。
diff --git a/.gitattributes b/.gitattributes
index d513d984..2e5afff7 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -10,4 +10,8 @@
 *.yml text
 
 *.ico binary
-*.png binary
\ No newline at end of file
+*.png binary
+
+# Preserve the checksum of pinned upstream source bytes on Windows checkouts.
+src/Infrastructure/GalNet.Media.Miniaudio/native/miniaudio.h -text
+src/Infrastructure/GalNet.Media.Miniaudio/native/stb_vorbis.c -text
diff --git a/.github/workflows/backend-portability.yml b/.github/workflows/backend-portability.yml
new file mode 100644
index 00000000..f14a1cbb
--- /dev/null
+++ b/.github/workflows/backend-portability.yml
@@ -0,0 +1,90 @@
+name: Backend portability
+
+on:
+  pull_request:
+    paths:
+      - 'src/Shared/**'
+      - 'src/Infrastructure/**'
+      - 'src/Tooling/**'
+      - 'src/Samples/GalNet.Sample.Headless/**'
+      - 'src/Samples/GalNet.Sample.Contracts/**'
+      - 'test/GalNet.Assets.Tests/**'
+      - 'test/GalNet.Media.Audio.Tests/**'
+      - 'Directory.*'
+      - 'global.json'
+      - 'scripts/test-native-aot.ps1'
+      - '.github/workflows/backend-portability.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  portable-backends:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+            library: galnet_miniaudio.dll
+          - os: ubuntu-latest
+            library: libgalnet_miniaudio.so
+          - os: macos-latest
+            library: libgalnet_miniaudio.dylib
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 20
+    env:
+      DOTNET_CLI_TELEMETRY_OPTOUT: '1'
+      DOTNET_NOLOGO: '1'
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: 10.0.401
+      - name: Build native audio library
+        shell: pwsh
+        run: |
+          cmake -S src/Infrastructure/GalNet.Media.Miniaudio/native -B artifacts/native -DCMAKE_BUILD_TYPE=Release
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          cmake --build artifacts/native --config Release
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          cmake --install artifacts/native --config Release --prefix artifacts/native/install
+          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+      - name: Verify shared resources and audio decoding
+        shell: pwsh
+        run: |
+          $nativePath = Join-Path $PWD 'artifacts/native/install/${{ matrix.library }}'
+          foreach ($project in @('GalNet.Assets.Tests', 'GalNet.Media.Audio.Tests')) {
+            $projectPath = "test/$project/$project.csproj"
+            dotnet restore $projectPath --locked-mode -p:GalNetMiniaudioNativePath="$nativePath"
+            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+            dotnet build $projectPath --no-restore --configuration Release -p:GalNetMiniaudioNativePath="$nativePath"
+            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+            dotnet test $projectPath --no-build --no-restore --configuration Release -p:GalNetMiniaudioNativePath="$nativePath" --logger "trx;LogFileName=$project.trx" --results-directory artifacts/results
+            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+          }
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: backend-tests-${{ matrix.os }}
+          path: artifacts/results
+          if-no-files-found: warn
+
+  native-aot:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 20
+    env:
+      DOTNET_CLI_TELEMETRY_OPTOUT: '1'
+      DOTNET_NOLOGO: '1'
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: 10.0.401
+      - name: Publish and execute NativeAOT engine acceptance
+        shell: pwsh
+        run: ./scripts/test-native-aot.ps1
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f6946a6d..92703cde 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -3,138 +3,36 @@ name: CI
 on:
   pull_request:
   push:
-    branches:
-      - master
+    branches: [master]
   workflow_dispatch:
 
 permissions:
   contents: read
 
-jobs:
-  format:
-    runs-on: windows-latest
-    timeout-minutes: 20
-    env:
-      DOTNET_CLI_TELEMETRY_OPTOUT: '1'
-      DOTNET_NOLOGO: '1'
-      AVALONIA_TELEMETRY_OPTOUT: '1'
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-dotnet@v5
-        with:
-          dotnet-version: 10.0.401
-      - name: Restore locked dependencies (excluding launcher)
-        shell: pwsh
-        run: |
-          $projects = Get-ChildItem src, test -Filter *.csproj -Recurse |
-            Where-Object { $_.FullName -notmatch '[\\/]src[\\/]Launcher[\\/]' } |
-            Sort-Object FullName
-          foreach ($project in $projects) {
-            dotnet restore $project.FullName --locked-mode
-            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          }
-      - name: Verify whitespace
-        shell: pwsh
-        run: |
-          $projects = Get-ChildItem src, test -Filter *.csproj -Recurse |
-            Where-Object { $_.FullName -notmatch '[\\/]src[\\/]Launcher[\\/]' } |
-            Sort-Object FullName
-          foreach ($project in $projects) {
-            dotnet format whitespace $project.FullName --no-restore --verify-no-changes --verbosity quiet
-            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          }
-      - name: Verify imports
-        shell: pwsh
-        run: |
-          $projects = Get-ChildItem src, test -Filter *.csproj -Recurse |
-            Where-Object { $_.FullName -notmatch '[\\/]src[\\/]Launcher[\\/]' } |
-            Sort-Object FullName
-          foreach ($project in $projects) {
-            dotnet format style $project.FullName --no-restore --verify-no-changes --diagnostics IDE0005 --verbosity quiet
-            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          }
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
-  desktop-build-and-test:
+jobs:
+  verify:
+    strategy:
+      fail-fast: false
+      matrix:
+        stage: [Format, BuildTest]
     runs-on: windows-latest
-    timeout-minutes: 30
-    env:
-      DOTNET_CLI_TELEMETRY_OPTOUT: '1'
-      DOTNET_NOLOGO: '1'
-      AVALONIA_TELEMETRY_OPTOUT: '1'
+    timeout-minutes: 45
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-dotnet@v5
         with:
-          dotnet-version: 10.0.401
-      - name: Restore test projects
-        shell: pwsh
-        run: |
-          Get-ChildItem test -Filter *.csproj -Recurse | ForEach-Object {
-            dotnet restore $_.FullName --locked-mode
-            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          }
-      - name: Restore editor CLI
-        run: dotnet restore src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj --locked-mode
-      - name: Restore headless sample
-        run: dotnet restore src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj --locked-mode
-      - name: Build editor CLI
-        run: dotnet build src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj --no-restore --configuration Release -p:ContinuousIntegrationBuild=true
-      - name: Build headless sample
-        run: dotnet build src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj --no-restore --configuration Release -p:ContinuousIntegrationBuild=true
-      - name: Test pure logic and architecture with coverage
-        shell: pwsh
-        run: |
-          $projects = @(
-            'GalNet.Architecture.Tests',
-            'GalNet.Core.Tests',
-            'GalNet.Runtime.Tests',
-            'GalNet.GameHost.Tests',
-            'GalNet.Primitives.Builtins.Tests',
-            'GalNet.Assets.Tests',
-            'GalNet.Storage.FileSystem.Tests'
-          )
-          foreach ($project in $projects) {
-            dotnet test "test/$project/$project.csproj" --no-restore --configuration Release --logger "trx;LogFileName=$project.trx" --results-directory artifacts/test-results --collect:"XPlat Code Coverage"
-            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          }
-      - name: Test editor and presentation with coverage
+          global-json-file: global.json
+      - name: Run shared local CI entry
         shell: pwsh
-        run: |
-          $projects = @(
-            'GalNet.Editor.Shared.Tests',
-            'GalNet.Editor.Tests',
-            'GalNet.Presentation.Tests'
-          )
-          foreach ($project in $projects) {
-            dotnet test "test/$project/$project.csproj" --no-restore --configuration Release --logger "trx;LogFileName=$project.trx" --results-directory artifacts/test-results --collect:"XPlat Code Coverage"
-            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          }
-      - name: Test integration with coverage
-        run: dotnet test test/GalNet.IntegrationTests/GalNet.IntegrationTests.csproj --no-restore --configuration Release --logger "trx;LogFileName=GalNet.IntegrationTests.trx" --results-directory artifacts/test-results --collect:"XPlat Code Coverage"
-      - name: Upload test results
+        run: ./scripts/ci/Invoke-CI.ps1 -Stage ${{ matrix.stage }} -OutputRoot out/ci/${{ matrix.stage }} -Coverage
+      - name: Upload check logs and test results
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: desktop-test-results
-          path: artifacts/test-results
+          name: ci-${{ matrix.stage }}
+          path: out/ci/${{ matrix.stage }}
           if-no-files-found: warn
-
-  platform-solution-build:
-    if: github.event_name == 'workflow_dispatch'
-    runs-on: windows-latest
-    timeout-minutes: 45
-    env:
-      DOTNET_CLI_TELEMETRY_OPTOUT: '1'
-      DOTNET_NOLOGO: '1'
-      AVALONIA_TELEMETRY_OPTOUT: '1'
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-dotnet@v5
-        with:
-          dotnet-version: 10.0.401
-      - name: Restore workloads
-        run: dotnet workload restore GalNet.slnx --version 10.0.401.1
-      - name: Restore locked dependencies
-        run: dotnet restore GalNet.slnx --locked-mode
-      - name: Build full solution
-        run: dotnet build GalNet.slnx --no-restore --configuration Release -p:ContinuousIntegrationBuild=true
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000..0026739d
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,113 @@
+name: Release
+
+on:
+  push:
+    tags: ['v*']
+  workflow_dispatch:
+    inputs:
+      version:
+        description: Local-only candidate version (no upload)
+        required: true
+        default: 0.1.0-dev.1
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  validate-source:
+    runs-on: windows-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Require the release tag to belong to master
+        if: github.event_name == 'push'
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        shell: pwsh
+        run: |
+          git fetch --no-tags origin '+refs/heads/master:refs/remotes/origin/master'
+          if ($LASTEXITCODE -ne 0) { throw 'Could not fetch the release main branch.' }
+          ./scripts/ci/Test-ReleaseRef.ps1 -Tag $env:RELEASE_TAG
+
+  build:
+    needs: validate-source
+    runs-on: windows-latest
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-dotnet@v5
+        with:
+          global-json-file: global.json
+      - name: Run the same CI checks as local development
+        shell: pwsh
+        run: ./scripts/ci/Invoke-CI.ps1 -Stage All -OutputRoot out/ci/release
+      - name: Build and validate the local release
+        env:
+          CANDIDATE_VERSION: ${{ inputs.version }}
+        shell: pwsh
+        run: |
+          if ('${{ github.event_name }}' -eq 'push') {
+            ./scripts/release/Release.ps1 -Tag $env:GITHUB_REF_NAME -SampleMode R2R
+          } else {
+            ./scripts/release/Release.ps1 -Version $env:CANDIDATE_VERSION -SampleMode R2R
+          }
+      - name: Upload sealed release files
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-files
+          path: |
+            out/release/*/nuget/*.nupkg
+            out/release/*/assets/*.zip
+            out/release/*/SHA256SUMS
+            out/release/*/release-index.json
+          if-no-files-found: error
+      - name: Upload validation evidence
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-evidence
+          path: |
+            out/ci/release
+            out/release/.work/**/logs
+            out/release/.work/**/package-validation.json
+          include-hidden-files: true
+          if-no-files-found: warn
+
+  publish:
+    if: github.event_name == 'push' && github.ref_type == 'tag'
+    needs: build
+    runs-on: windows-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-dotnet@v5
+        with:
+          global-json-file: global.json
+      - uses: actions/download-artifact@v4
+        with:
+          name: release-files
+          path: out/release
+      - name: Upload the verified files without rebuilding
+        shell: pwsh
+        env:
+          GH_TOKEN: ${{ github.token }}
+          NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}
+        run: |
+          $version = $env:GITHUB_REF_NAME.Substring(1)
+          ./scripts/release/Push.ps1 -Index "out/release/$version/release-index.json"
+      - name: Preserve upload journal
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-push-journal
+          path: out/release/*/push-state.json
+          if-no-files-found: warn
diff --git a/.gitignore b/.gitignore
index c4311db1..48cd1eed 100644
--- a/.gitignore
+++ b/.gitignore
@@ -461,6 +461,13 @@ riderModule.iml
 !.vscode/extensions.json
 
 # Project-specific
+/artifacts/benchmarks/
+/out/
+!/scripts/release/
+!/scripts/release/**
+!/src/Editor/GalNet.Editor/Properties/PublishProfiles/WindowsReadyToRun.pubxml
+!/src/Samples/GalNet.Sample.Avalonia/Properties/PublishProfiles/WindowsReadyToRun.pubxml
+!/src/Editor/GalNet.Editor.Headless/Properties/PublishProfiles/WindowsReadyToRun.pubxml
 /output/
 dev/*
 .galnet/
diff --git a/Directory.Build.props b/Directory.Build.props
index 0495e51d..973ef183 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -9,5 +9,22 @@
     <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
     <RestoreLockedMode Condition="'$(CI)' == 'true'">true</RestoreLockedMode>
     <ContinuousIntegrationBuild Condition="'$(CI)' == 'true'">true</ContinuousIntegrationBuild>
+    <DefineConstants Condition="'$(Benchmark)' == 'true'">$(DefineConstants);BENCHMARK</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Benchmark)' == 'true'">
+    <!-- Keep restore graphs and binaries separate from ordinary builds. -->
+    <BaseIntermediateOutputPath>obj/benchmark/</BaseIntermediateOutputPath>
+    <BaseOutputPath>bin/benchmark/</BaseOutputPath>
+    <NuGetLockFilePath>$(MSBuildProjectDirectory)/obj/benchmark/packages.lock.json</NuGetLockFilePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(PublishProfile)' == 'WindowsReadyToRun' And '$(Benchmark)' != 'true'">
+    <!-- Keep the RID publish graph separate from ordinary development locks, but track it for locked CI restores. -->
+    <BaseIntermediateOutputPath>obj/publish/WindowsReadyToRun/</BaseIntermediateOutputPath>
+    <BaseOutputPath>bin/publish/WindowsReadyToRun/</BaseOutputPath>
+    <NuGetLockFilePath>$(MSBuildProjectDirectory)/packages.lock.WindowsReadyToRun.json</NuGetLockFilePath>
+  </PropertyGroup>
+  <PropertyGroup>
+    <!-- Both output trees are generated, regardless of the active build mode. -->
+    <DefaultItemExcludes>$(DefaultItemExcludes);$(MSBuildProjectDirectory)/obj/**;$(MSBuildProjectDirectory)/bin/**</DefaultItemExcludes>
   </PropertyGroup>
 </Project>
diff --git a/Directory.Build.targets b/Directory.Build.targets
index cf2a329b..dad3fec8 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -6,4 +6,22 @@
     <!-- Preserve portable PDBs and local debugging; omit commit-specific URLs. -->
     <EnableSourceLink>false</EnableSourceLink>
   </PropertyGroup>
+  <!-- Contract identity is the deployed IL binary, not an R2R-transformed copy. -->
+  <ItemGroup Condition="'$(PublishReadyToRun)' == 'true'">
+    <PublishReadyToRunExclude Include="GalNet.Core.dll;GalNet.Contracts.Builtins.dll;GalNet.Project.Contracts.dll" />
+  </ItemGroup>
+  <!-- Generate a normal SDK apphost targeting the packaged managed entry in lib/.
+       Ordinary bin/publish apphosts are unaffected unless packaging opts in. -->
+  <Target Name="CreatePackageAppHost" AfterTargets="Publish"
+          DependsOnTargets="_GetAppHostPaths;_GetAppHostCreationConfiguration"
+          Condition="'$(PackageAppHostDestinationPath)' != '' And '$(_IsExecutable)' == 'true'">
+    <Error Condition="'$(AppHostSourcePath)' == '' Or !Exists('$(AppHostSourcePath)')" Text="Packaging requires an SDK apphost template." />
+    <CreateAppHost AppHostSourcePath="$(AppHostSourcePath)"
+                   AppHostDestinationPath="$(PackageAppHostDestinationPath)"
+                   AppBinaryName="lib/$(AssemblyName)$(TargetExt)"
+                   IntermediateAssembly="@(IntermediateAssembly->'%(FullPath)')"
+                   WindowsGraphicalUserInterface="$(_UseWindowsGraphicalUserInterface)"
+                   EnableMacOSCodeSign="$(_EnableMacOSCodeSign)"
+                   DisableCetCompat="$(_DisableCetCompat)" />
+  </Target>
 </Project>
diff --git a/GalNet.slnx b/GalNet.slnx
index aea9aac8..0e8ee1ce 100644
--- a/GalNet.slnx
+++ b/GalNet.slnx
@@ -6,6 +6,15 @@
   <Folder Name="/test/Schema/">
     <Project Path="test/GalNet.SchemaGenerator.Tests/GalNet.SchemaGenerator.Tests.csproj" />
   </Folder>
+  <Folder Name="/test/Fixtures/">
+    <Project Path="test/Fixtures/SchemaA/SchemaA.csproj" />
+    <Project Path="test/Fixtures/SchemaB/SchemaB.csproj" />
+    <Project Path="test/Fixtures/SchemaDependency/SchemaDependency.csproj" />
+    <Project Path="test/Fixtures/SchemaDuplicate/SchemaDuplicate.csproj" />
+    <Project Path="test/Fixtures/SchemaIncompatible/SchemaIncompatible.csproj" />
+    <Project Path="test/Fixtures/SchemaInvalid/SchemaInvalid.csproj" />
+    <Project Path="test/Fixtures/VersionedCore/VersionedCore.csproj" />
+  </Folder>
   <Folder Name="/src/Editor/">
     <Project Path="src/Editor/GalNet.Editor.DefaultContracts/GalNet.Editor.DefaultContracts.csproj" />
     <Project Path="src/Editor/GalNet.Editor.Abstraction/GalNet.Editor.Abstraction.csproj" />
@@ -14,20 +23,11 @@
     <Project Path="src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj" />
   </Folder>
   <Folder Name="/src/Infrastructure/">
+    <Project Path="src/Infrastructure/GalNet.Media.Audio/GalNet.Media.Audio.csproj" />
+    <Project Path="src/Infrastructure/GalNet.Media.Miniaudio/GalNet.Media.Miniaudio.csproj" />
     <Project Path="src/Infrastructure/GalNet.Media.LibVlc/GalNet.Media.LibVlc.csproj" />
     <Project Path="src/Infrastructure/GalNet.Storage.FileSystem/GalNet.Storage.FileSystem.csproj" />
   </Folder>
-  <Folder Name="/src/Launcher/">
-    <Project Path="src/Launcher/GalNet.Launcher.Android/GalNet.Launcher.Android.csproj">
-      <Deploy />
-    </Project>
-    <Project Path="src/Launcher/GalNet.Launcher.Browser/GalNet.Launcher.Browser.csproj" />
-    <Project Path="src/Launcher/GalNet.Launcher.Desktop/GalNet.Launcher.Desktop.csproj" />
-    <Project Path="src/Launcher/GalNet.Launcher.iOS/GalNet.Launcher.iOS.csproj">
-      <Deploy />
-    </Project>
-    <Project Path="src/Launcher/GalNet.Launcher/GalNet.Launcher.csproj" />
-  </Folder>
   <Folder Name="/src/Presentation/">
     <Project Path="src/Presentation/GalNet.Avalonia.GameHost/GalNet.Avalonia.GameHost.csproj" />
     <Project Path="src/Presentation/GalNet.Avalonia.Controls/GalNet.Avalonia.Controls.csproj" />
@@ -41,6 +41,7 @@
     <Project Path="src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj" />
   </Folder>
   <Folder Name="/src/Shared/">
+    <Project Path="src/Shared/GalNet.Diagnostics/GalNet.Diagnostics.csproj" />
     <Project Path="src/Shared/GalNet.Debugging/GalNet.Debugging.csproj" />
     <Project Path="src/Shared/GalNet.GameHost/GalNet.GameHost.csproj" />
     <Project Path="src/Shared/GalNet.Assets/GalNet.Assets.csproj" />
@@ -51,6 +52,8 @@
     <Project Path="src/Shared/GalNet.Runtime/GalNet.Runtime.csproj" />
   </Folder>
   <Folder Name="/test/">
+    <Project Path="test/GalNet.Media.Audio.Tests/GalNet.Media.Audio.Tests.csproj" />
+    <Project Path="test/GalNet.Diagnostics.Tests/GalNet.Diagnostics.Tests.csproj" />
     <Project Path="test/GalNet.Debugging.Tests/GalNet.Debugging.Tests.csproj" />
     <Project Path="test/GalNet.GameHost.Tests/GalNet.GameHost.Tests.csproj" />
     <Project Path="test/GalNet.Architecture.Tests/GalNet.Architecture.Tests.csproj" />
diff --git a/GameTestCase/Assets/Effects/Default/Bloom.sksl b/GameTestCase/Assets/Effects/Default/Bloom.sksl
new file mode 100644
index 00000000..5b24459a
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/Bloom.sksl
@@ -0,0 +1,54 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer,scenePost
+
+@param strength
+  uniform: strength
+  type: float
+  default: 0
+  range: 0..5
+  animatable: true
+
+@param radius
+  uniform: radius
+  type: float
+  default: 16
+  range: 0..64
+  animatable: true
+
+@param threshold
+  uniform: threshold
+  type: float
+  default: 0.8
+  range: 0..1
+  animatable: true
+
+@param softKnee
+  uniform: softKnee
+  type: float
+  default: 0.1
+  range: 0.001..1
+  animatable: true
+*/
+uniform shader source;
+uniform float strength, radius, threshold, softKnee;
+half4 main(float2 p) {
+    half4 c = source.eval(p);
+    float3 glow = float3(0);
+    float weights = 0.0;
+    for (int y = -2; y <= 2; y++) {
+        for (int x = -2; x <= 2; x++) {
+            float3 rgb = float3(source.eval(p + float2(float(x),float(y))*radius*0.5).rgb);
+            float luma = dot(rgb,float3(0.2126,0.7152,0.0722));
+            float soft = clamp(luma-threshold+softKnee,0.0,2.0*softKnee);
+            soft = soft*soft/(4.0*max(softKnee,0.001));
+            float w = exp(-float(x*x+y*y)/4.5);
+            glow += rgb * (max(luma-threshold,soft)/max(luma,0.0001)) * w;
+            weights += w;
+        }
+    }
+    // Keep premultiplied RGB inside alpha for partially transparent layers.
+    float3 room = max(float3(c.a)-float3(c.rgb),float3(0));
+    return half4(half3(float3(c.rgb)+room*clamp(glow*strength/max(weights,0.001),0.0,1.0)),c.a);
+}
diff --git a/GameTestCase/Assets/Effects/Default/Bloom.sksl.meta b/GameTestCase/Assets/Effects/Default/Bloom.sksl.meta
new file mode 100644
index 00000000..89d3b0f4
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/Bloom.sksl.meta
@@ -0,0 +1 @@
+{"path":"Effects/Default/Bloom.sksl","id":"b1000000000000000000000000000001","type":"effect-program"}
diff --git a/GameTestCase/Assets/Effects/Default/Blur.sksl b/GameTestCase/Assets/Effects/Default/Blur.sksl
new file mode 100644
index 00000000..fd198451
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/Blur.sksl
@@ -0,0 +1,34 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer,scenePost
+
+@param radius
+  uniform: radius
+  type: float
+  default: 0
+  range: 0..64
+  animatable: true
+
+@param direction
+  uniform: direction
+  type: vector2
+  default: [1,0]
+  animatable: false
+*/
+uniform shader source;
+uniform float radius;
+uniform float2 direction;
+half4 main(float2 p) {
+    if (radius <= 0.001) return source.eval(p);
+    float4 sum = float4(source.eval(p));
+    float weights = 1.0;
+    for (int i = 1; i <= 12; i++) {
+        float t = float(i) / 12.0;
+        float w = exp(-4.5 * t * t);
+        float2 d = direction * radius * t;
+        sum += (float4(source.eval(p+d)) + float4(source.eval(p-d))) * w;
+        weights += 2.0 * w;
+    }
+    return half4(sum / weights);
+}
diff --git a/GameTestCase/Assets/Effects/Default/Blur.sksl.meta b/GameTestCase/Assets/Effects/Default/Blur.sksl.meta
new file mode 100644
index 00000000..401a9e5f
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/Blur.sksl.meta
@@ -0,0 +1 @@
+{"path":"Effects/Default/Blur.sksl","id":"b1000000000000000000000000000002","type":"effect-program"}
diff --git a/GameTestCase/Assets/Effects/Default/ColorGrade.sksl b/GameTestCase/Assets/Effects/Default/ColorGrade.sksl
new file mode 100644
index 00000000..3ef9be59
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/ColorGrade.sksl
@@ -0,0 +1,45 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer,scenePost
+
+@param exposure
+  uniform: exposure
+  type: float
+  default: 0
+  range: -4..4
+  animatable: true
+
+@param saturation
+  uniform: saturation
+  type: float
+  default: 1
+  range: 0..2
+  animatable: true
+
+@param contrast
+  uniform: contrast
+  type: float
+  default: 1
+  range: 0..2
+  animatable: true
+
+@param temperature
+  uniform: temperature
+  type: float
+  default: 0
+  range: -1..1
+  animatable: true
+*/
+uniform shader source;
+uniform float exposure, saturation, contrast, temperature;
+half4 main(float2 p) {
+    half4 c = source.eval(p);
+    if (c.a <= 0.0) return c;
+    float3 rgb = float3(c.rgb) / float(c.a);
+    rgb *= exp2(exposure);
+    rgb = mix(float3(dot(rgb,float3(0.2126,0.7152,0.0722))),rgb,saturation);
+    rgb = (rgb - 0.5) * contrast + 0.5;
+    rgb += temperature * float3(0.12,0.025,-0.12);
+    return half4(half3(clamp(rgb,0.0,1.0) * c.a), c.a);
+}
diff --git a/GameTestCase/Assets/Effects/Default/ColorGrade.sksl.meta b/GameTestCase/Assets/Effects/Default/ColorGrade.sksl.meta
new file mode 100644
index 00000000..676a1d0a
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/ColorGrade.sksl.meta
@@ -0,0 +1 @@
+{"path":"Effects/Default/ColorGrade.sksl","id":"b1000000000000000000000000000004","type":"effect-program"}
diff --git a/GameTestCase/Assets/Effects/Default/DepthBlur.sksl b/GameTestCase/Assets/Effects/Default/DepthBlur.sksl
new file mode 100644
index 00000000..d4879d46
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/DepthBlur.sksl
@@ -0,0 +1,51 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer
+
+@param focusZ
+  uniform: focusZ
+  type: float
+  default: 0
+  animatable: true
+
+@param focusRange
+  uniform: focusRange
+  type: float
+  default: 0
+  range: 0..100000
+  animatable: true
+
+@param falloff
+  uniform: falloff
+  type: float
+  default: 0.1
+  range: 0..64
+  animatable: true
+
+@param maxRadius
+  uniform: maxRadius
+  type: float
+  default: 24
+  range: 0..64
+  animatable: true
+*/
+uniform shader source;
+uniform float layerZ;
+uniform float focusZ, focusRange, falloff, maxRadius;
+half4 main(float2 p) {
+    float r = clamp((abs(layerZ-focusZ)-focusRange)*falloff,0.0,maxRadius);
+    if (r <= 0.001) return source.eval(p);
+    float4 sum = float4(source.eval(p));
+    float weights = 1.0;
+    // A dense disk avoids the repeated-image grid produced by widely spaced square taps.
+    for (int i = 1; i <= 48; i++) {
+        float t = float(i)/48.0;
+        float angle = float(i)*2.39996323;
+        float2 offset = float2(cos(angle),sin(angle))*sqrt(t)*r;
+        float w = exp(-4.5*t);
+        sum += float4(source.eval(p+offset))*w;
+        weights += w;
+    }
+    return half4(sum/weights);
+}
diff --git a/GameTestCase/Assets/Effects/Default/DepthBlur.sksl.meta b/GameTestCase/Assets/Effects/Default/DepthBlur.sksl.meta
new file mode 100644
index 00000000..17f3965e
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/DepthBlur.sksl.meta
@@ -0,0 +1 @@
+{"path":"Effects/Default/DepthBlur.sksl","id":"b1000000000000000000000000000005","type":"effect-program"}
diff --git a/GameTestCase/Assets/Effects/Default/MaskReveal.sksl b/GameTestCase/Assets/Effects/Default/MaskReveal.sksl
new file mode 100644
index 00000000..345b8612
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/MaskReveal.sksl
@@ -0,0 +1,33 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer
+
+@param progress
+  uniform: progress
+  type: float
+  default: 0
+  range: 0..1
+  animatable: true
+
+@param softness
+  uniform: softness
+  type: float
+  default: 0.05
+  range: 0.001..1
+  animatable: true
+
+@texture mask
+  uniform: mask
+  required: true
+*/
+uniform shader source;
+uniform shader mask;
+uniform float progress, softness;
+half4 main(float2 p) {
+    if (progress <= 0.0) return half4(0);
+    if (progress >= 1.0) return source.eval(p);
+    float value = dot(float3(mask.eval(p).rgb),float3(0.2126,0.7152,0.0722));
+    float edge = mix(-softness,1.0+softness,progress);
+    return source.eval(p)*half(1.0-smoothstep(edge-softness,edge+softness,value));
+}
diff --git a/GameTestCase/Assets/Effects/Default/MaskReveal.sksl.meta b/GameTestCase/Assets/Effects/Default/MaskReveal.sksl.meta
new file mode 100644
index 00000000..4690a920
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/MaskReveal.sksl.meta
@@ -0,0 +1 @@
+{"path":"Effects/Default/MaskReveal.sksl","id":"b1000000000000000000000000000008","type":"effect-program"}
diff --git a/GameTestCase/Assets/Effects/Default/Reveal.sksl b/GameTestCase/Assets/Effects/Default/Reveal.sksl
new file mode 100644
index 00000000..819f8dd6
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/Reveal.sksl
@@ -0,0 +1,66 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer
+
+@param progress
+  uniform: progress
+  type: float
+  default: 0
+  range: 0..1
+  animatable: true
+
+@param softness
+  uniform: softness
+  type: float
+  default: 0.05
+  range: 0.001..1
+  animatable: true
+
+@param mode
+  uniform: mode
+  type: enum
+  default: Wipe
+  options: Wipe,Radial,Noise,Blinds
+  animatable: false
+
+@param angle
+  uniform: angle
+  type: float
+  default: 0
+  range: -360..360
+  animatable: true
+
+@param count
+  uniform: count
+  type: float
+  default: 12
+  range: 1..256
+  animatable: true
+
+@param center
+  uniform: center
+  type: vector2
+  default: [0.5,0.5]
+  animatable: false
+*/
+uniform shader source;
+uniform float2 size, center;
+uniform float progress, softness, mode, angle, count;
+float hash(float2 v) { return fract(sin(dot(v,float2(127.1,311.7)))*43758.5453); }
+half4 main(float2 p) {
+    if (progress <= 0.0) return half4(0);
+    if (progress >= 1.0) return source.eval(p);
+    float2 uv = p/max(size,float2(1));
+    float a = angle*0.01745329252;
+    float2 axis = float2(cos(a),sin(a));
+    float value = dot(uv-0.5,axis)/max(abs(axis.x)+abs(axis.y),0.001)+0.5;
+    if (mode > 0.5 && mode < 1.5) {
+        float farthest = length(max(center,1.0-center));
+        value = length(uv-center)/max(farthest,0.001);
+    } else if (mode > 1.5 && mode < 2.5) value = hash(floor(uv*160.0));
+    else if (mode > 2.5) value = fract(value*count);
+    float edge = mix(-softness,1.0+softness,progress);
+    float alpha = 1.0-smoothstep(edge-softness,edge+softness,value);
+    return source.eval(p)*half(alpha);
+}
diff --git a/GameTestCase/Assets/Effects/Default/Reveal.sksl.meta b/GameTestCase/Assets/Effects/Default/Reveal.sksl.meta
new file mode 100644
index 00000000..cc96c17d
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/Reveal.sksl.meta
@@ -0,0 +1 @@
+{"path":"Effects/Default/Reveal.sksl","id":"b1000000000000000000000000000007","type":"effect-program"}
diff --git a/GameTestCase/Assets/Effects/Default/SpeedLines.sksl b/GameTestCase/Assets/Effects/Default/SpeedLines.sksl
new file mode 100644
index 00000000..00960294
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/SpeedLines.sksl
@@ -0,0 +1,102 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer
+
+@param time
+  uniform: time
+  type: float
+  default: 0
+  animatable: true
+
+@param speed
+  uniform: speed
+  type: float
+  default: 2
+  range: -20..20
+  animatable: true
+
+@param density
+  uniform: density
+  type: float
+  default: 64
+  range: 4..256
+  animatable: true
+
+@param strength
+  uniform: strength
+  type: float
+  default: 1
+  range: 0..1
+  animatable: true
+
+@param flicker
+  uniform: flicker
+  type: float
+  default: 0.3
+  range: 0..1
+  animatable: true
+
+@param mode
+  uniform: mode
+  type: enum
+  default: Radial
+  options: Radial,Directional
+  animatable: false
+
+@param angle
+  uniform: angle
+  type: float
+  default: 0
+  range: -360..360
+  animatable: true
+
+@param center
+  uniform: center
+  type: vector2
+  default: [0.5,0.5]
+  animatable: false
+
+@param color
+  uniform: color
+  type: color
+  default: #FFFFFF
+  animatable: false
+*/
+uniform shader source;
+uniform float2 size, center;
+uniform float time, speed, density, strength, flicker, mode, angle;
+uniform float4 color;
+float hash(float x) { return fract(sin(x*127.1+311.7)*43758.5453); }
+half4 main(float2 p) {
+    float2 q = (p-center*size)/max(min(size.x,size.y),1.0);
+    float stroke;
+    if (mode < 0.5) {
+        float angular = (atan(q.y,q.x)+3.14159265)/6.2831853*floor(density);
+        float sector = floor(angular);
+        float noise = hash(sector);
+        float width = mix(0.035,0.14,hash(sector+71.0));
+        float across = 1.0-smoothstep(width,width+0.045,abs(fract(angular)-0.5));
+        float r = length(q);
+        float head = fract(time*speed*0.25+noise)*1.6;
+        float along = smoothstep(head-0.8,head-0.65,r)*(1.0-smoothstep(head,head+0.12,r));
+        stroke = across * along * smoothstep(0.08+noise*0.1,0.36,r);
+    } else {
+        float a = angle*0.01745329252;
+        float2 axis = float2(cos(a),sin(a));
+        float coordinate = dot(q,float2(-axis.y,axis.x))*density;
+        float lane = floor(coordinate);
+        float noise = hash(lane);
+        float width = mix(0.035,0.14,hash(lane+71.0));
+        float aa = max(0.02,0.5*density/max(min(size.x,size.y),1.0));
+        float across = 1.0-smoothstep(max(0.0,width-aa),width+aa,abs(fract(coordinate)-0.5));
+        float u = fract((dot(q,axis)-time*speed)*0.5+noise);
+        float along = smoothstep(0.1,0.2,u)*(1.0-smoothstep(0.8,0.9,u));
+        stroke = across * along;
+    }
+    float blink = 1.0-flicker*(0.5+0.5*sin(time*37.0));
+    float alpha = clamp(stroke*blink*strength*color.a,0.0,1.0);
+    // A shader-generated overlay; the transparent source is an explicit layer carrier.
+    half4 inputColor = source.eval(p);
+    return half4(half3(color.rgb*alpha),half(alpha)) + inputColor * half(1.0-alpha);
+}
diff --git a/GameTestCase/Assets/Effects/Default/SpeedLines.sksl.meta b/GameTestCase/Assets/Effects/Default/SpeedLines.sksl.meta
new file mode 100644
index 00000000..d5f20ef3
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/SpeedLines.sksl.meta
@@ -0,0 +1 @@
+{"path":"Effects/Default/SpeedLines.sksl","id":"b1000000000000000000000000000006","type":"effect-program"}
diff --git a/GameTestCase/Assets/Effects/Default/Vignette.sksl b/GameTestCase/Assets/Effects/Default/Vignette.sksl
new file mode 100644
index 00000000..14a249a7
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/Vignette.sksl
@@ -0,0 +1,42 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer,scenePost
+
+@param strength
+  uniform: strength
+  type: float
+  default: 0
+  range: 0..1
+  animatable: true
+
+@param radius
+  uniform: radius
+  type: float
+  default: 0.45
+  range: 0..2
+  animatable: true
+
+@param softness
+  uniform: softness
+  type: float
+  default: 0.4
+  range: 0.001..2
+  animatable: true
+
+@param center
+  uniform: center
+  type: vector2
+  default: [0.5,0.5]
+  animatable: false
+*/
+uniform shader source;
+uniform float2 size;
+uniform float strength, radius, softness;
+uniform float2 center;
+half4 main(float2 p) {
+    half4 c = source.eval(p);
+    float d = length((p / max(size,float2(1))) - center);
+    float fade = smoothstep(radius, radius + max(softness,0.001), d);
+    return half4(c.rgb * half(1.0 - strength * fade), c.a);
+}
diff --git a/GameTestCase/Assets/Effects/Default/Vignette.sksl.meta b/GameTestCase/Assets/Effects/Default/Vignette.sksl.meta
new file mode 100644
index 00000000..a6610d51
--- /dev/null
+++ b/GameTestCase/Assets/Effects/Default/Vignette.sksl.meta
@@ -0,0 +1 @@
+{"path":"Effects/Default/Vignette.sksl","id":"b1000000000000000000000000000003","type":"effect-program"}
diff --git a/GameTestCase/Graph/groups/ending.rawgalgroup b/GameTestCase/Graph/groups/ending.rawgalgroup
index 075115da..c55b9290 100644
--- a/GameTestCase/Graph/groups/ending.rawgalgroup
+++ b/GameTestCase/Graph/groups/ending.rawgalgroup
@@ -2,8 +2,383 @@
   "version": 2,
   "kind": "Raw",
   "entries": [
-    { "id": "stop-snow", "type": "particle.stop", "parameters": { "instanceId": "route-particles" } },
-    { "id": "hide-portrait", "type": "layer.hide", "parameters": { "handleId": "teacher" } },
-    { "id": "line", "type": "dialogue.text", "parameters": { "speaker": "guide", "content": "group.ending.entry.line.content" } }
+    {
+      "id": "stop-snow",
+      "type": "particle.stop",
+      "parameters": {
+        "instanceId": "route-particles"
+      }
+    },
+    {
+      "id": "hide-portrait",
+      "type": "layer.hide",
+      "parameters": {
+        "handleId": "teacher"
+      }
+    },
+    {
+      "id": "hide-toy-backdrop",
+      "type": "layer.hide",
+      "parameters": {
+        "handleId": "shader-toy-background"
+      }
+    },
+    {
+      "id": "visual-background",
+      "type": "layer.show",
+      "parameters": {
+        "handleId": "visual-bg",
+        "assetId": "a1000000000000000000000000000001",
+        "z": 0,
+        "displayMode": "Fill"
+      }
+    },
+    {
+      "id": "visual-portrait",
+      "type": "variants.show",
+      "parameters": {
+        "handleId": "visual-hero",
+        "assetId": "a1000000000000000000000000000020",
+        "selection": {
+          "expression": "shy"
+        },
+        "transform": {
+          "x": 420,
+          "y": 80
+        },
+        "z": 10
+      }
+    },
+    {
+      "id": "visual-intro",
+      "type": "dialogue.text",
+      "parameters": {
+        "speaker": "guide",
+        "content": "group.ending.entry.visual-intro.content"
+      }
+    },
+    {
+      "id": "visual-bloom",
+      "type": "effect.apply",
+      "parameters": {
+        "instanceId": "visual-bloom",
+        "program": "b1000000000000000000000000000001",
+        "parameters": {
+          "strength": 2,
+          "radius": 24
+        }
+      }
+    },
+    {
+      "id": "visual-vignette",
+      "type": "effect.apply",
+      "parameters": {
+        "instanceId": "visual-vignette",
+        "program": "b1000000000000000000000000000003",
+        "parameters": {
+          "strength": 0.8,
+          "radius": 0.2
+        }
+      }
+    },
+    {
+      "id": "visual-grade",
+      "type": "effect.apply",
+      "parameters": {
+        "instanceId": "visual-grade",
+        "program": "b1000000000000000000000000000004",
+        "parameters": {
+          "temperature": 0.4,
+          "saturation": 0.8
+        }
+      }
+    },
+    {
+      "id": "visual-grade-line",
+      "type": "dialogue.text",
+      "parameters": {
+        "speaker": "guide",
+        "content": "group.ending.entry.visual-grade.content"
+      }
+    },
+    {
+      "id": "stop-visual-bloom",
+      "type": "effect.stop",
+      "parameters": {
+        "instanceId": "visual-bloom"
+      }
+    },
+    {
+      "id": "stop-visual-vignette",
+      "type": "effect.stop",
+      "parameters": {
+        "instanceId": "visual-vignette"
+      }
+    },
+    {
+      "id": "stop-visual-grade",
+      "type": "effect.stop",
+      "parameters": {
+        "instanceId": "visual-grade"
+      }
+    },
+    {
+      "id": "depth-bg",
+      "type": "effect.apply",
+      "parameters": {
+        "instanceId": "depth-bg",
+        "targetHandleId": "visual-bg",
+        "program": "b1000000000000000000000000000005",
+        "parameters": {
+          "focusZ": 10,
+          "falloff": 2,
+          "maxRadius": 24
+        }
+      }
+    },
+    {
+      "id": "depth-hero",
+      "type": "effect.apply",
+      "parameters": {
+        "instanceId": "depth-hero",
+        "targetHandleId": "visual-hero",
+        "program": "b1000000000000000000000000000005",
+        "parameters": {
+          "focusZ": 10,
+          "falloff": 2,
+          "maxRadius": 24
+        }
+      }
+    },
+    {
+      "id": "visual-depth",
+      "type": "dialogue.text",
+      "parameters": {
+        "speaker": "guide",
+        "content": "group.ending.entry.visual-depth.content"
+      }
+    },
+    {
+      "id": "rack-focus",
+      "type": "timeline.play",
+      "parameters": {
+        "timeline": {
+          "playbackHandleId": "visual-rack-focus",
+          "frameRate": 60,
+          "durationFrames": 60,
+          "blocking": true,
+          "skippable": true,
+          "tracks": [
+            {
+              "handleId": "depth-bg",
+              "property": "focusZ",
+              "keys": [
+                {
+                  "frame": 0,
+                  "value": 10
+                },
+                {
+                  "frame": 60,
+                  "value": 0
+                }
+              ]
+            },
+            {
+              "handleId": "depth-hero",
+              "property": "focusZ",
+              "keys": [
+                {
+                  "frame": 0,
+                  "value": 10
+                },
+                {
+                  "frame": 60,
+                  "value": 0
+                }
+              ]
+            }
+          ],
+          "events": []
+        }
+      }
+    },
+    {
+      "id": "visual-focus",
+      "type": "dialogue.text",
+      "parameters": {
+        "speaker": "guide",
+        "content": "group.ending.entry.visual-focus.content"
+      }
+    },
+    {
+      "id": "stop-depth-bg",
+      "type": "effect.stop",
+      "parameters": {
+        "instanceId": "depth-bg"
+      }
+    },
+    {
+      "id": "stop-depth-hero",
+      "type": "effect.stop",
+      "parameters": {
+        "instanceId": "depth-hero"
+      }
+    },
+    {
+      "id": "jump",
+      "type": "preset.motion",
+      "parameters": {
+        "playbackHandleId": "visual-jump",
+        "handleId": "visual-hero",
+        "motion": "Jump",
+        "distance": 24,
+        "durationFrames": 24
+      }
+    },
+    {
+      "id": "nod",
+      "type": "preset.motion",
+      "parameters": {
+        "playbackHandleId": "visual-nod",
+        "handleId": "visual-hero",
+        "motion": "Nod",
+        "rotationDegrees": 8,
+        "durationFrames": 30
+      }
+    },
+    {
+      "id": "shake",
+      "type": "preset.shake",
+      "parameters": {
+        "playbackHandleId": "visual-shake",
+        "handleId": "visual-hero",
+        "amplitude": 12,
+        "angle": 15,
+        "durationFrames": 36
+      }
+    },
+    {
+      "id": "radial-lines",
+      "type": "preset.speedLines",
+      "parameters": {
+        "playbackHandleId": "visual-radial-lines",
+        "program": "b1000000000000000000000000000006",
+        "parameters": {
+          "mode": "Radial",
+          "density": 80,
+          "color": "#FFFFFF"
+        },
+        "durationFrames": 90
+      }
+    },
+    {
+      "id": "directional-lines",
+      "type": "preset.speedLines",
+      "parameters": {
+        "playbackHandleId": "visual-directional-lines",
+        "program": "b1000000000000000000000000000006",
+        "parameters": {
+          "mode": "Directional",
+          "angle": 0,
+          "color": "#FFFFFF"
+        },
+        "speed": 5,
+        "durationFrames": 90
+      }
+    },
+    {
+      "id": "impact",
+      "type": "preset.impact",
+      "parameters": {
+        "playbackHandleId": "visual-impact",
+        "program": "b1000000000000000000000000000006",
+        "handleId": "visual-hero",
+        "amplitude": 18,
+        "durationFrames": 48
+      }
+    },
+    {
+      "id": "visual-impact",
+      "type": "dialogue.text",
+      "parameters": {
+        "speaker": "guide",
+        "content": "group.ending.entry.visual-impact.content"
+      }
+    },
+    {
+      "id": "push",
+      "type": "preset.motion",
+      "parameters": {
+        "playbackHandleId": "visual-push",
+        "handleId": "visual-bg",
+        "motion": "Push",
+        "scale": 1.1,
+        "anchorX": 200,
+        "distance": 0,
+        "durationFrames": 60
+      }
+    },
+    {
+      "id": "wipe",
+      "type": "transition.reveal",
+      "parameters": {
+        "playbackHandleId": "visual-wipe",
+        "oldHandleId": "visual-bg",
+        "newHandleId": "visual-bg2",
+        "assetId": "a1000000000000000000000000000002",
+        "program": "b1000000000000000000000000000007",
+        "mode": "Wipe",
+        "durationFrames": 60
+      }
+    },
+    {
+      "id": "blur",
+      "type": "transition.blur",
+      "parameters": {
+        "playbackHandleId": "visual-blur",
+        "oldHandleId": "visual-bg2",
+        "newHandleId": "visual-bg3",
+        "assetId": "a1000000000000000000000000000001",
+        "blurProgram": "b1000000000000000000000000000002",
+        "durationFrames": 60
+      }
+    },
+    {
+      "id": "mask",
+      "type": "transition.reveal",
+      "parameters": {
+        "playbackHandleId": "visual-mask",
+        "oldHandleId": "visual-bg3",
+        "newHandleId": "visual-bg4",
+        "assetId": "a1000000000000000000000000000002",
+        "program": "b1000000000000000000000000000008",
+        "mode": "Mask",
+        "maskAsset": "a1000000000000000000000000000003",
+        "durationFrames": 60
+      }
+    },
+    {
+      "id": "visual-transitions",
+      "type": "dialogue.text",
+      "parameters": {
+        "speaker": "guide",
+        "content": "group.ending.entry.visual-transitions.content"
+      }
+    },
+    {
+      "id": "hide-visual-hero",
+      "type": "layer.hide",
+      "parameters": {
+        "handleId": "visual-hero"
+      }
+    },
+    {
+      "id": "line",
+      "type": "dialogue.text",
+      "parameters": {
+        "speaker": "guide",
+        "content": "group.ending.entry.line.content"
+      }
+    }
   ]
 }
diff --git a/GameTestCase/Graph/groups/intro.rawgalgroup b/GameTestCase/Graph/groups/intro.rawgalgroup
index 49bc009e..0ba89034 100644
--- a/GameTestCase/Graph/groups/intro.rawgalgroup
+++ b/GameTestCase/Graph/groups/intro.rawgalgroup
@@ -27,19 +27,21 @@
     { "id": "video-background", "type": "video.play", "parameters": { "asset": "a1000000000000000000000000000011", "handleId": "sample-video", "blocking": "false", "transform": { "x": -160, "y": 60, "scaleX": 0.5, "scaleY": 0.5, "rotationDegrees": 10 }, "z": 5, "opacity": 0.7, "displayMode": "Uniform" } },
     { "id": "intro-video-background", "type": "dialogue.text", "parameters": { "speaker": "guide", "content": "group.intro.entry.intro-video-background.content" } },
     { "id": "video-stop", "type": "video.stop", "parameters": { "handleId": "sample-video" } },
-    { "id": "bgm-duck", "type": "audio.seffect.apply", "parameters": { "trackId": "bgm", "instanceId": "sample-bgm-duck", "id": "seffect.gain", "parameters": { "gain": 0.35 } } },
+    { "id": "bgm-duck", "type": "audio.seffect.apply", "parameters": { "targetId": "bgm", "instanceId": "sample-bgm-duck", "id": "seffect.gain", "parameters": { "gain": 0.35 } } },
     { "id": "intro-line-effect-on", "type": "dialogue.text", "parameters": { "speaker": "guide", "content": "group.intro.entry.intro-line-effect-on.content" } },
     { "id": "bgm-pause-for-save", "type": "audio.pause", "parameters": { "trackId": "bgm" } },
     { "id": "audio-save-checkpoint", "type": "dialogue.text", "parameters": { "speaker": "guide", "content": "group.intro.entry.audio-save-checkpoint.content" } },
     { "id": "bgm-resume-after-save", "type": "audio.resume", "parameters": { "trackId": "bgm" } },
-    { "id": "bgm-unduck", "type": "audio.seffect.stop", "parameters": { "trackId": "bgm", "instanceId": "sample-bgm-duck" } },
+    { "id": "bgm-unduck", "type": "audio.seffect.stop", "parameters": { "targetId": "bgm", "instanceId": "sample-bgm-duck" } },
     { "id": "intro-line-effect-off", "type": "dialogue.text", "parameters": { "speaker": "guide", "content": "group.intro.entry.intro-line-effect-off.content" } },
-    { "id": "bgm-low-pass", "type": "audio.seffect.apply", "parameters": { "trackId": "bgm", "instanceId": "sample-bgm-low-pass", "id": "seffect.lowPass", "parameters": { "cutoffHz": 900, "attenuationDb": -20 } } },
+    { "id": "bgm-room", "type": "audio.seffect.apply", "parameters": { "scope": "bus", "targetId": "bgm", "instanceId": "sample-room", "id": "seffect.reverb", "parameters": { "roomSize": 0.65, "decaySeconds": 1.8, "damping": 0.4, "mix": 0.25 } } },
+    { "id": "bgm-low-pass", "type": "audio.seffect.apply", "parameters": { "targetId": "bgm", "instanceId": "sample-bgm-low-pass", "id": "seffect.lowPass", "parameters": { "cutoffHz": 900, "q": 0.7071 } } },
     { "id": "intro-line-low-pass", "type": "dialogue.text", "parameters": { "speaker": "guide", "content": "group.intro.entry.intro-line-low-pass.content" } },
-    { "id": "bgm-stop-low-pass", "type": "audio.seffect.stop", "parameters": { "trackId": "bgm", "instanceId": "sample-bgm-low-pass" } },
-    { "id": "bgm-high-pass", "type": "audio.seffect.apply", "parameters": { "trackId": "bgm", "instanceId": "sample-bgm-high-pass", "id": "seffect.highPass", "parameters": { "cutoffHz": 1200, "attenuationDb": -20 } } },
+    { "id": "bgm-stop-low-pass", "type": "audio.seffect.stop", "parameters": { "targetId": "bgm", "instanceId": "sample-bgm-low-pass" } },
+    { "id": "bgm-high-pass", "type": "audio.seffect.apply", "parameters": { "targetId": "bgm", "instanceId": "sample-bgm-high-pass", "id": "seffect.highPass", "parameters": { "cutoffHz": 1200, "q": 0.7071 } } },
     { "id": "intro-line-high-pass", "type": "dialogue.text", "parameters": { "speaker": "guide", "content": "group.intro.entry.intro-line-high-pass.content" } },
-    { "id": "bgm-stop-high-pass", "type": "audio.seffect.stop", "parameters": { "trackId": "bgm", "instanceId": "sample-bgm-high-pass" } },
+    { "id": "bgm-stop-high-pass", "type": "audio.seffect.stop", "parameters": { "targetId": "bgm", "instanceId": "sample-bgm-high-pass" } },
+    { "id": "bgm-room-stop", "type": "audio.seffect.stop", "parameters": { "scope": "bus", "targetId": "bgm", "instanceId": "sample-room" } },
     { "id": "portrait-jitter", "type": "animation.animate", "parameters": { "playbackHandleId": "portrait-jitter", "handleId": "teacher", "property": "transform.y", "from": 0, "to": 12, "duration": 0.06, "curve": "EaseInOut", "blocking": "false", "skippable": "false", "loopMode": "PingPong", "blendMode": "Additive" } },
     { "id": "variants-during-jitter", "type": "variants.select", "parameters": { "handleId": "teacher", "dimension": "expression", "value": "wink" } },
     { "id": "intro-line-2", "type": "dialogue.text", "parameters": { "speaker": "guide", "content": "group.intro.entry.intro-line-2.content" } },
diff --git a/GameTestCase/I18n/en-US/groups/ending.json b/GameTestCase/I18n/en-US/groups/ending.json
index 49a07596..ad00cc98 100644
--- a/GameTestCase/I18n/en-US/groups/ending.json
+++ b/GameTestCase/I18n/en-US/groups/ending.json
@@ -1,3 +1,9 @@
 {
+  "group.ending.entry.visual-intro.content": "The default visual library is next: editable project shaders and compiled performance presets.",
+  "group.ending.entry.visual-grade.content": "Bloom, vignette and warm color grading can be combined, then stopped independently.",
+  "group.ending.entry.visual-depth.content": "Layer Z depth of field: the portrait at Z=10 is sharp and the background at Z=0 is blurred.",
+  "group.ending.entry.visual-focus.content": "The focus moved to Z=0: the background is now sharp and the portrait is blurred.",
+  "group.ending.entry.visual-impact.content": "Jump, nod, character shake, animated radial and directional lines, then a combined impact. Every temporary overlay is cleaned up.",
+  "group.ending.entry.visual-transitions.content": "A directional soft wipe, two-pass blur crossfade, and image-mask dissolve. This example uses the brightness of an ordinary project image as the mask.",
   "group.ending.entry.line.content": "Runtime smoke test complete."
 }
diff --git a/GameTestCase/I18n/zh-CN/groups/ending.json b/GameTestCase/I18n/zh-CN/groups/ending.json
index 7ef5ff46..92399c28 100644
--- a/GameTestCase/I18n/zh-CN/groups/ending.json
+++ b/GameTestCase/I18n/zh-CN/groups/ending.json
@@ -1,3 +1,9 @@
 {
+  "group.ending.entry.visual-intro.content": "接下来展示默认视觉库：可编辑的项目 shader，以及编译为时间线的演出预设。",
+  "group.ending.entry.visual-grade.content": "Bloom、暗角和暖色调色可以叠加，也可以分别停止。",
+  "group.ending.entry.visual-depth.content": "按图层 Z 景深：Z=10 的人物清晰，Z=0 的背景模糊。",
+  "group.ending.entry.visual-focus.content": "焦点移到 Z=0 后，背景变清晰，人物变模糊。",
+  "group.ending.entry.visual-impact.content": "依次展示跳跃、点头、角色震动、动态径向与定向集中线，最后组合冲击；临时叠加图层会自动清理。",
+  "group.ending.entry.visual-transitions.content": "依次展示柔边擦除、两遍模糊交叉淡化和图片遮罩溶解；此例用普通项目图片的亮度作为遮罩。",
   "group.ending.entry.line.content": "运行时冒烟测试完成。"
 }
diff --git a/GameTestCase/README.md b/GameTestCase/README.md
index 42556dce..6fe3e709 100644
--- a/GameTestCase/README.md
+++ b/GameTestCase/README.md
@@ -1,5 +1,7 @@
 # Compiled-content runtime and presentation smoke test
 
+Both routes now finish with the default visual library showcase in `Graph/groups/ending.rawgalgroup`: bloom, vignette, grading, Z-based rack focus, character motion, synchronized shake, animated radial/directional speed lines, impact, wipe, blur and image-mask transitions. The editable default shaders live in `Assets/Effects/Default/`; see [the visual authoring manual](../docs/manual/default-visuals.md).
+
 This Raw-authoring game exercises the compiled runtime slice:
 
 The game includes English (`en-US`, its configured default) and Simplified Chinese
@@ -72,7 +74,7 @@ in `variants.show`; each image still has its own sprite ID. See
 From the repository root, validate and rebuild with the current project contracts:
 
 ```powershell
-./scripts/build-project-contracts.ps1 -ContractsProject ./src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj -ProjectDirectory ./GameTestCase
+./scripts/contracts/build-project-contracts.ps1 -ContractsProject ./src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj -ProjectDirectory ./GameTestCase
 dotnet run --project ./src/Editor/GalNet.Editor.Headless -- validate ./GameTestCase
 dotnet run --project ./src/Editor/GalNet.Editor.Headless -- build ./GameTestCase
 ```
@@ -107,6 +109,17 @@ intro group executes `gallery.unlock(100)`, making that item viewable after the
 
 Build and run from the repository root:
 
+The Sample launch scripts build and deploy Sample.Contracts before compiling this
+fixture, including on a fresh checkout:
+
+```powershell
+./scripts/samples/run-avalonia-sample.ps1
+./scripts/samples/run-headless-sample.ps1
+```
+
+`-SkipBuild` skips both contract deployment and content compilation. For direct
+CLI use, deploy the contracts as shown above before running:
+
 ```text
 dotnet run --project src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj -- build GameTestCase --output artifacts/sample-build
 dotnet run --project src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj -- artifacts/sample-build
@@ -122,7 +135,7 @@ Native decode tests are opt-in: set `GALNET_VIDEO_ASSETS` to the absolute `GameT
 本目录是当前格式的作者内容，entry 集合由独立 Sample.Contracts 项目声明。先从仓库根构建并部署工具契约，再使用 CLI 或打开 Editor：
 
 ```powershell
-./scripts/build-project-contracts.ps1 -ContractsProject ./src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj -ProjectDirectory ./GameTestCase
+./scripts/contracts/build-project-contracts.ps1 -ContractsProject ./src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj -ProjectDirectory ./GameTestCase
 dotnet run --project ./src/Editor/GalNet.Editor.Headless -- schema list ./GameTestCase
 dotnet run --project ./src/Editor/GalNet.Editor.Headless -- validate ./GameTestCase
 ```
@@ -137,3 +150,5 @@ Contracts/ 是本机构建产物，不提交 DLL；游戏 Sample 正常引用同
 intro 在 gain 效果启用后新增暂停 BGM 的对白检查点。运行到提示时新建存档，然后读档：背景/立绘与 gain 轨道效果应恢复，BGM 保持暂停；推进执行 audio.resume 后从头播放，并保留该效果直到后续 stop 指令。使用新存档验证，旧格式文件不做迁移。
 
 自动回归 `ModularSaveRestoreTests` 直接编译该实际作者文件中的图层/音频条目，通过 FileSaveService 写入全新槽位，再由 Engine 和注册式恢复会话读回；后端使用可观察的测试 host。实际 LibVLC 声音效果仍需按上面的原生媒体方式人工检查。
+
+Audio uses project section v2 (`audioBuses` / `busId`). The intro combines real track low/high-pass filters with bus `seffect.reverb`; effect entries use `scope` / `targetId`. The default Windows x64 host uses miniaudio; videos remain on LibVLC.
diff --git a/GameTestCase/settings.json b/GameTestCase/settings.json
index 309da3d9..e7a41a90 100644
--- a/GameTestCase/settings.json
+++ b/GameTestCase/settings.json
@@ -1,13 +1,74 @@
 {
-  "targetLocale": {
-    "code": "en-US"
-  },
-  "availableLocales": [
-    {
-      "code": "en-US"
-    },
-    {
-      "code": "zh-CN"
+  "version": 1,
+  "sections": {
+    "galnet.project": {
+      "version": 2,
+      "data": {
+        "defaultVisualPrograms": {
+          "bloom": "b1000000000000000000000000000001",
+          "blur": "b1000000000000000000000000000002",
+          "vignette": "b1000000000000000000000000000003",
+          "colorGrade": "b1000000000000000000000000000004",
+          "depthBlur": "b1000000000000000000000000000005",
+          "speedLines": "b1000000000000000000000000000006",
+          "reveal": "b1000000000000000000000000000007",
+          "maskReveal": "b1000000000000000000000000000008"
+        },
+        "targetLocale": {
+          "code": "en-US"
+        },
+        "availableLocales": [
+          {
+            "code": "en-US"
+          },
+          {
+            "code": "zh-CN"
+          }
+        ],
+        "audioBuses": [
+          {
+            "id": "bgm",
+            "name": "Settings.BgmVolume"
+          },
+          {
+            "id": "sfx",
+            "name": "Settings.SfxVolume"
+          },
+          {
+            "id": "vocal",
+            "name": "Settings.VoiceVolume"
+          }
+        ],
+        "audioTracks": [
+          {
+            "id": "bgm",
+            "busId": "bgm",
+            "name": "Music",
+            "preserveDuringCatchUp": true,
+            "defaultGain": 0.8,
+            "maxVoices": 1,
+            "maxQueuedItems": 64
+          },
+          {
+            "id": "sfx",
+            "busId": "sfx",
+            "name": "Effects",
+            "preserveDuringCatchUp": false,
+            "defaultGain": 1,
+            "maxVoices": 8,
+            "maxQueuedItems": 0
+          },
+          {
+            "id": "vocal",
+            "busId": "vocal",
+            "name": "Voice",
+            "preserveDuringCatchUp": false,
+            "defaultGain": 1,
+            "maxVoices": 1,
+            "maxQueuedItems": 64
+          }
+        ]
+      }
     }
-  ]
+  }
 }
diff --git a/README.md b/README.md
index 0ed1a136..9bdb47e9 100644
--- a/README.md
+++ b/README.md
@@ -61,20 +61,22 @@ dotnet format style GalNet.slnx --no-restore --verify-no-changes --diagnostics I
 以下脚本默认编译并运行 [`GameTestCase`](GameTestCase/README.md)：
 
 ```powershell
-.\scripts\run-headless-sample.ps1
-.\scripts\run-avalonia-sample.ps1
+.\scripts\samples\run-headless-sample.ps1
+.\scripts\samples\run-avalonia-sample.ps1
 ```
 
 Headless 示例在终端中交互；Avalonia 示例会启动桌面窗口。两个脚本都支持通过 `-Project`、`-BuildOutput` 和 `-SkipBuild` 指定已有内容。
 
+构建仓库自带的 `GameTestCase` 时，脚本会先构建并部署 Sample.Contracts，再编译剧情；`-SkipBuild` 跳过这两步。通过 `-Project` 指向其他内容项目时，需先按 [Sample.Contracts 说明](src/Samples/GalNet.Sample.Contracts/README.md) 部署与玩家匹配的项目契约。
+
 统计项目代码量可以运行：
 
 ```powershell
-.\scripts\count-code-lines.ps1
-.\scripts\count-code-lines.ps1 -Json
+.\scripts\maintenance\count-code-lines.ps1
+.\scripts\maintenance\count-code-lines.ps1 -Json
 ```
 
-脚本按编辑器、测试、文档和其他源码分组，显示文件数、物理行数和非空行数。默认识别 `.cs`、`.xaml`、`.axaml` 及常见源码扩展，并跳过构建产物、依赖、缓存和 agent 工具目录。
+脚本按编辑器、测试、文档和其他源码分组，显示文件数、物理行数和非空行数。默认识别 `.cs`、`.xaml`、`.axaml` 及常见源码扩展，并跳过构建产物、依赖、缓存和 agent 工具目录。其他脚本按 contracts、samples、performance、maintenance、release 分类，见 [scripts/README.md](scripts/README.md)。
 
 ## 开发流程
 
diff --git a/docs/README.md b/docs/README.md
index e9f03c09..eed785c2 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -12,6 +12,7 @@
 `spec/` 描述已实现的模块契约和当前限制。新增或修改功能后，应更新其唯一对应页面，而不是另建设计或 ADR 文档。
 
 - [架构与程序集边界](spec/architecture.md)
+- [CPU 性能事件](spec/cpu-benchmark.md)
 - [运行时与存档](spec/runtime.md)
 - [条目类型与项目契约](spec/entry-types.md)
 - [资源管理](spec/assets.md)
@@ -26,6 +27,12 @@
 
 ## 二次开发手册
 
+- [内容分包与资源补丁](manual/content-packaging.md)：单图章节启动、依赖闭包、剧情分包和独立资源覆盖矩阵。
+- [Track / Bus 音频混音](manual/audio-mixing.md)
+- [跨平台后端接入](manual/cross-platform-backends.md)：原生媒体构建、包内 PAK、缓存目录、设备生命周期及移动端验收边界。
+- [NativeAOT 发布与扩展契约](manual/native-aot.md)：复用 Headless Sample 发布、自检与源生成 JSON 元数据注册。
+- [默认视觉资源与演出预设](manual/default-visuals.md)
+
 - [接入新的表现层](manual/new-presentation-layer.md)：为 WPF、WinUI 或其他 UI 框架实现宿主和呈现适配的最小路径。
 - [定制 Avalonia Sample](manual/customize-avalonia-sample.md)：基于现有 Sample 落地项目配置、主题、原语和平台能力。
 - [注册通用 action](manual/custom-actions.md)：用固定双字符串原语调用项目逻辑，配置同步、异步和完整实例的运行行为。
@@ -33,3 +40,7 @@
 - [编辑游戏文本与翻译](manual/game-localization.md)：开发语言创作、多语言表格、语言顺序和草稿处理。
 - [创建图片差分图集](manual/image-variants.md)：目录导入、配置与差分预览、剧情初始选择及维度切换。
 - [使用与扩展 Editor 创作工作区](manual/editor-authoring-workspace.md)：常用字段、Inspector、会话草稿、问题定位与手动布局。
+- [外部工具创作与热重载](manual/external-project-authoring.md)：CLI 批量应用、Agent Skill、Git 回退和 Editor 外部文件同步。
+- [测量 CPU 启动](manual/cpu-benchmark.md)：编译开关、Editor/Sample 自动化基线与方法内埋点。
+- [使用 Windows ReadyToRun 发布](manual/ready-to-run.md)：发布版启动优化、隔离产物与契约字节身份。
+- [发布 Editor 与 Sample](manual/release-packaging.md)：本地 ZIP、GameTestCase / Galpak 整合包和 GitHub Release tag 流程。
diff --git a/docs/glossary.md b/docs/glossary.md
index 74986ff2..45b07041 100644
--- a/docs/glossary.md
+++ b/docs/glossary.md
@@ -18,9 +18,10 @@
 | target profile | `TargetProfileEntryCatalog` | 组合根为某个编辑或运行目标冻结的一组 Entry 模块及其 schema；它决定哪些 primitive/composite 可作者化和编译，未挂载类型不会回退到全局内置目录。 |
 | 原始组文件 | `.rawgalgroup` | 编辑器保存的 Group 源文件，可含 primitive 和 composite，`kind` 为 `Raw`。 |
 | 编译组文件 | `.galgroup` | 仅供 Runtime 加载的 Group 产物，只含 primitive，`kind` 为 `Compiled`。 |
-| 运行时 | `IGameRuntime` / `GameRuntime` | 当前节点、条目位置、变量、场景实例和文本解析器的唯一状态源。 |
+| 运行时 | `GalNet.Runtime.Runtime.IGameRuntime` / `GameRuntime` | 当前节点、条目位置、变量、场景实例和文本解析器的唯一状态源；执行模块借用 Core.Runtime.IGameContext。 |
 | 游戏引擎 | `GameEngine` | 驱动节点转移、活动 primitive 队列、batch skip、Choice 和稳定快照。 |
-| 游戏视图 | `IGameView` | 单条 primitive 的定义解析、参数规范化、实例创建和 dispatch 入口。 |
+| 指令分发端口 | `Core.Execution.IPrimitiveDispatcher` | 单条 primitive 的定义解析、参数规范化、实例创建和 dispatch 入口。 |
+| 游戏执行上下文 | `IGameContext` | primitive/呈现借用的变量、场景与游戏能力；游标修改和读档由 Engine 管理。 |
 | 呈现端口 | presenter interfaces | 宿主提供的窄端口，例如 dialogue、choice、layer、animation、effect。 |
 | 快照 | `GameSnapshot` | 可保存和恢复的运行时位置、变量与场景状态。 |
 | Gallery 目录 | `GalleryCatalog` | 由资源 `.meta.gallery[]` 与冻结类型注册聚合、在发行包中生成快照的不可变类型与资源条目索引，通过 `GameContent.Gallery` 交给宿主。 |
@@ -77,8 +78,10 @@
 | 资源管理器 | `IAssetManager` | 从 provider 按 GUID 定位资源，按 `(GUID, CLR 类型)` 解码/缓存，并以 `AssetHandle<T>` 引用计数释放已解析资源。 |
 | 资源句柄 | `AssetHandle<T>` | 一次成功 acquire 的独立资源引用；幂等 Dispose 只释放该次引用。 |
 | 资源解码器 | `IAssetDecoder<T>` | 将某种资源 type ID 的 `IGameFile` 解码为目标 CLR 类型；由宿主向资源管理器注册，不属于资源 metadata 类型注册。 |
-| 游戏内容提供者 | `IGameContentProvider` | 读取 Graph、设置、I18n 与 Gallery 等特殊内容的边界；`ProjectGameContentProvider` 从开发目录聚合 metadata，`InstalledGameContentProvider` 读取导出生成的 `gallery.json`。 |
+| 游戏内容提供者 | `IGameContentProvider` | 读取 Graph、设置、I18n 与 Gallery 等特殊内容的边界；`ProjectGameContentProvider` 从开发目录聚合 metadata，`InstalledGameContentProvider` 从 game.pak/localization.pak 读取内部文档与文本，兼容旧散文档。 |
 | pak | `.pak` | `PakBuilder` 构建的资源归档，含资源索引和数据。 |
-| 分发包 | `.galpak` | ZIP 分发容器，含根特殊内容、生成的 Gallery JSON、`Assets/Paks/000-base.pak` 与 JSON manifest；可验证后解压安装。 |
-| manifest | `<项目名>.galnet` | 当前 `.galpak` ZIP 根目录中唯一的 JSON manifest，描述项目与所有包的 SHA-256/大小；不是独立逻辑二进制。 |
+| 分发包 | `.galpak` | ZIP 分发容器，v3 以 `pak/` 为外层，含 game.pak、localization.pak、`Assets/Paks/*-base.pak` 和空扩展目录；可验证后解压安装。剧情 PAK 随导出生成在外部，资源覆盖 PAK 独立导出。 |
+| 剧情包 | story PAK | 同名 `storyPackage` Group 的独立依赖闭包减去本体资源，可由多个物理 PAK 组成；整体未安装时沿正常出口跳过。 |
+| 资源覆盖包 | override PAK | 携带原资源到替换资源的映射与目标依赖；按 priority、最终 PAK hash 确定覆盖来源。 |
+| manifest | `installation.json` | galpak v3 的 game.pak 内部安装清单，载荷路径相对内容根，描述项目与其余载荷 SHA-256/大小；兼容 v1/v2 的 `<项目名>.galnet` 外置清单。 |
 | 游戏安装 | `GameInstallation` | 将开发目录或验证并安装后的 `.galpak` 统一为内容 provider 与有序资源 provider 的宿主输入。 |
diff --git a/docs/manual/audio-mixing.md b/docs/manual/audio-mixing.md
new file mode 100644
index 00000000..8123a749
--- /dev/null
+++ b/docs/manual/audio-mixing.md
@@ -0,0 +1,63 @@
+# Track / Bus 音频混音
+
+默认宿主使用 `MiniaudioAudioPlaybackHost`，原生设备/解码适配位于 `GalNet.Media.Miniaudio`，跨平台 PCM 混音与 DSP 位于 `GalNet.Media.Audio`。LibVLC 继续服务视频和 Gallery，剧情音频不再通过独立 LibVLC player 输出。
+
+## 对象职责
+
+- 播放实例：资源、内容 gain、`fadeIn` / `fadeOut`、`loopCount`（0 为持续重复）和 `completion`（丢弃或重新入队）。替换时默认采用旧实例自己的淡出；显式 `audio.stop.fadeOut` 可覆盖。自然结尾淡出需要解码器提供时长。
+- Track：`maxVoices`、有界队列/溢出规则、`playbackOrder`（Sequential/Random）、`repeat`（None/One/All）、轨道音量和效果、`busId`。随机选择状态随存档恢复。失败、显式停止不会按自然结束重新入队。
+- Bus：真实汇总所属 Track，再执行一次共享效果链和整组音量。轨道不指定 Bus 时直接进入 Master。
+
+顺序为实例包络/gain → Track 汇总/有序 SEffect/音量 → Bus 汇总/有序 SEffect/音量 → Master 音量和限幅。Bus 效果不会复制到每个 Track 或实例。空输入仍处理效果尾音；停止音源不会清空房间混响。读档/reset 会清空旧 DSP 缓冲，不保存精确播放游标、包络时钟或尾音。
+
+## 效果与混音条目
+
+`audio.seffect.apply` / `audio.seffect.stop` 使用 `scope`（`track` / `bus`）、必填 `targetId` 和 `instanceId`。首次 apply 添加到链尾；相同实例/类型更新参数并保留链位置。移除平滑旁路，不重启声音。已附着的效果可在空闲时保留，新音源第一帧即经过目标链。
+
+Editor 的应用表单依次选择作用范围、Track/Bus、效果类型，再编辑参数。效果类型为 ComboBox；`id` 是其内部值。新建条目自动生成隐藏的 `instanceId`，复制时生成新身份并重映射批内引用，打开和保存既有内容不会补写身份。同一条目在剧情循环中再次执行仍操作原实例。
+
+停止表单先选择 Track/Bus，再选择该剧情位置之前已经挂载的实例，列表显示效果类型、创建来源和一定/可能存在。只列出直接挂载的效果；Track 不列出所属 Bus 的效果。分支、循环或自定义语义使分析不完整时显示提示，候选不要求先运行游戏。
+
+“全部效果”是显式 `all: true`，此时不填写 `instanceId`；不能同时指定非空实例。省略实例不会隐含停止全部。应用效果要求非空实例身份，既有无效身份保留原文供修复。
+
+```json
+{"type":"audio.seffect.apply","parameters":{"scope":"bus","targetId":"environment","instanceId":"room","id":"seffect.reverb","parameters":{"roomSize":0.65,"decaySeconds":1.8,"damping":0.4,"mix":0.25}}}
+```
+
+剧情后续调整已有实例使用 `audio.seffect.update`。在 Editor 中选择目标和实例后会展示对应参数；只填写需要改变的字段，未指定值保持不变。运行时合并后验证全部参数，失败时保留原值；实例不存在时无操作，不改变类型、不创建新实例、不改变链位置。
+
+```json
+{"type":"audio.seffect.update","parameters":{"scope":"bus","targetId":"environment","instanceId":"room","parameters":{"mix":0.4}}}
+```
+
+```json
+{"type":"audio.seffect.stop","parameters":{"scope":"bus","targetId":"environment","all":true}}
+```
+
+同一精确挂载身份在不同分支来自不同类型时，仍能停止，但更新表单不会猜测参数类型。既有未知类型、参数和失效引用保留，查询刷新不自动清空或改选。音频效果参数尚未接入 Timeline 动画，也没有新增音频 Timeline 事件。
+
+内置效果：
+
+| ID | 参数 |
+| --- | --- |
+| `seffect.gain` | `gain`，0～1 |
+| `seffect.lowPass` / `seffect.highPass` | 必填 `cutoffHz`，20～20000 Hz；`q` 默认 0.7071068，0.1～10；真实二阶滤波 |
+| `seffect.reverb` | `roomSize` 默认 0.5；`decaySeconds` 默认 1.5（0.1～20 秒）；`damping` 默认 0.4；`mix` 默认 0.25；其余范围 0～1 |
+
+混响是基础算法房间混响，空间大小、衰减、高频阻尼和干湿比例分别控制。更新参数/移除有平滑处理；移除效果会淡掉其输出，保留尾音的通常做法是仅停止音源。
+
+`audio.mix.set` 使用同样的 `scope` / `targetId`，配置 `gain`（默认 1）与 `muted`（默认 false）。这是可存档的剧情混音值；玩家音量由 `AudioMixOptions` 的 Master/Buses/Tracks 独立叠加。Master 静音覆盖干声和效果尾音。未指定字段使用 DTO 默认值，并非增量 patch。
+
+## 配置、构建与边界
+
+默认 `galnet.project` section 版本为 2，使用 `audioBuses` / `audioTracks[].busId`。旧 section v1 被明确拒绝，需更新字段和版本；SEffect 旧 `trackId` 改为 `targetId`，旧 EQ 参数 `attenuationDb` 删除。音频轨道/效果状态表版本为 2，并新增 `builtin.audio.channels`，旧档不能混用。
+
+Windows 开发构建需要 Visual Studio C++ Build Tools；源码固定 miniaudio 0.11.23，构建按目标 RID 选择 x64/ARM64 工具链，在 `obj/native/<rid>/` 生成并复制 `galnet_miniaudio.dll`，发布目录也包含它。ARM64 需要安装对应 C++ 工具；脚本按目标架构检查编译器、头文件和静态运行库，并显式选择版本最高的完整 MSVC 工具集，允许 ARM64 与 x64 使用不同的并存版本。其他系统通过 `native/CMakeLists.txt` 构建，并由 `GalNetMiniaudioNativePath` 传入匹配目标的动态库；Android/iOS 的包内原生库归宿主平台项目部署，不能仅依赖普通 Content 复制。当前实机验证 Windows x64，Windows ARM64 已验证原生库交叉编译、PE 架构和导出接口。内置解码支持 WAV/MP3/Ogg Vorbis/FLAC，其他格式明确报错；当前不提供 Send、跨 Bus 路由或 Sidechain。构建示例和验收边界见[跨平台后端接入](cross-platform-backends.md)。
+
+原生 ABI 当前为 2：路径统一为 UTF-8，Windows 内部转换为宽字符；设备回调使用静态 `UnmanagedCallersOnly` 入口和显式上下文，导入使用 `LibraryImport`。托管适配器和原生库必须一起更新，ABI 检查会拒绝不匹配版本；旧库缺少版本入口时同样不能运行。
+
+后端构造工厂为 `AvaloniaGamePresentationOptions.CreateAudioHost(assets, files)`。新适配器的所有权交给呈现会话，借用的 materializer 仍由宿主拥有。默认后端在后台解码至每实例两秒 PCM 有界缓冲，设备回调不读文件、不等待 Runtime 锁、不发布终态订阅；终态与文件释放在后台完成。源耗尽导致的缓冲不足填静音，不能据此宣称任意存储/设备条件下绝无断音。
+
+设备不可用时保留 PCM 效果目录和逻辑能力，避免设备状态使可移植存档的效果校验失效；实际 Start 通过 Failed 终态降级。
+
+`PcmAudioPlaybackHost.SupportsOutputSuspension` 表示输出实现是否支持可选的 `IAudioOutputLifecycle`。宿主可在控制线程调用 `SuspendOutput()` / `ResumeOutput()`；不得从设备渲染回调调用。暂停等待设备回调结束，不改变剧情 voice 的 Pause、gain、位置或 DSP 状态；解码仍可在有界缓冲范围内预读。Miniaudio 暂停时释放设备，恢复时重新选择默认设备，失败可重试；不自动监听系统音频焦点、路由或应用事件。宿主应先处理系统音频会话，再通知后端，并单独协调剧情推进。输出暂停不等于 Engine 停止，也不生成系统终止后的恢复点。
diff --git a/docs/manual/audio-playback.md b/docs/manual/audio-playback.md
new file mode 100644
index 00000000..b2aaf3f2
--- /dev/null
+++ b/docs/manual/audio-playback.md
@@ -0,0 +1,42 @@
+# 音频重复与轮播
+
+音轨选择使用项目设置中的稳定音轨 ID，`asset` 使用音频资源 ID。以下示例中的资源 ID 需要替换为项目实际值。
+
+## 重复同一首音乐
+
+```json
+{
+  "type": "audio.play",
+  "parameters": {
+    "trackId": "bgm",
+    "asset": "music-resource-id",
+    "placement": "replaceAll",
+    "loopCount": 0,
+    "completion": "discard"
+  }
+}
+```
+
+`loopCount` 为总播放次数：1 播放一次、3 连续播放三次、0 无限重复。默认值为 1。重复通过 Runtime 收到结束事件后重新启动，不保证无缝衔接。无限重复会占用当前逻辑声部，直到被停止、替换或 next 移除。
+
+## 多首曲目轮播
+
+在允许排队的单声部音轨上，依次添加两个 `audio.enqueue` 条目，每个条目分别设置不同的 `asset`，并都设置：
+
+```json
+{
+  "trackId": "bgm",
+  "asset": "music-a-resource-id",
+  "loopCount": 1,
+  "completion": "requeueTail"
+}
+```
+
+结果按 A、B、A、B 轮播。只有一个条目时会反复播放这一项。`completion` 默认为 `discard`，表示播放次数耗尽后丢弃；`requeueTail` 每次回到队尾时重置该项的播放次数进度。排队仍受音轨容量和溢出策略限制，失败项不会重新入队。
+
+## 停止、等待与恢复
+
+- `audio.stop` 停止当前项，`clearQueue` 为字符串 `"true"` 时同时清空待播项；不会因 completion 再次启动。`audio.next` 丢弃当前项并切换下一项。`audio.clear` 只清空待播队列。
+- `autoBlocking` 为字符串 `"true"` 时，自动推进等待完整逻辑播放结束；无限循环或轮播要靠停止/跳过终止等待。通常让 BGM 保持默认非自动阻塞。
+- 暂停保留播放和队列；读档从当前轮开头恢复，保留已完成的有限循环轮数，不恢复音频游标或淡化时钟。
+- 淡出期间调整音量或静音仍然有效。媒体文件直接复用已有资源租约；最后一个声音、视频或 Gallery 消费者释放后才删除临时文件。
diff --git a/docs/manual/content-packaging.md b/docs/manual/content-packaging.md
new file mode 100644
index 00000000..4561583e
--- /dev/null
+++ b/docs/manual/content-packaging.md
@@ -0,0 +1,46 @@
+# 游戏内容分包与资源补丁
+
+项目保持一张 Graph。章节可在入口按 save 变量分支，首页按钮传不同初始值；见[自定义 Sample](customize-avalonia-sample.md#单图章节启动参数)。
+
+## 剧情包
+
+选中 Group，在节点检查器填写「剧情包名称」，移开焦点提交。留空属于本体，相同名称聚合为一个剧情包；名称区分大小写，但不允许仅大小写不同的两组名称。候选列表提供已有名称。不需要另建剧情补丁面板。
+
+正常 galpak 导出会先保存当前项目，再从受保护的作者快照生成本体及全部剧情包。基础 PAK 放入 galpak，剧情 PAK 放在旁边 `StoryPatches/<buildId>/`。目录导出将它们放在输出目录内相同位置。分发时可以不带某个剧情包的所有分片，运行会沿其正常出口跳过；只缺一个分片、损坏或错版会报错。旧构建的剧情包不能配到新构建。
+
+新 galpak 使用 v3 布局，所有归档条目位于 `pak/` 下。使用普通解压工具解压到播放器目录后得到 EXE 同级的 `pak/`，玩家版双击 EXE 自动加载。配置/人物/Gallery/清单封装为 `game.pak`，内置文本封装为 `localization.pak`，每种语言合并成一个逻辑条目。玩家目录无需分发这些散装 JSON。`pak/I18n/<culture>/**/*.json` 只用于民间翻译等外置重载，缺省为空，详见[国际化](../spec/i18n.md#外部文本覆盖)。
+
+剧情与资源覆盖包分别放入 `pak/StoryPatches/<buildId>/`、`pak/ResourcePatches/`；即使没有任何补丁，也会保留这两个目录和 I18n 空目录。整合打包会将 galpak 旁匹配 buildId 的剧情目录与资源覆盖目录一并复制进去。目录导出与 `galpak install --output` 的参数均表示内容根，应指定 `app/pak`，不会生成双层 `pak/pak`。旧 v1/v2 galpak 仍可用安装器读取。
+
+本体先对全部普通 Group 和明确的基础根收集依赖。每个剧情包只扣除本体已有资源：A/B 都使用而本体没使用的资源，两包各带一份。条件分支里的静态资源全部计入，图集带齐其声明图片；不会因某次试玩没有走到分支而漏包。
+
+项目设置的 `galnet.packaging` 提供 maxPakBytes（默认 128 MiB）、includeResources 和 declaredCompleteResources。阈值按未压缩编译资源字节计算，单个超大资源独占一片，不拆资源。includeResources 用于 UI、自定义代码等静态剧情外的根；未知/动态引用还需在 declaredCompleteResources 中确认已补全依赖（资源 ID 或 Group 节点 ID）。声明完整不会自动添加资源。
+
+布局报告为 galpak 旁的 `<项目>.layout.json`，目录导出内置于 game.pak 的 packaging-layout.json，可查看每个资源的归属、直接依赖及未打包项。已有 Gallery 和默认视觉程序绑定属于基础根。文本和人物完整保留在本体文档包，不单独做剧情语言补丁。封装复用压缩 JSON，不引入 BSON；封装不是加密。
+
+## 资源补丁矩阵
+
+从面板菜单打开「资源补丁」。左列列出所有 Group（含剧情包）的资源引用，勾选「显示间接资源」可看到图集图片等依赖。点击原资源旁的定位图标进入编辑器文件管理器，悬停查看使用位置。没有静态引用的原资源可通过「补充原资源」加入，它也成为基础打包的显式根。
+
+1. 点击工具栏的新增图标创建补丁列。名称回车或移开焦点后自动保存，优先级用数字输入调整；列头图标分别用于导出和删除。
+2. 在格子里用现有资源选择器选择替换资源，空格子不覆盖。替换资源须有独立 ID 且类型相同；图集还须保留原维度名和原变体键，可以增加变体。
+3. 点击该列的导出图标独立生成 PAK，不需要先导出 galpak。导出只读取已保存的补丁定义和资源快照，不保存其他项目内容，也不提交其他页面未完成的输入。普通 galpak 导出不会自动生成资源覆盖包。
+4. 将 PAK 放在安装目录或其父目录的 `ResourcePatches/` 下，重新启动/新建安装会话采用它。
+
+列、映射和补充原资源的有效修改会立即写入 settings.json 的 `galnet.resourceOverrides`，无需应用或另行保存。撤销/重做也同步写盘，只发布该配置节，不顺带保存其他剧情或设置改动；失败会保留原版本并显示错误。定义继续支持恢复和重开。改名/移动资源保持 ID，因此映射仍有效；复制产生新 ID，不自动替换旧映射。删除原资源或目标会显示缺失，导出不能静默忽略缺失目标。
+
+优先级数值越大越优先；相同时按完整 PAK 的 SHA-256 字典序，较大者优先，同文件重复放置只算一次。没有语言条件或人工冲突选择页。每次引用只映射一次，A→B/B→C 不会把 A 直接变成 C。
+
+覆盖包携带 B 的完整依赖，明确读取该包内 B。携带资源不会隐式替换本体同 ID 资源；递归依赖同 ID 却内容不同会拒绝，应给修改后的依赖分配新 ID，必要时另建显式映射。通过「项目设置」中的资源补丁 section 可补充当前列的 includeResources / declaredCompleteResources，用于自定义资源的动态依赖。
+
+未安装的剧情包不会因资源覆盖包存在而被当作已安装。Graph/Group 不能通过资源矩阵覆盖。当前不提供运行中热装卸和 Gallery 补丁。
+
+## 存档与格式
+
+存档 v5 校验基础构建和准备时已安装的全部剧情包。删除其中任意剧情包都会阻止恢复，即使当时尚未播放到该包。文档封装格式参与 buildId，新旧布局不会误用同一构建存档。旧 galpak v1/v2 与 content v2 安装目录保持读取兼容，旧 GPAK v2 需重新导出；不自动转换旧格式。
+
+资源覆盖不改变存档中的逻辑资源 ID。图集替换后，读档会保留差分选择意图，并按当前有效图集重新解析实际图片；移除覆盖后也会重新解析。普通未覆盖图集仍严格校验保存结果与内容是否一致。
+
+例如目标为 128 MiB 时，300 MiB 的单文件会完整独占一个约 300 MiB 载荷的分片，不截断、不切碎，也不与后续资源混装。分包阈值是布局目标，不是内存限制；当前归档写入和读取仍会保留整片缓冲。使用大资源时应结合实际导出与运行峰值调整阈值，单资源超过阈值时仍完整保留。
+
+当前归档使用 byte[]，单资源与单 PAK 受约 2 GiB 的缓冲容量限制，实际还受可用内存约束；更大的媒体需要流式归档能力，不能通过调高阈值获得支持。
diff --git a/docs/manual/cpu-benchmark.md b/docs/manual/cpu-benchmark.md
new file mode 100644
index 00000000..fecc5cbc
--- /dev/null
+++ b/docs/manual/cpu-benchmark.md
@@ -0,0 +1,105 @@
+# 测量 CPU 启动
+
+需要 Windows、.NET 10 SDK 和 PowerShell 7。脚本先以 Benchmark=true 构建，再启动独立进程；构建不计入 Startup.Total。默认 Release、1 次预热、5 次测量。输出包含 Chrome Trace JSON、stdout/stderr、逐阶段 CSV、中位数/P95 摘要和运行环境/源码元数据。
+
+```powershell
+pwsh -File scripts/performance/benchmark-startup.ps1 -Target Editor -Iterations 10
+pwsh -File scripts/performance/benchmark-startup.ps1 -Target Editor -Configuration Debug -Iterations 10
+pwsh -File scripts/performance/benchmark-startup.ps1 -Target Sample -GameDirectory GameTestCase/Output -Profile Temp/benchmark-profile -Iterations 10
+```
+
+Sample 的游戏内容需要预先构建，Profile 应是已完成语言选择的测试档案（可复制已有 profile 到临时目录），避免弹窗等待。每次 Sample 启动仍会执行正常启动逻辑，包括更新该档案的启动次数。脚本不会替你构建游戏内容或修改语言选择逻辑。不要将个人正式档案用于 benchmark。
+
+`-Warmup 0` 可以保留第一次运行，但不等于操作系统冷缓存测试。脚本不清理系统缓存。相同配置、内容、profile 初始状态和机器负载下比较结果；5 次测量的 P95 只是 nearest-rank 样本分位数，样本少时通常就是最大值。外部进程探测得到的窗口时间和 Startup.Total 定义不同，不能直接比较。
+
+`-OutputDirectory` 指定结果目录；默认 `out/benchmarks/<target>-<timestamp>`。`-TimeoutSeconds` 默认 60。`-SkipBuild` 仅用于已经使用相同配置和 Benchmark=true 构建的输出，普通程序不会导出 trace。脚本串行运行，仅对自己创建的超时进程执行 Kill，不会结束已有 Editor 或游戏。超时、非零退出、缺失 Ready、事件溢出均中止并保留已生成数据。构建耗时仅代表本次实际构建（可能增量），不等同于 clean build 基线。
+
+Sample 的基准脚本构建时显式开启 `EnableLaunchArguments=true`，用于传入隔离的内容目录和 profile，不需要开启游戏调试。手动构建/发布用于 `-SkipBuild` 或采样分析的 Sample 时，也须传入 `-p:EnableLaunchArguments=true`；默认玩家构建只加载应用同级 `pak/`。
+
+在 Perfetto 或 Chrome Trace 查看器中手工打开任一 run JSON；CSV 可直接对比不同结果目录。元数据中的源码状态可能包含未提交文件，测量期间避免同时修改代码、编译或运行其他高负载任务。
+
+## 添加埋点
+
+让需要埋点的项目在 Benchmark=true 时引用 GalNet.Diagnostics，在方法内部显式添加编译保护：
+
+```csharp
+public async Task LoadAsync()
+{
+#if BENCHMARK
+    using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Game.Load", "Loading");
+#endif
+    await LoadAssetsAsync();
+#if BENCHMARK
+    GalNet.Diagnostics.CpuProfiler.Shared.Mark("Game.AssetsLoaded", "Loading");
+#endif
+}
+```
+
+`using` 在异常返回时也会结束区间。普通构建会移除整个埋点语句，包括参数求值、计时对象和 Dispose。可以在一段代码外加局部块限定区间，也可以跨 await；名称应稳定，避免逐帧字符串拼接。该系统适合阶段诊断，测量本身有锁和分配成本，不用于纳秒级微基准。
+
+启动之外的自定义捕获可创建 `new CpuProfiler(capacity)`，在完成所有区间后调用 Stop 和 WriteTrace(Stream)。不要使用已被 StartupBenchmark 停止的 Shared 实例继续采集。
+
+## 验证
+
+```powershell
+dotnet test test/GalNet.Diagnostics.Tests -p:Benchmark=true -p:UseSharedCompilation=false -m:1
+dotnet test test/GalNet.Diagnostics.Tests -p:Benchmark=false -p:UseSharedCompilation=false -m:1
+```
+
+运行普通宿主构建时不传 Benchmark，或显式 `-p:Benchmark=false`。Benchmark 输出使用每项目 bin/benchmark/<Configuration>，中间产物和锁文件使用 obj/benchmark，避免与普通构建的条件依赖图互相覆盖。切换模式后的首次构建必须允许 restore；-SkipBuild 只复用同模式现有产物。Core/Contracts 不引用诊断程序集。
+
+仓库在 CI=true 时启用 locked restore；全新 CI 工作区需要先准备 Benchmark 隔离锁文件，例如显式执行一次 `dotnet restore <host.csproj> -p:Benchmark=true -p:RestoreLockedMode=false`，再复用该还原目录。脚本不修改仓库的 CI 锁定策略。
+
+## 交错比较两个固定版本
+
+先分别构建并保存完整可运行目录，再使用固定 exe 路径做对照：
+
+```powershell
+pwsh -File scripts/performance/compare-startup.ps1 -Baseline Temp/startup-experiments/A/GalNet.Editor.exe -Candidate Temp/startup-experiments/B/GalNet.Editor.exe -Pairs 10 -OutputDirectory out/benchmarks/my-comparison
+```
+
+比较脚本默认针对 Editor，也支持 `-Target Sample -GameDirectory <built-content> -Profile <test-profile>`。两版各预热一次，再按 AB、BA 交替运行。每对只启动一个版本，保持同一个 Startup.Ready 完成点；输出 comparison.csv 和 summary.csv。每次元数据记录实际 exe 路径与对应宿主 DLL SHA256，避免工作树变化后误认测量版本。单独复用固定版本也可给 benchmark-startup.ps1 传入 `-SkipBuild -Executable <path>`。
+
+Editor 额外记录 Logging、ConfigureAvalonia、RunAvalonia、Window.Opened/Loaded 和 Startup.Loaded，便于区分配置、平台初始化和首屏布局间隔。不能把启动后的整个事件循环当作一个配置阶段。
+
+## 运行时调用栈与 JIT
+
+先构建 Benchmark=true 的宿主。工具可安装在仓库临时目录，不修改全局工具；以下版本是本轮验证版本：
+
+```powershell
+dotnet tool install dotnet-trace --tool-path Temp/dotnet-tools --version 10.0.750501
+pwsh -File scripts/performance/profile-startup.ps1 -Executable src/Editor/GalNet.Editor/bin/benchmark/Release/net10.0/GalNet.Editor.exe -TraceTool Temp/dotnet-tools/dotnet-trace.exe
+dotnet run scripts/performance/analyze-startup-trace.cs -- <capture-directory>/startup.nettrace
+```
+
+采集脚本在自己启动的进程上启用 GalNet-CPU 镜像、CLR JIT/加载事件和托管栈采样，正常就绪后自动关闭。保存 nettrace、CPU JSON、工具日志、版本及宿主 SHA256；超时仅停止本次采集进程树。默认输出在 out/benchmarks/profile-<timestamp>。不支持普通无 Benchmark 埋点的宿主。
+
+Sample 同样可采集，用 PowerShell 数组传入游戏和测试档案参数：
+
+```powershell
+& scripts/performance/profile-startup.ps1 -Executable <sample.exe> -TraceTool Temp/dotnet-tools/dotnet-trace.exe -ApplicationArguments @('<built-game>', '--profile', '<initialized-test-profile>')
+```
+
+分析器是需要 .NET 10 SDK 的 file-based app，固定使用 TraceEvent 3.1.21 与 scripts/performance/packages.lock.json；显式关闭工具自身的 AOT，并允许其诊断报告反射序列化。仅解析本地符号，不联网下载原生符号。生成 `<trace>.analysis.json`，提供阶段墙钟时间、主线程 JIT 区间并集、样本数、托管叶帧及包含帧、较慢 JIT 方法和丢事件检查。Sample 缺少 RunAvalonia 标记时使用 Ready 对齐，不虚构框架前置间隔。
+
+这些数字是诊断信息：JIT 区间并集不是精确 CPU 占用；采样可能把 JIT/原生工作归于最近的托管帧，Windows 原生调用内部仍需其他工具。嵌套阶段、包含栈样本不能求和。正式性能对比必须关闭 EventPipe 镜像与采样，并使用固定版本交错脚本。
+
+## Windows 原生启动栈
+
+使用管理员 PowerShell、系统 WPR 与前述 Benchmark 宿主。无需打开 WPA，脚本可离线分析；需要交互查看时用 WPA 打开 ETL。
+
+```powershell
+dotnet publish src/Editor/GalNet.Editor/GalNet.Editor.csproj -c Release -r win-x64 -p:Benchmark=true -p:PublishProfile=WindowsReadyToRun -o Temp/EditorBenchmarkReadyToRun
+pwsh -File scripts/performance/profile-startup-native.ps1 -Executable Temp/EditorBenchmarkReadyToRun/GalNet.Editor.exe -OutputDirectory out/benchmarks/native-editor
+$capture = 'out/benchmarks/native-editor'
+$targetProcessId = (Get-Content "$capture/metadata.json" -Raw | ConvertFrom-Json).ProcessId
+dotnet run scripts/performance/analyze-startup-native.cs -- "$capture/startup.etl" $targetProcessId --symbols
+```
+
+示例 exe 必须发布时启用 Benchmark=true。Sample 同样使用 `-ApplicationArguments @('<absolute-built-game>', '--profile', '<absolute-test-profile>')`。每次使用新的输出目录。
+
+脚本仅在 WPR 明确报告空闲时启动；已有录制或无法识别的本地化状态会直接拒绝，不停止其他录制。它采集短时系统级 CPU/模块事件和 GalNet 阶段，子进程就绪后正常关闭，再停止自己启动的录制。超时只终止本次子进程树；WPR 停止合并可能比程序启动长，不计入 benchmark。
+
+分析器按 metadata 的 PID 筛选主线程栈，输出 `.analysis.json` 中逐阶段采样计数、叶帧/包含帧与原始栈，拒绝丢事件 trace。默认不访问符号服务器；显式 `--symbols` 时从微软服务器解析 D3D11、DXGI、ImageHlp、WinTrust 等系统模块，缓存到当前目录的 Temp/native-symbols，详情在 `.symbols.log`。第三方驱动未必有公开函数符号，仍可看到模块与系统调用链。
+
+CPU 采样数量不等于精确毫秒数，也不能证明线程等待或 GPU 首帧时间。若全量 GeneralProfile 有丢事件，优先缩小 profile；当前 startup-native.wprp 不启用磁盘/文件/上下文切换等高流量事件。正式 A/B 比较不同时运行 WPR 或调用栈分析。
diff --git a/docs/manual/cross-platform-backends.md b/docs/manual/cross-platform-backends.md
new file mode 100644
index 00000000..2822dacd
--- /dev/null
+++ b/docs/manual/cross-platform-backends.md
@@ -0,0 +1,73 @@
+# 跨平台后端接入
+
+本页覆盖引擎后端，不创建 Avalonia Android/iOS App 模板。Core/Runtime 的执行和存档逻辑、PAK 格式、PCM 混音/DSP 继续共享；平台宿主选择资源入口、媒体实现和原生库部署。普通目录中的存档/变量/进度继续使用现有 .NET 文件实现，由宿主传入沙盒可写目录，不再包装一套 File API。
+
+## 从包内流读取 PAK
+
+```csharp
+var provider = new PakStreamProvider(
+    new Dictionary<string, Func<Stream>>
+    {
+        ["assets"] = () => OpenPackagedResource("Assets/assets.pak")
+    }, resourceTypes);
+using var assets = new AssetManager([provider]);
+await using var files = new AssetFileMaterializer(assets, applicationCacheDirectory);
+```
+
+`OpenPackagedResource` 是宿主提供的普通委托，可调用 Avalonia AssetLoader、Android AssetManager 或其他资源 API。每次返回独立、位于 PAK 起点的新可读流；provider 负责关闭流，不要求流可寻址，也不枚举包内目录。此入口沿用当前 Archive 的全量内存加载，不是大 PAK 的随机访问或流式解压方案。媒体实体化始终来自 AssetManager acquire 的字节，并保留文件租约。
+
+Graph/settings/I18n 的默认 `InstalledGameContentProvider` 仍读取展开后的安装目录。可将已验证游戏内容安装到应用私有目录再使用该实现；直接从应用包读取这些内容需实现现有 `IGameContentProvider`。新增 PAK 流入口不表示整个安装内容加载器已变成流接口。
+
+## 构建原生音频
+
+桌面 CMake 构建示例（在所需架构的编译器环境执行）：
+
+```sh
+cmake -S src/Infrastructure/GalNet.Media.Miniaudio/native -B out/native -DCMAKE_BUILD_TYPE=Release
+cmake --build out/native --config Release
+cmake --install out/native --config Release --prefix out/native/install
+```
+
+产物为 Windows 的 `galnet_miniaudio.dll`、Linux 的 `libgalnet_miniaudio.so`、macOS 的 `libgalnet_miniaudio.dylib`。Windows 默认托管构建也可自动调用 MSVC，按目标 RID 选择 win-x64/win-arm64，原生输出按 RID 隔离。脚本从已发现的 VS 实例中选择目标架构的编译器、头文件和静态运行库齐全的最高版本工具集，并用 `-vcvars_ver` 显式初始化；不要求默认最新工具集也安装该架构。自备动态库时传入绝对路径：
+
+```sh
+dotnet build path/to/Host.csproj -p:GalNetMiniaudioNativePath=/absolute/path/libgalnet_miniaudio.so
+```
+
+自备路径只关闭默认自动原生编译，并把该动态库复制到普通构建/发布输出；库的 CPU 架构和系统 ABI 必须与目标一致。Miniaudio 原生 ABI 为 2，托管和原生部分应同时更新。构建禁用 null 音频设备，无法打开真实设备时按初始化失败报告。
+
+Android 使用 NDK CMake 工具链，例如：
+
+```sh
+cmake -S src/Infrastructure/GalNet.Media.Miniaudio/native -B out/native-android \
+  -DCMAKE_TOOLCHAIN_FILE="$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake" \
+  -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-23 -DCMAKE_BUILD_TYPE=Release
+cmake --build out/native-android
+```
+
+平台宿主将生成的 `.so` 声明为对应 ABI 的 `AndroidNativeLibrary`；普通 Content 复制不替代 APK 内原生库打包。系统音频焦点和路由事件仍由宿主接入。
+
+iOS 在有 Xcode 的 macOS 上构建静态库，设备与模拟器分别构建：
+
+```sh
+cmake -S src/Infrastructure/GalNet.Media.Miniaudio/native -B out/native-ios \
+  -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64 \
+  -DCMAKE_OSX_DEPLOYMENT_TARGET=15.0 -DGALNET_MINIAUDIO_STATIC=ON -DCMAKE_BUILD_TYPE=Release
+cmake --build out/native-ios --config Release
+```
+
+宿主用 `NativeReference` 链接生成的 `.a`，选择 `Kind=Static`、`ForceLoad=true` 并带上 CoreFoundation/CoreAudio/AudioToolbox frameworks；构建托管适配器时传入全局属性 `GalNetMiniaudioStaticLink=true`，使导入绑定 `__Internal`。动态和静态托管变体应使用独立输出目录。宿主负责 AVAudioSession 策略，先激活系统音频会话再恢复设备。这些移动端命令是接入路径，当前 Windows 验证环境未执行其编译、签名和实机播放。
+
+## 系统中断与视频替换
+
+`PcmAudioPlaybackHost` 可通过 `SupportsOutputSuspension` 检查能力，在控制线程调用 `SuspendOutput` / `ResumeOutput`。Miniaudio 暂停会关闭设备并等待回调结束，恢复重新打开当前默认设备；保留源、租约、剧情 Pause 和 DSP，失败可重试。后台读取只继续到有界 PCM 缓冲填满。宿主负责将系统中断/路由事件映射到这些调用，并另外处理剧情暂停与恢复点；后端不会调用终态 `Engine.StopAsync`。
+
+剧情视频可通过 `AvaloniaGamePresentationOptions.CreateVideoPresenter` 提供任意 `IVideoPresenter`，返回实例由呈现会话拥有并优先异步释放。该 presenter 需要将画面接入宿主场景组合，不能仅创建一个脱离图层的播放器。默认仍为 LibVLC CPU 像素输出，不宣称已经支持移动端硬件解码与零拷贝。需要继续用 LibVLC 时，可用 `LibVlcRuntime(() => CreatePlatformLibVlc())` 完成平台初始化并创建实例；运行时拥有返回值，工厂失败保留 InitializationError。Gallery 当前仍使用默认 LibVLC 服务和控件，不会随剧情视频工厂一起替换。
+
+## AOT 与验证范围
+
+静态音频回调和源生成 P/Invoke 已消除该原生边界的动态委托 thunk；Core/Runtime、内置契约、Assets 和文件持久化的玩家 JSON 路径也已接入源生成元数据。状态数组、自定义资源、配置和字段 schema 均提供显式注册入口，普通 JIT 保留反射兼容路径。现有 Headless Sample 用标准 PublishAot 选项完成 Windows x64 原生发布并运行自检，确认动态代码/反射 JSON 均关闭；最终 ILLink/ILC 警告作为错误处理。操作和验收范围见 [NativeAOT 发布与扩展契约](native-aot.md)。
+
+桌面自检覆盖引擎和文件后端，不代表 Avalonia/Skia、LibVLC、原生设备或 Editor/CLI 作者编译器全部支持 AOT。移动端最终发布闭包、原生打包和实机生命周期仍需对应环境验收。不要用全局关闭裁剪或吞掉 IL 警告作为支持证据。
+
+本轮本地证据：资源测试 76 项、音频普通测试 26 项、真实 Windows x64 设备测试 2 项、视频工厂/失败清理测试 5 项及架构测试 52 项通过；CMake 动态库在 Windows x64 构建成功。Core/Runtime 的 AOT/裁剪分析构建通过但仍报告 IL2026/IL3050 等警告。补装 ARM64 MSVC 14.44 后，Windows ARM64 原生库交叉编译通过，确认 PE Machine 为 `0xAA64` 且 8 个原生 ABI 导出齐全；`GalNet.Media.Miniaudio` 的 Release / `-r win-arm64` 托管及原生组合构建也通过，0 错误。并验证 x64 仍选用完整的 MSVC 14.51，PE Machine 为 `0x8664`。Windows ARM64 尚未做实机运行验收。`.github/workflows/backend-portability.yml` 增加 Windows/Linux/macOS 的资源、原生解码和 CMake 验证任务，远端任务尚未在本地执行。Android/iOS 原生打包、系统中断、移动 GPU/Shader 和移动宿主 AOT 发布验收仍待对应环境完成。
diff --git a/docs/manual/customize-avalonia-sample.md b/docs/manual/customize-avalonia-sample.md
index 124aa2bb..3ca3dfbd 100644
--- a/docs/manual/customize-avalonia-sample.md
+++ b/docs/manual/customize-avalonia-sample.md
@@ -2,19 +2,126 @@
 
 `GalNet.Sample.Avalonia` 是项目级组合根示例：保留启动参数、项目选择、本地化和调试策略；通用会话、页面与展示组合应优先复用 `Avalonia.GameHost`、`Avalonia.GameView` 和 Themes，而不是复制其生命周期代码。
 
+## 调试构建与玩家发行
+
+Sample 通过 MSBuild 属性 `EnableGameDebugging` 控制游戏调试能力，启用时定义 `GALNET_GAME_DEBUG`。Debug 配置默认开启，Release 默认关闭；也可以显式构建带调试能力的优化版本：
+
+```powershell
+dotnet build src/Samples/GalNet.Sample.Avalonia -c Release -p:EnableGameDebugging=true
+```
+
+关闭时不编译调试服务、存档辅助工具、日志窗口和菜单，不引用 `GalNet.Debugging`，也不接入 Avalonia Developer Tools。独立的 `EnableLaunchArguments` 定义 `GALNET_LAUNCH_ARGS`，默认跟随 `EnableGameDebugging`：玩家版不编译内容路径、`--profile` 与调试参数解析，传入参数明确报错；开发版允许覆盖内容路径/profile。也可以在关闭游戏调试时显式开启普通参数；开启游戏调试则必须开启参数能力。
+
+所有构建无内容参数时默认加载应用同级 `pak/`，不依赖当前工作目录。发行依赖位于 `lib/`，程序明确区分程序集根与应用根。缺失或损坏内容通过启动窗口报告。默认 profile 为用户 `LocalApplicationData/GalNet/<SHA-256>/`：摘要输入是 `project:` 加 game.pak 内的 projectId（旧安装读取 content.json），与安装路径和 buildId 无关；开发目录缺少内容身份时使用 `directory:` 加目录绝对路径。日志位于 profile 的 `logs/`。此策略由 Sample 显式传入共享会话，旧 profile 不自动迁移或删除。
+
+`ConfigureServices` 的 `enableDebug` 只允许在已经编入调试能力的构建中抑制服务注册，不能给玩家构建重新启用调试。Release 关闭模式使用独立的 `packages.lock.NoGameDebugging.json`；切换开关后必须重新 restore，不能复用另一种依赖图的 `--no-restore` 输出。WindowsReadyToRun 玩家版使用该 profile 的独立锁文件，开发版使用 `packages.lock.WindowsReadyToRun.Debugging.json`。
+
+仓库发行脚本默认 `-SampleFlavor Player`，显式关闭游戏调试、启动参数和 PDB；`-SampleFlavor Developer` 使用带调试和参数能力的 Release 构建并保留符号，ZIP 名追加 `-developer`。两者均不改变契约程序集的编译参数和严格字节身份，也不改变 PAK 覆盖顺序或补丁策略。
+
+默认宿主的扩展目标是让项目自己实现功能。手机、小游戏、商城等可以使用项目服务、XAML、primitive 与状态恢复组合，不需要给框架增加同名业务系统。
+
+## 替换服务与页面行为
+
+`AddAvaloniaGameViewPages` 通过 `TryAddScoped` 提供默认服务，项目可以在调用前注册替代实现，或在调用后显式覆盖。标题、设置、游戏页面和 Shell 的默认 VM 可派生；标题命令的处理方法可以重载。注册派生 VM 的别名和实际 View：
+
+```csharp
+services.AddScoped<TitlePageViewModel, MyTitleViewModel>();
+services.AddScoped<MyNotebookViewModel>();
+services.AddAvaloniaGameViewPages(theme,
+    configureViews: views =>
+    {
+        views.Register<MyTitleViewModel, MyTitleView>();
+        views.Register<MyNotebookViewModel, MyNotebookView>();
+    });
+```
+
+`MyTitleViewModel` 派生 `TitlePageViewModel`，自己的按钮命令可调用 `IGameNavigationService.Navigate<MyNotebookViewModel>()`；返回使用现有导航历史。工厂按实际 VM 类型选择 View，因此派生类型也需要映射。更大幅度的定制可以替换 `IGameNavigationService`、`IPageViewFactory`，或由自己的窗口构造 Shell。页面的 XAML 和业务服务不需要字段生成器。
+
+## 自有设置模型与手写 XAML
+
+默认会话消费 `IAvaloniaPlayerSettings`，仅要求投影 `PlaybackOptions`、`AudioMix`、`TextSpeed`，接收玩家存储与音频声明，并提供变更通知和 `FlushAsync`。默认实现是 `AvaloniaPlayerSettingsService`，项目可以实现接口、持有自己的 DTO 和持久化规则，再注册到 DI。`IPlayerSettingsService` 应解析到同一实例；`IPlayerStartup` 可替换首次启动策略。窗口绑定和显示恢复可按需要实现。
+
+自动表单使用 `Categories` 和 `Editors`；手写设置页可以直接绑定自己的模型/命令，分类可为空。复杂偏好可以拆成玩家变量，或由项目显式序列化到自己的 profile 数据；不要把完整设置 DTO 放进 Engine。应用后发布 `SettingsChanged`，默认宿主将投影值更新到当前运行。预览、草稿取消、校验和格式迁移由项目设置服务定义。
+
+实际可运行示例见 `test/GalNet.IntegrationTests/ProjectSettingsView.axaml` 与 `SampleExtensibilityTests.cs`：独立偏好模型、手写 XAML、应用命令、保存重开，以及自定义标题按钮/页面。
+
+## 玩家与运行绑定
+
+`AvaloniaGameHostOptions.AttachPlayer` 在内容、首次启动及设置恢复完成后接入，收到借用的 `PlayerSession`、内容与 profile 路径；`AttachRun` 在每次运行 Prepare 完成后接入，收到当前 Engine。回调返回的 `IDisposable` 由宿主释放；若同时实现 `IAsyncDisposable`，宿主等待异步释放，项目可取消并排空自己的后台任务。
+
+运行替换/停止先终止 Engine，再释放运行绑定；玩家绑定在所有运行结束后、玩家存储和资源释放前结束。回调抛错会进入正常准备失败清理。需要多个项目服务时，在组合根中组合它们的绑定；不要在回调中留下未观察的任务或 `async void`。
+
+活动运行中的外部变量修改使用：
+
+```csharp
+await engine.SetVariablesAsync(new Dictionary<string, object>
+{
+    ["save.phoneReply"] = "accept",
+    ["player.chapterUnlocked"] = true
+}, cancellationToken);
+```
+
+条件扣款、计数累加可用 `UpdateVariablesAsync(current => changes)`：在同一执行门内读取带作用域前缀的独立快照并计算修改批次，校验通过后提交；计算委托必须同步，抛错时不修改变量。
+
+名称必须显式带 `save.` 或 `player.`。入口先验证全部值，再通过 Engine 唯一执行门修改；排队请求遇到恢复/停止会失效。显式修改的存档变量会合入稳定快照，保留原游标和呈现状态；玩家变量仍由玩家服务 flush，默认宿主退出时等待落盘。读取使用 `engine.Runtime.GetVariables(scope)` 的独立快照。玩家/profile 服务可以在没有活动运行时保存玩家级数据；不要在活动运行中绕过该入口修改剧情要读取的变量。
+
+此入口不是任意业务事务、商城订单协议或小游戏原地续玩的实现。项目仍负责奖励幂等、交互窗口校验、自定义状态及恢复策略；后台操作应绑定其实际所属的玩家或运行生命周期。
+
+## 单图章节启动参数
+
+项目保留唯一 Graph，章节可以在图入口按变量分支。默认标题 VM 提供 `StartNewGameWithVariablesCommand`，参数为 `IReadOnlyDictionary<string, object>`；派生首页 VM 可暴露不同字典供章节按钮绑定，例如 `new Dictionary<string, object> { ["save.chapter"] = 2 }`，无需每个按钮单独实现启动流程或填写 Graph ID。标题命令沿用 Loading → Prepare → 游戏页 → Begin 的流程。
+
+自定义应用也可通过 `IParameterizedGameSessionService.PrepareNewGameAsync(initialSaveVariables, ct)` 准备，再调用继承的 `BeginPreparedGameAsync`；不需要页面切换时可直接调用带字典的 `StartNewGameAsync`。默认 AvaloniaGameSession 实现该可选接口，原有无参启动和其他宿主实现无需强制接收新参数。
+
+例如在已有派生首页 VM 中增加两个参数属性，Graph 声明 chapter 并在入口判断其值：
+
+```csharp
+public IReadOnlyDictionary<string, object> ChapterOne { get; } =
+    new Dictionary<string, object> { ["save.chapter"] = 1 };
+public IReadOnlyDictionary<string, object> ChapterTwo { get; } =
+    new Dictionary<string, object> { ["save.chapter"] = 2 };
+```
+
+首页 View 共用已有命令：
+
+```xml
+<Button Content="第一章" Command="{Binding StartNewGameWithVariablesCommand}"
+        CommandParameter="{Binding ChapterOne}" />
+<Button Content="第二章" Command="{Binding StartNewGameWithVariablesCommand}"
+        CommandParameter="{Binding ChapterTwo}" />
+```
+
+首页替换继续使用本文的 DI 与 VM→View 注册方式；章节不要求新增 Graph。内容分包和资源矩阵见[内容打包手册](content-packaging.md)。
+
+初始值只允许显式 `save.` 键及 bool、Int32 范围整数、有限 Single 范围数值和字符串。共享 GameSession 在替换运行前复制并验证参数，在新 Run 初始化默认值和 Prepare 完成后、执行入口前一次应用；参数不会先写进旧 Run。默认宿主每次新建运行从 Graph 的 save 声明初始化，player 已存值保留，缺省 player 值才补入。读档只恢复存档，不重新应用标题页的章节参数；需要持久记录解锁章节时，另用 player 变量。
+
 外部 Editor 调试的启动配置、运行变量面板、路线定位和可选宿主接入见[对接外部游戏调试](external-game-debugging.md)。
 
 只需用两个字符串调用项目逻辑时，可用内置 `custom.invoke`，在运行组合中注册 action，无需为每个 action 新建项目契约；见[通用 action 注册与模式语义](custom-actions.md)。
 
 ## 推荐改造顺序
 
-1. **建立项目契约。** 复制或引用 `GalNet.Sample.Contracts`，在 `ProjectSchemas.Modules` 中列出项目允许的 `IEntryModule`。构建后用 `scripts/build-project-contracts.ps1` 部署到内容项目的 `Contracts/`。CLI/Editor 与玩家必须消费同一契约集合。
+1. **建立项目契约。** 复制或引用 `GalNet.Sample.Contracts`，在 `ProjectSchemas.Modules` 中列出项目允许的 `IEntryModule`。构建后用 `scripts/contracts/build-project-contracts.ps1` 部署到内容项目的 `Contracts/`。CLI/Editor 与玩家必须消费同一契约集合。
 2. **配置运行组合。** 在 Sample 的 `SampleCustomization` 中配置 catalog、执行模块、资源/玩家存储、音频 host 和项目启动策略。把项目专属 primitive 注册在这里；不要修改 `App`、Session 或关闭链来接入一条业务能力。
 3. **定制外观。** 通过 `AddAvaloniaGameViewPages` 选择 `ClassicTheme`、`MinimalTheme` 或 `PaperTheme`，也可在 `configureViews` 覆盖单个页面。运行期主题切换不受支持。
 4. **扩展项目功能。** schema/DTO 与 composite 放在契约项目；执行模块放在 Avalonia 或项目执行程序集。参数 DTO 用 `GenerateFieldSchema`/字段特性生成 descriptor，平台控件仅在页面/设置工厂中处理。
 
 ## 页面与主题边界
 
+存档页可直接编辑已有有效存档的名称，Enter 或失焦保存，Escape 放弃。名称保存在原存档 JSON 的 `Description` 字段，最多 120 个字符；清空名称恢复默认槽位名称。重命名不更新存档时间、截图和剧情快照，覆盖保存会保留名称。自定义会话实现可选 `ISaveSlotNamingSession`，自定义存储实现 `ISaveSlotNamingService`；没有该能力的宿主仍可使用只读卡片。
+
+自定义存储可额外实现 `ISaveSlotInfoSource`，避免保存或刷新单个槽位时遍历全部存档。批量更新 `SaveSlots` 时应合并集合通知；单槽保存使用 Replace，以复用其他卡片及缩略图。默认存档缩略图为不超过 480×270 的场景图。
+
+截图弹窗支持可选 `CapturePreviewPngAsync` 小图回调，默认 GameShell 使用不超过 720×405 的预览，包含界面/仅场景分别缓存；`CapturePngAsync` 始终负责正式导出。自定义截图服务保留两者的区别，不能把预览缓存当成正式截图保存。有关控件和场景捕获的边界见 [共享页面规范](../spec/control.md#截图对话框契约)。
+
+音量与静音共用一行：在音量 SettingItem 上设置 `InlineToggle` 指向同分类的 BoolSetting，并仍将两项放在 `Items` 中，以保留应用、恢复与持久化队列。界面通过 `DisplayItems` 合并显示；修改外观无需改变原设置 ID。
+
+`SampleCustomization.PlayerPalette` 同时供页面与桌面窗口使用，修改配色时保持 `PlayerTheme` 使用同一调色板。窗口装饰使用独立 CaptionButton/TitleBar 资源；仅修改内容区域的 Button 样式不能覆盖原生关闭按钮。退出确认沿用此配色，在窗口内显示遮罩并暂时禁用背景内容。
+
+退出确认的布局在 `Views/MainWindow.axaml`：使用紧凑桌面确认框比例，18px 标题、14px 正文、靠右的内容宽度按钮，面板/按钮圆角分别为 6/4。文字与按钮尺寸只在此弹窗内定义；定制时可独立调整，取消默认焦点、Escape 取消和背景输入屏蔽由代码维护。`SampleWindowThemeTests` 支持通过 `GALNET_THEME_CAPTURE_DIR` 输出中英文及最小窗口尺寸的截图。
+
+主页静态标题显式指定 `GalNet.Brush.TextPrimary`，避免退出确认禁用背景时继承容器的半透明禁用文字色。定制主页时保留这个前景色绑定；验证弹窗截图应挂载真实主页，再检查背景标题与取消后的恢复。
+
 - `GamePage` 是稳定的游戏页面宿主；其模板必须保留 `PART_Scene`、`PART_Dialogue`、`PART_Nvl` 和 `PART_Choice` 四个 ContentPresenter。
 - 对话与 NVL 的内部部件分别需要 `PART_Typewriter`、`PART_Lines` 和 `PART_ScrollViewer`。不要在剧情播放中重建这些部件。
 - 主题页面复用共享 ViewModel 和命令；只替换布局/样式，不复制 presenter、媒体或游戏会话逻辑。
@@ -54,3 +161,14 @@ MyOptions 代表项目自己的 schema DTO 类型；真实业务提交仍由宿
 共享默认样式中的 FieldEditorActions 提供显式默认值/null/缺省/恢复草稿。缺省提交需要宿主保存 presence，普通 CLR DtoBinding 没有这种能力时返回 dto.presence，不能把删除字段等同于 CLR 赋 null；Sample 的设置应用/保存规则保持由原宿主管理。
 
 具体生命周期、冻结、错误及当前支持范围见[Schema 字段表单](../spec/control.md#schema-字段表单)。
+
+
+## 对白历史与重播
+
+默认宿主提供从当前路线新游戏开始的历史；存读档通过宿主会话 API 一并保存/恢复。GamePageViewModel.OpenHistoryCommand 和输入 open.history（默认 WheelUp）打开覆盖层，CloseHistoryCommand 返回。自定义 GamePage 模板可增加 PART_History ContentPresenter，并以 TemplateBinding History 承载共享面板；原有四个必需承载点仍保持兼容。
+
+历史 journal 在 GameHost，实际文本/音频执行观察在 Avalonia.GameHost。默认组合注册 host.dialogue.history 计数状态；实际保存时才附加完整历史前缀到 GameSnapshot.Attachments，不应把正文复制到每次稳定快照。直接使用 Engine 的项目若需要完整历史，应自行接入对应宿主保存/恢复，而非期待 Engine 解释附加数据。
+
+同源相邻 audio.play 和文本以 rawId#n 的稳定编译身份关联；手写不同源音频不会自动变为对白语音。重播借用后端及原 track 的混音，以独立临时 voice 播放，不重新执行剧情。有效推进包括补全文字都会停止；单纯滚动历史或调整音量不会停止。
+
+默认设置增加 enableReadTextColor 与 readTextColor 玩家偏好，初始关闭、颜色 #A8B8C8。ReadTextStyle 的可继承 Foreground/WasRead 只作用于 TypewriterTextBlock 普通色片段；自定义布局无需改写富文本内容。ColorView 的 Fluent 样式由设置编辑器在自身作用域加载。
diff --git a/docs/manual/default-visuals.md b/docs/manual/default-visuals.md
new file mode 100644
index 00000000..9a897d72
--- /dev/null
+++ b/docs/manual/default-visuals.md
@@ -0,0 +1,123 @@
+# 默认视觉资源与演出预设
+
+新建默认契约项目时，编辑器将 8 个 SkSL 模板复制到 `Assets/Effects/Default/`，为每个项目生成资源 GUID。预览、运行和导出读取项目资产；升级编辑器不覆盖已有 shader。
+
+`galnet.project.defaultVisualPrograms` 保存 bloom、blur、vignette、colorGrade、depthBlur、speedLines、reveal、maskReveal 用途绑定。编辑器插入预设或切换类型时填入实际 GUID；修改用途绑定不会追改已有 Entry。CLI / 外部作者需要显式填写资源引用。
+
+## 旧项目补入
+
+先重建、部署与当前引擎匹配的项目契约（声明 effect.apply 和 defaultVisualPrograms），再使用 CLI：
+
+```text
+project visuals install <project> --dry-run
+project visuals install <project>
+```
+
+只补缺失用途，保留已有绑定和作者修改。缺失绑定对应的默认资产路径被占用时，整次操作拒绝覆盖；可以手动将用途绑定到已有资源。发布复用作者文件事务与 settings 原哈希检查；dry-run 不改项目，重复安装没有变化。不提供自动升级/覆盖已有 shader 的入口。
+
+## 通用效果
+
+使用现有 `effect.apply` / `effect.stop`，不为每种 shader 新增 Primitive。program 是项目资源 GUID，instanceId 是效果实例身份。
+
+```json
+{
+  "type": "effect.apply",
+  "parameters": {
+    "instanceId": "scene-vignette",
+    "program": "<vignette shader GUID>",
+    "parameters": { "strength": 0.7, "radius": 0.3, "softness": 0.4 }
+  }
+}
+```
+
+不填 targetHandleId 表示场景后处理，填写则只作用于该图层；metadata 必须支持相应 stage。默认对话 UI 不在场景后处理范围内。
+
+| 资源 | 参数与行为 |
+|---|---|
+| Bloom | strength、radius、threshold、softKnee；初始 strength=0 |
+| Blur | radius、direction；二维模糊组合 [1,0] 与 [0,1] 两个有序实例；radius=0 为原图 |
+| Vignette | strength、radius、softness、center；center 为归一化坐标 |
+| ColorGrade | exposure（档）、saturation、contrast、temperature；中性初值 |
+| DepthBlur | focusZ、focusRange、falloff、maxRadius；读取每次绘制的 layerZ |
+| SpeedLines | time、speed、density、strength、flicker、mode（Radial/Directional）、angle（度）、center、color |
+| Reveal | progress、mode（Wipe/Radial/Noise/Blinds）、softness、angle、count、center |
+| MaskReveal | progress、softness、mask（项目图片 GUID）；图片亮度作为遮罩并缩放到画布 |
+
+景深对每个参与图层显式应用 DepthBlur；半径为 `clamp((abs(layerZ-focusZ)-focusRange)*falloff,0,maxRadius)`。新增图层需要显式参与，不生成图片内部真实深度。layerZ 是保留 uniform，不能声明为作者参数。
+
+直接使用 SpeedLines 时，创建透明颜色图层（#00000000），附加 shader，并通过 animation.animate 或 timeline.play 驱动效果实例的 time。它不读取墙钟；只应用 shader 不会自动运动。
+
+## 复合预设
+
+所有预设编译为一个 `timeline.play`。playbackHandleId 在播放期间必须唯一；`<playbackHandleId>/visual/` 是本次演出的临时对象命名空间，不能用作目标图层身份。
+
+| Entry | 输入 |
+|---|---|
+| transition.reveal | oldHandleId、newHandleId、assetId、program、mode；Mask 另需 maskAsset |
+| transition.blur | oldHandleId、newHandleId、assetId、blurProgram、radius；双层各两遍模糊 |
+| preset.motion | handleId、motion；FadeIn/FadeOut/SlideIn/SlideOut/PopIn/Jump/Nod/ShakeHead/Push |
+| preset.shake | handleId、amplitude、cycles、angle、playbackMode；一个条目作用于一个图层 |
+| preset.speedLines | program、parameters（shader 参数对象）、speed、flicker、z、playbackMode |
+| preset.impact | 集中线参数加 handleId、amplitude、cycles、angle、flashOpacity；组合震动、缩放脉冲、闪白和集中线 |
+
+```json
+{
+  "type": "preset.impact",
+  "parameters": {
+    "playbackHandleId": "impact-01",
+    "program": "<speedLines shader GUID>",
+    "handleId": "hero",
+    "parameters": { "mode": "Radial", "density": 80, "color": "#FFFFFF" },
+    "durationFrames": 48,
+    "amplitude": 16,
+    "blocking": true
+  }
+}
+```
+
+帧率默认 60，最短 2 帧。人物 motion 的 transform 是作者指定的基准变换；Slide/PopIn/Push 据此生成绝对轨道，编译器不读取播放中的场景。Jump/Nod/ShakeHead、震动和冲击脉冲使用相对叠加并回到零。Nod 使用 rotationDegrees；ShakeHead 的水平位移幅度使用 distance。
+
+Push 的 anchorX/anchorY 为相对画布中心的逻辑坐标。锚点缩放与 angle/distance 移动分别控制；只推近时 distance=0。倍数为 s 时，X 终点为 `x + cos(angle)*distance + (x-anchorX)*(s-1)`。
+
+转场还接受 transform、z、displayMode。新图层需要排在旧图层前面；相同 Z 时后创建的新图层在前。既有 crossFade/slide/blinds/fadeBlack/fadeWhite/fadeColor 保留。
+
+替换 shader 必须满足编排要求：layer stage，time/progress/radius 等参数的种类、可动画性和数值范围。项目验证、单组编译、build/export 拒绝缺失或不匹配的资源。Mask 模式需选择 maskReveal 对应程序；切换 mode 不自动覆盖作者已选的 program。
+
+震屏和集中线的 `playbackMode` 默认为 `Timed`（指定时长），支持 `UntilStopped`（持续到停止）。定时模式的 `blocking` 决定剧情是否等待；持续模式固定为不阻塞且不可通过对白点击跳过，不受作者原来的 blocking/skippable 值影响。持续模式下 durationFrames/frameRate 是循环周期，震屏不逐轮衰减，集中线保持显示、不重复创建 Effect 或图层。人物动作、冲击和转场仍为单次播放。
+
+例如，先插入持续震屏，经过若干对白后用一个“停止动画”结束：
+
+```json
+{
+  "type": "preset.shake",
+  "parameters": {
+    "playbackHandleId": "earthquake",
+    "handleId": "background",
+    "playbackMode": "UntilStopped",
+    "durationFrames": 60,
+    "cycles": 4,
+    "amplitude": 16
+  }
+}
+```
+
+需要同时震动多个图层时，为每个图层添加一个 `preset.shake` 条目，分别选择 `handleId` 和唯一的 `playbackHandleId`。`preset.impact` 同样每个条目只选择一个图层。旧的 `targets` 数组不再作为输入；已有多目标配置需拆成多个条目。
+
+```json
+{
+  "type": "animation.stop",
+  "parameters": { "playbackHandleId": "earthquake", "mode": "CompleteImmediately" }
+}
+```
+
+集中线使用相同的停止方式。立即完成会等待本次演出收尾后再推进剧情：震屏偏移归零；集中线停止并移除自己的 Effect 和临时图层；其他独立效果保留。不需要追加 effect.stop。Timeline 的 `AfterIteration` 模式请求当前轮播完后再收尾，该停止 Entry 不等待整轮。无活动呈现的 Headless/CatchUp 循环直接完成逻辑收尾。
+
+正常完成和快进也执行末帧清理。scope 取消/被替换不视为正常完成，不保证末帧事件执行；非阻塞预设应在切场前明确完成，不能并发复用同一 playbackHandleId。立即停止清理完成后允许复用该标识。
+
+当前导出打包全部项目资产，时间线使用的 shader 和遮罩图片均在资源包中。静态引用查询仍报告候选与不完整性，零匹配不是删除安全证明。
+
+## 展示与范围
+
+GameTestCase 两条路线的 ending 组均展示调色、Bloom、暗角、Z 切焦、人物动作、多层震动、两种动态集中线、冲击、柔边擦除、模糊转场和图片遮罩溶解，附中英文说明。遮罩示例使用普通背景图片的亮度。
+
+真实相机/深度图景深、散景、镜头跟随、胶片/故障/水波 shader、翻页、天气配方和章节标题仍是候选，不属于本批交付。
diff --git a/docs/manual/editor-authoring-workspace.md b/docs/manual/editor-authoring-workspace.md
index 098fbcc4..4d7f5bc2 100644
--- a/docs/manual/editor-authoring-workspace.md
+++ b/docs/manual/editor-authoring-workspace.md
@@ -2,7 +2,7 @@
 
 ## 编写与参数
 
-Group 行内默认展示常用字段。单击选择条目后，Inspector 显示完整参数和执行条件；箭头独立控制行内展开。搜索框可以按正文、类型、条件或显示序号查找。锁定 Inspector 可持续查看指定条目；辅助面板不会清空它。
+Group 行内默认展示常用字段。单击选择条目后，Inspector 显示完整参数和执行条件；箭头独立控制行内展开；编辑器设置可指定新添加条目的参数是否默认展开。搜索框可以按正文、类型、条件或显示序号查找。锁定 Inspector 可持续查看指定条目；辅助面板不会清空它。
 
 人物输入按姓名或 ID 搜索后，可直接按 Enter 采用高亮候选，也可用方向键进入列表选择。输入法组合期间的 Enter 保留给输入法。
 
@@ -16,7 +16,13 @@ Graph 顶部可以搜索节点名称/ID、适配全图、定位选择和缩放
 
 ## 布局
 
-窗口菜单中手动选择剧情编写、动画编辑或游戏调试布局；工具打开不会替你切换预设。已有保存布局继续优先恢复。最大化面板可以再恢复到原布局。Timeline 左侧树与画布之间的分隔条可以拖动，底部可显示完整时长或定位播放头。
+角色表和变量表的新增入口位于列表右上角“＋”，应用、还原和删除使用图标按钮，悬停可查看说明。变量的玩家/存档子页分别记住选中项和未应用草稿；搜索过滤或关闭重开后可继续编辑。角色草稿同样随项目会话保留。两类面板的输入仍需点击应用，Save All 保存已应用的声明。
+
+资源 Inspector 上方编辑属性，下方为可折叠、可通过分隔条调整空间的预览；图片、音频和图片变体使用同一底部区域。资源 ID 与路径可选中复制，变体 JSON 修复区位于属性区域，预览不再夹在配置字段之间。
+
+Group 工具栏的添加和追加按钮会打开可搜索的条目类型列表，选择后按批量数量插入，按钮名称保持不变。Timeline 的添加事件按钮使用同样的选择方式；选择单个事件后在 Inspector 修改参数，点击应用提交或取消放弃草稿。前后关键帧按钮也会停在事件所在帧。
+
+窗口菜单中手动选择剧情编写、动画编辑或游戏调试布局；工具打开不会替你切换预设。已有保存布局继续优先恢复。最大化面板可以再恢复到原布局。Timeline 左侧树与画布之间的分隔条可以拖动；对象轨道与时间轴事件之间的水平分隔条可调整上下区域比例。底部保留显示完整时长，右侧显示当前帧和缩放滑条。
 
 ## 为项目 DTO 标记常用字段
 
@@ -33,3 +39,59 @@ public partial class MyOptions
 ```
 
 Common 只影响行内展示；AdvancedValue 仍在 Inspector 编辑。按现有项目契约流程重建 DLL，使 Editor 和游戏加载相同契约。手写 schema 可设置 `new EditorHints(IsCommon: true)`；自定义 DTO 编辑工厂读取 `DtoEditorContext.DisplayMode`，默认表单会自动筛选。嵌套对象继续使用自身编辑器，不自动铺开所有成员。完整契约见 [共享表单](../spec/control.md) 和 [Group 编辑](../spec/editor-groups.md)。
+
+## 选择数值编辑器
+
+Editor 的普通 `numeric` 字段默认显示上下调整框；需要明确指定时，可使用以下元数据：
+
+```csharp
+[Field(0, EditorId = ValueEditorIds.NumericUpDown, Step = .1)]
+public float Duration { get; set; }
+
+[Field(1, EditorId = ValueEditorIds.Slider, Minimum = 0, Maximum = 1, Step = .01)]
+public float Opacity { get; set; } = 1;
+
+[Field(2, EditorId = ValueEditorIds.NumericText)]
+public decimal ExactValue { get; set; }
+```
+
+Slider 在 Editor 中带精确输入框；步长只影响调整，输入 `.537` 仍可提交为 `0.537`，不会强制对齐到 `.01`。浮点输入支持 `.3` 和 `-.3`，Enter/失焦确认后规范显示。大整数和 decimal 始终保留无损文本路径；滑块需明确有限范围，不适用时回退并显示原因。宿主可通过 `registry.Replace(ValueEditorIds.Numeric, factory)` 或成员/类型注册覆盖选择，元数据不改变业务合法值。共享设置表单原有默认 numeric 文本路径保留。
+
+## 声明嵌套结构
+
+普通生成 DTO、数组/List 和字符串键字典会使用公共属性遍历与通用表单。需要保留 JsonElement wire 类型的固定对象，可以显式关联结构类型：
+
+```csharp
+[GenerateFieldSchema]
+public partial class PositionData
+{
+    [Field(0)] public float X { get; set; } = 0f;
+    [Field(1)] public float Y { get; set; } = 0f;
+}
+
+[GenerateFieldSchema]
+public partial class CustomOptions
+{
+    [Field(0, StructureType = typeof(PositionData))]
+    public JsonElement Position { get; set; }
+}
+```
+
+元数据关联不改写项目 JSON，也不将普通字符串当 JSON 解析。只有原契约确实支持历史编码时才声明 StructureAllowsJsonString；StructureIgnoresCase 和 StructureUsesFieldIds 同样属于显式兼容规则。专用 EditorId/成员/类型工厂仍可负责布局，复用公共字段描述与属性访问。
+
+手写 schema 可组合 ValueStructure。例如逐个 Map 值声明文本引用，而不是把整个字典标成字符串字段：
+
+```csharp
+var textValue = new FieldDescriptor("value", new(typeof(string)),
+    semantic: FieldValueSemantic.LocalizedText);
+var values = new ValueDescriptor(typeof(JsonElement))
+    .WithStructure(ValueStructure.Map(textValue));
+```
+
+读取/检查可使用 `using var document = new ValueDocument(field, json);`，然后调用 GetIterator、FindProperty 或 Validate。Patch 只返回候选值和诊断，宿主仍须通过原作者意图提交，复核来源并记录历史。共享 PropertyFieldBinding 为专用控件提供子字段访问；通过相同父 Context 和 registry 继承草稿、宿主能力和数字编辑路径。
+
+通用表单按 Header 分组并缩进，字典支持键/值操作，重复键拒绝提交。字段值草稿由项目会话保留；新增/改键等结构操作的未成功键名仅留在当前控件。八层/200 元素的 UI 回退与引用分析预算分别生效。
+
+应用特效与 SpeedLines/Impact 预设的参数分析复用 shader metadata，shader 表单与扫描共用 ShaderEffectFields；音频效果复用 ISEffectCatalog 中的字段，更新参数按前文挂载的实例解析。Editor 的 ProjectSceneTargets 通过 IEntryParameterMetadataSource 将现有资源查询快照接给 ProjectLocalizationQuery，随资源刷新重新分析，托管 shader 未保存的内容同样生效。独立调用 LocalizationReferenceIndex 可通过 EntryParameterMetadata 提供宿主目录与 shader 声明；未提供时仍能分析内置音效。
+
+Timeline 的轨道、关键帧和事件参数也进入同一遍历；运行 DTO schema 与 editorId/editorTangents 作者 metadata 分别提供结构，事件按项目 catalog/type 选择参数字段。事件中的 shader 资源会进入同一 metadata 快照。已知 shader 允许额外参数，切换后保留的 angle 等旧值属于合法数据，不需要为消除 warning 手工删除；只有声明字段仍按元数据校验。未知效果类型、资源声明不可用，以及其他尚未关联结构的 JSON 仍提示未覆盖，不能仅靠增加 UI 工厂来宣布引用检查完整。
diff --git a/docs/manual/external-game-debugging.md b/docs/manual/external-game-debugging.md
index 21607251..d603f1d1 100644
--- a/docs/manual/external-game-debugging.md
+++ b/docs/manual/external-game-debugging.md
@@ -1,10 +1,16 @@
 # 对接外部游戏调试
 
+Editor 的旧内嵌 Preview 已移除，游戏测试统一使用本页的外部进程调试链路。
+
 调试由游戏开发者显式启用。`GalNet.Runtime` 只提供 Engine 的受控调试端口；可选 `GalNet.Debugging` 提供 loopback TCP、会话和默认 Engine 适配。游戏、Engine 和玩家数据仍由宿主拥有。
 
 ## Editor 操作
 
-1. 在“项目设置”的调试启动配置中设置可执行文件、附加参数（每行一个）及可选工作目录，点击保存本地配置；也可以首次使用“测试 → 启动应用”时选文件。配置保存在项目 `.galnet/editor/debug-launch.json`。
+新建项目时，可以在契约目录上方选择游戏 App EXE。契约框为空时自动定位配套契约；创建项目只复制契约及其托管依赖，并自动保存所选 App 为调试可执行文件。手动填写的契约目录会保留。找不到或找到多份契约时需手动指定，不会静默改用默认契约。
+
+仓库中 Debug 构建 Sample 后，可直接选择 `src/Samples/GalNet.Sample.Avalonia/bin/Debug/net10.0/GalNet.Sample.Avalonia.exe`，无需先运行契约导出脚本。普通构建读取 EXE 同级 DLL，当前发行包读取同级 `lib/`。联调发行包使用 Developer 构建；选择 App 不会自动为玩家包启用调试。之后重建若改变契约字节，仍需同步项目 `Contracts/` 并重新打开项目。
+
+1. 在“项目设置”的启动配置分类中设置可执行文件、附加参数（每行一个）及可选工作目录；路径右侧的按钮可选择文件或目录，修改自动保存。也可以首次使用“测试 → 启动应用”时选文件。配置保存在项目 `.galnet/editor/debug-launch.json`。
 2. 启动前保存并正式校验/编译工程，产物位于 `Output/Debug`。Editor 先监听，再向 App 传入该目录、`--profile <项目/.galnet/debug-profile>` 和调试邀请参数。该 profile 与游戏原有玩家目录分离。
 3. App 连接后，若注册了开始回调，可点“开始游戏”；否则在 App 中自行开始。标题页连接和游戏运行绑定是两件事。
 4. 打开“游戏调试”面板，分别查看 Player/Save 当前实例变量。修改输入框后点击“应用”，刷新不会覆盖草稿。原值已改变时应用会拒绝；使用重置按钮取当前值后再编辑。变量提交不产生作者 Undo 或工程 dirty。
@@ -13,7 +19,7 @@
 
 “当前 Group 末尾”在出边前停止。与游戏根断开的 Group 可以显式选“以初始场景从此处测试”，缺少前置对象时仍会报告实际错误。
 
-调试面板顶部使用分组图标工具栏，悬停可查看操作名称，灰显表示当前不可用；窄 Dock 会按组换行。启动配置默认折叠。保存、构建、作者映射和启动阶段会显示在状态栏；构建与作者映射在后台执行，避免大项目校验占住 Editor UI。变量按“当前值／修改为”显示，勾选图标应用草稿，回转箭头取游戏当前值重置草稿；值冲突会显示文字提示。连接指示、运行状态和错误位于底部，较长错误可滚动并复制。
+调试面板顶部使用分组图标工具栏，悬停可查看操作名称，灰显表示当前不可用；窄 Dock 会按组换行。启动配置默认折叠。保存、构建、作者映射和启动阶段会显示在状态栏；构建与作者映射在后台执行，避免大项目校验占住 Editor UI。映射直接来自这次正式编译的结果，随构建内容一起返回；构建期间若作者内容改变，旧映射不会被认作当前作者版本。变量按“当前值／修改为”显示，勾选图标应用草稿，回转箭头取游戏当前值重置草稿；值冲突会显示文字提示。连接指示、运行状态和错误位于底部，较长错误可滚动并复制。
 
 关闭调试 Dock 保留连接和草稿；关闭项目会断开。停止只停止当前运行，App 可以再次开始。默认 Engine 适配在断线后取消旧请求、清除断点并解除暂停，App 继续由玩家控制。断开不会终止外部进程。
 
@@ -21,6 +27,8 @@
 
 ## 游戏接入
 
+Sample 必须以 `EnableGameDebugging=true` 构建才能接入（Debug 配置默认开启，Release 默认关闭），`EnableLaunchArguments` 默认随之开启。发布给玩家的 Sample 不包含调试协议、工具和启动参数；Release 联调可显式传入 `-p:EnableGameDebugging=true`，或使用发行脚本的 `-SampleFlavor Developer` 生成带符号的开发包。详见[调试构建与玩家发行](customize-avalonia-sample.md#调试构建与玩家发行)。
+
 引用 `GalNet.Debugging`，在项目组合根创建服务。开始回调可省略，开始/停止回调中所需的 UI 调度由宿主负责。
 
 ```csharp
@@ -43,7 +51,7 @@ using var binding = host.AttachRun(adapter);
 
 上例白名单仅为接口示例，应列出实际支持的指令。Scene 表示模块支持 CatchUp 场景重建；Ignore 表示调试重放时跳过副作用；未声明的类型默认拒绝定位。不能把任意插件一律标为 Scene。参数和资源校验仍执行，不因忽略流程条件而放宽。
 
-需要呈现恢复的 view 必须提供 `ICatchUpPresentation` 或 `GameDebugOptions.SynchronizePresentation`。回调不得重新等待 Engine 推进门。默认 Avalonia 宿主提供恢复协调，只需通过 `AvaloniaGameHostOptions.AttachDebugRun` 的可选中立回调绑定；其程序集不引用调试通信组件。Sample 的 `SampleExternalDebug` 展示完整接入，包括对白、场景指令、变量/Gallery/截图副作用策略。
+需要呈现恢复的 view 必须提供 `ICatchUpPresentation` 或 `GameDebugOptions.SynchronizePresentation`。回调不得重新等待 Engine 推进门。默认 Avalonia 宿主提供恢复协调，只需通过 `AvaloniaGameHostOptions.AttachRun` 的可选中立回调绑定；其程序集不引用调试通信组件。Sample 的 `SampleExternalDebug` 展示完整接入，包括对白、场景指令、变量/Gallery/截图副作用策略。
 
 自定义运行可以直接实现 `IDebugGameRun`，按 `Info.Capabilities` 报告可用方法；可覆写 `OnDisconnectedAsync` 定义断线行为。它不要求实现 IGameRun 或持有 Editor 文档。
 
@@ -59,9 +67,9 @@ Player 修改先同步当前 Runtime 与玩家变量服务，默认 Avalonia 宿
 
 CLI/Editor/App 应使用同一份项目契约构建产物，包括默认只含内置条目的工程；选择 Sample 时需先部署 Sample 对应的 Contracts。运行内容来自构建目录，不提供资源热更新；作者内容编辑后旧源码映射失效，需要重新启动测试。
 
-在仓库根目录运行 `./scripts/export-sample-contracts.ps1`（可选 `-Configuration Release`），会先构建 Avalonia Sample，再将配套契约及依赖 DLL 导出到根目录 `output/Contracts`。该输出目录已被 Git 忽略。关闭 Editor 项目，将导出的 DLL 复制到项目 `Contracts` 目录，重新打开项目，并使用脚本打印的对应 App 路径启动测试。
+在仓库根目录运行 `./scripts/contracts/export-sample-contracts.ps1`（可选 `-Configuration Release`），会先构建 Avalonia Sample，再将配套契约及依赖 DLL 导出到根目录 `out/Contracts`。该输出目录已被 Git 忽略。关闭 Editor 项目，将导出的 DLL 复制到项目 `Contracts` 目录，重新打开项目，并使用脚本打印的对应 App 路径启动测试。
 
-仓库对项目契约及其 Core/Builtins 编译引用禁用提交相关的 InformationalVersion 后缀和 SourceLink，以免仅提交无关文件就改变 DLL 身份；PDB 和本地调试仍保留，App 自身仍带提交信息。可用 `./scripts/test-contract-reproducibility.ps1` 对两个 SourceRevisionId 做真实 Rebuild 检查。首次迁移此构建规则需重导出并部署一次旧契约；源码、引用 API、生成器、SDK、路径或编译配置变化仍可能改变严格二进制身份。仓库外自定义契约及依赖也需自行保证构建稳定，不能只依靠相同程序集版本号。
+仓库对项目契约及其 Core/Builtins 编译引用禁用提交相关的 InformationalVersion 后缀和 SourceLink，以免仅提交无关文件就改变 DLL 身份；PDB 和本地调试仍保留，App 自身仍带提交信息。可用 `./scripts/contracts/test-contract-reproducibility.ps1` 对两个 SourceRevisionId 做真实 Rebuild 检查。首次迁移此构建规则需重导出并部署一次旧契约；源码、引用 API、生成器、SDK、路径或编译配置变化仍可能改变严格二进制身份。仓库外自定义契约及依赖也需自行保证构建稳定，不能只依靠相同程序集版本号。
 
 Editor 启动的 App 在 30 秒内未连接时，调试面板会报告连接超时；Editor 不会因此终止 App。调试请求 60 秒无响应时，面板会结束等待并提示操作可能仍在运行；先检查运行状态再重试。状态/检查轮询的单次请求上限为 10 秒。
 
diff --git a/docs/manual/external-project-authoring.md b/docs/manual/external-project-authoring.md
new file mode 100644
index 00000000..2c2ba625
--- /dev/null
+++ b/docs/manual/external-project-authoring.md
@@ -0,0 +1,72 @@
+# 外部工具创作与热重载
+
+Codex、Claude 等外部工具可以通过 GalNet CLI 读取项目契约和修改项目。CLI 不包含模型服务；创作 Skill 随 CLI 分发，Editor 观察普通文件变化，不识别或依赖 AI 来源。
+
+## 准备 CLI 与 Skill
+
+源码中构建 `src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj`，使用生成的可执行文件，或 `dotnet <GalNet.Editor.Headless.dll>`。需要对应的 .NET 10 运行环境。构建/发布目录包含 `README.md` 和 `Skills/galnet-project-authoring/`；将后者提供给所用工具的 Skill 机制。源码入口在 [Skill](../../skills/galnet-project-authoring/SKILL.md)。
+
+任务中明确目标游戏项目目录和 CLI 路径。可用 `GALNET_CLI` 环境变量向 Agent 提供路径；它是 Skill 的发现约定，不是 CLI 自身必需的配置。
+
+```text
+<cli> help --json
+<cli> project info <project>
+<cli> schema list <project>
+<cli> schema show <project> <type-id>
+<cli> help group.entry.patchParameters --json
+<cli> help project.apply --json
+```
+
+参数契约由机器帮助给出。小改动使用 `execute` 的文档批次；一次生成 Graph、Group、本地化、立绘和 sidecar 时使用 `project apply`。
+
+## 批量应用原生文件
+
+在 `Temp/` 或项目外的暂存目录准备新文件和版本 1 的 manifest。source 相对 manifest 所在目录，path 相对目标项目；两者均拒绝路径逃逸和链接。原生剧情源是 `.rawgalgroup`，可运行 `.galgroup` 由编译器产生。
+
+```json
+{
+  "version": 1,
+  "writes": [
+    {
+      "path": "Graph/groups/intro.rawgalgroup",
+      "source": "intro.rawgalgroup",
+      "contentHash": "<暂存文件的64位十六进制SHA-256>",
+      "expectedHash": "<开始生成前原文件的SHA-256>"
+    }
+  ],
+  "deletes": []
+}
+```
+
+新增目标使用显式 `expectedHash: null`，表示目标必须不存在。删除项包含 `path` 和非空 `expectedHash`。哈希大小写均接受；例如 Python 的 `hashlib.sha256(path.read_bytes()).hexdigest()` 或 PowerShell 的 `Get-FileHash -Algorithm SHA256` 可计算。expectedHash 应在生成前捕获；发生冲突后需要重新核对内容，不能只替换为最新哈希来跳过冲突。
+
+```text
+<cli> project apply <project> <manifest-file> --dry-run
+<cli> project apply <project> <manifest-file>
+<cli> validate <project>
+<cli> group compile <project> --id <group-id> --dry-run
+```
+
+dry-run 在临时目录验证最终候选，不写项目文件。正式应用重新检查原文件哈希和文件集合，再通过同一作者事务发布。资源大文件以文件复制参与事务，不嵌入 manifest JSON；候选校验只建立媒体存在性，不复制或解码既有媒体载荷。报告沿用 validate 的完整性和 skippedChecks，不把参数正确当作图片/音频可用的证明。
+
+资源载荷和 `.meta` 必须同时存在或同时删除；替换已有 metadata 保留资源 ID。删除资源、文件或 Graph 节点后，剩余静态 JSON 引用需在同批更新。自定义 C# 和运行表达式仍不保证完整发现。固定 Graph/settings 入口允许显式替换，不允许删除；Contracts、Output、Temp、`.galnet`、Git/IDE 内部路径不允许作为修改目标。
+
+失败由作者事务补偿；异常退出留下的事务材料位于 `.galnet/editor/transactions/`，恢复规则见[历史与保存](../spec/editor-history-and-save.md)。它不承诺跨进程多文件隔离或断电整体原子性。
+
+## Editor 保持打开
+
+保存当前编辑后运行外部工具。Editor 合并文件通知并定期复核，在候选结构有效、事务完成且当前项目没有未保存作者内容/待提交输入时，直接更新当前项目会话。Group 页面、稳定身份的选中条目和布局保留；删除的 Group 页面关闭。资源通过既有索引代次刷新，已打开的普通文本也会更新。
+
+外部版本采纳后，保存基线推进，旧 Undo/Redo 清除。Editor 的下一次编辑和 Save All 使用新基线；外部结果的长期回退通过 Git 或用户备份。
+
+有本地未保存内容或输入时，外部变化提示会保留双方版本。可在外部核对/还原磁盘内容后点“重新检查”，也可点“从磁盘重新加载”，确认放弃当前作者修改及待提交输入。已应用内容会保留恢复快照；该快照不保存控件中尚未提交的原始输入。进行中的输入法组字或异步输入不能安全取消时，仍等待输入结束。
+
+坏 JSON、稳定身份/结构不合法或来源仍在变化时保留当前会话，显示原因并重试。项目契约 DLL 改动要求重新打开项目，不能把新 DLL 混进旧契约 scope。已经启动的游戏预览不自动重演剧情，需要重新启动预览以运行新内容。
+
+## 常用创作任务
+
+- 文本转剧情：指定剧本、目标项目和期望分场，读取契约后生成 Group/Graph 与开发语言文本。`LocalizedText` 字段存 key，原文写入相应 I18n 文件；新 speaker 使用角色 catalog。
+- 补演出：保持对白 Entry ID、文本 key 和原文，添加出入场、表情、位置、过渡、等待及音频等契约支持的行为。
+- 生成/导入立绘：图像工具产出文件，再把图片、metadata、可选 variants 描述及剧情引用放入同一批次。图片质量与角色一致性由预览检查。
+
+在 Git 项目里先检查已有修改，再检查 AI 完成后的 diff。提交、建分支或回退沿用用户工作方式，避免覆盖无关未提交内容。Git restore/revert 造成的文件变化也会热重载。无 Git 时 CLI 仍可使用，但成功修改之后的回退需要用户已有备份。
diff --git a/docs/manual/game-localization.md b/docs/manual/game-localization.md
index 52b3c9d5..a5e19f21 100644
--- a/docs/manual/game-localization.md
+++ b/docs/manual/game-localization.md
@@ -2,21 +2,23 @@
 
 在视图菜单打开“游戏本地化”。左侧选择角色表、任意 GalGroup 或分支选项，右侧按语言显示文本；开发语言始终在最左列。普通剧情表单和角色表仍直接填写开发语言，移动条目不会改变译文身份。
 
-在语言代码框填写如 en-US、ja-JP、zh-Hans-CN，然后点击“添加语言”。新列初始缺译，不会复制原文。列头左右箭头调整其他语言的位置；开发语言不能用箭头移走。
+点击工具栏的“管理语言”图标，输入语言名称或代码（如 en-US、ja-JP、zh-Hans-CN），选择候选或直接输入有效代码，再点击“＋”。候选排除已添加语言，新语言不会复制原文。已有语言前的勾选控制列显示，开发语言始终显示；拖动列头右侧边缘调整列宽。语言行的更多菜单调整顺序或切开发语言，移除按钮将该语言从支持列表移除，但保留翻译文件；重新添加可恢复文本。开发语言需先切换后才能移除。
 
-单元格支持多行：Enter 换行，Ctrl+Enter 或移出焦点提交，Escape 放弃当前输入。缺译和空字符串不同；对空单元格明确按 Ctrl+Enter 会保存空字符串。修改原文会保留其他语言，并使已有原文关联的译文显示“待复核”；检查后重新提交译文即可关联当前原文。“复核状态未知”表示缺少关联证据。
+单元格默认紧凑显示，点击后从左上角开始多行编辑。失去焦点或按 Ctrl+Enter 提交，输入过程中不逐字更新项目，无需保存草稿或复核。Enter 换行，清空后提交会写入空字符串；缺译格按 Ctrl+Enter 可明确保存为空串。输入法组字期间保留候选，不提前提交。Escape 放弃未提交输入，已经提交的内容通过项目撤销恢复。修改原文保留其他语言的译文。
 
 分支选项或其他 `LocalizedText` 字段留空时会显示为空文本，不要求在本地化文件中建立空 key；只有非空 key 才参与缺译检查。
 
-同分类内共享文本只显示一行，并提示引用数量；修改会影响共享位置。使用“定位引用”打开对应创作位置。表格横向滚动可查看更多语言，左侧分类和右侧文本行可独立纵向滚动。
+同分类内共享文本只显示一行，并提示引用数量；修改会影响共享位置。使用行内的定位图标打开对应创作位置，多处引用时可选择目的位置。表格横向滚动可查看更多语言，上下文列保持可见，语言列头不随文本行上下滚动。左侧分类和右侧文本行可独立纵向滚动；窄面板通过分类下拉框选择范围。
 
-需要更换项目开发语言时，先添加该语言，再在“开发语言”中选择它，点击“检查变更”。面板显示目标语言缺译数量；检查后点击“应用开发语言”。这不会自动翻译或复制文本，普通创作页随后使用新的开发语言。检查后文本发生变化时，需要重新检查。项目设置页面的开发语言仅显示当前值。
+顶部搜索匹配原文、译文及定位信息；缺译图标开启“仅缺译”，检查当前显示的非开发语言列。显式空字符串不算缺译，隐藏的语言列不参与筛选。
 
-所有文本和语言操作支持项目撤销/重做，使用 Save All 保存。切换分类或关闭面板会保留未提交草稿；Save All 会尝试提交它们。遇到原文、译文、引用或 JSON 草稿冲突时，当前输入保留，请先检查现值；“放弃草稿”会清除面板中所有分类的待提交输入。项目关闭后不再接受旧面板写入。
+需要更换项目开发语言时，先添加该语言，再打开“管理语言”，在该语言的更多菜单中选择“应用开发语言”。弹层显示目标语言缺译数量；检查后点击“应用开发语言”。这不会自动翻译或复制文本，普通创作页随后使用新的开发语言。检查后文本发生变化时，需要重新检查。项目设置页面的开发语言仅显示当前值。
 
-选择交换语言，保留“全部分类”或取消以导出当前分类，再点击“导出 JSON”。默认输出带上下文和原文指纹的单语言模板；只修改 rows 中的 translation，保留项目身份、key、语言和原文列。行顺序可以调整。勾选“运行文本”会输出直接译文的平铺 JSON，缺译不输出。导出位置须在项目目录之外。
+所有文本和语言操作支持项目撤销/重做。失焦提交修改项目工作内容，Save All 也会提交当前尚未失焦的输入并统一写盘。切换分类或关闭面板会保留尚未提交的内容。遇到原文、译文、引用或 JSON 冲突时，失败输入保留并就地提示；检查现值后可用错误旁的重新读取按钮放弃失败输入。未解决错误会阻止保存。项目关闭后不再接受旧面板写入。
 
-点击“导入预览”选择模板，也可导入平铺 key→string/null JSON。平铺文件使用面板所选语言；模板按自身目标语言预览。目标语言必须先添加，且不能是当前开发语言。预览显示当前原文、导入值与状态，勾选要应用的行；未知文本不能选，null 跳过，空字符串须同时选择该行并勾选“允许空字符串清空译文”。原文发生变化的译文会显示待复核，应用不覆盖原文。预览过期时重新打开文件，不能强行覆盖当前值。
+点击导出图标，在弹层中选择交换语言，保留“全部分类”或取消以导出当前分类，再点击“导出 JSON”。默认输出带上下文和原文指纹的单语言模板；只修改 rows 中的 translation，保留项目身份、key、语言和原文列。行顺序可以调整。勾选“运行文本”会输出直接译文的平铺 JSON，缺译不输出。导出位置须在项目目录之外。
+
+点击导入图标，在弹层选择交换语言后点击“导入预览”，选择模板或平铺 key→string/null JSON。平铺文件使用该交换语言；模板按自身目标语言预览。目标语言必须先添加，且不能是当前开发语言。预览显示当前原文、导入值与状态，勾选要应用的行；未知文本不能选，null 跳过，空字符串须同时选择该行并勾选“允许空字符串清空译文”。模板原文发生变化时预览会提示“原文已变更”，应用不覆盖原文。预览过期时重新打开文件，不能强行覆盖当前值。
 
 点击“应用所选”把整批译文和复核状态纳入一次撤销/重做，随后 Save All。应用开始前可取消预览，应用期间控件暂时禁用。首次模板导出会持久分配项目交换 GUID，改目录名不影响匹配；后续文件输出失败时该身份仍保留，不会保存其他 dirty 文本。
 
diff --git a/docs/manual/image-variants.md b/docs/manual/image-variants.md
index 8ad1270a..56f86311 100644
--- a/docs/manual/image-variants.md
+++ b/docs/manual/image-variants.md
@@ -6,11 +6,11 @@
 
 1. 在 Assets 面板导入图片目录，例如 `smile_coat.png`、`smile_skirt.png`、`idle_coat.png`、`idle_skirt.png` 和 `weap.png`。使用普通导入操作，让每张图片获得资源 sidecar。
 2. 进入该目录，或选中目录，在菜单选择“从目录创建差分图集”。编辑器创建 `variants.variants` 和 sidecar；重名时使用新的文件名。默认图先按稳定顺序选择第一张。
-3. 选中描述文件，在属性区配置图片目录、默认图片和维度。目录相对描述文件，例如同目录为 `.`；允许在 Assets 内使用相对路径，不允许越界或链接。
-4. 自动维度默认是 `d1`、`d2` 等，对应文件名从左到右的位置。可把显示名改为“表情”“服装”；key 是剧情引用身份，label 只是显示文字。修改 key 或顺序后自行检查已有剧情引用，编辑器不会自动迁移。
-5. 点击“应用配置”形成一条可撤销的文件修改，或直接使用保存全部提交草稿并保存。关闭属性面板不会丢弃未应用的草稿。无效配置会阻止提交，诊断中的路径和代码可帮助定位。
+3. 选中描述文件，在属性区用目录选择器选择 Assets 内的图片目录，并用唯一的“默认图片”下拉框选择已有图片。图片目录以相对描述文件的路径显示。
+4. 文件名从左到右按 `_` 分段，最长名称决定维度数量。维度数量、顺序和选项自动计算，不能手工添加、删除或排序；每个位置可以修改显示名称，例如“表情”“服装”。位置标题使用本地化“维度 1、维度 2”，不显示内部 key。key 是稳定的剧情引用身份；新位置自动生成 `d1`、`d2` 等不冲突的 key。
+5. 修改默认图片或显示名称后立即进入可撤销的项目工作版本，不需要点击应用；用“保存全部”写入磁盘。属性区不再内嵌 JSON 编辑器，损坏的描述可通过通用文件入口修复。
 
-同一目录中不能有同名主干的多种图片，例如 `idle_coat.png` 和 `idle_coat.jpg`。下划线之间不能有空段，default 必须精确匹配已有主干。不同图片的段数可以不同；显式维度必须覆盖最长名称。
+同一目录中不能有同名主干的多种图片，例如 `idle_coat.png` 和 `idle_coat.jpg`。下划线之间不能有空段，default 必须精确匹配已有主干。不同图片的段数可以不同；维度命名配置不决定实际维度数量。目录增长时自动补充位置，缩短时不展示多余位置；已保存的位置名称保留，以便图片恢复后继续使用。
 
 原始描述示例：
 
@@ -32,7 +32,7 @@
 
 面板分别列出请求和实际图片，并展示每一步候选。匹配失败时，从后向前累计去掉这次没有明确选择的维度，仍按原位置精确匹配；全部失败则使用显式默认图。回退不会把请求覆盖为实际图的选择，也不会隐藏缺组合的值。
 
-扫描、切换预览和语言切换不写作者文件。配置或图片变化后可重新扫描；失效的预览请求会显示诊断，点击“重置预览选择”才重新从默认图开始。
+扫描、切换预览和语言切换不写作者文件。Assets 文件新增、删除、改名和内容变化会经防抖通知自动重新扫描，不提供手动重新扫描按钮。刷新保留预览请求，失效时显示诊断，点击“重置预览选择”才重新从默认图开始。默认图片缺失时下拉框留空，扫描诊断说明缺失，不会静默换图或在扫描时改写配置；重新选择已有图片即可修复。候选削减链收在“匹配详情”中。
 
 ## 在剧情中使用
 
@@ -42,7 +42,7 @@
 
 普通换图会清除对象的图集模式，隐藏会删除实例；再次显示图集重新初始化选择。Timeline 可以操作图集 Layer 的普通动画属性，但当前没有新增 Timeline 差分切换事件。
 
-配置应用后，即使尚未保存到磁盘，剧情字段会使用已提交的项目工作版本。仅在属性面板输入、尚未应用的配置草稿只用于本面板预览；应用或保存全部后再影响剧情查询。刷新、换条目或关闭项目后，旧选项不能继续提交。
+有效配置修改后，即使尚未保存到磁盘，剧情字段也会使用已提交的项目工作版本。无法通过校验的修改保留诊断，不能提交；外部修改描述文件仍遵循项目文件冲突处理，不覆盖未保存工作。刷新、换条目或关闭项目后，旧选项不能继续提交。
 
 ## 运行仓库示例
 
diff --git a/docs/manual/native-aot.md b/docs/manual/native-aot.md
new file mode 100644
index 00000000..0a9e83b3
--- /dev/null
+++ b/docs/manual/native-aot.md
@@ -0,0 +1,74 @@
+# NativeAOT 发布与扩展契约
+
+NativeAOT 是可执行宿主的发布选项，不需要独立 AOT 项目。当前复用 `GalNet.Sample.Headless` 验证引擎后端；普通构建仍使用 JIT。SDK 在 NativeAOT 发布时默认关闭反射 JSON。
+
+## 发布与自检
+
+安装目标平台 NativeAOT 工具链后运行：
+
+```powershell
+./scripts/test-native-aot.ps1 -RuntimeIdentifier win-x64
+```
+
+脚本用标准 `-p:PublishAot=true` 发布现有 Headless Sample，在 `.galnet/native-aot-acceptance/<rid>` 隔离恢复和编译产物，然后执行 `--aot-self-test --expect-aot`。单独发布的核心命令为：
+
+```powershell
+dotnet publish src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj -c Release -r win-x64 -p:PublishAot=true
+```
+
+仓库默认锁定依赖；RID 和 AOT 编译器会改变恢复图。日常验收优先使用脚本，它将该恢复图与普通开发的 lock 文件隔离。源码生成器是运行在编译器里的 netstandard 工具，其项目显式忽略玩家的 AOT、SelfContained 和 RID 属性。
+
+成功输出 `AOT_ACCEPTANCE_OK dynamicCode=False reflectionJson=False`。自检覆盖 Graph/编译后 Group 加载、剧情推进、NCalc 解释求值、自定义状态恢复、内置指令和状态、生成字段 codec/递归 schema、配置、资源 metadata/未知字段、PAK acquire、文件存档、玩家变量与已读进度。脚本将最终链接的 ILLink/ILC 警告视为错误；库源码分析仍可能报告未进入玩家闭包的作者工具或显式反射回退路径。
+
+## 自定义 DTO 的 JSON 元数据
+
+现有 `GalNet.SchemaGenerator` 继续生成字段读写、默认值和 schema。复杂 DTO 的 JSON 元数据使用 .NET 的 `System.Text.Json` 源生成器；两个生成器职责不同。请在真实源文件中声明 context，不能期待一个生成器消费另一个生成器在同一轮产生的类型声明。
+
+```csharp
+[assembly: FieldSchemaJsonContext(typeof(ProjectJsonContext))]
+
+[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata,
+    UseStringEnumConverter = true)]
+[JsonSerializable(typeof(ProjectOptions))]
+[JsonSerializable(typeof(ProjectSettings))]
+[JsonSerializable(typeof(ProjectState[]))]
+[JsonSerializable(typeof(ProjectMeta))]
+internal partial class ProjectJsonContext : JsonSerializerContext;
+```
+
+根类型要包含运行时需要的 DTO 和状态数组；嵌套类型由 JSON 生成器跟踪。枚举采用实际 wire 约定，字段上的 converter 继续生效。程序集标记让字段生成器将 resolver 注入 `ValueDescriptor`，同时生成 CLR/JSON 成员身份和延迟子 schema 委托；递归类型不会在 schema 初始化时无限展开。手写描述可通过 `jsonOptions`、`WithMember` 和 `WithSchemaProvider` 显式提供相同信息。
+
+扩展边界分别注册元数据：
+
+```csharp
+var stateOptions = JsonMetadata.CreateOptions(GameState.JsonOptions, ProjectJsonContext.Default);
+var stateInfo = JsonMetadata.GetTypeInfo<ProjectState[]>(stateOptions);
+states.Register<ProjectState>("project.state", item => item.Id, jsonTypeInfo: stateInfo);
+// IPrimitiveModule 内也可用 registry.State(stateInfo, "project.state", item => item.Id)。
+
+var section = new ConfigurationSection<ProjectSettings>("project.settings",
+    ProjectSettings.Schema, jsonResolver: ProjectJsonContext.Default);
+
+resources.Add<ProjectMeta>("project.data", ProjectJsonContext.Default, ".custom");
+```
+
+资源 DTO 需要公开无参构造函数；目录通过泛型工厂创建默认实例。`GameState.JsonOptions` 是冻结的存档设置，扩展应在其副本上组合 resolver，保持命名、未知字段拒绝和枚举约定一致。通用编码使用 `JsonCodec` 或接收 `JsonTypeInfo` 的框架重载；反射关闭且缺少元数据时明确报错。普通桌面 JIT 保留反射兼容入口。
+
+## 验收边界
+
+Sample 共享 UI 已完成一轮 AOT 准备：输入配置使用源生成 JSON 元数据，数值约束和共享表单 JSON 操作使用显式元数据，GamePage 内容绑定使用类型化 CompiledBinding；内置视觉效果按项目 shader 资源显式创建，不扫描程序集发现工厂。输入配置 wire 格式保持兼容。这些改进不等于桌面或 iOS Sample 已支持 NativeAOT，也尚无量化性能或包体收益数据。
+
+可独立验证这部分在 JSON 反射关闭时的行为：
+
+```powershell
+dotnet test test/GalNet.Presentation.Tests/GalNet.Presentation.Tests.csproj -c Release `
+  --artifacts-path out/sample-aot-tests `
+  -p:JsonSerializerIsReflectionEnabledByDefault=false `
+  --filter FullyQualifiedName~SampleAotPreparationTests
+```
+
+上述筛选测试不代替普通完整回归；普通测试使用默认反射设置。桌面最终链接仍通过 `scripts/release/Test-DesktopAot.ps1` 严格检查，不压制 ILLink/ILC 警告；本轮实现及具体剩余阻塞见 [Sample AOT 准备记录](../../features/F-20261027-04-tagged-release/sample-aot-preparation-20261028.md)。iOS 还需选择对应 .NET/Avalonia 发布路线，并在 Mac/Xcode 和真机上验证。
+
+本地已验证 Windows x64 NativeAOT 的 Headless 引擎闭包；CI 配置覆盖 Windows/Linux。测试工程本身是否支持 NativeAOT 取决于 test runner，普通 `dotnet test` 不等于运行了 NativeAOT。
+
+自检不验证 Avalonia/Skia 图形、LibVLC 视频、原生音频设备、动态加载项目程序集或 Editor/CLI 作者编译器。NativeAOT 玩家应在组合根静态引用项目契约。其他桌面 RID、Android/iOS 打包、系统媒体和移动端实机仍需在对应环境验证，不能由桌面自检推导已经支持。
diff --git a/docs/manual/new-presentation-layer.md b/docs/manual/new-presentation-layer.md
index 0237d370..65a97d1e 100644
--- a/docs/manual/new-presentation-layer.md
+++ b/docs/manual/new-presentation-layer.md
@@ -6,7 +6,7 @@
 
 1. 新建框架专属项目，引用 `GalNet.GameHost`、`GalNet.Presentation.Abstractions`、`GalNet.Runtime` 和所需的内容/存储项目；禁止让这些内层项目反向引用新框架。
 2. 以项目契约构建 `IEntryCatalog`，再通过 `GameRegistration` 注册对应的 `IPrimitiveModule`。只注册内容实际允许的 schema 和具有执行实现的 type ID。
-3. 实现 `IGameView`，或组合框架专属的 dialogue、choice、layer、animation、effect、particle、video presenter 后构建它。Presenter 将 Runtime 的中立请求映射为框架对象；不得把 UI 控件、Dispatcher 或媒体对象写入 `GameState`。
+3. 实现 `GalNet.Core.Execution.IPrimitiveDispatcher`，或组合框架专属的 dialogue、choice、layer、animation、effect、particle、video presenter 后构建它。Choice、快进同步和玩家播放控制协议同属 Core.Execution；Presenter 将 Runtime 的中立请求映射为框架对象，不得把 UI 控件、Dispatcher 或媒体对象写入 `GameState`。仅用自定义分发器的最小宿主可只引用 Core/Runtime，不要求呈现注册组合。
 4. 创建 `GameSession`/`GameRun` 的应用组合根。它负责开始、存档、替换运行和退出；停止时先释放 Engine，再异步释放 view、presenter、媒体后端及资源。
 5. 通过 `IAssetManager` 获取图片、音频和视频。若后端必须使用文件，使用 Asset 的 materializer/lease 产生临时实体文件，lease 存续期间才可使用。
 
@@ -14,10 +14,54 @@
 
 - `GameEngine` 是唯一的剧情推进器；UI 不自行推进、跳过 batch 或推断 Engine 终态。
 - primitive 先在 `GameState.Update` 提交可存档事实，再通知 presenter。读档后的展示由注册的恢复处理器和 `StateRestoreSession` 重建。
-- `GameSnapshot` 当前版本为 4；不要序列化 UI、Task、取消源、播放器 identity 或媒体时间轴。
-- 音频平台实现通过 `IAudioPlaybackHost` 组合；同一逻辑轨道的队列和状态仍由 `AudioRuntime` 管理。
+- `GameSnapshot` 当前版本为 5；不要序列化 UI、Task、取消源、播放器 identity 或媒体时间轴。
+- 音频平台实现通过 `GalNet.Contracts.Builtins.Audio.IAudioPlaybackHost` 组合；同一逻辑轨道的队列和状态仍由 `AudioRuntime` 管理。
 - 新的自定义 primitive 需要同时提供 schema、执行注册、参数/恢复验证和覆盖其生命周期的测试。
 
+## 从项目设置映射模块配置
+
+项目可以采用自己的普通 DTO，不必继承框架设置基类。组合根只传入模块需要的值：
+
+```csharp
+var playback = new PlaybackOptions
+{
+    AutoAdvanceIntervalMilliseconds = preferences.AutoDelay,
+    QuickReadOnly = preferences.ReadOnlySkip
+};
+var configuration = new AudioConfiguration(projectTracks, projectGroups);
+var audio = new BuiltinAudioModule(audioBackend, configuration: configuration);
+audio.ApplyMix(new AudioMixOptions
+{
+    MasterGain = preferences.MasterVolume,
+    Groups = new Dictionary<string, AudioMixLevel> { ["ambience"] = new(preferences.AmbienceVolume) },
+    Tracks = new Dictionary<string, AudioMixLevel> { ["rain"] = new(preferences.RainVolume) }
+});
+// Register the configured audio module with the other implementations.
+var runtime = new GameRuntime(textResolver, graph.RootNodeId, variableService: variables);
+await using var engine = new GameEngine(graph, runtime, dispatcher, playbackOptions: playback);
+await engine.UpdatePlaybackOptionsAsync(playback with { AutoAdvanceIntervalMilliseconds = 1500 });
+```
+
+PlaybackOptions 位于 Core.Execution，AudioMixOptions/AudioMixLevel 位于 Contracts.Builtins.Audio，BuiltinAudioModule 位于 Primitives.Builtins。默认 Avalonia.GameHost.Settings.GameSettings 提供示例映射方法，可直接使用或完全替换。音频模块不会读取 GameContent.Configuration，也不会自动创建轨道；默认宿主负责从配置文档投影项目声明的轨道。轨道声明和混音字典在入口隔离，后续修改项目对象不等于更新运行配置。文本速度传给文本呈现，窗口偏好交给显示服务，保存槽数交给保存服务，不把整个偏好对象塞进运行上下文。
+
+## 声明音频 Bus 与 Track
+
+`AudioConfiguration` 在构造时验证并隔离Track/Bus 声明；ID 由项目定义，一个轨道可以不指定 Bus，或用 `BusId` 引用一个已声明 Bus。空配置合法。`BuiltinAudioDefaults.Create()` 是可选的三 Bus 示例，Sample 和新项目模板显式选择它；Core 与音频模块不自动注入默认轨道。
+
+```csharp
+var configuration = new AudioConfiguration(
+    [new() { Id = "rain", Name = "Rain", BusId = "ambience", PreserveDuringCatchUp = true },
+     new() { Id = "wind", Name = "Wind", BusId = "ambience" },
+     new() { Id = "alert", Name = "Alert" }],
+    [new() { Id = "ambience", Name = "Environment" }]);
+```
+
+`AudioMixOptions` 分别接收 master、Buses 和 Tracks 的 gain/mute，缺省为 1/false。默认 PCM 后端在 Track/Bus 汇总后分别执行效果和音量，最后应用 Master 静音/音量及采样限幅；不会把 Bus 效果分配给各个实例。ApplyMix 在入口复制字典，更新当前和后续声音。玩家混音不写入剧情快照，恢复使用当前玩家值。
+
+`PreserveDuringCatchUp` 显式控制快进回放结束时是否投影最终播放内容，与 ID/Bus 名称无关。普通音频指令和语音复合指令均须显式提供 `trackId`。
+
+默认 Avalonia 设置服务从声明生成分组控件，以 `ShowTrackAudioControls` 选择是否同时显示单轨控件；隐藏单轨控件时仍恢复对应偏好。更高层可以完全采用自己的 DTO、UI 和持久化，只需映射上述配置。默认存储键按经过 URI 转义的 ID 区分 group/track，无固定三分类字段。
+
 ## 接入图片差分
 
 内置 layers 模块包含 `variants.show/select`。资源 scope 建立后，先注册 decoder 并异步准备目录，再构造执行 view：
@@ -34,11 +78,33 @@ var view = registration.AddBuiltinImplementations(projectCatalog,
 
 图集定义无需持有资源租约；sprite 图片仍按现有 presenter 生命周期管理。普通 `ILayerPresenter.ShowLayer/ReplaceLayer` 已足够，渲染器不解析文件名或维度。会话播放中目录不变，读档由同一目录进行同步内容预检；切换内容或项目时重新准备，不能把旧目录挂到新项目。默认 Avalonia 配置回调可从 `presentation.ImageVariants` 获取已准备目录，并传入 AddBuiltinImplementations。
 
+## 项目配置声明
+
+`ProjectSchemas.Configurations` 可返回 `ProjectConfigurationSchema`；未声明时为空。通过 `ConfigurationSection<MyOptions>` 为普通 DTO 显式提供 FieldDescriptor。配置统一使用标准 JSON 序列化和属性 converter，不另设生成 DTO 编解码入口。版本默认为 1，领域校验可通过声明时的委托提供。
+
+通过 `content.Configuration.Read(section)` 取得独立 DTO，修改后用 `content.Configuration.Set(section, options)` 发布；读取缺省配置不会写文件。运行模块继续接收由 DTO 投影的小配置。Storage 加载通过 `GameContentLoadOptions.Configurations` 显式选择 schema，并通过 `SelectDefaultCulture` 提供文化代码。默认 Sample 的组合见 SampleCustomization.CreateHostOptions，默认字段定义见 DefaultProjectConfiguration；它们是可选示例，不由 Core/Runtime 自动选择。项目设置窗口按声明生成通用字段表单，复合值使用共享 JSON 编辑器；应用或保存全部时验证整份候选，一次提交可撤销的配置变更。未知数据保留，默认模型的语言声明继续在 I18n 面板维护。调试沿外部宿主路径进行。
+
+CLI 可用 `execute <project> <patch.json>` 修改已声明的 section。例如：
+
+```json
+{"commandId":"project.configuration.patch","sectionId":"developer.options","values":{"caption":null},"remove":["count"]}
+```
+
+`values` 写入原始 JSON，`null` 是显式空值；`remove` 删除字段，使读取时恢复 schema 或 DTO 默认值。同一字段同时出现时以 `values` 为准。整份候选通过字段和领域校验后才发布，未知 section/字段不能通过补丁写入，已有未知数据仍保留。CLI 构建、两种导出及 Editor 导出/外部调试构建均传入项目 schema；直接调用共享服务时，通过 `configurations` 参数显式选择声明，无效配置在替换既有产物前失败。
+
+默认 Avalonia 宿主通过 `AvaloniaGameHostOptions.SelectProjectOptions` 接收项目投影，返回 `AvaloniaProjectOptions` 的存档容量、默认语言和 `AudioConfiguration`。宿主启动时只投影一次，随后运行、重置偏好和重新开局复用这些简单值；它不读取 `DefaultProjectOptions`。Sample 在组合根显式完成默认示例模型的映射，自有 DTO 可替换该回调。
+
 ## 验证清单
 
+最小自有分发器执行/恢复见 [ExecutionBoundaryTests](../../test/GalNet.Runtime.Tests/Engine/ExecutionBoundaryTests.cs)。自有 DTO 同时控制自动推进、实际文本呈现和 ambience 音量的组合验证见 [ProjectConfigurationCompositionTests](../../test/GalNet.IntegrationTests/ProjectConfigurationCompositionTests.cs)；自定义配置的保存/导出/安装链路另由 Editor 表单与安装测试覆盖。Sample 继续作为三个默认音频 Bus的完整接入示例。
+
 - 只含自定义 schema/执行的最小内容可编译和运行，缺失执行会明确失败。
 - 正常推进、Choice、阻塞实例自然完成、停止和重新打开不会并发推进或泄漏旧回调。
 - 存档/读档能重放 layer、effect、particle、循环动画及音频的稳定状态。
 - 资源、临时媒体文件、平台对象和 DI scope 均按失败路径释放。
 
 详细模块契约请分别查看[运行时](../spec/runtime.md)、[条目类型](../spec/entry-types.md)、[资源](../spec/assets.md)和[架构](../spec/architecture.md)。
+
+默认资源与 Gallery 工厂在 Contracts.Builtins.Assets/Gallery，差分图片契约在 Contracts.Builtins.Variants；不选择默认工厂时可直接组装自有目录，并按需要声明 DefaultType。创建 provider/PAK 时始终传入同一资源目录。宿主内容类型在 GameHost.Content，通用 Runtime 不再拥有 GameContent 或 Gallery 玩家包装。
+
+新的目标效果、混响、默认配置 v2 与 Windows 后端构建见 [音频混音手册](audio-mixing.md)。
diff --git a/docs/manual/ready-to-run.md b/docs/manual/ready-to-run.md
new file mode 100644
index 00000000..de6c51fb
--- /dev/null
+++ b/docs/manual/ready-to-run.md
@@ -0,0 +1,43 @@
+# 使用 Windows ReadyToRun 发布
+
+Editor 和 Avalonia Sample 提供 `WindowsReadyToRun` 发布配置：Release、win-x64、依赖已安装的 .NET 10 运行时、启用 ReadyToRun、关闭裁剪和单文件。它预编译发布程序集以减少启动 JIT，不改变 Debug 或普通 `dotnet run` 的启动方式。
+
+```powershell
+dotnet publish src/Editor/GalNet.Editor/GalNet.Editor.csproj -c Release -r win-x64 -p:PublishProfile=WindowsReadyToRun -o out/r2r/Editor
+& out/r2r/Editor/GalNet.Editor.exe
+
+dotnet publish src/Samples/GalNet.Sample.Avalonia/GalNet.Sample.Avalonia.csproj -c Release -r win-x64 -p:PublishProfile=WindowsReadyToRun -o out/r2r/Sample
+& out/r2r/Sample/GalNet.Sample.Avalonia.exe GameTestCase/Output --profile out/r2r/game-test-profile
+```
+
+必须运行发布目录中的程序才能获得预编译收益。发布配置保留完整 IL 和反射元数据，兼容现有 XAML、DI 和项目 schema 加载；不调整渲染后端或窗口效果。
+
+普通命名配置的编译与还原中间结果放在各项目的 `bin/publish/WindowsReadyToRun` 和 `obj/publish/WindowsReadyToRun`。RID 依赖图使用各项目根目录下独立跟踪的 `packages.lock.WindowsReadyToRun.json`，避免改写日常开发的 `packages.lock.json`，同时让全新环境可以执行 locked restore。Editor 默认契约 Content 从同模式的 DefaultContracts 输出复制。显式 Benchmark=true 时继续使用既有 bin/benchmark、obj/benchmark。
+
+CI=true 时仍尊重仓库 locked restore。Editor 和 Sample 的发布依赖闭包各自使用一组 R2R 锁文件；更新 SDK、RID 图或依赖版本后，需要显式重新生成并提交变更：
+
+```powershell
+dotnet restore src/Editor/GalNet.Editor/GalNet.Editor.csproj -r win-x64 -p:PublishProfile=WindowsReadyToRun -p:RestoreLockedMode=false
+dotnet restore src/Samples/GalNet.Sample.Avalonia/GalNet.Sample.Avalonia.csproj -r win-x64 -p:PublishProfile=WindowsReadyToRun -p:RestoreLockedMode=false
+```
+
+日常发布和 CI 使用 locked restore；解锁只用于有意更新上述锁文件。Restore 输出仍隔离在命名配置的 `obj` 路径中。配置不关闭仓库的 CI 锁定策略。
+
+## 契约字节身份
+
+ReadyToRun 会改写参与转换的 DLL，不能直接把转换后的 DLL 当作原契约。Directory.Build.targets 在 PublishReadyToRun=true 时排除 GalNet.Core.dll、GalNet.Contracts.Builtins.dll、GalNet.Project.Contracts.dll，保留固定契约入口及编译闭包的 IL 字节身份。项目契约和 App 调试匹配规则不放宽。
+
+## 已测收益与代价
+
+本机各 10 对交错测试（两版各预热一次），同样的 Release/win-x64/framework-dependent 发布，关闭采样：
+
+| 宿主 | 普通发布 Median | R2R Median | 改善 | P95 普通 → R2R |
+| --- | ---: | ---: | ---: | ---: |
+| Editor | 1446.65ms | 845.37ms | 41.6% | 1487.32 → 940.01ms |
+| Sample | 2214.57ms | 1515.76ms | 31.6% | 2255.08 → 2060.09ms |
+
+两个宿主均 10/10 配对更快。时间口径为 Main 到宿主 ready；Sample 使用预构建内容与完成语言选择的测试 profile。它们是预热缓存下的新进程启动，不代表系统重启后的冷缓存。性能随机器和内容变化，不与早期其他实验的绝对时间拼接比较。
+
+发布目录未压缩体积：Editor 约 421.3 → 452.3 MiB（增加约 31.0 MiB）；Sample 约 416.1 → 439.6 MiB（增加约 23.5 MiB）。预编译也增加发布阶段的工作量，不能把它计作启动收益。此次未量化工作集内存变化。
+
+原始 trace、摘要、身份校验及检查见 features/F-20261025-01-cpu-startup-benchmark/runtime-profile.md。后续使用 [CPU benchmark](cpu-benchmark.md) 对同一发布形式复测。
diff --git a/docs/manual/release-packaging.md b/docs/manual/release-packaging.md
new file mode 100644
index 00000000..78e3e103
--- /dev/null
+++ b/docs/manual/release-packaging.md
@@ -0,0 +1,136 @@
+# 本地 CI 与发布
+
+先在 Windows x64 安装 `global.json` 指定的 .NET SDK，以及包含 Windows SDK、C++ x64 编译工具和运行库的 Visual Studio Build Tools。SDK 禁止自动滚动到其他版本，保证本地与 runner 使用同一编译器。
+
+## 本地运行 CI
+
+```powershell
+pwsh -NoProfile -File scripts/ci/Invoke-CI.ps1 -Coverage
+```
+
+入口先检查 SDK 和十七项发布保护用例（含 tag 主分支归属和七 ZIP 上传预检），再执行 locked restore、空白与 using 检查、Release solution 构建、solution 中全部 GalNet 测试项目。restore/build/test 使用同一 Configuration，fixture 工程也列在 solution 内。构建完成后才启动 no-build 测试。测试阶段收集全部项目的失败，最后返回非零；真实设备的 Explicit 测试不属于普通 CI。
+
+可以单独运行：
+
+```powershell
+pwsh -NoProfile -File scripts/ci/Invoke-CI.ps1 -Stage Format
+pwsh -NoProfile -File scripts/ci/Invoke-CI.ps1 -Stage BuildTest -Coverage
+```
+
+默认日志保存在唯一的 `out/ci/<run>/`；`ci-results.json` 记录整体结果、各检查退出码和完整日志路径，`test-results/` 保存 TRX 与可选 coverage。`-OutputRoot` 可指定证据目录。Actions 的 CI workflow 调用相同脚本，分为 Format / BuildTest 两个 job。Windows 的 dotnet format/testhost 需要允许子进程与命名管道通信；受限执行沙箱内的管道拒绝不是源码格式错误。
+
+## 本地生成完整发行文件
+
+```powershell
+pwsh -NoProfile -File scripts/release/Release.ps1 -Version 0.1.0-dev.1
+```
+
+默认仅在本地生成和验收，不需要 GitHub/NuGet 凭据。已存在的最终版本目录不会被覆盖；试不同候选时增加 dev.N，或指定独立 `-OutputRoot`。
+
+最终目录：
+
+```text
+out/release/<version>/
+  nuget/                 五个 nupkg
+  assets/                七个 ZIP
+  SHA256SUMS
+  release-index.json
+```
+
+构建、打包、验收全部成功后才出现这个最终目录。中间文件与日志保留在同输出根的 `.work/<version>-<runId>/`，失败不会留下可误发布的完整索引。只构建 NuGet 或应用可用 `-Target NuGet` / `-Target Apps`。
+
+五个 NuGet：
+
+| 包 | 内容 |
+| --- | --- |
+| GalNet.Contracts | Core、内置作者契约 |
+| GalNet.Engine | 引擎、默认指令、内容与宿主抽象、调试/诊断 |
+| GalNet.Desktop | 默认文件存储、PCM 音频、Miniaudio、LibVLC 托管适配 |
+| GalNet.Avalonia | Avalonia 控件、渲染、默认页面、主题与宿主 |
+| GalNet.SchemaGenerator | 编译期字段/schema 生成器 |
+
+聚合包保留原 DLL 和命名空间。普通游戏引用 GalNet.Avalonia；自定义契约工程引用 GalNet.Contracts，并显式引用 GalNet.SchemaGenerator（`PrivateAssets="all"`）。所有 GalNet 包使用同一版本，依赖约束为精确版本；第三方依赖通过正常 NuGet 引入，不复制到聚合包里。Miniaudio 的预编译 win-x64 native 资产随 Desktop 包分发，消费者不需要 MSVC。LibVLC 原生分发包仍由宿主按平台选择。
+
+默认打包后，在仓库外临时目录及隔离 NuGet 缓存验证四种消费工程、生成器和原生资产传递，测试期间不借用源码 ProjectReference 或中央版本配置。现有包缓存也可作为第三方依赖的离线 feed。`-SkipPackageValidation` 只适合打包调查，产生的索引不允许公开上传。
+
+Windows x64 应用提供两种部署方式，均保留 R2R：默认完整版附带 .NET；`-framework-dependent` 精简版要求用户安装 Windows x64 **.NET 10 Runtime 的最新修补版本**，不需要 SDK、ASP.NET Core Runtime 或 Windows Desktop Runtime。Avalonia/Skia、Miniaudio 和 VLC 等应用原生依赖仍随两种版本提供。下载地址：https://dotnet.microsoft.com/download/dotnet/10.0 。
+
+共七个 ZIP：
+
+- `GalNet-Editor-<version>-win-x64-r2r.zip`：自包含 Editor，附同目录的 `GalNet.Editor.Headless.exe` 和 `Skills/galnet-project-authoring/`。Editor 与 CLI 共用一份运行时和字节相同的依赖；应保持整个目录完整，不单独移动 EXE。
+- `GalNet-Sample-<version>-win-x64-r2r.zip`：不含游戏内容，将内容放入同级 `pak/` 后双击 `GalNet.Sample.Avalonia.exe`。
+- `GalNet-Sample-GameTestCase-<version>-win-x64-r2r.zip`：包含位于 `pak/` 的编译 GameTestCase，双击 `GalNet.Sample.Avalonia.exe`。
+- `GalNet-Sample-Contracts-<version>.zip`：与 Sample 匹配的 Core、Contracts.Builtins、GalNet.Project.Contracts 三个 IL DLL，给 Editor 项目使用。
+- 上述 Editor、纯 Sample、整合 Sample 各有一个 `-win-x64-r2r-framework-dependent.zip` 版本，使用系统安装的 .NET；Contracts ZIP 两种部署共用。
+
+应用根只保留入口 EXE 与目录：全部托管依赖、runtimeconfig/deps、原生依赖及自包含运行时位于 `lib/`；`docs/` 保存 README、LICENSE 和 release-manifest.json；Editor 的作者 Skill 保留根 `Skills/`，默认作者契约位于 `lib/DefaultContracts/`。SDK 生成的原生 apphost 直接定位 `lib/<app>.dll`，仍是单个应用进程。Contracts ZIP 是作者 DLL 部署材料，保留原有平铺布局。
+
+默认应用 ZIP（包括 Editor 内嵌 CLI）不分发 PDB；构建目录仍保留调试符号，运行日志照常输出。仅保留 VLC 的 win-x64 原生文件，过滤原生 NuGet 附带的 win-x86 / win-arm64 文件。玩家关闭外部调试与启动参数。契约闭包排除 R2R 转换；内容编译直接使用这一份玩家契约，不另外重建一份。Editor 自带的默认契约与 Sample 契约不同，分别放置。
+
+整合 GameTestCase 经过 `project export-directory` 编译：Graph、Group 和资源均在 `pak/Assets/Paks/*.pak`，可选剧情分片位于 `pak/StoryPatches/<buildId>/`；内部清单、配置、人物和 Gallery 封装为 `pak/game.pak`，内置文本为 `pak/localization.pak`。验收通过分发 CLI 的 `game inspect <content-directory>` 读取版本 3 身份，并拒绝散装 JSON、loose Graph、散装素材、rawgalgroup 和作者 Contracts 目录。`-Galpak` 安装到同一 `pak/`，同时收集归档旁当前 buildId 的剧情包及 ResourcePatches。
+
+完整组合目录如下；没有补丁时仍保留扩展目录，纯 Sample 也提供空 pak/I18n、pak/ResourcePatches、pak/StoryPatches（没有游戏就没有 buildId 子目录）：
+
+```text
+Game/
+  GalNet.Sample.Avalonia.exe
+  lib/                         DLL、原生依赖与运行时
+  docs/                        说明、许可与发行清单
+  pak/
+    game.pak
+    localization.pak
+    Assets/Paks/*.pak
+    StoryPatches/<buildId>/     可选剧情分片，缺省可为空
+    ResourcePatches/            资源覆盖包，缺省为空
+    I18n/                      外置翻译覆盖，缺省为空
+```
+
+Sample 默认使用用户 `LocalApplicationData/GalNet/<project identity digest>/` 保存玩家数据和日志，安装目录无需可写权限。profile 不随安装目录或 buildId 改变；旧存档位置不自动迁移。开发版可用 `--profile` 显式指定。
+
+需要联调时，`Publish.ps1` 或 `Release.ps1` 加 `-SampleFlavor Developer`：Sample 仍使用 Release 优化，开启 `GALNET_GAME_DEBUG` 与 `GALNET_LAUNCH_ARGS`，保留 PDB，ZIP 名追加 `-developer`，发行清单记录 sampleFlavor。默认 `Player`。`Test-Release.ps1` 验收开发包也传入相同选项，Editor/Contracts 名称不变。
+
+完整版无需用户安装 .NET；系统 DLL、Avalonia/Skia/HarfBuzz 与 VLC 视频插件都是体积来源。R2R 保留 IL 并增加预编译代码，不能按 AOT 的体积预期评估。DLL 数量主要来自 VLC 插件，不能仅按扩展名删除；当前保留 x64 插件能力集合。Editor 与 CLI 先独立发布，再将字节一致的重名文件合并到同一目录，依赖冲突会明确失败，不覆盖另一程序的依赖。
+
+每个 ZIP 都有版本/commit/文件哈希清单（应用在 `docs/`，Contracts 在根）。流水线还会重新解压、验证哈希、检查 R2R 标记和契约字节身份、核对部署声明及运行时份数，并执行两种分发 CLI 的 help、创建项目和 schema 查询。可单独运行分发验证，`-DesktopSmoke` 额外检查两种 Editor 初始化及实际加载的运行时路径，并验证玩家在含空格路径、不同工作目录下无参数加载 `pak/`（验证机需安装 .NET 10 x64 Runtime）：
+
+```powershell
+pwsh -File scripts/release/Test-Release.ps1 -Version 0.1.0-dev.1 `
+  -AssetDirectory out/release/0.1.0-dev.1/assets `
+  -WorkDirectory out/release-smoke/dev1 -DesktopSmoke
+```
+
+桌面 smoke 使用分发 CLI 创建并导出唯一项目，复制分发玩家到测试目录，通过其真实默认策略创建唯一用户 profile，准备已完成首次启动的计数。检查 session 初始化日志后终止测试自己的进程，保留日志副本并清理该唯一 profile；不借用现有游戏数据。它验证播放器和目录策略，整合内容另作清单/PAK 检查，不证明完整 GameTestCase 剧情、存读档和音视频全流程验收通过。
+
+## AOT 当前状态
+
+Editor 仅发布 R2R。桌面 Sample NativeAOT 尚未通过严格链接和运行验收；`-SampleMode Aot/Both` 会明确失败，不回退为 R2R。可复现试编译：
+
+```powershell
+pwsh -File scripts/release/Test-DesktopAot.ps1
+```
+
+该诊断构建隔离 RID/AOT 恢复图，不改日常锁文件，最终 ILC/ILLink 警告按错误处理。目前已发现 JSON、反射绑定、主题资源、DI 与第三方裁剪问题。Headless 的 AOT 自检仍见 [NativeAOT 手册](native-aot.md)，不能据此宣称桌面玩家已支持。
+
+## tag、CI 与公开上传
+
+版本 tag 指向已提交 commit：`v1.2.3` 或 `v1.3.0-preview.1`。CI 自动发布同时要求 tag 指向的提交已经包含在主分支 `origin/master` 的历史中；允许为主分支历史提交发版，不要求它仍是最新 HEAD。先合并到 master，再推送版本 tag；只推送 master 提交不会发布，在未合并分支上推送 tag 会被门禁拒绝，之后合并不会自动重跑该 tag 的发布。
+
+精确 tag 构建要求工作区干净、tag 指向 HEAD；不会使用最近祖先 tag 给新提交命名。
+
+```powershell
+pwsh -File scripts/release/Release.ps1 -Tag v1.2.3
+```
+
+Release workflow 在 tag push 后先获取 master 并校验 tag 格式、checkout 身份与提交归属；门禁通过后才运行同一套 CI 和本地发布入口。GitHub 的 branch/tag push 过滤器不能表达两者同时满足，因此主分支归属检查由前置 job 执行。build job 上传已经验证的文件，publish job 下载后上传，不重新编译。普通 PR/master CI 保持原有行为；`workflow_dispatch` 只生成候选文件，不公开上传，也不要求候选分支已合并。
+
+公开上传需要 GitHub 权限和名为 `NUGET_API_KEY` 的 NuGet 发布凭据；可传入 Trusted Publishing 获取的短期 key。当前 workflow 从同名 GitHub secret 读取，首次发布前需配置。在本地也可上传已经验收的精确 tag 索引：
+
+```powershell
+pwsh -File scripts/release/Push.ps1 -Index out/release/1.2.3/release-index.json
+```
+
+Push 先检查索引、全部文件哈希、版本和消费者验收状态；GitHub 目标还在创建 draft 前检查七个发行 ZIP 是否齐全。随后创建 GitHub draft，按依赖顺序上传 NuGet、上传 ZIP，再公开 draft，preview 标记 prerelease。每个成功步骤记录在 `push-state.json`，失败时使用原文件和原 journal 恢复；不跳过未知重复版本，不覆盖公开包。NuGet/GitHub 之间没有事务，上传中断可能留下部分公开 NuGet 包。上传脚本本身不会创建或推送 tag。
+
+## 兼容原有本地应用入口
+
+`Publish.ps1 -Package Editor/Sample/SampleIntegrated/All -Version 1.2.3` 继续可用，默认仍生成旧式 ZIP 文件名，供 Editor 的仓库内导出窗口使用。可选 `-Deployment FrameworkDependent` 生成精简版，名称追加 `-framework-dependent`；默认 `SelfContained`。整合自定义目录或 galpak 的参数保持原语义；完整五包与新索引流程使用 Release.ps1，默认同时生成两种部署。直接运行旧入口不会产生可供 Push.ps1 使用的封存索引。`Test-Release.ps1 -Deployments SelfContained` 可单独验收完整版，默认验收两种部署。
diff --git a/docs/philosophy.md b/docs/philosophy.md
index 0d2d6f7b..5134623d 100644
--- a/docs/philosophy.md
+++ b/docs/philosophy.md
@@ -16,7 +16,7 @@ GalNet 将叙事运行、内容与资源、呈现和具体应用宿主分开。
 flowchart TB
     Content[Graph / .galgroup / 项目设置] --> Runtime[Runtime\n编译内容、Engine、GameState、存档]
     Contracts[Contracts.Builtins\nSchema 与 Composite] --> Runtime
-    Runtime --> Ports[Presentation.Abstractions\nIGameView、Presenter、应用端口]
+    Ports[Presentation.Abstractions\n执行组合、Presenter、应用端口]
     Core[Core\n领域模型与基础契约] --> Contracts
     Core --> Runtime
     Core --> Assets[Assets\nProvider、Archive、AssetManager]
diff --git a/docs/spec/architecture.md b/docs/spec/architecture.md
index ee8df62a..2c30f53c 100644
--- a/docs/spec/architecture.md
+++ b/docs/spec/architecture.md
@@ -2,15 +2,18 @@
 
 ## 分层
 
-`Core` 不依赖 UI、文件系统或 DI。Runtime 只依赖 Core 与呈现抽象；宿主组装文件系统、资源、媒体和页面实现。旧 `GalNet.Storage.Abstractions` 项目已删除。
+`Core` 不依赖 UI、文件系统或 DI。Runtime 的项目依赖只有 Core，不引用呈现抽象或默认执行模块；宿主组装文件系统、资源、媒体和页面实现。旧 `GalNet.Storage.Abstractions` 项目已删除。
 
 ```text
-Core ───────────────────── 领域模型、资源/Gallery registry、服务契约
-Contracts.Builtins ──────── 仅依赖 Core 的内置 schema、参数和 Composite
-Presentation.Abstractions ─ IGameView、presenter 与平台无关应用契约
-GameHost ───────────────── 游戏会话、运行生命周期、玩家持久化与偏好规则
+Core ───────────────────── 通用数据、执行/状态协议、通用资源 registry、服务契约
+Diagnostics ────────────── 可选 Benchmark 构建的 CPU 事件与启动捕获，独立于领域层
+Contracts.Builtins ──────── 内置场景/音频/Gallery/差分图片契约、默认资源、纯算法与 schema
+Presentation.Abstractions ─ 执行注册/恢复组合、presenter 与平台无关应用契约
+GameHost ───────────────── 游戏会话、内容聚合、运行生命周期、玩家持久化与偏好规则
 Avalonia.GameHost ───────── 默认 Avalonia 会话、展示组合、设置 UI 和平台适配
-Media.LibVlc ────────────── 可供不同 UI 框架复用的 LibVLC 音频后端
+Media.Audio ─────────────── 跨平台 PCM 混音与 DSP
+Media.Miniaudio ──────────── 原生设备与流式解码适配（当前实机验证 Windows x64）
+Media.LibVlc ────────────── 视频/Gallery 共用的 LibVLC 生命周期
 Runtime ────────────────── Graph、Compiled Group、Engine、存档状态与宿主端口
 Assets ─────────────────── Local/PAK provider、Archive、AssetManager
 Storage.FileSystem ─────── 项目/安装内容、保存、变量与进度实现
@@ -32,6 +35,9 @@ flowchart TB
     AvaloniaHost --> Host[GameHost]
     AvaloniaHost --> Builtins[Primitives.Builtins]
     AvaloniaHost --> Storage[Storage.FileSystem]
+    AvaloniaHost --> Audio[Media.Miniaudio]
+    Audio --> Mixer[Media.Audio]
+    Mixer --> Contracts
     AvaloniaHost --> Media[Media.LibVlc]
     Host --> Runtime
     Builtins --> Runtime
@@ -42,9 +48,12 @@ flowchart TB
     Media --> Ports[Presentation.Abstractions]
     GameView --> Ports
     GameView --> Rendering[Avalonia.Rendering]
-    Runtime --> Ports
+    Runtime --> Core
+    Ports --> Contracts
     Ports --> Core
     Contracts --> Core
+    Assets --> Contracts
+    Host --> Contracts
     Assets --> Core
 ```
 
@@ -54,17 +63,16 @@ flowchart TB
 
 ```text
 src/
-  Shared/          Core、Contracts.Builtins、Runtime、Assets、Presentation.Abstractions、Primitives.Builtins、GameHost
+  Shared/          Core、Contracts.Builtins、Runtime、Assets、Presentation.Abstractions、Primitives.Builtins、GameHost、Diagnostics
   Presentation/    Avalonia.Controls、Avalonia.Rendering、Avalonia.GameView、Avalonia.Themes、Avalonia.GameHost
-  Infrastructure/  Storage.FileSystem、Media.LibVlc
+  Infrastructure/  Storage.FileSystem、Media.Audio、Media.Miniaudio、Media.LibVlc
   Editor/          Editor.Abstraction、Editor.Shared、Editor、Editor.Headless
   Samples/         Sample.Contracts、Sample.Avalonia、Sample.Headless
-  Launcher/        Launcher 共享项目与 Android、Browser、Desktop、iOS 宿主
 ```
 
 物理分组用于表达查找和所有权，不改变程序集名称、根命名空间或依赖方向。新增生产项目应放入与其职责一致的分组，并同步 `GalNet.slnx`；测试项目统一位于 `test/<Assembly>.Tests`。
 
-程序集拥有自己的根命名空间：展示与执行注册端口位于 `GalNet.Presentation.Abstractions.*`，内置 schema、Entry DTO 与 Composite 位于 `GalNet.Contracts.Builtins`，primitive 和执行 module 位于 `GalNet.Primitives.Builtins`。契约项目只依赖 Core，执行模块按领域共享状态，可依赖 Runtime 的平台无关逻辑（如音频轨道）；Runtime 不反向依赖 Builtins。扩展程序集不得在 `GalNet.Core.*` 下声明类型；Core 只保留领域基础类型和扩展协议。注册的精确规则见[条目类型](entry-types.md)。
+程序集拥有自己的根命名空间：展示与执行注册端口位于 `GalNet.Presentation.Abstractions.*`，内置 schema、Entry DTO 与 Composite 位于 `GalNet.Contracts.Builtins`，primitive 和执行 module 位于 `GalNet.Primitives.Builtins`。契约项目只依赖 Core，执行模块按领域共享状态，可依赖 Runtime 的平台无关逻辑；Runtime 不反向依赖 Builtins。扩展程序集不得在 `GalNet.Core.*` 下声明类型；Core 只保留领域基础类型和扩展协议。注册的精确规则见[条目类型](entry-types.md)。
 
 资源层只向上暴露 `IAssetProvider`、`IArchive`、`IGameFile` 和 `IAssetManager`。provider 定位源文件；manager 负责 GUID 查询、decoder 分派、缓存和 `AssetHandle<T>` 生命周期。Core、Runtime 与 Editor.Shared 不引用 Avalonia。
 
@@ -76,23 +84,23 @@ src/
 开发项目 ── ProjectGameContentProvider ── .meta -> GalleryCatalog
            LocalFileProvider(Assets/) ───── GUID -> raw bytes
 
-安装目录 ── InstalledGameContentProvider ─ generated gallery.json + Graph/
+安装目录 ── InstalledGameContentProvider ─ game.pak / localization.pak / 外置 I18n
            PakFileProvider(Assets/Paks/**/*.pak) ─ GUID -> PAK bytes
 ```
 
-`.galpak` 只是 ZIP 运输容器。`GameInstallation` 验证并解压后，内容 provider 读取 Graph/settings/I18n/gallery 等特殊文件；只有 PAK 会成为资源 provider。详见 [资源](assets.md) 与 [文件格式](file-formats.md)。
+`.galpak` 是带 `pak/` 外层的 ZIP 运输容器。v3 固定入口 game.pak 包含安装清单、content 描述、设置、人物和 Gallery 等内部文档；localization.pak 每种语言一个逻辑文本条目。`GameInstallation` 验证并安装后，Storage 从文档包构造中立内容对象，Graph/Group 从普通资源 PAK 加载。文档包使用 Assets 的独立固定 document 类型目录，不贡献普通资源 provider，也不受资源补丁替换。旧 v1/v2 galpak 与 content v2 散文档读取保持兼容。桌面 Sample 默认选择应用同级 `pak/`，应用根与托管依赖所在的 `lib/` 分离；此定位策略属于 Sample 组合根，不进入共享内容加载器。详见 [资源](assets.md) 与 [文件格式](file-formats.md)。
 
 ## 游戏运行
 
 可选 `GalNet.Debugging` 组件提供本机长度帧 JSON 连接、会话/内容身份校验、App 服务和借用的运行绑定。组件可以引用 Runtime，Runtime 不反向依赖通信。App 的调试连接与当前游戏运行独立，开始回调可省略；Editor/Sample 的默认交互接入仍按 feature 后续阶段推进。
 
-`GameEngine` 持有 `IGameRuntime`，解释图、条目、Choice、skip batch 和快照；它不认识具体 UI。Engine 统一报告运行状态，负责停止、取消执行 scope 和等待内部 continuation 退出，不拥有执行 view 或平台后端。`IGameView` 解析 entry schema、创建 primitive instance 并调用 presenter 端口。影响场景的 primitive 先写入 `GameState`，再通知呈现端；读取快照后由宿主调用注册式 StateRestoreSession。
+`GameEngine` 持有 `IGameRuntime`，解释图、条目、Choice、skip batch 和快照；它不认识具体 UI。Engine 统一报告运行状态，负责停止、取消执行 scope 和等待内部 continuation 退出，不拥有执行 view 或平台后端。`IPrimitiveDispatcher` 解析 entry schema、创建 primitive instance 并调用 presenter 端口。影响场景的 primitive 先写入 `GameState`，再通知呈现端；读取快照后由宿主调用注册式 StateRestoreSession。
 
-Avalonia 展示按领域拆为 dialogue/choice、layer、animation 和 particle presenter；`AvaloniaGamePresenters` 只创建并暴露这些 presenter，`CompositeGameView` 组合独立的 schema catalog 与执行模块，提供 Runtime 使用的 `IGameView`。`GameHost.GameSession` 串行化准备、开始、存档回调、运行替换与停止，拥有可替换的 `IGameRun`；默认 `GameRun` 组合 Engine 与展示恢复，不注册任何 Builtins，也不要求 Layer Presenter。`PlayerSession` 协调玩家持久化，`PlayerPreferences` 和 `PlayerStartup` 提供偏好与首次启动规则。文件实现通过 `GameResourceScope` 和 `FilePlayerSession` 组合。
+Avalonia 展示按领域拆为 dialogue/choice、layer、animation 和 particle presenter；`AvaloniaGamePresenters` 只创建并暴露这些 presenter，`CompositeGameView` 组合独立的 schema catalog 与执行模块，提供 Runtime 使用的 `IPrimitiveDispatcher`。`GameHost.GameSession` 串行化准备、开始、存档回调、运行替换与停止，拥有可替换的 `IGameRun`；默认 `GameRun` 组合 Engine 与展示恢复，不注册任何 Builtins，也不要求 Layer Presenter。`PlayerSession` 协调玩家持久化，`PlayerPreferences` 和 `PlayerStartup` 提供偏好与首次启动规则。文件实现通过 `GameResourceScope` 和 `FilePlayerSession` 组合。
 
-`Avalonia.GameHost` 提供可直接使用的 `AvaloniaGameSession`、页面绑定 `AvaloniaGameRun`、展示组合 `AvaloniaGamePresentation`、纹理租约 `AvaloniaGameResources` 以及默认设置/窗口/手柄适配。`AvaloniaGameHostOptions` 由项目提供 catalog 和执行注册，预加载策略可替换；`AvaloniaGamePresentationOptions` 可替换 Layer 工厂与音频后端，新建适配对象的所有权交给展示会话。Sample 只保留启动参数、项目策略、本地化适配与调试扩展。
+`Avalonia.GameHost` 提供可直接使用的 `AvaloniaGameSession`、页面绑定 `AvaloniaGameRun`、展示组合 `AvaloniaGamePresentation`、纹理租约 `AvaloniaGameResources` 以及默认设置/窗口/手柄适配。`AvaloniaGameHostOptions` 由项目提供 catalog 和执行注册，预加载策略可替换；`AvaloniaGamePresentationOptions` 可替换 Layer 工厂与音频后端，新建适配对象的所有权交给展示会话。Sample 只保留启动参数、项目策略、本地化资源配置与调试扩展；默认本地化服务归 Avalonia.GameHost，中立 JSON 文本源适配归 GameHost。
 
-会话、显示能力和 Gallery 路径契约位于 `Presentation.Abstractions.Application`。共享 LibVLC 音频后端位于 `Media.LibVlc`，不引用 Avalonia；视频画面适配仍位于 Avalonia。释放顺序为运行/Engine → 展示恢复与执行 view → 平台后端 → Gallery 媒体与玩家持久化 → 纹理租约 → 内容资源。
+会话、显示能力和 Gallery 路径契约位于 `Presentation.Abstractions.Application`。剧情音频的混音/DSP 位于 `Media.Audio`，原生设备/解码适配位于 `Media.Miniaudio`，均不引用 Avalonia。Miniaudio 使用 UTF-8 路径和静态原生回调，提供 Windows x64/ARM64 构建选择及跨平台 CMake 入口；当前实机验证 Windows x64，其他平台需要宿主部署对应原生库并验收。`Media.LibVlc` 保留视频/Gallery 的原生运行时，接受平台初始化工厂；剧情视频通过 `IVideoPresenter` 和 `AvaloniaGamePresentationOptions.CreateVideoPresenter` 替换，缺省仍为 Avalonia LibVLC 像素输出。自定义视频适配器由展示会话拥有，优先异步释放。释放顺序为运行/Engine → 展示恢复与执行 view → 平台后端 → Gallery 媒体与玩家持久化 → 纹理租约 → 内容资源。
 
 Gallery catalog 是平台无关的静态内容。宿主把其自动生成的 `gallery_<item-id>_unlocked` Player bool 注册到变量服务；`GalleryDataSource` 合并 catalog 与当前 Player 值。Gallery 解锁不存于独立 UI 状态或存档槽。
 
@@ -100,21 +108,25 @@ Avalonia GameView 通过精确 Gallery `typeId` 的 `IGalleryPageRegistry` 选
 
 ## 编辑器工作流
 
-`EditorProjectDocument` 是 UI 无关的图、Group、设置编辑聚合。资源 metadata 属于 `Assets/`；Gallery annotation 不进入 Editor document，也不存在集中式 Gallery authoring 文件。预览编译 Raw Group，并用当前项目的 metadata 和共享 catalog 构建 `GameContent.Gallery`。
+`EditorProjectDocument` 是 UI 无关的图、Group、设置编辑聚合。资源 metadata 属于 `Assets/`；Gallery annotation 不进入 Editor document，也不存在集中式 Gallery authoring 文件。运行测试通过外部游戏调试构建正式内容并启动独立游戏进程；Editor 不再保留内嵌游戏 Engine、游戏呈现会话或运行变量副本。
 
-GUI 的 `IEditorDocumentService`、变量定义服务和 `EditorDockFactory` 由项目 scope 持有。项目打开时加载作者 Graph/Group 一次；Group 以稳定 ID 和独立源路径登记为 `EditorGroupDocument`，项目级 `EditorGroupProjectionStore` 缓存可观察投影。Graph 节点、边、分支项直接引用作者 DTO，Group 页面以 ID 打开，页面关闭只释放订阅，不丢弃未保存内容。`EditorEntryData.Parameters` 保留原始 JSON 值；字符串仅用于控件和既有 CLI 输入适配。变量声明以 Graph 为权威，保存 settings 时派生所需副本。
+GUI 的 `IEditorDocumentService`、变量定义服务和 `EditorDockFactory` 由项目 scope 持有。项目打开时加载作者 Graph/Group 一次；Group 以稳定 ID 和独立源路径登记为 `EditorGroupDocument`，项目级 `EditorGroupProjectionStore` 缓存可观察投影。Graph 节点、边、分支项直接引用作者 DTO，Group 页面以 ID 打开，页面关闭只释放订阅，不丢弃未保存内容。`EditorEntryData.Parameters` 保留原始 JSON 值；字符串仅用于控件和既有 CLI 输入适配。变量声明只保存在 Graph 的 playerVariables/saveVariables，settings 不再维护或派生变量副本。文档仓库仅接收项目路径，不消费设置模型或额外项目名称。
 
 Editor 随发行包提供默认契约模板，新建项目不需要用户准备 DLL；留空自定义契约目录时，自动将默认契约复制到项目 `Contracts/`。新项目随后使用同一项目契约加载路径，自定义目录仅供需要自定义 schema 的项目选择。打开已有项目不会用该模板替换缺失或损坏的契约。
 
-Editor 要求显式且唯一的 Entry 根节点，无效图不会被样例图替换或在加载时补节点。当前工作区暂不注册游戏预览面板，预览接入另立后续 feature。
+Editor 要求显式且唯一的 Entry 根节点，无效图不会被样例图替换或在加载时补节点。旧内嵌游戏预览已移除；旧布局中的游戏预览项作为不可用面板清理。
 
 Editor 内容历史采用项目单栈，不随 Dock/Inspector 焦点切换；设置页首先接入显式草稿提交。GUI 的 `ProjectContentSession` 统一捕获并发布 Graph、Group 与完整设置，以实际内容与保存基线判断 dirty，后续编辑不被异步保存误标为已保存。关闭提供保存全部/放弃未保存内容/取消。作者文件事务的 manifest/备份与周期作者快照位于 `.galnet/editor/`，补偿失败禁止继续写入。Graph 基本操作由项目数据编辑记录承担，页面按文档事件同步投影；Group 创建/删除复用 Working/Saved 结构计划。分支/条目旧记录和完整 Group 草稿继续按后续阶段迁移，见 [Graph 基础编辑](editor-graph.md)；当前语义及边界见 [Editor 项目历史与保存](editor-history-and-save.md)。
 
 CLI 只做参数、结果协议和退出码适配；Shared 提供原始查询、无写回校验、定向编译、严格编辑/保存、项目/Group 生命周期服务。原始访问保留未知内容，不依赖 entry DLL；有语义的操作使用项目 Contracts DLL，不回退内置。Editor 的 ProjectSchemaSession、catalog 及文档消费者由项目 scope 持有。不提供项目目录删除功能；最近项目列表仅支持移除记录。当前接口及范围见 [CLI README](../../src/Editor/GalNet.Editor.Headless/README.md)。
 
-`EditorAssetManager`、`EditorGameDataProvider`、`AssetCatalogService` 与 `GameExportService` 共享 Editor 组合根的 catalog。导出把资源写入基础 PAK，把 Graph/settings/I18n 和派生 Gallery JSON 写入 `.galpak`。
+`EditorAssetManager`、`AssetCatalogService` 与 `GameExportService` 共享 Editor 组合根的 catalog。导出把 Graph/Group 与资源写入基础/剧情 PAK，把内部 JSON 和内置文本分别封装为 game.pak、localization.pak，再将本体装入 `.galpak`；安装目录的 I18n 仅作为外置翻译入口。
 
-`EditorWorkspaceViewModel` 保留可观察 UI 状态、命令编排、history checkpoint 和自动保存触发。`GraphSelectionState` 维护节点/边选择与 `IsSelected` 一致性；`EditorWorkspacePersistence` 组合 repository、document service、mapper、save coordinator 与 project service 完成图的加载、保存和 Preview 数据构建。内置 Editor 命令由单一 handler 入口分派，Graph、Entry、Variable 和 Project 实现按领域分文件维护。
+`EditorWorkspaceViewModel` 保留可观察 UI 状态、命令编排、history checkpoint 和自动保存触发。`GraphSelectionState` 维护节点/边选择与 `IsSelected` 一致性；`EditorWorkspacePersistence` 组合 repository、document service、mapper 与 project service 完成图的投影加载和保存。Graph 集合以只读可观察集合公开，只有作者操作可以改变文档成员；Group 作者操作返回稳定 Entry ID，由界面解析投影。字段工厂直接查询变量声明，不通过 Workspace。GUI 与 Headless 共用 `GraphEditRules` 的名称、坐标与连接规则，空分支没有出口。内置 Editor 命令由单一 handler 入口分派，Graph、Entry、Variable 和 Project 实现按领域分文件维护。
+
+`Shell.EditorLayoutSession` 拥有布局恢复、命名布局和延迟持久化；`EditorMenuBuilder` 构建菜单，页面负责绑定与交互编排。`ProjectContentSession` 统一协调事务，草稿参与者由 `ProjectDraftRegistry` 管理，保存快照与内存内容比较由 `ProjectContentBaseline` 管理。比较不会为了读取 dirty 反复序列化或克隆整个项目，也不依赖历史游标或通知是否遗漏。
+
+外部调试的 `ProjectDebugPreparation` 负责保存、构建与监听准备；`ProjectContentBuilder` 同时返回实际编译内容的 SourceMap 和作者指纹。`ExternalGameDebugClient` 管理连接和请求，`DebugApplicationProcess` 管理启动、退出和输出监控；断开后继续排空进程输出的行为保留。
 
 Editor 扩展 registry 通过非泛型 `IDockPanelContribution` 和 `IInspectorControlContribution` 保存异构贡献，`object` 只存在于该类型擦除边界。新 contribution 应优先继承 `DockPanelContributionBase<TViewModel>`、`DockPanelContributionBase<TViewModel, TParameter>` 或 `InspectorControlContributionBase<TDockViewModel, TInspectorViewModel>`，由 bridge 集中校验 parameter、dock ViewModel 和 inspector ViewModel 类型；错误类型会在贡献边界报告预期与实际类型。`IServiceProvider` 继续表示全局或当前项目 scope，view 继续返回 `object` 以避免 Editor.Abstraction 引用 Avalonia。内置 panel 和 inspector contribution 均使用这些强类型入口。
 
@@ -150,6 +162,16 @@ Integration 测试只承载必须联合多个外层实现的场景；单一生
 
 Runtime 的 GraphLoader/GalgroupLoader/SaveManager 仅解析和序列化内容；文件路径和 I/O 由外层内容 provider、宿主和 ISaveService 实现处理。
 
+Engine 的导航索引持有验证后的私有图副本，不共享作者集合或可变条目。外部变量读取返回独立值；执行模块共享的场景记录仍统一在 GameState.Read/Update 边界访问，不跨程序集暴露锁对象。
+
+执行模块/呈现端借用 Core.Runtime.IGameContext；Engine 管理能力 IGameRuntime 与恢复候选 GameRestorePoint 属于 Runtime.Runtime。Core.Execution 拥有 IPrimitiveDispatcher、IChoicePresenter、ICatchUpPresentation 和 IPlayerPlaybackController，这些协议只包含中立执行数据；音频后端端口 IAudioPlaybackHost 与音频协议属于 Contracts.Builtins.Audio，音频执行、队列和票据属于 Primitives.Builtins.Audio。注册、分发及展示恢复组合仍位于 Presentation.Abstractions，具体 presenter 端口仍位于其 View。编辑器主题、Dock、快捷键、最近项目及嵌入布局 JSON 编码属于 Editor.Abstraction.Settings；Core 不持有这些宿主配置，未使用的 LauncherSettings 已删除。
+
 展示执行抽象的 StateRestoreSession 拥有重放 continuation；宿主在执行 view 和平台 presenter 释放前异步释放该会话。Suspend 等待取消后仍保留旧实例，下一次重放或释放会继续等待真实展示清理。
 
+Engine 只接收/更新 PlaybackOptions，音频接收不可变 AudioConfiguration Bus/Track 声明和 AudioMixOptions 的 master/bus/track 混音值，不依赖完整玩家设置或运行上下文的设置容器。默认玩家偏好模型 GameSettings 位于 Avalonia.GameHost.Settings，通过组合根投影为模块输入；通用 PlayerSession 只持有玩家持久化与进度，不持有该偏好模型。清空玩家数据后由默认宿主重新绑定默认偏好。Editor 没有另设未使用的游戏偏好服务。Core.Configuration 只定义版本化 ProjectConfiguration/ConfigurationSection 协议；GameContent、GalProject 和作者文档使用 Configuration，不再绑定固定 ProjectSettings。默认项目 DTO DefaultProjectOptions 位于可选 Contracts.Builtins，默认模板/Sample 显式选择其 schema；Storage 通过 GameContentLoadOptions 接收 schema 和文化代码投影，运行模块仍接收小配置。Editor 按项目 schema 生成通用 section 表单，批量提交、Undo/Redo、保存、导出和安装加载保留未知配置；默认语言声明由 I18n 面板编辑。宿主通过 SelectProjectOptions 显式投影，自有 DTO 控制模块输入；调试使用外部游戏宿主。
+
 运行与宿主资源的依赖及生命周期以本页的游戏运行段和[运行时规范](runtime.md)为准，包括 GameView 对 Assets 的媒体 adapter 默认实现依赖。
+
+场景/音频领域类型及纯算法位于可选 Contracts.Builtins.Scene/Audio。IGameContext 和 GameRuntime 不提供 SceneInstances；内置视觉模块通过 runtime.Scene() 访问按 GameState 根隔离的场景服务，临时动画控制不进入快照。StateCatalog 的可选 keySpace 提供跨表唯一性和查询，Core 只处理通用身份，不认识 ISceneInstance；内置视觉状态显式选择 builtin.scene。Runtime 仅引用 Core，最小自定义 primitive 不需要场景或音频模块。
+
+GameContent、GameContentLoadOptions 和 GameLocalizationContent 属于 GameHost.Content；GalleryDataSource 属于 GameHost.Gallery。它们是宿主选择的默认内容/玩家组合，Engine 不依赖这些聚合。Core.Assets 只保留通用 metadata、资源类型目录、查询与租约协议；默认 DTO/工厂和 Gallery/ImageVariants 数据属于 Contracts.Builtins。资源目录的默认类型由组合根显式选择，provider 和 PAK 接收该目录，不自行创建 Builtins。没有专属字段的默认资源复用 AssetMeta，sprite 另有 filter DTO。
diff --git a/docs/spec/assets.md b/docs/spec/assets.md
index 78ab32db..542849ab 100644
--- a/docs/spec/assets.md
+++ b/docs/spec/assets.md
@@ -16,11 +16,18 @@
 ```
 
 - `id` 是非空、全项目唯一的稳定资源 ID；推荐使用 GUID，但当前 codec 不限制其字符串形态。
-- `type` 是资源类型 ID；组合根通过冻结的 `IResourceTypeCatalog` 将其映射到具体 `AssetMeta` DTO。内置类型为 `sprite`、`image-variants`、`audio`、`video`、`font`、`effect-program` 和 `data`。
+- `type` 是资源类型 ID；组合根通过冻结的 `IResourceTypeCatalog` 将其映射到具体 `AssetMeta` DTO。内置作者资源类型为 `sprite`、`image-variants`、`audio`、`video`、`font`、`effect-program` 和 `data`；`graph`、`group` 用于编译生成的剧情资源。
 - `path` 相对 `Assets/`；provider 会以实际逻辑路径校正缺失或过时的值。
 - 可选字段缺失时使用 DTO 默认值；未知字段保存在 extension data，供 Editor 重写时保留。未知 `type`、无效 JSON、缺失 GUID 或缺失源文件是加载错误，不能静默跳过。
 - `gallery` 是 Gallery 的唯一作者真源。每项使用全局唯一正整数 ID；没有 `sortOrder` 或项目根可编辑 `gallery.json`。
 
+
+通用 `AssetMeta` 与类型目录协议位于 Core.Assets；`BuiltinResourceTypes`、sprite metadata 及默认 Gallery/ImageVariants 契约位于 Contracts.Builtins。没有专属字段的默认资源共用 AssetMeta，身份由 type ID 决定。Gallery 用可选 ReadGallery/SetGallery 扩展读取、重写 extension data，未知 annotation 字段也保留。
+
+资源注册可显式传入 JSON resolver，`AssetMetaCodec` 按注册类型组合源生成元数据并缓存 options；默认实例由注册时的泛型工厂创建，`Add/Replace<TMeta>` 要求公开无参构造函数。内置目录已提供元数据；反射关闭的玩家扩展须注册自己的 context，见 [NativeAOT 手册](../manual/native-aot.md)。
+
+组合根可通过 `ResourceTypeCatalogBuilder.DefaultType(id)` 为未知扩展选择默认类型；没有显式 type、扩展映射或该默认值时才报无法解析类型。默认工厂明确选择 data，低层 codec 不假定 data 必须存在。LocalFileProvider、PakFileProvider、Archive 和 PakBuilder 必须接收调用方目录；例如 `PakBuilder.Build("assets", files, types)`，压缩模式为后续可选参数。
+
 资源类型只负责识别、保存、枚举和打包；它不注册 decoder、Editor inspector 或 Avalonia 页面。decoder 以 `(typeId, target CLR type)` 另行注册。
 
 Editor 将原始资源与 sidecar 作为一次项目文件编辑：移动保留 ID 并重定位 path，导入/复制生成新资源 ID，保留 Gallery 内容与 metadata 扩展；Gallery ID 与项目/同批内容冲突时为副本重新分配正整数 ID，type/title 保持原值；无法无损类型化的 metadata 拒绝重写。资源索引刷新只读，不负责补建 sidecar。GUI 操作支持项目历史撤销，CLI 共用事务而不保留 GUI 历史，见 [Editor 项目文件操作](editor-files.md)。
@@ -41,20 +48,56 @@ IAssetProvider / IArchive / IGameFile
 
 ## 来源与发布边界
 
+目录导出与 `.galpak` 导出共用一份导出准备流程：在私有暂存内容上加载资源、编译图集与 Gallery、生成 PAK 和清单，随后由各自写出方式发布。资源编译结果在暂存目录移动前转为自有字节，不缓存指向旧目录的文件对象。普通 build 同样在暂存内容上检查图集，资源准备失败不会替换旧输出；最终产物的哈希及归档校验仍在发布前执行。
+
 | 输入 | 内容 provider | 资源 provider |
 | --- | --- | --- |
-| 开发项目目录 | `ProjectGameContentProvider` 读取 `Graph/`、`settings.json`、`I18n/`，并从 `Assets/**/*.meta` 编译 Gallery | `LocalFileProvider(Assets/)` |
-| 已安装包目录 | `InstalledGameContentProvider` 读取 `Graph/`、`settings.json`、`I18n/` 和生成的 `gallery.json` | 所有 `Assets/Paks/**/*.pak` |
+| 开发编译目录 | `ProjectGameContentProvider` 经资源 ID 加载剧情，读取 settings/I18n，并从 Assets metadata 编译 Gallery | `CompiledStoryAssetProvider(Graph/)` + `LocalFileProvider(Assets/)` |
+| 已安装包目录 | `InstalledGameContentProvider` 读取 `content.json` 唯一 Graph 入口并按资源 ID 加载剧情，读取 settings/I18n 和生成的 gallery | 清单声明的完整基础/剧情 PAK，经 ResourceOverlayProvider 应用独立资源覆盖 |
 
 同一宿主在创建内容 provider、资源 provider、Preview 与导出器时必须传入同一对冻结 `IResourceTypeCatalog` / `IGalleryTypeCatalog`。不能在下游入口重新创建 built-in catalog，否则插件注册无法贯穿完整路径。
 
-安装内容的 PAK 按相对路径倒序注册；更靠后的路径优先，因此 `100-extra.pak` 可覆盖 `000-base.pak`。`Graph/`、`I18n/`、`settings.json`、生成的 `gallery.json` 和 manifest 是特殊内容，永不注册为资源 provider。
+基础 PAK 只按清单装载，文件名排序不贡献覆盖。独立 override PAK 使用显式映射和 priority/hash 排序。`I18n/`、`settings.json`、生成的 `gallery.json`、`content.json` 和 manifest 是特殊内容。发行 Graph/Group 作为资源进入 PAK，不从 loose Graph 目录回退读取。
+
+项目仍只有一张 Graph，清单指向保留 ID `galnet:graph:main`；Group 正文 ID 为 `galnet:group:<稳定节点ID>`，与节点身份分开。两种资源使用 `DependentAssetMeta`。这些 metadata 由编译适配层生成，不需要在作者目录补 sidecar 或新增选图配置；自定义发行资源目录也须注册 graph/group 的 DependentAssetMeta。`CompiledStoryResources` 为发布和开发适配生成同一剧情 payload，开发 provider 按会话持有不可变快照。开发输入需已有编译 Group，缺少正文不再静默当空 Group。
+
+Group 依赖从编译后 primitive 参数的字段契约收集。`FieldAttribute.ResourceTypeId` / `FieldDescriptor.ResourceTypeId` 明确声明字符串字段为资源 ID；源生成器与结构遍历保留该声明，不从 EditorId、GUID 外形或任意字符串推断。opaque 结构或 custom.invoke 无法证明静态引用完整时，metadata 标记为不完整。开发 provider 没有编译 schema 上下文时不伪造非空 Group 的完整依赖，发行编译使用调用方 catalog 提供分析结果。
 
 ## PAK
 
-`.pak` 当前版本为 2，使用 `GPAK` magic。每个表项保存 UTF-8 GUID、逻辑路径、字符串 type ID、注册 DTO 序列化的 metadata JSON、数据偏移、原始/存储长度、压缩模式与 SHA-256。读取时 metadata 的 GUID、路径和 type ID 必须与表项一致，否则包无效。
+`.pak` 当前版本为 3，使用 `GPAK` magic。magic/version 后写入长度前缀的 UTF-8 控制 JSON，再写条目数量、资源表及连续数据块。每个表项保存 UTF-8 GUID、逻辑路径、字符串 type ID、注册 DTO 序列化的 metadata JSON、数据偏移、原始/存储长度、压缩模式与 64 字符小写十六进制 SHA-256。读取时 metadata 的 GUID、路径和 type ID 必须与表项一致，重复 ID/逻辑路径、非法范围和尾随数据拒绝；读取资源时验证实际载荷长度与 SHA-256。
+
+控制描述 `PakDescriptor` 的 `kind` 为 `base`、`story` 或 `override`，与资源 `typeId` 独立。共用 PAK 格式，未知 kind/控制字段、重复控制属性和不支持的版本拒绝。story 描述需要项目、基础构建和包身份及合法分片序号；override 需要包身份、单分片、整数 priority 和资源映射表，映射目标必须在本包内。base/story 不能携带 priority 或覆盖映射；`Archive.Descriptor` 返回隔离的映射快照。旧调用省略 descriptor 时生成匿名 base 包，游戏级构建身份由上层提供。
+
+默认安装内容加载器通过 `InstalledPackageSet` 验证剧情包集合，并通过 `ResourceOverlayProvider` 应用资源映射。自定义宿主须接入相同内容视图；仅扫描任意 PAK 文件不足以实现包的用途语义。
+
+数据块可使用 `none`、`deflate`、`gzip` 或 `brotli`；`PakBuilder` 默认选择 Brotli，并会跳过过小数据的压缩。写出按资源 ID 稳定排序，重新计算实际 payload 的 hash，不沿用可能过时的 IGameFile.Hash；控制映射按原 ID 排序，无归档名/时间戳写入。旧 enum PAK 和 v2 格式不受支持，需重新导出。
+
+## 资源依赖 metadata
+
+有依赖的 metadata DTO 可实现 Core 的 `IAssetDependencies`，返回直接引用列表及 `Complete`。`DependentAssetMeta` 提供可序列化的 `Dependencies` / `DependenciesComplete`；payload 编译器在同一快照生成依赖，不自动回写作者 sidecar。叶类型通过 `ResourceTypeCatalogBuilder.WithoutDependencies(...)` 明确声明；既没有接口也未声明叶类型时，按依赖分析不完整处理。内置 sprite、audio、video、font、effect-program 声明为叶；data 未默认视为无依赖。
+
+`AssetDependencyCollector` 按规范化资源 ID 收集闭包，检查缺失与预期类型、处理循环、支持取消，返回稳定排序的资源与不完整项，不负责切包或运行时 acquire。构建入口可给出已经由人工依赖声明覆盖的不完整资源 ID；该声明只确认分析完整性，不自动增加资源根。只有 graph 的直接引用可以携带 `RequiredStoryPackage`，仅在收集对应剧情包时跨入；普通必需资源缺失不能静默忽略。
+
+图集有效 metadata 使用 `DependentAssetMeta`，包含编译定义中全部 sprite ID，引用预期类型为 sprite。PAK 写出和打开时检查依赖与图集 payload 一致；本地目录扫描不为此修改源 `.meta`。缺少这些依赖 metadata 的旧编译图集必须重新构建。
 
-数据块可使用 `none`、`deflate`、`gzip` 或 `brotli`；`PakBuilder` 默认选择 Brotli，并会跳过过小数据的压缩。旧 enum PAK 格式不受支持。
+## 内容分包规划
+
+`ContentPackagePlanner` 先收集唯一 Graph、全部非补丁 Group 和额外根的闭包 B；每个剧情包独立取 C(P)−B，不扣除其他剧情包。基础 Gallery 项和默认视觉程序绑定也作为根。未知依赖必须由 `galnet.packaging` 的 includeResources 补根，并用 declaredCompleteResources 显式确认覆盖；后者可写资源 ID 或 Group 节点 ID，不会自动补根。
+
+每个集合按资源 ID ordinal 排序，以未压缩编译载荷的累计 Length 切片。maxPakBytes 缺省 128 MiB，是软目标，超限单项独占，不拆资源；PAK 头部、压缩和索引开销不计入阈值。分片逐个写到私有磁盘阶段，不同时保留全部 PAK 字节。当前 Archive 仍以内存打开单个 PAK，目标大小不是内存上限。
+
+只有闭包中的资源进入 PAK。图集包含全部声明图片、条件分支包含所有静态引用；UI/自定义运行代码的资源需显式补根。源资源校验仍覆盖整个目录，未被打包的坏作者资源也可能阻止构建。安装校验本体和每个剧情包的独立依赖闭包，重复 ID 的内容和 metadata 必须一致。
+
+## 独立资源覆盖
+
+`ResourceOverrideBuilder.Build(projectId, definition, available, types)` 验证作者 A/B 均存在且类型相同，生成单个 override PAK；映射和资源稳定排序，同内容重复导出 hash 稳定。`ResourceOverrideExporter.ExportAsync` 从 Assets 私有快照独立导出，不编译剧情、不要求 galpak、不写源 sidecar，失败/取消不替换旧目标。
+
+`ResourceOverlayProvider` 是冻结的统一逻辑资源视图。A→B 直接绑定包内 B，一次请求只查映射一次，A→B/B→C 不把 A 串成 C。有效文件保留原 ID/路径，metadata 和字节来自替换资源；ID、路径、解码和媒体实体化因此一致。图集替换保留原维度键和全部原变体键，可增加变体；递归图片由覆盖包提供，后续图片请求可再独立命中显式映射。
+
+夹带资源不会隐式覆盖本体同 ID。递归依赖若与本体/其他有效来源同 ID 却内容或 metadata 不一致，准备期拒绝，作者须为改动资源分配新 ID，再显式映射。直接替换目标 B 的来源被明确绑定，对原 B 的独立请求仍按自身映射或本体解析。有效视图和 manager 缓存限定于该安装会话；源文件定位继续使用作者目录。
+
+映射后的文件通过可选 IAssetOverrideFile 保留运行来源，图集目录记录采用覆盖的逻辑图集。图集 Layer 存档保留选择意图和 UsesResourceOverride 标记；安装或移除兼容覆盖时，在候选恢复状态中按当前图集重算显示图片，不改输入存档或旧运行状态。普通未覆盖内容不一致仍拒绝。自定义包装 provider 若替换 IGameFile 对象，应保留该来源标记。
 
 ## 图片差分资源
 
@@ -72,13 +115,13 @@ IAssetProvider / IArchive / IGameFile
 }
 ```
 
-folder 相对描述文件，允许 `.` 和不越过 Assets 的 `..`，兼容两种目录分隔符。仅收集指定目录直接包含的 sprite，不递归其子目录；空目录或缺省默认图无效。图片文件主名按 `_` 划分有序维度，空段、主名跨扩展名重复及仅大小写不同的变体键均无效。dimensions 可省略以生成 d1/d2 等位置 key；选项及变体按 ordinal 稳定排序，维度和值本身采用精确比较，不做大小写或空格归一化。
+folder 相对描述文件，允许 `.` 和不越过 Assets 的 `..`，兼容两种目录分隔符。仅收集指定目录直接包含的 sprite，不递归其子目录；空目录或缺省默认图无效。图片文件主名按 `_` 划分有序维度，空段、主名跨扩展名重复及仅大小写不同的变体键均无效。实际维度数量始终等于图片主名的最大段数。dimensions 仅命名对应位置，可省略；已有 key/label 保留，未命名的新位置生成 d1/d2 等 key，冲突时追加下划线，超出实际数量的命名保留于作者文件但不生成活动维度；选项及变体按 ordinal 稳定排序，维度和值本身采用精确比较，不做大小写或空格归一化。
 
 `LocalFileProvider` 先读取资源文件和 sidecar 的同一目录索引，再通过 `LocalAssetCompiler` / Core 的纯定义构建器编译所有图集；不会补建 metadata。目标目录内的 sprite 必须已有正常资源 ID 和正确类型，缺图、缺 sidecar、坏 default、坏描述等拒绝该归档，而不是略过错误变体。目录树和祖先路径不允许经过链接/重解析点。扫描刷新、取消和销毁具有代次检查；`Invalidate()` 可在已知作者修改后显式使目录索引失效。已经返回的编译字节属于该次快照；持有中的解码句柄仍遵循一般 AssetManager 缓存语义，不承诺原地热更新。
 
 编译后的 IGameFile 保留图集自身 ID、逻辑路径、类型和 metadata，payload 为 `kind="image-variants"`、version=1 的定义，包含维度 key/label、default 和各变体 key/sprite ID，不含 folder。解码后重新校验并建立不可变 `ImageVariantsDefinition`，选项从变体事实推导。`ImageVariantsCodec` 严格拒绝未知/重复 JSON 属性；作者描述不能当作发行 payload 解码。
 
-`PakBuilder` 直接打包本地归档的编译结果及正常 sprite，PAK 格式仍为 2。导出和包内验证沿用调用方的同一 resource catalog；从 PAK 读取定义无需原始图片文件夹。`project.validate`（项目范围，包括 structure-only）与 build 校验该资源，业务错误报告 `variants.invalid`；原始目录索引刷新不写作者文件或 dirty 状态。
+`PakBuilder` 直接打包本地归档的编译结果及正常 sprite，PAK 格式为 3。导出和包内验证沿用调用方的同一 resource catalog；从 PAK 读取定义无需原始图片文件夹。`project.validate`（项目范围，包括 structure-only）与 build 校验该资源，业务错误报告 `variants.invalid`；原始目录索引刷新不写作者文件或 dirty 状态。
 
 解码注册仍与类型注册分离。使用 Assets 中的 `RegisterImageVariantsDecoder()` 扩展方法注册 `(image-variants, ImageVariantsDefinition)`，默认 Avalonia 游戏宿主与项目级 EditorAssetManager 已接入；自定义宿主覆写 decoder 配置时需自行注册。编辑器资源刷新重建内部 manager 时重新注册该 decoder。
 
@@ -88,4 +131,16 @@ folder 相对描述文件，允许 `.` 和不越过 Assets 的 `..`，兼容两
 
 ## 后端媒体文件租约
 
+`PakStreamProvider` 使用宿主显式提供的归档名 → 新流工厂清单打开 PAK，适用于应用包、嵌入资源等没有普通文件路径的来源。`Exists` 仅查询清单；每次打开独立拥有并释放流，读取不要求 Length/Position/Seek。同步与异步入口均在返回前读完 PAK，保持当前 Archive 的内存加载语义；异步复制支持取消。工厂应返回位于 PAK 起始位置的新可读流，不得共享已借用流。归档名忽略大小写并接受 `.pak` 后缀别名，重复归一化名称会拒绝。此适配不接管 Graph/settings/I18n 的安装内容加载。
+
 `IAssetFileMaterializer` / `AssetFileLease` 位于 Core.Assets；Assets 的 `AssetFileMaterializer` 通过 AssetManager acquire 的字节实体化媒体。同一会话内资源 ID（忽略大小写）共享文件，最后一个租约释放才删除。关闭 materializer 取消待加载请求并拒绝新请求，已借用文件仍有效直到释放。Sample 将同一实例传给剧情音频、视频与 Gallery；视频先释放原生播放器再释放文件租约。Gallery 缩略图抽取和临时缓存由独立服务拥有。
+
+`AssetFileMaterializer(assets, cacheDirectory)` 允许宿主传入应用可写缓存根；缺省使用 .NET 临时目录。每个实例只创建并清理该根下 `GalNet/Media/<唯一目录>`，不会删除宿主提供的根或其他缓存。实体化结果是后端可打开的普通文件路径；包内 URI 不直接交给文件型媒体解码器。
+
+LibVLC 音频后端同样为每个 voice 持有独立文件租约，先销毁播放器再释放租约；自然结束、立即停止、淡出完成、创建失败与取消加载均归还租约。后端不再将播放过的文件保留到整个会话结束，也不另建音频引用计数或闲置缓存层。多个声音及视频/Gallery 仍通过同一个 materializer 共享文件，音频停止不会删除其他消费者仍在使用的文件。
+
+## 默认视觉资源
+
+默认契约项目初始化将 Editor.Shared 内嵌模板复制为 `Assets/Effects/Default/` 下的 8 个普通 effect-program 资源及 sidecar，每个项目生成自身 GUID。`galnet.project.defaultVisualPrograms` 保存创作用途绑定，不是运行时隐藏效果目录。`project visuals install` 通过现有作者文件事务显式补入缺失绑定及资源，保留已有绑定，拒绝覆盖被占用路径。自定义契约需声明相应配置字段及 effect.apply 能力才启用默认模板。
+
+Shader 的可选保留 `layerZ` uniform 在 CPU/GPU 图层效果链每次绘制时取当前图层 Z；不可声明为作者参数。texture 参数由效果运行器通过 AssetManager 获得独立租约，按画布大小绑定，停止、替换、释放或准备失败时归还。预览和运行只读取项目资源；导出包含项目 shader 和纹理。使用方式及景深、停止边界见[默认视觉库](../manual/default-visuals.md)。
diff --git a/docs/spec/control.md b/docs/spec/control.md
index 6dfad421..4aed05ee 100644
--- a/docs/spec/control.md
+++ b/docs/spec/control.md
@@ -66,6 +66,8 @@ GamePageViewModel 的自定义 View 必须继承 GamePage；DI 中的 GamePage 
 
 主题把 ScreenshotDialogViewModel 映射到 ScreenshotDialog 派生 View。XAML 加载后调用受保护的 InitializeDialog，布局必须提供 Preview(Image)、DirectoryBox/TextBox、FileNameBox/TextBox、IncludeUiBox(CheckBox)、BrowseButton/CancelButton/SaveButton(Button)、ErrorBlock(TextBlock)。缺失控件明确报错。基类管理选择目录、预览更新、保存、取消和 Bitmap 释放；服务通过 DI 创建独立实例，并加载当前主题样式。宿主可在 configureViews 中覆盖截图 View，构造参数可注入宿主服务。
 
+`GameScreenshotRequest.CapturePreviewPngAsync` 是可选的预览回调，未提供时复用原 `CapturePngAsync`；正式保存始终调用后者。GameShell 的预览按原比例限制到 720×405，不放大；“包含对话框和操作栏”两种状态在当前弹窗内分别缓存，失败可重试。正式导出保持原逻辑分辨率，PNG 编码在后台完成。`SceneLayerHost.CaptureControl` 和有尺寸上限的 `CapturePng` 同时限制场景中间纹理与 CPU 效果处理像素，图层位置和原生图片尺寸仍使用原逻辑坐标；剧情截图入口的无参捕获保持原行为。
+
 ### Gallery 页面
 
 Gallery 使用独立的 `IGalleryPageRegistry`，以精确 Gallery `typeId` 映射到页面 ViewModel 和 View。`Add<TViewModel, TView>` 注册新类型，`Replace<TViewModel, TView>` 显式覆盖既有类型；多个 type ID 可以映射到同一页面。该注册同时写入普通 ViewModel→View registry 和 DI，构建后不可修改。
@@ -76,7 +78,15 @@ Sample 新增 `operation`（操作）分类，与游戏、画面、音频并列
 
 设置项保持无逐行外框的布局。`InputBindingCapture` 使用 Button 样式键及 `player-input-binding` 类，将当前键值（如 Control）呈现为可点击的输入框：独立 1px 描边、主题底色与圆角、悬停文字/描边变色和键盘焦点提示；修改仅作用绑定控件，不给整行配置项加卡片。设置模板不再创建重复的可用性 Tooltip，避免空说明也弹出空白提示；不可用原因和错误仍以内联文字展示。不改变 SchemaForm 工厂、可用性或提交队列。
 
-`PlayerInputSettings` 与输入路由属于 GameView，宿主实现原始设备适配。Sample 的 Windows 手柄后端为 XInput，非 Windows 未提供原生手柄后端；三主题共享面板行为和现有设置页外壳。`PlayerInputSettings.OpenHistoryAsync` 是未来对白历史页的可选入口，无回调时历史动作禁用。`IFirstEmptySlotSession.SaveFirstEmptyAsync` 表示普通槽位的首空槽保存，null 表示槽位已满；Sample 在写门内重新查询并保存，满槽打开存档页供玩家选择。该行为独立于单文件 quick-save。
+`PlayerInputSettings` 与输入路由属于 GameView，宿主实现原始设备适配。Sample 的 Windows 手柄后端为 XInput，非 Windows 未提供原生手柄后端；三主题共享面板行为和现有设置页外壳。`PlayerInputSettings.OpenHistoryAsync` 接入默认对白历史覆盖层，无回调时历史动作禁用；默认键鼠绑定为 WheelUp，旧偏好仅在缺少该动作且没有手势冲突时补入，显式清空保持无绑定。`IFirstEmptySlotSession.SaveFirstEmptyAsync` 表示普通槽位的首空槽保存，null 表示槽位已满；Sample 在写门内重新查询并保存，满槽打开存档页供玩家选择。该行为独立于单文件 quick-save。
+
+默认宿主以 `DialogueHistoryJournal` 保存当前路线已完整显示的 ADV/NVL 文本，保留实际语言的姓名、富文本、进入前已读状态及可选语音引用；Quick/CatchUp 记录实际经过文本，调试重建不追加。新游戏清空，存档/读档恢复对应前缀；历史正文只在实际保存时进入 `GameSnapshot.Attachments[host.dialogue.history]`，状态表只编码计数游标。当前句按稳定边界重新执行，避免重复记录。默认三主题承载 GamePage.History（PART_History），列表虚拟化，每次打开定位末尾；正文行纯显示，不提供悬停、选择、焦点或点击行为，独立语音按钮可重播。打开取消自动/快速并屏蔽剧情输入，Escape/返回按钮关闭，关闭保持手动。
+
+尚未包含历史模块的当前格式旧存档由宿主补入空历史表，从读档后开始记录；无法补回此前没有保存的正文。已存在游标的存档必须具备长度一致的历史正文；其他模块状态校验保持严格。
+
+语音关联使用同 Group、同 raw entry 的紧邻编译原语身份（rawId#n 与 rawId#(n+1)），仅消费该次实际执行的 audio.play；条件跳过清除候选，不跨源或跨执行借用旧语音。对白原语音结束后显示重播按钮；历史行直接使用保存的资源/音轨/增益。`DialogueVoiceReplay` 以独立临时 voice 借用当前后端和轨道混音，不进入剧情音频队列；新的重播替换旧重播，补全文字、推进、选择、开启自动/快速/跳过、关闭历史、读档或结束运行均停止。迟到的音频事件按 voice ID/generation 隔离。
+
+已读正文配色默认关闭，启用后显示颜色选择器，初始 #A8B8C8，经玩家设置队列保存。每次进入文本前捕获 WasRead，首次显示完成不跳色。`ReadTextStyle` 只替换 typewriter 默认色 runs，显式富文本颜色、粗体、斜体和姓名样式保留；修改设置不重启打字，ADV 与每段 NVL 分别保留进入时状态。
 
 `PlayerInputRouter` 组合设备输入与手柄导航；`KeyboardMouseShortcutListener` 是可独立挂载/释放的非视觉监听模块，通过委托查询接收条件、提交动作和释放按住状态。它随播放器根控件 attach/detach 订阅所在 TopLevel 的键盘事件，鼠标事件仅订阅根控件；不要求游戏区域持有焦点，也不抢占焦点。文本、选择、范围编辑器和壳外宿主控件不触发游戏快捷键，工具栏按钮保留 Enter/Space 原生激活及鼠标交互，其余游戏快捷键仍可用。`GameActionDispatcher` 通过现有游戏 VM/会话命令执行设备无关动作，非运行游戏页、绑定捕获、选择和跳过确认期间不分发游戏动作。键鼠、手柄和触屏共用执行器；重置、失焦、窗口失活或卸载会释放键鼠按住状态并取消延迟触发。
 
@@ -84,6 +94,18 @@ Sample 新增 `operation`（操作）分类，与游戏、画面、音频并列
 
 内置主题的 `Common.SettingsCategories.Editors` 接收宿主 EditorRegistry；普通设置通过 `SettingItem<T>` 的 IFieldBinding 调用原有 apply/save 队列，类型化选项使用 ValueCodec 编码，标签与值分开。主题提供单字段表单模板与统一设置行的标签、说明、单位、可用性及错误；工厂注册或替换由宿主组合。旧 EditorTemplates/SettingEditor 和数值/选项 UI 转换代理已移除。自定义设置通过 `CustomSettingEditor` 创建独立控件租约并在 detach 时释放。
 
+设置页的 Checkbox 左对齐。音频音量项通过 `SettingItem.InlineToggle` 引用同分类中的静音 BoolSetting；`DisplayItems` 仅负责合并显示，原 `Items`、设置 ID、可用性及 SettingsCoordinator 写入队列保持完整。静音按钮与实际滑块编辑器同行，以喇叭/斜杠喇叭区分状态，保留键盘焦点和无障碍名称。
+
+设置和首次语言选择的 ComboBox 沿用 Fluent 模板，默认、悬停、焦点、按下、禁用和弹出列表状态显式映射到玩家配色；弹出列表使用 Surface 底色、Selection 选中底色和 TextPrimary 文字，不依赖系统主题提供文字对比。
+
+三套布局共用单外框 `SaveSlotCard`：预览铺满卡片，底部半透明信息区只显示名称和时间；悬停或内部焦点高亮整卡。有效存档的名称支持直接编辑，Enter/失焦提交、Escape 放弃。宿主通过可选 `ISaveSlotNamingSession` 接入；空槽、坏档和不支持改名的宿主保持只读。文件存档沿用原 `Description` 字段保存名称，`ISaveSlotNamingService` 只修改此字段，时间、预览和剧情快照保持原值。默认 PlayerSession 覆盖槽位时保留名称；改名不改变“继续游戏”按时间选择最近存档的顺序。
+
+GameShell 新生成的存档预览上限为 480×270；旧图按 480 宽度解码展示。默认会话整表刷新只发送一次集合 Reset，普通保存只替换目标槽位，其他行与已解码预览继续复用。`ISaveSlotInfoSource` 是存储的可选单槽元数据查询能力，PlayerSession 对未实现该接口的存储回退整表查询；文件存储实现直接查询并在后台序列化保存数据。
+
+Sample 的窗口装饰颜色从玩家调色板映射到 CaptionButton/TitleBar 资源，不依赖系统明暗主题推断。退出确认在玩家根控件内显示主题弹窗，默认聚焦取消，Escape 取消并恢复先前焦点；显示时禁用背景内容及其输入，确认后沿用原会话停止和资源释放链。三主题主页的静态标题显式使用 TextPrimary，避免继承内容容器的半透明禁用前景色；其视觉变暗仅由遮罩产生。
+
+最小化、最大化按钮悬停/按下使用中性灰色叠层；关闭按钮悬停红色、按下深红色，并使用白色图标。
+
 共享页面的静态文案使用 `PlayerTextExtension`，未接入宿主本地化时显示默认英文。官方 Sample 提供 `LocalizedString` 并绑定其 `Value`，沿用 DynamicLocalization 的 Culture/Provider 变更通知机制；宿主设置标签也可以使用同样的动态对象。该绑定不会自动翻译任意业务字符串或剧情内容。
 
 Sample 在会话初始化后将设置接入 Player 变量存储，恢复语言、文本速度、快速已读限制、快速/自动间隔、音量/静音及显示偏好。等待时间使用整数毫秒：快速默认 50、范围 0–5000、步长 10；自动默认 2000、范围 0–30000、步长 100；旧浮点秒值视为类型无效，回退默认值，不迁移。画面能力由宿主提供，桌面 Sample 支持窗口/无边框全屏与预设窗口尺寸，非独占全屏；全屏时禁用窗口尺寸。语言变更立即刷新绑定并排队持久化；清空玩家状态和销毁会话前等待写入完成。
@@ -94,7 +116,7 @@ Sample 在会话初始化后将设置接入 Player 变量存储，恢复语言
 
 游戏工具栏的快速/自动模式互斥且允许均关闭，再次点击已选模式可取消。两模式未选中时保持透明，仅选中时显示主题色背景；其他工具栏按钮平时透明，悬浮使用淡色背景，按下加深。左键取消旧模式后，模式按钮按点击前状态决定开启/关闭，并从权威播放状态刷新选中绑定；工具栏操作不同时推进剧情。
 
-Runtime 只依赖 `GalNet.Presentation.Abstractions` 中的 `IGameView` 与细分接口（文本、NVL、交互、图层、转场、音频、视频、效果）。`AvaloniaGamePresenters` 是页面侧 presenter 的组合器，分别暴露 dialogue/NVL/choice、layer、animation 和 particle 端口；它不是页面或执行 view。宿主通过 `CompositeGameView` 把这些端口组合成 Runtime 使用的 `IGameView`。`NullGameView` 供测试和无界面宿主使用。
+Runtime 通过 `GalNet.Core.Execution` 中的 IPrimitiveDispatcher、Choice 与快进/播放控制协议接入宿主，不引用呈现程序集。`GalNet.Presentation.Abstractions` 提供文本、NVL、图层、转场、视频、效果等具体领域 presenter 协议及执行注册/恢复组合。`AvaloniaGamePresenters` 是页面侧 presenter 的组合器，分别暴露 dialogue/NVL/choice、layer、animation 和 particle 端口；它不是页面或执行 view。宿主通过 `CompositeGameView` 把这些端口组合成 Runtime 使用的 `IPrimitiveDispatcher`。`NullGameView` 供测试和无界面宿主使用。
 
 各 presenter 共享 `IAvaloniaUiDispatcher`，但分别拥有自己的等待、动画和粒子生命周期。`AvaloniaGamePresenters` 通过宿主提供的 `IGamePageLayerFactory` 解析图层图像，因而共享页面不会自行推断资源路径。玩家推进从 `GamePageViewModel.AdvanceRequested` 直接连接宿主，不经过 dialogue presenter 或 presenter 集合转发。动画逐帧更新由呈现实现完成；Runtime 只维护可存档的场景状态和动画结束后的稳定属性。
 
@@ -110,6 +132,8 @@ EditorRegistry 以开放 EditorId 映射到工厂，提供 Register/Replace/Regi
 
 默认 Text/Numeric 使用 TextBox 保存草稿，Enter/失焦时只提交有编辑的文本；JSON 使用带标识的多行 TextBox，Ctrl+Enter/失焦提交，按原始 JSON 表达字符串引号，Escape 恢复未提交草稿；Numeric 不经过 double/decimal 控件值转换，以保留大整数和未完成输入。Toggle/Choice/Slider 提交选定值，复用 Core 的 codec/校验和项目 JSON 配置。Slider 需要有限 min/max、正步长；decimal、不安全整数精度/CLR 范围或非整数整数滑块配置明确诊断。Step 仅决定滑块交互，不限制业务合法值。合法选项与标签分开；binding 的动态选项更新不会重建表单。
 
+另有显式 `numericupdown` 与 `numerictext` 工厂；前者复用 NumericUpDown 主题的输入/上下按钮，保留原始文字并由 FieldEditorContext 提交，不以控件 Value 回写，避免模板初始化、舍入或钳制制造草稿。long/ulong/decimal 使用无损文本，超出可调整范围或非法步长可回退文本并返回工厂 Diagnostic。Editor 将默认 `numeric` 替换为此路径，并将 `slider` 替换为滑块加精确输入，其他宿主的默认 numeric/slider 行为保留。Registry.FormatIssue 允许宿主提供字段诊断文字；原始 ValueIssue 的代码与消息仍保留。浮点编辑文本的 `.3`/`-.3` 由 ValueCodec 规范化，JSON 源码不放宽；未完成数值前缀在输入时可中性展示，提交仍拒绝。
+
 宿主可通过 `EditorRegistry.CreateDefault(emptyInputClearsOptionalFields: true)` 选择非字符串空文本恢复缺省的策略；必填无默认值仍拒绝，JSON 源码不套用此策略。FieldEditorContext.Registry 是借用的只读引用，自定义组合编辑器创建子 Context 时可以传递同一 registry，使输入策略和工厂组合一致。FieldEditorRow 提供可响应宽度的标签、编辑区、诊断和单重置布局；FieldEditorActions.Simplified 选择单重置行为，默认共享表单和 Sample 仍保留原动作集。
 
 FieldValue 以未提供的 Json 和显式 JSON null 区分省略/null。Context 保留草稿和诊断；默认值只用于未提供状态的展示，未编辑的默认/null/空状态失焦不会写回。宿主可通过 CommitAsync 显式提交省略或 null；共享默认结构通过 FieldEditorActions 提供相应按钮，宿主自定义模板可自行组合。支持范围内对象/数组使用懒创建表单，其他类型明确使用 JSON；普通 CLR DtoBinding 没有 presence 时仍拒绝省略，不能静默写成 null。
@@ -138,10 +162,14 @@ Context 的生命周期包装取消旧提交、保留动态选项和 IFieldPrevi
 
 内置设置主题的普通设置改用 SettingItem.EditorItem/DtoEditorHost，继续提供原单字段 SchemaForm 的皮肤与设置应用/保存队列；Action/ICustomSetting 保留各自行为。Sample 的 CreateFieldEditors 组合结束后冻结 registry。Editor 的 Dock 创建 Group 面板时传入项目 registry；目前依赖旧资源/表达式等专属字段的 Entry 继续走原路径。P6b 补充普通嵌套结构表单；所有专属字段迁移、手势合并协议、状态查询与 timeline/曲线仍未包含。
 
-StructuredFieldEditor 复用 Expander 主题（StyleKey 为 Expander，宿主样式使用 Expander.structured-field 类选择器），按展开创建、折叠释放子控件。支持有生成静态 Schema 的 DTO，以及一维数组、List<T>/IList<T>/IReadOnlyList<T>/IEnumerable<T>。嵌套对象继续通过 DtoEditorHost 支持整 DTO 覆盖，默认内部表单继续成员/类型注册；根据 JsonTypeInfo 映射实际 wire 名，不构造 DTO 来生成 UI。对象提交合并当前 JSON，仅替换编辑成员，保留未知成员。自定义 converter、无 schema 的对象、字典、八层深度或超过 200 元素使用 JSON；用户也可显式切换结构/JSON。
+StructuredFieldEditor 复用 Expander 主题（StyleKey 为 Expander，宿主样式使用 Expander.structured-field 类选择器），按展开创建、折叠释放子控件。通过 Core 的 ValueDocument / ValueStructureResolver 统一读取 DTO、显式描述的 JSON 对象、一维数组、List<T>/IList<T>/IReadOnlyList<T>/IEnumerable<T> 以及 Dictionary/IDictionary/IReadOnlyDictionary<string,T>。嵌套对象继续通过 DtoEditorHost 支持整 DTO 覆盖，默认内部表单继续成员/类型注册；公共结构解析器根据 JsonTypeInfo 映射实际 wire 名，不构造 DTO 来生成 UI。对象提交使用公共属性 patch，仅替换编辑成员，保留未知成员。没有结构适配的对象级 converter、未知对象、不支持的键类型、八层深度或超过 200 元素使用 JSON；用户也可显式切换结构/JSON。
+
+通用对象使用单一可折叠 Header，字段行不重复显示相同标签；集合 Header 带数量，简单元素不额外显示 element 标签。字典为键/值行，键支持空串、数字及转义字符；新增、删除与改键是明确的结构操作，重复改键拒绝且保留当前输入。无效键名候选保留于当前控件，不作为跨视图的值草稿归档。ChildIndent、ItemSpacing 由宿主样式设置，统一缩进和组间距，不逐层插空白行。Transform/Flipbook 保留专用布局，子字段定义、读写和校验复用公共属性层；其他专用工厂覆盖顺序不变。
 
 列表结构变化取消当前版本令牌，旧索引绑定和延迟提交失效；普通元素值编辑保留其余行控件。共享控件不实现保存或撤销，依旧提交一个根字段 JSON 值，由宿主负责原子修改及历史。FieldEditorActions 提供显式默认值、缺省、null 和草稿恢复，CanOmit/CanSetNull/HasDefault 决定入口，宿主用 StyledProperty 翻译提示；仅打开表单不写默认值。
 
+PropertyFieldBinding 和通用结构子绑定转发 HostContext、可见性、宿主 Reset 策略及相对根字段的 PropertySegments；DTO scope 同样转发路径。列表序号和字典键通过 IsLabelLiteral 标记为字面标签，避免被当作本地化 key，同时普通字段 Header 保持本地化与字段名回退。导航优先匹配完整路径，避免同名深层字段误选。元数据解析器由控件/分析调用方持有和释放，不以全局静态缓存保留项目契约类型。
+
 ## 宿主接入约束
 
 - 每次独立运行必须使用独立的游戏会话与页面 Scope；切换项目或重启预览时释放旧 Scope。
@@ -172,3 +200,12 @@ StructuredFieldEditor 复用 Expander 主题（StyleKey 为 Expander，宿主样
 `IFieldBinding.Draft` 可选返回宿主拥有的 `FieldDraftState`。控件上下文同步输入和诊断，挂载结束只解除订阅；宿主决定草稿的保存、冲突和生命周期。ScopedBinding 转发该状态，结构化对象/列表和 Transform 子编辑器通过子路径取得独立草稿。输入法组合保护随控件租约登记，项目保存不能越过组合输入。没有宿主草稿的设置/游戏表单沿用控件本地生命周期。
 
 需要来源版本保护的宿主在内容变化时调用 `FieldDraftState.CheckSource()`；一旦观察到冲突，即使源值随后恢复相同内容也保留冲突，直到明确清除草稿。
+
+
+## 默认宿主扩展边界
+
+默认页面服务以 TryAdd 注册。项目可替换接口实现，或将 TitlePageViewModel、SettingsPageViewModel、GamePageViewModel、GameShellViewModel 的 DI 别名映射到自己的派生类型，并注册该实际类型的 View。标题命令支持重载；标题/Shell VM 的 Dispose 可扩展。默认 GamePage 的四个呈现部件约束继续有效。
+
+默认 Avalonia 会话依赖 IAvaloniaPlayerSettings 与 IPlayerStartup，不要求项目使用默认 GameSettings DTO 或自动字段 UI。设置接口只暴露模块输入及接入/保存/窗口生命周期，SettingsChanged 更新当前运行；IPlayerSettingsService 可供默认页面使用，手写页面可直接绑定项目模型。
+
+AvaloniaGameHostOptions.AttachPlayer 借用已准备的玩家服务和 profile；AttachRun 借用每次 Prepare 后的 Engine。绑定由宿主按运行→玩家→资源的依赖顺序释放，同时实现 IAsyncDisposable 时优先异步排空。业务活动、覆盖层和自定义保存语义归项目服务/模块，不属于默认页面注册协议。
diff --git a/docs/spec/cpu-benchmark.md b/docs/spec/cpu-benchmark.md
new file mode 100644
index 00000000..a332b399
--- /dev/null
+++ b/docs/spec/cpu-benchmark.md
@@ -0,0 +1,17 @@
+# CPU 性能事件
+
+`src/Shared/GalNet.Diagnostics` 是独立、不依赖 Core、UI 或日志库的诊断程序集。全仓 `Benchmark=true` 构建属性定义 `BENCHMARK`；Editor 和 Avalonia Sample 只在此属性启用时引用诊断项目。Benchmark 的 bin/obj/restore lock 均位于各项目的 benchmark 子目录，Editor 默认契约内容也从同模式产物复制。普通构建不包含宿主埋点代码或该程序集引用；诊断程序集本身的实现也被条件编译移除。
+
+`CpuProfiler.Shared.Measure(name, category)` 返回幂等 `IDisposable` 区间，`Mark` 记录瞬时事件。允许独立实例。时间使用 Stopwatch 单调时钟，单位为微秒；区间是 inclusive wall-clock duration，包含等待、调度、JIT 等开销，不是处理器执行时间或占用率。跨 await 区间归属开始时的 managed thread ID，不能据此把重叠异步区间解读成真实线程调用栈。没有 GPU timestamp 或 PIX 对接。
+
+Benchmark 可选 EventPipe 镜像：进程启动前设置 `GALNET_BENCHMARK_EVENTPIPE=1` 为 Shared 启用，独立实例可传 `emitEventPipe: true`。默认不创建 EventSource。provider 为 `GalNet-CPU`，事件 Record/1 包含 name、category、timestampMicroseconds、durationMicroseconds 和 threadId；瞬时事件 duration 为 -1，区间在结束时发出。缓冲停止或溢出的事件不镜像。采样会改变时序，只用于与 CLR JIT/采样栈对齐，不能作为正式 benchmark；普通构建完全没有镜像实现。
+
+同一 EventSource 也可被 Windows ETW 收集，确定性 GUID 为 b73a0b39-c81d-5026-2e0f-108dad0eff68。startup-native.wprp 仅启用进程/模块加载、原生 CPU 采样和阶段事件，不采集上下文切换或 GPU 完成时间。原生分析器拒绝丢事件 trace，按事件的 OS 线程 ID 对齐 UI 阶段；managed threadId 字段不用于替代 OS 线程 ID。
+
+采集和快照线程安全，每实例默认最多 100,000 个事件；超过容量后丢弃后续事件，导出 `droppedEvents`。`Stop` 阻止之后新增事件，包括尚未结束的区间；快照只包含已结束区间与瞬时事件。`WriteTrace(Stream)` 导出 Chrome Trace Event JSON（区间 X、瞬时 i），流所有权属于调用方。
+
+`StartupBenchmark.Start()` 在 Main 入口调用。存在 `GALNET_BENCHMARK_OUTPUT` 时创建 `Startup.Total` 区间；`Complete(success)` 结束它、记录 Ready/Failed、停止采集，并通过同目录临时文件导出 trace。每进程只完成一次。`GALNET_BENCHMARK_EXIT=1` 使 Complete 返回 true，由宿主正常关闭窗口。失败或导出错误设置非零进程退出码；未设置输出路径不会自动退出或写文件。Benchmark 构建中的手工 Measure/Mark 仍可用于自定义采集。
+
+Editor 在主窗口构造时准备欢迎页，避免在窗口 Loaded 后才开始首次导航；完成点仍为欢迎页 Loaded 后的 Background dispatcher 回调。Sample 完成点：会话初始化返回后、CompleteStartup 更新 UI 后的 Background dispatcher 回调；初始化失败不是 Ready。它们不保证 GPU 首帧完成或所有惰性初始化已执行。Startup.Total 不含 CLR 进入 Main 前、trace 写出及进程关闭；脚本另记 ProcessLifetimeMs，后者包含启动和退出，不能当作纯启动时间。嵌套阶段的时长不能直接求和。
+
+Editor 正常入口在平台初始化前启动两个数据准备任务（设置读取、本地化资源读取/解析），在框架初始化完成时等待并交给 DI；文化、主题、导航及控件仍在 UI 线程应用。设计器/默认 App 路径保留同步回退。此机制不改变 Ready 口径，也不是通用任务调度器。
diff --git a/docs/spec/dock-design.md b/docs/spec/dock-design.md
index cff5c494..6c268a4d 100644
--- a/docs/spec/dock-design.md
+++ b/docs/spec/dock-design.md
@@ -29,8 +29,8 @@ Dock.Avalonia 是一个面向 Avalonia UI 框架的停靠布局系统，支持
 │  EditorPageView.axaml — DockControl Layout="{Binding Layout}"   │
 ├──────────────────────────────────────────────────────────────────┤
 │  ViewModel 层                                                     │
-│  EditorPageViewModel — 管理 IRootDock Layout                     │
-│  各面板 ViewModel（EditorWorkspaceViewModel, GamePreviewPanel...）│
+│  EditorPageViewModel — 绑定 EditorLayoutSession.Layout                     │
+│  各面板 ViewModel（EditorWorkspaceViewModel, ExternalDebugPanel...）│
 ├──────────────────────────────────────────────────────────────────┤
 │  Dock 工厂层                                                      │
 │  EditorDockFactory — 创建/恢复布局树、管理面板生命周期             │
@@ -71,7 +71,7 @@ RootDock ("Root")
     ├── ProportionalDock ("Center", Vertical, Proportion=0.68)
     │   ├── DocumentDock ("Documents")           ← 中央主区域
     │   │   ├── Document ("NodeGraph")           ← 节点图编辑器
-    │   │   ├── Document ("GamePreview")          ← 游戏预览
+    │   │   ├── Document ("ExternalDebug")        ← 外部游戏调试
     │   │   └── ... (其他默认/用户打开的面板)
     │   ├── ProportionalDockSplitter
     │   └── DocumentDock ("LogDocuments")         ← 底部区域
@@ -139,7 +139,7 @@ registry.RegisterDockPanel(new DelegateDockPanelContribution(
 | `GroupEditor` | MainDocument | 否 | 否 | 组编辑器（按需打开） |
 | `Inspector` | InspectorDocument | 否 | 是 | 属性检查器 |
 
-Editor 工作区重构期间暂不注册 `GamePreview`，旧布局中的该项会作为不可用面板移除；当前也没有 `UiCustomization` contribution。`EditorDockFactory` 属于项目 scope。Group contribution 接收稳定 Group ID 字符串，项目文档及共享投影不由 Dock 页面拥有；关闭页面释放其订阅，重开继续使用相同项目内容。
+旧内嵌 `GamePreview` 及其运行宿主已删除，旧布局中的该项会作为不可用面板移除；当前也没有 `UiCustomization` contribution。`EditorDockFactory` 属于项目 scope。Group contribution 接收稳定 Group ID 字符串，项目文档及共享投影不由 Dock 页面拥有；关闭页面释放其订阅，重开继续使用相同项目内容。
 
 Timeline 使用项目 scope 的 `EntrySelectionContext` 与 `TimelineEditSession`；页面只发布稳定选择，面板不持有 Group 页字段 lease。激活 Group 页恢复其活动选择，工具面板获焦不改变来源。关闭 Timeline 释放面板并取消未确认输入，项目会话与内容历史保留；重新打开使用同一个项目会话。当前编辑行为与后续画布范围见 [Group 编辑](editor-groups.md#timeline-dock)。
 
@@ -314,3 +314,5 @@ services.AddTransient<MyNewPanelViewModel>();
 预设调整现有 Dock，不销毁打开的文档、作者选择或项目草稿。最大化当前面板可恢复操作前结构；临时最大化状态不覆盖自动保存的布局。Timeline 属性树初始宽 320 DIP，可通过分隔条调整；显示完整时长、定位播放头及缩放读数只改变视口。
 
 Editor 图标按钮默认透明、32 DIP 点击区域，保留键盘焦点、禁用及切换反馈。按钮、背景与文字使用 Editor 调色板；普通 Button、ToggleButton、输入与菜单的 hover 直接使用 Ursa/Semi 原生模板行为。Editor 不再向全局 `Border`、控件模板或图标按钮注入自定义画刷过渡，以免 entry 卡片等非按钮容器参与动画。游戏作者数据和其他宿主不依赖这些 Editor 外观。
+
+布局恢复、命名布局和防抖写盘由 `Shell.EditorLayoutSession` 统一持有；页面只公开布局与命令。菜单由 `EditorMenuBuilder` 根据命令和贡献项构建，普通面板切换只更新菜单勾选状态，命名布局变化才重建菜单。
diff --git a/docs/spec/editor-files.md b/docs/spec/editor-files.md
index 740d9dc4..3a4d50c5 100644
--- a/docs/spec/editor-files.md
+++ b/docs/spec/editor-files.md
@@ -22,7 +22,7 @@ GUI 的文件操作进入项目统一内容历史，每次完整意图占一条
 
 Apply 或失焦提交输入，Cancel input 只取消当前输入；文本控件保留本地撤销。项目撤销和保存前提交有效输入，关闭项目时未保存缓冲参与脏检查。正在发布保存时，首次打开新的文件缓冲返回忙状态，避免将新身份加入旧捕获版本；已有缓冲可继续存在。跨重启不恢复这些标签或 Undo 栈。
 
-监听发现文本被外部修改时保留当前缓冲并提示；保存和结构操作复核保存基线及目标不存在条件，拒绝覆盖外部文件。当前没有三方合并或交互式重载：需要关闭项目、核对两个版本后重新打开。
+外部文件变化通过项目级候选快照同步：项目无未保存作者内容和待提交输入时，直接刷新当前会话与已开文本；有本地修改时保留缓冲并显示冲突，可明确放弃并从磁盘重新加载，无需关闭项目。采纳外部版本清除旧项目 Undo/Redo 并推进保存基线。保存和结构操作继续复核尚未采纳的外部变化；当前不做自动三方合并。边界见[外部内容热重载](editor-history-and-save.md#外部内容热重载)。
 
 ## 支持范围
 
@@ -39,6 +39,10 @@ Apply 或失焦提交输入，Cancel input 只取消当前输入；文本控件
 
 资源 metadata 通过项目的 `IResourceTypeCatalog` 与 `AssetMetaCodec` 处理，保留 Gallery 和未知扩展字段。移动保留 Gallery 身份；复制/导入时，已被项目或同批内容占用的 Gallery ID 为副本重新分配，保留 type/title，避免生成重复解锁身份。无法完整类型化的 metadata 拒绝重写；检查受影响资源与其他 sidecar 的 ID 冲突。Assets 索引仅负责读取、缩略图与通知，不在刷新/监听时创建或改写 metadata。
 
+剧情资源字段只以 sidecar 的资源 ID 关联资源；名称、目录和扩展名不参与身份，不能在 ID 缺失时按同路径的新文件自动重新绑定。移动/改名保留资源 ID，复制/导入分配新 ID。已挂载的 Entry 资源字段和打开中的选择面板随资源代次刷新名称、路径和候选，保留当前 ID 与搜索条件；过期结果和旧候选不能提交。读取失败与确实缺失分别显示，不把索引错误表示为 Missing。
+
+EditorAssetManager 每代共享一次资源索引任务，以 ID 查询并拒绝重复身份；调用者取消只结束自己的等待，失败索引允许重试。资源变更或项目切换推进代次，自定义 decoder/provider 注册保留，旧代在活动查询和资源租约结束后释放。选择器按代次和 ID 复用候选及缩略图，单面板最多缓存 128 张宽 128 像素的图片缩略图，其余显示图标；代次变化、解绑或销毁时取消旧加载并释放 bitmap。
+
 ## 文档与引用
 
 文件结构操作立即发布。相同结构意图分别应用于工作版本与最近保存版本，磁盘只写变换后的保存版本，未保存文本不被顺带保存。Group source path 改变后仍使用同一会话文档；之后保存再撤销路径操作，保留刚保存的文本。放弃未保存内容不会撤销已完成的文件操作。详见 [历史与保存](editor-history-and-save.md)。
@@ -51,11 +55,13 @@ CLI 的现有资产命令使用同一文件计划与发布机制，执行前加
 
 Assets 文件面板可从当前或选中的图片目录创建 `.variants`，使用现有 CreateFile 事务生成描述及 sidecar。只读取已导入图片，按稳定顺序选择第一张作为显式 default，维度省略时由文件名推断；不在扫描时修复或补建图片 metadata。导入图片仍使用既有 Import 事务。
 
-图集属性区提供相对目录、默认图、维度 key/显示名、添加/移除/重排与重新推断。配置是项目 `ProjectTextBuffer` 的类型化投影：修改先成为草稿，应用时单次文件历史，保存全部也可提交尚未应用的有效草稿。关闭属性面板保留项目草稿；坏 default、维度或目录使应用与保存全部失败，即使属性面板已经关闭也一样。未知 JSON 字段/坏结构保留原文并禁用类型化改写，可用 JSON 入口修复。资源类型按扩展名或 sidecar 声明识别，支持图集描述被改为自定义扩展名。
+图集属性区提供只读相对路径与目录选择器、唯一的默认图 ComboBox、本地化“维度 1、维度 2”等位置标题与可编辑显示名称。移除默认图自由文本、维度增删/重排/重新推断、应用/重新扫描按钮和内嵌 JSON。数量、顺序和选项由图片文件决定，源 dimensions 仅保存位置的稳定 key/label；额外位置命名休眠保留，新位置自动推断。显示名称不参与剧情引用身份。
+
+配置仍通过项目 `ProjectTextBuffer` 与内容历史提交：有效修改自动提交工作版本，保存全部负责写盘；失败保留草稿和诊断。未知 JSON 字段/坏结构保留原文并禁用类型化改写，可用通用文件入口修复。默认图失效时下拉框留空并显示扫描诊断，允许从现存图片中重新选择，不静默选择其他默认图。资源类型按扩展名或 sidecar 声明识别，支持图集描述被改为自定义扩展名。
 
-扫描使用与编译相同的相对路径、metadata codec 和 Core builder，拒绝越界和链接。预览列出所有维度的全部选项，以普通 bitmap 展示实际 sprite，分别显示完整请求、实际图、结果原因和候选削减链。切换与刷新只改变面板状态，不写作者文件和历史；缺组合不隐藏选项。重新扫描保留请求意图及保护维度；请求因定义修改而失效时诊断，不静默改选默认图，作者可显式重置预览。异步图片读取和旧预览行按代次失效，面板释放时释放 bitmap 并解绑事件。
+扫描使用与编译相同的相对路径、metadata codec 和 Core builder，拒绝越界和链接。Assets 的文件监视器经防抖发出资源变更通知，Inspector 重新扫描；不提供手动扫描入口。刷新不改写作者配置、不生成历史。预览保留请求与保护维度，失效时诊断并允许显式重置；分别展示请求、实际图和结果原因，候选削减链放入折叠详情。异步图片读取和旧预览行按代次失效，面板释放时释放 bitmap 并解绑事件。图片移动/改名继续由既有资源事务预检维护或拒绝无效关系。操作见 [图片差分图集](../manual/image-variants.md)。
 
-维度 key/顺序变化显示引用影响提示，不迁移剧情参数；label 不参与身份。图片移动/改名继续由既有资源事务预检维护或拒绝无效关系。操作见 [图片差分图集](../manual/image-variants.md)。
+移动描述文件或图片目录时，`folder` 按目标位置重算，并在同一结构事务中分别作用于工作内容和最近保存内容，包括已打开的图集文本缓冲。未保存配置不被顺带保存；保存后撤销/重做移动会重算当前配置的路径，保留最新保存的其他配置。预检分别验证工作版与保存版的资源关系，不能只验证磁盘快照。
 
 ## 事务、撤销材料与恢复
 
@@ -67,4 +73,4 @@ Assets 文件面板可从当前或选中的图片目录创建 `.variants`，使
 
 ## 资源面板常用入口
 
-导入、新建文本和新建文件夹在工具栏直接可见，原右键菜单仍可用。类型筛选与缩略图/列表视图只影响浏览；搜索明确覆盖整个项目。空目录、搜索或筛选无结果、读取错误分别呈现，不把加载失败当作空文件夹。排队刷新使用已捕获的项目内容服务，不在 scope 释放后重新解析服务。浏览与布局不进入作者历史。
\ No newline at end of file
+导入、新建文本和新建文件夹在工具栏直接可见，原右键菜单仍可用。类型筛选与缩略图/列表视图只影响浏览；搜索明确覆盖整个项目。空目录、搜索或筛选无结果、读取错误分别呈现，不把加载失败当作空文件夹。排队刷新使用已捕获的项目内容服务，不在 scope 释放后重新解析服务。浏览与布局不进入作者历史。
diff --git a/docs/spec/editor-game-localization.md b/docs/spec/editor-game-localization.md
index a91dbca8..ab2a0c0f 100644
--- a/docs/spec/editor-game-localization.md
+++ b/docs/spec/editor-game-localization.md
@@ -22,10 +22,20 @@ Editor.Shared 的 LocalizationReferenceIndex 分析一个 EditorProjectDocument
 
 - 遍历全部 GroupEntries，不依赖页面是否打开；定位包含 Group ID、Entry StableId 和 JSON Pointer。
 - 对 Choice 分支使用稳定 option ID，显式索引 Text；角色 catalog 的 DisplayNameKey 也进入文本引用。
-- 递归分析带静态 Schema 的 IFieldDto 和数组/List/IList/IReadOnlyList/IEnumerable；列表下标只是导航位置，索引不生成或重算文本身份。
-- 缺省、null 与精确空字符串不生成引用，不补默认值；空 LocalizedText key 表示有意的空文本，运行时解析为空字符串。仅含空白字符的 key 仍报错；未知字段/类型、不可遍历结构与错误 shape 报告分析不完整。
+- 通过 Core.ValueDocument 的有界迭代分析带静态 Schema 的 IFieldDto、数组/List/IList/IReadOnlyList/IEnumerable、字符串键字典和显式关联 ValueStructure 的 JSON 字段；列表下标只是导航位置，索引不生成或重算文本身份。
+- 缺省、null、空字符串和纯空白字符串不生成引用，不补默认值；空 LocalizedText key 表示有意的空文本，启动时不要求对应译文，运行时解析为空字符串。空对象和空数组也不包含引用，不因缺少 schema 或未知字段而阻止分析；非空的未知字段/类型、不可遍历结构与错误 shape 仍报告分析不完整。
 - 深度上限 16，整个分析的值预算 100,000。超限产生 analysis.limit，不能以未找到引用认定角色未使用。
 
+内置 Transform、ToTransform 与 Flipbook 字段关联其可编辑子字段的共享 schema，正常非空值不再因为 JsonElement 外层类型而产生 field.opaque；未知非空扩展仍报告未覆盖。Transform 的历史字符串编码由显式结构适配解释。LocalizationReference / LocalizationIssue 的 Path 保留带编码边界的类型化逻辑路径；JsonPointer 指向实际外层 wire 位置，不伪造穿过 JSON 字符串的 Pointer。Problems 使用逻辑路径定位内部字段。
+
+effect.apply、SpeedLines/Impact 预设的 parameters 按所选 shader metadata 解析；无 program 的 effect.apply 使用宿主效果目录。音频 apply 使用当前音效目录，update 使用作者 Graph 前缀按 scope/targetId/instanceId 确定的实例类型。字段沿用目录和表单的 FieldDescriptor，由 ValueDocument 遍历；向量作为数值序列，颜色、纹理 ID、选项字符串不被猜测为本地化 key。显式契约结构优先。未知类型、缺失 metadata、封闭参数契约中的未知参数或不确定的更新类型仍报告未覆盖。项目扫描同时依赖作者快照和资源代次，使用未保存的托管 shader 内容；资源声明与代次在同一锁内捕获，加载完成后触发重新检查。磁盘验证读取 effect-program 资产声明，重复资源 ID 不被选作确定结构。
+
+Timeline 根、轨道、关键帧与事件复用 Timeline DTO 的共享 schema，Editor.Shared 补充 editorId/editorTangents 作者 metadata；兼容既有大小写不敏感成员和枚举编码。事件 parameters 通过当前项目 Entry catalog 的字段解析，事件中的 effect.apply 继续使用所选 shader metadata，资产发现与场景查询共用同一入口。运行结构检查和事件 allow-list 仍归原契约；未知事件参数/成员与其他尚未关联的 JSON 继续报告未覆盖。
+
+已知 shader 的参数对象是开放的：渲染器只消费声明成员，切换后保留的旧参数或其他额外 JSON 都是合法附加数据，不产生 field.unknown/field.opaque，也不导致引用分析不完整。扫描通过 OpenObject 和原子 JSON 附加值契约保留这些数据，不猜测其内部的文本/角色引用；该规则同样适用于 Timeline 中的 shader 参数。声明成员的类型/范围及重复成员仍诊断。未知 shader 不推定开放结构，普通 DTO、音效和 legacy catalog 的封闭校验不受影响。
+
+引用的 LocationKey 使用逻辑位置区分同一外层字符串中的多个叶值，Rewrite 使用类型化路径产生新参数快照并保留编码。角色引用比较/替换、文本草稿/复制写入以及本地化来源显示已接入该位置；旧公开 Pointer Set 入口保留，新的引用回写不再以外层 Pointer 猜测内部地址。
+
 I18n/catalog/characters.json 的角色按 Ordinal ID 检查；允许姓名译文相同。I18n/<culture>/**/*.json 支持平铺与嵌套字符串叶值，按文件路径 Ordinal 排序并保留每个来源及属性位置。FindDirect 返回同语言最后生效的定义；缺少直接翻译返回 null，不做运行时回退。显式空串与缺失独立。External 不进入作者索引。
 
 重复 JSON 属性、同文件扁平/嵌套 key 冲突、非字符串叶值、坏 JSON/无效 culture、无效 catalog 均有诊断，其他可读取文件仍可查询。未知角色和默认语言缺 key 单独报告；如果引用位置已经全部分析，这类目标不存在错误本身不会使 Complete 变 false。Complete 只描述分析覆盖程度，不代表项目可运行。
@@ -66,15 +76,19 @@ Graph/localization-authoring.json 使用 version=1、characterHighWater=非负 I
 
 ## 角色表与 speaker 创作
 
-角色 Dock 是项目级单例文档页，可从面板菜单打开，关闭后释放订阅，重新打开读取当前作者文档。列表显示开发语言姓名与角色 ID；搜索同时匹配两者，编辑草稿通过应用/还原按钮处理，Save All 仅保存已应用的作者值。
+角色 Dock 是项目级单例文档页，可从面板菜单打开，关闭后释放订阅。列表显示开发语言姓名与较弱显示的角色 ID，搜索同时匹配两者；右上角“＋”开始新建并聚焦姓名，应用/还原/删除为带提示的图标按钮。编辑区仅在选中或新建时显示，未应用状态单独标记；删除禁用时说明引用或分析不完整的原因。
+
+CharacterPanelState 属于项目 scope，以角色 ID 与 DisplayNameKey 的组合保存草稿及原声明基线；姓名文本 key 在会话内始终唯一时，可据此跟随角色 ID 改名，应用仍检查原声明基线。曾共享姓名文本的角色不通过文本 key 猜测身份，互不继承选择或草稿；新建草稿单独保存。换项、搜索过滤及关闭重开不丢失输入。Save All 仅保存已应用的角色作者值，草稿不跨项目或应用重启恢复。
+
+异步应用完成时只清理与本次提交快照相同的草稿；期间换项不抢回选择，关闭重开后产生的较新输入也不会被旧视图清理。应用或还原已有角色不顺带放弃独立的新建草稿。
 
 CharacterAuthoringService 以 catalog 为唯一角色身份来源，以项目 TargetLocale 的直接姓名译文为显示值；编辑器 UI 语言不改变作者姓名。允许同名、Ordinal 唯一 key；新角色不填 key 时使用持久预留的 character_n。修改角色 key 更新全部已声明的 CharacterReference，包括未打开 Group 与嵌套 DTO/列表中的实际 JSON 路径；姓名 DisplayNameKey 不变，其他语言译文保留。
 
-新建记录、姓名译文及 speaker 引用构成一次项目历史，保存前只修改 Working。第一次需要文件时，先发布空 catalog 和开发语言 characters.json 保存基线；初始化文件和编号预留不随值历史撤销，允许空文件与编号空洞。保存后撤销创建只还原 Working 值，下一次 Save All 整体落盘，不删除仍服务于 Saved Group 的文件。未使用角色只能显式删除，撤销可恢复；删除保留姓名文本。引用分析不完整时禁止删除和改 key，仍允许修改姓名。
+新建记录、姓名译文及 speaker 引用构成一次项目历史，保存前只修改 Working。第一次需要文件时，先发布空 catalog 和开发语言 characters.json 保存基线；初始化文件和编号预留不随值历史撤销，允许空文件与编号空洞。保存后撤销创建只还原 Working 值，下一次 Save All 整体落盘，不删除仍服务于 Saved Group 的文件。未使用角色只能显式删除，撤销可恢复；删除保留姓名文本。引用分析不完整时禁止删除和改 key，仍允许修改姓名。角色面板显示前五条不完整诊断的代码、Entry、位置和说明；尝试删除或改 key 时记录包含最多二十条原因的结构化 warning 日志。
 
 标记 CharacterReference 的字符串字段使用专属输入框，根字段与嵌套表单共用语义注册。候选按姓名/key 不区分大小写匹配，最多显示 50 项；选择提交精确 ID。搜索后默认高亮第一项，候选打开且输入非空时，在输入框按 Enter 可直接采用高亮角色；也可用向下键进入候选列表后按 Enter 确认。候选关闭或没有匹配时的 Enter、直接输入失焦仍按精确 key、唯一精确姓名的顺序解析；同名歧义要求选择，其他非空文本创建角色。空白输入清空引用，不创建角色。输入法组合期间不拦截 Enter/Escape，组合完成后 Escape 还原草稿；过期表单、取消或已移除 Entry 不能继续创建角色。普通未标记字符串保持原提交行为。
 
-角色身份只来源于 catalog，ProjectSettings 不再包含 Speakers。没有旧角色候选、旧姓名迁移或导入兼容入口；未知 speaker ID 报告 character.unknown。原文/JSON 草稿冲突沿用受管理文档的校验与保留规则。
+角色身份只来源于 catalog，默认项目配置不包含 Speakers。没有旧角色候选、旧姓名迁移或导入兼容入口；未知 speaker ID 报告 character.unknown。原文/JSON 草稿冲突沿用受管理文档的校验与保留规则。
 
 ## 默认语言文本与稳定身份
 
@@ -98,15 +112,21 @@ Graph/localization-authoring.json 的可选 textStates 记录每个文本 key 
 
 ## 游戏本地化面板
 
-Localization Dock 为项目级单实例，可通过视图菜单打开。左侧包含角色表、全部作者 Group（含未打开页面）和分支选项；分类和文本行使用 ListBox 虚拟化，右侧表格支持整体横向滚动。正常表格显示行/字段或选项上下文、直接文本及状态，不显示文本 key。同分类共享 key 合为一行并提示共享数量；定位按钮跳到角色表或对应 Group 条目/分支检查器。
+Localization Dock 为项目级单实例，可通过视图菜单打开。左侧包含角色表、全部作者 Group（含未打开页面）和分支选项；分类与文本行使用 ListBox 虚拟化，表格整体横向滚动。定位列保持在左侧，和表格使用同一个不透明背景，不显示“上下文”标题。Group 左侧显示当前 Entry 编号（如 Entry1）与字段槽位，编号沿用当前 Group 数据；提示也使用该编号，不显示稳定 Entry ID。右侧按钮垂直居中；分支显示名称、选项身份及槽位；角色显示开发语言姓名，完整身份在提示中查看。正常表格不显示文本 key。
+
+同分类共享 key 合为一行，提示引用数量，定位时可选择引用位置；修改影响所有共享位置。搜索匹配文本与完整定位信息；“仅缺译”检查当前显示的非开发语言列，任一列缺译即保留该行，显式空串不算缺译。不再提供草稿或复核状态筛选，也不为每格显示状态文字。
+
+工具栏仅保留搜索、缺译筛选、语言管理、导入和导出。语言管理列出已有语言名称和代码，勾选控制显示列；开发语言固定显示且排第一。候选输入框按代码、本地名称和英文名称搜索 CultureInfo 预设，排除已有语言，支持有效代码直接新增；选中候选或失焦不会隐式添加，点击“＋”才新增。I18nLocale 仍使用标准大小写，包括脚本子标签。语言调序与开发语言切换集中在管理器，不再占据每个列头。列宽可拖动调整，列可见性和宽度只属于项目会话的视图状态，不写入作者历史。
+
+移除语言只修改 AvailableLocales，保留已有翻译文件和指纹证据，再添加时恢复其直接文本；不是物理删除文件。开发语言必须先切换才能移除。移除入口先等待该语言的正在更新输入，失败则阻止移除；语言结构变化清除导入预览，旧单元格写入仍在历史执行边界检查支持语言。添加、移除、调序及开发语言切换均可项目撤销，保留其他设置。
 
-每列对应一种支持语言。开发语言固定第一，其余列按 AvailableLocales 顺序排列，可通过列头左右按钮调序。新增语言规范化并验证 culture，拒绝重复，只新增支持项，不复制任何原文。I18nLocale 使用 CultureInfo 标准名称，包括 zh-Hans-CN 等脚本子标签；项目设置原开发语言字段只读，切换入口在本面板。
+切开发语言时，在对应语言的操作菜单检查，按需显示缺译数量及应用按钮；执行时重查预览证据。缺译数量不代替完整项目检查，不自动翻译或复制文本。项目设置页面的原开发语言字段只读。
 
-切换开发语言分为检查和应用：先显示目标语言缺少的被引用文本数量，入队及历史真正执行时重查当前开发语言、引用 key 集合及目标直接文本；预览过期则拒绝。分析不完整会显示提示，缺译数量不代表完整发布检查。该操作保留全部原有文本，只修改 TargetLocale/AvailableLocales；新增语言、调序和切开发语言均可一次撤销，且不覆盖其他项目设置。
+单元格浏览时显示紧凑的两行文字，活动单元格展开多行输入。输入期间只保留单元格内的未提交文字，失焦、Ctrl+Enter 或 Save All 时提交到 Working，不存在单独的“保存草稿”或复核步骤；清空后提交得到显式空字符串。普通 Enter 换行，Ctrl+Enter 提交当前输入或显式将缺译保存为空串；Escape 放弃尚未提交的输入并退出编辑，已提交内容通过项目撤销恢复。正文输入与浏览摘要均靠左上排列。组字期间不提交候选文字，更新期间输入框保持可编辑及焦点。
 
-单元格区分缺译、空字符串、待复核、复核未知；空字符串可同时待复核，不用运行时回退冒充直接译文。多行 Ctrl+Enter 或失焦提交，Enter 保留换行，Escape 还原，组合输入期间不提交。异步提交将输入框设为只读，保留焦点。译文修改与其对应原文指纹进入同次历史；有直接开发原文时记录关联，缺原文时保持未知。切开发语言后，旧 sourceLocale 的证据不能冒充当前原文的已复核状态。
+连续输入不逐字写作者文档或刷新表格，只在首次变为待提交状态时通知项目保存状态。提交由面板串行协调，值和来源指纹进入同一次项目历史。提交期间新增的文字继续保留，等待下一次提交；目标或来源失效时保留失败输入并就地提示，可重新输入或明确重新读取现值。失效输入不会自动覆盖外部修改。Save All 收拢待提交输入、等待当前提交并阻止未解决错误，再按项目事务写盘。ViewModel 属于项目 scope，切分类或关闭/重开视图不丢失未提交内容。
 
-单元格草稿绑定分类、文本身份、目标译文和开发原文基线。相关 JSON 草稿先校验/提交；无效 JSON 保留，目标值、来源、开发语言或引用变化后拒绝过期写入。前置检查也在历史执行边界重做，不能因入队时有效就忽略前序操作的修改。面板 ViewModel 属于项目 scope，切分类、调列序、关闭/重开视图均保留草稿；Save All 提交所有已访问分类的草稿，冲突保留并阻止保存，可用“放弃草稿”显式清除。干净单元格随作者文档刷新，输入中的草稿不被静默覆盖。每次刷新共用一个派生快照及一次 metadata 解析，不按每个按键/单元格重建全项目索引。
+语言列头不随文本纵向滚动；表头与内容行均明确左对齐，隐藏列使内容宽度小于视口时仍保持列边界一致。定位列通过共享横向补偿冻结，不复制第二套列表。键盘聚焦的输入自动滚入冻结列右侧。分类区域可拖动，窄面板使用分类下拉框。
 
 ## 模板、导出与导入
 
diff --git a/docs/spec/editor-graph.md b/docs/spec/editor-graph.md
index 89f99cb5..203649cf 100644
--- a/docs/spec/editor-graph.md
+++ b/docs/spec/editor-graph.md
@@ -45,4 +45,6 @@ Group 页的类型搜索、批量插入、空格快速插入、折叠拖放和
 
 ## 可见导航工具
 
-画布工具栏提供名称/稳定 ID 搜索、显示全图、定位选择、缩放滑块及比例。滑块缩放保留视口中心；可切换的小地图默认关闭，点击只改变视口，不修改节点坐标或作者历史。Group、Problems 和变量引用使用统一作者导航服务定位当前有效节点/条目；字段存在时 Inspector 滚动并聚焦对应根字段。原有 F、Home 和画布快捷键继续可用。
\ No newline at end of file
+Group 检查器还提供剧情包名 `storyPackage`，空值表示本体，同名 Group 聚合导出为独立剧情包。字段失焦提交到项目历史，复制、撤销和保存重载保留该值；现有包名作为候选。完整操作见 [内容分包与资源补丁](../manual/content-packaging.md)。
+
+画布工具栏提供名称/稳定 ID 搜索、显示全图、定位选择、缩放滑块及比例。滑块缩放保留视口中心；可切换的小地图默认关闭，点击只改变视口，不修改节点坐标或作者历史。Group、Problems 和变量引用使用统一作者导航服务定位当前有效节点/条目；字段存在时 Inspector 滚动并聚焦对应根字段。原有 F、Home 和画布快捷键继续可用。
diff --git a/docs/spec/editor-groups.md b/docs/spec/editor-groups.md
index bdd829d7..90f77b77 100644
--- a/docs/spec/editor-groups.md
+++ b/docs/spec/editor-groups.md
@@ -14,7 +14,9 @@ GUI 使用仓库 Authoring 模式，允许缺必填参数、错误类型的参
 
 作者模式仍拒绝损坏 JSON、重复 JSON 属性/稳定 ID、未知顶层或 Entry 信封字段、非对象参数、无效 Graph 拓扑及不安全/重复归属的源路径，并保留外部文件冲突检查。共享仓库默认 Complete，CLI 写入与 validate/group compile 继续完整校验；预览编译路径亦保持原有严格契约。保存草稿成功不等于能构建或运行游戏。
 
-字段历史执行前检查当前作者值，发现外部变更则拒绝覆盖并保持历史游标。投影通知失败会恢复原作者值和投影；恢复再次失败进入 RepairRequired。
+字段历史执行前检查当前作者值，发现外部变更则拒绝覆盖并保持历史游标。Entry 操作直接更新作者数据，成功后按 [作者内容提交通知](editor-history-and-save.md#作者内容提交通知) 同步投影；可观察列表不再写回作者文档。投影订阅者异常单独记录，不回滚已经提交的作者内容和历史。真正的内容操作失败仍按原历史补偿规则处理，补偿再次失败进入 RepairRequired。
+
+Group 完整验证与构建共用一次编译分析。分析保留逐条目的参数/展开诊断，只在整个 Group 成功时提供编译文档和 SourceMap；CLI 单 Group 编译及项目构建直接消费本次结果，不重新展开同一份作者文档。原始 JSON 的结构检查与宽松作者草稿读取仍保留各自边界。
 
 ## 普通复杂值表单
 
@@ -32,6 +34,12 @@ Timeline 参数常态为“打开时间轴”及帧数/FPS/轨道数摘要。点
 
 生成 DTO 的对象字段按展开创建嵌套表单，常用一维数组/List 支持逐元素编辑、添加、删除与上下移动。三层 registry 在嵌套处仍有效；没有专属工厂时，没有 schema、字典、复杂转换器、超过八层或 200 元素的结构使用明确的多行 JSON 回退。成员覆盖与自定义类型工厂优先于显式 EditorId；无覆盖时显式 EditorId 决定常规工厂，不强行展开声明为 JSON 的字段。JSON 使用 Ctrl+Enter 或失焦提交，Escape 恢复未提交输入。
 
+`effect.apply` 在 Group 条目行内只展示 shader `program` 资源选择；Inspector 保留适用的外层字段。选择了 program 时隐藏仅供内置效果工厂使用的 `id`；未指定 program 时显示 `id`。项目 shader 元数据可用时，Inspector 从 `@gal.effect` 参数声明生成数字、布尔、选项、颜色、向量与纹理字段，逐字段提交到原 `parameters` JSON 对象。`vec2`/`float2`、`vec3`/`float3`、`vec4`/`float4` 分别使用固定 2、3、4 个数值输入，提交时整体更新对应向量。选择 shader 后不再显示原始 JSON 参数编辑区；元数据不可用时显示提示。切换 program 只刷新表单，不自动写入默认值或删除旧参数；未知键及未修改成员保留，旧 program 的字段租约在选择或元数据更新后失效。未指定 program 的内置 effect 路径仍使用原参数编辑方式。`preset.speedLines` 与 `preset.impact` 的参数字段也使用同一 shader 元数据与字段控件，编译器接管的 `time`、`speed`、`flicker` 不列为自定义参数。`preset.motion` 的 Transform 与 `transition.reveal` 的 Center 分别使用已有 Transform 与二维向量控件。
+
+`preset.shake` 和 `preset.impact` 各使用单个 `handleId`，通过共用场景目标选择器选取前文图层；多个目标由多个预设条目分别表达。仍保留 JSON 字段的明确范围：`video.play` 的跳过时间数组、粒子参数模块，以及没有 shader program 的内置 `effect.apply` 参数。跳过时间数组已有固定结构，可继续做专属列表控件；粒子参数按模块和曲线组织，需要独立的分组表单。其他 Transform、Variants 选择、Flipbook 和 Timeline 已由专属控件处理。
+
+选中 shader 的 `effect.apply` Inspector 将预览区固定在底部，与上方字段滚动区分离，沿用图片资源 Inspector 的可调整分隔条和折叠预览。预览在 192×192 示例贴图上用当前 `program`、`parameters` 和声明的额外纹理，经游戏使用的 SkSL 编译与纹理效果路径离屏渲染；修改参数、切换 shader 或刷新资源会重新生成，过期生成结果不覆盖新选择。预览图片只属于 Inspector 会话，不写入作者数据或内容历史；shader 无法编译、资源缺失或参数值异常时显示诊断。
+
 缺省、显式 null 与显式采用默认值在作者文档中独立保留；Group 操作入口按上述简化策略展示。短 DTO 对象默认展开，其余对象/列表可按需展开；组标题本地化，列表元素不重复显示 element 标签，控件按元素类型继续分派。展开不写默认值；对象局部编辑保留未知成员，按当前序列化配置使用实际属性名。每次成功提交通过原字段作者意图产生一条项目历史；列表结构变化取消旧索引绑定，Undo 不使旧绑定复活。折叠对象释放其子控件；Editor 的未提交字段草稿、已提交内容和历史仍属于项目会话。
 
 共享表单不查询游戏状态；Timeline 专属会话使用独立的[场景目标查询](editor-scene-targets.md)。通用 Locator 字段、Timeline 曲线和其他复杂专属控件仍待后续切片。
@@ -40,13 +48,13 @@ Timeline 参数常态为“打开时间轴”及帧数/FPS/轨道数摘要。点
 
 Timeline 是项目级单实例面板，打开后与资源、日志在底部同组；新用户的剧情布局按需打开，动画布局默认激活，可从查看菜单重新打开。它跟随当前活动 Group 页的活动 Entry，多选时使用最后活动项；无选择、普通条目和无效 Timeline 分别显示提示。聚焦工具面板不改变来源，关闭非活动 Group 页不会清除另一页的选择。
 
-树只显示已有属性轨道、当前面板中选择的对象及等待初值的属性草稿。顶部“＋”仅打开场景对象选择器，卡片/搜索/确认与普通字段和 Assets Picker 使用相同组件，不包含属性或初值表单。确认对象后出现对象行；行左侧“＋”弹出尚未加入的属性列表，选择一个属性加入重载，随后直接在叶行编辑当前帧值和绝对/叠加模式。
+树只显示已有属性轨道、当前面板中选择的对象及等待初值的属性草稿。对象轨道标题行的“＋”仅打开场景对象选择器，卡片/搜索/确认与普通字段和 Assets Picker 使用相同组件，不包含属性或初值表单。确认对象后出现对象行；行左侧“＋”弹出尚未加入的属性列表，选择一个属性加入重载，随后直接在叶行编辑当前帧值和绝对/叠加模式。
 
 属性当前值已知时，选择属性直接创建必要的第 0 帧和当前帧键，一次选择是一条项目历史；已经存在的属性不重复列出。值未知时先展示空值草稿行，明确输入数值后才创建轨道；绝对模式使用输入作为缺失的第 0 帧初值，叠加模式首帧为 0。新增属性时展开所属对象。只选对象、取消选择以及等待初值均不写空对象或不完整轨道，面板草稿不进入内容历史/持久化，切换 Entry 后清除；已提交轨道正常保存并支持撤销/重做。
 
 对象、属性组和属性叶行右键打开“取消重载”菜单：属性移除自身轨道，对象/属性组移除全部后代轨道，整次操作只产生一条项目历史；Undo 整体恢复。空对象和等待初值的属性只移除面板草稿，不写历史。菜单捕获的旧树行在来源、帧或作者数据版本改变后失效，不能通过旧索引删除新的轨道。目标查询与字段适配见 [场景目标查询](editor-scene-targets.md#查询与选择控件)。
 
-当前以对象→属性组→属性叶节点展示入口候选及已有轨道；显示创建来源和一定/可能存在，未解析引用保留为编号，不显示底层 handle。属性来自 Core 已声明能力，折叠与选择不进入内容历史，播放头变化保留折叠状态。帧输入不修改作者数据；叶值使用 NumericUpDown，Enter 或失焦确认，Escape 恢复未确认输入。当前帧有键时只更新值、保留切线和插值；没有键时按帧序插入，继承原区间插值和曲线导数。每次确认产生一条项目内容历史，可跨页撤销、保存和重开，未知 JSON 成员保留。
+当前以对象→属性组→属性叶节点展示入口候选及已有轨道；显示创建来源和一定/可能存在，未解析引用保留为编号，不显示底层 handle。属性来自 Core 已声明能力，折叠与选择不进入内容历史，播放头变化保留折叠状态。播放头定位不修改作者数据；叶值使用 NumericUpDown，Enter 或失焦确认，Escape 恢复未确认输入。当前帧有键时只更新值、保留切线和插值；没有键时按帧序插入，继承原区间插值和曲线导数。每次确认产生一条项目内容历史，可跨页撤销、保存和重开，未知 JSON 成员保留。
 
 统一从对象行“＋”添加属性，从右键菜单取消重载；不提供属性勾选、可添加属性模式或更换对象按钮。添加未知初值属性后，确认叶值写入必要的 0 帧与当前帧键，当前帧为 0 时只建一键；绝对模式采用已知初值，否则明确输入值同时用于第 0 帧；偏移模式非零帧创建时首键为零。不因获得焦点或初始化绑定建轨道，重复对象/属性不会新增。
 
@@ -56,7 +64,9 @@ Timeline 是项目级单实例面板，打开后与资源、日志在底部同
 
 属性树按展开状态生成可变高度的可见行（普通行 38、叶属性展开额外增加 176 的值图区域），与右侧关键帧画布共用纵向滚动；折叠父行显示后代关键帧汇总，汇总可选择和拖动：移动该汇总点所在时间的所有后代键，包括折叠隐藏的子项，其他时间的键不变。拖动沿用单历史、首帧和碰撞保护。时间区域支持缩放条、水平滚动条、Ctrl+滚轮锚定缩放及 Shift+滚轮平移；拖动顶部标尺时只重绘播放头预览线，松手后定位并更新属性采样一次，不在每个鼠标移动事件中重建属性行。Escape、捕获丢失、换来源或版本失效取消预览；点击同样在释放时定位，仅改变编辑帧。
 
-画布支持单选、Ctrl 多选、框选、整帧横向拖动、Delete 删除、Insert/按钮在当前帧加键及上一键/下一键定位。加键使用所选键的轨道，或左侧最后点击的属性轨道；已有键只选中，不重复写入。拖动只更新预览，松手一次提交项目历史；越过结束帧时自动延长，撤销同时恢复所有选中键和结束帧。Escape、源变化或捕获丢失取消旧手势。0 帧键不能移动或删除，负帧及整数溢出拒绝；目标碰撞保持非法预览，需明确替换碰撞键或取消，不能覆盖 0 帧键。
+画布支持单选、Ctrl 多选、框选、整帧横向拖动、Delete 删除、Insert/按钮在当前帧加键及上一键/下一键定位。加键使用所选键的轨道，或左侧最后点击的属性轨道；已有键只选中，不重复写入。拖动只更新预览，松手一次提交项目历史；越过结束帧时自动延长，撤销同时恢复所有选中键和结束帧。Escape、源变化或捕获丢失取消旧手势。0 帧键不能移动或删除，负帧及整数溢出拒绝；目标碰撞不提交并保留非法预览，可按 Escape 取消，不能覆盖 0 帧键。
+
+面板首行合并来源、结束帧/FPS 和上一键、下一键、增加键、删除键图标按钮；图标复用透明背景主题，并提供本地化 tooltip 与无障碍名称。对象轨道位于时间轴事件上方，两区默认等分可用高度，中间的水平分隔条可拖动调整上下比例，使用相同标题行高、树列宽和标尺，各自纵向滚动，共享水平滚动。底部右侧仅显示本地化当前帧文本（如“23 帧”）和缩放滑条；不再提供当前帧数字输入、缩放数值、编辑中状态、常驻分析不完整说明和快捷键提示行。无选择/无效内容提示、创建入口与实际编辑错误继续按状态显示；移除拖动时的替换/取消按钮和底部“定位播放头”按钮，Escape 仍可取消拖动或碰撞预览。
 
 结束帧与 FPS 使用 NumericUpDown，Enter 或失焦各自确认，Escape 恢复未确认草稿。FPS 修改保留帧号与切线，只改变播放速度；结束帧下限为最后一个关键帧或事件，输入更小值时钳制到下限，不删除内容。没有保留秒数、应用或裁剪按钮，也不保留旧重定时/裁剪路径；同帧事件顺序和未知 JSON 保留，一次确认一条历史，无变化不增加历史。整体时间缩放另作后续明确操作。
 
@@ -64,7 +74,7 @@ Timeline 是项目级单实例面板，打开后与资源、日志在底部同
 
 右键未选关键帧会先选中它，右键已选关键帧保留多选集合。菜单提供出段 Step/Linear/Hermite、双侧/入侧/出侧切线模式（自由、平坦、线性、自动贝塞尔）、联动/断开及“编辑数值…”弹窗。固定独立详情区已移除；弹窗使用 NumericUpDown 精确输入值、入/出切线，可按秒显示斜率，混合值留空。Enter/失焦确认，Escape 恢复未确认草稿；批量设绝对值与曲线增量拖动是不同动作。任一已知绝对属性端点不满足范围就整批拒绝，不在 Editor 单方面新增区间极值拒绝规则。
 
-曲线键/柄拖动只更新本地预览，松手一条项目历史；Escape、捕获丢失、选择/帧/条目/源版本变化取消旧手势。非法曲线手势释放时取消，不隐式覆盖碰撞键；普通时间轴仍保留原显式碰撞替换。第 0 帧可改值和切线，不能横移或删除。未知 JSON、同帧事件顺序和根字段大小写保留；保存重开及跨页面撤销/重做保持作者内容。
+曲线键/柄拖动只更新本地预览，松手一条项目历史；Escape、捕获丢失、选择/帧/条目/源版本变化取消旧手势。非法曲线手势释放时取消，不隐式覆盖碰撞键；普通时间轴的碰撞预览也可用 Escape 取消，不再提供碰撞替换按钮。第 0 帧可改值和切线，不能横移或删除。未知 JSON、同帧事件顺序和根字段大小写保留；保存重开及跨页面撤销/重做保持作者内容。
 
 键的 Editor 专用 `editorTangents` 保存 incoming/outgoing（Free/Flat/Linear/Auto）和 linked；运行时继续消费原有值/帧斜率，不解释编辑模式。修改值或增删/移动邻键时，自动/线性/平坦派生斜率与当前动作在同一 patch 中重算；无模式的键默认自由且断开，打开页面不补写。平坦为零；线性采用各自相邻段斜率；自动使用前后邻键中心斜率，局部极值为零，其他内部键限制在相邻同号斜率较小绝对值的三倍内，端点用相邻段斜率。此为非加权自动贝塞尔，保存的是 Hermite 等价斜率，不宣称复制其他产品的内部算法。
 
@@ -103,7 +113,7 @@ Timeline 是项目级单实例面板，打开后与资源、日志在底部同
 
 列表内容末尾有约 64 DIP 可滚动留白，不使用伪条目占位。点击列表背景取消选择；行内控件、工具栏、滚动条不误取消，其他 Dock 页不会通过全局点击监听清除此页选择。无选择时后续新增从末尾开始。
 
-参数展开状态由页面按 Entry StableId 保存，通过投影的 IsParametersExpanded 驱动行与拖动预览；它不进入作者 JSON、内容历史或 dirty。移动事件不重新配置字段表单，避免拖动/重排重建参数控件。拖放、重排和同页 Undo 保留折叠，面板重新打开默认展开，不跨重启保存。
+参数展开状态由页面按 Entry StableId 保存，通过投影的 IsParametersExpanded 驱动行与拖动预览；它不进入作者 JSON、内容历史或 dirty。移动事件不重新配置字段表单，避免拖动/重排重建参数控件。拖放、重排和同页 Undo 保留折叠，面板重新打开时已有条目默认展开，不跨重启保存。编辑器全局设置可控制新插入条目的初始展开状态，默认展开；改变设置不重置已有条目。
 
 关闭/重建列表容器不改变条目稳定身份。条目序号仅为展示顺序，重排后可重新编号，不能作为插入锚点或折叠状态的 key。持久化与失败撤销规则见 [历史与保存](editor-history-and-save.md)。
 
@@ -117,12 +127,16 @@ Timeline 是项目级单实例面板，打开后与资源、日志在底部同
 
 粘贴、批量删除和所选集合移动各为一条项目历史。多选时拖动其中一项会按原相对顺序移动整个集合；拖动未选中项先单选该项。折叠状态沿用稳定 ID，不随集合移动展开。Undo 恢复删除项的原位置，Redo 复用本次粘贴的身份；页面关闭不影响这些项目历史。
 
-剪切先等待系统剪贴板写入成功，再删除原条目；写入失败或等待期间原条目发生变化则保留原条目并提示。异步粘贴使用开始操作时的稳定锚点，锚点删除时拒绝；页面销毁或换绑后不执行晚返回。操作失败保持错误反馈，相关提示与历史标题支持四语。
+剪切等待系统剪贴板写入成功后只标记待移动，不删除原条目、不记内容历史；工具栏和原条目显示标记，Escape 或取消移动撤销标记。成功粘贴时以一条历史重排或跨 Group 移动，保留场景输出和播放身份。目标 Group 有 Entry ID 冲突时只分配新的作者 Entry ID，提交结果包含双向地址迁移，Undo/Redo 使用同一组确定的身份。过期、其他项目或重复粘贴票据按普通复制并提示；观察到其他剪贴板内容时取消原移动凭据。剪贴板写入失败或等待期间来源变化保留原条目，变化后再 Undo 成相同 JSON 也不复活旧凭据。异步粘贴使用开始操作时的稳定锚点，锚点删除时拒绝；页面销毁或换绑后不执行晚返回。
 
 嵌套字段提交仍经过根字段的值契约与宿主 partial 校验；其他已有子值使整个对象无法类型化时，失败诊断会显示高级源码入口，可切换 JSON 模式一并修复，当前不绕过根值校验。
 
 ## 常用字段与 Inspector
 
+“显示图层”的翻页动画使用列数、行数、总帧数和从 0 开始的当前帧数值输入框；总帧数不能超过网格容量。仅在明确提交时修改对应成员，保留原有字段大小写与未知 JSON 成员；无效旧数据保留高级修复入口。静态图片无需配置此字段，连续播放由 Timeline 的 `flipbook.index` 轨道驱动。
+
+音频播放、停止、队列操作、音效处理及带语音文本的音轨字段统一使用 ComboBox，候选来自当前项目音轨配置，显示名称与 ID，提交音轨 ID。项目设置变化会刷新候选；既有未配置 ID 保留显示，不因打开表单或刷新候选自动替换作者值。
+
 Group 页面默认在行内展示 DTO 标记为 Common 的根字段，折叠后保留内容摘要。选中与展开独立；单击条目选择，展开箭头不隐式更改作者选择。条件在完整 Inspector 编辑，非空条件在行内显示摘要。工具栏支持内容/类型/条件搜索、输入显示序号定位，以及全部展开/折叠；搜索结果重排按当前作者顺序映射，不把过滤后的索引当作原始索引。
 
 Inspector 为活动条目创建自己的字段控件和绑定租约，显示 Group、条目序号、类型、条件及完整可见参数。锁定时保留目标并持续显示锁定状态；日志、Timeline、Problems 等无自身 Inspector 的辅助工具不会清空作者详情。关闭 Group 页面使原页面字段绑定失效，锁定的 Inspector 使用自己的绑定；项目草稿不随页面释放。多选只沿用已有批量操作，不隐式批量修改详情参数。
@@ -130,3 +144,41 @@ Inspector 为活动条目创建自己的字段控件和绑定租约，显示 Gro
 详情跟随 Dock 的标签激活和面板焦点：从资源区返回已处于活动状态的 Group，仍会恢复条目 Inspector。后台资源/节点选择刷新不抢走当前详情；无 Inspector 的辅助工具也不替换用于解锁恢复的最近作者目标。
 
 字段草稿、源冲突和校验问题通过条目问题标记及 Problems 面板可见。Problems、变量引用和节点查找使用稳定作者身份导航；失效目标不按旧行号重定向。完整参数仍保留未知类型/参数提示，不因 Common 筛选丢弃作者数据。
+
+## 直接编辑与问题诊断
+
+Group 页面上的删除按钮、Delete 键、右键删除、移动粘贴以及换类型直接执行，不显示场景影响确认窗口。保留原消费者引用，引用缺失、目标不可用及分析不完整等诊断在 Problems 中随作者修改、Undo/Redo、资源更新和项目重开自动刷新，无需先点击检查。诊断提供稳定作者身份导航及条目问题标记，不自动弹窗或改绑引用。
+
+准备操作仍绑定原 Graph 文档实例及 Graph/Group 作者内容，提交时在现有历史串行门内检查来源，拒绝过期或重复消费的计划。成功执行是一条现有内容历史，保留输入归档及 Undo/Redo。影响报告按需计算，普通页面操作不预先计算引用变化。
+
+作者编辑允许暂时不完整。Problems 在项目页面初始化、内容提交、Undo/Redo、外部重载及相关资源/文件变化后自动检查内存工作版，220ms 合并连续变动；Graph/Group 契约及编译检查在后台执行，结果发布前核对项目检查代次。变动后旧完整校验错误立即退出活动列表，不要求手动点击才能清除；“检查当前内容”仍可立即重检。逐字输入只更新字段诊断，不自动提交或逐字编译项目。现有编译、内容构建及调试准备继续拒绝确定的契约、参数或结构错误。场景静态推断诊断仍为警告，不直接作为编译门禁，避免将分支、未知扩展等不确定性当作确定错误。活动输入冲突、归档写入失败等已有数据保护继续生效。
+
+合法待提交输入为中性提示，不计入条目问题数；数字 `-`、`.`、`-.` 和未完成指数等中间态在确认前保持中性，Enter/失焦或保存时仍校验。条目问题标记按实际错误或警告分色。常见字段错误显示本地化字段名、预期类型/范围和修正建议，来源显示 Group 名、条目序号/类型及字段路径；原始诊断可展开查看。字段级错误与同条目的重复参数汇总错误合并。有效作者问题点击打开页面、清除阻挡定位的搜索、选中稳定 Entry、展开参数并打开 Inspector，尽可能滚动聚焦字段；源位置已失效时无有效跳转按钮，点击旧请求再次核对身份，不按旧序号定位。Graph、文本文件和项目设置按对应入口打开。
+
+本地化分析不完整的诊断同样使用诊断自身携带的 Entry 稳定身份导航，不依赖是否成功识别引用；JSON Pointer 解码为根字段及嵌套路径。`field.opaque` 表示缺少可遍历的结构定义，显示为引用检查未覆盖的警告，不将其描述为字段值无效；原始消息保留在技术详情。
+
+已知固定结构通过公共属性树检查，正常 Transform/Flipbook 不再产生 opaque；未知扩展及尚未接入的动态结构继续报告未覆盖。类型化 Path 可表达字符串编码对象的内部位置，Inspector 优先按完整 PropertySegments 匹配，随后仅对没有路径信息的旧控件使用唯一字段名回退。专用 Transform/Flipbook 控件保留现有排版并共享子字段元数据、约束及局部修改；通用结构采用单一可折叠 Header、缩进和主题间距，字典使用键/值行与显式结构操作。
+
+普通数字在 Editor 使用保留文字草稿的 NumericUpDown，Enter/失焦提交，Escape 恢复输入，上下按钮/方向键按步长确认修改。`numericupdown`、`numerictext` 和 `slider` 可由字段元数据指定，宿主工厂仍可覆盖；`slider` 在 Editor 配对精确输入框，手输值不按滑块步长量化。已有 0–1 范围的 Variants 透明度和音频增益声明 slider。long/ulong/decimal 保留无损文字路径；滑块范围/类型或步长不适用时回退并提示。浮点文字支持 `.3`、`.22`、`-.3`，成功提交后显示合法 JSON 数字；Transform、向量、音效参数及 Save All 草稿提交共用解析规则，原始 JSON 输入继续严格。
+
+换类型通过统一语义目录按逻辑输出角色、身份域和目标种类迁移相容身份；字段名不同也可相容，例如普通层 handleId 与转场 newHandleId/toLayerHandleId，普通动画 playbackHandleId 与 Timeline 根播放身份。新增或不相容角色分配新身份，不自动改绑旧消费者。旧参数仍由类型变更历史保留以支持 Undo；旧表单失去提交权。引用规则见 [场景目标查询](editor-scene-targets.md#作者关系与引用诊断)。
+
+## Entry 输入归档与恢复
+
+Entry 作者操作删除目标、换类型或跨 Group 移动时，将相关未提交输入存入项目输入恢复区，并撤销旧输入的提交权；Undo 新增/粘贴时移除目标也走同一路径。同 Group 重排保留现有输入。归档为中立地址、类型、字段路径、根值基线、原始文本及校验状态，不保留旧控件或 ViewModel。
+
+归档和恢复请求不参与 Save All。撤销恢复作者内容后，Problems 提供恢复按钮及可复制的原始文本；作者明确请求后，由新字段绑定核对来源、类型、路径、字段类型和根值基线后接收。尚未打开或展开的子字段继续留在恢复区，真正恢复为活动输入后才重新参与保存。已有源冲突的归档不能直接恢复，但可以复制或明确丢弃。
+
+输入恢复文件位于 `.galnet/editor/input-archive.json`，独立于游戏作者文件和撤销栈，保存项目、清空历史及关闭重开均保留。默认最多 1,000 条且序列化不超过 16 MiB；不足时在修改作者内容前拒绝操作，Problems 提供查看/复制/丢弃。载入时发现恢复文件损坏则保留原文件并阻止需要写入的新归档，不静默覆盖。普通活动草稿及直接源冲突仍遵守原保存门禁。
+
+整 Group 删除、撤销 Group 创建及文件树删除关联 Group 也归档目标的未提交输入。结构服务先完成等待、候选和双版本校验，再在实际同步发布边界捕获最新输入；归档失败不会开始作者文件发布。文件删除准备提交其他有效草稿时，明确排除即将归档的 Group 输入，因此目标中的无效文字不会先阻止删除。Working/Saved 继续分别恢复，Undo 不自动激活归档输入。
+
+作者 incarnation 只随删除、换类型和离开原 Group 等作者生命周期变化推进；页面关闭只释放字段表单，不推进作者代次，因此常用字段与 Inspector 的有效草稿仍跨页面共享。旧控件不会因 Undo 恢复提交权。历史与恢复协议见 [历史与保存](editor-history-and-save.md#entry-输入草稿与保存反馈)。
+
+## 派生呈现与对象释放
+
+搜索声明依赖类型、摘要、条件和显示序号；这些属性改变以及 Undo/Redo 时，已挂载的筛选列表重新求值。摘要和场景 Picker 共用来源描述：显示资源名、Group/Entry 来源或未解析提示，不直接展示输出/目标 handle。资源名称在后台读取，最多缓存 512 个名称、并发准备 64 项；资源刷新使旧准备失效，关闭项目取消准备。语言和标签变化只刷新呈现，不推进作者历史或取消有效输入。
+
+活动 Group 投影拥有活动 ViewModel。移除后只留有限弱缓存（每 Group 最多 512 个 Entry、项目最多 64 个已退出 Group），用于仍被借用对象的短期复用；Undo 可以从中立 DTO 重建。文档服务也只弱跟踪退出的 Group 文档，仍有外部持有者时保持其文档身份。项目输入仓库弱持有干净字段，强持有未完成输入；输入记录通过中立作者数据和项目适配提交，不长期强持有 ViewModel。清空或淘汰历史不会隐式丢弃归档文字，已删除的 ViewModel 即使历史尚在也可回收。
+
+Problems 的旧检查结果不再展示为活动问题，自动检查期间显示检查中；归档恢复提示不计入活动错误数。场景诊断继续按当前作者版本刷新。
diff --git a/docs/spec/editor-history-and-save.md b/docs/spec/editor-history-and-save.md
index 4d53b134..0cc248c1 100644
--- a/docs/spec/editor-history-and-save.md
+++ b/docs/spec/editor-history-and-save.md
@@ -12,24 +12,42 @@
 
 历史串行执行异步编辑；同步入口在有编辑执行时拒绝重入。执行、撤销与重做都在成功后移动游标；失败不截断 redo。复合操作补偿已完成步骤，每个单独步骤必须自行保证失败时保持输入状态。补偿失败进入 RepairRequired，禁止继续编辑/写盘并保留作者恢复快照，用户需检查恢复材料再重新打开。通知观察者失败记录日志，不将已提交内容伪装为应用失败。
 
+### 作者内容提交通知
+
+`UndoRedoHistory.AuthorChanges` 在一次成功 Execute、Undo 或 Redo 完成并更新历史游标后发布一个 `AuthorChangeSet`，版本单调增加。Group 范围包含稳定 Group/Entry 身份、最早受影响位置及条件/参数/类型/成员/顺序变更标记；复合操作合并子范围。尚未声明完整范围的旧操作及混合复合操作标记 UnknownScope，消费者保守刷新。失败及其补偿不发布内容结果；Clear、MarkSaved、忙碌状态和空 Undo/Redo 不生成内容提交。发布期间禁止历史重入，单个订阅者异常记录在通知错误中，不阻止后续订阅者。
+
+Entry 字段、批量新增/粘贴/删除/重排直接修改项目作者数据。Group 的可观察集合只由投影同步更新，外部不能通过增删该集合写回作者文档；列表通知的接收者读取到的是完整作者操作。投影集合的单个观察者异常单独记录，既有内容与历史继续有效。Group 投影和 Timeline 的内容刷新使用成功提交事件；历史按钮、保存状态及其他尚未迁移的界面仍可使用 History.Changed。已知 Group 范围按 Entry 身份刷新投影，场景查询按受影响 Group 更新作者快照并复用分析；现有查询结果与写入上下文未变化时不广播作者刷新。Timeline 自身按活动 Group 接受作者提交，其他 Group 通过实际场景查询变化触发刷新。UnknownScope 仍保守刷新。
+
 ## 保存全部与关闭
 
 GUI 的项目保存统一经过项目 scope 的 `ProjectContentSession`。先提交设置草稿，在历史捕获租约中复制同一版本的 Graph、全部 Group 与完整设置，再形成一次写入/删除计划。普通保存的后台文件发布不持有历史捕获租约，用户后续编辑保留为新的未保存内容。不能在持有发布门时等待历史门，否则会与结构编辑形成锁反转。
 
-Graph、Group、settings 与当前 editor-state 在同一作者文件事务发布。变量定义以 Graph 为准，settings 中的变量副本由序列化派生。视口状态可以单独保存，不会自动保存其他作者内容。外部改变已有作者文件或 settings 后，保存明确失败，不以自己的旧内容覆盖；不承诺跨进程多文件原子性。
+Graph、Group、settings 与当前 editor-state 在同一作者文件事务发布。变量定义只保存在 Graph 中，settings 不再包含同名列表。视口状态可以单独保存，不会自动保存其他作者内容。尚未采纳的外部作者文件或 settings 变化会使保存明确失败，不以自己的旧内容覆盖；不承诺跨进程多文件原子性。
 
-GUI 的 Repository 显式使用 Authoring 验证策略：Raw Group 可以保留未知类型/参数、缺必填值、无效参数类型或未完成条件表达式，Graph 分支条件也可保留未完成文本；保存不 Normalize、不补默认值。当前格式、稳定身份、严格 JSON shape、重复属性、Graph 拓扑、源路径/归属及外部冲突仍检查。仓库默认 Complete 供 CLI 严格写入使用，validate/group compile 和预览编译不因 GUI 草稿可保存而放宽。保存后继续撤销类型变更会恢复原作者 JSON，并重新成为未保存内容。
+GUI 的 Repository 显式使用 Authoring 验证策略：Raw Group 可以保留未知类型/参数、缺必填值、无效参数类型或未完成条件表达式，Graph 分支条件也可保留未完成文本；保存不 Normalize、不补默认值。当前格式、稳定身份、严格 JSON shape、重复属性、Graph 拓扑、源路径/归属及外部冲突仍检查。仓库默认 Complete 供 CLI 严格写入使用，validate/group compile 和外部调试构建不因 GUI 草稿可保存而放宽。保存后继续撤销类型变更会恢复原作者 JSON，并重新成为未保存内容。
 
-GUI 的 dirty 状态统一由 ProjectContentSession 依据当前作者内容与最近成功保存内容比较，独立于历史位置；History.IsDirty 查询同一会话，保存和关闭检查不依赖 Document 或 GalProject 的手工 dirty 标记。比较忽略 Group 查询字典的插入顺序、参数查询顺序和显示行号；保留实际 Graph/Entry 顺序与 JSON 值。保存失败不更新基线，保存期间产生的新编辑仍为 dirty。设置草稿也参与关闭脏检查。
+GUI 的 dirty 状态统一由 ProjectContentSession 依据当前作者内容与最近成功保存内容比较，独立于历史位置；History.IsDirty 查询同一会话，保存和关闭检查不依赖 Document 或 GalProject 的手工 dirty 标记。比较忽略 Group 查询字典的插入顺序、参数查询顺序和显示行号；保留实际 Graph/Entry 顺序与 JSON 值。保存失败不更新基线，保存期间产生的新编辑仍为 dirty。设置草稿也参与关闭脏检查。`ProjectContentBaseline` 保留已保存快照，直接比较当前内存内容，读取状态不再执行全项目 JSON 克隆和序列化；可变作者模型的直接修改仍可被识别。草稿登记、预校验、提交和取消由 `ProjectDraftRegistry` 管理，发布门与历史捕获门仍由 ContentSession 统一协调。
 
 关闭项目或应用时先挂起并等待当前编辑与保存队列，取消尚未开始的自动保存。若有未保存内容，提供 Save All、Discard Unsaved Content、Cancel；取消保持原项目与草稿，保存失败也保留会话。保存期间再次产生未保存内容时重新检查，不能保存旧捕获版后直接关闭。放弃只丢弃未保存内容；已经完成的结构写盘不反向撤销。
 
+## 外部内容热重载
+
+`ExternalProjectSnapshotReader` 后台读取 Graph、Raw Group、settings、本地化和受管理文本的独立候选，前后核对文件集合与字节，使用 Authoring 结构策略校验。项目级 `ProjectExternalChanges` 合并文件事件并定期复核；prepared/publishing/repair-required 事务尚未完成时不采纳中间文件。
+
+`ProjectContentSession.ReloadExternalAsync` 在历史捕获门及发布门内重新核对候选。项目干净且无输入草稿时自动采纳；项目有本地修改时保留并报告冲突。明确放弃并重新加载会先捕获作者恢复快照，调用已注册草稿的取消方法；未能取消的组字/进行中输入仍阻止采纳。这里的作者恢复快照只包含已应用作者内容，不承诺保存所有控件原始输入；已归档 Entry 输入另有独立恢复文件。
+
+采纳保持当前项目 scope、Graph 和既有 Group 文档身份，按稳定 ID 更新内容与视图，并同时推进 Repository 源字节、settings、受管理文本和 GUI 保存基线。旧内容 Undo/Redo 作为历史边界释放，外部修改不生成 AI 专属历史。自己的保存/结构发布推进相同基线，后续监听事件不清除其历史。跨会话回退可由 Git 完成。
+
+首版以整个项目判断本地冲突，不做自动三方合并。契约 DLL 变化单独报告并要求重新打开项目；正在运行的游戏预览不自动重演。操作说明见[外部工具创作](../manual/external-project-authoring.md)。
+
 ## 结构计划与恢复材料
 
 `IProjectStructureChange` 分别对 Working 与 Saved 版本应用同一结构意图，允许删除/恢复保留各自的 Group 内容。`PublishStructureAsync` 只发布变换后的保存基线，内存仍保留原有未保存字段。后续保存再撤销路径变更时，变换应用于当时的基线，不用旧整份文件覆盖刚保存的其他字段。`IProjectFileStructureChange` 可附带普通文件、目录与大小写改名计划，与 Graph/Raw Group/settings 一起发布；项目文件界面与文本缓冲已接入。项目拥有的文件描述项使用稳定会话 ID，独立保存 path、存在状态和受管理文本字节；关闭视图不删除该状态。删除项的保留字节不参与当前 dirty 比较，但仍保留于历史/恢复材料，以支持分别恢复 Working/Saved。支持矩阵与引用规则见 [项目文件操作](editor-files.md)。
 
 作者文件事务材料位于 `.galnet/editor/transactions/<id>/`：manifest 记录路径、前后内容哈希与 prepared/publishing/committed/repair-required 状态，编号 `.old`/`.new` 文件保留备份与新内容。失败逆序恢复；恢复失败保留目录。打开项目时检查未完成计划，只在现有内容匹配记录的旧/新哈希时恢复，发现外部内容则拒绝覆盖并报告材料位置。成功材料清理失败只记录并延后清理，不将已成功发布报告为保存失败。
 
+输入生命周期通过结构发布的同步过渡注册接入：候选 Working/Saved、验证和文件计划已准备后，过渡包装实际文件/作者发布。等待期间的输入由这个边界重新捕获，期间不再 await。Group 删除的归档失败先于文件写入；发布失败恢复原归档，恢复失败封锁项目写入。归档仍是独立恢复文件，不承诺与作者事务跨进程共同原子提交。文件操作的草稿提交上下文可声明即将移除的 Group；仅这些 Entry 输入留待归档，其他登记草稿继续原提交规则。
+
 作者恢复快照位于 `.galnet/editor/recovery/`，包含版本、时间、载荷及 SHA-256；`ProjectRecoveryStore.Read` 验证完整性。默认有变更时每 30 秒捕获，关闭前及事务失败时也捕获；仅保留最近 3 份。历史默认 200 步，已声明的持有数据和恢复快照各按可配置 1 GiB 软预算淘汰，最新完整快照即使单份超预算仍保留。淘汰历史或截断 redo 会释放该记录自有的 disposable 资源。它不是进程堆内存硬限制，也不是跨重启历史。
 
 删除记录为历史保留，路径复用后同一路径可以同时拥有删除身份与一个有效身份；保存期望按有效路径归并，不分别要求同一路径既存在又不存在。多个有效身份占用同一路径仍是冲突。
@@ -43,10 +61,18 @@ GUI 的 dirty 状态统一由 ProjectContentSession 依据当前作者内容与
 
 ## Entry 输入草稿与保存反馈
 
+嵌套字段值的读取和局部修改复用 Core.ValueDocument。EntryEditSession 将现有子路径解析到当前结构，Save All 不再维护另一套成员/数组寻址；数字、空串/缺省及文本引用仍走原字段提交链路。包含 `/`、`~` 或数字的 Map 键按键身份处理。关闭全部视图后仍能提交值草稿，保持兄弟/未知成员并进入原 Undo/Redo；列表重排、换类型和作者代次规则不放宽。字典新增/改键属于显式结构操作，其未成功候选仅留在当前控件，不计为已归档字段值草稿。
+
 `EntryEditSession` 为项目 scope 拥有的输入会话，以 Group、Entry 稳定身份、来源代次和字段路径管理草稿。行内和 Inspector 创建各自控件，共享输入状态与现有作者提交意图。切条目、折叠、关闭面板、切语言或套用布局保留尚未提交的输入；Escape 或 Problems 中取消草稿明确丢弃它。源值、类型或列表结构改变后，旧草稿标记冲突，不写入新来源，也不因撤销而静默复活旧绑定。
 
 项目内容变化时检查草稿来源；已经观察到的来源冲突不会因为撤销恢复了相同 JSON 而自动解除，需明确取消旧草稿后重新编辑。
 
-Save All 经过现有草稿登记统一尝试提交；有效提交进入项目历史，不能转换、冲突或正在组合输入的草稿阻止此次写盘并保留输入。保存前已有的有效草稿提交可能已成为作者修改，保存失败不会伪装为这些修改从未发生。自动保存沿用相同规则，不弹出打断式对话框。未完成控件输入仅保留在当前项目会话，不承诺跨进程恢复。
+Save All 经过现有草稿登记统一尝试提交；有效提交进入项目历史，不能转换、冲突或正在组合输入的草稿阻止此次写盘并保留输入。保存前已有的有效草稿提交可能已成为作者修改，保存失败不会伪装为这些修改从未发生。自动保存沿用相同规则，不弹出打断式对话框。活动控件输入仅保留在当前项目会话；Entry 作者操作归档的输入另按下面的恢复区规则持久保留，不承诺恢复所有未归档控件输入。
+
+状态栏分别显示保存状态、待处理输入和作者检查状态；保存成功不等于可以运行。发布期间的新编辑仍为未保存内容。Problems 自动检查当前作者工作快照并复用 Graph/Group/本地化规则，变动后撤下旧活动结果，明确显示检查中及不完整分析；合法待提交提示不计入条目错误数。普通日志不靠解析字符串猜测跳转位置。诊断展示与数值输入规则见 [Group 编辑](editor-groups.md#直接编辑与问题诊断)。
+
+删除/换类型/跨 Group 移动以及 Undo 新增/粘贴导致 Entry 移除时，项目输入会话在同一历史门内协调受影响输入，采用独立恢复区保存原始文本。归档不参与 dirty/Save All，明确恢复至新绑定后才成为活动输入。恢复区有独立硬预算，不因历史淘汰或 Clear 自动删除；完整规则见 [Group 输入归档](editor-groups.md#entry-输入归档与恢复)。
+
+整 Group/文件删除及 Undo Group 创建同样进入输入归档边界，保留 Working/Saved 结构语义。活动草稿仓库只强保留未完成输入；干净字段随控件借用者释放，输入提交适配不强持有页面或 Entry ViewModel。保留未完成输入的容量取决于实际用户输入，不静默截断文字；持久归档另受明确硬预算约束。
 
-状态栏分别显示保存状态、待处理输入和作者检查状态；保存成功不等于可以运行。发布期间的新编辑仍为未保存内容。Problems 检查当前作者快照并复用 Graph/Group/本地化规则；不完整分析与已过期结果明确显示，普通日志不靠解析字符串猜测跳转位置。
+输入归档先发布恢复文件，再执行作者步骤；步骤失败恢复旧恢复文件，复合操作后续失败还通过本次事务的逆序回滚钩子恢复草稿状态。任一输入补偿失败进入 RepairRequired，历史门在同步/异步失败路径上均释放。观察者通知仍发生于稳定提交后，不参与作者补偿。跨 Group 移动在 AuthorChangeSet.Moves 中附带实际方向的地址迁移；Undo/Redo 发布新的单调版本。
diff --git a/docs/spec/editor-scene-targets.md b/docs/spec/editor-scene-targets.md
index 76a20829..047d08a6 100644
--- a/docs/spec/editor-scene-targets.md
+++ b/docs/spec/editor-scene-targets.md
@@ -1,9 +1,13 @@
 # Editor 场景目标查询
 
+音频效果现在使用同一作者快照、Graph/条件/固定点和前缀分析机制，结果使用独立的音频状态与完整性，详见文末“音频效果域”。
+
 `Editor.Shared.Services.SceneTargetAnalysis` 对作者 Graph 和 Group 快照进行纯分析，不创建游戏、不执行 Entry，也不读取或修改玩家数据。项目 scope 的 `ProjectSceneTargets` 是场景状态查询入口，按当前内存作者快照复用一代分析，包含 Group 入口事实；修改、撤销、重做或拓扑改变后整体换代，保存相同内容复用原代。项目 scope 释放时清除缓存并使旧查询选择失效。场景分析仍为同步纯计算，没有增量前缀缓存；效果声明与已编译图集定义的资源读取和解析在后台准备，完成后发布不可变快照并推进查询代次。
 
 普通查询位置是某个 Group 的某个稳定 Entry **执行前**，null 表示 Group 末尾；`AtTimeline` 查询指定 Timeline 的帧或事件前位置。目标来源为 Group ID、创建者稳定 Entry ID 和输出槽位组成的 `SceneLocator`，Timeline 事件创建者另有事件身份，内部解析到运行时 handle。返回对象种类、来源、资源提示、能力、唯一可知数值与存在性；候选的存在性只有一定存在、可能存在。没有入口或尚未分析到的位置返回不可分析结果，不伪造空场景已经完整分析。
 
+生产项目的查询服务订阅作者成功提交结果，捕获完整作者版本并发布 Changed；普通删除及撤销不再需要借助资源刷新才能通知查询消费者。Timeline 同时按提交结果读取最新作者内容，不用历史忙碌或保存状态变化代替内容事件。当前仍采用整作者快照代次，查询依赖/结果的局部版本尚未接入。
+
 所有可达 Graph 边参与保守合并，不求变量表达式的具体值：确定集合取交，可能集合取并；属性初值只有在所有输入都确定存在且数值相同时保留。空条件或字面量 true 执行，字面量 false 跳过，其他条件合并执行与跳过两路。循环工作队列求有限事实固定点；预算耗尽时只发布可能候选并标记不完整，不把未收敛状态当确定事实。
 
 两条分支若手工复用同一底层身份却产生不同对象类型，合并后保留为可能的未解析目标，不宣称其中一种类型一定存在，也不提供推测出的属性能力。
@@ -42,6 +46,8 @@ Move/Replace 保留已创建对象的 flipbook 能力，重新 Show 静态层移
 
 缺声明的效果仍具有已知身份和 Core 能力，按目标标记 CapabilitiesComplete=false。对外结果汇总当前能力完整性，内部组合查询仍保留语义完整性：停止此效果可以消除能力缺失，不会抹掉上游未知语义。条件、分支、Timeline 事件/未来候选和采样沿用同一声明；未来或可能对象不提供唯一当前数值。
 
+引用诊断按实际目标判断覆盖：已确定且能力完整的目标，不因其他对象缺少 metadata 而退化为 scene.reference.uncertain。Timeline 轨道还须确认对应属性受支持且当前值已知；目标自己的 shader 缺失、不支持该属性或属性值不能确定时仍保留提醒。整体查询 Complete、条件/未知语义和删除/重排影响分析的保守边界不因此改变。
+
 资产目录 Changed 通知使资源快照失效并重新准备。完成、刷新和项目释放都推进查询代次；旧资源加载不能覆盖新代，旧 Locator 选择、属性行和手势不能提交。取消单个 PrepareAsync 调用只取消该调用方的等待；刷新或项目释放才取消共享加载。Timeline 订阅变化并更新属性菜单/行，既有轨道与未知作者 JSON 保留，查询和刷新不写内容历史。没有实时游戏预览。
 
 ## Timeline 帧内查询
@@ -58,9 +64,9 @@ Timeline 事件作者界面使用独立事件行，按帧和同帧作者顺序
 
 事件画布复用共享选择/框选/整帧拖动，多事件可以在同一帧，帧 0 事件也可以移动；不使用属性关键帧的碰撞替换或首键限制。拖动仅预览，松手把移动和需要的时长延长合成一次内容历史，负帧拒绝、Escape 取消。事件右键支持同帧提前/延后和批量删除，未知事件保留原 JSON，可移动和删除，禁止进入不受支持的表单。
 
-事件参数弹窗通过 `DtoEditorHost` 使用同一个 `EditorRegistry`：整 DTO、成员及默认类型控件均可复用。Editor 外观由 Group 与事件弹窗共同引用 `AuthorFormStyles.axaml`；图片/效果程序成员复用资产选择控件，目标成员复用场景选择控件。输出身份隐藏；目标候选使用该事件执行前的位置，不包含同帧后续或未来创建者。表单修改先进入可取消草稿，点击应用才以单次历史 patch 参数；未改字段、未知扩展和作者大小写保留。帧/目标/相关作者版本改变或关闭后旧草稿不可提交，查询、打开、取消和语言切换均不写内容。实时预览仍不在范围内。
+选中单个可编辑事件后，Inspector 通过 `DtoEditorHost` 使用同一个 `EditorRegistry`：整 DTO、成员及默认类型控件均可复用。Editor 外观由 Group 与事件 Inspector 共同引用 `AuthorFormStyles.axaml`；图片/效果程序成员复用资产选择控件，目标成员复用场景选择控件。输出身份隐藏；目标候选使用该事件执行前的位置，不包含同帧后续或未来创建者。表单修改先进入可取消草稿，点击应用才以单次历史 patch 参数；未改字段、未知扩展和作者大小写保留。帧/目标/相关作者版本改变或关闭后旧草稿不可提交，查询、选择、取消和语言切换均不写内容。前后关键帧导航同时考虑事件帧。实时预览仍不在范围内。
 
-GUI 新增或切换为内置层、视频、粒子、效果创建条目时分配新的内部 GUID；animate 同时分配播放身份。六种内置转场分配输出新对象和播放身份，输入对象仍由作者选择。打开作者内容不会补写身份。
+GUI 新增内置层、视频、粒子、效果创建条目时分配新的内部 GUID；animate 和六种内置转场同时分配播放身份，Timeline 有根定义时也分配根播放身份。换类型按统一声明的逻辑输出角色、身份域和目标种类保留相容身份，包括不同输出字段名和 Timeline 根播放路径；新增或不相容角色分配新身份。转场输入对象仍由作者选择，打开作者内容不会补写身份。
 
 Group 条目粘贴先为批内创建者和 Timeline 播放/事件输出分配身份，再按已声明的引用槽位重映射批内引用。Graph 粘贴使用覆盖全部选中 Group 的同一批次映射，因此跨 Group 的对象、播放、Timeline 轨道/事件引用一起指向复制后的创建者。转场的输入引用仅在输入创建者也被复制时改写，转场输出和播放身份独立更新。外部引用、资源 ID、不相关 JSON 字符串、未知自定义条目的同名参数保留。重复粘贴生成不同身份，同次粘贴的身份随 Undo/Redo 保留。
 
@@ -96,8 +102,38 @@ animation.stop 的播放字段使用共享卡片选择器，显示本地化播
 
 共享 Avalonia `ResourcePickerPanel` 提供搜索、卡片、可选缩略图、方向键高亮、Enter 确认和 Escape 取消；原 Assets Picker 与 Editor 的 `SceneTargetPicker` 均使用此面板。资产文件与场景创建实例是不同的数据源，场景中使用同一资源的两个对象分别显示。搜索无结果时清除当前选择，不会确认上次目标；语言切换不写作者数据。
 
-内置 layer.hide/move/replace、video.stop、animation.animate 的目标，effect.apply 的目标层，以及 effect.stop、particle.stop 的实例字段通过 DTO 成员映射使用场景选择控件，不为所有字符串注册同一控件。创建者的内部输出身份从普通生成表单中隐藏，尚未解析的既有引用显示提示并保留原值；重选或清空才修改参数。effect.apply 的空目标显示“整个场景”。播放停止字段复用同一控件并使用独立的播放查询域；转场输入字段仅提供层候选。
+内置 layer.hide/move/replace、video.stop、animation.animate 的目标，effect.apply 的目标层，以及 effect.stop、particle.stop 的实例字段通过 DTO 成员映射使用场景选择控件，不为所有字符串注册同一控件。创建者的内部输出身份从普通生成表单中隐藏，尚未解析的既有引用显示提示并保留原值；重选或清空才修改参数。effect.apply 的空目标显示“整个场景”。播放停止字段复用同一控件并使用独立的播放查询域；转场输入字段仅提供层候选。animation.animate 的属性选择来自所选目标的当前可动画能力，包括 shader 元数据提供的标量属性；无目标时不列出全局属性，旧值保留且不自动改写。
 
-选择器展示一定存在与可能存在两类候选；不完整分析显示提示，仍允许作者选择可能目标。控件自行管理展示和焦点，字段与 Timeline 各自保存结果；没有统一弹窗调度服务。普通字段确认是一条项目内容历史，候选查询、搜索、取消均不写内容。切换/删除条目、改变作者数据或关闭项目后，旧选择不能提交；保存相同作者内容不使选择失效。
+选择器展示一定存在与可能存在两类候选；不完整分析显示提示，仍允许作者选择可能目标。控件自行管理展示和焦点，字段与 Timeline 各自保存结果；没有统一弹窗调度服务。普通字段确认是一条项目内容历史，候选查询、搜索、取消均不写内容。切换/删除条目、改变写入方参数或相关查询结果、关闭项目后，旧选择不能提交；无关作者修改、名称/语言刷新和保存相同作者内容不使选择失效。相关变化后再撤销不会复活旧选择。
 
 验证记录见 [P6e1](../../features/F-20261015-02-editor-authoring-workspace/phase-6e1.md)、[P6e2b](../../features/F-20261015-02-editor-authoring-workspace/scene-locator-plan.md) 与 [P6e4a](../../features/F-20261015-02-editor-authoring-workspace/phase-6e4.md)。
+
+## 作者关系与引用诊断
+
+Editor.Shared 的 `SceneAuthoringSemantics` 集中声明内置 Entry 的输出逻辑角色、JSON 字段、对象/播放身份域、引用允许的目标类别及图集/全局目标约束。自动身份、复制重映射、普通输出字段隐藏、目标筛选和引用索引共用此声明；场景中立类型也由该目录明确列出。值约束继续由原 schema 负责，具体状态转换继续使用已有纯分析和 Core 能力，不执行项目提供的扩展代码。
+
+`SceneReferenceIndex` 扫描所有 Group，包括未打开和不可达的 Group，记录 `(GroupId, EntryId)`、JSON Pointer、原始身份、定义/使用槽位、Timeline 帧/事件位置及覆盖诊断。Timeline 外壳成员按既有大小写规则处理，事件参数遵循对应 Entry 的 wire 字段。对象身份和播放身份分域；复制只改已声明槽位和批内同域引用，不替换资源 ID、普通字符串和未知 JSON。同一原始身份可以有多个候选定义，索引不声称某个消费者唯一依赖其中一个创建者。
+
+`SceneReferenceAnalysis` 在实际引用位置调用场景分析，分别报告缺少目标、仅可能存在、无法完整判断和不可达；未知类型、关系结构及预算不足单独报告覆盖不完整。索引遍历有 10,000 步预算和八层 Timeline 嵌套保护，达到上限保留已知事实并明确标记不完整。Timeline 轨道检查第 0 帧的目标可用性，事件在其执行前位置检查；诊断不是运行期每帧监控。
+
+可选的操作影响报告通过比较前后场景快照得到，既比较剩余引用，也比较可达 Group 的出口状态。因此删除创建者、删除 hide/stop、同名输出的来源变化和跨 Group 后继均能进入影响结果；同批删除的消费者不作为外部断引报告。未知内容或分析不足不能被解释为没有影响。报告按需计算，Group 页面直接提交操作，不显示影响确认；Problems 从当前作者快照自动刷新引用警告，不要求先执行检查。场景推断警告不替代严格编译/构建的数据校验。
+
+普通托管查询根据作者提交范围捕获不可变 Group 快照；已知 Entry 编辑只克隆受影响 Group，不在每次查询/IsCurrent 时序列化全项目。结构/未知范围和外部重载完整捕获，绕过作者服务直接修改 DTO 的调用必须显式通知文档服务。没有 journal 的独立查询保留快照比较回退。
+
+分析复用入口和内容均相同的 Group 出口，并在变化组复用相同前缀检查点，每代最多 128 份检查点；新代不保留旧分析对象。Graph 固定点仍遍历可达节点，出口相等时不重复传播；循环预算与保守降级不变。最多保留 256 个位置查询；结果事实版本、写入方上下文版本和全局诊断来源版本分别使用。每次提交核对已有位置，因此不会因错过中间查询而复活旧 lease；缓存淘汰后的新查询也使用新版本。Timeline 继续核对自身根值、对象身份、帧和查询结果，无关编辑不会丢失现有数值输入。
+
+`ProjectSceneTargets.Diagnostics()` 在项目当前作者/资源代次上生成带版本的结构化诊断。Problems 显式检查后显示这些警告，随后内容提交、撤销/重做及资源查询刷新更新场景诊断，保留作者位置和 JSON Pointer 供导航及检查使用。缺目标和不完整分析均不新增保存/编译门禁，也不清空、重绑或删除已有作者引用。
+
+摘要与 Picker 使用相同来源描述适配。摘要的只读检查复用纯分析和前缀缓存，不占用交互选择 lease 的位置缓存，因此滚动/筛选大量条目不会仅因摘要读取淘汰已打开的选择。资源名后台准备与作者/查询版本分离，迟到的旧资源名称不会覆盖新资源代次；名称和语言更新不改变作者内容。
+
+## 音频效果域
+
+`SceneTargetResult.AudioEffects` 独立返回音频挂载候选，`AudioComplete` 独立于视觉/播放候选完整性。`AudioEffectKey` 包含 scope、targetId、instanceId，候选保留可能的创建来源和类型集合。它们不进入可动画场景对象列表。`SceneAuthoringSemantics` 的 `AudioEffect` 身份域同时供自动分配、输出隐藏、引用索引和复制重映射使用；同一字符串在不同挂载目标不串改，Track/Bus 声明 ID 与算法类型 ID 不参与实例重映射。
+
+apply 创建/更新精确键；stop 删除单个精确键，all 显式清空一个目标；update 不创建对象、不改变类型或存在性。音源停止和混音音量修改保留挂载效果。分支合并确定集合取交、可能集合取并，并保留多来源/多类型；未知语义和预算耗尽降级完整性，未来创建者不会进入普通字段候选。未知算法/无效参数仅作为不完整的可能候选，不宣称 Runtime 成功创建。音频效果目录在无输出设备时也可用于创作。
+
+`ProjectSceneTargets` 在同一项目 scope 上查询各域，并为音频结果维护独立 AudioRevision；写入方上下文继续共用 ContextRevision。配置目标变化重新分析。`SceneTargetCatalog` 适配类型名称、创建来源和 Track/Bus 过滤，复用来源描述及查询有效性检查；摘要检查不占交互位置缓存。音频字段使用 ComboBox 和共享数值字段，不在控件中扫描 Graph。普通输出身份隐藏；stop 的 all 状态由实例选择器原子写入，不独立展示一个容易冲突的开关。
+
+参数类型来自 ISEffectCatalog；范围和默认值与契约/DSP 共用元数据。选择类型同时提交类型键和初始参数，为一次作者历史。stop/update 先选范围和目标，再列出直接挂载实例；Track 不显示所属 Bus 的挂载实例。同类多个效果按来源区分，类型歧义的 update 不生成猜测字段。参数编辑保留未改字段与未知 JSON；未知类型和失效引用不因刷新自动改选。
+
+选择提交检查位置、结果版本和写入方上下文；相关修改使旧候选失效，撤销不会复活旧选择。更换更新目标时清空原参数 patch，避免把另一算法的参数带入新目标；参数字段的草稿随所选目标/实例/类型变化失效。该扩展未新增 Timeline 音频事件或音频参数动画。
diff --git a/docs/spec/editor-variables.md b/docs/spec/editor-variables.md
index d6081e45..334428e5 100644
--- a/docs/spec/editor-variables.md
+++ b/docs/spec/editor-variables.md
@@ -4,9 +4,13 @@
 
 ## 草稿与项目历史
 
-左侧列出当前作用域的变量，右侧编辑名称、类型、默认值和说明。输入保留在面板草稿，点击应用才提交；还原草稿只重读当前声明，不产生历史。切换选中或作用域重新加载对应声明。外部声明刷新不静默覆盖同一选中项的未应用草稿，提交时按原声明快照检查冲突；发生冲突可还原后重新编辑。
+左侧列出当前作用域的变量，支持按名称/说明搜索，列表标题条右上角“＋”新增并选中新变量。列表与详情之间可拖动分隔条；窄面板改为上下排列。右侧编辑名称、类型、默认值和说明，应用、还原、删除与引用检查使用带本地化提示的图标按钮。
 
-新增、应用和删除各是一条项目历史，变量稳定 UID 不随改名/类型变化改变；关闭面板仍可撤销。Graph 的 playerVariables/saveVariables 为唯一作者来源，settings 中同名列表由保存派生，不由面板另外维护。GUI 声明修改统一通过 VariableAuthoringService，不依赖 Workspace 监听声明变化后补记历史。
+输入保留在草稿，点击应用才提交；还原草稿只重读当前声明，不产生历史。VariablePanelState 属于项目 scope，按作用域保存最后选中 UID，按 (Scope, UID) 保存未应用草稿及原声明基线。切换子页、同页换项、搜索过滤及关闭重开后恢复原选择和输入；控件与 transient ViewModel 仍可释放，状态不写入作者文档、不进入历史，也不跨项目或应用重启恢复。
+
+外部声明刷新不静默覆盖未应用草稿，提交时按原声明快照检查冲突；发生冲突可还原后重新编辑。原 UID 删除后显示失效提示并保留草稿，可通过撤销删除恢复或显式放弃；同名新变量不会继承旧选择或草稿。变量新增仍立即创建一条声明历史，切页不会隐式应用草稿，Save All 只保存已经应用的声明。
+
+新增、应用和删除各是一条项目历史，变量稳定 UID 不随改名/类型变化改变；关闭面板仍可撤销。Graph 的 playerVariables/saveVariables 为唯一持久来源，settings 不再包含同名列表。GUI 声明修改统一通过 VariableAuthoringService，不依赖 Workspace 监听声明变化后补记历史。
 
 IVariableDefinitionService 只提供保留稳定 UID 的独立声明快照和刷新通知，不提供声明写入或改名接口。Preview 显示只读名称、类型、默认值，并通过运行时变量服务编辑当前值；不提供声明新增、删除、排序、改名和默认值编辑。运行时变化更新 Preview 显示，不回写声明、不增加内容历史，也不影响作者内容的未保存状态。声明刷新后重建 Preview 行，已替换或隐藏的行不能继续提交当前值。
 
diff --git a/docs/spec/entry-types.md b/docs/spec/entry-types.md
index e8995161..19a931ed 100644
--- a/docs/spec/entry-types.md
+++ b/docs/spec/entry-types.md
@@ -6,33 +6,47 @@
 - `.rawgalgroup` 的 `parameters` 与编译后 `.galgroup` 的 `arguments` 都是 JSON 对象；数字、布尔值、对象和数组不被压平为字符串。
 - 某个 entry 是否可编辑、可编译，完全由当前 target profile 中挂载模块导出的 entry schema 决定。未挂载的类型被拒绝，不会回退到全局内置目录。
 - 每个 entry 定义的 `DynamicParameterTable` 是只读 schema：每个参数以 `typeof(T)` 指定进程内运行时类型，并包含 required、JSON 默认值和 JSON constraints。CLR 类型名绝不写入内容、metadata、存档或 pak；内容只保存 JSON 值。
-- Runtime 只接收通用 `PrimitiveEntry`，并通过 `IGameView.Dispatch` 动态路由。Core/Runtime 不要求任何内置 primitive 实现。
+- Runtime 只接收通用 `PrimitiveEntry`，并通过 `IPrimitiveDispatcher.Dispatch` 动态路由。Core/Runtime 不要求任何内置 primitive 实现。
 
-`EntryParameterType` 是当前编辑器的 UI hint，由独立的 `EditorHints` 适配，不是执行协议。内置描述不再把 editorType 放入值 constraints。
+Core Entry 的参数权威是 `Arguments` JSON，不再保留字符串 Values。`AuthoringPrimitiveEntry` 与 `CompositeEntry` 是作者表示，均不继承编译后的 sealed `PrimitiveEntry`；运行与作者类型在类型边界区分，不使用 IsGeneric 标志。`IEntryCatalog.Create` 接收 JSON arguments、应用 JSON 默认并保留草稿未知字段；完整编译/运行校验仍拒绝未知参数。Editor/CLI 的字符串输入由 EditorEntryData 适配，显式 null 与缺省不混淆。
+
+`EntryDefinition.DynamicParameters` 是唯一参数描述，不再保存平铺的 Parameters/Defaults/Options 字典。`EntryParameterType` 与按需投影的 `EntrySchema` 位于 `GalNet.Editor.Abstraction.Schemas`，仅服务编辑器；Core 通过开放的 `EditorHints` 提供展示提示，不依赖具体控件分类。内置描述不把 editorType 放入值 constraints。
+
+视觉 Effect 与音频 SEffect 的参数类型、必填、有限数值、范围和选项校验复用 `FieldDescriptor` / `ValueValidation`。目录复制调用方的参数、选项和能力集合，使查询元数据与校验规则保持一致；效果 stage、目标和 scope 的规则仍归各自领域，校验返回诊断，由调用方决定处理方式。
 
 `FieldDescriptor` 组合稳定 ID、值描述、required/默认值、标签 key 和可选编辑提示；`DynamicParameterDescriptor.Field` 是 Entry 的唯一字段元数据来源，`DynamicParameterTable.Fields` 按声明输入顺序冻结。`EditorHints.EditorId` 为开放字符串，内置值见 `ValueEditorIds`，宿主可以声明自己的 ID；Step/Format/UnitKey 仅描述展示，Step 不限制合法值。合法选项留在值约束，展示标签及动态选项留在宿主。CLI schema 查询单独输出 editor 提示，值 schema 不混入 UI 规则。共享 Avalonia SchemaForm/默认工厂及 Editor/设置最小宿主接入已实现，见 [表单契约](control.md#schema-字段表单)。
 
-参数值的公共基础位于 `GalNet.Core.Parameters`：`ValueDescriptor` 提供类型、null、约束及冻结的 JSON 配置，`ValueCodec` 负责序列化/反序列化/结构描述，`ValueValidation` 返回包含 code/path 的校验问题。Entry 的 `DynamicParameterDescriptor` 组合该描述，名称、必填和默认值仍归 Entry；CLI 可独立组合相同值描述。对象/数组通过 JSON/CLR 契约处理，不增加新的值容器。支持范围、字符长度、数组长度、enum/options；未知业务约束由契约自己的 validator 执行，结构描述不能替代完整代码校验。省略与显式 null 分开，根值规则不改变递归子类型；嵌入 schema 时需重定位其局部引用。
+参数值的公共基础位于 `GalNet.Core.Parameters`：`ValueDescriptor` 提供类型、null、约束及冻结的 JSON 配置，`ValueCodec` 负责序列化/反序列化/结构描述，`ValueValidation` 返回包含 code/path 的校验问题。Entry 的 `DynamicParameterDescriptor` 组合该描述，名称、必填和默认值仍归 Entry；CLI 可独立组合相同值描述。对象/数组通过 JSON/CLR 契约处理，不增加新的值容器。支持范围、字符长度、数组长度、JSON enum（Choices 文本声明在构造时转为类型化 enum）；未知业务约束由契约自己的 validator 执行，结构描述不能替代完整代码校验。省略与显式 null 分开，根值规则不改变递归子类型；嵌入 schema 时需重定位其局部引用。
 
 项目集合来自独立契约程序集的 `GalNet.Project.Contracts.ProjectSchemas.Modules`；CLI 每次调用加载，Editor 在打开项目时加载并由项目 scope 持有，关闭/切换释放。相同名称 DLL 可声明不同集合，模块名可重复但完整 typeId 排他。工具加载共享 Core/内置契约类型身份，拒绝缺失依赖和不兼容版本；不存在默认内置 fallback。命令见 [CLI README](../../src/Editor/GalNet.Editor.Headless/README.md)。
 
+### 嵌套属性访问
+
+字段生成器支持程序集级 `FieldSchemaJsonContext`，将显式 JSON context resolver 注入字段 codec，并生成 `FieldDescriptor.WithMember` 的 CLR/JSON 成员身份及 `ValueDescriptor.WithSchemaProvider` 的延迟子 schema。集合中的生成 DTO 同样保留子 schema；反射关闭的玩家通过这些元数据解析嵌套结构。手写 schema 可显式提供相同信息；反射只保留为启用了反射 JSON 的桌面兼容路径。扩展方式见 [NativeAOT 手册](../manual/native-aot.md)。
+
+`ValueDescriptor.WithStructure` 为值关联不可变 ValueStructure，旧构造函数签名保留。原生 IFieldDto 使用其静态 Schema；固定 JsonElement 字段可用 Field.StructureType 关联结构类型，生成器输出延迟类型引用，不在初始化时递归展开 schema。StructureAllowsJsonString、StructureIgnoresCase、StructureUsesFieldIds 仅为显式兼容表示提供规则，不改变通用 JSON 的默认命名或运行 codec；内置 Transform 保留原成员拼写与字符串表示，Flipbook 新成员沿用字段 ID。
+
+ValueStructure 提供 ForType、Object、OpenObject、Scalar、Sequence、Map 和 Dynamic 声明，集合元素/Map 值可拥有独立字段约束与文本/角色语义。Object 默认封闭；OpenObject 显式声明额外成员的值契约，附加字段描述的 ID 不作为这些成员的寻址别名。Scalar 可将领域明确不解释的 JSON 视为原子值，不假定其内部存在字段或引用语义。开放规则必须来自实际领域契约，不能从未知 JSON 自动推导。ValueStructureResolver 使用实际 JSON options 解析 wire 成员，缓存属于调用方作用域；无法解释的 converter/结构返回可定位诊断。IValueStructureProvider 只消费调用方提供的冻结上下文；动态领域查询及依赖有效性仍由调用方负责，接口本身不执行项目 I/O。
+
+ValueDocument 持有不可变 JSON 快照，提供 Root、FindProperty、GetIterator、Validate 和纯 Patch。PropertyPath 区分 Member、Index、MapKey、JsonString；对外实际 JSON Pointer 与逻辑内部路径分别编码。迭代由显式栈、节点/深度预算和取消控制；Validate 的 Partial 默认不要求缺失兄弟字段，完整模式显式检查已出现对象中的必填字段。展开、扫描和查找不写入默认值。Patch 仅产生候选值，不替代作者身份检查、事务或领域校验；它保留扩展与兄弟值，拒绝歧义和不存在的索引，显式 null 容器需要先被替换。旧索引句柄是否因重排失效由宿主结构代次核对，纯快照操作不会猜测元素身份。
+
 单平台执行可在外层模块直接借用具体页面；Sample 的 `sample.screenshot(fileName?)` 契约无 Avalonia 依赖，Avalonia 模块直接捕获 GamePage 场景，自动写入宿主 Pictures 目录。它不属于全内置模块，Headless 只可编译，缺执行实现时拒绝运行。Normal/Quick 生成 PNG，CatchUp 不写文件；参数、生命周期与示例见 [Sample.Contracts](../../src/Samples/GalNet.Sample.Contracts/README.md)。
 
-同步执行可用 PrimitiveRegistry.Immediate / Immediate<T>，自动传递批次并同步完成；实例非阻塞且不可跳过。Normal/Quick 执行 dispatch，CatchUp 默认重复 dispatch，可显式覆盖。异常按原 PrimitiveInstance 协议传播，不推断取消、平台 dispatch 或异步生命周期。带参数入口沿用 Register<T> 的独立 DTO 和契约身份检查。内置 audio.pause/resume/next/clear 共用 AudioTrackOptions，flow.wait 使用 WaitOptions；旧手写参数表已删除，JSON 字段、默认值和 null 策略保持原有行为。Contracts.Builtins 通过构建期 Analyzer 引用 SchemaGenerator，运行时仍只依赖 Core 和框架程序集。
+同步执行可用 PrimitiveRegistry.Immediate / Immediate<T>，自动传递批次并同步完成；实例非阻塞且不可跳过。Normal/Quick 执行 dispatch，CatchUp 默认重复 dispatch，可显式覆盖。异常按原 PrimitiveInstance 协议传播，不推断取消、平台 dispatch 或异步生命周期。带参数入口沿用 Register<T> 的独立 DTO 和契约身份检查。内置 audio.pause/resume/next/clear 共用 AudioTrackOptions，flow.wait 使用 WaitOptions；旧手写参数表已删除。音频及语音复合指令的 trackId 为无默认值、不可为 null 的必填字符串，不再隐含选择 bgm/vocal；其他字段沿用其各自 schema。Contracts.Builtins 通过构建期 Analyzer 引用 SchemaGenerator，运行时仍只依赖 Core 和框架程序集。
 
 dialogue.text、nvl.append、layer.hide/replace、animation.stop、audio.seffect.stop、video.stop、effect.stop、particle.stop、variable.set 和 gallery.unlock 已采用 DTO 参数与强类型执行读取；effect.stop/particle.stop 共用 InstanceIdOptions。对白/NVL 保留 reading 标记与独立实例；Gallery 的正整数和 catalog 检查仍在原执行边界。Editor 含专属字符串编辑提示的 DTO 保留补全、多行文本、资源选择和表达式控件投影，普通字段仍使用共享 binding，不另维护参数表。
 
-其余带参数的内置 Primitive 也采用 DTO：layer.show/showColor/move、animation.animate/play、audio.play/enqueue/seffect.apply、video.play、effect.apply、particle.play/burst。audio.play/enqueue 共用 AudioPlayOptions，enqueue 仍显式选择 Enqueue 策略。嵌套 JSON 字段保留 JsonElement 与原解析规则；固定标量、布尔和枚举使用强类型属性。动画 from 的省略由规范化参数 presence 判断，batchId 仍由编译信封提取；快照/重放与复杂实例生命周期未改变。
+其余带参数的内置 Primitive 也采用 DTO：layer.show/showColor/move、animation.animate、timeline.play、audio.play/enqueue/seffect.apply、video.play、effect.apply、particle.play/burst。audio.play/enqueue 共用 AudioPlayOptions，enqueue 仍显式选择 Enqueue 策略。嵌套 JSON 字段保留 JsonElement 与原解析规则；固定标量、布尔和枚举使用强类型属性。动画 from 的省略由规范化参数 presence 判断，batchId 仍由编译信封提取；快照/重放与复杂实例生命周期未改变。
 
 `animation.animate.property` 的内置选择包含 `time`，供 effect-program 元数据将该逻辑参数映射到 shader 时间 uniform；具体 program 仍需把对应参数标为可动画。
 
 DynamicParameterTable 的 ValidatePartialArguments 用于尚未补默认值的局部作者参数；可选回调省略时沿用完整 validator。ForDto<T> 可显式提供 validatePartialArguments；字段自身校验照常执行，Normalize 的完整业务校验仍使用 ValidateArguments。内置视频/粒子/动画计划将完整业务规则保留在编译/执行边界，逐字段创作不要求其他尚未填写的字段。
 
-所有 8 条内置 Composite 使用 ForDto<T> 接收输入，普通 schema 类型/选项/未知字段检查由同一 Normalize 执行；业务展开、正数/颜色/变换校验保持显式。语音子指令及计划 Primitive 外层参数通过 ValueCodec.SerializeFields 使用对应子 DTO 的字段 codec；undefined JSON 字段省略，null 默认保留，可显式选择省略 null。黑白与自定义颜色过渡共用源基类的 12 个字段；生成器合并继承字段并拒绝隐藏/重写或 Order/ID 冲突。
+所有 14 条内置 Composite 使用 ForDto<T> 接收输入，普通 schema 类型/选项/未知字段检查由同一 Normalize 执行；业务展开、正数/颜色/变换校验保持显式。语音子指令及计划 Primitive 外层参数通过 ValueCodec.SerializeFields 使用对应子 DTO 的字段 codec；undefined JSON 字段省略，null 默认保留，可显式选择省略 null。黑白与自定义颜色过渡共用源基类的 12 个字段；生成器合并继承字段并拒绝隐藏/重写或 Order/ID 冲突。
 
-BuiltinEntryIds 集中声明 45 个内置稳定 wire ID。内置 Primitive 的作者类壳及取 ID 的泛型工厂已移除；catalog.Create 继续返回 Core 的通用作者表示，运行时依旧使用通用 PrimitiveEntry。项目仍显式选择 14 个独立 schema modules，不通过 CLR 类扫描启用指令。
+BuiltinEntryIds 集中声明 51 个内置稳定 wire ID。内置 Primitive 的作者类壳及取 ID 的泛型工厂已移除；catalog.Create 继续返回 Core 的通用作者表示，运行时依旧使用通用 PrimitiveEntry。项目仍显式选择 14 个独立 schema modules，不通过 CLR 类扫描启用指令。
 
-Field.DefaultJson 声明经值 codec 校验的 JSON 默认，不能与属性初始化值同时声明；Choices 提供固定合法选项。StringBooleanValueConverter / StringEnumValueConverter 通过 IStringValueEncoding 保留字符串 wire 类型、选项及编辑文本，同时提供强类型成员；普通 converter 行为不改变。audio.stop 已用 AudioStopOptions，clearQueue 保持字符串 true/false 与显式 null 的旧行为。DefaultCompositeEntryBase.ForDto<T> 提供类型化编译展开，共用 ValueCodec.DeserializeFields，源 JSON 保留 null/presence，输出仍通过目标 primitive 契约规范化。
+Field.DefaultJson 声明经值 codec 校验的 JSON 默认，不能与属性初始化值同时声明；Choices 提供固定合法选项。StringBooleanValueConverter / StringEnumValueConverter 通过 IStringValueEncoding 保留字符串 wire 类型、选项及编辑文本，同时提供强类型成员；普通 converter 行为不改变。audio.stop 已用 AudioStopOptions，clearQueue 保持字符串 true/false 与显式 null 的旧行为。DefaultCompositeEntryBase.ForDto<T> 提供类型化编译展开，通过 PrimitiveArgumentHelper.NormalizeFields<T> 在归一化时直接填入独立 DTO，源 JSON 保留 null/presence，输出仍通过目标 primitive 契约规范化。
 
 ## Entry Module
 
@@ -68,17 +82,25 @@ transition.blinds
 transition.fadeBlack
 transition.fadeWhite
 transition.fadeColor
+transition.reveal
+transition.blur
+preset.motion
+preset.shake
+preset.speedLines
+preset.impact
 ```
 
 这些 entry 不是 Runtime primitive，也不绕过 target profile：展开后的每一个 primitive 都必须在所选 profile 中存在。
 
+视觉预设均编译为 `timeline.play`，shader 由 Entry 的 program / blurProgram 显式资源参数传递。编辑器插入/类型切换时从项目 defaultVisualPrograms 用途绑定填入 GUID；编译器不查找隐藏默认 shader，不新增各 shader 专用 primitive。project/group validate、单组编译和 build/export 在项目资源边界校验所需 shader stage、参数种类、可动画性与数值范围。震动/冲击目标为 targets[].handleId，参与场景引用索引、复制重映射和时间线终态分析。参数及停止边界见[默认视觉库手册](../manual/default-visuals.md)。
+
 ## 内置 primitive ID
 
 `GalNet.Contracts.Builtins` 提供只依赖 Core 的作者契约；`GalNet.Primitives.Builtins` 提供运行时领域模块。`BuiltinSchemas.CreateAllModules()` 返回 14 个独立模块的只读列表，各组件也可通过 `Create<Domain>Module()` 单独选择；没有合成全内置大模块或内置专用 catalog 工厂。消费者使用 `new TargetProfileEntryCatalog(modules)`。
 
 完整运行入口是 `GameRegistration.AddBuiltins`；也可单独调用 `AddBuiltinSchemas` 注册模块列表，再组合部分内置或自定义执行模块。内置 entry DTO、纯参数校验和 Composite 位于 `GalNet.Contracts.Builtins`，primitive instance 和执行 module 位于 `GalNet.Primitives.Builtins`；`GalNet.Core.Entry` 只包含通用基础设施。内容格式只保存下列稳定 `TypeId`，不保存 CLR 类型名。
 
-`GameRegistration.UseCatalog(catalog)` 使用现有项目 catalog，禁止随后增加 schema。`AddBuiltinImplementations(catalog, ...)` 按该集合选择已声明的内置 primitive，不增加 schema；选择不拆散组件状态或释放所有权。宿主通过 `RequireInstructions(compiledTypes)` 检查实际内容需要的执行实现；可选 `RequireExecutionCoverage()` 检查整个 primitive 集合。工具契约加载不要求执行实现，Editor preview 缺少自定义实现时明确失败。
+`GameRegistration.UseCatalog(catalog)` 使用现有项目 catalog，禁止随后增加 schema。`AddBuiltinImplementations(catalog, ...)` 按该集合选择已声明的内置 primitive，不增加 schema；选择不拆散组件状态或释放所有权。宿主通过 `RequireInstructions(compiledTypes)` 检查实际内容需要的执行实现；可选 `RequireExecutionCoverage()` 检查整个 primitive 集合。工具契约加载不要求执行实现，外部游戏宿主缺少自定义实现时明确失败。
 
 ```text
 dialogue.text, dialogue.textVoice, dialogue.show, dialogue.hide
@@ -88,7 +110,7 @@ variants.show, variants.select
 animation.animate, animation.stop
 timeline.play
 audio.play, audio.stop, audio.pause, audio.resume, audio.enqueue, audio.next, audio.clear
-audio.seffect.apply, audio.seffect.stop
+audio.seffect.apply, audio.seffect.update, audio.seffect.stop, audio.mix.set
 video.play, video.stop
 effect.apply, effect.stop
 particle.play, particle.stop
@@ -96,6 +118,8 @@ flow.wait, variable.set, gallery.unlock
 custom.invoke
 ```
 
+`audio.play` 与 `audio.enqueue` 支持 `loopCount`（非负整数，默认 1，0 为无限）及 `completion`（`discard` 或 `requeueTail`，默认 `discard`）。`loopCount` 控制一个播放项的连续播放次数，`completion` 控制次数耗尽后是否回到队尾；失败或显式移除不会重新入队。Editor 使用数字输入和选项下拉编辑，使用方式见[音频重复与轮播](../manual/audio-playback.md)。
+
 `gallery.unlock` 的参数是正整数 `id`，其值必须是当前 `GalleryCatalog` 中存在的稳定 Gallery item ID。执行时写入 `player.gallery_<id>_unlocked = true`；Gallery item 从资源 `.meta.gallery[]` 聚合，发行运行读取其生成快照。旧的 category/sequence 参数不受支持。
 
 ## 图片差分指令
@@ -145,3 +169,9 @@ select 保留同一个 Layer 对象、变换、显示模式、层级、透明度
 GenerateFieldSchema + Field 属性生成中立 FieldDescriptor 列表及 IFieldDto 成员访问，不生成平台控件。DefaultPrimitiveEntryBase.ForDto<T> 使用 T.Schema 建表，并记录 FieldDataType，不提供 Editor DTO 工厂。运行时仍调度通用 PrimitiveEntry；执行模块可使用 PrimitiveRegistry.Register<T>，注册时检查 DTO 类型，执行时用规范化参数和逐字段 ValueCodec 填充独立 DTO。契约运行时不依赖 Roslyn，生成器仅为构建工具。默认值通过完整 ValueCodec 投影；旧字符串文档不能无损表示的默认值不填入 Defaults，仍保留在字段描述中，避免 JSON null 字符串和字符串编码枚举被改写。具体接入方式见[定制 Avalonia Sample 手册](../manual/customize-avalonia-sample.md)。
 
 Timeline 使用 TimelineOptions.Timeline 对应的 timeline 根参数（JsonElement），内容为 TimelineDefinition；播放接口为 PlayTimelineAsync。旧 animation.play ID 和 plan 根参数没有别名。动画轨道、键与事件分别使用 TimelineTrackDefinition、TimelineKeyframeDefinition、TimelineEventDefinition，纯采样入口为 TimelineSampler。
+
+Timeline 事件的 `execution` 默认为 `EachIteration`，按帧逐轮执行；`Once` 仅允许帧 0，属于整次播放的初始化；`OnCompletion` 仅允许结束帧的 layer.hide/effect.stop/particle.stop，属于整次播放的收尾，不随循环触发。恢复不重复已提交的首帧初始化。震屏/集中线预设支持 `playbackMode=Timed/UntilStopped`；持续模式编译为非阻塞、不可点击跳过的 Loop，集中线的创建和移除分别使用 Once/OnCompletion。其他预设保持单次。
+
+音频效果条目目标为 `scope`（track/bus）与必填 `targetId`；播放/轨道控制仍使用 `trackId`。效果参数和新 PCM 后端见 [音频混音](../manual/audio-mixing.md)。
+
+`audio.seffect.update` 使用 `AudioSEffectUpdateOptions`，以 `instanceId` 引用已有实例，`parameters` 为字段 patch；合并后验证，缺失实例无操作。`audio.seffect.stop` 的 `all` 默认 false；true 时停止目标上的全部效果且不能同时指定非空实例身份。Editor 自动隐藏 apply 的输出身份，类型/参数及 stop/update 的引用选择见 [作者目标查询](editor-scene-targets.md)。
diff --git a/docs/spec/file-formats.md b/docs/spec/file-formats.md
index 6fa0ee74..e65e6953 100644
--- a/docs/spec/file-formats.md
+++ b/docs/spec/file-formats.md
@@ -19,23 +19,49 @@ Project/
   Output/ Temp/ .galnet/  工作文件，不是游戏内容
 ```
 
-项目根不存在可编辑 `gallery.json`。Gallery 从 `Assets/**/*.meta` 的 `gallery[]` 聚合：类型由宿主代码/插件注册，item ID 为全局唯一正整数，资源 ID 是父 metadata 的 GUID。开发运行在内容加载时聚合一次；发行运行只读取导出生成的 `gallery.json`。
+项目根不存在可编辑 `gallery.json`。Gallery 从 `Assets/**/*.meta` 的 `gallery[]` 聚合：类型由宿主代码/插件注册，item ID 为全局唯一正整数，资源 ID 是父 metadata 的 GUID。开发运行在内容加载时聚合一次；发行运行读取 `game.pak` 内导出生成的 `gallery.json`。
 
 `I18n/` 的人物表、文本源与默认语言完整性检查见 [国际化](i18n.md)。它是特殊内容，不是资源 provider 输入。
 
 `Contracts/` 不进入 galpak。游戏通过自己的契约项目引用取得同一集合；CLI/Editor 外层加载固定的 `GalNet.Project.Contracts.ProjectSchemas.Modules` 静态只读模块列表。缺少 DLL 时原始查询和结构校验仍可用，语义校验/编译/Editor 打开明确失败。Editor 新建项目会自动部署随程序分发的默认契约，无需用户准备 DLL，也可选择自定义构建目录。CLI 项目创建仍可先生成缺契约骨架；自定义部署方法见 [Sample 契约](../../src/Samples/GalNet.Sample.Contracts/README.md)。项目显示名改名不移动目录，不改变节点/entry ID；整项目删除采用系统回收站。
 
+Editor 新建项目可先选择游戏 App EXE：契约目录为空时，只在 EXE 同级与同级 `lib/` 查找 `GalNet.Project.Contracts.dll`，分别对应普通构建与当前发行布局。唯一结果自动填充目录；已有输入不覆盖，缺失或多份结果提示手动选择。已选 App 时不因契约缺失回退到默认契约。自定义来源在创建前解析静态托管依赖闭包并验证，仅部署契约及其非平台托管依赖，不复制 App、运行时或无关文件；DLL 字节保持不变。动态或原生加载不属于作者契约。未选 App 且契约目录为空时保留默认契约部署流程。所选 EXE 在进入工作区前保存到 `.galnet/editor/debug-launch.json`，供现有外部调试启动流程使用。
+
 ## Graph 与 Group
 
 `Graph/graph.json` 是版本 2 的编辑图，包含稳定节点/边 ID、坐标、变量和 Group 的 `groups/<id>.rawgalgroup` 文件引用。`.rawgalgroup` 是版本 2、`kind: Raw` 的编辑源，可包含 primitive 和 composite；`.galgroup` 是版本 3、`kind: Compiled` 的运行产物，只能包含 primitive。旧分号文本、旧版本 Group 格式和运行时加载 Raw 文档均不受支持。
 
 图允许多个前驱汇合到同一目标；每个输出口最多一条边，禁止自连接和连接到 Entry。GUI 与 CLI 新建连接只替换同一输出口的旧边。
 
-变量声明的字段固定为 `name`、`defaultValue`、`type`，以及可选字符串 `description`（作者说明，省略时为空），不随 JSON serializer 的命名策略变化；`defaultValue` 使用变量 converter 的 `Uid`、`Name`、`Type`、`Value`。编辑工具只接受当前源格式，不补稳定 ID、不从 settings 迁移变量。GUI 使用 Authoring 模式保留未知 Entry 类型/参数、不完整参数和条件表达式；原始 JSON 结构、信封字段和稳定身份必须有效，未知 Graph/Group 顶层或 Entry 信封字段仍拒绝。默认 Complete 仓库与 CLI 检查/编译继续要求完整契约有效；空字符串不会作为缺失参数删除。Editor 作者参数直接保存 JSON 值，保留复杂值、大整数、缺省与显式 null，不要求所有值先通过字符串表示往返。Group 源路径按 Graph 中的 file 原样保留，显示名改名不重建文件名。GUI 打开另要求显式且唯一的 Entry 根节点，结构/CLI 工具不因此统一限制为 GUI 入口规则。
+变量声明的字段固定为 `name`、`defaultValue`、`type`，以及可选字符串 `description`（作者说明，省略时为空），不随 JSON serializer 的命名策略变化；`defaultValue` 使用变量 converter 的 `Uid`、`Name`、`Type`、`Value`。编辑工具只接受当前源格式，不补稳定 ID、不从 settings 迁移变量。settings.json 不再包含 playerVariables/saveVariables，变量声明只在 Graph 保存。GUI 使用 Authoring 模式保留未知 Entry 类型/参数、不完整参数和条件表达式；原始 JSON 结构、信封字段和稳定身份必须有效，未知 Graph/Group 顶层或 Entry 信封字段仍拒绝。默认 Complete 仓库与 CLI 检查/编译继续要求完整契约有效；空字符串不会作为缺失参数删除。Editor 作者参数直接保存 JSON 值，保留复杂值、大整数、缺省与显式 null，不要求所有值先通过字符串表示往返。Group 源路径按 Graph 中的 file 原样保留，显示名改名不重建文件名。GUI 打开另要求显式且唯一的 Entry 根节点，结构/CLI 工具不因此统一限制为 GUI 入口规则。
 
 共享保存先准备并校验 Graph/Group 写入计划，再暂存全部目标文件后发布。删除 Group 节点并删除其 entries 时同步删除该源文件；保留 entries 时源文件成为孤立作者文件。同一 Group 变更 source path 时，新路径写入计划并删除旧源文件。GUI 保存全部将 settings、editor-state 和已跟踪的普通文本字节合入同一计划，失败不更新作者基线。普通文本描述项的 ID/路径/存在状态/字节属于 Editor 会话与恢复材料，不改变游戏源文件格式；结构操作对 Working/Saved 分别变换，文件页关闭不丢弃缓冲。作者文件事务在 `.galnet/editor/transactions/` 持久化 manifest、前后哈希和备份，后续发布失败逆序恢复；恢复失败明确报告并保留材料。GUI 打开项目核对未完成计划，外部内容不匹配时停止恢复，不承诺断电或跨进程修改下的整体原子事务。周期作者恢复快照另存于 `.galnet/editor/recovery/`，不进入游戏内容或跨重启 Undo 栈。普通文件事务也记录目录状态与大小写改名的中间路径；会话历史字节材料另存 `.galnet/editor/history/`，不进入发布包或跨重启 Undo 栈。详见 [Editor 项目历史与保存](editor-history-and-save.md) 和 [项目文件操作](editor-files.md)。
 
-Compiled primitive 使用 `{ id, typeId, batchId, condition, arguments }` 信封。`arguments` 保存 JSON 值，不保存 CLR 类型名；当前 target profile 的冻结 schema 负责校验。Graph 与 Group 目前是特殊内容文件，不通过资源 GUID provider 查询。
+Compiled primitive 使用 `{ id, typeId, batchId, condition, arguments }` 信封。`arguments` 保存 JSON 值，不保存 CLR 类型名；当前 target profile 的冻结 schema 负责校验。项目保持唯一 Graph；Graph/Group 发布为 PAK 内的 graph/group 资源，开发编译目录由 CompiledStoryAssetProvider 适配同一资源 ID。保留 Graph ID 为 `galnet:graph:main`，Group ID 从稳定节点 ID 派生为 `galnet:group:<id>`；不新增多图列表、默认图选择或跨图存档字段。运行图还保留 playerVariables/saveVariables 声明，宿主创建新 Run 时据此初始化默认值。
+
+Group 节点 DTO 可保存可选字符串 `storyPackage`；空字符串属于本体，同名聚合为剧情包。编译 Graph 保留节点和包名，正文只进入相应 story PAK。GUI 节点检查器可编辑名称，进入项目历史并随 Graph 保存。
+
+## 项目配置 `settings.json`
+
+配置文档版本为 1，替代旧的平铺设置格式，不提供兼容迁移：
+
+```json
+{
+  "version": 1,
+  "sections": {
+    "galnet.project": { "version": 1, "data": { "defaultWidth": 1920 } },
+    "developer.options": { "version": 1, "data": { "enabled": true } }
+  }
+}
+```
+
+根信封固定为 version/sections；section 信封固定为正整数 version 和对象 data。重复 JSON 属性拒绝。未知 section 的版本和 data 原样保留；已声明 section 的未知字段在类型化修改时保留。缺省 section 按调用方声明读取新的默认 DTO，不写入文件。类型化读取是隔离快照，修改后须调用 `configuration.Set(section, dto)` 显式发布。项目契约可公开静态 `ProjectConfigurationSchema Configurations`，缺省为空；schema 复用 FieldDescriptor/ValueValidation，负责已声明字段和领域规则。默认模板显式选择可选 `DefaultProjectConfiguration.Schema`，不由 Core/Storage 自动注入。
+
+通用作者表单通过 section.Resolve 读取隔离的有效值快照（含默认值），不会把默认值写回原始配置；原始 section 仍是唯一持久源。项目设置窗口的字段草稿通过所选 schema 校验后批量进入项目历史，Undo/Redo 保留 section 的缺省状态及无关 section。
+
+配置补丁命令为 `project.configuration.patch`，接收 `sectionId`、必需的 `values` 对象及可选 `remove` 字段 ID 列表。先删除、后覆盖，显式 null 与缺省分开；仅允许修改声明的字段，完整候选验证成功才替换 section，其他字段/section 保留。构建与导出使用调用方所选 schema，在发布产物前验证已存储配置。
+
+资源补丁作者数据使用可选 `galnet.resourceOverrides` section（版本 1）：packages 为 ResourceOverrideDefinition 列表（稳定 id、name、priority、mappings、includeResources、declaredCompleteResources），additionalOriginals 为补充的原资源 ID 列表。定义随 settings 保存并进入已有 Undo/Redo、工作版/保存版和作者恢复快照；不创建独立 UI 状态文件作为真源。矩阵名称回车/失焦、数字优先级变更及映射/列操作自动发布该配置节，撤销/重做同样持久化；不提交其他页面输入，不保存其他未发布配置。资源补丁导出只读取保存版定义并捕获资源快照。additionalOriginals 同时成为基础打包根。
 
 ## `.galpak` 导出与安装
 
@@ -43,19 +69,36 @@ Compiled primitive 使用 `{ id, typeId, batchId, condition, arguments }` 信封
 
 ```text
 <Project>.galpak
-  <Project>.galnet          JSON manifest，版本 1
-  settings.json
-  Graph/**
-  I18n/**
-  gallery.json              从 metadata 派生
-  Assets/Paks/000-base.pak  资源 PAK
+  pak/
+    game.pak                固定入口，内部文档 GPAK
+    localization.pak        内置文本，每种语言一个逻辑条目
+    Assets/Paks/000-base.pak 基础资源首片，后续为 001-base.pak 等
+    StoryPatches/<buildId>/  即使无剧情包也保留空目录
+    ResourcePatches/         即使无补丁也保留空目录
+    I18n/                    空的外置翻译覆盖入口
 ```
 
-manifest 列出每个 ZIP 条目的路径、大小和 SHA-256。导出在临时文件中创建，重新验证 ZIP 条目与 PAK 后才替换目标文件。
+新导出为 galpak v3。`game.pak` 内含六个紧凑 JSON 文档：`content.json`、`installation.json`、`settings.json`、`gallery.json`、`characters.json` 和 `packaging-layout.json`。文档容器复用 GPAK v3 的压缩与逐项校验，采用独立固定的 document 类型目录，不加入普通资源 provider。`localization.pak` 使用同一文档容器，每个文化为 `texts/<culture>.json` 平铺字典；作者文件仍可按多个嵌套 JSON 编辑，导出时按原相对路径 ordinal 顺序合并。
+
+内部 `installation.json` 为版本 3，列出基础资源 PAK 与 localization.pak 的相对路径、大小和 SHA-256；不包含 game.pak 自身，避免循环哈希。入口文档由 GPAK 逐项校验，并交叉校验项目、构建身份及 content/index 一致性。ZIP 条目额外带 `pak/` 前缀，显式保存空扩展目录。v3 拒绝内容根外条目、重复 ZIP 路径和未声明载荷。导出在临时文件中创建，重新验证 ZIP 条目与 PAK 后才替换目标文件。压缩封装不提供加密或防提取保证。
+
+传入 `.galpak` 时，`GameInstallation.OpenAsync` 先读取固定 `pak/game.pak` 入口和内部安装清单，校验声明路径、条目大小与 SHA-256，再原子安装到包文件旁的 `pak/`。`GalpakInstaller.InstallAsync` 显式目标表示实际内容根，目标为 `app/pak` 时不会再追加 `pak`；返回实际内容根。普通解压工具选择解压到应用目录同样得到 `app/pak`。相同安装可复用并保留外置翻译/补丁；不同或损坏内容不会覆盖现有目录。安装器仍兼容 v1 平铺归档与 v2 的 `pak/<Project>.galnet` 布局；v1 默认目标保留包文件同名目录，v2/v3 默认目标为 pak。新导出只生成 v3。
+
+运行时只装载 content 描述中声明并校验的基础分片，额外丢入 Assets/Paks 的文件不贡献覆盖。包内 content.json v3 保存固定 graphId、projectId、buildId、basePaks、stories 和 localizationPak；每个文件描述路径、大小、SHA-256。Graph 和编译 Group 经普通资源 provider 加载，配置/人物/文本从文档包读取。旧 content v2 安装目录仍按散文件读取；发现 game.pak 时优先使用且损坏报错，不回退到散文件。旧 GPAK v2 或 loose Graph 发行内容仍需重新导出。
+
+正常导出还在 galpak 旁生成 `StoryPatches/<buildId>/*.pak`；目录导出则放在目标目录内同一路径。装载同时检查安装根及其父目录下当前 buildId 的剧情目录，以头部而非文件名识别分片。整个剧情包零分片表示未安装；存在部分分片、哈希错误、用途/项目/构建不匹配或依赖缺失都拒绝。缺席 Group 沿正常出口跳过；纯空 Group 推进循环拒绝。剧情目录按构建隔离并整体发布，旧基础包不会采用新构建的剧情片段。
+
+buildId 对资源内容、有效 metadata、特殊内容、格式标记和实际分片布局计算稳定指纹；默认阈值或切片算法改变物理布局时也产生新的构建身份。
+
+导出产生布局报告（galpak 旁 `<Project>.layout.json`，以及 game.pak 内 packaging-layout.json），列出资源归属、直接依赖和未打包项。配置、人物、文本完整留在本体的文档包，不按剧情拆分；未安装剧情不参与正文文本引用校验。Gallery 保持原基础聚合。资源补丁不能替换这些内部文档。
+
+GameSnapshot 当前为 v5，记录 ContentBuildId 和 StoryPackages；恢复拒绝不同构建或缺少记录的剧情包。首版保守记录会话准备时已安装的全部剧情包，因此删除当时尚未播放的包也会阻止恢复；不自动降级到跳过剧情。开发目录构建标识为空。
+
+资源归档格式为 GPAK v3，包含 base/story/override 用途控制描述；旧 v2 PAK 需重新导出。控制字段和 metadata 依赖校验见 [资源规范](assets.md#pak)。
 
-传入 `.galpak` 时，`GameInstallation.OpenAsync` 先校验 ZIP 根目录唯一 manifest、声明路径、条目大小与 SHA-256，再原子解压到包文件旁的同名目录。已存在且与 manifest 一致的安装目录可复用；不同或损坏内容不会覆盖现有目录。
+资源覆盖包独立放在安装根或其父目录的 `ResourcePatches/*.pak`。头部 kind=override、projectId 对应项目、buildId 为空，不依赖先导出基础构建。包保存 packageId、priority、原资源 ID→替换资源 ID 的 mappings，携带替换资源完整闭包。准备期校验全部 payload，按 priority 降序、完整文件 SHA-256 ordinal 降序决定各原资源的胜者，同 hash 去重。文件名不参与优先级，无语言条件。
 
-运行时从解压目录读取特殊内容，并且只扫描 `Assets/Paks/**/*.pak` 作为资源源。PAK 按相对路径倒序覆盖：`000-base.pak` 是基础包，后续/更高排序路径的包可作为补丁覆盖同 GUID 资源。ZIP、manifest、Graph、I18n、settings 和 gallery 不进入 `IAssetProvider`。
+GameInstallation 缓存当前包集合；重启或新建安装会话采用新增/移除包。已持有 handle 保持值和释放约定。未安装剧情的映射不创建原资源，不能使剧情被视为已安装。Graph/Group 禁止通过资源补丁覆盖。
 
 ## 生成的 `gallery.json`
 
diff --git a/docs/spec/i18n.md b/docs/spec/i18n.md
index 473f2b37..9698e01c 100644
--- a/docs/spec/i18n.md
+++ b/docs/spec/i18n.md
@@ -10,7 +10,7 @@ Editor 的成员值本地化标记、作者索引、角色表/speaker、默认
 - Avalonia Sample UI 使用 `DynamicLocalization.Core` 2.1.2 与 Sample 自有的 Avalonia 12 绑定适配层，从 Sample 程序集 `Localization/` 的嵌入 JSON 加载 `en-US` 与 `zh-CN`；`{loc:Localize ...}` 绑定读取同一 culture service。该 Sample UI 来源与游戏包 `I18n/` 内容仍是不同边界。
 - Runtime 不依赖 DynamicLocalization 或某种 JSON 结构。宿主向 `GameEngine` 提供 `ITextResolver`；内置 dialogue、NVL 和分支选项在展示前调用它。未提供时使用 `PassthroughTextResolver`，即把 key 原样返回。
 
-内置 `content` 与分支选项文本从 raw 开始就是 key；编译和复合展开原样传递。`speaker` 是人物 ID，空值表示无说话人。宿主把 `CharacterCatalog` 传给 `AddBuiltins`、`AddBuiltinImplementations` 或 `AddBuiltinDialogue`；catalog 记录唯一 `Id` 和非空 `DisplayNameKey`，内置对话先查人物再解析姓名 key，未知人物 ID 抛出内容错误。自定义参数如何本地化由 implement 决定。
+内置 `content` 与分支选项文本从 raw 开始就是 key；编译和复合展开原样传递。缺省、null、空串或纯空白文本引用按空内容处理，加载时不要求对应译文，GameTextResolver 返回空字符串；已定义 key 的空字符串译文也保持有效。非空 key 缺少默认语言译文仍在加载时报告错误。`speaker` 是人物 ID，空值或纯空白表示无说话人。宿主把 `CharacterCatalog` 传给 `AddBuiltins`、`AddBuiltinImplementations` 或 `AddBuiltinDialogue`；catalog 记录唯一 `Id` 和非空 `DisplayNameKey`，内置对话先查人物再解析姓名 key，未知人物 ID 抛出内容错误。自定义参数如何本地化由 implement 决定。
 
 ## 编辑器 UI
 
@@ -39,11 +39,13 @@ I18nKey.ForBranchOption(branchId, optionIndex, "text");
 
 ## 项目设置
 
-`ProjectSettings` 保存默认语言 `TargetLocale` 与可用语言 `AvailableLocales`；`I18nLocale` 内置常用的 `zh-CN`、`zh-TW`、`en-US`、`ja-JP`、`ko-KR` 值。项目构建递归复制 `I18n/`，导出作为 `.galpak` 的特殊内容逐文件分发，不进入资源 PAK。
+默认模板选择 Contracts.Builtins 的 `DefaultProjectOptions`，在 `galnet.project` 配置 section 保存默认语言 `TargetLocale` 与可用语言 `AvailableLocales`；核心内容文档不规定这些字段。Sample 通过 GameContentLoadOptions 的选择委托将开发语言传给加载器，本地化加载器只接收文化代码。`I18nLocale` 内置常用的 `zh-CN`、`zh-TW`、`en-US`、`ja-JP`、`ko-KR` 值。项目构建递归复制 `I18n/`；新发行导出将人物表写入 game.pak、内置文本写入 localization.pak，使用独立文档容器，不进入普通资源 provider。
 
 ## 包内游戏文本加载
 
-项目和安装内容 provider 使用相同的 `GameLocalizationLoader`，从游戏根目录读取：
+项目目录和旧 content v2 安装目录使用 `GameLocalizationLoader` 读取以下作者布局：
+
+文本和人物文件整体保留在本体特殊内容中，不随剧情 PAK 拆分。安装内容只对已安装的 Group 检查剧情文本引用；未安装的可选剧情不要求加载正文。资源覆盖包按 priority/hash 统一排序，没有语言匹配条件；文本覆盖仍使用下述独立 JSON 来源规则。
 
 ```text
 I18n/catalog/characters.json      人物 metadata 数组
@@ -52,17 +54,19 @@ I18n/<culture>/**/*.json          平铺或嵌套对象，叶值必须是字符
 
 人物记录如 `{"id":"guide","displayNameKey":"character.guide.name"}`。文本文件按规范化相对路径的 ordinal 顺序递归加载；catalog 与 External 子树不作为内置文本源，递归枚举不跟随 reparse point，根和 catalog 路径拒绝链接。`GameContent.Localization` 提供 catalog 和 JSON 来源描述，Core/Runtime 不引用 DynamicLocalization。
 
+新 content v3 安装目录从 game.pak 的 characters.json 读取人物，从 localization.pak 的 `texts/<culture>.json` 读取内置文本。每种文化一个平铺字典，由作者多文件按上述 ordinal 次序合并，后文件同名 key 覆盖前文件，空串译文保留。语言条目仍独立，整个语言包为一个物理文件；当前读取仍保留整包缓冲，不承诺按语言流式加载。作者源文件与目录不改变，作者 I18n/External 不进入导出。
+
 加载时验证默认语言包含所有人物姓名、编译后的内置 dialogue/NVL content 和 choice 文本 key，并拒绝未知 speaker ID。无效包内 JSON 或默认语言缺 key 拒绝内容加载；自定义 entry 参数不作本地化推断。构建器只编译/复制，此检查发生在内容加载时。
 
-Sample 的 `GameLocalizationProvider` 为每个文件创建独立 DynamicLocalization JSON provider，不合并文件；同 culture 内后文件覆盖前文件，独有 key 保留。查询顺序为当前语言 → 父语言链 → 游戏默认语言及其父语言 → key。Avalonia 使用同一个 CultureService 配置 UI 与游戏 resolver，切换设置影响后续展示文本，不重新翻译已有剧情历史。Headless 使用游戏默认语言。嵌入 UI、包内文本与外部来源在同一 adapter 中按 culture 优先查询，替换游戏保留嵌入 UI 的内容。
+中立宿主的 `GameLocalizationContent.CreateResolver` 将各 JSON 来源转为独立的文本查询，`AvaloniaPlayerLocalization` 用薄 provider 适配 DynamicLocalization；同 culture 内后文件覆盖前文件，独有 key 保留。查询顺序为当前语言 → 父语言链 → 游戏默认语言及其父语言 → key。Avalonia 使用同一个 CultureService 配置 UI 与游戏 resolver，切换设置影响后续展示文本，不重新翻译已有剧情历史。Headless 使用游戏默认语言。嵌入 UI、包内文本与外部来源在同一 adapter 中按 culture 优先查询，替换游戏保留嵌入 UI 的内容。
 
 ## 外部文本覆盖
 
-`I18n/External/<culture>/**/*.json` 在启动时递归读取。同 culture 内优先级是嵌入 UI → 包内游戏 → 外部 JSON；每层按 ordinal 相对路径排序，最后文件优先。损坏 JSON、非字符串叶值、无效 culture 或不可读取的外部文件记入 `GameContent.Localization.Diagnostics` 并跳过，Sample 输出诊断；外部树不跟随 reparse point。默认语言完整性只检查包内文本，不能靠外部文件补齐。
+新打包内容的 `pak/I18n/<culture>/**/*.json` 在启动时递归读取，整个 I18n 目录仅作为外置覆盖入口；不再添加 External 层。开发目录和旧 content v2 安装目录继续使用 `I18n/External/<culture>/**/*.json`。同 culture 内优先级是嵌入 UI → 包内游戏 → 外部 JSON；每层按 ordinal 相对路径排序，最后文件优先。损坏 JSON、非字符串叶值、无效 culture 或不可读取的外部文件记入 `GameContent.Localization.Diagnostics` 并跳过，Sample 输出诊断；外部树不跟随 reparse point。默认语言完整性只检查包内文本，不能靠外部文件补齐。
 
-外部新增语言自动进入 Sample 设置语言列表，显示 culture 的本地名称。外部来源不会修改人物 metadata，也不进入资源 provider。宿主可通过 `SampleLocalizationService.AttachGame(content, additionalSources)` 或 `GameLocalizationProvider` 的 `additionalSources` 参数提供更高优先级的自定义 JSON 来源；其加载方式由宿主自行实现。修改文件后重新启动生效，不提供文件监听热更新。
+外部新增语言自动进入 Sample 设置语言列表，显示 culture 的本地名称。外部来源不会修改人物 metadata，也不进入资源 provider。宿主可通过 `AvaloniaPlayerLocalization.AttachGame(content, additionalSources)` 或中立 `CreateResolver` 的 `additional` 参数提供更高优先级的自定义 JSON 来源；其加载方式由宿主自行实现。修改文件后重新启动生效，不提供文件监听热更新。
 
-安装器创建空 External 目录，复用相同安装时保留用户文件。不同/损坏包仍拒绝覆盖既有目录，因此不会删除翻译；没有新增覆盖更新协议。导出 `.galpak` 排除 External，安装器拒绝将该保留路径作为包 payload。
+新导出与安装器保留空 I18n 目录，galpak ZIP 显式保存该空目录；旧格式安装仍创建 I18n/External。复用相同安装时保留用户文件。不同/损坏包仍拒绝覆盖既有目录，因此不会删除翻译；没有新增覆盖更新协议。新 galpak 不包含外置翻译，安装器拒绝将 I18n 子文件作为 v3 payload。
 
 ## 首次启动
 
@@ -72,8 +76,8 @@ Avalonia Sample 在载入游戏内容和玩家变量后、显示标题和创建
 
 确认后将所选 locale 与启动次数一起提交到 profile 的 `player-variables.json`，成功写盘才更新内存和 culture；每次成功启动加一，计数在 Int32 上限饱和。取消选择退出窗口；关闭窗口会取消等待；取消、内容加载失败或写盘失败不会提交启动次数。后续启动跳过选择页，恢复可用的已保存语言；已移除语言回退到游戏默认/首个可用语言。没有游戏目录的 bootstrap 启动不计数。
 
-现有“清空游戏数据”会重置玩家变量并重启，因此下次再次显示首次选择。默认 profile 是每个游戏的 `.galnet`，也可用 `--profile` 显式指定；用户主动共享 profile 时也会共享偏好。该流程只在 Sample 宿主实现，Headless 不显示首次选择页。设置切换不强制重启：UI 即时刷新，已显示的人物名、对话、选项和 NVL 历史保持原文，后续条目使用新语言。
+现有“清空游戏数据”会重置玩家变量并重启，因此下次再次显示首次选择。Sample 默认 profile 位于用户 `LocalApplicationData/GalNet/<project identity digest>/`，身份来自 game.pak 内的 projectId（旧安装读取 content.json）；与安装位置和 buildId 无关。开发目录无内容身份时使用绝对路径摘要，开发版可用 `--profile` 显式指定；用户主动共享 profile 时也会共享偏好。该流程只在 Sample 宿主实现，Headless 不显示首次选择页。设置切换不强制重启：UI 即时刷新，已显示的人物名、对话、选项和 NVL 历史保持原文，后续条目使用新语言。
 
 资源的区域变体可由 `AssetLocaleResolver` 通过宿主选择的目录规则定位；这与文本的 `ITextResolver` 相互独立。
 
-文化与来源覆盖算法由 `Runtime.I18n.GameTextResolver` 统一实现，仅接收 `LocalizedTextSource` 查询委托；Runtime 不依赖 DynamicLocalization 或 JSON 格式。Sample adapter 负责每个 JSON 文件的 provider 构造、嵌入来源接入和 UI 框架适配，Avalonia 与 Headless 消费同一 Runtime 查询规则。
+文化与来源覆盖算法由 `Runtime.I18n.GameTextResolver` 统一实现，仅接收 `LocalizedTextSource` 查询委托；Runtime 不依赖 DynamicLocalization 或 JSON 格式。GameHost 的文本源解析为字典，Storage 校验复用同一解析规则；Avalonia.GameHost 负责嵌入来源和 observable 文本适配。Headless 不依赖 DynamicLocalization，两个宿主消费同一 Runtime 查询规则。默认文化由加载器写入 GameLocalizationContent.DefaultCulture，查询不读取默认项目 DTO。
diff --git a/docs/spec/runtime.md b/docs/spec/runtime.md
index 209049fe..12822216 100644
--- a/docs/spec/runtime.md
+++ b/docs/spec/runtime.md
@@ -8,7 +8,7 @@
 Graph + .galgroup
   -> GraphLoader / GalgroupLoader
   -> GameEngine
-  -> IGameView.Dispatch
+  -> IPrimitiveDispatcher.Dispatch
   -> PrimitiveInstance
 ```
 
@@ -16,12 +16,14 @@ Runtime 只执行 primitive entry。Composite entry 只能存在于 `.rawgalgrou
 
 ## GameEngine
 
-`GameEngine` 持有编译图索引、`IGameRuntime`、`IGameView`、可选 `IChoicePresenter`，以及当前活动的 `PrimitiveInstance` 队列。对玩家或 UI 只暴露一个推进入口：
+条件与变量表达式共用 NCalc 求值入口；双引号字符串按 JSON 转义规则读取，单引号字符串保留 NCalc 语法，未知变量读取为 null。非法条件按 false 处理并记录 `expression.invalid`（包含运行位置）；同一求值器对相同非法条件只报告一次，最多记录 64 个条件，避免循环刷屏。作者侧验证仍直接报告表达式错误。可选展示失败由对应内置模块降级，必需执行/状态错误继续传播；音频诊断订阅者异常不能阻止播放清理。
+
+`GameEngine` 持有编译图索引、`IGameRuntime`、`IPrimitiveDispatcher`、可选 `IChoicePresenter`，以及当前活动的 `PrimitiveInstance` 队列。对玩家或 UI 只暴露一个推进入口：
 
 ```csharp
 public Task<bool> AdvanceAsync(CancellationToken cancellationToken = default);
 public GameSnapshot CreateSaveData();
-public void RestoreFrom(GameSnapshot data);
+public Task RestoreFromAsync(GameSnapshot data, CancellationToken cancellationToken = default);
 public Task StopAsync();
 public ValueTask DisposeAsync();
 ```
@@ -31,18 +33,28 @@ public ValueTask DisposeAsync();
 1. 清理已完成实例。
 2. 在稳定边界更新最后稳定快照。
 3. 如果存在 pending Choice，直接返回。
-4. 如果调用开始时已有未完成 blocking instance，选择 sequence 最早者所属 batch，只 skip 该 batch 中当前已分发且可跳过的实例。
+4. 如果调用开始时已有未完成 blocking instance，选择分发顺序最早者所属 batch，只 skip 该 batch 中当前已分发且可跳过的实例。
 5. 如果当前 blocking 已解除，继续按顺序消费剧情，直到遇到新的 blocking instance、Choice 等待或剧情结束。
 
+长推进每批让出执行门，重新取得门后复核运行 scope 和阻塞边界；调用方取消仅结束本次推进，保留当前有效运行，不发布 Faulted。批次预算不是内容长度上限。`CheckpointCreated` 在执行门外发布，每个订阅者收到独立快照，订阅者失败不影响剧情。
+
+恢复在执行门内先准备隔离的 `GameRestorePoint`，验证变量、状态表、图位置与模块语义，随后才取消旧 scope 并提交；验证失败保留当前运行。已准备的状态表直接用于提交，不二次反序列化。
+
+GameSession 替换已有运行时先通过旧运行的 ValidateSnapshotAsync 校验候选存档，通过后才停止旧运行；无效存档不会释放当前运行。实际新运行仍自行验证和恢复，不能把预检结果当作任意运行的授权。呈现恢复失败发生在切换之后，正常报告故障，不声称已经回滚平台资源。
+
 手动模式下 Blocking instance 自然完成时，Engine 只执行无 skip 权限的内部 continue；它不是第二个玩家入口，也不能跳过下一个新遇到的 batch。自动/快速模式在有效推进边界等待全部 `IsAutoBlocking` 解除，再计时推进；不会通过模拟点击执行。
 
 ### 状态通知和停止
 
+默认 Avalonia 宿主在恢复/Seek 的中间 `Ready` 通知中保持当前会话状态；准备就绪不表示游戏终止，不触发返回标题页。
+
+玩家推进、播放计时、追帧、Step/Seek 的常规收尾共用状态捕获与门禁释放方法，释放后才发布通知；只需释放门禁的只读/准备步骤仍保持独立。追帧与调试回放共用现有推进内核，停止目标和逻辑副作用策略由各自入口明确决定。
+
 `State` 和 `StateChanged(GameEngineStateChange)` 统一报告 `Ready`、`Running`、`Completed`、`Faulted`、`Stopped`；失败通知附带原始异常。自然阻塞完成、Choice 结果/异常和玩家推进都经过同一状态机制，宿主不需要分别推断终态。通知在执行锁外按发生顺序发布，重复状态不重复通知；订阅者异常只诊断，不改变剧情状态。事件处理器不应同步等待 Engine 的异步操作；UI 线程切换、日志文案和存档槽刷新由宿主处理。
 
-`StopAsync()` 是该 Engine 的终态操作：立即拒绝新推进，取消执行 scope，清理活动实例和 pending Choice，并等待内部 continuation 退出和已读进度 FlushAsync 完成后报告 `Stopped`。Choice 后端即使没有协作取消，Engine 的等待也能退出；平台资源本身仍由宿主释放。停止后推进返回 `false`，不能恢复该 Engine；重开使用新 Engine。正常完成后再次推进不会重放已经结束的内容。未停止时 `RestoreFrom()` 取消旧 scope 并重新进入 `Ready`。
+`StopAsync()` 是该 Engine 的终态操作：立即拒绝新推进，取消执行 scope，清理活动实例和 pending Choice，并等待内部 continuation 退出和已读进度 FlushAsync 完成后报告 `Stopped`。Choice 后端即使没有协作取消，Engine 的等待也能退出；平台资源本身仍由宿主释放。停止后推进返回 `false`，不能恢复该 Engine；重开使用新 Engine。正常完成后再次推进不会重放已经结束的内容。未停止时 `RestoreFromAsync()` 取消旧 scope 并重新进入 `Ready`。
 
-Engine 同时支持同步和异步释放；异步宿主优先使用 `await using`。释放 Engine 不释放借用的 `IGameView`：先停止/释放 Engine，再异步释放执行 view，最后释放 presenters、媒体后端及资源。不新增通用 Runner 或要求平台实现继承宿主基类。
+Engine 同时支持同步和异步释放；异步宿主优先使用 `await using`。释放 Engine 不释放借用的 `IPrimitiveDispatcher`：先停止/释放 Engine，再异步释放执行 view，最后释放 presenters、媒体后端及资源。不新增通用 Runner 或要求平台实现继承宿主基类。
 
 ## Batch 与活动实例
 
@@ -71,7 +83,7 @@ Runtime 本地变量表归一化作用域前缀；向 IVariableService 回写已
 - 空 `BatchId` 表示实例独立成批。
 - skip 只发送给当前 `IsSkippable == true` 且尚未完成的实例；实例自己的 `Skip()` 仍必须幂等并重新判断阶段。
 
-`IGameView` 不保存活动队列，不选择 skip batch，也不推进剧情。活动队列、sequence、完成事件订阅、清理与内部 continue 都由 Engine 管理。
+`IPrimitiveDispatcher` 不保存活动队列，不选择 skip batch，也不推进剧情。活动队列、分发顺序、完成事件订阅、清理与内部 continue 都由 Engine 管理。
 
 ## Choice 与控制流
 
@@ -90,22 +102,27 @@ Choice 节点由 Engine 求值并过滤可见选项，再通过 `IChoicePresente
 
 `GameRuntime` 是游戏事实的唯一来源：
 
-内容 provider 将项目与安装目录的 `settings.json` 解析为 `GameContent.Settings`；两个 Sample 都把它注入 Runtime 的 `SettingsContainer`，自定义音频轨道不会退回默认轨道。缺少文件使用默认设置，非法 JSON 明确拒绝。
+内容 provider 将项目与安装目录的 `settings.json` 解析为 `GameContent.Configuration`（Core.Configuration.ProjectConfiguration）。它是版本化的作者内容文档，保存 section ID、版本和 JSON；不含固定游戏设置模型。宿主通过 GameContentLoadOptions 显式提供配置 schema 和开发语言选择委托；Storage 不引用默认 DTO。文件缺省时返回空文档，读取 section 默认值不修改内容，未知 section/字段保留，非法信封或已声明配置拒绝加载。默认模板和 Sample 选择 Contracts.Builtins 的 DefaultProjectOptions；自有项目可声明自己的 section。通用 section 编辑与完整自有 DTO 预览接入仍在实施。
+
+宿主把轨道定义显式传入 BuiltinAudioModule，把 PlaybackOptions 传给 Engine；GameRuntime 和 IGameContext 不携带完整设置或设置容器。未配置音频模块轨道时为空，不隐式创建默认轨道。
 
 | 状态 | 说明 |
 | --- | --- |
 | `CurrentNodeId` / `EntryIndex` | 当前流程位置 |
 | `IsGameEnded` | 结束标记 |
 | `TextResolver` | 宿主提供的剧情文本解析器；默认原样返回 |
-| `Settings` | 运行期设置容器 |
-| `State` / `SceneInstances` | 按注册类型/ID 存储的 GameState，以及其派生场景句柄索引与临时执行控制 |
+| `State` | 按注册类型/ID 存储的通用 GameState；契约可选择 keySpace 共享跨表身份索引 |
 | 变量存储 | Player / Save 作用域变量与表达式求值 |
 
-`GameSnapshot` 当前版本为 4，旧版本直接拒绝，不提供迁移兼容。它包含 `NodeId`、`EntryIndex`、Save 变量与 `States`：稳定 StateId → section version / JSON payload。模块组合时显式注册纯数据表与恢复处理器，未注册类型、重复 ID、缺失/未知 section、版本不符及无效载荷明确报错。builtin.animations 当前 section version 为 2，LoopAnimationState 保存 Request 或 Timeline；builtin.layers 当前 section version 也为 2，新增可选的 LayerVariantsState；两者均明确拒绝旧 v1 section。PrimitiveRegistry.State 的 version 参数传递到 Core 状态契约，其他模块默认仍为 1。每份存档写出全部注册表，包括空表；不写 CLR 类型名、Task 或后端对象。
+`GameSnapshot` 当前版本为 5，旧版本直接拒绝，不提供迁移兼容。它包含 NodeId、EntryIndex、Save 变量、ContentBuildId、StoryPackages 与 States（稳定 StateId → section version / JSON payload）。安装内容校验基础构建与准备时已安装的全部剧情包，缺少记录包不通过跳过降级恢复；开发目录构建标识为空。模块仍显式注册数据表及恢复器，未注册类型、重复 ID、缺失/未知 section、版本不符及无效载荷报错。builtin.animations 和 builtin.layers 的 section version 均为 2，拒绝旧 v1；其他模块默认仍为 1。每份存档包含全部注册表（含空表），不写 CLR 类型名、Task 或后端对象。
+
+差分 Layer 保存逻辑图集 ID、完整请求、最后保护集合、变体键、解析原因及可选 UsesResourceOverride（缺省 false）。解码检查来源互斥与状态结构，ValidateState 按会话图集解析。普通内容核对实际变体/图片/原因，不一致拒绝；明确的图集资源覆盖在安装或移除后，以选择意图重算候选状态的显示缓存和标记，保留输入存档及旧运行根。未知维度/值仍报错。展示恢复在呈现前复核；定义在准备阶段异步加载，show/select 同步。继续选择保留曾因缺组合而未显示的服装等意图。
+
+状态编解码支持显式 `JsonTypeInfo<T[]>`：Core 使用 `StateCatalogBuilder.Register` 的 `jsonTypeInfo` 参数，执行模块可使用 metadata 在首位的 `PrimitiveRegistry.State` 重载。内置模块已注册源生成数组元数据，自定义 AOT 状态需在组合期提供相同契约。`GameState.JsonOptions` 公开冻结的存档设置，配置 section 也可显式提供 DTO resolver；接入见 [NativeAOT 手册](../manual/native-aot.md)。
 
-差分 Layer 保存图集资源 ID、完整请求、最后保护集合、实际变体键和解析原因，实际 sprite ID 仍以 Layer.AssetId 为真源。解码阶段检查来源互斥与状态结构，模块的同步 ValidateState 使用会话已准备的不可变 ImageVariantsCatalog 重新解析，核对实际变体/图片/原因，再允许替换状态根；内容版本变更导致不一致时拒绝读档。展示恢复还会在呈现前复核内容。定义异步加载在会话准备阶段完成，show/select 本身同步，无需改变 Engine 读档协议。恢复后继续选择仍保留曾因缺组合而未显示的服装等意图。
+`CreateSaveData()` 返回 Engine 保存的最后稳定快照。状态表编码共享短同步边界，JSON 载荷和变量与运行对象隔离；不再由中央代码逐类型复制字段。读档先解码/校验候选状态与模块规则，再取消旧 scope 并替换整个 GameState；可选场景模块按新状态根解析独立场景服务。旧回调保留旧状态根，不能清理新代。展示恢复成功前暂停推进，恢复失败进入 Faulted。
 
-`CreateSaveData()` 返回 Engine 保存的最后稳定快照。状态表编码共享短同步边界，JSON 载荷和变量与运行对象隔离；不再由中央代码逐类型复制字段。读档先解码/校验候选状态与模块规则，再取消旧 scope 并替换整个 GameState/SceneInstances。旧回调保留旧状态根，不能清理新代。展示恢复成功前暂停推进，恢复失败进入 Faulted。
+`GameSnapshot.Attachments` 为可选的宿主附加 JSON 数据字典；SnapshotCopy 隔离复制，Engine 不解释或导入其内容。默认 Avalonia 宿主实际保存时附加对白历史，运行时快照不携带完整历史正文。`readingBoundaryId` 前导原语到其阅读原语之间不发布新的稳定快照，避免带语音对白读档落在音频和文字之间。`IPrimitiveDispatcher.OnInstructionSkipped` 是条件未执行通知；`OnPlaybackContinuing` 在有效手动推进（含仅补全文字）、自动推进、有效选择及启用自动/快速时通知宿主清理临时交互；`OnCheckpointCreating` 在执行门内提交已完成的宿主观察，随后捕获状态，防止展示完成的异步续体滞后导致游标和剧情位置不一致。这些方法默认空实现，不引入具体媒体依赖。
 
 Save scope 随存档槽保存和恢复；Player scope 由宿主变量服务独立持久化，普通读档不得回滚。内置系统可以通过 `SystemVariableDefinition` 注册生成变量。Gallery 为每个 item 注册默认 `false` 的 Player bool `gallery_<item-id>_unlocked`；`gallery.unlock` 校验 item ID 后把该变量设为 `true`。
 
@@ -156,7 +173,7 @@ Dialogue/NVL 使用 Builtins 的 `TextAdvancePrimitiveInstance` 共用打字、
 
 `SynchronizePresentationAsync` 与追帧展示协调在 Engine 执行门内调用；回调及其等待的清理任务不得重新进入或等待 Engine 推进/模式操作，否则会形成循环等待。同步使用该代隔离的 runtime 和 run token；调用者 token 只控制进入同步门，不作为持久播放的生命周期 token。
 
-玩家间隔配置为 `GameSettings.AutoAdvanceIntervalMilliseconds` 与 `QuickAdvanceIntervalMilliseconds`（int，默认 2000/50），Runtime 以毫秒计时并拒绝负值。Normal/Quick/CatchUp 分发与 `IsAutoBlocking`、状态事件、`IAdvanceWaitInstance` 分别表达呈现策略、自动等待和全文后推进等待；自动模式不会把对白等待下一次推进误当作仍在打字。完整阅读成功使用 group ID + 稳定编译条目 ID 记录，progress v2 与 compiled v3 拒绝旧格式，不迁移。
+玩家间隔配置为 `PlaybackOptions.AutoAdvanceIntervalMilliseconds` 与 `QuickAdvanceIntervalMilliseconds`（int，默认 2000/50），Runtime 以毫秒计时并在更新入口拒绝负值。Normal/Quick/CatchUp 分发与 `IsAutoBlocking`、状态事件、`IAdvanceWaitInstance` 分别表达呈现策略、自动等待和全文后推进等待；自动模式不会把对白等待下一次推进误当作仍在打字。完整阅读成功使用 group ID + 稳定编译条目 ID 记录，progress v2 与 compiled v3 拒绝旧格式，不迁移。
 
 ## Entry Module 与 GameView
 
@@ -182,28 +199,56 @@ Engine 不拥有 view。宿主先释放 Engine，再 `await view.DisposeAsync()`
 - `animation.animate` / `timeline.play` / `animation.stop`：创建 animation primitive instance；一次性动画先提交最终逻辑状态，循环动画提交第 0 帧状态并保存完整重放定义，再启动呈现动画。timeline 是单个 instance，内部事件只作为 animation 模块私有 layer/effect 事件处理，不重新进入通用 Entry 分发。
 - `effect.apply` / `effect.stop`：维护唯一的 EffectInstance 数据表和 `IEffectPresenter` 调用；动画直接修改同一记录，不维护 ActiveEffectState 镜像。Skia effect-program 的 `@gal.effect` 元数据声明可动画参数，动画使用其逻辑参数名；`time` 可映射到常见 shader 时间 uniform。
 - `audio.play` / `audio.stop` / `audio.pause` / `audio.resume` / `audio.enqueue` / `audio.next` / `audio.clear`：`AudioRuntime` 持有轨道队列与 voice 生命周期，`IAudioPlaybackHost` 只执行平台播放请求。`dialogue.textVoice` 与 `nvl.appendVoice` 会先发出非阻塞的 `audio.play(replaceIfDifferent)`，默认使用 `vocal` 轨道，再按正常文本语义阻塞。
-- `audio.seffect.apply` / `audio.seffect.stop`：以 `trackId` 和 `instanceId` 附着或移除宿主 catalog 已注册的轨道 SEffect；当前 Avalonia host 支持 `seffect.gain`、基于 equalizer 频段近似的 `seffect.lowPass` 与 `seffect.highPass`。未知 ID、非法参数或不支持 scope 只记录诊断，不会静默附着。
+- `audio.play` / `audio.enqueue` 的 `loopCount` 默认 1，0 为无限重复；`completion` 默认为 `discard`，`requeueTail` 在完整播放次数结束后回到队尾。单项重复优先于 completion，失败、停止、替换、next 与 scope 清理不触发重播。每轮重新生成后端 identity；这是结束事件驱动的重复播放，不承诺无缝。有限循环保存 `CompletedIterations`，旧数据缺省为 0；旧请求缺省仍为一次播放并丢弃，当前轨道与效果状态表为 v2，旧档不能混用。无限循环计数不累加。暂停期间结束的播放保留逻辑项，Resume 后启动新一轮。
+- `audio.seffect.apply` / `audio.seffect.update` / `audio.seffect.stop`：以 `scope`（track/bus）、`targetId` 和 `instanceId` 管理有序目标效果链。默认 PCM 后端支持 gain、真正的二阶 lowPass/highPass（cutoffHz/q）和 reverb（roomSize/decaySeconds/damping/mix），不再使用 EQ 频段近似。apply 同实例更新保留顺序；update 只合并已有实例的参数，整体验证后更新，缺失实例不创建。stop 默认精确停止，`all=true` 显式移除该目标的全部效果，与非空 instanceId 互斥。启停平滑；参数或目标非法则诊断。`audio.mix.set` 保存独立于玩家偏好的目标 gain/muted。
 - `particle.play` / `particle.stop`：用 `rate` 创建和停止持续 emitter，维护唯一的 ParticleEmitterInstance 数据表，场景句柄查找引用同一记录。存档只保存 emitter 定义、排序与动画值；宿主读档后通过模块注册的恢复处理器 以相同 seed 从头重建，不保存单颗粒子。`initial` 的 lifetime、velocity、size、rotation、angular velocity、color 以及 `flipbook` 的播放速度与起始帧都按粒子确定性采样；`motion` 提供 gravity、noise、drag、radial、orbit、attractor，`lifetime` 曲线线性插值 size、opacity、velocity、rotation、color。当前粒子年龄、位置和 flipbook 帧不单独存档。
 - `particle.burst`：用 `count` 向 `IParticlePresenter` 发出一次性 burst，不创建 Runtime scene state，也不参与存档恢复。有限持续效果由流程或 animation timeline 编排 play/stop；重复 burst 由 animation timeline 事件表达，跳过 timeline 时不补发未来 burst。
 - `video.play` / `video.stop`：视频是 Runtime Layer，`IVideoPresenter` 将平台解码帧送入场景管线；阻塞时每次推进跳到当前播放位置之后的下一时间戳，跳转期间保持阻塞，结束后继续剧情。稳定存档只保存视频图层定义，非阻塞视频恢复时从零播放；播放 identity 和游标不入存档。
 - `flow.wait`：blocking、skippable 的等待实例。
-- `variable.set`：求值后写入 Runtime 变量。
+- `variable.set`：求值后写入 Runtime 变量；表达式非法或没有值时拒绝本次赋值、保留原值并给出定位诊断，不把失败转换为空字符串。写入/状态错误仍正常传播。
 - `gallery.unlock`：按稳定 item ID 解锁 Gallery，写入对应的系统 Player bool。
 - `custom.invoke`：`BuiltinCustomActionModule` 按 ordinal action ID 查注册的实例工厂，原样传入 argument。注册在 view 组合时冻结，重复/空白 ID 拒绝。`RegisterImmediate` 同步非阻塞；`RegisterAsync` 支持运行 scope/模块生命周期联合取消和可选阻塞，并通过 PrimitiveTaskScope 在异步释放时取消、排空任务和聚合错误。两种便利入口 Normal 调 execute，Quick 调 quick 或回退 execute，CatchUp 调 catchUp 或空操作；运行中模式切换不重启委托。`RegisterFactory` 返回的独立实例自行管理完整模式/跳过/完成和资源清理语义。未匹配时所有模式 warning 后同步完成，可配置严格缺失报错；处理器自身失败正常传播。模块不自动注册持久状态，也不序列化委托或资源。接入见[通用 action](../manual/custom-actions.md)。
 
-视频图层与音频的轨道播放、淡化、队列和当前轨道 SEffect 行为由内置模块实现。玩家音量/静音按 master × bus × 内容 gain × 轨道默认 gain 合成并应用到当前及后续 voice；item effect 和音频参数动画仍未实现。AudioTrackState 保存轨道当前播放项、内容 gain、暂停状态与有序队列；AudioSEffectState 单独保存轨道效果，空闲时仍保留并作用于后续 voice。所有仍存在的轨道状态按检查点恢复，包含 SFX/Vocal；活动内容从头开始，不恢复游标和淡化时钟。暂停轨道在 Resume 前不启动播放器。恢复重新读取项目轨道配置并应用当前玩家音量；正常结束先更新逻辑状态和队列，后端身份/ticket 不入存档。Gallery 的平台无关 catalog 与解锁数据层由 Core/Runtime 提供；默认 Avalonia 前端通过宿主提供的 `IGameGallerySession` 浏览 CG、视频和音频，不把页面或媒体状态写入 Runtime。
+音频实例保存资源、内容 gain、淡入淡出与完成处理；Track 管理容量、顺序/随机选择和 None/One/All 循环策略。跨平台 PCM 路径为实例 → Track 汇总/效果/音量 → Bus 汇总/效果/音量 → Master 限幅。玩家 mix 与剧情目标 mix 独立相乘，Bus 效果处理一次汇总结果，源结束后继续输出尾音。AudioTrackState/AudioSEffectState 版本为 2，新增 AudioChannelState；随机状态、队列、暂停和效果顺序可恢复。读档活动源从头开始，不保存媒体游标、包络或 DSP 缓冲；暂停源在 Resume 前不启动。配置 `galnet.project` v2 使用 audioBuses / busId。旧配置/状态版本拒绝，详见 [音频混音](../manual/audio-mixing.md)。
+
+循环播放读档时从当前轮开头重播并保留已完成轮数；重新入队开始新一轮循环计数。ticket 随完整逻辑播放完成，轮播/无限重复需通过停止、替换或跳过终止。`ReplaceIfDifferent` 命中相同资源时更新 gain、completion 与 loopCount，次数改变时重新计数，不重启当前后端声音。
+
+淡出项立即从逻辑播放集合移除，但 AudioRuntime 保留运行期 retiring voice，继续发送玩家音量/静音更新；retiring 不进入存档，也不占逻辑声部/队列容量。支持淡出的 host 必须在真实结束（含显式停止、淡出完成、停止尚未启动的声音）时上报对应 Ended，供运行时清理身份；scope 切换和释放会强制立即停止所有 retiring。此类结束不会重新入队。
 
 动画 timeline 的事件与轨道共用 presenter 的播放时间源。`PlayTimelineAsync` 必须在采样前 await `beforeFrame(elapsedFrames)`，正常完成前提供末帧；Loop/PingPong 的 elapsedFrames 单调增加，不在循环时归零。跳过不补发未来 particle burst。
 
-音频后端请求按 voice 顺序提交，Stop 即刻取消尚未完成的 Start；异步销毁等待排队请求结束。Avalonia host 先登记待加载音频，停止/销毁取消加载，等待加载结束后释放 LibVLC 与临时目录。读档停止旧 scope 音频，模块恢复时重新生成后端 identity。旧 scope Reset 与延迟终态事件不能影响新代。Headless 仍保留轨道/效果逻辑数据；缺少 host 时流程 ticket 完成。
+Timeline 的播放级 Once 初始化事件不随迭代重放，OnCompletion 清理仅在整段完成/跳过时通知。`animation.stop / CompleteImmediately` 等待对应播放实例的 PresentationCompletion；中立实例补发剩余非 burst 事件并提交循环终态后才移除播放身份，保证后续剧情可复用标识。Timeline 的 AfterIteration 请求由单调播放时钟在下一轮边界完成；无活动呈现的循环直接提交逻辑终态。CatchUp 分离、scope 取消和被替换不补发完成清理。事件生命周期为 Timeline 的可选字段，builtin.animations section 仍为 v2。
+
+音频后端请求按 voice 顺序提交，目标级 Configure/Mix/Effect/Reset 另有顺序屏障，Start 等待已提交的目标配置。Stop 即刻取消待加载 Start；异步销毁等待后台源和设备回调退出。Windows miniaudio 解码至每实例有界 PCM 缓冲；设备回调不执行文件 I/O、不取得 Runtime 锁或调用终态订阅。取消后的租约和原生解码器均释放，读档清空旧图，旧 scope Reset 与迟到终态不能影响新代。Headless 保留逻辑状态；无 host 时流程 ticket 完成。
 
 ## 已读进度提交边界
 
+存档槽、玩家变量和已读进度的文件写入共用替换工具：每次写入使用同目录下独立临时文件，成功写完并检查取消后替换目标，失败时清理本次临时文件。各服务继续负责自身的锁、数据快照和提交时机；进度 revision 只在替换成功后推进。
+
 `ReadProgressIndex` 在 Runtime 中维护内存索引与 revision。文件实现 MarkRead 不执行磁盘 I/O，默认每 2 秒批量写入；同一个进度实例串行化 flush/clear，写入期间的新标记保留 dirty 状态。后台失败由 LastPersistenceError 暴露并在下个周期重试。Engine StopAsync 在执行与 continuation 退出后等待 FlushAsync，失败仍发布 Stopped 并向调用者传播；Sample 保存前 flush，销毁进度实例时取消定时器并完成最终提交。强制终止可能丢失自上次成功 flush 以来的标记（正常 I/O 时最多一个周期，持续失败时不保证时间上限）。存档槽恢复不回滚玩家已读进度。
 
 ## 执行内部协作者
 
+primitive 和呈现恢复只借用 `Core.Runtime.IGameContext`：游戏位置只读，允许变量/场景操作和显式 EndGame，不提供游标修改、快照或读档方法。Engine 持有的 `Runtime.Runtime.IGameRuntime` 才拥有这些运行管理能力，准备恢复使用同程序集的 GameRestorePoint；旧 scope 在状态同步边界内检查取消，不能在恢复提交后写入新代变量。
+
+执行上下文没有 Settings 属性。Engine 以 Core.Execution.PlaybackOptions 的不可变值保存自动/快速推进配置，宿主通过 UpdatePlaybackOptionsAsync 一致更新；无效间隔在提交前拒绝，不更改当前配置或使运行 Faulted。音频模块借构造参数获取独立的轨道定义副本，以 AudioConfiguration 接收已验证的 Bus/Track 声明，以 AudioMixOptions 接收主音量与分别按 Bus/Track ID 索引的混音值；ApplyMix 复制集合后更新已有及后续 voice，不在每次播放时读取完整玩家模型。Avalonia.GameHost.Settings.GameSettings 只是默认宿主的偏好模型，映射到上述输入，项目不必继承它。窗口、文本和保存设置由各自宿主/呈现服务消费。SettingsContainer、SettingsSection、无消费者的 SaveSettings 和旧 SfxChannelCount 已删除；并发数量只由每轨 MaxVoices 表达。
+
+`IPrimitiveDispatcher`、IChoicePresenter、ICatchUpPresentation 和 IPlayerPlaybackController 位于 Core.Execution，描述分发、状态验证、Choice 输入、快进同步和玩家播放控制，与具体 presenter/UI 无关；CompositeGameView 是分发协议的组合实现。音频后端端口位于可选 Contracts.Builtins.Audio，Runtime 不引用 Presentation.Abstractions 或内置场景/音频契约。`EngineNotifications` 统一按产生顺序排队状态、播放模式和检查点通知，在执行门外发布并隔离每个订阅者。活动实例列表本身保持分发顺序，不维护额外排序或自动阻塞镜像集合。
+
+运行图在 Engine 构造时验证并复制到私有导航索引；外部修改作者图、条目参数或边不会改变已创建的运行。重复节点/出口、缺失根/边目标和非法出口在启动时拒绝；没有后继边仍表示正常结束，合法循环不因批次预算被拒绝。
+
+Runtime 的变量读取和变量集合快照均返回独立 Variable，稳定 UID 保留，写入必须经过 SetVariable。模块使用的 StateTable/可选 runtime.Scene() 仍返回同一持久记录，必须在 State.Update 内修改；这是执行模块内部的共享数据边界，不是隔离快照。GameState 不公开锁对象，跨层同步使用 Read/Update，编码后的 Capture 才是可传递的隔离状态。
+
 Engine 保持唯一执行门禁、运行取消和终态通知。ActivePrimitiveRegistry 拥有实例顺序、group execution identity、事件订阅、完成实例清理与 skip batch；GameGraphNavigator 在启动时索引编译图，运行期间拓扑保持稳定。AudioRuntime 保留轨道、票据、队列溢出、音量和 SEffect 逻辑；AudioBackendDispatcher 负责逐 voice 命令顺序、待加载 start 取消、能力降级和异步工作 drain，并共享 AudioRuntime 的锁。同步后端终态回调的清理在提交完成后取得同一锁，且纳入销毁等待。
 
 
 状态表是持久事实的唯一来源；Layer、EffectInstance、ParticleEmitterInstance 在此处是中立数据/动画属性对象，不包含播放任务。AnimationPlaybackInstance 等停止控制只存在于派生运行索引。读取活动数据后修改属性必须在 `State.Update` 中完成，展示/异步操作放在同步边界外。当前保存仍恢复检查点时刻的状态；检查点之后自然结束的声音不会反向改写已冻结的历史快照。
+
+内置场景的唯一句柄由状态契约显式声明 keySpace="builtin.scene"，写入与恢复使用同一通用跨表身份检查。可选 Primitives.Builtins.BuiltinScene 按 GameState 根提供 Scene()，持久对象来自上述索引，临时动画控制只属于该根。读取旧 scope 不能解析到读档后的新状态。音频运行、后端调度与票据移入 Primitives.Builtins.Audio，混音配置与后端端口位于 Contracts.Builtins.Audio。
+
+
+## 宿主显式变量修改
+
+GameEngine.SetVariablesAsync 接收带 player./save. 前缀的有限基础值批次，复制并预验证输入后，通过唯一执行门及 GameState 同步边界提交；恢复或停止使已排队的旧 scope 请求失效。它不推进剧情，也不捕获未完成的呈现状态，仅把本批显式存档变量合入原稳定快照，并在执行锁外发布检查点通知。玩家变量由原变量桥接回写，持久化仍由宿主协调。变量观察者接收独立副本，异常记录日志且不截断其他更新。
+
+UpdateVariablesAsync 可在同一门内读取独立变量快照并同步计算修改批次，计算/校验失败不提交，适合条件扣款和计数累加。该入口不提供任意异步业务事务或阻塞活动原地恢复；项目通过模块状态及明确检查点策略处理复杂行为。通过 Runtime 对象直接写入不会自动刷新 Engine 的稳定存档快照，外部应用应使用此入口。
diff --git a/features/F-20260916-02-audio-system/follow-up-20261026.md b/features/F-20260916-02-audio-system/follow-up-20261026.md
new file mode 100644
index 00000000..2b776357
--- /dev/null
+++ b/features/F-20260916-02-audio-system/follow-up-20261026.md
@@ -0,0 +1,58 @@
+# 音频结束策略、重复播放与资源回收
+
+用户已授权实现本轮整理的待办，并明确将资源缓存回收纳入范围。沿用现有 audio.play/enqueue/stop/next 等原语，不新增另一套播放控制。
+
+## 设计与验收
+
+- `completion` 使用 `discard`（默认）或 `requeueTail`。仅自然结束触发重新入队；失败、显式停止、替换、next、scope 清理不重新入队。多首曲目遵循 FIFO 和已有容量/溢出策略。
+- `loopCount` 为非负整数，默认 1，0 表示无限重复；单项重复优先于 completion。有限次数进度保存到 AudioItemState，读档从当前轮开头继续剩余轮次。旧数据省略参数仍为一次播放并丢弃。重复由 Runtime 重新发出 Start，不宣称无缝，不改变后端播放协议。
+- 自动推进 ticket 在完整逻辑播放（含重复与轮播）终止时完成；无限播放需要停止/跳过才能完成等待。每轮生成新后端 identity，旧事件不能消耗新轮。
+- 淡出逻辑项立即离开存档状态，但运行时保留 retiring voice；玩家音量/静音仍能控制它。后端终态清理 retiring，scope 清理强制停止；retiring 不入存档。
+- 复用现有 AssetManager / AssetFileMaterializer 引用计数，不新增音频专属缓存或 LRU 层。加载中、活动与淡出声音持有独立 AssetFileLease，播放器先释放、租约后释放；最后一个使用者释放时，已有 materializer 删除文件。其他声音、视频/Gallery 的租约不受影响。
+- 不实现 seek、精准恢复、无缝循环、自然结尾交叉淡化、其他 DSP 或音轨重构。
+
+## 阶段
+
+1. **verified**：Core/Contracts 参数、Runtime 重复/轮播与持久化；有限/无限、FIFO、失败/停止、暂停/恢复及旧代事件已通过测试。
+2. **verified**：retiring voice 与后端终态；淡出期间音量、静音、scope 清理及真实 LibVLC 淡出终态已通过测试。
+3. **verified**：voice 租约正确归还；并发共享、跨消费者持有、取消加载、停止/自然结束/淡出/销毁的释放已通过原生测试。用户指出已有计数层后，移除初稿的音频专属缓存方案，直接修复后端租约持有范围。
+4. **verified**：四语 Editor 标签、规范、使用手册与相关回归完成。保留开工时所有无关改动（含 ReadyToRun 配置与此前表单修改）。
+
+## 验证记录
+
+- `dotnet build` 顺序构建 Runtime.Tests、Presentation.Tests、Primitives.Builtins.Tests、Editor.Tests，均成功；统一使用 `-m:1 -nr:false --no-restore -p:OutputPath=bin/audio-followup/`，避免覆盖正在使用的常规产物。
+- Runtime 全项目 121 项通过，包含 23 项音频测试。
+- Primitives 全项目 178 项通过，包含编译参数到执行端与自动阻塞的端到端测试。
+- Editor 10 项 Group 属性/音轨/循环参数测试通过，真实控件提交及项目 Undo/Redo 已验证。
+- 原生 LibVLC 生命周期测试 7 项通过：立即停止/淡出/自然结束释放文件、并发声音及外部消费者共享、加载取消/销毁、忽略取消的 provider 返回后的租约释放。使用本地 win-x64 LibVLC、临时静音 WAV 与 dummy 音频输出；沙箱内原生测试未返回，停止后改为宿主运行通过。
+- 四语新增 `loopCount`、`completion`、`discard`、`requeueTail` 标签；手册见 [音频重复与轮播](../../docs/manual/audio-playback.md)。
+
+## 总结与边界
+
+本轮修复了实际租约持有范围，没有修改共享资源计数层，也没有留下音频专属缓存。循环与轮播属于 Runtime 逻辑调度，不承诺无缝；不恢复精确音频游标。当前仅验证本地 LibVLC dummy 输出及平台无关测试，未作真实设备听感验收。没有修改旧的首期总结或其他任务中的代码/构建配置。
+
+
+## 合并后的架构对齐修复
+
+合入引擎核心重构后，后续音频提交仍引用已删除的 `Core.Audio`、`Runtime.Audio` 和旧 Runtime Settings API，且循环契约/执行实现没有迁入新目录，导致 `AudioCompletion` 缺失及后续编译错误。
+
+- 在 `Contracts.Builtins.Audio` 补齐 completion、总播放次数与已完成轮数；在 `Primitives.Builtins.Audio.AudioRuntime` 合入循环/轮播与 retiring voice 逻辑，保留 `GameState.Update` 和显式 `AudioConfiguration` / `AudioMixOptions` 边界。
+- `BuiltinAudioModule` 恢复当前架构的构造、恢复及 scope 接口，并将 DTO 的循环参数传入播放请求。
+- 音轨编辑器通过 `Configuration.ReadDefaultOptions()` 读取声明，无项目上下文时不注入固定音轨；项目设置测试按 section API 写回不可变音轨记录。
+- 循环测试移至 Primitives.Builtins.Tests；作者测试显式声明音轨/配置，原生媒体测试显式传入资源类型 catalog。
+
+### 从远端基线重新整理
+
+按用户要求，撤回未推送的本地提交 `1d32eae4`，以远端 `origin/dev` 的 `5fe17e6b` 重新整理本轮音频与表单改动。原提交保留在 `codex/backup-before-audio-remerge-20261026-212617`，当时全部未提交内容另存于 `artifacts/audio-remerge-20261026-212617/`。使用独立 Git 索引构造 27 文件候选，隔离工作区其他正在修改的 Group 文件；没有覆盖它们。
+
+候选快照位于上述目录的 `review/`，证据位于该目录的 `build.log`、`format.log`、各测试日志和 `results/*.trx`：
+
+- Locked restore、完整解决方案构建、候选文件格式检查通过；构建 304 个警告、0 个错误。
+- Primitives 282、Runtime 123、Presentation 244、Architecture 49 项全部通过。
+- Editor 相关控件 10 项执行，9 项通过；音轨选择、循环/轮播参数、Undo、翻页输入均通过。
+- 本地 LibVLC dummy 输出下的原生音频生命周期 7 项全部通过。
+- 共执行 715 项，714 项通过。`TimelinePropertyOpensItsOwnEntryAndReopensDockWithoutCreatingMissingData` 在测试准备期间的 `EditorProjectCreator.Directory.Move` 失败，暂存目录访问被拒绝；没有进入 Timeline 断言。该项目创建代码与远端相同，根因未确认，不将其归为本轮合并问题，也没有添加重试或跳过。此项不标记为通过。
+
+此前工作区构建与回归的原始记录保留在 `artifacts/merge-fix-*`：正常构建曾通过；后续正常目录构建被运行中的 Editor 占用，改用独立输出。Editor 全量先后有 43/325 和 5/325 失败，后一次均为暂存目录移动失败；定向复验 13 项中 11 项通过、2 项同类失败。保留这些失败记录，不以重新合并抹去验证限制。
+
+重合并结果只保存为本地提交，尚未推送。
diff --git a/features/F-20261013-02-parameter-and-sample-simplification/phase-1.md b/features/F-20261013-02-parameter-and-sample-simplification/phase-1.md
index e0de13ec..322e43ca 100644
--- a/features/F-20261013-02-parameter-and-sample-simplification/phase-1.md
+++ b/features/F-20261013-02-parameter-and-sample-simplification/phase-1.md
@@ -47,7 +47,7 @@
 
 用户实际运行发现 GameTestCase/Contracts 仍保留旧构建，引用已变更的 DynamicParameterDescriptor 五参数构造函数，导致 Method not found。前述测试使用新编译契约，未覆盖仓库内容项目的已部署产物，属于本阶段验证遗漏。
 
-使用 scripts/build-project-contracts.ps1 重新构建 Sample.Contracts 并整体替换 GameTestCase/Contracts（含 Core、Builtin.Contracts）；构建零警告、零错误。随后运行 Headless 的 `build GameTestCase`，返回 operationId=project.build、success=true、compiledGroupCount=4、diagnostics=[]。未添加旧构造函数兼容重载。部署 DLL 与 Output 属于忽略的生成产物；README 补充 API 改动后必须重新部署的说明。
+使用 scripts/contracts/build-project-contracts.ps1 重新构建 Sample.Contracts 并整体替换 GameTestCase/Contracts（含 Core、Builtin.Contracts）；构建零警告、零错误。随后运行 Headless 的 `build GameTestCase`，返回 operationId=project.build、success=true、compiledGroupCount=4、diagnostics=[]。未添加旧构造函数兼容重载。部署 DLL 与 Output 属于忽略的生成产物；README 补充 API 改动后必须重新部署的说明。
 
 ## 下一阶段
 
diff --git a/features/F-20261015-02-editor-authoring-workspace/design.md b/features/F-20261015-02-editor-authoring-workspace/design.md
index 32bd16e0..69f14d7d 100644
--- a/features/F-20261015-02-editor-authoring-workspace/design.md
+++ b/features/F-20261015-02-editor-authoring-workspace/design.md
@@ -1,5 +1,7 @@
 # Editor 创作工作区设计
 
+2026-10-26 Group 一致性补充设计已获用户授权按阶段实施：针对 [专项审核](review.md)，以项目作者操作的准备/提交边界统一变更发布，以共享 Entry 作者语义目录支持引用索引、身份迁移和场景分析；草稿生命周期与控件 lease 分离，查询按依赖和结果版本失效。沿用现有作者文档、历史和保存基线，不新增通用事件总线或重复 schema。模块职责、接口、数据流、取舍、兼容性、迁移与验收见 [Group 编辑一致性与模块化设计](group-authoring-consistency-design.md)。GC1 作者提交边界已 verified，900 项执行通过、4 项 Explicit 原生 GUI 未运行，见 [阶段记录](phase-group-consistency.md)；待移动剪切、删除输入归档/恢复与局部依赖失效仍在后续阶段，不表示这些交互已经交付。
+
 2026-10-21 P6e4c4：播放控制候选以 Playbacks 与场景 Targets 分域，共用纯分析、项目代次和 Locator 选择 lease；停止动画字段复用共享选择器，语言刷新保留域，UI 只显示类型及原条目来源。后续播放存在性保持可能，立即完成与迭代后停止区别处理，阻塞终态不泄漏内部播放。范围及验证见 [phase-6e4.md](phase-6e4.md)，当前行为见 [场景目标规范](../../docs/spec/editor-scene-targets.md)。
 
 2026-10-21 P6e4c3b：效果声明通过项目级后台资源准备进入不可变场景查询代次，Core 与 renderer 共用受支持标量转换；legacy catalog 与 program metadata 分开处理。当前对象能力缺失与上游语义未知独立保留；资源刷新/关闭使旧加载、选择及编辑行失效，既有轨道保留。已验证边界见 [phase-6e4.md](phase-6e4.md)，稳定规则见 [场景目标查询规范](../../docs/spec/editor-scene-targets.md)。
diff --git a/features/F-20261015-02-editor-authoring-workspace/feature.md b/features/F-20261015-02-editor-authoring-workspace/feature.md
index 817dcb6a..16065047 100644
--- a/features/F-20261015-02-editor-authoring-workspace/feature.md
+++ b/features/F-20261015-02-editor-authoring-workspace/feature.md
@@ -4,11 +4,24 @@ title: Editor 创作工作区重构
 type: refactor
 status: in-progress
 created: 2026-10-15
-updated: 2026-10-21
+updated: 2026-10-26
 ---
 
+Group 一致性补充改造 GC1–GC5 已完成并验证：删除引用影响、移动身份、输入归档（含整 Group/文件删除）、局部查询、实时搜索/友好摘要及对象释放已收口。最终 926 项回归通过，当前源码解决方案构建、格式与指纹核对通过；四项原生 GUI 及人工 IME/剪贴板流程未验收。详见 [阶段记录](phase-group-consistency.md)、[实现后复核](review.md) 和 [摘要](summary.md)。整个 feature 的其他 P6/P7 计划继续分别追踪，status 保持 in-progress。
+
 # Editor 创作工作区重构
 
+2026-10-26 Group 交互简化 verified：删除、换类型、移动直接执行，引用问题在 Problems 自动更新，无需影响确认或先点击检查；保留严格编译/构建错误门禁。Editor 325 项与 Shared 相关 34 项通过，详见 [直接编辑修订](group-direct-editing.md)。此修订替代下文历史记录中的 Group 影响弹窗行为。
+
+2026-10-26 GC3 Entry 身份与输入生命周期 verified：待移动剪切、相容输出身份迁移、删除输入持久归档和新绑定显式恢复已接通；四项目 918 项执行通过，4 项 Explicit 原生 GUI 未执行，四语/格式/32 文件指纹通过，见 [阶段记录](phase-group-consistency.md#gc3身份与输入生命周期)。GC4/GC5 和整 Group/文件结构删除的独立输入协调验收保留。
+
+
+2026-10-26 用户要求继续，GC2 语义与引用诊断 verified：统一声明/索引、位置影响、Group 删除与换类型确认、Problems 警告已接通；四项目 909 项执行通过，4 项 Explicit 原生 GUI 未运行，四语/格式/指纹通过。GC1 提交为 `1496e0c`，本阶段证据见 [实施记录](phase-group-consistency.md#gc2语义引用诊断与操作影响)。剪切身份、删除输入、局部失效及释放仍按 GC3–GC5 保留。
+
+2026-10-26 用户授权开始 Group 一致性重构，按 [补充阶段](phase-plan.md#group-一致性补充阶段2026-10-26) 推进；GC1 作者提交边界 verified，四项目 900 项执行通过、4 项 Explicit 原生 GUI 未执行，格式与源码指纹通过，见 [阶段记录](phase-group-consistency.md)。后续引用、身份/草稿、依赖缓存和释放分阶段验证。授权覆盖设计推荐方向，具体行为与偏差随阶段记录；此前 proposed 表示设计形成时的状态。
+
+2026-10-26：用户要求分析 Group 删除、引用、场景推断更新及相关异常，形成 [专项审核](review.md)；随后要求更统一、模块化的处理设计，补充 [Group 一致性设计](group-authoring-consistency-design.md)。当前状态为 proposed，只有设计与审核文档；剪切和草稿交互取舍尚待确认，未开始本方案业务实现，也未将本轮建议同步为正式 spec。
+
 ## 用户原始目标与澄清
 
 UI Editor 的功能落后于当前项目能力，需要分析并重构整体架构，使基本创作流程跟上进度。最初讨论了接入现有命令模型；用户随后明确：
diff --git a/features/F-20261015-02-editor-authoring-workspace/group-authoring-consistency-design.md b/features/F-20261015-02-editor-authoring-workspace/group-authoring-consistency-design.md
new file mode 100644
index 00000000..a41f4078
--- /dev/null
+++ b/features/F-20261015-02-editor-authoring-workspace/group-authoring-consistency-design.md
@@ -0,0 +1,237 @@
+# Group 编辑一致性与模块化设计
+
+2026-10-26 交互修订：用户确认 Group 删除、换类型、移动直接执行，不再显示场景影响确认。引用保留，由 Problems 自动更新诊断；静态场景推断警告不作为编辑或编译门禁，确定的作者数据错误继续由现有严格编译/构建校验拒绝。保留提交版本检查、身份迁移、输入归档和 Undo/Redo；影响报告改为按需计算，普通操作不再预先分析影响。下文影响确认相关内容保留为历史设计。
+
+日期：2026-10-26。状态：**GC1–GC5 verified，本轮 Group 改造已收口**。归属 F-20261015-02，原始问题与实现后复核见 [专项审核](review.md)，实际实现、取舍及证据见 [阶段计划](phase-plan.md) 和 [实施记录](phase-group-consistency.md)。本文保留设计目标与演进背景，当前行为以 spec 为准；整个 feature 的其他范围仍分别追踪。
+
+## 1. 要统一的边界
+
+将一次作者修改统一为“准备操作 → 检查影响 → 提交 → 发布结果”。字段控件、删除按钮、剪贴板、Undo/Redo 都进入同一事务边界；引用索引、场景查询、Problems 和投影消费该边界发布的结果。
+
+统一的是修改协议与语义事实，而不是把所有功能塞进一个服务。沿用现有项目作者文档、内容历史、保存基线、Schema/Forms 和纯场景分析，不另建文档副本、第二条历史或通用事件总线，也不要求 GUI 绕道 CLI。
+
+当前代码的主要问题是：操作修改可观察投影，投影通知又写回作者文档；历史通知同时承担“按钮状态改变”和“内容已提交”；各消费者据此自行猜测失效范围。建议最终让作者文档成为操作的直接修改目标，投影只读并呈现结果。
+
+```mermaid
+flowchart TD
+    UI[Group / Inspector / Timeline] --> OP[准备作者操作]
+    OP --> PLAN[变更计划与影响报告]
+    SEM[Entry 作者语义目录] --> PLAN
+    PLAN --> TX[项目内容事务与现有历史]
+    TX --> DOC[权威作者文档与草稿迁移]
+    TX --> CHANGE[一次提交结果]
+    CHANGE --> INDEX[引用索引 / 场景查询 / 诊断]
+    CHANGE --> VIEW[投影与绑定更新]
+    INDEX --> VIEW
+```
+
+## 2. 模块职责
+
+下面是职责分区，不是每行强制新增一个程序集或接口。
+
+| 模块 | 核心职责 | 不负责 |
+| --- | --- | --- |
+| 作者操作 | 将字段 patch、删除、移动、换类型、复制等变成可预检的计划 | 控件、弹窗、运行游戏 |
+| 项目事务 | 串行校验和提交，协调现有历史、作者版本、草稿迁移，发布提交结果 | 按 Entry 类型推断对象语义 |
+| Entry 作者语义目录 | 声明输出、引用、目标类别、身份迁移和场景影响 | 参数 schema 的重复定义、UI 事件订阅 |
+| 项目派生事实 | 引用索引、场景数据流分析与依赖、结构化诊断 | 改写作者内容、强制保存门禁 |
+| 草稿与绑定 | 草稿的归属和状态、视图租约、操作影响下的迁移 | 控制内容历史游标 |
+| Editor 呈现 | 选择、展开、搜索、摘要、影响确认、导航和交互错误 | 修改另一份业务真源、自己扫描引用 |
+
+部署在现有层级：Abstraction 仅放跨宿主的中立地址/变更/诊断契约；Shared 放作者操作计划、语义目录、纯索引和纯场景分析；Editor 放项目事务与现有历史的接入、控件绑定及展示。Shared 不反向引用 Editor 的 UndoRedoHistory。事务协议可以中立化，现有历史由 Editor 适配；不要为了复用一次性搬迁整个保存系统。
+
+资源读取/效果声明准备仍由宿主负责，以不可变资源事实交给 Shared。共享 Avalonia Forms 只认识字段绑定和 lease，不认识 Group/Graph 历史。
+
+## 3. 操作与提交协议
+
+### 3.1 一个入口，两种执行成本
+
+简单字段编辑仍可一轮调用完成，内部生成小计划并直接提交。删除、剪切、跨 Group 移动、换类型等操作才向 UI 暴露 Prepare 结果，必要时显示影响确认。不要让每次输入都等待全项目引用分析。
+
+概念上的契约如下，名称和具体类型在实施时可按现有类归并：
+
+```csharp
+PreparedAuthorEdit Prepare(AuthorIntent intent, AuthorReadView source);
+Task<CommitResult> CommitAsync(PreparedAuthorEdit plan, ImpactResolution resolution);
+
+record PreparedAuthorEdit(
+    EditPreconditions Preconditions,
+    DocumentEdits Edits,
+    DraftTransition Drafts,
+    EditImpact Impact);
+
+record AuthorChangeSet(
+    long Revision,
+    ChangeCause Cause,
+    IReadOnlyList<GroupChange> Groups,
+    GraphChange? Graph,
+    IReadOnlyList<ResourceChange> Resources);
+```
+
+DocumentEdits 使用领域修改及其逆操作，不引入任意对象反射 patch 引擎。计划包含字段前值、成员身份、Group 顺序等实际读依赖；异步确认后必须重查。第一版可用项目 revision 做保守预检，后续按读集缩小，不能仅凭弹窗打开时的行号执行。
+
+### 3.2 提交时序
+
+1. Prepare 只读当前作者快照，生成变更及候选结果，不提交任何草稿或写盘。
+2. UI 根据影响选择策略；无需要选择的影响直接继续。
+3. 获取现有项目编辑串行门，重新检查计划依赖。过期时返回可重建的结果，不暗中覆盖或重新解释用户选择。
+4. 应用作者修改、必要的草稿状态迁移和历史记录，作为同一个逻辑操作。必须参与一致性的部分失败时补偿；补偿再失败沿用 RepairRequired。
+5. 成功后推进内容 revision，先标记相关派生事实失效并更新生命周期，再统一发布 AuthorChangeSet。
+6. 投影、菜单、Problems 和各面板收到稳定结果后更新。不能让外部订阅者在集合逐项增删中看到半次提交。
+
+History.Changed 继续用于 Undo/Redo 按钮和历史面板；内容消费者改用 AuthorChangeSet。IsBusy、MarkSaved、草稿输入、语言切换不冒充一次作者内容修改。
+
+Undo/Redo 必须经相同的提交边界，成功后产生**新的单调版本**及实际方向的 ChangeSet。不能倒退 revision，也不能只把原事件再广播一遍。
+
+投影/显示订阅者在提交完成后失败，应记录错误并重新同步该投影，不能回滚已经成功记入历史的作者修改。当前“ObservableCollection 通知失败即补偿作者内容”的测试和行为只能在权威文档与投影解耦后一起迁移，不能先把异常吞掉。核心修改与草稿迁移失败仍属于事务失败。
+
+有文件发布的结构操作沿用已有 Working/Saved 双版本与失败恢复流程；本文不把文件 I/O 伪装成可内存回滚的事务。
+
+## 4. 一份语义声明，多种消费者
+
+### 4.1 Schema 管值，作者语义管关系
+
+沿用 Core 的参数 schema/ValueCodec 做类型、缺省、约束验证。在 Editor.Shared 的作者语义目录中补足关系信息，例如：
+
+| 类型 | 定义输出 | 使用引用 | 额外语义 |
+| --- | --- | --- | --- |
+| layer.show / showColor | 主图层输出，wire 槽位 handleId | 图片资源等属于独立资源域 | 创建/替换 Layer |
+| layer.hide / move | 无 | 图层 handleId | 移除/修改目标 |
+| animation.animate | 播放输出 playbackHandleId | 场景目标 handleId | 播放存在性及属性变化 |
+| timeline.play | 根播放输出、事件中的输出 | 轨道、事件中的目标引用 | 委托 Timeline 子结构适配器 |
+| 转场 | 输出 Layer、播放实例 | 输入 Layer | 委托现有纯编译终态分析 |
+
+每个声明至少提供稳定的**逻辑输出角色**、实际 JSON 地址、引用域与允许目标类别。逻辑角色不能等同于参数名：handleId、newHandleId、toLayerHandleId 可能承载相容的主图层输出。兼容迁移由显式规则决定，不是“都是字符串就保留”。
+
+从当前 SceneAuthoringIdentities、SceneFieldSemantics 与查询的重复清单开始收敛。复制重映射、自动创建身份、隐藏输出字段、目标筛选、引用索引与摘要都消费同一声明。场景转换算法作为可选的纯分析贡献器挂在同一目录下，继续复用 Core 能力和现有 Timeline/转场实现，不把复杂算法写成字段配置。
+
+这里的“纯”是不得执行游戏 Entry 或产生 I/O/写回副作用。首版仅内置目录，不从项目 schema DLL 扫描和执行任意贡献器。未知自定义 Entry 标记覆盖不完整；后续需要扩展时再复用显式 Editor 扩展注册边界。原始 JSON 与未知字段始终保留。
+
+### 4.2 引用索引与存在性分析必须分开
+
+**引用索引**扫描所有作者文档，产出定义与使用记录：拥有者、JSON 路径、原始身份、引用域、允许种类和覆盖诊断。它回答“哪里写了这个引用”，包含未打开和不可达的 Group。
+
+**场景分析**沿 Graph/Entry/Timeline 执行顺序，回答“这个位置能对应哪些创建者、一定还是可能存在、属性是否可知”。它沿用保守合并和预算，不执行游戏。
+
+同一个 raw handle 可能被多个创建者重复定义或在不同分支替换。引用索引不能把 handle→唯一创建者当作事实；需保留候选定义，再由位置分析解析。普通资源 ID、变量 key 和场景身份分域，禁止对整个 JSON 做字符串替换。
+
+**影响分析**把操作前后的场景结果与引用索引结合：删除创建者可能使引用失配；删除 hide/stop 则可能让对象重新出现；重排和拓扑变化会改变可达性。不能只分析“被删除条目自身输出了什么”。同批删除的消费者不作为外部断引警告，但该批对剩余剧情的状态影响仍需计算。
+
+缺目标是作者警告，继续保留原引用并允许保存/编译；值契约、非法结构等仍按原规则报错。不完整分析独立携带原因，不能自动推导为“无影响”，也不默认阻止所有操作。
+
+## 5. 身份与操作策略
+
+需要分清三类身份：作者地址、场景运行身份、视图绑定代次。
+
+- 作者地址沿用 `(GroupId, EntryStableId)`，Timeline 事件再加稳定事件身份。仓库允许不同 Group 使用相同 EntryStableId，不能假设全项目唯一。
+- 场景运行身份沿用作者 JSON 中现有输出字符串；输出来源和逻辑角色用于编辑器解析与迁移。首版不修改 Raw/Compiled wire 格式，不把缓存 Locator 自动写进作者参数。
+- 控件 lease 使用项目会话、作者地址、来源 incarnation/结构代次。删除/重建/不相容换类型产生新代次；Undo 恢复同一稳定 ID，也不复活旧控件。
+
+推荐策略：
+
+| 操作 | 身份与引用处理 |
+| --- | --- |
+| 同 Group 重排 | 保留作者及输出身份；重新分析受影响区间和后继 |
+| 复制/副本 | 新作者身份、新输出身份，仅重映射复制批次内部引用 |
+| 相容换类型 | 按逻辑输出角色显式迁移已有输出身份；新角色分配新身份 |
+| 不相容换类型/删除 | 不自动改绑外部消费者；给出影响列表，允许保留未解析引用 |
+| 项目内移动 | 保留输出身份；目标 Group 有 Entry ID 冲突时分配新作者 ID，并发布地址迁移表；失效旧 Locator/lease |
+| Undo/Redo | 复用该操作确定的作者与输出身份，发布新来源代次与变更结果 |
+
+### 剪切的推荐取舍
+
+推荐先把“立即删除式剪切”改为会话内**待移动**：Ctrl+X 保留原条目并标识，成功粘贴时以一次事务移除源、插入目标，保留场景输出身份，并检查源版本及插入锚点。取消待移动不修改作者内容；来源后来改变、会话关闭或剪贴板被替换就撤销凭据。此方案避免两次操作之间的断引和两份同身份对象。
+
+OS 剪贴板保留普通可复制数据；原对象所有权只由本项目会话凭据证明，不能信任外部 JSON 自称“剪切”。跨项目/已过期凭据按复制处理并给明确反馈。若必须保留 Ctrl+X 立即删除的现有体验，需要另设计历史持有的移动票据与消费状态，复杂度更高，不推荐作为首版。
+
+这是一项待确认的用户交互变化，本文未将其写成已接受的规范。第一版至少保证所有路径复用引用影响提示，不能继续静默制造断引。
+
+## 6. 用依赖与结果版本替代全局失效
+
+保留全项目单调 revision 用于事务顺序，但不让它决定每个控件是否失效。派生服务按实际读依赖区分：
+
+| 版本/代次 | 作用 |
+| --- | --- |
+| 内容 revision | 标识一次稳定作者提交、快照与诊断来源 |
+| 目标来源/结构代次 | 判断字段、列表项、轨道/事件身份是否还是同一编辑对象 |
+| 查询依赖版本 | Graph 入口摘要、Group 相关前缀、语义目录与所需资源事实 |
+| 查询结果版本 | 目标/能力/数值/完整性等可观察事实发生变化时更新 |
+| 展示变化 | 名称、语言和路径标签刷新，不撤销仍有效的编辑意图 |
+
+服务以 ChangeSet 的 Group 范围和最早受影响位置失效前缀；重新求出口摘要，仅在出口事实改变时传播给后继。拓扑变化重建相关依赖，循环继续用有限固定点和预算；超预算保守降级并保留原因，不能提供假确定结果。
+
+首版可先用粗粒度 Group 缓存，在相关结果相等时保留结果版本，再逐步加入前缀检查点。缓存保存有限数量的快照/检查点，不为每条 Entry 永久存一份场景，也不再在每次 IsCurrent 时序列化全项目。
+
+版本相等只是优化，提交仍要验证当前写入位置、源值/结构、目标引用及实际读依赖。依赖变了但可证明结果等价时，服务可显式换发有效 lease；已明确失效的旧 lease 永不自行复活。避免“全局 revision 变了就丢草稿”和“结果一样就允许任意旧操作”两个极端。
+
+后台资源准备绑定项目会话和实际作者/资源读集，旧资源代次结果不能覆盖新代。查询开始准备时保留同一逻辑请求，完成后换发快照；等待者取消只取消自己的等待。主线程按固定顺序发布结果，Changed 不再只代表资源变化。
+
+## 7. 草稿是项目输入，控件只是借用者
+
+草稿记录用显式 DraftKey 定位：作者地址、根字段、稳定子项身份/路径和来源版本；不要使用对象 RuntimeHelpers.GetHashCode 作为身份。没有稳定身份的数组项在结构变化时明确进入冲突，不能按旧下标偷偷提交。
+
+草稿仓库只持有作者地址、基线值、输入、解析状态和解析/提交适配，不长期持有 Entry ViewModel。控件持有可释放 lease；关闭页面释放控件订阅，项目中仍有效的草稿继续保留。
+
+推荐状态与保存规则：
+
+| 状态 | 是否参与 Save All | 处理 |
+| --- | --- | --- |
+| 活动且有效 | 是 | 提交后进入现有内容历史 |
+| 活动但无效/组合输入/冲突 | 是，需先处理 | Problems 提供定位和取消 |
+| 因用户删除目标而归档 | 否 | 随删除操作保留，可查看、复制或明确丢弃 |
+| 目标恢复后的待恢复输入 | 否，直到明确恢复 | 新绑定验证基线后恢复；旧绑定无提交权 |
+| 干净且无视图/历史引用 | 否 | 可回收 |
+
+默认删除语义建议为“删除条目，并把相关未提交输入随操作归档”，影响面板显示数量并提供取消。Undo 恢复作者内容后，若有归档输入，显示可恢复提示；恢复经新绑定验证，不让旧冲突草稿自动进入活动保存队列。历史淘汰前若仍有未解决的归档输入，转入有预算的项目输入回收区并提示，不能默默销毁用户输入。显式清空历史应单独说明其对这类恢复材料的影响。
+
+这种归档/恢复策略同样是建议的交互决定，需要在实施前确定容量、提示及超预算策略。第一版可以保守保留现有冲突规则并在删除前明确协调输入；不能只为消除保存错误而直接删除所有草稿。
+
+直接改同一字段导致的外部冲突继续保留，不能与“用户主动删除整个目标”混成同一种生命周期。普通输入的 Dirty 状态也不能触发场景内容版本改变。
+
+## 8. 诊断、反馈与缓存所有权
+
+Problems 消费结构化诊断，至少包含 code、severity、作者地址、JSON 路径、分析来源版本、相关创建者和可用操作。影响确认与 Problems 使用同一份分析事实，摘要/Picker 使用同一来源描述适配器，禁止再分别猜测 handle 的含义。
+
+对象存在性仍只有一定/可能两类。引用失配、资源缺失、分析覆盖不完整、字段输入冲突和过期操作是不同诊断代码；不能把它们都显示成“未知错误”。历史结果过期后标注版本或替换，不给已删除的 Entry 计入活动错误数。
+
+更新投影时维护 `(GroupId, EntryId)` 映射，并根据 ChangeSet 批量增删/局部刷新。搜索声明自己依赖 Type/Summary/Condition/显示序号，相关字段改变就重筛；与场景推断无关的展示更新不触发分析。
+
+对象由明确拥有者保留：
+
+- 活动投影拥有活动 Entry 的 ViewModel。
+- 历史拥有可逆操作所需的中立数据和草稿归档句柄，并计入保留字节预算。
+- 草稿仓库拥有活动/待恢复输入；分析缓存只拥有不可变事实。
+- 页面拥有控件及订阅，不拥有作者文档；任何缓存都不永久持有已删除 ViewModel。
+
+删除后活动投影释放对应对象，Undo 可从中立数据重建。历史淘汰释放其专属材料；项目关闭取消后台任务并释放全部仓库。不再使用 `_allEntries` 永久收集历次 ViewModel 作为销毁机制。
+
+## 9. 方案取舍与迁移
+
+不推荐继续在每个删除按钮、字段工厂和 Timeline 中增加各自的引用扫描与事件订阅：重复语义和通知顺序问题会持续增加。也不采用“每次修改都全项目重算”：正确性容易起步，但仍会误伤无关输入并放大 UI 成本。
+
+暂不采用全量事件溯源/不可变文档重写；现有历史、文件发布和作者保存已经有大量约束与验证，解决本轮问题不需要整体替换。采用领域操作计划、提交结果和派生服务的组合，允许一次迁移一类操作。
+
+推荐依赖顺序，具体 Phase 另行制定：
+
+1. **事务与通知边界**：从 Entry 字段及批量增删重排切入，统一成功提交结果、版本及 Undo/Redo；建立文档→投影单向更新，保留失败补偿。新旧写入口不能对同一修改重复记历史/发内容事件。
+2. **语义目录与引用诊断**：先迁移已有内置清单及 Timeline 子结构，接通只读引用索引、操作影响和 Problems；保持现有序列化/运行时语义。
+3. **身份与草稿策略**：在用户确认交互取舍后接通待移动剪切、相容换类型和删除输入协调。每个纵向切片同时完成提交/Undo/Redo/Save/重开验证。
+4. **查询依赖及 lease**：用 ChangeSet 驱动 Group/前缀缓存和结果发布，普通字段、Timeline 统一消费；验证后删除读时整项目 JSON 比较和多路历史订阅。
+5. **呈现与释放**：迁移筛选/摘要/Problems 导航，移除永久 ViewModel 保留集合，加入长期编辑与预算验证。
+
+Graph、项目文件和本地化操作可以逐步接入同一提交结果协议；已有专门原子性与保存基线规则由各模块继续拥有，不在首次 Group 切片中合并成巨型协调服务。跨域复合操作由项目事务组合中立子计划。
+
+## 10. 必须验证的行为
+
+- 删除创建者更新同 Group 后文和跨 Group 后继；删除 hide/stop 让后续候选恢复；Undo/Redo 都产生新的稳定提交结果。
+- 不可达/条件/分支/循环/同名输出均保守处理；索引中“有字符串引用”不冒充“确定依赖该创建者”。
+- 普通输出、播放实例、转场和 Timeline 轨道/事件使用相同声明；未知 JSON 无损，未支持语义有覆盖诊断。
+- 复制只重映射批内引用；项目内移动保留输出身份；地址冲突、过期剪切、跨项目粘贴、取消和重复粘贴都有明确行为。
+- 相容换类型不丢引用，不相容时提示影响；缺目标仍可保存/编译，运行时缺目标核验单列。
+- 删除有输入的目标不会留下不可见的活动保存阻塞；恢复输入经过新 lease，Undo 不复活旧控件。
+- 修改 Timeline 后文、无关 Group、名称或语言保留有效输入；修改实际前缀事实、根轨道/事件结构或相关资源使真正受影响的操作失效。
+- 一次批量操作没有中间作者通知；失败补偿、通知失败、外部重载、项目关闭和资源迟到结果均不产生半份状态。
+- 长期增删并淘汰历史后，已删除 ViewModel 和无主缓存可释放；归档输入和历史材料都计入实际预算。
+- 最终通过真实挂载控件、多面板、保存重开、CLI 严格校验及当前源码构建；性能用实际大项目数据度量，不用静态推断虚报改善比例。
+
+实施后决定：待移动剪切、独立持久输入恢复区、新绑定显式恢复已按用户继续实施的授权接通；容量、失败行为和验证证据见 GC3/GC5。查询采用 Group 事实复用与有限前缀检查点，仍保留可达 Graph 固定点遍历；没有把本设计扩为全量事件溯源或新的运行时协议。
diff --git a/features/F-20261015-02-editor-authoring-workspace/group-direct-editing.md b/features/F-20261015-02-editor-authoring-workspace/group-direct-editing.md
new file mode 100644
index 00000000..325eb62d
--- /dev/null
+++ b/features/F-20261015-02-editor-authoring-workspace/group-direct-editing.md
@@ -0,0 +1,20 @@
+# Group 直接编辑修订（2026-10-26）
+
+用户确认删除、换类型、移动不再逐次弹窗；临时引用问题集中在 Problems，确定的作者错误由编译/构建拒绝。
+
+## 实现
+
+- Group 删除、换类型和待移动粘贴直接提交，删除影响确认窗口及页面确认回调。
+- 保留作者快照/版本校验、单条历史、身份迁移、输入归档及撤销重做；可选影响报告延迟到显式读取时计算。
+- Problems 在创建时即查询场景诊断，并随内容、资源和外部重载更新，不要求先执行检查；保留原消费者引用和稳定身份导航。
+- 场景静态分析继续提供警告，不将未知扩展、条件/分支等不确定性变成编译错误。现有严格参数、契约及结构校验仍用于编译、构建和调试准备。
+
+## 验证
+
+- 本轮交互与引用核心用例 2 项通过：删除、换类型、跨 Group 移动、即时问题标记、Undo/Redo、保存重开，以及既有准备计划过期/重复提交拒绝。
+- Shared 校验、契约编译及引用分析 34 项通过，包括无效参数不能编译或替换既有产物。
+- Editor 全量回归 325 项通过，包含前述 2 项核心用例；加 Shared 共 359 项通过。原生 GUI 未执行，`git diff --check` 通过。
+- 全量运行较慢，首次无超时上限的运行主动中止后，以 45 秒无进展超时重跑，最终 4 分 48 秒完成，未触发挂起保护。
+- 默认输出目录因运行中的 Editor 锁定而构建失败，改用 `-p:OutputPath=bin/GroupNoDialog/` 完成编译。沙箱中的 testhost 连接超时，调整为允许本地测试进程通信后核心用例和 Shared 测试执行通过。
+
+当前规范见 [Group 编辑](../../docs/spec/editor-groups.md#直接编辑与问题诊断) 和 [场景引用诊断](../../docs/spec/editor-scene-targets.md#作者关系与引用诊断)。
diff --git a/features/F-20261015-02-editor-authoring-workspace/phase-group-consistency.md b/features/F-20261015-02-editor-authoring-workspace/phase-group-consistency.md
new file mode 100644
index 00000000..daa043a9
--- /dev/null
+++ b/features/F-20261015-02-editor-authoring-workspace/phase-group-consistency.md
@@ -0,0 +1,145 @@
+# Group 一致性实施记录
+
+## GC1：作者操作提交边界
+
+日期：2026-10-26。状态：**verified**。用户在整体设计后明确要求开始实施；总体设计见 [一致性设计](group-authoring-consistency-design.md)，阶段依赖见 [phase-plan](phase-plan.md)。
+
+### 实现
+
+- Abstraction 增加中立 `AuthorChangeSet`：单调版本、Execute/Undo/Redo 原因、按 Group 合并的稳定 Entry 身份、最早受影响位置及变更标记。旧操作/混合复合操作保守标记 UnknownScope。
+- Editor 的 `AuthorChangeJournal` 由现有 `UndoRedoHistory` 拥有，在其串行门内积累范围；操作与历史游标成功后只发布一次。同步/异步、复合操作和撤销/重做共用边界；失败及补偿丢弃本次范围。状态通知保留原 History.Changed，Clear/MarkSaved/空撤销不制造作者提交。
+- Entry 字段和批量新增/粘贴/删除/重排直接修改 `EditorGroupDocument`，批量历史保留中立 Entry DTO，不以投影集合通知写回文档。正常表单仍经原有 schema、partial 校验及本地化复合操作。
+- Group 可观察集合只允许投影同步修改；字段/集合更新发生在作者和历史完整提交之后。集合与属性通知按订阅者隔离异常，后续订阅者仍收到更新；投影错误留在 LastNotificationError/日志，不回滚已经提交的作者内容。真正操作失败仍按历史原子性与 RepairRequired 规则处理。
+- Group 投影和 Timeline 改用成功提交通知。ProjectSceneTargets 在作者提交后捕获稳定版本并发 Changed，删除/撤销不再依赖资源刷新才能主动通知。
+- 更新故障注入测试为新发布契约，并补充单调版本、无操作、组合范围、混合旧操作、失败补偿、重入拒绝、跨 Group 相同 Entry ID 和删除/恢复场景候选通知测试。仍验证旧字段不能因撤销而恢复提交权。
+
+### 本轮验证与修正
+
+1. 第一份工作区内源码快照完成 9 项定向测试，全部通过。随后源码目录与日志不再存在，保留下 focused TRX；清理原因未确认。本轮后续验证改用独立临时目录，未关闭运行中的 Editor，也未修改其他任务的文件来解除 DLL 锁。
+2. 第一轮完整 Editor 为 308 通过、2 失败。一项旧生命周期测试直接调用投影集合 Remove；改为真实 Group 作者删除入口，继续验证项目释放后旧字段失效。
+3. 另一项 `UnknownCharacterIdsRemainErrorsAndUncertainReferencesBlockDestructiveEdits` 在重构前服务源码上独立复现失败：空参数未知 Entry 按已实现空引用规则不使分析不完整。将这条测试夹具改为非空 opaque 载荷，保持“未知非空引用阻止破坏性角色操作”的原测试意图，未修改生产本地化规则。基线证据见 `gc1-baseline-character.trx`。
+4. 基线备份恢复带回旧时间戳，曾使 MSBuild 复用基线 DLL，导致候选测试编译报缺 AuthorChanges。显式刷新临时快照被替换源码时间戳后重新编译，不能把该次编译失败归为候选 API 未实现；经验见 `.agents/lessons/L-20261026-01-baseline-restore-timestamps.md`。
+5. 最终候选 Editor **311 项通过、0 失败、0 跳过**，使用标准 dotnet test/NUnit 宿主，包含真实 Headless 表单/Timeline、多面板、剪贴板、历史、保存重开与查询相关回归。
+
+最终验证：
+
+| 项目/检查 | 实际结果 |
+| --- | --- |
+| GalNet.Editor.Tests | 311 通过、0 失败 |
+| GalNet.Editor.Shared.Tests | 417 通过、0 失败 |
+| GalNet.Architecture.Tests | 49 通过、0 失败 |
+| GalNet.IntegrationTests | 123 通过、0 失败；4 项 Explicit 原生 GUI 用例未执行 |
+| 当前阶段 C# 格式与 IDE0005 | Abstraction、Editor、Editor.Tests 的 13 个变更文件均通过 verify-no-changes |
+| 源字节核对 | 主工作区与候选快照 13 个实现/测试文件 SHA-256 一致 |
+
+合计 **900 项执行通过、0 失败**。四个测试项目及其依赖在固定候选中成功编译；没有执行全解决方案/Launcher 构建，也没有把 4 项未执行的原生 GUI 用例计为通过。现有编译警告保留，不宣称零警告。
+
+材料目录：`artifacts/group-consistency-gc1/`，包括各轮 TRX、最终项目日志、`source-hashes.json` 与临时快照路径。已知基线失败与首次构建失败均保留，最终结果未以旧 DLL 或直接反射调用替代标准测试宿主。
+
+本阶段自审结论：**pass-with-follow-up**，没有发现阻止 GC1 交付的问题；GC2–GC5 的原始问题仍属于后续必需工作，专项审核对整个 Group 一致性改造的 blocked 结论没有据此撤销。正式当前事实已同步到 [历史与保存](../../docs/spec/editor-history-and-save.md#作者内容提交通知)、[Group 编辑](../../docs/spec/editor-groups.md) 和 [场景目标查询](../../docs/spec/editor-scene-targets.md)。
+
+### 当前边界
+
+GC1 不新增删除引用弹窗、不改变剪切语义、不归档删除目标的草稿，也不实现相容换类型身份迁移。整项目作者 JSON 比较、整组投影刷新及 `_allEntries` 保留仍存在，分别留 GC4/GC5。Graph/文件/本地化的旧编辑只以 UnknownScope 接入发布边界，原有文件事务和 Working/Saved 约束未重写。
+
+投影通知不再参与作者回滚是本阶段刻意采用的设计变更；原来的集合补偿故障注入用例不能继续将观察者失败当作领域操作失败。复合领域步骤失败与补偿失败仍有独立回归，不能删除这类原子性保证。
+
+原工作区有其他编辑器 UI、音频、导出/发布和脚本整理改动，均非本阶段业务范围；验证使用固定快照，并在提交时限制本阶段文件。项目整体 feature 保持 in-progress，GC2–GC5 不据此宣告完成。
+
+## GC2：语义、引用诊断与操作影响
+
+日期：2026-10-26。状态：**verified**。用户“继续”授权推进；GC1 已独立提交为 `1496e0c`。
+
+### 实现与取舍
+
+- Shared 的 `SceneAuthoringSemantics` 声明输出逻辑角色、对象/播放身份域、允许目标类别、图集与全局目标约束。自动身份、复制、输出隐藏、Picker 与索引共用声明；中立 Entry 清单也迁入目录。Core schema 和具体纯状态转换保持各自职责，没有加载任意项目贡献器。
+- `SceneIdentityWalker` 只扫描声明的普通槽位、Timeline 根播放/轨道和事件子结构，保留大小写、未知 JSON 和数值；`SceneReferenceIndex` 保留所有 Group 的定义/使用地址、JSON Pointer 与覆盖原因。对象/播放分域复制修复两域原始字符串相等时的串绑。
+- `SceneReferenceAnalysis` 分离语法候选定义和位置上的可用性，比较剩余引用与可达 Group 出口。删除创建者、hide/stop 和跨 Group 后继均可报告，同批删除的消费者不报外部断引。索引有 10,000 步预算和嵌套保护；未知、结构不支持及超预算明确为不完整。
+- `PreparedEntryEdit` 只读捕获前后候选，将确认绑定原文档实例及 Graph/Group 内容。真正提交在原历史门内复查；过期和重复提交拒绝，失败不推进游标。首次成功后丢弃历史包装器的预检快照/原文档引用，Undo/Redo 仍是同一条内容历史。
+- Group 删除按钮、键盘/菜单删除、剪切删除和类型选择使用同一影响确认。零影响且完整直接执行；有引用/出口变化或不完整则显示可取消/继续的窗口。UI 来源为 Group 名称与 Entry 序号；内部 handle 不展示。底层直接服务 API 保留给显式程序调用，不要求无界面调用显示窗口。
+- `ProjectSceneTargets.Diagnostics()` 返回当前版本的结构化警告，Problems 显式检查后接入，并随内容提交、Undo/Redo、资源准备更新；导航复用稳定作者地址。警告保留引用，不新增保存/编译门禁。四语同步新增 14 项文本。
+
+### 验证过程
+
+初轮 Shared 定向 14 项通过；Editor 定向首轮 1 通过、1 失败，暴露 Problems 的场景查询发布为 UI 排队事件且测试固定匹配中文的问题。修正为实际内容变更后同步刷新已有场景诊断，并按当前本地化文本断言；保留独立资源刷新订阅。随后四项目初轮完整回归 907 项执行通过。最终加入索引预算、停止播放/循环影响、结构化诊断版本、文档实例预检与隐藏技术路径的窗口呈现，另跑最终候选验证。
+
+最终四项目标准测试宿主结果：Editor **313**、Editor.Shared **424**、Architecture **49**、Integration **123**，合计 **909 项执行通过、0 失败**。集成项目另有 4 项 Explicit 原生 GUI 用例未执行，与 GC1 相同；未据此宣称原生媒体全验收。各项目及依赖成功构建，未执行全解决方案/Launcher 发布构建，既有分析器警告仍保留。
+
+最终材料位于 `artifacts/group-consistency-gc2/`：`results/gc2-*-final.trx`、各项目 `*-final.log`、`source-hashes.json`、`format.log`。Whitespace verify-no-changes 退出 0，四语键集合一致；20 个自有候选文件在工作区、固定快照及哈希清单中一致。语言资源工作副本含其他任务的额外文本，提交时仅抽取本阶段 14 项键，避免夹带其业务改动。其他源码与测试使用 GC1 的独立临时快照基线，不能用本轮证据替代其他任务随后修改的工作区文件验证。
+
+### 阶段边界与自审
+
+本阶段没有相容换类型迁移、待移动剪切和删除输入归档；因此原始审核的剪切身份和孤立草稿阻塞仍待 GC3。全量快照/前缀分析及全投影刷新仍留 GC4，搜索/摘要和保留预算仍留 GC5。Timeline 轨道诊断检查第 0 帧，事件诊断检查执行前位置，不声称覆盖运行期每帧，也未修改运行时缺目标行为。Graph 重排/拓扑编辑目前获得提交后的诊断刷新，没有新增每一种 Graph 操作的影响弹窗。
+
+阶段自审结论：**pass-with-follow-up**。本轮自审重点：同名输出保留候选而不伪造唯一来源；缺目标不升级为错误；未知内容不被当作无影响；取消/过期检查不写历史；剪切保持原身份问题明确留后续。整个 Group 一致性改造继续 in-progress。
+
+## GC3：身份与输入生命周期
+
+日期：2026-10-26。状态：**verified**。用户在 GC2 验证后要求继续实施。
+
+本阶段采用已授权设计的待移动剪切：Ctrl+X 只标记，首次成功粘贴才以单历史移动并保留输出身份；地址冲突只重分配 Entry stable ID，提交结果带地址迁移。外部/过期/重复票据按复制并提示；观察到其他剪贴板内容时撤销本会话凭据。不会轮询系统剪贴板，精确原文票据只有本会话保留的未消费来源能证明移动权。
+
+相容换类型按语义目录的逻辑角色、身份域、目标种类匹配已有输出；新增角色分配新身份，不相容身份不擅自改绑。旧字段/草稿 lease 仍随删除、换类型和跨 Group 移动失效。
+
+归档采用项目独立、有硬预算的输入恢复区，而不随撤销栈淘汰：最多 1,000 条、序列化文件最多 16 MiB，超预算在作者修改前拒绝操作，作者可在 Problems 中复制或明确丢弃。恢复区位于 `.galnet/editor/input-archive.json`，不参与作者 Save All/dirty 比较，并在保存、清空历史和关闭重开后保留。归档更新在历史门内先发布恢复文件，再执行内容步骤；内容步骤失败时恢复旧文件，恢复也失败沿用 RepairRequired。没有把文件 I/O 伪装为可无条件内存回滚。
+
+恢复输入必须显式请求，并由新字段绑定核对地址、类型、根值基线、路径及字段类型后接收；在实际字段打开前仍保留归档，不进入活动保存队列。源冲突归档只提供可复制文本，不自动恢复。归档记录为中立数据，不保留旧控件或 ViewModel；活动草稿的全量保留预算留 GC5。
+
+### GC3 验证过程与当前边界
+
+首次隔离编译成功。首轮定向 4 项中 3 通过，归档 I/O 拒绝测试在 Windows 上返回 UnauthorizedAccessException 而不是 IOException，修正测试接受这两类真实文件拒绝，并继续断言作者/输入/历史均未变化。
+
+第一轮完整 Editor 为 313 通过、5 失败：两项测试夹具给 Group 作者服务传 null；一项工具栏测试把新增的取消移动按钮当作原来的新增按钮；另外两项是实际生命周期回归——页面 Dispose 误推进作者 incarnation，破坏 Common/Inspector 草稿共享和关闭全部页面后的本地化输入保存。夹具改为提供真实作者服务，移动状态控件放入独立容器，作者代次推进与表单释放拆开；随后包含新增嵌套/本地化、移动输入、旧 lease 和上述回归的定向 12 项全部通过。关联 lesson：`.agents/lessons/L-20261026-02-author-incarnation-view-lifetime.md`。
+
+后续候选四项目 918 项执行通过；再将 Timeline 根播放输出的容器路径纳入同一语义声明，补充普通动画/转场/Timeline 之间的身份迁移与未知数值保留断言，最终证据以 `*-verified.log` 和 `gc3-*-verified.trx` 为准。
+
+当前阶段只接入 Entry 作者服务的新增/粘贴之 Undo、删除、换类型与跨 Group 移动。整 Group/文件删除沿用 Working/Saved 结构发布协议，不把其异步文件发布与 Entry 内存修改混成同一种可补偿步骤；该路径的输入协调仍需专门验证。原生 IME 候选和真实系统剪贴板多应用交互未人工验收；已有 Headless 控件验证失败/迟到剪贴板、待移动标记、Problems 原始文本和恢复。GC4 的查询依赖优化及 GC5 的搜索、友好摘要、缓存/活动草稿回收仍待推进。
+
+最终标准测试宿主：Editor **321**、Editor.Shared **425**、Architecture **49**、Integration **123**，共 **918 项执行通过、0 失败**；4 项 Explicit 原生 GUI 未运行。各项目及依赖构建成功，未执行全解决方案/Launcher 发布构建。材料位于 `artifacts/group-consistency-gc3/`：`results/gc3-*-verified.trx`、`*-verified.log`、`source-hashes.json`、`format.log`。Whitespace verify-no-changes 退出 0，32 个候选文件的工作区/隔离快照哈希相同；四语工作副本 1,089 keys 一致，阶段提交仅包含本阶段 11 项新增文本（提交版各 1,080 keys），不夹带其他任务的 9 项文本和 Entry 列表布局改动。
+
+自审结论：**pass-with-follow-up**。Entry 操作范围内的剪切身份、相容换类型和孤立输入保存阻塞已修复，补偿与 RepairRequired 门释放有定向测试；尚未迁入的结构删除及 GC4/GC5 保留在计划，不据此宣告整个 feature 完成。已同步 Group、历史保存和场景查询规范，lesson 记录作者/视图代次分离的可复用边界。归档仍为独立恢复文件，不纳入作者文件事务；相关 I/O 失败会拒绝操作或进入 repair-required，不承诺跨进程两套文件的共同原子性。
+
+## GC4：查询依赖、结果版本和有限缓存
+
+日期：2026-10-26。用户要求继续至当前 Group 改造全部完成。状态：**verified**。
+
+托管项目从作者提交/文档通知捕获快照：已知 Entry 范围只克隆受影响 Group，普通查询与 IsCurrent 不再序列化全项目；未知范围和结构/外部重载完整捕获。独立构造、没有 journal 的调用保留快照比较兼容路径。直接修改 DTO 的夹具或外部调用必须显式 SynchronizeGroups 通知，不能将绕过作者服务的修改当成有版本的提交。
+
+纯分析保留 Group 入口/出口事实，在入口和条目语义相同时复用出口；变化组复用相同前缀检查点。检查点每分析最多 128 份，不保留上一分析对象；循环和超预算继续使用原保守语义。固定点仍遍历可达 Graph，不宣称完整的动态依赖图增量算法。项目只保留最多 256 个位置查询，结果版本按对象/能力/数值/存在性/完整性变化推进；写入方上下文另有版本，改变源参数后即使前方候选相同，旧字段选择也不可提交。淘汰后重新查询获得新版本。
+
+Timeline 输入验证自身作者基线与当前帧查询结果，不再以全项目 Revision 取消无关输入。所有已缓存位置在每次成功提交/资源事实更新时核对，因此相关结果变化再 Undo 也不会复活旧选择器。投影已知字段变更只刷新对应 Entry，未知范围/结构变化仍完整同步。
+
+初轮编译完成，但筛选器误用了文件名而不是实际 partial 测试类，执行 0 项，不计为测试通过。随后完整 Editor 首轮 311 通过、11 失败：4 项直接写 DTO 后未通知；6 项暴露选择器还需要独立的写入方上下文版本；1 项旧测试用实际播放结果相同的可选条件来要求全局失效。已补上下文版本、明确夹具通知，并将播放失效场景改为真实删除来源的 false 条件。全部初轮日志保留于 `artifacts/group-consistency-gc4/`，最终证据待验证结束补齐。
+
+第二轮完整 Editor **322 通过、0 失败**。Shared 首轮 425 通过、1 失败，原因是夹具在构造后修改已声明不可变的分析输入；修改后重新构造分析，Shared **426 通过、0 失败**。补充相同 JSON 替换写入方 DTO 的身份保护和查询局部作者准备版本后，相关 Editor **22 项通过**；Architecture **49**、Integration **123** 通过，4 项 Explicit 原生 GUI 未执行。完整四项目规模为 920 项，最后补充以 22 项定向证据为准，GC5 结束还需对联合源码重跑完整回归。
+
+性能计数夹具包含分支/汇合、两组各 2,000 条 Entry：重复位置读取不增加传递次数，末尾修改重放少于 64 条 Entry，至少 3 个 Group 复用出口，循环结果与全新分析等价；检查点不超过 128。托管查询连续 100 次不增加作者快照捕获次数。未测出或承诺通用耗时百分比。当前自审 pass-with-follow-up，GC5 与结构删除协调继续实施。
+
+## GC5：呈现、释放与结构删除输入协调
+
+日期：2026-10-26。状态：**verified**。用户明确要求继续至本轮 Group 改造全部完成。
+
+### 实现
+
+- 绑定列表按 Type、Summary、Condition、显示序号的属性通知重筛；摘要与 Picker 共用来源描述，隐藏内部目标/输出 handle，缺目标显示本地化未解析提示。资源名称异步准备，最多缓存 512 项、每代并发 64 项，刷新/关闭取消旧准备。摘要用不占 lease 的检查入口，避免大列表呈现挤掉已打开选择的缓存。
+- 删除的 Entry/Group 投影退出强缓存，以 512/64 的弱缓存保留短期复用；从中立作者 DTO 可重建。文档服务移除非活动 Group，但弱跟踪仍有持有者的原文档身份。活动草稿字典改为弱持有干净字段、强保留未完成输入；提交/读取适配只捕获作者数据、字段基线和项目服务，旧 ViewModel 不再由草稿闭包长期保留。保留输入不强行截断，其持久归档沿用既有硬预算。
+- Problems 不再为每次历史状态变化序列化全项目来判断内容变更；使用提交版本，外部重载另行更新。旧检查明确过期，删除目标和归档信息不计入活动条目错误。
+- Abstraction 的草稿提交上下文表达将移除的 Group；文件操作提交其他草稿时排除这些即将归档的输入。Shared 结构发布提供同步过渡边界，Editor 输入会话在所有等待结束、双版本验证完成后捕获原始输入并包装真实发布。没有修改 Working/Saved 的文件事务算法，也不将独立恢复文件宣称为跨进程共同原子事务。
+
+### 验证进展
+
+首次编译有一个 default 重载二义性，显式指定提交上下文类型后修正。定向 **56 项通过**，包含新增挂载搜索/四语摘要、晚输入结构删除、文件树删除/恢复、归档写入拒绝和强制 GC 回收测试。首次联合 Editor **326 项通过**；Shared **425 通过、1 失败**，暴露外部删除再恢复应保持仍被持有的 Group 文档身份，已以弱身份登记修复，保留原测试。第一次当前工作区完整源码快照 locked restore 和解决方案 build 成功（274 警告、0 错误）；最终格式、完整回归和重建证据待补齐。
+
+最终复核补充了两条边界：纯分析的前代复用必须使用相同的资源声明对象，否则不能复用旧能力；300 条引用摘要读取不占用交互选择缓存。当前完整快照的首次 Shared 失败来自遗漏 CLI 随附的 `skills/`，补齐原仓库文件后原用例通过；一次 Picker 断言使用并发 Timeline 后事实仍相同的可选条件，改为真实候选移除，并在后续创建流程恢复可选条件，保留实际失效验证而不要求全局失效。
+
+之后同源完整 Editor 的一次运行在 `Avalonia.Headless.HeadlessUnitTestSession.DisposeAsync` 出现 NullReferenceException，涉及 CollapsedEntryRemainsCollapsedInDragPreviewAfterReorderAndUndo；此前该用例已随完整回归通过。没有删除断言、加 Retry 或改业务代码绕过；同一最终构建独立重跑该用例通过，完整重跑记录另存 `editor-accepted.log`。内部释放异常的根因未确认，原始 `*-complete.log`/TRX 保留为后续排查材料，不能将该次运行记为全绿。
+
+### 最终验收与收口
+
+最终当前源码候选：Editor **327**、Shared **427**、Architecture **49**、Integration **123**，合计 **926 项执行通过、0 失败**。Editor 采用 `gc5-editor-accepted.trx`，其余采用 `gc5-*-complete.trx`；四项 Explicit 原生媒体 GUI 未执行，不计为通过。CLI 实际 apply 与随附 skill 分发检查包含在 Shared 完整回归中。`final-build-verified.log` 的完整解决方案构建退出 0（67 条本次增量构建警告、0 错误）；不宣称零警告或原生人工验收完成。
+
+`format-verify-whitespace.log` 与 `format-verify-style.log` 对 51 个本轮 C# 文件执行真实候选路径的 whitespace/IDE0005 verify，均退出 0。`current-source-hashes.json` 核对当前工作区与独立最终快照 **1,356 个文件全部一致**，包含现有其他任务源码以验证兼容；提交仅抽取 Group 自有源码、文档与 lesson，不包含音频/字段控件等其他任务改动。快照位置记于 `current-snapshot.txt`，所有材料保留在 `artifacts/group-consistency-gc5/`。
+
+新增验收包括：真实列表随条件/参数/类型与 Undo 重筛，四语来源摘要，缺目标再恢复；300 个摘要不挤占选择 lease；异步历史等待期间的最新输入归档；整 Group 与文件树删除、Working/Saved 分别恢复、明确新绑定恢复与保存重开；恢复文件写入拒绝不改变作者/保存基线/历史门；24 个删除投影在仍持有旧字段状态和中立历史时强制 GC 可回收，12 份归档继续保留；新的资源声明不复用旧能力。
+
+独立自审结论 **pass-with-follow-up**：原始九项 Group 问题均已处理，GC1–GC5 当前范围收口。后续关注本轮仅观察一次、未确认根因的 Headless 释放异常；原生 IME/系统剪贴板多应用交互没有人工验收。Graph 固定点仍遍历可达节点，未知语义保守降级、独立恢复文件不承诺跨进程共同原子提交，这些是明确边界；不把其他 P6/P7 与运行时语义后续工作混称本轮已完成。
diff --git a/features/F-20261015-02-editor-authoring-workspace/phase-plan.md b/features/F-20261015-02-editor-authoring-workspace/phase-plan.md
index a7b032e9..5a5576de 100644
--- a/features/F-20261015-02-editor-authoring-workspace/phase-plan.md
+++ b/features/F-20261015-02-editor-authoring-workspace/phase-plan.md
@@ -1,5 +1,21 @@
 # Editor 创作工作区实施计划
 
+2026-10-26 Group 无弹窗修订（verified）：移除页面影响确认，Problems 无需先检查即可刷新场景诊断，保留严格编译/构建门禁及草稿/历史保护。Editor 325 项及 Shared 相关 34 项通过，覆盖删除、换类型、移动、Undo/Redo、保存重开和既有编译错误拒绝；隔离输出编译及 diff 格式检查通过，原生 GUI 未执行，详见 [修订记录](group-direct-editing.md)。
+
+## Group 一致性补充阶段（2026-10-26）
+
+用户“开始吧”授权实施 [Group 一致性设计](group-authoring-consistency-design.md)，随后要求继续至全部完成。GC1–GC5 现已逐阶段实现与验证；本轮 Group 改造收口，整个 feature 其他 P6/P7 状态仍分别保留。
+
+| 阶段 | 状态 | 目标与模块 | 验证及退出条件 |
+| --- | --- | --- | --- |
+| GC1 作者提交边界 | verified | Abstraction 变更契约、Editor 历史事务、Entry 字段/批量操作、Group 投影、场景查询与 Timeline 通知；操作直接修改作者数据，成功后一次发布；投影不回写作者列表 | 四项目 900 项执行通过，4 项 Explicit 原生 GUI 未运行；同步/异步/复合补偿、未知范围、提交完整性、通知失败隔离、挂载表单/Timeline/剪贴板/保存重开已验证，格式与 13 文件指纹一致；见 [阶段记录](phase-group-consistency.md) |
+| GC2 语义与引用诊断 | verified | 前置 GC1；Shared 收敛输出/引用/类别声明、引用索引与位置影响；接入删除/换类型影响及 Problems | 四项目 909 项通过、4 项 Explicit GUI 未运行；跨 Group、条件/分支/循环、Timeline 事件/轨道、播放实例、未知/预算及取消/过期/Undo/Save 重开已验证，四语/格式/指纹通过；见阶段记录 |
+| GC3 身份与输入生命周期 | verified | 前置 GC2；相容换类型、项目内待移动剪切、草稿归档/新绑定恢复 | 四项目 918 项通过、4 项 Explicit GUI 未运行；待移动/跨 Group 冲突地址/过期与跨项目复制、输出角色迁移、输入预算/持久化/新绑定恢复/补偿均验证；四语/格式/32 文件指纹通过，见阶段记录 |
+| GC4 查询依赖与局部失效 | verified | 前置 GC1/GC2；提交范围驱动 Group/前缀缓存、结果版本和统一 lease；资源代次与来源代次分开 | Editor 322、Shared 426、Architecture 49、Integration 123 通过；最后上下文/资源准备补充 22 项通过；2,000 条目夹具验证复用、128 检查点和无重复捕获；见阶段记录 |
+| GC5 呈现与释放 | verified | 前置 GC3/GC4；筛选、友好摘要、诊断导航、历史/草稿/投影释放；整 Group/文件删除输入协调 | 最终四项目 926 项通过；当前源码完整解决方案构建、51 个 C# 文件格式/IDE0005、1,356 文件指纹一致；实际 GC、挂载列表、四语、保存重开及结构删除失败/恢复验收，见阶段记录 |
+
+每阶段证据和当前 spec 已同步，保留已有 Working/Saved 文件事务。GC1 的整代查询/全投影与强缓存后续已由 GC4/GC5 收敛，GC2 的语义/诊断与 GC3 的身份/归档完成联合验收；整 Group/文件删除输入协调也已验证。四项 Explicit GUI 与原生 IME/剪贴板人工流程未在本轮执行；一次未复现的 Headless 释放异常保留材料供后续关注。
+
 日期：2026-10-15；进度更新：2026-10-17。依赖：[需求](feature.md)、[设计](design.md)。用户已授权实施，P1a 已验证，见 [phase-1a.md](phase-1a.md)；P1b 已完成当前工作树集成验证，构建成功、311 项测试通过，见 [phase-1b.md](phase-1b.md)。P2 已验证，当前工作树构建成功、323 项回归通过，见 [phase-2.md](phase-2.md)。用户追加编辑器 UI i18n 后，在 P3 前插入 P2i；P2i 已验证，隔离基线构建成功、328 项回归通过，见 [phase-2i.md](phase-2i.md)；P3 已验证，当前工作树构建成功、339 项回归通过，见 [phase-3.md](phase-3.md)；P4a 已验证，当前工作树构建成功、365 项相关回归通过，见 [phase-4a.md](phase-4a.md)；P4b 已验证，最终隔离解决方案构建成功、383 项相关回归通过，见 [phase-4b.md](phase-4b.md)；P6a 共享 UI 基础提前验证，P5a Group 交互、P5b 多选剪贴板及 P5c 变量面板已验证，P5d/P5e 已验证，P5 整体 verified（635 项相关回归）；状态只使用 planned / in-progress / verified / skipped；状态更新必须附实际证据。
 
 ## 顺序与范围
diff --git a/features/F-20261015-02-editor-authoring-workspace/review.md b/features/F-20261015-02-editor-authoring-workspace/review.md
new file mode 100644
index 00000000..29092525
--- /dev/null
+++ b/features/F-20261015-02-editor-authoring-workspace/review.md
@@ -0,0 +1,159 @@
+# Editor Group 专项审核（2026-10-26）
+
+## GC1–GC5 实现后复核
+
+当前结论：**pass-with-follow-up**。本轮 Group 一致性范围已收口，原始九项问题的修复映射如下；下节保留实施前的 blocked 证据，不表示当前仍有九项未修复。
+
+| 原始问题 | 实现与验证 |
+| --- | --- |
+| 1 删除/换类型缺引用保护 | 统一语义、引用索引、位置分析和 PreparedEntryEdit；UI 影响确认、版本化 Problems；取消、过期与跨 Group/Timeline 覆盖测试 |
+| 2 剪切改变身份 | 会话待移动票据、一次性单历史迁移、保留输出身份、冲突地址迁移；失效/跨项目复制提示与 Undo/重开测试 |
+| 3 孤立输入阻止保存 | 独立持久输入恢复区、新绑定明确恢复；整 Group/文件发布边界也捕获晚输入；预算、IO 拒绝、保存和双版本恢复测试 |
+| 4 无关修改取消 Timeline 输入 | 查询结果/写入上下文/准备作者依赖与资源版本分开；后文无关修改保留数值，相关修改再 Undo 不复活旧 lease |
+| 5 作者通知分散 | 既有历史门内的 AuthorChangeJournal，成功提交一次发布；观察者隔离、同步/异步与复合补偿测试 |
+| 6 每读整项目与整投影刷新 | 托管快照按提交捕获，Group 出口与有限前缀复用，局部投影字段刷新；真实计数、资源声明换代与全新分析对照 |
+| 7 删除 VM 与草稿长期保留 | 退出投影弱缓存、文档弱身份登记、干净草稿弱持有、未完成输入中立提交适配；保留旧字段/历史时强制 GC 验证 |
+| 8 搜索不实时更新 | Type/Summary/Condition/序号通知触发挂载列表重筛；真实控件、Undo/换类型验证 |
+| 9 摘要暴露 handle | 共用来源描述与资源名准备；四语、缺目标/恢复、300 个摘要不淘汰交互选择的回归 |
+
+最终当前源码解决方案 build 成功；Editor 327、Shared 427、Architecture 49、Integration 123，**926 项执行通过**。格式/IDE0005 和 1,356 文件源码指纹核对通过；完整过程与失败轮次见 [GC5 记录](phase-group-consistency.md#gc5呈现释放与结构删除输入协调)。复核使用同一 agent 独立审查轮次，没有未经授权创建子任务或混入其他任务改动。
+
+保留后续关注：一次 `HeadlessUnitTestSession.DisposeAsync` 空引用没有在同源独立用例和完整 Editor 重跑中复现，根因未确认，日志保留；四项 Explicit 原生 GUI、原生 IME 和系统剪贴板多应用人工流程未执行。固定点仍遍历可达 Graph，未知语义保守降级，输入恢复文件不承诺与作者文件跨进程共同原子提交。未发现阻止本轮 Group 改造交付的剩余 P1/P2；其他 P6/P7 计划不因此完成。
+
+## 实施前原始审核
+
+结论：**blocked**。删除引用保护、剪切的身份语义和草稿生命周期仍存在影响日常创作的缺口。本次是问题分析，没有修改业务代码、设计或正式规范，也没有宣告整个 feature 完成。
+
+后续实施：2026-10-26 GC1 已完成作者提交边界迁移，四项目 900 项执行通过，4 项 Explicit 原生 GUI 未运行，单阶段自审为 pass-with-follow-up，见 [实施记录](phase-group-consistency.md)。本审核的问题 5 所述普通作者提交通知缺口已接入；查询局部失效、引用、身份、草稿和回收等剩余事项没有据此标记完成。上段结论与验证范围描述的是原始审核轮次。
+
+2026-10-26 GC2 后续实施已验证：Group 页面删除/换类型和当前剪切删除路径接入统一影响确认，Problems 接入版本化场景诊断；问题 1 的上述路径已修复，Graph 操作的逐项预检与运行时缺目标全路径核验不在本阶段。四项目 909 项通过、4 项 Explicit GUI 未运行，见 [GC2 记录](phase-group-consistency.md#gc2语义引用诊断与操作影响)。问题 2–4、6–9 仍按后续阶段保留，整个改造继续 in-progress，原始 blocked 审核不因局部修复而撤销。
+
+2026-10-26 GC3 后续实施已验证：问题 2 的 Entry 剪切改为会话待移动，粘贴单历史保留场景身份；问题 3 的 Entry 作者删除将原始输入持久归档，归档不阻塞保存，Undo 后明确恢复到新绑定。相容换类型按语义角色迁移。四项目 918 项通过，4 项 Explicit GUI 未执行，见 [GC3 记录](phase-group-consistency.md#gc3身份与输入生命周期)。整 Group/文件结构删除仍沿原发布协议单列验收，问题 4、6–9 留 GC4/GC5；整个 feature 继续 in-progress。
+
+## 范围与证据边界
+
+检查 Group 新增/删除/剪切/粘贴/换类型/重排、项目历史、作者投影、场景查询、普通 Locator 字段、Timeline、未提交草稿、Problems 和保存链路。规范以 `docs/spec/editor-groups.md`、`editor-scene-targets.md`、`editor-history-and-save.md` 为准，并核对本 feature 的 feature/design/phase-plan。
+
+工作区有正在变化的其他未提交编辑器改动，本次未覆盖、回滚或提交它们。以下区分当前源码静态证据与运行探针：
+
+- 场景 Shared 项目由当前源码成功编译；标准 vstest 宿主连接超过 90 秒而中止。改用独立进程直接调用无 setup/teardown 的 `Scene*` 测试，包括 TestCase/TestCaseSource，**116 个用例通过、0 失败**。这不是标准 NUnit 集成运行，也不覆盖 GUI。
+- Editor 正常构建首次被当时未提交的 Flipbook 字段命名错误阻断；该文件随后由其他工作改动。最后一次正常构建在复制 DLL 时被运行中 Editor 的文件占用阻断。尝试 C# 13 也因仓库已有 C# 14 语法而失败，不作为修复方案。
+- Editor 行为探针使用现有 `test/GalNet.Editor.Tests/bin/Debug/net10.0` 二进制（Editor DLL 时间为 2026-10-25 01:43），创建全新的临时项目，执行真实项目服务。其结果用于复现并与当前未改动的相关服务源码交叉核对，**不能替代当前工作区的完整 Editor 回归**。
+- 运行材料在 `artifacts/group-audit-20261026/`：`probe-results.txt`、`shared-probe-results.txt`、`editor-build.log` 及两个独立探针项目。artifacts 为忽略目录。
+
+## 首先澄清：删除后底层查询会重算
+
+探针使用 show → hide 的最小项目：hide 执行前候选数为 1；删除 show 后再次查询变为 0；撤销后恢复为 1。删除时查询 `Changed` 通知次数为 0。
+
+因此目前不能把症状解释为“底层场景算法完全没有更新”。实际有三件不同的事：
+
+1. 当前作者列表已更新，重新查询能得到新事实。
+2. 原消费者参数中的旧 handle 被原样保留，查询不会替作者清空或改绑。
+3. 已打开控件的显示、候选和过期状态依赖历史、表单、选择上下文和资源通知等不同入口。
+
+Group 投影和 Timeline 已订阅项目历史，正常删除后存在刷新路径；不能笼统宣称它们一律不刷新。未解析引用保留也是当前规范的明确行为。真正缺少的是影响分析、统一发布和可操作诊断。
+
+`parameter-editor-design.md:116` 已要求删除生产者后保留引用并提示未匹配目标；`:124` 明确缺目标应跳过，不能仅因候选缺失阻止保存或编译。因此以下引用诊断建议属于作者提示，不能擅自升级为编译错误或删除门禁；参数格式、类型/属性和值契约错误仍按原规则处理。
+
+## 问题清单
+
+### 1. [P1] 删除和换类型没有场景引用影响分析，显式检查也补不上
+
+**证据**：`src/Editor/GalNet.Editor/Services/GroupEntryAuthoringService.cs:91` 的 Delete 直接构造 PresenceEdit；`EntryFieldAuthoringService.cs:31` 的 SetType 直接替换类型和参数，并通过 NewEntry 重新分配创建者输出身份。普通删除、键盘删除、菜单删除和剪切均通向这套删除入口。
+
+`src/Editor/GalNet.Editor/ViewModels/ProblemsPanelViewModel.cs:74` 的 Validate 检查 Graph、Group 契约、值与本地化；`src/Editor/GalNet.Editor.Shared/Services/ProjectValidationService.cs:111` 以单条 Entry 进行参数/编译校验，没有场景引用可达性检查。SceneTargetResult 只提供候选与 Complete/Reachable，没有“哪个消费者的哪个字段引用了已移除来源”的诊断。
+
+**复现**：创建层并让 hide/move/Timeline 引用它，删除创建者，或将 show 换成 showColor。探针确认换类型后创建者 handle 已改变，消费者仍保留旧 handle；Problems 没有给出相应场景断引诊断。
+
+**影响**：作者不知道哪些后续 Entry、下游 Group、Timeline 轨道/事件受影响；错误或无效果可能直到运行时才暴露。尚未重新选择的旧参数不会自动获得新对象身份。这里的引用是场景实例引用，不等于图片资源是否还在项目里。
+
+**方向**：在作者操作前生成项目级影响结果，至少给出来源稳定 ID、消费者稳定 ID、字段/JSON 路径、确定失效/可能失效和分析不完整原因；删除批次内部的相互引用应排除。没有外部影响时直接删除，有影响时让作者明确选择保留断引、重选或取消。相容的换类型评估保留输出身份，不相容时同样报告影响。检查应覆盖跨 Group、Timeline 轨道/事件和播放实例。对不完整/自定义语义保持明确的未知状态，不能声称没有引用。
+
+### 2. [P1] 剪切后粘贴使用复制语义，批次外引用永久留在旧身份
+
+**证据**：`src/Editor/GalNet.Editor/Controls/EntryListEditorControl.axaml.cs:159` 附近的 CopySelectionAsync(cut) 写入普通剪贴板后删除原条目；`GroupEntryAuthoringService.cs:76` 对所有粘贴执行 RemapCopy。剪贴板没有项目内移动身份/事务信息。
+
+**复现**：只剪切创建层的 Entry，保留一个引用它的消费者，再粘贴创建者。探针结果为 `preserved handle=False`、`outside consumer unchanged=True`。即使放回原 Group，外部消费者仍指向已删除身份。剪切整个引用闭包可能正常，现有批内重映射并不能证明单独剪切安全。
+
+**影响**：作者以为是在搬移已有对象，实际创建了新对象；Undo、原条目与粘贴副本之间的身份含义也不同。
+
+**方向**：复制与项目内剪切移动需要明确区分。项目内移动应保留或整体迁移引用身份，验证源版本，并将搬移及必要引用调整纳入同一项目历史。跨项目/失效剪切凭据按复制处理时应明确告知。即使暂不实现移动协议，也应复用问题 1 的影响提示。
+
+### 3. [P1] 删除带未提交输入的 Entry 后，孤立草稿继续阻止整个项目保存
+
+**证据**：`src/Editor/GalNet.Editor/Services/EntryEditSession.cs:25` 的 Pending 包含全部字典草稿；CheckSources 只标记冲突，没有删除目标的迁移/归档流程；`:120` 的批量提交继续提交这些草稿。`ProjectContentSession.CommitDraftsAsync` 在写盘前统一提交。
+
+**复现**：为层的 opacity 建立未提交的 0.7 草稿，再删除层。探针得到 PendingCount=1、IsConflicted=true；统一提交失败，提示“源值或目标已改变”。Undo 恢复 Entry 后，草稿仍冲突。
+
+**影响**：看起来已经删掉的条目还会阻止保存其他内容。当前可以到 Problems 明确丢弃草稿，因此这是可恢复的问题，不是数据已经损坏。
+
+**规范关系**：源改变后保留冲突、Undo 不自动复活草稿，是现有保存规范明确规定的保护行为。缺口在于删除操作未把这项后果展示给作者，也没有把删除目标的草稿与其生命周期协调起来；不能简单通过静默丢弃输入“修复”。
+
+**方向**：删除前展示相关未提交输入并决定提交/归档/放弃/取消；若归档随历史保留，应从活动 Save All 队列中移出，并为撤销恢复制定明确规则。保留冲突时，错误直接定位到删除操作与可用的取消草稿入口，避免只留下不再存在的 Entry 定位。
+
+### 4. [P2] 全项目 Revision 被当成当前场景事实版本，误伤无关 Timeline 输入
+
+**证据**：`src/Editor/GalNet.Editor/Services/ProjectSceneTargets.cs:96` 序列化完整 Graph/所有 Group 后比较，任何作者内容改变均推进同一 Revision。`TimelineEditSession.cs:92` 即使根 Timeline、选择和 sceneSignature 相同，也要求 Revision 相同才保留行；否则重建树、递增 generation 并使旧行失效。Submit 同样拒绝旧 Revision。
+
+**复现**：在 Timeline 行填入尚未提交的 99，再修改它后面一个 Wait 的 condition。前缀场景与 Timeline JSON 没变，探针仍观察到新行不再保留 99，旧行 Commit=false。
+
+**影响**：其他页面或后文的无关编辑会取消正在输入的 Timeline 数值、菜单或手势；容易被理解为偶发失效。规范承诺无关且事实未变的更新保留本地输入，现有版本粒度比该承诺更宽。
+
+**方向**：区分作者事务代次、资源代次、来源/位置代次与当前查询事实版本。不可只删掉 stale 检查；应在根值、目标身份和相关事实仍一致时重基当前有效输入，在真正受影响时才取消。
+
+### 5. [P2] 作者变化没有统一的场景查询发布事件，消费者各自补通知
+
+**证据**：`ProjectSceneTargets.cs:55` 的内容事件只比较 Assets 工作字节；Capture 在查询时推进作者 Revision，但不发 Changed。Changed 主要来自资源准备、刷新。`EditorGroupProjectionStore.cs:26` 另行订阅 DocumentChanged/字段 Changed/History Changed；Timeline 又自行订阅这些部分事件。
+
+**复现**：删除 show 后显式查询已经改变，但 Changed=0。该事实不等于当前所有控件都停留在旧场景：它们可经其他通知刷新。
+
+**影响**：只监听场景服务 Changed 的新消费者容易遗漏普通作者修改；批量编辑期间的同步集合/字段刷新也可能多次观察中间内容。界面最终是否刷新依赖订阅组合与顺序，难以定义一致性契约。
+
+**方向**：以项目操作完成后的稳定作者快照发布一次有范围的通知，查询层拥有自身的失效契约；控件按该契约更新显示和过期状态。已打开的旧选择需要明确失效/重新查询，不能自动把旧用户选择替换成新目标。批量与补偿失败路径应一并验证。
+
+### 6. [P2] 场景快照检查和全投影刷新同步放大编辑成本
+
+**证据**：ProjectSceneTargets.Capture 每次 Query/IsCurrent/PreparationStamp 都序列化整个作者项目；`SceneTargetAnalysis.StateBefore` 每次从 Group 入口重放到指定 Entry。`EditorGroupProjectionStore.cs:31` 每次历史变化同步全部已加载 Group，`:90` 内容相等时仍刷新每条 Entry 的字段和表单；字段选项再次触发场景查询。
+
+**影响**：存在多个 Group/多个 Locator 表单时，一次小修改可能引发多次完整 JSON 序列化及前缀分析，均可处于 UI 调用链上。这是源码确认的复杂度风险，本次没有测量大型项目延迟，不声称已经测得卡顿阈值。
+
+**方向**：先用单调作者代次替代读时全量序列化；按受影响 Group/Entry 范围刷新，并缓存 Group 摘要/前缀。先建立代表性计数/耗时证据，再决定是否异步化；异步化仍需保留正确的过期保护。
+
+### 7. [P2] 已删除对象越过历史预算继续被项目缓存强引用
+
+**证据**：`EditorGroupProjectionStore.cs:59` 的 `_allEntries` 只 UnionWith/Add，直到整个项目 Dispose 才 Clear。`EntryEditSession` 的 `_drafts` 同样直到项目关闭才整体清空，没有按失效、干净与历史可达性回收。
+
+**复现**：删除后清空历史，探针观察到 Group 活动条目为 3，而 `_allEntries` 仍保留 5。清空历史后这些对象仍可从投影集合直接到达，不依赖 GC 时机。
+
+**影响**：频繁新增/删除或长期编辑时，200 步/字节历史预算无法约束这部分 Entry/Source/草稿/闭包。历史释放不等于对象释放。
+
+**方向**：明确活动投影、历史保留对象、未提交草稿各自的所有权；用可释放句柄或按可达性回收，不用永久 HashSet 作为统一销毁清单。关闭页面仍须保留有效草稿，不能简单清掉所有缓存。
+
+### 8. [P2] 过滤列表不随搜索字段的编辑重新发布
+
+**证据**：`GroupEditorPanelViewModel.cs:71` 的过滤依赖 Id/Type/Summary/Condition，但只在 SearchText 和集合变化时通知 VisibleEntries；`:271` 的条目属性订阅仅处理展开状态与 Type→Configure，没有在上述搜索字段变化后刷新过滤结果。
+
+**影响**：搜索期间修改条件、文本/资源摘要或类型时，画面中的条目可能继续保留或不能及时出现；此时屏幕所见与重新计算的 VisibleEntries 不同，增加选择、删除和重排的理解成本。此项为静态确认的通知缺口，未完成当前主题下的真实键鼠复现。
+
+**方向**：对实际搜索字段变化重筛，批量/输入时合并通知，并按稳定 ID 保持或明确移除选择。需要测试匹配→不匹配、不匹配→匹配及过滤中的多选/重排。
+
+### 9. [P2] Group 摘要仍直接展示内部 handle
+
+**证据**：`EntryEditSession.cs:140` 附近的 Summary 和 `GraphPresentationModels.cs:437` 的备用 Summary 都拼接 handleId 原字符串；常用字段 Group 头部展示 Summary。专属 Picker 隐藏了 handle，但摘要没有同样适配。
+
+**复现**：探针确认消费者 Summary 包含其 opaque handle。
+
+**影响**：作者在对象被删除、换类型或重命名后看到 GUID，而不是对象来源、资源和失效原因；与现有隐藏内部身份的创作交互方向不一致。
+
+**方向**：摘要使用统一的场景来源/资源描述；缺失时明确显示未解析对象并能跳到诊断。JSON 高级修复入口仍可保留真实身份。
+
+## 修复顺序与验收建议
+
+1. **先建立引用影响与诊断闭环**：覆盖删除、换类型、剪切、重排越过创建者和 Group/拓扑变化；复用创建/引用槽位声明，避免另写按参数名猜测的扫描。必须区分一定缺失、条件/分支可能缺失、分析不完整；不要因为候选暂时缺失就自动删除作者轨道。
+2. **明确剪切/复制与草稿语义**：同项目搬移、跨项目复制、过期剪切凭据、删除带草稿目标都应有可预测的单次历史和 Undo/Redo 行为。有效旧引用不能静默改绑到新对象；旧控件也不能因撤销恢复提交权。
+3. **再统一变更发布与失效粒度**：一项作者事务只发布稳定结果；删除创建者必须更新其后及下游 Group，删除 hide/stop 应恢复后续候选，撤销/重做应重算；改无关后文应保留当前 Timeline 输入。
+4. **最后处理缓存、过滤与呈现**：监测全量序列化/前缀重放次数和长期对象保留，修复过滤通知与摘要。完成后执行当前工作区的真正 Editor 集成/挂载测试及保存重开流程。
+
+关键回归矩阵应同时包含普通层、差分层、粒子、效果、视频、animate/Timeline 播放、转场输出，以及 Timeline 事件内部创建者；同 Group/跨 Group、条件、分支、循环、未知条目均要覆盖。删除自身批次不产生多余外部引用提示，资源文件引用与场景实例引用分开报告。
+
+本次没有复现并确认用户提到的全部具体异常堆栈；不能将任何运行时错误都归因于 entry 删除。已复现的草稿冲突和 stale 拒绝提供了具体来源，其余异常仍需以对应日志和最小作者数据继续定位。
diff --git a/features/F-20261015-02-editor-authoring-workspace/summary.md b/features/F-20261015-02-editor-authoring-workspace/summary.md
index 6ae0fa76..a554935b 100644
--- a/features/F-20261015-02-editor-authoring-workspace/summary.md
+++ b/features/F-20261015-02-editor-authoring-workspace/summary.md
@@ -1,5 +1,7 @@
 # 已实施切片摘要
 
+2026-10-26 Group 直接编辑修订已验证：删除、换类型、移动不再显示影响确认，Problems 自动展示当前引用警告；原引用、输入归档、Undo/Redo 和严格编译/构建校验保留。Editor 325 项及 Shared 相关 34 项通过，原生 GUI 未执行，见 [修订记录](group-direct-editing.md)。
+
 本 feature 仍在实施；完整阶段状态见 [phase-plan.md](phase-plan.md)，此前实施记录在各 Phase 文档中。本页从 P6e4c3b 起维护已收口切片，不表示整体 feature 已完成。
 
 ## P6e4c3b：效果 metadata 能力
@@ -15,3 +17,19 @@
 停止动画通过共享 Picker 选择 Animate 或 Timeline 的播放来源，支持本地化名称和英文类型搜索，不展示内部 handle。播放候选与可动画场景对象分域，Timeline 对象树保持原有范围；立即停止与迭代后停止采用不同的保守候选规则。选择域、过期保护、单步历史、复制引用及保存重开已验证。
 
 解决方案构建成功，1239 项相关回归通过，2 项既有 Group 布局断言失败，6 项原生媒体环境用例未执行。完整证据见 [阶段记录](phase-6e4.md)，当前契约见 [Editor 场景目标查询](../../docs/spec/editor-scene-targets.md)。P6e4c 整体仍在实施。
+
+## Group 作者一致性（GC1–GC5）
+
+本轮针对删除 Entry 缺少引用提示、剪切身份改变、孤立输入阻止保存、无关编辑取消 Timeline 输入，以及搜索/摘要/对象保留问题，收敛为作者提交结果、语义目录、操作影响、输入生命周期和派生查询五个模块。完整实现与验收证据见 [Group 阶段记录](phase-group-consistency.md)，原始问题与复核见 [review](review.md)。这项收口不表示本 feature 其他 P6/P7 范围已经完成。
+
+现有项目历史是唯一作者提交边界，Entry 集合只作单向投影；普通编辑与 Undo/Redo 成功后发布一次范围结果。共享语义声明负责输出逻辑角色、引用身份域及允许目标种类，自动身份、复制、Picker、影响检查和 Problems 共用。缺目标保留为作者警告，不自动清空原引用，也不新增保存门禁。
+
+项目内剪切先标记待移动，成功粘贴才以单历史迁移并保留场景身份；过期或跨项目票据按复制提示。相容换类型按输出角色迁移身份。删除、换类型、跨 Group 移动及整 Group/文件删除归档原始输入，恢复必须经新绑定检查；归档独立持久保存并有 1,000 条/16 MiB 硬预算，不随清空历史丢弃。异步结构操作在实际同步发布边界捕获最新输入，保留既有 Working/Saved 事务。
+
+托管查询按提交范围克隆 Group 快照，复用相同入口/出口与前缀检查点；最多 128 份检查点、256 个位置结果，结果版本、写入上下文和资源准备版本分开。旧选择失效后不因 Undo 复活，无关编辑和展示变化保留有效 Timeline 输入。固定点仍遍历可达 Graph，不宣称完整动态依赖图或通用性能提升比例。
+
+搜索依赖属性变化实时重筛，摘要与 Picker 共用可读来源。干净字段和退出投影使用弱保留，未完成输入通过中立适配保存，历史只保留中立作者数据；强制 GC 用例验证删除 ViewModel 在历史仍保留时可释放。资源名称后台准备有独立预算与取消，摘要读取不挤占交互选择缓存。
+
+正式当前行为见 [Group 编辑](../../docs/spec/editor-groups.md)、[历史与保存](../../docs/spec/editor-history-and-save.md)、[场景目标](../../docs/spec/editor-scene-targets.md)。原生 IME 候选、真实系统剪贴板多应用交互和四项 Explicit 原生媒体 GUI 流程没有在本轮人工验收；未知自定义语义仍保守报告覆盖不足，运行时缺目标语义没有在本轮改写。
+
+本轮最终验证：当前源码完整解决方案构建成功，Editor 327、Shared 427、Architecture 49、Integration 123，共 **926 项执行通过**；51 个 C# 文件格式/IDE0005 verify 通过，工作区与最终快照 1,356 文件哈希一致。一次 Headless 会话 DisposeAsync 异常保留日志，同一构建的独立用例与完整 Editor 重跑通过，根因未确认。GC1–GC5 verified，专项复核 pass-with-follow-up，材料见 `artifacts/group-consistency-gc5/`。
diff --git a/features/F-20261017-01-sample-shader-effect-showcase/summary.md b/features/F-20261017-01-sample-shader-effect-showcase/summary.md
index 13874fdb..ff01481c 100644
--- a/features/F-20261017-01-sample-shader-effect-showcase/summary.md
+++ b/features/F-20261017-01-sample-shader-effect-showcase/summary.md
@@ -15,7 +15,7 @@
 ## Validation
 
 - `dotnet build src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj --no-restore -m:1 -v:minimal -p:UseSharedCompilation=false`: succeeded, zero errors; existing analyzer warnings remain.
-- `scripts/build-project-contracts.ps1` for `GameTestCase`: succeeded, zero errors. NuGet vulnerability data lookup emitted `NU1900` because the package source was unavailable in the sandbox.
+- `scripts/contracts/build-project-contracts.ps1` for `GameTestCase`: succeeded, zero errors. NuGet vulnerability data lookup emitted `NU1900` because the package source was unavailable in the sandbox.
 - Headless CLI `project.build` for `GameTestCase`: succeeded, four compiled groups, no diagnostics. The temporary generated output was removed afterward.
 - No tests were added or run. Shader compilation and rendering are validated through Skia RuntimeEffect CPU previews; the full Avalonia host was not launched.
 
diff --git a/features/F-20261021-02-image-variants/design.md b/features/F-20261021-02-image-variants/design.md
index cc8efd4c..7c27dc1c 100644
--- a/features/F-20261021-02-image-variants/design.md
+++ b/features/F-20261021-02-image-variants/design.md
@@ -235,3 +235,9 @@ builtin.layers 节升至 v2，旧 v1 明确拒绝；GameSnapshot 外层仍为 v4
 ## 15. P5 示例素材适配
 
 用户将真实立绘更名为 `xy_表情.png`；Sample 使用 pose / expression 两个维度，并复制 wink 为较短名称 `solo.png`，演示削减后保留表情。两张原有 classroom JPEG 使用 scene / mode / focus 三维命名，演示合法值缺组合时显式 Default 及后续精确命中。保留既有资源 ID、图片字节与 Gallery 引用；没有改写算法或引入别名机制。原始 smile/coat/weap 名称矩阵仍由纯解析和运行时测试覆盖。实际示例、验证范围和限制见 [P5](phase-5.md)。
+
+## 2026-10-25 Inspector 简化修订
+
+用户确认：维度数量、顺序及选项完全由文件决定，只保留显示名称编辑；稳定 key 不开放修改。此修订取代第 3 节手工维度数量与重排的设计。作者 dimensions 作为位置命名元数据，缺少的位置自动生成不冲突 key，多余的位置不活动但保留原文名称。扫描与编译统一执行此规则，自动扫描不改写配置。
+
+默认图仅一个下拉框，目录用选择器；移除配置应用、维度增删排序、内嵌 JSON；有效配置自动进入项目历史，统一保存写盘。刷新只扫描与更新预览，文件变化通过既有资源监视通知被动触发。保留回退状态，完整候选链折叠显示。验证见 [本次记录](inspector-20261025.md)。
diff --git a/features/F-20261021-02-image-variants/feature.md b/features/F-20261021-02-image-variants/feature.md
index 6e2e6257..460b5d06 100644
--- a/features/F-20261021-02-image-variants/feature.md
+++ b/features/F-20261021-02-image-variants/feature.md
@@ -38,3 +38,5 @@
 - 第一版拟采用即时切图，沿用图层移动/动画能力；专属差分交叉淡化后续单独设计。
 - [实施阶段计划](phase-plan.md)记录各阶段状态；[P1 实施与验证](phase-1.md)、[P2 实施与验证](phase-2.md)、[P3 实施与验证](phase-3.md)记录已完成能力及证据。
 - 图集资源、发布、指令、CatchUp 与存档恢复已接入；[P4a](phase-4a.md) 已接入场景静态分析、基础资源/对象选择与引用身份，[P4b](phase-4b.md) 已完成创建、配置、差分预览及维度/值联动。[P5](phase-5.md) 完成立绘/场景示例、真实导出安装与原生 SceneHost 截图验证、回归和正式文档收尾；限制与后续人工范围保持明确。
+
+- 2026-10-25：按用户确认简化 Inspector，维度结构自动推断、仅显示名可编辑，默认图单下拉、自动提交配置、移除内嵌 JSON；设计修订和验证见 [实施记录](inspector-20261025.md)。
diff --git a/features/F-20261021-02-image-variants/inspector-20261025.md b/features/F-20261021-02-image-variants/inspector-20261025.md
new file mode 100644
index 00000000..b1ad0fef
--- /dev/null
+++ b/features/F-20261021-02-image-variants/inspector-20261025.md
@@ -0,0 +1,29 @@
+# 2026-10-25 Inspector 简化
+
+状态：本轮实现与定向验证 verified；原生目录对话框、DPI/IME 未做人工验收。
+
+## 已确认范围与实现
+
+- 默认图片仅一个 ComboBox；失效值显示原名称及缺失提示，可重新选择修复。
+- 图片目录使用选择器，路径只读；拒绝 Assets 外路径与链接。
+- 图片文件决定维度数量、顺序及选项；稳定 key 只读，仅编辑显示名称。保留旧 key，因此 GameTestCase 的 pose/expression 等剧情引用无需迁移。
+- 维度配置仅命名位置。新位置自动生成不冲突 key，超出实际数量的命名休眠保留；扫描不改写配置。Core builder、作者扫描与资源编译共用规则；编译 payload 仍要求完整结构，decoder 不自动修复坏 payload。
+- 移除自由输入默认名、维度增删排序/重新推断、应用配置和内嵌 JSON；有效修改自动提交项目内容历史，统一保存落盘。
+- 既有资源文件监视通知触发扫描，保留主动刷新；保留预览选择及显式重置，候选削减链折叠为匹配详情。
+- 同步四语资源、操作手册与正式规范。
+
+## 验证与边界
+
+- 使用 HEAD 加本次变更的 Temp/variants-inspector-source 源码副本验证，以避开共享工作区另一项本地化改动的暂时编译错误，保留用户正在运行的 Editor。
+- 普通沙箱 testhost 连接超时，后续允许的本机测试执行正常。普通 bin 被运行中的 Editor 锁定；曾同时构建共享项目导致临时 apphost 文件竞争，最终验证改为串行。
+- 首轮挂载断言错误使用 Has.Count 检查迭代器/数组，已改为显式 Count()；该失败没有被计作通过。
+- Core 差分 33 passed；Assets 管线 24 passed；Editor.Shared 差分与场景查询 29 passed；GameTestCase/差分集成 10 passed；Editor 挂载与移动重基 7 passed；Primitives.Builtins 运行与恢复 23 passed。合计 126 passed，无最终失败。Runtime 项目初次筛选无匹配测试，未计入；运行用例实际位于 Primitives.Builtins。
+- Editor 及集成依赖编译通过；本次 7 个 C# 文件 whitespace 检查通过。9 个实现/测试文件与测试副本字节一致，四语 key 集合一致。
+- 验证挂载控件只有一个默认图 ComboBox，名称编辑自动形成历史；撤销重做与保存重开保留 default、label 和原 key。资源刷新新增维度但不改作者文本/历史，缺失默认图可用下拉框修复；目录选择拒绝 Assets 外路径。
+- 原生目录对话框、真实 DPI/IME 本轮未人工验证；目录命令与 Assets 范围检查由挂载测试验证。
+
+## 后续交互修订
+
+用户进一步确认移除主动重新扫描，仅保留文件变化被动扫描；默认图未匹配时下拉框留空，不显示原名称占位，仍保留扫描诊断且不改写作者配置。位置标题改为四语本地化的“维度 1、维度 2”，内部 key 不展示；未命名的预览选项同样显示本地化位置名。空显示名不写入本地化文字，由界面动态回退，切换语言不产生配置历史。
+
+本轮验证：隔离源码 7 项 Editor 定向挂载/重基回归全部通过；两个 C# 文件 whitespace 检查通过，三个实现/测试文件与测试副本字节一致，四语 key 集合一致。确认按钮不存在、缺失默认值无占位、中文维度标题与预览请求正确且切语言不改配置。
diff --git a/features/F-20261021-02-image-variants/phase-plan.md b/features/F-20261021-02-image-variants/phase-plan.md
index 2d6fce40..957b2a17 100644
--- a/features/F-20261021-02-image-variants/phase-plan.md
+++ b/features/F-20261021-02-image-variants/phase-plan.md
@@ -186,3 +186,5 @@
 - P4 拆为两个可独立验证切片。P4a 已验证：新增 18 项通过；Editor.Shared 排除并行调试路线测试后 381 项通过，Architecture 47 项通过，Editor 全量 254 项通过、两项既有布局断言失败。完整解决方案构建被并行 Sample 调试构造函数改动阻断，Editor 及相关测试构建成功；格式检查通过。P4 整体与 P4b 仍未完成，见 [P4a 记录](phase-4a.md)。
 - 2026-10-22：P4b verified，P4 作者流程完成。创建、项目文本草稿/校验、属性配置、真实图片预览、初始选择与维度/值联动、工作定义及冷启动代次保护已验证；完整解决方案隔离构建通过，最终相关回归 698 项通过。Editor 排除两项既有布局失败，其余 258 项通过；原完整运行的一次 Headless 释放异常及复跑证据如实保留。新增 12 项通过；见 [P4b 记录](phase-4b.md)。P5 尚未开始，不宣称整项最终验收完成。
 - 2026-10-23：P5 技术集成 verified，整体自查 pass-with-follow-up。Sample 接入用户更名后的 xy 与两张 classroom 素材；新增三模式正式导出/安装及两类回退快照继续选择、原生五截图与正常退出、可重复规模观测。CLI validate/build（含默认 Output）、完整隔离解决方案构建通过；八个回归项目 1258 passed，原生显式 1 passed。Editor 全量 257 passed / 3 failed，两项既有布局失败及一次 Headless 释放 NRE；后者单独复跑通过。完整证据及未覆盖人工/规模矩阵见 [P5](phase-5.md)；没有把全部人工验收标记为 verified。
+
+- 2026-10-25：Inspector 简化 verified：默认图单下拉、自动位置/只编辑显示名、目录选择器、配置自动提交、JSON/应用/维度结构操作移除、匹配详情折叠。隔离源码定向 126 passed，相关编译、格式与源码指纹通过；原生目录对话框/DPI/IME 人工验收未执行。见 [实施记录](inspector-20261025.md)。
diff --git a/features/F-20261021-03-external-game-debugging/phase-contract-identity.md b/features/F-20261021-03-external-game-debugging/phase-contract-identity.md
index e658ad9b..eb302d28 100644
--- a/features/F-20261021-03-external-game-debugging/phase-contract-identity.md
+++ b/features/F-20261021-03-external-game-debugging/phase-contract-identity.md
@@ -18,7 +18,7 @@
 
 ## 验证
 
-- `scripts/test-contract-reproducibility.ps1` 成功：SourceRevisionId 为 40 个 1 和 40 个 2 的两次真实 Rebuild 均产生 `C5D6C3E62379955CFF5E943976EF5A15CAAC1BB1B06754D9B176263B0D338AFA`。
+- `scripts/contracts/test-contract-reproducibility.ps1` 成功：SourceRevisionId 为 40 个 1 和 40 个 2 的两次真实 Rebuild 均产生 `C5D6C3E62379955CFF5E943976EF5A15CAAC1BB1B06754D9B176263B0D338AFA`。
 - 正常构建并运行导出脚本成功，0 错误；导出目录与实际 Sample App 契约同为该 SHA256。PDB 保留，新增错误同时包含实际/预期哈希。
 - 复用刚构建引用运行 Integration 的实际契约身份检查与真实失败子进程回归，两项通过；未放宽协议身份比较。
 - 构建有既有分析/XAML 警告及 NuGet 漏洞查询网络警告；不声明全解决方案测试通过。项目中已加载的旧契约不会自动替换，需要用户关闭项目、部署导出 DLL 后重开。
diff --git a/features/F-20261021-03-external-game-debugging/phase-launch-diagnostics.md b/features/F-20261021-03-external-game-debugging/phase-launch-diagnostics.md
index 03222afe..efc92ff9 100644
--- a/features/F-20261021-03-external-game-debugging/phase-launch-diagnostics.md
+++ b/features/F-20261021-03-external-game-debugging/phase-launch-diagnostics.md
@@ -10,7 +10,7 @@
 
 ## 实现
 
-- `scripts/export-sample-contracts.ps1` 构建 Debug/Release Avalonia Sample，验证实际 App 和契约产物哈希相同，将契约及依赖 DLL 导出至根 `output/Contracts`，打印对应 App 路径；`/output/` 加入 Git 忽略。
+- `scripts/contracts/export-sample-contracts.ps1` 构建 Debug/Release Avalonia Sample，验证实际 App 和契约产物哈希相同，将契约及依赖 DLL 导出至根 `output/Contracts`，打印对应 App 路径；`/output/` 加入 Git 忽略。
 - Editor 在项目会话内持有自己启动的进程监控；持续排空 stderr，只保留最近 8192 字符。连接前任何退出、连接后非零退出均通知现有调试面板 Error 与 Editor 日志；启动本身抛错也进入面板及日志。
 - 断开时取消等待/读取并释放进程句柄，不杀 App；会话取消和代次检查防止旧进程污染新会话。
 - Sample 顶层捕获日志初始化前的参数/契约错误，向 stderr 输出异常，以退出码 1 结束；运行期 fatal 同样保留非零退出码。
diff --git a/features/F-20261023-01-editor-uiux/analysis-20261025.md b/features/F-20261023-01-editor-uiux/analysis-20261025.md
new file mode 100644
index 00000000..bb3afcef
--- /dev/null
+++ b/features/F-20261023-01-editor-uiux/analysis-20261025.md
@@ -0,0 +1,124 @@
+# Editor UI 第二轮优化分析
+
+日期：2026-10-25。状态：analysis / proposed，尚未实施或完成视觉验收。
+
+归属：原 Editor UIUX feature 的后续设计。用户本轮要求纯分析；不将此前实施授权延伸到本轮，不修改业务代码、运行配置或正式规范。本文基于当前工作区源码与规范，包含已有未提交改动；没有启动真实窗口测量像素、DPI 或输入法行为。
+
+## 目标与边界
+
+提高控件对齐、列表操作密度、表格可用面积与编辑连续性。沿用现有项目历史、稳定身份、作者文档与冲突检查，不引入文件格式、运行期语义或自动保存策略变化。
+
+“减少文本”主要针对重复操作按钮与常驻说明；字段含义、状态区别及有影响的操作仍需可理解。沿用调试页已有 EditorIconButton：32×32 点击区域、16 左右图标、透明背景、键盘焦点框、禁用提示。新增、应用、还原、删除、定位、导入、导出使用一致图形与本地化 Tooltip/AutomationProperties.Name。不以 Unicode 字符或 emoji 代替正式图标资源，也不重新引入全局 hover 动画改造。
+
+## 1. GameTextBox 的输入框对齐
+
+当前事实：
+
+- BranchOptionListEditorControl 中 GameTextBox 与 ConditionEditorControl 已同时设置 VerticalAlignment=Center。该文件有本轮开工前的未提交修改，应保留。
+- GameTextBox 包装 FieldEditorRow，后者内部编辑器和操作区均为 Top，默认两行并有 RowSpacing=4。
+- GameTextFieldEditor 返回输入框与可见性动态变化的提示 StackPanel；缺译、共享文本可能增加高度。ConditionEditorControl 也有独立错误行。
+
+因此不能只在外层重复加 Center 就宣称解决。具体像素偏移仍需挂载测量；以上结构是调查线索，不是已复现的唯一根因。
+
+建议：以“主输入行”作为对齐单位，正文输入、条件输入、拖动柄、删除及重置按钮对齐同一中线；缺译、共享、错误放到输入行下方。输入区保持横向填满，单行文字垂直居中，多行正文保留顶部阅读起点。优先提供局部紧凑/行内布局，避免修改通用 FieldEditorRow 后影响全部 DTO 多行表单。禁止用固定负 Margin 校正某个 DPI 的视觉误差。
+
+验收：比较实际 TextBox.Bounds 而非仅外层 Bounds；覆盖普通/共享/缺译/错误、窄 Inspector、长条件、100%/150%/200% DPI。提示出现不使相邻主输入框上下跳动。
+
+## 2. Inspector 将预览放到最后
+
+当前事实：AssetInspectorControl 普通图片预览在 Filter/Compression 前；ImageVariantsEditor 自带预览，但其后还有 JSON 修复区。视频当前只有标题与压缩设置，没有真实视频播放器。
+
+建议结构：
+
+1. 对象信息：名称、路径、可复制 ID。
+2. 编辑设置：过滤/压缩、变体目录、维度、默认值与应用操作。
+3. 高级/JSON 修复及配置诊断。
+4. 最后一块统一预览：普通图片、变体图片或音频控制；变体选择器、请求/实际结果、回退说明属于预览区。
+
+建议将预览作为 Inspector 底部独立区域，上部属性滚动，下部预览高度可调并可折叠。与“仅把 Image 移到长 StackPanel 末尾”相比，可在编辑属性时持续看到结果；也避免预览内部与外部形成重复区域。低高度时允许收起，预览需有高度上限，防止属性区被挤没。视频保留当前能力，真实视频预览另行评估。
+
+拆分的是视图区域，不复制 ViewModel、图像加载或音频播放器所有权。切对象、锁定/解锁和关闭仍按原生命周期处理，预览错误就近显示；配置错误保留在配置区。透明图片建议棋盘底色，点击原尺寸查看可列后续增强。
+
+## 3. 角色表：列表与紧凑编辑条
+
+当前为搜索+文字新增、双列表头、姓名/key 列表、双输入及三个文字操作按钮。固定双等宽列让短姓名与较长 key 竞争空间；未选中时编辑区仍占空间。
+
+建议：
+
+- 顶部搜索横向伸展，右侧固定“＋”图标，复用调试页工具栏视觉。
+- 列表优先展示姓名，key 使用较弱颜色和省略号，完整值通过提示/复制获取。宽面板保留双列，窄面板改为姓名下方显示 key。
+- 选中/新建时显示底部编辑区；姓名与 key 保留简短标签，key 不只依赖 placeholder 表达含义。
+- 应用、还原、删除改为勾号/回转/垃圾桶图标，固定在编辑区操作侧；有草稿标记，未改动时禁用应用与还原。
+- 删除不可用时解释“仍被引用”或“分析未完成”，不能只呈现灰色按钮。
+- 新建后聚焦姓名；应用成功后保留并滚动到角色；不要在修改 key 时顺带修改姓名文本身份。
+
+额外发现：当前选择变化会 Load 新声明，搜索刷新又可能保留旧草稿但让 Selected 变空。应明确绑定草稿所属角色，避免搜索过滤后编辑内容与可操作对象脱节。建议按角色身份保存草稿；尚未创建的新角色用独立草稿身份，key 可改，不能直接把可变 key 当成永久身份。此扩展需在实现时选择合适的会话身份方案。
+
+## 4. 游戏本地化：表格优先，低频配置按需展开
+
+当前事实：顶部常驻语言新增、放弃草稿、交换语言与选项、导入导出、开发语言预览/应用；导入预览还会继续增加顶部高度。分类固定 190，表格上下文约 188、每语言列 244；每行定位是文字按钮，每格另有状态与错误文本。当前没有表内搜索/状态筛选入口。横向滚动覆盖上下文列，长表纵向滚动时列头是否持续可见应实测。
+
+建议主布局：
+
+- 分类导航宽度可调，小窗口可折叠；保留分类名称。
+- 一行主工具栏：文本搜索、目标语言与状态筛选；右侧定位明确的语言管理、导入、导出、更多图标。
+- “语言管理”弹层承接新增、排序及开发语言切换；语言代码与“开发语言”标记保留文本。开发语言切换继续先检查、再明确应用，展示影响范围。
+- 导出弹层保留目标语言、当前/全部分类、模板/运行文本等有意义的标签；导入采用独立预览对话框或展开面板，显示目标语言、变化/跳过/清空数量与明细，保留显式空串授权及应用/取消文字。
+- 表格语言列头持续可见；上下文列固定，语言列共享横向滚动偏移。固定区和可滚动区必须共享行高与纵向位置，避免长译文使行错位。
+- 列头调序按钮改为统一图标或列头菜单；行定位改为图标；状态用小图标/短标签+提示，错误文本仍贴近单元格。
+- 常见筛选为缺译、待复核、有草稿；空字符串与缺译、复核未知与已完成不能被合并。搜索/筛选只影响投影，草稿仍绑定原文本与语言身份。
+- 后续可考虑只显示开发语言+选定目标语言，其余语言按需显示，降低多语言横向滚动成本。
+
+现有表格已有 ListBox 虚拟化，不应为了视觉重排改成全量 ItemsControl。列宽可调和冻结列有价值，但复杂度高于替换图标，宜单独验证。表头、错误行与列表的同步应在真实长表/长译文场景验收。
+
+## 5. 变量子页选择、草稿与右上角新增
+
+当前事实：OnScopeIndexChanged 明确清空 baseline 和 Selected，再 Refresh；没有每个作用域的最后 UID。选择变化会 LoadDraft，未应用输入也会随之被替换。列表宽度固定 240，新增文字按钮在列表下方。VariablesPanelViewModel 为 transient，关闭 Dock 时 Dispose，因此同一面板内切页保留与关闭重开保留是两个不同范围。
+
+建议：
+
+- 每个作用域保存 LastSelectedUid；切换前保存当前页状态，切回按 UID 恢复，禁止按行号或名称定位。
+- 同时保存未应用草稿与原声明快照。最低要求是两个子页各保留当前编辑项；更一致的方案是用 (Scope, Uid) 缓存已编辑草稿，让同页换项也不丢输入。
+- 状态先限定当前项目会话，不写作者 JSON、不进入撤销历史、不跨项目串用。若要求关闭重开也保留，用项目 scope 的状态服务承载，ViewModel/控件仍可正常释放，不靠保留旧控件实现。
+- 外部改名按 UID 恢复；外部修改同一声明保留草稿并在应用时检查基线；目标删除后取消有效选择并显示失效草稿/显式放弃入口，禁止重绑到同名新变量。
+- 新增后选中新 UID、滚动可见并聚焦名称。当前 Add 是立即创建声明的一条历史，图标调整不暗中改成“输入后才创建”。
+- 列表顶端设置“搜索 / 数量 / ＋”标题条，右上角图标常驻。优先独立 Auto 行，避免覆盖第一项、滚动条或空状态。列表与详情改用可拖分隔条，窄宽度时允许上下布局。
+- 如果采用叠加“＋”，只覆盖预留的标题空间；明确 Z 顺序和自身命中区域。按实际父控件监听的 PointerPressed/Released/Click 阶段阻止选择、清空或拖动副作用，不能只处理 Click 后认定事件已隔离，也不能在隧道路由里提前吞掉按钮激活。保留正常键盘激活与焦点导航。
+
+不把切页操作做成隐式 Apply；保留用户对草稿提交的控制。Save All 当前只保存已应用的变量/角色声明，与本地化单元格会提交草稿的策略不同；本轮先让界面明确“未应用”，如要统一必须另列行为设计。
+
+## 6. 其他 UI/UX 改进与优先级
+
+| 优先级 | 建议 | 理由与边界 |
+| --- | --- | --- |
+| P0 | 变量选择与草稿分作用域保留 | 高频切换导致编辑上下文和输入丢失，应先解决 |
+| P0 | GameTextBox 主输入行对齐 | 需要实际挂载证明；兼顾提示、错误与多行 |
+| P1 | 预览统一放最后，属性与预览可分别分配空间 | 避免预览打断设置流程 |
+| P1 | 角色/变量/本地化复用同一图标与工具栏规范 | 降低文字噪声；复用已有样式，不重做主题 |
+| P1 | 本地化低频配置移入弹层 | 直接增加表格可见面积 |
+| P1 | 变量列表搜索、类型小标记、描述截断 | 当前描述长文换行会让列表扫描效率下降 |
+| P1 | 未选中、空列表、无搜索结果各有对应提示 | 不能都只留下大片空白或禁用表单 |
+| P1 | 明确草稿/已应用未保存/错误状态 | 当前不同面板提交策略有差异，操作图标化后更需要反馈 |
+| P2 | 本地化冻结上下文和列头、列宽/可见列、状态筛选 | 长表收益大，需要滚动同步和性能验证 |
+| P2 | 角色与分类搜索前后的身份/滚动恢复 | 防止筛选使编辑对象丢失或跳到别项 |
+
+建议额外统一：只读 ID/路径可选择与复制；长文本省略时可查看完整值；操作失败就近显示而非只有底部总错误；禁用动作说明原因；图标保留 Tab 焦点和可访问名称；窄 Dock 下不要依靠 WrapPanel 无限堆叠把内容区挤没。删除等操作已有项目撤销能力，不一律增加确认弹窗。
+
+## 后续实施与验收影响
+
+建议先做选择/草稿状态及主输入行布局，再收口图标与预览，最后重排本地化表格。前两部分验收通过后再扩大表格结构，便于定位回归。本文不替代实施 Phase 计划。
+
+状态验证需要覆盖：玩家 A → 存档 B → 玩家 A、双方未应用输入、新增、改名、外部刷新、删除/撤销、同名新 UID、项目关闭；关闭重开的项目会话保留仅在采纳该扩展后加入。新加号要真实点击验证不触发列表选择/空白清除/拖动，且只新增一次。
+
+视觉验收需要覆盖：宽/窄/低高度 Dock、浮动/最大化、四种 UI 语言、长姓名/key/描述/译文、亮暗主题、DPI、键盘与 IME；本地化大量行保持虚拟化，滚动后编辑身份正确。必须保留缺译/空串、过期导入预览、开发语言切换证据和单次历史等已有语义回归。
+
+源码入口：
+
+- `src/Editor/GalNet.Editor/Controls/GameTextBox.cs`、`GameTextFieldEditor.cs`、`BranchOptionListEditorControl.axaml`
+- `src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorRow.cs`
+- `src/Editor/GalNet.Editor/Inspector/Views/AssetInspectorControl.axaml`、`ImageVariantsEditor.axaml`
+- `src/Editor/GalNet.Editor/Views/CharactersPanelView.axaml`、`GameLocalizationPanelView.axaml` 及其 code-behind、`VariablesPanelView.axaml`
+- `src/Editor/GalNet.Editor/ViewModels/VariablesPanelViewModel.cs`、`CharactersPanelViewModel.cs`
+- `src/Editor/GalNet.Editor/Views/ExternalDebugPanelView.axaml`、`Themes/EditorButtons.axaml`
+
+约束依据：`docs/spec/editor-variables.md`、`docs/spec/editor-game-localization.md`、`docs/manual/editor-authoring-workspace.md`。
diff --git a/features/F-20261023-01-editor-uiux/analysis-localization-20261025.md b/features/F-20261023-01-editor-uiux/analysis-localization-20261025.md
new file mode 100644
index 00000000..bfd45035
--- /dev/null
+++ b/features/F-20261023-01-editor-uiux/analysis-localization-20261025.md
@@ -0,0 +1,103 @@
+# 游戏本地化 UI 再精简：分析与修订建议
+
+日期：2026-10-25。状态：analysis / proposed。本轮分析当前实现、用户反馈和官方资源编辑器资料，不修改业务代码或正式规范。此前第二轮实施授权不作为本轮新行为的实施状态；语言移除、单元格浏览/编辑模式及状态降噪均尚未实现。
+
+## 结论
+
+上一轮将按钮图标化，但保留了大量常驻状态、整行筛选和每格独立的大输入框，信息密度仍然偏低。建议收敛成“紧凑资源表＋按需语言管理”，以对照原文、填写译文和定位出处为主流程。
+
+## 当前事实
+
+- GameLocalizationPanelView 主工具栏下仍有单独一整行目标语言与四种状态筛选。目标语言又与导出/平铺导入共用 ExchangeLanguage，显示所有语言的表格为什么还要选一个语言，不够直观。
+- 每个单元格一直使用多行 TextBox，MinHeight=64、MaxHeight=160，下方再显示缺译/空串及复核状态；每列固定 244。表格观感更接近一排表单。
+- 语言列头为每个非开发语言放两个左右按钮；行定位按钮则放在位置文字下方。即使内容很短，操作区仍明显抬高行高。
+- 管理语言弹层目前只有新增输入和开发语言切换，没有展示“已有语言”的专门管理列表，也没有移除入口。服务只有 AddLanguageAsync、MoveLanguageAsync 和开发语言切换，没有 RemoveLanguageAsync。
+- 语言管理图标是上一轮手写的 PanelLanguageIcon 复合 Path，不是现成的 Ursa 图标。用户已反馈显示不完整；本轮未挂载测量裁剪，不将原因直接断言为按钮宽度或某个模板问题。
+- 固定列与左上角目前绑定 SemiColorBackground0；GameLocalizationPanelView 自身未显式建立表格底色。Violet/Aurora 的该画刷定义为不透明颜色，但它是否与实际 Dock/ListBox/选中行的底色一致，不能仅凭资源名认定。视觉反馈中的透明/不一致需要通过最终合成效果验收。
+
+源码入口：Views/GameLocalizationPanelView.axaml 及 code-behind、ViewModels/GameLocalizationPanelViewModel.cs、Services/GameLocalizationPanelService.cs、Themes/AuthoringPanelResources.axaml，均位于 src/Editor/GalNet.Editor/。
+
+## 1. 复核与草稿是否必要
+
+| 概念 | 现在的含义 | 建议 |
+| --- | --- | --- |
+| 待复核 | 译文关联的原文指纹与当前原文不同；只说明原文变了，不能证明译文已经不正确 | 默认取消常驻筛选与格下文字。可选地显示小角标，提示“原文已变更”；不新增审核步骤或阻止正常保存 |
+| 复核未知 | 没有足够的原文关联证据 | 正常表格不展示，避免导入后整表充满不能直接处理的提示 |
+| 有草稿 | 当前输入还未通过失焦/Ctrl+Enter 等提交为项目内容，不是另存的翻译版本 | 保留防丢输入、冲突基线和 Save All 协调，取消常驻“有草稿”筛选和独立的用户流程 |
+| 缺译 | 没有该语言的直接译文 | 保留为有用的筛选和单元格提示；默认用轻量占位/标记，不为每格增加状态行 |
+
+原文指纹目前属于作者 metadata；Runtime 不依赖复核状态运行，当前发布语义检查也不把“待复核”作为缺译错误。复核证据可继续供导入判断与可选提示使用，没有必要让普通作者承担审核工作流。若以后决定完全移除这项功能，应另行清理 metadata 写入、复制及交换测试，不能仅删除表格文字后宣称机制已移除。
+
+草稿与“已提交但尚未 Save All”的内容不同。保留内部草稿的理由是切分类、关闭重开、输入法组合和冲突时不丢输入；正常编辑不需要用户理解“存草稿”。保持现有失焦/Ctrl+Enter 提交与 Escape 取消，冲突发生时才展示就近错误；全局“放弃所有草稿”移到更多菜单，限定范围、只在有输入时可用。
+
+## 2. 语言管理与新增候选
+
+建议弹层或小型管理窗口分两段：
+
+```text
+项目语言
+中文（简体）  zh-CN       开发语言
+English       en-US         [移除]
+日本語        ja-JP         [移除]
+───────────────────────────────
+[ 搜索语言名称或代码…        ▾ ] [+]
+```
+
+- 已有列表显示原生语言名＋标准 culture code；开发语言有清晰标记，不能直接移除。设置开发语言作为行菜单动作，只有执行该动作时展开影响预览与应用，不常驻另一整套表单。
+- 新增候选来自 CultureInfo 的有效文化与常用预设，包含中性及地区/脚本文化；支持按 code、原生名和英文名搜索，排除已选的规范化 code，选择后得到确切 culture。允许直接输入合法 code，不强迫只选少数预设。
+- 项目锁定 Irihi.Ursa 2.1.0。已安装 DLL 中可以确认 MultiAutoCompleteBox、MultiComboBox；项目现有 ComboBox IsEditable=True 也已有使用。单项新增先验证可编辑 ComboBox/AutoCompleteBox 在 Semi/Ursa 主题中的体验，不为单项新增强套多选控件。若不能提供期望的候选过滤/键盘行为，复用人物选择器的“输入＋候选列表”交互模式，候选数据与创建语义独立。
+- Enter 接受高亮候选，明确“＋”或确认动作才添加；失焦搜索不新增语言。IME Enter 不被截走。输入无法解析时就近提示；不得把显示名当成 culture code 写入配置。
+- 列调序集中到此处的拖动/行菜单，移除每个语言列头的两个常驻箭头。显示/隐藏语言列属于视图设置，必须与“从项目移除”区分。
+- 替换手写语言图标为清晰的现成图形，保持统一图标尺寸和点击区域；以实际轮廓、缩放、主题及 Bounds 检查完整性，不把裁剪问题简单扩大按钮后了事。
+
+### 移除语言的建议语义
+
+当前 UI 没有办法执行该操作，属于缺失功能。建议默认动作命名为“从项目语言列表移除”：移除 AvailableLocales 中的该语言并隐藏其列，保留翻译文件与复核证据，重新添加可继续使用原译文，配置变更支持一次撤销。保留文件也意味着不承诺该语言字节已从发布包或磁盘清除。
+
+“同时删除翻译文件”属于另一种有内容损失的操作，若需要应单独设计并显示文件范围，复用项目文件事务；本轮不把它偷偷附加到移除列表动作上。
+
+有该语言未提交输入时，必须先解决这些输入或明确放弃后再移除，不把其他语言输入顺带提交；不允许留下隐藏、失效且持续阻止 Save All 的草稿。当前开发语言不可移除，需先切换。针对该语言的导入预览应失效，应用中的导入需协调，历史实际执行时还要复查语言与项目身份，防旧单元格继续写入被移除语言。
+
+## 3. 定位列按用户提出的两列布局
+
+去掉左上角“上下文”标题，保留与语言表头对齐所需的空白角格。行内使用文字列＋固定宽度操作列，按钮跨两行垂直居中：
+
+```text
+e84a…19c2      ┌────┐
+content        │ ↗  │
+               └────┘
+```
+
+- Group：左上为条目 ID（长 ID 省略显示，提示和复制提供完整值），左下为槽位，如 content 或嵌套字段路径。显示序号与稳定 ID 不混用，导航仍使用真实完整身份。
+- 分支：左上为分支名/ID，左下为选项身份与槽位；完整分支、选项身份和路径放提示。不能仅用会随排序变化的“选项 2”承担导航身份。
+- 角色：左侧显示角色名，ID 放提示或次级文字，右侧为居中定位按钮；没有意义的槽位不硬凑一行。
+- Context 当前是拼接完成的展示字符串。需在服务投影中提供结构化主标签、副标签、完整路径和引用目标，不能通过拆分“·”或当前中文文案倒推身份。所有类别仍保留原引用对象供定位。
+- 同一文本被多处共享时继续合并一行，用轻量数量提示；多引用定位能选择具体出处，避免按钮永远跳到第一处且界面看不出还有其他位置。
+
+表格根面板、固定列、空白角格统一绑定同一个表面画刷，填充必须不透明，文字变浅使用文字颜色，不对固定列父容器降 Opacity。悬停/选中时固定列和其余行保持同样的表面状态；滚动后不得透出后方译文。验收同时检查原始画刷与最终渲染。
+
+## 4. 参考资源编辑器后建议的整体布局
+
+```text
+[搜索…………………………] [仅缺译]   [语言] [导入] [导出] [更多]
+──────────────────────────────────────────────────────
+位置（不显示此标题） │ 中文（开发） │ English │ 日本語
+条目 ID         [↗] │ 原文……       │ 译文……  │ 译文……
+槽位                │              │         │
+```
+
+1. 默认仅一行工具栏，取消目标语言＋四状态占一整行的布局。导出/平铺导入的目标语言放进交换操作，不与表格筛选混用。仅缺译检查当前显示的非开发语言列，任一缺译即保留该行。
+2. 表格浏览态使用紧凑文字单元格，默认约 48–56 DIP 的双行定位行；仅活动单元格进入输入态。移除所有格常驻输入框底色和最小 64 高限制；长文通过展开编辑器/弹层处理，不把整个表格持续撑高。
+3. 开发语言固定显示，其他列按需显示。记住当前项目会话里的可见语言、列宽、分类和滚动位置；视图设置不写作者历史。列宽可调，避免固定 244 导致短文本浪费和长文本横向拥堵。
+4. 缺译使用弱占位或小标记；显式空串与缺译继续区分，但不为每个空串开一行说明。冲突和错误才就近展开详情；复核提示可选，未知状态不展示。
+5. 浏览态支持方向键、Enter/F2 编辑；编辑态保留文本箭头与多行 Enter、Ctrl+Enter 提交、Escape 取消，Tab/Shift+Tab 提交并切相邻单元格。冻结列不能遮住键盘聚焦的输入。
+6. 保留真实行虚拟化和单元格稳定身份，避免为了固定列复制第二套列表。不预设必须换 DataGrid：当前项目没有该包依赖，具体控件需先验证 Avalonia 版本、虚拟化、多行编辑与输入法适配。
+
+## 参考依据与取舍
+
+- [Rider Localization Manager](https://www.jetbrains.com/help/rider/Resources__LocalizationManager.html)：左侧资源范围、行资源/列语言的工作表，可隐藏文化列，问题筛选按需开启。可借鉴语言可见性、集中表格和键盘定位；不照搬与 GalNet 稳定引用不同的 resx 身份规则。
+- [Visual Studio Resource Explorer](https://learn.microsoft.com/en-us/visualstudio/ide/managing-application-resources-dotnet?view=visualstudio)：并列编辑译文、可见语言配置、工具栏搜索，以及单元格小标记和提示。可借鉴轻量提示、主题一致性；不直接把 .NET 占位符校验套到可能具有自定义富文本/参数语法的游戏正文。
+- [Avalonia ComboBox](https://docs.avaloniaui.net/controls/input/selectors/combobox) 与 [AutoCompleteBox ItemsSource](https://api-docs.avaloniaui.net/docs/P_Avalonia_Controls_AutoCompleteBox_ItemsSource)：输入与候选列表已有基础能力；具体建议过滤与键盘体验仍要按项目版本挂载验证。
+- [Ursa 官方仓库](https://github.com/irihitech/Ursa.Avalonia)：配合本机锁定的 2.1.0 包检查，不把当前网站或 main 分支的新 API 当成项目已安装能力。
+
+建议顺序：先减去状态与重复工具栏、替换图标并完善已有语言列表；再完成定位列/不透明统一背景；最后验证紧凑浏览/活动编辑、列宽及可见语言。移除语言是新增作者行为，单独覆盖开发语言保护、撤销、草稿与导入交错。所有建议尚未实施，本轮不修改 Runtime、作者格式或既有保存边界。
diff --git a/features/F-20261023-01-editor-uiux/design-recursive-properties-20261027.md b/features/F-20261023-01-editor-uiux/design-recursive-properties-20261027.md
new file mode 100644
index 00000000..035fe78c
--- /dev/null
+++ b/features/F-20261023-01-editor-uiux/design-recursive-properties-20261027.md
@@ -0,0 +1,75 @@
+# 递归字段树与属性遍历设计
+
+此文保留前期讨论历史，正式设计与当前实施状态见独立 [F-20261027-03-recursive-properties](../F-20261027-03-recursive-properties/feature.md)。
+
+状态：design；用户于 2026-10-27 提出嵌套结构采用类似 Unity 的迭代序列化方式，统一编辑和检查逻辑。此文记录目标与分阶段边界，尚未实现，不作为当前 spec。
+
+## 问题与目标
+
+目前 ValueCodec 使用字段值类型及 JsonSerializerOptions 进行转换；StructuredFieldEditor 自行反射嵌套 DTO Schema、计算 wire 名称和建立子绑定；LocalizationReferenceIndex 又独立识别 DTO/集合和反射成员。Transform、Flipbook 及动态参数编辑器还拥有各自的子字段描述与 JSON patch。内置 Transform 在 Entry DTO 中保存为 JsonElement，因此能被专用控件编辑，却被本地化索引判定为不可遍历。
+
+目标是类似 SerializedObject / SerializedProperty 的字段描述、属性视图和迭代入口。序列化、通用与专用表单、子值校验、引用索引和字段定位共享同一结构事实。专用控件继续负责交互布局，领域服务继续拥有业务规则。消除 Transform 等已知结构的分析盲区，同时保留对真正未知结构的覆盖提醒。
+
+不采用逐字段“确定不含引用”的跳过标记作为这次修复的主体，也不按字段名、EditorId 或看起来像 key 的字符串猜测语义。
+
+## 统一结构描述
+
+以现有 FieldDescriptor / ValueDescriptor / IFieldDto 为基础增加结构解析能力，避免建立第二套字段配置。结构种类包括标量、对象、序列、字符串键映射和不透明值；动态字段由解析器返回上述某一种结构或明确的未解析结果。
+
+- 对象提供有序 FieldDescriptor、字段身份与实际 JSON 名称的映射；允许递归类型，子结构延迟解析，不能在初始化时无限展开。
+- 序列提供元素描述；映射提供值描述和实际键，字典不能仅被当作任意对象，也不能让任意 JSON 自动变成已知映射。
+- 每个叶字段保留现有类型、约束、默认值、编辑提示和 LocalizedText / CharacterReference 语义。引用语义始终来自契约。
+- 生成器为可描述 DTO 提供结构入口，手写 schema 使用同一接口。实际 wire 名称与 converter 规则以 codec 为准，不能让遍历和落盘各用一套命名逻辑。
+- 结构元数据按契约生命周期缓存；动态解析结果还绑定其作者依赖与资源版本，项目卸载不得留下对插件程序集或旧项目的永久缓存。
+
+固定结构优先直接使用可描述的类型。对目前保存为 JsonElement 的兼容字段，允许契约声明其结构类型/适配器，例如 Transform 映射 LayerTransform、Flipbook 映射 FlipbookDefinition。具体声明 API 在基础层实现时确定；结构映射不能改变外层 wire 类型或变成绕过校验的机制。
+
+## 属性视图与迭代
+
+中立属性视图建立在不可变 JSON 快照与结构描述之上，不通过构造作者 DTO 或运行属性 setter 来扫描数据。属性提供当前值、缺省/null/已提供状态、实际 wire 路径、字段元数据、结构解析状态和子节点枚举。
+
+提供类似 FindProperty 与 GetIterator 的入口。内部用显式栈进行深度优先遍历，并设置深度、节点预算、取消和未解析结构结果；消费者可选择只遍历当前层或进入子节点。对象字段缺省时可显示描述与默认值，但只读遍历不写入默认值。未知成员保留独立节点与未解析状态，不能悄悄认定其中无引用。
+
+路径使用类型化的成员、索引和映射键片段；JSON Pointer 仅作对外编码，统一处理 `~` 与 `/`。同一路径由引用诊断、草稿、子值校验和导航共用。Group/Entry 的稳定身份与作者代次属于 Editor 的外层地址，不混入通用结构描述。
+
+列表下标仅表示当前快照内的位置。删除、移动或替换列表使旧属性句柄失效，不能让旧子字段草稿或异步导航落到新的第 N 项；已有稳定元素身份的领域结构可提供身份映射。
+
+## 读取、编辑与落盘
+
+Core 提供平台无关的结构解析、路径、快照读取与遍历协议，现有 ValueCodec 仍是 JSON 转换入口，并逐步使用共享结构描述处理嵌套成员。编辑器项目层在其上包装 SerializedObject 风格的编辑会话和 SerializedProperty 风格的属性句柄，写入仍通过现有 FieldEditorContext、项目作者意图、历史与保存事务。
+
+子属性写入生成局部 patch，不把整个根值反序列化再序列化；保留未知 JSON、原成员大小写、缺省/null 以及无关的兄弟字段。已存在的 JSON 字符串包裹对象格式由显式适配器读取和回写，保持原有编码方式；不把普通字符串当 JSON 递归解析。格式冲突或重复别名必须报告，不任意选择一个成员。
+
+结构与字段规则的校验共用属性树；“目标是否存在”“缩放必须为正”“Flipbook FrameCount 不超过容量”等业务规则仍由各自领域拥有，诊断使用相同路径返回。不能把“可遍历”当作“值合法”，也不能把引用扫描成功当作完整项目校验通过。
+
+## 动态结构
+
+音效/视觉效果参数根据类型、program 或目标上下文查询对应目录的参数描述；Timeline 的固定轨道/关键帧结构可直接描述，事件参数再按事件类型解析。解析器是读取契约和依赖快照的纯查询，不执行游戏 Entry 或任意属性 getter，不把 Avalonia 控件作为结构来源。
+
+解析缺少依赖、未知类型、结构损坏或达到预算时返回有位置的分析不完整结果。实际引用缺失则返回独立的引用错误。明确区分“已知结构且没有引用”和“还不知道内部结构”，不能通过统一隐藏 field.opaque 让角色删除等操作误判引用不存在。
+
+## 分层与迁移
+
+| 层 | 职责 |
+| --- | --- |
+| Core.Parameters | 字段/值结构、路径、codec 协议与有界快照遍历，无 UI 或项目 I/O |
+| Contracts.Builtins | 内置结构声明、兼容适配及领域契约 |
+| Editor.Shared / 项目查询 | 作者地址、动态结构上下文与只读引用索引 |
+| Controls / Editor | 属性绑定、草稿与历史桥接、通用/专用控件布局、问题导航 |
+
+按可验证阶段推进，不一次性重写所有存储格式：
+
+1. **基础协议**：统一 DTO/对象、列表和映射的结构解析、命名、路径与有界迭代；覆盖递归类型、serializer options/converter、缺省/null、未知成员和失效句柄。
+2. **固定内置结构与引用检查**：给 Transform、Flipbook 及其他确定的固定 JSON 结构提供正式描述，索引迁入统一遍历。正常非空 Transform 不再报 opaque；嵌套文本/角色仍能识别，未知扩展结构保持分析不完整。
+3. **表单和校验接入**：通用对象/集合及 Transform、Flipbook 专用布局使用同一子属性与描述；验证局部 patch、关闭重开、Undo/Redo、跨视图草稿、深层字段定位和无默认写入。
+4. **动态参数与 Timeline**：接入效果目录和事件契约，验证切类型/切资源、未知类型、局部 patch、异步结果过期及契约卸载；迁完对应消费者后删除重复的结构反射/字段清单。
+
+每阶段必须验证相同字段在表单、校验、索引和 codec 中的名称、路径及类型一致。原作者 JSON、运行数据和旧项目兼容是退出条件；不能只用警告数量下降作为验收依据。
+
+## 取舍与风险
+
+采用共享结构与属性游标，而不是只在 LocalizationReferenceIndex 特判 Transform；前者能消除表单和分析长期分叉。保留契约控制的可遍历类型，不扫描所有 public getter，避免把计算属性（如 Flipbook Capacity）变成可写作者字段。
+
+不强制所有 JsonElement 立即替换成 CLR DTO，否则未知成员、历史字符串编码、动态参数和 presence 都可能丢失。类型结构与 wire 表示可通过显式适配共存，最终是否迁移文件格式应另有明确版本与迁移方案。
+
+本设计涉及共享元数据及多模块消费，范围超出原先仅修复警告定位的补丁；实现证据与实际退出状态应按以上阶段追加记录。当前尚未修改业务代码，不声称正常 Transform 警告已经消失。
diff --git a/features/F-20261023-01-editor-uiux/feature.md b/features/F-20261023-01-editor-uiux/feature.md
index e5287926..b6ea36bc 100644
--- a/features/F-20261023-01-editor-uiux/feature.md
+++ b/features/F-20261023-01-editor-uiux/feature.md
@@ -13,3 +13,13 @@
 验收及实施顺序见 [设计](design.md)、[阶段](phase-plan.md)。现有其他 feature 与测试修改保留。
 
 首次使用反馈见 [2026-10-24 后续记录](follow-up-20261024.md)：人物 Enter 与 Inspector 焦点问题已修复；按钮 hover 最初仅分析，随后按用户授权实施 [动画统一](motion-unification.md)。
+
+第二轮 UI 优化的原始分析见 [2026-10-25 分析](analysis-20261025.md)：GameTextBox 主输入行对齐、Inspector 底部预览、角色/本地化图标与排版、变量子页选择及草稿、其他 UX 建议。用户随后明确授权实施，进度及证据见 [第二轮实施](phase-ui-20261025.md)。
+
+本地化页后续反馈与资源表精简方案见 [本地化 UI 再分析](analysis-localization-20261025.md)：状态降噪、已有语言列表/新增候选/移除语义、双行定位列、不透明统一背景及 VS/Rider 参考。用户随后授权实施，并要求直接更新输入、不提供草稿或复核流程；进度与验证见 [本地化精简实施](phase-localization-20261025.md)。
+
+本地化实测反馈：隐藏列后表头错位、正文输入需左上对齐、逐字更新卡顿。用户要求改为失焦提交，当前修正见 [本地化交互修正](follow-up-localization-20261025.md)。
+
+2026-10-27 Group 后续：待提交分级、自动检查、人性化提示与稳定定位，以及 NumericUpDown/Slider/精确文本可选路径和浮点简写已实现验证，见 [实现及验证记录](follow-up-group-diagnostics-numeric-20261027.md)。
+
+2026-10-27 嵌套结构后续：用户要求借鉴 Unity 的属性迭代，统一结构描述、编辑、校验和引用分析，替代对已知 JSON 对象的分析盲区；[前期设计讨论](design-recursive-properties-20261027.md) 保留于此，后续已按用户选择归入独立 [F-20261027-03-recursive-properties](../F-20261027-03-recursive-properties/feature.md)，已进入实现和验证，实际范围与遗留见该 feature 总结。
diff --git a/features/F-20261023-01-editor-uiux/follow-up-group-diagnostics-numeric-20261027.md b/features/F-20261023-01-editor-uiux/follow-up-group-diagnostics-numeric-20261027.md
new file mode 100644
index 00000000..c5476a06
--- /dev/null
+++ b/features/F-20261023-01-editor-uiux/follow-up-group-diagnostics-numeric-20261027.md
@@ -0,0 +1,48 @@
+# Group 诊断与数值输入后续
+
+状态：verified。用户确认分析后于 2026-10-27 授权开始，三个 Phase 均已实现并验证。
+
+范围：正常待提交输入不作为错误；数字中间态保留；作者内容和依赖变化自动检查内存工作版，旧结果不再作为当前问题；本地化可操作的问题提示、去重和稳定身份导航；NumericUpDown、Slider + 精确输入、无损数字文本三条可由元数据/宿主选择的路径；浮点简写 `.3`、`-.22`。
+
+设计：共享 codec 只对类型化数字编辑输入规范化简写，JSON 源码仍严格。共享表单保留 numeric 文本兼容，新增显式 numericupdown/numerictext 路径；Editor 的 numeric 默认使用保留原始文字的上下调整框，slider 使用配对数值输入，不把步长用作业务校验。无法安全调整的类型/范围回退文本并说明原因。表单错误由宿主格式化，Core 保持平台中立。
+
+Problems 合并短时间内的更新，捕获当前项目快照后运行契约检查，不自动提交字段。检查结果绑定版本，变动后撤下旧活动错误；字段和场景诊断继续独立更新。提示显示 Group/条目/字段名称和修正建议，原始细节可展开；不存在目标不提供有效跳转，点击时再次核对稳定身份。
+
+Phase 1：诊断状态、自动检查与定位；Phase 2：数字输入与控件路径；Phase 3：实际挂载/交互、保存与撤销回归、相关构建及正式文档同步。只有测试证据齐备才标 verified。
+
+保护：开工已有 ProblemsPanelView.axaml 的 WrapPanel 排版及 CheckBox 居中改动保留。不修改运行时业务校验与文件格式。
+
+## 实现结果
+
+- Problems 的正常输入为 info，不计条目错误/警告数；标记按实际严重程度分色。数字中间态（包含 `1.`）在确认前中性展示，确认仍拒绝不完整值。
+- 作者历史、资源和工作文件变化触发 220ms 合并检查。UI 捕获中立工作快照，Graph/Group 契约及编译在后台检查，代次拒绝过期结果；输入期间不提交、不逐字全项目检查，旧活动校验结果撤下。手动入口可立即检查。
+- 本地化提示包含字段类型、上下限和修正方法，只有单边约束时不显示无穷大。来源显示 Group 名、序号、类型和字段路径。原始消息保留在技术详情，重复参数汇总去重；可跳转的正文及来源靠左且整个按钮区域可点击。
+- 作者导航按稳定身份重新核对；打开对应 Group/Graph/文件/设置，清除阻挡定位的搜索、选中 Entry、展开参数、显示 Inspector。条件、普通字段及能唯一识别的 Transform/向量等子字段聚焦到实际控件，已删除目标不跟随旧序号。视图晚挂载仍接收请求，延迟焦点复核来源与字段路径。
+- `NumericFieldEditors` 提供原始文字驱动的 NumericUpDown，复用 Semi/宿主主题及上下按钮/方向键/焦点内滚轮，提交使用 FieldEditorContext；模板初始化不能制造输入。显式 numericupdown/numerictext 工厂及 Editor slider 配对输入，宿主注册仍可替换。long/ulong/decimal、自定义字符串数值编码及不适用范围保留无损文本。滑块手输不受步长量化。
+- Variants 透明度及音频增益已有 0–1 约束改为 slider 元数据；未改变合法范围。Transform、Flipbook、向量和音效数字复用注册表，子字段提示使用相同本地化名称；音效 update 继续保持可选 patch，同时保留 EditorHints。
+- Core ValueCodec 仅在类型化浮点编辑文本中规范化前导小数点。共享表单和项目草稿 Save All 同用此入口，原始 JSON 仍严格。
+
+## 验证
+
+- 解决方案 `dotnet build GalNet.slnx --no-restore -m:1 /nr:false -p:UseSharedCompilation=false`，设置 AVALONIA_TELEMETRY_OPTOUT=1，成功、0 错误。最终标签补充后再次构建通过；既有分析器警告保留。
+- 完整回归：Editor 336、Core 129、Editor.Shared 456、Presentation 262、Architecture 52；内置 schema/效果参数专项 11，共 1,246 个不同用例通过。TRX 为各测试项目 `TestResults/group-release-*.trx`。
+- 最终本地化子字段补充后，当前产物的 16 项 Editor 聚焦再次通过，见 `group-final-authoring-verified.trx`；覆盖问题自动刷新/快速连续修改/Undo/Redo、四语提示、重复诊断合并、错误点击/实际条件与缩放 Y 聚焦、正常输入不安排全检查、原始上下按钮与方向键、清空/取消、失效字段、关闭页面后 Save All 与重开、滑块精确值、ulong/decimal 精度、Transform/Flipbook/音效及 DTO patch。
+- Presentation TRX 另有四项原生视频环境用例和一项显式预览生成 NotExecuted，不计入通过数。
+- 四语各 1,153 keys，一致；changed C# whitespace、git diff --check 通过。普通 solution 格式工具受沙箱命名管道限制，whitespace 使用无 MSBuild 的 folder 模式；没有声称语义格式检查通过。
+- 真实主题 Headless 控件已挂载、执行输入与按钮交互，并检查截图：`artifacts/editor-group-diagnostics-20261027-session/group-problems.png`、`group-numeric.png`，另有 Group 宽/窄视图。源码指纹位于同目录 `source-fingerprints.json`。
+
+## 验证中修正与边界
+
+首次 NumericUpDown 适配的原生模板同步制造了未编辑草稿，回归暴露列表/设置/外部刷新问题；最终直接拥有模板输入与 spinner 事件，使用同步 PropertyChanged 捕获输入，挂载无草稿和输入后立即 Enter 均有断言。经验见 `.agents/lessons/L-20261027-05-numeric-template-drafts.md`。Timeline 对象选择器的既有测试曾在异步准备结束前读取 flyout，改为等待实际准备信号；没有通过修改产品准备语义迎合测试。新增 Core 断言使用 JsonException 的派生类型匹配，音效断言校验本地化解释及原始 issue 代码。
+
+检查覆盖沿用现有 Graph/Group/本地化与场景静态规则，不把运行期和所有资源解码问题声称为静态可判定。无法唯一识别的复杂同名嵌套子字段仍定位到根字段。原生桌面 IME、DPI 与辅助技术体验保留人工验收边界。
+
+正式规范同步：[Group 编辑](../../docs/spec/editor-groups.md)、[共享表单](../../docs/spec/control.md)、[历史与保存](../../docs/spec/editor-history-and-save.md)；接入示例见 [创作工作区手册](../../docs/manual/editor-authoring-workspace.md#选择数值编辑器)。
+
+## 本地化分析警告定位修正（2026-10-27）
+
+用户实测 `Structured value has no traversable field schema.` 无法定位到 Entry。原因是 Problems 从成功解析的 References 查询 Entry 身份，未使用 LocalizationIssue.EntryId；无法遍历的结构恰好没有成功引用，相同路径还可能误用另一条目的引用。现改为直接使用诊断自己的稳定身份，JSON Pointer 解码为根字段和嵌套路径；`field.opaque` 四语正文解释为引用检查覆盖不足，保留 warning 及原始技术详情。
+
+回归 `LocalizationAnalysisWarningsNavigateToTheirOwnEntriesWithoutResolvedReferences` 使用两个真实 MoveLayer 条目的非空 Transform，验证同字段警告分别定位正确 Entry、参数展开和 Inspector 字段请求，并检查四语提示和含 `/`、`~` 的字段身份。它与既有自动检查/Undo/Redo/实际字段聚焦、稳定导航及两项语言资源回归共 5 项通过，见 `test/GalNet.Editor.Tests/TestResults/localization-navigation-verified.trx`。
+
+Editor.Tests 的 Release 依赖构建成功、0 错误，既有分析器警告保留；changed C# whitespace 与 `git diff --check` 通过。Debug 构建因正在使用的 Editor DLL 被占用而失败，随后改用 Release 验证，未关闭运行中的 Editor。构建日志位于 `artifacts/.tmp-localization-navigation-final-build.log`。当前运行实例需使用新构建重新启动后才能体现修复。
diff --git a/features/F-20261023-01-editor-uiux/follow-up-localization-20261025.md b/features/F-20261023-01-editor-uiux/follow-up-localization-20261025.md
new file mode 100644
index 00000000..908ec1c4
--- /dev/null
+++ b/features/F-20261023-01-editor-uiux/follow-up-localization-20261025.md
@@ -0,0 +1,24 @@
+# 本地化表格实测修正
+
+状态：verified（自动验证）。用户明确要求修复隐藏语言后的列对齐、正文从左上编辑，并将逐字更新改为失焦提交以降低输入卡顿。本轮沿用 feature 实现流程，不改变翻译文件格式及项目保存事务。
+
+## 设计修订与实现
+
+- 表头与内容行都固定左对齐。原表头指定 Width 但保留默认对齐，语言减少到比视口窄时居中，而 ListBox 内容靠左。真实挂载测试复现首列相差 121 DIP；覆盖横向滚动后隐藏中间列、仅剩开发语言和恢复列。
+- TextBox 的 HorizontalContentAlignment/TextAlignment 为 Left、VerticalContentAlignment 为 Top，浏览摘要也置顶。测试检查实际 TextPresenter 的顶部坐标，不只检查属性值。
+- 输入只更新单元格文字，捕获一次来源基线；不逐字调用作者写入，也不逐字通知全项目刷新。首次待提交状态仍通知保存/dirty 状态，同时抑制这次通知引起的自身表格重建。
+- 失焦或 Ctrl+Enter 提交一次当前文本，Save All 收拢未提交输入；空串、错误重试、来源失效保护保留。提交期间再输入的内容等待后续提交，不自动接着逐字写入。Escape 放弃未提交输入；若上一笔提交尚在进行，仅取消后续输入，保留已送出的值。
+
+## 验证
+
+进行中。原错位复现日志：`artifacts-localization-alignment-repro.log`。第一次定向 33/34 通过，失败定位到上一笔失焦提交未结束时立即重新输入并按 Escape 的边界；已补上对当前已送出值的保留和输入框同步，继续复验。首次测试编译缺少 Avalonia 坐标扩展 using，已补齐。
+
+## 最终结果
+
+- 完整 Editor 回归 **295/295 通过**，未排除用例；日志 `artifacts-localization-blur-editor.log`，TRX `test/GalNet.Editor.Tests/TestResults/localization-blur-editor.trx`。覆盖新隐藏列坐标回归、逐字输入无写入/无逐字项目刷新、失焦/Ctrl+Enter/Save All、输入法组合态、异步提交后再输入、Escape、空串与来源冲突。
+- `dotnet build GalNet.slnx --no-restore -c Release -m:1` **0 错误、256 警告**，包含平台目标；日志 `artifacts-localization-blur-solution.log`。构建在测试结束后顺序进行，未重现并行复制 DLL 锁冲突；未把现有 CA/nullable/XAML 警告描述为无警告构建。
+- 五个受影响 C# 文件的只读 whitespace 与 IDE0005/style 检查通过，`git diff --check` 通过。style 指出的视图 using 顺序已修正，不混入其他模块格式化。
+- TextChanging 在渲染前同步捕获单元格本地输入，避免 TextChanged 的异步渲染时机让立即 Save All 或 Escape 读到旧值；真实挂载测试在赋值后不等待渲染直接 Save All，检查保存内容与焦点，已通过。
+- 正式 spec/manual、feature summary 与 agent 上下文已更新。记录两条可复用经验：显式窄表左边界、同步捕获本地待提交输入。原生 IME 窗口和真实系统 DPI 保留桌面人工验收边界。
+
+本轮不恢复常驻草稿/复核 UI，不修改作者格式或 Runtime。已有的角色诊断相关改动与四语资源修改保留，未纳入本轮提交。
diff --git a/features/F-20261023-01-editor-uiux/phase-localization-20261025.md b/features/F-20261023-01-editor-uiux/phase-localization-20261025.md
new file mode 100644
index 00000000..5fbbcf52
--- /dev/null
+++ b/features/F-20261023-01-editor-uiux/phase-localization-20261025.md
@@ -0,0 +1,35 @@
+# 本地化资源表精简与直接更新
+
+状态：verified（自动验证）。用户已批准后续分析，并明确要求“直接更新，写什么更新什么”。本记录取代分析中的草稿提交/复核提示交互，其他作者格式和项目保存边界不变。
+
+## 本阶段范围
+
+- 正常单元格输入直接更新 Working，删除草稿/复核筛选与常驻状态文字；保留缺译提示和失败输入恢复。磁盘通过 Save All 发布，不按键写盘。
+- 串行处理连续输入，组字期间不提交候选；项目撤销恢复已提交内容，不用 Escape 回滚已更新值。
+- 单行工具栏、语言管理列表、搜索候选（排除已添加语言）、移除及开发语言保护；移除只修改支持列表，保留翻译文件，可一次撤销。
+- 不透明统一表格背景；结构化双行定位列与居中按钮；紧凑浏览和活动单元格编辑；语言列可见性和宽度属于会话视图状态。
+- 导入语言放在导入入口内，语言调序集中在管理器；已有历史执行时的身份/来源校验继续保留。
+
+## 验证计划
+
+覆盖连续输入/空串/撤销/Save All、历史阻塞时的新输入及来源失效、语言移除/恢复/旧写入口拒绝、候选排重、隐藏列缺译筛选，以及真实挂载的输入/组字/滚动/弹层/图标边界。更新对应旧交互测试、正式 spec/manual，构建与相关回归通过后提交本阶段。
+
+## 实现与验证结果
+
+- 常规编辑已移除草稿/复核状态、筛选和放弃全部草稿入口。输入直接更新 Working，连续输入等待写入期间保持可编辑并保留最新值；清空为显式空串。内部来源证据与项目历史保护继续工作，错误可修复后重试或就地重新读取。Save All 等待更新后统一写盘。
+- 单行工具栏与紧凑单元格；活动格展开多行，普通格两行摘要。ID/槽位＋居中定位按钮使用结构化投影，共享文本可选择引用目标。表格与冻结定位列使用同一不透明背景，表头删除上下文标签。
+- 语言管理提供已有语言、可见性、调序、按需开发语言检查、输入候选与明确新增、移除。使用本项目 Avalonia/Semi 的 AutoCompleteBox 显式双向绑定，搜索代码/本地名称/英文名称；非已选 CultureInfo 候选供选择。替换语言图标，真实挂载检查 16×16 边界并保留截图。移除只改支持列表，不删翻译文件，可项目撤销；列宽拖动与列可见性保存在当前项目会话。
+- 新增 5 项行为/挂载测试，并修订旧草稿交互测试。`dotnet test test/GalNet.Editor.Tests/GalNet.Editor.Tests.csproj --no-restore -c Release -m:1 -p:RunAnalyzers=false` 最终 **293/293 通过**，包括导入导出、历史/保存、连续输入、无效 JSON 修复后原输入重试、语言移除恢复、候选真实展开、指针新增、列宽拖动、组字保护及窄屏冻结列。日志 `artifacts-localization-editor-verified.log`，TRX `test/GalNet.Editor.Tests/TestResults/localization-editor-verified.trx`。
+- `dotnet build GalNet.slnx --no-restore -c Release -m:1` **0 错误、96 警告**，含 Android/Browser 目标；日志 `artifacts-localization-solution-verified.log`。警告含现有 nullable、XAML 和 CA 建议，未声称无警告。
+- 本轮六个 C# 文件只读 whitespace 检查通过，`git diff --check` 通过；四语 JSON 各 1034 keys，键集合相同。截图在忽略目录 `artifacts/localization-ui/`（含 `localization-manager.png`、宽窄表格等）。正式 spec/manual 与 feature summary 已同步。
+
+## 发现与修正
+
+1. 首轮定向 19/22 通过：定位按钮测试误把新增错误恢复按钮也算入，改用明确定位名称；模拟 Button.Click 路由事件不会代替真实新增命令点击，改用弹层指针点击；组字测试只设置 PreeditText，不把直接赋 Text（会清除 preedit）当作输入法候选。修正后 22/22 通过。
+2. 首轮全量 291/292 通过：无 UI 的异步测试在自动写入结束前切分类并读 Rows；等待该写入结束后再核验失败输入及视图。最终全量 293/293 通过。没有隐藏或排除测试。
+3. 同时执行 solution build 与 testhost 导致 Windows DLL 被锁，构建复制失败；顺序重跑后解决方案通过。沙箱内 testhost/format 的命名管道访问失败，使用本机权限运行验证。一次自动审批因额度不足未执行，用户要求继续后重试成功。
+4. 浏览摘要和活动编辑共用单元格模型，复用行对象避免每次直接更新重建活动输入框；来源变化或语种移除仍在历史执行边界检查，不用取消保护换取即时更新。
+
+## 验证边界
+
+真实系统 DPI、原生 IME 候选窗口仍需桌面人工验收。长文本在活动单元格内展开，未新增独立编辑弹层；没有另加表格式方向键浏览模式或跨视图滚动位置记忆。当前支持 TextBox 键盘编辑与 Tab 导航，保留行虚拟化。本阶段不改变 Runtime 或作者文件格式，其他任务的角色诊断/图片变体改动不纳入本提交。
diff --git a/features/F-20261023-01-editor-uiux/phase-plan.md b/features/F-20261023-01-editor-uiux/phase-plan.md
index 116d5d5d..45fa7b3b 100644
--- a/features/F-20261023-01-editor-uiux/phase-plan.md
+++ b/features/F-20261023-01-editor-uiux/phase-plan.md
@@ -22,7 +22,7 @@
 | Primitives.Builtins | 175 通过 | `artifacts-uiux-recheck-GalNet.Primitives.Builtins.Tests.log` |
 | SchemaGenerator | 18 通过 | `artifacts-uiux-recheck-GalNet.SchemaGenerator.Tests.log` |
 
-`scripts/test-contract-reproducibility.ps1 -Configuration Release` 通过：两次不同 SourceRevisionId 的 Sample 契约 SHA-256 同为 `9B97CA52F84880E640C7DAD5012C9DB9667C7887FD47959FDB1A07F1FF2CE535`。Editor 默认契约输出与打包目录 DLL 指纹一致。
+`scripts/contracts/test-contract-reproducibility.ps1 -Configuration Release` 通过：两次不同 SourceRevisionId 的 Sample 契约 SHA-256 同为 `9B97CA52F84880E640C7DAD5012C9DB9667C7887FD47959FDB1A07F1FF2CE535`。Editor 默认契约输出与打包目录 DLL 指纹一致。
 
 `dotnet build GalNet.slnx --no-restore -c Release -m:1` 在本机 IPC 权限下通过，0 错误、14 个 NU1900 审计连接警告（`artifacts-uiux-solution-elevated.log`）。首次沙箱运行的 Android/Browser MSBuild 任务宿主连接失败；同一命令在本机构建权限下成功，未为绕过错误修改平台构建配置。
 
@@ -41,3 +41,7 @@
 实际挂载 1200×800、960×640 和模拟 150% 缩放，并检查实际字段尺寸、透明按钮、资源/Graph/Timeline 控件。稳定截图位于忽略的 `artifacts/uiux/uiux-*.png`。截图捕获临时取消实例过渡以获得稳定端点；颜色中间值由独立过渡测试验证，不用稳定截图替代动画验证。
 
 真实系统 DPI、原生 IME 候选窗口及完整桌面人工操作仍待人工验收。GUI 检查同步捕获当前版本，没有异步旧结果发布窗口。对象/列表草稿使用保守根来源签名，相关根值变化需要解决冲突。正式 spec/manual 已同步，详见 summary。
+
+本地化页后续精简及直接更新已自动验证，最终 Editor 293/293 通过、解决方案 0 错误；范围及人工验收边界见 [实施记录](phase-localization-20261025.md)。
+
+本地化实测修正：表头/内容明确左对齐、正文左上对齐、输入改为失焦/Ctrl+Enter/Save All 提交。完整 Editor 295/295 通过，详见 [交互修正记录](follow-up-localization-20261025.md)。
diff --git a/features/F-20261023-01-editor-uiux/phase-ui-20261025.md b/features/F-20261023-01-editor-uiux/phase-ui-20261025.md
new file mode 100644
index 00000000..f98df013
--- /dev/null
+++ b/features/F-20261023-01-editor-uiux/phase-ui-20261025.md
@@ -0,0 +1,38 @@
+# 第二轮 UI 优化实施
+
+用户于 2026-10-25 确认实施 [分析方案](analysis-20261025.md)。保留开工前工作区的资源变体等改动，不纳入本轮提交。
+
+| Phase | 状态 | 验收 |
+| --- | --- | --- |
+| U1 变量与主输入行 | verified（定向自动验证） | 分作用域 UID 选择、按 UID 草稿、关闭重开、冲突及删除保护；正常/缺译/条件错误时实际输入框中线一致 |
+| U2 Inspector 与角色 | verified（定向自动验证） | 最后独立预览区、窄面板、图标工具栏、角色草稿/搜索连续性及共享姓名身份隔离 |
+| U3 本地化 | verified（定向自动验证） | 工具栏/按需配置、搜索与状态筛选、固定列头/上下文、虚拟化与实际导出弹层 |
+| U4 验证与文档 | verified（自动验证；套件分批） | 282+1 项回归及新增交错用例、最终 13 项定向复验、解决方案构建、四语与格式检查通过；单次全套的 Headless 释放异常保留记录 |
+
+本轮选择列表标题条右上角“＋”，不覆盖列表项，因此不增加不必要的指针路由拦截。变量状态通过项目级数据服务保存，视图与 transient ViewModel 仍正常释放。跨重启保存 UI 状态不在范围。
+
+## 实现与修订
+
+- GameTextBox 内容横向伸展，单行输入最小 32、文字居中；分支主输入、拖动柄和删除按钮使用相同主行，提示和错误向下增长。
+- 变量与角色分别使用项目级纯数据状态服务；不缓存控件，不修改作者格式或保存语义。角色身份使用 ID+姓名文本组合；共享姓名不能推断成同一角色。
+- 角色异步应用只清理其提交的草稿快照；等待历史队列时切到另一角色、关闭重开后编辑，以及保留独立新建草稿均有交错回归。完成回调不抢回其他选择，应用/还原已有角色不放弃新建草稿。
+- 变量新增仍立即创建声明，工具栏固定在详情顶部，窄 Dock 下也能直接应用。类型输入适配仅接受当前类型控件回写，避免隐藏数字/布尔输入改变字符串草稿，空文本规范化为空字符串。
+- AssetInspector 属性与预览拆分，ImageVariantsEditor 仅编辑配置/JSON，ImageVariantsPreview 使用同一模型展示预览，无额外加载器或播放器。
+- 本地化保持单套虚拟化行；上下文与表头共享横向位移补偿，不复制第二套列表。键盘聚焦单元格后将其显示到固定上下文旁，避免输入框藏在固定区域下。分类窄屏降为下拉框。搜索/目标语言状态筛选不改变单元格身份，导入应用期间仍禁用目标语言切换。
+
+## 验证过程
+
+- 第一批定向 11 项通过：`artifacts-uiux-round2-verify.log`。
+- 截图后补充固定变量操作栏、无输入时的干净状态、共享姓名角色保护；重点 6 项通过：`artifacts-uiux-round2-refine.log`。
+- 挂载截图：`artifacts/uiux-round2/`，含角色窄面板、变量宽/窄、本地化宽/窄与横向滚动、Inspector 底部预览。测试使用透明 2×2 图片夹具验证资源已加载，截图不用于证明大图质量。
+- 早期失焦测试仍指向现已收进弹层的新增语言框，已改为可见搜索框。首轮完整回归中导出测试误选了 ComboBox 模板内部按钮；已限定命名按钮并通过 finally 关闭弹层，真实点击/文件回读回归通过。该次运行被中止，不能作为完整套件结果。
+- 单次完整套件随后在 `EntryMultiDragPreservesOrderFoldingAndOneHistoryStep` 的 `Avalonia.Headless.HeadlessUnitTestSession.DisposeAsync` 抛出空引用，未得到成功完整统计。该方法未在本轮修改；这与历史记录中的 Headless 释放异常同类，但没有证据将本次根因定性为某个业务模块。运行中断后，独立重跑该用例通过 1 项（`artifacts-uiux-round2-drag-isolated.log`），其余全体用例通过 282 项（`artifacts-uiux-round2-suite.log`、`test/GalNet.Editor.Tests/TestResults/uiux-round2-suite.trx`）。本轮共 283 项分批通过，不声称单次全套全绿；没有删除测试或修改框架释放代码来消除失败。
+- 最终源码完成解决方案 Release 构建（包含 Android/Browser）：0 错误、260 个警告，包含分析器提示和 NU1900 审计连接警告，见 `artifacts-uiux-round2-solution.log`。随后最终 12 项定向回归通过，包括冻结列键盘定位、变量干净状态/类型切换、草稿和导出弹层（`artifacts-uiux-round2-final-targeted.log`）。
+- 追加异步角色草稿保护后，13 项定向复验通过（`artifacts-uiux-round2-last-targeted.log`）；最后补充还原已有角色不清除新建草稿的断言，完整最终产物再次 13 项通过（`artifacts-uiux-round2-committed-targeted.log`）。新增交错用例额外计 1 项，合计 284 个不同用例分批验证。最终解决方案构建仍为 0 错误、260 个警告，见 `artifacts-uiux-round2-last-build.log`。
+- 本轮 18 个 C# 文件的空白与 IDE0005 只读格式检查均 exit 0，见 `artifacts-uiux-round2-verify-format.log`、`artifacts-uiux-round2-verify-style.log`；最终 `git diff --check` 通过。四语 JSON 无重复 key、各 1026 key 一致；文档相对链接有效。
+- 最后两次角色保护修订后，18 个 C# 文件的空白只读检查再次通过（`artifacts-uiux-round2-committed-format.log`），没有新增引用。
+- 七个新增回归位于 `AuthoringUiContinuityTests.cs`。既有本地化失焦/导出和变体挂载用例随新布局调整实际操作入口，未放松作者状态、历史或落盘断言。
+
+## 保留边界
+
+真实系统 DPI、原生输入法和原生文件对话框仍需人工验收。语言列宽拖动、按需隐藏语言列、图片棋盘底色与原尺寸窗口属于后续增强；本轮没有增加视频播放器或跨应用重启保存草稿。
diff --git a/features/F-20261023-01-editor-uiux/summary.md b/features/F-20261023-01-editor-uiux/summary.md
index 094077ab..0218b1cb 100644
--- a/features/F-20261023-01-editor-uiux/summary.md
+++ b/features/F-20261023-01-editor-uiux/summary.md
@@ -39,6 +39,8 @@ Core、Presentation、Editor.Shared、Editor、Architecture、Primitives.Builtin
 
 ## 正式文档
 
+第二轮面板优化（2026-10-25）已实现变量分作用域选择和项目会话草稿、正文主输入行对齐、Inspector 底部独立预览、角色图标工具栏与身份安全的草稿保留，以及本地化搜索/状态筛选、语言与导出弹层、固定上下文和列头、窄面板布局。完整实施、验证结果与保留边界见 [第二轮实施](phase-ui-20261025.md)；原始候选方案保留在 [分析](analysis-20261025.md)。本轮不修改作者格式、项目保存语义或 Runtime。
+
 - [共享表单契约](../../docs/spec/control.md)
 - [Group 与 Inspector](../../docs/spec/editor-groups.md)
 - [历史、草稿与保存](../../docs/spec/editor-history-and-save.md)
@@ -46,3 +48,9 @@ Core、Presentation、Editor.Shared、Editor、Architecture、Primitives.Builtin
 - [Graph 导航](../../docs/spec/editor-graph.md)
 - [资源操作](../../docs/spec/editor-files.md)
 - [使用及 DTO 扩展手册](../../docs/manual/editor-authoring-workspace.md)
+
+本地化页后续按用户反馈进一步精简：单行工具栏、紧凑资源表、结构化双行定位列、统一不透明背景、语言搜索/已有语言管理/移除及列宽与可见性。输入直接更新 Working，取消草稿/复核 UI，Save All 仍负责写盘；失败输入就地保留，成功更新通过项目撤销恢复。实现与验证边界见 [本地化精简实施](phase-localization-20261025.md)，当前规范及操作见 [本地化规范](../../docs/spec/editor-game-localization.md) 和 [使用手册](../../docs/manual/game-localization.md)。
+
+后续实测修正：输入改为失焦/Ctrl+Enter/Save All 提交，输入期间不逐字更新项目；正文和摘要左上对齐。表头明确靠左，修复隐藏语言后表格变窄时居中导致的列错位。验证见 [交互修正记录](follow-up-localization-20261025.md)。
+
+2026-10-27 Group 后续完成：正常待提交输入不计条目问题，完整作者检查自动刷新；提示使用本地化字段名及修正建议，可跳转正文按稳定身份定位到 Entry/字段及能唯一识别的子字段。普通数字默认保留文字的上下调整框，支持显式 NumericUpDown、Slider + 精确输入及无损文本路径，浮点简写与 Save All 共用解析。解决方案构建和 1,246 项相关回归通过，最后子字段标签补充另有 16 项聚焦通过；5 项既有媒体/显式预览未执行。模块、取舍、验证中修正和范围边界见 [本轮记录](follow-up-group-diagnostics-numeric-20261027.md)。
diff --git a/features/F-20261025-01-cpu-startup-benchmark/design.md b/features/F-20261025-01-cpu-startup-benchmark/design.md
new file mode 100644
index 00000000..25c0ad47
--- /dev/null
+++ b/features/F-20261025-01-cpu-startup-benchmark/design.md
@@ -0,0 +1,15 @@
+# 设计
+
+`Benchmark=true` 在 Directory.Build.props 定义 BENCHMARK；宿主通过条件 ProjectReference 接入 GalNet.Diagnostics。普通宿主无该程序集依赖；所有埋点以 #if BENCHMARK 围住，避免 no-op scope 与参数求值开销。诊断项目本身的实现也只在该符号下编译。
+
+独立程序集避免向 Core 引入文件系统或影响契约编译闭包。CpuProfiler.Shared 是全局入口，也允许独立实例用于测试/自定义捕获。Stopwatch 单调时钟，完成区间 X 与瞬时 i 事件；Dispose 幂等、并发安全，有限容量并显式记录丢弃数。异步区间标在起始线程，度量 inclusive wall time（含 await），不是 CPU 占用率；重叠异步区间不暗示线程执行栈。
+
+StartupBenchmark 读取显式输出路径，在 Main 开始总区间，在 UI 准备完成后导出并可自动退出。计时不包含 CLR 进入 Main 前、JSON 导出或退出清理。Editor 的 ready 定义为欢迎页 Loaded 后的 Background dispatcher 回调；Sample 为会话初始化返回成功、CompleteStartup 后的回调，不等价于 GPU 首帧完成。
+
+脚本先构建，再串行运行预热和测量进程，预热不计入分位数；保留 trace、日志、逐次数据、构建时长、配置和源码状态，失败/超时不作为成功样本。仅关闭或终止脚本拥有的子进程；不修改当前 PowerShell 的环境。Sample 内容构建与语言初始化准备独立于启动测量。
+
+验证调整：条件引用切换时复用普通 assets/deps 曾导致运行时找不到 Diagnostics；采用各项目 bin/benchmark 与 obj/benchmark（含独立 restore lock），默认契约 Content 同步选择该输出路径。未改动普通构建路径。
+
+P3 扩展：Benchmark 实现可显式镜像阶段事件到 GalNet-CPU EventSource，供 EventPipe 将阶段与运行时 JIT/采样栈对齐；默认关闭，采样数据仅用于诊断。发布实验确认收益后提供 WindowsReadyToRun 配置，使用独立 bin/obj/lock，排除契约入口与 Core/Contracts.Builtins 的 R2R 转换以保留严格字节身份。保留 IL、反射和现有渲染配置；不引入裁剪或单文件发布。
+
+P4 扩展：同一 EventSource 通过 ETW 对齐原生 CPU 栈。Editor 正常 Main 启动两个数据准备 Task，完成后才将设置和本地化数据交给 UI/DI；文化切换与控件不后台化，设计器保持同步回退，失败退出仍观察任务。不建设通用调度系统，也不修改 Sample 的初始化策略。图形后端探测未达到收益门槛，保持原配置。
diff --git a/features/F-20261025-01-cpu-startup-benchmark/experiments.md b/features/F-20261025-01-cpu-startup-benchmark/experiments.md
new file mode 100644
index 00000000..802e44e9
--- /dev/null
+++ b/features/F-20261025-01-cpu-startup-benchmark/experiments.md
@@ -0,0 +1,48 @@
+# Editor 启动优化实验
+
+状态：verified。用户授权每个有效优化单独提交，无效说明并按需回退。
+
+先将已验证 CPU 系统提交为 49e2713，再细化日志/框架配置/窗口/欢迎页里程碑。保持 Startup.Ready 定义不变。
+
+方法：Release，固定 A/B 程序快照；项目自身程序集复制，未变化的第三方依赖共享文件数据；每个版本先运行一次预热，然后 10 组配对，AB/BA 交替顺序。保存每次 trace、源码状态与程序集 SHA256。每项只改变一个因素；实验期间不并行编译或执行重负载测试。
+
+保留标准：中位数改善约 5% 以上，多数配对改善，P95 无明显回退，并通过相关行为验证。边缘结果增加反向对照；无效代码恢复到本轮实验前版本，仅保留结果记录。
+
+候选：1. 主窗口显示前准备欢迎页；2. 首屏延迟工作区相关主题（同时验证首次打开工作区）；3. Acrylic 窗口效果 A/B。先测后决定，不预设结果。
+
+P2 退出条件：每项有测量与处置结论；有效改动具备独立提交和验证证据；无效实验不残留产品代码。
+
+## 实验 1：显示窗口前准备欢迎页 — verified，保留
+
+基线 A 在 MainWindow.Loaded 后导航；候选 B 在构造完成时导航。Startup.Ready 仍为欢迎页 Loaded 后的 Background 回调。
+
+第一次 10 对：A median 1769.28ms，B 1721.87ms（2.7%），7/10 更快，收益不够明确，因此增加反向顺序验证。第二轮交换标签运行 10 对：实际 A median 2026.29ms，实际 B 1936.94ms（4.4%）。
+
+合并 20 对：A median 1938.59ms，B 1834.01ms，改善 5.39%；14/20 配对更快，配对差值中位数 134.91ms。以 seed=25 对配对差值中位数 bootstrap 20,000 次，描述性 95% 区间约 [5.22, 191.78]ms；这是本机探索性估计，不是通用性能保证。两轮方向一致，符合约 5% 的预设门槛；保留。合并 nearest-rank P95 从 2321.63ms 降至 2124.10ms。
+
+证据目录：artifacts/benchmarks/experiment-early-welcome、experiment-early-welcome-confirm；合并统计 early-welcome-combined.json。构建之间的源码哈希比对确认仅 MainWindow.axaml.cs 发生预期变化。两版程序集快照不同，第三方依赖保持相同。
+
+行为验证：Release 下新增的 2 个首屏/首次显示导航用例与既有真实视图主题用例全部通过（3/3），证据 artifacts-benchmark-startup-behavior-release.log。Debug 尝试因用户运行中的 Editor 锁定输出而失败，保留用户进程后改用 Release 验证。
+
+## 实验 2：首屏不加载 Dock/ColorPicker 主题 — rejected，已回退
+
+这是仅用于测量潜在收益的理想化探测，不是可交付的延迟加载实现；候选只暂时移除两个主题，基线均保留实验 1 的提前导航。
+
+10 对：A median 1907.65ms，B 1845.32ms，改善 3.27%；7/10 更快，配对差值中位数 62.05ms，描述性 bootstrap 95% 区间约 [-80.94, 273.50]ms。XAML 阶段中位数 452.78 → 384.67ms，但总启动收益不足预设门槛，且不确定范围覆盖零；完整延迟实现还需处理首次工作区加载成本及浮动 Dock/ColorPicker 样式生命周期，故不继续引入复杂度。
+
+证据：artifacts/benchmarks/experiment-theme-probe。App.axaml 已逐字节恢复，产品不保留缺失主题或延迟主题的代码；无需为被拒绝方案扩大实现范围。
+
+## 实验 3：关闭 Acrylic 并改为不透明背景 — rejected，已回退
+
+基线保留实验 1 的提前导航和完整主题；候选仅将主窗口 AcrylicBlur/透明背景换为 None/主题不透明背景。
+
+10 对：A median 1473.09ms，B 1477.35ms，候选约慢 0.29%；P95 1588.47 → 1559.65ms。总启动未显示收益，不为此改变窗口外观。证据：artifacts/benchmarks/experiment-acrylic，详细配对统计在 assessment.json。
+
+MainWindow.axaml 已逐字节恢复。三轮比较处于不同缓存/机器负载状态，不能跨轮把绝对毫秒数串成优化趋势；只比较同轮交错 A/B。
+
+## 处置
+
+- 49e2713：已验证的 CPU benchmark 系统独立提交。
+- 828bf9f：追加启动里程碑、固定 exe/SHA256 和 AB/BA 比较脚本。
+- 4bb1dbc：唯一保留的产品优化，首屏显示前准备欢迎页。
+- 主题与 Acrylic 探测均不保留产品改动；最终恢复后的构建/启动再验证结果见 summary.md。
diff --git a/features/F-20261025-01-cpu-startup-benchmark/feature.md b/features/F-20261025-01-cpu-startup-benchmark/feature.md
new file mode 100644
index 00000000..f393a0aa
--- /dev/null
+++ b/features/F-20261025-01-cpu-startup-benchmark/feature.md
@@ -0,0 +1,16 @@
+# CPU 启动 benchmark
+
+状态：verified，quick 通道。用户授权：先实现 CPU 事件计时、Benchmark 编译开关及自动化启动测试；Editor 与 Sample 共用。
+
+目标：区分构建、程序初始化和各启动阶段，形成可重复的优化基线。
+范围：独立诊断程序集；手工方法内埋点；有界线程安全事件；Chrome Trace JSON；启动完成自动退出；重复运行和统计脚本。
+非目标：GPU timestamp/query、PIX 注入、自动 IL 编织、BenchmarkDotNet 微基准、此次直接优化启动。
+验收：启用与禁用构建均通过；区间/瞬时事件和并发/容量测试通过；Editor 自动运行生成有效 trace 与统计；Sample 接入编译并尽可能实测。
+
+设计见 design.md；验证计划见 phase-plan.md；最终证据见 summary.md。
+
+P2 后续优化已完成三项对照实验；仅保留显示窗口前准备欢迎页，其他探测恢复原状。处置、提交和证据见 experiments.md。
+
+P3 已完成调用栈诊断及契约安全的 ReadyToRun 发布对照，Editor/Sample 各 10 对全部更快。保留显式发布配置和通用诊断脚本，见 runtime-profile.md；普通 Debug 启动方式不变。
+
+P4 已完成原生图形诊断与简单并行实验；保留 Editor 两个数据准备任务，WGL 探测回退，见 parallel-native.md。原生诊断脚本在 Editor/Sample 共用，未引入通用依赖调度系统。
diff --git a/features/F-20261025-01-cpu-startup-benchmark/parallel-native.md b/features/F-20261025-01-cpu-startup-benchmark/parallel-native.md
new file mode 100644
index 00000000..70fdc503
--- /dev/null
+++ b/features/F-20261025-01-cpu-startup-benchmark/parallel-native.md
@@ -0,0 +1,54 @@
+# P4 原生图形 profile 与简单并行准备
+
+状态：verified。2026-10-25，用户授权两三个并行任务即可，不建立依赖图/调度系统；图形初始化自行 profile 并按收益决定保留或回退。
+
+## 保留：两个数据准备任务
+
+Editor 的 Main 在启动 Avalonia 前创建 EditorStartupPreparation，仅包含两个 Task.Run：读取 EditorSettingsService 设置，以及读取/解析嵌入本地化资源。框架初始化完成时等待任务，向 DI 提交同一设置实例及准备好的资源；CultureService 构造、Current 发布、文化切换、主题应用、导航和控件仍在 UI 线程执行。
+
+参数为空的设计器入口及默认 App 保留同步回退。设置服务不与消费者并发访问；准备任务完成后才发布，主程序退出时观察两个任务（包括平台初始化提前失败路径）。没有通用调度器或长期后台线程。新增 Benchmark 阶段 PrepareSettings、PrepareLocalization、WaitStartupPreparation；Ready 定义不变。
+
+两版均为同源范围的 Release/win-x64/framework-dependent R2R 固定发布，基线 Temp/r2r-experiment/r2r，候选 Temp/p4/parallel；测量关闭 WPR/EventPipe，先各预热一次，再 AB/BA 交错。
+
+| 轮次 | 对数 | 基线 Median | 候选 Median | 基线 P95 | 候选 P95 | 说明 |
+| --- | ---: | ---: | ---: | ---: | ---: | --- |
+| 初轮 | 10 | 1007.99ms | 926.88ms | 2225.96ms | 1041.57ms | 基线有明显异常，不能仅凭此轮宣称约 8% 收益 |
+| 独立确认 | 20 | 900.11ms | 862.88ms | 949.41ms | 921.10ms | 16/20 对更快，中位数降低 4.1% |
+
+确认轮配对差值中位数 59.78ms；固定 seed=25、10,000 次 bootstrap 的配对中位数 95% 区间 [10.63, 78.41]ms。两个版本的边际中位数之差不等于配对差值中位数。证据：artifacts/benchmarks/p4-parallel、p4-parallel-confirm（comparison.csv、summary.csv、assessment.json、逐次 trace/日志/SHA256）。
+
+确认轮候选的后台准备阶段中位数：设置 43.95ms、本地化 24.84ms；UI 等待中位数 0.11ms（最大 0.19ms），UI 设置/文化/主题应用中位数 1.62ms。准备工作与图形/XAML 启动重叠；这些区间存在并行，不能相加。收益是本机预热缓存新进程的 Main→ready，不外推系统冷缓存、GPU 首帧或其他机器，也不与 P3 跨轮绝对时间叠加计算。
+
+## 原生诊断
+
+最初 GeneralProfile 录制约 2 GiB，WPR 报告丢失 61,372 个事件，明确拒绝用它推断细分时间。改用 scripts/performance/startup-native.wprp：只采进程/模块、原生 CPU 栈和 GalNet-CPU 阶段，不采上下文切换、文件/磁盘事件。
+
+profile-startup-native.ps1 在 WPR 明确空闲时启动自己的录制和子进程，就绪后正常关闭、停止/合并 trace；无法识别状态或已有录制会拒绝。Editor 与 Sample 都实测成功，退出码 0；分析器对缺 Ready、丢事件直接失败。原生分析按 OS 线程 ID 对齐，Sample 无 RunAvalonia 时使用 Ready 回退。可选下载微软系统符号，第三方驱动多数仍是模块/地址。采样计数不是精确耗时，没有采集线程等待或 GPU 首帧。
+
+两份有效 Editor trace（事件丢失均 0）：
+
+| Capture | RunAvalonia→XAML wall | UI CPU 样本 | 包含 D3D11CreateDevice | 包含 ImageGetCertificateDataEx |
+| --- | ---: | ---: | ---: | ---: |
+| native-editor-02，原 R2R 基线 | 455.17ms | 383 | 238 | 92 |
+| native-editor-03，两个准备任务 | 297.55ms | 280 | 182 | 74 |
+
+上表用于定位，不用于比较性能：采样干扰与机器状态不同。典型链路为 D3D11CreateDevice → DXGI CUMDAdapter/OpenAdapter10_2 → nvldumdx → CryptQueryObject → CryptSIPGetSignedDataMsg → ImageGetCertificateDataEx → FindCertificate / RabinKarpFindPatternInBuffer。说明本机图形启动的一部分 CPU 工作落在 NVIDIA 驱动加载期间的系统证书读取/检查；不能把所有设备创建耗时归因于证书，也不能外推到其他驱动。
+
+没有证据显示应用重复创建设备；暂不修改 Avalonia 生命周期，不关闭系统校验或任意指定显卡。诊断工具独立提交 e54b147；复现方式见 docs/manual/cpu-benchmark.md。Editor 第二次、Sample 与 WGL 验证文件位于 artifacts/benchmarks/native-*；原始大文件被 Git 忽略。
+
+## 拒绝：WGL 后端探测
+
+仅在实验输出中将优先级改为 Wgl、AngleEgl、Software，其他设置/并行准备完全相同；发布到 Temp/p4/wgl 后立即从逐字节快照恢复 Program.cs。与默认 ANGLE 的固定 Temp/p4/parallel 进行 10 对比较：中位数 917.14→905.68ms，但只有 4/10 对更快，配对差值中位数 -6.52ms，bootstrap 区间 [-35.38, 58.02]ms 跨零。P95 1185.76→1024.29ms 也不足以证明稳定收益。
+
+未达到收益门槛，不保留图形后端切换；也未以这项启动探测替代视频/特效/透明窗口和持续渲染兼容性验证。
+
+额外 native-wgl-01 trace（EventsLost=0）确认没有悄悄回退：前置间隔 254 个样本中，184 个包含 opengl32、189 个包含 nvoglv64，D3D11 帧为 0；OpenGL 后端确实进入 NVIDIA OpenGL 驱动，仍未形成稳定启动收益。源码恢复后的最终产物继续使用默认 ANGLE。
+
+## 验证
+
+- Release Editor 相关测试 7/7：新增后台准备不发布全局本地化、不改调用线程文化，保存 locale 正确消费与缺 key 回退；原本四语资源/本地化、两项首屏导航和真实视图主题回归。日志 artifacts-benchmark-p4-tests.log。
+- 普通 WindowsReadyToRun/Benchmark=false 发布成功，deps 无 Diagnostics；实际窗口进入空闲后正常关闭，退出码 0。Core/Builtins/DefaultContracts 的发布字节与同模式编译输入一致，默认契约实际加载 45 项。日志 artifacts-benchmark-p4-normal-publish.log、normal-smoke.log；输出 Temp/p4/normal。
+- 默认 ANGLE 源码恢复后，最终 Benchmark 发布和真实启动/导出/退出 smoke 成功：Temp/p4/final、artifacts/benchmarks/p4-final-smoke。单次 945.03ms 仅验证链路，不并入收益统计。
+- 原生采集脚本在 Editor/Sample 实测成功，分析器在两者均成功且 EventsLost=0；PowerShell 语法、git diff --check 通过。没有终止用户已有 Editor。只运行相关测试，不声称全仓测试通过。
+
+当前保留的产品改动仅为两个 Editor 数据准备任务；Sample 本轮只验证了诊断工具复用，未修改其初始化策略。图形后端仍保持 ANGLE/D3D11；后续若要继续改善，需要针对具体驱动/设备创建证据选择实验。
diff --git a/features/F-20261025-01-cpu-startup-benchmark/phase-plan.md b/features/F-20261025-01-cpu-startup-benchmark/phase-plan.md
new file mode 100644
index 00000000..03e69b24
--- /dev/null
+++ b/features/F-20261025-01-cpu-startup-benchmark/phase-plan.md
@@ -0,0 +1,25 @@
+# Phase plan
+
+## P1 — verified
+
+实现事件采集、编译开关、Editor/Sample 埋点和脚本；验证事件序列、Dispose 幂等、跨 await、容量上限、禁用后类型不存在；构建两个宿主；运行 Editor 重复启动基线。退出条件：实际证据记录在 summary.md，限制明确。
+
+退出证据：4 项启用模式测试、1 项禁用模式测试、49 项架构检查通过；两个宿主的普通与 Benchmark Release 均构建通过，普通 deps 无诊断引用；Editor 和 Sample 自动采集、最终 smoke 和失败路径均验证，见 summary.md。
+
+## P2 — verified
+
+用户授权按 experiments.md 逐项测量、验证和独立提交；不改变 ready 口径，不提交其他 UI feature 改动。
+
+三项实验完成：提前准备欢迎页在 20 对交错测试中改善约 5.4%，相关 3 个行为/主题测试通过，独立提交 4bb1dbc；主题探测及 Acrylic 探测均未达到门槛并逐字节恢复。恢复后的最终 Benchmark 构建与真实进程启动成功，记录见 experiments.md、summary.md。
+
+## P3 — verified
+
+用户授权继续采集启动调用栈，并在 JIT 占比明显时测试 ReadyToRun。增加 Benchmark 专用、显式启用的 EventPipe 事件镜像，用 dotnet-trace 将阶段与 JIT/采样栈对齐；普通构建无实现。采样只用于诊断，不参与优化收益统计。若进行 R2R，对比相同 RID、部署形式和源代码的普通 publish 与 R2R publish，保持契约程序集字节身份；以固定快照交错测量并验证后决定提交或拒绝。
+
+退出证据：三次基线调用栈确认大量启动 JIT；Editor/Sample 各 10 对固定发布快照全部改善，中位数分别降低 41.6%/31.6%。保留 WindowsReadyToRun 发布配置，并隔离 RID 还原图；契约闭包排除转换且逐字节验证。启用/禁用诊断测试 5/5、1/1，Editor 相关回归 3/3；两个普通发布真实启动并正常退出、无诊断依赖，Editor 实际加载 45 个契约条目。详细数据与限制见 runtime-profile.md。
+
+## P4 — verified
+
+用户授权原生图形初始化 profile/优化，以及简单的两三个并行准备任务；不建设通用依赖图或调度系统。先以 WPR 原生 trace 定位 ANGLE/D3D11 边界；逐项实验、固定快照交错比较，有效才保留并提交。并行仅涉及无 UI 副作用的准备工作，文化/主题应用和控件创建仍在 UI 线程；异常、退出与契约身份不变。图形实验不以牺牲首帧/功能或持续渲染表现换取启动数值。
+
+退出证据：原生采集/分析工具在 Editor/Sample 成功；两份无丢事件 trace 定位 D3D11CreateDevice 与 NVIDIA 驱动中的系统证书读取路径。Editor 两个后台数据准备任务经独立 20 对确认中位数改善 4.1%，16/20 胜出；相关测试 7/7、普通发布真实启动退出/契约字节及实际加载通过。WGL 探测收益不成立，源码逐字节恢复且默认后端最终发布 smoke 成功。详细证据与限制见 parallel-native.md。
diff --git a/features/F-20261025-01-cpu-startup-benchmark/runtime-profile.md b/features/F-20261025-01-cpu-startup-benchmark/runtime-profile.md
new file mode 100644
index 00000000..4242d3c5
--- /dev/null
+++ b/features/F-20261025-01-cpu-startup-benchmark/runtime-profile.md
@@ -0,0 +1,54 @@
+# P3 启动调用栈与 ReadyToRun 实验
+
+状态：verified。用户授权：继续启动调用栈分析；JIT 明显时测试 R2R；有效且验证通过独立提交，否则拒绝并回退。
+
+使用 dotnet-trace 10.0.750501（安装在 Temp/dotnet-tools），采集 Runtime 0x1C（JIT/Loader/AssemblyLoader）、SampleProfiler 与显式启用的 GalNet-CPU。普通构建不编译此镜像；常规 Benchmark 默认不触发 EventSource。三份 trace 均为诊断数据，不参与性能收益对照。
+
+TraceEvent 3.1.21 离线读取并配对 MethodJittingStarted / MethodLoad 事件，按 UI 线程裁切阶段、计算区间并集；以 Editor.RunAvalonia 瞬时事件对齐 JSON 时间轴与 EventPipe 时间轴。统计为 wall-clock 区间，不是精确 JIT CPU 占用，不能与采样计数直接相加。
+
+| Capture | Total wall / JIT union | XAML wall / JIT union | RunAvalonia→XAML wall / JIT union |
+| --- | --- | --- | --- |
+| 01 | 1629.6 / 979.7 ms | 374.6 / 297.6 ms | 419.8 / 104.4 ms |
+| 02 | 1606.3 / 996.7 ms | 384.8 / 306.7 ms | 367.3 / 97.1 ms |
+| 03 | 1651.6 / 1033.6 ms | 406.9 / 323.5 ms | 364.5 / 99.6 ms |
+
+每份主线程已配对 JIT 方法 13,428 个，没有未配对起点。XAML 阶段初次生成的样式填充方法与类型初始化明显；前置框架间隔还大量采样于 Avalonia.Win32.OpenGl.Angle.AngleWin32EglDisplay.CreateD3D11Display（首份该区域 221 个样本中有 122 个叶帧归属此方法）。EventPipe 没有完整 Windows 原生栈，故只能定位到托管调用边界，不能进一步断言是驱动、硬件还是某个原生子函数。
+
+结论：JIT 在整个启动中占比明显，值得进行 R2R 对照。保持当前 GPU 后端与外观，不通过切软件渲染改变性能目标。
+
+R2R 方法：两版均 Release、win-x64、framework-dependent，同一源代码、同一 Benchmark 开关，仅 PublishReadyToRun 不同。排除 Core、Contracts.Builtins 和固定入口 Contracts，避免转换改写严格二进制身份；发布后检查哈希与 PE native header，并在不启用 EventPipe 时交错比较固定输出。baseline/candidate 位于 Temp/r2r-experiment/il 与 r2r。
+
+原始证据：artifacts/benchmarks/runtime-profile-01、02、03。分析源码：scripts/performance/analyze-startup-trace.cs；复现方式见 docs/manual/cpu-benchmark.md。
+
+## 同轮交错对照
+
+2026-10-25，两版各预热一次，再进行 AB/BA 交错 10 对，无 EventPipe 采样；ready 口径未变。Sample 使用 GameTestCase/Output 与已完成语言选择的 Temp/cpu-benchmark-profile。
+
+| 宿主 | IL Median | R2R Median | 改善 | IL P95 | R2R P95 | 胜出 |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| Editor | 1446.65ms | 845.37ms | 41.6% | 1487.32ms | 940.01ms | 10/10 |
+| Sample | 2214.57ms | 1515.76ms | 31.6% | 2255.08ms | 2060.09ms | 10/10 |
+
+配对差值中位数分别 600.03ms、708.81ms；对配对差值 bootstrap（固定 seed=25，10,000 次）中位数 95% 区间分别 [572.85, 629.01]ms、[642.83, 735.84]ms。样本仍仅为本机预热缓存的新进程启动，不是系统冷启动；不与 P1/P2 跨轮绝对时间比较。
+
+Editor 未压缩发布体积 421.29→452.27 MiB，增加 30.98 MiB；Sample 416.12→439.60 MiB，增加 23.47 MiB。未量化工作集或发布耗时，发布转换本身增加构建工作。
+
+固定输出：Temp/r2r-experiment/il、r2r；Temp/r2r-sample/il、r2r。证据：artifacts/benchmarks/r2r-editor/paired 与 r2r-sample/paired 的 comparison.csv、summary.csv、各次 trace/metadata；identity.json 保留程序集身份检查。原始大文件被 Git 忽略，本报告保留方法和统计。
+
+## 发布配置与完整性
+
+提供 Editor/Sample 的 WindowsReadyToRun.pubxml：Release、win-x64、framework-dependent、不裁剪、不合并单文件。普通命名配置隔离到 bin/publish/WindowsReadyToRun、obj/publish/WindowsReadyToRun（含 lock），避免向普通 packages.lock.json 写入 RID 目标；Benchmark=true 仍走 benchmark 输出。Editor DefaultContracts Content 随模式选择正确的 class library 产物路径。
+
+R2R 会改写程序集；Directory.Build.targets 明确排除 Core、Contracts.Builtins、GalNet.Project.Contracts。实验发布与最终普通发布均检查：被排除 DLL 的 native header 为空、SHA256 与对应编译输入一致；Editor/Sample 主程序集具有 R2R native header。Editor 实际 LoadContractsDirectory 成功返回 45 个定义，未放宽匹配逻辑。
+
+## 验证与诊断复查
+
+- Diagnostics 启用测试 5/5；禁用测试 1/1，包含 CpuTraceEvents 不存在检查。
+- Editor 首次显示/预先导航及真实视图主题回归 3/3；日志 artifacts-benchmark-r2r-regression.log。
+- Editor/Sample 最终普通发布成功，deps 无 Diagnostics；真实进程分别等到窗口可用、Session initialized. 后正常关闭，退出码均 0。日志 artifacts-benchmark-normal-profile.stdout.log、artifacts-benchmark-sample-normal-smoke.log。没有终止用户的 Editor。
+- Editor 最终普通发布契约实际加载通过；Core/Builtins 与默认契约输入逐字节一致。Sample 根契约与同模式源产物一致。
+- profile-startup.ps1 实际采集基线与两宿主 R2R；analyze-startup-trace.cs 均成功，丢失事件 0、未配对 JIT 起点 0。PowerShell 脚本语法、git diff --check 通过。本轮仅运行相关测试，不声称全仓测试通过。
+
+R2R Editor 诊断 trace：Total wall/JIT union 929.0/239.0ms，UI JIT 2,857 个；XAML 130.7/28.8ms。R2R Sample：1497.7/289.7ms，UI JIT 3,411 个。这些单次带采样时间不参与上表收益统计。证据在两个 r2r-*/runtime-profile 目录。
+
+后续最大的可见线索仍是 ANGLE/D3D11 初始化的托管边界；当前证据不足以断言原生细分原因，暂不切换 GPU 后端。使用发布配置才能获得本轮收益，普通 Debug/dotnet run 不会自动加速；操作见 docs/manual/ready-to-run.md。
diff --git a/features/F-20261025-01-cpu-startup-benchmark/summary.md b/features/F-20261025-01-cpu-startup-benchmark/summary.md
new file mode 100644
index 00000000..d003b606
--- /dev/null
+++ b/features/F-20261025-01-cpu-startup-benchmark/summary.md
@@ -0,0 +1,83 @@
+# CPU 启动 benchmark — 实现总结
+
+P1 已完成 quick 通道的 CPU 事件采集与自动化基线；P1 交付时未进行启动性能优化。后续 P2 优化实验见 experiments.md。
+
+## 实现
+
+- 独立 GalNet.Diagnostics：CpuProfiler.Shared、作用域 Measure、瞬时 Mark、Stop/Snapshot/WriteTrace，有界线程安全缓冲和 Chrome Trace JSON。计时为 CPU 侧 wall time，可跨 await，包含等待；没有 GPU 时间戳。
+- Benchmark=true 定义 BENCHMARK；所有宿主埋点显式条件编译。普通宿主不引用 Diagnostics。Benchmark 输出、obj 和 restore lock 与普通构建隔离；默认契约内容使用同模式产物。
+- Editor 接入 Main、XAML、服务注册/校验、设置/语言/主题、主窗口、欢迎页创建/导航；Sample 接入相同框架阶段及会话初始化。
+- scripts/performance/benchmark-startup.ps1：单独构建、预热、重复启动、自动完成退出，保存 trace/日志、逐次 CSV、Median/P95 和环境/源码元数据。失败、超时、缺失 Ready、事件溢出不计入成功结果。
+
+当前规范：[CPU 性能事件](../../docs/spec/cpu-benchmark.md)。操作与方法内埋点：[测量 CPU 启动](../../docs/manual/cpu-benchmark.md)。
+
+## 验证
+
+2026-10-25，当前 Windows 工作区：
+
+- `dotnet test test/GalNet.Diagnostics.Tests/GalNet.Diagnostics.Tests.csproj -p:Benchmark=true -p:UseSharedCompilation=false -m:1 -nr:false`：4/4，包括嵌套/瞬时事件 JSON、跨线程幂等 Dispose、容量/停止、启动导出/单次完成。
+- 同项目 Benchmark=false：1/1，诊断实现类型不存在。
+- GalNet.Architecture.Tests：49/49，新诊断项目无内层依赖。
+- Editor/Sample 的 Benchmark Release 和普通 Release 均构建成功；普通宿主 deps.json 无 GalNet.Diagnostics。
+- Editor 最终采集 smoke 成功：artifacts/benchmarks/editor-final-smoke。
+- Sample 最终采集 smoke 成功：artifacts/benchmarks/sample-final-smoke。
+- 使用空游戏内容的 Sample 失败检查：artifacts/benchmarks/sample-failure-final；进程退出码 1，trace 有 Startup.Failed，无成功摘要。
+- PowerShell 脚本语法解析及 git diff --check 通过。
+
+VSTest 在 sandbox 内无法连接 testhost，实际通过记录来自允许本地进程通信的运行环境。构建中有既有分析器/XAML 警告，以及 NuGet audit 服务暂不可达的 NU1900；无编译错误。
+
+## 本轮测量
+
+Release；每目标 1 次预热，预热排除；Sample 使用预先构建的 GameTestCase/Output，并复制玩家变量到 Temp/cpu-benchmark-profile，未改动原玩家档案。数值单位 ms。
+
+| 阶段 | 样本 | Median | P95 |
+| --- | ---: | ---: | ---: |
+| Editor Startup.Total | 5 | 2068.31 | 2318.66 |
+| Editor.Xaml | 5 | 498.96 | 564.03 |
+| Editor.CreateMainWindow | 5 | 251.19 | 290.84 |
+| Editor.BuildServiceProvider | 5 | 20.66 | 25.09 |
+| Sample Startup.Total | 3 | 3691.36 | 5336.43 |
+| Sample.FrameworkInitialization | 3 | 1122.13 | 1235.86 |
+| Sample.InitializeSession | 3 | 799.74 | 1521.31 |
+
+完整证据：artifacts/benchmarks/editor-isolated 与 artifacts/benchmarks/sample-baseline，包含各 run trace、measurements.csv、summary.csv、metadata.json 和 build.log。结果目录被 Git 忽略；本表保留便于追溯的样本统计。最终修正失败退出码后各宿主又完成一次成功 smoke；该 smoke 不并入以上统计。
+
+本轮仅验证采集链路并提供初始数据，工作区还有另一项 UI feature 的改动。样本少且 Sample 变化明显，不能据此建立稳定回归阈值。Startup.Total 从 Main 到宿主 ready，不包含 CLR 进入 Main 前、trace 输出、退出清理，也不代表 GPU 首帧完成。阶段存在嵌套，不能求和。已测 Editor DI 校验约 21ms，不是主要已测阶段；框架与调度之间仍有未细分时间。
+
+## 验证中修正与限制
+
+- 条件 ProjectReference 与普通 restore 图混用，曾造成编译成功但运行缺少 Diagnostics；隔离 bin/obj/lock 后实际启动通过。见 .agents/lessons/L-20261025-02-benchmark-restore-graph.md。
+- Avalonia lifetime 可覆盖提前设置的 Environment.ExitCode；宿主在 lifetime 返回后的 finally 根据保留的 Failed 状态重申失败码。最终失败集成检查证实为 1，脚本还同时检查 Ready。见 L-20261025-03-avalonia-benchmark-exitcode.md。
+- 事件时间戳允许同一时钟刻度；测试按事件名验证协议，不依赖相同时间戳事件的数组顺序。
+- Startup 自动捕获每进程一次，完成后停止 Shared。需要进一步运行时采集时可不使用启动自动输出、由调用方导出 Shared，或使用独立 CpuProfiler 实例。
+- 当前自动脚本针对 Windows 桌面宿主；Sample 需预构建内容和完成语言选择的测试 profile。CI locked restore 的首次隔离锁准备见手册。GPU、自动方法织入和性能优化未列入本次范围。
+
+## P2 持续优化
+
+三项实验均已结束，ready 定义未变。完整结果见 [experiments.md](experiments.md)。
+
+| 实验 | 同轮基线 Median | 候选 Median | 处置 |
+| --- | ---: | ---: | --- |
+| 窗口显示前准备欢迎页，20 对 | 1938.59ms | 1834.01ms | 改善约 5.4%，保留并提交 4bb1dbc |
+| 暂停首屏加载 Dock/ColorPicker，10 对 | 1907.65ms | 1845.32ms | 约 3.3%，波动覆盖零，未达到门槛；回退 |
+| 关闭 Acrylic，10 对 | 1473.09ms | 1477.35ms | 无总启动收益；回退 |
+
+第一项 14/20 配对更快，P95 2321.63 → 2124.10ms。新增首次显示/预先导航的 2 个行为用例与既有真实视图主题用例通过，共 3/3；Debug 输出被正在运行的用户 Editor 锁定后，使用 Release 验证且保留该进程。比较工具及额外里程碑另行提交 828bf9f。
+
+两个被拒绝探测的 XAML 已按实验前快照逐字节恢复，git diff 确认无产品代码残留。恢复后 Benchmark Release 再构建成功（0 errors），真实启动/导出/自动退出 smoke 成功：artifacts/benchmarks/optimization-final-restored-smoke。本次只运行相关检查，不声称全仓测试通过。
+
+同一个固定提前首页快照在不同轮次的基线可从约 1908ms 变化到 1473ms，说明缓存与机器负载影响明显；只能使用各轮固定二进制的交错 A/B 判断收益。最终 smoke 不是额外的优化幅度证据。
+
+## P3 调用栈与 ReadyToRun
+
+已完成，完整方法和证据见 [runtime-profile.md](runtime-profile.md)。增加显式启用的 Benchmark EventPipe 镜像、运行时采集/离线分析脚本，并将交错比较扩展到 Sample。三次调用栈发现大量启动 JIT，随后保持相同源代码/RID/部署形式进行无采样对照，各 10 对全部更快：Editor Median 1446.65→845.37ms（41.6%），Sample 2214.57→1515.76ms（31.6%）。
+
+保留两个宿主的 WindowsReadyToRun 发布配置，隔离 RID 还原图，排除严格契约闭包的转换并验证字节身份；不裁剪、不改变渲染或匹配规则。代价为 Editor/Sample 未压缩目录约增加 31.0/23.5 MiB。收益限于发布程序；Main→ready、预热缓存的新进程测试不代表冷缓存、GPU 首帧或普通 Debug。
+
+启用/禁用诊断测试 5/5、1/1，Editor 相关回归 3/3，两个普通发布的真实启动/正常退出与无诊断依赖通过，Editor 发布契约实际加载 45 项。手册已同步 CPU 调用栈和 ReadyToRun 操作；未运行全仓测试或测量工作集。
+
+## P4 原生诊断与并行准备
+
+已完成，见 [parallel-native.md](parallel-native.md)。保留两个简单 Task.Run：设置读取、本地化数据准备，与框架/图形初始化重叠；UI 线程应用文化/主题和构造视图。独立 20 对确认中位数 900.11→862.88ms（4.1%），16/20 对更快，相关测试 7/7、普通发布真实启动/退出及契约验证通过。
+
+增加 Editor/Sample 共用的 WPR 原生采集与离线分析。两份无丢事件 trace 定位到 D3D11CreateDevice、NVIDIA 驱动及系统证书读取路径；样本计数不是耗时比例。WGL 探测仅 4/10 对更快、配对差值区间跨零，已拒绝并恢复默认 ANGLE/D3D11。Sample 未修改初始化策略；没有通用调度系统，也没有绕过驱动/系统校验。
diff --git a/features/F-20261025-02-external-project-authoring/design.md b/features/F-20261025-02-external-project-authoring/design.md
new file mode 100644
index 00000000..7ab7c03a
--- /dev/null
+++ b/features/F-20261025-02-external-project-authoring/design.md
@@ -0,0 +1,31 @@
+# 设计
+
+## 当前事实
+
+CLI 已有机器帮助、契约查询、原始查询、校验及文档批次；文件操作只允许单条，不能与文档操作混批。Editor 使用 ProjectContentSession 管理工作版/保存基线，Repository 另持作者源字节基线。GUI 历史操作可能持有 DTO/文件身份，不能直接重载磁盘后继续执行旧历史。
+
+## 数据流与职责
+
+外部 Agent → CLI 查询/生成/预览/发布 → 项目磁盘 → Editor 文件监听与定期复核 → 后台候选快照 → 会话门内采纳 → 既有文档/资源通知 → 打开视图刷新。
+
+1. Shared 负责候选读取与验证，以及在项目会话中更新保存基线。读取先后核对文件集合/哈希，拒绝正在变化的候选；使用 Authoring 校验，不因合法的未知/不完整作者参数而拒绝刷新。
+2. Editor 的项目级监听器合并通知、有限重试，并在 UI 线程采纳候选。自己的保存以基线哈希去重；发布中的事务不读取。周期复核弥补监听事件合并/遗漏。
+3. 自动采纳仅发生于会话干净、无输入草稿、无编辑/保存执行、无 RepairRequired 时。冲突保留内存和磁盘双方，不自动写盘。明确的“从磁盘重新加载”在确认后放弃本地作者修改，不关闭项目或 Dock。
+4. 采纳保持项目 scope 和已有 Group 文档身份；按稳定节点/Entry 身份同步视图。保存基线、settings 原始字节、Repository 的源基线及受管理文本一起推进。源节点被删时关闭对应 Group 页，其他页面和布局保留。
+5. 采纳是旧历史的边界：释放 Undo/Redo 后再允许编辑；刷新本身不制造 AI 专属 Undo。Git restore/revert 造成的磁盘变化走同一热重载路径。
+
+## 外部批次
+
+CLI 的事务 publication manifest 是外部写入边界。Editor 在存在 prepared/publishing/repair-required 事务时推迟采纳，不靠固定延迟猜测批次完成。任意程序的普通文件保存通过稳定哈希快照处理；没有提交协议的多个保存不能声称来自同一个原子事务。
+
+批量应用采用明确的项目变更清单，给新建作者文件和资源提供同一个发布入口。清单中的写入/删除必须有期望原哈希，新增文件要求原先不存在。预览和正式执行都校验最终候选项目，正式执行复核原文件及输入载荷后通过既有作者事务发布。大资源从暂存文件复制，不把图片/音频嵌入 JSON。
+
+## Skill 与 Git
+
+Skill 说明“发现 CLI → 查询项目/契约 → 检查已有修改 → 生成预览 → 应用 → 校验 → 展示 diff”。CLI 帮助是参数真相来源，不在 Skill 复制所有指令。项目 Git 是可选的版本控制；回退已有成功变更需要 Git 或用户备份，CLI 的失败补偿不宣称持久 Undo。
+
+## 取舍与边界
+
+首版保守地在项目存在本地未保存内容时暂停自动采纳，不实现自动三方合并。它保留本地历史和草稿，常见“保存 Editor → 外部 Agent 改项目 → 自动刷新”的路径直接可用。契约 DLL 的 scope 重建涉及平台实现和预览生命周期，本阶段显式提示而不沿用变化后的 DLL。普通作者内容和资源热重载不重启 Editor。
+
+验证重点是候选读取/采纳交错、自己的保存不误刷新、草稿/坏 JSON 保留、结构创建删除与已开 Group 同步、采纳后 Save All 不再报旧基线冲突，以及 Git 恢复文件后可再次采纳。
diff --git a/features/F-20261025-02-external-project-authoring/feature.md b/features/F-20261025-02-external-project-authoring/feature.md
new file mode 100644
index 00000000..7ab705f0
--- /dev/null
+++ b/features/F-20261025-02-external-project-authoring/feature.md
@@ -0,0 +1,33 @@
+# 外部项目创作与 Editor 热重载
+
+状态：implemented；验证证据见 [实现总结](summary.md)。
+
+## 目标
+
+用户通过 Codex、Claude 等外部工具及项目创作 Skill 使用 GalNet CLI：纯文本剧本转 Raw Group、给既有对白补演出、导入立绘/差分并关联剧情。Editor 保持打开，识别任意来源的项目文件变化并刷新；成功变更的跨会话回退使用 Git。
+
+用户已授权：整理设计，确认技术上可行后开始实现。本记录承接本次对话，不引入模型提供商或 MCP 依赖。
+
+## 范围与验收
+
+- CLI 对外提供可发现、结构化、可预览的项目修改能力，复用当前契约与事务。
+- 普通作者文件和已打开文本发生外部变化时，无需关闭项目即可采纳；文档/资源索引和打开视图一起更新。
+- 文件尚未写完、损坏、发生本地编辑冲突时，不覆盖当前内容；显示原因并允许重试。
+- 采纳外部版本建立新的保存基线并清除旧 Undo/Redo，Git 负责回退外部修改。
+- 外部 CLI 的批量发布不能让 Editor 采纳其中间状态。
+- 提供可交付给外部 AI 工具的项目创作 Skill、Git 工作流程及三类创作示例。
+- 已有本地化改动保留；功能只依赖 Editor 层，不进入 Core/Runtime。
+
+## 设计决策
+
+- 首版以项目会话为冲突单位：有已应用未保存内容或未提交输入时，自动采纳暂停。这样可以保留本地 Undo 与草稿，避免为局部自动合并增加一套版本合并机制。
+- 用户可明确放弃当前作者修改并从磁盘刷新；执行前保留作者恢复材料。未应用的角色/变量面板输入沿用既有来源冲突规则。
+- Contracts DLL 变化单独报告，需重建契约 scope；普通内容热重载不替换正在使用的契约。
+- 文件监听只提供变化提示；哈希核对、候选结构校验和发布门内复核决定能否采纳。
+
+## 文档
+
+- [设计](design.md)
+- [阶段计划](phase-plan.md)
+- [实现总结](summary.md)
+- 当前基础：[历史与保存](../../docs/spec/editor-history-and-save.md)、[文件操作](../../docs/spec/editor-files.md)、[CLI](../../src/Editor/GalNet.Editor.Headless/README.md)。
diff --git a/features/F-20261025-02-external-project-authoring/phase-plan.md b/features/F-20261025-02-external-project-authoring/phase-plan.md
new file mode 100644
index 00000000..61f0f758
--- /dev/null
+++ b/features/F-20261025-02-external-project-authoring/phase-plan.md
@@ -0,0 +1,31 @@
+# 阶段计划
+
+## P1：通用外部内容热重载 — verified
+
+依赖：现有项目会话、文档服务与历史。
+
+任务：候选快照/源哈希核对；会话安全采纳；项目级监听/周期复核；外部冲突与显式重新加载入口；四语状态反馈；Group/Graph/settings/本地化/受管理文本刷新；CLI 已有事务边界识别。
+
+退出：干净项目外部修改自动反映在当前打开页面；坏文件和本地草稿不丢失；创建/删除/改名可刷新；旧历史清除；关闭/保存交错不复活旧 scope；相关回归与构建通过。
+
+证据：Shared 回归 417 项、热重载/批次最终定向 19 项通过；Editor 相关最终 36 项通过，包含 5 项本次新增场景与项目 schema 生命周期回归，最后的文件面板/资源通知 4 项通过。实际 Headless 窗口中的文件监听、结构插入后的选中条目/行号、文本编码与二进制变化、组字保护及继续保存已验证。Editor 隔离输出构建通过，保留 4 项既有 Nullable/XAML 警告。
+
+## P2：CLI 批量应用 — verified
+
+依赖：现有作者事务与校验；P1 识别事务边界。
+
+任务：可发现的变更清单应用入口；作者文档与资源同批；期望哈希与载荷检查；dry-run 及结构化报告；完整候选校验；原子发布/失败补偿。
+
+退出：单次批次可创建 Group 并导入资源、修改引用；预览无项目写入；过期来源拒绝；中间状态不被 P1 采纳；实际 CLI 验证通过。
+
+证据：原生场景经真实 CLI dry-run/apply，包含角色、开发语言对白、等待演出及图片/sidecar；Group 定向 dry-run 编译通过。来源哈希、目标哈希、资源配对、静态删除引用和第二个文件发布失败补偿均有通过用例；CLI 自带 Skill 文件已在输出目录验证。
+
+## P3：Agent 创作入口与文档 — verified
+
+依赖：P1/P2 已验证行为。
+
+任务：官方创作 Skill；CLI 获取/调用说明；Git diff/回退与无 Git 边界；文本转 Group、补演出、资源导入示例；同步已实现 spec/manual；实现总结。
+
+退出：按文档从外部工具发现 CLI 并完成代表性创作流程；文档清楚描述契约变化和本地冲突边界，不宣称未实现功能。
+
+证据：Skill quick_validate.py 通过；机器帮助的 manifest schema 与真实 CLI 原生场景流程通过；spec/manual/CLI 说明及实现总结已同步。未调用真实外部 AI 服务，不宣称图像或剧情生成质量已验收。
diff --git a/features/F-20261025-02-external-project-authoring/review.md b/features/F-20261025-02-external-project-authoring/review.md
new file mode 100644
index 00000000..2984e9bd
--- /dev/null
+++ b/features/F-20261025-02-external-project-authoring/review.md
@@ -0,0 +1,11 @@
+# 实现自审
+
+结论：pass-with-follow-up。本记录是实现后的自审，不宣称独立 agent 审核。
+
+审阅范围：目标/设计/阶段记录、CLI 路由和 manifest 校验、候选磁盘读取、项目保存基线、历史捕获门/发布门顺序、输入草稿、打开 Group/文本页面、资源刷新与项目 scope 关闭。
+
+已核对的关键边界：源文件/载荷过期拒绝；新增目标不存在条件；批次中途发布失败补偿；外部坏 JSON 不改变活文档；自动采纳不覆盖本地编辑；显式放弃不跳过输入法/异步输入；取消草稿后当前字段仍能继续提交；自己的保存不清空历史；外部删除/恢复 Group 不遗留旧投影；外部采纳后继续保存不会使用旧 Repository/settings/文本基线。
+
+审阅中修正：引用查询正常返回的 `references.partial` warning 不能以诊断数量判断为错误；文本编码变化应重新判断可编辑性；内容会话初始化失败应释放已创建 scope；资源通知也必须等待外部文件事务结束。
+
+验证证据见 [summary](summary.md)。后续事项：大型项目性能、原生 IME 人工验收、可选契约 scope 无关闭重建，以及需要时的更细粒度冲突合并。它们不属于当前普通内容热重载已实现路径。
diff --git a/features/F-20261025-02-external-project-authoring/summary.md b/features/F-20261025-02-external-project-authoring/summary.md
new file mode 100644
index 00000000..dd509455
--- /dev/null
+++ b/features/F-20261025-02-external-project-authoring/summary.md
@@ -0,0 +1,37 @@
+# 实现总结
+
+## 已实现
+
+- 新增 `project apply`：版本化 manifest、原/新文件 SHA-256、dry-run、完整候选校验、资源/sidecar 配对、删除后的静态 JSON 引用保护，以及同一作者事务中的多文件发布/补偿。结果明确 `referencesComplete=false`，不宣称覆盖自定义代码或媒体解码。
+- 新增通用外部内容同步：后台读取稳定候选，等待外部事务完成，在同一项目 scope 中更新 Graph、Group、settings、本地化和受管理文本；文件监听配合周期复核，不依赖修改源是 AI。
+- 无本地未保存内容/输入时自动采纳。有本地冲突时保留内容，提供重新检查和明确放弃后的重新加载；坏 JSON/不安全结构保留旧会话。资源刷新与文件面板也等待外部事务。
+- 保留已有 Group、节点和相同 Entry 身份，结构插入后更新行号并保持选择；采纳推进全部保存基线并清除旧 Undo/Redo。自己的保存不会成为外部历史边界。
+- 待提交输入可取消；组字/异步输入未能取消时继续阻止加载。已打开文本支持外部编码变化，变为二进制时只读且保留真实字节，恢复文本后可继续编辑。
+- CLI 携带 `Skills/galnet-project-authoring`，包含查询/生成/应用/Git 工作方式及文本转 Group、补演出、导入立绘与差分的说明；不绑定模型提供商。
+
+## 设计取舍与限制
+
+- 以整个项目判断本地冲突；当前没有自动三方合并或“只合并无冲突字段”的第二套状态机制。
+- 外部采纳是历史边界，成功外部修改的长期回退依赖 Git 或用户备份。CLI 事务只负责失败补偿，不提供持久 Undo。
+- 契约 DLL 变化要求重新打开项目。已启动的游戏预览不自动重演；普通作者内容及资源刷新不关闭项目。
+- 任意外部工具未提供提交协议时，多个文件保存无法被推断为原子批次；CLI 使用事务 manifest 提供明确的发布边界。中断事务保留恢复材料，不自动覆盖未知外部内容。
+- 大项目扫描/长媒体导入性能和原生 IME 人工验收未执行。候选验证不复制既有媒体负载，也不解码新媒体。
+
+## 验证
+
+- Shared 全回归 417 项通过；最终原生场景/批次与热重载定向 19 项通过。
+- Editor 相关回归初轮 30 项通过，包括实际挂载 Group 的文件监听、结构插入后的选择/行号保留、设置/文本草稿保护、明确放弃后的继续编辑，以及历史和四语资源。
+- 最终 Editor 相关 36 项通过，新增外部资源事务通知与项目 schema 生命周期覆盖；二进制/文本来回切换保持真实字节并恢复可编辑性。最后一次仅调整文件面板异常捕获位置，重新构建后文件面板/资源通知 4 项通过。最后修正 CLI 文字帮助的 manifest 标签，Headless 构建与机器/文字帮助实际调用通过。
+- 实际 CLI 使用项目 DefaultContracts 预览/应用带角色、开发语言对白、等待演出及图片/metadata 的场景，并成功定向编译。没有调用真实外部模型或图像生成服务，不把该证据描述为生成质量验收。
+- Shared/Headless 构建通过；Editor 使用独立 `artifacts/external-authoring/` 输出验证，未关闭用户进程。首轮普通输出构建遇到运行中进程的 DLL 锁定，之后采用隔离输出。
+- Skill 的 `quick_validate.py` 通过。沙箱中的 testhost 连接超时后，测试在允许本机测试进程通信的环境中通过。
+
+TRX 位于 `artifacts/external-authoring/{shared-results,editor-results,final-results}/`。仓库原有其他本地化改动保留，未提交或重置用户工作区。
+
+## 正式文档
+
+- [使用手册](../../docs/manual/external-project-authoring.md)
+- [历史与保存](../../docs/spec/editor-history-and-save.md#外部内容热重载)
+- [文件操作](../../docs/spec/editor-files.md)
+- [CLI](../../src/Editor/GalNet.Editor.Headless/README.md)
+- [产品创作 Skill](../../skills/galnet-project-authoring/SKILL.md)
diff --git a/features/F-20261026-01-engine-core-simplification/design.md b/features/F-20261026-01-engine-core-simplification/design.md
new file mode 100644
index 00000000..3f8ce087
--- /dev/null
+++ b/features/F-20261026-01-engine-core-simplification/design.md
@@ -0,0 +1,149 @@
+# 后续架构提案：缩小内核，分离默认领域与项目策略
+
+状态：completed，R1–R8 verified；当前实现与最终验收见 phase-plan.md / summary.md。用户已确认“轨道与分组均可自定义、支持两个层级的控制、设置模型归高层、内部接收简单配置、Sample 保留三个默认分组”的方向，并授权按整体计划开始实施；具体拆分仍依实际消费者收敛。上一轮 P6 的适用环境项已在 R8 复核，原始失败和调整依据保留在 summary.md。
+
+依据：2026-10-26 用户提出 Core 中的游戏设置、固定音频分类和 Core/Runtime 领域分布需要重新审视；用户允许破坏性调整，以功能、低耦合、精简和职责清晰为先。本文记录设计与取舍，实施和验收进度以 phase-plan.md 为准。
+
+## 问题判断
+
+上轮解决了执行正确性、重复数据和一部分接口边界，但没有完成“可替换默认玩法”的架构收敛。当前 Core 同时承担扩展协议、默认视觉/音频领域、项目配置和玩家偏好；Runtime 同时承担通用执行机制与可选音频/Gallery 实现。无 UI 依赖不等于职责归属正确。
+
+Core 与 Runtime 同时出现同一领域本身合理：供契约、模块、工具共同使用的模型/协议在内层，运行实现放外层。判断标准是消费者和依赖方向，而不是类型名中是否含 Runtime，也不是只有接口才能进 Core。
+
+## 设计评估时的证据（R1 实施前）
+
+| 当前代码 | 问题与影响 |
+| --- | --- |
+| `Core/Settings/GameSettings.cs` | sealed 类型混合自动/快速推进、文本速度、四套音量/静音及全屏。Engine、音频和默认宿主读取同一具体模型；用户 DTO 不能直接替代。 |
+| `Core/Settings/ProjectSettings.cs` | 语言、存档槽、窗口大小、轨道、变量声明混合。`Runtime.Content.GameContent.Settings`、文件加载器和 Editor document 都绑定它。单纯把文件迁出 Core 不能解决端到端绑定。 |
+| `Core/Settings/SettingsContainer.cs` | `Get<T>()` 读取即构造、写入默认值，要求继承与无参构造；同 key 不同类型会被静默替换。它不是已完成的自定义设置扩展协议。 |
+| `Core/Audio/AudioTrackDefinition.cs`、`Runtime/Audio/AudioRuntime.cs` | track ID 可自定义，但 bus 被 `AudioBuses.IsValid` 限为 bgm/sfx/vocal；增益 switch 直接读取 GameSettings 固定字段。轨道默认集合、中文名称和默认增益也在 Core。 |
+| `Core/Settings/SaveSettings.cs`、`ProjectSettings.SfxChannelCount` | 生产代码搜索未发现 SaveSettings 的实际消费者；SfxChannelCount 仍被编辑/复制，但音频并发采用每轨 MaxVoices。这是可删除的旧表示候选，不应再围绕它们设计扩展。 |
+| `Core/Runtime/GameState.cs`、`Core/Runtime/IGameContext.cs` | 通用状态表内维护 ISceneInstance 索引，执行上下文强制提供场景管理器；纯逻辑项目也携带默认视觉领域。 |
+| `Runtime/Runtime/SceneInstanceManager.cs` | 已是持久表的派生查询加临时控制对象，不是第二份持久状态；迁移时不能重新引入状态镜像。 |
+| `Presentation.Abstractions/Execution/IPrimitiveDispatcher.cs` | 签名只使用 Core 类型，却归展示程序集，导致 Runtime 为执行端口依赖整个展示抽象。 |
+| `Core/Runtime/IGameRuntime.cs`、`GameRestorePoint.cs` | 属于游标和恢复管理；Core 中的 primitive 创建契约只需要 IGameContext。具备下移到 Runtime 的条件。 |
+| `Core/Scene`、`Core/Audio`、`Core/Gallery` | 包含 Layer、Timeline、粒子、Shader 元数据解析、默认效果和 Gallery 规则；其中很多是可复用的默认领域，但并非通用剧情执行所必需。 |
+| `Core/Entry/EntryDefinition`、`Scene/EffectCatalog`、`Audio/SEffectCatalog` | Entry 保留多份参数投影；效果和音频效果各有参数描述与基础校验。存在进一步复用既有参数体系的空间，但领域约束不能被通用校验替代。 |
+
+## 建议的归属
+
+| 边界 | 应拥有 | 不应拥有 |
+| --- | --- | --- |
+| Core | 指令/参数/执行上下文契约、控制流模型、变量值、通用状态注册与快照数据、必要资源访问协议 | 默认窗口/音量/语言策略、固定轨道分类、具体视觉模块规则、仅供 Engine 管理的内部恢复流程 |
+| Runtime | Engine、唯一执行门、scope/取消、导航、播放调度、变量求值、恢复协调 | 全量玩家设置、必须安装的内置音频或视觉系统、默认 Gallery 解锁策略 |
+| Contracts.Builtins | 默认指令及其共用的音频/视觉数据、领域校验和纯算法 | 平台实现、项目自己的设置 DTO、默认窗口/玩家持久化路径 |
+| Primitives.Builtins | 默认领域执行、音频队列/票据、场景句柄与临时控制、内置状态注册 | 独立于 Engine 的剧情推进门禁、通用宿主会话 |
+| Presentation.Abstractions | presenter/后端端口、可复用的展示恢复协作 | 为通用执行端口承载不必要的展示依赖 |
+| GameHost / 默认 Avalonia 宿主 | 会话、持久化与平台协调；默认宿主提供可选默认接线 | 要求所有项目采用同一个玩家设置模型或 Gallery |
+| Editor / Storage / 项目组合根 | 作者文档、序列化适配、配置校验、加载/导出、自定义设置的 UI 与持久化 | 把项目的完整配置对象传给每条指令 |
+| Sample / 项目模板 | 一套完整项目设置与玩家偏好示例、默认轨道/分类、对模块的显式映射 | 重复实现 Engine、音频队列或可复用呈现逻辑 |
+
+优先复用现有 Contracts.Builtins / Primitives.Builtins，不新增一个装所有内容的 Common，也不按命名空间批量新建程序集。可选领域如果出现真实的独立消费者，再决定是否拆专门的领域包。Gallery 同样应可选，具体包装位置在迁移其消费者时确定，不强行归入 primitive 执行模块。
+
+## 设置的数据流
+
+```text
+项目自己的配置 / 玩家偏好 DTO + 自己的读取、UI、持久化
+                     |
+               组合根显式映射
+          +----------+-----------+
+          |          |           |
+   PlaybackOptions  音频配置/混音值  文本呈现选项
+          |          |           |
+        Engine    AudioModule   Presenter
+```
+
+- Engine 只消费推进真正需要的几个值；配置采用小型强类型值对象，通过显式更新入口应用。无必要时不添加 provider/interface 层。
+- 音频模块构造/更新时接收轨道定义与混音值，不从 Runtime.Settings 获取整个 ProjectSettings/GameSettings。
+- 接收的配置与高层 DTO 隔离；通过显式更新提交一个一致的配置值，而不是由引擎观察任意可变设置对象。配置模型的序列化、存储 key、变更事件和 UI 均归高层。
+- 文本速度属于文本呈现，全屏/窗口大小属于显示宿主，存档槽和缩略图属于保存服务/页面。
+- 项目 DTO 无需继承框架基类，不将 `GameEngine<TSettings>` 一直传染到所有模块，也不以 `IServiceProvider` 取代 SettingsContainer 形成新的万能入口。
+- 没有模块消费者后，删除 IGameContext.Settings。SettingsContainer/SettingsSection 若仅剩编辑器用途，则收敛到 Editor；不用为了保留 API 将其迁到新公共包。
+- `GameContent.Settings` 和 Editor document 也要改：最小内容描述保存 Engine 必需数据；默认项目文档拥有自身配置。若 Editor 要读改自定义项目 section，使用现有 schema 能力做明确的序列化/表单适配；未理解的 JSON section 必须保留。
+- 自定义配置必须贯穿打开、编辑、保存、导出、安装加载与预览。仅增加任意字典或把 DTO 改成 object，并不算支持完成。
+- 无配置的普通偏好采用中性默认值；无效作者配置在加载/提交边界诊断。不要每条指令重新进行同样的配置验证。
+
+## 音频分组与轨道（方向已确认）
+
+保留 track 的队列、并发和溢出语义，但去掉固定业务分类。
+
+- Track 和 mix group 均由开发者定义稳定 ID；分组是独立声明，不是 bgm/sfx/vocal 枚举，也不以名称推断行为。一个轨道暂归属零个或一个分组；未分组时使用中性分组值。暂不建设多重归属、总线树、路由图或复杂 mixer。
+- 混音输入为 master gain/mute，加分别按 group ID 和 track ID 索引的 gain/mute。高层可以提供分组滑块、单轨滑块、两者同时提供或完全采用自己的 UI；内部执行能力不取决于默认 UI 暴露了哪些控件。
+- 作用规则明确为：最终增益 = master × group × track × 轨道预设 gain × 播放项内容 gain，最后按后端支持范围规范化；任一层 mute 则静音。未配置/未保存的增益使用 1，mute 使用 false，轨道调节不会改写所属组或其他轨道的配置。
+- 配置加载/显式更新时校验分组与轨道 ID 的唯一性和引用关系，再一致应用；声明中的错误引用应诊断，不能把自定义分组退回 SFX。日常播放不重复执行全套配置校验。
+- BGM、SFX、Vocal、Ambience 等仅是示例声明。显示名称、本地化 key、预设增益和初始轨道集合由项目/模板提供。
+- 未来其他设置也可声明针对 track/group 的明确操作；每项能力分别定义合成/覆盖/执行规则。例如音量相乘不代表并发上限或效果链也能同样合并。当前先实现 gain/mute，不引入任意 object 参数袋，不宣称已有分组 DSP 或所有设置的统一继承系统。
+- 默认音频/语音 Composite 中的 bgm/vocal 默认值同样属于预设，需要同步检查；只移除 AudioBuses 会留下隐含依赖。
+- 更新设置仍必须作用于当前 voice 和后续 voice；恢复使用当前项目轨道与当前玩家混音，不恢复后端句柄、播放时钟或旧偏好。
+
+Sample 继续只声明音乐、音效、语音三个分组，默认设置 UI 按声明构造音量项；这套项目自有 DTO 与模块映射作为唯一完整接入示例。自定义 `ambience` 分组和同组多轨的场景通过测试证明，不为展示扩展能力给 Sample 增加第四个默认组，也不维护固定三类与自定义路径两套实现。
+
+## 通用执行与可选领域
+
+- 将 IPrimitiveDispatcher 归入 Core 的执行协议；注册/分发实现可暂留现有程序集。Runtime 不再为这个接口引用展示包。状态验证/恢复请求仍是执行生命周期能力，不要求 Engine 知道 presenter 类型。
+- 将仅供管理使用的 IGameRuntime / GameRestorePoint 下移 Runtime；保留真正被模块消费的 IGameContext 和快照契约。不要为减少重复领域名合并整个 Core/Runtime。
+- 默认 Layer/Timeline/粒子/音频等数据迁到其共享领域契约，纯采样器和静态领域校验可与该契约共置，Editor 和呈现复用同一个算法。
+- 音频运行实现在 Runtime 内的直接使用者是 BuiltinAudioModule，具备移入内置执行模块的条件；后台命令顺序、drain 和状态同步语义必须一起保留。
+- 场景句柄能力移交默认场景模块，IGameContext 不再强制 SceneInstances。通用 GameState 只管理注册表与同步，不直接维护 ISceneInstance 专用索引。
+- 场景句柄跨类型唯一性仍须由场景领域集中保证，并在读档准备阶段验证；临时播放控制不能进快照。优先由模块从唯一持久状态派生查询，不另造一份可变持久索引。确需通用索引能力时再按真实消费者抽取，不能为了搬文件先造框架。
+
+## 共享逻辑的判断
+
+建议共享：Entry 的唯一参数描述、效果/音频效果的 JSON 基础约束、Timeline sampler、同一个 Engine 内快进/回放的执行批次机制。
+
+继续分别拥有：不同领域的恢复/降级策略、音频与视觉效果的业务校验、宿主 UI 模型和运行状态、原始作者文档与已编译指令。
+
+基础参数约束优先适配现有 FieldDescriptor / ValueValidation，不增加第四套 schema。Shader 元数据仍需要解析器将其语法投影为领域/参数描述；解析器不能被通用值校验替代。
+
+## 备选与取舍
+
+- 仅搬文件：调用链继续读取同一 GameSettings/ProjectSettings，不能解决用户模型替换；不采用。
+- Core/Runtime 合并：会让自定义契约和编辑工具被迫引用执行实现/NCalc/日志依赖；不采用。
+- 只保留接口的极小 Core：纯算法与共享模型被迫散落，容易增加包装与重复；不采用。
+- 项目模型 + 小型模块输入 + 可选默认领域：需要一次破坏性迁移，但让功能边界可验证；推荐。
+
+## 实施计划
+
+完整任务、依赖、风险、验证与退出条件统一维护在 [phase-plan.md 的 R1–R8](phase-plan.md#后续整体重构)：执行协议归位→设置消费解耦→自定义音频→配置完整链路→可选领域剥离→参数体系→执行流程→集成验收。
+
+整理整体计划时，将可独立验证的执行协议调整提前，避免后续领域迁移反复改变依赖；将运行端设置解耦与作者配置完整链路拆成两个有明确出口的阶段。它们共同完成同一端到端目标，中间阶段不宣称自定义配置链路已验收。
+
+阶段可以因依赖拆成更小批次，但每批都要完成仓库调用方迁移；不保留旧设置适配器维持兼容。完整 schema/包格式变更必须明确版本，不将格式不兼容伪装成默认值回退。
+
+## 验收影响
+
+- 只用自定义 primitive 的最小运行，不需要 GameSettings/ProjectSettings、场景模块、音频、Gallery 或 Avalonia。
+- 项目自己的 DTO 可控制推进、文本速度和自定义 ambience 混音；框架无需修改固定 switch。
+- 同组两条轨道中，调整分组同时影响两者，调整单轨只影响该轨；master/group/track 静音和增益组合符合规则，更新同时影响现有和后续 voice。Sample 默认仍只有音乐、音效、语音三个分组。
+- Editor 修改已知字段后，自定义配置在保存、撤销/重做、导出、安装加载与预览中完整保留。
+- 自定义轨道的播放、静音/增益热更新、队列、恢复和旧 scope 取消继续正确。
+- 场景跨类型句柄冲突、临时实例不入档、读档候选验证、旧 scope 隔离仍有回归覆盖。
+- Runtime 不引用默认展示/领域实现；契约项目不引用 Runtime。架构测试除程序集引用外，检查内核不得重新依赖具体设置和内置视觉/音频类型。
+- 不以文件移动数量或行数下降证明架构完成；以最小自定义项目和端到端配置路径证明。
+
+R1–R8 已实施并验证，当前事实同步 docs/spec/manual；本文保留设计方向与实施取舍，最终证据及历史限制以 summary.md 为准。
+
+R4 按可验证依赖拆分：R4a 先删除 settings 中的变量声明副本与仓库 Load 的无用名称/设置输入；Graph 是唯一变量持久源。R4b 再落地版本化配置 section 协议、项目契约的 schema 声明和默认模型归属；R4c 验证编辑/历史/保存/导出/安装/预览与项目自有 DTO。R4a 不等于完整自定义配置链路完成，GameContent 与作者模型尚存的固定绑定继续保留为 R4b/R4c 工作。
+
+R4b 实施边界：Core 只提供版本化配置文档和 section 描述协议，值仍由项目 DTO/schema 定义，复用 FieldDescriptor/ValueValidation；它是作者/内容交换数据，不是运行时服务容器。读取不写默认值，提交前验证，未知 section/字段保留。默认项目 DTO 归可选 Contracts.Builtins，组合根显式投影；GameContent/作者聚合只持有配置文档。项目契约公开 Configurations 目录；加载器接收目录与开发语言选择委托，不依赖默认 DTO。R4c 补齐通用 section 编辑 UI、历史和最终自有 DTO 接入验证。
+
+R4b 精简修订：用户要求去掉不必要的新增代码。配置只走普通 DTO + 显式 FieldDescriptor 的标准 JSON 路径，移除尚无产品消费者的 ForDto/DataType/DefaultData 和 IFieldDto 专用读写分支；不为配置维护另一套生成 DTO 编解码。JSON 属性 converter 由标准 serializer 处理。SDK JSON 信封解析替代手写成员解析和递归重复检查；已知字段/领域验证在合并后的候选上统一执行，未知数据和原子发布保持。
+
+R4c 按实际消费者拆分：先以通用配置补丁替代固定字段 switch，让已声明 schema 贯穿作者命令、构建与导出，证明自有 DTO 的保存/安装链路；再用已有字段表单和项目历史接入 GUI 与宿主。当前并行 Editor 调整移除了内嵌预览，后续验收使用外部调试/游戏宿主，不恢复旧预览。各步单独验证提交，R4 总体验收仍保留 GUI/历史及自有运行配置要求。
+
+R4c2 复用 DtoEditorHost/FieldDraftState，设置窗口只做 schema 字段草稿、批量提交和数据历史；普通复合值复用 JSON 编辑，不再保留音频列表专用模型。Configuration.Patch 同时服务命令和 GUI，Resolve 为表单提供隔离的有效默认值快照。Avalonia 宿主在项目组合根通过 SelectProjectOptions 投影存档容量、语言和音频声明，启动后缓存简单配置，不读取默认 DTO。
+
+R5 实施选择：复用 Contracts.Builtins 承载场景/音频/Gallery 的共享领域契约和采样算法，不新增 Common 包；运行侧音频与场景管理归 Primitives.Builtins。GameState 原有场景专用字典改为状态契约可选声明的 keySpace 索引，保留跨表身份冲突在写入/恢复时拒绝及 O(1) 查询，Core 不认识场景类型。场景模块按旧 GameState 根持有临时控制，恢复后不会解析到新根。R5a 先处理场景/音频，R5b 再处理 Gallery、资源默认策略和内容宿主归属。
+
+R5b 根据消费者归位：Gallery、ImageVariants 及默认资源 DTO/工厂属于可选 Contracts.Builtins；AssetMeta 只保留通用字段和原始扩展 JSON，Gallery 通过可选扩展读写该注解。GameContent/加载选项/本地化内容聚合归 GameHost.Content，Runtime 不拥有宿主内容组合。资源默认类型由 catalog 显式声明；provider/PAK 强制接收调用方目录，不在低层补默认 Builtins。
+
+R5b 精简：没有独立 metadata 字段的六个默认空 DTO 直接共用 AssetMeta，类型身份仍由 resource type ID 决定；仅 sprite 的 filter 需要独立 DTO。删除 GameContent 中没有生产消费者的 AssetRoot。
+
+R6 选择 DynamicParameterTable 为 Entry 唯一参数源，删除平铺 Parameters/Defaults/Options、nullable schema 回退和旧字典转 schema 工厂。具体编辑器类型投影移到 Editor.Abstraction，显示文本/选项在 UI 需要时生成；不在注册期预格式化。Effect/SEffect 元数据在 catalog 边界投影为既有 FieldDescriptor，复用 ValueValidation；目标 stage/scope 和 Shader 语法仍由领域拥有。目录复制输入集合以保证元数据查询与缓存校验一致，删除 EditorHints 的旧 ABI 兼容重载。
+
+R7 审核后只抽取 Engine 内完全相同的状态捕获/释放/锁外通知，并消除前跳 Seek 收束后的重复快照。ContinueUntilBlockedAsync 已被玩家推进、追帧与调试回放共用；AsyncPrimitiveInstance 与 PrimitiveTaskScope 已覆盖实际共享异步机制。视频、动画、Timeline 的完成/恢复策略不同，继续保留领域实现，不新增 Runner、策略参数或生命周期框架。原生窗口关闭与测试基础设施统一留在 R8 集成验收，避免混入通用 Engine。
+
+R8 验收调整：Windows 链接边界测试的目标是拒绝 reparse point 和祖先链接，不依赖特定 symlink tag；测试辅助在系统明确报告缺少 symlink 特权（1314）时创建无需该权限的目录 junction，仍执行相同产品断言，其他错误不降级。真实 symlink 仍优先使用，记录实际替代，不更改系统权限，也不将 junction 说成 symlink 特权验证。Editor/Integration 的 Headless 测试改用官方缓存会话，沿用 Presentation 的 PerTest 隔离与资源释放；原生关闭先记录窗口身份，再按证据修正。
+
+R8 原生验证发现宿主把恢复/Seek 的中间 Ready 映射成 IsPlaying=false，GameShell 因而导航到标题页。Ready 保留既有宿主会话状态，只有实际 Running/终态更新活动标志；首次准备仍保持未开始状态。此修正位于默认 Avalonia 宿主，不改变 Engine 状态协议，也不把 UI 策略放回 Core。
diff --git a/features/F-20261026-01-engine-core-simplification/phase-plan.md b/features/F-20261026-01-engine-core-simplification/phase-plan.md
new file mode 100644
index 00000000..d0bddffd
--- /dev/null
+++ b/features/F-20261026-01-engine-core-simplification/phase-plan.md
@@ -0,0 +1,148 @@
+# 引擎核心精简与职责收敛
+
+状态：completed。P0–P6、R1–R8 均 verified；最终验收 1789 项普通测试与 10 项原生测试通过。
+
+本文件是整个重构的实施与进度入口。P0–P6 保留已提交的历史；R1–R8 整理后续工作，设计依据见 [design.md](design.md)。设计整理完成不代表实现完成。
+
+## 目标与约束
+
+- 功能正确、低耦合、代码精简、职责清晰优先；不保留旧 API、旧数据格式或过渡适配层来维持向后兼容。
+- 可恢复的小问题不应终止剧情；失败处理放在能够判断业务后果的模块边界。
+- 优先删除重复表示、重复控制流程和无效分支；不为了拆分类而引入接口、服务或通用框架。
+- Engine 保留唯一执行门与运行生命周期，协作者不能各自推进剧情；保留已验证的 batch、已读、播放模式和检查点语义。
+- 本轮不做 benchmark、profile 或专项性能改造。仅顺手消除有明确不变量保障的重复遍历、排序、转换和分配；不宣称未测量的性能收益。
+- 不为性能引入状态 revision、增量快照、缓存失效体系、并行调度或对象池；这些留给后续性能任务。
+- 计划中的类型划分是方向，实施时依据实际调用关系收敛，不要求逐项创建新类型。
+
+## 进度维护
+
+按顺序实施；每次只将正在处理的阶段标为 `in-progress`。必要代码、调用方迁移、相关验证和文档完成后，才能勾选并标为 `verified`。
+
+完成阶段的详细清单压缩为：**完成结果一句话 + 验证结果 + 证据链接/提交**。实际缺口不能被压缩掉；延期项标记 `skipped` 并说明原因，不计作完成。重要偏差在收尾 `summary.md` 中保留原因。
+
+用户追加约定：每个阶段验证完成后单独提交 Git，再继续下一阶段；未完成或仅规划的阶段不能标为完成。R1 提交为 `76753fc`，R3 提交为 `0c51c23`；R2 提交为 `669b586`（部分早期修改另包含在独立清理提交 `2a5c678`）。
+
+| 阶段 | 内容 | 状态 |
+| --- | --- | --- |
+| P0 | 核心审查与问题复现 | [x] verified |
+| P1 | 收敛错误处理，修正表达式 | [x] verified |
+| P2 | 修正推进、通知与恢复生命周期 | [x] verified |
+| P3 | 收紧状态访问，隔离运行图 | [x] verified |
+| P4 | 统一 Entry 数据，删除旧路径 | [x] verified |
+| P5 | 收敛引擎协作者与模块边界 | [x] verified |
+| P6 | 集成验证与文档收尾 | [x] verified |
+
+## P0 — verified
+
+已审查 Core、Runtime、执行/呈现抽象并抽查 Builtins/GameHost，复现表达式、检查点观察者、读档位置、可变变量暴露、重复节点和推进取消问题。前次审查验证：Core 149、Runtime 114、Architecture 49 项通过；额外复现位于本地 `artifacts/engine-core-audit/Program.cs`（忽略产物，不是长期回归测试）。关键问题在对应实施阶段转为正式回归。
+
+## 错误处理原则
+
+严格检查集中在编译、内容装载、注册和存档恢复边界。日常执行只检查会变化或不能在入口保证的条件，不在多层重复执行相同校验。
+
+| 情况 | 默认处理方向 |
+| --- | --- |
+| 重复 stop/hide、已清理的可选目标、预期取消、过期回调 | 幂等完成或忽略；通常不报错，也不反复警告。 |
+| 可选音效/特效、可降级的展示后端失败 | 由领域模块定义静音、跳过或替代呈现；释放阻塞和资源，保留必要诊断。 |
+| 本地化缺项 | 沿用已定义的文化/默认文本回退；最终缺失采用明确占位与诊断，不无故终止剧情。 |
+| 事件观察者、日志接收方失败 | 隔离异常，不改变引擎执行状态；诊断失败不能递归造成新失败。 |
+| 条件表达式解析失败 | 修复合法文本解析；非法条件返回 false 并给出定位诊断，作者校验明确报错，不静默吞错。变量赋值表达式失败拒绝该次赋值，不擅自写入默认值。 |
+| 存档无效、读档位置不合法 | 拒绝本次恢复并报告原因，保留当前运行；不要把无效节点当正常结束。 |
+| 保存/持久化失败 | 报告该次操作失败，保留可重试的数据；不误报保存成功，不无故中断仍可继续的剧情。 |
+| 无法判定的控制流、必需指令缺实现、身份冲突、状态不变量破坏 | 入口尽早拒绝；若执行期间发生且不能保持一致性，则明确进入 Faulted。 |
+
+“可选”由指令/模块的业务语义确定，不能依据异常类型或是否非阻塞一概跳过。已部分修改持久状态的操作，必须有一致的提交或补偿策略后才能降级。缺失 custom action 保留当前默认 warning/no-op 策略，不将所有未知指令都视为可选。诊断包含稳定 code 与可用的 Group/Entry/资源上下文，重复诊断应有界；优先复用现有通道，不建设全局错误策略框架。
+
+## P1 — verified
+
+修复字符串表达式、非法条件定位与限量诊断，失败/空值赋值保留原变量，音频诊断观察者不影响清理；现有可选展示降级和关键指令失败规则保留。Runtime 120、Builtins 177 项通过；实现与验证见 ExpressionEvaluatorTests、AudioRuntimeTests、BuiltinPrimitiveInstanceTests 及 [runtime 规范](../../docs/spec/runtime.md)。
+
+## P2 — verified
+
+检查点在锁外隔离发布，推进分批让出且可取消，Engine 改为异步读档并先准备验证候选再提交；宿主、调试和测试调用方已迁移。Runtime 125、Builtins 177、GameHost 5、Presentation 243 项通过；Integration 122 通过、1 项因 Windows 无创建符号链接特权失败（ScreenshotEntryTests:169）。完整解决方案构建另遇 Avalonia 遥测权限/WebAssembly 包哈希问题，最终构建在 P6 复核。行为证据见 GameEngineLifecycleTests 和 [runtime 规范](../../docs/spec/runtime.md)。
+
+## P3 — verified
+
+变量读取/集合快照隔离，运行图使用验证后的私有副本，状态锁改由 Read/Update 封装；执行模块共享的活记录保留，避免全量深拷贝。Runtime 132、Builtins 177、Core 149、Storage 22 项通过；新增外部图修改隔离、非法图入口与变量读取隔离测试，规范见 runtime/architecture。调试路线测试补齐真实的分支出口定义后通过。
+## P4 — verified
+
+Entry 统一为 JSON，作者/编译类型分离，删除 IsGeneric、字符串 Values、历史 Layer 特判和无效回退；选项统一为类型化 enum，Editor/CLI 保留输入适配与未知草稿。Core 149、Builtins 177、Generator 18 项通过，Editor 构建通过；Editor.Shared 初轮 417 通过、5 失败、2 跳过，其中选项夹具迁移后定向 5 项通过，余下为 3 项符号链接权限和 1 项文件移动拒绝访问（后者根因尚未确认，P6 重查）。规范见 entry-types。
+## P5 — verified
+
+primitive/呈现仅借用 IGameContext，Engine 管理 IGameRuntime 与 IPrimitiveDispatcher；通知统一为 EngineNotifications，删除阻塞镜像和冗余排序，Editor 设置移回 Editor.Abstraction，移除无使用者的 LauncherSettings。另补宿主替换前存档预检，避免上层提前释放旧运行。Runtime 133、Builtins 177、Presentation 243、GameHost 6、Architecture 49 项通过；Editor 构建通过，正式边界见 runtime/architecture。
+## P6 — verified（R8 复核）
+
+适用当前仓库的验收已完成：完整解决方案/locked restore 通过，链接安全断言以真实 symlink 优先、缺权限时 junction 执行，10 项真实原生/外进程测试通过。Browser 工程已不在当前解决方案，不宣称验证已移除的 WebAssembly 目标。原始限制和验收调整保留在 [summary](summary.md#r8最小组合与最终验收)。
+
+## 可顺手做的优化
+
+仅在触及相应代码时进行：活动实例顺序已经单调时删除多余 OrderBy；复用已经准备好的恢复结果；消除同一边界内无必要的重复查询/转换。保留必要的输入校验、隔离复制和检查点语义；若优化需要额外缓存或改变所有权，移出本轮。
+
+## 后续整体重构
+
+目标：项目策略归高层，通用执行归 Runtime，可选内置领域不进入内核；通过删除多份表示和共享实际重复机制精简代码。
+
+设置模型归高层、内部接收简单配置、轨道/分组可自定义、Sample 保留三个分组是已确认方向。其余拆分位置为实施方向，具体类型/程序集归属依据消费者核实，不为完成表格制造新框架。实施时遇到会改变行为或范围的偏差，先更新设计与本计划。
+
+| 阶段 | 内容 | 依赖 | 状态 |
+| --- | --- | --- | --- |
+| R1 | 执行协议与管理类型归位 | 已提交基线 | [x] verified |
+| R2 | 设置模型与模块配置解耦 | R1 | [x] verified |
+| R3 | 自定义音频分组与轨道控制 | R2 | [x] verified |
+| R4 | 自定义配置贯穿作者与运行链路 | R2、R3 | [x] verified |
+| R5 | 剥离可选领域与场景依赖 | R1–R4 | [x] verified |
+| R6 | 统一参数描述与基础校验 | R5 | [x] verified |
+| R7 | 收敛执行与异步生命周期重复 | R5、R6 | [x] verified |
+| R8 | 最小项目、完整回归与文档收尾 | R1–R7 | [x] verified |
+
+### R1 — verified
+
+执行/Choice/快进/播放端口归 Core.Execution，音频后端端口归 Core.Audio，IGameRuntime/GameRestorePoint 下移 Runtime.Runtime；Runtime 项目只依赖 Core，调用方与锁图已迁移，无兼容包装或行为变更。音频领域整体迁移仍归 R5。
+
+893 项相关回归通过，1 项集成夹具受既有符号链接权限限制；普通桌面解决方案构建、locked restore、格式和架构门禁通过。34 个锁文件仅有项目依赖变化，第三方版本/哈希和目标框架键保持不变；Browser/R2R/原生平台验证限制见 [summary](summary.md#r1执行协议与管理类型归位)。证据含 Runtime 的 ExecutionBoundaryTests（自定义分发器执行/恢复、编译产物依赖检查）与 ProjectDependencyTests，正式边界见 [architecture](../../docs/spec/architecture.md)。
+
+### R2 — verified
+
+Engine 只接收/更新不可变 PlaybackOptions，音频只接收隔离轨道定义和 AudioMixOptions，文本消费速度值，保存服务接收槽位数；IGameContext/GameRuntime 不再携带设置容器。默认偏好模型上移 Avalonia.GameHost，PlayerSession 不持有完整设置；删除无用设置类型/服务和 SfxChannelCount 的 UI/CLI/复制路径。GameContent.Settings/作者 ProjectSettings 的整体迁移仍归 R4，自定义分组声明与单轨控制仍归 R3。
+
+1645 项相关测试通过，4 项为既有符号链接权限失败，2 项跳过；当前完整解决方案构建、locked restore、格式与 diff 检查通过。覆盖显式配置更新/拒绝、集合隔离、已有/后续 voice、默认偏好清空重绑和存档容量。证据见 [summary](summary.md#r2设置模型与模块配置解耦)、PlaybackModeTests、AudioRuntimeTests、TypedBuiltinAuthoringTests、SampleLocalizationTests、SampleSaveSessionTests；接入示例见 [manual](../../docs/manual/new-presentation-layer.md#从项目设置映射模块配置)。
+
+### R3 — verified
+
+分组/轨道任意声明，允许空配置/未分组；不可变 AudioConfiguration 在入口统一校验，master/group/track 混音影响当前及后续 voice，快进保留为显式轨道策略。删除固定分类与指令默认目标；Sample/模板明确选择三分组，默认 UI 和 Editor 复用同一声明。
+
+1752 项测试通过，4 项既有符号链接权限失败、3 项跳过；完整解决方案构建、空白格式与 diff 检查通过。最终修正后的 Builtins 185 项全通过，Integration 123 通过/1 项权限失败。证据含 AudioConfigurationTests、AudioRuntimeTests、ProjectAudioSettingsTests、SampleLocalizationTests 与 GameInstallationTests；记录见 [summary](summary.md#r3自定义音频分组与轨道)，规范见 [runtime](../../docs/spec/runtime.md) 和[接入手册](../../docs/manual/new-presentation-layer.md)。原生/外进程环境项继续保留，完整自定义 section/领域归位归 R4/R5。
+
+### R4 — verified
+
+版本化配置、通用 schema 表单和批量历史贯穿作者命令、保存、两种导出与安装加载；宿主显式投影自有 DTO，默认语言编辑仍归 I18n 面板。未知数据和缺省 section 的 Undo/Redo 无损。R4c2 产品净减 143 行，构建及 1091 项相关回归通过，3 项符号链接权限失败、2 项跳过；实际外部 Sample 的运行/Seek/停止通过，原生关闭超时继续纳入 R7/R8，不记为完整原生验收。
+
+- [x] R4a：变量单一来源，`5a08d4f`。
+- [x] R4b：配置协议/默认模型归位，`1228f94`；精简 `6218d5f`。
+- [x] R4c1：通用命令与发布链路，`3d37f50`。
+- [x] R4c2：通用界面、批量历史和宿主投影；见 [summary](summary.md#r4c2通用表单历史与宿主投影)。
+
+### R5 — verified
+
+场景/音频/Gallery/差分图片契约归可选 Builtins，运行侧音频/场景管理归内置执行，内容聚合与 Gallery 玩家包装归宿主；Core/Runtime 无上述领域依赖，最小自有执行与恢复通过。资源目录显式传递，默认类型由组合根选择；删除六个空 metadata DTO 和未使用的 AssetRoot。R5a `469a4ba`、R5b 合计产品 C# 净增 4 行；R5b 全量相关回归 1779 通过，3 项权限失败/3 项跳过，构建/locked restore/格式通过。证据见 [summary](summary.md#r5bgallery资源默认策略与宿主内容归位)。原生关闭问题继续归 R7/R8。
+
+### R6 — verified
+
+Entry 仅保存 DynamicParameterTable，编辑器按需投影；效果基础约束共用 ValueValidation，删除旧字典/回退/ABI 兼容路径。产品 C# 净减 122 行，构建/格式通过，完整回归 1781 通过、3 项权限失败及 1 项已知 Headless 释放竞态；该 GUI 用例单独复核通过（合计 1782）。测试框架会话稳定性与原生关闭仍归 R8。证据见 [summary](summary.md#r6唯一参数源与共享基础校验)。
+
+### R7 — verified
+
+共享 Engine 完全相同的收尾，确保门禁在状态捕获异常时也能释放；Seek 复用收束后快照。推进内核与异步基础已有复用，领域差异保留，不新增框架。产品净减 5 行，完整构建、格式及 Runtime/Builtins/Presentation/Debugging 640 项通过。证据见 [summary](summary.md#r7执行收尾与快照复用)。
+
+### R8 — verified
+
+最小无内置执行/恢复、自有 DTO 控制推进/实际文本/ambience、Sample 三分组和配置完整链路均通过；修正宿主把恢复 Ready 当成停止的映射。完整构建、locked restore、格式、1789 项普通回归及 10 项原生回归通过，无失败/跳过的普通用例；R6–R8 产品 C# 合计净减 125 行。并行图校验改动独立保留，共享层使用源码一致的隔离候选验证。见 [summary](summary.md#r8最小组合与最终验收) 与 [review](review.md#r8最终自审)。
+
+后续同样遵循前述进度维护规则：只勾选实际 verified 阶段，完成后压缩为“结果一句话 + 验证 + 证据”。用户已授权开始实施；各阶段状态以本表及实际验证证据为准。
+
+## 参考
+
+- [运行时规范](../../docs/spec/runtime.md)
+- [架构规范](../../docs/spec/architecture.md)
+- [Entry 契约](../../docs/spec/entry-types.md)
+- 本计划依据 2026-10-26 会话中的核心审查及用户修订：功能/低耦合/精简优先，专项性能工作延期。
diff --git a/features/F-20261026-01-engine-core-simplification/review.md b/features/F-20261026-01-engine-core-simplification/review.md
new file mode 100644
index 00000000..8e64ddad
--- /dev/null
+++ b/features/F-20261026-01-engine-core-simplification/review.md
@@ -0,0 +1,97 @@
+# 核心精简自审
+
+结论：pass（R8 最终验收）。本 feature 1789 项普通测试与 10 项原生测试通过；以下保留各轮自审和历史限制。
+
+检查范围：实际 diff、Core/Runtime/执行与呈现抽象、Builtins、GameHost、Editor/CLI 接口迁移、参数生成器、生命周期和正式文档。此次为同一实施 agent 的自审，未声称独立审核。
+
+## 已修正的问题
+
+- 检查点观察者异常和重入：统一锁外通知，逐订阅者隔离并复制快照。
+- 无阻塞循环取消：每批让出，重查代次/阻塞，调用方取消不转 Faulted。
+- 不合法恢复位置/状态：先验证候选，再取消和替换；宿主也在释放旧运行前预检。
+- 旧取消回调异常：P6 自审补充 CancelDetachedScope 与正式回归，避免合法恢复半提交。
+- 可变变量泄漏与图共享：读取隔离，运行持有私有图副本；场景活记录保留明确模块边界。
+- 作者/运行条目和选项双轨：JSON 权威、独立类型、单一 enum 约束；当前消费者和契约夹具已迁移。
+- 职责边界：IGameContext 不暴露游标/恢复，执行端口与 presenter 区分；通知协作者不拥有执行门。
+
+没有发现本次改动中尚未修复的 P1/P2 行为问题。回归与环境失败详见 [summary](summary.md)，不把相关失败算作通过；原生桌面、符号链接和 Browser 包哈希限制仍需补验，P6 保持 in-progress。
+
+## R1 自审
+
+结论：pass-with-follow-up。此次仍为实施 agent 自审，不声称独立审核。
+
+检查了七个迁移类型、生产/测试引用、Runtime 编译产物、默认接口释放语义及 34 个锁图差异；没有新增兼容层、执行门或后台推进逻辑。核心执行接口与 Choice/快进/播放协议只依赖 Core 数据，Runtime.Audio 通过 Core.Audio 后端协议工作。运行管理接口和恢复候选不再由 Core 拥有。最小自定义分发器可执行、保存并恢复，Runtime 程序集没有呈现或内置实现依赖。
+
+发现并修正调试测试夹具原先借助 Runtime 获取的隐式呈现引用；显式引用仅加到测试项目。强制还原产生的 WebAssembly 包哈希与 iOS 框架键无关变化均已撤回，只保留项目依赖变化。新夹具的稳定快照初始化时机也已修正。
+
+893 项相关回归通过，集成中 1 项已知符号链接权限失败；普通桌面构建、locked restore、格式和架构门禁通过。未发现尚未修复的 R1 行为问题；R2–R8 的设置/领域重构仍未完成。R2R 缺包、Browser 哈希与原生平台条件详见 summary，不将发布验证计为通过。
+
+## R2 自审
+
+结论：pass-with-follow-up，仍为实施 agent 自审。运行执行与通用 PlayerSession 均不依赖完整玩家模型；GameContent 的作者模型边界明确延期到 R4。配置输入不可变或在入口复制，显式更新前验证，失败保留当前状态；音频恢复复用组合期轨道与当前混音，旧 scope 清理语义未改。
+
+修正了无运行设置容器后音频夹具仍依赖隐式默认轨道的问题，夹具和宿主改为明确传入声明；没有为迁移保留隐式默认分支。默认偏好从通用 GameHost 进一步上移 Avalonia 默认宿主，并复核清空/重绑；保存槽数显式传入文件服务，避免删去旧设置类型后保留失效配置。
+
+1645 项测试通过，4 项既有符号链接权限失败、2 项跳过；当前完整解决方案构建、locked restore 与格式检查通过。未发现 R2 尚未修复的行为问题；自定义分组/单轨控制、完整作者配置和领域剥离尚未实施，不能计作完成。
+
+## R3 自审
+
+实施 agent 自审，未声称独立审核。复核了任意 ID/未分组/空配置、入口隔离与配置错误、混音叠加和当前/后续 voice、快进策略、状态恢复/旧 scope、声明式默认 UI 与 Editor 历史/持久化。没有新增音频路由树、第二套三分类执行分支或任意设置参数袋。
+
+发现并修正了 schema 的空串属性默认导致 Required 仍可省略的问题；构造函数只提供 CLR 初值，schema 不声明默认。声明记录不可变后，Editor 克隆/比较改为复制集合和 record 值相等，确保新增 group/policy 不漏复制。配置加载与编辑入口共用校验，未知运行轨道保持诊断/安全结束；玩家混音仍不写入剧情快照。
+
+结论：pass-with-follow-up。1752 项通过，4 项既有符号链接权限失败、3 项跳过；构建/格式通过。初轮遗漏的测试目标与复合测试断言已迁移，Builtins/Integration 分别重建并完整重跑，无尚未修复的 R3 代码失败。完整项目设置模型/自定义 section 仍待 R4，Core 默认领域归属仍待 R5。
+
+## R4a 自审
+
+实施 agent 自审。复核变量声明仅从 Graph 持久化/恢复；删除的 settings 副本没有运行消费者。Graph 克隆仍同时隔离 player/save 声明，未将变量数据随设置字段删除。仓库 Load 的名称/设置输入没有消费者，删除接口及全部包装器后保持原 Graph/Group 验证、外部基线和事务逻辑。未使用 Normalize 的删除没有改变实际名称验证行为。
+
+结论：pass-with-follow-up。相关 868 项通过，4 项既有符号链接权限失败、2 项跳过；普通与同源码隔离构建、locked restore/格式通过。初次 GUI 的 Headless DisposeAsync 空引用与既有会话发布竞态位置一致，定向和完整 323 项重跑通过，保留原日志且未修改产品代码。默认输出被用户 Editor 占用时使用同源码隔离输出，不将文件锁归为代码错误或停止用户程序。R4b/R4c 的配置扩展尚未完成。
+
+## R4b 自审
+
+实施 agent 自审。复核配置的所有权、类型化读写、未知 section/字段保留、版本边界、重复属性、schema 默认值、失效输入拒绝和原子发布；Core/Runtime/Storage 不依赖默认项目 DTO，没有将配置文档加入运行上下文。Editor 保存、结构发布和外部重载使用所选 schema；GalProject/契约释放时清除自有类型引用。默认模板及两个 Sample 显式声明默认模型，既有 caada23 的本地化绑定与定位修正保留。
+
+修正了精确字段校验与 Web DTO 解码大小写规则不一致的绕过点，新增 regression；语言候选过滤造成显示字符串解析失败的既有问题在 `2a92fb6` 独立修复，没有删除失败用例或改成空操作。去掉配置复制的 JSON 往返以及索引中每条文本的重复配置解码。
+
+结论：pass-with-follow-up。1770 项通过，4 项既有符号链接权限失败、3 项跳过；普通解决方案构建、格式和 diff 检查通过，无依赖/锁文件变更。R4b 的协议/归属迁移完成；通用 section UI/历史、构建导出端的项目自有 schema 贯穿，以及完全自有 DTO 的运行/预览证明继续归 R4c，不能将 R4 整体标为完成。默认宿主和 Editor 默认面板仍显式消费默认模型，这是剩余适配范围，不是内核已支持任意模型的端到端验收证据。
+
+## R4b 精简自审
+
+实施 agent 自审，结论 pass-with-follow-up。统一标准 JSON DTO 路径，移除 ForDto/IFieldDto 分支、DataType/DefaultData 和重复验证/保存读取/克隆；SDK 替代手写 JSON 解析、输出及重复属性递归。核对构造/schema 默认值、未知数据、大整数、大小写、无效候选原子拒绝和既有版本规则继续有效。产品净删 88 行，隔离完整构建、774 项相关回归及格式通过，4 项既有权限失败、2 项跳过。其他并行 Editor 改动未纳入，R4c/R4 整体未完成。
+
+
+## R4c1 审核
+
+固定设置命令已删除且仓库无调用残留；候选先验证后发布，未知数据与 section 版本保留，null/缺省语义分开。构建与两种导出在替换产物前检查所选 schema，Editor 导出/外部调试与 CLI 一致。普通 DTO 的编辑到安装加载由实际流水线测试验证，产品净减 20 行。隔离构建、1089 项相关回归及格式检查通过，3 项既有符号链接权限失败、2 项跳过保留；没有将环境失败计为通过。当前范围未发现待修问题；GUI/历史及宿主投影继续列为 R4c2，不能据此宣称 R4 完成。验证细节见 summary 的 R4c1。
+
+
+## R4c2 审核
+
+表单与命令共用补丁语义；字段/领域错误在发布前拒绝，草稿可继续修正，历史不保留视图且保留缺省/未知数据。绑定在取消、重载、Undo/Redo 和关闭后失效。宿主不再依赖默认配置 DTO。1091 项相关回归通过，3 项符号链接权限失败与 2 项跳过保留。显式原生关闭超时已记录为未解决项，需在 R7/R8 复核；不将 R4 的配置功能验证等同完整 native close 验收。
+
+
+## R5a 审核
+
+Core/Runtime 源码与公开接口已无场景/音频领域类型依赖；Runtime 编译引用门禁通过。状态索引采用显式 keySpace，没有场景类型判断；单一持久记录、跨表冲突拒绝和旧根隔离由相同测试保持。场景服务与音频执行只由可选内置模块使用，未建立新公共程序集或兼容包装。1776 项回归通过，3 项权限失败/3 项跳过保留；依赖锁第三方内容无变化。Gallery/默认资源和宿主内容边界继续列为 R5b，原生关闭问题继续保留。
+
+
+## R5b 审核
+
+Core/Runtime 无可选领域/宿主聚合引用，执行边界与最小自有执行器测试通过。默认资源 ID 与 metadata DTO 解耦，目录/默认类型由调用方决定，没有低层默认工厂；注解扩展不改变 wire 字段并保留未知成员。内容聚合/玩家 Gallery 包装按真实消费者归宿主。1779 项回归通过，环境权限项和原生关闭缺口均保留，未扩大为新公共包或场景持久镜像。
+
+## R6 自审
+
+结论 pass-with-follow-up。核对值约束和编辑提示的依赖方向：Core 不含具体 EntryParameterType，参数表始终存在，编译、CLI 和 GUI 使用同一字段描述；删除的 ABI 为明确不保留的兼容接口。效果目录返回诊断，基础共享不吞领域错误，数值字符串/null/溢出浮点仍拒绝；调用方改动参数列表、选项和 scope 不影响目录规则。产品净减 122 行。构建/格式及 1782 项功能验证通过；完整测试中的 3 项权限失败和 1 项已知 Headless 释放竞态如实记录，框架稳定性及原生关闭在 R8 收尾。
+
+## R7 自审
+
+结论 pass。逐一复核收尾替换均为原有捕获/释放/发布的相同次序，未把只读、准备和分批 yield 的门禁协议混入；发布继续在锁外，捕获异常也释放门禁。Seek 的单次快照保留压缩后场景及当前变量。640 项相关回归、完整构建/格式通过。既有异步基础保留，不以抽取数量作为目标；原生宿主关闭继续由 R8 实际验证。
+
+## R8 最终自审
+
+结论 pass，实施 agent 自审，未声称独立审核。检查 Core/Runtime 编译依赖、可选领域所有权、配置单一来源/未知 JSON 保留、任意音频分组/轨道与热更新、Entry 单一参数描述、门禁与异步完成/取消、宿主 Ready 状态及实际窗口关闭。没有新增通用框架或恢复默认领域强依赖，R6–R8 产品净减 125 行。
+
+完整构建、locked restore、格式检查、1789 项普通与 10 项原生回归通过。实际挂载/保存/发布/运行和真实呈现证据均存在，旧权限/框架/原生问题不再以跳过代替。保留真实 symlink 不可用、已移除 Browser 目标不在覆盖范围及 NU1900 元数据警告的准确说明。测试基础设施改动没有吞异常，junction 仅替代同一 reparse-point 不变量；独立候选的默认契约产物由同源码补建，62 个源码指纹一致。
+
+并行的 0c436b42 及其后图校验工作保持独立，不是本次 R8 的审核或提交内容。最终范围、验证及原始失败见 summary 的 R8；本 feature 无遗留 blocker。
diff --git a/features/F-20261026-01-engine-core-simplification/summary.md b/features/F-20261026-01-engine-core-simplification/summary.md
new file mode 100644
index 00000000..9c01df6a
--- /dev/null
+++ b/features/F-20261026-01-engine-core-simplification/summary.md
@@ -0,0 +1,222 @@
+# 引擎核心精简与职责收敛
+
+状态：completed。P0–P6、R1–R8 verified；最终 1789 项普通测试、10 项真实原生测试通过。各轮原始失败记录保留，最终结论见 R8。
+
+## 整体结果
+
+- Core/Runtime 保留通用执行与状态协议；可选场景、音频、Gallery、差分图片契约归 Contracts.Builtins，执行归 Primitives.Builtins，内容聚合归 GameHost。
+- 项目自有 DTO/schema 贯穿表单、命令、历史、保存、导出与安装；组合根投影为推进、文本、音频等小配置。默认示例不再是内核要求。
+- 轨道和分组由项目定义，支持 master/group/track gain/mute；Sample 继续保留三个默认分组。
+- Entry 只有一份参数描述，效果基础约束共用现有校验；执行收尾共用方法，领域生命周期差异保留。R6–R8 产品 C# 净减 125 行。
+- 构建、locked restore、格式和最终回归通过；已验证配置/运行链路与剩余范围见下文 R8。
+
+## 首轮实现结果（P1–P5）
+
+- 表达式双引号文本按 JSON 转义绑定为值，保留 NCalc 单引号语法；非法条件按 false 处理并限量诊断。变量赋值表达式失败/无值时保留原值，不把失败写成空字符串。
+- 状态、播放模式和检查点由 EngineNotifications 按发生顺序在执行门外发布，隔离订阅者异常。音频诊断观察者不能阻断后端清理。
+- 所有推进路径有批次预算和让出机制，长剧情/合法循环不因预算耗尽报错；调用方取消不使 Engine Faulted。跨批次重查 scope 与阻塞边界。
+- Engine 读档使用 RestoreFromAsync，先准备 GameRestorePoint 并验证图位置、变量和模块状态，再替换旧 scope；复用已解码的候选状态。宿主替换前预检候选存档，无效存档保留当前运行。旧 scope 的取消回调异常不能留下半份恢复。
+- 变量读取与集合快照隔离；运行图保存验证后的私有副本。模块共享场景记录保留，通过 GameState.Read/Update 协调，锁对象不跨程序集公开。
+- Entry 只有一份 JSON 参数；AuthoringPrimitiveEntry/CompositeEntry 与 sealed PrimitiveEntry 类型分离。移除 IsGeneric、字符串 Values、CreatePrimitive<T>、Layer 历史参数特判和必然失败的序列化回退。Choices 最终只产生类型化 enum 约束，表单和生成器同步迁移。
+- primitive/呈现使用 IGameContext，Engine 使用含游标与恢复能力的 IGameRuntime；分发依赖改为 Execution.IPrimitiveDispatcher。编辑器设置/最近项目/布局编码迁到 Editor.Abstraction.Settings，无使用者的 LauncherSettings 删除。
+- 删除活动列表的多余排序、sequence 字段和自动阻塞镜像集合；未引入缓存、增量快照、对象池或并行调度。
+
+## 关键边界
+
+错误处理按业务后果确定。可选展示有已定义降级时继续；无效条件有诊断；无效存档拒绝本次操作。关键执行或状态失败仍正常传播，不统一吞异常。已部分提交的状态不靠 catch 伪装成成功。
+
+GameState 的活记录是执行模块内部共享对象，不宣称其读取结果是不可变快照。Engine 的图副本对宿主/作者代码隔离，继续使用已有 Node/Group 数据形状，没有另建公开 CompiledGraph 类型层。
+
+Engine 仍拥有唯一执行门；调试控制保留为内部 DebugSession，没有新增独立 Runner。通知队列与已有导航/活动实例协作者承担独立职责。同步的低层 GameRuntime.RestoreFrom 是纯内存准备/提交入口，Engine 的读档入口已异步化；现有同步释放入口仍供同步宿主使用，不为兼容新增包装。
+
+## 验证
+
+最终回归共 1648 通过、4 项因 Windows 创建符号链接缺少特权而失败、2 项跳过。详细结果如下；本地输出在忽略产物 `artifacts/engine-core-audit/final-*.log`。
+
+| 测试项目 | 通过 | 失败/跳过 |
+| --- | ---: | --- |
+| Core | 150 | 0 |
+| Runtime | 134 | 0 |
+| Primitives.Builtins | 177 | 0 |
+| GameHost | 6 | 0 |
+| Architecture | 49 | 0 |
+| SchemaGenerator | 18 | 0 |
+| Storage.FileSystem | 22 | 0 |
+| Presentation | 243 | 0 |
+| Editor.Shared | 419 | 3 失败、2 跳过 |
+| Editor | 308 | 0 |
+| Integration | 122 | 1 失败 |
+
+4 个失败均停在测试准备阶段的 Directory.CreateSymbolicLink：GroupCompileServiceTests.LinkedOutput_IsRejectedAndExternalDirectoryUnchanged、ProjectAuthoringSafetyTests.Preview_RejectsLinkedOutputBeforeWriting、ProjectSchemaContextTests.AncestorLinks_AreRejectedForRawReadsAndContractLoads、ScreenshotEntryTests.GeneratedNames_AreUnique_AndRelativeOrLinkedDirectoriesAreRejected。没有通过跳过或修改这些用例来掩盖失败，仍待支持符号链接权限的环境复核。Editor.Shared 初轮另有一次文件移动拒绝访问，最终完整重跑已通过，根因未确认。
+
+原生桌面/真实外进程的显式测试没有执行；相关能力不能由 headless 测试替代。Editor 构建已通过；最终解决方案构建仅剩 Browser 的 NU1403：Microsoft.NET.Sdk.WebAssembly.Pack 10.0.12 包内容哈希不匹配。只使用本地包缓存的 locked restore 仍复现，仓库锁文件保持未改动；没有禁用哈希校验或改写包缓存来绕过问题。空白格式和 git diff --check 已通过。
+
+P6 保持 in-progress，待具备目录符号链接特权、正确 WebAssembly SDK 包和原生桌面条件后补验，不把以上失败算成完整验收。
+
+验证命令使用单进程构建、禁用共享编译器，并为 Avalonia 设置遥测 opt-out；现有平台环境限制与代码问题分别记录。未开展专项 benchmark/profile，不报告未经测量的性能收益。
+
+## 计划调整
+
+- P5 补充宿主替换前的候选存档预检：仅修正 Engine 读档不能防止上层提前释放旧运行。
+- P6 自审补充旧 scope 取消回调异常的隔离与回归，保证合法候选不会因旧回调异常停在恢复中间。
+- 不增加额外可变场景镜像/深拷贝体系；保留模块活记录，隐藏同步实现并明确使用边界。
+- 调试路线测试原先引用未声明的第 7 个出口，夹具补齐实际分支项，保留“忽略条件/选择进行显式路线回放”的原测试目标。
+
+## 当前规范
+
+本次公开 API 有破坏性变化，仓库内调用方已同步迁移；外部项目的 Contracts DLL 需要使用新 Core/Contracts 重新构建，不保留旧二进制适配。
+
+- [架构](../../docs/spec/architecture.md)
+- [运行时](../../docs/spec/runtime.md)
+- [Entry 与参数](../../docs/spec/entry-types.md)
+- [术语](../../docs/glossary.md)
+- [接入表现层](../../docs/manual/new-presentation-layer.md)
+
+## R1：执行协议与管理类型归位
+
+执行契约移入 Core.Execution：IPrimitiveDispatcher、IChoicePresenter、ICatchUpPresentation、IPlayerPlaybackController；IAudioPlaybackHost 与现有音频数据协议同归 Core.Audio。IGameRuntime 与 GameRestorePoint 移入 Runtime.Runtime。Runtime 的项目依赖现在只有 Core，注册与展示恢复组合继续留在 Presentation.Abstractions，没有新增包装类型或变更播放/恢复语义。音频领域整体可选化仍待 R5。
+
+仓库内宿主、呈现、内置模块、Sample 和测试调用方已迁移。Debugging.Tests 夹具使用 GameRegistration，以前借 Runtime 获得隐式呈现引用；现在由测试项目直接声明 Presentation.Abstractions，生产 Debugging/Runtime 不因此依赖展示实现。
+
+相关测试共 893 通过、1 个既有符号链接夹具失败：
+
+| 项目 | 通过 | 限制 |
+| --- | ---: | --- |
+| Core | 150 | 无 |
+| Runtime | 136 | 含新增自定义分发器执行/恢复与编译产物依赖测试 |
+| Architecture | 49 | Runtime allowlist 仅 Core |
+| GameHost | 6 | 无 |
+| Presentation | 243 | 无 |
+| Primitives.Builtins | 177 | 无 |
+| Debugging | 10 | 无 |
+| Integration | 122 | 1 项 ScreenshotEntryTests 在 Directory.CreateSymbolicLink 缺少 Windows 特权 |
+
+普通桌面/测试解决方案构建通过，包含 Editor、两个 Sample 和所有桌面测试项目；该验证使用忽略产物 r1-desktop.slnx 排除 Android/iOS/Browser，不等同于全部平台解决方案构建。Editor 单独构建也通过。普通桌面图从本地缓存执行不含 force-evaluate 的 locked restore 通过；定向 C# 未使用引用清理和空白格式通过，git diff --check 通过。日志在忽略产物 artifacts/engine-core-audit/r1-*.log。
+
+34 个普通/ReadyToRun 锁文件已重算并审查，仅删除 Runtime→Presentation 的项目依赖及无其他消费者的项目节点，第三方版本/哈希和框架键保持原值。发布验证仍有限制：R2R 本地缺少 .NET Runtime/WindowsDesktop/AspNetCore/Crossgen2 等 win-x64 包，未完成发布还原/构建；Browser 恢复仓库原哈希后，普通 locked restore 仍复现 WebAssembly.Pack 10.0.12 的 NU1403。不能把锁图生成成功当作发布验证成功。iOS 本地还原曾派生出不同平台版本键，已撤回该无关生成差异；原生平台未构建。
+
+强制重算 Browser 锁图会接受本地包的不同 contentHash，即使同时使用 locked-mode 也不是原锁哈希验证。本轮恢复原哈希后以不含 force-evaluate 的 locked restore 复现失败，没有改写缓存或关闭验证来绕过问题；可复用经验见 .agents/lessons/L-20261026-03-forced-restore-package-hash.md。新增测试初版在 Engine 构造后才初始化变量，却读取构造期稳定快照，夹具改为构造前初始化；生产检查点语义未改动。
+
+R1 的普通执行边界退出条件已满足；完整平台限制继续保留在 P6/R8，不视为解决。后续 R2 从设置模型与模块配置解耦开始。外部消费者需要随公开类型迁移重新构建，不提供旧命名空间适配。
+
+## R2：设置模型与模块配置解耦
+
+IGameContext/GameRuntime 不再携带 Settings。Engine 构造和 UpdatePlaybackOptionsAsync 只接收不可变 PlaybackOptions，配置无效时拒绝本次更新，不替换旧值或使运行 Faulted。BuiltinAudioModule 在组合时接收独立的轨道定义副本，以 AudioMixOptions/AudioMixLevel 接收主音量和按分组 ID 索引的混音值；入口复制集合，不在每次播放或恢复时读取完整项目/玩家模型，更新作用于当前及后续 voice。
+
+默认 GameSettings 上移 Avalonia.GameHost.Settings；它向模块投影配置，项目不必继承此模型。通用 PlayerSession 不再拥有该模型，清空玩家数据后由默认宿主重新绑定偏好。Headless 文本只消费速度值，项目轨道显式传入模块；FilePlayerSession 接收简单 maxSlots 参数，两个默认宿主都将项目 SaveSlotCount 传入保存服务，修正原先忽略该值的问题。
+
+SettingsContainer/SettingsSection、无消费者的 SaveSettings、Editor 的旧游戏设置接口/空实现/DI 入口，以及 SfxChannelCount 字段与 UI/CLI/复制路径已删除。编辑器历史夹具用实际仍生效的分辨率字段验证无关设置保留。分组声明与单轨混音仍待 R3；GameContent/Editor/Storage 共用的作者 ProjectSettings 归属和自定义配置链路仍待 R4，本阶段没有用额外跨层依赖把作者模型简单搬家。
+
+验证共 1645 项通过、4 项符号链接权限失败、2 项跳过：Core 150、Runtime 138、Builtins 178、GameHost 6、Presentation 243、Architecture 49、Debugging 10、Storage 22、Editor.Shared 419（3 失败、2 跳过）、Editor 308、Integration 122（1 失败）。4 个失败仍为先前记录的 Directory.CreateSymbolicLink 特权不足，没有新增未修复的代码失败。默认偏好模型最终上移后重跑了 GameHost/Integration，存档槽映射补齐后重跑了 Storage/Integration。
+
+当前完整 GalNet.slnx 构建、普通 locked restore、定向 C# 格式清理与 git diff --check 通过。工作期间的独立清理提交 2a5c678 删除 Launcher 并包含部分早期 R2 修改，保留该提交；旧临时解决方案引用删除项目导致的构建失败已改用当前 GalNet.slnx 后验证通过。当前解决方案不再包含旧 Browser 目标，这不证明其历史哈希问题被修复；原生交互、符号链接权限与 R2R 发布环境限制仍按后续阶段处理。日志在忽略产物 artifacts/engine-core-audit/r2-*.log。
+
+新增回归覆盖推进选项显式更新/无效输入、混音集合隔离和当前/后续 voice、轨道定义不借用作者对象、清空后默认偏好重绑和自定义存档容量。正式规范与接入示例已同步，未引入兼容适配层。R2 完成后按用户约定提交，再进入 R3。
+
+## R3：自定义音频分组与轨道
+
+AudioConfiguration 在组合/加载入口验证并复制分组与轨道，声明元素改为不可变 record。组与轨道 ID 均由开发者定义，轨道可以不分组，空配置合法；移除 AudioBuses 和 Core 默认轨道工厂。Runtime 使用索引查找声明，播放期间不重复验证整个配置。master/group/track 的 gain/mute 同时作用于已有和后续 voice，最终叠加轨道预设与内容增益并限制到后端范围；中间乘积使用 double，合法的大增益不会因 float 溢出意外变成静音。
+
+快进保留由 PreserveDuringCatchUp 明确指定，不按 bgm 名称推断。普通音频与语音 Composite 均要求显式 trackId；没有保留旧默认目标。可选 BuiltinAudioDefaults 位于 Contracts.Builtins，Sample/新项目模板显式选择音乐、音效、语音三组，完整路径仍复用同一配置/混音机制。
+
+默认 Avalonia 偏好改为 Groups/Tracks 字典；声明生成分组 gain/mute，ShowTrackAudioControls 可选择显示单轨控件，隐藏时仍恢复单轨偏好。存储键使用区分层级、URI 转义的 ID；清空和重绑会重建动态恢复项。Editor 支持增删分组、任意归属和快进策略，删组将成员轨道解除归属；草稿、Undo/Redo、保存、重开、导出/安装和预览保留这些值。Editor 提交/加载/保存与安装加载复用 AudioConfiguration 的校验。
+
+新增回归覆盖配置集合隔离、空/未分组/任意分组、同组两轨的独立混音、各层静音、当前/后续 voice、与名称无关的快进策略、大增益饱和、动态偏好恢复/隐藏控件/重新配置、Editor 历史与重开及包安装。初轮发现 DTO 空串属性初始化值仍导出 schema 默认，按现有 lesson 改为构造函数初始化，并扩展所有音频/语音 schema 的缺省/null 回归。
+
+最终验证 1752 项通过、4 项既有符号链接权限失败、3 项跳过；Core 152、Runtime 141、Builtins 185、Editor 323、Editor.Shared 422（3 失败/2 跳过）、Integration 123（1 失败）、Presentation 243、Architecture 49、Assets 57（1 跳过）、GameHost 6、Debugging 10、Diagnostics 1、Storage 22、Generator 18。完整解决方案构建通过；最后仅迁移遗漏的测试轨道目标及复合测试断言，分别重建并重跑 Builtins/Integration。C# 空白格式和 git diff 检查通过，无依赖/锁文件变更。原生媒体、显式外进程及符号链接权限限制继续保留。日志位于忽略产物 artifacts/engine-core-audit/r3-*.log。正式行为见 [runtime](../../docs/spec/runtime.md)、[entry-types](../../docs/spec/entry-types.md)，接入见 [new-presentation-layer](../../docs/manual/new-presentation-layer.md)。完整自定义项目 section 和领域归属仍归 R4/R5，本阶段不将其计为完成。
+
+## R4a：变量单一数据源与仓库输入
+
+ProjectSettings 不再包含 PlayerVariables/SaveVariables，删除命令编辑、快照比较、克隆和保存时的派生副本与同步。变量定义只由 Graph 保存并供运行初始化使用；不保留旧设置变量适配。EditorDocumentRepository.Load 仅接收项目路径，删除一直未使用的项目名与完整设置参数，迁移 GUI、CLI/Shared、外部重载和测试包装器。未使用的 VariableNameRules.Normalize 和重复定义清理分支已删除，保留实际使用的名称验证/清理。
+
+保存断言改为确认 settings 无变量列表、Graph 保留原声明；面板重开继续从 Graph 验证描述、UID 和默认值。完整配置 section 和默认 DTO 归属仍待 R4b/R4c，R4 总阶段尚未完成。
+
+普通输出构建遇到正在运行的用户 Editor 锁定 DLL，保留其进程并改用 artifacts/engine-core-audit/r4a-isolated。locked restore 和同源码隔离解决方案构建通过；固定路径的契约夹具由本次隔离输出补齐，没有取用不明版本 DLL。初次默认并发 restore 未输出诊断即退出并遗留 380 个 MSBuild worker，按父 ID/命令行/启动时间确认后只清理本次 worker；串行 --disable-parallel -m:1 /nr:false 后成功。根因尚未确认，经验补充到现有构建 lesson。
+
+最终相关回归 868 项通过：Editor.Shared 422（3 项既有符号链接权限失败、2 跳过）、Editor 323、Integration 123（1 项既有符号链接权限失败）。初次 Editor 回归 322 通过、1 项 Timeline 测试在 HeadlessUnitTestSession.DisposeAsync 发生空引用，与现有 Avalonia 12.0.5 会话发布竞态 lesson 的失败位置一致；定向 1 项与完整 323 项重跑通过，未修改 Timeline 业务代码，保留原失败日志，不声称修复框架竞态。空白格式和 git diff 检查通过，依赖/锁文件没有变化。日志位于忽略产物 artifacts/engine-core-audit/r4a-*.log。
+
+R4a 收尾时默认输出不再占用，普通 GalNet.slnx 完整构建也通过，日志 r4a-final-standard-build.log。工作区后来出现本地化面板的并行变更，保留且不纳入本阶段提交；868 项回归以本阶段同源码隔离产物为依据。
+
+## R4b：配置协议与默认模型归位
+
+删除 Core.Settings.ProjectSettings，默认作者模型改为可选 Contracts.Builtins.DefaultProjectOptions；Core.Configuration 仅持有版本化配置文档、section/schema 协议，复用 FieldDescriptor/ValueValidation。GameContent、GalProject、作者快照和外部重载统一使用 Configuration，没有旧 Settings 别名。settings.json 改为 version/sections 信封，各 section 带版本与对象 data，不读取旧平铺格式。
+
+类型化读取返回独立 DTO，缺省读取不落盘；显式 Set 在验证后发布，保留 section 中未声明的字段和不认识的 section。生成 DTO 使用字段 codecs/schema 默认，普通 DTO 可显式提供字段描述。未知版本只在声明消费该 section 时检查；修改已知字段失败不发布半份配置，合法更新可修复旧的已知无效值。字段检查与 DTO 解码统一区分大小写，避免未知大小写字段在解码时覆盖已验证值。
+
+项目契约可公开 ProjectSchemas.Configurations；缺省为空，关闭项目/契约时释放对自有 CLR 类型的引用。Editor 打开、保存、结构发布和外部重载应用所选 schema；CLI 编辑与 apply 接收 schema。Storage 不依赖默认模型，由 GameContentLoadOptions 接收 schema 与开发语言选择委托；本地化加载器只接收文化代码。两种 Sample 和默认契约显式选择默认 schema。预览 provider 补齐项目配置副本，避免预览丢失声明的音频配置。
+
+初轮全量回归暴露 caada23 中的语言显示名称输入问题：设置显示字符串触发过滤，候选列表已清空，旧候选匹配无法取得代码。保留新的 Code 绑定，只恢复显示字符串回退的代码提取，单独提交。另去掉 DirectProjectPersistence 为复制配置进行的 JSON 编解码往返，使用文档 Clone；本地化索引单次取得文化代码，避免每条文本重新解码配置。
+
+R4c 仍需完成通用 section 编辑/历史及自有 DTO 的完整导出、安装、运行与预览链路，R4 整体尚未完成。正式协议见 [file-formats](../../docs/spec/file-formats.md)、[runtime](../../docs/spec/runtime.md)，接入见 [new-presentation-layer](../../docs/manual/new-presentation-layer.md)。
+
+最终全量回归 1770 项通过、4 项既有符号链接权限失败、3 项跳过：Core 166、Runtime 141、Builtins 185、Editor 323、Editor.Shared 424、Integration 125、Presentation 243、Architecture 49、Assets 57、GameHost 6、Debugging 10、Diagnostics 1、Storage 22、Generator 18。普通解决方案构建通过，无依赖或锁文件变更；格式和 diff 检查通过。格式工具的 MSBuild 工作区因沙箱命名管道权限不可用，使用 folder 模式完成格式化与只读核验。初轮语言名称失败日志保留，独立修复提交为 `2a92fb6`，最终完整 GUI 回归通过。原生媒体/显式外进程未执行；符号链接环境限制不隐藏。证据位于忽略产物 artifacts/engine-core-audit/r4b-final-build.log、r4b-final-tests.log/trx 与 r4b-format-verify.log。
+
+### R4b 精简
+
+按用户反馈删除配置专用 IFieldDto 分支、ForDto 工厂和无消费者的 DataType/DefaultData，统一普通 DTO + 字段 schema 的 JSON 路径；默认值和候选验证共用 Read。SDK JSON 信封反序列化、重复属性选项及标准序列化替代手写解析/递归检查/输出。Set 在合并后验证一次，持久化移除重复读取/克隆和无效 serializer 配置。保留构造默认值、schema 默认值、未知数据、大小写规则、版本与原子拒绝行为；不把外部同时进行的 Editor 精简混入本次提交。
+
+产品代码净删 88 行，Core 配置从 239 缩到 166 行；测试代码净删 7 行，只移除已删除能力的模拟 DTO，关键行为回归保留。当前工作区并行 Editor 重构曾导致 DebugApplicationProcess.Error/Status/Changed 未定义，未修改这些外部文件；以 1228f94 基线和五个配置改动源码组成独立候选，SHA-256 与提交源码核对一致。候选 locked restore、完整解决方案构建和格式检查通过；774 项通过（Core 166、Architecture 49、Editor.Shared 424、Integration 125、配置相关 GUI 10），4 项既有符号链接权限失败、2 项跳过。原生/显式外进程未执行，NU1900 漏洞源不可达警告保留，无依赖/锁文件变更。证据：artifacts/engine-core-audit/r4b-cleanup-candidate-*.log、r4b-cleanup-results 和 candidate-source.json。
+
+
+## R4c1：通用配置命令与发布链路
+
+用 project.configuration.patch 取代固定设置字段分支，按项目 schema 验证整份 section 候选后发布；values 支持显式 null，remove 表示删除并恢复读取默认值，同键以 values 为准。拒绝未声明字段/section 和不支持的版本，保留已有未知数据。CLI 构建、两种导出、Editor 导出及外部调试构建显式传递所选 schema，无效配置不能覆盖既有产物。没有新增配置框架，产品代码净减 20 行；新增主要为测试夹具与验证。
+
+以 b87297f 为基线组成隔离候选，当前阶段源码 SHA-256 一致。locked restore、完整解决方案构建、格式/diff 检查通过；初轮构建发现 builder 缺少持久化命名空间引用，补齐后最终构建通过。1089 项通过：Core 166、Architecture 49、Editor.Shared 430、Editor 318、Integration 126；Shared 2 项和 Integration 1 项仍因 Windows 创建符号链接权限失败，Shared 另有 2 项跳过。NU1900 漏洞源不可达警告保留，没有依赖或锁文件变更。
+
+ProjectContractPipelineTests 覆盖实际 CLI 修改、显式 null/删除、领域校验整批拒绝、版本拒绝、未知数据、两种导出和安装保留；GameInstallationTests 验证自有 DTO 经命令保存、导出、安装后由所选 schema 重新加载。证据位于 artifacts/engine-core-audit/r4c1-build-final.log、r4c1-restore.log、r4c1-results 与 r4c1-sources.json。协议与用法已同步至 file-formats 和 new-presentation-layer；GUI 通用表单、Undo/Redo 和自有配置的宿主映射属于 R4c2，R4 整体仍在进行中，不恢复内嵌预览。
+
+
+## R4c2：通用表单、历史与宿主投影
+
+删除固定设置/音频编辑模型，用 DtoEditorHost 和 FieldDraftState 生成 section 表单；普通复合值复用 JSON 编辑。草稿应用/保存整批校验，历史只保留数据与必要项目引用，Undo 可恢复缺省 section，未知 section/字段和无关更新保留。命令与 GUI 共享 Configuration.Patch；Resolve 为表单读取 DTO 的有效默认值，不回写原始配置。默认语言声明仍由 I18n 的内容迁移操作维护。AvaloniaGameHostOptions.SelectProjectOptions 将项目 DTO 映射为存档容量、语言和音频声明，宿主启动后缓存这些简单配置，删除宿主对默认 DTO 的直接读取。产品净减 143 行。
+
+11 项定向测试通过；初轮发现语言切换清掉错误提示及新增挂载测试缺少主题，均修正后通过。完整解决方案构建、格式/diff 检查与 1091 项相关回归通过（Core 166、Architecture 49、Shared 430、Editor 320、Integration 126）；3 项符号链接权限失败、2 项跳过保留。新增真实挂载验证覆盖字段输入、批量应用、过期绑定、Undo/Redo、保存、导出、安装及重新打开；安装用例进一步验证自有 DTO 映射存档容量并实际生成对应数量槽位。
+
+显式原生外进程 3 项实际完成启动、变量编辑、Seek、Step、停止/重启和旧 run 拒绝，均在请求关闭后的退出等待超时。首次诊断读取活动日志遇到 FileShare 冲突，改为共享读写读取后暴露真实关闭超时；未吞掉异常或把失败计为通过。日志保留于 artifacts/engine-core-audit/r4c2-native*.log/trx，关闭链路继续纳入 R7/R8；不阻塞其余重构。其他证据为 r4c2-verified-build.log、r4c2-targeted-final.log、r4c2-results。正式用法同步 new-presentation-layer 与 file-formats。
+
+
+## R5a：场景、音频领域归位
+
+Scene/Audio 数据、端口和纯算法从 Core 迁到 Contracts.Builtins；音频执行/后台调度/票据迁入 Primitives.Builtins.Audio，混音输入归可选契约。删除 IGameContext/GameRuntime 的场景管理器要求及无消费者的接口，内置模块通过 runtime.Scene() 使用按 GameState 根隔离的场景服务。GameState 的场景专用字典改为状态契约选择的 keySpace 身份索引，写入/恢复时继续保证跨表唯一性与 O(1) 查询；不保存额外状态镜像。相关领域测试随职责迁移，调试引擎夹具改用自有普通状态，补充通用身份空间写入/恢复测试。产品 C# 净减 31 行。
+
+完整解决方案构建、locked restore、格式/diff 检查通过。14 个测试项目共 1776 项通过，3 项既有符号链接权限失败、3 项跳过；Runtime 115、Builtin 232、Core 147、Presentation 243、Editor 320、Shared 430、Integration 126，其余架构/资源/生成器/宿主等全部通过。验证覆盖场景跨类型冲突、临时控制不入档、旧状态根/旧 scope 隔离、音频队列/drain/恢复及无 Builtins 的自有执行器。23 个锁文件只有项目引用变化，第三方依赖/目标框架/哈希不变。证据为 artifacts/engine-core-audit/r5a-results、r5a-verified-build.log、r5a-locked-restore.log。
+
+R5 整体仍在进行中：Gallery、资源默认策略和 Runtime.Content 的宿主归属留在 R5b；已观察到的原生关闭超时仍归 R7/R8，未计为本阶段原生验收。
+
+
+## R5b：Gallery、资源默认策略与宿主内容归位
+
+Gallery/ImageVariants 领域及默认资源工厂迁入 Contracts.Builtins；GameContent、加载选项、本地化聚合和 GalleryDataSource 归 GameHost。Core 仅保留通用资源协议、metadata 与目录，Gallery 通过可选扩展读写原始注解；未知 annotation 字段在资源复制重编号后仍保留。默认资源类型由 catalog.DefaultType 显式选择，provider/PAK 不再创建默认目录。六个没有额外字段的默认空 DTO 共用 AssetMeta，仅 sprite 保留 filter DTO；删除无生产消费者的 AssetRoot。R5b 产品 C# 净增 35 行，与 R5a 合计净增 4 行，没有新建公共程序集。
+
+全量及受影响重跑共 1779 项通过，3 项既有符号链接权限失败、3 项跳过；Core 114、Builtin 268、Runtime 115、Shared 430、Editor 320、Integration 126、Presentation 243，其余项目全部通过。补充目录自选默认类型、未声明默认时的类型解析，以及可选 Gallery 注解未知字段保留测试。初轮发现旧测试辅助函数仍传 null 目录，迁移为显式选择后 8 项恢复；provider 在构造入口报告缺失目录，不留后续空引用。完整构建、locked restore、格式/diff 通过；18 个锁文件只有项目引用变化，第三方依赖及哈希未变。证据为 artifacts/engine-core-audit/r5b-results、r5b-clean-build.log、r5b-final-*.log、r5b-locked-restore.log；最初失败日志保留。
+
+## R6：唯一参数源与共享基础校验
+
+EntryDefinition 只保留不可为空的 DynamicParameterTable；删除 Parameters/Defaults/Options 的注册期副本和旧字典构造路径。具体编辑器类型与投影归 Editor.Abstraction，UI 按需生成文本和选项。Effect/SEffect 在目录边界转换为已有 FieldDescriptor 并复用 ValueValidation；目标 stage/scope 等领域规则独立保留，输入集合隔离复制。删除 EditorHints 的旧 ABI 重载及其兼容断言，实际 Common 字段测试保留。产品 C# 净减 122 行。
+
+完整构建、格式/diff 检查通过。14 项目回归 1781 通过，3 项创建符号链接权限失败，3 项跳过，1 项 HeadlessUnitTestSession.DisposeAsync 空引用；该 GUI 用例单独复核通过，合计 1782 项功能验证通过。首次测试仍检查已删除的 ABI，移除该断言后构建通过。完整 GUI 319 通过/1 框架释放失败，竞态符合既有 lesson；R8 将复用 Presentation 已采用的框架缓存会话，失败原始日志保留，不把一次重跑记为框架修复。证据为 artifacts/engine-core-audit/r6-final-build.log、r6-results、r6-editor-recheck.log、r6-editor-targeted.log。参数规范已更新；无依赖或锁文件变化。
+
+## R7：执行收尾与快照复用
+
+Engine 的玩家推进、同步呈现、恢复、异步完成、计时播放、追帧、Step/Seek 共用 FinishDispatch：锁内捕获状态，finally 释放唯一执行门，再锁外通知。只释放门禁、已在其他位置捕获状态及分批让出的不同语义继续显式保留。前跳 Seek 对收束后的状态与当前变量使用同一次快照，保持 terminal scene 和变量语义。产品净减 5 行。
+
+审核确认 ContinueUntilBlockedAsync、AsyncPrimitiveInstance、PrimitiveTaskScope 已覆盖真实共享机制；动画、视频、Timeline 的业务完成/失败/恢复差异不再强抽取，不增加 Runner 或布尔策略框架。完整解决方案构建、格式/diff 检查通过；Runtime 115、Builtins 272、Presentation 243、Debugging 10，共 640 项通过。包括取消/自然阻塞完成、Choice、播放模式、Step/Seek、前跳动画终态、变量保留、呈现失败和观察者锁外通知。证据为 artifacts/engine-core-audit/r7-build.log、r7-results。原生关闭与测试框架会话稳定性仍归 R8，未宣称完成原生验收。
+
+## R8：最小组合与最终验收
+
+自有 ProjectOptions 在配置 JSON 往返后直接控制 Engine 自动推进、实际 Avalonia 文本呈现速度和自定义 ambience 分组音量，不使用默认设置 section。既有 ExecutionBoundaryTests 继续证明仅自有分发器的最小执行/恢复无需 Builtins；GUI 配置、CLI、历史、保存、导出、安装和 Sample 三分组的证据沿用各阶段回归。
+
+原生验收修正了两个实际问题：测试的 Process.MainWindowHandle 选择无标题辅助窗口，改为仅定位自有 PID 的明确 Sample 窗口后发送 Close；默认宿主把恢复/Seek 的中间 Ready 映射成 IsPlaying=false，触发 GameShell 返回标题，现保留当前会话状态。真实外进程运行/变量编辑/Seek/Step/停止/重启/旧 run 拒绝与正常退出 3 项通过；真实打包安装、删除作者源后五个不同呈现检查点及正常关闭 1 项通过；原生视频解码/自然结束/提前关闭/延迟加载取消 4 项、音频停止/销毁取消加载 2 项通过。已查看实际呈现场景截图。
+
+Windows 链接测试先创建真实 symlink，仅在错误 1314 时改用无需该特权的目录 junction，继续验证相同 reparse-point/祖先路径拒绝；其他错误不降级，不更改系统设置。六个原先失败/跳过的链接用例现执行产品断言。首次发现一例递归清理 junction 失败，改为测试 finally 显式移除链接，再清理临时目录。此调整验证的是当前路径安全不变量，不声称获得了真实 symlink 特权。当前解决方案已无 Browser 工程，完整构建没有旧 WebAssembly 包哈希失败，不宣称恢复已移除的平台目标。
+
+Editor 与剩余 Integration Headless 测试改用框架缓存 worker，沿用每次 Dispatch 的应用隔离与显式资源释放，不吞框架异常。最终普通回归 14 项目共 1789 通过、0 失败/跳过：Core 113、Runtime 115、Builtins 272、Shared 434、Editor 320、Integration 128、Presentation 243、Assets 58、GameHost 6、Architecture 49、SchemaGenerator 18、Storage 22、Debugging 10、Diagnostics 1。上述 10 项显式原生测试另行执行，不重复计入普通矩阵。
+
+完整解决方案构建、locked restore、格式/diff 检查通过；无第三方依赖/锁文件变更。NU1900 漏洞元数据源不可达及既有分析器警告保留。原生截图首次受沙箱 Pictures 写入权限限制，随后以受控测试权限复验；修正前后的真实失败日志均保留。混合普通/显式 OR 过滤曾只运行普通用例，最终按显式方法/fixture 单独过滤并核对 TRX 数量。
+
+最终回归期间出现独立图校验工作：其提交 0c436b42 和继续进行的其他源码改动不属于本 feature。完整构建/普通矩阵主体基于变动前的本 feature；共享层最后使用 7da84d26 加本 feature 文件的独立候选，62 个 C#/props 源文件 SHA-256 与工作区一致。候选首次缺少 CLI 测试固定查找的 DefaultContracts/bin 产物，补建同源码默认契约后完整 Shared 434 项通过；没有复用旧 DLL。所有权清单与指纹保留，不将其他工作混入 R8 提交。
+
+证据位于 artifacts/engine-core-audit/r8-final-results、r8-results（其中 external-native-final / packaged-native-final / VideoNativeSmokeTests / AvaloniaAudioLifetimeTests 为最终原生结果）、r8-verified-build.log、r8-locked-restore.log、r8-owned-shared-verified.log、r8-owned-sources.json；真实截图保留于 artifacts/image-variants-p5/native。当前规范同步 architecture/runtime/entry-types 与 new-presentation-layer，agent lessons 记录窗口身份和 Ready 映射。
+
+本 feature 无未完成实现或阻塞项。benchmark/profile、缓存/对象池/并行调度仍按用户要求延期；旧数据/API 兼容不保留，其他工作区并行改动单独保留。
diff --git a/features/F-20261026-02-sample-extensibility/design.md b/features/F-20261026-02-sample-extensibility/design.md
new file mode 100644
index 00000000..7a3b0f78
--- /dev/null
+++ b/features/F-20261026-02-sample-extensibility/design.md
@@ -0,0 +1,29 @@
+# 设计：开放现有边界，复用默认实现
+
+## 决策
+
+1. 设置宿主依赖一个小接口，只消费 PlaybackOptions、AudioMixOptions、文本速度及接入/保存/窗口生命周期；项目 DTO 不进入接口。页面仍通过已有 IPlayerSettingsService 读取可选分类，纯 XAML 可直接使用项目服务。
+2. 默认 DI 使用 TryAdd，默认页面 VM 开放继承和必要命令重载。项目通过现有类型注册将默认 VM 别名指向自己的派生 VM，并注册自己的 View；无需新建路由角色/菜单贡献框架。完整 Shell 可由组合根替换。
+3. 将调试专用的运行绑定推广为项目运行绑定，并补玩家绑定；使用 IDisposable 表达借用关系。玩家绑定在资源与设置就绪后接入，运行绑定在 Prepare 完成后接入；停止后释放绑定，最后释放玩家和资源。
+4. 外部变量更新提供小型、带显式 player./save. 作用域的 Engine 批量入口；校验在提交前完成，执行门与状态同步边界内修改。保留稳定检查点的游标与领域状态，仅合入外部显式修改的存档变量。请求绑定调用时的运行 scope，恢复/停止后拒绝旧请求。不把它包装成万能业务事务或任意异步 Runtime 回调。
+5. 本地化的通用查询与 Avalonia provider 桥接分别归中立宿主和 Avalonia 宿主，Sample 只配置资源。保留 culture-first 与按源覆盖的规则，不引入 Runtime 对 UI 库的依赖。
+6. Headless 使用现有玩家服务所有权和 Engine 终态事件，观察输入及保存任务的失败；取消不能伪装成可取消的 Console.ReadLine。
+
+## 用户故事的落点
+
+- 标题按钮/新页面：派生默认 VM 或自有页面 VM + DI + Register。
+- 手写设置：自己的模型/服务实现设置接口，自己的 XAML 绑定；自动 DTO UI 可选。
+- Gallery：已有类型→页面注册；任意图鉴可使用普通页面和自己的数据。
+- 小游戏/手机：项目模块、阻塞 primitive、自己的 XAML/状态/恢复，使用运行绑定与变量入口。
+- 商城：项目玩家级服务、自己的订单与幂等规则；通过玩家绑定取得 profile 服务，运行期修改走 Engine 入口。
+
+## 取舍与风险
+
+- 选择可替换接口和局部继承，避免给每个具体类增加接口或把所有成员 virtual。
+- 变量入口保证显式批量值的预校验及执行同步；不保证网络事务、任意业务回调回滚，也不改变已有阻塞活动的稳定快照语义。
+- 注册/绑定失败必须清理已取得的资源；停止和销毁均不能留下旧回调。
+- 用户已有源码改动不属于本 feature，验证以当前组合工作区为准，提交精确选择本次文件。
+
+## 兼容与迁移
+
+仓库调用方一并迁移接口/绑定命名。公开示例和手册同步更新，不保留无消费者的 Sample 包装。
diff --git a/features/F-20261026-02-sample-extensibility/feature.md b/features/F-20261026-02-sample-extensibility/feature.md
new file mode 100644
index 00000000..cd4f5296
--- /dev/null
+++ b/features/F-20261026-02-sample-extensibility/feature.md
@@ -0,0 +1,42 @@
+# Sample 与默认宿主的项目扩展边界
+
+状态：implementation。用户已确认范围并授权实现、验证及 Git 提交。
+
+## 用户目标
+
+以 Sample.Avalonia 作为未来游戏模板。开发者可以在自己的项目中定制 UI、数据模型、设置、服务、Gallery 和剧情交互；优先开放必要接口、组合和局部重载，不为手机、小游戏、商城逐项建设框架。代码增量应小，设计简洁、低耦合。
+
+## 范围
+
+- 默认设置/启动服务可替换，消费者不强制依赖默认偏好 DTO。
+- 复用现有页面注册、DI 与导航；允许扩展默认 VM、替换服务和手写 XAML。
+- 项目服务可绑定玩家 scope 与当前运行，并随失败、停止和释放清理。
+- 外部变量写入与 Engine 的执行/恢复同步，立即存档不丢失显式修改。
+- 整理共享本地化适配和 Headless 的错误传播/资源所有权。
+- 以真实接入测试和手册说明验证模板可扩展性。
+
+## 非目标
+
+不实现手机、小游戏、商城、通用活动/覆盖层系统、订单协议、任意复杂状态的原地续玩或主题运行期切换；项目通过已有模块、状态恢复、XAML 和服务自行实现业务。
+
+## 约束与依赖
+
+- 底层重构 F-20261026-01 已 completed；以当前接口为基线，不重复它的配置/模块分层工作。
+- 开工时 EntryModule、PrimitiveArgumentHelper、PrimitiveRegistry、CompositeGameView 及 InvocationFieldDecodingTests 存在其他改动；不修改、不提交这些内容。
+- 无兼容层要求；保留有真实用途的现有 API，避免平行框架。
+- 不持有执行锁等待 UI/网络，不将服务/Task 写入存档。
+
+## 验收
+
+1. 自定义设置模型与手写 View 能复用默认会话；默认设置继续恢复、应用、保存。
+2. 自定义标题 VM/按钮/页面可从启动进入并返回；DI 服务可在注册前后替换。
+3. 玩家/运行绑定在正常结束和失败时按所有权释放；过期运行写入被拒绝。
+4. 显式外部变量更新在当前剧情可读，合法检查点立即保存包含更新，玩家变量可落盘重开。
+5. 本地化 culture-first/覆盖/空译文语义保持；Headless 对 EOF/引擎失败返回失败。
+6. 相关构建与回归通过，正式文档、review、summary 完成，提交仅含本 feature。
+
+## 开放问题
+
+无需要再次确认的产品问题。实现细节随代码证据收敛，偏差记入设计及总结。
+
+关联：[设计](design.md)、[阶段计划](phase-plan.md)。
diff --git a/features/F-20261026-02-sample-extensibility/phase-plan.md b/features/F-20261026-02-sample-extensibility/phase-plan.md
new file mode 100644
index 00000000..96b99284
--- /dev/null
+++ b/features/F-20261026-02-sample-extensibility/phase-plan.md
@@ -0,0 +1,23 @@
+# 实施阶段
+
+| Phase | 内容 | 状态 |
+| --- | --- | --- |
+| P1 | 设置/启动可替换、默认 DI 与页面扩展 | verified |
+| P2 | 玩家/运行绑定和显式变量提交 | verified |
+| P3 | 本地化/Headless 整理、集成验证与收尾 | in-progress |
+
+## P1
+
+依赖：底层重构完成。修改 Avalonia.GameHost、GameView、Sample 接线。验证自有设置实现、派生标题 VM/手写 View、已有设置与页面回归。退出：默认与替换路径均实际运行，接口不引用完整默认偏好 DTO。
+
+## P2
+
+依赖：P1。修改 Engine 的有限变量入口及宿主生命周期。验证预校验、检查点、玩家落盘、恢复/停止隔离、绑定失败/释放。退出：同一套默认生命周期支持项目服务，不增加第二个执行门。
+
+## P3
+
+依赖：P2。删除 Sample 中可移入默认宿主的重复适配，修复 Headless 输入/终态/保存观察；同步规范与手册。执行 Runtime、GameHost、Presentation、Integration、Architecture 相关回归与解决方案构建，review 后修复本次问题。退出：有测试证据、review/summary、正式文档及精确 Git 提交；任何环境限制明确保留。
+
+P1 证据：手写 ProjectSettingsView.axaml、派生标题命令及默认服务接入已运行；首轮定向 Integration 38 项通过，日志 artifacts/sample-extensibility-integration.log。Runtime 新增变量入口 7 项已通过，生命周期扩充验证继续归 P2。
+
+P2 证据：ExternalVariableTests 7 项通过；SampleExtensibilityTests 3 项通过，包含玩家设置真实落盘重开、Prepare 后接入运行、替换/停止/失败恢复及异步绑定释放。测试曾因 UI 回调中的 ThrowsAsync 同步阻塞而挂起，改用直接 await/try-catch 后通过，复用既有 L-20261015-02-ui-tests-await-failures，不新增重复 lesson。日志 artifacts/sample-extensibility-runtime.log、sample-extensibility-lifecycle.log。
diff --git a/features/F-20261026-03-default-visual-library/catalog.md b/features/F-20261026-03-default-visual-library/catalog.md
new file mode 100644
index 00000000..85990992
--- /dev/null
+++ b/features/F-20261026-03-default-visual-library/catalog.md
@@ -0,0 +1,33 @@
+# 默认项目视觉内容清单
+
+本清单区分本 feature 实施内容与后续候选；最终验证状态以 phase-plan / summary 为准。
+
+## 第一批实施（P1–P4 已验证）
+
+| 分类 | 内容 | 行为 |
+|---|---|---|
+| 效果 | Bloom | 亮部阈值、半径、强度 |
+| 效果 | 高斯 / 方向模糊 | 可动画半径，组合横纵两遍 |
+| 效果 | 暗角 | 中心、半径、柔和度、强度 |
+| 效果 | 调色 | 曝光、饱和度、对比度、暖冷色 |
+| 效果 | 图层 Z 景深 | 明确选定参与图层，每次绘制读取当前 Z，焦点与范围可动画 |
+| 程序图层 | 动态集中线 / 速度线 | 时间、速度、密度、中心、方向、闪烁、颜色 |
+| 转场 | 柔边擦除 / 径向开合 / 噪声溶解 / 百叶窗 | 图层 shader 遮罩，进度可动画 |
+| 转场 | 图片遮罩溶解 | 作者提供遮罩图；通用 shader texture 参数绑定已实现 |
+| 转场 | 模糊交叉淡化 | 双层淡化与模糊包络 |
+| 演出 | 震动 / 跳跃 / 点头 / 摇头 / 颤抖 | 相对叠加并以零偏移结束 |
+| 演出 | 定向推近 / 推拉 / CG 缓移 | 锚点与方向分开，可保留终态 |
+| 演出 | 淡入淡出 / 滑入滑出 / 弹入 | 接受目标图层及明确参数 |
+| 演出 | 集中线闪烁 / 冲击组合 | 自建程序图层，时间线驱动并清理临时实例 |
+
+已有 crossFade、slide、blinds、fadeBlack、fadeWhite、fadeColor 保留。
+
+## 后续候选（此次不宣称完成）
+
+- 效果：径向与缩放模糊、胶片噪点/划痕、色差/故障、波纹/热浪、局部聚光/轮廓光、像素化/反相/色阶化。
+- 转场：缩放切场、曝光闪光、像素化、故障、翻页/幕布。
+- 编排：说话人强调、镜头跟随、心跳、回忆/梦境、章节标题、多段黑场演出。
+- 氛围：雨雪、樱花、尘埃、萤火虫的粒子与调色配方。
+- 进阶景深：单张图片深度图、遮挡边缘处理、散景、真实相机参数。
+
+后续项有些可用已有 Entry 手动组合；需要独立验证其产品参数和生命周期后才成为默认预设。
diff --git a/features/F-20261026-03-default-visual-library/design.md b/features/F-20261026-03-default-visual-library/design.md
new file mode 100644
index 00000000..89c3fdd6
--- /dev/null
+++ b/features/F-20261026-03-default-visual-library/design.md
@@ -0,0 +1,72 @@
+# 设计
+
+## 当前事实
+
+GameTestCase 有 Bloom / Blur / ColorGrade / Blinds 项目资源。Composite 已将转场展开为 timeline.play；效果 time 可由时间线驱动。渲染支持 layer 与 scenePost，shader 的 size uniform 自动绑定。图层 Z 当前仅决定合成顺序。shader texture 参数尚无纹理解析器。
+
+## 设计方向
+
+默认资源作为显式项目资产部署，不新增运行时按名字回退的隐藏效果目录。编辑器安装包可嵌入初始化模板；新建默认项目时，在原子 staging 中将 `.sksl` 与 metadata 复制到 `Assets/Effects/`，并创建项目自己的默认视觉资源绑定。dry-run 准确报告新增文件。自定义契约项目不隐式注入内置内容。
+
+项目资产是预览、运行与导出的唯一资源来源；更新编辑器不会自动覆盖已有项目。已有项目通过显式补入操作添加默认资源，遇到已有文件或绑定保留作者修改，不自动替换。
+
+## 已确认的资源引用与 Entry 设计（2026-10-26）
+
+用户已确认：
+
+1. 单个 shader 不新增独立效果 Entry，统一使用现有 `effect.apply` / `effect.stop`。默认项目提供的是 shader 资产和默认绑定。
+2. 转场、集中线和冲击等需要编排的演出保留 Composite Entry。预设通过显式资源参数接收 shader；多个 shader 使用具名参数，如 `linesProgram`、`blurProgram`。遮罩图片等也作为独立资源参数传入。
+3. 项目配置保存用途到 shader 资源 ID 的默认映射，例如 `speedLines`、`blur`、`reveal`。用途键用于创作便利，不是运行时的效果 ID，也不要求 shader 的 GUID 固定。
+4. 编辑器添加预设时读取项目绑定，将实际资源 ID 写入 Entry。作者可在 Entry 上改选其他项目 shader。修改项目默认绑定只影响之后的填充，不追改已有 Entry。
+5. 编译器读取 Entry 上的明确引用，并原样写入生成的 `effect.apply.program`。编译器不持有 shader 对象、不读取编辑器安装路径，也不通过用途名或硬编码默认 GUID 补齐资源。
+6. 默认绑定缺失时，创作表单保留未填字段并提示选择；完整编译拒绝缺失必需引用。CLI / 外部作者显式传入同样的资源参数，不依赖编辑器补默认值。
+7. 替换 shader 需要满足配方所需契约：如遮罩转场要求可动画 float `progress`，集中线要求可动画 float `time`，并支持对应 layer / scenePost stage。stage、参数类型与可动画性由项目资源 metadata 校验；不把“任意 shader 可用于任意预设”作为承诺。
+8. 预设参数中的 shader / 图片引用以及项目配置绑定需要进入资源依赖检查。编译后时间线事件中的引用也必须被导出依赖收集识别。
+
+数据流：初始化模板 → 项目 shader 资产与用途绑定 → 编辑器填入复合 Entry 的资源参数 → 编译得到显式 `effect.apply` 与动画计划 → 运行时按项目资源 ID 加载。
+
+已实现的配置示例（资源 ID 为占位符；字段位于 galnet.project section 的 data 内）：
+
+```json
+{
+  "defaultVisualPrograms": {
+    "speedLines": "<project-speed-lines-shader-id>",
+    "blur": "<project-blur-shader-id>",
+    "reveal": "<project-reveal-shader-id>"
+  }
+}
+```
+
+```json
+{
+  "type": "preset.speedLines",
+  "parameters": {
+    "playbackHandleId": "impact-lines-01",
+    "program": "<project-speed-lines-shader-id>",
+    "durationFrames": 60,
+    "speed": 2
+  }
+}
+```
+
+上述 type ID 与字段名已实现；资源 ID 占位符需要替换为项目自身 GUID。预设编译生成承载图层、效果实例、时间/透明度轨道和末尾清理；资源 ID 从输入传递，临时实例 ID 与资源 ID 分开。
+
+视觉配方契约与纯时间线编译位于 Contracts.Builtins；SkSL 及模板部署资源由 Editor.Shared 分发，平台渲染能力留在 Rendering / GameView。效果资源不进入 Core。
+
+集中线使用透明颜色图层作为承载，layer shader 生成带预乘 alpha 的程序线条；time 为逻辑动画时间，无墙钟自动播放。场景级冲击可将同一 shader 用于 scenePost；组合优先使用临时图层，结束时释放。
+
+景深显式选择参与图层，各图层应用相同参数的 DepthBlur。渲染向支持的 shader 注入当前 layerZ，每次绘制重新读取；radius = clamp((abs(layerZ-focusZ)-focusRange)*falloff,0,maxRadius)。这样移动 Z 后仍生效，不扩展 Core 成为 3D 引擎，也不让对话 UI 失焦。第一版不自动覆盖之后新增的图层。
+
+图片遮罩通过通用 texture 参数解析补齐，不绑定某种具体转场类型。所有 shader 纹理租约由对应效果实例拥有，停止/替换/页面释放时释放。
+
+## 组合与边界
+
+组合优先只输出一个 timeline.play，沿用事件、轨道、存读档与快进机制。临时 ID 从显式 playbackHandleId 派生；调用方保证播放期间唯一。相对动作使用 Additive 并回到零；保留终态的镜头/登退场明确使用 Replace。取消语义沿用现有 animation.stop；不宣称取消一定执行末帧清理，必须验证并说明。
+
+默认配方需要编辑器能分析其展开，不让新增类型全部变成 opaque。新转场复用既有分析，演出按编译结果传递状态。
+
+## 取舍
+
+- 先交付推荐的第一批和同底座简单预设，完整远期列表保留在 catalog，避免承诺未经设计的翻页与真实 3D 景深。
+- 不新增默认自动开启的全局滤镜，也不修改现有项目资产。
+- 使用仓库已有 shader 与原创实现，避免第三方许可与外部服务依赖。
diff --git a/features/F-20261026-03-default-visual-library/feature.md b/features/F-20261026-03-default-visual-library/feature.md
new file mode 100644
index 00000000..c8141c8e
--- /dev/null
+++ b/features/F-20261026-03-default-visual-library/feature.md
@@ -0,0 +1,35 @@
+# 默认视觉效果与演出库
+
+状态：complete（约定首批 P1–P4 已验证；远期候选见 catalog）
+
+## 原始目标
+
+默认项目提供更多 SkSL 效果（Bloom、模糊、暗角、按 Z 景深）、转场与通过组合 Entry 编译的动画预设。集中线必须动态，优先 shader 图层；整理候选内容到文件并按 feature 流程实施。
+
+## 范围与验收
+
+- 提供可随默认项目部署、可编辑、按需启用的效果资源，不能只在 GameTestCase 可用。
+- 集中线由时间动画驱动，支持径向与定向运动、闪烁，不依赖静态贴图。
+- 第一批实现上一轮明确推荐的 Bloom、模糊、暗角、调色、Z 景深、柔边擦除、遮罩溶解、模糊转场、震屏、定向推近、集中线、登退场、冲击组合，并扩展复用同一基础能力的预设。
+- 完整候选清单见 [catalog.md](catalog.md)，明确实现与后续范围；不将列表中的全部研究项视为已实现。
+- 组合编译为现有 timeline.play 时间线及 effect/layer 等原语；保持 Core/Runtime 平台无关。
+- 每种 shader 不单独新增 Entry，效果统一使用 effect.apply / effect.stop；具有编排价值的转场与演出提供复合 Entry。
+- 初始化部署项目 shader 资产及用途绑定；编辑器创作时将实际资源 ID 填入预设参数，作者可覆盖。编译使用已保存的显式引用，不依赖隐藏默认 shader 或固定 GUID。
+- 校验替换 shader 与配方所需 stage、参数类型和动画能力匹配，确保资源依赖检查及导出识别生成时间线中的引用。
+- 校验 shader 编译、像素行为、时间变化、组合展开与清理、项目创建部署；更新用户手册。
+
+## 约束与假设
+
+- 用户本轮已授权实现代码，无需再次确认。
+- 默认有资源不等于默认开启强后处理。
+- Z 是图层排序；景深按图层 Z 计算，不承诺单张图片内部的真实几何景深。
+- 不覆盖当前编辑器作者一致性工作区修改。
+- 不引入来源不明的第三方 shader；复用本仓库示例或原创实现。
+
+## 文档
+
+- [设计](design.md)
+- [阶段计划](phase-plan.md)
+- [交付总结](summary.md)
+- [交付自审与后续边界](review.md)
+- [使用手册](../../docs/manual/default-visuals.md)
diff --git a/features/F-20261026-03-default-visual-library/phase-plan.md b/features/F-20261026-03-default-visual-library/phase-plan.md
new file mode 100644
index 00000000..87548b38
--- /dev/null
+++ b/features/F-20261026-03-default-visual-library/phase-plan.md
@@ -0,0 +1,35 @@
+# 阶段计划
+
+## P1 效果资源与默认项目部署 — verified
+
+补齐 Bloom / Blur / Vignette / ColorGrade / DepthBlur / SpeedLines / Reveal 等资源、项目用途绑定和默认模板部署。模板可内嵌于编辑器，部署后作为项目资产使用，不要求全项目固定 GUID。验证 metadata、SkSL 编译、项目 staging 与 dry-run，以及已有内容补入时保留修改。退出：资源能加载且默认项目获得可编辑源文件和指向自身资产的默认绑定。
+
+结果：8 个 shader（含 MaskReveal）嵌入 Editor.Shared 初始化模板；默认项目创建将其复制为普通项目资产并生成自身 GUID。新增 `galnet.project.defaultVisualPrograms`；纯自定义契约和无契约 scaffold 不注入资源。准备计划克隆配置、保留已有绑定及未知 section，重复准备不替换已绑定资产。已有项目的用户入口留到 P4 集成，不将 Prepare API 宣称为已上线的补入命令。
+
+验证：ProjectCreationTests + DefaultVisualTemplateTests 共 9 项通过；DefaultVisualShaderTests 共 8 项通过（metadata 及 SKRuntimeEffect 实际编译）。Editor.Shared 串行构建 0 警告/0 错误（RunAnalyzers=false）。普通多进程构建曾无诊断退出，串行构建通过；受限环境 testhost 连接超时，沙箱外相同测试通过，未将该超时归因为业务代码失败。尚不宣称 DepthBlur 的 layerZ 注入或 MaskReveal 的纹理绑定完成，二者属于 P2。
+
+## P2 渲染能力 — verified
+
+注入图层 Z；补齐 texture 参数租约和绑定。验证景深在 Z 变化后更新、遮罩真实采样、alpha 与资源释放。退出：CPU 像素证据与已有渲染回归通过；GPU 路径共享绑定代码并构建通过。
+
+结果：CPU/GPU 层效果链每次绘制传入当前图层 Z，通用 shader 自动绑定保留的 `layerZ` uniform；外部 texture 参数按画布缩放，缺省可选纹理绑定透明值。默认宿主向效果运行器注入 AssetManager，各效果独立拥有纹理租约；替换/停止/Dispose/部分准备失败释放。异步准备使用实例代次防止停止后复活。27 项 shader/像素/生命周期及既有效果测试通过；GameHost 构建通过（既有 BuiltinScene nullable 警告 1 项）。像素测试验证移动 Z 后失焦及恢复、径向/定向集中线随 time 变化、遮罩实际采样及缩放。GPU 共享绑定路径构建通过，未宣称本阶段有真实 GPU 截图验收。
+
+## P3 转场与演出组合 — verified
+
+实现 catalog 第一批组合，带 schema、边界校验、临时资源清理和作者分析；不为每种 shader 新增效果 Entry。编辑器从项目用途绑定填充显式资源参数，编译器只传递 Entry 上的引用。验证缺失绑定、手动替换、项目绑定变更不追改旧 Entry、CLI 显式参数、shader 契约匹配与生成事件的资源依赖。验证展开、末帧、短时长、非法参数、不同播放 handle、快进/停止行为。退出：推荐第一批可调用且编译结果通过现有时间线验证，导出包含所需 shader 与纹理。
+
+结果：新增 transition.reveal（Wipe/Radial/Noise/Blinds/Mask）、transition.blur、preset.motion（9 种动作）、preset.shake（最多 32 个同步图层）、preset.speedLines、preset.impact，共 6 个 Composite；未新增 shader 专用 Primitive。资源检查在项目 ValidateGroup / build / export 入口验证资源存在、layer stage、参数种类/可动画性/范围。编辑器插入与类型切换填充用途绑定；CLI 编译仍要求显式资源。场景分析编译复合时间线，引用/复制支持 targets[].handleId。新增四种编辑器语言标签。
+
+验证：Builtins 完整 306 项通过；Editor.Shared 完整 447 项通过；后续范围检查调整后 4 项资源/作者用例再次通过；独立 artifacts 输出的桌面作者交互 9 项通过（实际预设创建/类型切换/Undo/Redo/保存重开、6 种原转场选择器、引用审查、批量插入）。两帧短时长、不同模式、锚点推近、显式引用传递、末帧清理、Normal/Quick/CatchUp 稳定状态与快照恢复均有测试。普通 Editor 输出被已打开的编辑器 PID 锁定，改用独立输出；未关闭用户进程。animation.stop 的现有 Cancel/Replaced 语义不承诺执行末帧清理；完整收尾使用 CompleteImmediately，P4 手册说明。
+
+## P4 展示、回归与文档 — verified
+
+提供可运行展示与手册，运行相关构建/测试，审查 diff；summary 逐项报告实现与限制。退出：第一批验收证据齐全，远期项明确保留。
+
+实现：新增 project visuals install 显式补入命令，复用 ProjectApplyService 的候选验证、原哈希检查和作者文件事务；保留已有绑定，拒绝占用路径，支持 dry-run/重复执行。GameTestCase ending 接入首批效果、切焦、动作、两种集中线及转场，两个语言与两条路线共用；样例 shader 作为普通项目资产保存。手册和 spec 同步。
+
+视觉复核修正：CPU contact sheet 暴露了稀疏景深网格重影与块状集中线；景深改为中心加 48 点圆盘采样，集中线改为连续细线和像素覆盖抗锯齿。128×128 定向线回归曾复现全透明，修正后通过。证据为 artifacts/visual-library-preview.png 及显式 WriteDefaultVisualPreview。真实 GPU 截图与性能专项未执行，不能把 CPU 视觉结果表述成 GPU 验收。
+
+最终验证：Shared 完整 448 项通过；Presentation 完整 257 项通过；GameTestCase 集成 7 项通过，包含双语两路线及从实际 PAK 读取八个 shader 与遮罩图片；安装/CLI 帮助相关 13 项通过（包含于 Shared 完整集）。Builtins 306 项、桌面作者交互 9 项在 P3 通过。CLI 完整项目校验无 error；32 条现有开放 JSON 的 localization opaque/incomplete 警告保留，不宣称静态分析完全。原示例忽略的 Contracts DLL ABI 过期，重建并本地部署后验证；二进制不纳入提交。上次自动审批服务额度限制导致一次导出测试未执行，恢复后重跑通过。
+
+格式：dotnet format whitespace GalNet.slnx --no-restore --include（本 feature 已跟踪与新建 C# 文件）--verify-no-changes 通过；git diff --check 通过。收尾仅修正本 feature 的空白格式，未改动无关代码。交付自审为 pass-with-follow-up；GPU 截图和性能专项保留为后续。
diff --git a/features/F-20261026-03-default-visual-library/review.md b/features/F-20261026-03-default-visual-library/review.md
new file mode 100644
index 00000000..d5a3eb79
--- /dev/null
+++ b/features/F-20261026-03-default-visual-library/review.md
@@ -0,0 +1,23 @@
+# 交付自审
+
+结论：pass-with-follow-up。此为实施者依据代码、差异与测试证据的自审，未声称独立 reviewer 审核。
+
+## 已核对
+
+- 效果资源属于项目；初始化模板不构成运行时 fallback。
+- 默认用途绑定只影响创作填充，复合编译传递显式资源 ID；未新增 shader 专用 Primitive。
+- 时间线包含动态 time / progress / radius 轨道、结束事件及临时资源清理；同步震动使用回零 Additive 轨道。
+- shader 替换在项目边界检查资源、stage、字段种类、可动画性和数值范围；shader / 图片导出到 PAK 有实际读取验证。
+- 纹理租约覆盖停止/替换/Dispose/准备失败；每次绘制注入图层 Z。新字段和代码不进入平台无关 Core。
+- 默认项目部署、自定义契约边界、旧项目补入、路径冲突、dry-run、重复执行和作者修改保留有测试。
+- 场景分析、targets[].handleId 引用索引/复制重映射、创作填充与 Undo/Redo/保存重开有验证。
+- CPU shader 像素与 contact sheet 已检查，采样问题修正后复验。
+
+## 已知边界 / 后续
+
+- 真实 GPU 场景截图与性能专项仍需单独执行；本次 GPU 路径为共享绑定代码构建验证。
+- 取消/被替换沿用现有时间线语义，不保证执行末帧清理；完整收尾使用 CompleteImmediately，手册已说明。
+- 图片内部深度图、散景、故障/水波等远期候选未实现；见 catalog。
+- 开放 shader parameters / timeline JSON 仍可能产生本地化静态分析 opaque 警告，不作为已完成全静态引用分析的证据。
+
+未发现阻止约定首批交付的问题。验证计数与命令范围见 phase-plan；feature 修改/新建 C# 文件的格式检查及 git diff --check 已通过。
diff --git a/features/F-20261026-03-default-visual-library/summary.md b/features/F-20261026-03-default-visual-library/summary.md
new file mode 100644
index 00000000..9250605e
--- /dev/null
+++ b/features/F-20261026-03-default-visual-library/summary.md
@@ -0,0 +1,51 @@
+# 阶段交付记录
+
+整体状态：约定首批已完成，P1–P4 verified。完整候选清单中的后续内容不属于本批交付。
+
+## P1
+
+- 新建默认契约项目获得 8 个可编辑 SkSL 资产及自身 metadata；运行不依赖编辑器模板。
+- `defaultVisualPrograms` 保存项目用途绑定；准备阶段保留作者已有值，不改变传入配置。
+- dry-run 报告包含将要部署的 shader/metadata；自定义契约和无契约 scaffold 维持显式能力边界。
+- 9 项初始化/CLI 测试及 8 项真实 shader 编译测试通过。
+- P1 提交时 DepthBlur / MaskReveal 仅有可编译资源，后续 P2 完成实际 Z 注入与外部纹理绑定，P3 完成预设与创作入口，P4 完成展示和文档。
+
+## P2
+
+- CPU/GPU 纹理链传入当前图层 Z，DepthBlur 读取每次绘制的实际值。
+- 补齐通用 texture 参数加载、缩放与绑定，租约跟随效果实例，覆盖替换/停止/释放/准备失败；异步准备失效后不重新发布。
+- 27 项实际 shader、像素及既有效果测试通过。默认宿主构建通过；真实 GPU 视觉验收尚未执行。
+
+## P3
+
+- 六个 Composite 编译为既有时间线：shader 遮罩转场、模糊淡化、人物动作、多层震动、动态集中线、冲击演出。
+- 编辑器在插入/类型切换时填入项目绑定；保持显式可替换资源引用，编译器不查找默认 shader。
+- 项目验证检查 shader 元数据契约、动画范围和遮罩资源；现有导出包含全部项目资产，不依赖扫描参数名裁剪资源。
+- 场景分析及复制支持复合演出和 targets[].handleId。
+- 306 项 Builtins、447 项 Shared、9 项桌面作者交互通过。普通 Editor 输出锁定，使用隔离 artifacts 验证。
+
+## P4
+
+- 新增 `project visuals install <project> [--dry-run]`，通过现有作者文件事务显式补入缺失资源和绑定。保留已有 shader 修改及绑定，拒绝覆盖占用路径，重复执行无变化。
+- GameTestCase 两条路线的 ending 组演示首批效果、景深切焦、人物动作、同步震动、动态径向/定向集中线、冲击、擦除/模糊/图片遮罩转场，提供中英文文本。
+- CPU contact sheet 视觉复核发现并修正景深采样网格重影和块状集中线；低分辨率线条抗锯齿问题由像素测试复现并修复。预览由显式 `WriteDefaultVisualPreview` 生成到 `artifacts/visual-library-preview.png`，不提交生成物。
+- 最终 Shared 完整 448 项、Presentation 完整 257 项通过；GameTestCase 7 项集成通过，实际导出 PAK 中八个 shader 与遮罩图片可读取。显式预览生成 1 项通过。P3 的 Builtins 306 项和桌面作者交互 9 项保持有效；之后编译器/测试助手仅进行空白格式调整。
+- feature C# 文件的格式检查和 git diff --check 通过。自审结论 pass-with-follow-up。
+
+## 实现决定与边界
+
+- 不新增 shader 专用效果 Primitive；六个复合入口展开为 `timeline.play`，所有 shader 引用来自作者 Entry 的显式参数。
+- 稳定项目资源 GUID 与临时演出实例 ID 分离；项目配置的用途绑定只用于创作填充。
+- 按图层 Z 景深需要显式选择参与图层；不提供图片内部深度图和散景。
+- 正常完成/快进清理临时对象。取消/被替换沿用已有语义，不保证末帧事件执行；需要完整收尾时使用 `CompleteImmediately`。
+- GPU 路径共享绑定代码构建通过，但本批没有真实 GPU 截图/性能验收；CPU 像素与视觉检查不能替代该验证。
+- 开放 JSON 的本地化 opaque/incomplete 警告继续报告，样例完整 CLI 校验无 error、保留 32 条 warning。不把静态候选引用查询描述为完全分析。
+- 旧项目补入通过 CLI 提供；未新增专属 GUI 安装按钮。契约 DLL ABI 变化仍需用户重建部署/重开项目，本地示例忽略的旧 DLL 已更新用于验证，二进制未入库。
+
+## 文档与提交
+
+- [使用手册](../../docs/manual/default-visuals.md)、[Entry 规范](../../docs/spec/entry-types.md)、[资源规范](../../docs/spec/assets.md)。
+- P1 `398f2cbb`：初始化 shader 与用途绑定。
+- P2 `f8d33f4c`：图层 Z 与租约纹理绑定。
+- P3 `882af07b`：转场、演出及作者集成。
+- P4 为本收尾提交，包含样例、补入命令、视觉修正、测试和文档。
diff --git a/features/F-20261027-01-audio-mixer/authoring-design.md b/features/F-20261027-01-audio-mixer/authoring-design.md
new file mode 100644
index 00000000..de1e1667
--- /dev/null
+++ b/features/F-20261027-01-audio-mixer/authoring-design.md
@@ -0,0 +1,121 @@
+# 音频效果创作与目标分析设计
+
+2026-10-27，状态：implemented，音频创作范围验证通过；[实现与验证](authoring-summary.md) 区分当前能力和全仓保留项。用户确认效果类型通过 ComboBox 选择、创建实例身份自动分配并隐藏，停止时先选 Track/Bus 再选择已有的效果；选择、身份和分析尽量复用 Layer 等已有机制。本文件补充 [后端设计](design.md)，不改变已验证的 PCM/DSP 架构；以下保留设计取舍，当前实现事实与验证结果见实现记录。
+
+## 当前事实与问题
+
+当前 `audio.seffect.apply` 的 `id`、`instanceId` 仍是普通文本，`parameters` 为 JSON。`targetId` 已根据 `scope` 选择项目声明的 Track 或 Bus。运行时按 `(scope, targetId, instanceId)` 保存效果；同键 apply 为更新，stop 只移除该键，找不到时无操作。Runtime 会拒绝空的应用实例身份；stop 的空键仍是精确查找且通常无操作，不能改解释为“全部”。
+
+Editor 已有 `SceneAuthoringSemantics` 输出/引用声明、`SceneAuthoringIdentities` 自动身份和批量复制重映射、剧情位置分析、项目查询代次和选择 lease、`ResourcePickerPanel`。音频效果目前在场景语义中属于中立条目，尚无音频效果候选。场景对象结构包含动画属性等视觉专用数据，不能直接把音频效果当作可动画 Layer。
+
+## 作者交互
+
+### 创建效果
+
+表单顺序：作用对象类型（Track/Bus）→ 具体目标 → 效果类型 ComboBox → 类型对应的参数字段。
+
+- 类型选项来自 `ISEffectCatalog`，按 `SupportedScopes` 筛选。展示本地化名称“增益、低通、高通、混响”，保存稳定类型键，如 `seffect.reverb`；不再提供常驻 ID 文本输入。
+- GUI 创建条目时一次性生成隐藏 `instanceId`。刷新、展开表单、改参数、改效果类型、保存重开和运行该条目均不重新生成。循环再次执行同一条目更新同一目标上的该实例，不不断追加处理器。
+- 参数使用共享表单字段和数值校验，混响显示空间大小、衰减时间、高频阻尼和干湿比例，滤波显示截止频率与 Q。以目录元数据生成，不在控件中另写一套类型/范围判断。
+- 目录补充稳定的默认值及展示元数据；参数默认值由契约、DSP 和作者表单共用，不能只改 UI 默认值。语言资源在 Editor 中适配，音频契约不引用 Avalonia。
+- 修改类型时保留实例身份；该次明确操作原子替换为新类型及其参数，旧类型参数不按同名猜测迁移。打开/刷新未知类型或未知参数时保留原 JSON 并提示，不自动换成第一个有效选项。
+- 改 scope/target 会重新筛选类型；不再适用的旧类型显示诊断，等待明确选择。目标改变不会自动改写其他条目引用；旧 stop/update 引用应被诊断，避免暗中改停另一个目标。
+
+### 停止效果
+
+表单顺序：作用对象类型 → 具体目标 → 该目标在当前剧情位置之前已有的效果。效果下拉显示类型、创建来源与一定/可能存在标记；同类型多个实例分别列出，例如“混响 · 房间进入/第 3 条”和“混响 · 梦境开始/第 2 条”。来源标签不作为持久身份，不要求作者取名或填写 GUID。
+
+列表只包含直接挂载在选中目标上的实例。Track 经过 Bus 混响并不表示 Track 自己挂了混响；停止这个 Bus 的混响必须选择该 Bus。不能按效果类型批量猜测要停止哪个实例。
+
+“全部效果”是明确选项，序列化为独立的 `all: true`；默认 `all: false`。单个实例选择保存 `instanceId`。`all=true` 与非空实例同时给出属于无效输入；`all=false` 且未指定实例时仍按旧的精确空键处理（通常无操作），GUI 不创建空身份。清空字段、候选为空和引用失效都不代表停止全部。
+
+运行时停止全部只移除该目标执行时已经存在的所有效果，包含静态分析未能列出的实例；不影响以后新增的效果或其他目标。逐实例清理和后端命令沿用已有平滑移除路径，逻辑状态在同一次状态更新中完成。
+
+### 修改已有实例
+
+编辑原创建条目的参数属于创作修改，不产生新实例。剧情后续位置调整已有实例需要引用语义，不能伪装成另一个自动生成身份的创建者。
+
+设计建议新增 `audio.seffect.update`：先选目标和已有实例，再按其类型展示参数；不选择新的类型、不生成输出身份、不暴露 `id`。提交的参数为字段 patch，Runtime 从当前实例合并后，用相同目录完成整体验证，再更新该实例并保持链位置。目标不存在时无操作，不隐式复活。缺少新类型选择也避免把“调整混响”误用为“替换成滤波器”。
+
+本轮采用新增 update Entry 的实现方式，已与创建/停止一起交付；设计阶段允许拆分实现阶段。不能通过手工填写隐藏身份作为临时产品入口。update 候选在分支中类型不唯一时不能伪造参数表单，应提示先选择类型一致的来源或调整剧情结构。
+
+## 数据与身份
+
+| 字段/概念 | 作用 | GUI 表现 |
+| --- | --- | --- |
+| `scope` + `targetId` | 指向项目声明的 Track 或 Bus | 两级选择，共用目标字段适配 |
+| `id` | 稳定效果类型键 | ComboBox 的值，显示类型名称 |
+| `instanceId` | 挂载实例身份 | 创建时隐藏输出；stop/update 中通过选择候选写入 |
+| Locator | Group/稳定 Entry/输出槽位等作者来源 | 选择与重查依据，不替换 Runtime 的线格式 |
+| `all` | stop 的显式整目标操作 | “全部效果”选项 |
+
+音频使用独立 `AudioEffect` 身份域；运行时匹配和分析键均包含 `(scope, targetId, instanceId)`。即使遗留内容在不同 Track/Bus 复用同一字符串，也不能串选、串停或误重映射。新 GUI 输出虽使用 GUID，分析与复制仍不能依赖字符串全局唯一的假设。
+
+自动生成、输出隐藏、引用索引和复制统一消费输出/引用语义声明。Group/Graph 批量复制先分配新输出，再在同身份域和相同原挂载目标内重映射批内引用；外部实例引用、Track/Bus 声明 ID、效果类型 ID、普通参数字符串不改。Undo/Redo 复用该次操作生成的身份。改 Entry 类型只保留角色与身份域相容的输出。
+
+同一运行时键可能来自不同分支的不同创建者，查询应保留来源集合与类型可能集合；不能随意选一个 Locator 代表全部来源。停止可按同一精确键操作；类型不一致会限制后续参数编辑，但不会让停止变成类型匹配。
+
+## 复用架构
+
+目标是复用一套作者位置、Graph 传播、身份和选择有效性规则，不复制一份只把 Scene 改名为 Audio 的分析器。
+
+| 层 | 复用与新增职责 |
+| --- | --- |
+| 作者语义声明 | 在既有输出/引用目录增加音频域、目标限定和 apply/stop/update 语义；支持“对某个目标的全部实例”这一非单实例操作 |
+| Editor.Shared 纯分析 | 复用 Graph 遍历、条件分叉、固定点、预算、Group 前缀缓存和位置边界；增加独立音频效果状态与转移，不依赖设备/播放器 |
+| 项目查询服务 | 共用作者快照、位置和生命周期；分域提供场景对象、播放控制、音频效果结果与完整性，避免一个域未知就污染所有域 |
+| 目录/选择适配 | 复用候选来源描述、快照与写入方版本检查、失效取消；音频适配增加 scope/target 过滤与类型名称 |
+| 字段控件 | 复用 ComboBox、共享参数表单、必要时的 ResourcePickerPanel；控件不扫描 Graph，也不持有 Runtime |
+| Runtime/音频后端 | 保留目标级混音/DSP；补 stop-all 和 update 的明确契约，执行不依赖 Editor 的候选列表 |
+
+实现时只提取两类消费者确实需要的公共位置、身份与数据流机制，保留现有 Scene 查询外观作为适配。不同领域的 payload、状态转移和完整性独立；不为了命名统一强制重命名全部 Scene API，不引入可执行项目扩展的通用插件分析框架。已有视觉/播放候选顺序、属性能力和失效语义必须回归。
+
+目前音频条目对视觉场景中立，这一点仍成立；增加音频转移不能让视觉分析把它当未知场景操作。相反，已知纯视觉条目对音频域中立。未知自定义条目无法证明不修改音频时，音频事实应保守降级，不调用该条目求结果。
+
+## 音频事实与查询规则
+
+数据流：已提交作者快照 + 项目音频声明 + 效果目录 → 共享位置/Graph 分析 → 音频状态结果 → 按作用目标筛选候选 → 选择 lease → 提交前重查 → 单次作者历史写入。
+
+查询使用消费者 Entry **执行前**的位置；候选不包含本条目的输出和后续创建者。Graph 分支确定集合取交、可能集合取并，条件为未知时合并执行/跳过两路，循环使用有限事实固定点。无效参数、未知语义、不可达位置和预算耗尽显式报告不完整/不可分析，不能把查询失败当作“确定没有效果”。
+
+| 操作 | 音频域转移 |
+| --- | --- |
+| apply | 创建或更新精确挂载键，记录来源与类型；重新执行同键不增加实例 |
+| update | 仅更新存在实例的已知参数，保留身份/类型；不把“可能存在”提升为“一定存在” |
+| 单实例 stop | 删除该精确键；空键仍按旧单实例规则 |
+| stop all | 清除该目标所有已知实例；可以消除这些实例自身的类型/元数据问题，不能抹掉上游未知语义造成的全局不完整 |
+| play/stop/next/clear 等音源控制 | 保留挂载链，音源停止不表示效果或混响尾音停止 |
+| `audio.mix.set` | 保留效果身份，仅改变独立目标音量/静音 |
+
+音频实例不会因为时间过去或音源结束就从分析里移除。不同分支中效果链顺序可能不同，选择器不承诺一个确定运行时序号；以来源区分实例，不做链顺序编辑或推测尾音。首期不新增 Timeline 音频事件类型，也不把音频参数暴露成 Timeline 可动画属性。共享查询保留事件前位置扩展能力，但不能靠分析单方面宣称 Runtime 已支持音频事件。
+
+选择有效性同时包含作者位置、查询结果版本、写入方上下文和 scope/target。改变目标、删除创建者、相关上游编辑、撤销重做、关闭项目等按既有 lease 规则失效；无关名称/语言刷新不写数据。切换目标后旧实例引用显示未解析并保留原文，必须明确重选；不能仍被当成新目标上的有效实例，更不能自动选第一项或转为全部。条目删除后再撤销也不能让旧弹窗获得提交权。
+
+## 兼容、边界与取舍
+
+- 保留已有 `id`、`instanceId`、`scope`、`targetId` 线字段和旧显式身份；主要变化是作者表现和声明式引用语义，不为隐藏两个字段而重命名 JSON。新增 stop `all` 默认 false，新增 update 是可加的 Entry；单纯这些改动不要求提升现有音频存档表版本。
+- 读取既有内容不补 GUID、不改引用、不丢未知类型/参数。既有空身份保留原文并提示无效，查询不宣称其成功创建；修复须通过显式作者操作，不能打开项目就批量改身份。
+- 新 GUI 身份和批量复制重映射不能用来推断唯一依赖；引用索引需覆盖未打开 Group 和跨 Group 复制。重复来源/冲突应诊断，不偷偷修复。
+- 不采用运行中后端枚举来决定作者候选；编辑器不需要播放到该处，也不访问设备。目录在无设备时仍可用于创作。
+- 不在此轮加入 Bus 跨路由/Send、效果链拖动排序、自定义效果命名系统、实时音频预听、卷积混响或其他平台设备实现。
+- 不按类型停效果：同目标可有多个同类型实例，类型是算法身份，实例键才是操作身份。显示层隐藏 ID 不等于删除底层身份。
+
+## 交付与验收边界
+
+原设计的实施顺序如下，实际验收见实现记录；不改变 P1–P4 的历史验证结果。
+
+1. 共享语义/身份：独立音频域、目标限定、自动输出隐藏和批量复制；旧视觉/播放身份回归。
+2. 共享分析/查询：音频状态转移、确定/可能结果、精确目标过滤、分域完整性与选择 lease。
+3. 创建/停止表单与契约：类型 ComboBox、元数据参数表单、已有实例与全部选择、stop-all 原语；完成可实际操作的闭环。
+4. 后续参数更新：引用现有实例的 update Entry、patch 合并与完整验证、类型歧义提示；复用同一查询和字段适配。
+
+关键验收包括：
+
+- 挂载后的真实 ComboBox 可选择类型，参数按类型切换，界面没有常驻类型 ID/输出身份文本；无设备时仍可编辑。
+- 同目标两个混响各自可选/可停；Track 和同名 Bus 不串选，Track 不列出所属 Bus 的挂载效果；没有正在播放的音源仍可选效果。
+- 顺序、条件、跨 Group、分支合并、循环、不可达、未知条目和预算耗尽按既有保守规则；未来创建者不能出现在消费者候选里。
+- 新建、复制、跨 Group 粘贴、换类型、Undo/Redo、保存重开保持身份及引用约束；遗留相同 instanceId 位于不同目标不串改。
+- 删除/改目标/撤销造成旧选择失效，名称和语言变化不提交参数；原未知 JSON、既有无效空身份和未解析引用保留。
+- “全部效果”只作用于精确目标，缺失单实例无操作；stop 不重启声音，沿用平滑移除，不影响之后新增的效果。
+- update 不创建缺失实例、不更改类型或链顺序；参数 patch 保留未改值，合并后验证失败不部分更新。
+- 共享机制提取后，现有 Layer/视觉效果/播放选择、引用诊断与 Timeline 事件前查询相关回归仍通过。既有非音频 Timeline UI 失败继续单独记录，不能据此宣称全仓验收已通过。
diff --git a/features/F-20261027-01-audio-mixer/authoring-summary.md b/features/F-20261027-01-audio-mixer/authoring-summary.md
new file mode 100644
index 00000000..5e637cce
--- /dev/null
+++ b/features/F-20261027-01-audio-mixer/authoring-summary.md
@@ -0,0 +1,42 @@
+# 音频效果创作交互实现记录
+
+2026-10-27。用户先要求提交已有工作，再授权实现 [创作设计](authoring-design.md)。后端与设计基线已提交为 `f3c19655`；本记录描述其后的创作交互增量。并行聊天的 Inspector/持续视觉预设改动由其各自提交，本轮没有重置或覆盖这些内容。
+
+## 实现
+
+- 应用效果表单使用类型 ComboBox，类型改变时将类型键与目录默认参数作为一次历史提交；参数以共享数值字段编辑，显示范围错误。范围、默认值和 PCM 默认值复用契约元数据/常量。
+- GUI 创建时自动生成隐藏实例身份。新增 AudioEffect 身份域，在现有输出/引用声明、身份遍历、批量复制与引用索引中复用；复制按原 scope/target 限定重映射，不改算法 ID 或 Track/Bus 声明 ID。
+- 复用现有 Graph 遍历、条件合并、固定点、Group 前缀缓存和项目查询生命周期，在同一分析状态中增加独立音频集合及完整性。结果保留可能的创建来源与类型集合，不把音频效果加入视觉可动画对象。
+- 停止与更新选择当前剧情位置之前、直接挂载在选定目标上的实例，按类型和创建来源区分同类效果。停止提供显式“全部效果”，选择原子写入 all/instanceId。音源停止不删除效果；Track 不列出所属 Bus 的效果。
+- 新增 `audio.seffect.update`，将参数 patch 合入已有实例后整体验证；失败保留旧值，不创建缺失实例、不改类型或链顺序。选中来源类型不唯一时不生成猜测的参数表单；改变目标后清除原 patch，字段草稿按目标/实例/类型失效。
+- 音频查询结果使用独立 AudioRevision，并沿用写入方 ContextRevision 和提交前有效性检查；相关修改使旧选择失效，Undo 不复活旧选择。参数和引用的未知/失效值保留原文，查询刷新不自动改选。
+
+## 设计校正与兼容
+
+初稿错误地将可空 DTO 字段解释为 Runtime 允许创建空实例。实际 `ValidateEffect` 已拒绝空/空白身份；设计和手册已校正。省略 stop 的实例仍是精确空键查找、通常无操作，不代表全部。新 `all` 默认 false，true 与非空实例互斥。既有非空显式身份、线字段和音频存档表结构保留，无需为这些创作变更提升存档版本。
+
+没有为复用而另写音频 Graph 分析器，也没有大范围重命名 Scene 外观 API；共享状态传播中增加领域 payload。已有场景/播放结果保持独立。没有新增 Timeline 音频事件、音频参数动画、Bus 路由/Send 或实时预听。
+
+## 验证
+
+最终采用独立输出 `artifacts/audio-isolated`，不覆盖正在运行的 Editor。构建参数为 `--no-restore -m:1 -p:RunAnalyzers=false -p:UseSharedCompilation=false`，设置 AVALONIA_TELEMETRY_OPTOUT=1。测试前使用同次构建的默认契约 DLL。
+
+| 检查 | 结果 |
+| --- | --- |
+| 解决方案构建 | 0 错误 |
+| Editor.Shared 全套（含新增音频分析/身份/引用 7 项） | 456 通过 |
+| Media.Audio（含新增 update/stop-all 2 项） | 22 通过 |
+| Primitives.Builtins | 321 通过 |
+| Architecture | 52 通过 |
+| Presentation | 262 通过 |
+| Integration | 132 通过 |
+| 音频与共享选择器最终挂载回归（含新增 2 项） | 11 通过 |
+| Editor 全套 | 329 通过、2 失败；范围文案断言已修正并经上述最终复验通过，既有 Timeline Flyout 空引用保留 |
+
+对应日志为 `artifacts/audio-authoring-*.log`；最终源码指纹位于 `audio-authoring-final-sourcehashes.json`，另保留较早的 `audio-authoring-sourcehashes.json`。四语本地化各 1125 键且无同名重复。NUnit 显式设备/原生示例用例不计入普通通过数；本轮不重复声称执行了真实设备验收。
+
+中间失败保留：测试夹具先误用了 SchemaA、又在 Group 表单准备前读取表单，修正后两个挂载用例通过。后续范围错误显示断言误要求错误文案包含数字 1，而共享 ValueValidation 只提供稳定错误码 `value.range` 和通用文案，已改为检查错误码与可见消息。旧 TimelineEventQueryPickerKeepsPositionAndPropertyCreationUsesFrameZeroBaseline 的 Flyout 空引用仍需单独报告。
+
+一次最终验证被提前启动的测试进程锁住输出 DLL，构建失败；日志保存为 `audio-authoring-overlap-build.log` 与 `audio-authoring-overlap-editor.log`，未用作最终验收。等待这些进程退出后，同源码构建以 0 错误通过，再启动最终测试。规则见 [lesson](../../.agents/lessons/L-20261027-04-build-before-no-build-tests.md)。
+
+正式用法见 [音频手册](../../docs/manual/audio-mixing.md)，契约见 [Entry 类型](../../docs/spec/entry-types.md)、[Runtime](../../docs/spec/runtime.md)，查询边界见 [作者目标查询](../../docs/spec/editor-scene-targets.md)。全 feature 的后端验证仍见 [原总结](summary.md)，不覆盖其历史证据和保留项。
diff --git a/features/F-20261027-01-audio-mixer/design.md b/features/F-20261027-01-audio-mixer/design.md
new file mode 100644
index 00000000..ec9dd933
--- /dev/null
+++ b/features/F-20261027-01-audio-mixer/design.md
@@ -0,0 +1,15 @@
+# 设计
+
+后端设计已实现；2026-10-27 新增 [音频效果创作与目标分析设计](authoring-design.md)，描述用户确认的类型选择、隐藏实例身份、已有实例选择，以及对现有 Layer 选择/分析机制的复用。该补充已实现，见 [创作实现记录](authoring-summary.md)；其验证与原后端验证分开记录。
+
+当前问题：每 Voice 的 LibVLC player 独立输出；启停 EQ 改变原生滤波链。Group 只参与标量音量计算，不能代表实际 Bus。先 Start 后附着效果也不能保证首帧处理。
+
+采用统一 float32/48 kHz/stereo PCM 混音。跨平台托管混音/DSP 与平台设备/解码分离。miniaudio 0.11.23 使用薄 C ABI 封装，隐藏原生结构布局，Windows 首期构建 DLL；固定第三方源版本和 SHA256，MIT/Public Domain 授权随源码保存。设备回调只消费已准备的 PCM，后台解码至有界 SPSC 缓冲；不在回调读文件、等待剧情锁或调用完成订阅者。
+
+实例拥有资源、gain、淡入/淡出、有限播放次数和完成处理。Track 保留容量/队列/溢出规则，新增顺序/随机和队列循环策略；随机状态随 Track 存档。Bus 替代原 Group，每 Track 可进入一个 Bus 或直接进入 Master。数据流：实例增益/包络 → Track 汇总 → Track 效果链/音量 → Bus 汇总 → Bus 效果链/音量 → Master 音量与硬限幅。Bus 效果执行一次，空输入仍运行以保留尾音。
+
+SEffect 支持 Track/Bus。首次 apply 定位链顺序，同实例更新不改变顺序；真正双二阶高低通（cutoffHz/Q）、算法混响（roomSize/decaySeconds/damping/mix）、gain。参数和效果启停平滑；移除默认平滑旁路，reset/读档清除 DSP 尾音。停止某个音源不清除目标链。旧 attenuationDb 不再接受，示例显式迁移。
+
+Runtime 只持久化逻辑播放、目标效果和作者混音状态，后端 Configure/ApplyMix/Reset 为目标级命令，不再把 Track 效果复制给每 Voice。旧音频状态表版本提升，拒绝旧 payload，不伪装兼容。玩家音量仍是独立的即时偏好投影。
+
+候选：NAudio/WASAPI 能快速接入，但此处选择 miniaudio 设备/解码层，托管 DSP 保持可离线验证且无需依赖第三方绑定结构 ABI。Windows 构建需要 MSVC C++ 工具；发布产物携带 DLL，玩家无需编译器。Linux/macOS 端口只保留接口，不宣称已验证。
diff --git a/features/F-20261027-01-audio-mixer/feature.md b/features/F-20261027-01-audio-mixer/feature.md
new file mode 100644
index 00000000..9a3a8d4f
--- /dev/null
+++ b/features/F-20261027-01-audio-mixer/feature.md
@@ -0,0 +1,13 @@
+# Track / Bus 音频混音后端
+
+状态：implemented，音频范围验证通过；全仓验收保留一项非音频 Timeline UI 失败，见 [总结](summary.md)。2026-10-27 用户明确授权开始实现；此前讨论确认实例拥有自身播放和收尾配置，Track 管理顺序/随机、循环队列和轨道声音，Bus 汇总 Track 并执行共享 SEffect。允许重构 Entry 和原语。跨平台契约，首期 Windows。
+
+目标：替换 LibVLC EQ 近似；真实低通、高通和混响；Track/Bus 有序效果链；无播放重启的效果更新；实例淡入淡出；已有取消、迟到事件、恢复保护保持有效。
+
+非目标：公开 Voice/Send 对象、任意循环路由、VST、精确游标/混响缓冲存档、音视频时钟统一、其他系统的设备验收。
+
+验收：PCM 频响、混响尾音和 Bus 汇总测试；播放队列/随机/循环与结束策略、恢复和取消回归；Windows 原生解码与设备播放验证；编辑器/示例配置和正式文档迁移。
+
+见 [设计](design.md)、[阶段](phase-plan.md)。
+
+2026-10-27 创作交互补充：用户确认效果类型使用 ComboBox、实例身份类似 Layer 自动生成并隐藏，停止时按 Track/Bus 选择已有实例，复用现有选择和分析机制。状态：implemented，音频范围验证通过；类型/参数表单、自动身份、已有实例与全部停止、参数 patch 更新已交付。见 [创作设计](authoring-design.md) 和 [创作实现记录](authoring-summary.md)。全仓 Timeline 失败继续保留。
diff --git a/features/F-20261027-01-audio-mixer/phase-plan.md b/features/F-20261027-01-audio-mixer/phase-plan.md
new file mode 100644
index 00000000..324ad66c
--- /dev/null
+++ b/features/F-20261027-01-audio-mixer/phase-plan.md
@@ -0,0 +1,19 @@
+# 阶段计划
+
+1. P1 verified：契约、Bus 配置、Track 策略、实例淡出、目标效果状态与原语迁移。307 项原语/契约回归，以及新增恢复、随机和循环测试通过。
+2. P2 verified：统一 PCM mixer、真实滤波、混响、有序平滑效果链。频响、顺序、汇总、尾音、连续性、零分配、效果重挂/换类型测试通过。
+3. P3 verified：miniaudio Windows 原生解码/输出、有界流缓冲、取消和释放；默认宿主接入。Unicode WAV/Vorbis 解码、真实 Windows 设备与播放中 Track 效果/Bus 混响、文件租约和取消验证通过。
+4. P4 in-progress（全仓门禁保留）：编辑器/配置/示例/文档迁移已完成，音频相关验证通过；独立输出的解决方案构建、普通发布与原生 DLL 分发检查通过。当前工作区的一项非音频 Timeline UI 用例仍失败，未伪装为全仓通过。见 [总结](summary.md)。
+
+## 音频创作交互（音频范围 verified）
+
+见 [补充设计](authoring-design.md)。在保留 P1–P4 证据的基础上，拟依次推进共享音频身份/复制语义、剧情位置音频事实与查询、创建/停止选择与参数表单，最后接入后续位置参数更新。各步骤依赖与验收见该设计的“交付与验收边界”；实际证据见 [创作实现记录](authoring-summary.md)。
+
+2026-10-27 用户授权提交基线并开始实现；基线提交 `f3c19655`。A1 身份/复制、A2 分域分析、A3 创建/停止表单及 A4 参数更新均已实现并通过对应验证。
+
+- A1 verified：新建/复制身份、目标限定重映射与引用索引，新增纯分析/身份回归覆盖。
+- A2 verified：复用位置、Graph、条件/循环和前缀缓存，独立音频 payload/完整性；Editor.Shared 全套 456 项通过。
+- A3 verified：类型 ComboBox、元数据参数字段、显式 all 与既有实例选择；音频及共享选择器挂载回归 11 项通过。
+- A4 verified：update patch 合并、原子验证和不复活缺失实例；Media.Audio 22 项通过，Primitives.Builtins 321 项通过。
+
+整体 feature 不宣称全仓关闭：完整 Editor 在断言修正前为 329 通过/2 失败，范围文案断言已修正并在最终音频回归通过，既有 TimelineEventQueryPickerKeepsPositionAndPropertyCreationUsesFrameZeroBaseline 的 Flyout 空引用保留。
diff --git a/features/F-20261027-01-audio-mixer/summary.md b/features/F-20261027-01-audio-mixer/summary.md
new file mode 100644
index 00000000..eb67183a
--- /dev/null
+++ b/features/F-20261027-01-audio-mixer/summary.md
@@ -0,0 +1,51 @@
+# 实现与验证
+
+2026-10-27。音频实现已落地，相关验证通过；全仓验收保留一项 Timeline UI 失败，feature 不标为完全关闭。
+
+## 行为
+
+- 作者模型为实例 → Track → Bus。实例保留资源/gain/播放次数/结束处理，新增自身淡出；省略停止淡出时采用实例配置，显式 0 硬切。Track 新增顺序/随机和 None/One/All 循环策略，随机状态持久化。
+- Bus 替代标量 Group，真实汇总 Track 后处理一次效果和音量。SEffect 使用 scope（track/bus）/targetId，首次添加决定顺序，更新保留顺序，停止再挂移到链尾。换类型时只保留一个逻辑活动实例，旧处理器平滑退出。
+- 默认后端改为 miniaudio 设备/解码 + 托管统一 PCM 混音/DSP；删除 LibVLC 音频 host 与 EQ 模拟，视频/Gallery 保留 LibVLC。真实二阶高低通、gain 和基础房间混响，参数/启停平滑；音源结束后尾音继续，reset/读档清除旧 DSP 缓冲。
+- 解码在后台，经每实例约两秒的有界缓冲交给设备；回调无文件 I/O、Runtime 锁或用户事件。后台终态释放原生解码器和租约，单项清理/观察者失败不阻断其余源；异常会汇总而非吞掉。无设备仍保留效果契约，实际播放通过 Failed 降级。
+- `audio.mix.set` 保存剧情目标 gain/muted，玩家 Master/Buses/Tracks 混音独立叠加。编辑器目标选择随 scope 使用 Track 或 Bus 声明，已挂载测试覆盖只有 Bus 才存在的 room ID。
+
+## 迁移与构建
+
+`galnet.project` section v2：audioGroups → audioBuses，groupId → busId；效果 trackId → targetId，可显式 scope=bus；旧 attenuationDb → 真正滤波器的 q（不是等价数值映射）。旧 section v1 明确拒绝。音频 tracks/seffects 状态表 v2，新增 channels 表，旧档拒绝。GameTestCase 已同步并加入 Bus 混响示例。
+
+miniaudio 0.11.23 和固定提交 stb_vorbis 的源码、授权、SHA256 随 native/README 保存。Windows x64 开发构建需 MSVC C++ Build Tools；静态 CRT 的 DLL 自动复制到输出/发布，玩家不需要编译器。WAV/MP3/Ogg Vorbis/FLAC 支持，设备的其他平台实现尚未交付。Windows ReadyToRun 发布锁图同步。
+
+## 验证证据
+
+采用 AVALONIA_TELEMETRY_OPTOUT=1、-m:1、UseSharedCompilation=false；解决方案构建禁用 analyzer 执行（现有 nullable/XAML 警告保留）。最终使用 artifacts/audio-isolated 独立输出，避免覆盖正在运行的 Editor.exe/DLL；默认契约从该次构建产物补入对应测试输出。
+
+| 检查 | 结果 |
+| --- | --- |
+| 新音频 DSP/状态/解码/异常清理 | 20 通过 |
+| 显式 Windows 默认设备播放、Bus 混响和播放中滤波启停 | 1 实际执行并通过 |
+| Primitives.Builtins | 307 通过 |
+| Presentation | 261 通过 |
+| Architecture | 52 通过 |
+| Editor 音频相关挂载/历史/配置 | 6 通过 |
+| Editor.Shared | 448 通过 |
+| Storage.FileSystem | 24 通过 |
+| Integration | 132 通过 |
+| GameHost | 6 通过 |
+| 解决方案独立输出构建 | 0 错误 |
+| Sample Debug 普通 publish smoke | 成功，包含 galnet_miniaudio.dll（774656 bytes） |
+| 新音频文件 whitespace / git diff --check | 通过 |
+
+较早全量 Editor 回归 324/326：TimelinePropertyTree 的文件移动权限错误在单项复核通过；TimelineEventQueryPickerKeepsPositionAndPropertyCreationUsesFrameZeroBaseline 在单项复核仍于 TimelineEventQueryTests.cs:55 空引用失败（读取异步 Flyout 时为空，未在本 feature 继续定位）。该用例不含音频路径，未修改相关 Timeline 实现或隐藏该失败。工作区同时存在其他编辑器改动，均保留。
+
+架构测试依赖清单同时补齐既有 Editor.Shared.Tests → Editor.DefaultContracts 引用，未扩大生产层依赖。普通输出目录的最后覆盖尝试被正在运行的 Editor 锁定；保留进程，独立输出验证成功，不把锁定误报为代码编译失败。
+
+## 边界
+
+混响为基础算法空间，不是卷积 IR。没有公开 Voice/Send、跨 Bus 路由、Sidechain 或 VST；只有 Windows x64 设备验收。没有保存精确游标、DSP 尾音或包络时钟，也未承诺无缝队列/循环或任何负载下的绝对无断音。尚未对混响进行专业主观调音或长时间压力测试。
+
+当前接口与示例见 [音频手册](../../docs/manual/audio-mixing.md)、[Runtime](../../docs/spec/runtime.md)、[架构](../../docs/spec/architecture.md)。
+
+## 音频效果创作增量
+
+基线提交 `f3c19655` 后，已实现类型 ComboBox、隐藏自动身份、直接挂载实例分析/选择、显式停止全部和参数 patch 更新。独立验证与设计校正见 [创作实现记录](authoring-summary.md)，不覆盖本文的后端历史证据和全仓保留项。
diff --git a/features/F-20261027-02-sustained-visual-presets/design.md b/features/F-20261027-02-sustained-visual-presets/design.md
new file mode 100644
index 00000000..f15c10f5
--- /dev/null
+++ b/features/F-20261027-02-sustained-visual-presets/design.md
@@ -0,0 +1,13 @@
+# 设计
+
+复用预设编译为 timeline.play 的机制。Shake/SpeedLines 增加 playbackMode=Timed/UntilStopped；持续模式生成 Loop 且固定 blocking=false、skippable=false。durationFrames/frameRate 表示循环周期，cycles 是该周期内震动参数。持续震屏保持振幅；持续集中线维持不透明度。
+
+现有 Timeline 的所有事件均按迭代重放，不能直接用于持续集中线。增加事件 execution：EachIteration（默认，保留原行为）、Once（首帧初始化）、OnCompletion（末帧清理，仅 hide/stop 操作）。恢复不重复首帧，循环不重置 Once 的通知状态，退出时执行 OnCompletion。作者原始 Timeline JSON 与复制逻辑继续保留新字段。
+
+animation.stop 立即完成路径等待播放实例的 PresentationCompletion，保证收尾后才推进后续剧情。Timeline presenter 返回正常/跳过结果后，由中立实例补发剩余非 burst 事件并更新循环终态。取消 scope、被替换和 CatchUp 分离不执行完成事件，以免污染新会话或提前结束存档中的持续演出。Headless/CatchUp 已脱离播放的循环通过保存定义清理逻辑状态。
+
+收尾审核补充：循环提交终态需有显式停止请求或 Skipped 结果；宿主单独返回 Completed 不改变循环恢复初值。Timeline 使用稳定完成信号覆盖 presenter 退出及事件清理，点击跳过期间保留播放身份，让交错到达的停止指令也等待同一次清理。
+
+AfterIteration 请求由 Timeline 的单调采样时钟在下一周期边界结束；不阻塞停止 Entry 等待整轮。普通 animation.animate 的 AfterIteration 行为不在本次范围内。
+
+这项修改涉及可序列化 Timeline 契约和跨层停止生命周期，已从轻量入口转为普通实施记录；不进行新的人物动作架构设计。
diff --git a/features/F-20261027-02-sustained-visual-presets/feature.md b/features/F-20261027-02-sustained-visual-presets/feature.md
new file mode 100644
index 00000000..bf237763
--- /dev/null
+++ b/features/F-20261027-02-sustained-visual-presets/feature.md
@@ -0,0 +1,7 @@
+# 持续演出预设与停止收尾
+
+用户于 2026-10-27 授权实现。震屏和集中线可选择定时播放或持续到停止；持续模式不阻塞且不随对白点击跳过。统一通过 animation.stop / CompleteImmediately 停止，震屏归零，集中线移除其 Effect 和临时图层。人物动作、冲击和转场保持单次。
+
+验收：定时行为不退化；持续震屏不衰减；集中线循环不重复创建/删除对象；主动停止、正常结束、跳过及恢复后的停止均完整清理；无关效果和人物基础变换保留；停止完成后同标识可以重用。
+
+范围不含淡出停止、人物中途姿态保留、新的停止 Entry 或自定义复杂演出编辑器。保留已有三处无关工作树修改。
diff --git a/features/F-20261027-02-sustained-visual-presets/phase-plan.md b/features/F-20261027-02-sustained-visual-presets/phase-plan.md
new file mode 100644
index 00000000..b3e56dcc
--- /dev/null
+++ b/features/F-20261027-02-sustained-visual-presets/phase-plan.md
@@ -0,0 +1,9 @@
+# 实施阶段
+
+## P1 — 持续预设与统一停止（verified）
+
+实现预设参数、事件生命周期、停止等待与完整收尾；同步编辑器四语和静态分析、文档。
+
+验证：编译参数与循环轨道；用可控 presenter 重现提前停止缺失清理，覆盖循环多轮/定时/恢复/跳过/无关对象保留/同 ID 重用；运行 Primitives、Editor.Shared、Presentation 等相关回归与解决方案构建、格式检查。完成后提交本阶段相关文件。
+
+结果：Primitives 321、Editor.Shared 449、Presentation 262、Runtime 123、Architecture 52、Editor 预设保存重开 1 项通过，共 1208 项。最终完整解决方案构建 0 错误，3 项已有 AVLN3001 警告；四语各 1105 key 一致。主目录并行音频改动导致初始构建失败，改用独立工作树固定基线 0818aab4 验证；未修改并行任务代码。
diff --git a/features/F-20261027-02-sustained-visual-presets/summary.md b/features/F-20261027-02-sustained-visual-presets/summary.md
new file mode 100644
index 00000000..3b024ae3
--- /dev/null
+++ b/features/F-20261027-02-sustained-visual-presets/summary.md
@@ -0,0 +1,24 @@
+# 持续演出预设与统一停止
+
+震屏、集中线新增 playbackMode（Timed / UntilStopped）。持续模式固定不阻塞、不随对白点击跳过；震屏保持振幅，集中线维持显示。人物动作、冲击及转场仍单次。blocking 已列为常用字段，播放方式具备中英日韩四语标签。
+
+一个 animation.stop / CompleteImmediately 即可结束演出：震屏移除叠加偏移，集中线移除自己创建的 Effect 与临时图层，保留其他效果和人物基础位置，收尾后允许复用播放标识。停止 Entry 等待真实收尾；初始化期间停止，以及点击跳过和停止交错，也使用同一完成信号。
+
+Timeline 事件新增可选 execution：EachIteration 保持旧行为，Once 用于首帧初始化，OnCompletion 用于末帧 hide/stop 清理。持续集中线循环不重建图层/Effect，恢复不重复初始化。Timeline 的 AfterIteration 在下一轮边界完成，Headless/CatchUp 无活动呈现的循环直接清理逻辑状态。编辑器复合分析区分结构错误和时间不确定性，停止候选返回原预设的 playbackHandleId 槽位。
+
+## 验证
+
+- Primitives 321、Editor.Shared 449、Presentation 262、Runtime 123、Architecture 52、Editor 预设创建/撤销/保存重开 1 项：共 1208 项通过。
+- 完整 GalNet.slnx 构建：0 错误；3 项已有 AVLN3001 警告。
+- locked restore 成功；四语各 1105 key 一致；修改文件格式和 diff whitespace 复核。
+- 新增 14 项用例覆盖配置、循环初始化、停止收尾、等待异步清理、初始化交错、跳过交错、恢复、Headless、播放标识复用和真实 Avalonia 震动偏移移除。
+
+## 修正与限制
+
+完整回归曾发现宿主直接结束循环呈现时错误提交末值（恢复粒子 emissionRate 从 18 变成 36）；已要求有明确停止意图并通过原用例。额外的跳过/停止交错回归先复现停止过早完成，再修正为稳定完成信号与延后身份释放。经验见 `.agents/lessons/L-20261027-03-timeline-stop-event-cleanup.md`。
+
+主目录存在并行音频开发，因此基于 0818aab4 创建独立工作树验证。初次主目录音频缺失 JsonElement using 和首次独立工作树 sandbox 写权限失败均为验证环境/并行开发问题，未借此修改产品功能。
+
+未运行显式原生视频或 shader 图片导出用例；没有新增图形特效或修改 shader。持续集中线的 shader time 按作者循环周期重播；不承诺跨周期相位无缝。未新增人物姿态中断、淡出停止或复杂动作编排。
+
+当前操作见 [默认视觉库手册](../../docs/manual/default-visuals.md)，事件契约见 [Entry 类型](../../docs/spec/entry-types.md)，停止生命周期见 [Runtime](../../docs/spec/runtime.md)。
diff --git a/features/F-20261027-03-recursive-properties/design.md b/features/F-20261027-03-recursive-properties/design.md
new file mode 100644
index 00000000..0dd6ac33
--- /dev/null
+++ b/features/F-20261027-03-recursive-properties/design.md
@@ -0,0 +1,167 @@
+# 递归属性访问设计
+
+状态：implementation / verification；2026-10-27 根据用户“继续”指令形成正式设计，随后获授权实施。本文保留设计基准；实际接口、验证、偏差和未完成项以 phase-plan、review、summary 为准。
+
+## 目标与本次交付边界
+
+借鉴 Unity SerializedObject / SerializedProperty 的属性访问方式，在现有 FieldDescriptor、ValueDescriptor 和 JSON codec 上提供可迭代、可定位、可局部修改的结构视图。共享结构元数据驱动通用表单、专用编辑器、嵌套值检查与本地化引用索引，保留各自的展示与领域业务职责。
+
+本次交付覆盖：基础结构/路径/有界遍历；DTO、数组和现有 List 类集合、字符串键映射；Transform/Flipbook 的固定结构声明及引用分析；这两种专用编辑器、通用结构表单和项目子字段草稿的属性访问统一。Transform 的编辑、检查、定位闭环是首个可见成果，不等全部迁移结束才验证。
+
+动态音效/视觉参数、Timeline 轨道与事件列为后续迁移场景。本次保留可注入的结构解析入口，并用测试结构证明其上下文失效行为；不重写这些领域的编辑器、执行或存储。未迁移的非空未知结构继续报告分析未覆盖，不能宣传所有内置 opaque 警告都已消除。
+
+## 当前事实与重复来源
+
+| 当前代码 | 已有能力与限制 |
+| --- | --- |
+| Core.Parameters.FieldDescriptor / ValueDescriptor | 字段身份、presence 规则、默认、约束、JSON options、引用语义；尚无共享的子结构访问入口 |
+| ValueCodec / ValueValidation | 使用 System.Text.Json 转换和检查值；不负责项目历史，不保证 DTO 的每个嵌套字段规则都被递归执行 |
+| SchemaGenerator / IFieldDto | 生成静态 Schema 和成员访问；仅显式 Field 成员进入 schema，不应扩大为扫描任意 getter |
+| StructuredFieldEditor | 自行判断 DTO/集合、反射 schema、用 JsonTypeInfo 映射 wire 名、建立子绑定；字典与未知 converter 等回退 JSON |
+| LocalizationReferenceIndex | 另行判断 DTO/集合并映射成员；无法识别 Entry 中 JsonElement 的 Transform 等结构 |
+| TransformFieldEditor / FlipbookFieldEditor | 手写子字段和局部修改；Transform 兼容对象及字符串包裹的 JSON，保留实际成员大小写 |
+| EntryEditSession | 已有根字段加子路径、项目级草稿和作者 incarnation；另有 JSON 寻址/回写逻辑 |
+
+因此不是缺少 JSON 读写器，而是结构与属性访问在消费者之间分叉。采用公共结构入口收敛重复实现，同时保留现有序列化与作者操作机制。
+
+## 结构模型
+
+### 元数据单一来源
+
+继续使用 FieldDescriptor 表达 ID、标签、默认值、约束、编辑提示和语义。ValueDescriptor 增加可选的不可变结构关联，工作名 ValueStructure；它仅描述如何理解当前 wire 值，不创建第二种存储值容器。
+
+优先提供 `WithStructure(...)` 一类返回新描述的组合入口，并保留现有公开构造函数签名。不能只在旧构造函数尾部追加可选参数并假定二进制兼容；插件契约、手写 schema 和生成代码都需编译/加载回归。
+
+结构种类：
+
+- **Scalar**：由现有 codec 完整处理的叶值，包括 string-encoded 数字/枚举。
+- **Object**：有序成员描述，保留字段 ID、CLR 成员身份与实际 wire 名的映射。
+- **Sequence**：元素字段描述，支持一维数组、List/IList/IReadOnlyList/IEnumerable 的现有范围。
+- **Map**：字符串键和值字段描述；键是数据，不能当对象 schema 字段或数组索引。
+- **Opaque**：没有可证明的结构，保留原值和未解析原因。
+
+动态不是第六种存储类型，而是解析器根据值与只读上下文得到上述结构之一。初期不自动枚举 arbitrary IEnumerable 实例；遍历对象为 JSON 数组，CLR 集合类型只用于取得元素契约。
+
+序列元素/映射值使用可携带 FieldValueSemantic 的字段描述，以便表达“列表中的每个字符串是文本 key”。不把父字段语义自动传播给所有字符串，也不放宽现有 LocalizedText / CharacterReference 只标记字符串字段的规则。自动推导得到的普通字符串元素保持无引用语义，显式集合语义由结构声明提供。
+
+### DTO 与兼容 JSON 结构
+
+原生 IFieldDto 使用现有 Schema；schema 解析集中到公共结构解析器，过渡期可对静态 Schema 反射一次并按作用域缓存。只读取 schema 元数据与 JsonTypeInfo，不构造作者 DTO 来遍历，不调用作者属性 getter/setter。自动生成器提供更直接入口可以后续演进，不要求首期大改 IFieldDto 接口。
+
+固定 JsonElement 字段通过声明关联结构类型。例如 FieldAttribute 的拟增 `StructureType` 指向 LayerTransform 或 FlipbookDefinition，生成器生成 ValueDescriptor 的结构关联；手写描述调用同一组合入口。此关联保持外层 ValueType=JsonElement，不改变 wire 格式。
+
+LayerTransform / FlipbookDefinition 可复用现有类并为可编辑成员增加生成 schema；Clone、Capacity、IsValid 等成员保留，未标记的计算属性不进入属性树。字段默认、标签等元数据从共享 schema 取得，专用控件不再复制一套字段定义。新增特性不应改变现有 JsonSerializer 对实例属性的输出。
+
+### 命名与 codec
+
+对象成员区分稳定字段 ID 和实际 wire 名：前者供注册/元数据查找，后者供读取、局部 patch 与 JSON Pointer。JsonPropertyName、命名策略、字段 converter 优先级和父级 JSON options 在公共解析入口统一处理。
+
+对象/集合级自定义 converter 改变了结构时，不能凭 CLR 成员继续推断；没有显式结构适配则为 Opaque。成员级已声明 codec 与父级 options 的合并规则必须在索引和表单中相同。JSON Schema 导出继续表达实际 wire 契约，不因为可编辑结构声明就丢弃兼容表示。
+
+Transform 等既有兼容字段采用 Contracts.Builtins 拥有的显式 wire 适配器：声明对象及该字段已支持的 JSON 字符串编码，按现有规则匹配成员大小写并保留原键。普通 DTO 的精确命名规则不因此变成全局大小写不敏感。重复 JSON 属性、大小写别名冲突和多义成员必须报告，不能选取第一个后继续写入。
+
+普通 string 不尝试 JSON 解析。字符串包裹结构的逻辑子路径不是外层 JSON Pointer 能直接寻址的真实属性；诊断同时保留实际 wire 位置及结构内逻辑路径，编辑和导航经适配器恢复该边界，不能声称对外 JSON Pointer 可以直接穿过字符串。
+
+## 属性快照、路径与迭代
+
+Core 提供平台无关的 ValueDocument / ValueProperty 只读快照视图，工作命名以区别 Editor 项目对象。引用图描述递归类型，值属性按需展开，不预先构造整棵 schema 或值树。
+
+属性视图至少包含：字段元数据、结构种类/解析状态、当前原始值、Missing/Null/Provided 状态、实际 wire 路径、逻辑路径及直接子项入口。有效默认值是独立的展示查询；引用索引只扫描实际作者值，UI 展开缺省对象不写回默认值。
+
+PropertyPath 的片段具有 Member、Index、MapKey 及显式编码边界信息，键 `"0"`、空键、`"a/b~c"` 不得被误解为数组位置或多级成员。JSON Pointer 的转义/反转义由单一工具完成；原字符串路径和已归档草稿在外层适配，不能静默改变历史路径含义。
+
+提供 FindProperty、EnumerateChildren、GetIterator/MoveNext 风格入口。迭代使用显式栈，允许访问者进入或跳过子项；每次访问受节点预算、深度与取消控制。命中未知值、坏结构、缺失映射或预算时产生有路径的结构结果；调用方将其转为对应 UI/工具诊断。
+
+默认引用分析预算先保持现有深度 16、总值 100,000。UI 的八层/200 元素边界继续作为控件实例化策略，不等价于分析完整性限制。FindProperty 也需有界，不能用直接查找绕开对字符串解码和递归结构的保护。
+
+快照根负责 JSON 生命周期；捕获时一次持有独立且不可变的值，不对每个子节点递归 Clone。未知成员可以读取/保留，但没有描述的非空结构不能被当成已完整检查。空值无引用的现有约定继续有效；结构校验与引用覆盖是独立结果。
+
+## 局部修改与项目作者桥接
+
+Core 的属性 patch 是纯操作：输入快照、类型化路径及 Set/Remove/集合结构修改，输出新候选值或带路径的问题。保持未知成员、兄弟值、原成员拼写和显式编码方式；不保证空白字节不变，不通过根 DTO 重建替换 JSON。集合元素不能用省略代替删除，映射键操作须单独检查重复与冲突。
+
+省略对象上的显式子属性写入可建立必要容器，仅落入该操作要求的值；不自动创建不存在的第 N 个列表元素，不把 null 自动恢复为默认对象。重置/删除能力仍由宿主决定，Timeline 等禁用通用 Reset 的策略保留。
+
+Editor 提供已有 FieldEditorContext / IFieldBinding 的属性绑定适配；工作名 SerializedPropertyBinding。项目级作者数据仍唯一归项目文档，未增加与之同步的可变 SerializedObject 副本。候选经当前字段规则、partial 领域校验及 EntryFieldAuthoringService 进入一条历史；准备失败不得部分提交。
+
+EntryEditSession 的子字段草稿提交改用公共属性 patch；关闭表单只释放控件租约，不使作者 incarnation 失效。保存时仍能从当前作者状态重建属性访问并提交有效草稿。旧归档路径通过当前 schema 和 wire 规则明确映射，无法唯一对应时保留为不可恢复提示，不猜测目标。
+
+读取快照的版本、写入方身份与控件 lease 分开：写入必须核对项目 scope、Group/Entry 稳定 ID、类型、作者 incarnation、根来源/相关依赖及集合结构代次。无关条目变更不必使当前字段输入全部失效；列表移动/删除、换类型、删除后 Undo 或动态结构切换不能让旧子属性写入新的位置。结构变化后旧索引句柄一律重新解析，不将 JSON 相同视为身份相同。
+
+## 校验与引用分析接入
+
+共享结构访问允许统一执行每个已提供叶值的 ValueValidation，并在对象层检查形状、必需项和重复成员。提供作者 Partial 与完整检查的明确模式：逐字段编辑不强迫其他尚未填写的字段完整；完整编译规则及领域业务校验继续由原契约入口执行。
+
+现有 ValueValidation.Validate 的行为不通过本次迁移被全局偷偷加强。可添加基于属性树的嵌套检查入口，再由已迁移调用方显式使用；默认值和约束校验与实际 wire 解码须一致。ValueCodec 继续负责最终类型转换；可描述结构不代表任意 converter 能安全跳过，也不能把标量检查成功当作嵌套业务有效。
+
+LocalizationReferenceIndex 改用公共迭代：识别有语义的字符串叶值，未知/无结构处生成现有分析未覆盖结果；缺失文本/角色继续独立报错。保持 Group/Entry 身份和属性路径，不再根据“成功找到的引用”反推诊断位置。未知成员不因其他兄弟字段已知而被吞掉。
+
+Transform 的正常已知成员可完整遍历，索引不再报 field.opaque。若 Transform 内含未描述的非空扩展对象，仍报告该扩展路径未覆盖；其未知值必须在编辑后保留。字段格式损坏或叶值类型错误仍可被明确定位。
+
+Character 删除/替换等依赖 Complete 的行为保持保守；迁移后的 Complete 只反映引用分析覆盖，不能复用为编译成功状态。
+
+## 控件与动态场景
+
+### 默认分组展示与专用覆盖
+
+2026-10-27 用户确认：保留现有专用编辑体验；没有专用覆盖的结构使用紧凑分组表单。结构元数据统一不意味着所有控件都必须呈现为同一种树形布局。
+
+| 节点 | 默认展示 |
+| --- | --- |
+| 标量叶字段 | 标签与编辑器一行，诊断紧随字段，不额外建立对象 Header |
+| 对象 | 单一可折叠 Header，下方缩进展示子字段；沿用简短对象默认展开、复杂对象按需展开的策略 |
+| 序列 | Header、当前数量及新增操作；简单元素直接展示编辑器，复杂元素使用可折叠标题，提供删除/移动操作 |
+| 字符串键映射 | Header、数量及新增入口；内部为键/值行，操作明确区分改键与改值 |
+| 未知或暂不支持的结构 | 保留明确的 JSON 编辑/修复入口及相关诊断 |
+
+Header 使用本地化字段名称，父字段行与内部对象标题只保留一份名称，不再同时堆叠字段标签、类型名标题和 element 标签。复杂集合元素可显示序号或已有领域摘要，不以统一布局为由新增稳定身份。
+
+同组字段采用紧凑间距，分组之间增加一档间距；层级通过 Header 和缩进表达。间距由宿主主题/样式统一控制，不在每层插入空白行或随深度累加底部空白。实际尺寸沿用宿主样式，在 P4 挂载验证中检查深层/窄窗口的密度与可读性。
+
+Transform、Flipbook、颜色、资源选择及 Timeline 等专用交互继续保留；本次迁移范围内的专用控件共享结构访问与字段规则，布局仍由各自工厂负责。未迁移的专用控件不因保留展示而宣称已经接入共享遍历。
+
+### 属性绑定与动态解析
+
+StructuredFieldEditor 的成员映射、集合判断、子属性读取及 patch 使用公共结构入口；仍负责懒加载、样式、控件数量限制及 JSON 修复入口。字符串键字典使用独立键/值行和显式新增/删除/改键操作；禁止静默覆盖重复键，键编辑失败时保留草稿。
+
+Transform/Flipbook 保留当前专用布局，子输入仍按 registry 选择 NumericUpDown、Slider 或精确文本，并转发 HostContext、CanReset、草稿与本地化能力。EditorRegistry 的引用语义、成员、类型、EditorId 和 DTO 覆盖顺序保持原行为，结构解析不依赖控件注册。
+
+音效 apply 的类型来自 id，update 的参数类型可能来自前缀查询的实例候选；Timeline 事件的 Parameters 来自事件 Type 对应目录。因此本次不通过一套字段名列表将这些对象宣称为固定结构。预留 IValueStructureResolver 的纯查询接口，输入描述、属性位置与调用方提供的不可变上下文，返回结构/未解析原因和依赖令牌；Core 不认识项目资源、effect 或 SceneTargetCatalog。
+
+未来迁移时，目录读取和异步资源准备由现有项目查询服务完成，worker 遍历只消费其冻结结果。动态结果变化使相应写入上下文失效，不以全项目 revision 代替局部依赖。当前不更改这些领域的专用编辑器，也不把未接入归为通过检查。
+
+## 模块职责与数据流
+
+| 模块 | 新增或收敛的职责 | 保留的边界 |
+| --- | --- | --- |
+| Core.Parameters | ValueStructure、成员映射、属性路径、快照访问、有界迭代、纯 patch 与可选嵌套检查 | 无 UI、DI、项目 I/O、内置类型依赖 |
+| SchemaGenerator | 输出固定结构关联，校验声明，复用既有字段元数据 | 不执行构造函数或领域逻辑 |
+| Contracts.Builtins | Transform/Flipbook schema 与历史 wire 适配，相关 Entry 字段关联 | 原运行数据及业务算法 |
+| Editor.Shared | 只读引用索引消费公共遍历，保留作者地址 | 不持有 Avalonia 控件 |
+| Avalonia.Controls | 公共结构的字段绑定、通用对象/集合/映射展示 | 保存和历史由宿主承担 |
+| Editor | 专用控件、草稿提交桥接、生命周期、诊断导航 | 项目文档仍是作者数据唯一来源 |
+
+数据流：契约描述 → 公共结构解析 → 当前 JSON 属性快照 → 表单/嵌套检查/引用分析；作者操作 → 属性 patch → 现有提交与领域验证 → 历史/保存 → 新快照及自动检查。
+
+元数据解析器有明确作用域，缓存键至少区分类型、冻结 JSON options 身份和显式结构关联；不只以 Type 缓存。结构定义延迟引用递归类型，不在静态 schema 初始化时构造循环。避免全局强引用插件类型/委托，项目卸载释放解析器、动态上下文和旧快照；后台检查应在释放契约前结束。
+
+## 兼容、迁移与验收
+
+首期新增能力不要求用户迁移项目文件。旧公开构造函数、schema 入口、控件注册与 codec 规则保留；需要新增元数据时同源码重建默认契约，并核对 Editor 打包副本。源码兼容与二进制兼容分别验证，不能把一次解决方案重建当成旧插件加载证据。
+
+先建立结构/路径基础并覆盖命名与 converter，再接固定内置结构和引用分析；随后迁移专用属性写入与草稿，打通 Transform 闭环；再迁移通用对象/集合/字典表单。每类迁移完成才删除其重复反射/字段清单，不混入格式化或全局重命名。
+
+验证重点是同一数据在多个消费者中的一致性：包括嵌套 per-field codec、引用语义、默认/presence、大小写冲突、字符串编码、未知扩展、列表结构变化、MapKey 转义、旧草稿、契约卸载，以及挂载后的真实输入和导航。测试计划见 phase-plan；本设计阶段不运行或宣称构建/测试结果。
+
+正式规范仅在实现验证后同步至 entry-types、control、editor-game-localization、editor-groups 与 editor-history-and-save。后续动态迁移及尚未实现的 UI 能力明确留在 feature 记录。
+
+## 取舍与风险处理
+
+- 采用共享属性层，避免仅为引用索引特判字段；仍复用 System.Text.Json，控制迁移范围。
+- 允许 JsonElement 搭配显式结构适配，避免强制 DTO 往返丢失扩展和 presence；代价是必须测试 wire 与逻辑路径的边界。
+- 保留显式 schema，避免反射所有 public 成员；计算属性和运行属性不成为作者字段。
+- 分开 Partial 编辑、结构有效、引用覆盖和领域完整检查，避免统一逻辑后扩大保存/提交限制。
+- UI 与扫描有独立预算，防止“界面回退 JSON”被误判成分析失败，或分析器生成大量控件。
+- 动态目录不在当前交付全量迁移，限制跨领域重构扩散；仍有未覆盖警告的场景必须在总结中如实列出。
+
+参考：[feature](feature.md)、[前期讨论](../F-20261023-01-editor-uiux/design-recursive-properties-20261027.md)、[字段契约](../../docs/spec/entry-types.md)、[共享表单](../../docs/spec/control.md#schema-字段表单)、[本地化索引](../../docs/spec/editor-game-localization.md#只读作者索引)。
diff --git a/features/F-20261027-03-recursive-properties/feature.md b/features/F-20261027-03-recursive-properties/feature.md
new file mode 100644
index 00000000..169f5f6b
--- /dev/null
+++ b/features/F-20261027-03-recursive-properties/feature.md
@@ -0,0 +1,90 @@
+# 递归属性访问与嵌套结构统一
+
+状态：in-progress（P1–P4 已验证，P5 综合验证与收尾中）。
+创建日期：2026-10-27。
+用户已选择普通 feature 流程，并明确要求开始实现。正式 [设计](design.md) 和 [阶段计划](phase-plan.md) 已进入实施；当前证据见阶段计划，最终结果以 summary/review 为准。
+
+## 用户目标
+
+起点是 Editor 中正常填写的结构化字段出现 `Structured value has no traversable field schema.` 警告。问题导航已在 UI/UX 后续修复，但已知结构仍存在引用分析盲区。
+
+用户原话：
+
+> 嵌套结构应该也弄成类似unity的迭代序列化吧，逻辑统一也好用。
+
+随后用户询问重构规模、现有特定设计是否可以复用以及收益，并确认“ok，走feature流程吧”。
+
+目标是让嵌套对象和集合可通过一致的属性访问及遍历机制被编辑、校验、分析和定位，减少重复结构逻辑、误报警与引用漏检；保留已有效工作的专用编辑体验与项目作者机制。
+
+## 当前问题
+
+- FieldDescriptor / ValueDescriptor / IFieldDto.Schema 已存在，但嵌套结构的消费者分别解释类型、成员、实际 JSON 名称与路径。
+- StructuredFieldEditor 与 LocalizationReferenceIndex 分别实现 DTO/集合遍历，支持边界不同。
+- Transform、Flipbook 等字段在 Entry 契约中使用 JsonElement，专用编辑器知道子字段，本地化索引无法获取同一结构信息。
+- 通用字典、按类型决定的动态参数与 Timeline 事件需要表达结构和上下文依赖，不能仅以“是 JSON 对象”判断覆盖完整。
+- 只隐藏警告或增加逐字段跳过分析标记，不能满足用户提出的结构统一目标。
+
+## 范围
+
+- 以现有字段元数据、schema 生成和 codec 能力为基础，支持嵌套对象、数组、List 类集合及字符串键字典的结构描述、属性访问和有界遍历。
+- 为编辑、校验、本地化文本/角色引用检查及问题导航提供一致的结构事实和字段路径。
+- 让已知的固定内置结构能够被正确检查；优先打通 Transform 的完整编辑与检查闭环，Flipbook 为同类固定结构接入对象。
+- 保留 NumericUpDown、Slider、无损文本等字段编辑器选择，以及类型、成员和 DTO 专用编辑器覆盖能力。
+- 通用对象使用单一可折叠 Header 和缩进，集合/字典显示数量及对应操作；简单元素保持紧凑。通过主题统一组内/组间间距，不逐层插空白行；专用控件保留各自布局。此展示方向已由用户确认。
+- 保留局部 JSON 修改、未知成员、缺省/null、既有编码兼容、项目草稿、撤销/重做和保存事务。
+- 音效/视觉效果动态参数及 Timeline 作为扩展场景纳入设计；本次提供解析扩展入口与上下文失效验证，实际编辑器/索引全量迁移留待后续。未迁移的未知结构继续报告未覆盖。
+
+## 非目标
+
+- 重写整个 JSON 序列化器或把所有 JsonElement 一次性替换为 CLR DTO。
+- 引入 Unity 的 Prefab override、多对象编辑或任意对象图持久化系统。
+- 改变作者文件、编译内容、存档和运行时执行格式，或在内容中写入 CLR 类型身份。
+- 重做 Transform、Flipbook、Timeline 的既有交互布局。
+- 将领域业务校验搬入通用结构层，或将“引用分析完整”解释成“项目可运行”。
+- 全局关闭不透明结构的提醒，或猜测普通字符串是否是本地化 key。
+
+## 验收标准
+
+1. 同一嵌套字段在编辑、校验、引用索引和问题导航中使用一致的字段身份、实际 JSON 路径及类型规则。
+2. 正常非空 Transform 不再因为结构未知而触发 field.opaque；相关编辑和实际业务校验保持有效。Flipbook 及其他纳入实施范围的结构采用同样标准。
+3. 嵌套对象、集合和字典中的明确文本/角色引用能够被识别；不存在的引用仍有准确定位。未知结构或超限不能被误判为“确定没有引用”。
+4. 修改子字段只修改对应作者数据，保留未知成员、兄弟值、原有编码及缺省/null；只读展开和扫描不写入默认值。
+5. 保留专用控件覆盖、数值编辑路径、跨视图草稿、关闭重开、Save All、Undo/Redo 和稳定 Entry 导航。
+6. 列表结构改变、字段换类型、作者删除、异步结果过期及项目卸载后，旧属性访问不能写到新目标或持有旧项目契约。
+7. 对递归/异常结构具有有界行为和可定位结果；遍历不执行游戏逻辑或任意计算属性 getter。
+8. 被迁移消费者中的重复结构定义和遍历逻辑得到收敛；有构建、针对性回归与正式文档同步证据，不以警告消失作为唯一证明。
+
+## 约束与复用边界
+
+- Core/Runtime 保持平台中立，不依赖 Avalonia、编辑器项目 I/O 或内置业务实现。
+- FieldDescriptor / ValueDescriptor、IFieldDto 生成器、ValueCodec / System.Text.Json 为优先复用资产。
+- 现有 EditorRegistry 覆盖机制、FieldEditorContext / IFieldBinding、作者历史与保存入口继续承担各自职责。
+- 实际 JSON 命名、converter 与历史字符串编码必须被兼容；不能为统一结构而丢弃作者扩展数据。
+- 专用控件保留展示与交互，音效/视觉/场景等领域继续拥有业务规则。
+- 实施需分阶段验证，首批验收优先覆盖基础能力和 Transform 闭环，再据证据推进更复杂的迁移。
+
+## 假设与开放问题
+
+已有讨论作为设计输入。正式设计已确定下列边界，具体 API 名称与实现细节可在不改变需求的前提下调整，并记录实际偏差：
+
+- 复用现有 codec；以显式结构关联/适配解释固定 JsonElement，兼容对象和已支持的字符串编码。
+- 结构缓存有作用域，读取快照与作者写入身份分离；列表结构变化不能复活旧索引句柄。
+- 嵌套检查显式区分 Partial/完整规则；引用覆盖不等同运行有效性，UI 与扫描预算分离。
+- 动态目录与 Timeline 暂不全量迁移，不将扩展入口解释为已有覆盖。
+- 保留旧公开构造函数签名；按五个 Phase 逐步迁移并验证专用/通用消费者。
+
+实施仍需验证 converter 组合、旧契约加载、旧草稿路径和卸载行为。它们是明确的测试与退出条件，不是已证实兼容的声明。
+
+## 归属与相关资料
+
+本 feature 独立于 F-20261023-01-editor-uiux：后者拥有已实现的问题文案、自动检查、稳定定位与数值输入；此处拥有递归结构基础层与消费者统一。保留原有历史，不重复声称定位修复是本 feature 的成果。实际结果见 [实现总结](summary.md) 与 [审核记录](review.md)。
+
+- [前期讨论草案](../F-20261023-01-editor-uiux/design-recursive-properties-20261027.md)：历史设计输入，尚非本 feature 的正式 design。
+- [UI/UX 后续及警告定位证据](../F-20261023-01-editor-uiux/follow-up-group-diagnostics-numeric-20261027.md)。
+- [当前字段与条目契约](../../docs/spec/entry-types.md)。
+- [当前共享表单能力](../../docs/spec/control.md#schema-字段表单)。
+- [当前本地化索引规则](../../docs/spec/editor-game-localization.md#只读作者索引)。
+- [Group 编辑与问题定位](../../docs/spec/editor-groups.md)。
+- [项目历史与保存](../../docs/spec/editor-history-and-save.md)。
+
+后续流程：design → phase-plan → implement → review → closeout。各阶段生成其实际产物和证据后再更新状态。
diff --git a/features/F-20261027-03-recursive-properties/follow-up-effect-parameters.md b/features/F-20261027-03-recursive-properties/follow-up-effect-parameters.md
new file mode 100644
index 00000000..0b2d0ca0
--- /dev/null
+++ b/features/F-20261027-03-recursive-properties/follow-up-effect-parameters.md
@@ -0,0 +1,33 @@
+# 效果参数结构补全
+
+后续语义修订：[合法 shader 扩展参数不产生 warning](follow-up-open-shader-parameters.md)。本记录中早期将 shader 额外成员按 field.unknown 处理的结论已被用户纠正；已知 shader 的开放参数规则以该后续记录与正式规范为准。
+
+2026-10-27 用户反馈：最新提交后，应用特效、应用音频效果的参数 JSON 仍报告 `Structured value has no traversable field schema.`。
+
+原因：首轮迁移只关联 Transform/Flipbook；动态参数表单已经消费效果目录和 shader metadata，但本地化扫描没有收到同一份元数据。此前 summary 将动态迁移留待后续，不能认为正常效果参数的覆盖已完成。
+
+本次按用户反馈补全应用效果、音频效果、shader 预设参数以及音频更新参数的扫描。统一复用 shader 字段投影和效果目录字段，通过每次作者快照的 Entry 类型、program/id 和前缀音频实例身份选择结构。未知类型、资源不可用、未知参数及不确定的更新目标仍保留覆盖诊断。显式自定义字段结构优先，不覆盖契约提供的 schema。
+
+Phase：实现共享字段投影及扫描适配 → 接通项目资源代次、Editor/磁盘验证 → 补回归、同步规范。资源加载继续归现有项目服务；分析接收该代不可变 metadata，不依赖 Avalonia 或执行游戏代码。Timeline 事件全量迁移仍另列范围。
+
+验证要求：有效视觉/音频参数不再 opaque；向量、类型切换、未知成员、未知类型、缺失资源、资源刷新、作用域不同但同名实例、前后文变化、Undo/Redo；扫描不修改作者数据，保留原引用语义和定位。
+
+## 实现
+
+- EntryParameterStructures 在每个作者快照内把所选效果的参数字段关联到 ValueDocument，保留显式契约结构的优先级；不将普通字符串推断为文本引用。
+- ShaderEffectFields 从原表单提取公共字段投影；EffectParameterDefinition.Field 和既有 SEffectParameterDefinition.Field 供目录校验与扫描复用。
+- ProjectSceneTargets 实现 IEntryParameterMetadataSource，复用现有资源准备；目录、shader 声明与 Revision 在同一锁内捕获。ProjectLocalizationQuery 的缓存同时跟踪作者内容和该资源代次。异步发布不能把旧声明标记为新代结果。
+- shader 加载读取托管工作版；音频 update 通过共享 SceneTargetAnalysis 的前缀查询，以 scope/targetId/instanceId 匹配，未来、已停止或不确定类型保持 opaque。
+- 磁盘本地化验证只解析 effect-program 的声明块，不创建渲染器。未知资源、重复 GUID 或不可读清单保留覆盖诊断。
+
+## 验证
+
+- Editor 首轮 6 项通过，包含新增的实际 Problems/资源刷新/未保存 shader 用例；TRX：`TestResults/effects-editor.trx`。
+- Editor.Shared 全量 465 项通过（新增 7 项），包括内置音效、shader 全参数种类、未知成员/资源、自定义目录、音频更新的完整附件身份、磁盘解析和重复资产 ID；TRX：`TestResults/effects-shared.trx`。
+- 最终 Editor Release 构建成功，扩大聚焦 11 项全部通过，包含 shader 实际编辑/预览、音频类型切换与更新、元数据刷新、问题定位和保存重开；TRX：`TestResults/effects-editor-final.trx`。首轮 6 项不重复累计。
+- 并行序列化迁移整合后，Editor.Shared 再次构建成功，效果/本地化索引聚焦 32 项全部通过；TRX：`TestResults/effects-shared-final.trx`。不与此前全量累计。
+- `git diff --check` 的本轮范围通过。验证使用 `AVALONIA_TELEMETRY_OPTOUT=1`、`-m:1 -nr:false -p:UseSharedCompilation=false`，不让共享编译器/遥测目录权限混入产品诊断。没有执行整解决方案构建或宣称原 feature 所有 P5 项完成。
+
+工作区在本轮期间存在并行 JSON/AOT 迁移；未回滚其改动。验证过程中修正了新生成的 `.WithMember(...)` 链前目标类型 `new(...)` 无法推断的单行生成代码，以及 JsonCodec 的缺失 using；这些属于当前工作区编译整合，不将并行迁移的其余改动归为本次效果参数修复。
+
+状态：本补充修复已实现并验证。正式本地化规范与创作工作区手册已同步；Timeline 全量结构迁移仍在本补充范围之外。
diff --git a/features/F-20261027-03-recursive-properties/follow-up-open-shader-parameters.md b/features/F-20261027-03-recursive-properties/follow-up-open-shader-parameters.md
new file mode 100644
index 00000000..c48da022
--- /dev/null
+++ b/features/F-20261027-03-recursive-properties/follow-up-open-shader-parameters.md
@@ -0,0 +1,28 @@
+# 合法 shader 扩展参数不产生 warning
+
+2026-10-27 用户明确纠正：切换 shader 后留下的额外参数本身合法，不应产生 `Unknown author field cannot be analyzed` warning。此前将“允许保留”解释为“保留但警告”不符合需求。
+
+已核对渲染器 ShaderProgramTextureEffect：仅枚举 descriptor.Parameters 绑定 uniform/texture，额外 JSON 成员不被执行、也不承载隐含本地化引用。因此已知 shader 的 parameters 是开放对象，而不是封闭 DTO。该规则覆盖 effect.apply、shader 预设及 Timeline 中的 shader 效果事件。
+
+实现计划：公共结构元数据支持带显式附加值契约的开放对象；shader 将附加值声明为不解释其内部含义的原子 JSON。扫描保留附加值，不将其误认为漏掉的引用，也不将未知 shader 当作已知结构。已声明字段仍按原类型/范围校验；普通 DTO、事件 envelope、Timeline、音效和 legacy catalog 的封闭字段规则不变。
+
+验证：用户 Bloom 参数示例（angle/strength/softKnee/radius/threshold）无警告且原字节语义保留；附加嵌套对象/数组、空键均合法；重复成员、已声明字段的非法值和未知 shader 仍诊断；实际 Editor 资源切换与 Timeline 回归。
+
+## 实现与证据
+
+Core.ValueStructure 新增 OpenObject 和显式 Scalar 元数据，ResolvedValueStructure 保留原公开构造函数并增加 AdditionalField。ValueDocument 只在领域显式声明时接受附加成员，沿实际成员名定位；附加值描述的字段 ID 不成为所有额外成员的公共别名。默认 Object 仍封闭。
+
+EntryParameterStructures 仅为成功解析 metadata 的 shader 参数使用开放结构。额外值作为原子 JSON，不遍历其中未经声明的引用语义；原作者 JSON 保留。该行为通过同一适配覆盖普通效果、shader 预设和 Timeline 效果事件。
+
+- Core Release 构建与全量 **139 项通过**；`TestResults/open-shader-core.trx`。新增开放对象/原子 JSON/空键/重复成员/局部 patch/封闭对象边界用例。
+- Editor Release 构建与聚焦 **7 项通过**；`TestResults/open-shader-editor.trx`。实际 Problems 验证保留的 angle/旧参数不 warning，shader 不再支持 radius 时轨道引用仍正确提醒。
+- Editor.Shared Release 构建通过。全量 473 项首轮 **472 通过、1 失败**：ProtectedAndEscapingTargetsAreRejected 在 SetUp 创建项目的 WriteManifest/File.Move 阶段出现 UnauthorizedAccessException，与参数扫描断言无关；不把未知原因归结为已确认的环境根因。未改测试逻辑，复跑该组及效果/本地化索引 **43 项全部通过**，包括用户 Bloom 参数、附加嵌套 JSON、Timeline shader 事件、重复成员与缺失 metadata。证据 `TestResults/open-shader-shared.trx`、`open-shader-shared-recheck.trx`；不声称单轮全量零失败。
+- 本轮 `git diff --check` 通过。正式字段契约、本地化规范与作者手册已同步，经验记录为 `.agents/lessons/L-20261027-10-open-shader-parameters.md`。
+
+## 整理与复验
+
+按用户要求移除只做转发的 metadata 适配，由 ProjectSceneTargets 直接实现快照接口；shader 表单和预设直接调用公共字段投影。合并参数结构选择分支，使用具名遍历上下文，复用 Timeline JSON options，并将引用诊断改为直接收集结果。英文/XML 注释仅说明快照一致性和开放字段边界。
+
+整理后 Release 构建通过；Core 全量 **139 项**、Editor.Shared 全量 **473 项**、Primitives.Builtins 全量 **321 项**、Editor 聚焦 **8 项**全部通过。证据为 `TestResults/cleanup-{core,shared,builtins,editor}.trx`。此次共享层全量零失败；此前失败与复跑记录保留，不覆盖历史结果。
+
+状态：本修复已实现并验证。此记录修订此前补充中“shader 旧字段保留并 warning”的结论。
diff --git a/features/F-20261027-03-recursive-properties/follow-up-timeline-structure.md b/features/F-20261027-03-recursive-properties/follow-up-timeline-structure.md
new file mode 100644
index 00000000..222ea092
--- /dev/null
+++ b/features/F-20261027-03-recursive-properties/follow-up-timeline-structure.md
@@ -0,0 +1,28 @@
+# Timeline 结构覆盖与按目标诊断
+
+后续修订：[开放 shader 参数](follow-up-open-shader-parameters.md)。本文“保留旧 shader 字段并 warning”的早期判断已撤回；合法附加值不产生 warning。轨道引用自身缺失/属性不支持的诊断仍有效。
+
+2026-10-27 用户再次反馈：效果参数仍有提示（可能为切换 shader 后保留的旧成员，用户允许继续保留）；Timeline 根字段仍有 `Structured value has no traversable field schema.`，且 `/parameters/timeline/tracks/0/handleId` 报 `scene.reference.uncertain`。
+
+用户样例为 60 FPS/60 帧 Timeline，目标 `c2121d4d69544d4d8a584d392dfedbe6` 的 radius 轨道从 32 到 34.3，Replace/Linear；第 8 帧含 layer.show 事件。没有提供此前目标的创建 Entry，因此不能仅凭此片段证明其运行时存在性或 shader 声明有效。
+
+此次用户明确要求处理 Timeline，扩展前一补充未包含的范围：
+
+- TimelineDefinition、Track、Keyframe、Event 的运行 DTO 提供共享 Field schema，保持原有 JSON/wire 与默认实例行为。
+- Editor.Shared 将 editorId/editorTangents 作者 metadata 合入只读结构；事件参数根据当前项目 Entry catalog 和事件 type 解析，效果事件继续复用 shader 参数结构。不运行游戏逻辑、不修改作者 JSON。
+- 已关联 Timeline 中的 shader 资产也参与参数扫描的 metadata 捕获；未知事件/成员/资源保持覆盖诊断。
+- 诊断层对确定、能力完整且已知当前属性值的目标，不再因另一个对象的能力缺失而给出 uncertain。全局 Complete 与删除/重排影响分析仍保留原保守语义；目标自身缺能力、属性不支持/值不可确定、条件或未知引用仍保留诊断。
+- shader 切换留下的旧字段不清除，仍按未知成员报告；不把已知结构覆盖问题与作者数据扩展混为一谈。
+
+验证计划：用户原样例的无副作用遍历、大小写/枚举/编辑器切线、事件内动态 schema 与本地化语义、未知成员及缺失 metadata；无关效果能力缺失不能污染已知 radius 轨道，但目标自身缺失/不支持属性必须仍报警；实际 Editor Problems/导航回归。
+
+## 验证结果
+
+- Editor.Shared Release 构建通过；聚焦 138 项通过后，全量 **470 项全部通过**。新增 4 项 Timeline 结构用例与 1 项按目标诊断用例，包括用户 radius/第 8 帧 layer.show 样例、事件内 shader、自定义项目事件字段的本地化语义、未知成员定位。
+- Editor Release 构建通过；聚焦 **8 项全部通过**，含新增实际 Problems/资源刷新用例，以及原有 shader 编辑、保存重开和警告导航。旧导航测试改用确实缺少 shader metadata 的事件 payload，正常 Timeline 不再被当作 opaque 测试夹具。
+- Primitives.Builtins Release 构建与全量 **321 项全部通过**，覆盖运行契约、Timeline 执行与序列化相关回归。
+- 本轮 `git diff --check` 通过。证据为 `TestResults/timeline-structure-{shared-full,editor,builtins}.trx` 及同名前缀构建日志；聚焦与全量不重复累计。不声称执行了整解决方案构建。
+
+正式本地化规范、场景查询规范与作者手册已同步。工作区中其他 Timeline/UI 和 JSON/AOT 改动保留，没有提交或回滚。
+
+状态：本轮结构补全及已复现的按目标误报修复已验证。随后用户提供完整 Group 并确认 Timeline 不再 warning；剩余问题为已知 shader 的 angle 附加参数被错误警告，已转入开放参数补充修复。目标自身缺失、shader 不支持轨道属性等有效诊断仍保留。
diff --git a/features/F-20261027-03-recursive-properties/phase-plan.md b/features/F-20261027-03-recursive-properties/phase-plan.md
new file mode 100644
index 00000000..b772b435
--- /dev/null
+++ b/features/F-20261027-03-recursive-properties/phase-plan.md
@@ -0,0 +1,108 @@
+# 递归属性访问实施阶段
+
+状态：in-progress；2026-10-27。依据 [需求](feature.md) 和 [设计](design.md)。P1–P4 已按下方证据推进，P5 进行综合验证与收尾。
+
+## 顺序与本次退出范围
+
+| Phase | 状态 | 前置 | 交付 |
+| --- | --- | --- | --- |
+| P1 结构、路径与快照遍历 | verified | 当前设计 | Core 全量与生成器全量通过；旧 API consumer 加载通过，见下方证据 |
+| P2 固定结构与引用索引 | verified | P1 | Editor.Shared 全量 457 项通过，含已知固定结构、未知扩展及编码路径 |
+| P3 专用编辑与项目写入闭环 | verified | P1、P2 | Editor 聚焦 29 项及 Core 全量 136 项通过；共享纯 patch 与专用绑定接入 |
+| P4 通用结构表单迁移 | verified | P1、P3 | Presentation 聚焦 17 项、Editor 聚焦 39 项；含字典操作与关闭全部视图后保存深层草稿 |
+| P5 综合验证、审核与文档 | in-progress | P1–P4 | 证据齐备，迁移边界明确，正式文档与总结同步 |
+
+P3 退出时进行首批闭环评估；P4 仍属于本次交付。动态音效/视觉参数与 Timeline 实际迁移不在本计划范围，只预留解析接口并验证其上下文边界，后续另行形成有范围与证据的计划。不能把它们标成已经迁移或已经消除警告。
+
+## P1：结构、路径与快照遍历
+
+**目标/模块**：Core.Parameters 与 SchemaGenerator；提取共同结构事实，暂不改变已有消费者行为。
+
+任务：建立不可变结构描述及对象成员、集合元素、Map 值规则；增加兼容的描述组合入口与固定 StructureType 声明；统一 JsonTypeInfo/wire 映射及 converter 边界；实现类型化路径、只读属性快照、查找和显式栈遍历。递归结构延迟展开，动态解析接口只消费调用方冻结上下文。明确缓存所有权，不全局持有插件契约。
+
+验证：Core/SchemaGenerator 测试覆盖同类型不同 JSON options、JsonPropertyName、父子 converter 优先级、自定义对象 converter 回退、递归/深层/宽集合预算、取消、missing/null/default、未知/重复属性、Map 的空键/数字键/`/`/`~`、集合元素引用语义。沿用旧构造函数与手写 schema 的调用样例；另用固定旧 API fixture 验证二进制加载，保留旧公开签名。
+
+文档：在 feature 中记录最终 API 与设计偏差，正式 spec 暂不把消费者能力写为已实现。
+
+风险/退出：防止 schema 静态初始化循环、单按 Type 缓存及扫描 getter。相关测试和构建通过，现有 codec 的实际 wire 行为保持一致，公共遍历无 UI/项目依赖后才标 verified。
+
+## P2：固定结构与引用索引
+
+**目标/模块**：Contracts.Builtins、Editor.Shared，依赖 P1。
+
+任务：声明 LayerTransform/FlipbookDefinition 的实际可编辑字段；复用标签、默认值及约束；给相关固定 Entry 字段关联结构与历史编码适配。LocalizationReferenceIndex 迁入共享迭代，保留现有 code、Entry 身份及覆盖判定，支持结构内逻辑位置与实际 wire 位置。
+
+验证：非空正常 Transform/Flipbook 不报 opaque；直接 DTO、对象数组/列表及 Map 中嵌套文本/角色引用仍可找到；缺失引用正确报错；非空未知扩展、未知 converter、坏 JSON 字符串、错误形状与超限仍使覆盖不完整。对照迁移前已有内置 scalar/Choice/catalog 行为；证明扫描不改作者 JSON、不补默认、不依赖页面打开。
+
+相关现有回归：Editor.Shared 的 LocalizationReferenceIndexTests；必要的角色删除/替换及文本查询集成；Builtins 固定结构契约测试。上轮用真实 Transform 制造 opaque 的导航测试需改用真正未知结构，同时新增已知 Transform 不报警断言，不能直接删掉导航回归。
+
+文档：记录已覆盖的固定 Entry 字段清单与残余盲区，准备 editor-game-localization 的实际行为更新。
+
+风险/退出：不能把未知扩展当已知字段，也不能因传递了结构定义就绕过格式错误。新旧引用结果和诊断位置对照成立，固定结构误报消失且未知覆盖仍保守，相关构建/测试通过。
+
+## P3：专用编辑与项目写入闭环
+
+**目标/模块**：Core 的纯 patch、Editor 属性绑定桥接、Transform/Flipbook 控件、EntryEditSession 与导航适配，依赖 P1/P2。
+
+任务：实现 Set/Remove 等路径修改与必要容器创建规则；专用布局从共享 schema/属性取得子字段，移除重复字段清单和 JSON 寻址。子草稿 Save All 使用相同 patch；旧档案路径显式兼容。写入仍经过现有作者意图与 partial/领域校验，保留类型/成员/DTO 覆盖及数字编辑路径。作者身份、控件 lease、根来源与列表结构代次分别复核。
+
+验证：实际挂载 Transform/Flipbook，编辑后立即 Enter、失焦、Escape、上下调整和精确值输入；验证待提交/错误分级、自动检查及点击根/子字段聚焦。包含对象与历史字符串编码、大小写保留与冲突拒绝、未知兄弟成员、缺省/null、关闭所有页面后 Save All、保存重开、Undo/Redo 和跨 Common/Inspector 草稿。删除/换类型/删除后 Undo/根来源改变拒绝旧提交；关闭页面不丢作者草稿；同 JSON 替换不能复活旧句柄。
+
+相关现有回归：GroupDiagnosticsNumericTests、StructuredGroupFormTests、DtoEditorIntegrationTests 与作者历史/草稿用例；补充针对公共 patch 的 Core 测试，不只测试 UI 最终赋值。
+
+展示验收：Transform/Flipbook 专用布局与子字段控件覆盖保持现有体验，公共结构访问不强制把它们改成默认树形表单。
+
+文档：记录首批闭环证据与最终绑定接口；准备 editor-groups、editor-history-and-save 的变化。
+
+风险/退出：不允许写入一半、重序列化根 DTO 丢扩展、别名不一致或关闭视图错误推进作者代次。完整闭环通过、旧格式语义保持、Transform/Flipbook 读写定义与索引一致，再进入 P4。
+
+## P4：通用结构表单迁移
+
+**目标/模块**：Avalonia.Controls 的 StructuredFieldEditor、绑定与默认 registry 适配，依赖 P1/P3。
+
+任务：以公共属性访问替换对象/集合判断和成员反射；保留 DtoEditorHost、整 DTO patch、成员/类型工厂及懒加载。加入字符串键映射的明确键值行与新增/删除/改键行为。元素移动/复制/删除后的子绑定重新解析，保留八层/200 元素 UI 回退与 JSON 修复入口。
+
+展示任务与验收：实现用户确认的单一对象 Header、子字段缩进、序列/字典数量及操作；简单元素不额外包标题。组内/组间间距由主题统一，避免字段标签与内部类型标题重复、逐层空白累加。实际挂载宽/窄窗口及多层对象/集合混合结构，检查折叠、诊断、按钮可达性与布局密度。
+
+验证：Presentation 的 StructuredFormTests、DtoEditorTests、DtoBindingTests；Editor 的 StructuredGroupFormTests 与 DtoEditorIntegrationTests。增加深层 DTO/列表/Map 组合的实际挂载，检查专用覆盖仍命中、集合和字典元素类型/语义一致、原子多字段 patch、未知成员、键冲突草稿、空键/数字键、重排后旧第 N 项提交拒绝、折叠重开和宿主能力转发。UI 回退 JSON 不降低只读分析覆盖。
+
+文档：准备 control 和手册的嵌套结构/Map 扩展示例，记录移除的重复逻辑及仍保留的领域实现。
+
+风险/退出：防止控件重建丢草稿、重复 lease/订阅、通用表单覆盖优先级变化，以及绑定把字典键当成员 ID。迁移范围内的表单与索引/codec 的字段身份一致，相关测试通过并有实际挂载证据后标 verified。
+
+## P5：综合验证、审核与文档
+
+**目标/模块**：全部受影响模块、正式文档与 feature 收尾，依赖 P1–P4。
+
+任务：审核需求逐项覆盖、公共 API/模块依赖、兼容策略与未迁移边界；修复发现的问题。验证默认契约生成及 Editor 打包副本一致。更新 spec/manual，写 review.md、summary.md 和最终状态，已验证经验按仓库流程记录。
+
+验证计划：先确认整解决方案构建成功，再运行 Core、SchemaGenerator、Editor.Shared、Editor、Presentation、Architecture 相关回归；Builtins 运行受影响结构/契约/效果参数用例，按失败或实际改动扩大。构建与共享二进制的 no-build 测试不重叠。运行契约兼容/卸载证据、四语资源一致性、changed C# 格式和 git diff 检查；需要时挂载窄/宽窗口检查焦点与键/值布局。记录实际测试数、失败、环境跳过及证据路径，不能复制旧 feature 的通过数。
+
+文档：实现事实进入 docs/spec/entry-types.md、control.md、editor-game-localization.md、editor-groups.md、editor-history-and-save.md；接入方式进入 docs/manual/editor-authoring-workspace.md；未实现动态场景留在 summary 的边界和后续项。
+
+风险/退出：不因本次统一而意外改变编译或运行 JSON、原生命令业务规则、契约可卸载性及现有专用交互。需求验收矩阵逐项有证据、review 无未处理阻塞问题、正式文档一致、残余盲区明确后才标 feature complete。
+
+## 需求到阶段映射
+
+| 验收点 | 主要阶段 |
+| --- | --- |
+| 共享身份、类型、wire 路径与迭代 | P1、P2、P4 |
+| 固定结构正常值不再 opaque、未知结构仍报告 | P2、P5 |
+| 嵌套引用识别与可点击定位 | P2、P3 |
+| 局部修改、未知成员、编码与 presence | P1、P3、P4 |
+| 数字/专用覆盖、草稿、保存及 Undo/Redo | P3、P4 |
+| 作者/列表/动态上下文失效、契约卸载 | P1、P3、P4、P5 |
+| 有界行为、无隐式业务执行、架构边界 | P1、P5 |
+| 重复逻辑收敛、验证与正式文档 | P2–P5 |
+
+## 变更记录
+
+P1 证据：`recursive-p1-core.trx`（Core 全量）及 `recursive-p1-generator.trx`（生成器全量）；包含递归元数据复用、预算/取消、命名/编码/MapKey、动态上下文、无 getter 扫描，以及对旧 API stub 编译出的独立 consumer 在当前 Core 上实际加载。日志为 `artifacts/.tmp-recursive-p1-*.log`。旧公开构造函数未修改；增加 WithStructure 组合入口。初次兼容 fixture 的 using/assembly attribute 顺序错误已修正，非产品兼容失败。
+
+P5 自审补充：实际 Pointer 在字符串边界终止，而逻辑路径可以进入内部。角色参数比较/替换与文本 draft/复制提交不能再用外层 Pointer 当唯一位置；增加基于 PropertyPath 的纯 Rewrite、LocationKey 并迁移这些消费者，保留旧公开 Pointer Set 签名。CLI/本地化表也保留 Entry 身份及内部位置。补充编码数组中多个引用共享外层 Pointer 但分别安全回写、保留未知大整数的回归。此次属于统一属性路径的必要补全，没有扩大到动态领域迁移。
+
+当前 artifacts 目录曾被工作区清理，部分中间日志/截图已不在；保留的阶段 TRX 仍在各测试项目。最终验证与重新生成的截图统一保存到本 feature 的 `TestResults/`（gitignored），summary 只链接实际存在的最终证据。
+
+2026-10-27：将前期草案的动态参数/Timeline 全量迁移从本次交付中分离，原因是其结构依赖类型、资源和剧情前缀查询，若同时迁移会把固定结构闭环扩大成多个领域改造。本次保留上下文解析扩展口及其失效验证；不得以此默认隐藏未迁移字段警告。后续若扩大范围，先更新设计与计划并在 summary 中保留原因。
+
+2026-10-27：用户确认保留专用展示，通用结构使用可折叠 Header、缩进及主题间距；将展示规则和挂载验收补入 P3/P4，阶段仍为 planned，本轮不实施代码。
diff --git a/features/F-20261027-03-recursive-properties/review.md b/features/F-20261027-03-recursive-properties/review.md
new file mode 100644
index 00000000..5c10e3e0
--- /dev/null
+++ b/features/F-20261027-03-recursive-properties/review.md
@@ -0,0 +1,33 @@
+# 递归属性访问审核
+
+审核方式：实现作者自审、代码/需求逐项核对及实际回归；未安排独立第二审阅者。当前范围结论为 **pass-with-follow-up**；整仓库验收仍有下述构建阻挡，P5 不标 complete。
+
+## 已核对
+
+- 共享结构描述复用现有字段 schema 和 codec，未增加第二份可变作者数据；Core 无 UI/项目 I/O 依赖。
+- 旧公开描述构造函数及 Pointer Set API 保留；独立 consumer 对旧 API stub 编译后在当前 Core 上加载通过。
+- 固定内置结构支持共享只读分析、专用编辑、局部 patch 和保存；未知字段、重复/歧义及无法理解的 codec 不被当作确定无引用。
+- JsonString、MapKey、Index 与 Member 分开，已同时检查读取、定位、引用身份比较、复制和回写；数值 Map 键显示为字面键，避免与数组序号混淆。
+- 只读遍历无实例 getter/DTO 构造；预算/取消、Partial/完整检查、missing/null/default 与编码边界有实际断言。
+- 既有专用布局、注册覆盖、宿主 Reset/可见性、值草稿及项目历史链路保留。失败的键名结构操作仅在当前控件保留，已在 spec/manual 明确。
+- 控件/分析缓存均有作用域，旧列表绑定由结构代次取消，DTO scope 转发属性路径。动态查询入口不伪装成已有领域迁移。
+- 相关 source/build/default-contract 证据在 TestResults；正式规范与接入手册只写入当前实现，不宣称动态效果/Timeline 已覆盖。
+
+## 审核中已修正
+
+1. 字符串内部多个引用共用实际 Pointer，旧引用比较/回写会冲突或替换整段字符串。迁入 LocationKey / PropertyPath.Rewrite，编码数组及文本/角色旧回归验证独立叶值更新。
+2. JsonArray 递归回写原节点会触发 NodeAlreadyHasParent。仅在节点实例实际改变时重新挂载；保留失败回归与修复证据。
+3. 编码对象被按原始 string 误判结构改变，导致叶编辑重建；编码集合结构操作也会失去编码。改按解码形状判断并在提交时保留原表示。
+4. Root Reset 能力与宿主 Reset 策略不能混同，子字段现在继承宿主能力；未知旧输入回退 JSON，避免空的专用面板。
+5. 字面标签与本地化 token 分开；显示完整路径时 Map 键不按整数索引格式化。相同末级字段优先按完整 PropertySegments 聚焦。
+6. 显式结构类型不应投影成无子结构的错误标量并静默通过；未知 DTO codec 的 string wire 也不证明内部没有引用。加固为 schema.invalid/opaque 诊断并补充断言。
+
+## 剩余验证与跟进
+
+**仓库构建阻挡**：最近保留的整解决方案 Release 构建在 `src/Samples/GalNet.Sample.Avalonia/SampleCustomization.cs:105` 报 CS1503：第 7 个视频参数 IVideoPresenter 无法转换为 AvaloniaVideoPresenter。此 feature 未修改 Sample/视频宿主，相关 Editor/Core/Controls 测试项目构建通过。该失败保留于 `TestResults/solution-build.log`，不能声称当前整解决方案构建通过；P5 保持待全局复核状态。
+
+**图集用例稳定性**：ColdAtlasSelectorCanFinishPreparationButAnAuthorEditStillInvalidatesIt 在两个 Release 全量中失败，单独/前缀运行通过；旧 Debug 基线 336 项通过。配置和产物不同，不能用 Debug 通过直接证明 Release 的失败与本次完全无关。用例新增更严格的初次 Select 断言及实际失效版本信息，未修改 SceneTargetSelection/ProjectSceneTargets，也未放宽版本保护；随后 Release 全量 338 项通过。根因尚未确定，保留 suite-order/时间相关稳定性跟进，不将其描述为已修复。
+
+**范围边界**：动态效果、Timeline、未描述 JSON、自定义复杂 converter 仍可报告未覆盖；这是本次明确的交付边界。原生 IME/DPI/辅助技术及独立第二审核未执行，不用 Headless 截图替代这些验收。
+
+最终验证结果与实际次数以 [summary](summary.md) 和 TestResults 中最终 TRX 为准，复跑不重复累计。无证据的全局通过或未迁移能力不计入结论。
diff --git a/features/F-20261027-03-recursive-properties/summary.md b/features/F-20261027-03-recursive-properties/summary.md
new file mode 100644
index 00000000..8bd35ad4
--- /dev/null
+++ b/features/F-20261027-03-recursive-properties/summary.md
@@ -0,0 +1,54 @@
+# 递归属性访问实施总结
+
+状态：implemented / verification-in-progress。实现已落地，P5 正在汇总最终验证；不能把本文件解释为整仓库构建和回归均通过。
+
+## 已实现
+
+Core.Parameters 以现有 FieldDescriptor / ValueDescriptor 为基础增加 ValueStructure、ValueStructureResolver、PropertyPath 和 ValueDocument。旧公开构造函数保持不变，WithStructure 为组合入口；静态 schema 使用延迟类型引用，元数据缓存区分类型、冻结 JSON options 与显式结构声明，并由调用方作用域释放。
+
+属性快照支持对象、现有一维数组/List 类集合及字符串键映射。GetIterator 使用显式栈、深度/节点预算与取消，FindProperty 解析实际 wire 名和字段身份；Validate 显式区分 Partial/必填检查，Patch 生成局部候选而不写作者文档。类型化路径区分成员、索引、Map 键和 JSON 字符串边界。未知结构、重复/歧义成员及不匹配 codec 不被静默认定为覆盖完整。
+
+生成器支持 StructureType 及显式编码/命名兼容标记。LayerTransform / FlipbookDefinition 的可编辑成员提供共享 schema，相关内置 Transform/ToTransform/Flipbook 字段关联结构；计算属性不进入作者字段。正常非空已知值不再仅因为 JsonElement 外层类型而报 opaque，未知扩展仍报告未覆盖。
+
+LocalizationReferenceIndex 改用共享遍历，保留 Entry 身份与实际/逻辑位置。字符串编码结构的引用比较、角色替换、文本草稿和复制回写使用 LocationKey / Rewrite；本地化来源、CLI 诊断和 Problems 保留其正确位置。原公开 Pointer Set 调用入口保留。
+
+Transform/Flipbook 保留专用布局，子字段读取、修改和草稿保存接入公共属性层；通用结构表单也使用同一结构解析与 patch。DTO/成员/类型工厂覆盖、NumericUpDown/Slider/无损文本、宿主能力、已有历史与保存入口保留。通用对象使用单一可折叠 Header、缩进及主题间距；列表显示数量，字典提供键/值、新增/删除/改键及重复键拒绝。字面 Map 键/序号和本地化字段名分别处理，完整 PropertySegments 用于深层字段聚焦。
+
+## 验证记录
+
+最终证据位于本目录的 `TestResults/`（gitignored）。阶段与最终运行分开，不重复累计复跑数量。
+
+| 范围 | 当前结果 | 证据 |
+| --- | --- | --- |
+| Core | 138 通过；后续保守覆盖加固待最终复核 | final-core.trx |
+| SchemaGenerator | 20 通过，包含旧 ABI consumer 实际加载 | generator.trx |
+| Editor.Shared | 458 通过；编码数组多引用分别回写 | final-shared.trx |
+| Presentation | 267 通过；已验证编码对象/列表、语义标量复制和字典操作 | display-presentation.trx |
+| Editor | 全量曾 337 通过、1 图集选择器失败；定位复跑及最终轮次仍在跟进 | final-editor.trx、atlas-prefix.trx、editor-diagnostic.trx |
+| Architecture | 52 通过 | architecture.trx |
+| Primitives.Builtins | 321 通过 | builtins.trx |
+
+已验证场景包括：只读遍历无 getter/DTO 构造、递归 metadata 复用、深度/步数/取消、命名与 converter 边界、missing/null/default、空/数字/转义 Map 键、未知兄弟成员及大整数、旧接口调用、编码内多个引用、上下控件/精确值输入、根/子字段定位，以及关闭全部视图后保存深层 Map 值草稿和 Undo/Redo。截图 `recursive-map-group.png` 及 Group 宽/窄视图已实际检查；原生 IME、DPI、辅助技术仍保留人工验收边界。
+
+相关模块 Release 构建通过并保留分析器警告。整解决方案先前运行通过，但最后保留的 `solution-build.log` 被未在本 feature 修改的 SampleCustomization.cs:105 视频参数类型不匹配阻挡；不得将当前整仓库状态描述为全部可构建。格式检查只声称 changed C# whitespace；源码指纹及默认契约/Editor 打包 DLL 哈希另存 TestResults。部分早期 artifacts 日志被工作区清理，最终证据改存此 feature 的 TestResults。
+
+## 验证中修正
+
+- 已知 Transform 从“制造 opaque 的测试数据”改为正常覆盖断言；警告导航测试改用真正尚未描述的 Timeline JSON，保留定位回归。
+- 公共路径回写不能把已属于 JsonArray 的原节点再挂回原位置，编码数组及旧文本/角色列表回归实际发现此问题；修复后按节点引用决定是否替换。
+- 编码对象叶编辑不应按外层 string 误判结构改变并重建控件；编码列表结构操作也须保留字符串表示。
+- 列表标量元素的引用语义需要一起交给宿主 CopyValue；通过带元素描述的临时结构包装保留原回调 ABI。
+- Header 的本地化 key 与字面 Map 键需分别标记，避免显示 Entry.Parameter.* 或把数值 Map 键误写成列表序号。旧无结构的专用工厂输入回退 JSON，避免创建空面板。
+- 全量中的图集冷加载用例已补强初次选择断言及失效信息，没有通过去掉版本校验或弱化断言使之通过；其顺序/时间相关性仍以最终诊断结果为准。
+
+## 边界与计划落实
+
+当前 shader 参数边界已按用户纠正修订为[开放参数对象](follow-up-open-shader-parameters.md)：已知 shader 的额外成员合法、原样保留且不 warning，不再按普通封闭 DTO 判为漏分析。声明字段仍校验；此规则不全局覆盖未知 schema 或其他封闭领域契约。
+
+首轮交付将动态音效/视觉参数和 Timeline 的全量结构/索引迁移按设计留待后续。用户随后反馈正常效果参数仍有 opaque，已追加[效果参数结构补全](follow-up-effect-parameters.md)：应用效果、shader 预设及音频 apply/update 接入领域 metadata。再次反馈后追加 [Timeline 结构与按目标诊断](follow-up-timeline-structure.md)，接通轨道、关键帧、作者 metadata 与按项目契约解析的事件 payload，修正无关能力缺失污染已知轨道的诊断。实际范围和验证分别以补充记录为准，其他未关联 JSON 仍保留覆盖诊断。IValueStructureProvider 保留纯查询入口；返回结构或未解析结果，冻结上下文及其依赖有效性由调用方拥有，未引入额外的异步领域解析框架或独立依赖令牌系统。
+
+未新增可变 SerializedObject 作者副本。ValueDocument 是只读快照/纯候选操作，作者数据、草稿与历史继续归现有项目会话。序列元素身份由当前快照索引及宿主结构代次保护，未增加全局元素 UID。失败的新增/改键候选仅留在当前控件；字段值草稿才进入跨视图的项目归档。
+
+实际后端仍使用 System.Text.Json；没有重写 JSON 序列化器、替换全部 JsonElement、扩展 Prefab/多对象系统或改变运行/存档格式。当前只读结构解析集中复用现有 Schema，未强制改写所有生成 DTO 的公共接口。完整编译/运行和跨字段领域规则继续由原契约负责。
+
+正式行为同步：[字段契约](../../docs/spec/entry-types.md)、[共享表单](../../docs/spec/control.md)、[本地化索引](../../docs/spec/editor-game-localization.md)、[Group 编辑](../../docs/spec/editor-groups.md)、[历史与保存](../../docs/spec/editor-history-and-save.md)；接入示例见[创作工作区手册](../../docs/manual/editor-authoring-workspace.md#声明嵌套结构)。经验见 `.agents/lessons/L-20261027-06-property-wire-boundaries.md`。
diff --git a/features/F-20261027-04-tagged-release/ci-investigation.md b/features/F-20261027-04-tagged-release/ci-investigation.md
new file mode 100644
index 00000000..f80dfefb
--- /dev/null
+++ b/features/F-20261027-04-tagged-release/ci-investigation.md
@@ -0,0 +1,34 @@
+# CI 与本地基线调查
+
+## 远端证据
+
+- GitHub run `40099479342`（2026-10-24，commit f32b683e）失败于 desktop-build-and-test 的 Editor/UI 测试；format 成功。
+- 失败用例：UiuxVariableEditorsMountCompletionControlsAndSaveOtherValidDrafts；异常位于 Avalonia.Headless.HeadlessUnitTestSession.DisposeAsync，270 项中 269 通过、1 失败。
+- 当前源码已经使用 GetOrStartForAssembly 复用 session，不再在此用例逐次 DisposeAsync；该修正早于本 feature，不将其记作本次新增修复。
+- `40098419620` 是此前成功的 CI run。用户观察到多数运行失败属实，但不是从未成功。
+- gh run list 可读；gh 日志接口反复返回 EOF。使用 GitHub 连接器读取 jobs 与具体 job 日志获得上述证据。
+- [远端失败记录](https://github.com/StarryXYJ/Gal.Net/actions/runs/40099479342)。本次工作未推送、未触发或重跑远端任务，不能宣称远端已绿。
+
+## 本地发现
+
+1. 普通沙箱中 dotnet format 的 build host 管道被拒绝；相同命令在允许本地 IPC 的执行环境可以运行。初次 testhost 连接超时单独复验通过，不通过加大超时或重试掩盖测试失败。
+2. 当前源码存在空白与 using 顺序违规；使用原 CI 的 whitespace / IDE0005 规则修正，不关闭规则。
+3. solution 未列 fixture，Release 构建实际将这些引用工程输出到 Debug，而测试读取 Release 残留。加入全部 fixture 后，ProjectContractPipelineTests 8 项通过。
+4. 精简音轨/Bus JSON 的源生成反序列化丢失 init-only 属性默认值；新增回归先失败，显式 JsonConstructor 默认参数后通过，既有 Editor 音频草稿用例恢复。
+5. UI 用例仍寻找已换成 EntryTypePicker 的旧 AddEntryCommand 按钮；改为验证同一工具栏现有 ExpandAll 图标按钮，保留尺寸、透明背景、键盘焦点等断言。场景选择器先 await PrepareAsync，再操作候选；三项失败用例一起复验通过。
+6. 完整 coverage 运行进一步暴露共享 Headless 指针命中的顺序依赖；场景选择器用例改用实际 Flyout.ShowAt 打开，仍验证候选、提交和 Undo。随后整套 Editor 342 项通过。
+7. GameTestCase ending 的 shake/impact 仍使用旧 targets 数组；迁移为当前 handleId，并同步两种语言的展示说明。集成测试 130 项通过。
+
+最终 P1：`out/ci/local-pass/ci-results.json` 为 passed=true，15 个测试项目合计 2011 passed / 0 failed，包含 coverage；没有禁用用例或放宽产品校验。发布保护用例 6 项通过。远端尚未推送或执行新的 workflow。
+
+## AOT 实际限制
+
+真实桌面 Sample 在独立 artifacts 目录发布，最终 ILC 将约 60 条裁剪/AOT 分析诊断视为错误。涉及源生成 JSON 缺口、反射绑定、动态主题资源、DI 类型保留，以及 Serilog / Ursa / Ursa.Themes.Semi。没有压制这些诊断，也没有产出标记为支持 AOT 的发行 ZIP。
+
+`Test-DesktopAot.ps1` 保留可复现的严格试编译；Release.ps1 对 Aot/Both 明确失败，不回退 R2R。桌面 AOT 仍是未完成阶段，需要单独完成闭包迁移、依赖处理和真实 UI/音视频验收。
+
+## 首发远端 CI 跟进（2026-10-28）
+
+已将 2f64e423 推送到 dev，并手动触发 CI 40559879643。Format 成功，solution build 0 errors；BuildTest 仅 Editor 的 ColdAtlasSelectorCanFinishPreparationButAnAuthorEditStillInvalidatesIt 失败（341 passed / 1 failed），其余测试项目通过。测试在作者操作已经触发后台资源读取后才设置 Gate，无法保证冷查询；改为项目创建前安装 Gate，并显式断言准备任务受控阻塞。后续 tag Release 自带完整 CI 门禁，不跳过失败测试。
+
+修复本地验收：定向用例 1/1、完整 Editor 342/342 成功，证据在 `out/ci/editor-first-release-diagnostic`；修改文件的 whitespace 门禁通过。完整回归使用逐项日志确认持续推进，5.66 分钟完成。仓库已配置 NUGET_API_KEY，用户确认首发版本 v0.1.0-preview.1。
diff --git a/features/F-20261027-04-tagged-release/design.md b/features/F-20261027-04-tagged-release/design.md
new file mode 100644
index 00000000..7f26d46e
--- /dev/null
+++ b/features/F-20261027-04-tagged-release/design.md
@@ -0,0 +1,164 @@
+# Tag 驱动的 NuGet 与 Windows Release 设计
+
+日期：2026-10-27。本文保留目标设计；已实现范围、接口调整和未完成事项以 summary.md / phase-plan.md 为准。桌面 AOT 尚未交付，实际可用命令见正式发布手册。
+
+## 需求与边界
+
+先让本地在无发布凭据时产出完整可验收文件，随后让 CI 在推送 tag 时调用相同脚本。Editor 仅提供 R2R；Sample 提供 R2R 与 NativeAOT，两者均有纯玩家和整合 GameTestCase 两种 ZIP。独立发布给 Editor 使用的 Sample Contracts IL DLL。
+
+首期 RID 建议为 win-x64。只限制应用与原生二进制的交付平台，不给纯托管 NuGet 包人为加 Windows 限制。NuGet 第一批保持现有 net10.0；SchemaGenerator 保持 netstandard2.0。不在本功能中承诺 ARM64、Linux/macOS、移动端、单文件发行或安装器。
+
+## 已核实的现状
+
+- `scripts/release/Publish.ps1` 已生成 Editor / Sample / Sample-GameTestCase 三种 ZIP、每包 manifest 和 SHA-256，固定 Windows x64、Self-contained、R2R。
+- `.github/workflows/release.yml` 已监听 v* tag，接受正式版与 preview.N，调用该脚本再创建 Release；尚无 NuGet 发布步骤。
+- 现有脚本无精确 tag 时用最近的历史 tag 推导版本，有把新提交误标为旧正式版的风险；manifest 中版本尚未统一注入包与应用元数据。
+- `Directory.Build.targets` 对 Core / Contracts.Builtins / GalNet.Project.Contracts 稳定 Git 元数据，并排除三者的 R2R 转换，维护严格契约字节身份。
+- Sample Contracts 工程输出名是 `GalNet.Project.Contracts.dll`。Editor.DefaultContracts 也使用这个程序集名，但语义不同，不能互相替换。
+- `export-sample-contracts.ps1` 当前会重新构建桌面 Sample，并读取普通 bin，不能直接用于保证隔离发布图的产物一致性。
+- Windows x64 Headless NativeAOT 已有自检；桌面 Avalonia/Skia、LibVLC、真实音频设备和桌面 UI 闭包尚未完成 AOT 验收。
+- 源生成器通过 ProjectReference 进入源码构建，但还需设计 NuGet analyzer 资产。
+
+## NuGet：按消费边界聚合为 5 个包
+
+根据用户反馈，取消一程序集一包的方案。保留现有 csproj、程序集名、命名空间与源码依赖边界，在打包层把多个项目的 DLL 放进同一个 nupkg；不做程序集物理合并，也不把 Sample 或 Editor 可执行程序当库发布。
+
+| PackageId | 包含现有项目（下列项目均以 GalNet. 开头） | 包间依赖 |
+| --- | --- | --- |
+| GalNet.Contracts | Core、Contracts.Builtins | 无其他 GalNet 运行时包 |
+| GalNet.Engine | Runtime、Primitives.Builtins、Presentation.Abstractions、GameHost、Assets、Debugging、Diagnostics | Contracts |
+| GalNet.Desktop | Storage.FileSystem、Media.Audio、Media.Miniaudio、Media.LibVlc | Engine |
+| GalNet.Avalonia | Avalonia.Controls、Avalonia.Rendering、Avalonia.GameView、Avalonia.Themes、Avalonia.GameHost | Desktop（间接获得 Engine / Contracts） |
+| GalNet.SchemaGenerator | SchemaGenerator，作为编译器 analyzer | 不添加 GalNet 运行时依赖 |
+
+合计 5 个统一版本的包，收纳 19 个项目。Editor 不发布 SDK，修改 Editor 直接克隆源码；Editor.Abstraction、Editor.Shared 和 Editor.DefaultContracts 仅参与源码构建及应用发行。包内含多个真实 DLL，不是仍然依赖二十多个小包的元包。
+
+使用路径：自定义 Contracts 工程引用 GalNet.Contracts + GalNet.SchemaGenerator，后者设置 PrivateAssets=all；普通 Avalonia 游戏引用 GalNet.Avalonia，间接获得默认后端与 Engine；自备存储/媒体/展示的 Headless 或其他 UI 宿主引用 GalNet.Engine，需要默认后端时再加 GalNet.Desktop。Sample 自身的 GalNet.Project.Contracts.dll 仍为独立 Release 资产，不发布通用 NuGet。
+
+Engine 聚合剧情执行、默认指令、内容读取抽象、宿主会话和展示端口，不带文件存储、设备音频、LibVLC 或 Avalonia 实现。Debugging/Diagnostics 两个小型托管库随 Engine 分发，便于消费者接入协议/诊断，不代表玩家启用调试或基准功能。
+
+Contracts 单独分包的依据是实际消费需求：作者契约项目只需要类型和 schema，而不需要 Runtime 的 NCalc/Serilog 等依赖。当前 Core 包含的类型不全是狭义 DTO，因此 Contracts 的定义是“扩展与内容契约基础”，不承诺纯 DTO 程序集；先通过包装现有两个 DLL 实现，不为包名重构源码。
+
+Desktop 表示默认文件/媒体后端组合；其中 Storage.FileSystem、Media.Audio 等托管代码本身不被宣称仅支持桌面，但默认 Miniaudio 原生资产首期只有 win-x64。聚合的代价是只需要 PCM 的消费者也会取得该后端包的依赖；等存在独立音频/移动宿主消费需求再拆包。Avalonia 保留五个相关项目的聚合，包含默认页面与主题，减少首次接入选择。
+
+SchemaGenerator 保留独立包，明确其只作用于编译期；单独引用它不会为契约项目引入 Engine、Desktop 或 Avalonia。
+
+### 对照其他框架后的取舍
+
+- MonoGame 的官方平台文档提供 WindowsDX / DesktopGL 等后端包入口，体现按真实平台选择分发；不要求把 GalNet 每个内部模块都变成包。
+- Stride 的官方包列出 Core、Engine、Audio、Rendering 等模块，Engine 同时通过依赖组合多个功能；表明 Engine 名称不等于一个无依赖的纯执行器，也不代表其粒度应直接照搬。
+- Avalonia 将 Desktop 入口与 Fluent/Simple 主题作为独立分发选择。GalNet 首期把默认页面/主题聚合在 Avalonia 包内；出现独立主题消费需求后再拆。
+- 本方案从 GalNet 真实用户路径出发：写契约、自备宿主、复用默认后端、使用默认 Avalonia 玩家。由此保留 4 个运行时包和 1 个生成器包；无需独立发布 Editor SDK。
+
+`Sample.Contracts`、`Editor.DefaultContracts`、Sample/Headless/Editor/CLI 应用、测试与 fixture 显式不打 NuGet。未来 CLI 可以独立作为 dotnet tool；不计入本次包数。
+
+### 包的关键要求
+
+1. 普通 NuGet 包发布 IL，R2R / AOT 属于宿主发布模式，不建立 `.R2R` / `.Aot` 包族。
+2. 通过显式白名单描述 5 个 PackageId、各自拥有的程序集、第三方依赖与验证入口，禁止对整个 solution 盲目 pack。每个 GalNet DLL 只归属一个包；上层包只声明依赖，不能再复制下层包的 DLL。
+3. SchemaGenerator 放在 `analyzers/dotnet/cs`，编译器依赖不作为玩家运行时依赖。外部项目显式 PackageReference 并设 PrivateAssets=all；验证从包消费时真实生成代码。不能默认 ProjectReference 的 analyzer 语义会自动转成正确 NuGet 资产。
+4. GalNet.Desktop 随包携带 Media.Miniaudio 的预构建 `runtimes/win-x64/native/galnet_miniaudio.dll`，由 NuGet 选择资产；消费方不应安装 MSVC 或编译仓库 native 源码。首期该原生资产只支持 win-x64，使用默认 Miniaudio 后端的其他 RID 明确报不支持。未来增加 RID 资产，而非新增包名。
+5. Media.LibVlc 是托管适配；桌面宿主按平台引用 LibVLC 原生分发依赖，保留当前宿主组合边界。
+6. 同族包依赖约束首期建议精确版本 `[V]`，保持快速演进阶段的契约/生成器一致；第三方依赖沿用集中版本。打包检查实际 nuspec，不仅检查 csproj。
+7. 包元数据包含许可证、README、仓库地址、commit、XML 文档；符号与 SourceLink 按程序集身份约束配置，不能覆盖现有契约闭包的稳定元数据规则。
+
+### 聚合包实现方式
+
+增加专用打包定义（例如 `packaging/` 下的 packaging csproj 或 nuspec），输入统一发布构建的文件清单。普通 DLL/XML 放 `lib/net10.0`，生成器放 analyzer 目录，原生文件放 runtimes；不对所有 bin 文件做递归通配复制。
+
+显式将内部 ProjectReference 映射为“同包 DLL”或上述 5 个包之一，不能让 pack 自动生成不存在的 GalNet.Core / GalNet.Runtime 等包依赖。聚合同包各项目的第三方 PackageReference，保留版本和 compile/runtime/build/analyzer 资产语义，排除编译器私有依赖。不要仅 SuppressDependenciesWhenPacking 后遗漏第三方依赖，也不要把第三方 DLL 全塞进包以绕开 NuGet。
+
+包消费验收必须离开源码工程：检查 nuspec 仅引用真实存在的聚合包与第三方依赖；验证 Contracts+生成器不带入 Engine、Engine 不带入默认后端/图形依赖，以及 Desktop、Avalonia 的完整依赖链；验证同时引用上下层包无重复程序集/版本冲突；验证生成器、资源与 native 资产真实进入所需构建/发布输出。
+
+## Windows Release 产物
+
+| 文件名模板 | 用途 | 发布条件 |
+| --- | --- | --- |
+| GalNet-Editor-V-win-x64-r2r.zip | Editor，自包含 | 默认 |
+| GalNet-Sample-V-win-x64-r2r.zip | 纯玩家，接收内容目录 | 默认 |
+| GalNet-Sample-GameTestCase-V-win-x64-r2r.zip | 玩家 + 已编译展开的 GameTestCase | 默认 |
+| GalNet-Sample-V-win-x64-aot.zip | 固定 Sample 契约的纯玩家 | 桌面 AOT 完整验收后 |
+| GalNet-Sample-GameTestCase-V-win-x64-aot.zip | 同一 AOT 玩家 + GameTestCase | 桌面 AOT 完整验收后 |
+| GalNet-Sample-Contracts-V.zip | Editor 使用的 Sample 契约 IL 依赖闭包 | 默认 |
+
+最终为 6 个 ZIP；AOT 验收前为 4 个 ZIP。Contracts 是 IL 资产，不加 RID 或 r2r/aot 后缀；仅在跨模式身份一致验收通过后，由两种玩家共享。若实际闭包无法统一，必须显式区分契约包及指纹，不能错误标为通用。
+
+每个 ZIP 包含 README、许可证/第三方声明、release-manifest.json；顶层生成统一 SHA256SUMS 与 release-index.json。默认玩家关闭 EnableGameDebugging，不携带 PDB；运行日志保留。原生 DLL 仍可为外部依赖，不把 AOT 等同于单文件。
+
+Editor 附带或内嵌独立构建的 Headless CLI 与项目创作 skill，具体由运行入口决定；CLI 依赖闭包须完整，不能只复制单个 exe。打包后在无仓库环境执行内容检查/导出验收，避免发行版调用源码路径。Editor 的默认契约与 Sample 契约使用不同目录。
+
+纯 Sample ZIP 不含 GameTestCase；整合包复用该模式的相同玩家文件，额外加入编译后的内容与启动脚本。内容只编译一次，再进入两个模式的整合包，前提是契约指纹一致。不分发中间 galpak 代替最终可运行目录。
+
+## AOT 与契约身份
+
+Editor 仍走 CoreCLR + R2R，继续动态加载项目契约。Sample AOT 在组合根静态引用项目契约、指令与 JSON 元数据；纯 Sample 的“纯”表示无游戏内容，不表示支持随意加载其他项目 DLL。替换剧情/资源须遵守同一契约，替换自定义 C# 扩展需重新编译玩家。R2R Sample 也应明确现有静态 Sample 契约边界，不能默认其是任意插件宿主。
+
+契约身份以未变换的 IL 为源：
+
+1. 在发布专用、固定配置的构建图生成 Core、Contracts.Builtins、Project.Contracts 的 IL，并计算每文件哈希，连同第三方必要依赖形成契约清单。
+2. Contracts ZIP、Editor 内容编译、R2R 玩家与 AOT 编译输入均来源于该构建产物。必须证明实际消费相同 IL；重复构建时进行字节比对，而非仅比较版本号。
+3. R2R 继续排除契约身份闭包的转换。AOT 将类型链接入可执行文件，同时嵌入源 IL 的契约清单，在需要身份验证时使用这份清单；不能依赖 AOT 的 Assembly.Location 或散落 DLL 代表已链接的代码。
+4. 给 Editor 使用的 DLL 只承担作者 schema 加载；它的存在不能给 AOT 增加动态扩展能力。玩家内容入口按契约清单校验，不关闭原有身份验证解决构建不一致。
+5. 所有模式统一受控的 Version/AssemblyVersion/FileVersion/InformationalVersion 策略：PackageVersion 与发布版本一致；AssemblyVersion 建议按 major.minor 固定，FileVersion 为 major.minor.patch.0；契约闭包禁用 commit 自动注入，commit 留在 manifest。升级 SDK、生成器、依赖或编译选项都可能改变字节身份。
+
+桌面 AOT 作为独立可交付阶段，覆盖 Avalonia 编译绑定、Ursa/Semi/DynamicLocalization、JSON/DI、Skia/shader、LibVLC 与原生音频。最终链接产生的 ILLink/ILC 警告逐项处理；不通过全局压制警告或关闭功能得到名义上的成功。明确请求 AOT 时失败必须返回非零，不能静默降级 R2R。
+
+## 本地脚本接口与流水线
+
+保留 `Publish.ps1` 及现有 Editor 调用兼容，在其上增加总入口 `Release.ps1`，把“构建文件”和“发布到服务”分开。以下命令为拟议接口：
+
+```powershell
+# 本地第一阶段：真实构建、pack、ZIP 和验收，不上传
+pwsh -File scripts/release/Release.ps1 -Version 0.1.0-dev.1 -Target All -SampleMode R2R
+
+# 桌面 AOT 验收完成后的完整本地候选
+pwsh -File scripts/release/Release.ps1 -Version 0.1.0-preview.1 -Target All -SampleMode Both
+
+# 正式 tag：必须精确指向 HEAD 且工作区干净
+pwsh -File scripts/release/Release.ps1 -Tag v0.1.0 -Target All -SampleMode Both
+
+# 只上传已经完成验证的文件，不重建
+pwsh -File scripts/release/Push.ps1 -Index out/release/0.1.0/release-index.json -Destination NuGet,GitHub
+```
+
+阶段：ResolveVersion → ValidateEnvironment → Restore → BuildContracts → PackNuGet → PublishHosts → CompileContent → Assemble → Verify → SealIndex。Push 只消费封存索引，校验哈希、commit 和验证结果后上传。NuGet 和主机输出分开，禁止通配上传整个版本目录。
+
+`Target` 支持 NuGet / Apps / Contracts / All；`SampleMode` 支持 R2R / Aot / Both。Editor 始终只构建 R2R，Contracts 只生成一份。构建计划写入索引，验证期望文件清单，不能继续使用“至少六个文件”判断产物完整。
+
+工作目录按版本、RID、模式和唯一 runId 隔离；最终文件放 `out/release/V/nuget`、`out/release/V/assets`，日志、obj/bin/staging 位于同版本的专用工作区。索引只在全部验收通过后封存。不要混入上次运行文件，不删除目录外文件，不并发写同一套 obj/bin。
+
+RID/R2R/AOT/无调试开关影响 restore 图：每种图固定 SDK 和 locked restore，采用受版本控制的独立锁文件；更新锁是显式维护操作。编译期 netstandard 生成器剥离宿主 RID/AOT 属性。原生编译检查 MSVC 完整工具链；普通 NuGet 消费不触发这些工具。
+
+## 版本、tag 与 CI
+
+- 正式版 `v1.2.3`，预览版 `v1.3.0-preview.1`。版本 tag 标记一个已经提交的 commit，tag 不代替 commit。
+- Tag 模式解析精确 tag，验证其指向 HEAD；禁止取最近祖先 tag。正式发布要求干净工作区。
+- 本地无 tag 使用显式版本，或 `0.0.0-dev.<提交数>+<短SHA>`；dirty 状态写入清单。本地同一版本的多轮候选使用独立缓存，NuGet 消费验收采用独立 NUGET_PACKAGES，避免读到旧缓存。
+- tag 版本统一写入 NuGet、应用元数据、文件名和 manifest。PackageVersion 不带仅用于本地溯源的 build metadata；commit 始终在索引独立记录。
+- CI checkout 精确 tag、恢复锁定 SDK/原生工具链，调用 Release.ps1，再上传不可变流水线产物。第一次接入可提供 workflow_dispatch 仅构建验收，不发布。
+- 发布任务下载这些文件并调用 Push.ps1；不另写 CI 专用打包逻辑，也不重新编译。Release 先创建 draft，上传全部资产、推送全部 NuGet 并核实可见性后，最终发布 draft；preview 标记 prerelease。
+- NuGet 与 GitHub 不存在跨服务事务。NuGet 按依赖顺序逐包上传，记录每包状态；中断后从原索引恢复，已有版本须核实同一产物身份。不能用 skip-duplicate 掩盖版本冲突，也不覆盖已公开版本；必要时新发补丁版。
+- 同一 tag 的发布加并发互斥。NuGet.org 凭据建议用 Trusted Publishing；本地第一阶段不需要账号凭据。
+
+## 验收与推进
+
+1. **本地 R2R + Contracts + NuGet**：产出 4 ZIP 和 5 个聚合 NuGet 包；从空目录与隔离包缓存创建外部消费工程，仅用本地 feed 引用，检查依赖、源生成与 native 资产，验证 R2R publish 和真实音频。解压 Editor 后打开 GameTestCase，纯 Sample 指定内容启动，整合 Sample 双击启动；验证编译后的内容可加载、契约哈希一致、无源码路径依赖。
+2. **桌面 Sample AOT**：先独立发布实际 Sample，修复/验证完整桌面闭包；验证页面、语言、场景/图层/shader、声音、视频、选项、存读档和退出。补纯 AOT/整合 AOT 两个 ZIP，验证 RuntimeFeature.IsDynamicCodeSupported=false、源 IL 指纹一致、同一内容在两种模式可运行。AOT 能力未完成前只发布明确的 R2R 产物集。
+3. **CI 仅构建**：在干净 Windows runner 上调用相同入口，验证 SDK、锁文件、原生构建、内容与目录完备。原生 UI/音视频完整本地验收与 CI 可自动执行的 smoke 分别记录。
+4. **公开发布**：接 NuGet 认证与 GitHub 发布，测试 preview tag、失败重试、部分包上传恢复、正式 tag；成功后才更新正式发布手册。
+
+## 取舍与风险
+
+- 5 个聚合包减少分发与版本管理成本，保留源码模块划分与契约/引擎/后端/UI 的消费边界；代价是包级可选粒度更粗，且打包层需维护程序集所有权和第三方依赖映射。通过白名单与外部消费验收控制风险，不通过额外发布二十多个小包解决。
+- 统一版本简化契约兼容和用户升级，代价是小改动也发布整族；待公共 API 稳定后再考虑独立版本。
+- 桌面 AOT 是实际工程工作，不能从 Headless 自检推断。若依赖阻塞，记录具体阻塞并保留 R2R 交付，不给 Editor 增加 AOT 工作。
+- GitHub 自动源码 ZIP 不包含生成后的可运行 Sample；可执行包与 Contracts 必须作为显式 release assets。
+- GameTestCase 和字体/音视频等第三方素材发布前核实再分发许可，应用包保留相应声明。
+
+## 依据
+
+仓库现状：`docs/manual/release-packaging.md`、`docs/manual/native-aot.md`、`docs/manual/cross-platform-backends.md`、`Directory.Build.targets`、`scripts/release/Publish.ps1`、`scripts/contracts/export-sample-contracts.ps1`、`.github/workflows/release.yml`。
+
+外部约束：[NativeAOT 限制](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/)、[NuGet analyzer 约定](https://learn.microsoft.com/en-us/nuget/guides/analyzers-conventions)、[NuGet 原生资产](https://learn.microsoft.com/en-us/nuget/create-packages/native-files-in-net-packages)、[NuGet 多程序集选择](https://learn.microsoft.com/en-us/nuget/create-packages/select-assemblies-referenced-by-projects)、[NuGet pack 规则](https://learn.microsoft.com/en-us/nuget/reference/msbuild-targets)、[NuGet Trusted Publishing](https://learn.microsoft.com/en-us/nuget/nuget-org/trusted-publishing)。
+
+同类分发参考：[MonoGame 平台与包](https://docs.monogame.net/articles/getting_started/platforms.html)、[Stride.Engine 包依赖](https://www.nuget.org/packages/Stride.Engine)、[Avalonia 官方仓库](https://github.com/AvaloniaUI/Avalonia)、[Avalonia 主题包](https://docs.avaloniaui.net/docs/styling/themes)。
diff --git a/features/F-20261027-04-tagged-release/feature.md b/features/F-20261027-04-tagged-release/feature.md
new file mode 100644
index 00000000..17934636
--- /dev/null
+++ b/features/F-20261027-04-tagged-release/feature.md
@@ -0,0 +1,12 @@
+# Tag 驱动的 NuGet 与 Windows Release
+
+- 状态：本地与远端 CI、五包 NuGet 与 Windows R2R 发行已验收；v0.1.0-preview.1 已公开发布。桌面 Sample AOT 未完成。
+- 日期：2026-10-27。
+- 需求：本地先运行完整发布流水线，后续 CI 在版本 tag 上调用同一套仓库脚本，生成 NuGet 和 GitHub Release。
+- 已确认：Editor 不做 AOT；仅 Sample 提供 R2R / NativeAOT 两种模式。Release 包含纯 Sample、整合 GameTestCase 的 Sample、Editor 和 Sample Contracts DLL。
+- 已确认：NuGet 将多个项目合入少量包，不采用一项目一包。Editor 不提供 SDK，修改时克隆源码。
+- 当前提案：Contracts、Engine、Desktop、Avalonia、SchemaGenerator 共 5 个包，保留现有程序集边界；分开契约、运行逻辑、默认后端与图形展示。
+- 设计假设：第一批可执行发行包只支持 Windows x64；Windows ARM64 在桌面依赖和实机验收后再增加。
+- [设计方案](design.md)。本文与设计均是目标状态，不替代当前正式发布文档。
+- [阶段与验收](phase-plan.md)、[CI 调查与 AOT 限制](ci-investigation.md)。当前可运行命令见 docs/manual/release-packaging.md。
+- [实现总结与验收证据](summary.md)。
diff --git a/features/F-20261027-04-tagged-release/phase-plan.md b/features/F-20261027-04-tagged-release/phase-plan.md
new file mode 100644
index 00000000..f4fb41a9
--- /dev/null
+++ b/features/F-20261027-04-tagged-release/phase-plan.md
@@ -0,0 +1,20 @@
+# 实施阶段
+
+用户于 2026-10-27 授权实现，并要求本地优先、先验证 CI；可用 GitHub CLI 读取远端失败证据。
+
+| Phase | 范围与退出条件 | 状态 |
+| --- | --- | --- |
+| P1 | 读取最近 CI 失败日志；将 restore/build/test/format 形成仓库本地入口，Actions 复用；本地实际运行，保留失败或通过证据 | verified：15 项目，2011 passed / 0 failed，含 coverage |
+| P2 | 5 个聚合 NuGet 包、外部消费验证、R2R/Contracts 本地发布入口、版本与产物索引；实际生成验收 | verified：0.1.0-dev.1 完整本地发行和桌面初始化 smoke 通过 |
+| P3 | 桌面 Sample AOT 发布与运行验证；不将 Headless 证据当作桌面支持 | in-progress：严格试编译失败，未开放 AOT 发行 |
+| P4 | tag workflow 调用同一入口、上传已验证产物的独立脚本、文档和收尾；无明确发布请求不上传公共 NuGet 或创建版本 tag | verified：用户授权首发 v0.1.0-preview.1，远端 build/publish 成功，五包获 NuGet Created，四 ZIP/索引/校验和已公开 |
+
+验证按阶段顺序运行，避免构建输出竞争。失败不能通过跳过用例或放宽校验掩盖。跨平台后端 job 仍需对应系统执行，本地 Windows 不能证明所有 runner 都通过。
+
+P1 证据：`out/ci/local-pass/ci-results.json` 整体 passed=true；15 份 TRX 合计 2011 passed / 0 failed，含 coverage。6 项发布保护负例独立通过；最终保护检查接线/格式验证见 `out/ci/format-with-release-guards`。Headless AOT 自检输出 AOT_ACCEPTANCE_OK dynamicCode=False reflectionJson=False。
+
+P2：`out/release/0.1.0-dev.1/release-index.json` 包含 5 个 NuGet 与 4 个 ZIP、完整文件哈希。独立消费工程编译/运行、所有 GalNet 程序集公开类型加载、源生成器、native DLL 加载通过；ZIP 解压/hash/R2R 标记/契约身份/CLI help/Skill 文件验证通过。`out/release-smoke/dev1/app-validation.json` 为 passed=true、desktopStartup=true，日志确认 11 个 sprite 和 15 个 effect program 资产发现，Session initialized。
+
+P3：真实桌面 NativeAOT 严格链接失败，见 ci-investigation.md；保留诊断脚本和明确拒绝 AOT/Both 的发布门禁。不能标记本 feature 全部完成。
+
+2026-10-28 P2 跟进 verified：用户要求核实体积及整合内容形态。过滤全部应用 PDB 和非 x64 VLC 内容；发布验收检查仅保留所需架构，并要求整合内容为非空 PAK / 编译剧情而非原始作者文件。`Release.ps1 -Version 0.1.0-dev.2 -Target Apps -OutputRoot out/release-size-check`、独立解压 DesktopSmoke（`out/release-size-smoke/dev2/app-validation.json`）及 7 项保护检查均通过。ZIP 体积对比见 summary.md。
diff --git a/features/F-20261027-04-tagged-release/runtime-sharing-20261028.md b/features/F-20261027-04-tagged-release/runtime-sharing-20261028.md
new file mode 100644
index 00000000..cff076de
--- /dev/null
+++ b/features/F-20261027-04-tagged-release/runtime-sharing-20261028.md
@@ -0,0 +1,33 @@
+# Editor/CLI 运行时共享与精简发行
+
+用户授权：Editor 与 CLI 避免重复运行时；额外分发要求用户安装 .NET 的 Editor/Sample。VLC 仅考虑容易裁减的部分，不引入复杂构建维护。
+
+## 实现
+
+- 两个应用先独立 publish，再合并到同一应用目录。重名发布文件必须 SHA256 一致，否则失败；不覆盖依赖，不依靠删除 CLI 运行时后搜索父目录的未定义行为。CLI 入口调整为根目录 `GalNet.Editor.Headless.exe`，Skill 为根目录 `Skills/galnet-project-authoring`。
+- `Publish.ps1 -Deployment SelfContained/FrameworkDependent` 控制部署方式，默认保持完整版。两种方式均保留 R2R、win-x64 原生依赖与契约 IL 身份规则。
+- `Release.ps1` 默认生成六个应用 ZIP 和一个两种方式共享的 Contracts ZIP；精简应用名追加 `-framework-dependent`，README 写明 .NET 10 x64 Runtime 要求和下载入口。
+- 验收涵盖两种方式的 manifest/hash、运行时份数、runtimeconfig、所有入口的 R2R、契约闭包、解压 CLI 的 help/创建项目/schema 查询。可选 DesktopSmoke 增加 Editor 初始化及实际加载的 runtime 路径检查，保留 Sample 会话初始化。
+- VLC 暂不追加裁剪。Gallery 缩略图截图、视频/音频播放及 Editor 预览有不同依赖，现阶段保留已有 x64 插件集合。
+
+## 验证
+
+本地候选已封存：`out/runtime-sharing/0.1.0-dev.30`，七个 ZIP、SHA256SUMS、release-index.json。发布保护七项、脚本语法及改动文件的 whitespace 检查通过。
+
+| ZIP | 完整版 MiB | Framework-dependent MiB |
+| --- | --- | --- |
+| Editor（含 CLI） | 111.95 | 76.80 |
+| Sample | 107.36 | 72.20 |
+| Sample-GameTestCase | 137.71 | 102.55 |
+
+Contracts ZIP 为 0.35 MiB，两种部署共用。与上次 Editor 149.66 MiB 的候选相比，共目录发布后约减少 37.71 MiB；跨版本源码可能有其他小变化，不能将差值全部当作精确运行时大小。
+
+`out/runtime-sharing-smoke/app-validation.json` 为 passed=true、desktopStartup=true，包含两种部署。全部入口均有 R2R 标记、跨模式玩家契约闭包字节一致、完整版每包只有根目录一份 coreclr，精简版不含 coreclr/hostfxr/hostpolicy/System.Private.CoreLib。两种分发 CLI 均通过 help、实际创建项目和 schema 查询；两种 Sample 的独立 profile 日志均含 Session initialized。
+
+实际进程模块：完整版 Editor 从解压目录根加载 coreclr.dll；精简版从 `C:/Program Files/dotnet/shared/Microsoft.NETCore.App/10.0.12/coreclr.dll` 加载。Editor 只验证初始化和 runtime 来源，Sample 只验证会话初始化，不代表所有 UI 或完整剧情验收。
+
+首次 Release 在精简版 CLI 创建临时目录时出现一次 Access denied，未封存最终目录。相同 CLI、相同路径独立重试成功；未修改产品代码或加入自动重试。随后在独立短目录对原七个 ZIP 重新进行完整分发与 DesktopSmoke 验证并通过。使用 `out/runtime-sharing-resume.ps1` 调用 Release.ps1 的原始封存尾段生成最终索引，未重新编译或修改 ZIP；原始失败日志保留在 `.work/.../app-validation/logs/`。访问拒绝的具体原因未证实。
+
+工作区另有并行 content-packaging 源码改动，未覆盖这些改动；这是 dirty 本地 Apps 候选，未重复构建或验收 NuGet，不宣称正式 tag 发布。构建仍有既有分析器与 Avalonia 警告。
+
+这次只生成本地候选，不上传、不创建 tag，不代表跨平台发行已验证。
diff --git a/features/F-20261027-04-tagged-release/sample-aot-preparation-20261028.md b/features/F-20261027-04-tagged-release/sample-aot-preparation-20261028.md
new file mode 100644
index 00000000..6a280aa5
--- /dev/null
+++ b/features/F-20261027-04-tagged-release/sample-aot-preparation-20261028.md
@@ -0,0 +1,37 @@
+# Sample AOT 准备：自有 JSON 与静态访问路径
+
+## 范围与授权
+
+用户确认仅 Sample 需要移动端、iOS 为目标，并授权先改进自有 JSON 元数据等路径，即使 NativeAOT 尚未支持也保留可复用改进。本轮处理不改变产品语义的 JSON、主页面绑定和工厂发现；不迁移 Editor/CLI，不创建 iOS App，不为通过链接关闭警告或裁剪。桌面严格 NativeAOT 只用于发现共享代码问题，不替代 iOS 构建、签名和真机验收。
+
+## 实现
+
+- 输入设置增加私有源生成 JSON context，保持原有 PascalCase 属性、数字设备枚举、校验与无效输入恢复默认行为。
+- 数值设置约束用已有源生成字典元数据，去除匿名 DTO 的反射序列化。
+- 共享表单的 null、JSON 文本、对象/字典及数组操作统一走显式元数据 JsonCodec；数组临时列表转成已注册的 JsonElement[]，自定义 DTO 仍由字段描述的 JSON 元数据负责。
+- 枚举选项和初始值使用 underlying-type 数组后 Enum.ToObject，避免运行时生成未知枚举数组；保留数值排序、别名和 ulong 值。
+- GamePage 的八条运行时字符串路径换为类型化 CompiledBinding，继续跟随 DataContext 替换及属性通知。
+- 删除 renderer 程序集扫描：当前唯一工厂需要 shader program 资源参数，不存在无参内置工厂。保留 DiscoverTextureFactories 公共入口返回空集；资源 shader 工厂仍由 GetProgramFactoryAsync 显式创建。
+
+## 验证与边界
+
+- 已在关闭 System.Text.Json 反射的测试进程运行 SampleAotPreparationTests，9/9 通过；涵盖旧 wire 格式、无效配置回退、数值上下界、ulong 枚举别名及页面 DataContext 替换。证据：`out/sample-aot-preparation/test-results/reflection-off.trx`、`reflection-off.runtimeconfig.json`。
+- 普通 Presentation 完整回归 276 passed / 0 failed（设备与人工预览 Explicit 用例未执行）。证据：`out/sample-aot-preparation/test-results/presentation-regression.trx`。
+- 改动文件的 dotnet format whitespace、IDE0005 imports 与 git diff --check 均通过。
+- 最终严格 NativeAOT 未通过：ILC 报告 21 条最终链接诊断，不产出可发行的 AOT ZIP。日志为 `out/sample-aot-preparation/probe-final/logs/desktop-aot.log`，提取列表为同 probe 根的 `analysis-errors.txt`。本轮第一次成功进入 ILC 的探测为 23 条；移除动态枚举数组后，两条 IL3050 消失。该轮内差异仅用于确认枚举改动，历史约 60 条不作为固定基线比较。
+- 初次受限环境的 MSBuild/ILLink task host 报 MSB4216，属于本地子进程/管道限制；放开本地验证执行后才进入 ILC 最终分析。测试夹具首次使用了其他测试类私有的 NoOp 导航类型，修正为真实无操作路径的 GameNavigationService 后通过。
+- 当前工作区存在其他任务的共享源码修改，本轮没有覆盖这些文件。不能把历史约 60 条与本轮诊断数量直接当作固定源码的收益对比。
+
+这些改动提高裁剪兼容性、消除对应反射调用；没有进行包体、启动或内存 A/B 测量，不宣称定量性能改善。
+
+## 剩余阻塞
+
+| 类别 | 当前最终诊断/位置 | 后续边界 |
+| --- | --- | --- |
+| 本地化与 XAML 模板 | PlayerTextExtension / PlayerTextBlock、GameShell 的 SkipPrompt 与多个编译 XAML closure 的反射 Binding，IL2026/IL3050 | 需要静态类型化的本地化接口与模板绑定上下文，不通过保留整个程序集解决动态代码要求 |
+| 主题/调色板 | GameLayoutTheme、GamePalette 在 C# 中通过 URI 创建 StyleInclude/ResourceInclude，IL2026 | 为内置资源提供编译期引用/工厂，同时明确自定义主题的扩展接口，保留每个玩家根的资源隔离语义 |
+| 页面构造与 DI | ViewTypes 集合的 Type 构造声明、Gallery 泛型注册、截图对话框的 Type 返回值，IL2072/IL2091 | 在注册和工厂边界传递正确的构造保留要求，不能只在消费端压警告 |
+| 通用结构表单 | StructuredFieldEditor.InitialValue 仍对未知值类型 Activator.CreateInstance，IL2072 | 需要显式初始值工厂，兼容自定义 struct 的无参构造、字段默认值及现有编辑语义 |
+| 第三方库 | Serilog 的对象属性解构、Ursa EnumSelector 的枚举字段反射，IL2072/IL2075 | 评估版本支持、可替换路径或准确的库级适配，不全局吞诊断 |
+
+本轮有边界的准备与验证已完成，完整 Sample NativeAOT/iOS 支持仍未完成。Windows 编译通过本身也不能替代后续真实 UI/音视频、Mac/Xcode 与 iPhone 设备验收。
diff --git a/features/F-20261027-04-tagged-release/summary.md b/features/F-20261027-04-tagged-release/summary.md
new file mode 100644
index 00000000..8375df8e
--- /dev/null
+++ b/features/F-20261027-04-tagged-release/summary.md
@@ -0,0 +1,71 @@
+# 本地 CI 与 R2R 发布实现总结
+
+日期：2026-10-28。范围：已完成本地/远端 CI、五个聚合 NuGet、Windows x64 R2R 与 Contracts ZIP；v0.1.0-preview.1 已公开发行，桌面 AOT 未完成。
+
+## 实现结果
+
+- `scripts/ci/Invoke-CI.ps1` 是本地与 Actions 共用入口，固定 SDK、Configuration 和 locked restore；构建完成后逐项目 no-build 测试，支持 coverage，输出 JSON/TRX/原始日志。
+- CI 已纳入全部 15 个 GalNet 测试项目；所有契约 fixture 加入 solution，避免 Release 测试读取 Debug 构建之外的旧 DLL。修正既有格式/using、音频源生成 JSON 默认值、旧 UI 测试入口、Headless 选择器交互和 GameTestCase 过时参数。
+- `packaging/packages.json` 明确 19 个库项目归属；按 Contracts / Engine / Desktop / Avalonia / SchemaGenerator 发布 5 个聚合包，每个 DLL 只有一个 owner，保留原程序集与命名空间。没有 Editor SDK 包。
+- `Release.ps1` 统一版本、构建、NuGet pack、仓库外消费测试、R2R 应用/内容组装、ZIP 验收及最终索引；只有全流程成功才暴露版本目录。
+- Editor 附独立、自包含的 Headless CLI 与项目创作 Skill。纯 Sample 与整合 Sample 复用相同玩家，整合内容直接展开；Contracts ZIP 从实际玩家复制三份匹配 IL DLL，不重新构建另一份契约。
+- `Push.ps1` 只上传索引列出的文件，检查哈希/版本/干净 tag/消费验收；使用 draft、依赖顺序、逐文件 journal，不重新编译或静默跳过重复版本。首次实际推包与 GitHub prerelease 已成功。
+- Release workflow 调用相同 CI/本地发布入口；workflow_dispatch 仅生成候选，tag 才进入公开上传 job。NuGet 认证由 NUGET_API_KEY 环境变量提供。
+
+## 本地证据
+
+| 检查 | 结果与位置 |
+| --- | --- |
+| 完整 CI + coverage | `out/ci/local-pass/ci-results.json` passed=true；15 项目，2011 passed / 0 failed |
+| 发布保护 | `out/ci/release-guards-final/guard-results.json`，7 项通过（含 tag commit 校验），无构建/上传命令 |
+| 最终 guard 接线与格式 | `out/ci/format-with-release-guards/ci-results.json` passed=true |
+| Headless NativeAOT 回归 | `out/tagged-release-headless-aot.log`：AOT_ACCEPTANCE_OK dynamicCode=False reflectionJson=False |
+| 完整本地发行 | `out/release-local-acceptance.log`，Release.ps1 退出 0 |
+| 五包/四 ZIP 与哈希 | `out/release/0.1.0-dev.1/release-index.json`、SHA256SUMS |
+| 外部包消费 | `out/release/.work/0.1.0-dev.1-f62990397b54464d8d6cf72cad4b2ceb/validation/package-validation.json` passed=true |
+| ZIP 解压、R2R、契约、分发 CLI | 同 work 根的 `app-validation/app-validation.json` passed=true |
+| 真实桌面 Sample 初始化 | `out/release-smoke/dev1/app-validation.json` passed=true、desktopStartup=true；独立 profile 日志含 Session initialized |
+| Workflow YAML | 三份 YAML 使用 PyYAML 解析成功；尚未在 GitHub 执行新 workflow |
+
+ZIP 大小约：Editor 261.43 MiB，纯 Sample 191.81 MiB，整合 Sample 222.17 MiB，Contracts 0.34 MiB。五个 NuGet 合计约 2.4 MiB。
+
+### 2026-10-28 发行体积跟进
+
+后续已完成 Editor/CLI 共目录共享运行时，并新增 framework-dependent 发行包；当前实现与验收见 [运行时共享跟进](runtime-sharing-20261028.md)。以下四 ZIP 与独立 CLI 描述保留为此前候选的历史记录，当前发行说明以手册为准。
+
+真实载荷发现 VLC NuGet 带了约 178.4 MiB 的 win-x86 / win-arm64，Editor 还有约 102.8 MiB PDB。现在在生成 manifest 前过滤全部 PDB 及上述非目标架构文件，保留 x64 核心与插件。Editor 的独立自包含 CLI 暂时仍保留运行时副本。
+
+| 应用 ZIP | 首次候选 MiB | 精简后 MiB |
+| --- | --- | --- |
+| Editor | 261.43 | 149.66 |
+| Sample | 191.81 | 107.35 |
+| Sample-GameTestCase | 222.17 | 137.70 |
+
+`out/release-size-check/0.1.0-dev.2` 为本次 Apps 候选；未重复构建 NuGet。所有应用 PDB=0，Sample 的 DLL 数量由 1214 降到 577。四个 ZIP 的解压/hash/契约/R2R/CLI/架构及内容检查通过；`out/release-size-smoke/dev2/app-validation.json` 为 passed=true、desktopStartup=true；7 项发布保护用例再次通过。第一次验证因用户同时清理输出目录而中断，换独立输出根重跑后成功。
+
+整合 GameTestCase 原本已通过 export-directory 编译，本次进一步锁定产物形态：资源 `Assets/Paks/000-base.pak` 约 30.4 MiB、剧情 `.galgroup`，保留运行时 Graph/配置/本地化 JSON；发布验证拒绝散装作者素材、rawgalgroup 和 Contracts 作者目录。不能将这些运行时 JSON 当作“未编译素材”删除。
+
+本地候选从 CI 修复 commit `88c12e7b` 及当时未提交的发布脚本构建，索引如实标记 dirty=true，没有 tag，因此不能通过公开上传门禁。它是可运行开发候选，不冒充正式 tag 发行。SDK/第三方源审计遇到网络问题时仍有 NU1900 警告；构建和测试的通过不代表零警告。
+
+## 未完成与实际限制
+
+1. **桌面 Sample AOT 未完成。** 首次真实 ILC 严格链接约 60 条诊断，涉及 JSON、反射绑定、主题资源、DI 保留和 Serilog/Ursa 裁剪。没有全局吞警告，也没有伪造 AOT ZIP。`Test-DesktopAot.ps1` 可重现；Release 的 Aot/Both 明确失败。Headless 通过不能替代桌面验收。
+   2026-10-28 已完成一轮 Sample 自有 JSON、静态绑定、工厂与枚举路径准备：关闭 JSON 反射的 9 项测试及 276 项普通 Presentation 回归通过；最终严格链接仍有 21 条诊断。具体范围、证据及未完成的自有/第三方阻塞见 [Sample AOT 准备](sample-aot-preparation-20261028.md)。
+2. **中断恢复尚未实测。** 首次远端完整 CI、公开 NuGet 上传与 GitHub prerelease 已成功；跨服务部分上传中断后的恢复仍未实测。
+3. **桌面 smoke 范围有限。** 验证解压后玩家加载整合内容并初始化，不代表完整剧情、全部音视频设备、存读档和正常退出均已完成原生验收；测试只终止自己启动的进程。
+4. 首期仅 win-x64；ARM64、其他系统和移动端未纳入发行。CLI 自包含分发已验收，但 Editor 原有“导出游戏”界面的仓库脚本依赖仍保留，未宣称 GUI 已成为脱离源码的完整构建工具链。
+
+## 与目标设计的接口调整
+
+- 首期 Target 为 All / NuGet / Apps；Contracts 随 Apps 或 All 生成，从实际玩家复制，未增加独立 Contracts 构建目标。
+- Version 通过 SDK 统一写入程序集元数据，AssemblyVersion 采用 SDK 的 major.minor.patch.0 默认策略，未额外固定到 major.minor；原有契约稳定 Git 元数据及 R2R 排除规则保留。
+- 本地执行的是 Actions 共用的真实检查脚本，不模拟 checkout、权限、GitHub artifact 服务或 NuGet 上传端点。后者必须在远端或实际预发布时验证。
+
+## 文档与经验
+
+2026-10-28 首发：用户授权 `v0.1.0-preview.1`，tag 指向 `bea00e144e8dd489c3e83ac5cd29c9805eee053a`。首次手动 CI 暴露冷图集测试 Gate 安装过晚，修复后本地 Editor 342/342、远端 15 项目 2011 passed / 0 failed。Release workflow [40566476656](https://github.com/StarryXYJ/Gal.Net/actions/runs/40566476656) 的 build/publish 均成功；NuGet 五次返回 Created / Your package was pushed；[GitHub prerelease](https://github.com/StarryXYJ/Gal.Net/releases/tag/v0.1.0-preview.1) isDraft=false、isPrerelease=true，四 ZIP 加索引/校验和共六个资产。公开索引 dirty=false、consumer validation passed=true。证据在 `out/first-release-cloud-evidence` 与 `out/first-release-cloud-index`；NuGet 上传后查询 flat-container 暂为 404，公开索引传播仍需时间，不能将服务器已接收等同于客户端已经可恢复。
+
+- 当前使用说明：`docs/manual/release-packaging.md`、`scripts/README.md`。
+- 过程与远端证据：`ci-investigation.md`。
+- lessons：solution fixture 配置与 init-only 源生成 JSON 默认值，已索引到 agent-knowledge。
+- CI 阶段提交：`88c12e7b`。发行阶段提交在验收后独立创建。
diff --git a/features/F-20261028-01-content-packaging/design.md b/features/F-20261028-01-content-packaging/design.md
new file mode 100644
index 00000000..ce1f42bb
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/design.md
@@ -0,0 +1,265 @@
+# 单 Graph 资源化、剧情分包与资源覆盖设计
+
+状态：保留根据 2026-10-28 用户讨论形成的设计历史，P1–P6 已验证。正文中的“当前事实”指设计开始时的基线；最终实现及偏差见各阶段记录，当前规范见 docs/spec。范围与状态见 [feature 清单](feature.md)。
+
+P3 实施修订：文本/人物暂保留基础完整文件，不按剧情分片；存档保守记录准备时所有已安装剧情包。64 MiB 是默认软阈值而非内存保证，大资源观测留给 P6。证据与边界见 [P3 记录](phase-3.md)。
+
+P6 实施修订：根据合成大资源导出/安装观测，最终默认软阈值改为 32 MiB；保留 P3 的 64 MiB 历史。图集覆盖后的存档按当前有效图集重新解析派生图片，支持安装和移除资源覆盖；普通未覆盖图集仍严格校验。观测方法和兼容限制见 [P6 记录](phase-6.md)。
+
+实现顺序与退出条件见 [阶段计划](phase-plan.md)。
+
+## 1. 目标与已确认约束
+
+1. 项目继续只有一张 Graph，Sample 自动启动该图；章节按钮传初始存档变量，由图入口条件分支选路。不新增多图管理、选图或按图隔离变量。
+2. 运行时 Graph 与编译后 Group 和普通资源一样放入 PAK，使用稳定资源 ID 寻址。作者源文件与运行产物继续分离。
+3. 构建先处理唯一 Graph 的全部非补丁 Group 及本体公共内容，再按名称处理剧情补丁。基础内容内部去重；每个剧情补丁只扣除本体资源，不扣除其他剧情补丁的资源。
+4. 剧情补丁通过 Group 的字符串包名标记，空字符串表示本体；同名聚合。正常导出时一并生成，无独立剧情补丁面板。
+5. 资源补丁独立制作、独立导出。编辑器使用资源矩阵：行是剧情使用的原资源，列是资源补丁，单元格是替换资源；不按剧情是否属于补丁筛掉行。
+6. 资源补丁以寻址映射覆盖原资源；原资源与替换资源在作者项目内各自保持独立 ID。运行时统一按包内优先级排序，同优先级按 PAK 内容 SHA-256 的字典序排序，不引入语言条件或冲突选择流程。
+7. 资源依赖由 metadata 类型实现接口暴露。依赖分析、包归属、物理切包和运行时覆盖分别负责，不互相代替。
+
+非目标：多 Graph 管理、选图、跨图存档、按图隔离变量和跨图跳转/调用；任意 Graph 节点拼接协议；运行中热装卸补丁；通用远程下载系统；二进制差分；自动共享包优化；资源补丁的语言匹配、冲突选择 UI；Gallery 的补丁聚合、覆盖与扩展；在本次设计阶段修改业务代码。
+
+## 2. 当前事实与目标差异
+
+- `Core.Assets.AssetMeta` 描述资源 ID、路径、type ID、压缩等；`ResourceTypeRegistration` 按 type ID 注册 metadata DTO、JSON resolver 和创建工厂。
+- 多个资源类型当前共用 `AssetMeta`。依赖接口落到 metadata 后，有结构化依赖的类型需要自己的 DTO，不能因为当前共用 CLR 类型就把它们视为同一种资源语义。
+- `IGameFile` 已提供 metadata 和字节读取；PAK 已保存类型化 metadata JSON，依赖信息可沿现有通路进入归档。
+- 图集当前由 `LocalAssetCompiler` 根据作者描述和 sprite 索引生成运行定义；sprite ID 在编译后 payload 中，现有 metadata 不提供该依赖列表。
+- Graph/Group 当前属于特殊内容，由固定的 `Graph/graph.json` 和 Group 路径加载。`GameContent` 仅暴露一个 Graph；`GameRun` 接收 Graph 实例，不是全局静态 Graph 单例。
+- `GraphLoader` 当前不恢复持久 Graph ID，而使用模型生成的 ID；Graph 资源化必须使用稳定资源身份，不能每次加载随机生成寻址 ID。这不要求新增图选择能力。
+- `GamePackageExporter` 当前生成一个 `000-base.pak`，Graph、I18n、settings、Gallery 另行发布。
+- 现有资源 provider 支持按顺序查找同 ID，但这不等于已经实现本设计的独立映射包和包完整性。
+- 当前存档包含 NodeId/EntryIndex，未记录 Graph ID；项目保持单图，本期不为跨图恢复新增该字段。
+
+以上是现状；下文均为目标设计，不写入 `docs/spec` 作为已实现事实。
+
+## 3. 资源身份与运行内容
+
+### 3.1 Graph / Group
+
+新增运行时资源类型 `graph` 和 `group`，具有各自稳定的资源 ID。作者目录布局可以继续使用 Graph 目录，不要求用户先移动现有工程文件；构建适配层统一产出 `IGameFile`。新建资源的 sidecar/作者身份布局需要由实现阶段统一确定，不能让路径成为发行身份。
+
+P2 已确定：单图使用保留 ID `galnet:graph:main`，Group ID 为 `galnet:group:<稳定节点ID>`；生成 metadata，不额外写作者 sidecar。开发编译目录经 CompiledStoryAssetProvider 适配，发行内容直接读 PAK，共用 CompiledStoryResources 的剧情 payload 生成。每个游戏内容作用域独立，因此不引入用于跨游戏合并的全局 Graph 身份。
+
+Graph 资源保存稳定 Graph 身份、节点、边、变量声明，以及节点引用的 Group 资源 ID 和所属剧情包。Node ID 与 Group 资源 ID 分开：前者标识图中位置，后者标识被加载的正文。
+
+Group 运行资源只保存编译后的 primitive 内容。作者 raw 不进入运行 PAK。同一 Group 的所属剧情包只有一个作者真源，唯一 Graph 编译时复制其标记作为节点描述；不在两处提供独立可编辑的包名。
+
+项目保持唯一 Graph，不维护 Graph 列表、`defaultGraphId` 或显式选图 API。游戏清单保存该 Graph 的资源 ID，Sample 和宿主按它启动；这是加载信息，不是需要用户选择的默认值。Graph 缺失或清单非法则报错，不扫描另选一张图。
+
+Graph 的稳定 ID 仅用于底层寻址。章节按钮不引用 Graph ID，共用带参数的新游戏命令，传不同章节变量值，唯一 Graph 的入口条件分支负责选路；不新增章节 Graph 描述对象或第二套章节别名目录。
+
+共享宿主提供新游戏初始存档变量入口（具体类型命名在实现时确定）：在新 Run 初始化唯一 Graph 的默认值后、执行入口前，校验并应用一批显式 save 变量。标题按钮可共用一个启动命令、传不同章节参数；不通过修改旧 Run 的存档变量来传递新游戏参数。玩家解锁/通关状态仍为 player 变量；没有活动 Run 时可由玩家服务写入，不能与新游戏的 save 初始化混为一谈。读档使用存档本身的变量和游标，不再次应用新游戏参数。多次 Run 的 save 值独立，不增加按图存储层。同一 Run 内图中章节直接衔接可保留变量，从标题页新开章节默认重建 save 值；不同 Run 之间状态传递由项目显式定义。
+
+首页替换复用现有 DI 与 View 映射：只换外观则替换 TitlePageViewModel 对应 View；换行为则用派生 VM 替换标题服务注册并映射实际 VM 类型。此能力已存在，本 feature 仅补齐新启动参数及示例，不新增 UI 编辑器。
+
+### 3.2 最小启动目录
+
+保留一个可在打开剧情资源前读取的轻量游戏目录/manifest，提供项目身份、唯一 Graph 的资源 ID、基础 PAK 清单、格式/构建版本及必要宿主配置入口，不包含 Graph 列表或默认/显式选图配置。无需把宿主设置全部强行改成普通资源。
+
+Graph 与 Group 不再靠 loose `Graph/**` 路径参与发行加载。开发项目与安装内容分别适配成同一种资源访问视图。
+
+### 3.3 共用 PAK 格式，区分包用途
+
+三种包共用同一 PAK 二进制格式、资源表、metadata、压缩与数据校验；包头的版本化控制描述使用 `kind` 区分用途：
+
+| kind | 内容与额外描述 | 装载规则 |
+| --- | --- | --- |
+| `base` | 本体资源，基础构建身份与分片标识 | 按游戏清单加载，缺少受管分片是错误 |
+| `story` | 命名剧情正文及依赖，剧情包名、目标基础构建、分片清单 | 整组完整才视为已安装；整组未安装时按 Graph 描述跳过 |
+| `override` | 原资源到替换资源的映射、替换载荷与依赖、优先级 | 校验后按 `(priority, pakSha256)` 应用映射 |
+
+`kind` 是包用途，`typeId` 是每项资源类型，二者独立；一个 `story` 包可以包含 group、sprite、audio。控制描述不作为普通可覆盖资源，不能通过资源映射修改包用途、优先级或基础构建身份。未知 kind/不支持的格式版本明确拒绝，不根据文件名猜包用途，也不以旧 provider 扫描顺序替代用途校验。剧情包的完整性校验与 override 的覆盖排序分别处理。
+
+## 4. Metadata 依赖协议
+
+### 4.1 接口归属
+
+允许 metadata DTO 实现依赖接口，不要求 metadata 读取文件系统、查目录或自行递归加载其他资源。以下为形状示意，最终命名可在实现时调整：
+
+```csharp
+public interface IAssetDependencies
+{
+    AssetDependencyInfo GetDependencies();
+}
+
+public sealed record AssetDependencyInfo(
+    IReadOnlyList<AssetDependency> Direct,
+    bool Complete);
+
+public sealed record AssetDependency(
+    string AssetId,
+    string? ExpectedTypeId = null,
+    string? RequiredStoryPackage = null);
+```
+
+- `Direct` 只含直接依赖，不能包含递归闭包；可带预期类型，便于在解码前诊断。
+- `Complete=false` 表示资源存在无法完整分析的引用，不等于没有依赖；诊断另带资源/参数来源位置。
+- 普通叶资源无需实现该接口。但必须在类型注册中明确声明为无依赖；未实现接口且未声明无依赖的扩展类型按未知处理，不静默判空。
+- `RequiredStoryPackage` 仅用于 Graph 对可选剧情 Group 的引用。普通图片、图集、音频依赖均为必需依赖，不提供任意的“缺失忽略”。
+- 接口依赖 Core 中立数据，不引入 Editor、文件系统、运行时 decoder 或呈现框架。
+- 类型注册、metadata JSON resolver 和接口实例必须使用同一冻结目录；不依赖反射扫描发现接口实现，不绕过 NativeAOT 源生成约束。
+
+### 4.2 依赖事实如何生成
+
+作者 `.meta` 与构建/本地预览得到的有效 metadata 快照需要区分：
+
+- 若引用本来就在 metadata 中，接口直接返回这些引用。
+- 若引用来自正文，资源编译器在生成运行 payload 的同一过程中生成依赖，填入新的有效 metadata 快照。该快照进入 PAK；正常扫描/构建不自动回写作者 sidecar。
+- 图集由运行定义列出的全部 sprite ID 生成依赖；Group 从 composite 展开后的指令与参数 schema 生成依赖；Graph 从编译后的节点引用生成依赖。
+- 不独立扫描第二遍文件夹来猜测最终运行内容。payload 和依赖 metadata 同属一次不可变编译结果。
+- 从已有 PAK 导入/验证时，已知结构化类型应能对照 payload 校验依赖，拒绝遗漏、过时或身份不一致；不把人为删除 metadata 依赖当作合法瘦包技巧。
+- shader 正文自身若没有外部资源引用，不凭文本猜测依赖；指令/配置的纹理参数由拥有这些引用的 Group 或配置资源报告。
+
+### 4.3 动态引用与递归边界
+
+资源引用由 schema/类型契约声明，不猜 GUID 字符串、不从路径文本推断。动态拼接 ID 的自定义指令必须提供声明依赖或通过额外包含补足覆盖范围。构建报告保留不完整诊断；发行导出不能无提示忽略该问题。首版默认阻止未处置的不完整依赖，显式额外包含/声明覆盖范围后才允许发布。
+
+闭包算法按规范化资源 ID 去重，维护 visited 防循环。Graph 的执行回环不等于资源依赖循环；通用收集器不强制整个项目必须为 DAG。具体类型如有禁止循环的解码约束，由对应类型校验。
+
+依赖表示“发布内容应能提供”，不表示同 PAK、不要求同时加载，也不自动 acquire 所有依赖。图集加载定义不应因此一次解码整套图片。
+
+## 5. 本体与剧情补丁的构建
+
+### 5.1 根集合
+
+本体根包括唯一 Graph 资源、其全部非补丁 Group，以及显式 UI/启动资源、基础 Gallery 引用和额外包含资源。所有非补丁 Group 均纳入，不用运行可达性裁剪掉作者仍保留的剧情。
+
+剧情补丁根为同一包名的全部 Group，以及该包所需文本、人物和显式额外资源。引用分类必须覆盖这些非媒体内容，不能只拆 Group 和图片而丢失补丁文本。Gallery 保持既有基础导出路径，本期不设计按补丁拆分或新增贡献。
+
+Graph 到补丁 Group 的边在本体遍历时只保留描述，不跨入其正文闭包；构建该剧情包时才以该 Group 为根收集正文及必需资源。禁止普通必需引用绕过这条边界依赖缺席的补丁 Group。
+
+### 5.2 确定性算法
+
+令 `B` 为本体闭包，`C(P)` 为剧情包 P 的闭包：
+
+```text
+本体有效资源 = B
+剧情包 P 的资源 = C(P) - B
+```
+
+其他剧情包的资源不参与扣除。A/B 都使用 X、本体无 X 时，两包各自携带 X；本体有 X 时，两包均省略 X。基础资源只去重一次；每个剧情包内部各自去重。
+
+同 ID 的重复副本必须具有相同的有效内容和 metadata；若两包携带同 ID 的不同内容，则是冲突，不能借 provider 文件名排序实现隐式资源补丁。显式资源覆盖由另一机制负责。
+
+每个集合按稳定 ID 排序，再按配置的未压缩编译载荷大小目标切 PAK；目标是软上限，单资源超限独占一包。未压缩口径使边界可预测，输出报告另列实际压缩大小和索引开销。当前 Archive 整包内存读取语义意味着默认阈值必须结合实际内存验收，本文不预设未经测试的数值。
+
+资源身份按 ID 去重，不将字节相同的不同 ID 合并身份。每次构建输出 ID、内容/metadata 指纹、归属、依赖和物理 PAK 的布局报告，为后续发布增量提供基线。
+
+### 5.3 导出结果
+
+正常游戏导出一次完成基础与全部剧情包生成，不新增剧情补丁面板：
+
+```text
+Output/
+  Game.galpak
+  StoryPatches/
+    afterstory-000.pak
+    afterstory-001.pak
+    extra-ending-000.pak
+```
+
+基础 `.galpak` 不要求安装这些外部剧情包。包名是稳定机器键，空串表示本体；拒绝路径穿越、仅大小写冲突等不确定名称。编辑器可以提供已有名称候选，重命名须作为引用重构而非仅修改输出文件名。
+
+目录导出与 galpak 导出共用相同的准备、归属和验证流程。先私有暂存、验证完整产物再发布；失败不能留下被识别为已安装的半包。
+
+## 6. 剧情包装载与跳过
+
+基础 Graph 保留节点和边，以及 `groupResourceId` / `storyPackage`。不为缺席正文生成同 ID 的空 Group 资源。
+
+- `storyPackage` 为空：正文必需，缺失是内容错误。
+- 非空且对应包没有安装：不读取正文，沿该 Group 的唯一正常出口继续。
+- 包已安装且完整：加载正文并执行。
+- 检测到该包部分文件、错误版本、哈希不匹配或缺失必需资源：明确报告不完整，不能降级成“未安装”。
+
+允许连续跳过多个可选 Group；若跳过路径形成无执行推进的循环，须有校验/运行保护。若没有后继则按正常剧情结束处理。将来出现多出口可选节点时必须另设明确 fallback，首版不推测出口。
+
+跨过补丁后主线所需变量必须有基础默认值；不能让基础必需人物、文本或资源依赖补丁才能成立。
+
+每个剧情包记录 project ID、包 ID、格式版本、目标基础构建、分片列表和校验信息。描述可以嵌入 PAK 控制区；具体二进制布局在实现时版本化，不能伪装成可被剧情覆盖的普通资源。首版匹配明确基础构建，后续兼容范围必须有验证依据。不以文件名排序判断有效版本。
+
+## 7. 独立资源补丁
+
+### 7.1 作者面板
+
+矩阵行来自唯一 Graph 及其全部 Group 的静态资源引用，包括剧情补丁内容；不因包是否安装隐藏作者资源。默认聚合相同原资源，保留使用位置，支持跳转到编辑器文件管理器。可展开间接依赖或手动添加动态引用资源。
+
+新建资源补丁增加一列；格子为替换资源 ID 或空值。空值表示该列不贡献覆盖，不表示删除原资源。图集可整体替换，也可展开后替换单张 sprite。首版限制媒体/普通业务资源覆盖；不借此面板替换 Graph/Group、游戏包清单或宿主配置，剧情结构更新另立范围。
+
+每列具有稳定 patch ID、显示名称和写入包内的整数优先级（默认 0）。资源补丁独立保存、验证和导出，不依赖执行一次完整 galpak 导出。不提供语言条件、手动冲突选择或 Gallery 贡献编辑；不混入剧情分包标记。首版每列导出一个资源补丁 PAK，剧情包的大小分片规则不自动套用到资源补丁。
+
+### 7.2 映射与自包含
+
+作者 A/B 各自保持独立 ID，补丁保存 `A -> B` 并携带 B 的依赖闭包。独立导出默认携带全部替换载荷和依赖，不因当前作者项目存在某资源而省略它；只有选定真实已发布基线后，才允许显式优化扣除，并记录基线要求。
+
+运行目标须精确标识来源包及目标 ID；补丁携带的 B 和依赖不是自动全局覆盖所有同 ID 资源。仅声明的 A 映射改变全局寻址，避免夹带依赖隐式覆盖其他素材。物理查找需要包来源上下文，同 ID 在基础/补丁中的不同字节不可由模糊 provider 顺序决定。
+
+每次逻辑引用只做一次映射：选择 A 的目标 B 后读取该物理资源，不继续把 B 当新映射源串成 C。B 内容中对 sprite 等的独立引用是新的寻址请求；必须使用一致的来源和覆盖规则。自映射/循环映射应诊断，不依赖无限重定向。
+
+### 7.3 固定覆盖顺序
+
+对所有启用的资源补丁，按 `(priority, pakSha256)` 升序排列，后者覆盖前者，即优先级数值较大者优先，同优先级时 hash 字典序较大者优先。hash 是最终 PAK 文件字节的 SHA-256，统一为小写十六进制并使用 ordinal 比较；在写完包后从外部计算，不把自身 hash 写回包内形成自引用。相同 hash 的重复包只装载一次；路径、文件名和目录枚举顺序不参与比较。
+
+同一原资源出现多个映射是正常覆盖，直接按上述规则选取最终映射，不阻止装载，也不要求用户解决冲突。可在诊断中显示最终来源，无需新增冲突 UI。资源类型与图集变体键兼容性属于内容有效性检查，仍需保留。独立包可在无完整目标游戏时导出结构合法载荷，挂载时必须补做目标存在性和兼容检查。所谓资源 i18n 仅是作者用此面板制作替换素材的用途，运行时不根据语言自动选包；启用的包始终按同一规则生效。
+
+资源补丁可以覆盖仅属于剧情补丁的资源：剧情包缺席时映射不使其自动变成已安装剧情；剧情包存在时才有相关使用请求。
+
+### 7.4 查询、缓存与生命周期
+
+正式 ID 查询、Acquire、原始文件查询和媒体实体化必须使用同一覆盖视图，避免画面替换而视频仍读旧资源。编辑器源文件定位继续使用作者目录视图，不因为运行覆盖而丢失 A 的位置。Gallery 的新覆盖语义另行设计，本期不扩展其行为。
+
+一次内容会话冻结包集合与映射代次，缓存以实际资源来源/版本及目标 CLR 类型隔离。语言不是资源补丁解析或缓存的维度。首版启停资源补丁在重启或重新准备相关会话时生效，不原地修改已借用 handle；租约和媒体文件仍按原有所有权释放。
+
+## 8. 文本、人物与 Gallery 范围
+
+- 文本仍按 culture + key 解析，不把每行译文变成独立资源。基础与剧情包保存各自文本贡献，挂载后验证有效内容的默认语言完整性。没有安装的剧情包不要求其文本出现在本体。
+- 人物按稳定 ID 合并。基础引用项不能仅存在于可选包。两个剧情包重复携带同一基础外定义时必须一致，不能成为彼此的隐式依赖。
+- Gallery 由用户明确延期。本期不新增补丁条目合并、覆盖、删除、解锁迁移或 type 扩展协议；不在资源补丁面板聚合替换资源的 Gallery 标注。既有 Gallery 基础导出路径与其独有资源保留，不将本期实施扩大为 Gallery 重构。
+- 原有 External 翻译来源的保留与优先级不能在迁移中丢失；包内 key 合并不等于整份文本文件覆盖。
+
+## 9. 存档、版本与发布边界
+
+存档继续在项目唯一 Graph 中恢复 NodeId、EntryIndex、save 变量及呈现状态；仅补充分包恢复所需的内容包/兼容信息，不增加跨图 Graph ID 或选图流程。恢复前验证正文、资源和内容版本；新游戏章节参数不参与读档，不把旧存档重定向到另一个章节入口。
+
+本设计不解决已有 Group 中插入/重排 entry 后的 EntryIndex 迁移；稳定资源 ID 不能保证旧执行位置仍有相同语义。首版应明确拒绝不兼容构建或另行提供可验证迁移，不能跳过当前存档所需的补丁并假装正常恢复。已存在的画面状态可能引用补丁资源，也属于恢复依赖。
+
+PAK 控制描述、Galpak 游戏目录、Graph/Group 和存档的格式变化均需显式版本化。当前安装器按旧 manifest 验证安装内容，需区分基础受管文件与额外包位置，不能把任意投放 PAK 直接视为完整升级协议。是否支持旧项目/发行包自动转换，尚未获得用户要求；实现前明确格式策略，不承诺静默兼容。
+
+基础与所有剧情包在同一构建快照生成。后续基于已发布清单的修复更新应新增变更包或整体替换一组已验证文件，不重排旧 PAK 造成无关更新；该自动增量流程不属于首版必做范围。
+
+## 10. 模块职责与取舍
+
+| 层 | 责任 |
+| --- | --- |
+| Core | metadata 依赖接口、资源身份、Graph/Group 引用与中立包描述契约 |
+| Contracts.Builtins | 内置 metadata DTO、JSON resolver、无依赖类型声明、已知参数引用契约 |
+| 内容编译/Assets | 编译 payload 与有效 metadata、闭包计算、PAK 读写、来源明确的覆盖解析 |
+| Editor.Shared | 本体/剧情包规划、基线、布局报告、导出准备与验证；不能仅靠 GUI 操作才能使用 |
+| Storage | 目录/galpak 安装、包发现与校验、开发源适配；文件系统不进入 Core |
+| GameHost | 加载唯一 Graph、冻结有效内容会话、应用新游戏初始变量、准备运行、存档兼容检查 |
+| Editor GUI | Group 包名编辑、资源补丁矩阵、文件定位、导出入口与诊断 |
+
+采用 metadata 接口的理由：延续现有 sidecar 与 PAK metadata 通道，依赖可枚举、可序列化且可校验。没有选择让 metadata 自行读文件的分析器模式，因为这会把文件系统/编译职责带入 DTO；正文产生的依赖由已有编译过程填充解决。
+
+没有采用遍历时先遇到先归属，因为会使基础内容依赖可选包；没有自动创建共享包，因为用户明确要求 A/B 独立携带基础外共享资源；没有合并剧情与资源补丁，因为两者导出时机、缺席语义和作者操作不同。
+
+## 11. 验收重点
+
+1. 唯一 Graph 能按清单资源 ID 从 PAK 启动；Sample 无需选图配置，章节初始变量在入口执行前生效，读档保持原位置与变量。
+2. 图集全部直接 sprite 进入闭包；叶资源、未知依赖、动态额外包含可区分；构建不回写源 `.meta`。
+3. 本体与补丁共同使用 X 时只在本体；A/B 共同使用 X 且本体不用时各一份；目录扫描顺序改变不改变归属。
+4. 唯一 Graph 的所有非补丁 Group 都进入基础构建；UI、Gallery 独有和额外包含资源不丢失。
+5. 剧情包未安装可连续跳过并结束；安装完整则执行；分片丢失、错版、坏 Group/依赖不能被静默跳过。
+6. 资源补丁独立导出 A→B，带齐 B 的图集依赖；关闭补丁恢复 A；B 的夹带依赖不隐式覆盖无映射资源。
+7. 优先级较大者覆盖；同优先级按 SHA-256 ordinal 较大者覆盖；相同文件去重。更改文件名/扫描顺序不改变结果；多包重复映射无需人工解决冲突；语言不影响资源补丁解析。一次映射、原始字节/解码/媒体的有效来源一致，旧 handle 不被原地变更。
+8. 缺少剧情包的存档明确拒绝恢复；新游戏的初始参数不覆盖存档变量；不同 Run 的 save 值不串用，不兼容 EntryIndex 不伪装兼容。
+9. 目录导出、galpak 导出和开发预览共用有效编译事实；无 GUI 的导出入口可运行同样规划与校验。
+10. 失败输出不替换有效旧产物；反射关闭路径能反序列化新增 metadata；大包内存和取消路径实际验收。
+
+## 12. 参考
+
+- [Ren'Py 构建与归档](https://www.renpy.org/doc/html/build.html)：作者规则归类和归档生成。
+- [Unity Addressables Groups](https://docs.unity.cn/Packages/com.unity.addressables%402.10/manual/groups-intro.html)：逻辑分组与物理归档策略分离。
+- [Godot packs / patches](https://docs.godotengine.org/en/stable/tutorials/export/exporting_pcks.html)：额外内容包和基于发布基线的更新。
+- 当前规范：`docs/spec/assets.md`、`docs/spec/file-formats.md`、`docs/spec/i18n.md`。它们描述现状，不因本草案自动改变。
diff --git a/features/F-20261028-01-content-packaging/feature.md b/features/F-20261028-01-content-packaging/feature.md
new file mode 100644
index 00000000..761b90bc
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/feature.md
@@ -0,0 +1,93 @@
+# F-20261028-01 — 单 Graph 资源化与游戏内容分包
+
+状态：`completed`，2026-10-28。P1–P6 全部 verified，按用户要求每阶段独立 Git 提交。实现结果、验证与限制见 [summary](summary.md)，收尾核对见 [review](review.md)。
+
+## 用户目标
+
+项目继续只有一张 Graph，将 Graph、Group 纳入 PAK 资源寻址；按依赖自动生成本体和可选剧情包；允许作者通过资源矩阵独立制作和导出覆盖包。保留默认 Sample 的简单启动，通过初始存档变量和单图入口分支实现章节选择，首页沿用现有定制接口。
+
+## 当前问题
+
+- 内容加载固定一张 loose Graph，Graph/Group 尚未与资源 ID、PAK 管线统一。
+- 导出仅生成一个基础资源 PAK，没有基于 metadata 依赖的分包规划与剧情包完整性语义。
+- 资源 provider 的顺序查找不足以表达独立的 A→B 覆盖映射和确定排序。
+- 新游戏启动没有显式初始存档变量参数，标题按钮设置当前状态后再开始可能被新 Run 初始化覆盖。
+
+## 范围
+
+### 1. 资源依赖与 PAK 类型
+
+- 有依赖的 metadata DTO 实现接口，返回直接依赖、预期类型和分析完整性；叶资源与未知依赖明确区分。
+- 图集、Group、Graph 编译时同步生成有效依赖 metadata，不自动回写作者 sidecar。
+- PAK 共用格式，以包头 `kind=base/story/override` 区分用途；资源 `typeId` 独立存在。
+- 递归收集、缺失/错类型检查、动态额外包含、稳定切包与布局报告共用一套服务。
+
+### 2. 单 Graph 资源化与章节启动
+
+- 项目只有一张 Graph；运行 Graph/编译 Group 作为 PAK 资源按稳定 ID 获取。
+- 游戏清单记录唯一 Graph 的资源 ID，Sample 自动读取，不引入 `defaultGraphId`、Graph 列表或选择 API，也不要求首页按钮填写 Graph ID。
+- 存档继续恢复节点、游标、存档变量和呈现状态，仅增加分包兼容所需校验，不为本 feature 引入跨图存档身份。
+- 存档变量属于本次 Run，继续使用唯一 Graph 的声明和默认值；不同 Run 的值互相独立，玩家变量仍在 profile 内共享，不增加按 Graph 隔离的变量层。
+- 新游戏可传初始存档变量，初始化默认值后、入口执行前一次校验并应用；读档只用存档，不重新套用新游戏参数。
+- 章节按钮共用启动命令、传不同章节初始变量，由唯一 Graph 的入口条件分支选路；不新增章节 Graph 或第二套章节目录。图内自然衔接保留当前 Run 变量，从标题页新开章节则创建新 Run，不自动继承上一 Run 的 save 值。
+
+### 3. 本体与剧情补丁
+
+- Group 有剧情包名称字符串：空表示本体，同名聚合。
+- 先处理唯一 Graph 的全部非补丁 Group 及基础资源，再独立处理各剧情包。
+- 剧情包只扣除本体已有资源，不扣除其他剧情包资源；本体没有、A/B 共用的资源两包各带一份。
+- 每个集合内部去重，再按大小目标切 PAK；正常导出一并生成基础 galpak 与外部剧情 PAK，不新增剧情补丁面板。
+- 基础 Graph 保留补丁节点及所属包描述；包完全未安装时跳过正文并沿正常出口继续，部分安装/损坏/错版明确报错。
+- 文本、人物及动态引用额外包含不能在拆包时丢失。
+
+### 4. 独立资源补丁与作者矩阵
+
+- 行是唯一 Graph 及其全部 Group 引用的原资源，包含剧情补丁；支持使用位置、依赖展开和编辑器文件管理器定位。
+- 每个资源补丁一列，每个格子选择替换资源；空值不贡献覆盖。每列可独立导出一个 override PAK。
+- 原资源和替换资源各有独立作者 ID；覆盖包保存 A→B，携带 B 的依赖闭包，来源明确，不让夹带资源隐式全局覆盖。
+- 优先级数值较大者优先，相同则最终 PAK SHA-256 ordinal 较大者优先；相同文件去重。无需语言匹配或人工冲突处理。
+- 原始文件、解码、媒体实体化使用一致覆盖视图；重启/重建相关会话采用补丁变化，不原地修改现有资源 handle。
+- 项目定义支持保存、重开、撤销/重做和作者快照导出。
+
+### 5. 默认应用模板边界
+
+- 延续现有 TitlePageViewModel 派生、DI 别名替换、VM→View 映射和项目服务注册，不新增通用 UI 编辑器。
+- 补齐新游戏初始变量入口并提供章节按钮示例；新能力落在共享宿主接口，Sample 做项目组合。
+- 现有标题外观/行为替换已经有代码与集成测试，不将既有能力列为本 feature 的待实现成果；仅做必要回归与文档衔接。
+
+## 非目标
+
+- 多 Graph 管理、Graph 选择、跨图存档识别、按图隔离变量、跨图跳转/调用栈。
+- 任意剧情图拼接、二进制差分、下载器、自动共享包优化。
+- 资源补丁的语言条件、冲突选择 UI、运行中热装卸。
+- Gallery 补丁聚合、覆盖、删除、解锁迁移或 type 扩展；保留既有基础功能。
+- 通用可视化 UI 制作器或通过 galpak 自动创建任意业务页面。
+- 未经要求的旧项目自动转换或旧存档语义迁移。
+
+## 验收标准
+
+1. 唯一 Graph 可从开发/导出/安装内容按资源 ID 启动，Sample 自动使用清单入口；无需新增 Graph 选择配置或跨图存档字段。
+2. 图集与编译剧情依赖完整进入闭包；构建不修改作者 `.meta`，缺失与未知依赖有明确诊断。
+3. 本体先行、补丁独立去重和物理切包符合上述公式；包扫描顺序不影响归属。
+4. 未安装剧情可跳过，坏包不能被静默跳过；正文、文本、存档和资源闭包一致。
+5. A→B 可独立导出运行，按 priority/hash 确定结果，依赖不泄漏覆盖，raw/decoder/media 来源一致。
+6. 编辑器可完成包名编辑、正常导出、创建补丁列、选择资源、定位原文件及独立导出，定义保存重开不丢失。
+7. 单图章节按钮传入初始变量可在首次入口判断前生效；新 Run 不继承旧 Run 存档变量，读档不被新游戏参数覆盖。
+8. 正式文档只记录已验证实现；每阶段退出条件和检查证据如实记录。
+
+## 约束、假设与开放事项
+
+当前没有等待用户决策的产品阻塞。具体二进制字段、作者身份文件布局及切包默认阈值由实现阶段结合现有结构和验证确定；格式/API 需显式版本化，不隐式接受不支持的旧内容。遇到与已确认行为冲突时记录原因，不能擅自增加共享包依赖、语言匹配或冲突门禁。
+
+范围修正：用户明确项目保留唯一 Graph。先前记录的多 Graph 管理、默认/显式选图、跨图存档和按图变量隔离均已移出本 feature；章节选择采用单图入口分支与初始变量。Graph 资源化保留，它与支持多图不是同一项能力。
+
+## 设计与计划
+
+- [设计](design.md)
+- [阶段计划](phase-plan.md)
+- 当前事实：`docs/spec/assets.md`、`docs/spec/file-formats.md`、`docs/spec/i18n.md`。
+- 现有应用扩展：`docs/manual/customize-avalonia-sample.md`。
+
+## 后续界面调整
+
+用户要求提高默认分包阈值、资源补丁面板采用图标及紧凑布局，配置改动即时持久化，导出只导出；本轮独立验证和提交，见 [调整记录](follow-up-panel-20261028.md)。
diff --git a/features/F-20261028-01-content-packaging/follow-up-panel-20261028.md b/features/F-20261028-01-content-packaging/follow-up-panel-20261028.md
new file mode 100644
index 00000000..9fbb3ae0
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/follow-up-panel-20261028.md
@@ -0,0 +1,46 @@
+# 后续调整：资源补丁面板与分包阈值
+
+状态：`verified`，2026-10-29。用户要求提高默认包大小，简化资源补丁面板，使编辑自动持久化、导出只导出，并参考既有页面的图标按钮与对齐风格。本轮作为一个独立可验证阶段提交。
+
+## 实现范围
+
+- 默认未压缩软阈值由 32 MiB 提高到 128 MiB；超限单项仍完整独占，不拆文件。Archive 仍是整片缓冲，约 2 GiB 数组容量和实际内存约束不因阈值改变而解除。
+- 面板复用 AuthoringPanelResources / EditorIconButton，资源搜索工具栏、补充原资源图标弹层及两行列头，导出/删除/定位使用图标并提供 tooltip 和可访问名称；取消仅导出期间出现。间接资源复选框垂直居中。
+- 名称完成编辑、数字优先级、列和映射操作经原有历史与 PublishStructureAsync 发布，只变更 resourceOverrides 节；撤销/重做同步落盘，其他工作版内容仍未发布。不新增全局自动保存行为。
+- 移除面板的草稿注册、放弃草稿和保存并导出语义。非法名称显示错误并回到有效值，不阻塞其他页面保存。导出只捕获已保存定义和独立资源快照，不调用项目 SaveAsync。
+
+## 验证计划
+
+实际挂载验证图标按钮、名称失焦/数字编辑、矩阵操作、多列布局、复选框居中、撤销/重做、即时落盘和重开。另验证未保存剧情及无关未完成输入不被补丁编辑/导出提交；导出内容与已存映射一致。检查四语键、默认大小和超限完整保留；渲染截图需实际查看。
+
+## 已执行验证
+
+| 检查 | 结果 |
+| --- | --- |
+| Release locked restore + 完整解决方案构建 | 通过，316 warning / 0 error |
+| 实际挂载面板 + 四语键 | 4/4 通过：搜索、图标、名称失焦、整数优先级、复选框中心对齐、多列滚动、选择/定位、自动保存/重开与导出 |
+| Editor.Shared 全套 | 476/476 通过 |
+| 分包规划 | 5/5 通过，含软阈值及超限项完整独占 |
+| 打包安装/独立导出集成 | 7/7 通过 |
+| 相关用例合计 | 492 项通过 |
+| 128 MiB 默认实际导出/安装 | 通过；1 个本体分片、2 个剧情分片，未使用项排除、A/B 公共额外资源各带一份 |
+
+默认值观测见 [result-128MiB.json](memory-probe/result-128MiB.json)：样本输入 152 MiB，最大物理 PAK 83,888,597 bytes；峰值 working set 1,180,585,984 bytes，耗时 3,515 ms。较大分片会增加缓冲开销，不能将软阈值当作内存预算；历史 32/64 MiB 观测保留，不用新结果覆盖旧证据。
+
+已实际查看 [新版截图](verification/ui/resource-patches-refined.png)。截图为挂载控件测试环境，确认布局、图标和对齐；不冒充完整原生主题的人工验收。正常导出、包用途和资源解析协议没有改变。
+
+## 验证中发现的修正
+
+新增的“局部保存后其他内容仍 dirty”检查发现 `ProjectContentBaseline.Node` 漏比较 StoryPackage。加入该字段，确保单独修改 Group 包名会被判断为未保存；资源补丁保存/撤销/导出均不抹掉未发布剧情。相关用例已通过，经验另存于 agent lesson。
+
+本轮没有重跑其余无关默认套件，原始 P6 的 2,064 项记录仍只对应 P6；本轮交付证据以上表为准。变更 C# 的 whitespace / IDE0005 验证及 git diff --check 通过。无阻止本轮交付的已知问题。
+
+## 延期事项：流式 PAK 与大文件支持
+
+2026-10-29 用户明确要求先记录、以后再做；当前不实施，也不作为本轮未完成项。
+
+- 当前整个 PAK 与单资源解压结果使用 byte[]，资源长度还受 int.MaxValue 校验，单 PAK/单资源无法支持超过约 2 GiB；游戏总容量可通过多个 PAK 超过该值。
+- 压缩、复制、解压存在临时缓冲，小于该容量也可能因可用内存不足而失败；128 MiB 仅是分包软目标。
+- 后续考虑流式写包、只加载索引并按资源范围读取，以及媒体通过流或临时文件交给后端，避免整包/大媒体同时驻留内存。
+- 需一并评估资源读取 API、64 位偏移/长度、压缩及哈希校验、取消与文件租约生命周期；保持现有分包归属和覆盖优先级语义。
+- 届时用超过 2 GiB 的单文件/单 PAK、随机读取、损坏输入及峰值内存验证，不仅验证多个小包的总容量。
diff --git a/features/F-20261028-01-content-packaging/memory-probe/MemoryProbe.csproj b/features/F-20261028-01-content-packaging/memory-probe/MemoryProbe.csproj
new file mode 100644
index 00000000..fb904251
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/memory-probe/MemoryProbe.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../../src/Editor/GalNet.Editor.Shared/GalNet.Editor.Shared.csproj" />
+    <ProjectReference Include="../../../src/Infrastructure/GalNet.Storage.FileSystem/GalNet.Storage.FileSystem.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/features/F-20261028-01-content-packaging/memory-probe/Program.cs b/features/F-20261028-01-content-packaging/memory-probe/Program.cs
new file mode 100644
index 00000000..bc0bc49a
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/memory-probe/Program.cs
@@ -0,0 +1,73 @@
+using System.Diagnostics;
+using System.Security.Cryptography;
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Core.Entry;
+using GalNet.Core.Configuration;
+using GalNet.Editor.Shared.Services;
+using GalNet.Storage.FileSystem;
+
+var root = Path.Combine(Path.GetTempPath(), "galnet-package-memory-" + Guid.NewGuid().ToString("N"));
+var source = Path.Combine(root, "source"); var output = Path.Combine(root, "export");
+Directory.CreateDirectory(Path.Combine(source, "Assets")); Directory.CreateDirectory(Path.Combine(source, "Graph", "groups"));
+try
+{
+    var configuration = new ProjectConfiguration();
+    if (args.Length > 1) configuration.Set(ContentPackagingOptions.Section, new() { MaxPakBytes = long.Parse(args[1], System.Globalization.CultureInfo.InvariantCulture) * 1024 * 1024 });
+    File.WriteAllText(Path.Combine(source, "settings.json"), JsonSerializer.Serialize(configuration));
+    // Synthetic incompressible texture payloads exercise package I/O, not image decoding/rendering.
+    var block = new byte[1024 * 1024];
+    long inputBytes = 0;
+    foreach (var (id, mib) in new[] { ("b0", 20), ("b1", 20), ("b2", 20), ("b3", 20), ("shared-x", 20), ("a-only", 20), ("unused", 32) })
+    {
+        using (var file = File.Create(Path.Combine(source, "Assets", id + ".png")))
+            for (var index = 0; index < mib; index++) { RandomNumberGenerator.Fill(block); file.Write(block); }
+        inputBytes += (long)mib * block.Length;
+        File.WriteAllText(Path.Combine(source, "Assets", id + ".png.meta"), JsonSerializer.Serialize(new { id, type = "sprite", compress = "none" }));
+    }
+    File.WriteAllText(Path.Combine(source, "Graph", "graph.json"), """
+        {"version":2,"name":"Memory probe","rootNodeId":"base","nodes":[
+         {"id":"base","name":"Base","type":"Group","file":"groups/base.rawgalgroup"},
+         {"id":"a","name":"A","type":"Group","file":"groups/a.rawgalgroup","storyPackage":"A"},
+         {"id":"b","name":"B","type":"Group","file":"groups/b.rawgalgroup","storyPackage":"B"}],
+         "edges":[{"id":"e1","fromNodeId":"base","fromOutlet":0,"toNodeId":"a"},
+         {"id":"e2","fromNodeId":"a","fromOutlet":0,"toNodeId":"b"}],"playerVariables":[],"saveVariables":[]}
+        """);
+    Group("base", ["b0", "b1", "b2", "b3"]); Group("a", ["b0", "shared-x", "a-only"]); Group("b", ["b0", "shared-x"]);
+    var types = BuiltinResourceTypes.CreateCatalog(); var gallery = BuiltinGalleryTypes.CreateCatalog(types);
+    var watch = Stopwatch.StartNew();
+    var result = await GamePackageExporter.ExportDirectoryAsync("probe", "Memory probe", source, output, types, gallery,
+        new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules()));
+    if (!result.Success) throw new InvalidDataException(result.Error);
+    _ = await new InstalledGameContentProvider(output, types, gallery).LoadAsync();
+    var paks = Directory.GetFiles(output, "*.pak", SearchOption.AllDirectories);
+    var sharedPackages = new HashSet<string>(); var unusedExcluded = true;
+    foreach (var path in paks)
+    {
+        using var archive = Archive.Deserialize("assets", File.ReadAllBytes(path), types);
+        unusedExcluded &= !archive.Contains("unused");
+        if (archive.Descriptor.Kind == "story" && archive.Contains("shared-x")) sharedPackages.Add(archive.Descriptor.PackageId);
+    }
+    if (!unusedExcluded || !sharedPackages.SetEquals(["A", "B"])) throw new InvalidDataException("Large resource package membership is incorrect.");
+    watch.Stop(); GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect();
+    using var process = Process.GetCurrentProcess(); process.Refresh();
+    var report = JsonSerializer.Serialize(new
+    {
+        inputBytes, targetPakBytes = configuration.Read(ContentPackagingOptions.Section).MaxPakBytes,
+        pakBytes = paks.Sum(path => new FileInfo(path).Length), largestPakBytes = paks.Max(path => new FileInfo(path).Length),
+        baseParts = Directory.GetFiles(Path.Combine(output, "Assets", "Paks"), "*.pak").Length,
+        storyParts = paks.Count(path => path.Contains("StoryPatches", StringComparison.Ordinal)), unusedExcluded,
+        sharedDuplicatedInBothStories = sharedPackages.Count == 2,
+        peakWorkingSetBytes = process.PeakWorkingSet64, afterGcManagedBytes = GC.GetTotalMemory(false), elapsedMilliseconds = watch.ElapsedMilliseconds
+    }, new JsonSerializerOptions { WriteIndented = true });
+    Console.WriteLine(report);
+    if (args.Length > 0) File.WriteAllText(Path.GetFullPath(args[0]), report + Environment.NewLine);
+    void Group(string id, string[] images) => File.WriteAllText(Path.Combine(source, "Graph", "groups", id + ".rawgalgroup"), JsonSerializer.Serialize(new
+    {
+        version = 2, kind = "Raw", entries = images.Select((image, index) => new { id = "e" + index, type = "layer.show", parameters = new { assetId = image } })
+    }));
+}
+finally { Directory.Delete(root, true); }
diff --git a/features/F-20261028-01-content-packaging/memory-probe/README.md b/features/F-20261028-01-content-packaging/memory-probe/README.md
new file mode 100644
index 00000000..92646144
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/memory-probe/README.md
@@ -0,0 +1,15 @@
+# 内容分包内存观测
+
+从仓库根构建并运行：
+
+```powershell
+dotnet restore features/F-20261028-01-content-packaging/memory-probe/MemoryProbe.csproj --locked-mode
+dotnet build features/F-20261028-01-content-packaging/memory-probe/MemoryProbe.csproj -c Release --no-restore
+dotnet features/F-20261028-01-content-packaging/memory-probe/bin/Release/net10.0/MemoryProbe.dll features/F-20261028-01-content-packaging/memory-probe/result-128MiB.json
+```
+
+第二个应用参数可指定 MiB 阈值，例如在结果路径后加 `64`。不传时使用当前默认值 128 MiB。程序在自建临时目录中生成并清理数据，不使用用户素材。
+
+152 MiB 随机 payload 模拟资源 I/O，带 sprite metadata，但不执行图片解码。每个 1 MiB 块单独随机填充，避免重复块被 Brotli 高比例压缩而掩盖成本。内存记录为当前进程 `PeakWorkingSet64`，包含导出、安装及逐包归属检查；不代表引擎实际画面运行内存，也不构成硬上限。
+
+比较与结果解释见 [P6](../phase-6.md)。result-64MiB.json、result-32MiB.json 和 result.json 保留 P6 的 64/32 MiB 对照及当时缺省值复跑；result-128MiB.json 记录用户后续调大阈值后的缺省值复跑，随机数据和运行调度使耗时及峰值可变化。
diff --git a/features/F-20261028-01-content-packaging/memory-probe/packages.lock.json b/features/F-20261028-01-content-packaging/memory-probe/packages.lock.json
new file mode 100644
index 00000000..025c38ce
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/memory-probe/packages.lock.json
@@ -0,0 +1,108 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.debugging": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.editor.abstraction": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )"
+        }
+      },
+      "galnet.editor.shared": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Debugging": "[1.0.0, )",
+          "GalNet.Editor.Abstraction": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.storage.filesystem": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      },
+      "Serilog": {
+        "type": "CentralTransitive",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/features/F-20261028-01-content-packaging/memory-probe/result-128MiB.json b/features/F-20261028-01-content-packaging/memory-probe/result-128MiB.json
new file mode 100644
index 00000000..e1698a74
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/memory-probe/result-128MiB.json
@@ -0,0 +1,13 @@
+{
+  "inputBytes": 159383552,
+  "targetPakBytes": 134217728,
+  "pakBytes": 146805518,
+  "largestPakBytes": 83888597,
+  "baseParts": 1,
+  "storyParts": 2,
+  "unusedExcluded": true,
+  "sharedDuplicatedInBothStories": true,
+  "peakWorkingSetBytes": 1180585984,
+  "afterGcManagedBytes": 86668648,
+  "elapsedMilliseconds": 3515
+}
diff --git a/features/F-20261028-01-content-packaging/memory-probe/result-32MiB.json b/features/F-20261028-01-content-packaging/memory-probe/result-32MiB.json
new file mode 100644
index 00000000..0d70aa87
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/memory-probe/result-32MiB.json
@@ -0,0 +1,13 @@
+{
+  "inputBytes": 159383552,
+  "targetPakBytes": 33554432,
+  "pakBytes": 146806312,
+  "largestPakBytes": 20973449,
+  "baseParts": 4,
+  "storyParts": 3,
+  "unusedExcluded": true,
+  "sharedDuplicatedInBothStories": true,
+  "peakWorkingSetBytes": 698605568,
+  "afterGcManagedBytes": 86926024,
+  "elapsedMilliseconds": 2511
+}
diff --git a/features/F-20261028-01-content-packaging/memory-probe/result-64MiB.json b/features/F-20261028-01-content-packaging/memory-probe/result-64MiB.json
new file mode 100644
index 00000000..ddeeafb6
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/memory-probe/result-64MiB.json
@@ -0,0 +1,12 @@
+{
+  "inputBytes": 159383552,
+  "pakBytes": 146805716,
+  "largestPakBytes": 62915346,
+  "baseParts": 2,
+  "storyParts": 2,
+  "unusedExcluded": true,
+  "sharedDuplicatedInBothStories": true,
+  "peakWorkingSetBytes": 806952960,
+  "afterGcManagedBytes": 86780840,
+  "elapsedMilliseconds": 2412
+}
diff --git a/features/F-20261028-01-content-packaging/memory-probe/result.json b/features/F-20261028-01-content-packaging/memory-probe/result.json
new file mode 100644
index 00000000..5ae848de
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/memory-probe/result.json
@@ -0,0 +1,13 @@
+{
+  "inputBytes": 159383552,
+  "targetPakBytes": 33554432,
+  "pakBytes": 146806312,
+  "largestPakBytes": 20973449,
+  "baseParts": 4,
+  "storyParts": 3,
+  "unusedExcluded": true,
+  "sharedDuplicatedInBothStories": true,
+  "peakWorkingSetBytes": 656039936,
+  "afterGcManagedBytes": 86910112,
+  "elapsedMilliseconds": 2993
+}
diff --git a/features/F-20261028-01-content-packaging/phase-1.md b/features/F-20261028-01-content-packaging/phase-1.md
new file mode 100644
index 00000000..47b4299a
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/phase-1.md
@@ -0,0 +1,41 @@
+# P1 — Metadata 依赖和 PAK 用途
+
+状态：`verified`，2026-10-28。
+
+## 实现
+
+- Core 的 `IAssetDependencies` / `DependentAssetMeta` 暴露直接引用及完整性；资源目录通过 `WithoutDependencies` 明确叶类型，未声明的 data 仍为未知依赖。
+- 图集编译在同一快照填充全部 sprite 引用，保留未知 metadata 字段，不回写源 sidecar。
+- `AssetDependencyCollector` 提供类型检查、缺失诊断、取消、循环处理、显式动态完整性声明和 graph→group 的可选剧情包边界；输出稳定排序的闭包，不决定包归属。
+- GPAK v3 使用独立控制描述区分 base/story/override，校验用途字段组合、分片序号、映射目标及映射循环。旧调用默认写匿名 base，旧 v2 明确拒绝。
+- 归档按稳定 ID 排序，按实际数据重算 SHA-256；读取校验索引身份、重复 ID/路径、数据范围和尾随数据，获取资源时校验实际 hash/长度。已知编译图集对照正文检查依赖 metadata。
+- 三种用途目前是格式协议，实际分包导出、story 缺席跳过和 override 映射将在 P3/P4 接入；当前并未保证未引用素材已从现有导出中剔除。
+
+## 验证证据
+
+所有构建使用 SDK 10.0.401，先确认 build 完成，再启动 no-build 测试。
+
+| 验证 | 结果 |
+| --- | --- |
+| `dotnet build GalNet.slnx -c Release --no-restore --nologo -m:1 -nodeReuse:false -p:UseSharedCompilation=false -clp:ErrorsOnly` | 通过，250 warning / 0 error |
+| `dotnet test test/GalNet.Assets.Tests/GalNet.Assets.Tests.csproj -c Release --no-build --no-restore` | 89/89 通过，包括新增 13 个用途/依赖契约用例 |
+| Editor.Shared 测试筛选 `ImageVariantsResourceTests` / `ExportPreparationTests` | 12/12 通过 |
+| `verification/ReflectionOff.csproj` Release 构建及直接执行 | 输出 `P1_REFLECTION_OFF_OK kinds=3 dependencies=2 reflectionJson=false` |
+| `git diff --check` | 通过 |
+
+反射关闭验证程序包含断言，必须实际关闭 reflection JSON，检查本地编译、图集依赖闭包、三种用途 metadata/控制描述往返。复跑：
+
+```powershell
+dotnet restore features/F-20261028-01-content-packaging/verification/ReflectionOff.csproj --locked-mode
+dotnet build features/F-20261028-01-content-packaging/verification/ReflectionOff.csproj -c Release --no-restore -m:1 -nodeReuse:false -p:UseSharedCompilation=false
+dotnet features/F-20261028-01-content-packaging/verification/bin/Release/net10.0/ReflectionOff.dll
+```
+
+## 验证中的修正与限制
+
+- 两个旧图集负例手动构造普通 AssetMeta；迁移为有效依赖 metadata 后继续检查它们原本的缺 sprite/错误类型，不删除原负例。
+- 对 PAK 控制 JSON 的重复属性/未知字段，以及大小写不敏感的映射循环均有校验；图集依赖与正文不一致在写入和读取时拒绝。
+- 受限进程环境曾出现构建失败但无错误、测试宿主无结果；终止这些无结果运行后，在正常进程环境构建/测试得到上述明确通过结果。未把无结果尝试当成成功，也未据此认定业务缺陷。
+- 原有 release 脚本、发布文档及其他 feature 的并行改动不属于本提交。
+
+正式规范已同步到 `docs/spec/assets.md`、`docs/spec/file-formats.md`；未提前宣称 Graph 已资源化或补丁挂载行为已实现。
diff --git a/features/F-20261028-01-content-packaging/phase-2.md b/features/F-20261028-01-content-packaging/phase-2.md
new file mode 100644
index 00000000..8ab7cf7c
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/phase-2.md
@@ -0,0 +1,36 @@
+# P2 — 唯一 Graph 资源化与章节参数
+
+状态：`verified`，2026-10-28；P1 提交为 `a3ae72bd`。
+
+## 行为
+
+- 保留一个项目一张图。`content.json` 记录唯一保留 Graph ID，Sample 自动读取；没有 Graph 列表、默认图设置、显式选图 API 或跨图存档字段。
+- Graph/Group 都进入基础 PAK，不再发行 loose `Graph/**`。Group ID 从稳定节点 ID 派生，图 payload 指向该资源 ID；Graph 自身不再每次加载生成随机身份。
+- CompiledStoryResources 同时服务导出和开发 provider，开发编译目录经 CompiledStoryAssetProvider 按同一 ID 寻址；缺少编译正文明确失败。安装加载不回退到 loose Graph。资源查询与内容加载使用统一的安装 provider 工厂。
+- `FieldAttribute.ResourceTypeId` / FieldDescriptor 明确标记资源引用，生成 schema、嵌套结构及描述项复制保留它。编译 Group 按 primitive schema 生成依赖，不猜字符串；未知/opaque/custom.invoke 保留不完整标记。开发适配没有 schema 时不伪造非空 Group 的完整依赖。
+- Group 作者 DTO 增加可选 storyPackage，运行节点与依赖同步携带；本阶段仍全部进入 base，实际拆包和缺席跳过交由 P3。
+- GraphLoader 保留 player/save 声明。默认 Avalonia、Headless 及 GameEngine 自建 runtime 使用声明默认值；新 Run 的 save 初始化不从上次玩家服务缓存继承，已存 player 值保留。
+- NewGameVariables 校验并复制 save-only 初始值，GameSession 在 Prepare 后、Begin 前应用；错误参数先于旧 Run 释放被拒绝，读档不使用新游戏参数。GameRun 拒绝对非新准备状态重复执行该初始化。
+- AvaloniaGameSession 实现可选 IParameterizedGameSessionService；默认标题 VM 有 StartNewGameWithVariablesCommand，复用既有 Loading/Prepare/Begin 与页面替换能力。
+
+## 验证
+
+| 检查 | 结果 |
+| --- | --- |
+| 完整 Release 解决方案构建，`--no-restore -m:1 -nodeReuse:false -p:UseSharedCompilation=false` | 通过，最终完整构建 202 warning / 0 error |
+| Editor.Shared 全套（中途快照） | 476/476 通过 |
+| 最终 StoryResourceCompiler / ExportPreparation / ProjectContractPipeline / ImageVariantsResource 回归 | 23/23 通过 |
+| GameHost 全套 | 8/8 通过，包括首条指令前参数、默认值重建、存档恢复与参数复制/拒绝 |
+| Runtime 全套 | 123/123 通过 |
+| GameInstallation / GameLocalizationLoading / SampleExtensibility 集成 | 18/18 通过 |
+| 反射关闭 verification/ReflectionOff | P1 smoke 仍通过，新增 `P2_STORY_REFLECTION_OFF_OK graph=galnet:graph:main groups=1 saveDefault=1` |
+
+导出集成实际检查 content.json、无 loose Graph、PAK 内 graph/group ID 获取、开发编译目录同 ID 获取、删除 PAK 后即使伪造 loose Graph 也不回退。旧直接 ZIP Group 路径断言和手写安装夹具已迁移至新格式，保留原自定义契约及文本检查。
+
+## 实施边界
+
+P2 没有实际剔除未引用 Assets，也没有把命名剧情 Group 放进独立包；这属于 P3。override 映射尚未应用，资源矩阵尚未创建。Gallery 保留旧基础导出，没有补丁功能。
+
+自定义游戏资源目录需要显式注册 graph/group 对应 DependentAssetMeta；内置目录已经提供。测试新增到既有 Storage 工程的引用，对应锁文件已更新，未新增第三方依赖。
+
+正式规范同步 assets.md / file-formats.md，Sample 手册增加初始章节参数用法。工作区并行的发布/AOT 改动不属于本阶段，提交按文件审计，不打包无关变动。
diff --git a/features/F-20261028-01-content-packaging/phase-3.md b/features/F-20261028-01-content-packaging/phase-3.md
new file mode 100644
index 00000000..48c80553
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/phase-3.md
@@ -0,0 +1,30 @@
+# P3 — 本体与剧情包
+
+状态：`verified`，2026-10-28；前置 P2 提交 `a7f08962`。
+
+## 已实现
+
+- 本体闭包 B 与各剧情包独立的 C(P)−B；稳定排序、软阈值切片、超大项独占、未引用资源裁剪和布局报告。
+- primitive schema、Timeline 事件、shader texture、粒子纹理递归依赖。未知结构/custom.invoke 要求额外根和完整性声明。基础 Gallery 与默认视觉绑定作为根。
+- galnet.packaging：maxPakBytes（缺省 64 MiB）、includeResources、declaredCompleteResources。后者可填 Group 节点 ID 或资源 ID，只声明覆盖，不自动补根。
+- 同一私有阶段生成基础及剧情 PAK，逐片落盘。content.json v2 保存项目/构建/分片校验和。ZIP 外部 StoryPatches/buildId 目录整体发布，目录导出整体发布；取消保留已有 galpak。
+- 安装选择冻结并校验用途、身份、哈希、完整性、重复资源一致性和独立依赖。provider 后续打开复验所选字节；分片改名仍识别，完整缺席沿正常出口跳过，部分安装/损坏拒绝。
+- GameSnapshot v5 保存构建和准备时已安装的全部剧情包；不同构建或缺包拒绝恢复。未播放的已安装包也属于恢复要求，这是首版保守策略。
+
+## 验证
+
+| 检查 | 结果 |
+| --- | --- |
+| 完整 Release 解决方案构建 | 通过，261 warning / 0 error；后续受影响工程复编通过 |
+| Assets 全套 | 94/94，含独立扣除、顺序、阈值、未知依赖、包边界 |
+| Editor.Shared 全套最终快照 | 480/480，含四种安装组合、改名、损坏/部分安装、缺包读档、ZIP 外部发布、重复导出 hash、取消及嵌套依赖 |
+| Integration 全套最终快照 | 130/130；Explicit 原生窗口用例未执行 |
+| Runtime 全套 | 123/123 |
+| ReflectionOff | P1/P2 smoke 均通过 |
+| git diff --check | 通过 |
+
+## 边界与设计修订
+
+settings、I18n 和人物文件仍完整留在基础内容，首版不按剧情拆分文本贡献；正文文本校验只检查已加载 Group。Gallery 保持旧基础聚合。此为明确修订，不声称完成最初的文本分片计划。
+
+64 MiB 为软目标，不是内存上限。Archive 仍以内存打开单个 PAK；代表性大资源峰值观测留给 P6。源目录仍完整校验，未引用的坏资源可能阻止导出。override 与矩阵分别待 P4/P5。
diff --git a/features/F-20261028-01-content-packaging/phase-4.md b/features/F-20261028-01-content-packaging/phase-4.md
new file mode 100644
index 00000000..53e9ac7a
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/phase-4.md
@@ -0,0 +1,23 @@
+# P4 — 独立资源补丁与覆盖
+
+状态：`verified`，2026-10-28；前置 P3 提交 `f97bca72`。
+
+## 实现
+
+- ResourceOverrideDefinition 保存稳定 ID、名称、priority、A→B、动态补根和完整性声明。Builder 完整收集替换闭包；Exporter 独立截取 Assets 私有阶段、编译图集、验证并发布一个 PAK，无需 galpak/剧情编译。
+- override 绑定项目、buildId 为空；story 绑定基础构建。映射和资源稳定排序，同语义输入 hash 不变。ResourcePatches 装载准备期校验全部 payload、用途/项目与闭包。
+- 固定 priority 降序、全文件 SHA-256 ordinal 降序，同 hash 去重。ResourceOverlayProvider 明确绑定来源，保留原 ID/路径，使用替换 metadata/payload；查询、Acquire、路径加载、媒体实体化共用视图。
+- 一次请求只映射一次；夹带 B 不改变本体对 B 的独立查询。递归依赖同 ID 不同内容时拒绝，作者须使用新 ID，避免隐式替换。图集保留原维度键和变体键。
+- 原资源不在当前安装时映射不激活，不能替缺席剧情补正文。会话包集合冻结，旧 handle 保持值，新安装会话采用新包。
+
+## 证据
+
+| 检查 | 结果 |
+| --- | --- |
+| 完整 Release 解决方案构建 | 通过，261 warning / 0 error |
+| Assets 全套 | 102/102，含 sprite/audio/video 查询、ID、路径、实体化，图集闭包、单次映射、优先级/hash/重复文件、类型/缺目标/依赖冲突、稳定 hash |
+| Editor.Shared 全套 | 481/481，含先于基础导出、改名/重复包、缺席剧情、冻结/重开会话、坏 payload 准备期拒绝 |
+| Integration 全套 | 130/130；Explicit 原生窗口用例未执行 |
+| ReflectionOff | P4_OVERRIDE_REFLECTION_OFF_OK，P1/P2 smoke 保持通过 |
+
+矩阵 GUI 与作者定义的持久化/历史属于 P5。无热装卸、语言条件或 Gallery 补丁行为。
diff --git a/features/F-20261028-01-content-packaging/phase-5.md b/features/F-20261028-01-content-packaging/phase-5.md
new file mode 100644
index 00000000..74399c90
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/phase-5.md
@@ -0,0 +1,28 @@
+# P5 — 作者入口与资源矩阵
+
+状态：`verified`，2026-10-28；前置 P4 提交 `5b2c1a74`。
+
+## 实现
+
+- Group 检查器编辑 storyPackage，提供已有名称候选，失焦提交并支持项目 Undo/Redo。补齐作者 DTO 手写克隆和身份保留重载，避免包名在保存/结构操作后丢失。
+- 资源补丁面板扫描整张图的所有 Group，包括未打开和剧情补丁 Group；基于显式字段 schema、Timeline、shader、粒子与 metadata 展开间接依赖。资源缺失保留行与诊断，补充动态原资源同时成为基础打包根。
+- 一列一个稳定补丁身份；名称/优先级草稿回车或保存时提交，无效草稿保留并阻止保存；映射单元格复用 AssetPicker，原资源点击定位文件管理器。列增删改、映射和额外原资源进入 settings 的 galnet.resourceOverrides 与统一历史/保存/恢复路径。
+- 资源代次和作者通知使扫描重新捕获，合并异步刷新。相同结果不重建控件，避免鼠标按下/抬起之间移除目标。横向滚动覆盖多列，Dock 关闭不销毁项目草稿。
+- 覆盖导出保存工作版，捕获保存版定义，保护资源复制至私有阶段后释放作者门，后续编辑不混入正在导出的资源包；正常 galpak 导出也保存并保护快照。保留独立导出及取消/失败反馈。
+- 面板、包名和历史文案进入四种编辑器语言。章节按钮示例与 DI/VM→View 衔接见 Sample 手册，不新增多图或页面编辑产品。
+
+## 已有证据
+
+实际挂载的三项 Editor 测试验证包名失焦、矩阵新建/改名、资源选择器确认、原文件定位、五列滚动、撤销/重做、保存重开和独立 PAK 内容；无效优先级草稿阻止保存。共享测试验证补丁 Group 的间接引用、缺失资源、克隆与重载。
+
+| 检查 | 结果 |
+| --- | --- |
+| 完整 Release 解决方案构建 | 通过，214 warning / 0 error；最后布局改动的 Editor.Tests 工程复编通过 |
+| Editor 全套 | 345/345，5 分 34 秒；最后布局修正后作者入口与四语言键一致性 4/4 复验通过 |
+| Editor.Shared 全套 | 483/483 |
+| Integration 全套 | 130/130；Explicit 原生窗口用例未执行 |
+| 变更文件格式整理 / git diff --check | 通过 |
+
+最后的实际挂载测试还检查了列头按钮不跨列重叠；可复现截图见 [矩阵截图](verification/ui/resource-patches.png)。测试通过真实鼠标点击和选择器确认进入服务，不只赋值 VM。修正过程中的无效 PNG 夹具已替换为真实图片，独立窗口夹具初始化真实 Dock 后验证原文件定位。
+
+操作说明见 docs/manual/content-packaging.md。P6 的整体验证与文档收尾尚未完成，不宣称整个 feature 完成。
diff --git a/features/F-20261028-01-content-packaging/phase-6.md b/features/F-20261028-01-content-packaging/phase-6.md
new file mode 100644
index 00000000..6fdb4ebd
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/phase-6.md
@@ -0,0 +1,58 @@
+# P6 — 集成与文档收尾
+
+状态：`verified`，2026-10-28；前置 P5 提交 `043638d9`。实现、完整检查及发现问题的定向复验完成，机器可读汇总见 [validation-results.json](verification/validation-results.json)。
+
+## 集成修正
+
+- 图集覆盖后的旧存档保留逻辑图集 ID、选择请求和受保护维度，在候选恢复状态按当前图集重算派生图片。覆盖来源通过 `IAssetOverrideFile` 传入会话图集目录，存档附加可选 `UsesResourceOverride`，支持安装和移除覆盖的双向恢复；普通未覆盖图集保持严格一致性检查，不修改输入存档。
+- 打包内容的内部调试 replay 快照补齐构建和剧情包身份；Sample 的进度/Group 起点调试存档也保留身份。外部缺身份或错构建存档仍拒绝，没有放宽恢复门禁。
+- 资源矩阵索引使用实际文件 ID，配置反序列化后继续使用大小写无关的映射键；反射关闭 smoke 覆盖作者配置和新增 Layer 状态。
+- 按仓库格式规则整理本 feature 修改的 C# 文件，正式文档同步唯一 Graph、GPAK v3、content v2、save v5、剧情包和资源覆盖契约。
+- 完整架构检查发现 Editor.Shared.Tests 的安装夹具直接引用 Storage，违反测试依赖规则。将 ExportPreparationTests 和 StoryPackageExportTests 移到现有 IntegrationTests，移除该直接依赖，不放宽架构白名单；更新锁文件并重验受影响工程。
+- 构建指纹纳入格式标记和物理分片布局。仅更改引擎默认切片值时，源 settings 与资源字节可能完全不变，但剧情包分片集合会变化，必须得到不同 buildId，避免复用同一不可变剧情目录。
+- SchemaGenerator 的既有旧契约二进制兼容测试发现：给 FieldDescriptor 构造函数增加可选 resourceTypeId 会改变 CLR 签名。保留旧八参数构造函数，转发到新实现，不要求未使用新能力的已编译契约重新编译。
+
+## 原生验证
+
+Debug 构建下显式执行 `Packaged_variants_render_in_native_sample_and_close_cleanly`：1/1 通过。测试导出真实素材后删除作者目录，从安装包启动真实 Avalonia Sample，完成调试 seek/step、五幅不同渲染截图和正常关闭。进程峰值 working set 480,911,360 bytes，关闭时日志确认 Run、scope 和根服务释放。
+
+最终源码重新构建 Debug（96 warning / 0 error）并单独选择该 Explicit 用例再次通过 1/1，峰值 457,216,000 bytes。调试快照工厂另通过 2/2。混合过滤普通与 Explicit 测试不会保证执行 Explicit，最终分别选择并核对实际执行数。
+
+首次尝试使用默认 Release 构建，因调试桥默认关闭而等待监听超时；改用具有调试桥的 Debug 构建。随后实际暴露的内部快照身份丢失已修复并通过上述用例，未用禁用内容校验绕过。
+
+图集资源覆盖的独立 PAK→catalog→引擎读档→呈现集成测试已通过 1/1，验证 A 衣服旧档装补丁后显示 B，B 补丁档移除补丁后显示 A，并核对输入存档未改变。
+
+## 大资源观测与默认值
+
+可复现程序见 [memory-probe](memory-probe/Program.cs)。152 MiB 合成不可压缩资源：本体 80 MiB、A/B 共用 20 MiB、A 独用 20 MiB、未用 32 MiB；资源模拟 PAK I/O，不代表图片解码/渲染压测。程序导出、安装并逐包核对未用资源排除以及 A/B 各带公共资源。
+
+| 软阈值 | 最大实际 PAK | 本体/剧情分片 | 进程峰值 working set | 导出+安装耗时 |
+| --- | --- | --- | --- | --- |
+| 64 MiB | 62,915,346 bytes | 2 / 2 | 806,952,960 bytes | 2,412 ms |
+| 32 MiB | 20,973,449 bytes | 4 / 3 | 698,605,568 bytes | 2,511 ms |
+
+原始比较报告保存在 result-64MiB.json、result-32MiB.json。最终默认由 P3 的 64 MiB 调整为 **32 MiB**，其余切片规则不变。以上是一次本地观测，峰值约降低 13%，不能推导所有项目相同比例或严格内存上限。
+
+Archive 当前仍以整片缓冲读写，压缩/输出会产生临时副本；即使分片也会有较高峰值。此阶段没有扩展为流式归档重写，默认值只是降低常见单片开销。超大单资源仍独占且可能超过目标。最终不传阈值参数的重跑结果见 [result.json](memory-probe/result.json)：默认 33,554,432 bytes，归属检查通过，峰值 656,039,936 bytes，耗时 2,993 ms；运行间存在波动。
+
+## 完整检查
+
+执行仓库统一入口 `scripts/ci/Invoke-CI.ps1 -Stage All -Configuration Release`：完成发布保护、锁定还原、格式、完整构建及全部 **15** 个测试工程。首次运行暴露上述架构依赖和构造函数二进制兼容问题，保留原始失败；修复后完成最终 Format 入口、完整 Release 复编和受影响工程定向复验，不把首次失败输出改写为成功。
+
+| 最终证据 | 结果 |
+| --- | --- |
+| 发布保护 / 精确 SDK / Release locked restore / whitespace / IDE0005 | 通过；最终 Format 报告 passed=true |
+| 完整 Release 解决方案构建 | 通过，386 warning / 0 error，3 分 40 秒 |
+| Architecture | 52/52 复验通过，白名单未放宽 |
+| SchemaGenerator / Core | 20/20、139/139 复验通过，含旧 consumer 装载当前 Core |
+| Editor.Shared / Integration | 迁移后 476/476、138/138 全套通过 |
+| Editor | 完整运行 345/345，最终作者操作 3/3 复验通过 |
+| 其他默认工程 | Assets 103、Debugging 10、Diagnostics 1、GameHost 8、Media.Audio 26、Presentation 276、Primitives 322、Runtime 124、Storage 24，均通过 |
+| 默认工程组合证据 | 15 工程，2,064 项通过；逐工程来源保存在 validation-results.json |
+| Debug 原生 / 精简快照 | 分别 1/1、2/2，最终源码复编后执行 |
+| ReflectionOff | 四个阶段标记均出现，reflection JSON=false |
+| 大资源 / 本地文档链接 / git diff --check | 通过 |
+
+默认 TRX 仍包含 8 项未执行的 Explicit/环境用例，其中打包原生 Sample 已在 Debug 单独执行；未声称其余媒体环境/平台用例已执行。最终复验只覆盖新增修正和迁移影响，没有为未改动的用例重复整套运行。CI 原始日志与 TRX 留在 out/ci/content-packaging-p6*；提交内保留简洁汇总及内存报告。
+
+正式文档已同步资源、发布格式、运行时、文本边界、Graph 作者入口和操作手册。文本/人物完整在本体、保守剧情包存档、整片内存、Gallery 延期等边界与设计修订一致。没有剩余阻止本 feature 交付的已知问题。
diff --git a/features/F-20261028-01-content-packaging/phase-plan.md b/features/F-20261028-01-content-packaging/phase-plan.md
new file mode 100644
index 00000000..8646ce4f
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/phase-plan.md
@@ -0,0 +1,218 @@
+# 单 Graph 资源化与内容分包阶段计划
+
+状态：P1–P6 `verified`。根据已确认的 [设计](design.md) 拆分；各阶段测试段落为计划，已执行证据见阶段记录。
+
+范围和需求见 [feature 清单](feature.md)。用户已明确授权开始实现，并要求每完成一个阶段提交一次 Git；仅将已有验证证据的阶段标记为 verified。
+
+## 1. 交付顺序
+
+```text
+P1 资源依赖与 PAK 用途契约
+  → P2 单 Graph / Group 资源化与章节启动闭环
+  → P3 本体及剧情补丁分包、安装与执行
+  → P4 独立资源补丁导出和运行时覆盖
+  → P5 编辑器作者工作区与资源补丁矩阵
+  → P6 集成、格式策略与正式文档收尾
+```
+
+每个阶段完成后记录具体构建、用例和已知限制，再推进后续。中间阶段可以由低层集成夹具或现有无 GUI 入口验证，不要求先做完 GUI 才证明包可运行。仅为验证需要补充共享入口，不额外扩大成新一套 CLI 产品。
+
+核心约束：项目只有一张 Graph；本体先收集该图的全部非补丁 Group；章节采用入口条件分支与新游戏初始变量；剧情补丁之间不扣除共享资源；资源补丁独立导出；优先级和 hash 决定覆盖；不做语言选包和 Gallery 补丁。
+
+## P1 — 依赖 metadata 与 PAK 用途（verified）
+
+2026-10-28：实现和验证完成，见 [P1 记录](phase-1.md)。资源层 89 项、图集/导出回归 12 项通过；反射关闭独立程序通过；完整 Release 解决方案构建通过（250 个 warning、0 error）。本阶段不启用未引用资源裁剪或剧情/资源补丁装载，分别在后续阶段接入。
+
+### 目标与前置
+
+前置：现有设计。形成后续资源化、分包和覆盖共用的协议，并以现有图集证明协议能实际贯通本地编译与 PAK 往返。
+
+涉及 Core.Assets、Contracts.Builtins、Assets 的资源编译与 Archive/PakBuilder；沿用注册时的冻结目录和 JSON resolver。
+
+### 工作
+
+- metadata 的 `IAssetDependencies` 与直接依赖、预期类型、完整性结果；类型注册显式区分叶资源和未知依赖。
+- 为图集等结构化资源注册适当 DTO。图集 payload 与依赖 metadata 同步生成，仅更新有效编译快照，不写回源 sidecar。
+- 共用 PAK 格式增加版本化控制描述，区分 `base`、`story`、`override`，定义各自必需字段与合法组合。
+- 统一资源 ID 规范化、依赖闭包和来源诊断。闭包不负责包归属，必需资源缺失/错误类型明确失败。
+- 处理新增 metadata 的源生成序列化，明确新旧格式识别与错误，不默读旧格式为新包。
+
+### 验证与文档
+
+测试图集的直接依赖与递归收集、重复引用、未知依赖与显式叶资源、循环终止、缺资源/错类型；本地编译和 PAK 读取依赖一致；源 `.meta` 字节不变；metadata/payload 不一致拒绝。验证三种 kind 往返、未知 kind、非法字段组合和取消/坏归档。用实际反射关闭路径验证新 DTO。
+
+在本阶段记录实际协议/API与格式决定；只有经验证的事实才同步 `docs/spec/assets.md` / `file-formats.md`。
+
+### 风险与退出
+
+风险：共用 AssetMeta 的注册迁移丢扩展字段或默认值；依赖遗漏被误判为空；PAK 格式变化影响现有导出器和 fixture。
+
+退出：现有图集通过同一协议编译、打包、读取和验证，源文件不被修复写盘；三种用途合法性可独立验证；受影响旧入口已适配或明确拒绝不支持的旧格式。
+
+## P2 — 单 Graph / Group 资源化与章节启动（verified）
+
+2026-10-28：见 [P2 记录](phase-2.md)。唯一 Graph/Group 资源寻址和初始章节参数闭环已实现；完整构建、Runtime 123 项、GameHost 8 项、相关集成 18 项、最终编译/导出 23 项及反射关闭 smoke 通过。剧情分包与覆盖装载尚未接入。
+
+### 目标与前置
+
+前置 P1。先完成“唯一 Graph 与 Group 位于基础 PAK，Sample 自动启动并支持初始章节参数”的垂直闭环，本阶段可暂不拆物理包。
+
+涉及 Graph/Group 文档与编译、Editor.Shared、开发/安装内容 provider、GameHost、默认 Sample、存档入口和 Editor Preview。
+
+### 工作
+
+- 固化 Graph/Group 的作者身份与 sidecar 布局，使 Graph ID、Group 资源 ID、节点 ID 明确分开；更新现有作者结构校验和源生成 DTO。
+- 保留唯一 Graph 的作者结构，新增 Group 剧情包标记的作者真源；清单保存唯一 Graph 的资源 ID，不增加 Graph 列表、defaultGraphId 或选图 API。
+- 将编译后的 Graph/Group 作为资源产出 metadata 和 payload，按资源 ID 加载，移除发行加载对固定 graph.json/Group 文件路径的依赖。
+- Group 依赖按展开后的指令 schema 收集；Graph 引用携带包标记。动态引用不完整时保留可处置诊断。
+- Sample 按清单自动加载唯一 Graph；Preview 与开发源使用同一有效编译事实，不改变项目只有一图的约束。
+- 补齐新游戏初始 save 变量参数：初始化默认值后、开始执行前整批验证应用；读档不套用新游戏参数。章节由图入口条件分支选择。
+- 存档仅补充内容包/版本兼容所需信息，不增加跨图身份字段或按图变量存储层；节点、游标和 save 变量继续在项目唯一 Graph 中恢复。
+
+### 验证与文档
+
+从开发目录、导出目录、安装后的 galpak 分别启动唯一 Graph，Sample 无需选图参数；清单缺失或引用错误明确失败，不扫描猜图。Graph 重命名/源文件移动保持资源身份，raw 不进入运行包。沿用现有自定义契约、未知作者内容保留和 Preview 流程回归。
+
+验证同图重复新游戏不泄漏上次 save 值，初始章节参数在第一次分支前可见，整批参数无效时不执行入口，读档不被当前启动参数改写；player 解锁数据仍跨 Run 保留。
+
+经验证后同步 Graph/Group 资源格式、初始变量启动/自定义 Sample 手册；保留本阶段尚未支持分包的事实。
+
+### 风险与退出
+
+风险：资源化改动破坏现有单图作者历史/文件操作；运行仍暗中读取 loose graph.json；初始章节参数应用晚于第一条分支；新 Run 的初始化与旧 save 值混用。
+
+退出：唯一 Graph 在三种内容来源中均可按资源 ID 运行、保存和恢复，章节初始参数正确生效，源文件身份稳定，默认 Sample 与无 GUI 集成夹具均通过；不存在发行 loose Graph 回退掩盖缺失资源。
+
+## P3 — 本体与剧情补丁闭环（verified）
+
+2026-10-28：见 [P3 记录](phase-3.md)。分包、四种安装组合、损坏/部分安装、ZIP 发布和读档校验均通过。文本/人物留在基础完整文件；存档保守要求准备时安装的全部剧情包。大资源峰值观测交给 P6。
+
+### 目标与前置
+
+前置 P2。正常导出一次生成基础 galpak 和外部剧情 PAK；可独立安装任一剧情包，不依赖其他可选剧情包。
+
+涉及构建规划器、GamePackageExporter、包目录/安装发现、GameHost 内容准备与运行调度。
+
+### 工作
+
+- 本体根覆盖唯一 Graph、全部非补丁 Group、UI/启动/额外资源及现有基础 Gallery 所需资源；不只扫描当前打开的 Group 或运行可达路径。
+- 实现 `B` 与 `C(P)-B`，每个剧情包独立计算；复制资源同 ID 的内容及 metadata 必须一致。
+- 明确 Group 引用的包边界，Graph 留节点描述、补丁正文只进入 story；普通必需依赖不能绕过此边界。
+- 稳定排序、按未压缩编译载荷目标切 PAK、超限单资源独占，输出布局报告。阈值默认值依据实际内存验证选择。
+- 同一次私有快照生成基础与剧情包、文本及人物贡献；目录导出与 galpak 共用准备/校验流程，失败不发布半包。
+- 根据 `kind` 与清单发现完整 story 分片，验证项目/基础构建/资源闭包。安装器保留基础受管内容与额外包边界。
+- 未安装剧情节点沿唯一正常出口跳过；坏包不得变成未安装。连续跳过、结束和空推进循环具备明确行为。
+
+### 验证与文档
+
+建立一张 Graph、多个普通/补丁 Group、两个剧情包、基础共享资源与补丁间共享资源的集成项目，验证：
+
+- 本体用 X 时 A/B 均不带 X；仅 A/B 使用 X 时各自带 X；交换遍历顺序不改变结果。
+- 仅安装 A、仅安装 B、全不装、全安装均执行正确路线；缺单分片、坏哈希、错基础构建、坏正文明确失败。
+- 未安装剧情不要求其文本；已安装剧情缺默认语言文本仍失败；Gallery 沿旧基础路径运行，不新增补丁聚合。
+- 删除当前存档必需的剧情包不能通过跳过恢复；分片重命名不改变包类型与完整性判断。
+- 切包边界、超大单项、取消/故障输出和最终产物复验；用代表性项目观测加载峰值内存。
+
+同步已验证分包算法、输出目录、包安装与跳过语义；操作手册不引入独立剧情补丁面板。
+
+### 风险与退出
+
+风险：Gallery 原基础聚合意外拉入补丁独有内容；本体递归越过可选 Group；包目录只认文件存在而不认完整性；补丁发布失败仍留下可挂载分片。
+
+退出：一份正常导出产物可按上述四种安装组合独立运行；资源归属、文本和恢复检查成立；失败输出不会被识别成新完整包。
+
+## P4 — 独立资源补丁服务与覆盖（verified）
+
+2026-10-28：见 [P4 记录](phase-4.md)。独立导出、统一来源视图、确定排序、图集和媒体、冻结/重开会话及反射关闭路径已验证。
+
+### 目标与前置
+
+前置 P1/P2/P3 的内容会话和包来源模型。先以共享服务和集成夹具完成独立导出与运行验证，再连接矩阵 UI。
+
+涉及 Editor.Shared 导出、Assets 查询/Acquire/缓存、Storage 包发现、GameHost 会话和媒体实体化。
+
+### 工作
+
+- 定义每列的稳定身份、整数 priority 与 A→B 映射；默认 priority=0。每列导出一个 override PAK，带齐 B 的递归依赖，不依赖先导出 galpak。
+- 来源明确的目标绑定，补丁携带资源不隐式替换其他 ID。Graph/Group 和控制描述不接受此面板覆盖。
+- 固定 `(priority, finalPakSha256)` 顺序，较大者胜；hash 取完整文件字节，ordinal 比较，同 hash 去重，不引入语言条件、冲突阻断或手动冲突流程。
+- 每次引用仅映射一次，嵌套依赖作为独立请求处理；类型和图集变体兼容性继续验证。
+- 统一 ID 文件查询、Acquire、媒体实体化的有效视图，保留源文件定位视图。缓存隔离实际来源与版本，现有 handle/媒体租约所有权不变。
+- 包集合冻结；首版在重启或重建相关会话时采用启停变化。剧情包缺席时，其资源映射不能使剧情被视为已安装。
+
+### 验证与文档
+
+独立导出衣服 A→B 图集并运行；覆盖单张 sprite、音频、视频的有效来源一致。验证 B 的完整依赖、未映射依赖无副作用、不同 priority、同 priority 的已知 hash 顺序、相同文件去重、文件名/目录枚举无关、多映射正常覆盖、语言切换不影响解析。验证 A→B/B→C 不串成链，旧 handle 安全释放，重建会话采用新包。缺目标、坏包及不兼容类型明确诊断。
+
+同步覆盖解析和独立导出 API/手册；不写 Gallery 新语义或语言自动选包说明。
+
+### 风险与退出
+
+风险：只覆盖 Acquire 但 raw/media 仍走旧 provider；hash 包含不稳定导出元数据导致相同优先级重新导出改变胜者；夹带 B 依赖形成意外全局覆盖；缓存命中旧版本。
+
+退出：无矩阵 UI 也能独立制作、导出和加载资源补丁；排序和来源全链路一致。确保不必要时间戳/随机序列不进入资源补丁文件，使同内容重复导出 hash 稳定；实际变更导致 hash 变化按既定规则接受。
+
+## P5 — 编辑器作者入口与资源补丁矩阵（verified）
+
+2026-10-28：见 [P5 记录](phase-5.md)。Group 包名、整图资源矩阵、原文件定位、列/映射历史、保存重开与独立导出已由实际挂载控件验证，完整构建与相关全套回归通过。
+
+### 目标与前置
+
+前置 P2/P3/P4 共享能力已验证。提供完整作者操作，不在 GUI 再实现一套依赖或打包逻辑。
+
+涉及 Editor 的项目/Graph 文档、Inspector、文件面板、资源引用查询、项目历史/保存和本地化。
+
+### 工作
+
+- 保留单图作者工作区；项目级资源扫描覆盖该图全部 Group，包括未打开的正文和补丁 Group，不增加多图管理 UI。
+- 默认应用模板的章节按钮示例共用带初始章节变量的启动能力。首页替换继续复用现有 DI/VM→View 注册，不重复实现既有扩展机制。
+- Group 包名编辑、已有名称候选及正常导出整合；不提供额外剧情补丁面板。
+- 资源矩阵行聚合唯一 Graph 及其全部 Group 的引用，包括补丁；显示使用位置、展开间接依赖、允许补充动态原资源。
+- 原资源定位到编辑器文件管理器；新建/重命名/删除补丁列，单元格复用资源选择器并校验类型，显示/编辑包内 priority，独立导出当前列。
+- 作者补丁定义随项目保存并进入现有 Undo/Redo/恢复机制；工作版与保存版明确，导出捕获一致作者快照，避免后台导出混入之后编辑。
+- 删除/复制资源、Graph/Group 变化和外部项目修改更新矩阵引用；保留现有身份/事务边界，不把补丁面板状态藏成唯一真源。
+- 面板文案进入现有编辑器语言资源；无语言条件列、Gallery 配置或冲突处理页。
+
+### 验证与文档
+
+验证单图内切换 Group 不串文档/草稿/历史；创建列、选资源、撤销、保存、重开和恢复得到同一映射；删除/复制目标资源后的引用诊断；定位原资源而非运行替换资源。实际挂载控件验证资源选择器、矩阵编辑/滚动和导出，避免仅靠 VM 赋值证明 UI 可用。覆盖后台导出快照、取消及失败提示。
+
+发布面向作者的单图章节启动、剧情分包和资源矩阵操作手册；共享服务/API 文档指向真实实现。
+
+### 风险与退出
+
+风险：全部 Group 的资源引用扫描成本过高；项目草稿与保存版混淆；矩阵复用失效绑定；将打开的 UI 作为后台任务唯一数据源。
+
+退出：用户可在编辑器完成单图的 Group 包名→正常导出，以及新建资源补丁列→选择替换资源→独立导出的两条流程；章节按钮示例使用初始变量，保存重开不丢定义，运行结果与共享服务集成夹具一致。
+
+## P6 — 集成与文档收尾（verified）
+
+2026-10-28：见 [P6 记录](phase-6.md)。完整构建、发布保护、格式和 15 工程默认用例组合证据通过，原生 Sample、反射关闭和大资源观测完成；首次 CI 发现均已修复并复验。
+
+### 目标与前置
+
+前置 P1–P5。完成跨模块回归、格式策略和交付事实记录，不将“测试未执行”写成“通过”。
+
+### 工作、验证与文档
+
+- 按实际协议确定所有受影响格式/API版本。实现早期记录格式策略：新格式显式识别，旧版不支持时明确拒绝；未经请求不追加自动转换产品。若现有示例/fixture 必须升级则同步升级。
+- 运行相关分层测试与跨层项目夹具，再按仓库现有入口完成所需解决方案构建、检查和默认 Sample 验证。仅在新增变化或失败需要时扩大/重复验证。
+- 实际验收已安装产物、唯一 Graph 启动与初始章节参数、所有剧情包组合、独立资源补丁、读档、原生媒体文件租约、取消、损坏/部分安装及大资源峰值内存。
+- 核对默认/自定义资源类型目录、契约扩展和反射关闭路径，正式文档与实际 CLI/GUI 行为一致。
+- 收敛 `docs/spec/assets.md`、`file-formats.md`、`i18n.md`、相关作者/宿主手册；保留设计及偏差原因，生成实现 summary。Gallery 补丁与跨图执行保持延期。
+
+### 风险与退出
+
+风险：跨模块构建失败被局部通过掩盖；发布脚本仍假设唯一基础 PAK/loose Graph；旧存档被错误接受；文档声明超出实际支持范围。
+
+退出：必需检查全部有证据，预先存在的失败与本次引入问题明确区分；无未处理的目标范围错误；未完成的人工/环境验证如实列出，不据此宣称完整收尾。
+
+## 2. 当前决策与剩余工程选择
+
+设计没有等待用户回答的产品阻塞。PAK 二进制具体字段顺序、作者 sidecar 布局和默认大小阈值是实现阶段根据现有结构及验证确定的工程选择，不需要为它们重新发起需求确认。
+
+工程实现不能删去的边界：补丁部分安装不等于未安装；缺少依赖不等于空依赖；包的 kind 与资源 typeId 独立；覆盖不改变作者资源 ID；项目保持唯一 Graph；Gallery 不扩展。
+
+范围修正记录：按用户明确要求移除原计划中的多 Graph 管理、默认/显式选图、跨图存档身份与按图变量隔离，P2/P5 及所有集成验收均改为单图；Graph/Group 资源化和初始章节变量保留。
+
+若实施时发现与上述已确认行为冲突，记录原因并修订计划，不通过增加语言条件、共享包依赖或手动冲突流程绕开问题。
diff --git a/features/F-20261028-01-content-packaging/review.md b/features/F-20261028-01-content-packaging/review.md
new file mode 100644
index 00000000..7f0c20f5
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/review.md
@@ -0,0 +1,33 @@
+# 交付核对
+
+状态：`pass`，2026-10-28。这是实施者的最终自查，不宣称独立 agent 审核。
+
+## 核对范围
+
+以 feature、设计修订、阶段记录和实际代码为准，核对单图范围、静态依赖完整性、剧情包集合语义、显式覆盖来源、作者保存历史、快照导出及格式文档。验证证据见各阶段记录与 [最终汇总](verification/validation-results.json)。
+
+## 已处理发现
+
+| 发现 | 影响 | 处理和证据 |
+| --- | --- | --- |
+| 图集保存的是原 sprite 派生结果 | 安装兼容衣服覆盖后旧档被拒绝 | 候选恢复按逻辑选择重算，覆盖来源标记支持移除；真实 PAK 到呈现的双向读档集成通过 |
+| 内部 debug replay/精简存档丢构建身份 | 原生打包 Sample seek 失败 | 当前引擎标记内部基线、复制源身份，原生显式用例通过；保留外部不匹配拒绝 |
+| 映射 JSON 往返丢字典比较器 | 大小写变体可能分裂原资源映射 | DTO setter 恢复 OrdinalIgnoreCase，索引使用文件规范 ID，增加回归 |
+| 默认切片未有实际内存观测 | 可能把阈值误写为内存预算 | 对比报告及文档明确整片缓冲限制，最终默认 32 MiB |
+| 跨层安装夹具放在 Editor.Shared.Tests | 完整架构门禁失败 | 迁移到已有 IntegrationTests，移除 Storage 直接引用，保持白名单不变并重验 |
+| FieldDescriptor 增加可选参数改变 CLR 签名 | 已编译的旧契约调用构造函数失败 | 保留旧八参数签名并转发；使用既有“编译旧 API/装载当前 Core”测试复验 |
+| 资源相同但物理分片布局变化未进入指纹 | 可能向同一不可变目录写入不同分片集 | buildId 纳入格式标记和实际布局，重复导出稳定性与独立安装夹具复验 |
+
+## 边界核对
+
+- 项目唯一 Graph，章节命令只传初始变量；Graph/Group 资源身份没有变成多图产品。
+- 依赖未知时拒绝不完整构建，显式声明不能自动增加根；编译不回写 sidecar。
+- 剧情闭包只减本体，所有安装组合有执行夹具；整包缺席与部分/损坏严格区分。
+- 覆盖包明确来源，priority/hash 稳定，一次映射不串联，夹带资源不隐式改本体；缺席剧情不被覆盖包激活。
+- 资源面板与导出复用共享服务，作者定义进入项目历史，导出先私有快照，挂载控件验证实际操作。
+- PAK payload 校验与索引区分，资源补丁准备期逐项验证；没有用排序 hash 冒充预期完整性校验。
+- 正式文档保留文本整文件、本体 Gallery、保守剧情包存档和整片内存限制；未承诺 Gallery 补丁、热装卸或自动旧格式迁移。
+
+## 结论
+
+`pass`：以上发现全部修复并有复验；完整构建、发布保护、格式和默认 15 工程组合证据通过，另有原生/反射关闭/内存验证。没有发现阻止本次范围交付的剩余问题。此结论不涵盖未执行的其余 Explicit 媒体/平台用例，不承诺流式内存、Gallery 补丁或跨图功能。
diff --git a/features/F-20261028-01-content-packaging/summary.md b/features/F-20261028-01-content-packaging/summary.md
new file mode 100644
index 00000000..82b17a3e
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/summary.md
@@ -0,0 +1,55 @@
+# 单 Graph 内容分包与独立资源覆盖
+
+状态：`completed`，P1–P6 全部 verified，2026-10-28。各阶段独立提交。
+
+后续面板与默认阈值调整见 [调整记录](follow-up-panel-20261028.md)：图标化、配置即时持久化、纯导出，默认阈值提高为 128 MiB。
+
+## 实现结果
+
+项目保持唯一 Graph。Graph 与编译 Group 作为普通 PAK 资源读取，固定 Graph 资源 ID 由清单提供，Sample 无需配置选图。章节按钮通过新游戏初始存档变量选择入口分支；默认值初始化后应用参数，新 Run 与读档各遵守既有变量生命周期。
+
+metadata 的 `IAssetDependencies` 提供直接依赖和完整性，叶类型显式注册。编译期生成图集、Graph、Group 的有效依赖，不改作者 sidecar；自定义动态引用通过显式补根和完整性确认参与构建。只有依赖闭包进入 PAK，条件分支及图集的全部静态依赖都会纳入。
+
+本体先行，剧情包各自扣除本体已有项；A/B 共用但本体没有的资源分别携带。包内去重，以未压缩大小软切片，首版默认 32 MiB（后续按用户要求改为 128 MiB）。普通 galpak 导出同时生成外部剧情包。未安装整包时沿正常出口跳过，部分安装、坏包、错项目/构建和依赖缺失拒绝。
+
+资源覆盖独立导出。作者面板聚合所有 Group 引用，支持间接资源、原文件定位、补丁列与资源选择、优先级、撤销/重做、保存重开。A→B 保存明确来源并携带 B 闭包，按 priority、最终 PAK SHA-256 降序裁决，禁止隐式夹带覆盖和 Graph/Group 覆盖。寻址、解码和媒体文件租约共用冻结视图；图集替换后旧档重新解析选择意图。
+
+## 模块与协议
+
+| 模块 | 变化 |
+| --- | --- |
+| Core / Contracts | 依赖接口、类型声明、包控制 DTO、配置 section、资源字段标注、可选图集覆盖状态 |
+| Assets | GPAK v3、闭包收集/规划、Graph/Group 编译适配、独立覆盖 Builder、统一覆盖 provider |
+| Runtime / GameHost | 单图资源装载、缺席剧情导航、save v5 兼容校验、新游戏初始变量、内部调试快照身份 |
+| Storage / Editor.Shared | content.json v2、基础/剧情整组导出与验证、布局报告、覆盖快照导出、资源引用索引 |
+| Editor / Sample | Group 包名和资源补丁矩阵、四种 UI 语言、章节命令示例与既有首页 DI 扩展衔接 |
+
+旧 GPAK/安装内容需重新导出；旧版存档不自动迁移。没有增加多 Graph、选图、按图变量隔离或第二套首页框架。
+
+## 验证
+
+分阶段证据见 [P1](phase-1.md)、[P2](phase-2.md)、[P3](phase-3.md)、[P4](phase-4.md)、[P5](phase-5.md)、[P6](phase-6.md)。最终发布保护、锁定还原、两项格式和完整 Release 构建通过；完整运行与修复后定向复验组成 15 工程、2,064 项默认用例通过的证据，另有 Debug 快照 2/2、原生 Sample Explicit 1/1、反射关闭和大资源观测。详见 [机器可读汇总](verification/validation-results.json)。构建仍有 386 个 warning，未宣称零告警。
+
+首次完整 CI 暴露测试越层依赖和 FieldDescriptor 旧签名丢失，均已修复并复验；原始失败记录保留。跨层安装夹具移至 IntegrationTests，未放宽架构规则。公开 FieldDescriptor 保留旧构造函数，已编译契约可继续装载。buildId 纳入实际分片布局，避免默认切片策略变化复用旧剧情目录。
+
+P5 实际挂载控件验证选择器、定位、矩阵多列滚动/编辑、撤销、保存重开和独立导出。P6 显式 Debug 原生测试从打包内容启动、seek/step、五组截图并正常退出；合成大资源程序验证未使用项排除和独立剧情包归属。性能数据是本机观测，不代表内存硬上限。
+
+## 实施偏差与限制
+
+- 按用户后续确认移除最初讨论的多 Graph，最终始终唯一 Graph。
+- 文本和人物文件完整放在本体，未实施按剧情文本贡献合并；缺席剧情不参与正文引用检查。既有 External 翻译来源继续保留。
+- 存档保守记录准备时所有已安装剧情包；移除其中任何一个都会阻止恢复，即使尚未播放。没有执行游标迁移或二进制差分更新。
+- 默认软阈值从 P3 的 64 MiB 经 P6 观测调到 32 MiB；Archive 仍整片缓冲，不保证低内存设备。流式读写可另开后续工作。
+- 资源补丁不按语言匹配，不热装卸；新建安装会话采用包变化，已持有 handle 不原地改变。依赖同 ID 不同内容须分配新 ID。
+- Gallery 补丁按约定延期，既有 Gallery 资源仍属于基础根。UI/动态代码资源需显式根，不以运行时是否走到某分支裁剪。
+
+## 当前文档
+
+- [作者操作](../../docs/manual/content-packaging.md)
+- [资源契约](../../docs/spec/assets.md)
+- [发布格式](../../docs/spec/file-formats.md)
+- [运行时与存档](../../docs/spec/runtime.md)
+- [文本边界](../../docs/spec/i18n.md)
+- [Sample 章节与首页扩展](../../docs/manual/customize-avalonia-sample.md)
+
+每阶段独立 Git 提交：P1 `a3ae72bd`、P2 `a7f08962`、P3 `f97bca72`、P4 `5b2c1a74`、P5 `043638d9`；P6 为本记录所在的最终收尾提交。
diff --git a/features/F-20261028-01-content-packaging/verification/Program.cs b/features/F-20261028-01-content-packaging/verification/Program.cs
new file mode 100644
index 00000000..8a2c5da4
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/verification/Program.cs
@@ -0,0 +1,64 @@
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Assets.Provider;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Core.Assets;
+
+if (JsonSerializer.IsReflectionEnabledByDefault) throw new Exception("Reflection JSON was not disabled.");
+var types = BuiltinResourceTypes.CreateCatalog();
+var root = Path.Combine(Path.GetTempPath(), "galnet-p1-reflection-" + Guid.NewGuid().ToString("N"));
+Directory.CreateDirectory(Path.Combine(root, "images"));
+try
+{
+    File.WriteAllText(Path.Combine(root, "images/idle.png"), "sprite");
+    File.WriteAllText(Path.Combine(root, "images/idle.png.meta"), """{"id":"sprite","type":"sprite"}""");
+    File.WriteAllText(Path.Combine(root, "atlas.variants"), """{"folder":"images","default":"idle"}""");
+    File.WriteAllText(Path.Combine(root, "atlas.variants.meta"), """{"id":"atlas","type":"image-variants"}""");
+    using var provider = new LocalFileProvider(root, types);
+    using var local = await provider.OpenArchiveAsync("assets");
+    var closure = AssetDependencyCollector.Collect(local.AssetIds.Select(id => local.GetAsset(id)!), ["atlas"], types);
+    if (!closure.Complete || closure.Files.Count != 2) throw new Exception("Incomplete dependency closure.");
+    foreach (var kind in new[] { "base", "story", "override" })
+    {
+        var control = new PakDescriptor { Kind = kind, ProjectId = "game", BuildId = "build", PackageId = kind == "base" ? "" : "extra", Mappings = kind == "override" ? new() { ["original"] = "atlas" } : [] };
+        using var restored = Archive.Deserialize("assets", PakBuilder.Build("assets", closure.Files, types, descriptor: control), types);
+        if (restored.Descriptor.Kind != kind || ((IAssetDependencies)restored.GetAsset("atlas")!.Metadata).GetDependencies().Direct.Count != 1) throw new Exception("Metadata/control roundtrip failed.");
+    }
+    Console.WriteLine("P1_REFLECTION_OFF_OK kinds=3 dependencies=2 reflectionJson=false");
+    var story = CompiledStoryResources.Create(System.Text.Encoding.UTF8.GetBytes("""
+        {"name":"single","rootNodeId":"main","nodes":[{"id":"main","type":"Group"}],"edges":[],
+         "saveVariables":[{"name":"chapter","defaultValue":{"Uid":"chapter-id","Name":"chapter","Type":1,"Value":1},"type":"Int"}]}
+        """), _ => GalNet.Core.Serialization.JsonCodec.SerializeToUtf8Bytes(new GalNet.Core.Serialization.CompiledGroupDocument()));
+    using var storyPak = Archive.Deserialize("assets", PakBuilder.Build("assets", story, types), types);
+    var loadedGraph = GalNet.Runtime.Loader.GraphLoader.LoadFromJson(System.Text.Encoding.UTF8.GetString(storyPak.GetAsset(StoryResourceIds.Graph)!.ReadAllBytes()));
+    var runtime = new GalNet.Runtime.Runtime.GameRuntime(null, loadedGraph.RootNodeId, saveDefaults: loadedGraph.SaveVariables);
+    if (loadedGraph.Id != StoryResourceIds.Graph || storyPak.GetAsset(StoryResourceIds.Group("main"))?.TypeId != "group"
+        || runtime.GetVariable("chapter")?.AsInt() != 1) throw new Exception("Story resource/default variable roundtrip failed.");
+    Console.WriteLine("P2_STORY_REFLECTION_OFF_OK graph=galnet:graph:main groups=1 saveDefault=1");
+    var original = new GameFile("original", "original.png", "sprite", new SpriteAssetMeta { Id = "original", Path = "original.png", TypeId = "sprite" }, "old"u8.ToArray());
+    var definition = new GalNet.Core.Configuration.ResourceOverrideDefinition { Id = "clothes", Mappings = new() { ["original"] = "sprite" } };
+    definition = GalNet.Core.Serialization.JsonCodec.Deserialize<GalNet.Core.Configuration.ResourceOverrideDefinition>(GalNet.Core.Serialization.JsonCodec.Serialize(definition))!;
+    var overrideBytes = ResourceOverrideBuilder.Build("game", definition, [original, local.GetAsset("sprite")!], types);
+    var overridePath = Path.Combine(root, "clothes.pak"); File.WriteAllBytes(overridePath, overrideBytes);
+    var originalPath = Path.Combine(root, "base.pak"); File.WriteAllBytes(originalPath, PakBuilder.Build("assets", [original], types));
+    var baseProvider = new PakFileProvider(originalPath, "assets", types);
+    var overrideProvider = new PakFileProvider(overridePath, "assets", types);
+    using var overlayPak = overrideProvider.OpenArchive("assets");
+    using var assets = new AssetManager([new ResourceOverlayProvider([new(original, baseProvider)],
+        [new(((IPakArchive)overlayPak).Descriptor, CryptoHelper.HashSHA256(overrideBytes), overlayPak.AssetIds.Select(id => new ResourceFileSource(overlayPak.GetAsset(id)!, overrideProvider)).ToArray())], types)]);
+    using var replaced = await assets.AcquireAsync<string>("original");
+    if (replaced?.Value != "sprite") throw new InvalidDataException("Override reflection-off roundtrip failed.");
+    Console.WriteLine("P4_OVERRIDE_REFLECTION_OFF_OK original=sprite");
+    var layer = new GalNet.Contracts.Builtins.Scene.Layer { Id = "hero", AssetId = "sprite",
+        Variants = new() { AssetId = "atlas", VariantKey = "idle", UsesResourceOverride = true } };
+    var layerJson = JsonSerializer.Serialize(new[] { layer }, GalNet.Contracts.Builtins.BuiltinJson.StateTypeInfo<GalNet.Contracts.Builtins.Scene.Layer>());
+    var layerCopy = JsonSerializer.Deserialize(layerJson, GalNet.Contracts.Builtins.BuiltinJson.StateTypeInfo<GalNet.Contracts.Builtins.Scene.Layer>())!;
+    var configuration = new GalNet.Core.Configuration.ProjectConfiguration();
+    definition.Name = "Clothes";
+    configuration.Set(GalNet.Core.Configuration.ResourceOverrideOptions.Section, new() { Packages = [definition] });
+    var configurationCopy = GalNet.Core.Serialization.JsonCodec.Deserialize<GalNet.Core.Configuration.ProjectConfiguration>(GalNet.Core.Serialization.JsonCodec.Serialize(configuration))!;
+    if (layerCopy[0].Variants?.UsesResourceOverride != true || configurationCopy.Read(GalNet.Core.Configuration.ResourceOverrideOptions.Section).Packages[0].Mappings["ORIGINAL"] != "sprite")
+        throw new InvalidDataException("Override author/snapshot metadata requires reflection JSON.");
+    Console.WriteLine("P6_OVERRIDE_STATE_REFLECTION_OFF_OK");
+}
+finally { Directory.Delete(root, true); }
diff --git a/features/F-20261028-01-content-packaging/verification/ReflectionOff.csproj b/features/F-20261028-01-content-packaging/verification/ReflectionOff.csproj
new file mode 100644
index 00000000..95a1d5ae
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/verification/ReflectionOff.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <JsonSerializerIsReflectionEnabledByDefault>false</JsonSerializerIsReflectionEnabledByDefault>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../../src/Shared/GalNet.Assets/GalNet.Assets.csproj" />
+    <ProjectReference Include="../../../src/Shared/GalNet.Runtime/GalNet.Runtime.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/features/F-20261028-01-content-packaging/verification/packages.lock.json b/features/F-20261028-01-content-packaging/verification/packages.lock.json
new file mode 100644
index 00000000..f714a650
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/verification/packages.lock.json
@@ -0,0 +1,51 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Serilog": {
+        "type": "CentralTransitive",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/features/F-20261028-01-content-packaging/verification/ui/resource-patches-refined.png b/features/F-20261028-01-content-packaging/verification/ui/resource-patches-refined.png
new file mode 100644
index 00000000..3790e99b
Binary files /dev/null and b/features/F-20261028-01-content-packaging/verification/ui/resource-patches-refined.png differ
diff --git a/features/F-20261028-01-content-packaging/verification/ui/resource-patches.png b/features/F-20261028-01-content-packaging/verification/ui/resource-patches.png
new file mode 100644
index 00000000..0ecfaf40
Binary files /dev/null and b/features/F-20261028-01-content-packaging/verification/ui/resource-patches.png differ
diff --git a/features/F-20261028-01-content-packaging/verification/validation-results.json b/features/F-20261028-01-content-packaging/verification/validation-results.json
new file mode 100644
index 00000000..05adb0e1
--- /dev/null
+++ b/features/F-20261028-01-content-packaging/verification/validation-results.json
@@ -0,0 +1,172 @@
+{
+  "schemaVersion": 1,
+  "passed": true,
+  "phase": "P6",
+  "sdk": "10.0.401",
+  "configuration": "Release",
+  "initialFullRun": {
+    "source": "out/ci/content-packaging-p6/ci-results.json",
+    "failedChecks": [
+      "GalNet.Architecture.Tests",
+      "GalNet.SchemaGenerator.Tests"
+    ],
+    "resolvedBy": "Targeted final rechecks after fixes; initial failures retained."
+  },
+  "finalFormat": {
+    "passed": true,
+    "source": "out/ci/content-packaging-p6-final-format/ci-results.json"
+  },
+  "finalSolutionBuild": {
+    "passed": true,
+    "warnings": 386,
+    "errors": 0,
+    "elapsed": "00:03:40.32"
+  },
+  "defaultSuiteProjects": 15,
+  "defaultSuitePassed": 2064.0,
+  "suites": [
+    {
+      "project": "GalNet.Architecture.Tests",
+      "passed": 52,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6-recheck/test-results/GalNet.Architecture.Tests.trx"
+    },
+    {
+      "project": "GalNet.Assets.Tests",
+      "passed": 103,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.Assets.Tests.trx"
+    },
+    {
+      "project": "GalNet.Core.Tests",
+      "passed": 139,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6-recheck/test-results/GalNet.Core.Tests.trx"
+    },
+    {
+      "project": "GalNet.Debugging.Tests",
+      "passed": 10,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.Debugging.Tests.trx"
+    },
+    {
+      "project": "GalNet.Diagnostics.Tests",
+      "passed": 1,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.Diagnostics.Tests.trx"
+    },
+    {
+      "project": "GalNet.Editor.Shared.Tests",
+      "passed": 476,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6-recheck/test-results/GalNet.Editor.Shared.Tests.trx"
+    },
+    {
+      "project": "GalNet.Editor.Tests",
+      "passed": 345,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.Editor.Tests.trx"
+    },
+    {
+      "project": "GalNet.GameHost.Tests",
+      "passed": 8,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.GameHost.Tests.trx"
+    },
+    {
+      "project": "GalNet.IntegrationTests",
+      "passed": 138,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6-recheck/test-results/GalNet.IntegrationTests.trx"
+    },
+    {
+      "project": "GalNet.Media.Audio.Tests",
+      "passed": 26,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.Media.Audio.Tests.trx"
+    },
+    {
+      "project": "GalNet.Presentation.Tests",
+      "passed": 276,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.Presentation.Tests.trx"
+    },
+    {
+      "project": "GalNet.Primitives.Builtins.Tests",
+      "passed": 322,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.Primitives.Builtins.Tests.trx"
+    },
+    {
+      "project": "GalNet.Runtime.Tests",
+      "passed": 124,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.Runtime.Tests.trx"
+    },
+    {
+      "project": "GalNet.SchemaGenerator.Tests",
+      "passed": 20,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6-recheck/test-results/GalNet.SchemaGenerator.Tests.trx"
+    },
+    {
+      "project": "GalNet.Storage.FileSystem.Tests",
+      "passed": 24,
+      "failed": 0,
+      "notExecuted": 0,
+      "source": "out/ci/content-packaging-p6/test-results/GalNet.Storage.FileSystem.Tests.trx"
+    }
+  ],
+  "additionalChecks": [
+    {
+      "name": "Final mounted Editor authoring checks",
+      "passed": 3,
+      "source": "out/ci/content-packaging-p6-recheck/test-results/GalNet.Editor.Tests.trx"
+    },
+    {
+      "name": "Debug snapshot factories",
+      "passed": 2,
+      "source": "out/ci/content-packaging-p6-native/NativeAndSnapshot.trx"
+    },
+    {
+      "name": "Native packaged Sample explicit test",
+      "passed": 1,
+      "source": "out/ci/content-packaging-p6-native/NativeSample.trx"
+    },
+    {
+      "name": "Reflection-disabled JSON",
+      "passed": true,
+      "markers": [
+        "P1_REFLECTION_OFF_OK",
+        "P2_STORY_REFLECTION_OFF_OK",
+        "P4_OVERRIDE_REFLECTION_OFF_OK",
+        "P6_OVERRIDE_STATE_REFLECTION_OFF_OK"
+      ]
+    },
+    {
+      "name": "Default large-resource membership and memory",
+      "passed": true,
+      "source": "../memory-probe/result.json"
+    }
+  ],
+  "notes": [
+    "Suite evidence combines the initial full run with final affected-suite rechecks.",
+    "Eight default-run Explicit/environment cases were not executed; the packaged native Sample was separately selected and passed in Debug.",
+    "Archive remains buffered; the PAK size target is not a memory guarantee."
+  ],
+  "completedUtc": "2026-10-28T14:28:38.8897455Z"
+}
diff --git a/features/F-20261029-01-desktop-package-layout/design.md b/features/F-20261029-01-desktop-package-layout/design.md
new file mode 100644
index 00000000..511b5bab
--- /dev/null
+++ b/features/F-20261029-01-desktop-package-layout/design.md
@@ -0,0 +1,23 @@
+# 设计
+
+这是涉及归档布局和多入口发行的普通分阶段实现，不采用快速通道压缩验证。
+
+## 内容
+
+galpak v2 全部 ZIP 内容位于 pak/；manifest 本身位于 pak/<name>.galnet，但 Files 中路径仍相对内容根。PAK/content/save 格式与构建身份算法不因运输外层改变。v1 平铺包继续读取。显式安装目标始终代表内容根；v2 默认目标为归档旁 pak，返回实际内容根，不追加第二层 pak。目录导出的显式输出同样代表内容根，发行脚本传入 <app>/pak。
+
+剧情分片保持独立分发；整合发行将匹配的外部 StoryPatches/ResourcePatches 合入 pak。所有内容校验和拒绝覆盖原则保留。新版归档拒绝 pak 之外载荷、混合布局和重复 ZIP 路径。
+
+## 启动与玩家数据
+
+Sample 显式分离应用根与托管程序集根；发布后依赖目录是 lib，pak 相对应用根定位，与工作目录无关。开发版可覆盖内容与 profile；玩家版不编译通用参数解析。EnableLaunchArguments 默认跟随 EnableGameDebugging，两个符号保持独立，调试接入要求参数能力。
+
+默认 profile 位于用户 LocalApplicationData/GalNet/<project identity digest>；已打包内容使用 content.json 的 projectId，不包含 buildId 或安装路径；开发内容缺少身份时使用目录身份。无有效身份的启动失败使用独立默认日志目录，内容错误由窗口原有启动错误流程报告。旧 profile 不自动迁移。平台共享会话默认策略不变，由 Sample 组合根显式传入 profile。
+
+## 发行
+
+使用 SDK CreateAppHost 任务生成目标为 lib/<app>.dll 的原生启动器，整个依赖树移动至 lib，不引入第二个进程或托管解析器。Editor/CLI 两个入口共用同一个 lib，保留编译产物契约字节。DefaultContracts 随程序集位于 lib；作者 Skill 保留根 Skills。docs 保存 LICENSE、README、release-manifest（路径仍相对应用根）。
+
+发布入口提供 Player/Developer 两种 SampleFlavor，均使用 Release 优化编译；Developer 开启调试与参数并保留 PDB，产物名称和清单显式区分。正式 Release 默认 Player。不更改三份契约 IL 的编译条件。
+
+先验证 apphost 子目录定位及原生库，再验收两种部署，避免仅验证托管代码能编译。macOS/Linux 目录策略保留组合根可扩展性，本轮仅承诺 Windows 发行。
diff --git a/features/F-20261029-01-desktop-package-layout/feature.md b/features/F-20261029-01-desktop-package-layout/feature.md
new file mode 100644
index 00000000..c5681c53
--- /dev/null
+++ b/features/F-20261029-01-desktop-package-layout/feature.md
@@ -0,0 +1,10 @@
+# 桌面发行目录与统一 pak 内容根
+
+- 状态：verified（本地实现与范围内验证完成）
+- 授权：用户确认目录、galpak 外层 pak、开发/玩家构建方案后要求开始实现。
+- 目标：应用根只含入口 EXE 和目录；依赖置于 lib，说明/许可证/发行清单置于 docs；Sample 双击加载同级 pak。
+- 范围：galpak v2 的 pak/ 外层、v1 读取兼容、安装器、Sample 参数编译开关和用户 profile、Windows 发行脚本与验收、开发包。
+- 非目标：体积优化、裁减媒体能力、AOT、移动端发行、自动迁移或删除旧存档。
+- 验收：新包普通解压与安装得到一致内容；安装不产生 pak/pak，不覆盖不同内容；两种 .NET 部署均能从不同工作目录启动；开发包能解析参数并编入调试，玩家包默认固定 pak；项目 profile 不依赖安装位置或 buildId；契约字节身份保持。
+- 设计：[design.md](design.md)；阶段：[phase-plan.md](phase-plan.md)。
+- 无待用户确认阻塞；旧包兼容读取，旧用户数据保留，新布局不自动覆盖已有内容。
diff --git a/features/F-20261029-01-desktop-package-layout/phase-plan.md b/features/F-20261029-01-desktop-package-layout/phase-plan.md
new file mode 100644
index 00000000..0ac1b93b
--- /dev/null
+++ b/features/F-20261029-01-desktop-package-layout/phase-plan.md
@@ -0,0 +1,18 @@
+# 实施阶段
+
+| 阶段 | 内容与验证 | 状态 |
+| --- | --- | --- |
+| P1 | galpak v2 导出/校验/安装、旧包兼容；集成覆盖普通解压、安装复用、损坏/混合路径拒绝与剧情包 | verified |
+| P2 | Sample 应用根、参数开关、用户 profile；开发/玩家/独立参数模式构建与启动策略测试 | verified |
+| P3 | lib/docs/pak 发行布局、SDK apphost、开发包；两种部署的真实解压 CLI/桌面启动和清单校验 | verified |
+| P4 | 正式文档与总结、diff/格式检查、记录已验证事实与限制 | verified |
+
+每阶段退出需要相应验证通过；构建完成后再运行同输出根的 no-build 测试。过程日志与产物写入 out/package-layout/，不上传、不创建 tag。
+
+- P1/P2 首轮：archive-player.trx 25 passed；integration-player.trx 154 passed；developer.trx 7 passed（含实际子进程契约不匹配退出）。
+- 初次构建因 Avalonia telemetry 在用户目录写日志被沙箱拒绝；设置 AVALONIA_TELEMETRY_OPTOUT=1 后通过，未修改第三方目标或产品行为。
+- 最终玩家完整回归：final-player.trx 154 passed；独立参数开关：arguments-only.trx 6 passed；错误开关组合：invalid-capabilities.log 明确拒绝。
+- 发行：release/0.1.0-dev.42/ 生成并验收 7 ZIP；desktop-smoke/app-validation.json 两种部署 passed=true，实际无参数从不同工作目录加载 pak。
+- 开发包：developer/0.1.0-dev.43/；published-native-confirmed.trx 5 passed，其中 3 项使用该 ZIP 的真实 EXE 调试并正常退出，2 项加载两种实际整合包的 Graph/资源。
+- galpak 集成：galpak-integration-final/verification.json 与 galpak-winps/verification.json 均通过；实际导出独立剧情包，调用发布脚本原函数安装并归并，验证不复制其他 buildId。分别运行于 PowerShell 7 和 Windows PowerShell 5.1。
+- 发布保护 7 项、修改文件 whitespace/IDE0005 通过；dotnet format 初次因沙箱命名管道失败，允许本机进程通信后通过。
diff --git a/features/F-20261029-01-desktop-package-layout/review.md b/features/F-20261029-01-desktop-package-layout/review.md
new file mode 100644
index 00000000..9075550d
--- /dev/null
+++ b/features/F-20261029-01-desktop-package-layout/review.md
@@ -0,0 +1,12 @@
+# 实现自检
+
+- 结论：pass。
+- 范围：执行者对照已确认需求、设计和实际 diff 自检；未声称由独立 agent 审核。
+
+检查了 galpak 运输前缀与内容逻辑路径分离、v1 读取兼容、唯一 manifest/重复条目/混合布局/校验和拒绝；安装目标只代表内容根，已有不同内容不覆盖。检查应用根与程序集根、用户 profile 的稳定身份，以及玩家/开发/独立参数的编译边界。
+
+两种 .NET 部署的分发 CLI、实际 Editor 与 Sample apphost 均运行，确认 lib 下的运行时和原生依赖布局可用；契约闭包仍字节相同。开发 ZIP 的三种原生调试用例完成连接、运行、变量编辑、seek/step、停止和正常关闭，并验证玩家变量落盘。两种实际 GameTestCase 组合包经运行时加载 Graph/资源。发布脚本原 Add-GameContent 函数经真实 galpak 与外部剧情包验证，兼容 Windows PowerShell 5.1。
+
+没有发现阻止本范围交付的问题。初次原生测试只发送 WM_CLOSE，退出遮罩使其超时；修正测试后相同 ZIP 三项通过，没有改变产品退出策略。另修正了原有发布验收的过时 loose Graph/Group 假设，与已实现的 PAK 剧情布局一致。
+
+限制：本轮不验证完整 GameTestCase 剧情、所有音视频格式、原生窗口视觉或其他操作系统；没有进行完整解决方案 CI、NuGet 重打包、体积或性能测量。旧 profile 不自动迁移。具体证据见 [summary.md](summary.md)。
diff --git a/features/F-20261029-01-desktop-package-layout/summary.md b/features/F-20261029-01-desktop-package-layout/summary.md
new file mode 100644
index 00000000..52e4f468
--- /dev/null
+++ b/features/F-20261029-01-desktop-package-layout/summary.md
@@ -0,0 +1,42 @@
+# 桌面发行目录与统一 pak 内容根
+
+日期：2026-10-29。状态：实现与范围内验证完成；仅本地候选，没有上传或创建 tag。
+
+## 实际行为
+
+- Windows 应用根只保留入口 EXE 与目录。SDK 原生 apphost 指向 lib/<app>.dll，托管库、运行时配置、.NET 自包含运行时及原生依赖都在 lib；说明、许可与发行清单在 docs。Editor 与 CLI 共用一个 lib，作者 Skill 留在根 Skills，默认作者契约在 lib/DefaultContracts。
+- Sample 无参数加载应用同级 pak，不受当前工作目录影响。游戏内容缺失/损坏沿现有窗口启动错误流程报告。默认 profile 位于用户 LocalApplicationData/GalNet/<project identity digest>，打包目录中 content.json 的 projectId 决定身份，安装位置和 buildId 不参与。没有自动迁移/删除旧数据。
+- EnableLaunchArguments / GALNET_LAUNCH_ARGS 独立控制普通参数，默认跟随 EnableGameDebugging。游戏调试要求参数开关开启；玩家构建拒绝参数，开发构建可覆盖内容/profile。基准脚本显式开启普通参数，保留 Release 基准用法。
+- Publish.ps1、Release.ps1 提供 SampleFlavor Player/Developer。默认玩家版排除调试工具、参数解析与 PDB；开发版保持 Release 优化，保留调试及符号，文件名追加 -developer。开发 R2R 恢复图有独立锁文件，契约 IL 的编译规则不变。
+- 新 galpak v2 所有 ZIP 条目在 pak/，manifest.Files 和运行时内容路径仍相对内容根；安装显式目标不再追加目录，默认 v2 安装到归档旁 pak。旧 v1 平铺包仍读取并保留原默认安装目标。重复/越界/根外/未声明载荷拒绝，已有不同安装不覆盖。
+- 目录导出和整合发行的目标直接是 pak。galpak 旁匹配 buildId 的 StoryPatches 与 ResourcePatches 合入内容根，其他剧情构建不复制。内容/PAK/save 版本与构建身份算法没有因运输外层变更。
+
+## 验证证据
+
+| 验证 | 结果与证据 |
+| --- | --- |
+| 归档、安装、剧情包和玩家启动策略首轮 | 25 passed，out/package-layout/tests/archive-player.trx |
+| 最终玩家完整集成回归 | 154 passed，out/package-layout/tests/final-player.trx |
+| Release 开发能力与契约错误子进程 | 7 passed，out/package-layout/tests/developer.trx |
+| 无游戏调试的独立参数模式 | 6 passed，out/package-layout/tests/arguments-only.trx |
+| 禁用参数却开启调试 | 构建门禁明确拒绝，out/package-layout/invalid-capabilities.log |
+| 两种部署完整 Apps 发行 | 7 ZIP，out/package-layout/release/0.1.0-dev.42/release-index.json |
+| 解压清单、契约身份、R2R、原生载荷和分发 CLI | release 的 app-validation passed=true |
+| 两种 Editor/玩家真实桌面启动 | out/package-layout/desktop-smoke/app-validation.json passed=true, desktopStartup=true；不同工作目录与含空格安装路径，无参数加载唯一测试项目，测试 profile 已清理 |
+| 实际开发包三种原生调试场景 + 两种 GameTestCase 内容加载 | 5 passed，out/package-layout/tests/published-native-confirmed.trx |
+| 开发包符号、调试依赖、文件哈希 | out/package-layout/developer-extracted/docs/release-manifest.json；ZIP 位于 developer/0.1.0-dev.43 |
+| 发布原函数处理 galpak/外部剧情目录 | out/package-layout/galpak-integration-final/verification.json 与 galpak-winps/verification.json，PowerShell 7/5.1 均通过 |
+| 发布保护 | 7 passed，out/package-layout/guards/guard-results.json |
+| 修改 C# whitespace / IDE0005 | format-whitespace.log、format-imports.log 均退出 0；脚本语法与 git diff --check 通过 |
+
+原生调试验证使用开发 ZIP 的实际 EXE 与其中的契约指纹，覆盖标题连接、开始、变量修改、定位/步进、停止、重开运行、拒绝旧运行、退出确认、零退出码和玩家变量持久化。桌面 smoke 使用独立导出的唯一项目；GameTestCase 的两个实际内容目录另外通过运行时加载，不把 smoke 当作完整剧情验收。
+
+## 偏差、修正与限制
+
+首次构建的 Avalonia telemetry 用户日志写入、首次 format 的本机命名管道受沙箱限制；分别设置 telemetry opt-out 与允许本机验证后通过。没有修改第三方任务来掩盖问题。
+
+原生关闭测试尚未适配已存在的退出确认遮罩，初次三项失败；补充在自有 HWND 的真实确认后，相同开发 ZIP 全部通过。经验见 .agents/lessons/L-20261029-06-native-exit-confirmation.md。发布验收还移除了历史 loose Graph/Group 预期，改为检查当前 content v2 与 PAK 布局。
+
+本轮不做体积优化、AOT、其他平台发行；未跑完整解决方案 CI 或重新打 NuGet，没有完整剧情/所有音视频格式/原生视觉验收。未用 ACL 实测只读安装目录，但已将玩家写入显式移出安装内容，并验证不产生 pak/.galnet。旧 profile 和旧安装内容不自动搬移或覆盖。
+
+正式说明已同步到 docs/spec/file-formats.md、architecture.md、docs/glossary.md，以及 docs/manual/release-packaging.md、content-packaging.md、customize-avalonia-sample.md、external-game-debugging.md、cpu-benchmark.md。
diff --git a/features/F-20261029-01-desktop-package-layout/verification/Test-GalpakIntegration.ps1 b/features/F-20261029-01-desktop-package-layout/verification/Test-GalpakIntegration.ps1
new file mode 100644
index 00000000..2cd1aa80
--- /dev/null
+++ b/features/F-20261029-01-desktop-package-layout/verification/Test-GalpakIntegration.ps1
@@ -0,0 +1,76 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Cli,
+    [Parameter(Mandatory)][string]$Contracts,
+    [Parameter(Mandatory)][string]$WorkDirectory
+)
+$ErrorActionPreference = 'Stop'
+$Cli = [IO.Path]::GetFullPath($Cli)
+$Contracts = [IO.Path]::GetFullPath($Contracts)
+$WorkDirectory = [IO.Path]::GetFullPath($WorkDirectory)
+if (Test-Path -LiteralPath $WorkDirectory) { throw 'Use a new verification directory.' }
+New-Item -ItemType Directory -Path $WorkDirectory | Out-Null
+$repository = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../..'))
+$scriptPath = Join-Path $repository 'scripts/release/Publish.ps1'
+$parseErrors = $null
+$ast = [Management.Automation.Language.Parser]::ParseFile($scriptPath, [ref]$null, [ref]$parseErrors)
+if ($parseErrors.Count) { throw 'Publish script does not parse.' }
+# Load the actual packaging helpers without running the build/publish entry point.
+foreach ($name in @('Get-RelativePath', 'Copy-ContentTree', 'Add-GameContent')) {
+    $definition = $ast.FindAll({ param($node) $node -is [Management.Automation.Language.FunctionDefinitionAst] -and $node.Name -eq $name }, $false)
+    . ([scriptblock]::Create($definition.Extent.Text))
+}
+$headlessProject = 'unused-build-project'
+function Invoke-DotNet([string[]]$Arguments) {
+    $separator = [Array]::IndexOf($Arguments, '--')
+    if ($separator -lt 0 -or $Arguments[$separator + 1] -ne 'galpak' -or $Arguments[$separator + 2] -ne 'install') {
+        throw 'This verification may only run the distributed galpak installer.'
+    }
+    & $Cli @($Arguments[($separator + 1)..($Arguments.Length - 1)]) | Out-Null
+    if ($LASTEXITCODE) { throw 'Distributed installation failed.' }
+}
+function Invoke-Cli([string[]]$Arguments) {
+    $output = & $Cli @Arguments
+    if ($LASTEXITCODE) { $output | Write-Host; throw "CLI failed: $Arguments" }
+}
+$project = Join-Path $WorkDirectory 'StoryFixture'
+Invoke-Cli @('project', 'create', $project, '--contracts', $Contracts)
+foreach ($generated in Get-ChildItem -LiteralPath (Join-Path $project 'Graph/groups') -Filter '*.rawgalgroup' -File) {
+    Remove-Item -LiteralPath $generated.FullName
+}
+@'
+{"version":2,"name":"Story","rootNodeId":"base","nodes":[{"id":"base","name":"Base","type":"Group","file":"groups/base.rawgalgroup"},{"id":"chapter","name":"Chapter","type":"Group","file":"groups/chapter.rawgalgroup","storyPackage":"extra"},{"id":"end","name":"End","type":"Group","file":"groups/end.rawgalgroup"}],"edges":[{"id":"first","fromNodeId":"base","fromOutlet":0,"toNodeId":"chapter"},{"id":"second","fromNodeId":"chapter","fromOutlet":0,"toNodeId":"end"}],"playerVariables":[],"saveVariables":[]}
+'@ | Set-Content -LiteralPath (Join-Path $project 'Graph/graph.json') -Encoding utf8
+New-Item -ItemType Directory -Force -Path (Join-Path $project 'Graph/groups') | Out-Null
+foreach ($group in @('base', 'chapter', 'end')) {
+    '{"version":2,"kind":"Raw","entries":[]}' | Set-Content -LiteralPath (Join-Path $project "Graph/groups/$group.rawgalgroup") -Encoding utf8
+}
+$packages = Join-Path $WorkDirectory 'packages'
+Invoke-Cli @('export', $project, '--output', $packages)
+$Galpak = (Get-ChildItem -LiteralPath $packages -Filter '*.galpak').FullName
+$zip = [IO.Compression.ZipFile]::OpenRead($Galpak)
+try {
+    $reader = [IO.StreamReader]::new($zip.GetEntry('pak/content.json').Open())
+    try { $content = $reader.ReadToEnd() | ConvertFrom-Json } finally { $reader.Dispose() }
+}
+finally { $zip.Dispose() }
+$storyFiles = @(Get-ChildItem -LiteralPath (Join-Path $packages "StoryPatches/$($content.buildId)") -Filter '*.pak' -File)
+if (!$storyFiles.Count) { throw 'Fixture did not produce external story PAKs.' }
+$unrelatedBuild = 'b' * 64
+New-Item -ItemType Directory -Path (Join-Path $packages "StoryPatches/$unrelatedBuild"), (Join-Path $packages 'ResourcePatches') | Out-Null
+'unrelated build' | Set-Content (Join-Path $packages "StoryPatches/$unrelatedBuild/unused.txt")
+'external resource package notes' | Set-Content (Join-Path $packages 'ResourcePatches/notes.txt')
+$payload = Join-Path $WorkDirectory 'payload'
+New-Item -ItemType Directory -Path $payload | Out-Null
+Add-GameContent $WorkDirectory $payload $Contracts
+$installed = Join-Path $payload 'pak'
+if ((Test-Path (Join-Path $installed 'pak')) -or !(Test-Path (Join-Path $installed 'content.json'))) { throw 'Incorrect content root.' }
+foreach ($file in $storyFiles) {
+    $copied = Join-Path $installed "StoryPatches/$($content.buildId)/$($file.Name)"
+    if ((Get-FileHash -LiteralPath $copied).Hash -ne (Get-FileHash -LiteralPath $file.FullName).Hash) { throw 'Story package changed.' }
+}
+if (Test-Path (Join-Path $installed "StoryPatches/$unrelatedBuild")) { throw 'Copied another build.' }
+if (!(Test-Path (Join-Path $installed 'ResourcePatches/notes.txt'))) { throw 'Missing external resource package directory.' }
+[ordered]@{ passed = $true; storyParts = $storyFiles.Count; contentRoot = $installed; unrelatedBuildExcluded = $true } |
+    ConvertTo-Json | Set-Content -LiteralPath (Join-Path $WorkDirectory 'verification.json') -Encoding utf8
+Write-Host "Galpak integration passed: $installed"
diff --git a/features/F-20261029-02-packed-game-documents/design.md b/features/F-20261029-02-packed-game-documents/design.md
new file mode 100644
index 00000000..206c0959
--- /dev/null
+++ b/features/F-20261029-02-packed-game-documents/design.md
@@ -0,0 +1,21 @@
+# 设计
+
+## 文档容器
+
+复用 GPAK v3、现有压缩/逐项 SHA-256 和元数据编码，不新增 BSON 或第二种二进制格式。文档包使用独立固定的 document 类型目录和保留逻辑路径，不贡献普通资源 provider，因此资源覆盖包不能替换配置、人物或内置文本。game.pak/localization.pak 的控制身份必须和包内 content 描述一致。
+
+game.pak 保存 content.json（新导出 version=3）、settings.json、gallery.json、characters.json、packaging-layout.json 与 installation.json（运输清单 version=3）。content 描述仍声明基础/剧情分片及其哈希，新增 localization.pak 的完整文件描述。localization.pak 内每文化一个 texts/<culture>.json 平铺文本字典。作者多文件维持原路径 ordinal 覆盖次序；JSON 紧凑编码后由 GPAK 压缩。空语言集也生成有效空语言包。
+
+galpak v3 ZIP 仍统一 pak/ 外层，唯一固定入口为 pak/game.pak；运输清单位于其内部，列出其余文件（避免自哈希循环）。game.pak 自身通过 GPAK 表项校验，安装复用还比较完整入口文件。新输出运输清单使用固定时间，避免同内容重复导出的入口包非确定性；发行时间由发行清单承担。旧 v1/v2 的顶层或 pak/<name>.galnet 路径保持读取兼容。旧 content v2 继续按散文件加载，发现 game.pak 时不回退。
+
+## 本地化与扩展目录
+
+新安装的内置人物和文本仅从包读取；外置 I18n/<culture>/**/*.json 全部是可选重载，不使用 External 层。开发目录和旧安装仍保持 I18n 内置 + I18n/External 的旧规则。默认语言完整性只检查内置源；外置来源损坏记录诊断并跳过，文化回退/来源顺序沿用当前 resolver。
+
+打包与安装始终生成 I18n/、ResourcePatches/、StoryPatches/<当前 buildId>/，ZIP 显式保存空目录。启动不创建安装目录中的文件。相同安装复用保留外置翻译和补丁，不覆盖不同内容。
+
+## 接入
+
+文档编解码归 Assets；文件定位和安装归 Storage.FileSystem；GameHost/Runtime 继续消费既有中立内容对象。Sample 使用同一个入口读取器取得 projectId，保持 profile 摘要规则。给分发 CLI 增加只读 game inspect，以便 PowerShell 5.1/7 脚本读取身份而不重复实现 GPAK 或加载玩家 DLL。
+
+当前仍保留整片读取语义，不宣称按语言分条目已实现按需 I/O。新打包布局标记进入 buildId，因此旧存档不会被误认为同一个内容构建；存档版本和资源 PAK 版本不变。
diff --git a/features/F-20261029-02-packed-game-documents/feature.md b/features/F-20261029-02-packed-game-documents/feature.md
new file mode 100644
index 00000000..621dc851
--- /dev/null
+++ b/features/F-20261029-02-packed-game-documents/feature.md
@@ -0,0 +1,9 @@
+# 内置内容封装与外置翻译入口
+
+- 状态：implemented-with-follow-up。范围内实现、回归与发行载荷已验证；两种玩家部署均有实际初始化成功证据。组合桌面 smoke 中的偶发字体原生崩溃另保留跟进，不宣称完整桌面验收全绿。
+- 授权：用户确认整理后的六项范围，并要求先提交上一轮再开始；上一轮提交为 86cc021b。
+- 目标：玩家内容目录不分发内部 JSON；game.pak 为固定入口，localization.pak 按语言封装内置文本；I18n 仅供外置覆盖；始终提供空补丁/翻译目录。
+- 范围：导出/安装/运行加载/profile 身份/发行脚本及兼容、相关测试和文档。
+- 非目标：BSON、加密、防提取、资源裁剪、AOT、热更新、通用版本升级协议。
+- 验收：直接目录导出、galpak 普通解压和安装得到同样可运行布局；即使无补丁也存在 StoryPatches/<buildId>、ResourcePatches、I18n；内置语言按原排序语义合并，外置部分覆盖/新增语言/损坏跳过，外置不能补足缺失的内置默认语言；损坏包拒绝且旧安装和用户翻译保留；旧 v1/v2 布局仍可读取。
+- 无待确认问题。设计见 design.md，阶段见 phase-plan.md。
diff --git a/features/F-20261029-02-packed-game-documents/phase-plan.md b/features/F-20261029-02-packed-game-documents/phase-plan.md
new file mode 100644
index 00000000..d5a9e175
--- /dev/null
+++ b/features/F-20261029-02-packed-game-documents/phase-plan.md
@@ -0,0 +1,14 @@
+# 实施阶段
+
+| 阶段 | 退出条件 | 状态 |
+| --- | --- | --- |
+| P1 | 文档 GPAK、导出、安装与旧布局兼容；空目录和校验/原子安装用例通过 | verified |
+| P2 | 运行内容/内置语言与外置翻译/profile/CLI inspect，语言覆盖和完整性用例通过 | verified |
+| P3 | 发行脚本读取新入口并保留空目录；实际组合包与两种部署启动验证 | verified-with-follow-up |
+| P4 | 相关回归、格式、自检、正式文档与总结同步 | verified-with-follow-up |
+
+证据目录 out/packed-documents/。构建/测试按依赖顺序运行，不重叠同输出根的构建和 no-build 测试。不上传，不自动提交本轮。
+
+P1/P2 证据：isolated-build.log 完整 solution 构建成功；isolated-integration.log / tests/isolated-integration.trx 164 项通过；isolated-editor-shared.log / tests/isolated-editor-shared.trx 477 项通过。为隔离同时进行的对话历史与 Editor 改动，最终发行验收使用 HEAD 86cc021b 加本轮文件覆盖的独立源码快照 source/，范围与 SHA-256 见 source-files.json。当前工作区先前的构建失败日志保留，不视为本轮独立快照的结果。
+
+P3/P4：release/0.1.0-dev.44 生成并验收七 ZIP；实际两种 GameTestCase 加载 2 passed；galpak-pwsh、galpak-winps 均 passed。native-comparison/results.json 中旧版、自包含新版、依赖框架新版均 ready=true，运行时位置符合部署。组合桌面 smoke 曾发生 Skia 字体合成 0xC0000005，未定位根因，不能宣称完整桌面 smoke 通过；证据及后续见 summary.md / review.md。修改后的验证脚本已在失败分支保留 stdout、stderr 与 profile 日志，不掩盖失败或自动重试。
diff --git a/features/F-20261029-02-packed-game-documents/review.md b/features/F-20261029-02-packed-game-documents/review.md
new file mode 100644
index 00000000..f5d5ec6f
--- /dev/null
+++ b/features/F-20261029-02-packed-game-documents/review.md
@@ -0,0 +1,20 @@
+# 自审
+
+结论：pass-with-follow-up。打包范围内未发现阻止交付代码的问题；桌面原生字体崩溃的跟进仍开放，不宣称所有桌面验收通过。不声称独立 reviewer 审核。
+
+- 核对固定入口与六个文档、文档专用 GPAK catalog、project/build 身份和 content/index 文件集合一致性。正常资源覆盖无法进入文档加载入口。
+- 核对内置文本按作者相对路径 ordinal 合并、每文化一个条目、空字符串保留与父文化回退；非 JSON 作者说明和 External 不导出。默认语言完整性先于外置来源加载，损坏外置文件以诊断跳过。
+- 核对普通解压、目录导出、安装三路径的空目录保证，以及安装复用保留外置文件、损坏入口/载荷拒绝和暂存发布行为。v1/v2 与旧 content v2 读取测试保留。
+- 核对默认 profile 稳定 projectId 摘要；InvalidDataException 在身份探测处回退，使正式启动内容校验继续报告损坏。
+- 修改旧测试时仍验证自定义契约编译产物、自定义资源 metadata 和未知配置往返；仅将旧 ZIP 根路径与散 JSON 入口改成当前格式。CLI inspect 不要求项目/契约且只读。
+- 检查模块引用方向与新增 DTO 字段；Core 继续无平台依赖，文档编码归 Assets，文件定位/安装/加载归 Storage.FileSystem，Sample 只选择启动位置与用户 profile。
+- 隔离快照完整 solution 构建成功，7 个相关测试项目共 969 项通过。修改文件的 whitespace/IDE0005 检查及 git diff --check 通过。发布保护 7 项通过。
+- 七个发行 ZIP 的载荷验收 passed，实际两种 GameTestCase 内容加载 2 passed；PowerShell 5.1/7 使用真实分发 CLI 的 galpak 整合均通过。native-comparison/results.json 显示两种新版玩家均初始化完成且运行时正确。
+
+## 待跟进的原生验证问题
+
+组合桌面 smoke 在 SelfContained 玩家初始化时出现过 `SkiaSharp.SKStream.Read → SkiaTypeface.TryGetStream → TryCreateSyntheticGlyphTypeface` 的 0xC0000005，见 desktop-smoke-confirmed/SelfContained/player-stderr.log。原封不动的相同发行文件在后续对照中初始化成功；旧版对照也成功，因此尚不能断定属于旧问题或已修复。不修改字体行为，也不因后续单次成功删除失败证据。风险是发布环境仍可能遇到字体初始化崩溃，正式发布前应单独定位并复核。
+
+另一次组合 smoke 的 CLI 导出暂存目录曾报 Access denied，同路径独立重试成功，见 desktop-smoke-final.log / desktop-export-retry.log；未确认根因，不当作代码修复完成。验证脚本补充了成功/失败两分支的进程输出与 profile 日志保留，测试仍正常清理自己的唯一 profile。
+
+范围与限制：压缩容器不是加密；当前整包缓冲与按语言逻辑条目不等于按需流式读取。没有新增更新/合并覆盖协议，没有 BSON、AOT 或体积专项优化。并行工作区中的对话历史和 Editor 默认契约改动未纳入本次源码快照或自审。
diff --git a/features/F-20261029-02-packed-game-documents/summary.md b/features/F-20261029-02-packed-game-documents/summary.md
new file mode 100644
index 00000000..b6e9fd75
--- /dev/null
+++ b/features/F-20261029-02-packed-game-documents/summary.md
@@ -0,0 +1,45 @@
+# 内置文档与本地化封装
+
+日期：2026-10-29。状态：implemented-with-follow-up。核心实现、回归与发行载荷验证完成，两种玩家均有实际启动成功证据；组合桌面 smoke 的原生字体崩溃仍待跟进。上一轮已提交 86cc021b，本轮未自动提交或上传。
+
+## 交付行为
+
+- 新 galpak v3 固定为 pak/game.pak 入口，包含 content、installation、settings、Gallery、characters、layout 六个紧凑 JSON 文档；不分发内部散 JSON 或 .galnet。复用 GPAK v3 压缩和逐项校验，没有引入 BSON。
+- localization.pak 为一个物理文件，每种文化独立文本条目；作者多文件按原 ordinal 路径次序合并。新内容 pak/I18n/<culture>/**/*.json 仅作为社区翻译的可选覆盖入口，支持部分覆盖、新增语言与无效来源诊断。默认语言完整性只依赖内置文本。
+- 导出、普通解压、安装提供空 I18n、ResourcePatches、StoryPatches/<buildId>。纯 Sample 提供三个空扩展目录，没有游戏时不创建虚构 buildId。
+- 安装仍使用暂存校验后发布；复用相同内容保留用户翻译和补丁，入口 game.pak 也参与复用比较。v1/v2 galpak 和 content v2 安装目录保留读取兼容；损坏新入口不会回退散文件。
+- 只读 CLI game inspect 让发行脚本在 PowerShell 5.1/7 读取新旧描述，无需重复解析 GPAK。Sample 用户 profile 继续按 projectId 摘要，与安装位置和 buildId 无关。
+
+## 实现位置
+
+Assets 的 PackedGameDocuments 编解码固定文档集合；Editor.Shared 的 GamePackageExporter 准备文档和语言包；Storage.FileSystem 的 InstalledGameDescriptor、GalpakInstaller、InstalledPackageSet 和内容加载器负责定位、校验、安装和兼容。Sample 与发行脚本接入新入口。
+
+内部安装索引不包含 game.pak 自身，避免循环哈希；使用固定导出时间使同一输入重复生成稳定文档包，实际发行时间保留在发行清单。新格式标记参与 buildId，存档/GPAK 版本不变。
+
+## 验证
+
+证据根为 out/packed-documents/。
+
+| 检查 | 结果 |
+| --- | --- |
+| 完整 solution 构建 | isolated-build.log，0 errors |
+| 导出/安装/运行内容集成 | tests/isolated-integration.trx，164 passed |
+| 共享作者工具与真实 CLI | tests/isolated-editor-shared.trx，477 passed |
+| Assets / Core / Storage / Architecture / GameHost | 分别 103 / 139 / 26 / 52 / 8 passed，相关 TRX 与 related-tests.json |
+| 发布保护 | guards/guard-results.json，7 passed |
+| 修改 C# 格式与 using | format-whitespace.log、format-imports.log，退出 0；git diff --check 通过 |
+| 实际分发 CLI 的 galpak 整合 | galpak-pwsh/verification.json、galpak-winps/verification.json，PowerShell 7/5.1 均通过 |
+| 两种部署完整 Apps | release/0.1.0-dev.44/release-index.json；release.log 与 .work/0.1.0-dev.44-af2f37c1f9724a388f53762f72419381/app-validation/app-validation.json，七 ZIP 载荷验收 passed |
+| 实际两种 GameTestCase 内容加载 | tests/published-content.trx，2 passed |
+| 实际玩家默认启动与运行时位置 | native-comparison/results.json：旧版、自包含新版、依赖框架新版均 ready=true，运行时位置正确，唯一 profile 已清理 |
+| 组合桌面 smoke | 未全绿；保留 desktop-smoke.log、desktop-smoke-final.log、desktop-smoke-confirmed.log 和各进程日志，见下文 |
+
+工作区有同时进行的对话历史和 Editor 改动，首轮工作区构建曾因这些文件的临时编译错误失败；原日志保留。为提供稳定证据，最终使用 HEAD 86cc021b 加本轮明确文件列表的源码快照构建与打包；source-files.json 记录覆盖路径和 SHA-256，source/ 保存可复现输入。该快照不包含其他任务的未提交代码，不声称当前整个脏工作区已通过完整 CI。
+
+组合桌面 smoke 中发生过 Skia 字体合成的原生 0xC0000005，失败堆栈位于 desktop-smoke-confirmed/SelfContained/player-stderr.log；同一发行玩家随后在 native-comparison 中成功初始化，旧版对照也成功，根因尚未确认，不能据此断言为已有问题或已修复。另一次 CLI 导出暂存目录访问拒绝在同路径重试成功。验证脚本已增强 stdout/stderr 和 profile 日志保留，失败仍返回非零，不自动吞错或重试。正式发布前需要单独定位原生字体风险；本轮没有通过改字体/延时/强制跳过启动步骤来制造通过结果。
+
+## 文档与边界
+
+已同步 [文件格式](../../docs/spec/file-formats.md)、[国际化](../../docs/spec/i18n.md)、[架构](../../docs/spec/architecture.md)、[内容分包](../../docs/manual/content-packaging.md)、[发行打包](../../docs/manual/release-packaging.md)、[Sample 定制](../../docs/manual/customize-avalonia-sample.md)、glossary 和 Headless README。
+
+本轮没有体积专项优化、加密、防提取、BSON、AOT、热加载或通用更新协议。保留整包缓冲；按语言条目组织不代表流式按需 I/O。Windows x64 是发行验收平台，未运行其他平台发行、完整剧情/全部音视频格式或完整 CI/NuGet 消费验收。发现并修复的启动异常继承边界记录在 .agents/lessons/L-20261029-08-invalid-data-startup-fallback.md。
diff --git a/features/F-20261029-02-packed-game-documents/verification/Test-GalpakIntegration.ps1 b/features/F-20261029-02-packed-game-documents/verification/Test-GalpakIntegration.ps1
new file mode 100644
index 00000000..d0ab93aa
--- /dev/null
+++ b/features/F-20261029-02-packed-game-documents/verification/Test-GalpakIntegration.ps1
@@ -0,0 +1,72 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Cli,
+    [Parameter(Mandatory)][string]$Contracts,
+    [Parameter(Mandatory)][string]$WorkDirectory
+)
+$ErrorActionPreference = 'Stop'
+$Cli = [IO.Path]::GetFullPath($Cli)
+$Contracts = [IO.Path]::GetFullPath($Contracts)
+$WorkDirectory = [IO.Path]::GetFullPath($WorkDirectory)
+if (Test-Path -LiteralPath $WorkDirectory) { throw 'Use a new verification directory.' }
+New-Item -ItemType Directory -Path $WorkDirectory | Out-Null
+$repository = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../../..'))
+$scriptPath = Join-Path $repository 'scripts/release/Publish.ps1'
+$parseErrors = $null
+$ast = [Management.Automation.Language.Parser]::ParseFile($scriptPath, [ref]$null, [ref]$parseErrors)
+if ($parseErrors.Count) { throw 'Publish script does not parse.' }
+# Load the actual packaging helpers without running the build/publish entry point.
+foreach ($name in @('Get-RelativePath', 'Copy-ContentTree', 'Add-GameContent')) {
+    $definition = $ast.FindAll({ param($node) $node -is [Management.Automation.Language.FunctionDefinitionAst] -and $node.Name -eq $name }, $false)
+    . ([scriptblock]::Create($definition.Extent.Text))
+}
+$headlessProject = 'unused-build-project'
+function Invoke-DotNet([string[]]$Arguments, [switch]$JsonOutput) {
+    $separator = [Array]::IndexOf($Arguments, '--')
+    if ($separator -lt 0 -or "$($Arguments[$separator + 1]) $($Arguments[$separator + 2])" -notin @('galpak install', 'game inspect')) {
+        throw 'This verification may only install or inspect the distributed content.'
+    }
+    $output = & $Cli @($Arguments[($separator + 1)..($Arguments.Length - 1)])
+    if ($LASTEXITCODE) { throw 'Distributed installation failed.' }
+    if ($JsonOutput) { return $output | ConvertFrom-Json }
+}
+function Invoke-Cli([string[]]$Arguments) {
+    $output = & $Cli @Arguments
+    if ($LASTEXITCODE) { $output | Write-Host; throw "CLI failed: $Arguments" }
+}
+$project = Join-Path $WorkDirectory 'StoryFixture'
+Invoke-Cli @('project', 'create', $project, '--contracts', $Contracts)
+foreach ($generated in Get-ChildItem -LiteralPath (Join-Path $project 'Graph/groups') -Filter '*.rawgalgroup' -File) {
+    Remove-Item -LiteralPath $generated.FullName
+}
+@'
+{"version":2,"name":"Story","rootNodeId":"base","nodes":[{"id":"base","name":"Base","type":"Group","file":"groups/base.rawgalgroup"},{"id":"chapter","name":"Chapter","type":"Group","file":"groups/chapter.rawgalgroup","storyPackage":"extra"},{"id":"end","name":"End","type":"Group","file":"groups/end.rawgalgroup"}],"edges":[{"id":"first","fromNodeId":"base","fromOutlet":0,"toNodeId":"chapter"},{"id":"second","fromNodeId":"chapter","fromOutlet":0,"toNodeId":"end"}],"playerVariables":[],"saveVariables":[]}
+'@ | Set-Content -LiteralPath (Join-Path $project 'Graph/graph.json') -Encoding utf8
+New-Item -ItemType Directory -Force -Path (Join-Path $project 'Graph/groups') | Out-Null
+foreach ($group in @('base', 'chapter', 'end')) {
+    '{"version":2,"kind":"Raw","entries":[]}' | Set-Content -LiteralPath (Join-Path $project "Graph/groups/$group.rawgalgroup") -Encoding utf8
+}
+$packages = Join-Path $WorkDirectory 'packages'
+Invoke-Cli @('export', $project, '--output', $packages)
+$Galpak = (Get-ChildItem -LiteralPath $packages -Filter '*.galpak').FullName
+$buildId = (Get-ChildItem -LiteralPath (Join-Path $packages 'StoryPatches') -Directory).Name
+$storyFiles = @(Get-ChildItem -LiteralPath (Join-Path $packages "StoryPatches/$buildId") -Filter '*.pak' -File)
+if (!$storyFiles.Count) { throw 'Fixture did not produce external story PAKs.' }
+$unrelatedBuild = 'b' * 64
+New-Item -ItemType Directory -Path (Join-Path $packages "StoryPatches/$unrelatedBuild"), (Join-Path $packages 'ResourcePatches') | Out-Null
+'unrelated build' | Set-Content (Join-Path $packages "StoryPatches/$unrelatedBuild/unused.txt")
+'external resource package notes' | Set-Content (Join-Path $packages 'ResourcePatches/notes.txt')
+$payload = Join-Path $WorkDirectory 'payload'
+New-Item -ItemType Directory -Path $payload | Out-Null
+Add-GameContent $WorkDirectory $payload $Contracts
+$installed = Join-Path $payload 'pak'
+if ((Test-Path (Join-Path $installed 'pak')) -or !(Test-Path (Join-Path $installed 'game.pak'))) { throw 'Incorrect content root.' }
+foreach ($file in $storyFiles) {
+    $copied = Join-Path $installed "StoryPatches/$buildId/$($file.Name)"
+    if ((Get-FileHash -LiteralPath $copied).Hash -ne (Get-FileHash -LiteralPath $file.FullName).Hash) { throw 'Story package changed.' }
+}
+if (Test-Path (Join-Path $installed "StoryPatches/$unrelatedBuild")) { throw 'Copied another build.' }
+if (!(Test-Path (Join-Path $installed 'ResourcePatches/notes.txt'))) { throw 'Missing external resource package directory.' }
+[ordered]@{ passed = $true; storyParts = $storyFiles.Count; contentRoot = $installed; unrelatedBuildExcluded = $true } |
+    ConvertTo-Json | Set-Content -LiteralPath (Join-Path $WorkDirectory 'verification.json') -Encoding utf8
+Write-Host "Galpak integration passed: $installed"
diff --git a/features/F-20261029-03-dialogue-history/design.md b/features/F-20261029-03-dialogue-history/design.md
new file mode 100644
index 00000000..1759e108
--- /dev/null
+++ b/features/F-20261029-03-dialogue-history/design.md
@@ -0,0 +1,21 @@
+# 设计
+
+## 数据与边界
+
+宿主观察原语执行，读取执行前已读状态及解析后的文本。以 GroupId、同源稳定 ID 的紧邻编号（rawId#n → rawId#(n+1)）和本次实际执行关联播放 ticket；ReadingBoundaryId 则保护整句快照边界。条件未执行或其他原语打断会清除候选，不跨源推断。Quick/CatchUp 未真正播放时仍保留该次执行的语音资源描述，不借用旧 ticket。
+
+GameHost 的历史 journal 保存不可变展示记录；每次执行用独立 visit，展示成功后追加。状态表只记录历史条数游标，稳定快照在当前对白之前，实际保存按其游标截取历史，从而读档重显当前句不会重复。存档正文使用平台无关、可选的 opaque Attachments 字典，只在宿主实际保存时附加，不在运行状态中累积。此为上一轮“存档附加数据”的具体接口选择；引擎忽略其内容。
+
+执行验证补充：readingBoundaryId 前导原语到阅读原语之间不发布稳定快照，否则读档可能只重执行文本，遗漏同源音频。Engine 以领域无关的 reading preamble 标志保护整句边界。条件未执行的原语通过可选 dispatcher 通知清除宿主的待关联音频；有效推进也通过可选通知停止临时播放，包括仅补全文字的推进。
+
+临时语音直接使用既有后端独立 voice ID 和 generation，在原 track/bus 上接受现有混音。临时播放不进入 AudioRuntime 的持久队列；有效推进、选择、开启播放模式、关闭历史及运行释放均停止，迟到事件不得影响新播放。
+
+## 展示
+
+共享历史覆盖层由 GamePage 拥有，三主题承载同一内容。打开取消自动/快速并锁住剧情输入，关闭保持手动。ScrollViewer 内使用虚拟化 ItemsControl，每次打开 ScrollIntoView 最后一行。历史正文纯显示，行不提供悬停、选择、焦点或点击行为；独立语音按钮仍可重播。富文本历史即时渲染，忽略延迟指令。
+
+已读颜色作为 typewriter 普通 runs 的可继承默认色，显式颜色保持优先。每行保留进入时 WasRead，设置变化只刷新默认 runs，不重启打字机。
+
+## 风险与验证
+
+重点验证：快照游标与历史前缀一致；异步展示完成不能写入旧代；同句循环与条件跳过音频；调试回放；迟到音频事件；按钮/滚轮不穿透；大量历史虚拟化；自动等待原语回归。
diff --git a/features/F-20261029-03-dialogue-history/feature.md b/features/F-20261029-03-dialogue-history/feature.md
new file mode 100644
index 00000000..f7bd2c58
--- /dev/null
+++ b/features/F-20261029-03-dialogue-history/feature.md
@@ -0,0 +1,22 @@
+# Sample 对白历史、语音重播与已读配色
+
+状态：verified。用户已在本会话完成设计确认并明确授权实现；结果和验证见 [summary.md](summary.md)。
+
+## 目标与验收
+
+- 设置中提供默认关闭的已读正文配色，启用后显示颜色选择器，默认 #A8B8C8；保留显式富文本颜色及其他样式。
+- 进入文本时捕获此前已读状态，首次显示完成不跳色；支持 ADV/NVL。
+- 同 raw entry 展开的相邻、实际执行的音频与文本关联，复用稳定编译身份/阅读边界；不同源不猜测关联，重复执行独立。
+- 历史从当前路线的新游戏开始，随普通/快速存档恢复，读旧档丢弃之后历史；默认滚轮上和工具栏按钮打开，每次定位末尾，列表虚拟化。
+- 历史正文纯显示，不提供行悬停、选择、焦点或点击行为；独立语音按钮保留。
+- 完整显示后追加历史，CatchUp 记录实际经过文本，调试恢复不制造重复记录。
+- 对白原语音结束后可重播；历史行可播放语音。使用独立临时播放实例，复用音轨混音，任何有效剧情继续均停止重播；关闭历史、读档和结束运行清理。
+- 保留现有文字与语音均结束后再等待自动间隔的行为。
+
+## 约束
+
+Core/Runtime 不依赖平台或内置对白领域。保护现有其他任务修改。历史正文不参与每个指令的稳定快照编码。三主题及 Sample 本地化同步。
+
+## 设计和实施
+
+见 [design.md](design.md)、[phase-plan.md](phase-plan.md)。本记录源于当前对话确认的需求，不回写过去的 feature 历史。
diff --git a/features/F-20261029-03-dialogue-history/phase-plan.md b/features/F-20261029-03-dialogue-history/phase-plan.md
new file mode 100644
index 00000000..a7fa2ad6
--- /dev/null
+++ b/features/F-20261029-03-dialogue-history/phase-plan.md
@@ -0,0 +1,25 @@
+# 阶段计划
+
+P1/P2 的执行绑定和页面 VM 共同组成可编译的垂直切片，因此集成验证后一起提交，避免不可运行的中间版本。
+
+## P1 历史数据与执行关联（verified）
+
+实现存档附加数据、历史 journal/游标、执行观察与语音 ticket、临时重播；验证普通/快速存档的前缀恢复、重复执行、取消和播放结束。Core/Runtime 保持领域中立。
+
+证据：历史/重播/自动播放与宿主生命周期等 51 项定向集成通过；Runtime 全量 124 项通过。增加前导快照和异步完成交错测试。
+
+## P2 页面、配色与输入（verified）
+
+共享历史覆盖层、三主题入口/承载、默认快捷键、对白重播按钮、已读颜色设置及本地化。验证富文本、实际挂载输入、关闭与清理。
+
+证据：展示层全量 296 项通过，包含三主题真实挂载、2000 行虚拟化、末尾定位、Escape、颜色优先级和输入；ColorView 弹层模板及偏好恢复集成通过。
+
+## P3 回归和收尾（verified）
+
+运行相关测试与构建，自审实际 diff，同步 spec/manual、实现总结与已验证经验；逐阶段仅提交本 feature 文件。
+
+证据：Core 139、Storage 26、Architecture 52 项通过；合计相关回归 688 项。Debug Sample 与 Release 集成项目构建通过；受影响配置锁文件更新，Release locked restore 通过；限定功能文件的 whitespace/IDE0005 格式处理及最终只读格式检查通过。未运行全仓发布、原生视频显式用例或人工扬声器试听。详见 summary.md。
+
+## 后续修正：历史纯显示与确认按钮本地化（verified）
+
+按用户反馈将历史列表改为 ScrollViewer 承载的虚拟化 ItemsControl，移除行选择和悬停样式，保留独立语音按钮。颜色选择器确认按钮改用已有 Common.Confirm。展示层全量 296 项、设置/本地化集成 14 项通过，Release 两测试项目构建通过；覆盖三主题 2000 行虚拟化、末尾定位、正文点击不抢焦点或推进、独立重播与弹层中英文动态切换。
diff --git a/features/F-20261029-03-dialogue-history/review.md b/features/F-20261029-03-dialogue-history/review.md
new file mode 100644
index 00000000..96c10015
--- /dev/null
+++ b/features/F-20261029-03-dialogue-history/review.md
@@ -0,0 +1,17 @@
+# 自审
+
+结论：pass。由实现者对需求、实际 diff、测试与截图进行自审，不冒充独立 agent 审核。
+
+已检查并修正：
+
+- 对白关系使用同 Group、同 rawId 的相邻原语，不猜测当前正在响的声音；条件跳过、跨源和循环访问不会借用旧候选。
+- 稳定快照覆盖整个阅读前导；OnCheckpointCreating 在执行门内同步提交已完成历史，补充可控的异步完成交错测试。
+- 原语音 ticket 只控制初次播放完成按钮；重播以独立后端 voice ID/generation 播放，取消加载、自然结束、替换与迟到事件均有验证。
+- 历史跟随存档前缀，当前句重执行不重复。当前格式的旧存档仅补空历史表，其他模块校验保持严格。
+- 已读色只作用普通 runs；显式富文本颜色、粗斜体、姓名和打字机任务保留。ColorView 在自身样式作用域加载，实际弹层模板完成挂载。
+- 三主题承载同一虚拟化面板；历史打开后输入不穿透，关闭保持手动。旧输入偏好只补缺少且不冲突的历史默认键。
+- 运行释放先停止重播，异步 UI 回调检查旧运行是否已释放，避免影响新运行。
+
+验证：Core 139、Runtime 124、Presentation 296、Storage 26、Architecture 52、定向 Integration 51，共 688 项通过。参见 summary.md 的限制和环境说明。
+
+范围说明：保留既有选择界面的快捷键接收约束，选择时可通过工具栏打开历史；手写不同 raw entry 的独立音频不自动附到文本。默认 PCM 后端提供重播所借用的轨道/Bus 混音。
diff --git a/features/F-20261029-03-dialogue-history/summary.md b/features/F-20261029-03-dialogue-history/summary.md
new file mode 100644
index 00000000..7dd11551
--- /dev/null
+++ b/features/F-20261029-03-dialogue-history/summary.md
@@ -0,0 +1,48 @@
+# 对白历史、语音重播与已读正文配色
+
+状态：verified。
+
+## 实现结果
+
+- Sample 游戏设置提供“已读文本颜色”：默认关闭，启用显示颜色选择入口，默认 #A8B8C8，保存开关与颜色。ADV/NVL 捕获进入前已读状态，显式富文本颜色及粗体、斜体、换行保持原样，设置变化不重启打字。
+- 三主题工具栏增加历史按钮，默认滚轮向上，支持原有输入设置。共享面板按顺序显示姓名、即时富文本和可选语音按钮，2000 行虚拟化验证，每次打开定位末尾，Escape/返回关闭，输入不穿透。
+- 历史从当前路线的新游戏开始，重复访问分别记录，完整显示后追加。实际存档附加完整历史前缀，日常状态只保存小游标；读旧档恢复对应前缀，当前句重显示不重复。已有当前格式旧档缺少历史模块时从空历史继续，不制造此前未记录的文本。
+- 复用同 Group、同 rawId 的紧邻编译身份关联 audio.play 和文本；保存语音资源/音轨/增益，本次 ticket 控制原语音结束后出现的对白重播按钮。
+- 独立临时 voice 重播，使用现有后端与轨道混音；重复播放替换旧播放。有效继续（含补全文字）、选项、自动/快速/跳过、关闭历史、读档与退出运行停止，迟到事件不影响新播放。
+- 原有文字/语音都结束后再计算自动间隔的行为保留。
+
+## 模块与关键决定
+
+Core 只新增 opaque Snapshot Attachments 和可选 dispatcher 观察协议。Runtime 保护 reading preamble 的稳定快照边界，并在执行门内同步提交已完成的宿主观察。GameHost 保存历史 journal 与临时重播生命周期；Avalonia.GameHost 观察内置执行并绑定页面；GameView/Controls/Themes 提供页面、输入、富文本默认色和设置控件。新增 ColorPicker NuGet 依赖及受影响的普通/玩家/ReadyToRun/调试锁文件。
+
+P1/P2 合并为可编译的垂直切片后集成验证。复查发现的半句快照、历史异步完成滞后和旧运行 UI 回调问题已修正，见 [design.md](design.md)、[review.md](review.md) 与 [lesson](../../.agents/lessons/L-20261029-09-reading-preamble-checkpoints.md)。
+
+## 验证
+
+| 范围 | 通过 |
+|---|---:|
+| Core 全量 | 139 |
+| Runtime 全量 | 124 |
+| Presentation 全量 | 296 |
+| Storage.FileSystem 全量 | 26 |
+| Architecture 全量 | 52 |
+| 历史/重播/设置/自动播放/存档/宿主生命周期等定向集成 | 51 |
+| 合计 | 688 |
+
+Debug Sample、Release 集成项目构建通过；Release locked restore 通过；C# whitespace、IDE0005 清理及最终格式检查通过。截图与日志在本地 `out/dialogue-history/`，集成结果为 `results/dialogue-history.trx`，三主题历史截图在 `screenshots/`。
+
+环境/测试修正记录：Avalonia 遥测写用户目录受限，验证使用 UsedAvaloniaProducts 空值；dotnet format 的命名管道需要沙箱外执行，只处理本功能列出的文件。早期 Debug 构建用了不匹配的恢复图，按相同 Configuration/EnableGameDebugging 恢复后 Debug 构建通过。Storage 并发替换测试首次出现 Windows 临时访问失败，单项及全量重试均通过，未修改无关存储实现。两项输入用例原先假定中键默认推进、右键没有冲突，现改为夹具显式配置对应手势；AOT 序列化用例明确验证只补入新增历史动作，其余线格式保持。
+
+## 当前限制
+
+- 不从旧存档重新执行剧情补全过去未记录的文本。
+- 手写不同源音频不自动关联；选择界面保留原有快捷键约束，可用工具栏进入历史。
+- 本次未执行全仓发行打包、原生视频显式用例或人工扬声器试听；共享后端的原生能力不由 Headless 验证代替。
+
+规范见 [control](../../docs/spec/control.md)、[runtime](../../docs/spec/runtime.md)，接入说明见 [定制 Sample](../../docs/manual/customize-avalonia-sample.md#对白历史与重播)。
+
+## 后续修正：历史纯显示与确认按钮本地化
+
+历史改用不带选择行为的虚拟化 ItemsControl，正文行无悬停样式、选择、焦点或点击行为；滚动、打开末尾定位及独立语音重播按钮保持可用。已读颜色弹层确认按钮原来引用缺失的 Common.Apply，现复用 Common.Confirm，随界面语言显示 Confirm/确认。
+
+Release 展示层和集成测试项目构建通过；展示层全量 296 项、颜色设置及本地化集成 14 项通过。三主题实际挂载测试覆盖 2000 行虚拟化、末尾定位、正文点击不抢焦点或推进及独立重播；弹层测试加载 Sample 内置语言，验证打开时与中英文切换后的确认/取消文字。
diff --git a/features/F-20261029-04-new-project-application/design.md b/features/F-20261029-04-new-project-application/design.md
new file mode 100644
index 00000000..63a6801e
--- /dev/null
+++ b/features/F-20261029-04-new-project-application/design.md
@@ -0,0 +1,10 @@
+# 设计
+
+- `NewProjectPanelViewModel.ApplicationPath` 驱动自动定位，仅契约输入为空时填充；同时支持浏览与文本赋值。只检查当前 EXE 同级和 lib 两处固定位置，不递归扫描、不猜测多份结果。
+- Shared 的 `ProjectContractSource` 使用 PE 元数据递归解析程序集引用，排除当前 .NET 平台程序集；其余引用必须存在于来源目录。用 `ProjectRawReader` 保留目录链接与路径逃逸限制。
+- 自定义来源在创建前后台制作独立临时契约快照，并以既有 `ProjectSchemaContext` 验证。既有 `IProjectService.CreateAsync` 接收精简快照，公共创建接口及 CLI 的目录复制行为不变。快照在成功或失败后释放。未选 App 且未指定契约时沿用默认目录：该目录仅含入口 DLL，其 Core/Builtins 由 Editor 共享，不按外部来源要求完整闭包。
+- 自包含 Editor 的平台程序集按运行时 deps 清单中 `runtimepack.Microsoft.NETCore.App.Runtime.*` 的 runtime 资产识别；框架依赖部署使用独立框架目录中的平台程序集。不能以自包含部署的共享目录排除业务 DLL。
+- 创建并打开项目后、导航到工作区前，以既有 `ExternalGameDebugClient.SaveSettings` 保存 EXE。工作目录采用既有默认值（EXE 目录），无额外启动参数。没有选 App 时不生成调试配置。
+- 选 App 不代表判断其是否启用了调试协议；普通 Debug Sample 默认支持，玩家发行包需使用 Developer 构建。契约更新仍沿用严格指纹校验。
+
+限制：仅部署静态托管引用闭包，动态加载、原生执行不属于作者契约。文件读取/校验失败先于项目创建；项目创建成功后的调试配置 I/O 失败沿用创建面板错误展示，不回滚已经创建的项目。
diff --git a/features/F-20261029-04-new-project-application/feature.md b/features/F-20261029-04-new-project-application/feature.md
new file mode 100644
index 00000000..cb0b9d26
--- /dev/null
+++ b/features/F-20261029-04-new-project-application/feature.md
@@ -0,0 +1,9 @@
+# 新建项目选择游戏 App
+
+用户授权：2026-10-29 确认开始实现。
+
+在 Editor 新建项目契约目录上方提供可选 App EXE。契约目录为空时，识别当前普通构建的 EXE 同级契约和当前发行布局的 lib 契约；不支持历史布局。已有契约输入保留，取消选择保留输入。自动发现失败或存在多份入口时提示手动选择，不静默使用默认契约。
+
+创建时部署契约及非平台托管依赖，保持 DLL 字节身份，不复制整个 App 或运行时。所选 EXE 保存为项目外部调试 App。未选 App 且契约为空时保留 Editor 默认契约行为。
+
+验收：两种目录发现、依赖闭包、手动覆盖/取消、无效来源阻止创建、默认/自定义原流程、调试配置重开保留与四语资源验证通过。开发输出默认具有调试能力，玩家发行包能力仍由原构建开关决定。
diff --git a/features/F-20261029-04-new-project-application/phase-plan.md b/features/F-20261029-04-new-project-application/phase-plan.md
new file mode 100644
index 00000000..69502a4d
--- /dev/null
+++ b/features/F-20261029-04-new-project-application/phase-plan.md
@@ -0,0 +1,9 @@
+# Phase
+
+## P1：选择 App 并创建可调试项目
+
+状态：verified。
+
+实现 UI/四语资源、固定目录发现、契约依赖快照和既有调试配置接入。退出条件为新建项目端到端测试覆盖开发/发行布局、依赖排除及身份、手动契约与取消选择、缺失/损坏/依赖不全/歧义来源；原有默认/自定义创建和本地化回归通过，正式说明同步。
+
+验证：完整依赖 Debug 构建成功（0 error）；8 项新增用例、2 项原有创建用例和四语资源一致性检查合计 11 项通过。自包含 smoke 读取真实 Sample Debug 目录及带传递依赖的 SchemaA，保留原始 DLL 字节并清理临时快照。详见 summary.md；扩大回归另有 3 项不涉及本次实现路径的失败，不标为整库全绿。
diff --git a/features/F-20261029-04-new-project-application/summary.md b/features/F-20261029-04-new-project-application/summary.md
new file mode 100644
index 00000000..f6941ae1
--- /dev/null
+++ b/features/F-20261029-04-new-project-application/summary.md
@@ -0,0 +1,39 @@
+# 新建项目选择 App：实现总结
+
+状态：本次实现与定向验证完成；不代表当前工作树全部回归通过。
+
+## 行为与实现
+
+- 新建项目在契约目录上方提供可选游戏 App EXE 输入与浏览。仅契约输入为空时自动填入发现目录；已有输入和取消选择均保留。支持普通构建 EXE 同级及当前发行包的 lib，不做历史兼容或递归猜测。
+- 缺失/多份契约时提示手动选择；指定 App 后不回退到默认契约。创建前后台读取并校验静态托管依赖闭包，部署保持原字节的精简临时快照，排除框架、原生和无关 App 文件。
+- 自包含宿主按 deps 中的 runtimepack runtime 资产识别平台程序集；避免将与 corelib 同目录的 Core/Builtins 错当作平台排除。框架依赖部署使用独立框架目录的 TPA 列表。
+- 项目创建并打开后，在工作区导航前复用既有调试配置保存所选 EXE。参数为空，工作目录遵循现有 EXE 所在目录默认值。
+- 未指定 App 且未指定契约时保留原默认部署流程。Editor 的 DefaultContracts 目录只包含入口 DLL，Core/Builtins 由 Editor 共享，不作为外部完整闭包处理。
+
+主要文件：`ProjectContractSource.cs`、`NewProjectPanelViewModel.cs`、`NewProjectPanelView.axaml`、四语资源与 `ProjectWorkspaceLifecycleTests.Application.cs`。公共创建接口、CLI 目录复制语义与既有调试协议均未修改。
+
+## 验证证据
+
+- 完整构建 `dotnet build test/GalNet.Editor.Tests/GalNet.Editor.Tests.csproj -c Debug --no-restore -m:1 -nr:false -p:UseSharedCompilation=false`：0 error，209 个仓库 analyzer/XAML warning；见 `out/new-project-app-full-build.log`。早期另一个进行中的 feature 的 DialogueHistoryOverlay XAML 编译失败，之后该文件由其原工作流修正，本次没有修改它。
+- 最新完整构建后，`NewProjectApplication`、`NewProjectView` 与 `FourPublishedLanguagesHaveIdenticalKeysAndCompatibleFormatArguments`：11/11 通过；见 `out/new-project-app-ui-final.log` 与 `out/new-project-app-results/new-project-app-ui-final.trx`。
+- 新增 8 个用例验证：两种布局通过实际挂载的新建面板创建并重开；复制传递依赖，排除框架/无关/原生/符号/EXE 文件，保持契约字节；已有契约和取消选择保留；缺失、损坏、依赖不全、歧义来源阻止创建；手动指定解决自动发现失败。
+- 自包含 `out/new-project-app-smoke/published/ContractSmoke.exe` 已实际读取 SchemaA 与真实 `src/Samples/GalNet.Sample.Avalonia/bin/Debug/net10.0`。Sample 精简结果为 `GalNet.Project.Contracts.dll`、`GalNet.Core.dll`、`GalNet.Contracts.Builtins.dll`；SchemaA 还保留其 SchemaDependency 和测试夹具所引用的 TestPlatform 依赖。验证所有输出与来源逐字节相等、临时目录释放。
+- 实际 Sample Debug 构建成功（0 error，2 个既有 XAML warning）；见 `out/new-project-app-sample-build.log`。初次使用 `--no-restore` 遇到此前 Player 配置的还原图，缺少 WithDeveloperTools；按 Debug/EnableGameDebugging=true 做 locked restore 后恢复正常，没有修改 Sample 源码或锁文件。随后对新构建 EXE 的契约发现/精简 smoke 再次通过，见 `out/new-project-app-smoke-sample.log`。
+- Headless 截图 `out/new-project-app-results/screenshots/p1a-new-project-default.png` 已人工查看：App 位于契约目录上方，输入、提示及创建按钮布局可见。
+- 针对本次三个 C# 文件的 `dotnet format whitespace . --folder --include ...` 成功，定向 diff whitespace 检查通过。MSBuild workspace 模式格式化在当前受限环境加载失败，改用只格式化所选文件的 folder 模式。
+
+扩大回归保留的失败（均不调用新增契约来源实现，且失败位置未由本次修改）：
+
+1. `ProjectContractPipelineTests.CliValidateBuildAndExport_UseTheSameDeployedCustomContract`：旧测试按散装 Assets/Paks 路径读取导出归档，当前另一个进行中的打包 feature 已改动发布布局，取 entry 为 null。见 `out/new-project-app-shared-test.log`。
+2. `ProjectContractPipelineTests.CustomConfigurationPatch_PreservesUnknownDataThroughExportAndInstall`：旧测试直接读安装根 settings.json，当前安装格式变化导致文件不在原路径。该批测试合计 18 pass / 2 fail。
+3. `EditorLocalizationTests.FoundationViewsHaveNoUnlistedLiteralUserInterfaceText`：未修改的 ProjectSettingsPanelView.axaml 中现有 `Content="…"` 不在测试白名单；新建面板没有新增未本地化 literal。最初该批还有本次触发的默认契约闭包错误，已修复并由最终默认创建用例通过确认。
+
+## 正式文档与经验
+
+- [项目格式](../../docs/spec/file-formats.md)：新建项目来源发现、复制边界与调试配置。
+- [外部游戏调试](../../docs/manual/external-game-debugging.md)：直接选择 Debug Sample EXE、Developer 包和契约更新要求。
+- [自包含平台程序集 lesson](../../.agents/lessons/L-20261029-07-self-contained-platform-assemblies.md)：已记录并索引；未扩大修改既有 SchemaLoadContext 的平台回退实现。
+
+## 限制
+
+只收集静态托管引用，动态/原生加载不属于作者契约。选择 App 不检查或启用其调试能力；Debug Sample 默认启用，玩家发行包需换用 Developer 构建。未用原生文件对话框或真实游戏进程执行完整调试连接验收；本次复用既有选择器与启动配置链路。创建成功后的调试配置写盘若发生 I/O 错误，会显示错误并保留已经创建的项目，不提供跨项目创建与调试配置的回滚事务。项目与 App 后续契约变更仍需同步 DLL 并重新打开项目。
diff --git a/global.json b/global.json
index b5715a74..1769bc16 100644
--- a/global.json
+++ b/global.json
@@ -1,7 +1,7 @@
 {
   "sdk": {
     "version": "10.0.401",
-    "rollForward": "latestFeature",
+    "rollForward": "disable",
     "allowPrerelease": false
   }
 }
diff --git a/packaging/Bundle.csproj b/packaging/Bundle.csproj
new file mode 100644
index 00000000..6ca5d107
--- /dev/null
+++ b/packaging/Bundle.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <IsPackable>true</IsPackable>
+    <RestorePackagesWithLockFile>false</RestorePackagesWithLockFile>
+    <RestoreLockedMode>false</RestoreLockedMode>
+  </PropertyGroup>
+</Project>
diff --git a/packaging/packages.json b/packaging/packages.json
new file mode 100644
index 00000000..d8f69a31
--- /dev/null
+++ b/packaging/packages.json
@@ -0,0 +1,27 @@
+{
+  "GalNet.Contracts": {
+    "projects": ["Shared/GalNet.Core", "Shared/GalNet.Contracts.Builtins"],
+    "dependencies": [],
+    "description": "GalNet extension contracts and built-in authoring schemas."
+  },
+  "GalNet.Engine": {
+    "projects": ["Shared/GalNet.Runtime", "Shared/GalNet.Primitives.Builtins", "Shared/GalNet.Presentation.Abstractions", "Shared/GalNet.GameHost", "Shared/GalNet.Assets", "Shared/GalNet.Debugging", "Shared/GalNet.Diagnostics"],
+    "dependencies": ["GalNet.Contracts"],
+    "description": "GalNet narrative runtime, content abstractions and host sessions."
+  },
+  "GalNet.Desktop": {
+    "projects": ["Infrastructure/GalNet.Storage.FileSystem", "Infrastructure/GalNet.Media.Audio", "Infrastructure/GalNet.Media.Miniaudio", "Infrastructure/GalNet.Media.LibVlc"],
+    "dependencies": ["GalNet.Engine"],
+    "description": "GalNet default file storage and audio/video backends. Native audio assets currently support Windows x64."
+  },
+  "GalNet.Avalonia": {
+    "projects": ["Presentation/GalNet.Avalonia.Controls", "Presentation/GalNet.Avalonia.Rendering", "Presentation/GalNet.Avalonia.GameView", "Presentation/GalNet.Avalonia.Themes", "Presentation/GalNet.Avalonia.GameHost"],
+    "dependencies": ["GalNet.Desktop"],
+    "description": "GalNet Avalonia player views, rendering, themes and host composition."
+  },
+  "GalNet.SchemaGenerator": {
+    "projects": ["Tooling/GalNet.SchemaGenerator"],
+    "dependencies": [],
+    "description": "Compile-time GalNet field schema generator. Reference with PrivateAssets=all."
+  }
+}
diff --git a/scripts/README.md b/scripts/README.md
new file mode 100644
index 00000000..0031f797
--- /dev/null
+++ b/scripts/README.md
@@ -0,0 +1,12 @@
+# Scripts
+
+仓库脚本按用途分类：
+
+- `contracts/`：构建、部署和复现性检查项目 Contracts。
+- `samples/`：运行 Headless 与 Avalonia Sample。
+- `performance/`：启动 benchmark、trace 分析和 native profile。
+- `maintenance/`：仓库代码量统计等维护工具。
+- `ci/`：本地与 Actions 共用的 restore、format、build、test 入口。
+- `release/`：五个聚合 NuGet、Editor/Sample/Contracts ZIP、独立消费和分发验收、产物索引与单独上传。
+
+本地 CI / Release 用法见 [`docs/manual/release-packaging.md`](../docs/manual/release-packaging.md)。先运行 `ci/Invoke-CI.ps1 -Coverage`，再运行 `release/Release.ps1 -Version 0.1.0-dev.1`。GitHub Release 由 `vMAJOR.MINOR.PATCH` 或 `vMAJOR.MINOR.PATCH-preview.N` tag 触发；手动 workflow_dispatch 仅构建候选。桌面 AOT 尚未通过验收，`Test-DesktopAot.ps1` 用于严格诊断。
diff --git a/scripts/ci/Invoke-CI.ps1 b/scripts/ci/Invoke-CI.ps1
new file mode 100644
index 00000000..abeb3a4b
--- /dev/null
+++ b/scripts/ci/Invoke-CI.ps1
@@ -0,0 +1,77 @@
+[CmdletBinding()]
+param(
+    [ValidateSet('All', 'Format', 'BuildTest')][string]$Stage = 'All',
+    [ValidateSet('Debug', 'Release')][string]$Configuration = 'Release',
+    [string]$OutputRoot,
+    [switch]$Coverage
+)
+
+$ErrorActionPreference = 'Stop'
+$repo = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../..'))
+if (!$OutputRoot) { $OutputRoot = Join-Path $repo "out/ci/$([DateTime]::UtcNow.ToString('yyyyMMdd-HHmmss'))-$([guid]::NewGuid().ToString('N').Substring(0, 8))" }
+$OutputRoot = [IO.Path]::GetFullPath($OutputRoot)
+New-Item -ItemType Directory -Force -Path $OutputRoot | Out-Null
+$env:DOTNET_CLI_TELEMETRY_OPTOUT = '1'
+$env:DOTNET_NOLOGO = '1'
+$env:AVALONIA_TELEMETRY_OPTOUT = '1'
+$results = [Collections.Generic.List[object]]::new()
+$previousCI = $env:CI
+$env:CI = 'true'
+$succeeded = $false
+
+function Invoke-Check([string]$Name, [string[]]$Arguments, [switch]$ContinueOnFailure) {
+    $log = Join-Path $OutputRoot "$Name.log"
+    Write-Host "[$Name] dotnet $($Arguments -join ' ')"
+    & dotnet @Arguments *> $log
+    $code = $LASTEXITCODE
+    $results.Add([ordered]@{ name = $Name; exitCode = $code; log = $log })
+    if ($code -ne 0) {
+        Get-Content -LiteralPath $log -Tail 65 | Write-Host
+        if ($ContinueOnFailure) { Write-Warning "CI check '$Name' failed ($code). Full log: $log"; return }
+        throw "CI check '$Name' failed ($code). Full log: $log"
+    }
+    Get-Content -LiteralPath $log -Tail 3 | Write-Host
+}
+
+Push-Location $repo
+try {
+    $expected = (Get-Content global.json -Raw | ConvertFrom-Json).sdk.version
+    $actual = (& dotnet --version).Trim()
+    if ($LASTEXITCODE -ne 0 -or $actual -ne $expected) { throw "Expected .NET SDK $expected; selected $actual." }
+    $guardRoot = Join-Path $OutputRoot "guards-$([guid]::NewGuid().ToString('N').Substring(0, 8))"
+    $guardLog = Join-Path $OutputRoot 'release-guards.log'
+    & pwsh -NoProfile -File (Join-Path $PSScriptRoot 'Test-ReleaseGuards.ps1') -OutputRoot $guardRoot *> $guardLog
+    $guardCode = $LASTEXITCODE
+    $results.Add([ordered]@{ name = 'release-guards'; exitCode = $guardCode; log = $guardLog })
+    if ($guardCode -ne 0) { throw "Release guard checks failed. Log: $guardLog" }
+    # Configuration affects the Sample and integration restore graphs. Use it in every phase.
+    Invoke-Check 'restore' @('restore', 'GalNet.slnx', '--locked-mode', "-p:Configuration=$Configuration", '-m:1', '-nr:false')
+    if ($Stage -in @('All', 'Format')) {
+        Invoke-Check 'whitespace' @('format', 'whitespace', 'GalNet.slnx', '--no-restore', '--verify-no-changes', '--verbosity', 'quiet')
+        Invoke-Check 'imports' @('format', 'style', 'GalNet.slnx', '--no-restore', '--verify-no-changes', '--diagnostics', 'IDE0005', '--verbosity', 'quiet')
+    }
+    if ($Stage -in @('All', 'BuildTest')) {
+        Invoke-Check 'build' @('build', 'GalNet.slnx', '-c', $Configuration, '--no-restore', '-m:1', '-nr:false', '-p:UseSharedCompilation=false')
+        # Discover actual solution test projects, never generated fixture copies in obj/bin.
+        [xml]$solution = Get-Content GalNet.slnx
+        $projects = @($solution.SelectNodes('//Project') | ForEach-Object { $_.Path } |
+            Where-Object { $_ -match '^test/GalNet\.[^/]+\.Tests/|^test/GalNet\.IntegrationTests/' } | Sort-Object)
+        if ($projects.Count -lt 14) { throw "Unexpected test project count: $($projects.Count)." }
+        foreach ($project in $projects) {
+            $name = [IO.Path]::GetFileNameWithoutExtension($project)
+            $arguments = @('test', $project, '-c', $Configuration, '--no-build', '--no-restore', '--logger', "trx;LogFileName=$name.trx", '--results-directory', (Join-Path $OutputRoot 'test-results'))
+            if ($Coverage) { $arguments += '--collect:XPlat Code Coverage' }
+            Invoke-Check $name $arguments -ContinueOnFailure
+        }
+        $failed = @($results | Where-Object { $_.exitCode -ne 0 })
+        if ($failed.Count) { throw "Failed CI checks: $(($failed | ForEach-Object name) -join ', '). Evidence: $OutputRoot" }
+    }
+    $succeeded = $true
+}
+finally {
+    $report = [ordered]@{ schemaVersion = 1; passed = $succeeded; stage = $Stage; configuration = $Configuration; checks = @($results.ToArray()); completedUtc = [DateTime]::UtcNow.ToString('O') }
+    $report | ConvertTo-Json -Depth 6 | Set-Content (Join-Path $OutputRoot 'ci-results.json') -Encoding utf8
+    $env:CI = $previousCI
+    Pop-Location
+    Write-Host "CI evidence: $OutputRoot"
+}
diff --git a/scripts/ci/Test-ReleaseGuards.ps1 b/scripts/ci/Test-ReleaseGuards.ps1
new file mode 100644
index 00000000..f712dfcd
--- /dev/null
+++ b/scripts/ci/Test-ReleaseGuards.ps1
@@ -0,0 +1,111 @@
+[CmdletBinding()]
+param([string]$OutputRoot)
+$ErrorActionPreference = 'Stop'
+$repo = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../..'))
+if (!$OutputRoot) { $OutputRoot = Join-Path $repo "out/ci/release-guards-$([guid]::NewGuid().ToString('N'))" }
+$OutputRoot = [IO.Path]::GetFullPath($OutputRoot)
+New-Item -ItemType Directory -Force -Path $OutputRoot | Out-Null
+$attempts = [Collections.Generic.List[string]]::new()
+# Negative tests must never reach a real build or external publication command.
+function gh { $attempts.Add('gh'); throw 'External command forbidden in guard tests.' }
+function dotnet { $attempts.Add('dotnet'); throw 'Build command forbidden in guard tests.' }
+function Expect-Failure([scriptblock]$Action, [string]$Pattern) {
+    $message = $null
+    try { & $Action } catch { $message = $_.Exception.Message }
+    if (!$message -or $message -notmatch $Pattern) { throw "Expected failure '$Pattern'; got '$message'." }
+}
+$releaseScript = Join-Path $repo 'scripts/release/Release.ps1'
+$pushScript = Join-Path $repo 'scripts/release/Push.ps1'
+Expect-Failure { & $releaseScript -Version '../escape' -OutputRoot $OutputRoot } 'Version must'
+Expect-Failure { & $releaseScript -Version '99.99.99-dev.1' -SampleMode Both -OutputRoot $OutputRoot } 'not release-ready'
+$existing = Join-Path $OutputRoot '99.99.99'
+New-Item -ItemType Directory -Path $existing | Out-Null
+'keep' | Set-Content (Join-Path $existing 'sentinel.txt')
+Expect-Failure { & $releaseScript -Version '99.99.99' -OutputRoot $OutputRoot } 'already exists'
+if ((Get-Content (Join-Path $existing 'sentinel.txt')).Trim() -ne 'keep') { throw 'Existing output was modified.' }
+$indexPath = Join-Path $OutputRoot 'release-index.json'
+$index = [ordered]@{ schemaVersion = 1; dirty = $true; tag = 'v99.99.99'; version = '99.99.99'; packageValidationSkipped = $false; packageValidation = @{ passed = $true }; files = @() }
+$index | ConvertTo-Json -Depth 6 | Set-Content $indexPath
+Expect-Failure { & $pushScript -Index $indexPath -Destination GitHub } 'clean, exact-tag'
+$index.dirty = $false
+$index.files = @(@{ path = '../escape.txt'; sha256 = 'invalid'; size = 0 })
+$index | ConvertTo-Json -Depth 6 | Set-Content $indexPath
+Expect-Failure { & $pushScript -Index $indexPath -Destination GitHub } 'escaped release directory'
+$index.files = @(@{ path = '99.99.99/sentinel.txt'; sha256 = 'invalid'; size = 0 })
+$index | ConvertTo-Json -Depth 6 | Set-Content $indexPath
+Expect-Failure { & $pushScript -Index $indexPath -Destination GitHub } 'Release file changed'
+$index.files = @(@{ path = '99.99.99/sentinel.txt'; sha256 = (Get-FileHash (Join-Path $existing 'sentinel.txt') -Algorithm SHA256).Hash.ToLowerInvariant(); size = (Get-Item (Join-Path $existing 'sentinel.txt')).Length })
+$index['sourceCommit'] = (& git -C $repo rev-parse HEAD).Trim()
+$index | ConvertTo-Json -Depth 6 | Set-Content $indexPath
+Expect-Failure { & $pushScript -Index $indexPath -Destination GitHub } 'tag commit does not match'
+
+# Exercise the actual ancestry check in a disposable repository, without fetching or pushing.
+$refScript = Join-Path $repo 'scripts/ci/Test-ReleaseRef.ps1'
+$refRepo = Join-Path $OutputRoot 'tag-fixture'
+New-Item -ItemType Directory -Path $refRepo | Out-Null
+$gitCommand = (Get-Command git -CommandType Application | Select-Object -First 1).Source
+function Invoke-FixtureGit([string[]]$Arguments) {
+    $output = & $gitCommand -C $refRepo @Arguments 2>&1
+    if ($LASTEXITCODE -ne 0) { throw "Fixture git failed: $Arguments / $output" }
+    return ($output -join "`n").Trim()
+}
+Invoke-FixtureGit @('init', '--initial-branch=master') | Out-Null
+Invoke-FixtureGit @('config', 'user.name', 'GalNet Release Guard') | Out-Null
+Invoke-FixtureGit @('config', 'user.email', 'release-guard@example.invalid') | Out-Null
+Invoke-FixtureGit @('config', 'commit.gpgSign', 'false') | Out-Null
+Invoke-FixtureGit @('config', 'tag.gpgSign', 'false') | Out-Null
+Invoke-FixtureGit @('config', 'core.hooksPath', (Join-Path $OutputRoot 'no-hooks')) | Out-Null
+Invoke-FixtureGit @('commit', '--allow-empty', '-m', 'Mainline base') | Out-Null
+$baseCommit = Invoke-FixtureGit @('rev-parse', 'HEAD')
+Invoke-FixtureGit @('tag', 'v99.99.0') | Out-Null
+Invoke-FixtureGit @('commit', '--allow-empty', '-m', 'Mainline next') | Out-Null
+$mainCommit = Invoke-FixtureGit @('rev-parse', 'HEAD')
+Invoke-FixtureGit @('tag', '-a', 'v99.99.1', '-m', 'Annotated release') | Out-Null
+Invoke-FixtureGit @('tag', 'v99.99.1-preview.1') | Out-Null
+Invoke-FixtureGit @('update-ref', 'refs/remotes/origin/master', $mainCommit) | Out-Null
+& $refScript -Tag 'v99.99.1' -RepositoryPath $refRepo
+& $refScript -Tag 'v99.99.1-preview.1' -RepositoryPath $refRepo
+Expect-Failure { & $refScript -Tag 'v99.99.0' -RepositoryPath $refRepo } 'checked-out HEAD'
+Invoke-FixtureGit @('checkout', '--detach', $baseCommit) | Out-Null
+& $refScript -Tag 'v99.99.0' -RepositoryPath $refRepo
+Invoke-FixtureGit @('checkout', '-b', 'unmerged') | Out-Null
+Invoke-FixtureGit @('commit', '--allow-empty', '-m', 'Unmerged change') | Out-Null
+Invoke-FixtureGit @('tag', 'v99.99.2') | Out-Null
+Expect-Failure { & $refScript -Tag 'v99.99.2' -RepositoryPath $refRepo } 'has not been merged'
+Expect-Failure { & $refScript -Tag 'v99.99.98' -RepositoryPath $refRepo } 'does not resolve'
+Expect-Failure { & $refScript -Tag 'v99.99.2-dev.1' -RepositoryPath $refRepo } 'Invalid release tag'
+Invoke-FixtureGit @('checkout', '--detach', $mainCommit) | Out-Null
+Invoke-FixtureGit @('update-ref', '-d', 'refs/remotes/origin/master') | Out-Null
+Expect-Failure { & $refScript -Tag 'v99.99.1' -RepositoryPath $refRepo } 'main branch is missing'
+
+function Test-GitHubPayloadSet {
+    $uploadCalls = [Collections.Generic.List[string]]::new()
+    function gh { $uploadCalls.Add(($args -join ' ')); $global:LASTEXITCODE = 0 }
+    $fixtureScripts = Join-Path $refRepo 'scripts/release'
+    New-Item -ItemType Directory -Path $fixtureScripts -Force | Out-Null
+    Copy-Item -LiteralPath $pushScript, (Join-Path $repo 'scripts/release/Common.ps1') -Destination $fixtureScripts
+    Invoke-FixtureGit @('remote', 'add', 'origin', 'https://github.com/example/galnet-release-guard.git') | Out-Null
+    $payloadRoot = Join-Path $refRepo 'out/release/99.99.1'
+    $assetRoot = Join-Path $payloadRoot 'assets'
+    New-Item -ItemType Directory -Path $assetRoot -Force | Out-Null
+    $assetFiles = @(0..6 | ForEach-Object {
+        $assetPath = Join-Path $assetRoot "asset-$_.zip"
+        "fixture-$_" | Set-Content $assetPath
+        @{ path = "assets/asset-$_.zip"; sha256 = (Get-FileHash $assetPath).Hash.ToLowerInvariant(); size = (Get-Item $assetPath).Length }
+    })
+    'fixture checksums' | Set-Content (Join-Path $payloadRoot 'SHA256SUMS')
+    $payloadIndex = [ordered]@{ schemaVersion = 1; dirty = $false; tag = 'v99.99.1'; version = '99.99.1'; sourceCommit = $mainCommit; packageValidationSkipped = $false; files = @($assetFiles[0..3]) }
+    $payloadIndexPath = Join-Path $payloadRoot 'release-index.json'
+    $fixturePush = Join-Path $fixtureScripts 'Push.ps1'
+    $payloadIndex | ConvertTo-Json -Depth 6 | Set-Content $payloadIndexPath
+    Expect-Failure { & $fixturePush -Index $payloadIndexPath -Destination GitHub } 'Expected seven'
+    if ($uploadCalls.Count -or (Test-Path (Join-Path $payloadRoot 'push-state.json'))) { throw 'Invalid payload count reached publication.' }
+    $payloadIndex.files = $assetFiles
+    $payloadIndex | ConvertTo-Json -Depth 6 | Set-Content $payloadIndexPath
+    & $fixturePush -Index $payloadIndexPath -Destination GitHub
+    if ($uploadCalls.Count -ne 11 -or $uploadCalls[-1] -notmatch '^release edit .*--draft=false') { throw 'Seven-asset publication sequence was not completed.' }
+}
+Test-GitHubPayloadSet
+if ($attempts.Count) { throw "Guard tests attempted external commands: $($attempts -join ', ')" }
+[ordered]@{ passed = $true; cases = 17; externalCommands = 0; releaseRefCases = 8; payloadCases = 2 } | ConvertTo-Json | Set-Content (Join-Path $OutputRoot 'guard-results.json')
+Write-Host 'Release guard tests passed (17 cases, no builds or uploads).'
diff --git a/scripts/ci/Test-ReleaseRef.ps1 b/scripts/ci/Test-ReleaseRef.ps1
new file mode 100644
index 00000000..03fda421
--- /dev/null
+++ b/scripts/ci/Test-ReleaseRef.ps1
@@ -0,0 +1,20 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Tag,
+    [string]$RepositoryPath = (Join-Path $PSScriptRoot '../..'),
+    [string]$MainlineRef = 'refs/remotes/origin/master'
+)
+$ErrorActionPreference = 'Stop'
+if ($Tag -notmatch '^v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-preview\.(0|[1-9][0-9]*))?$') {
+    throw 'Invalid release tag: expected vX.Y.Z or vX.Y.Z-preview.N.'
+}
+$tagCommit = & git -C $RepositoryPath rev-parse --verify "refs/tags/$Tag^{commit}" 2>$null
+if ($LASTEXITCODE -ne 0) { throw 'Release tag does not resolve to a commit.' }
+$headCommit = & git -C $RepositoryPath rev-parse --verify HEAD 2>$null
+if ($LASTEXITCODE -ne 0 -or $tagCommit -cne $headCommit) { throw 'Release tag must point exactly to the checked-out HEAD.' }
+$mainlineCommit = & git -C $RepositoryPath rev-parse --verify "$MainlineRef^{commit}" 2>$null
+if ($LASTEXITCODE -ne 0) { throw 'Release main branch is missing; fetch origin/master before checking the tag.' }
+& git -C $RepositoryPath merge-base --is-ancestor $tagCommit $mainlineCommit
+if ($LASTEXITCODE -eq 1) { throw 'Release tag commit has not been merged into origin/master.' }
+if ($LASTEXITCODE -ne 0) { throw 'Could not verify release tag ancestry.' }
+Write-Host "Release tag $Tag is contained in origin/master."
diff --git a/scripts/build-project-contracts.ps1 b/scripts/contracts/build-project-contracts.ps1
similarity index 100%
rename from scripts/build-project-contracts.ps1
rename to scripts/contracts/build-project-contracts.ps1
diff --git a/scripts/export-sample-contracts.ps1 b/scripts/contracts/export-sample-contracts.ps1
similarity index 91%
rename from scripts/export-sample-contracts.ps1
rename to scripts/contracts/export-sample-contracts.ps1
index ef5f3cb6..7667da48 100644
--- a/scripts/export-sample-contracts.ps1
+++ b/scripts/contracts/export-sample-contracts.ps1
@@ -5,11 +5,11 @@ param(
 
 Set-StrictMode -Version Latest
 $ErrorActionPreference = 'Stop'
-$repositoryRoot = Split-Path -Parent $PSScriptRoot
+$repositoryRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
 $sampleProject = Join-Path $repositoryRoot 'src/Samples/GalNet.Sample.Avalonia/GalNet.Sample.Avalonia.csproj'
 $sampleOutput = Join-Path $repositoryRoot "src/Samples/GalNet.Sample.Avalonia/bin/$Configuration/net10.0"
 $contractsOutput = Join-Path $repositoryRoot "src/Samples/GalNet.Sample.Contracts/bin/$Configuration/net10.0"
-$destination = Join-Path $repositoryRoot 'output/Contracts'
+$destination = Join-Path $repositoryRoot 'out/Contracts'
 
 & dotnet build $sampleProject -c $Configuration -m:1
 if ($LASTEXITCODE -ne 0) { throw 'Sample build failed; no contracts exported.' }
diff --git a/scripts/test-contract-reproducibility.ps1 b/scripts/contracts/test-contract-reproducibility.ps1
similarity index 94%
rename from scripts/test-contract-reproducibility.ps1
rename to scripts/contracts/test-contract-reproducibility.ps1
index c825f058..46f4093b 100644
--- a/scripts/test-contract-reproducibility.ps1
+++ b/scripts/contracts/test-contract-reproducibility.ps1
@@ -3,7 +3,7 @@ param([ValidateSet('Debug', 'Release')][string]$Configuration = 'Debug')
 
 Set-StrictMode -Version Latest
 $ErrorActionPreference = 'Stop'
-$repositoryRoot = Split-Path -Parent $PSScriptRoot
+$repositoryRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
 $project = Join-Path $repositoryRoot 'src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj'
 $assembly = Join-Path $repositoryRoot "src/Samples/GalNet.Sample.Contracts/bin/$Configuration/net10.0/GalNet.Project.Contracts.dll"
 $expectedHash = $null
diff --git a/scripts/count-code-lines.ps1 b/scripts/maintenance/count-code-lines.ps1
similarity index 99%
rename from scripts/count-code-lines.ps1
rename to scripts/maintenance/count-code-lines.ps1
index 93eeea86..b2b35f04 100644
--- a/scripts/count-code-lines.ps1
+++ b/scripts/maintenance/count-code-lines.ps1
@@ -45,7 +45,7 @@ $ErrorActionPreference = 'Stop'
 
 if ([string]::IsNullOrWhiteSpace($Root))
 {
-    $Root = Join-Path $PSScriptRoot '..'
+    $Root = Join-Path $PSScriptRoot '../..'
 }
 
 $rootPath = [System.IO.Path]::GetFullPath((Resolve-Path -LiteralPath $Root).Path)
diff --git a/scripts/performance/analyze-startup-native.cs b/scripts/performance/analyze-startup-native.cs
new file mode 100644
index 00000000..9c865a35
--- /dev/null
+++ b/scripts/performance/analyze-startup-native.cs
@@ -0,0 +1,69 @@
+#:property PublishAot=false
+#:property JsonSerializerIsReflectionEnabledByDefault=true
+#:property ManagePackageVersionsCentrally=false
+#:package Microsoft.Diagnostics.Tracing.TraceEvent@3.1.21
+using System.Globalization;
+using System.Text.Json;
+using Microsoft.Diagnostics.Tracing;
+using Microsoft.Diagnostics.Tracing.Etlx;
+using Microsoft.Diagnostics.Tracing.Parsers.Kernel;
+using Microsoft.Diagnostics.Symbols;
+
+if (args.Length is < 2 or > 3 || (args.Length == 3 && args[2] != "--symbols"))
+    throw new ArgumentException("Usage: dotnet run scripts/performance/analyze-startup-native.cs -- <startup.etl> <pid> [--symbols]");
+var file = Path.GetFullPath(args[0]);
+var pid = int.Parse(args[1], CultureInfo.InvariantCulture);
+var etlx = TraceLog.CreateFromEventTraceLogFile(file, file + ".etlx", new TraceLogOptions { LocalSymbolsOnly = true });
+using var log = new TraceLog(etlx);
+if (log.EventsLost != 0) throw new InvalidDataException($"Trace lost {log.EventsLost} events; recapture before interpreting it.");
+// The iterator reuses event objects. Retained events must be cloned.
+var events = log.Events.Where(item => item.ProcessID == pid).Select(item => item.Clone()).ToArray();
+var marks = events.Where(item => item.ProviderGuid == Guid.Parse("b73a0b39-c81d-5026-2e0f-108dad0eff68") && (int)item.ID == 1).ToArray();
+if (!marks.Any(item => (string)item.PayloadValue(0) == "Startup.Ready")) throw new InvalidDataException("No ready phase event for this PID.");
+var anchor = marks.FirstOrDefault(item => ((string)item.PayloadValue(0)).EndsWith(".RunAvalonia", StringComparison.Ordinal))
+    ?? marks.Single(item => (string)item.PayloadValue(0) == "Startup.Ready");
+var offset = anchor.TimeStampRelativeMSec - Convert.ToDouble(anchor.PayloadValue(2), CultureInfo.InvariantCulture) / 1000;
+var thread = anchor.ThreadID;
+var regions = marks.Where(item => Convert.ToDouble(item.PayloadValue(3), CultureInfo.InvariantCulture) >= 0)
+    .Select(item => new Region((string)item.PayloadValue(0),
+        offset + Convert.ToDouble(item.PayloadValue(2), CultureInfo.InvariantCulture) / 1000,
+        offset + (Convert.ToDouble(item.PayloadValue(2), CultureInfo.InvariantCulture) + Convert.ToDouble(item.PayloadValue(3), CultureInfo.InvariantCulture)) / 1000)).ToList();
+var xaml = regions.FirstOrDefault(item => item.Name.EndsWith(".Xaml", StringComparison.Ordinal));
+if (((string)anchor.PayloadValue(0)).EndsWith(".RunAvalonia", StringComparison.Ordinal) && xaml is not null)
+    regions.Add(new("RunAvalonia_to_Xaml", anchor.TimeStampRelativeMSec, xaml.Start));
+var samples = events.OfType<SampledProfileTraceData>().Where(item => item.ThreadID == thread).ToArray();
+var modules = samples.SelectMany(Frames).Select(item => item.ModuleFile).Where(item => item is not null).Distinct().ToArray();
+if (args.Length == 3)
+{
+    using var writer = File.CreateText(file + ".symbols.log");
+    using var symbols = new SymbolReader(writer, "srv*" + Path.GetFullPath("Temp/native-symbols") + "*https://msdl.microsoft.com/download/symbols");
+    string[] systemModules = ["dxgi", "d3d11", "ntdll", "kernelbase", "kernel32", "combase", "imagehlp", "wintrust", "crypt32"];
+    foreach (var module in modules.Where(item => systemModules.Contains(item!.Name, StringComparer.OrdinalIgnoreCase)))
+        log.CodeAddresses.LookupSymbolsForModule(symbols, module!);
+}
+var stacks = samples.Select(item => new Sample(item.TimeStampRelativeMSec,
+    Frames(item).Select(address => address.ModuleName + "!" +
+        (string.IsNullOrEmpty(address.FullMethodName) ? "0x" + address.Address.ToString("X", CultureInfo.InvariantCulture) : address.FullMethodName)).ToArray())).ToArray();
+var summaries = regions.Select(region =>
+{
+    var selected = stacks.Where(item => item.Time >= region.Start && item.Time <= region.End).ToArray();
+    return new { region.Name, StartMs = region.Start, EndMs = region.End, WallMs = region.End - region.Start, Samples = selected.Length,
+        TopExclusive = Counts(selected.Select(item => item.Frames.FirstOrDefault() ?? "[no stack]"), 25),
+        TopInclusive = Counts(selected.SelectMany(item => item.Frames.Distinct()), 80) };
+}).ToArray();
+var report = new { DiagnosticOnly = true,
+    Interpretation = "CPU samples are counts, not exact wall time; no context-switch/wait or GPU completion analysis. Nested phases and inclusive frames cannot be summed.",
+    Trace = file, ProcessId = pid, EventsLost = log.EventsLost, MainThread = thread, MarkerCount = marks.Length,
+    ResolvedMicrosoftSymbols = args.Length == 3, Regions = summaries,
+    Modules = modules.Select(item => new { item!.Name, item.FilePath }), Stacks = stacks };
+File.WriteAllText(file + ".analysis.json", JsonSerializer.Serialize(report, new JsonSerializerOptions { WriteIndented = true }));
+Console.WriteLine(JsonSerializer.Serialize(summaries.Select(item => new { item.Name, item.WallMs, item.Samples }), new JsonSerializerOptions { WriteIndented = true }));
+
+static IEnumerable<TraceCodeAddress> Frames(TraceEvent item)
+{
+    for (var stack = item.CallStack(); stack is not null; stack = stack.Caller) yield return stack.CodeAddress;
+}
+static object[] Counts(IEnumerable<string> names, int limit) => names.GroupBy(name => name).OrderByDescending(group => group.Count())
+    .Take(limit).Select(group => (object)new { Frame = group.Key, Samples = group.Count() }).ToArray();
+sealed record Region(string Name, double Start, double End);
+sealed record Sample(double Time, string[] Frames);
diff --git a/scripts/performance/analyze-startup-trace.cs b/scripts/performance/analyze-startup-trace.cs
new file mode 100644
index 00000000..c1b24ed5
--- /dev/null
+++ b/scripts/performance/analyze-startup-trace.cs
@@ -0,0 +1,86 @@
+#:property PublishAot=false
+#:property JsonSerializerIsReflectionEnabledByDefault=true
+#:package Microsoft.Diagnostics.Tracing.TraceEvent@3.1.21
+#:property ManagePackageVersionsCentrally=false
+using System.Text.Json;
+using Microsoft.Diagnostics.Tracing;
+using Microsoft.Diagnostics.Tracing.Etlx;
+using Microsoft.Diagnostics.Tracing.Parsers.Clr;
+
+if (args.Length != 1) throw new ArgumentException("Usage: dotnet run scripts/performance/analyze-startup-trace.cs -- <startup.nettrace>");
+var file = Path.GetFullPath(args[0]);
+var etlx = TraceLog.CreateFromEventPipeDataFile(file, file + ".etlx", new TraceLogOptions { LocalSymbolsOnly = true });
+using var log = new TraceLog(etlx);
+var marks = new List<Marker>();
+var pending = new Dictionary<string, JitStart>();
+var jits = new List<Jit>();
+var samples = new List<Sample>();
+var providerCounts = new Dictionary<string, int>();
+foreach (var data in log.Events)
+{
+    providerCounts[data.ProviderName] = providerCounts.GetValueOrDefault(data.ProviderName) + 1;
+    if (data.ProviderName == "GalNet-CPU" && data.ID == (TraceEventID)1)
+        marks.Add(new((string)data.PayloadValue(0), Convert.ToDouble(data.PayloadValue(2)),
+            Convert.ToDouble(data.PayloadValue(3)), data.TimeStampRelativeMSec, data.ThreadID));
+    if (data is MethodJittingStartedTraceData start)
+        pending[$"{start.ProcessID}/{start.MethodID}"] = new(start.TimeStampRelativeMSec,
+            start.MethodNamespace + "." + start.MethodName, start.ThreadID);
+    if (data is MethodLoadUnloadVerboseTraceData end &&
+        pending.Remove($"{end.ProcessID}/{end.MethodID}", out var first))
+        jits.Add(new(first.Name, first.Time, end.TimeStampRelativeMSec, first.Thread));
+    if (data.ProviderName == "Microsoft-DotNETCore-SampleProfiler")
+    {
+        var frames = new List<string>();
+        var stack = data.CallStack();
+        while (stack is not null)
+        {
+            frames.Add(string.IsNullOrEmpty(stack.CodeAddress.FullMethodName)
+                ? stack.CodeAddress.ModuleName + "+0x" + stack.CodeAddress.Address.ToString("X")
+                : stack.CodeAddress.FullMethodName);
+            stack = stack.Caller;
+        }
+        samples.Add(new(data.TimeStampRelativeMSec, data.ThreadID, frames));
+    }
+}
+if (log.EventsLost != 0) throw new InvalidDataException("Runtime trace lost events; do not use incomplete timings.");
+if (!marks.Any(item => item.Name == "Startup.Ready")) throw new InvalidDataException("No ready mirror event");
+var anchor = marks.FirstOrDefault(item => item.Name.EndsWith(".RunAvalonia", StringComparison.Ordinal))
+    ?? marks.Single(item => item.Name == "Startup.Ready");
+var offset = anchor.EventTime - anchor.StartUs / 1000;
+var uiThread = anchor.Thread;
+var regions = marks.Where(item => item.DurationUs >= 0)
+    .Select(item => new Region(item.Name, offset + item.StartUs / 1000,
+        offset + (item.StartUs + item.DurationUs) / 1000)).ToList();
+var xaml = regions.FirstOrDefault(item => item.Name.EndsWith(".Xaml", StringComparison.Ordinal));
+if (anchor.Name.EndsWith(".RunAvalonia", StringComparison.Ordinal) && xaml is not null)
+    regions.Add(new("RunAvalonia_to_Xaml", anchor.EventTime, xaml.Start));
+var summaries = regions.Select(region =>
+{
+    var intervals = jits.Where(item => item.Thread == uiThread && item.End > region.Start && item.Start < region.End)
+        .Select(item => (Start: Math.Max(item.Start, region.Start), End: Math.Min(item.End, region.End)))
+        .OrderBy(item => item.Start).ToArray();
+    double union = 0, last = double.NegativeInfinity;
+    foreach (var item in intervals) { union += Math.Max(0, item.End - Math.Max(last, item.Start)); last = Math.Max(last, item.End); }
+    var selected = samples.Where(item => item.Thread == uiThread && item.Time >= region.Start && item.Time <= region.End).ToArray();
+    var leaf = selected.Where(item => item.Frames.Count > 0).GroupBy(item => item.Frames[0])
+        .Select(group => new { Method = group.Key, Samples = group.Count() }).OrderByDescending(item => item.Samples).Take(15).ToArray();
+    var inclusive = selected.SelectMany(item => item.Frames.Distinct()).GroupBy(name => name)
+        .Select(group => new { Method = group.Key, Samples = group.Count() }).OrderByDescending(item => item.Samples).Take(20).ToArray();
+    return new { region.Name, WallMs = region.End - region.Start, MainThreadJitUnionMs = union,
+        MainThreadJitCount = intervals.Length, SampleCount = selected.Length, TopExclusive = leaf, TopInclusive = inclusive };
+}).ToArray();
+var startup = regions.Single(item => item.Name == "Startup.Total");
+var topJit = jits.Where(item => item.Start >= startup.Start && item.Start < startup.End)
+    .OrderByDescending(item => item.End - item.Start).Take(40)
+    .Select(item => new { item.Name, DurationMs = item.End - item.Start, item.Thread }).ToArray();
+var report = new { DiagnosticOnly = true,
+    Interpretation = "JIT event interval union is wall time, not CPU usage; samples may attribute native/JIT work to the nearest managed frame. Do not sum nested phases.",
+    Trace = file, EventsLost = log.EventsLost, MainThread = uiThread, MarkerCount = marks.Count, ProviderCounts = providerCounts,
+    JitCount = jits.Count, UnmatchedJitStarts = pending.Count, Regions = summaries, TopJit = topJit };
+File.WriteAllText(file + ".analysis.json", JsonSerializer.Serialize(report, new JsonSerializerOptions { WriteIndented = true }));
+Console.WriteLine(JsonSerializer.Serialize(summaries.Select(item => new { item.Name, item.WallMs, item.MainThreadJitUnionMs, item.MainThreadJitCount, item.SampleCount }), new JsonSerializerOptions { WriteIndented = true }));
+sealed record Marker(string Name, double StartUs, double DurationUs, double EventTime, int Thread);
+sealed record Region(string Name, double Start, double End);
+sealed record JitStart(double Time, string Name, int Thread);
+sealed record Jit(string Name, double Start, double End, int Thread);
+sealed record Sample(double Time, int Thread, List<string> Frames);
diff --git a/scripts/performance/benchmark-startup.ps1 b/scripts/performance/benchmark-startup.ps1
new file mode 100644
index 00000000..294e1dec
--- /dev/null
+++ b/scripts/performance/benchmark-startup.ps1
@@ -0,0 +1,132 @@
+[CmdletBinding()]
+param(
+    [ValidateSet('Editor', 'Sample')][string]$Target = 'Editor',
+    [ValidateSet('Debug', 'Release')][string]$Configuration = 'Release',
+    [ValidateRange(1, 1000)][int]$Iterations = 5,
+    [ValidateRange(0, 100)][int]$Warmup = 1,
+    [ValidateRange(1, 600)][int]$TimeoutSeconds = 60,
+    [string]$GameDirectory,
+    [string]$Profile,
+    [string]$OutputDirectory,
+    [string]$Executable,
+    [switch]$SkipBuild
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+$repositoryRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+$assemblyName = if ($Target -eq 'Editor') { 'GalNet.Editor' } else { 'GalNet.Sample.Avalonia' }
+$group = if ($Target -eq 'Editor') { 'Editor' } else { 'Samples' }
+$projectDirectory = Join-Path $repositoryRoot "src/$group/$assemblyName"
+if (-not $OutputDirectory) {
+    $OutputDirectory = Join-Path $repositoryRoot ('out/benchmarks/' + $Target + '-' + (Get-Date -Format 'yyyyMMdd-HHmmss-fff'))
+}
+$OutputDirectory = [IO.Path]::GetFullPath($OutputDirectory)
+$null = New-Item -ItemType Directory -Path $OutputDirectory -Force
+if ($Target -eq 'Sample') {
+    if (-not $GameDirectory) { throw 'Sample requires -GameDirectory pointing to built game content. Build content separately.' }
+    $GameDirectory = (Resolve-Path -LiteralPath $GameDirectory).Path
+    if ($Profile) { $Profile = [IO.Path]::GetFullPath($Profile) }
+}
+
+$buildMilliseconds = $null
+if (-not $SkipBuild) {
+    $buildWatch = [Diagnostics.Stopwatch]::StartNew()
+    $launchProperties = if ($Target -eq 'Sample') { @('-p:EnableLaunchArguments=true') } else { @() }
+    & dotnet build (Join-Path $projectDirectory "$assemblyName.csproj") -c $Configuration -p:Benchmark=true @launchProperties -p:UseSharedCompilation=false -m:1 -nr:false -v:minimal *> (Join-Path $OutputDirectory 'build.log')
+    $buildWatch.Stop()
+    if ($LASTEXITCODE -ne 0) { throw "Benchmark build failed. See $OutputDirectory/build.log" }
+    $buildMilliseconds = $buildWatch.Elapsed.TotalMilliseconds
+}
+if ($Executable -and -not $SkipBuild) { throw '-Executable requires -SkipBuild; build and snapshot candidates before comparing.' }
+$executable = if ($Executable) { [IO.Path]::GetFullPath($Executable) } else { Join-Path $projectDirectory "bin/benchmark/$Configuration/net10.0/$assemblyName.exe" }
+if (-not (Test-Path -LiteralPath $executable)) { throw "Executable missing: $executable" }
+$runs = [Collections.Generic.List[object]]::new()
+for ($index = 0; $index -lt ($Warmup + $Iterations); $index++) {
+    $kind = if ($index -lt $Warmup) { 'warmup' } else { 'measured' }
+    $runName = '{0}-{1:D3}' -f $kind, $index
+    $tracePath = Join-Path $OutputDirectory "$runName.json"
+    if (Test-Path -LiteralPath $tracePath) { throw "Trace already exists: $tracePath. Use a new output directory." }
+    $startInfo = [Diagnostics.ProcessStartInfo]::new($executable)
+    $startInfo.WorkingDirectory = Split-Path -Parent $executable
+    $startInfo.UseShellExecute = $false
+    $startInfo.CreateNoWindow = $true
+    $startInfo.WindowStyle = [Diagnostics.ProcessWindowStyle]::Hidden
+    $startInfo.RedirectStandardOutput = $true
+    $startInfo.RedirectStandardError = $true
+    $startInfo.Environment['GALNET_BENCHMARK_OUTPUT'] = $tracePath
+    $startInfo.Environment['GALNET_BENCHMARK_EXIT'] = '1'
+    if ($Target -eq 'Sample') {
+        $startInfo.ArgumentList.Add($GameDirectory)
+        if ($Profile) {
+            $startInfo.ArgumentList.Add('--profile')
+            $startInfo.ArgumentList.Add($Profile)
+        }
+    }
+    $process = [Diagnostics.Process]::new()
+    $process.StartInfo = $startInfo
+    $runWatch = [Diagnostics.Stopwatch]::StartNew()
+    $started = $false
+    try {
+        $null = $process.Start()
+        $started = $true
+        $stdout = $process.StandardOutput.ReadToEndAsync()
+        $stderr = $process.StandardError.ReadToEndAsync()
+        $timedOut = -not $process.WaitForExit($TimeoutSeconds * 1000)
+        if ($timedOut) {
+            $process.Kill($true)
+            $process.WaitForExit()
+        }
+        $runWatch.Stop()
+        $stdout.GetAwaiter().GetResult() | Set-Content (Join-Path $OutputDirectory "$runName.stdout.log")
+        $stderr.GetAwaiter().GetResult() | Set-Content (Join-Path $OutputDirectory "$runName.stderr.log")
+        if ($timedOut) { throw "Startup timed out: $runName. Sample language selection requires an initialized profile." }
+        if ($process.ExitCode -ne 0) { throw "Startup failed: $runName (exit $($process.ExitCode)). See run logs." }
+    }
+    finally {
+        # Own only the child created by this iteration; never stop another Editor/game.
+        if ($started -and -not $process.HasExited) { $process.Kill($true); $process.WaitForExit() }
+        $process.Dispose()
+    }
+    if (-not (Test-Path -LiteralPath $tracePath)) { throw "No trace from $runName. Rebuild with -p:Benchmark=true." }
+    $trace = Get-Content -LiteralPath $tracePath -Raw | ConvertFrom-Json
+    if ($trace.droppedEvents -ne 0) { throw "Trace overflow: $runName" }
+    if (-not @($trace.traceEvents | Where-Object name -eq 'Startup.Ready').Count) { throw "Startup did not reach ready: $runName" }
+    $durations = @($trace.traceEvents | Where-Object ph -eq 'X')
+    if (@($durations | Where-Object name -eq 'Startup.Total').Count -ne 1) { throw "Invalid startup total: $runName" }
+    $runs.Add([pscustomobject]@{ Run = $runName; Warmup = ($kind -eq 'warmup'); ProcessLifetimeMs = $runWatch.Elapsed.TotalMilliseconds; Events = $durations })
+    $total = ($durations | Where-Object name -eq 'Startup.Total').dur / 1000
+    Write-Host ('{0}: Startup.Total = {1:F2} ms' -f $runName, $total)
+}
+$rows = foreach ($run in $runs) {
+    if ($run.Warmup) { continue }
+    foreach ($event in $run.Events) {
+        [pscustomobject]@{ Run = $run.Run; Stage = $event.name; Milliseconds = $event.dur / 1000 }
+    }
+}
+$summary = @($rows | Group-Object Stage | ForEach-Object {
+    $values = @($_.Group.Milliseconds | Sort-Object)
+    $count = $values.Count
+    $median = if ($count % 2) { $values[[int][Math]::Floor($count / 2)] } else { ($values[$count / 2 - 1] + $values[$count / 2]) / 2 }
+    [pscustomobject]@{
+        Stage = $_.Name; Samples = $count
+        MedianMs = $median
+        P95Ms = $values[[Math]::Ceiling($count * 0.95) - 1]
+        MinMs = $values[0]; MaxMs = $values[-1]
+    }
+} | Sort-Object MedianMs -Descending)
+$rows | Export-Csv (Join-Path $OutputDirectory 'measurements.csv') -NoTypeInformation
+$summary | Export-Csv (Join-Path $OutputDirectory 'summary.csv') -NoTypeInformation
+$metadata = [ordered]@{
+    Target = $Target; Configuration = $Configuration; Iterations = $Iterations; Warmup = $Warmup
+    BuildMilliseconds = $buildMilliseconds; Utc = [DateTime]::UtcNow.ToString('O')
+    Commit = (& git -C $repositoryRoot rev-parse HEAD); DirtyFiles = @(& git -C $repositoryRoot status --short)
+    OS = [Environment]::OSVersion.ToString(); ProcessorCount = [Environment]::ProcessorCount
+    Dotnet = (& dotnet --version); GameDirectory = $GameDirectory; Profile = $Profile
+    Executable = $executable
+    AssemblySha256 = (Get-FileHash -Algorithm SHA256 -LiteralPath (Join-Path (Split-Path $executable) "$assemblyName.dll")).Hash
+    Runs = @($runs | Select-Object Run, Warmup, ProcessLifetimeMs)
+}
+$metadata | ConvertTo-Json -Depth 5 | Set-Content (Join-Path $OutputDirectory 'metadata.json')
+$summary | Format-Table Stage, Samples, MedianMs, P95Ms -AutoSize
+Write-Host "Results: $OutputDirectory"
diff --git a/scripts/performance/compare-startup.ps1 b/scripts/performance/compare-startup.ps1
new file mode 100644
index 00000000..d8811cc9
--- /dev/null
+++ b/scripts/performance/compare-startup.ps1
@@ -0,0 +1,41 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Baseline,
+    [Parameter(Mandatory)][string]$Candidate,
+    [Parameter(Mandatory)][string]$OutputDirectory,
+    [ValidateSet('Editor', 'Sample')][string]$Target = 'Editor',
+    [string]$GameDirectory,
+    [string]$Profile,
+    [ValidateRange(3, 100)][int]$Pairs = 10
+)
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+$OutputDirectory = [IO.Path]::GetFullPath($OutputDirectory)
+$null = New-Item -ItemType Directory -Force -Path $OutputDirectory
+$executables = @{ A = [IO.Path]::GetFullPath($Baseline); B = [IO.Path]::GetFullPath($Candidate) }
+$benchmark = Join-Path $PSScriptRoot 'benchmark-startup.ps1'
+foreach ($label in @('A', 'B')) {
+    & $benchmark -Target $Target -GameDirectory $GameDirectory -Profile $Profile -SkipBuild -Executable $executables[$label] -Warmup 0 -Iterations 1 -OutputDirectory (Join-Path $OutputDirectory "warmup-$label") *> (Join-Path $OutputDirectory "warmup-$label.log")
+}
+$results = [Collections.Generic.List[object]]::new()
+for ($pair = 0; $pair -lt $Pairs; $pair++) {
+    # AB, BA alternation balances order effects; both candidates use the same ready milestone.
+    $order = if ($pair % 2) { @('B', 'A') } else { @('A', 'B') }
+    foreach ($label in $order) {
+        $runDirectory = Join-Path $OutputDirectory ('pair-{0:D2}-{1}' -f $pair, $label)
+        & $benchmark -Target $Target -GameDirectory $GameDirectory -Profile $Profile -SkipBuild -Executable $executables[$label] -Warmup 0 -Iterations 1 -OutputDirectory $runDirectory *> "$runDirectory.log"
+        $trace = Get-Content (Join-Path $runDirectory 'measured-000.json') -Raw | ConvertFrom-Json
+        $total = ($trace.traceEvents | Where-Object name -eq 'Startup.Total').dur / 1000
+        $results.Add([pscustomobject]@{ Pair = $pair; Label = $label; Milliseconds = $total })
+    }
+    Write-Host ('Pair {0}/{1} complete' -f ($pair + 1), $Pairs)
+}
+$results | Export-Csv (Join-Path $OutputDirectory 'comparison.csv') -NoTypeInformation
+$statistics = foreach ($label in @('A', 'B')) {
+    $values = @($results | Where-Object Label -eq $label | Select-Object -ExpandProperty Milliseconds | Sort-Object)
+    $count = $values.Count
+    $median = if ($count % 2) { $values[[int][Math]::Floor($count / 2)] } else { ($values[$count / 2 - 1] + $values[$count / 2]) / 2 }
+    [pscustomobject]@{ Label = $label; Samples = $count; MedianMs = $median; P95Ms = $values[[Math]::Ceiling($count * 0.95) - 1] }
+}
+$statistics | Export-Csv (Join-Path $OutputDirectory 'summary.csv') -NoTypeInformation
+$statistics | Format-Table -AutoSize
diff --git a/scripts/performance/packages.lock.json b/scripts/performance/packages.lock.json
new file mode 100644
index 00000000..d5010b1a
--- /dev/null
+++ b/scripts/performance/packages.lock.json
@@ -0,0 +1,73 @@
+{
+  "version": 1,
+  "dependencies": {
+    "net10.0": {
+      "Microsoft.Diagnostics.Tracing.TraceEvent": {
+        "type": "Direct",
+        "requested": "[3.1.21, )",
+        "resolved": "3.1.21",
+        "contentHash": "/OrJFKaojSR6TkUKtwh8/qA9XWNtxLrXMqvEb89dBSKCWjaGVTbKMYodIUgF5deCEtmd6GXuRerciXGl5bhZ7Q==",
+        "dependencies": {
+          "Microsoft.Diagnostics.NETCore.Client": "0.2.510501",
+          "System.Reflection.TypeExtensions": "4.7.0"
+        }
+      },
+      "Microsoft.Diagnostics.NETCore.Client": {
+        "type": "Transitive",
+        "resolved": "0.2.510501",
+        "contentHash": "juoqJYMDs+lRrrZyOkXXMImJHneCF23cuvO4waFRd2Ds7j+ZuGIPbJm0Y/zz34BdeaGiiwGWraMUlln05W1PCQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Logging": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "k6PWQMuoBDGGHOQTtyois2u4AwyVcIwL2LaSLlTZQm2CYcJ1pxbt6jfAnpWmzENA/wfrYRI/X9DTLoUkE4AsLw==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "xlzi2IYREJH3/m6+lUrQlujzX8wDitm4QGnUu6kUXTQAWPuZY8i+ticFJbzfqaetLA6KR/rO6Ew/HuYD+bxifg=="
+      },
+      "Microsoft.Extensions.Logging": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "eIbyj40QDg1NDz0HBW0S5f3wrLVnKWnDJ/JtZ+yJDFnDj90VoPuoPmFkeaXrtu+0cKm5GRAwoDf+dBWXK0TUdg==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection": "6.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Logging.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Options": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "/HggWBbTwy8TgebGSX5DBZ24ndhzi93sHUBDvP1IxbZD7FDokYzdAr6+vbWGjw2XAfR2EJ1sfKUotpjHnFWPxA=="
+      },
+      "Microsoft.Extensions.Options": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "dzXN0+V1AyjOe2xcJ86Qbo233KHuLEY0njf/P2Kw8SfJU+d45HNS2ctJdnEnrWbM9Ye2eFgaC5Mj9otRMU6IsQ==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "6.0.0",
+          "Microsoft.Extensions.Primitives": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "9+PnzmQFfEFNR9J2aDTfJGGupShHjOuGw4VUv+JB044biSHrnmCIMD+mJHmb2H7YryrfBEXDurxQ47gJZdCKNQ=="
+      },
+      "System.Reflection.TypeExtensions": {
+        "type": "Transitive",
+        "resolved": "4.7.0",
+        "contentHash": "VybpaOQQhqE6siHppMktjfGBw1GCwvCqiufqmP8F1nj7fTUNtW35LOEt3UZTEsECfo+ELAl/9o9nJx3U91i7vA=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/scripts/performance/profile-startup-native.ps1 b/scripts/performance/profile-startup-native.ps1
new file mode 100644
index 00000000..b7764590
--- /dev/null
+++ b/scripts/performance/profile-startup-native.ps1
@@ -0,0 +1,73 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Executable,
+    [string]$OutputDirectory,
+    [string[]]$ApplicationArguments = @(),
+    [ValidateRange(10, 600)][int]$TimeoutSeconds = 60
+)
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+$repositoryRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+$Executable = (Resolve-Path -LiteralPath $Executable).Path
+if (-not $OutputDirectory) {
+    $OutputDirectory = Join-Path $repositoryRoot ('out/benchmarks/native-' + (Get-Date -Format 'yyyyMMdd-HHmmss-fff'))
+}
+$OutputDirectory = [IO.Path]::GetFullPath($OutputDirectory)
+$null = New-Item -ItemType Directory -Path $OutputDirectory -ErrorAction Stop
+$wpr = (Get-Command wpr.exe -ErrorAction Stop).Source
+$state = & $wpr -status 2>&1 | Out-String
+$state | Set-Content (Join-Path $OutputDirectory 'wpr-before.log')
+# Fail closed for an existing recorder or an unrecognized/localized status.
+if ($state -notmatch 'WPR is not recording') { throw 'WPR is not confirmed idle; existing recordings are never stopped.' }
+$trace = Join-Path $OutputDirectory 'startup.etl'
+$cpuPath = Join-Path $OutputDirectory 'startup.cpu.json'
+$profile = (Join-Path $PSScriptRoot 'startup-native.wprp') + '!StartupCPU'
+$process = [Diagnostics.Process]::new()
+$startInfo = [Diagnostics.ProcessStartInfo]::new($Executable)
+$startInfo.WorkingDirectory = Split-Path -Parent $Executable
+$startInfo.UseShellExecute = $false
+$startInfo.CreateNoWindow = $true
+$startInfo.WindowStyle = [Diagnostics.ProcessWindowStyle]::Hidden
+$startInfo.RedirectStandardOutput = $true
+$startInfo.RedirectStandardError = $true
+$startInfo.Environment['GALNET_BENCHMARK_OUTPUT'] = $cpuPath
+$startInfo.Environment['GALNET_BENCHMARK_EXIT'] = '1'
+$startInfo.Environment['GALNET_BENCHMARK_EVENTPIPE'] = '1'
+foreach ($argument in $ApplicationArguments) { $startInfo.ArgumentList.Add($argument) }
+$process.StartInfo = $startInfo
+$recording = $false
+$started = $false
+try {
+    & $wpr -start $profile -filemode *> (Join-Path $OutputDirectory 'wpr-start.log')
+    if ($LASTEXITCODE -ne 0) { throw 'WPR start failed; see wpr-start.log. An elevated terminal is required.' }
+    $recording = $true
+    $null = $process.Start()
+    $started = $true
+    $stdout = $process.StandardOutput.ReadToEndAsync()
+    $stderr = $process.StandardError.ReadToEndAsync()
+    $timedOut = -not $process.WaitForExit($TimeoutSeconds * 1000)
+    if ($timedOut) { $process.Kill($true); $process.WaitForExit() }
+    $stdout.GetAwaiter().GetResult() | Set-Content (Join-Path $OutputDirectory 'stdout.log')
+    $stderr.GetAwaiter().GetResult() | Set-Content (Join-Path $OutputDirectory 'stderr.log')
+    [ordered]@{
+        Executable = $Executable
+        ProcessId = $process.Id
+        ExitCode = $process.ExitCode
+        AssemblySha256 = (Get-FileHash -Algorithm SHA256 -LiteralPath ([IO.Path]::ChangeExtension($Executable, '.dll'))).Hash
+        Utc = [DateTime]::UtcNow.ToString('O')
+        DiagnosticOnly = $true
+    } | ConvertTo-Json | Set-Content (Join-Path $OutputDirectory 'metadata.json')
+    if ($timedOut) { throw 'Startup timed out; only this child process tree was stopped.' }
+    if ($process.ExitCode -ne 0) { throw "Startup failed (exit $($process.ExitCode)); see stderr.log." }
+    $cpu = Get-Content -LiteralPath $cpuPath -Raw | ConvertFrom-Json
+    if ($cpu.droppedEvents -ne 0 -or -not @($cpu.traceEvents | Where-Object name -eq 'Startup.Ready').Count) { throw 'CPU capture incomplete.' }
+}
+finally {
+    if ($started -and -not $process.HasExited) { $process.Kill($true); $process.WaitForExit() }
+    $process.Dispose()
+    if ($recording) {
+        & $wpr -stop $trace *> (Join-Path $OutputDirectory 'wpr-stop.log')
+        if ($LASTEXITCODE -ne 0) { throw 'WPR stop failed; inspect wpr-stop.log and recorder status.' }
+    }
+}
+Write-Host "Native trace captured: $trace. Analyze event loss before using it."
diff --git a/scripts/performance/profile-startup.ps1 b/scripts/performance/profile-startup.ps1
new file mode 100644
index 00000000..b0455699
--- /dev/null
+++ b/scripts/performance/profile-startup.ps1
@@ -0,0 +1,70 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Executable,
+    [string]$TraceTool = 'dotnet-trace',
+    [string]$OutputDirectory,
+    [string[]]$ApplicationArguments = @(),
+    [ValidateRange(10, 600)][int]$TimeoutSeconds = 60
+)
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+$repositoryRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+$Executable = (Resolve-Path -LiteralPath $Executable).Path
+$traceCommand = (Get-Command $TraceTool -ErrorAction Stop).Source
+if (-not $OutputDirectory) {
+    $OutputDirectory = Join-Path $repositoryRoot ('out/benchmarks/profile-' + (Get-Date -Format 'yyyyMMdd-HHmmss-fff'))
+}
+$OutputDirectory = [IO.Path]::GetFullPath($OutputDirectory)
+$null = New-Item -ItemType Directory -Force -Path $OutputDirectory
+$tracePath = Join-Path $OutputDirectory 'startup.nettrace'
+$cpuPath = Join-Path $OutputDirectory 'startup.cpu.json'
+if ((Test-Path -LiteralPath $tracePath) -or (Test-Path -LiteralPath $cpuPath)) { throw 'Capture already exists; use a new output directory.' }
+$startInfo = [Diagnostics.ProcessStartInfo]::new($traceCommand)
+$startInfo.WorkingDirectory = Split-Path -Parent $Executable
+$startInfo.UseShellExecute = $false
+$startInfo.CreateNoWindow = $true
+$startInfo.WindowStyle = [Diagnostics.ProcessWindowStyle]::Hidden
+$startInfo.RedirectStandardOutput = $true
+$startInfo.RedirectStandardError = $true
+$startInfo.Environment['GALNET_BENCHMARK_OUTPUT'] = $cpuPath
+$startInfo.Environment['GALNET_BENCHMARK_EXIT'] = '1'
+$startInfo.Environment['GALNET_BENCHMARK_EVENTPIPE'] = '1'
+foreach ($argument in @('collect', '--profile', 'dotnet-sampled-thread-time', '--providers',
+    'Microsoft-Windows-DotNETRuntime:0x1C:5,GalNet-CPU:0xFFFFFFFFFFFFFFFF:4',
+    '--output', $tracePath, '--', $Executable) + $ApplicationArguments) {
+    $startInfo.ArgumentList.Add($argument)
+}
+$process = [Diagnostics.Process]::new()
+$process.StartInfo = $startInfo
+$started = $false
+try {
+    $null = $process.Start()
+    $started = $true
+    $stdout = $process.StandardOutput.ReadToEndAsync()
+    $stderr = $process.StandardError.ReadToEndAsync()
+    $timedOut = -not $process.WaitForExit($TimeoutSeconds * 1000)
+    if ($timedOut) { $process.Kill($true); $process.WaitForExit() }
+    $stdout.GetAwaiter().GetResult() | Set-Content (Join-Path $OutputDirectory 'trace.stdout.log')
+    $stderr.GetAwaiter().GetResult() | Set-Content (Join-Path $OutputDirectory 'trace.stderr.log')
+    if ($timedOut) { throw 'Trace capture timed out; only this capture process tree was stopped.' }
+    if ($process.ExitCode -ne 0) { throw "dotnet-trace failed (exit $($process.ExitCode)); see capture logs." }
+}
+finally {
+    if ($started -and -not $process.HasExited) { $process.Kill($true); $process.WaitForExit() }
+    $process.Dispose()
+}
+if (-not (Test-Path -LiteralPath $tracePath)) { throw 'No runtime trace produced.' }
+$cpu = Get-Content -LiteralPath $cpuPath -Raw | ConvertFrom-Json
+if ($cpu.droppedEvents -ne 0 -or -not @($cpu.traceEvents | Where-Object name -eq 'Startup.Ready').Count) { throw 'CPU capture incomplete.' }
+$assemblyPath = Join-Path (Split-Path $Executable) ([IO.Path]::GetFileNameWithoutExtension($Executable) + '.dll')
+[ordered]@{
+    Executable = $Executable
+    AssemblySha256 = (Get-FileHash -Algorithm SHA256 -LiteralPath $assemblyPath).Hash
+    ToolVersion = (& $traceCommand --version)
+    Commit = (& git -C $repositoryRoot rev-parse HEAD)
+    Utc = [DateTime]::UtcNow.ToString('O')
+    Providers = 'Microsoft-Windows-DotNETRuntime:0x1C:5,GalNet-CPU:0xFFFFFFFFFFFFFFFF:4'
+    Profile = 'dotnet-sampled-thread-time'
+    TimingUse = 'Diagnostic only; do not compare instrumented elapsed times as benchmark results.'
+} | ConvertTo-Json | Set-Content (Join-Path $OutputDirectory 'metadata.json')
+Write-Host "Startup trace captured: $tracePath"
diff --git a/scripts/performance/startup-native.wprp b/scripts/performance/startup-native.wprp
new file mode 100644
index 00000000..c6ed198a
--- /dev/null
+++ b/scripts/performance/startup-native.wprp
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<WindowsPerformanceRecorder Version="1.0" Author="GalNet">
+  <Profiles>
+    <SystemCollector Id="Kernel" Name="GalNet startup CPU">
+      <BufferSize Value="256" />
+      <Buffers Value="128" />
+    </SystemCollector>
+    <EventCollector Id="Events" Name="GalNet startup phases">
+      <BufferSize Value="64" />
+      <Buffers Value="64" />
+    </EventCollector>
+    <SystemProvider Id="KernelProvider">
+      <Keywords><Keyword Value="ProcessThread" /><Keyword Value="Loader" /><Keyword Value="SampledProfile" /></Keywords>
+      <Stacks><Stack Value="SampledProfile" /></Stacks>
+    </SystemProvider>
+    <!-- EventSource's deterministic GUID for GalNet-CPU. -->
+    <EventProvider Id="Phases" Name="b73a0b39-c81d-5026-2e0f-108dad0eff68" Level="4" />
+    <Profile Id="StartupCPU.Verbose.File" Name="StartupCPU" Description="Native CPU samples and GalNet startup phases" LoggingMode="File" DetailLevel="Verbose">
+      <Collectors>
+        <SystemCollectorId Value="Kernel"><SystemProviderId Value="KernelProvider" /></SystemCollectorId>
+        <EventCollectorId Value="Events"><EventProviders><EventProviderId Value="Phases" /></EventProviders></EventCollectorId>
+      </Collectors>
+    </Profile>
+  </Profiles>
+</WindowsPerformanceRecorder>
diff --git a/scripts/release/Common.ps1 b/scripts/release/Common.ps1
new file mode 100644
index 00000000..d3416f06
--- /dev/null
+++ b/scripts/release/Common.ps1
@@ -0,0 +1,37 @@
+$ErrorActionPreference = 'Stop'
+$repoRoot = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../..'))
+
+function Invoke-ReleaseCommand([string]$Name, [string]$Command, [string[]]$Arguments) {
+    $log = Join-Path $script:logRoot "$Name.log"
+    Write-Host "[$Name] $Command $($Arguments -join ' ')"
+    & $Command @Arguments *> $log
+    if ($LASTEXITCODE -ne 0) {
+        Get-Content -LiteralPath $log -Tail 60 | Write-Host
+        throw "$Name failed ($LASTEXITCODE). Log: $log"
+    }
+}
+
+function Get-ReleaseVersion([string]$Version, [string]$Tag) {
+    if ($Tag) {
+        if ($Version) { throw 'Pass Version or Tag, not both.' }
+        if ($Tag -notmatch '^v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-preview\.(0|[1-9][0-9]*))?$') { throw 'Invalid release tag.' }
+        $tagCommit = & git -C $repoRoot rev-parse "$Tag^{commit}"
+        if ($LASTEXITCODE -ne 0) { throw 'Tag does not exist.' }
+        $headCommit = & git -C $repoRoot rev-parse HEAD
+        if ($tagCommit -ne $headCommit) { throw 'Release tag must point exactly to HEAD.' }
+        if (& git -C $repoRoot status --porcelain) { throw 'Tag releases require a clean working tree.' }
+        return $Tag.Substring(1)
+    }
+    if (!$Version) {
+        $count = & git -C $repoRoot rev-list --count HEAD
+        if ($LASTEXITCODE -ne 0) { throw 'Cannot determine local version.' }
+        $Version = "0.0.0-dev.$count"
+    }
+    if ($Version -notmatch '^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-(preview|dev)\.(0|[1-9][0-9]*))?$') { throw 'Version must be x.y.z, x.y.z-preview.N or x.y.z-dev.N.' }
+    return $Version
+}
+
+function Write-ReleaseZip([string]$Source, [string]$Destination) {
+    if (Test-Path -LiteralPath $Destination) { throw "Refusing to overwrite $Destination" }
+    [IO.Compression.ZipFile]::CreateFromDirectory($Source, $Destination, [IO.Compression.CompressionLevel]::Optimal, $false)
+}
diff --git a/scripts/release/Pack-NuGet.ps1 b/scripts/release/Pack-NuGet.ps1
new file mode 100644
index 00000000..5f75be2d
--- /dev/null
+++ b/scripts/release/Pack-NuGet.ps1
@@ -0,0 +1,103 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Version,
+    [Parameter(Mandatory)][string]$OutputDirectory,
+    [Parameter(Mandatory)][string]$WorkDirectory,
+    [switch]$SkipBuild
+)
+. (Join-Path $PSScriptRoot 'Common.ps1')
+$Version = Get-ReleaseVersion $Version ''
+$OutputDirectory = [IO.Path]::GetFullPath($OutputDirectory)
+$WorkDirectory = [IO.Path]::GetFullPath($WorkDirectory)
+$script:logRoot = Join-Path $WorkDirectory 'logs'
+New-Item -ItemType Directory -Force -Path $OutputDirectory, $logRoot | Out-Null
+$mapping = Get-Content (Join-Path $repoRoot 'packaging/packages.json') -Raw | ConvertFrom-Json -AsHashtable
+$commit = & git -C $repoRoot rev-parse HEAD
+$buildProperties = @("-p:Version=$Version", '-p:ContinuousIntegrationBuild=true', '-p:UseSharedCompilation=false', '-m:1', '-nr:false')
+if (!$SkipBuild) {
+    Invoke-ReleaseCommand 'restore-libraries' 'dotnet' (@('restore', (Join-Path $repoRoot 'GalNet.slnx'), '--locked-mode', '-p:Configuration=Release') + $buildProperties)
+    Invoke-ReleaseCommand 'build-libraries' 'dotnet' (@('build', (Join-Path $repoRoot 'GalNet.slnx'), '-c', 'Release', '--no-restore') + $buildProperties)
+}
+
+# All project ownership and dependency mapping is explicit. Each DLL belongs to one package.
+$owners = @{}
+foreach ($packageId in $mapping.Keys) {
+    foreach ($project in $mapping[$packageId].projects) {
+        $name = Split-Path $project -Leaf
+        if ($owners.ContainsKey($name)) { throw "Duplicate package owner for $name" }
+        $owners[$name] = $packageId
+    }
+}
+
+foreach ($packageId in $mapping.Keys) {
+    $spec = $mapping[$packageId]
+    $isGenerator = $packageId -eq 'GalNet.SchemaGenerator'
+    $framework = if ($isGenerator) { 'netstandard2.0' } else { 'net10.0' }
+    $payload = Join-Path $WorkDirectory $packageId
+    if (Test-Path -LiteralPath $payload) { throw "Use a fresh WorkDirectory: $payload" }
+    New-Item -ItemType Directory -Path $payload | Out-Null
+    Copy-Item (Join-Path $repoRoot 'LICENSE') (Join-Path $payload 'LICENSE')
+    $spec.description | Set-Content (Join-Path $payload 'README.md') -Encoding utf8
+    $dependencies = [ordered]@{}
+    foreach ($dependency in $spec.dependencies) { $dependencies[$dependency] = @{ version = "[$Version]"; exclude = 'Build,Analyzers' } }
+    foreach ($project in $spec.projects) {
+        $name = Split-Path $project -Leaf
+        $projectRoot = Join-Path $repoRoot "src/$project"
+        $dllRoot = Join-Path $projectRoot "bin/Release/$framework"
+        $assemblyVersion = [Reflection.AssemblyName]::GetAssemblyName((Join-Path $dllRoot "$name.dll")).Version.ToString()
+        $expectedVersion = $Version.Split('-')[0] + '.0'
+        if ($assemblyVersion -ne $expectedVersion) { throw "Stale assembly $name ($assemblyVersion); expected $expectedVersion. Build this release version before packing." }
+        $destination = Join-Path $payload $(if ($isGenerator) { 'analyzers/dotnet/cs' } else { "lib/$framework" })
+        New-Item -ItemType Directory -Force -Path $destination | Out-Null
+        Copy-Item (Join-Path $dllRoot "$name.dll") $destination
+        if (Test-Path (Join-Path $dllRoot "$name.xml")) { Copy-Item (Join-Path $dllRoot "$name.xml") $destination }
+        $assets = Get-Content (Join-Path $projectRoot 'obj/project.assets.json') -Raw | ConvertFrom-Json -AsHashtable
+        foreach ($reference in $assets.project.restore.frameworks[$framework].projectReferences.Keys) {
+            $referenceName = [IO.Path]::GetFileNameWithoutExtension($reference)
+            if (!$owners.ContainsKey($referenceName)) { throw "Unmapped project dependency: $name -> $referenceName" }
+            # Analyzer ProjectReferences are build-only and do not become runtime dependencies.
+            if ($referenceName -eq 'GalNet.SchemaGenerator') { continue }
+            $owner = $owners[$referenceName]
+            if ($owner -ne $packageId) {
+                # A direct package dependency is valid even if another dependency already brings it transitively.
+                $dependencies[$owner] = @{ version = "[$Version]"; exclude = 'Build,Analyzers' }
+            }
+        }
+        $packageDependencies = $assets.project.frameworks[$framework].dependencies
+        if (!$packageDependencies) { $packageDependencies = @{} }
+        foreach ($entry in $packageDependencies.GetEnumerator()) {
+            $info = $entry.Value
+            if ($info.autoReferenced -or $info.suppressParent -eq 'All') { continue }
+            $dependency = @{ version = $info.version; exclude = 'Build,Analyzers' }
+            if ($info.include) { $dependency.include = $info.include }
+            if ($info.exclude) { $dependency.exclude = $info.exclude }
+            if ($dependencies.Contains($entry.Key) -and $dependencies[$entry.Key].version -ne $dependency.version) { throw "Inconsistent dependency $($entry.Key) in $packageId" }
+            $dependencies[$entry.Key] = $dependency
+        }
+    }
+    if ($packageId -eq 'GalNet.Desktop') {
+        $native = Join-Path $payload 'runtimes/win-x64/native'
+        New-Item -ItemType Directory -Force -Path $native | Out-Null
+        Copy-Item (Join-Path $repoRoot 'src/Infrastructure/GalNet.Media.Miniaudio/obj/native/win-x64/galnet_miniaudio.dll') $native
+    }
+    $document = [xml]'<package><metadata/><files><file src="**/*" target="" /></files></package>'
+    $metadata = $document.SelectSingleNode('/package/metadata')
+    foreach ($entry in ([ordered]@{ id = $packageId; version = $Version; authors = 'GalNet contributors'; description = $spec.description; readme = 'README.md' }).GetEnumerator()) {
+        $element = $document.CreateElement($entry.Key); $element.InnerText = $entry.Value
+        [void]$metadata.AppendChild($element)
+    }
+    $license = $document.CreateElement('license'); $license.SetAttribute('type', 'file'); $license.InnerText = 'LICENSE'; [void]$metadata.AppendChild($license)
+    $repository = $document.CreateElement('repository'); $repository.SetAttribute('type', 'git'); $repository.SetAttribute('url', 'https://github.com/StarryXYJ/Gal.Net'); $repository.SetAttribute('commit', $commit); [void]$metadata.AppendChild($repository)
+    $dependencyNode = $document.CreateElement('dependencies')
+    $group = $document.CreateElement('group'); $group.SetAttribute('targetFramework', $framework)
+    foreach ($dependencyId in $dependencies.Keys) {
+        $node = $document.CreateElement('dependency'); $node.SetAttribute('id', $dependencyId)
+        foreach ($key in $dependencies[$dependencyId].Keys) { $node.SetAttribute($key, $dependencies[$dependencyId][$key]) }
+        [void]$group.AppendChild($node)
+    }
+    [void]$dependencyNode.AppendChild($group); [void]$metadata.AppendChild($dependencyNode)
+    $nuspec = Join-Path $WorkDirectory "$packageId.nuspec"
+    $document.Save($nuspec)
+    Invoke-ReleaseCommand "pack-$packageId" 'dotnet' @('pack', (Join-Path $repoRoot 'packaging/Bundle.csproj'), '-c', 'Release', '-o', $OutputDirectory, "-p:NuspecFile=$nuspec", "-p:NuspecBasePath=$payload", "-p:PackageVersion=$Version", '-p:NuGetAudit=false')
+}
+Write-Host "NuGet packages: $OutputDirectory"
diff --git a/scripts/release/Publish.ps1 b/scripts/release/Publish.ps1
new file mode 100644
index 00000000..559787ef
--- /dev/null
+++ b/scripts/release/Publish.ps1
@@ -0,0 +1,355 @@
+[CmdletBinding()]
+param(
+    [ValidateSet('Editor', 'Sample', 'SampleIntegrated', 'All')]
+    [string]$Package = 'All',
+    [string]$Version,
+    [string]$OutputRoot,
+    [string]$ProjectDirectory,
+    [string]$Galpak,
+    [string]$ContractOutputDirectory,
+    [ValidateSet('SelfContained', 'FrameworkDependent')]
+    [string]$Deployment = 'SelfContained',
+    [ValidateSet('Player', 'Developer')]
+    [string]$SampleFlavor = 'Player',
+    [switch]$IncludeModeInName
+)
+
+$ErrorActionPreference = 'Stop'
+$repoRoot = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../..'))
+$headlessProject = Join-Path $repoRoot 'src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj'
+$selfContained = $Deployment -eq 'SelfContained'
+$deploymentProperty = "-p:SelfContained=$($selfContained.ToString().ToLowerInvariant())"
+$sampleDebugging = ($SampleFlavor -eq 'Developer').ToString().ToLowerInvariant()
+
+if ([string]::IsNullOrWhiteSpace($Version)) {
+    $tag = (& git -C $repoRoot describe --tags --exact-match --match 'v[0-9]*' 2>$null)
+    if ($LASTEXITCODE -eq 0 -and $tag -match '^v(.+)$') { $Version = $Matches[1] }
+    else { $Version = '0.1.0-dev' }
+}
+if ($Version -notmatch '^[0-9]+\.[0-9]+\.[0-9]+(?:-(?:preview\.[0-9]+|dev(?:\.[0-9]+)?))?$') {
+    throw "Version '$Version' must use MAJOR.MINOR.PATCH or MAJOR.MINOR.PATCH-preview.N (dev is allowed for local builds)."
+}
+if ([string]::IsNullOrWhiteSpace($OutputRoot)) { $OutputRoot = Join-Path $repoRoot 'out/release' }
+$OutputRoot = [IO.Path]::GetFullPath($OutputRoot)
+$versionRoot = Join-Path $OutputRoot $Version
+$stagingRoot = Join-Path $OutputRoot '.staging'
+$dotnetLogsRoot = Join-Path $stagingRoot 'logs'
+New-Item -ItemType Directory -Path $versionRoot -Force | Out-Null
+New-Item -ItemType Directory -Path $stagingRoot -Force | Out-Null
+New-Item -ItemType Directory -Path $dotnetLogsRoot -Force | Out-Null
+
+if ($Package -in @('SampleIntegrated', 'All') -and [string]::IsNullOrWhiteSpace($Galpak) -and [string]::IsNullOrWhiteSpace($ProjectDirectory)) {
+    $ProjectDirectory = Join-Path $repoRoot 'GameTestCase'
+}
+if (![string]::IsNullOrWhiteSpace($Galpak)) {
+    $Galpak = (Resolve-Path -LiteralPath $Galpak).Path
+    if (![string]::Equals([IO.Path]::GetExtension($Galpak), '.galpak', [StringComparison]::OrdinalIgnoreCase)) {
+        throw 'The integration input must be a .galpak file.'
+    }
+}
+if (![string]::IsNullOrWhiteSpace($ProjectDirectory)) {
+    $ProjectDirectory = (Resolve-Path -LiteralPath $ProjectDirectory).Path
+    if (!(Test-Path -LiteralPath (Join-Path $ProjectDirectory 'Graph/graph.json'))) {
+        throw "ProjectDirectory does not contain Graph/graph.json: $ProjectDirectory"
+    }
+}
+
+function Invoke-DotNet([string[]]$Arguments, [switch]$JsonOutput) {
+    # Runtime CLI arguments must not receive MSBuild properties.
+    $properties = @("-p:Version=$Version", '-p:ContinuousIntegrationBuild=true')
+    $separator = [Array]::IndexOf($Arguments, '--')
+    if ($separator -ge 0) {
+        $Arguments = @($Arguments[0..($separator - 1)]) + $properties + @($Arguments[$separator..($Arguments.Length - 1)])
+    }
+    else { $Arguments += $properties }
+    $logPath = Join-Path $dotnetLogsRoot "dotnet-$([guid]::NewGuid().ToString('N')).log"
+    Write-Host "[apps] dotnet $($Arguments[0]) $($Arguments[1])"
+    & dotnet @Arguments *> $logPath
+    $exitCode = $LASTEXITCODE
+    if ($exitCode -ne 0) {
+        $details = Get-Content -LiteralPath $logPath -Tail 80 | Out-String
+        throw "dotnet $($Arguments -join ' ') failed with exit code $exitCode. Log: $logPath`n$details"
+    }
+    Write-Host "[apps] completed; log: $logPath"
+    if ($JsonOutput) { return Get-Content -LiteralPath $logPath -Raw | ConvertFrom-Json }
+}
+
+function Get-RelativePath([string]$BasePath, [string]$Path) {
+    $base = [IO.Path]::GetFullPath($BasePath).TrimEnd('\', '/') + [IO.Path]::DirectorySeparatorChar
+    $target = [IO.Path]::GetFullPath($Path)
+    $baseUri = [Uri]::new($base)
+    $targetUri = [Uri]::new($target)
+    return [Uri]::UnescapeDataString($baseUri.MakeRelativeUri($targetUri).ToString()).Replace('/', [IO.Path]::DirectorySeparatorChar)
+}
+
+function Copy-ContentTree([string]$Source, [string]$Target, [string[]]$Names) {
+    foreach ($name in $Names) {
+        $sourcePath = Join-Path $Source $name
+        if (!(Test-Path -LiteralPath $sourcePath)) { continue }
+        if ((Get-Item -LiteralPath $sourcePath -Force).Attributes -band [IO.FileAttributes]::ReparsePoint) {
+            throw "Content cannot be a symbolic link: $sourcePath"
+        }
+        if (Test-Path -LiteralPath $sourcePath -PathType Leaf) {
+            $targetPath = Join-Path $Target $name
+            New-Item -ItemType Directory -Path (Split-Path -Parent $targetPath) -Force | Out-Null
+            Copy-Item -LiteralPath $sourcePath -Destination $targetPath
+            continue
+        }
+
+        $pending = [Collections.Generic.Stack[string]]::new()
+        $pending.Push($sourcePath)
+        while ($pending.Count -gt 0) {
+            $directory = $pending.Pop()
+            if ((Get-Item -LiteralPath $directory -Force).Attributes -band [IO.FileAttributes]::ReparsePoint) {
+                throw "Content cannot contain symbolic links: $directory"
+            }
+            $relativeDirectory = Get-RelativePath $Source $directory
+            New-Item -ItemType Directory -Path (Join-Path $Target $relativeDirectory) -Force | Out-Null
+            foreach ($item in Get-ChildItem -LiteralPath $directory -Force) {
+                if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) {
+                    throw "Content cannot contain symbolic links: $($item.FullName)"
+                }
+                if ($item.PSIsContainer) { $pending.Push($item.FullName); continue }
+                $relativeFile = Get-RelativePath $Source $item.FullName
+                $destination = Join-Path $Target $relativeFile
+                New-Item -ItemType Directory -Path (Split-Path -Parent $destination) -Force | Out-Null
+                Copy-Item -LiteralPath $item.FullName -Destination $destination
+            }
+        }
+    }
+}
+
+function Copy-PublishedFiles([string]$Source, [string]$Target, [string[]]$ExcludedRootFiles = @()) {
+    foreach ($file in Get-ChildItem -LiteralPath $Source -File -Recurse) {
+        $relative = Get-RelativePath $Source $file.FullName
+        if ($ExcludedRootFiles -contains $relative.Replace('\', '/')) { continue }
+        $destination = Join-Path $Target $relative
+        New-Item -ItemType Directory -Path (Split-Path -Parent $destination) -Force | Out-Null
+        Copy-Item -LiteralPath $file.FullName -Destination $destination
+    }
+}
+
+function Add-PackageManifest([string]$PackageRoot, [string]$Kind) {
+    $files = @(Get-ChildItem -LiteralPath $PackageRoot -File -Recurse |
+        Sort-Object { (Get-RelativePath $PackageRoot $_.FullName).Replace('\', '/') } |
+        ForEach-Object {
+            $relative = (Get-RelativePath $PackageRoot $_.FullName).Replace('\', '/')
+            $hash = (Get-FileHash -LiteralPath $_.FullName -Algorithm SHA256).Hash.ToLowerInvariant()
+            [ordered]@{ path = $relative; size = $_.Length; sha256 = $hash }
+        })
+    $commit = (& git -C $repoRoot rev-parse HEAD 2>$null)
+    if ($LASTEXITCODE -ne 0) { $commit = $null }
+    $manifest = [ordered]@{
+        schemaVersion = 1
+        product = 'GalNet'
+        version = $Version
+        package = $Kind
+        runtime = 'win-x64'
+        selfContained = $selfContained
+        readyToRun = $true
+        sourceCommit = $commit
+        sampleFlavor = if ($Kind.StartsWith('Sample')) { $SampleFlavor } else { $null }
+        files = $files
+    }
+    $manifest | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath (Join-Path $PackageRoot 'docs/release-manifest.json') -Encoding utf8
+}
+
+function Set-PackageLayout([string]$PackageRoot) {
+    $rootPath = [IO.Path]::GetFullPath($PackageRoot).TrimEnd('\', '/') + [IO.Path]::DirectorySeparatorChar
+    $libraryRoot = Join-Path $PackageRoot 'lib'
+    $documentsRoot = Join-Path $PackageRoot 'docs'
+    New-Item -ItemType Directory -Force -Path $libraryRoot, $documentsRoot | Out-Null
+    foreach ($item in Get-ChildItem -LiteralPath $PackageRoot -Force) {
+        if ($item.Name -in @('lib', 'docs', 'pak', 'Skills', 'GalNet.Editor.exe', 'GalNet.Editor.Headless.exe', 'GalNet.Sample.Avalonia.exe')) { continue }
+        $destination = Join-Path $(if ($item.Name -in @('README.txt', 'README.md', 'LICENSE')) { $documentsRoot } else { $libraryRoot }) $item.Name
+        if (!$item.FullName.StartsWith($rootPath, [StringComparison]::OrdinalIgnoreCase) -or
+            ![IO.Path]::GetFullPath($destination).StartsWith($rootPath, [StringComparison]::OrdinalIgnoreCase)) {
+            throw 'Refusing to move files outside the application payload.'
+        }
+        Move-Item -LiteralPath $item.FullName -Destination $destination -Force
+    }
+}
+
+function Complete-Package([string]$Kind, [string]$PackageRoot) {
+    # Some native NuGet content ignores the publish RID and symbol-copy setting.
+    # Filter the final payload, including the nested CLI, before hashing it.
+    $payloadRoot = [IO.Path]::GetFullPath($PackageRoot).TrimEnd('\', '/') + [IO.Path]::DirectorySeparatorChar
+    $unwanted = @(Get-ChildItem -LiteralPath $PackageRoot -Recurse -File | Where-Object {
+        ($_.Extension -eq '.pdb' -and !($Kind.StartsWith('Sample') -and $SampleFlavor -eq 'Developer')) -or
+        (Get-RelativePath $PackageRoot $_.FullName).Replace('\', '/') -match '(^|/)libvlc/win-(x86|arm64)/'
+    })
+    foreach ($file in $unwanted) {
+        if (!$file.FullName.StartsWith($payloadRoot, [StringComparison]::OrdinalIgnoreCase)) {
+            throw "Refusing to remove a file outside the release payload: $($file.FullName)"
+        }
+        Remove-Item -LiteralPath $file.FullName -Force
+    }
+    Copy-Item -LiteralPath (Join-Path $repoRoot 'LICENSE') -Destination (Join-Path $PackageRoot 'LICENSE') -Force
+    Set-PackageLayout $PackageRoot
+    if (!$selfContained) {
+        @'
+
+Requires the Windows x64 .NET 10 Runtime (latest servicing patch).
+Install the .NET Runtime, not the SDK; this Avalonia app does not require
+the Windows Desktop Runtime or ASP.NET Core Runtime.
+Download: https://dotnet.microsoft.com/download/dotnet/10.0
+'@ | Add-Content -LiteralPath (Join-Path $PackageRoot 'docs/README.txt') -Encoding utf8
+    }
+    Add-PackageManifest $PackageRoot $Kind
+    $modeSuffix = if ($IncludeModeInName) { '-r2r' } else { '' }
+    if (!$selfContained) { $modeSuffix += '-framework-dependent' }
+    if ($Kind.StartsWith('Sample') -and $SampleFlavor -eq 'Developer') { $modeSuffix += '-developer' }
+    $zipName = "GalNet-$Kind-$Version-win-x64$modeSuffix.zip"
+    $zipPath = Join-Path $versionRoot $zipName
+    if (Test-Path -LiteralPath $zipPath) { Remove-Item -LiteralPath $zipPath -Force }
+    if (Test-Path -LiteralPath "$zipPath.sha256") { Remove-Item -LiteralPath "$zipPath.sha256" -Force }
+    Compress-Archive -Path (Join-Path $PackageRoot '*') -DestinationPath $zipPath -CompressionLevel Optimal
+    $hash = (Get-FileHash -LiteralPath $zipPath -Algorithm SHA256).Hash.ToLowerInvariant()
+    Set-Content -LiteralPath "$zipPath.sha256" -Value "$hash  $zipName" -Encoding ascii
+    Write-Output $zipPath
+}
+
+function Publish-Editor {
+    $stage = Join-Path $stagingRoot "$Version-Editor-$([guid]::NewGuid().ToString('N'))"
+    $hostRoot = Join-Path $stage 'payload'
+    New-Item -ItemType Directory -Path $hostRoot -Force | Out-Null
+    try {
+        $project = Join-Path $repoRoot 'src/Editor/GalNet.Editor/GalNet.Editor.csproj'
+        Invoke-DotNet @('restore', $project, '-r', 'win-x64', '-p:PublishProfile=WindowsReadyToRun', $deploymentProperty, '--locked-mode', '-p:NuGetAudit=false', '-m:1', '-nr:false')
+        Invoke-DotNet @('publish', $project, '-c', 'Release', '-r', 'win-x64', '--no-restore', '-p:PublishProfile=WindowsReadyToRun', $deploymentProperty, "-p:PackageAppHostDestinationPath=$hostRoot/GalNet.Editor.exe", '-p:UseSharedCompilation=false', '-m:1', '-nr:false', '-o', $hostRoot)
+        $cliRoot = Join-Path $stage 'cli'
+        Invoke-DotNet @('restore', $headlessProject, '-r', 'win-x64', '-p:PublishProfile=WindowsReadyToRun', $deploymentProperty, '--locked-mode', '-p:NuGetAudit=false', '-m:1', '-nr:false')
+        Invoke-DotNet @('publish', $headlessProject, '-c', 'Release', '-r', 'win-x64', '--no-restore', '-p:PublishProfile=WindowsReadyToRun', $deploymentProperty, "-p:PackageAppHostDestinationPath=$cliRoot/GalNet.Editor.Headless.exe", '-p:UseSharedCompilation=false', '-m:1', '-nr:false', '-o', $cliRoot)
+        # Both apphosts target lib/<app>.dll. Merge only
+        # byte-identical shared files; never silently replace an Editor dependency.
+        foreach ($file in Get-ChildItem -LiteralPath $cliRoot -Recurse -File) {
+            if ($file.Extension -eq '.pdb' -or $file.Name -eq 'README.md') { continue }
+            $destination = Join-Path $hostRoot (Get-RelativePath $cliRoot $file.FullName)
+            if (Test-Path -LiteralPath $destination) {
+                if ((Get-FileHash $destination).Hash -ne (Get-FileHash $file.FullName).Hash) {
+                    throw "Editor/CLI dependency collision: $destination"
+                }
+            }
+            else {
+                New-Item -ItemType Directory -Force -Path (Split-Path $destination -Parent) | Out-Null
+                Copy-Item -LiteralPath $file.FullName -Destination $destination
+            }
+        }
+        @'
+GalNet Editor
+
+Run GalNet.Editor.exe to start the editor.
+Run GalNet.Editor.Headless.exe help to use the CLI. Keep both executables
+in this directory; they share dependencies and (in the full package) .NET.
+'@ | Set-Content -LiteralPath (Join-Path $hostRoot 'README.txt') -Encoding utf8
+        Complete-Package 'Editor' $hostRoot
+    }
+    finally { Remove-Stage $stage }
+}
+
+function Add-GameContent([string]$Stage, [string]$PackageRoot, [string]$ContractsRoot) {
+    $contentBuildRoot = Join-Path $Stage 'GameTestCase'
+    $contentRoot = Join-Path $PackageRoot 'pak'
+    if (![string]::IsNullOrWhiteSpace($Galpak)) {
+        Invoke-DotNet @('run', '--project', $headlessProject, '--configuration', 'Release', '--no-launch-profile', '--no-build', '--no-restore', '--', 'galpak', 'install', $Galpak, '--output', $contentRoot)
+        $inspection = Invoke-DotNet @('run', '--project', $headlessProject, '--configuration', 'Release', '--no-launch-profile', '--no-build', '--no-restore', '--', 'game', 'inspect', $contentRoot) -JsonOutput
+        $buildId = $inspection.data.buildId
+        if ($buildId -cnotmatch '^[a-f0-9]{64}$') { throw 'Integrated content has an invalid buildId.' }
+        foreach ($patches in @("StoryPatches/$buildId", 'ResourcePatches')) {
+            $patchSource = Join-Path (Split-Path -Parent $Galpak) $patches
+            if (Test-Path -LiteralPath $patchSource) { Copy-ContentTree (Split-Path -Parent $Galpak) $contentRoot @($patches) }
+        }
+        return
+    }
+    if ([string]::IsNullOrWhiteSpace($ProjectDirectory)) { throw 'Pass either -ProjectDirectory or -Galpak for SampleIntegrated.' }
+    New-Item -ItemType Directory -Path $contentBuildRoot -Force | Out-Null
+    Copy-ContentTree $ProjectDirectory $contentBuildRoot @('Assets', 'Graph', 'I18n', 'settings.json')
+    $isDefaultSample = [IO.Path]::GetFullPath($ProjectDirectory).TrimEnd('\') -eq [IO.Path]::GetFullPath((Join-Path $repoRoot 'GameTestCase')).TrimEnd('\')
+    if (!$isDefaultSample -and (Test-Path -LiteralPath (Join-Path $ProjectDirectory 'Contracts'))) {
+        Copy-ContentTree $ProjectDirectory $contentBuildRoot @('Contracts')
+    }
+    else {
+        if (Test-Path (Join-Path $ContractsRoot 'lib/GalNet.Core.dll')) { $ContractsRoot = Join-Path $ContractsRoot 'lib' }
+        $targetContracts = Join-Path $contentBuildRoot 'Contracts'
+        New-Item -ItemType Directory -Force -Path $targetContracts | Out-Null
+        foreach ($name in @('GalNet.Core.dll', 'GalNet.Contracts.Builtins.dll', 'GalNet.Project.Contracts.dll')) {
+            Copy-Item -LiteralPath (Join-Path $ContractsRoot $name) -Destination $targetContracts
+        }
+    }
+    Invoke-DotNet @('run', '--project', $headlessProject, '--configuration', 'Release', '--no-launch-profile', '--no-build', '--no-restore', '--', 'project', 'export-directory', $contentBuildRoot, '--output', $contentRoot)
+}
+
+function Publish-SamplePackages([switch]$IncludePure, [switch]$IncludeIntegrated) {
+    $stage = Join-Path $stagingRoot "$Version-Sample-$([guid]::NewGuid().ToString('N'))"
+    $runtimeRoot = Join-Path $stage 'runtime'
+    New-Item -ItemType Directory -Path $runtimeRoot -Force | Out-Null
+    try {
+        $project = Join-Path $repoRoot 'src/Samples/GalNet.Sample.Avalonia/GalNet.Sample.Avalonia.csproj'
+        Invoke-DotNet @('restore', $project, '-r', 'win-x64', '-p:PublishProfile=WindowsReadyToRun', $deploymentProperty, "-p:EnableGameDebugging=$sampleDebugging", '--locked-mode', '-p:NuGetAudit=false', '-m:1', '-nr:false')
+        Invoke-DotNet @('publish', $project, '-c', 'Release', '-r', 'win-x64', '--no-restore', '-p:PublishProfile=WindowsReadyToRun', $deploymentProperty, "-p:EnableGameDebugging=$sampleDebugging", "-p:EnableLaunchArguments=$sampleDebugging", "-p:CopyOutputSymbolsToPublishDirectory=$sampleDebugging", "-p:PackageAppHostDestinationPath=$runtimeRoot/GalNet.Sample.Avalonia.exe", '-p:UseSharedCompilation=false', '-m:1', '-nr:false', '-o', $runtimeRoot)
+
+        if ($ContractOutputDirectory) {
+            New-Item -ItemType Directory -Force -Path $ContractOutputDirectory | Out-Null
+            foreach ($name in @('GalNet.Core.dll', 'GalNet.Contracts.Builtins.dll', 'GalNet.Project.Contracts.dll')) {
+                Copy-Item -LiteralPath (Join-Path $runtimeRoot $name) -Destination $ContractOutputDirectory -Force
+            }
+        }
+
+        if ($IncludePure) {
+            foreach ($directory in @('StoryPatches', 'ResourcePatches', 'I18n')) {
+                New-Item -ItemType Directory -Force -Path (Join-Path $runtimeRoot "pak/$directory") | Out-Null
+            }
+            @'
+GalNet Sample
+
+Place the expanded game content in pak/ beside GalNet.Sample.Avalonia.exe,
+then double-click the executable. New .galpak archives already contain pak/;
+extract them into the application directory. Keep lib/ intact.
+Player data and logs are stored under the user's local application data,
+in GalNet/<project identity digest>/, independently of the installation path.
+The developer flavor also supports content, --profile and --debug-* arguments.
+'@ | Set-Content -LiteralPath (Join-Path $runtimeRoot 'README.txt') -Encoding utf8
+            Complete-Package 'Sample' $runtimeRoot
+        }
+
+        if ($IncludeIntegrated) {
+            $packageRoot = Join-Path $stage 'integrated-payload'
+            New-Item -ItemType Directory -Path $packageRoot -Force | Out-Null
+            $excluded = if ($IncludePure) { @('docs/README.txt', 'docs/release-manifest.json') } else { @() }
+            Copy-PublishedFiles $runtimeRoot $packageRoot $excluded
+            Add-GameContent $stage $packageRoot $runtimeRoot
+            @'
+GalNet Sample with compiled GameTestCase content
+
+Double-click GalNet.Sample.Avalonia.exe. Compiled content is in pak/;
+resources and story data are stored in pak/Assets/Paks/*.pak, with optional
+story packages in pak/StoryPatches/. Keep lib/ and pak/ beside the executable.
+Player data and logs are stored in the user's local application data.
+'@ | Set-Content -LiteralPath (Join-Path $packageRoot 'README.txt') -Encoding utf8
+            Complete-Package 'Sample-GameTestCase' $packageRoot
+        }
+    }
+    finally { Remove-Stage $stage }
+}
+
+function Remove-Stage([string]$Stage) {
+    if (!(Test-Path -LiteralPath $Stage)) { return }
+    $resolvedStage = [IO.Path]::GetFullPath($Stage).TrimEnd('\', '/')
+    $resolvedStagingRoot = [IO.Path]::GetFullPath($stagingRoot).TrimEnd('\', '/') + [IO.Path]::DirectorySeparatorChar
+    if (!$resolvedStage.StartsWith($resolvedStagingRoot, [StringComparison]::OrdinalIgnoreCase)) {
+        throw "Refusing to remove a release staging directory outside $stagingRoot"
+    }
+    Remove-Item -LiteralPath $resolvedStage -Recurse -Force
+}
+
+if ($Package -in @('SampleIntegrated', 'All')) {
+    Invoke-DotNet @('restore', $headlessProject, '--locked-mode', '-p:NuGetAudit=false', '-m:1', '-nr:false')
+    Invoke-DotNet @('build', $headlessProject, '-c', 'Release', '--no-restore', '-m:1', '-p:UseSharedCompilation=false')
+}
+
+if ($Package -in @('Editor', 'All')) { Publish-Editor }
+if ($Package -in @('Sample', 'SampleIntegrated', 'All')) {
+    Publish-SamplePackages -IncludePure:($Package -in @('Sample', 'All')) -IncludeIntegrated:($Package -in @('SampleIntegrated', 'All'))
+}
+
+Write-Output "Release packages are in $versionRoot"
diff --git a/scripts/release/Push.ps1 b/scripts/release/Push.ps1
new file mode 100644
index 00000000..bc175498
--- /dev/null
+++ b/scripts/release/Push.ps1
@@ -0,0 +1,77 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Index,
+    [ValidateSet('NuGet', 'GitHub')][string[]]$Destination = @('NuGet', 'GitHub')
+)
+. (Join-Path $PSScriptRoot 'Common.ps1')
+$Index = (Resolve-Path -LiteralPath $Index).Path
+$root = Split-Path $Index -Parent
+$release = Get-Content -LiteralPath $Index -Raw | ConvertFrom-Json
+if ($release.schemaVersion -ne 1 -or $release.dirty -or !$release.tag -or $release.tag -cne "v$($release.version)") { throw 'Push requires a clean, exact-tag release index.' }
+if ($release.packageValidationSkipped -or ($Destination -contains 'NuGet' -and !$release.packageValidation.passed)) { throw 'NuGet consumer validation is required.' }
+if ($Destination -contains 'NuGet' -and !$env:NUGET_API_KEY) { throw 'NUGET_API_KEY is required (a short-lived Trusted Publishing key is supported).' }
+$remote = (& git -C $repoRoot remote get-url origin).Trim()
+if ($remote -notmatch 'github\.com[:/](?<repository>[^/]+/[^/]+?)(?:\.git)?$') { throw 'Push currently requires a github.com origin remote.' }
+$githubRepository = $Matches.repository
+$paths = @{}
+foreach ($file in $release.files) {
+    if ([IO.Path]::IsPathRooted($file.path)) { throw 'Index paths must be relative.' }
+    $path = [IO.Path]::GetFullPath((Join-Path $root $file.path))
+    if (!$path.StartsWith($root.TrimEnd('\', '/') + [IO.Path]::DirectorySeparatorChar, [StringComparison]::OrdinalIgnoreCase)) { throw 'Index path escaped release directory.' }
+    $actual = (Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash.ToLowerInvariant()
+    if ($actual -cne $file.sha256 -or (Get-Item $path).Length -ne $file.size) { throw "Release file changed: $($file.path)" }
+    $paths[$file.path] = $path
+}
+$tagCommit = & git -C $repoRoot rev-parse --verify "$($release.tag)^{commit}" 2>$null
+if ($LASTEXITCODE -ne 0 -or $tagCommit -cne $release.sourceCommit) { throw 'Release tag commit does not match the sealed source commit.' }
+$assets = @($release.files | Where-Object { $_.path.StartsWith('assets/') } | ForEach-Object { $paths[$_.path] })
+if ($Destination -contains 'GitHub' -and $assets.Count -ne 7) { throw 'Expected seven verified R2R/Contracts release ZIPs.' }
+$indexHash = (Get-FileHash $Index -Algorithm SHA256).Hash
+$statePath = Join-Path $root 'push-state.json'
+$state = @{ indexHash = $indexHash; completed = @() }
+if (Test-Path -LiteralPath $statePath) {
+    $state = Get-Content $statePath -Raw | ConvertFrom-Json -AsHashtable
+    if ($state.indexHash -cne $indexHash) { throw 'Push journal belongs to a different index.' }
+}
+function Save-PushStep([string]$Step) {
+    $state.completed += $Step
+    $state | ConvertTo-Json -Depth 4 | Set-Content $statePath -Encoding utf8
+}
+if ($Destination -contains 'GitHub' -and $state.completed -notcontains 'github-draft') {
+    & gh release create $release.tag --repo $githubRepository --verify-tag --draft --title "GalNet $($release.version)" --generate-notes
+    if ($LASTEXITCODE -ne 0) { throw 'Creating release draft failed. Existing releases are not overwritten.' }
+    Save-PushStep 'github-draft'
+}
+if ($Destination -contains 'NuGet') {
+    $mapping = Get-Content (Join-Path $repoRoot 'packaging/packages.json') -Raw | ConvertFrom-Json -AsHashtable
+    foreach ($id in $mapping.Keys) {
+        $step = "nuget-$id"
+        if ($state.completed -contains $step) { continue }
+        $relative = "nuget/$id.$($release.version).nupkg"
+        if (!$paths.ContainsKey($relative)) { throw "Missing $relative" }
+        # Never skip an unknown duplicate: a version conflict needs explicit investigation.
+        & dotnet nuget push $paths[$relative] --source https://api.nuget.org/v3/index.json --api-key $env:NUGET_API_KEY
+        if ($LASTEXITCODE -ne 0) { throw "NuGet push failed: $id. Resume using the same index and push journal." }
+        Save-PushStep $step
+    }
+}
+if ($Destination -contains 'GitHub') {
+    if ($state.completed -notcontains 'github-assets') {
+        foreach ($asset in @($assets) + @($Index, (Join-Path $root 'SHA256SUMS'))) {
+            $step = 'github-asset-' + [IO.Path]::GetFileName($asset)
+            if ($state.completed -contains $step) { continue }
+            & gh release upload $release.tag $asset --repo $githubRepository
+            if ($LASTEXITCODE -ne 0) { throw "Uploading release asset failed: $asset" }
+            Save-PushStep $step
+        }
+        Save-PushStep 'github-assets'
+    }
+    if ($state.completed -notcontains 'github-published') {
+        $arguments = @('release', 'edit', $release.tag, '--repo', $githubRepository, '--draft=false')
+        if ($release.version -match '-preview\.') { $arguments += '--prerelease' }
+        & gh @arguments
+        if ($LASTEXITCODE -ne 0) { throw 'Publishing release draft failed.' }
+        Save-PushStep 'github-published'
+    }
+}
+Write-Host "Upload completed. Journal: $statePath"
diff --git a/scripts/release/Release.ps1 b/scripts/release/Release.ps1
new file mode 100644
index 00000000..45b09ffd
--- /dev/null
+++ b/scripts/release/Release.ps1
@@ -0,0 +1,76 @@
+[CmdletBinding()]
+param(
+    [string]$Version,
+    [string]$Tag,
+    [ValidateSet('All', 'NuGet', 'Apps')][string]$Target = 'All',
+    [ValidateSet('R2R', 'Aot', 'Both')][string]$SampleMode = 'R2R',
+    [ValidateSet('Player', 'Developer')][string]$SampleFlavor = 'Player',
+    [string]$OutputRoot,
+    [switch]$SkipPackageValidation
+)
+. (Join-Path $PSScriptRoot 'Common.ps1')
+$Version = Get-ReleaseVersion $Version $Tag
+if ($SampleMode -ne 'R2R') {
+    throw 'Desktop Sample NativeAOT is not release-ready: strict native linking reports JSON, reflection binding, DI and third-party trimming errors. Run scripts/release/Test-DesktopAot.ps1 for the diagnostic publish. R2R is the verified release mode; no fallback was performed.'
+}
+if (!$OutputRoot) { $OutputRoot = Join-Path $repoRoot 'out/release' }
+$OutputRoot = [IO.Path]::GetFullPath($OutputRoot)
+$versionRoot = Join-Path $OutputRoot $Version
+if (Test-Path -LiteralPath $versionRoot) { throw "Output already exists: $versionRoot. Use a fresh version or OutputRoot." }
+$work = Join-Path $OutputRoot ".work/$Version-$([guid]::NewGuid().ToString('N'))"
+$script:logRoot = Join-Path $work 'logs'
+New-Item -ItemType Directory -Force -Path $logRoot | Out-Null
+$candidate = Join-Path $work 'candidate'
+$nuget = Join-Path $candidate 'nuget'
+$assets = Join-Path $candidate 'assets'
+New-Item -ItemType Directory -Force -Path $nuget, $assets | Out-Null
+$commit = (& git -C $repoRoot rev-parse HEAD).Trim()
+$dirty = [bool](& git -C $repoRoot status --porcelain)
+$packageValidation = $null
+if ($Target -in @('All', 'NuGet')) {
+    & (Join-Path $PSScriptRoot 'Pack-NuGet.ps1') -Version $Version -OutputDirectory $nuget -WorkDirectory (Join-Path $work 'pack')
+    if (!$?) { throw 'NuGet packing failed.' }
+    if (!$SkipPackageValidation) {
+        & (Join-Path $PSScriptRoot 'Test-NuGet.ps1') -Version $Version -PackageDirectory $nuget -WorkDirectory (Join-Path $work 'validation')
+        if (!$?) { throw 'NuGet validation failed.' }
+        $packageValidation = Get-Content (Join-Path $work 'validation/package-validation.json') -Raw | ConvertFrom-Json
+    }
+}
+if ($Target -in @('All', 'Apps')) {
+    $contracts = Join-Path $work 'contracts'
+    foreach ($deployment in @('SelfContained', 'FrameworkDependent')) {
+        & (Join-Path $PSScriptRoot 'Publish.ps1') -Package All -Version $Version -OutputRoot (Join-Path $work 'apps') -ContractOutputDirectory $contracts -IncludeModeInName -Deployment $deployment -SampleFlavor $SampleFlavor
+        if (!$?) { throw "Application packaging failed: $deployment" }
+    }
+    Copy-Item (Join-Path $work "apps/$Version/*.zip") $assets
+    Copy-Item (Join-Path $repoRoot 'LICENSE') (Join-Path $contracts 'LICENSE')
+    @'
+Sample authoring contracts. Copy this complete directory into the Editor project's Contracts directory, then reopen the project.
+These IL DLLs match this release's Sample. They do not enable dynamic C# loading in a NativeAOT player.
+'@ | Set-Content (Join-Path $contracts 'README.txt') -Encoding utf8
+    $contractFiles = @(Get-ChildItem -LiteralPath $contracts -Filter '*.dll' | Sort-Object Name | ForEach-Object {
+        [ordered]@{ path = $_.Name; sha256 = (Get-FileHash $_.FullName -Algorithm SHA256).Hash.ToLowerInvariant() }
+    })
+    if ($contractFiles.Count -ne 3) { throw 'Expected three Sample contract closure DLLs.' }
+    [ordered]@{ version = $Version; sourceCommit = $commit; files = $contractFiles } | ConvertTo-Json -Depth 5 | Set-Content (Join-Path $contracts 'release-manifest.json') -Encoding utf8
+    Write-ReleaseZip $contracts (Join-Path $assets "GalNet-Sample-Contracts-$Version.zip")
+    $zipFiles = @(Get-ChildItem -LiteralPath $assets -Filter '*.zip')
+    if ($zipFiles.Count -ne 7) { throw "Expected 7 ZIP files; found $($zipFiles.Count)." }
+    & (Join-Path $PSScriptRoot 'Test-Release.ps1') -Version $Version -AssetDirectory $assets -WorkDirectory (Join-Path $work 'app-validation') -SampleFlavor $SampleFlavor
+    if (!$?) { throw 'Release payload verification failed.' }
+}
+$files = @(Get-ChildItem -LiteralPath $candidate -File -Recurse | Sort-Object FullName | ForEach-Object {
+    [ordered]@{ path = [IO.Path]::GetRelativePath($candidate, $_.FullName).Replace('\', '/'); size = $_.Length; sha256 = (Get-FileHash $_.FullName -Algorithm SHA256).Hash.ToLowerInvariant() }
+})
+$files | ForEach-Object { "$($_.sha256)  $($_.path)" } | Set-Content (Join-Path $candidate 'SHA256SUMS') -Encoding ascii
+$index = [ordered]@{
+    schemaVersion = 1; version = $Version; tag = $Tag; sourceCommit = $commit; dirty = $dirty
+    target = $Target; runtime = 'win-x64'; sampleModes = @('r2r'); sampleFlavor = $SampleFlavor; deployments = @('self-contained', 'framework-dependent'); packageValidation = $packageValidation
+    packageValidationSkipped = [bool]$SkipPackageValidation; files = $files; createdUtc = [DateTime]::UtcNow.ToString('O')
+}
+$index | ConvertTo-Json -Depth 8 | Set-Content (Join-Path $candidate 'release-index.json') -Encoding utf8
+# Only expose a release directory once every requested phase succeeded.
+New-Item -ItemType Directory -Force -Path $OutputRoot | Out-Null
+[IO.Directory]::Move($candidate, $versionRoot)
+Write-Host "Local release complete: $versionRoot"
+Write-Host "Evidence and logs: $work"
diff --git a/scripts/release/Test-DesktopAot.ps1 b/scripts/release/Test-DesktopAot.ps1
new file mode 100644
index 00000000..c79852ea
--- /dev/null
+++ b/scripts/release/Test-DesktopAot.ps1
@@ -0,0 +1,13 @@
+[CmdletBinding()]
+param([string]$OutputDirectory)
+. (Join-Path $PSScriptRoot 'Common.ps1')
+if (!$OutputDirectory) { $OutputDirectory = Join-Path $repoRoot "out/desktop-aot/$([guid]::NewGuid().ToString('N'))" }
+$OutputDirectory = [IO.Path]::GetFullPath($OutputDirectory)
+$script:logRoot = Join-Path $OutputDirectory 'logs'
+New-Item -ItemType Directory -Force -Path $logRoot | Out-Null
+Invoke-ReleaseCommand 'desktop-aot' 'dotnet' @('publish', (Join-Path $repoRoot 'src/Samples/GalNet.Sample.Avalonia/GalNet.Sample.Avalonia.csproj'),
+    '-c', 'Release', '-r', 'win-x64', '--self-contained', '--artifacts-path', (Join-Path $OutputDirectory 'artifacts'), '-o', (Join-Path $OutputDirectory 'publish'),
+    '-p:PublishAot=true', '-p:EnableGameDebugging=false', '-p:RestoreLockedMode=false', '-p:RestorePackagesWithLockFile=false',
+    "-p:NuGetLockFilePath=$(Join-Path $OutputDirectory 'probe.lock.json')", '-p:NuGetAudit=false', '-p:UseSharedCompilation=false',
+    '-p:ILLinkTreatWarningsAsErrors=true', '-p:IlcTreatWarningsAsErrors=true', '-p:TrimmerSingleWarn=false', '-m:1', '-nr:false')
+Write-Host 'Native compilation passed. Desktop runtime acceptance is still required before adding AOT to release artifacts.'
diff --git a/scripts/release/Test-NuGet.ps1 b/scripts/release/Test-NuGet.ps1
new file mode 100644
index 00000000..1cdc1cf4
--- /dev/null
+++ b/scripts/release/Test-NuGet.ps1
@@ -0,0 +1,106 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Version,
+    [Parameter(Mandatory)][string]$PackageDirectory,
+    [Parameter(Mandatory)][string]$WorkDirectory
+)
+. (Join-Path $PSScriptRoot 'Common.ps1')
+$PackageDirectory = [IO.Path]::GetFullPath($PackageDirectory)
+$WorkDirectory = [IO.Path]::GetFullPath($WorkDirectory)
+$script:logRoot = Join-Path $WorkDirectory 'logs'
+New-Item -ItemType Directory -Force -Path $logRoot | Out-Null
+$mapping = Get-Content (Join-Path $repoRoot 'packaging/packages.json') -Raw | ConvertFrom-Json -AsHashtable
+$owned = @{}
+foreach ($packageId in $mapping.Keys) {
+    $path = Join-Path $PackageDirectory "$packageId.$Version.nupkg"
+    $archive = [IO.Compression.ZipFile]::OpenRead($path)
+    try {
+        $specEntry = @($archive.Entries | Where-Object { $_.FullName.EndsWith('.nuspec') })
+        if ($specEntry.Count -ne 1) { throw "Invalid nuspec count in $path" }
+        $reader = [IO.StreamReader]::new($specEntry[0].Open())
+        try { [xml]$nuspec = $reader.ReadToEnd() } finally { $reader.Dispose() }
+        foreach ($dependency in $nuspec.SelectNodes('//*[local-name()="dependency"]')) {
+            if ($dependency.id.StartsWith('GalNet.') -and !$mapping.Contains($dependency.id)) { throw "Unpublished dependency $($dependency.id) in $path" }
+        }
+        $dlls = @($archive.Entries | Where-Object { $_.FullName -match '^lib/.*\.dll$|^analyzers/.*\.dll$' })
+        foreach ($dll in $dlls) {
+            $name = [IO.Path]::GetFileNameWithoutExtension($dll.FullName)
+            if ($owned.ContainsKey($name)) { throw "Duplicate DLL $name" }
+            $owned[$name] = $packageId
+        }
+        foreach ($project in $mapping[$packageId].projects) {
+            $name = Split-Path $project -Leaf
+            if ($owned[$name] -ne $packageId) { throw "Missing $name in $packageId" }
+        }
+        if ($packageId -eq 'GalNet.Desktop' -and !$archive.GetEntry('runtimes/win-x64/native/galnet_miniaudio.dll')) { throw 'Missing native audio asset.' }
+    }
+    finally { $archive.Dispose() }
+}
+
+# Outside the checkout: no Directory.Build.props, project references or central versions can hide a bad package.
+$consumerRoot = Join-Path ([IO.Path]::GetTempPath()) "galnet-consumer-$([guid]::NewGuid().ToString('N'))"
+New-Item -ItemType Directory -Path $consumerRoot | Out-Null
+$sources = @($PackageDirectory, 'https://api.nuget.org/v3/index.json')
+$sourceAssets = Get-Content (Join-Path $repoRoot 'src/Shared/GalNet.Core/obj/project.assets.json') -Raw | ConvertFrom-Json -AsHashtable
+# Installed package caches also form valid hierarchical offline feeds for third-party packages.
+$sources += @($sourceAssets.packageFolders.Keys)
+$configuration = [xml]'<configuration><packageSources><clear /></packageSources></configuration>'
+$index = 0
+foreach ($source in $sources) {
+    $node = $configuration.CreateElement('add'); $node.SetAttribute('key', "source$index"); $node.SetAttribute('value', $source)
+    [void]$configuration.configuration.packageSources.AppendChild($node); $index++
+}
+$configuration.Save((Join-Path $consumerRoot 'NuGet.Config'))
+$previousPackages = $env:NUGET_PACKAGES
+$env:NUGET_PACKAGES = Join-Path $consumerRoot 'packages'
+try {
+    foreach ($packageId in @('GalNet.Contracts', 'GalNet.Engine', 'GalNet.Desktop', 'GalNet.Avalonia')) {
+        $consumer = Join-Path $consumerRoot $packageId
+        New-Item -ItemType Directory -Path $consumer | Out-Null
+        @"
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup><TargetFramework>net10.0</TargetFramework><OutputType>Exe</OutputType><ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable></PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="$packageId" Version="[$Version]" />
+    <PackageReference Include="GalNet.SchemaGenerator" Version="[$Version]" PrivateAssets="all" />
+  </ItemGroup>
+</Project>
+"@ | Set-Content (Join-Path $consumer 'Consumer.csproj') -Encoding utf8
+        @'
+using GalNet.Core.Parameters;
+Console.WriteLine(ConsumerOptions.Schema is not null ? "PACKAGE_CONSUMER_OK" : throw new Exception("Generator missing"));
+foreach (var library in Directory.EnumerateFiles(AppContext.BaseDirectory, "GalNet*.dll"))
+{
+    if (Path.GetFileName(library) == "GalNet.SchemaGenerator.dll") throw new Exception("Analyzer leaked into runtime output");
+    _ = System.Runtime.Loader.AssemblyLoadContext.Default.LoadFromAssemblyPath(library).GetExportedTypes();
+}
+var native = Path.Combine(AppContext.BaseDirectory, "runtimes", "win-x64", "native", "galnet_miniaudio.dll");
+if (File.Exists(native))
+{
+    var handle = System.Runtime.InteropServices.NativeLibrary.Load(native);
+    try { _ = System.Runtime.InteropServices.NativeLibrary.GetExport(handle, "gn_abi_version"); }
+    finally { System.Runtime.InteropServices.NativeLibrary.Free(handle); }
+}
+[GenerateFieldSchema]
+public partial class ConsumerOptions
+{
+    [Field(0)]
+    public string Name { get; set; } = "consumer";
+}
+'@ | Set-Content (Join-Path $consumer 'Program.cs') -Encoding utf8
+        $project = Join-Path $consumer 'Consumer.csproj'
+        Invoke-ReleaseCommand "restore-$packageId" 'dotnet' @('restore', $project, '--configfile', (Join-Path $consumerRoot 'NuGet.Config'), '--ignore-failed-sources', '-p:NuGetAudit=false')
+        Invoke-ReleaseCommand "build-$packageId" 'dotnet' @('build', $project, '-c', 'Release', '--no-restore', '-p:UseSharedCompilation=false')
+        Invoke-ReleaseCommand "run-$packageId" 'dotnet' @('run', '--project', $project, '-c', 'Release', '--no-build', '--no-restore')
+        $assets = Get-Content (Join-Path $consumer 'obj/project.assets.json') -Raw | ConvertFrom-Json -AsHashtable
+        $names = @($assets.libraries.Keys | ForEach-Object { $_.Split('/')[0] })
+        if ($packageId -eq 'GalNet.Contracts' -and ($names -contains 'GalNet.Engine' -or $names -contains 'CoreCLR-NCalc')) { throw 'Contracts leaked runtime dependencies.' }
+        if ($packageId -eq 'GalNet.Engine' -and ($names -contains 'GalNet.Desktop' -or $names -contains 'Avalonia' -or $names -contains 'LibVLCSharp')) { throw 'Engine leaked backend dependencies.' }
+        if ($packageId -in @('GalNet.Desktop', 'GalNet.Avalonia')) {
+            if (!(Test-Path (Join-Path $consumer 'bin/Release/net10.0/runtimes/win-x64/native/galnet_miniaudio.dll'))) { throw "Native audio did not flow to $packageId consumer." }
+        }
+    }
+    [ordered]@{ passed = $true; consumerDirectory = $consumerRoot; packageCount = $mapping.Count; version = $Version } | ConvertTo-Json | Set-Content (Join-Path $WorkDirectory 'package-validation.json') -Encoding utf8
+}
+finally { $env:NUGET_PACKAGES = $previousPackages }
+Write-Host "External NuGet consumers verified: $consumerRoot"
diff --git a/scripts/release/Test-Release.ps1 b/scripts/release/Test-Release.ps1
new file mode 100644
index 00000000..5d85ef77
--- /dev/null
+++ b/scripts/release/Test-Release.ps1
@@ -0,0 +1,198 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory)][string]$Version,
+    [Parameter(Mandatory)][string]$AssetDirectory,
+    [Parameter(Mandatory)][string]$WorkDirectory,
+    [ValidateSet('SelfContained', 'FrameworkDependent')][string[]]$Deployments = @('SelfContained', 'FrameworkDependent'),
+    [ValidateSet('Player', 'Developer')][string]$SampleFlavor = 'Player',
+    [switch]$DesktopSmoke
+)
+. (Join-Path $PSScriptRoot 'Common.ps1')
+$AssetDirectory = [IO.Path]::GetFullPath($AssetDirectory)
+$WorkDirectory = [IO.Path]::GetFullPath($WorkDirectory)
+$script:logRoot = Join-Path $WorkDirectory 'logs'
+New-Item -ItemType Directory -Force -Path $logRoot | Out-Null
+foreach ($deployment in $Deployments) {
+    $selfContained = $deployment -eq 'SelfContained'
+    $deploymentWork = Join-Path $WorkDirectory $deployment
+    $roots = @{}
+    foreach ($kind in @('Editor', 'Sample', 'Sample-GameTestCase', 'Sample-Contracts')) {
+        $suffix = if ($kind -eq 'Sample-Contracts') { '' } else { '-win-x64-r2r' }
+        if ($kind -ne 'Sample-Contracts' -and !$selfContained) { $suffix += '-framework-dependent' }
+        if ($kind -in @('Sample', 'Sample-GameTestCase') -and $SampleFlavor -eq 'Developer') { $suffix += '-developer' }
+        $zip = Join-Path $AssetDirectory "GalNet-$kind-$Version$suffix.zip"
+        $root = Join-Path $deploymentWork $kind
+        if (Test-Path -LiteralPath $root) { throw "Use a fresh validation directory: $root" }
+        [IO.Compression.ZipFile]::ExtractToDirectory($zip, $root)
+        $roots[$kind] = $root
+        $isDeveloper = $kind -in @('Sample', 'Sample-GameTestCase') -and $SampleFlavor -eq 'Developer'
+        if (!$isDeveloper -and (Get-ChildItem -LiteralPath $root -Recurse -Filter '*.pdb')) { throw "$kind ZIP contains PDB files." }
+        if ($isDeveloper -and !(Test-Path (Join-Path $root 'lib/GalNet.Sample.Avalonia.pdb'))) { throw 'Developer ZIP is missing player symbols.' }
+        if (Get-ChildItem -LiteralPath $root -Recurse -File | Where-Object {
+            [IO.Path]::GetRelativePath($root, $_.FullName).Replace('\', '/') -match '(^|/)libvlc/win-(x86|arm64)/'
+        }) { throw "$kind ZIP contains VLC assets for another architecture." }
+        if ($kind -ne 'Sample-Contracts') {
+            foreach ($name in @('libvlc.dll', 'libvlccore.dll', 'plugins/codec/libavcodec_plugin.dll')) {
+                if (!(Test-Path (Join-Path $root "lib/libvlc/win-x64/$name"))) { throw "Missing VLC x64 dependency: $kind / $name" }
+            }
+        }
+        $manifestPath = Join-Path $root $(if ($kind -eq 'Sample-Contracts') { 'release-manifest.json' } else { 'docs/release-manifest.json' })
+        $manifest = Get-Content $manifestPath -Raw | ConvertFrom-Json
+        if ($manifest.version -ne $Version) { throw "Incorrect version in $kind manifest." }
+        if ($kind -ne 'Sample-Contracts') {
+            if ($manifest.selfContained -ne $selfContained) { throw "Incorrect deployment mode: $kind" }
+            $runtimeFiles = @(Get-ChildItem $root -Recurse -Filter coreclr.dll)
+            if ($runtimeFiles.Count -ne [int]$selfContained) { throw "Expected $([int]$selfContained) runtime copies: $kind" }
+            if ($selfContained -and !(Test-Path (Join-Path $root 'lib/coreclr.dll'))) { throw "Runtime must be in lib: $kind" }
+            if (!$selfContained -and (Get-ChildItem $root -Recurse -File | Where-Object Name -in @('hostfxr.dll', 'hostpolicy.dll', 'System.Private.CoreLib.dll'))) { throw "Framework-dependent package contains runtime files: $kind" }
+            $apps = if ($kind -eq 'Editor') { @('GalNet.Editor', 'GalNet.Editor.Headless') } else { @('GalNet.Sample.Avalonia') }
+            foreach ($app in $apps) {
+                if (!(Test-Path (Join-Path $root "$app.exe"))) { throw "Missing apphost: $app" }
+                $config = Get-Content (Join-Path $root "lib/$app.runtimeconfig.json") -Raw | ConvertFrom-Json
+                if ($selfContained) {
+                    if (!$config.runtimeOptions.includedFrameworks) { throw "Missing bundled framework declaration: $app" }
+                }
+                elseif ($config.runtimeOptions.framework.name -ne 'Microsoft.NETCore.App' -or $config.runtimeOptions.framework.version -notlike '10.*') { throw "Expected .NET 10 runtime dependency: $app" }
+                $stream = [IO.File]::OpenRead((Join-Path $root "lib/$app.dll"))
+                $reader = [Reflection.PortableExecutable.PEReader]::new($stream)
+                try {
+                    if ($reader.PEHeaders.CorHeader.ManagedNativeHeaderDirectory.Size -eq 0) { throw "$app DLL is not ReadyToRun." }
+                }
+                finally { $reader.Dispose(); $stream.Dispose() }
+            }
+            $rootFiles = @(Get-ChildItem -LiteralPath $root -File)
+            if ($rootFiles.Count -ne $apps.Count -or ($rootFiles | Where-Object Name -notin @($apps | ForEach-Object { "$_.exe" }))) {
+                throw "Application root must contain only entry executables and directories: $kind"
+            }
+            if ($kind -in @('Sample', 'Sample-GameTestCase')) {
+                if ($manifest.sampleFlavor -ne $SampleFlavor) { throw 'Sample flavor mismatch.' }
+                if ((Test-Path (Join-Path $root 'lib/GalNet.Debugging.dll')) -ne $isDeveloper) { throw 'Incorrect game debugging dependency.' }
+            }
+        }
+        foreach ($file in $manifest.files) {
+            $path = [IO.Path]::GetFullPath((Join-Path $root $file.path))
+            if (!$path.StartsWith($root + [IO.Path]::DirectorySeparatorChar, [StringComparison]::OrdinalIgnoreCase)) { throw 'Manifest escaped payload.' }
+            if ((Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash.ToLowerInvariant() -cne $file.sha256) { throw "Hash mismatch in $kind : $($file.path)" }
+        }
+        if ($kind -in @('Sample', 'Sample-GameTestCase')) {
+            foreach ($name in @('GalNet.Sample.Avalonia.exe', 'lib/galnet_miniaudio.dll')) {
+                if (!(Test-Path (Join-Path $root $name))) { throw "Missing player dependency $name" }
+            }
+        }
+    }
+    foreach ($name in @('GalNet.Core.dll', 'GalNet.Contracts.Builtins.dll', 'GalNet.Project.Contracts.dll')) {
+        $hash = (Get-FileHash (Join-Path $roots['Sample-Contracts'] $name) -Algorithm SHA256).Hash
+        foreach ($kind in @('Sample', 'Sample-GameTestCase')) {
+            if ((Get-FileHash (Join-Path $roots[$kind] "lib/$name") -Algorithm SHA256).Hash -cne $hash) { throw "Contract identity mismatch: $kind / $name" }
+        }
+    }
+    $cli = Join-Path $roots.Editor 'GalNet.Editor.Headless.exe'
+    Invoke-ReleaseCommand "distributed-cli-help-$deployment" $cli @('help')
+    if (!(Test-Path (Join-Path $roots.Editor 'Skills/galnet-project-authoring/SKILL.md'))) { throw 'Distributed CLI is missing its authoring skill.' }
+    $authorProject = Join-Path $deploymentWork "cli-project-$([guid]::NewGuid().ToString('N'))"
+    Invoke-ReleaseCommand "distributed-cli-create-$deployment" $cli @('project', 'create', $authorProject, '--contracts', $roots['Sample-Contracts'])
+    Invoke-ReleaseCommand "distributed-cli-schema-$deployment" $cli @('schema', 'list', $authorProject)
+    $game = Join-Path $roots['Sample-GameTestCase'] 'pak'
+    Invoke-ReleaseCommand "distributed-cli-inspect-$deployment" $cli @('game', 'inspect', $game)
+    $content = (Get-Content (Join-Path $logRoot "distributed-cli-inspect-$deployment.log") -Raw | ConvertFrom-Json).data
+    if ($content.version -ne 3 -or !$content.projectId -or !$content.buildId -or !$content.basePaks.Count) { throw 'Integrated content descriptor is missing or invalid.' }
+    foreach ($name in @('game.pak', 'localization.pak')) {
+        if (!(Test-Path (Join-Path $game $name))) { throw "Missing internal document package: $name" }
+    }
+    if (Get-ChildItem -LiteralPath $game -Recurse -File | Where-Object Extension -in @('.json', '.galnet')) { throw 'Integrated content contains loose internal documents.' }
+    foreach ($directory in @('StoryPatches', 'ResourcePatches', 'I18n')) {
+        if (!(Test-Path (Join-Path $game $directory) -PathType Container) -or !(Test-Path (Join-Path $roots.Sample "pak/$directory") -PathType Container)) { throw "Missing extension directory: $directory" }
+    }
+    if (!(Test-Path (Join-Path $game "StoryPatches/$($content.buildId)") -PathType Container)) { throw 'Missing current-build story directory.' }
+    $paks = @(Get-ChildItem (Join-Path $game 'Assets/Paks') -Filter '*.pak' -File -ErrorAction SilentlyContinue)
+    if (!$paks.Count -or ($paks | Where-Object Length -eq 0)) { throw 'Integrated game resources must be compiled into nonempty PAK files.' }
+    if (Get-ChildItem (Join-Path $game 'Assets') -Recurse -File | Where-Object Extension -ne '.pak') { throw 'Integrated game contains loose authoring assets.' }
+    if (Test-Path (Join-Path $game 'Graph')) { throw 'Integrated story data must be in PAK resources.' }
+    if ((Test-Path (Join-Path $game 'Contracts')) -or (Get-ChildItem $game -Recurse -Filter '*.rawgalgroup')) { throw 'Integrated game contains authoring sources.' }
+    if (Get-ChildItem (Join-Path $roots.Sample 'pak') -Recurse -File) { throw 'Pure player contains integrated game content.' }
+
+    if ($DesktopSmoke) {
+        $editorOutput = Join-Path $deploymentWork 'editor-stdout.log'
+        $editorError = Join-Path $deploymentWork 'editor-stderr.log'
+        $editor = Start-Process -FilePath (Join-Path $roots.Editor 'GalNet.Editor.exe') -PassThru -WindowStyle Hidden -RedirectStandardOutput $editorOutput -RedirectStandardError $editorError
+        try {
+            $deadline = [DateTime]::UtcNow.AddSeconds(45)
+            $ready = $false
+            while (!$editor.HasExited -and [DateTime]::UtcNow -lt $deadline) {
+                if ((Get-Content $editorOutput -Raw -ErrorAction SilentlyContinue) -match '=== GalNet Editor starting ===') {
+                    $ready = $true
+                    break
+                }
+                Start-Sleep -Milliseconds 250
+            }
+            if (!$ready) { throw "Distributed Editor did not initialize: $editorOutput / $editorError" }
+            $runtime = @($editor.Modules | Where-Object ModuleName -eq 'coreclr.dll')
+            if ($runtime.Count -ne 1) { throw 'Could not identify Editor runtime.' }
+            $localRuntime = $runtime[0].FileName.StartsWith($roots.Editor + [IO.Path]::DirectorySeparatorChar, [StringComparison]::OrdinalIgnoreCase)
+            if ($localRuntime -ne $selfContained) { throw "Editor loaded the wrong runtime: $($runtime[0].FileName)" }
+            $runtime[0].FileName | Set-Content (Join-Path $deploymentWork 'editor-runtime.txt')
+        }
+        finally {
+            if (!$editor.HasExited) { $editor.Kill($true); $editor.WaitForExit() }
+            $editor.Dispose()
+        }
+        # Use a unique exported project so fixed-path player builds exercise their
+        # real defaults without touching an existing game's user profile.
+        $smokeRoot = Join-Path $deploymentWork 'player smoke with spaces'
+        New-Item -ItemType Directory -Path $smokeRoot | Out-Null
+        Copy-Item -LiteralPath (Join-Path $roots.Sample 'lib') -Destination (Join-Path $smokeRoot 'lib') -Recurse
+        Copy-Item -LiteralPath (Join-Path $roots.Sample 'GalNet.Sample.Avalonia.exe') -Destination $smokeRoot
+        Invoke-ReleaseCommand "distributed-cli-export-$deployment" $cli @('project', 'export-directory', $authorProject, '--output', (Join-Path $smokeRoot 'pak'))
+        Invoke-ReleaseCommand "distributed-cli-smoke-inspect-$deployment" $cli @('game', 'inspect', (Join-Path $smokeRoot 'pak'))
+        $smokeContent = (Get-Content (Join-Path $logRoot "distributed-cli-smoke-inspect-$deployment.log") -Raw | ConvertFrom-Json).data
+        $projectKey = [Convert]::ToHexStringLower([Security.Cryptography.SHA256]::HashData([Text.Encoding]::UTF8.GetBytes("project:$($smokeContent.projectId)")))
+        $userDataRoot = Join-Path ([Environment]::GetFolderPath('LocalApplicationData')) 'GalNet'
+        $profile = Join-Path $userDataRoot $projectKey
+        if (Test-Path -LiteralPath $profile) { throw "Smoke profile must be new: $profile" }
+        New-Item -ItemType Directory -Path $profile | Out-Null
+        try {
+            @'
+{"player.galnet.startup.launchCount":{"Uid":"release-smoke-count","Name":"player.galnet.startup.launchCount","Type":1,"Value":1}}
+'@ | Set-Content (Join-Path $profile 'player-variables.json') -Encoding utf8
+            $info = [Diagnostics.ProcessStartInfo]::new((Join-Path $smokeRoot 'GalNet.Sample.Avalonia.exe'))
+            $info.UseShellExecute = $false; $info.CreateNoWindow = $true
+            $info.RedirectStandardOutput = $true; $info.RedirectStandardError = $true
+            $info.WorkingDirectory = $deploymentWork
+            $process = [Diagnostics.Process]::Start($info)
+            $playerOutput = $process.StandardOutput.ReadToEndAsync()
+            $playerError = $process.StandardError.ReadToEndAsync()
+            try {
+                $deadline = [DateTime]::UtcNow.AddSeconds(45)
+                $ready = $false
+                while (!$process.HasExited -and [DateTime]::UtcNow -lt $deadline) {
+                    $log = @(Get-ChildItem (Join-Path $profile 'logs') -Filter 'game-*.log' -ErrorAction SilentlyContinue | Sort-Object LastWriteTime | Select-Object -Last 1)
+                    if ($log -and (Get-Content $log[0].FullName -Raw) -match 'Session initialized\. SaveSlots=') { $ready = $true; break }
+                    Start-Sleep -Milliseconds 250
+                }
+                if (!$ready) { throw "Distributed player did not initialize. Profile/logs: $profile" }
+                Copy-Item -LiteralPath $log[0].FullName -Destination (Join-Path $deploymentWork 'player-startup.log')
+                if (Test-Path (Join-Path $smokeRoot 'pak/.galnet')) { throw 'Player wrote its profile into installed content.' }
+            }
+            finally {
+                # Terminate only the smoke process we created.
+                if (!$process.HasExited) { $process.Kill($true); $process.WaitForExit() }
+                $playerOutput.GetAwaiter().GetResult() | Set-Content (Join-Path $deploymentWork 'player-stdout.log')
+                $playerError.GetAwaiter().GetResult() | Set-Content (Join-Path $deploymentWork 'player-stderr.log')
+                $profileLogs = Join-Path $profile 'logs'
+                if (Test-Path -LiteralPath $profileLogs) {
+                    Copy-Item -LiteralPath $profileLogs -Destination (Join-Path $deploymentWork 'player-logs') -Recurse
+                }
+                $process.Dispose()
+            }
+        }
+        finally {
+            $resolvedProfile = [IO.Path]::GetFullPath($profile)
+            if ([IO.Path]::GetDirectoryName($resolvedProfile) -ne [IO.Path]::GetFullPath($userDataRoot) -or [IO.Path]::GetFileName($resolvedProfile) -cne $projectKey) {
+                throw 'Refusing to remove a profile outside the unique smoke target.'
+            }
+            Remove-Item -LiteralPath $resolvedProfile -Recurse -Force
+        }
+    }
+}
+[ordered]@{ passed = $true; version = $Version; sampleFlavor = $SampleFlavor; deployments = $Deployments; desktopStartup = [bool]$DesktopSmoke; extractionDirectory = $WorkDirectory } | ConvertTo-Json | Set-Content (Join-Path $WorkDirectory 'app-validation.json') -Encoding utf8
+Write-Host "Release payload verification passed: $WorkDirectory"
diff --git a/scripts/run-avalonia-sample.ps1 b/scripts/samples/run-avalonia-sample.ps1
similarity index 65%
rename from scripts/run-avalonia-sample.ps1
rename to scripts/samples/run-avalonia-sample.ps1
index ce61002b..7b47ecdb 100644
--- a/scripts/run-avalonia-sample.ps1
+++ b/scripts/samples/run-avalonia-sample.ps1
@@ -9,8 +9,9 @@ param(
 Set-StrictMode -Version Latest
 $ErrorActionPreference = 'Stop'
 
-$repositoryRoot = Split-Path -Parent $PSScriptRoot
-$Project = if ($Project) { [System.IO.Path]::GetFullPath($Project) } else { Join-Path $repositoryRoot 'GameTestCase' }
+$repositoryRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+$defaultProject = Join-Path $repositoryRoot 'GameTestCase'
+$Project = if ($Project) { [System.IO.Path]::GetFullPath($Project) } else { $defaultProject }
 $gameDirectory = if ($BuildOutput) { [System.IO.Path]::GetFullPath($BuildOutput) } else { Join-Path $Project 'Output' }
 $profileDirectory = if ($Profile) { [System.IO.Path]::GetFullPath($Profile) } else { Join-Path $Project '.galnet' }
 $sampleProject = Join-Path $repositoryRoot 'src\Samples\GalNet.Sample.Avalonia\GalNet.Sample.Avalonia.csproj'
@@ -18,6 +19,11 @@ $editorProject = Join-Path $repositoryRoot 'src\Editor\GalNet.Editor.Headless\Ga
 
 if (-not $SkipBuild)
 {
+    if ([string]::Equals($Project.TrimEnd([char[]]@('\', '/')), $defaultProject, [StringComparison]::OrdinalIgnoreCase))
+    {
+        $contractsProject = Join-Path $repositoryRoot 'src\Samples\GalNet.Sample.Contracts\GalNet.Sample.Contracts.csproj'
+        & (Join-Path $repositoryRoot 'scripts\contracts\build-project-contracts.ps1') -ContractsProject $contractsProject -ProjectDirectory $Project
+    }
     & dotnet run --project $editorProject -- build $Project --output $gameDirectory
     if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
 }
diff --git a/scripts/run-headless-sample.ps1 b/scripts/samples/run-headless-sample.ps1
similarity index 70%
rename from scripts/run-headless-sample.ps1
rename to scripts/samples/run-headless-sample.ps1
index f8915060..64bf9147 100644
--- a/scripts/run-headless-sample.ps1
+++ b/scripts/samples/run-headless-sample.ps1
@@ -11,14 +11,20 @@ param(
 Set-StrictMode -Version Latest
 $ErrorActionPreference = 'Stop'
 
-$repositoryRoot = Split-Path -Parent $PSScriptRoot
-$Project = if ($Project) { [System.IO.Path]::GetFullPath($Project) } else { Join-Path $repositoryRoot 'GameTestCase' }
+$repositoryRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+$defaultProject = Join-Path $repositoryRoot 'GameTestCase'
+$Project = if ($Project) { [System.IO.Path]::GetFullPath($Project) } else { $defaultProject }
 $gameDirectory = if ($BuildOutput) { [System.IO.Path]::GetFullPath($BuildOutput) } else { Join-Path $Project 'Output' }
 $playerProject = Join-Path $repositoryRoot 'src\Samples\GalNet.Sample.Headless\GalNet.Sample.Headless.csproj'
 $editorProject = Join-Path $repositoryRoot 'src\Editor\GalNet.Editor.Headless\GalNet.Editor.Headless.csproj'
 
 if (-not $SkipBuild)
 {
+    if ([string]::Equals($Project.TrimEnd([char[]]@('\', '/')), $defaultProject, [StringComparison]::OrdinalIgnoreCase))
+    {
+        $contractsProject = Join-Path $repositoryRoot 'src\Samples\GalNet.Sample.Contracts\GalNet.Sample.Contracts.csproj'
+        & (Join-Path $repositoryRoot 'scripts\contracts\build-project-contracts.ps1') -ContractsProject $contractsProject -ProjectDirectory $Project
+    }
     & dotnet run --project $editorProject -- build $Project --output $gameDirectory
     if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
 }
diff --git a/scripts/test-native-aot.ps1 b/scripts/test-native-aot.ps1
new file mode 100644
index 00000000..d187c7b0
--- /dev/null
+++ b/scripts/test-native-aot.ps1
@@ -0,0 +1,23 @@
+param(
+    [string]$RuntimeIdentifier = [System.Runtime.InteropServices.RuntimeInformation]::RuntimeIdentifier,
+    [string]$OutputDirectory
+)
+$ErrorActionPreference = 'Stop'
+if ($RuntimeIdentifier -notmatch '^[a-z0-9-]+$') { throw 'Invalid runtime identifier.' }
+$repository = Split-Path $PSScriptRoot -Parent
+if (!$OutputDirectory) { $OutputDirectory = Join-Path $repository ".galnet/native-aot-acceptance/$RuntimeIdentifier" }
+$outputRoot = [System.IO.Path]::GetFullPath($OutputDirectory)
+New-Item -ItemType Directory -Force -Path $outputRoot | Out-Null
+$publishDirectory = Join-Path $outputRoot 'publish'
+$project = Join-Path $repository 'src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj'
+# Keep RID/compiler restore inputs away from ordinary development lock files.
+$arguments = @('publish', $project, '-c', 'Release', '-r', $RuntimeIdentifier, '--self-contained',
+    '--artifacts-path', (Join-Path $outputRoot 'artifacts'), '-o', $publishDirectory, '-m:1', '-nr:false',
+    '-p:PublishAot=true', '-p:UseSharedCompilation=false', '-p:IlcTreatWarningsAsErrors=true',
+    '-p:ILLinkTreatWarningsAsErrors=true', '-p:RestorePackagesWithLockFile=false', '-p:RestoreLockedMode=false',
+    "-p:NuGetLockFilePath=$(Join-Path $outputRoot 'unused.lock.json')")
+& dotnet @arguments
+if ($LASTEXITCODE -ne 0) { throw "NativeAOT publish failed: $LASTEXITCODE" }
+$executable = Join-Path $publishDirectory ('GalNet.Sample.Headless' + $(if ($RuntimeIdentifier.StartsWith('win-')) { '.exe' } else { '' }))
+& $executable --aot-self-test --expect-aot
+if ($LASTEXITCODE -ne 0) { throw "NativeAOT acceptance failed: $LASTEXITCODE" }
diff --git a/skills/galnet-project-authoring/SKILL.md b/skills/galnet-project-authoring/SKILL.md
new file mode 100644
index 00000000..4b83bac0
--- /dev/null
+++ b/skills/galnet-project-authoring/SKILL.md
@@ -0,0 +1,31 @@
+---
+name: galnet-project-authoring
+description: Use the GalNet project CLI to turn scripts into Raw Groups, add staging to existing dialogue, and import character images or expression variants. Applies to authoring game projects; framework development uses the repository's development workflow.
+---
+
+# GalNet project authoring
+
+Use the user's installed GalNet CLI and the target project's own contract. The editor can stay open: clean projects reload external changes automatically; unsaved editor content pauses reload and remains protected.
+
+## Find the tool and project
+
+- Prefer the CLI command/path supplied by the user, `GALNET_CLI`, or `GalNet.Editor.Headless` on PATH. A distributed CLI's `Skills/galnet-project-authoring` folder sits two levels below its executable. A `.dll` launch uses `dotnet <dll>`; source checkouts can build `src/Editor/GalNet.Editor.Headless` once and use its output.
+- Require an explicit target project directory; the framework repository and a game project are different roots.
+- Run `help --json` and query relevant operations with `help <operation-id> --json`. Read `inputSchema`, `documentInputSchema`, capability limits, structured diagnostics and exit codes. Avoid guessing operation names or parameter encodings.
+
+## Read enough context
+
+Use `project info`, Graph/Group queries, `schema list/show`, and resource/reference queries. Query the schemas for the entry types actually used by this project. Resource fields use sidecar IDs. `LocalizedText` stores text keys; `CharacterReference` stores catalog character IDs. Their visible text is stored separately.
+
+Keep existing stable Group/Entry/node IDs, localization keys, unrelated author fields and entry order. For a performance-only request, retain dialogue and source text unless the user also requested rewriting. Do not assume a particular project's entry catalog includes the standard builtins.
+
+## Prepare and apply changes
+
+- Inspect Git status and existing edits. Preserve user changes. A branch or worktree is useful when the user's workflow allows it. Use Git diff to explain actual changes; commit, reset and rollback only within the user's authorization. A successful CLI operation has no persistent Undo; projects without Git need an existing backup for later rollback.
+- Capture original target contents and SHA-256 before generating replacements. Generate new files under `Temp/` or outside the game project. Preserve that original hash in `expectedHash`; replacing it with a newer disk hash after a conflict could overwrite intervening user edits.
+- Small structured modifications can use `execute` and its document batch dry run. Use `project apply` for native Graph/Raw Group/localization files and resources that must publish together. Discover its manifest with `help project.apply --json`.
+- An apply manifest declares version 1, writes and deletions. Each write names a project-relative target, a source relative to the manifest directory, the source's SHA-256, and the target's original SHA-256. `expectedHash: null` explicitly means the target must not exist. Resources and `.meta` sidecars must exist or be deleted together; replacement metadata preserves the resource ID.
+- Run `project apply <project> <manifest-file> --dry-run`, inspect diagnostics, and apply the same manifest when its effects match the authorized request. A stale target requires rereading and regenerating against the new content. The CLI's file transaction compensates failed publication; it does not replace Git history.
+- Use the relevant Group/project validation and, when requested, compile/build. Respect reported skipped checks and analysis completeness. Report changed files, diagnostics and unresolved content decisions.
+
+See [authoring recipes](references/authoring-recipes.md) for script conversion, staging existing dialogue and image/variant imports. Read the recipe relevant to the task.
diff --git a/skills/galnet-project-authoring/references/authoring-recipes.md b/skills/galnet-project-authoring/references/authoring-recipes.md
new file mode 100644
index 00000000..97574eb9
--- /dev/null
+++ b/skills/galnet-project-authoring/references/authoring-recipes.md
@@ -0,0 +1,27 @@
+# Authoring recipes
+
+## Plain script to Group
+
+Read the project's existing Graph and a representative Group, then query schemas for dialogue, actions and flow. Split the script according to scene/branch structure. Preserve any identities already supplied by the user and assign unique IDs to new nodes and entries.
+
+Native Group sources are `.rawgalgroup` files with current `version`, `kind: "Raw"` and an ordered `entries` array. A `.galgroup` file is compiled output: use the compiler to produce it. Read the current CLI queries rather than copying an old version of a project format.
+
+For each schema parameter whose semantic is `LocalizedText`, place a stable text key in the entry and the text in the project's development-language source JSON. Add character records to `I18n/catalog/characters.json` when the user supplied new speakers; their `displayNameKey` also needs source text. Empty optional text can stay empty; never fabricate an unknown speaker identity. Existing catalog identities and text keys remain stable.
+
+Publish the changed Graph, new Group sources, catalog and source texts in the same apply manifest. A Group file without a Graph node remains an orphan and will not become reachable automatically. Full project validation checks development-language texts and character references too.
+
+## Add performance to existing dialogue
+
+Read dialogue in context and list available character images, backgrounds, voices and music. Query entry schemas for the project-supported equivalent of show/hide, expression selection, transitions, timing and audio. Use existing resource identities and handles; preserve the relationship between object creation and later updates.
+
+Retain dialogue entry IDs, text keys and dialogue order. Insert presentation entries around them. Keep simple entrance/exit and expression changes explicit; use Timeline only when the project schema and the requested choreography justify it. Missing media should be reported or generated as a separate asset task, never silently referenced as if present.
+
+## Character images and expressions
+
+Use the user's available image-generation tool when generation was requested. The GalNet CLI imports files; it does not generate image pixels.
+
+Import each generated payload with a matching sidecar. Use a unique resource GUID for a new resource, and retain the GUID when replacing the image of an existing resource. Metadata identifies resource type and runtime references use its ID, not its filename.
+
+For image variants, follow the project's current descriptor/metadata example and query the variants entry schemas. Import the descriptor, referenced images and all sidecars in the same batch as the story references. Descriptor `folder` is relative to the descriptor; default/request values must resolve to an actual imported combination.
+
+Validate the finished batch. Project validation checks metadata, references and variant definitions but explicitly skips decoding image/audio/video payloads; a real visual preview is needed to assess appearance and consistency.
diff --git a/src/Editor/GalNet.Editor.Abstraction/Changes/AuthorChangeSet.cs b/src/Editor/GalNet.Editor.Abstraction/Changes/AuthorChangeSet.cs
new file mode 100644
index 00000000..509a944f
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Abstraction/Changes/AuthorChangeSet.cs
@@ -0,0 +1,24 @@
+namespace GalNet.Editor.Abstraction.Changes;
+
+public enum AuthorChangeCause { Execute, Undo, Redo }
+
+[Flags]
+public enum GroupChangeKind
+{
+    None = 0,
+    Condition = 1,
+    Parameters = 2,
+    EntryType = 4,
+    Membership = 8,
+    Order = 16
+}
+
+/// <summary>A committed change range; indexes describe the earliest affected prefix, not an object identity.</summary>
+public sealed record AuthorGroupChange(string GroupId, int FirstIndex, GroupChangeKind Kind, IReadOnlyList<string> EntryIds);
+
+/// <summary>One successful content transaction. Unknown scope conservatively covers legacy edits.</summary>
+public sealed record AuthorEntryMove(string SourceGroupId, string SourceEntryId, string TargetGroupId, string TargetEntryId);
+public sealed record AuthorChangeSet(long Revision, AuthorChangeCause Cause, IReadOnlyList<AuthorGroupChange> Groups, bool UnknownScope)
+{
+    public IReadOnlyList<AuthorEntryMove> Moves { get; init; } = [];
+}
diff --git a/src/Editor/GalNet.Editor.Abstraction/Changes/EditorChanges.cs b/src/Editor/GalNet.Editor.Abstraction/Changes/EditorChanges.cs
index f6d985ec..553754d2 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Changes/EditorChanges.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Changes/EditorChanges.cs
@@ -42,7 +42,7 @@ public static class EditorDocumentCloner
         GroupEntries = source.GroupEntries.ToDictionary(
             pair => pair.Key,
             pair => pair.Value.Select(CloneEntry).ToList()),
-        Settings = CloneSettings(source.Settings),
+        Configuration = source.Configuration.Clone(),
         Files = source.Files.ToDictionary(pair => pair.Key, pair => new EditorFileDocument { Id = pair.Value.Id, Path = pair.Value.Path, Exists = pair.Value.Exists, ManagedContent = pair.Value.ManagedContent, Data = pair.Value.Data.ToArray() })
     };
 
@@ -65,6 +65,7 @@ public static class EditorDocumentCloner
         X = source.X,
         Y = source.Y,
         File = source.File,
+        StoryPackage = source.StoryPackage,
         BranchType = source.BranchType,
         Options = source.Options?.Select(option => new EditorGraphBranchOptionDto
         {
@@ -96,27 +97,6 @@ public static class EditorDocumentCloner
         Parameters = source.Parameters.ToDictionary(pair => pair.Key, pair => pair.Value.Clone())
     };
 
-    private static GalNet.Core.Settings.ProjectSettings CloneSettings(GalNet.Core.Settings.ProjectSettings source) => new()
-    {
-        TargetLocale = new GalNet.Core.I18n.I18nLocale(source.TargetLocale.Code),
-        AvailableLocales = source.AvailableLocales.Select(locale => new GalNet.Core.I18n.I18nLocale(locale.Code)).ToList(),
-        SaveSlotCount = source.SaveSlotCount,
-        SfxChannelCount = source.SfxChannelCount,
-        DefaultWidth = source.DefaultWidth,
-        DefaultHeight = source.DefaultHeight,
-        PlayerVariables = source.PlayerVariables.Select(variable => variable.Clone()).ToList(),
-        SaveVariables = source.SaveVariables.Select(variable => variable.Clone()).ToList(),
-        AudioTracks = source.AudioTracks.Select(track => new GalNet.Core.Audio.AudioTrackDefinition
-        {
-            Id = track.Id,
-            Name = track.Name,
-            Bus = track.Bus,
-            DefaultGain = track.DefaultGain,
-            MaxVoices = track.MaxVoices,
-            MaxQueuedItems = track.MaxQueuedItems,
-            OverflowPolicy = track.OverflowPolicy,
-            QueueOverflowPolicy = track.QueueOverflowPolicy
-        }).ToList()
-    };
+
 
 }
diff --git a/src/Editor/GalNet.Editor.Abstraction/Commands/BuiltInEditorCommands.cs b/src/Editor/GalNet.Editor.Abstraction/Commands/BuiltInEditorCommands.cs
index 657eea5e..1cf843bf 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Commands/BuiltInEditorCommands.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Commands/BuiltInEditorCommands.cs
@@ -216,7 +216,8 @@ public sealed record RenameProjectCommand(string Name) : IProjectEditCommand
     public string CommandId => "project.rename";
 }
 
-public sealed record PatchProjectSettingsCommand(IReadOnlyDictionary<string, JsonElement> Values) : IProjectEditCommand
+public sealed record PatchConfigurationCommand(string SectionId, IReadOnlyDictionary<string, JsonElement> Values,
+    IReadOnlyList<string>? Remove = null) : IProjectEditCommand
 {
-    public string CommandId => "project.settings.patch";
+    public string CommandId => "project.configuration.patch";
 }
diff --git a/src/Editor/GalNet.Editor.Abstraction/Commands/ProjectApplyContracts.cs b/src/Editor/GalNet.Editor.Abstraction/Commands/ProjectApplyContracts.cs
new file mode 100644
index 00000000..2e618b1f
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Abstraction/Commands/ProjectApplyContracts.cs
@@ -0,0 +1,27 @@
+namespace GalNet.Editor.Abstraction.Commands;
+
+/// <summary>Native author files and resources, published together after validating the final project.</summary>
+public sealed class ProjectApplyManifest
+{
+    public required int Version { get; init; }
+    public required IReadOnlyList<ProjectApplyWrite> Writes { get; init; }
+    public required IReadOnlyList<ProjectApplyDelete> Deletes { get; init; }
+}
+
+public sealed class ProjectApplyWrite
+{
+    public required string Path { get; init; }
+    public required string Source { get; init; }
+    public required string ContentHash { get; init; }
+    /// <summary>Null explicitly requires a new target; otherwise SHA-256 of the current target.</summary>
+    public required string? ExpectedHash { get; init; }
+}
+
+public sealed class ProjectApplyDelete
+{
+    public required string Path { get; init; }
+    public required string ExpectedHash { get; init; }
+}
+
+public sealed record ProjectApplyReport(bool DryRun, IReadOnlyList<string> WrittenFiles, IReadOnlyList<string> DeletedFiles,
+    IReadOnlyDictionary<string, string> ContentHashes, ProjectValidationReport Validation, bool ReferencesComplete = false);
diff --git a/src/Editor/GalNet.Editor.Abstraction/Commands/ProjectBuildContracts.cs b/src/Editor/GalNet.Editor.Abstraction/Commands/ProjectBuildContracts.cs
index 99977d33..12d65721 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Commands/ProjectBuildContracts.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Commands/ProjectBuildContracts.cs
@@ -2,3 +2,5 @@ namespace GalNet.Editor.Abstraction.Commands;
 
 public sealed record ProjectBuildReport(string OutputPath, int CompiledGroupCount);
 public sealed record ProjectExportReport(string? PackagePath);
+public sealed record ProjectExportDirectoryReport(string ContentDirectory);
+public sealed record GalpakInstallReport(string InstallationDirectory);
diff --git a/src/Editor/GalNet.Editor.Abstraction/Documents/EditorDocumentModels.cs b/src/Editor/GalNet.Editor.Abstraction/Documents/EditorDocumentModels.cs
index b8b82072..d35d8d56 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Documents/EditorDocumentModels.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Documents/EditorDocumentModels.cs
@@ -1,9 +1,9 @@
 using System.Collections.Generic;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
-using GalNet.Core.Settings;
 using GalNet.Core.Variable;
 
 namespace GalNet.Editor.Abstraction.Documents;
@@ -52,6 +52,10 @@ public sealed class EditorGraphNodeDto
     [JsonPropertyName("file")]
     public string? File { get; set; }
 
+    [JsonPropertyName("storyPackage")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public string? StoryPackage { get; set; }
+
     [JsonPropertyName("branchType")]
     public string? BranchType { get; set; }
 
@@ -107,15 +111,23 @@ public sealed class EditorEntryData
     /// <summary>Owned author JSON. A missing key and a provided JSON null are distinct.</summary>
     public Dictionary<string, JsonElement> Parameters { get; set; } = new();
 
+    /// <summary>Text-to-JSON adaptation lives at the author input boundary, not in Core entries.</summary>
+    public static Dictionary<string, JsonElement> CreateParameters(IEntryCatalog catalog, string type,
+        IReadOnlyDictionary<string, string>? text = null)
+    {
+        var entry = catalog.Create(type, arguments: text is null ? null : JsonSerializer.SerializeToElement(ParseParameters(catalog, type, text)));
+        return entry.Arguments.EnumerateObject().ToDictionary(property => property.Name, property => property.Value.Clone(), StringComparer.Ordinal);
+    }
+
     public static Dictionary<string, JsonElement> ParseParameters(IEntryCatalog catalog, string type, IReadOnlyDictionary<string, string> values) =>
         values.ToDictionary(pair => pair.Key,
-            pair => catalog.TryGet(type, out var schema) && schema.Parameters.ContainsKey(pair.Key)
-                ? ValueCodec.ParseEditorText(schema.DynamicParameters![pair.Key].Value, pair.Value).Clone()
+            pair => catalog.TryGet(type, out var schema) && schema.DynamicParameters.ContainsKey(pair.Key)
+                ? ValueCodec.ParseEditorText(schema.DynamicParameters[pair.Key].Value, pair.Value).Clone()
                 : JsonSerializer.Deserialize<JsonElement>(pair.Value).Clone(), StringComparer.Ordinal);
 
     public Dictionary<string, string> GetParameterText(IEntryCatalog catalog) => Parameters.ToDictionary(pair => pair.Key,
-        pair => catalog.TryGet(Type, out var schema) && schema.Parameters.ContainsKey(pair.Key)
-            ? ValueCodec.ToEditorText(schema.DynamicParameters![pair.Key].Value, pair.Value) : pair.Value.GetRawText(), StringComparer.Ordinal);
+        pair => catalog.TryGet(Type, out var schema) && schema.DynamicParameters.ContainsKey(pair.Key)
+            ? ValueCodec.ToEditorText(schema.DynamicParameters[pair.Key].Value, pair.Value) : pair.Value.GetRawText(), StringComparer.Ordinal);
 }
 
 /// <summary>Project-owned content identity; its path can change without replacing the document.</summary>
@@ -141,7 +153,7 @@ public sealed class EditorProjectDocument
 {
     public EditorGraphDocument Graph { get; set; } = new();
     public Dictionary<string, List<EditorEntryData>> GroupEntries { get; set; } = [];
-    public ProjectSettings Settings { get; set; } = new();
+    public ProjectConfiguration Configuration { get; set; } = new();
     public Dictionary<string, EditorFileDocument> Files { get; set; } = [];
 }
 
diff --git a/src/Editor/GalNet.Editor.Abstraction/Documents/ExternalProjectSnapshot.cs b/src/Editor/GalNet.Editor.Abstraction/Documents/ExternalProjectSnapshot.cs
new file mode 100644
index 00000000..a7c3d287
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Abstraction/Documents/ExternalProjectSnapshot.cs
@@ -0,0 +1,13 @@
+using GalNet.Core.Configuration;
+
+namespace GalNet.Editor.Abstraction.Documents;
+
+/// <summary>A detached, validated disk candidate. Reading it never mutates the live project.</summary>
+public sealed record ExternalProjectSnapshot(
+    LoadedEditorProjectDocument Document,
+    ProjectConfiguration Configuration,
+    IReadOnlyDictionary<string, byte[]> Files,
+    IReadOnlyDictionary<string, byte[]?> AuthorSources,
+    string ContractsFingerprint);
+
+public enum ExternalReloadResult { Unchanged, Reloaded, LocalChanges, Retry, Unavailable }
diff --git a/src/Editor/GalNet.Editor.Abstraction/Project/GalProject.cs b/src/Editor/GalNet.Editor.Abstraction/Project/GalProject.cs
index 5ebe3674..dd6ac1c0 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Project/GalProject.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Project/GalProject.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
-using GalNet.Core.Settings;
+using GalNet.Core.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace GalNet.Editor.Abstraction.Project;
@@ -10,7 +10,7 @@ namespace GalNet.Editor.Abstraction.Project;
 /// <summary>
 /// 编辑器打开中的一个游戏工程。
 /// 承载工程元数据、路径、项目设置、项目级 DI Scope。
-/// 注意：编辑器级设置（字体、主题、快捷键等）不在此处，走全局 ISettingsService。
+/// 注意：编辑器级设置（字体、主题、快捷键等）不在此处，走全局 IEditorSettingsService。
 /// </summary>
 public sealed class GalProject : IDisposable, IAsyncDisposable
 {
@@ -58,7 +58,9 @@ public sealed class GalProject : IDisposable, IAsyncDisposable
     public string EditorStateFilePath => Path.Combine(EditorStateDirectory, "editor-state.json");
 
     /// <summary>项目设置（持久化在 settings.json，每个项目一份）</summary>
-    public ProjectSettings Settings { get; }
+    public ProjectConfiguration Configuration { get; }
+
+    public ProjectConfigurationSchema Configurations { get; private set; }
 
     public EditorProjectState EditorState { get; }
 
@@ -68,12 +70,14 @@ public sealed class GalProject : IDisposable, IAsyncDisposable
     /// <summary>项目级 ServiceProvider</summary>
     public IServiceProvider Services => Scope.ServiceProvider;
 
-    public GalProject(string id, string name, string rootPath, ProjectSettings settings, EditorProjectState editorState, IServiceScope scope)
+    public GalProject(string id, string name, string rootPath, ProjectConfiguration settings, EditorProjectState editorState, IServiceScope scope,
+        ProjectConfigurationSchema? configurations = null)
     {
         Id = id;
         Name = name;
         RootPath = rootPath;
-        Settings = settings;
+        Configuration = settings;
+        Configurations = configurations ?? ProjectConfigurationSchema.Empty;
         EditorState = editorState;
         Scope = scope;
     }
@@ -108,6 +112,7 @@ public async ValueTask DisposeAsync()
             }
         }
         _closingCallbacks.Clear();
+        Configurations = ProjectConfigurationSchema.Empty;
         Scope.Dispose();
 
         if (failures is { Count: > 0 })
@@ -120,6 +125,7 @@ public void Dispose()
             return;
         _disposed = true;
         _closingCallbacks.Clear();
+        Configurations = ProjectConfigurationSchema.Empty;
         Scope.Dispose();
     }
 
diff --git a/src/Editor/GalNet.Editor.Abstraction/Schemas/EntrySchema.cs b/src/Editor/GalNet.Editor.Abstraction/Schemas/EntrySchema.cs
new file mode 100644
index 00000000..cb8e5b5b
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Abstraction/Schemas/EntrySchema.cs
@@ -0,0 +1,48 @@
+using System.Text.Json;
+using GalNet.Core.Parameters;
+using GalNet.Core.Primitives;
+
+namespace GalNet.Editor.Abstraction.Schemas;
+
+/// <summary>Editor-facing input kind for a serialized entry parameter.</summary>
+public enum EntryParameterType
+{
+    Text,
+    MultilineText,
+    Integer,
+    Float,
+    Autocomplete,
+    ImageAsset,
+    AudioAsset,
+    VideoAsset,
+    EffectProgramAsset,
+    Select,
+    VariableName,
+    Expression,
+    Json
+}
+
+/// <summary>Editor input hints projected from the single parameter contract.</summary>
+public static class EntrySchema
+{
+    public static EntryParameterType GetEditorType(DynamicParameterDescriptor parameter)
+    {
+        if (parameter.Editor?.EditorId is { } editorId && editorId != ValueEditorIds.Numeric)
+            foreach (var type in Enum.GetValues<EntryParameterType>())
+                if (GetEditorId(type) == editorId) return type;
+        if (parameter.ValueType == typeof(int)) return EntryParameterType.Integer;
+        if (parameter.ValueType == typeof(float) || parameter.ValueType == typeof(double) || parameter.ValueType == typeof(decimal)) return EntryParameterType.Float;
+        if (parameter.ValueType == typeof(JsonElement)) return EntryParameterType.Json;
+        if (parameter.ValueType == typeof(bool)) return EntryParameterType.Select;
+        return EntryParameterType.Text;
+    }
+
+    private static string GetEditorId(EntryParameterType type) => type switch
+    {
+        EntryParameterType.Integer or EntryParameterType.Float => ValueEditorIds.Numeric,
+        EntryParameterType.Json => ValueEditorIds.Json,
+        EntryParameterType.Select => ValueEditorIds.Choice,
+        EntryParameterType.Text => ValueEditorIds.Text,
+        _ => "entry." + type.ToString().ToLowerInvariant()
+    };
+}
diff --git a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorDocumentRepository.cs b/src/Editor/GalNet.Editor.Abstraction/Services/IEditorDocumentRepository.cs
index cc5c5601..96eff19e 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorDocumentRepository.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Services/IEditorDocumentRepository.cs
@@ -1,13 +1,15 @@
 using System.Collections.Generic;
 using System.Threading;
-using GalNet.Core.Settings;
 using GalNet.Editor.Abstraction.Documents;
 
 namespace GalNet.Editor.Abstraction.Services;
 
 public interface IEditorDocumentRepository
 {
-    LoadedEditorProjectDocument Load(string projectPath, string projectName, ProjectSettings settings);
+    LoadedEditorProjectDocument Load(string projectPath);
+
+    IReadOnlyDictionary<string, byte[]?> SourceBaseline => new Dictionary<string, byte[]?>();
+    void AdoptExternalBaseline(IReadOnlyDictionary<string, byte[]?> sources) => throw new NotSupportedException("External reload is unavailable for this repository.");
 
     ProjectSavePlan PrepareSave(string projectPath, EditorGraphDocument document,
         IReadOnlyDictionary<string, IReadOnlyList<EditorEntryData>> groupEntries);
diff --git a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorDocumentService.cs b/src/Editor/GalNet.Editor.Abstraction/Services/IEditorDocumentService.cs
index 0c5c03cf..21caf1b5 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorDocumentService.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Services/IEditorDocumentService.cs
@@ -13,6 +13,7 @@ public interface IEditorDocumentService
     event Action? DocumentChanged;
 
     void Load(LoadedEditorProjectDocument loadedDocument);
+    void Reload(LoadedEditorProjectDocument loadedDocument) => throw new NotSupportedException();
     void Unload();
     void SynchronizeGroups();
     EditorGroupDocument GetOrCreateGroup(string groupId, string relativePath);
diff --git a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorPlayerVariableStore.cs b/src/Editor/GalNet.Editor.Abstraction/Services/IEditorPlayerVariableStore.cs
deleted file mode 100644
index 4a599c93..00000000
--- a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorPlayerVariableStore.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using GalNet.Core.Variable;
-
-namespace GalNet.Editor.Abstraction.Services;
-
-public interface IEditorPlayerVariableStore
-{
-    event Action? Changed;
-
-    IReadOnlyDictionary<string, Variable> Snapshot { get; }
-
-    void ConfigureSystemVariables(IReadOnlyCollection<SystemVariableDefinition> definitions);
-
-    void Reload();
-
-    IReadOnlyDictionary<string, Variable> EnsureInitialized();
-
-    void Reset();
-
-    void SetValue(string name, object value);
-
-    void SetVariable(string name, Variable variable);
-
-    void Remove(string name);
-}
diff --git a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorSaveCoordinator.cs b/src/Editor/GalNet.Editor.Abstraction/Services/IEditorSaveCoordinator.cs
deleted file mode 100644
index 5a1c3fdc..00000000
--- a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorSaveCoordinator.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System.Collections.Generic;
-using GalNet.Editor.Abstraction.Documents;
-
-namespace GalNet.Editor.Abstraction.Services;
-
-public interface IEditorSaveCoordinator
-{
-    string BuildPreviewData(
-        string previewPath,
-        EditorGraphDocument document,
-        IReadOnlyDictionary<string, IReadOnlyList<EditorEntryData>> groupEntries);
-}
diff --git a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorSettingsService.cs b/src/Editor/GalNet.Editor.Abstraction/Services/IEditorSettingsService.cs
index 524560a8..9e75b0d8 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Services/IEditorSettingsService.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Services/IEditorSettingsService.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Settings;
+using GalNet.Editor.Abstraction.Settings;
 
 namespace GalNet.Editor.Abstraction.Services;
 
diff --git a/src/Editor/GalNet.Editor.Abstraction/Services/IGameExitService.cs b/src/Editor/GalNet.Editor.Abstraction/Services/IGameExitService.cs
deleted file mode 100644
index ccb9ace3..00000000
--- a/src/Editor/GalNet.Editor.Abstraction/Services/IGameExitService.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace GalNet.Editor.Abstraction.Services;
-
-/// <summary>
-/// Controls what happens when the game requests to exit / quit.
-/// Different hosts (Editor, Launcher, standalone) inject different implementations.
-/// </summary>
-public interface IGameExitService
-{
-    void Exit();
-}
diff --git a/src/Editor/GalNet.Editor.Abstraction/Services/IProjectContentSession.cs b/src/Editor/GalNet.Editor.Abstraction/Services/IProjectContentSession.cs
index d81383ef..4d7f9185 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Services/IProjectContentSession.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Services/IProjectContentSession.cs
@@ -4,20 +4,29 @@
 
 namespace GalNet.Editor.Abstraction.Services;
 
+public readonly record struct ProjectDraftCommitContext(IReadOnlySet<string>? RemovingGroups = null);
+
 public interface IProjectContentSession
 {
     bool IsDirty { get; }
-    bool IsPublishing => false;
-    bool HasEditsSincePublication => false;
+    bool IsPublishing { get; }
+    bool HasEditsSincePublication { get; }
     bool RepairRequired { get; }
     Exception? LastError { get; }
     Exception? LastRecoveryError { get; }
     event Action? Changed;
+    event Action? ExternalReloaded;
     IDisposable RegisterDraft(Func<bool> hasChanges, Func<Task> commit);
-    IDisposable RegisterFileDraft(string fileId, Func<bool> hasChanges, Func<Task> commit, Action validate) => RegisterDraft(hasChanges, commit);
-    Task CommitFileDraftsAsync(string fileId) => CommitDraftsAsync();
+    IDisposable RegisterDraft(Func<bool> hasChanges, Func<Task> commit, Action discard);
+    IDisposable RegisterDraft(Func<bool> hasChanges, Func<ProjectDraftCommitContext, Task> commit, Action discard);
+    /// <summary>Wraps the synchronous publication boundary after preparation/validation and before any file or live author mutation.</summary>
+    IDisposable RegisterStructureTransition(Action<EditorProjectDocument, EditorProjectDocument, Action> transition);
+    IDisposable RegisterFileDraft(string fileId, Func<bool> hasChanges, Func<Task> commit, Action validate);
+    IDisposable RegisterFileDraft(string fileId, Func<bool> hasChanges, Func<Task> commit, Action validate, Action discard);
+    Task CommitFileDraftsAsync(string fileId);
     IDisposable RegisterCaptureGuard(Func<bool, CancellationToken, Task<IDisposable>> acquire);
     Task CommitDraftsAsync();
+    Task CommitDraftsAsync(ProjectDraftCommitContext context);
     void Open(GalProject project);
     void Refresh();
     void BlockWrites(Exception failure);
@@ -28,9 +37,10 @@ public interface IProjectContentSession
     Task PublishStructureAsync(Func<EditorProjectDocument, EditorProjectDocument, IProjectStructureChange> prepare);
     EditorProjectDocument CaptureWorking();
     EditorProjectDocument CaptureSaved();
-    IReadOnlyDictionary<string, EditorFileDocument> FileDocuments => new Dictionary<string, EditorFileDocument>();
-    EditorFileDocument TrackFile(string path, byte[]? textBytes = null) => throw new NotSupportedException();
-    EditorFileDocument TrackLocalizationFile(string path, byte[] textBytes) => throw new NotSupportedException();
+    Task<ExternalReloadResult> ReloadExternalAsync(ExternalProjectSnapshot snapshot, bool discardLocalChanges = false, CancellationToken cancellationToken = default);
+    IReadOnlyDictionary<string, EditorFileDocument> FileDocuments { get; }
+    EditorFileDocument TrackFile(string path, byte[]? textBytes = null);
+    EditorFileDocument TrackLocalizationFile(string path, byte[] textBytes);
     Task SuspendAsync();
     void ResumeSaves();
 }
diff --git a/src/Editor/GalNet.Editor.Abstraction/Services/IProjectService.cs b/src/Editor/GalNet.Editor.Abstraction/Services/IProjectService.cs
index eee7167a..3d0d91d3 100644
--- a/src/Editor/GalNet.Editor.Abstraction/Services/IProjectService.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Services/IProjectService.cs
@@ -1,8 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using GalNet.Core.Settings;
+using GalNet.Core.Configuration;
 using GalNet.Editor.Abstraction.Project;
+using GalNet.Editor.Abstraction.Settings;
 
 namespace GalNet.Editor.Abstraction.Services;
 
@@ -22,7 +23,7 @@ public interface IProjectService
     Task<GalProject> OpenAsync(string projectPath);
 
     /// <summary>新建项目</summary>
-    Task<GalProject> CreateAsync(string projectPath, string name, ProjectSettings settings, string contractsDirectory);
+    Task<GalProject> CreateAsync(string projectPath, string name, ProjectConfiguration settings, string contractsDirectory);
 
     /// <summary>关闭当前项目（含脏检查）</summary>
     Task CloseAsync();
diff --git a/src/Editor/GalNet.Editor.Abstraction/Services/ISettingsService.cs b/src/Editor/GalNet.Editor.Abstraction/Services/ISettingsService.cs
deleted file mode 100644
index 6d0303d7..00000000
--- a/src/Editor/GalNet.Editor.Abstraction/Services/ISettingsService.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-using GalNet.Core.Settings;
-
-namespace GalNet.Editor.Abstraction.Services;
-
-/// <summary>
-/// Game settings service — reads/writes player preferences (volume, text speed, fullscreen).
-/// </summary>
-public interface ISettingsService
-{
-    float BgmVolume { get; set; }
-    float SfxVolume { get; set; }
-    float VoiceVolume { get; set; }
-    float TextSpeed { get; set; }
-    bool Fullscreen { get; set; }
-
-    /// <summary>Get current settings snapshot.</summary>
-    GameSettings GetSnapshot();
-
-    /// <summary>Restore from a snapshot.</summary>
-    void ApplySnapshot(GameSettings settings);
-
-    /// <summary>Load settings from disk.</summary>
-    Task LoadAsync(string path);
-
-    /// <summary>Persist settings to disk.</summary>
-    Task SaveAsync(string path);
-
-    /// <summary>Fired when any setting changes.</summary>
-    event Action? Changed;
-}
diff --git a/src/Shared/GalNet.Core/Settings/EditorSettings.cs b/src/Editor/GalNet.Editor.Abstraction/Settings/EditorSettings.cs
similarity index 85%
rename from src/Shared/GalNet.Core/Settings/EditorSettings.cs
rename to src/Editor/GalNet.Editor.Abstraction/Settings/EditorSettings.cs
index b1294ab8..8fedd83c 100644
--- a/src/Shared/GalNet.Core/Settings/EditorSettings.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Settings/EditorSettings.cs
@@ -3,14 +3,13 @@
 using System.Text.Json.Serialization;
 using GalNet.Core.I18n;
 
-namespace GalNet.Core.Settings;
+namespace GalNet.Editor.Abstraction.Settings;
 
 /// <summary>
 /// 编辑器全局设置 —— 持久化在编辑器配置目录。
 /// </summary>
-public sealed class EditorSettings : SettingsSection
+public sealed class EditorSettings
 {
-    public override string SectionKey => "editor";
 
     /// <summary>编辑器 UI 语言</summary>
     public I18nLocale UiLocale { get; set; } = I18nLocale.ZhCn;
@@ -33,6 +32,9 @@ public sealed class EditorSettings : SettingsSection
 
     public bool AutoSaveProject { get; set; } = true;
 
+    /// <summary>Whether newly inserted Group entries show their parameter fields.</summary>
+    public bool ExpandNewEntries { get; set; } = true;
+
     /// <summary>Stable UI command ID to Avalonia gesture text. Empty text disables the shortcut.</summary>
     public Dictionary<string, string> GestureOverrides { get; set; } = new(StringComparer.OrdinalIgnoreCase);
 }
diff --git a/src/Shared/GalNet.Core/Settings/EmbeddedJsonStringConverter.cs b/src/Editor/GalNet.Editor.Abstraction/Settings/EmbeddedJsonStringConverter.cs
similarity index 95%
rename from src/Shared/GalNet.Core/Settings/EmbeddedJsonStringConverter.cs
rename to src/Editor/GalNet.Editor.Abstraction/Settings/EmbeddedJsonStringConverter.cs
index 4b04a70a..557424b8 100644
--- a/src/Shared/GalNet.Core/Settings/EmbeddedJsonStringConverter.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Settings/EmbeddedJsonStringConverter.cs
@@ -1,7 +1,7 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace GalNet.Core.Settings;
+namespace GalNet.Editor.Abstraction.Settings;
 
 /// <summary>Stores a JSON document held as text as an embedded JSON value.</summary>
 public sealed class EmbeddedJsonStringConverter : JsonConverter<string>
diff --git a/src/Shared/GalNet.Core/Settings/RecentProjectInfo.cs b/src/Editor/GalNet.Editor.Abstraction/Settings/RecentProjectInfo.cs
similarity index 85%
rename from src/Shared/GalNet.Core/Settings/RecentProjectInfo.cs
rename to src/Editor/GalNet.Editor.Abstraction/Settings/RecentProjectInfo.cs
index e5c6e892..1981ed2a 100644
--- a/src/Shared/GalNet.Core/Settings/RecentProjectInfo.cs
+++ b/src/Editor/GalNet.Editor.Abstraction/Settings/RecentProjectInfo.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Settings;
+namespace GalNet.Editor.Abstraction.Settings;
 
 /// <summary>
 /// 最近项目信息 —— 持久化到编辑器设置中。
diff --git a/src/Editor/GalNet.Editor.Abstraction/packages.lock.WindowsReadyToRun.json b/src/Editor/GalNet.Editor.Abstraction/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..14ab4d76
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Abstraction/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,17 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Direct",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Editor/GalNet.Editor.DefaultContracts/ProjectSchemas.cs b/src/Editor/GalNet.Editor.DefaultContracts/ProjectSchemas.cs
index 5919d1a7..5122c2f6 100644
--- a/src/Editor/GalNet.Editor.DefaultContracts/ProjectSchemas.cs
+++ b/src/Editor/GalNet.Editor.DefaultContracts/ProjectSchemas.cs
@@ -1,4 +1,5 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
 
 namespace GalNet.Project.Contracts;
@@ -6,5 +7,6 @@ namespace GalNet.Project.Contracts;
 /// <summary>Default authoring contract deployed when creating an Editor project.</summary>
 public static class ProjectSchemas
 {
+    public static ProjectConfigurationSchema Configurations { get; } = DefaultProjectConfiguration.Schema;
     public static IReadOnlyList<IEntryModule> Modules { get; } = Array.AsReadOnly(BuiltinSchemas.CreateAllModules().ToArray());
 }
diff --git a/src/Editor/GalNet.Editor.DefaultContracts/packages.lock.WindowsReadyToRun.json b/src/Editor/GalNet.Editor.DefaultContracts/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..9fb490d8
--- /dev/null
+++ b/src/Editor/GalNet.Editor.DefaultContracts/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,17 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj b/src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj
index 253f5bff..391b4c9b 100644
--- a/src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj
+++ b/src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj
@@ -6,7 +6,11 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
+    <Content Include="..\..\..\skills\galnet-project-authoring\**\*" Link="Skills\galnet-project-authoring\%(RecursiveDir)%(Filename)%(Extension)" CopyToOutputDirectory="PreserveNewest" CopyToPublishDirectory="PreserveNewest" />
+    <Content Include="README.md" CopyToOutputDirectory="PreserveNewest" CopyToPublishDirectory="PreserveNewest" />
     <ProjectReference Include="..\GalNet.Editor.Abstraction\GalNet.Editor.Abstraction.csproj" />
     <ProjectReference Include="..\GalNet.Editor.Shared\GalNet.Editor.Shared.csproj" />
+    <ProjectReference Include="..\..\Infrastructure\GalNet.Storage.FileSystem\GalNet.Storage.FileSystem.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Editor/GalNet.Editor.Headless/Program.cs b/src/Editor/GalNet.Editor.Headless/Program.cs
index aa8cc635..599c5ace 100644
--- a/src/Editor/GalNet.Editor.Headless/Program.cs
+++ b/src/Editor/GalNet.Editor.Headless/Program.cs
@@ -1,11 +1,13 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Shared.Commands;
 using GalNet.Editor.Shared.Services;
+using GalNet.Storage.FileSystem;
 
 namespace GalNet.Editor.Headless;
 
@@ -34,6 +36,18 @@ public static async Task<int> Main(string[] args)
                 else Console.Out.Write(ToolHelp.RenderText(definitions, invocation.Positionals.Count != 0));
                 return 0;
             }
+            if (_operationId == "galpak.install")
+            {
+                var directory = await GalpakInstaller.InstallAsync(invocation.Positionals[0], invocation.Get("--output"));
+                WriteJson(new ToolResult(_operationId, true, new GalpakInstallReport(directory), []));
+                return 0;
+            }
+            if (_operationId == "game.inspect")
+            {
+                var descriptor = InstalledGameDescriptor.Read(invocation.Positionals[0]);
+                WriteJson(new ToolResult(_operationId, true, descriptor, []));
+                return 0;
+            }
             args = new[] { _operationId }.Concat(invocation.Positionals)
                 .Concat(invocation.Options.SelectMany(pair => new[] { pair.Key, pair.Value })).ToArray();
 
@@ -83,9 +97,22 @@ public static async Task<int> Main(string[] args)
             }
             using var projectSchema = ProjectSchemaContext.Load(projectPath);
             var entryCatalog = projectSchema.Catalog;
-            if (verb == "project.build") return await BuildAsync(projectPath, args, entryCatalog);
-            if (verb == "project.export") return await ExportAsync(projectPath, args, entryCatalog);
-            var edits = new ProjectEditService(projectPath, entryCatalog);
+            if (verb == "project.visuals.install")
+            {
+                var result = await GalNet.Editor.Shared.Visuals.DefaultVisualInstaller.InstallAsync(projectPath, entryCatalog, projectSchema.Configurations, invocation.Has("--dry-run"));
+                WriteJson(result);
+                return result.Success ? 0 : 5;
+            }
+            if (verb == "project.apply")
+            {
+                var applied = await new ProjectApplyService(projectPath, entryCatalog, configurations: projectSchema.Configurations).ApplyAsync(invocation.Positionals[1], invocation.Has("--dry-run"));
+                WriteJson(applied);
+                return applied.Success ? 0 : 5;
+            }
+            if (verb == "project.build") return await BuildAsync(projectPath, args, projectSchema);
+            if (verb == "project.export") return await ExportAsync(projectPath, args, projectSchema);
+            if (verb == "project.export-directory") return await ExportDirectoryAsync(projectPath, args, projectSchema);
+            var edits = new ProjectEditService(projectPath, entryCatalog, projectSchema.Configurations);
             if (verb is "project.rename" or "group.create" or "group.rename" or "group.delete")
             {
                 IProjectEditCommand command = verb switch
@@ -118,7 +145,7 @@ public static async Task<int> Main(string[] args)
         catch (Exception exception) { return Fail(exception.Message, 1); }
     }
 
-    private static async Task<int> ExportAsync(string projectPath, string[] args, IEntryCatalog entryCatalog)
+    private static async Task<int> ExportAsync(string projectPath, string[] args, ProjectSchemaContext schema)
     {
         if (!Directory.Exists(projectPath)) throw new DirectoryNotFoundException($"Project directory not found: {projectPath}");
         var outputIndex = Array.IndexOf(args, "--output");
@@ -129,19 +156,35 @@ private static async Task<int> ExportAsync(string projectPath, string[] args, IE
         var projectName = Path.GetFileName(Path.TrimEndingDirectorySeparator(projectPath));
         var resourceTypes = BuiltinResourceTypes.CreateCatalog();
         var galleryTypes = BuiltinGalleryTypes.CreateCatalog(resourceTypes);
-        var result = await GamePackageExporter.ExportAsync(projectName, projectName, projectPath, outputDirectory, resourceTypes, galleryTypes, entryCatalog);
+        var result = await GamePackageExporter.ExportAsync(projectName, projectName, projectPath, outputDirectory, resourceTypes, galleryTypes, schema.Catalog, schema.Configurations);
         WriteJson(new ToolResult("project.export", result.Success, new ProjectExportReport(result.PackagePath),
             result.Success ? [] : [new("project.exportFailed", "error", result.Error ?? "Export failed.")]));
         return result.Success ? 0 : 5;
     }
 
-    private static async Task<int> BuildAsync(string projectPath, string[] args, IEntryCatalog entryCatalog)
+    private static async Task<int> ExportDirectoryAsync(string projectPath, string[] args, ProjectSchemaContext schema)
+    {
+        if (!Directory.Exists(projectPath)) throw new DirectoryNotFoundException($"Project directory not found: {projectPath}");
+        var outputIndex = Array.IndexOf(args, "--output");
+        if (outputIndex < 0 || outputIndex + 1 >= args.Length) return Fail("project export-directory requires --output <new-directory>.");
+        var outputDirectory = Path.GetFullPath(args[outputIndex + 1]);
+        var projectName = Path.GetFileName(Path.TrimEndingDirectorySeparator(projectPath));
+        var resourceTypes = BuiltinResourceTypes.CreateCatalog();
+        var galleryTypes = BuiltinGalleryTypes.CreateCatalog(resourceTypes);
+        var result = await GamePackageExporter.ExportDirectoryAsync(projectName, projectName, projectPath, outputDirectory,
+            resourceTypes, galleryTypes, schema.Catalog, schema.Configurations);
+        WriteJson(new ToolResult(_operationId, result.Success, result.Success ? new ProjectExportDirectoryReport(result.ContentDirectory!) : null,
+            result.Success ? [] : [new("project.exportFailed", "error", result.Error ?? "Export failed.")]));
+        return result.Success ? 0 : 5;
+    }
+
+    private static async Task<int> BuildAsync(string projectPath, string[] args, ProjectSchemaContext schema)
     {
         if (!Directory.Exists(projectPath)) throw new DirectoryNotFoundException($"Project directory not found: {projectPath}");
         var outputIndex = Array.IndexOf(args, "--output");
         if (outputIndex >= 0 && outputIndex + 1 >= args.Length) return Fail("--output requires a directory path.");
         var outputDirectory = outputIndex >= 0 ? Path.GetFullPath(args[outputIndex + 1]) : null;
-        var result = await new ProjectContentBuilder(entryCatalog).BuildAsync(projectPath, outputDirectory);
+        var result = await new ProjectContentBuilder(schema.Catalog, configurations: schema.Configurations).BuildAsync(projectPath, outputDirectory);
         WriteJson(new ToolResult("project.build", true, new ProjectBuildReport(result.OutputPath, result.CompiledGroupCount), result.Diagnostics));
         return 0;
     }
diff --git a/src/Editor/GalNet.Editor.Headless/Properties/PublishProfiles/WindowsReadyToRun.pubxml b/src/Editor/GalNet.Editor.Headless/Properties/PublishProfiles/WindowsReadyToRun.pubxml
new file mode 100644
index 00000000..b72131f7
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Headless/Properties/PublishProfiles/WindowsReadyToRun.pubxml
@@ -0,0 +1,10 @@
+<Project>
+  <PropertyGroup>
+    <Configuration>Release</Configuration>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <SelfContained>true</SelfContained>
+    <PublishReadyToRun>true</PublishReadyToRun>
+    <PublishSingleFile>false</PublishSingleFile>
+    <PublishTrimmed>false</PublishTrimmed>
+  </PropertyGroup>
+</Project>
diff --git a/src/Editor/GalNet.Editor.Headless/README.md b/src/Editor/GalNet.Editor.Headless/README.md
index ff42e2f6..0dcb0587 100644
--- a/src/Editor/GalNet.Editor.Headless/README.md
+++ b/src/Editor/GalNet.Editor.Headless/README.md
@@ -1,5 +1,22 @@
 # 项目工具 CLI
 
+`game inspect <content-directory>` 无需作者项目或契约，只读返回安装内容的 projectId、buildId 和分包描述。支持 game.pak 固定入口和旧 content.json；此命令读取描述，不执行全部资源载荷或游戏运行校验。
+
+默认视觉资源可通过 `project visuals install <project> [--dry-run]` 显式补入；保留已有绑定与作者修改，需先部署当前项目契约。使用方式见[默认视觉库](../../../docs/manual/default-visuals.md)。
+
+外部 Agent 创作 Skill 随 CLI 分发在 `Skills/galnet-project-authoring/`，支持文本转 Group、给对白补演出和资源导入。完整使用流程及 Editor 热重载见[外部工具创作](../../../docs/manual/external-project-authoring.md)。
+
+```text
+project apply <project> <manifest-file> [--dry-run]
+help project.apply --json
+```
+
+`project.apply` 将原生作者文件与资源作为一个批次应用。版本 1 manifest 包含 `writes`/`deletes`；write 为 `path`、相对 manifest 目录的 `source`、`contentHash` 与必需的 `expectedHash`，delete 为 `path`/`expectedHash`。哈希使用 SHA-256；`expectedHash: null` 明确要求新目标不存在。target 拒绝链接、越界和 Contracts/Output/Temp/内部目录，Graph/settings 固定入口不可删除。资源与 sidecar 必须配对，替换已有 metadata 保持 ID；被移除资源/Graph 节点和删除路径的剩余静态 JSON 引用需同批更新。
+
+dry-run 在临时候选中运行当前项目契约的完整校验，不写项目。原有媒体只建立存在性占位，不复制或解码载荷；variants 描述与 metadata 保留真实内容供校验。正式发布复核目标原哈希、校验输入和项目文件集合，再用作者文件事务统一复制/删除；失败补偿，成功无持久 Undo。报告包含 `writtenFiles`、`deletedFiles`、`contentHashes` 和 `validation`，沿用完整性及 skippedChecks；自定义代码引用和媒体内容未被检查。
+
+Editor 对任意来源文件修改执行通用热重载：无本地未保存内容/草稿时采纳新基线并刷新打开页面；有冲突时保留当前输入。采纳外部版本清除旧 Undo/Redo，Git 或用户备份负责后续回退。项目契约 DLL 变化仍需要重新打开项目。
+
 ```text
 help
 help --json
diff --git a/src/Editor/GalNet.Editor.Headless/packages.lock.WindowsReadyToRun.json b/src/Editor/GalNet.Editor.Headless/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..756af833
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Headless/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,109 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.debugging": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.editor.abstraction": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )"
+        }
+      },
+      "galnet.editor.shared": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Debugging": "[1.0.0, )",
+          "GalNet.Editor.Abstraction": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.storage.filesystem": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      },
+      "Serilog": {
+        "type": "CentralTransitive",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Editor/GalNet.Editor.Headless/packages.lock.json b/src/Editor/GalNet.Editor.Headless/packages.lock.json
index 106d16c3..025c38ce 100644
--- a/src/Editor/GalNet.Editor.Headless/packages.lock.json
+++ b/src/Editor/GalNet.Editor.Headless/packages.lock.json
@@ -10,6 +10,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -47,9 +48,19 @@
           "Serilog": "[4.2.0, )"
         }
       },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -58,10 +69,19 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
+      "galnet.storage.filesystem": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
       "CoreCLR-NCalc": {
         "type": "CentralTransitive",
         "requested": "[3.1.253, )",
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/AssetFileCommandExecutor.cs b/src/Editor/GalNet.Editor.Shared/Commands/AssetFileCommandExecutor.cs
index c98b5d93..38ca58aa 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/AssetFileCommandExecutor.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/AssetFileCommandExecutor.cs
@@ -7,7 +7,8 @@
 namespace GalNet.Editor.Shared.Commands;
 
 /// <summary>CLI adapter. The same planner and publisher are used by the GUI; only the GUI retains undo records.</summary>
-public sealed class AssetFileCommandExecutor(IEntryCatalog catalog, IResourceTypeCatalog? resourceTypes = null) : IProjectFileCommandExecutor
+public sealed class AssetFileCommandExecutor(IEntryCatalog catalog, IResourceTypeCatalog? resourceTypes = null,
+    GalNet.Core.Configuration.ProjectConfigurationSchema? configurations = null) : IProjectFileCommandExecutor
 {
     public static ProjectFileRequest Translate(IProjectFileCommand command)
     {
@@ -29,7 +30,7 @@ public async Task<FileCommandResult> ExecuteAsync(string projectPath, IProjectFi
         try
         {
             cancellationToken.ThrowIfCancellationRequested();
-            var persistence = new DirectProjectPersistence(projectPath, new EditorDocumentRepository(catalog));
+            var persistence = new DirectProjectPersistence(projectPath, new EditorDocumentRepository(catalog), configurations);
             var document = persistence.Load();
             using var edit = new ProjectFileOperation(projectPath, Translate(command), catalog, resourceTypes);
             await edit.ApplyAsync(true, prepare => persistence.PublishStructureAsync(document, prepare, cancellationToken));
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandDomains.cs b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandDomains.cs
index 36767981..10d718ae 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandDomains.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandDomains.cs
@@ -1,3 +1,4 @@
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Abstraction.Documents;
@@ -14,10 +15,10 @@ private interface ICommandDomain
 
     private readonly ICommandDomain[] Domains;
 
-    public BuiltInEditorCommandHandler(IEntryCatalog catalog)
+    public BuiltInEditorCommandHandler(IEntryCatalog catalog, ProjectConfigurationSchema? configurations = null)
     {
         ArgumentNullException.ThrowIfNull(catalog);
-        Domains = [new GraphDomain(), new EntryDomain(catalog), new VariableDomain(), new ProjectDomain()];
+        Domains = [new GraphDomain(), new EntryDomain(catalog), new VariableDomain(), new ProjectDomain(configurations ?? ProjectConfigurationSchema.Empty)];
     }
 
     private sealed class GraphDomain : ICommandDomain
@@ -77,10 +78,10 @@ private sealed class VariableDomain : ICommandDomain
             _ => throw new InvalidOperationException()
         };
     }
-    private sealed class ProjectDomain : ICommandDomain
+    private sealed class ProjectDomain(ProjectConfigurationSchema configurations) : ICommandDomain
     {
-        public bool CanHandle(IProjectEditCommand command) => command is RenameProjectCommand or PatchProjectSettingsCommand;
-        public CommandExecution Execute(EditorProjectDocument d, IProjectEditCommand c, EditorCommandContext _) => c switch { RenameProjectCommand v => RenameProject(d, v), PatchProjectSettingsCommand v => PatchSettings(d, v), _ => throw new InvalidOperationException() };
+        public bool CanHandle(IProjectEditCommand command) => command is RenameProjectCommand or PatchConfigurationCommand;
+        public CommandExecution Execute(EditorProjectDocument d, IProjectEditCommand c, EditorCommandContext _) => c switch { RenameProjectCommand v => RenameProject(d, v), PatchConfigurationCommand v => PatchConfiguration(d, v, configurations), _ => throw new InvalidOperationException() };
     }
 
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Entry.cs b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Entry.cs
index d80f245a..328cc5c9 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Entry.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Entry.cs
@@ -21,14 +21,14 @@ private static CommandExecution AddEntry(EditorProjectDocument document, AddEntr
         var type = command.Type.Trim();
         if (!catalog.TryGet(type, out var definition))
             return Error("group.entry.unknownType", $"Unknown entry type '{type}'.");
-        if (command.Parameters?.Keys.FirstOrDefault(key => !definition.Parameters.ContainsKey(key)) is { } unknown)
+        if (command.Parameters?.Keys.FirstOrDefault(key => !definition.DynamicParameters.ContainsKey(key)) is { } unknown)
             return Error("group.entry.unknownParameter", $"Unknown parameter '{unknown}' for '{type}'.");
         var entry = new EditorEntryData
         {
             StableId = command.EntryId,
             Type = type,
             Condition = command.Condition ?? "",
-            Parameters = EditorEntryData.ParseParameters(catalog, type, catalog.Create(type, values: command.Parameters).Values)
+            Parameters = EditorEntryData.CreateParameters(catalog, type, command.Parameters)
         };
         groupEntries.Insert(index, entry);
         Renumber(groupEntries);
@@ -68,7 +68,7 @@ private static CommandExecution SetEntryType(EditorProjectDocument document, Set
         if (!catalog.TryGet(type, out _))
             return Error("group.entry.unknownType", $"Unknown entry type '{type}'.");
         entry!.Type = type;
-        entry.Parameters = EditorEntryData.ParseParameters(catalog, type, catalog.Create(type).Values);
+        entry.Parameters = EditorEntryData.CreateParameters(catalog, type);
         return Success($"Set entry '{command.EntryId}' type to '{entry.Type}'.", "History.Entry.SetType", EntryResource(command.GroupId, command.EntryId), command.EntryId, entry.Type);
     }
 
@@ -84,9 +84,9 @@ private static CommandExecution SetEntryParameters(EditorProjectDocument documen
     {
         if (!TryFindEntry(document, command.GroupId, command.EntryId, out _, out var entry, out var failure))
             return failure!;
-        if (command.Parameters.Keys.FirstOrDefault(key => !catalog.Get(entry!.Type).Parameters.ContainsKey(key)) is { } unknown)
+        if (command.Parameters.Keys.FirstOrDefault(key => !catalog.Get(entry!.Type).DynamicParameters.ContainsKey(key)) is { } unknown)
             return Error("group.entry.unknownParameter", $"Unknown parameter '{unknown}' for '{entry!.Type}'.");
-        entry!.Parameters = EditorEntryData.ParseParameters(catalog, entry.Type, catalog.Create(entry.Type, values: command.Parameters).Values);
+        entry!.Parameters = EditorEntryData.CreateParameters(catalog, entry.Type, command.Parameters);
         return Success($"Replaced parameters for entry '{command.EntryId}'.", "History.Entry.SetParameters", EntryResource(command.GroupId, command.EntryId), command.EntryId);
     }
 
@@ -99,12 +99,12 @@ private static CommandExecution PatchEntryParameters(EditorProjectDocument docum
         {
             if (string.IsNullOrWhiteSpace(key))
                 return Error("group.entry.parameterKeyRequired", "Entry parameter keys cannot be empty.");
-            if (!catalog.Get(entry.Type).Parameters.ContainsKey(key))
+            if (!catalog.Get(entry.Type).DynamicParameters.ContainsKey(key))
                 return Error("group.entry.unknownParameter", $"Unknown parameter '{key}' for '{entry.Type}'.");
             if (value is null) parameters.Remove(key);
             else parameters[key] = value;
         }
-        entry.Parameters = EditorEntryData.ParseParameters(catalog, entry.Type, catalog.Create(entry.Type, values: parameters).Values);
+        entry.Parameters = EditorEntryData.CreateParameters(catalog, entry.Type, parameters);
         return Success($"Patched parameters for entry '{command.EntryId}'.", "History.Entry.PatchParameters", EntryResource(command.GroupId, command.EntryId), command.EntryId);
     }
 
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Graph.cs b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Graph.cs
index beada22f..0319531c 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Graph.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Graph.cs
@@ -11,7 +11,7 @@ private static CommandExecution CreateNode(EditorProjectDocument document, Creat
             return Error("graph.node.idRequired", "Node ID is required.");
         if (FindNode(document, command.NodeId) is not null)
             return Error("graph.node.duplicateId", $"Node '{command.NodeId}' already exists.", NodeResource(command.NodeId));
-        if (!double.IsFinite(command.X) || !double.IsFinite(command.Y))
+        if (!GraphEditRules.IsFinitePosition(command.X, command.Y))
             return Error("graph.node.invalidPosition", "Node coordinates must be finite numbers.");
         if (command.Kind == EditorNodeKind.LinearGroup && (command.NodeId is "." or ".." || command.NodeId.Contains('/') || command.NodeId.Contains('\\') || command.NodeId.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0))
             return Error("graph.node.invalidGroupId", "Group node ID must be a valid single filename component.");
@@ -33,7 +33,7 @@ private static CommandExecution CreateNode(EditorProjectDocument document, Creat
                 EditorNodeKind.ConditionBranch => "Condition",
                 _ => null
             },
-            Name = string.IsNullOrWhiteSpace(command.Name) ? command.NodeId : command.Name.Trim(),
+            Name = string.IsNullOrWhiteSpace(command.Name) ? command.NodeId : GraphEditRules.NormalizeName(command.Name),
             X = command.X,
             Y = command.Y,
             File = command.Kind == EditorNodeKind.LinearGroup ? $"groups/{command.NodeId}.rawgalgroup" : null,
@@ -81,7 +81,7 @@ private static CommandExecution RenameNode(EditorProjectDocument document, Renam
         if (string.IsNullOrWhiteSpace(command.Name))
             return Error("graph.node.nameRequired", "Node name is required.", NodeResource(command.NodeId));
         var oldName = node.Name;
-        node.Name = command.Name.Trim();
+        node.Name = GraphEditRules.NormalizeName(command.Name);
         return Success($"Renamed node '{oldName}' to '{node.Name}'.", "History.Graph.RenameNode", NodeResource(node.Id), oldName, node.Name);
     }
 
@@ -97,7 +97,7 @@ private static CommandExecution MoveNodes(EditorProjectDocument document, MoveNo
             var node = FindNode(document, position.NodeId);
             if (node is null)
                 return NotFound("graph.node.notFound", "Node", position.NodeId, NodeResource(position.NodeId));
-            if (!double.IsFinite(position.X) || !double.IsFinite(position.Y))
+            if (!GraphEditRules.IsFinitePosition(position.X, position.Y))
                 return Error("graph.node.invalidPosition", $"Coordinates for node '{position.NodeId}' must be finite.");
         }
         foreach (var position in command.Nodes)
@@ -129,15 +129,9 @@ private static CommandExecution Connect(EditorProjectDocument document, ConnectN
             return NotFound("graph.node.notFound", "Node", command.FromNodeId, NodeResource(command.FromNodeId));
         if (to is null)
             return NotFound("graph.node.notFound", "Node", command.ToNodeId, NodeResource(command.ToNodeId));
-        if (from.Id == to.Id)
-            return Error("graph.edge.selfConnection", "A node cannot connect to itself.");
-        if (IsEntryNode(to))
-            return Error("graph.edge.entryInput", "The entry node cannot have an incoming edge.", NodeResource(to.Id));
-        if (command.Outlet < 0 || command.Outlet >= OutputCount(from))
-            return Error("graph.edge.invalidOutlet", $"Outlet {command.Outlet} does not exist on node '{from.Id}'.", NodeResource(from.Id));
+        if (GraphEditRules.ConnectionError(from, command.Outlet, to) is { } issue)
+            return CommandExecution.Failed(issue);
 
-        document.Graph.Edges.RemoveAll(edge =>
-            (edge.FromNodeId == from.Id && edge.FromOutlet == command.Outlet));
         var edge = new EditorGraphEdgeDto
         {
             Id = string.IsNullOrWhiteSpace(command.EdgeId) ? Guid.NewGuid().ToString("N") : command.EdgeId,
@@ -147,6 +141,8 @@ private static CommandExecution Connect(EditorProjectDocument document, ConnectN
         };
         if (document.Graph.Edges.Any(item => item.Id == edge.Id))
             return Error("graph.edge.duplicateId", $"Edge '{edge.Id}' already exists.");
+        document.Graph.Edges.RemoveAll(edge =>
+            (edge.FromNodeId == from.Id && edge.FromOutlet == command.Outlet));
         document.Graph.Edges.Add(edge);
         return Success(
             $"Connected '{from.Id}' outlet {command.Outlet} to '{to.Id}'.",
@@ -192,11 +188,6 @@ private static bool IsConditionNode(EditorGraphNodeDto node) =>
         node.Type.Equals("Branch", StringComparison.OrdinalIgnoreCase) &&
         node.BranchType?.Equals("Condition", StringComparison.OrdinalIgnoreCase) == true;
 
-    private static int OutputCount(EditorGraphNodeDto node)
-    {
-        if (IsChoiceNode(node)) return Math.Max(1, node.Options?.Count ?? 0);
-        if (IsConditionNode(node)) return Math.Max(1, node.Conditions?.Count ?? 0);
-        return 1;
-    }
+    private static int OutputCount(EditorGraphNodeDto node) => GraphEditRules.OutputCount(node);
 
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Project.cs b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Project.cs
index b6d81820..c88e6a6b 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Project.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Project.cs
@@ -1,5 +1,5 @@
 using System.Text.Json;
-using GalNet.Core.I18n;
+using GalNet.Core.Configuration;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Abstraction.Documents;
 
@@ -16,56 +16,19 @@ private static CommandExecution RenameProject(EditorProjectDocument document, Re
         return Success($"Renamed project '{oldName}' to '{document.Graph.Name}'.", "History.Project.Rename", "project", oldName, document.Graph.Name);
     }
 
-    private static CommandExecution PatchSettings(EditorProjectDocument document, PatchProjectSettingsCommand command)
+    private static CommandExecution PatchConfiguration(EditorProjectDocument document, PatchConfigurationCommand command,
+        ProjectConfigurationSchema configurations)
     {
-        if (command.Values.Count == 0)
-            return Error("project.settings.emptyPatch", "At least one project setting is required.");
-        foreach (var (key, value) in command.Values)
+        var section = configurations.Sections.FirstOrDefault(section => section.Id == command.SectionId);
+        if (section is null) return Error("project.configuration.unknownSection", $"Configuration section '{command.SectionId}' is not declared.");
+        if (command.Values is null || command.Values.Count + (command.Remove?.Count ?? 0) == 0)
+            return Error("project.configuration.emptyPatch", "At least one field change is required.");
+        try
         {
-            try
-            {
-                switch (key)
-                {
-                    case "defaultWidth":
-                        document.Settings.DefaultWidth = PositiveInt(value, key);
-                        break;
-                    case "defaultHeight":
-                        document.Settings.DefaultHeight = PositiveInt(value, key);
-                        break;
-                    case "saveSlotCount":
-                        document.Settings.SaveSlotCount = NonNegativeInt(value, key);
-                        break;
-                    case "sfxChannelCount":
-                        document.Settings.SfxChannelCount = PositiveInt(value, key);
-                        break;
-                    case "targetLocale":
-                        var locale = new I18nLocale(value.GetString() ?? throw new JsonException("A locale string is required."));
-                        document.Settings.TargetLocale = locale;
-                        if (!document.Settings.AvailableLocales.Contains(locale))
-                            document.Settings.AvailableLocales.Add(locale);
-                        break;
-                    default:
-                        return Error("project.settings.unknownField", $"Project setting '{key}' is not editable through this command.");
-                }
-            }
-            catch (Exception exception) when (exception is JsonException or InvalidOperationException or ArgumentException)
-            {
-                return Error("project.settings.invalidValue", $"Invalid value for '{key}': {exception.Message}");
-            }
+            document.Configuration.Patch(section, command.Values, command.Remove);
+            return Success($"Updated configuration '{section.Id}'.", "History.ProjectSettings.Patch", ["project/configuration/" + section.Id], command.Values.Count + (command.Remove?.Count ?? 0));
         }
-        return Success($"Updated {command.Values.Count} project setting(s).", "History.ProjectSettings.Patch", ["project/settings"], command.Values.Count);
+        catch (Exception error) when (error is JsonException or InvalidDataException or ArgumentException)
+        { return Error("project.configuration.invalidValue", error.Message); }
     }
-
-    private static int PositiveInt(JsonElement value, string key)
-    {
-        var result = value.GetInt32();
-        return result > 0 ? result : throw new InvalidOperationException($"'{key}' must be greater than zero.");
-    }
-
-    private static int NonNegativeInt(JsonElement value, string key)
-    {
-        var result = value.GetInt32();
-        return result >= 0 ? result : throw new InvalidOperationException($"'{key}' cannot be negative.");
-    }
-
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Variable.cs b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Variable.cs
index a2e7bc5e..7ac1d134 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Variable.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/BuiltInEditorCommandHandler.Variable.cs
@@ -35,7 +35,6 @@ private static CommandExecution AddVariable(EditorProjectDocument document, AddV
         if (command.DefaultValue is { } value && !TrySetVariableValue(variable, value, out var message))
             return Error("variable.invalidDefault", message!);
         list.Insert(index, variable);
-        SyncSettingsVariables(document);
         return Success($"Added {command.Scope.ToString().ToLowerInvariant()} variable '{command.Name}'.", "History.Variable.Add", VariableResource(command.Scope, command.Name), command.Name);
     }
 
@@ -46,7 +45,6 @@ private static CommandExecution DeleteVariable(EditorProjectDocument document, D
         if (variable is null)
             return NotFound("variable.notFound", "Variable", command.Name, VariableResource(command.Scope, command.Name));
         list.Remove(variable);
-        SyncSettingsVariables(document);
         return Success($"Deleted {command.Scope.ToString().ToLowerInvariant()} variable '{command.Name}'.", "History.Variable.Delete", VariableResource(command.Scope, command.Name), command.Name);
     }
 
@@ -60,7 +58,6 @@ private static CommandExecution MoveVariable(EditorProjectDocument document, Mov
             return InvalidIndex("variable", command.Index, list.Count);
         list.Remove(variable);
         list.Insert(command.Index, variable);
-        SyncSettingsVariables(document);
         return Success($"Moved variable '{command.Name}' to index {command.Index}.", "History.Variable.Move", VariableResource(command.Scope, command.Name), command.Name, command.Index);
     }
 
@@ -78,7 +75,6 @@ private static CommandExecution RenameVariable(EditorProjectDocument document, R
             ReplaceVariableReferences(document, command.Name, command.NewName);
         variable.Name = command.NewName;
         variable.DefaultValue.Name = command.NewName;
-        SyncSettingsVariables(document);
         return Success($"Renamed variable '{command.Name}' to '{command.NewName}'.", "History.Variable.Rename", VariableResource(command.Scope, command.NewName), command.Name, command.NewName);
     }
 
@@ -88,7 +84,6 @@ private static CommandExecution SetVariableType(EditorProjectDocument document,
         if (variable is null)
             return NotFound("variable.notFound", "Variable", command.Name, VariableResource(command.Scope, command.Name));
         variable.Type = command.Type;
-        SyncSettingsVariables(document);
         return Success($"Set variable '{command.Name}' type to {command.Type}.", "History.Variable.SetType", VariableResource(command.Scope, command.Name), command.Name, command.Type);
     }
 
@@ -99,7 +94,6 @@ private static CommandExecution SetVariableDefault(EditorProjectDocument documen
             return NotFound("variable.notFound", "Variable", command.Name, VariableResource(command.Scope, command.Name));
         if (!TrySetVariableValue(variable, command.Value, out var message))
             return Error("variable.invalidDefault", message!);
-        SyncSettingsVariables(document);
         return Success($"Updated default value for variable '{command.Name}'.", "History.Variable.SetDefault", VariableResource(command.Scope, command.Name), command.Name);
     }
 
@@ -150,12 +144,6 @@ private static void ReplaceVariableReferences(EditorProjectDocument document, st
         }
     }
 
-    private static void SyncSettingsVariables(EditorProjectDocument document)
-    {
-        document.Settings.PlayerVariables = document.Graph.PlayerVariables.Select(item => item.Clone()).ToList();
-        document.Settings.SaveVariables = document.Graph.SaveVariables.Select(item => item.Clone()).ToList();
-    }
-
     private static List<ProjectVariableDefinition> Variables(EditorProjectDocument document, VariableScope scope) =>
         scope == VariableScope.Player ? document.Graph.PlayerVariables : document.Graph.SaveVariables;
 
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/DirectProjectPersistence.cs b/src/Editor/GalNet.Editor.Shared/Commands/DirectProjectPersistence.cs
index 8e11eb8c..a489295d 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/DirectProjectPersistence.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/DirectProjectPersistence.cs
@@ -1,6 +1,5 @@
 using System.Text.Json;
-using System.Text.Json.Serialization;
-using GalNet.Core.Settings;
+using GalNet.Core.Configuration;
 using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
@@ -8,15 +7,9 @@
 
 namespace GalNet.Editor.Shared.Commands;
 
-public sealed class DirectProjectPersistence(string projectPath, IEditorDocumentRepository repository)
+public sealed class DirectProjectPersistence(string projectPath, IEditorDocumentRepository repository, ProjectConfigurationSchema? configurations = null)
 {
-    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
-    {
-        WriteIndented = true,
-        PropertyNameCaseInsensitive = false,
-        UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow,
-        Converters = { new JsonStringEnumConverter() }
-    };
+    private static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true };
     private readonly string _projectPath = Path.GetFullPath(projectPath);
     private readonly IEditorDocumentRepository _repository = repository ?? throw new ArgumentNullException(nameof(repository));
     private byte[]? _settingsBaseline;
@@ -25,15 +18,15 @@ public EditorProjectDocument Load()
     {
         if (!Directory.Exists(_projectPath)) throw new DirectoryNotFoundException($"Project directory not found: {_projectPath}");
         var settings = LoadSettings(_projectPath);
+        configurations?.Validate(settings);
         _settingsBaseline = File.ReadAllBytes(new ProjectRawReader(_projectPath).Resolve("settings.json"));
-        var loaded = _repository.Load(_projectPath, Path.GetFileName(Path.TrimEndingDirectorySeparator(_projectPath)), settings);
-        return new EditorProjectDocument { Graph = loaded.Document, GroupEntries = loaded.GroupEntries, Settings = settings };
+        var loaded = _repository.Load(_projectPath);
+        return new EditorProjectDocument { Graph = loaded.Document, GroupEntries = loaded.GroupEntries, Configuration = settings };
     }
 
     public Task SaveAsync(EditorProjectDocument document, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        if (File.Exists(Path.Combine(_projectPath, "settings.json"))) _ = LoadSettings(_projectPath);
         var plan = PrepareSave(document);
         _repository.ApplySave(_projectPath, plan, cancellationToken);
         _settingsBaseline = plan.Writes["settings.json"].ToArray();
@@ -42,17 +35,15 @@ public Task SaveAsync(EditorProjectDocument document, CancellationToken cancella
 
     public ProjectSavePlan PrepareSave(EditorProjectDocument document)
     {
+        configurations?.Validate(document.Configuration);
         var settingsPath = new ProjectRawReader(_projectPath).Resolve("settings.json");
         if (_settingsBaseline is not null && (!File.Exists(settingsPath) || !_settingsBaseline.AsSpan().SequenceEqual(File.ReadAllBytes(settingsPath))))
             throw new IOException("Project settings changed after loading. Reload before saving.");
         if (File.Exists(settingsPath)) _ = LoadSettings(_projectPath);
         var plan = _repository.PrepareSave(_projectPath, document.Graph,
             document.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value));
-        var settings = JsonSerializer.SerializeToElement(document.Settings, JsonOptions).Deserialize<ProjectSettings>(JsonOptions)!;
-        settings.PlayerVariables = document.Graph.PlayerVariables.Select(item => item.Clone()).ToList();
-        settings.SaveVariables = document.Graph.SaveVariables.Select(item => item.Clone()).ToList();
         var writes = new Dictionary<string, byte[]>(plan.Writes)
-        { ["settings.json"] = JsonSerializer.SerializeToUtf8Bytes(settings, JsonOptions) };
+        { ["settings.json"] = JsonSerializer.SerializeToUtf8Bytes(document.Configuration, JsonOptions) };
         return new(writes, plan.DeletedFiles);
     }
 
@@ -65,11 +56,11 @@ public Task PublishStructureAsync(EditorProjectDocument document, Func<EditorPro
         if (change is GalNet.Editor.Abstraction.Changes.IProjectFileStructureChange files) plan = plan with { Files = files.Files };
         _repository.ApplySave(_projectPath, plan, cancellationToken);
         _settingsBaseline = plan.Writes["settings.json"].ToArray();
-        document.Graph = next.Graph; document.GroupEntries = next.GroupEntries; document.Settings = next.Settings;
+        document.Graph = next.Graph; document.GroupEntries = next.GroupEntries; document.Configuration = next.Configuration;
         return Task.CompletedTask;
     }
 
-    public static ProjectSettings LoadSettings(string projectPath)
+    public static ProjectConfiguration LoadSettings(string projectPath)
     {
         var path = new ProjectRawReader(projectPath).Resolve("settings.json");
         using var raw = JsonDocument.Parse(File.ReadAllBytes(path));
@@ -77,7 +68,8 @@ public static ProjectSettings LoadSettings(string projectPath)
         var diagnostics = new List<GalNet.Editor.Abstraction.Commands.ToolDiagnostic>();
         ProjectValidationService.DuplicateProperties(raw.RootElement, "settings.json", "", diagnostics);
         if (diagnostics.Count != 0) throw new InvalidDataException(string.Join("\n", diagnostics.Select(item => $"{item.JsonPointer}: {item.Message}")));
-        return raw.RootElement.Deserialize<ProjectSettings>(JsonOptions)
+        var settings = raw.RootElement.Deserialize<ProjectConfiguration>(JsonOptions)
             ?? throw new InvalidDataException("Project settings must be an object.");
+        return settings;
     }
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/EditorCommandCatalog.cs b/src/Editor/GalNet.Editor.Shared/Commands/EditorCommandCatalog.cs
index 1a1903ff..ccf0f8b2 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/EditorCommandCatalog.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/EditorCommandCatalog.cs
@@ -64,7 +64,7 @@ private static IReadOnlyList<IProjectCommandDefinition> CreateDefinitions() =>
         Define<SetVariableDefinitionTypeCommand>("variable.definition.setType", "Changes a variable type and converts or resets its default value."),
         Define<SetVariableDefaultValueCommand>("variable.definition.setDefault", "Changes the default value of a project variable."),
         Define<RenameProjectCommand>("project.rename", "Changes the project display name without moving its directory."),
-        Define<PatchProjectSettingsCommand>("project.settings.patch", "Updates selected project settings after validating each supported field.")
+        Define<PatchConfigurationCommand>("project.configuration.patch", "Sets or removes fields in a declared configuration section; validates the complete candidate before publishing.")
     ];
 
     private static ProjectCommandDefinition Define<TCommand>(string id, string description)
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/EditorDocumentValidator.cs b/src/Editor/GalNet.Editor.Shared/Commands/EditorDocumentValidator.cs
index 61546d8f..94b17bae 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/EditorDocumentValidator.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/EditorDocumentValidator.cs
@@ -5,9 +5,11 @@ namespace GalNet.Editor.Shared.Commands;
 
 public sealed class EditorDocumentValidator
 {
-    public static ValidationResult Validate(EditorProjectDocument document)
+    public static ValidationResult Validate(EditorProjectDocument document, GalNet.Core.Configuration.ProjectConfigurationSchema? configurations = null)
     {
         var diagnostics = new List<EditorDiagnostic>();
+        try { configurations?.Validate(document.Configuration); }
+        catch (InvalidDataException error) { diagnostics.Add(EditorDiagnostic.Error("settings.configuration.invalid", error.Message, "settings.json")); }
         AddDuplicateDiagnostics(document.Graph.Nodes.Select(node => node.Id), "graph.node.duplicateId", "node", diagnostics);
         AddDuplicateDiagnostics(document.Graph.Edges.Select(edge => edge.Id), "graph.edge.duplicateId", "edge", diagnostics);
         if (document.Graph.Nodes.Any(node => string.IsNullOrWhiteSpace(node.Id)))
@@ -26,10 +28,10 @@ public static ValidationResult Validate(EditorProjectDocument document)
         {
             if (!nodes.TryGetValue(edge.FromNodeId, out var from))
                 diagnostics.Add(EditorDiagnostic.Error("graph.edge.fromNotFound", $"Edge '{edge.Id}' references missing source node '{edge.FromNodeId}'.", $"graph/edges/{edge.Id}"));
-            if (!nodes.ContainsKey(edge.ToNodeId))
+            if (!nodes.TryGetValue(edge.ToNodeId, out var to))
                 diagnostics.Add(EditorDiagnostic.Error("graph.edge.toNotFound", $"Edge '{edge.Id}' references missing target node '{edge.ToNodeId}'.", $"graph/edges/{edge.Id}"));
-            if (from is not null && (edge.FromOutlet < 0 || edge.FromOutlet >= OutputCount(from)))
-                diagnostics.Add(EditorDiagnostic.Error("graph.edge.invalidOutlet", $"Edge '{edge.Id}' references invalid outlet {edge.FromOutlet} on '{from.Id}'.", $"graph/edges/{edge.Id}"));
+            if (from is not null && GraphEditRules.ConnectionError(from, edge.FromOutlet, to) is { } issue)
+                diagnostics.Add(EditorDiagnostic.Error(issue.Code, issue.Message, $"graph/edges/{edge.Id}"));
         }
 
         foreach (var (groupId, entries) in document.GroupEntries)
@@ -66,12 +68,4 @@ private static void AddDuplicateDiagnostics(
             diagnostics.Add(EditorDiagnostic.Error(code, $"Duplicate {kind} identifier '{value.Key}'."));
     }
 
-    private static int OutputCount(EditorGraphNodeDto node)
-    {
-        if (node.BranchType?.Equals("Choice", StringComparison.OrdinalIgnoreCase) == true)
-            return Math.Max(1, node.Options?.Count ?? 0);
-        if (node.BranchType?.Equals("Condition", StringComparison.OrdinalIgnoreCase) == true)
-            return Math.Max(1, node.Conditions?.Count ?? 0);
-        return 1;
-    }
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/EditorProjectCreator.cs b/src/Editor/GalNet.Editor.Shared/Commands/EditorProjectCreator.cs
index 22f2ced6..fc6a6a58 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/EditorProjectCreator.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/EditorProjectCreator.cs
@@ -1,10 +1,13 @@
 using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
-using GalNet.Core.Settings;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Project;
 using GalNet.Editor.Shared.Services;
+using GalNet.Editor.Shared.Visuals;
 
 namespace GalNet.Editor.Shared.Commands;
 
@@ -12,16 +15,14 @@ public static class EditorProjectCreator
 {
     private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web) { WriteIndented = true };
 
-    public static async Task<ToolResult> CreateAsync(ProjectCreateRequest request, ProjectSettings? settings = null,
+    public static async Task<ToolResult> CreateAsync(ProjectCreateRequest request, ProjectConfiguration? settings = null,
         CancellationToken cancellationToken = default)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(request.Path);
         var root = Path.TrimEndingDirectorySeparator(Path.GetFullPath(request.Path));
         if (root == Path.GetPathRoot(root)) throw new ArgumentException("A filesystem root cannot be a project target.");
         var parent = Path.GetDirectoryName(root)!;
-        for (var current = root; current is not null; current = Path.GetDirectoryName(current))
-            if ((File.Exists(current) || Directory.Exists(current)) && (File.GetAttributes(current) & FileAttributes.ReparsePoint) != 0)
-                throw new InvalidDataException("Project creation cannot traverse filesystem links.");
+        FileSystemPaths.RequireNoLinks(root, "Project creation cannot traverse filesystem links.");
         EnsureEmptyTarget(root);
         var name = request.Name is null ? Path.GetFileName(root) : request.Name.Trim();
         if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Project display name is required.");
@@ -36,8 +37,16 @@ public static async Task<ToolResult> CreateAsync(ProjectCreateRequest request, P
         }
         var entryId = Guid.NewGuid().ToString("N");
         var groupId = Guid.NewGuid().ToString("N");
+        var configuration = (settings ?? DefaultSettings()).Clone();
+        // A custom contract opts in by declaring this authoring field and effect capability.
+        var includeVisuals = contract is not null && contract.Catalog.TryGet(BuiltinEntryIds.ApplyEffect, out _) &&
+            contract.Configurations.Sections.Any(section => section.Id == DefaultProjectConfiguration.Section.Id &&
+                section.Fields.Any(field => field.Id == "defaultVisualPrograms"));
+        var visuals = includeVisuals ? DefaultVisualTemplate.Prepare(configuration) : null;
+        configuration = visuals?.Configuration ?? configuration;
         var files = new[] { "Graph/graph.json", $"Graph/groups/{groupId}.rawgalgroup", "settings.json", ".galnet/editor-state.json" }
             .Concat(contractFiles.Keys.Select(file => "Contracts/" + file))
+            .Concat(visuals?.Files.Keys ?? Enumerable.Empty<string>())
             .Concat(contract is null ? ["Contracts/README.md"] : Array.Empty<string>()).Order(StringComparer.Ordinal).ToArray();
         var report = new ProjectCreateReport(root, name, request.DryRun, contract is not null, contract?.Fingerprint, files);
         if (request.DryRun) return new("project.create", true, report, []);
@@ -58,6 +67,12 @@ public static async Task<ToolResult> CreateAsync(ProjectCreateRequest request, P
                 Directory.CreateDirectory(Path.GetDirectoryName(path)!);
                 await File.WriteAllBytesAsync(path, bytes, cancellationToken);
             }
+            foreach (var (file, bytes) in visuals?.Files ?? new Dictionary<string, byte[]>())
+            {
+                var path = new ProjectRawReader(stage).Resolve(file);
+                Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+                await File.WriteAllBytesAsync(path, bytes, cancellationToken);
+            }
             if (contract is null)
                 await File.WriteAllTextAsync(Path.Combine(stage, "Contracts/README.md"),
                     "Deploy GalNet.Project.Contracts.dll and its managed dependencies here. The public static GalNet.Project.Contracts.ProjectSchemas.Modules property declares this project's schemas. No built-in fallback is used.\n", cancellationToken);
@@ -65,7 +80,7 @@ await File.WriteAllTextAsync(Path.Combine(stage, "Contracts/README.md"),
             var catalog = deployed?.Catalog ?? new TargetProfileEntryCatalog([]);
             var document = new EditorProjectDocument
             {
-                Settings = settings ?? new ProjectSettings(),
+                Configuration = configuration,
                 Graph = new EditorGraphDocument
                 {
                     Name = name,
@@ -79,7 +94,7 @@ await File.WriteAllTextAsync(Path.Combine(stage, "Contracts/README.md"),
                 },
                 GroupEntries = { [groupId] = [] }
             };
-            await new DirectProjectPersistence(stage, new EditorDocumentRepository(catalog)).SaveAsync(document, cancellationToken);
+            await new DirectProjectPersistence(stage, new EditorDocumentRepository(catalog), contract?.Configurations).SaveAsync(document, cancellationToken);
             await File.WriteAllTextAsync(Path.Combine(stage, ".galnet/editor-state.json"), JsonSerializer.Serialize(new EditorProjectState(), JsonOptions), cancellationToken);
             cancellationToken.ThrowIfCancellationRequested();
             EnsureEmptyTarget(root);
@@ -101,6 +116,12 @@ await File.WriteAllTextAsync(Path.Combine(stage, "Contracts/README.md"),
         }
     }
 
+    private static ProjectConfiguration DefaultSettings()
+    {
+        var audio = GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create();
+        return new GalNet.Contracts.Builtins.DefaultProjectOptions { AudioBuses = audio.Buses.ToList(), AudioTracks = audio.Tracks.ToList() }.ToConfiguration();
+    }
+
     private static void EnsureEmptyTarget(string root)
     {
         if (File.Exists(root) || Directory.Exists(root) && Directory.EnumerateFileSystemEntries(root).Any())
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/GraphEditRules.cs b/src/Editor/GalNet.Editor.Shared/Commands/GraphEditRules.cs
new file mode 100644
index 00000000..7e6ca7ee
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Commands/GraphEditRules.cs
@@ -0,0 +1,25 @@
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Commands;
+
+/// <summary>Shared graph invariants; GUI history and disk command execution remain separate adapters.</summary>
+public static class GraphEditRules
+{
+    public static bool IsFinitePosition(double x, double y) => double.IsFinite(x) && double.IsFinite(y);
+    public static string NormalizeName(string name) => name.Trim();
+    public static int OutputCount(EditorGraphNodeDto node) => node.BranchType switch
+    {
+        "Choice" => node.Options?.Count ?? 0,
+        "Condition" => node.Conditions?.Count ?? 0,
+        _ => 1
+    };
+    public static EditorDiagnostic? ConnectionError(EditorGraphNodeDto from, int outlet, EditorGraphNodeDto? to)
+    {
+        if (from.Id == to?.Id) return EditorDiagnostic.Error("graph.edge.selfConnection", "A node cannot connect to itself.");
+        if (to?.Type.Equals("Entry", StringComparison.OrdinalIgnoreCase) == true)
+            return EditorDiagnostic.Error("graph.edge.entryInput", "The entry node cannot have an incoming edge.", $"graph/nodes/{to.Id}");
+        return outlet < 0 || outlet >= OutputCount(from)
+            ? EditorDiagnostic.Error("graph.edge.invalidOutlet", $"Outlet {outlet} does not exist on node '{from.Id}'.", $"graph/nodes/{from.Id}") : null;
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/ProjectApplyService.cs b/src/Editor/GalNet.Editor.Shared/Commands/ProjectApplyService.cs
new file mode 100644
index 00000000..b3d919fb
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Commands/ProjectApplyService.cs
@@ -0,0 +1,204 @@
+using System.Security.Cryptography;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Core.Assets;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Changes;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Shared.Commands;
+
+/// <summary>Optimistic, all-or-compensated publication of externally prepared project files.</summary>
+public sealed class ProjectApplyService(string root, IEntryCatalog catalog, AuthorFileTransaction? transaction = null,
+    GalNet.Core.Configuration.ProjectConfigurationSchema? configurations = null)
+{
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
+    { UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow, PropertyNameCaseInsensitive = false, RespectNullableAnnotations = true };
+
+    public async Task<ToolResult> ApplyAsync(string manifestFile, bool dryRun = false, CancellationToken cancellationToken = default)
+    {
+        const string operation = "project.apply";
+        string? scratch = null;
+        try
+        {
+            var reader = new ProjectRawReader(root);
+            manifestFile = Path.GetFullPath(manifestFile);
+            var sources = new ProjectRawReader(Path.GetDirectoryName(manifestFile)!);
+            using var raw = JsonDocument.Parse(await File.ReadAllBytesAsync(sources.Resolve(Path.GetFileName(manifestFile)), cancellationToken));
+            var duplicates = new List<ToolDiagnostic>();
+            ProjectValidationService.DuplicateProperties(raw.RootElement, "apply-manifest", "", duplicates);
+            if (duplicates.Count != 0) return new(operation, false, null, duplicates);
+            var manifest = raw.RootElement.Deserialize<ProjectApplyManifest>(JsonOptions) ?? throw new JsonException("An apply manifest must be an object.");
+            if (manifest.Version != 1 || manifest.Writes is null || manifest.Deletes is null || manifest.Writes.Count + manifest.Deletes.Count == 0)
+                throw new ArgumentException("An apply manifest requires version 1 and at least one write or deletion.");
+            var targets = new HashSet<string>(ProjectFilePaths.Comparer);
+            var plan = new ProjectFilePlan();
+            foreach (var write in manifest.Writes)
+            {
+                ArgumentNullException.ThrowIfNull(write);
+                var path = Target(write.Path, deleting: false);
+                if (!targets.Add(path)) throw new ArgumentException($"Duplicate apply target '{path}'.");
+                var expected = HashValue(write.ExpectedHash, allowNull: true);
+                if (HashFile(reader.Resolve(path)) != expected) throw new IOException($"Apply target changed: '{path}'.");
+                plan.ExpectedHashes.Add(path, expected);
+                _ = HashValue(write.ContentHash, allowNull: false);
+                _ = sources.Resolve(ProjectFilePaths.Normalize(write.Source));
+            }
+            foreach (var deletion in manifest.Deletes)
+            {
+                ArgumentNullException.ThrowIfNull(deletion);
+                var path = Target(deletion.Path, deleting: true);
+                if (!targets.Add(path)) throw new ArgumentException($"Duplicate apply target '{path}'.");
+                var expected = HashValue(deletion.ExpectedHash, allowNull: false);
+                if (HashFile(reader.Resolve(path)) != expected) throw new IOException($"Apply target changed: '{path}'.");
+                plan.ExpectedHashes.Add(path, expected); plan.Deletes.Add(path);
+            }
+            if (ExternalProjectSnapshotReader.HasPendingTransaction(root)) throw new IOException("Project publication is already in progress.");
+            scratch = Path.Combine(Path.GetTempPath(), "GalNet-apply-" + Guid.NewGuid().ToString("N"));
+            var payloads = Path.Combine(scratch, "payloads"); var candidate = Path.Combine(scratch, "project");
+            Directory.CreateDirectory(payloads); Directory.CreateDirectory(candidate);
+            var contentHashes = new Dictionary<string, string>(ProjectFilePaths.Comparer);
+            for (var index = 0; index < manifest.Writes.Count; index++)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                var write = manifest.Writes[index]; var path = Target(write.Path, false);
+                var payload = Path.Combine(payloads, index.ToString(System.Globalization.CultureInfo.InvariantCulture));
+                File.Copy(sources.Resolve(ProjectFilePaths.Normalize(write.Source)), payload);
+                var hash = HashFile(payload)!;
+                if (hash != HashValue(write.ContentHash, false)) throw new IOException($"Apply source changed or has an incorrect hash: '{write.Source}'.");
+                plan.Copies.Add(path, payload); contentHashes.Add(path, hash);
+            }
+            var diagnostics = new List<ToolDiagnostic>();
+            var originalFiles = reader.Files(null, diagnostics);
+            if (diagnostics.Count != 0) return new(operation, false, null, diagnostics);
+            var finalFiles = originalFiles.ToDictionary(path => path, reader.Resolve, ProjectFilePaths.Comparer);
+            foreach (var path in plan.Deletes) finalFiles.Remove(path);
+            foreach (var pair in plan.Copies) finalFiles[pair.Key] = pair.Value;
+            CheckAssets(reader, finalFiles, targets);
+            var types = BuiltinResourceTypes.CreateCatalog(); var codec = new AssetMetaCodec(types);
+            var descriptors = finalFiles.Where(pair => pair.Key.StartsWith("Assets/", StringComparison.Ordinal) && pair.Key.EndsWith(".meta", StringComparison.OrdinalIgnoreCase))
+                .Where(pair => codec.Deserialize(File.ReadAllText(pair.Value), pair.Key[7..^5]).TypeId == "image-variants")
+                .Select(pair => pair.Key[..^5]).ToHashSet(ProjectFilePaths.Comparer);
+            // Validation checks author JSON, sidecars, descriptor content and resource existence.
+            // Existing media payloads are intentionally not copied or decoded, matching validate's skipped asset-payloads check.
+            foreach (var (path, source) in finalFiles)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                var target = Path.Combine(candidate, path); Directory.CreateDirectory(Path.GetDirectoryName(target)!);
+                var needsContent = path.EndsWith(".json", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".rawgalgroup", StringComparison.OrdinalIgnoreCase) ||
+                    path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase) || descriptors.Contains(path);
+                if (needsContent)
+                {
+                    File.Copy(source, target);
+                    if (!plan.Copies.ContainsKey(path)) plan.ExpectedHashes.TryAdd(path, HashFile(target));
+                }
+                else using (File.Create(target)) { }
+            }
+            // Empty descriptor folders participate in image-variants validation too.
+            CopyEmptyAssetDirectories(reader, candidate);
+            _ = DirectProjectPersistence.LoadSettings(candidate);
+            var validation = new ProjectValidationService(candidate).Validate(catalog: catalog, configurations: configurations);
+            var referenceDiagnostics = validation.Success ? RemovedReferences(reader, candidate, finalFiles, targets, plan.Deletes) : [];
+            var report = new ProjectApplyReport(dryRun, plan.Copies.Keys.Order(StringComparer.Ordinal).ToArray(), plan.Deletes.Order(StringComparer.Ordinal).ToArray(),
+                contentHashes, (ProjectValidationReport)validation.Data!);
+            var allDiagnostics = validation.Diagnostics.Concat(referenceDiagnostics).ToArray();
+            if (!validation.Success || referenceDiagnostics.Any(item => item.Severity == "error")) return new(operation, false, report, allDiagnostics);
+            if (!dryRun)
+            {
+                var nowDiagnostics = new List<ToolDiagnostic>(); var currentFiles = reader.Files(null, nowDiagnostics);
+                if (nowDiagnostics.Count != 0 || !originalFiles.ToHashSet(ProjectFilePaths.Comparer).SetEquals(currentFiles))
+                    throw new IOException("The project file set changed during apply preparation.");
+                (transaction ?? new AuthorFileTransaction()).Commit(root, new ProjectSavePlan(new Dictionary<string, byte[]>(), []) { Files = plan }, cancellationToken);
+            }
+            return new(operation, true, report, allDiagnostics);
+        }
+        catch (Exception error) when (error is IOException or InvalidDataException or UnauthorizedAccessException or ArgumentException or JsonException or InvalidOperationException or KeyNotFoundException)
+        { return new(operation, false, null, [new("project.applyRejected", "error", error.Message)]); }
+        finally
+        {
+            if (scratch is not null && Directory.Exists(scratch))
+                try { Directory.Delete(scratch, true); }
+                catch (Exception error) when (error is IOException or UnauthorizedAccessException) { Serilog.Log.Warning(error, "Apply staging cleanup deferred: {Directory}", scratch); }
+        }
+    }
+
+    private static string Target(string path, bool deleting)
+    {
+        path = ProjectFilePaths.Normalize(path);
+        if (path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase)) path = "Assets/" + path[7..];
+        if (path is "Graph/graph.json" or "settings.json")
+        { if (deleting) throw new ArgumentException($"Cannot delete project entry point '{path}'."); return path; }
+        if (path == LocalizationJson.CatalogPath || path == LocalizationJson.MetadataPath) return path;
+        if (path.StartsWith("Assets/", StringComparison.Ordinal)) return path;
+        return ProjectFilePaths.Editable(path);
+    }
+
+    private static void CheckAssets(ProjectRawReader reader, IReadOnlyDictionary<string, string> finalFiles, IEnumerable<string> targets)
+    {
+        foreach (var path in targets.Where(path => path.StartsWith("Assets/", StringComparison.Ordinal)))
+        {
+            var resource = path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase) ? path[..^5] : path;
+            if (finalFiles.ContainsKey(resource) != finalFiles.ContainsKey(resource + ".meta"))
+                throw new InvalidDataException($"Resource and metadata must exist or be deleted together: '{resource}'.");
+            if (!path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase) || !finalFiles.TryGetValue(path, out var source) || !File.Exists(reader.Resolve(path))) continue;
+            using var before = JsonDocument.Parse(File.ReadAllBytes(reader.Resolve(path)));
+            using var after = JsonDocument.Parse(File.ReadAllBytes(source));
+            if (ProjectRawReader.MetadataIdentity(before.RootElement).Id != ProjectRawReader.MetadataIdentity(after.RootElement).Id)
+                throw new InvalidDataException($"Replacing existing metadata must preserve its resource identity: '{path}'.");
+        }
+    }
+
+    private static void CopyEmptyAssetDirectories(ProjectRawReader reader, string candidate)
+    {
+        if (!Directory.Exists(reader.Resolve("Assets"))) return;
+        var pending = new Stack<string>(); pending.Push("Assets");
+        while (pending.TryPop(out var path))
+        {
+            Directory.CreateDirectory(Path.Combine(candidate, path));
+            foreach (var directory in Directory.EnumerateDirectories(reader.Resolve(path)))
+            { var relative = reader.Relative(directory); _ = reader.Resolve(relative); pending.Push(relative); }
+        }
+    }
+
+    private static IReadOnlyList<ToolDiagnostic> RemovedReferences(ProjectRawReader reader, string candidate, IReadOnlyDictionary<string, string> finalFiles,
+        IEnumerable<string> targets, IEnumerable<string> deleted)
+    {
+        var removed = deleted.Select(path => (Value: path, Kind: "resource")).ToList();
+        var remainingIds = finalFiles.Where(pair => pair.Key.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)).Select(pair =>
+        { using var json = JsonDocument.Parse(File.ReadAllBytes(pair.Value)); return ProjectRawReader.MetadataIdentity(json.RootElement).Id; }).ToHashSet(StringComparer.OrdinalIgnoreCase);
+        foreach (var path in targets.Where(path => path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase) && File.Exists(reader.Resolve(path))))
+        {
+            using var json = JsonDocument.Parse(File.ReadAllBytes(reader.Resolve(path)));
+            if (ProjectRawReader.MetadataIdentity(json.RootElement).Id is { } id && !remainingIds.Contains(id)) removed.Add((id, "resource"));
+        }
+        using var oldGraph = JsonDocument.Parse(File.ReadAllBytes(reader.Resolve("Graph/graph.json")));
+        using var nextGraph = JsonDocument.Parse(File.ReadAllBytes(Path.Combine(candidate, "Graph/graph.json")));
+        var nextIds = nextGraph.RootElement.GetProperty("nodes").EnumerateArray().Select(node => ProjectRawReader.Text(node, "id")).ToHashSet(StringComparer.Ordinal);
+        foreach (var node in oldGraph.RootElement.GetProperty("nodes").EnumerateArray())
+            if (ProjectRawReader.Text(node, "id") is { } id && !nextIds.Contains(id)) removed.Add((id, ProjectRawReader.Text(node, "type") == "Group" ? "group" : "node"));
+        var result = new List<ToolDiagnostic>();
+        var query = new ProjectQueryService(candidate);
+        foreach (var (value, kind) in removed.Distinct())
+        {
+            var scan = query.References(value, kind); result.AddRange(scan.Diagnostics);
+            foreach (var reference in ((QueryPage<ProjectReferenceItem>)scan.Data!).Items)
+                result.Add(new("project.applyReference", "error", $"A static JSON reference to removed content '{value}' remains. Update it in the same batch.", reference.File, JsonPointer: reference.JsonPointer));
+        }
+        return result;
+    }
+
+    private static string? HashValue(string? value, bool allowNull)
+    {
+        if (value is null && allowNull) return null;
+        if (value is null || value.Length != 64 || !value.All(Uri.IsHexDigit)) throw new ArgumentException("Hashes must be 64 hexadecimal SHA-256 characters; expectedHash=null explicitly requests a new file.");
+        return value.ToUpperInvariant();
+    }
+    private static string? HashFile(string path)
+    {
+        if (!File.Exists(path)) return null;
+        using var stream = File.OpenRead(path); return Convert.ToHexString(SHA256.HashData(stream));
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/ProjectEditService.cs b/src/Editor/GalNet.Editor.Shared/Commands/ProjectEditService.cs
index d05723a4..9e1c5cb1 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/ProjectEditService.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/ProjectEditService.cs
@@ -8,7 +8,7 @@
 namespace GalNet.Editor.Shared.Commands;
 
 /// <summary>Shared disk-operation boundary. CLI parsing and editor presentation stay outside it.</summary>
-public sealed class ProjectEditService(string projectPath, IEntryCatalog catalog)
+public sealed class ProjectEditService(string projectPath, IEntryCatalog catalog, GalNet.Core.Configuration.ProjectConfigurationSchema? configurations = null)
 {
     public Task<ToolResult> ExecuteGroupAsync(IProjectEditCommand command, bool dryRun = false, CancellationToken cancellationToken = default)
     {
@@ -37,13 +37,13 @@ public async Task<ToolResult> ExecuteAsync(IReadOnlyList<IProjectEditCommand> co
         try
         {
             if (commands.Count == 0) throw new ArgumentException("At least one command is required.");
-            var persistence = new DirectProjectPersistence(projectPath, new EditorDocumentRepository(catalog));
+            var persistence = new DirectProjectPersistence(projectPath, new EditorDocumentRepository(catalog), configurations);
             var document = persistence.Load();
             var reader = new ProjectRawReader(projectPath);
             var pathComparer = OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
             var ownedFiles = document.Graph.Nodes.Where(node => node.Type == "Group")
                 .Select(node => reader.Relative(reader.Resolve("Graph/" + node.File))).Append("Graph/graph.json").ToHashSet(pathComparer);
-            var handler = new BuiltInEditorCommandHandler(catalog);
+            var handler = new BuiltInEditorCommandHandler(catalog, configurations);
             var descriptions = new List<string>();
             var changed = new List<string>();
             var references = new List<ProjectReferenceItem>();
@@ -122,7 +122,7 @@ public async Task<ToolResult> ExecuteJsonAsync(string json, CancellationToken ca
                 if (dryRun) throw new JsonException("File operations do not support dryRun; no files were changed.");
                 var payload = Payload(elements[0], !batch);
                 var command = files.Deserialize(CommandId(payload), payload, CommandJson.Options);
-                var result = await new AssetFileCommandExecutor(catalog).ExecuteAsync(projectPath, command, cancellationToken);
+                var result = await new AssetFileCommandExecutor(catalog, configurations: configurations).ExecuteAsync(projectPath, command, cancellationToken);
                 return new(operationId, result.Success, result,
                     result.Diagnostics.Select(item => new ToolDiagnostic(item.Code, item.Severity.ToString().ToLowerInvariant(), item.Message, item.Resource)).ToArray());
             }
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/ToolHelp.cs b/src/Editor/GalNet.Editor.Shared/Commands/ToolHelp.cs
index 02047699..a4df8b96 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/ToolHelp.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/ToolHelp.cs
@@ -28,7 +28,7 @@ public static string RenderText(IReadOnlyList<ToolOperationDefinition> definitio
                 .AppendLine(CultureInfo.InvariantCulture, $"  Batch: {definition.BatchMode}")
                 .AppendLine(CultureInfo.InvariantCulture, $"  Input: {definition.InputSchema.GetRawText()}");
             if (definition.DocumentInputSchema is { } documentInput)
-                text.AppendLine(CultureInfo.InvariantCulture, $"  Document input (execute): {documentInput.GetRawText()}");
+                text.AppendLine(CultureInfo.InvariantCulture, $"  {(definition.OperationId == "project.apply" ? "Manifest input (project apply)" : "Document input (execute)")}: {documentInput.GetRawText()}");
             foreach (var example in definition.Examples) text.AppendLine(CultureInfo.InvariantCulture, $"  Example: {example}");
             foreach (var exit in definition.ExitCodes) text.AppendLine(CultureInfo.InvariantCulture, $"  Exit {exit.Key}: {exit.Value}");
         }
diff --git a/src/Editor/GalNet.Editor.Shared/Commands/ToolOperationCatalog.cs b/src/Editor/GalNet.Editor.Shared/Commands/ToolOperationCatalog.cs
index 1282b89d..140331cc 100644
--- a/src/Editor/GalNet.Editor.Shared/Commands/ToolOperationCatalog.cs
+++ b/src/Editor/GalNet.Editor.Shared/Commands/ToolOperationCatalog.cs
@@ -44,6 +44,13 @@ public ToolOperationCatalog()
                  new("--search", "string", "Search operation ID, command path and description.")],
                 requiresProject: false),
             Route("project.info", "project info", "Shows raw project settings, graph and Group counts without modifying files.", Project()),
+            Route("project.apply", "project apply", "Validates and publishes a manifest of native author files and resources in one transaction. Every target requires its prior SHA-256 (or null for a new file); source paths are relative to the manifest directory.",
+                Project(new CliParameter("manifest-file", "string", "Version 1 JSON apply manifest; see documentInputSchema.", true, true),
+                    new("--dry-run", "boolean", "Validate the final project and report the batch without changing project files.", Default: false)),
+                readOnly: false, requiresContract: true, dryRun: true, batchMode: "Native author files, resources and sidecars in one transaction.") with
+                { DocumentInputSchema = ManifestSchema() },
+            Route("project.visuals.install", "project visuals install", "Adds missing default shader assets and project bindings atomically. Existing bindings are preserved; occupied asset paths are rejected without overwrite.",
+                Project(new CliParameter("--dry-run", "boolean", "Validate and report missing visuals without writing the project.", Default: false)), readOnly: false, requiresContract: true, dryRun: true),
             Route("project.create", "project create", "Creates an empty author project, optionally deploying a validated contract directory. Without a contract, semantic operations remain unavailable.",
                 Project(new CliParameter("--name", "string", "Project display name."), new("--contracts", "string", "Built contract directory containing GalNet.Project.Contracts.dll and managed dependencies."),
                     new("--dry-run", "boolean", "Validate inputs and report files without creating directories or files.", Default: false)), readOnly: false, requiresProject: false, dryRun: true),
@@ -90,6 +97,15 @@ public ToolOperationCatalog()
                 readOnly: false, requiresContract: true),
             Route("project.export", "export", "Exports a project to a galpak package.", Project(new CliParameter("--output", "string", "Output directory (default: project/Output).")),
                 readOnly: false, requiresContract: true),
+            Route("project.export-directory", "project export-directory", "Builds and exports a project directly to the expanded installed-content layout without an intermediate .galpak.",
+                Project(new CliParameter("--output", "string", "New output directory for expanded game content.", true)),
+                readOnly: false, requiresContract: true),
+            Route("galpak.install", "galpak install", "Verifies a .galpak and expands it directly into a new output directory.",
+                [new CliParameter("package-file", "string", "Input .galpak archive.", true, true),
+                 new("--output", "string", "New output directory for installed content.", true)],
+                readOnly: false, requiresProject: false),
+            Route("game.inspect", "game inspect", "Reads the packed or legacy installed content identity and package descriptors.",
+                [new CliParameter("content-directory", "string", "Installed content root (for example app/pak).", true, true)], requiresProject: false),
             Route("execute", "execute", "Executes JSON typed document operations or one asset file operation.",
                 Project(new CliParameter("command-file", "string", "JSON file path, or '-' to read stdin.", true, true)),
                 readOnly: false, requiresContract: true, dryRun: true, batchMode: "Document operations only; one file operation per invocation. File dry-run is unsupported.")
@@ -141,8 +157,13 @@ private static ToolOperationDefinition DescribeOutput(ToolOperationDefinition op
         Type? dataType = operation.OperationId switch
         {
             "project.create" => typeof(ProjectCreateReport),
+            "project.visuals.install" => typeof(GalNet.Editor.Shared.Visuals.DefaultVisualInstallReport),
+            "project.apply" => typeof(ProjectApplyReport),
             "project.build" => typeof(ProjectBuildReport),
             "project.export" => typeof(ProjectExportReport),
+            "project.export-directory" => typeof(ProjectExportDirectoryReport),
+            "galpak.install" => typeof(GalpakInstallReport),
+            "game.inspect" => typeof(GalNet.Core.Serialization.GameContentManifest),
             "project.rename" or "group.create" or "group.rename" or "group.delete" => typeof(ProjectEditReport),
             "files" => typeof(QueryPage<ProjectFileItem>),
             "find" or "graph.nodes" or "graph.node" or "graph.edges" or "group.entries" or "variables" => typeof(QueryPage<ProjectObjectItem>),
@@ -181,6 +202,14 @@ private static ToolOperationDefinition FromCommand(IProjectCommandDefinition def
         file ? "file-operation" : "document-operation");
     }
 
+    private static JsonElement ManifestSchema()
+    {
+        var options = new JsonSerializerOptions(JsonSerializerDefaults.Web) { TypeInfoResolver = new DefaultJsonTypeInfoResolver(), UnmappedMemberHandling = System.Text.Json.Serialization.JsonUnmappedMemberHandling.Disallow };
+        var schema = options.GetJsonSchemaAsNode(typeof(ProjectApplyManifest));
+        schema["properties"]!["version"]!["const"] = 1;
+        return JsonSerializer.SerializeToElement(schema);
+    }
+
     public static ToolOperationDefinition Route(string id, string path, string description, IReadOnlyList<CliParameter> parameters,
         bool readOnly = true, bool requiresProject = true, bool requiresContract = false,
         bool dryRun = false, string batchMode = "None")
diff --git a/src/Editor/GalNet.Editor.Shared/GalNet.Editor.Shared.csproj b/src/Editor/GalNet.Editor.Shared/GalNet.Editor.Shared.csproj
index ad7e1bb3..363fbafd 100644
--- a/src/Editor/GalNet.Editor.Shared/GalNet.Editor.Shared.csproj
+++ b/src/Editor/GalNet.Editor.Shared/GalNet.Editor.Shared.csproj
@@ -19,4 +19,7 @@
         <ProjectReference Include="..\..\Shared\GalNet.Runtime\GalNet.Runtime.csproj" />
     </ItemGroup>
 
+    <ItemGroup>
+        <EmbeddedResource Include="Visuals/Shaders/*.sksl" LogicalName="GalNet.Visuals.%(Filename)%(Extension)" />
+    </ItemGroup>
 </Project>
diff --git a/src/Editor/GalNet.Editor.Shared/Services/AudioEffectTarget.cs b/src/Editor/GalNet.Editor.Shared/Services/AudioEffectTarget.cs
new file mode 100644
index 00000000..8916119a
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/AudioEffectTarget.cs
@@ -0,0 +1,25 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using GalNet.Contracts.Builtins.Audio;
+
+namespace GalNet.Editor.Shared.Services;
+
+public sealed record AudioEffectKey(SEffectScope Scope, string TargetId, string InstanceId);
+public sealed record AudioEffectTarget(AudioEffectKey Key, TargetPresence Presence,
+    IReadOnlyList<SceneLocator> Sources, IReadOnlyList<string> Types, bool MetadataComplete = true);
+
+/// <summary>Attachment qualification shared by identity copying, indexing and position analysis.</summary>
+public static class AudioAuthoringTarget
+{
+    public static string? Qualifier(JsonObject owner)
+    {
+        try
+        {
+            var scope = owner["scope"]?.GetValue<string>() ?? "track";
+            var target = owner["targetId"]?.GetValue<string>();
+            return scope is "track" or "bus" && !string.IsNullOrWhiteSpace(target)
+                ? JsonSerializer.Serialize(new[] { scope, target }) : null;
+        }
+        catch (InvalidOperationException) { return null; }
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/DebugApplicationProcess.cs b/src/Editor/GalNet.Editor.Shared/Services/DebugApplicationProcess.cs
new file mode 100644
index 00000000..b28c396a
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/DebugApplicationProcess.cs
@@ -0,0 +1,211 @@
+using System.Diagnostics;
+using System.Text;
+using GalNet.Debugging;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Launches and drains an external application's output independently of the debug transport lifetime.</summary>
+internal sealed class DebugApplicationProcess(DebugLaunchDiagnostics? diagnostics, Func<bool> isCurrent, Action<string, string> reportFailure)
+{
+    private static readonly TimeSpan LaunchConnectionTimeout = TimeSpan.FromSeconds(30);
+    private readonly DebugLaunchDiagnostics? _diagnostics = diagnostics;
+    private readonly Func<bool> _isCurrent = isCurrent;
+    private readonly Action<string, string> _reportFailure = reportFailure;
+    private string AddDiagnosticPath(string message) => _diagnostics?.FullPath is { } path && !message.Contains(path, StringComparison.OrdinalIgnoreCase)
+        ? $"{message}{Environment.NewLine}Diagnostics: {path}" : message;
+    public Task Launch(GameDebugLaunchSettings settings, string contentRoot, string profileRoot, DebugInvitation invitation, Task connected)
+    {
+        if (!File.Exists(settings.Executable))
+        {
+            var message = AddDiagnosticPath($"Debug application was not found: {settings.Executable}");
+            _diagnostics?.WriteLine(message);
+            throw new FileNotFoundException(message, settings.Executable);
+        }
+        _diagnostics?.WriteLine("Debug App launch requested.");
+        _diagnostics?.WriteLine($"Executable: {settings.Executable}");
+        _diagnostics?.WriteLine($"Working directory: {settings.WorkingDirectory ?? Path.GetDirectoryName(settings.Executable)}");
+        _diagnostics?.WriteLine($"Content root: {contentRoot}");
+        _diagnostics?.WriteLine($"Profile root: {profileRoot}");
+        _diagnostics?.WriteLine($"Project ID: {invitation.Identity.ProjectId}");
+        _diagnostics?.WriteLine($"Content fingerprint: {invitation.Identity.ContentFingerprint}");
+        _diagnostics?.WriteLine($"Contract fingerprint: {invitation.Identity.ContractFingerprint ?? "(none)"}");
+        _diagnostics?.WriteLine($"Additional configured argument count: {settings.Arguments.Length}; argument values are omitted.");
+        _diagnostics?.WriteLine($"Connection timeout: {LaunchConnectionTimeout.TotalSeconds:0} seconds.");
+        var start = new ProcessStartInfo(settings.Executable)
+        {
+            UseShellExecute = false,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            StandardOutputEncoding = Encoding.UTF8,
+            StandardErrorEncoding = Encoding.UTF8,
+            WorkingDirectory = settings.WorkingDirectory ?? Path.GetDirectoryName(settings.Executable)!
+        };
+        foreach (var argument in settings.Arguments) start.ArgumentList.Add(argument);
+        foreach (var argument in new[] { contentRoot, "--profile", profileRoot, "--debug-port", invitation.Port.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            "--debug-token", invitation.Token, "--debug-session", invitation.SessionId, "--debug-project", invitation.Identity.ProjectId })
+            start.ArgumentList.Add(argument);
+        if (invitation.Identity.ContractFingerprint is { } contract) { start.ArgumentList.Add("--debug-contract"); start.ArgumentList.Add(contract); }
+        Process process;
+        try { process = Process.Start(start) ?? throw new InvalidOperationException("Could not start the debug application."); }
+        catch (Exception error)
+        {
+            _diagnostics?.WriteLine($"Process start failed: {error}");
+            throw new InvalidOperationException(AddDiagnosticPath(error.Message), error);
+        }
+        Serilog.Log.Information("Started debug application {Executable}, process {ProcessId}", settings.Executable, process.Id);
+        _diagnostics?.WriteLine($"Process started. PID={process.Id}.");
+        _diagnostics?.WriteLine("Waiting for the App to complete the authenticated debug connection.");
+        return MonitorLaunchAsync(process, connected, invitation.Token, _diagnostics);
+    }
+    private async Task MonitorLaunchAsync(Process process, Task connected, string secretToken, DebugLaunchDiagnostics? diagnostics)
+    {
+        using (process)
+        {
+            try
+            {
+                var stdoutTail = new BoundedOutputTail(secretToken);
+                var stderrTail = new BoundedOutputTail(secretToken);
+                // Keep draining the redirected pipes until the child exits, even after the
+                // Editor disconnects. A child can outlive its debug session and must not block
+                // while writing to a full stdout/stderr pipe.
+                var stdout = CaptureOutputAsync(process.StandardOutput, "stdout", process.Id, secretToken, stdoutTail, diagnostics);
+                var stderr = CaptureOutputAsync(process.StandardError, "stderr", process.Id, secretToken, stderrTail, diagnostics);
+                var exit = process.WaitForExitAsync(CancellationToken.None);
+                var timeout = Task.Delay(LaunchConnectionTimeout, CancellationToken.None);
+                var first = await Task.WhenAny(connected, exit, timeout).ConfigureAwait(false);
+                if (first == timeout && _isCurrent() && !connected.IsCompleted && !process.HasExited)
+                {
+                    var details = FormatOutputTails(stdoutTail.Value, stderrTail.Value);
+                    var message = AddDiagnosticPath(
+                        $"The debug application did not connect within {LaunchConnectionTimeout.TotalSeconds:0} seconds. The process is still running and was not terminated." + details);
+                    diagnostics?.WriteLine(message);
+                    _reportFailure(message, "Application connection timed out");
+                }
+
+                await exit.ConfigureAwait(false);
+                await Task.WhenAll(stdout, stderr).ConfigureAwait(false);
+                if (!_isCurrent()) return;
+                diagnostics?.WriteLine($"Process exited with code {process.ExitCode}.");
+                if (process.ExitCode == 0 && connected.IsCompleted) return;
+                if (process.ExitCode != 0 || !connected.IsCompleted)
+                {
+                    var message = $"Debug application exited {(connected.IsCompleted ? "" : "before connecting ")}(exit code {process.ExitCode})." +
+                        (string.IsNullOrWhiteSpace(stdoutTail.Value) && string.IsNullOrWhiteSpace(stderrTail.Value)
+                            ? " Check the launch diagnostics and game log."
+                            : FormatOutputTails(stdoutTail.Value, stderrTail.Value));
+                    message = AddDiagnosticPath(message);
+                    diagnostics?.WriteLine(message);
+                    _reportFailure(message, "Application exited");
+                }
+            }
+            catch (OperationCanceledException) when (!_isCurrent()) { }
+            catch (Exception error) when (error is IOException or InvalidOperationException or ObjectDisposedException)
+            {
+                if (!_isCurrent()) return;
+                _reportFailure(AddDiagnosticPath(error.Message), "Could not monitor application");
+                diagnostics?.WriteLine($"Launch monitor failed: {error}");
+                Serilog.Log.Error(error, "Could not monitor debug application");
+            }
+        }
+    }
+    private static string FormatOutputTails(string stdout, string stderr)
+    {
+        var output = new StringBuilder();
+        if (!string.IsNullOrWhiteSpace(stdout)) output.AppendLine().Append("stdout:").AppendLine().Append(stdout.Trim());
+        if (!string.IsNullOrWhiteSpace(stderr)) output.AppendLine().Append("stderr:").AppendLine().Append(stderr.Trim());
+        return output.ToString();
+    }
+
+    private static async Task CaptureOutputAsync(StreamReader reader, string stream, int processId, string secretToken,
+        BoundedOutputTail tail, DebugLaunchDiagnostics? diagnostics)
+    {
+        var buffer = new char[1024];
+        var line = new StringBuilder();
+        try
+        {
+            int count;
+            while ((count = await reader.ReadAsync(buffer.AsMemory()).ConfigureAwait(false)) > 0)
+            {
+                var chunk = new string(buffer, 0, count);
+                tail.Add(chunk);
+                diagnostics?.WriteOutput(stream, chunk);
+                foreach (var character in chunk)
+                {
+                    if (character == '\n')
+                    {
+                        WriteAppOutput(stream, processId, line.ToString(), secretToken);
+                        line.Clear();
+                    }
+                    else if (character != '\r')
+                    {
+                        line.Append(character);
+                        if (line.Length > 4096) DrainSafeOutputPrefix(stream, processId, line, secretToken);
+                    }
+                }
+            }
+        }
+        finally
+        {
+            if (line.Length > 0) WriteAppOutput(stream, processId, line.ToString(), secretToken);
+            diagnostics?.CompleteOutput(stream);
+        }
+    }
+
+    private static void DrainSafeOutputPrefix(string stream, int processId, StringBuilder pending, string secretToken)
+    {
+        var buffered = pending.ToString();
+        var commitLength = Math.Max(0, buffered.Length - secretToken.Length + 1);
+        var searchFrom = 0;
+        while (commitLength > 0 && searchFrom < commitLength)
+        {
+            var tokenIndex = buffered.IndexOf(secretToken, searchFrom, StringComparison.OrdinalIgnoreCase);
+            if (tokenIndex < 0 || tokenIndex >= commitLength) break;
+            if (tokenIndex + secretToken.Length > commitLength)
+            {
+                commitLength = tokenIndex;
+                break;
+            }
+            searchFrom = tokenIndex + 1;
+        }
+        if (commitLength <= 0) return;
+        WriteAppOutput(stream, processId, buffered[..commitLength], secretToken);
+        pending.Remove(0, commitLength);
+    }
+
+    private static void WriteAppOutput(string stream, int processId, string text, string secretToken)
+    {
+        if (string.IsNullOrEmpty(text)) return;
+        var safeText = text.Replace(secretToken, "[REDACTED]", StringComparison.OrdinalIgnoreCase);
+        var logger = Serilog.Log.ForContext("LogChannel", "Game").ForContext("DebugAppProcessId", processId);
+        if (stream == "stderr") logger.Error("[Debug App stderr] {Output}", safeText);
+        else logger.Information("[Debug App stdout] {Output}", safeText);
+    }
+
+    private sealed class BoundedOutputTail(string secretToken)
+    {
+        private const int MaximumTailCharacters = 8192;
+        private readonly object _gate = new();
+        private readonly StringBuilder _value = new();
+        public string Value
+        {
+            get
+            {
+                lock (_gate)
+                {
+                    var redacted = _value.ToString().Replace(secretToken, "[REDACTED]", StringComparison.OrdinalIgnoreCase);
+                    return redacted.Length > MaximumTailCharacters ? redacted[^MaximumTailCharacters..] : redacted;
+                }
+            }
+        }
+        public void Add(string value)
+        {
+            lock (_gate)
+            {
+                _value.Append(value);
+                var retainedCharacters = MaximumTailCharacters + secretToken.Length;
+                if (_value.Length > retainedCharacters) _value.Remove(0, _value.Length - retainedCharacters);
+            }
+        }
+    }
+
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/DiskEntryParameterMetadata.cs b/src/Editor/GalNet.Editor.Shared/Services/DiskEntryParameterMetadata.cs
new file mode 100644
index 00000000..a2b1fd43
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/DiskEntryParameterMetadata.cs
@@ -0,0 +1,55 @@
+using System.Text;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>CLI/build metadata lookup. Missing or ambiguous resources remain unresolved.</summary>
+internal static class DiskEntryParameterMetadata
+{
+    private const int MaximumSourceBytes = 1024 * 1024;
+    public static EntryParameterMetadata Capture(string root, EditorProjectDocument document)
+    {
+        var programs = EntryParameterMetadata.ProgramIds(document).Take(256).ToDictionary(id => id, _ => (ShaderEffectDescriptor?)null, StringComparer.Ordinal);
+        if (programs.Count == 0) return new(Programs: programs);
+        var requested = programs.Keys.Where(id => Guid.TryParse(id, out _)).GroupBy(id => Guid.Parse(id)).ToDictionary(group => group.Key, group => group.ToArray());
+        var reader = new ProjectRawReader(root);
+        var diagnostics = new List<ToolDiagnostic>();
+        var paths = new Dictionary<Guid, string?>();
+        try
+        {
+            if (!Directory.Exists(reader.Resolve("Assets"))) return new(Programs: programs);
+            foreach (var path in reader.Files("Assets", diagnostics).Where(path => path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)))
+            {
+                // Do not run the renderer or deserialize arbitrary resource objects.
+                if (new FileInfo(reader.Resolve(path)).Length > MaximumSourceBytes) continue;
+                var meta = reader.Read(path, diagnostics);
+                if (meta is null || !Guid.TryParse(ProjectRawReader.MetadataIdentity(meta.Value).Id, out var id) || !requested.ContainsKey(id)) continue;
+                var shader = ProjectRawReader.Text(meta.Value, "type") == "effect-program" ? path[..^5] : null;
+                if (!paths.TryAdd(id, shader)) paths[id] = null;
+            }
+            if (diagnostics.Any(diagnostic => diagnostic.Severity == "error")) return new();
+            foreach (var (id, path) in paths)
+            {
+                if (path is null) continue;
+                try
+                {
+                    var absolute = reader.Resolve(path);
+                    if (new FileInfo(absolute).Length > MaximumSourceBytes) continue;
+                    var source = File.ReadAllText(absolute, new UTF8Encoding(false, true));
+                    foreach (var resource in requested[id])
+                    {
+                        var parsed = ShaderEffectMetadataParser.Parse(new(resource), source);
+                        if (parsed.Success) programs[resource] = parsed.Descriptor;
+                    }
+                }
+                catch (Exception error) when (error is IOException or UnauthorizedAccessException or ArgumentException or InvalidDataException)
+                { /* Unreadable resources retain the normal opaque coverage diagnostic. */ }
+            }
+        }
+        catch (Exception error) when (error is IOException or UnauthorizedAccessException or ArgumentException or InvalidDataException)
+        { return new(); }
+        return new(Programs: programs);
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/EditorDocumentRepository.cs b/src/Editor/GalNet.Editor.Shared/Services/EditorDocumentRepository.cs
index 775aa6d8..c61c8d76 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/EditorDocumentRepository.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/EditorDocumentRepository.cs
@@ -1,7 +1,6 @@
 using System.Text.Json;
 using GalNet.Core.Entry;
 using GalNet.Core.Serialization;
-using GalNet.Core.Settings;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
@@ -17,7 +16,13 @@ public sealed class EditorDocumentRepository(IEntryCatalog catalog, EditorDocume
     private static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true };
     private Dictionary<string, byte[]?>? _baseline;
 
-    public LoadedEditorProjectDocument Load(string projectPath, string projectName, ProjectSettings settings)
+    public IReadOnlyDictionary<string, byte[]?> SourceBaseline => _baseline is null ? new Dictionary<string, byte[]?>() :
+        _baseline.ToDictionary(pair => pair.Key, pair => pair.Value?.ToArray(), PathComparer);
+
+    public void AdoptExternalBaseline(IReadOnlyDictionary<string, byte[]?> sources) =>
+        _baseline = sources.ToDictionary(pair => pair.Key, pair => pair.Value?.ToArray(), PathComparer);
+
+    public LoadedEditorProjectDocument Load(string projectPath)
     {
         var reader = new ProjectRawReader(projectPath);
         var validator = new ProjectValidationService(projectPath);
@@ -51,7 +56,7 @@ public ProjectSavePlan PrepareSave(string projectPath, EditorGraphDocument docum
     {
         var reader = new ProjectRawReader(projectPath);
         EnsureUnchanged(reader);
-        if (_baseline is null && File.Exists(reader.Resolve("Graph/graph.json"))) _ = Load(projectPath, document.Name, new ProjectSettings());
+        if (_baseline is null && File.Exists(reader.Resolve("Graph/graph.json"))) _ = Load(projectPath);
         var diagnostics = new List<ToolDiagnostic>();
         var validator = new ProjectValidationService(projectPath);
         var graph = JsonSerializer.SerializeToElement(document, JsonOptions);
@@ -111,7 +116,7 @@ public GroupEntryDocument SerializeEntry(EditorEntryData entry)
         {
             var definition = catalog.Get(entry.Type);
             foreach (var key in entry.Parameters.Keys)
-                if (!definition.Parameters.ContainsKey(key)) throw new InvalidDataException($"Unknown parameter '{key}' for '{entry.Type}'.");
+                if (!definition.DynamicParameters.ContainsKey(key)) throw new InvalidDataException($"Unknown parameter '{key}' for '{entry.Type}'.");
         }
         return new GroupEntryDocument
         {
diff --git a/src/Editor/GalNet.Editor.Shared/Services/EditorDocumentService.cs b/src/Editor/GalNet.Editor.Shared/Services/EditorDocumentService.cs
index 2d4ef9fe..ebae247b 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/EditorDocumentService.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/EditorDocumentService.cs
@@ -7,6 +7,7 @@ namespace GalNet.Editor.Shared.Services;
 public sealed class EditorDocumentService : IEditorDocumentService
 {
     private readonly Dictionary<string, EditorGroupDocument> _groups = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, WeakReference<EditorGroupDocument>> _retiredGroups = new(StringComparer.Ordinal);
     private readonly Dictionary<string, EditorGroupDocument> _paths = new(OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
     public LoadedEditorProjectDocument LoadedProject { get; private set; } = new();
     public EditorGraphDocument CurrentDocument => LoadedProject.Document;
@@ -29,11 +30,46 @@ public void Unload()
     {
         LoadedProject = new();
         _groups.Clear();
+        _retiredGroups.Clear();
         _paths.Clear();
         IsLoaded = false;
         NotifyDocumentChanged();
     }
 
+    public void Reload(LoadedEditorProjectDocument loadedDocument)
+    {
+        if (!IsLoaded) throw new InvalidOperationException("No project document is loaded.");
+        var next = loadedDocument.Document;
+        var old = CurrentDocument;
+        // Keep DTO and Group identities where their author identity and kind still match.
+        next.Nodes = next.Nodes.Select(node =>
+        {
+            var existing = old.Nodes.SingleOrDefault(item => item.Id == node.Id && item.Type == node.Type && item.BranchType == node.BranchType);
+            if (existing is null) return node;
+            existing.Name = node.Name; existing.X = node.X; existing.Y = node.Y; existing.File = node.File;
+            existing.StoryPackage = node.StoryPackage;
+            existing.Options = node.Options; existing.Conditions = node.Conditions;
+            return existing;
+        }).ToList();
+        foreach (var (id, entries) in loadedDocument.GroupEntries)
+            if (LoadedProject.GroupEntries.TryGetValue(id, out var previous))
+                for (var index = 0; index < entries.Count; index++)
+                {
+                    var entry = entries[index];
+                    var existing = previous.SingleOrDefault(item => item.StableId == entry.StableId && item.Type == entry.Type);
+                    if (existing is null) continue;
+                    existing.Id = entry.Id; existing.Condition = entry.Condition; existing.Parameters = entry.Parameters;
+                    entries[index] = existing;
+                }
+        old.Version = next.Version; old.Name = next.Name; old.RootNodeId = next.RootNodeId;
+        old.Nodes = next.Nodes; old.Edges = next.Edges;
+        old.PlayerVariables = next.PlayerVariables; old.SaveVariables = next.SaveVariables;
+        LoadedProject.GroupEntries = loadedDocument.GroupEntries;
+        foreach (var id in _groups.Keys.Where(id => !loadedDocument.GroupEntries.ContainsKey(id)).ToArray())
+            _groups[id].Entries.Clear();
+        SynchronizeGroups();
+    }
+
     public EditorGroupDocument GetOrCreateGroup(string groupId, string relativePath)
     {
         if (_groups.TryGetValue(groupId, out var existing)) return existing;
@@ -41,7 +77,15 @@ public EditorGroupDocument GetOrCreateGroup(string groupId, string relativePath)
         if (_paths.ContainsKey(relativePath)) throw new InvalidDataException($"A Group document already owns '{relativePath}'.");
         if (!LoadedProject.GroupEntries.TryGetValue(groupId, out var entries))
             LoadedProject.GroupEntries.Add(groupId, entries = []);
-        var document = new EditorGroupDocument(groupId, relativePath, entries);
+        EditorGroupDocument document;
+        if (_retiredGroups.Remove(groupId, out var retired) && retired.TryGetTarget(out var previous))
+        {
+            document = previous;
+            if (!ReferenceEquals(document.Entries, entries))
+            { var values = entries.ToArray(); document.Entries.Clear(); document.Entries.AddRange(values); LoadedProject.GroupEntries[groupId] = document.Entries; }
+            document.ChangeSourcePath(relativePath);
+        }
+        else document = new EditorGroupDocument(groupId, relativePath, entries);
         _groups.Add(groupId, document);
         _paths.Add(relativePath, document);
         return document;
@@ -52,6 +96,10 @@ public EditorGroupDocument GetOrCreateGroup(string groupId, string relativePath)
     public void SynchronizeGroups()
     {
         _paths.Clear();
+        var live = CurrentDocument.Nodes.Where(node => node.Type == "Group").Select(node => node.Id).ToHashSet(StringComparer.Ordinal);
+        foreach (var id in _retiredGroups.Where(pair => !pair.Value.TryGetTarget(out _)).Select(pair => pair.Key).ToArray()) _retiredGroups.Remove(id);
+        foreach (var id in _groups.Keys.Where(id => !live.Contains(id)).ToArray())
+        { _retiredGroups[id] = new(_groups[id]); _groups.Remove(id); }
         foreach (var node in CurrentDocument.Nodes.Where(node => node.Type == "Group"))
         {
             var path = ("Graph/" + node.File).Replace('\\', '/');
diff --git a/src/Editor/GalNet.Editor.Shared/Services/EditorGameExitService.cs b/src/Editor/GalNet.Editor.Shared/Services/EditorGameExitService.cs
deleted file mode 100644
index b2c72400..00000000
--- a/src/Editor/GalNet.Editor.Shared/Services/EditorGameExitService.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace GalNet.Editor.Shared.Services;
-
-/// <summary>
-/// Editor implementation: Quit does nothing — the embedded game stays on its page.
-/// </summary>
-public class EditorGameExitService : GalNet.Editor.Abstraction.Services.IGameExitService
-{
-    public void Exit()
-    {
-        // No-op: Quit in editor preview does nothing
-    }
-}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/EditorPlayerVariableStore.cs b/src/Editor/GalNet.Editor.Shared/Services/EditorPlayerVariableStore.cs
deleted file mode 100644
index 1e44ed1f..00000000
--- a/src/Editor/GalNet.Editor.Shared/Services/EditorPlayerVariableStore.cs
+++ /dev/null
@@ -1,222 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.Json;
-using GalNet.Core.Gallery;
-using GalNet.Core.Variable;
-using GalNet.Editor.Abstraction.Project;
-using GalNet.Editor.Abstraction.Services;
-using Serilog;
-
-namespace GalNet.Editor.Shared.Services;
-
-public sealed class EditorPlayerVariableStore : IEditorPlayerVariableStore, IDisposable
-{
-    private static readonly JsonSerializerOptions IndentedJsonOptions = new() { WriteIndented = true };
-    private readonly IProjectService _projectService;
-    private readonly IVariableDefinitionService _variableDefinitions;
-    private readonly Dictionary<string, Variable> _variables = new(StringComparer.Ordinal);
-    private readonly Dictionary<string, SystemVariableDefinition> _systemVariables = new(StringComparer.Ordinal);
-
-    public event Action? Changed;
-
-    public IReadOnlyDictionary<string, Variable> Snapshot => _variables;
-
-    public EditorPlayerVariableStore(IProjectService projectService, IVariableDefinitionService variableDefinitions)
-    {
-        _projectService = projectService;
-        _variableDefinitions = variableDefinitions;
-        _projectService.CurrentChanged += OnProjectChanged;
-        _variableDefinitions.DefinitionsChanged += OnDefinitionsChanged;
-        Reload();
-    }
-
-    private void OnProjectChanged(GalProject? _) => Reload();
-
-    public void Dispose()
-    {
-        _projectService.CurrentChanged -= OnProjectChanged;
-        _variableDefinitions.DefinitionsChanged -= OnDefinitionsChanged;
-    }
-
-    public void ConfigureSystemVariables(IReadOnlyCollection<SystemVariableDefinition> definitions)
-    {
-        ArgumentNullException.ThrowIfNull(definitions);
-        var configured = definitions
-            .Where(definition => definition.Scope == VariableScope.Player)
-            .ToDictionary(definition => definition.Name, StringComparer.Ordinal);
-
-        _systemVariables.Clear();
-        foreach (var pair in configured)
-            _systemVariables.Add(pair.Key, pair.Value);
-
-        EnsureInitialized();
-        Changed?.Invoke();
-    }
-
-    public void Reload()
-    {
-        _variables.Clear();
-
-        if (_projectService.Current is not { } project)
-        {
-            Changed?.Invoke();
-            return;
-        }
-
-        var path = GetStoragePath(project);
-        if (File.Exists(path))
-        {
-            try
-            {
-                var json = File.ReadAllText(path);
-                var restored = JsonSerializer.Deserialize<Dictionary<string, Variable>>(json) ?? [];
-                foreach (var pair in restored.Where(pair => GalleryUnlockVariable.IsReservedName(pair.Key)))
-                    _variables[pair.Key] = CloneVariable(pair.Key, pair.Value);
-                foreach (var definition in GetDefinitions())
-                {
-                    if (restored.TryGetValue(definition.Name, out var variable)
-                        && variable.Type == definition.DefaultValue.Type)
-                        _variables[definition.Name] = CloneVariable(definition.Name, variable);
-                    else
-                        _variables[definition.Name] = CloneVariable(definition.Name, definition.DefaultValue);
-                }
-            }
-            catch (Exception ex)
-            {
-                Log.Warning(ex, "Failed to reload editor player variables from {Path}", path);
-            }
-        }
-
-        EnsureInitialized();
-        Changed?.Invoke();
-    }
-
-    public IReadOnlyDictionary<string, Variable> EnsureInitialized()
-    {
-        var definitions = GetDefinitions();
-
-        var staleNames = _variables.Keys
-            .Except(definitions.Select(v => v.Name), StringComparer.Ordinal)
-            .Where(name => !GalleryUnlockVariable.IsReservedName(name))
-            .ToList();
-        foreach (var staleName in staleNames)
-            _variables.Remove(staleName);
-
-        foreach (var definition in definitions)
-        {
-            if (_variables.TryGetValue(definition.Name, out var variable)
-                && variable.Type == definition.DefaultValue.Type)
-                continue;
-
-            _variables[definition.Name] = CloneVariable(definition.Name, definition.DefaultValue);
-        }
-
-        Save();
-        return Snapshot;
-    }
-
-    public void Reset()
-    {
-        _variables.Clear();
-        foreach (var definition in GetDefinitions())
-            _variables[definition.Name] = CloneVariable(definition.Name, definition.DefaultValue);
-
-        Save();
-        Changed?.Invoke();
-    }
-
-    public void SetValue(string name, object value)
-    {
-        if (!VariableNameRules.IsValid(name))
-            return;
-
-        if (!_variables.TryGetValue(name, out var variable))
-            variable = _variables[name] = new Variable { Name = name };
-
-        variable.SetValue(value);
-        Save();
-        Changed?.Invoke();
-    }
-
-    public void SetVariable(string name, Variable variable)
-    {
-        if (!VariableNameRules.IsValid(name))
-            return;
-
-        _variables[name] = CloneVariable(name, variable);
-        Save();
-        Changed?.Invoke();
-    }
-
-    public void Remove(string name)
-    {
-        if (_variables.Remove(name))
-        {
-            Save();
-            Changed?.Invoke();
-        }
-    }
-
-    private void Save()
-    {
-        if (_projectService.Current is not { } project)
-            return;
-
-        try
-        {
-            Directory.CreateDirectory(Path.GetDirectoryName(GetStoragePath(project))!);
-            var json = JsonSerializer.Serialize(_variables, IndentedJsonOptions);
-            File.WriteAllText(GetStoragePath(project), json);
-        }
-        catch (Exception ex)
-        {
-            Log.Warning(ex, "Failed to save editor player variables");
-        }
-    }
-
-    private static string GetStoragePath(GalProject project) =>
-        Path.Combine(project.EditorStateDirectory, "player", "player-variables.json");
-
-    private void OnDefinitionsChanged(VariableScope scope)
-    {
-        if (scope != VariableScope.Player)
-            return;
-
-        EnsureInitialized();
-        Changed?.Invoke();
-    }
-
-    private List<(string Name, Variable DefaultValue)> GetDefinitions()
-    {
-        var definitions = new Dictionary<string, Variable>(StringComparer.Ordinal);
-        foreach (var definition in _systemVariables.Values)
-            definitions[definition.Name] = definition.DefaultValue;
-        foreach (var definition in _variableDefinitions.GetDefinitions(VariableScope.Player))
-            definitions.TryAdd(definition.Name, definition.DefaultValue);
-        return definitions.Select(pair => (pair.Key, pair.Value)).ToList();
-    }
-
-    private static Variable CloneVariable(string name, Variable source)
-    {
-        var clone = new Variable { Name = name };
-        switch (source.Type)
-        {
-            case VariableType.Bool:
-                clone.SetValue(source.AsBool());
-                break;
-            case VariableType.Int:
-                clone.SetValue(source.AsInt());
-                break;
-            case VariableType.Float:
-                clone.SetValue(source.AsFloat());
-                break;
-            default:
-                clone.SetValue(source.AsString());
-                break;
-        }
-
-        return clone;
-    }
-}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/EditorSaveCoordinator.cs b/src/Editor/GalNet.Editor.Shared/Services/EditorSaveCoordinator.cs
deleted file mode 100644
index f5b28623..00000000
--- a/src/Editor/GalNet.Editor.Shared/Services/EditorSaveCoordinator.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Security.Cryptography;
-using System.Text;
-using System.Text.Json;
-using GalNet.Core.Compilation;
-using GalNet.Core.Entry;
-using GalNet.Core.Serialization;
-using GalNet.Editor.Abstraction.Documents;
-using GalNet.Editor.Abstraction.Services;
-
-namespace GalNet.Editor.Shared.Services;
-
-public sealed class EditorSaveCoordinator : IEditorSaveCoordinator
-{
-    private readonly IEditorDocumentRepository _repository;
-    private readonly IEntryCatalog _catalog;
-    private static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true };
-
-    public EditorSaveCoordinator(IEditorDocumentRepository repository, IEntryCatalog catalog)
-    {
-        _repository = repository;
-        _catalog = catalog;
-    }
-
-    public string BuildPreviewData(
-        string previewPath,
-        EditorGraphDocument document,
-        IReadOnlyDictionary<string, IReadOnlyList<EditorEntryData>> groupEntries)
-    {
-        for (var directory = new DirectoryInfo(Path.GetFullPath(previewPath)); directory is not null; directory = directory.Parent)
-            if (directory.Exists && (directory.Attributes & FileAttributes.ReparsePoint) != 0)
-                throw new InvalidDataException("Preview output must not traverse directory links.");
-        Directory.CreateDirectory(previewPath);
-
-        foreach (var file in Directory.EnumerateFiles(previewPath, "*.galgroup"))
-            File.Delete(file);
-
-        var previewDocument = new EditorGraphDocument
-        {
-            Version = document.Version,
-            Name = document.Name,
-            RootNodeId = document.RootNodeId,
-            Nodes = document.Nodes.Select(node => new EditorGraphNodeDto
-            {
-                Id = node.Id,
-                Type = node.Type,
-                Name = node.Name,
-                X = node.X,
-                Y = node.Y,
-                File = node.Type == "Group" ? PreviewFile(node.Id) : null,
-                BranchType = node.BranchType,
-                Options = node.Options?.Select(option => new EditorGraphBranchOptionDto
-                {
-                    Id = option.Id,
-                    Text = option.Text,
-                    Condition = option.Condition
-                }).ToList(),
-                Conditions = node.Conditions?.Select(condition => new EditorGraphBranchConditionDto
-                {
-                    Id = condition.Id,
-                    Expression = condition.Expression
-                }).ToList()
-            }).ToList(),
-            Edges = document.Edges.Select(edge => new EditorGraphEdgeDto
-            {
-                Id = edge.Id,
-                FromNodeId = edge.FromNodeId,
-                FromOutlet = edge.FromOutlet,
-                ToNodeId = edge.ToNodeId
-            }).ToList(),
-            PlayerVariables = document.PlayerVariables.Select(v => v.Clone()).ToList(),
-            SaveVariables = document.SaveVariables.Select(v => v.Clone()).ToList()
-        };
-
-        File.WriteAllText(Path.Combine(previewPath, "graph.json"), JsonSerializer.Serialize(previewDocument, JsonOptions));
-        foreach (var (groupId, entries) in groupEntries)
-        {
-            var raw = new GroupDocument { Kind = GroupDocumentKind.Raw, Entries = entries.Select(SerializeEntry).ToList() };
-            var compiled = GalgroupCompiler.Compile(raw, _catalog).Document;
-            File.WriteAllText(Path.Combine(previewPath, PreviewFile(groupId)), JsonSerializer.Serialize(compiled, JsonOptions));
-        }
-
-        return previewPath;
-    }
-
-    private static string PreviewFile(string id) => Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(id))) + ".galgroup";
-    private GroupEntryDocument SerializeEntry(EditorEntryData entry) => new EditorDocumentRepository(_catalog).SerializeEntry(entry);
-}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/EditorSettingsService.cs b/src/Editor/GalNet.Editor.Shared/Services/EditorSettingsService.cs
index 68b79945..ba6f8996 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/EditorSettingsService.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/EditorSettingsService.cs
@@ -1,8 +1,8 @@
 using System;
 using System.IO;
 using System.Text.Json;
-using GalNet.Core.Settings;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Abstraction.Settings;
 using Serilog;
 
 namespace GalNet.Editor.Shared.Services;
diff --git a/src/Editor/GalNet.Editor.Shared/Services/EditorVariableService.cs b/src/Editor/GalNet.Editor.Shared/Services/EditorVariableService.cs
deleted file mode 100644
index a4bc9c58..00000000
--- a/src/Editor/GalNet.Editor.Shared/Services/EditorVariableService.cs
+++ /dev/null
@@ -1,138 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using GalNet.Core.Variable;
-using GalNet.Editor.Abstraction.Services;
-using GalNet.Runtime.Variables;
-
-namespace GalNet.Editor.Shared.Services;
-
-/// <summary>
-/// Editor implementation of IVariableService.
-/// Wraps EditorPlayerVariableStore for player variables and manages save variables in-memory.
-/// </summary>
-public sealed class EditorVariableService : IVariableService, IDisposable
-{
-    private readonly IEditorPlayerVariableStore _playerStore;
-    private readonly IVariableDefinitionService _variableDefinitions;
-    private readonly Dictionary<string, Variable> _saveVariables = new(StringComparer.Ordinal);
-    private readonly Dictionary<string, SystemVariableDefinition> _systemVariables = new(StringComparer.Ordinal);
-
-    public event Action<VariableScope, string, Variable>? VariableChanged;
-
-    public EditorVariableService(
-        IEditorPlayerVariableStore playerStore,
-        IVariableDefinitionService variableDefinitions)
-    {
-        _playerStore = playerStore;
-        _variableDefinitions = variableDefinitions;
-        _variableDefinitions.DefinitionsChanged += OnDefinitionsChanged;
-    }
-
-    public void Dispose() => _variableDefinitions.DefinitionsChanged -= OnDefinitionsChanged;
-
-    public void ConfigureSystemVariables(IReadOnlyCollection<SystemVariableDefinition> definitions)
-    {
-        ArgumentNullException.ThrowIfNull(definitions);
-        var configured = definitions.ToDictionary(definition => definition.Name, StringComparer.Ordinal);
-        var userNames = _variableDefinitions.GetDefinitions(VariableScope.Player)
-            .Concat(_variableDefinitions.GetDefinitions(VariableScope.Save))
-            .Select(definition => definition.Name)
-            .ToHashSet(StringComparer.Ordinal);
-        var conflict = configured.Keys.FirstOrDefault(userNames.Contains);
-        if (conflict is not null)
-            throw new InvalidDataException(
-                $"User variable '{conflict}' conflicts with a generated system variable.");
-
-        _systemVariables.Clear();
-        foreach (var pair in configured)
-            _systemVariables.Add(pair.Key, pair.Value);
-
-        _playerStore.ConfigureSystemVariables(definitions);
-        foreach (var definition in definitions.Where(definition => definition.Scope == VariableScope.Save))
-        {
-            if (!_saveVariables.TryGetValue(definition.Name, out var current)
-                || current.Type != definition.DefaultValue.Type)
-                _saveVariables[definition.Name] = CloneVariable(definition.DefaultValue, definition.Name);
-        }
-    }
-
-    public IReadOnlyDictionary<string, Variable> GetSnapshot(VariableScope scope)
-    {
-        if (scope == VariableScope.Player)
-            return _playerStore.Snapshot;
-
-        if (_saveVariables.Count == 0)
-        {
-            foreach (var def in _variableDefinitions.GetDefinitions(VariableScope.Save))
-            {
-                if (!_saveVariables.ContainsKey(def.Name))
-                    _saveVariables[def.Name] = CloneVariable(def.DefaultValue, def.Name);
-            }
-        }
-
-        return _saveVariables;
-    }
-
-    public VariableScope ResolveScope(string name)
-    {
-        if (_systemVariables.TryGetValue(name, out var systemVariable))
-            return systemVariable.Scope;
-
-        return _variableDefinitions.GetDefinitions(VariableScope.Save)
-            .Any(v => string.Equals(v.Name, name, StringComparison.Ordinal))
-            ? VariableScope.Save
-            : VariableScope.Player;
-    }
-
-    /// <summary>Notify that a variable changed in the runtime. Syncs back to editor state.</summary>
-    public void NotifyVariableChanged(VariableScope scope, string name, Variable variable)
-    {
-        if (scope == VariableScope.Player)
-            _playerStore.SetVariable(name, variable);
-        else
-            _saveVariables[name] = CloneVariable(variable, name);
-
-        VariableChanged?.Invoke(scope, name, variable);
-    }
-
-    public void ResetAll()
-    {
-        _saveVariables.Clear();
-        foreach (var definition in _variableDefinitions.GetDefinitions(VariableScope.Save))
-            _saveVariables[definition.Name] = CloneVariable(definition.DefaultValue, definition.Name);
-        _playerStore.Reset();
-    }
-
-    private void OnDefinitionsChanged(VariableScope scope)
-    {
-        if (scope != VariableScope.Save)
-            return;
-
-        var definitions = _variableDefinitions.GetDefinitions(VariableScope.Save);
-        var staleNames = _saveVariables.Keys.Except(definitions.Select(v => v.Name), StringComparer.Ordinal).ToList();
-        foreach (var stale in staleNames)
-            _saveVariables.Remove(stale);
-
-        foreach (var definition in definitions)
-        {
-            if (_saveVariables.TryGetValue(definition.Name, out var variable) && variable.Type == definition.Type)
-                continue;
-
-            _saveVariables[definition.Name] = CloneVariable(definition.DefaultValue, definition.Name);
-        }
-    }
-
-    private static Variable CloneVariable(Variable source, string name)
-    {
-        var clone = new Variable { Name = name };
-        clone.SetValue(source.Type switch
-        {
-            VariableType.Bool => source.AsBool(),
-            VariableType.Int => source.AsInt(),
-            VariableType.Float => source.AsFloat(),
-            _ => source.AsString()
-        });
-        return clone;
-    }
-}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/EntryParameterStructures.cs b/src/Editor/GalNet.Editor.Shared/Services/EntryParameterStructures.cs
new file mode 100644
index 00000000..86a8b130
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/EntryParameterStructures.cs
@@ -0,0 +1,123 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Entry;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Metadata captured for the same author/resource generation as an analysis.</summary>
+public sealed record EntryParameterMetadata(IEffectCatalog? Effects = null, ISEffectCatalog? AudioEffects = null,
+    IReadOnlyDictionary<string, ShaderEffectDescriptor?>? Programs = null, long? Revision = null)
+{
+    public static IEnumerable<string> ProgramIds(EditorProjectDocument document) => document.GroupEntries.Values.SelectMany(entries => entries)
+        .SelectMany(ReferencedPrograms).Where(id => !string.IsNullOrWhiteSpace(id)).Distinct(StringComparer.Ordinal);
+    private static IEnumerable<string> ReferencedPrograms(EditorEntryData entry)
+    {
+        if (entry.Type is BuiltinEntryIds.ApplyEffect or BuiltinEntryIds.SpeedLinesPreset or BuiltinEntryIds.ImpactPreset)
+            yield return EntryParameterStructures.Text(entry, "program");
+        if (entry.Type != BuiltinEntryIds.PlayTimeline || entry.Parameters.GetValueOrDefault("timeline") is not { ValueKind: JsonValueKind.Object } timeline) yield break;
+        foreach (var events in timeline.EnumerateObject().Where(property => property.Name.Equals("events", StringComparison.OrdinalIgnoreCase) && property.Value.ValueKind == JsonValueKind.Array))
+            foreach (var item in events.Value.EnumerateArray().Take(10_000))
+                if (EntryParameterStructures.EventEntry(item) is { Type: BuiltinEntryIds.ApplyEffect } effect) yield return EntryParameterStructures.Text(effect, "program");
+    }
+}
+
+/// <summary>Captures parameter declarations and their resource revision as one analysis snapshot.</summary>
+public interface IEntryParameterMetadataSource
+{
+    long Revision { get; }
+    EntryParameterMetadata Capture(EditorProjectDocument document);
+}
+
+internal readonly record struct EntryStructureContext(string GroupId, EditorEntryData Entry);
+
+/// <summary>Resolves domain JSON fields before handing them to the shared property walker.</summary>
+internal sealed class EntryParameterStructures(EditorProjectDocument document, EntryParameterMetadata metadata, IEntryCatalog catalog) : IValueStructureProvider
+{
+    private readonly ISEffectCatalog _audio = metadata.AudioEffects ?? SEffectCatalog.Builtins;
+    private static readonly FieldDescriptor ShaderExtension = new("extension", new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Scalar()));
+    private SceneTargetAnalysis? _analysis;
+
+    public FieldDescriptor Describe(FieldDescriptor field, string group, EditorEntryData entry)
+    {
+        // Explicit contract structures, including custom providers, take precedence.
+        if (field.Value.ValueType != typeof(JsonElement) || field.Value.Structure is not null) return field;
+        if (field.Id == "timeline" && entry.Type == BuiltinEntryIds.PlayTimeline) return TimelineValueStructure.Describe(field);
+        ValueStructure? known = (entry.Type, field.Id) switch
+        {
+            (BuiltinEntryIds.ShowVariants, "selection") => ValueStructure.Map(new("value", new(typeof(string)))),
+            ("video.play", "skipPoints") => ValueStructure.Sequence(new("value", new(typeof(double)))),
+            (BuiltinEntryIds.PlayParticleEmitter or BuiltinEntryIds.BurstParticles, "parameters") => ValueStructure.OpenObject(
+                [new("particleTexture", new(typeof(string)), resourceTypeId: "sprite")], ShaderExtension),
+            _ => null
+        };
+        // These codecs have one resource field (particles) or exclusively numeric/name values.
+        if (known is not null) return new(field.Id, field.Value.WithStructure(known), field.IsRequired,
+            field.DefaultValue, field.Editor, field.LabelKey, field.DescriptionKey, field.Semantic, field.ResourceTypeId);
+        if (field.Id != "parameters") return field;
+        var structure = ParameterStructure(group, entry);
+        return structure is null ? field : new(field.Id, field.Value.WithStructure(structure), field.IsRequired,
+            field.DefaultValue, field.Editor, field.LabelKey, field.DescriptionKey, field.Semantic, field.ResourceTypeId);
+    }
+
+    private ValueStructure? ParameterStructure(string group, EditorEntryData entry)
+    {
+        if (entry.Type is BuiltinEntryIds.ApplyEffect or BuiltinEntryIds.SpeedLinesPreset or BuiltinEntryIds.ImpactPreset)
+        {
+            var program = Text(entry, "program");
+            if (!string.IsNullOrWhiteSpace(program))
+                return metadata.Programs?.GetValueOrDefault(program) is { } shader
+                    ? ValueStructure.OpenObject(shader.Parameters.Select(ShaderEffectFields.Create), ShaderExtension) : null;
+            return entry.Type == BuiltinEntryIds.ApplyEffect && metadata.Effects?.TryGet(Text(entry, "id"), out var effect) == true
+                ? ValueStructure.Object(effect.Parameters.Select(parameter => parameter.Field)) : null;
+        }
+        if (entry.Type is BuiltinEntryIds.ApplyAudioSEffect or BuiltinEntryIds.UpdateAudioSEffect)
+        {
+            var type = entry.Type == BuiltinEntryIds.ApplyAudioSEffect ? Text(entry, "id") : AudioType(group, entry);
+            return type is not null && _audio.TryGet(type, out var effect)
+                ? ValueStructure.Object(effect.Parameters.Select(parameter => parameter.Field)) : null;
+        }
+        return null;
+    }
+
+    public ValueStructure? Resolve(string id, FieldDescriptor field, JsonElement? value, PropertyPath path, object? context)
+    {
+        // Event paths are relative to the timeline root: events/index/parameters.
+        if (id != TimelineValueStructure.EventParameters || path.Count != 3 || path[1].Kind != PropertySegmentKind.Index
+            || context is not EntryStructureContext owner) return null;
+        if (owner.Entry.Parameters.GetValueOrDefault("timeline") is not { ValueKind: JsonValueKind.Object } timeline
+            || !timeline.TryGetProperty(path[0].Value, out var events) || events.ValueKind != JsonValueKind.Array
+            || !int.TryParse(path[1].Value, out var index) || index >= events.GetArrayLength()
+            || EventEntry(events[index]) is not { } entry || !TimelineEventCapabilities.Supports(entry.Type)
+            || !catalog.TryGet(entry.Type, out var definition)) return null;
+        return ValueStructure.Object(definition.DynamicParameters.Fields.Select(child => Describe(child, owner.GroupId, entry)));
+    }
+
+    internal static EditorEntryData? EventEntry(JsonElement value)
+    {
+        if (value.ValueKind != JsonValueKind.Object) return null;
+        var types = value.EnumerateObject().Where(property => property.Name.Equals("type", StringComparison.OrdinalIgnoreCase)).ToArray();
+        var parameters = value.EnumerateObject().Where(property => property.Name.Equals("parameters", StringComparison.OrdinalIgnoreCase)).ToArray();
+        if (types.Length != 1 || types[0].Value.ValueKind != JsonValueKind.String || parameters.Length != 1 || parameters[0].Value.ValueKind != JsonValueKind.Object) return null;
+        var values = new Dictionary<string, JsonElement>(StringComparer.Ordinal);
+        foreach (var item in parameters[0].Value.EnumerateObject()) if (!values.TryAdd(item.Name, item.Value)) return null;
+        return new() { Type = types[0].Value.GetString()!, Parameters = values };
+    }
+
+    private string? AudioType(string group, EditorEntryData entry)
+    {
+        var scope = Text(entry, "scope") switch { "" or "track" => SEffectScope.Track, "bus" => SEffectScope.Bus, _ => (SEffectScope?)null };
+        if (scope is null) return null;
+        _analysis ??= new(document.Graph, document.GroupEntries, audioCatalog: _audio);
+        var before = _analysis.Before(group, entry.StableId);
+        if (!before.Reachable || !before.AudioComplete) return null;
+        var key = new AudioEffectKey(scope.Value, Text(entry, "targetId"), Text(entry, "instanceId"));
+        var target = before.AudioEffects.FirstOrDefault(effect => effect.Key == key);
+        return target is { Types.Count: 1, MetadataComplete: true } ? target.Types[0] : null;
+    }
+
+    internal static string Text(EditorEntryData entry, string name) => entry.Parameters.GetValueOrDefault(name) is { ValueKind: JsonValueKind.String } text ? text.GetString() ?? "" : "";
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ExternalGameDebugClient.cs b/src/Editor/GalNet.Editor.Shared/Services/ExternalGameDebugClient.cs
index f236cbad..ef3898da 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ExternalGameDebugClient.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ExternalGameDebugClient.cs
@@ -1,5 +1,4 @@
 using System.Diagnostics;
-using System.Text;
 using System.Text.Json;
 using GalNet.Debugging;
 using GalNet.Runtime.Engine;
@@ -12,7 +11,6 @@ public sealed record GameDebugLaunchSettings(string Executable, string[] Argumen
 public sealed class ExternalGameDebugClient : IAsyncDisposable, IDisposable
 {
     private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
-    private static readonly TimeSpan LaunchConnectionTimeout = TimeSpan.FromSeconds(30);
     private static readonly TimeSpan DebugRequestTimeout = TimeSpan.FromSeconds(60);
     private static readonly TimeSpan StatusRequestTimeout = TimeSpan.FromSeconds(10);
     private CancellationTokenSource? _lifetime;
@@ -60,202 +58,12 @@ public void BeginDiagnostics(string profileRoot)
     public void Launch(GameDebugLaunchSettings settings, string contentRoot, string profileRoot)
     {
         var invitation = Invitation ?? throw new InvalidOperationException("Start listening before launching the App.");
+        var lifetime = _lifetime!;
+        var epoch = _epoch;
         _diagnostics ??= DebugLaunchDiagnostics.TryCreate(profileRoot);
-        if (!File.Exists(settings.Executable))
-        {
-            var message = AddDiagnosticPath($"Debug application was not found: {settings.Executable}");
-            _diagnostics?.WriteLine(message);
-            throw new FileNotFoundException(message, settings.Executable);
-        }
-        _diagnostics?.WriteLine("Debug App launch requested.");
-        _diagnostics?.WriteLine($"Executable: {settings.Executable}");
-        _diagnostics?.WriteLine($"Working directory: {settings.WorkingDirectory ?? Path.GetDirectoryName(settings.Executable)}");
-        _diagnostics?.WriteLine($"Content root: {contentRoot}");
-        _diagnostics?.WriteLine($"Profile root: {profileRoot}");
-        _diagnostics?.WriteLine($"Project ID: {invitation.Identity.ProjectId}");
-        _diagnostics?.WriteLine($"Content fingerprint: {invitation.Identity.ContentFingerprint}");
-        _diagnostics?.WriteLine($"Contract fingerprint: {invitation.Identity.ContractFingerprint ?? "(none)"}");
-        _diagnostics?.WriteLine($"Additional configured argument count: {settings.Arguments.Length}; argument values are omitted.");
-        _diagnostics?.WriteLine($"Connection timeout: {LaunchConnectionTimeout.TotalSeconds:0} seconds.");
-        var start = new ProcessStartInfo(settings.Executable)
-        {
-            UseShellExecute = false,
-            RedirectStandardOutput = true,
-            RedirectStandardError = true,
-            StandardOutputEncoding = Encoding.UTF8,
-            StandardErrorEncoding = Encoding.UTF8,
-            WorkingDirectory = settings.WorkingDirectory ?? Path.GetDirectoryName(settings.Executable)!
-        };
-        foreach (var argument in settings.Arguments) start.ArgumentList.Add(argument);
-        foreach (var argument in new[] { contentRoot, "--profile", profileRoot, "--debug-port", invitation.Port.ToString(System.Globalization.CultureInfo.InvariantCulture),
-            "--debug-token", invitation.Token, "--debug-session", invitation.SessionId, "--debug-project", invitation.Identity.ProjectId })
-            start.ArgumentList.Add(argument);
-        if (invitation.Identity.ContractFingerprint is { } contract) { start.ArgumentList.Add("--debug-contract"); start.ArgumentList.Add(contract); }
-        Process process;
-        try { process = Process.Start(start) ?? throw new InvalidOperationException("Could not start the debug application."); }
-        catch (Exception error)
-        {
-            _diagnostics?.WriteLine($"Process start failed: {error}");
-            throw new InvalidOperationException(AddDiagnosticPath(error.Message), error);
-        }
-        Serilog.Log.Information("Started debug application {Executable}, process {ProcessId}", settings.Executable, process.Id);
-        _diagnostics?.WriteLine($"Process started. PID={process.Id}.");
-        _diagnostics?.WriteLine("Waiting for the App to complete the authenticated debug connection.");
-        _launchMonitor = MonitorLaunchAsync(process, _epoch, _connected!.Task, invitation.Token, _diagnostics, _lifetime!.Token);
-    }
-    private async Task MonitorLaunchAsync(Process process, long epoch, Task connected, string secretToken, DebugLaunchDiagnostics? diagnostics, CancellationToken token)
-    {
-        using (process)
-        {
-            try
-            {
-                var stdoutTail = new BoundedOutputTail(secretToken);
-                var stderrTail = new BoundedOutputTail(secretToken);
-                // Keep draining the redirected pipes until the child exits, even after the
-                // Editor disconnects. A child can outlive its debug session and must not block
-                // while writing to a full stdout/stderr pipe.
-                var stdout = CaptureOutputAsync(process.StandardOutput, "stdout", process.Id, secretToken, stdoutTail, diagnostics);
-                var stderr = CaptureOutputAsync(process.StandardError, "stderr", process.Id, secretToken, stderrTail, diagnostics);
-                var exit = process.WaitForExitAsync(CancellationToken.None);
-                var timeout = Task.Delay(LaunchConnectionTimeout, CancellationToken.None);
-                var first = await Task.WhenAny(connected, exit, timeout).ConfigureAwait(false);
-                if (first == timeout && !token.IsCancellationRequested && epoch == _epoch && !connected.IsCompleted && !process.HasExited)
-                {
-                    var details = FormatOutputTails(stdoutTail.Value, stderrTail.Value);
-                    var message = AddDiagnosticPath(
-                        $"The debug application did not connect within {LaunchConnectionTimeout.TotalSeconds:0} seconds. The process is still running and was not terminated." + details);
-                    diagnostics?.WriteLine(message);
-                    ReportLaunchFailure(message, "Application connection timed out");
-                }
-
-                await exit.ConfigureAwait(false);
-                await Task.WhenAll(stdout, stderr).ConfigureAwait(false);
-                if (token.IsCancellationRequested || epoch != _epoch) return;
-                diagnostics?.WriteLine($"Process exited with code {process.ExitCode}.");
-                if (process.ExitCode == 0 && connected.IsCompleted) return;
-                if (process.ExitCode != 0 || !connected.IsCompleted)
-                {
-                    var message = $"Debug application exited {(connected.IsCompleted ? "" : "before connecting ")}(exit code {process.ExitCode})." +
-                        (string.IsNullOrWhiteSpace(stdoutTail.Value) && string.IsNullOrWhiteSpace(stderrTail.Value)
-                            ? " Check the launch diagnostics and game log."
-                            : FormatOutputTails(stdoutTail.Value, stderrTail.Value));
-                    message = AddDiagnosticPath(message);
-                    diagnostics?.WriteLine(message);
-                    ReportLaunchFailure(message, "Application exited");
-                }
-            }
-            catch (OperationCanceledException) when (token.IsCancellationRequested) { }
-            catch (Exception error) when (error is IOException or InvalidOperationException or ObjectDisposedException)
-            {
-                if (token.IsCancellationRequested || epoch != _epoch) return;
-                Error = AddDiagnosticPath(error.Message);
-                Status = "Could not monitor application";
-                diagnostics?.WriteLine($"Launch monitor failed: {error}");
-                Serilog.Log.Error(error, "Could not monitor debug application");
-                Changed?.Invoke();
-            }
-        }
-    }
-    private static string FormatOutputTails(string stdout, string stderr)
-    {
-        var output = new StringBuilder();
-        if (!string.IsNullOrWhiteSpace(stdout)) output.AppendLine().Append("stdout:").AppendLine().Append(stdout.Trim());
-        if (!string.IsNullOrWhiteSpace(stderr)) output.AppendLine().Append("stderr:").AppendLine().Append(stderr.Trim());
-        return output.ToString();
-    }
-
-    private static async Task CaptureOutputAsync(StreamReader reader, string stream, int processId, string secretToken,
-        BoundedOutputTail tail, DebugLaunchDiagnostics? diagnostics)
-    {
-        var buffer = new char[1024];
-        var line = new StringBuilder();
-        try
-        {
-            int count;
-            while ((count = await reader.ReadAsync(buffer.AsMemory()).ConfigureAwait(false)) > 0)
-            {
-                var chunk = new string(buffer, 0, count);
-                tail.Add(chunk);
-                diagnostics?.WriteOutput(stream, chunk);
-                foreach (var character in chunk)
-                {
-                    if (character == '\n')
-                    {
-                        WriteAppOutput(stream, processId, line.ToString(), secretToken);
-                        line.Clear();
-                    }
-                    else if (character != '\r')
-                    {
-                        line.Append(character);
-                        if (line.Length > 4096) DrainSafeOutputPrefix(stream, processId, line, secretToken);
-                    }
-                }
-            }
-        }
-        finally
-        {
-            if (line.Length > 0) WriteAppOutput(stream, processId, line.ToString(), secretToken);
-            diagnostics?.CompleteOutput(stream);
-        }
-    }
-
-    private static void DrainSafeOutputPrefix(string stream, int processId, StringBuilder pending, string secretToken)
-    {
-        var buffered = pending.ToString();
-        var commitLength = Math.Max(0, buffered.Length - secretToken.Length + 1);
-        var searchFrom = 0;
-        while (commitLength > 0 && searchFrom < commitLength)
-        {
-            var tokenIndex = buffered.IndexOf(secretToken, searchFrom, StringComparison.OrdinalIgnoreCase);
-            if (tokenIndex < 0 || tokenIndex >= commitLength) break;
-            if (tokenIndex + secretToken.Length > commitLength)
-            {
-                commitLength = tokenIndex;
-                break;
-            }
-            searchFrom = tokenIndex + 1;
-        }
-        if (commitLength <= 0) return;
-        WriteAppOutput(stream, processId, buffered[..commitLength], secretToken);
-        pending.Remove(0, commitLength);
-    }
-
-    private static void WriteAppOutput(string stream, int processId, string text, string secretToken)
-    {
-        if (string.IsNullOrEmpty(text)) return;
-        var safeText = text.Replace(secretToken, "[REDACTED]", StringComparison.OrdinalIgnoreCase);
-        var logger = Serilog.Log.ForContext("LogChannel", "Game").ForContext("DebugAppProcessId", processId);
-        if (stream == "stderr") logger.Error("[Debug App stderr] {Output}", safeText);
-        else logger.Information("[Debug App stdout] {Output}", safeText);
-    }
-
-    private sealed class BoundedOutputTail(string secretToken)
-    {
-        private const int MaximumTailCharacters = 8192;
-        private readonly object _gate = new();
-        private readonly StringBuilder _value = new();
-        public string Value
-        {
-            get
-            {
-                lock (_gate)
-                {
-                    var redacted = _value.ToString().Replace(secretToken, "[REDACTED]", StringComparison.OrdinalIgnoreCase);
-                    return redacted.Length > MaximumTailCharacters ? redacted[^MaximumTailCharacters..] : redacted;
-                }
-            }
-        }
-        public void Add(string value)
-        {
-            lock (_gate)
-            {
-                _value.Append(value);
-                var retainedCharacters = MaximumTailCharacters + secretToken.Length;
-                if (_value.Length > retainedCharacters) _value.Remove(0, _value.Length - retainedCharacters);
-            }
-        }
+        _launchMonitor = new DebugApplicationProcess(_diagnostics, () => !lifetime.IsCancellationRequested && epoch == _epoch,
+            ReportLaunchFailure).Launch(settings, contentRoot, profileRoot, invitation, _connected!.Task);
     }
-
     private void ReportLaunchFailure(string message, string status)
     {
         Error = message;
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ExternalProjectSnapshotReader.cs b/src/Editor/GalNet.Editor.Shared/Services/ExternalProjectSnapshotReader.cs
new file mode 100644
index 00000000..28441a63
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/ExternalProjectSnapshotReader.cs
@@ -0,0 +1,102 @@
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Commands;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Stable author snapshots shared by file notifications and explicit reload.</summary>
+public static class ExternalProjectSnapshotReader
+{
+    public static ExternalProjectSnapshot Read(string root, IEnumerable<EditorFileDocument> tracked, IEntryCatalog catalog)
+    {
+        if (HasPendingTransaction(root)) throw new IOException("Project publication is still in progress.");
+        var files = tracked.Select(file => new EditorFileDocument { Path = file.Path, ManagedContent = file.ManagedContent }).ToArray();
+        var before = ReadFiles(root, files);
+        var contracts = ContractsFingerprint(root);
+        var settings = DirectProjectPersistence.LoadSettings(root);
+        var repository = new EditorDocumentRepository(catalog, EditorDocumentValidation.Authoring);
+        var loaded = repository.Load(root);
+        if (loaded.Document.Nodes.Count(node => node.Type == "Entry") != 1 ||
+            !loaded.Document.Nodes.Any(node => node.Type == "Entry" && node.Id == loaded.Document.RootNodeId))
+            throw new InvalidDataException("The editor graph requires one explicit Entry root node.");
+        foreach (var (path, bytes) in before.Where(pair => IsLocalization(pair.Key))) LocalizationJson.Validate(path, bytes);
+        if (HasPendingTransaction(root) || !Same(before, ReadFiles(root, files)) || contracts != ContractsFingerprint(root))
+            throw new IOException("Project files changed while reading the external version. Retrying after publication.");
+        return new(loaded, settings, before, repository.SourceBaseline, contracts);
+    }
+
+    public static bool IsCurrent(string root, ExternalProjectSnapshot snapshot, IEnumerable<EditorFileDocument> tracked) =>
+        !HasPendingTransaction(root) && snapshot.ContractsFingerprint == ContractsFingerprint(root) && Same(snapshot.Files, ReadFiles(root, tracked));
+
+    public static Dictionary<string, byte[]> ReadFiles(string root, IEnumerable<EditorFileDocument> tracked)
+    {
+        var reader = new ProjectRawReader(root);
+        var paths = new HashSet<string>(ProjectFilePaths.Comparer) { "Graph/graph.json", "settings.json" };
+        var diagnostics = new List<ToolDiagnostic>();
+        foreach (var directory in new[] { "Graph", "I18n" })
+            if (Directory.Exists(reader.Resolve(directory)))
+                foreach (var path in reader.Files(directory, diagnostics))
+                    if (path.EndsWith(".rawgalgroup", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".json", StringComparison.OrdinalIgnoreCase)) paths.Add(path);
+        foreach (var file in tracked.Where(file => file.ManagedContent)) paths.Add(file.Path);
+        if (diagnostics.Any(item => item.Severity == "error")) throw new IOException(string.Join("\n", diagnostics.Select(item => item.Message)));
+        var result = new Dictionary<string, byte[]>(ProjectFilePaths.Comparer);
+        foreach (var path in paths.Order(StringComparer.Ordinal))
+        {
+            var full = reader.Resolve(path);
+            if (File.Exists(full)) result.Add(path, File.ReadAllBytes(full));
+        }
+        return result;
+    }
+
+    public static bool IsLocalization(string path)
+    {
+        if (path == LocalizationJson.MetadataPath) return true;
+        if (!path.StartsWith("I18n/", StringComparison.Ordinal) || !path.EndsWith(".json", StringComparison.OrdinalIgnoreCase)) return false;
+        try { return LocalizationJson.Path(path) == path; }
+        catch (Exception error) when (error is ArgumentException or InvalidOperationException or IOException) { return false; }
+    }
+
+    public static string ContractsFingerprint(string root)
+    {
+        var reader = new ProjectRawReader(root);
+        if (!Directory.Exists(reader.Resolve("Contracts"))) return "";
+        var diagnostics = new List<ToolDiagnostic>();
+        var files = reader.Files("Contracts", diagnostics).Where(path => path.EndsWith(".dll", StringComparison.OrdinalIgnoreCase));
+        if (diagnostics.Count != 0) throw new IOException("Cannot inspect project contract dependencies.");
+        using var hash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
+        foreach (var path in files)
+        {
+            hash.AppendData(Encoding.UTF8.GetBytes(path + "\0"));
+            using var stream = File.OpenRead(reader.Resolve(path));
+            hash.AppendData(SHA256.HashData(stream));
+        }
+        return Convert.ToHexString(hash.GetHashAndReset());
+    }
+
+    public static bool Same(IReadOnlyDictionary<string, byte[]> first, IReadOnlyDictionary<string, byte[]> second) =>
+        first.Count == second.Count && first.All(pair => second.TryGetValue(pair.Key, out var bytes) && pair.Value.AsSpan().SequenceEqual(bytes));
+
+    public static bool HasPendingTransaction(string root)
+    {
+        var directory = new ProjectRawReader(root).Resolve(".galnet/editor/transactions");
+        if (!Directory.Exists(directory)) return false;
+        foreach (var transaction in Directory.EnumerateDirectories(directory))
+        {
+            var manifest = Path.Combine(transaction, "manifest.json");
+            try
+            {
+                if (!File.Exists(manifest)) return true;
+                using var json = JsonDocument.Parse(File.ReadAllBytes(manifest));
+                if (json.RootElement.GetProperty("status").GetString() != "committed") return true;
+            }
+            catch (DirectoryNotFoundException) { }
+            catch (FileNotFoundException) { }
+            catch (Exception error) when (error is IOException or JsonException or KeyNotFoundException or UnauthorizedAccessException) { return true; }
+        }
+        return false;
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/GamePackageExporter.cs b/src/Editor/GalNet.Editor.Shared/Services/GamePackageExporter.cs
index d315b4b2..2c7d3f33 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/GamePackageExporter.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/GamePackageExporter.cs
@@ -1,133 +1,317 @@
+using System.Globalization;
 using System.IO.Compression;
 using System.Security.Cryptography;
+using System.Text;
 using System.Text.Json;
 using GalNet.Assets;
 using GalNet.Assets.Provider;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Core.Serialization;
 
 namespace GalNet.Editor.Shared.Services;
 
+/// <summary>Plans dependency-owned PAKs in a private stage and publishes verified game content.</summary>
 public static class GamePackageExporter
 {
-    private const string AssetsPakPath = "Assets/Paks/000-base.pak";
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web) { WriteIndented = true };
+    private static readonly JsonSerializerOptions CompactOptions = new(JsonSerializerDefaults.Web);
+    private sealed record Payload(string Path, string StagedPath, string Sha256, long Size)
+    {
+        public GalpakFileEntry Entry => new(Path, Sha256, Size);
+    }
+    private sealed record Prepared(Payload[] Base, Payload[] Stories, byte[] Layout, string BuildId);
 
-    public static async Task<GamePackageExportResult> ExportAsync(
-        string projectId,
-        string projectName,
-        string projectRoot,
-        string outputDirectory,
-        IResourceTypeCatalog resourceTypes,
-        IGalleryTypeCatalog galleryTypes,
-        IEntryCatalog entryCatalog,
-        CancellationToken cancellationToken = default)
+    public static async Task<GameContentExportResult> ExportDirectoryAsync(string projectId, string projectName, string projectRoot,
+        string outputDirectory, IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes, IEntryCatalog entryCatalog,
+        ProjectConfigurationSchema? configurations = null, CancellationToken cancellationToken = default)
     {
-        string? temporaryPath = null;
-        string? stagingRoot = null;
+        string? stage = null;
+        string? publish = null;
         try
         {
-            ArgumentNullException.ThrowIfNull(entryCatalog);
-            ProjectContentBuilder.ValidateOutputPath(Path.GetFullPath(projectRoot), Path.GetFullPath(outputDirectory));
-            Directory.CreateDirectory(outputDirectory);
-            var packagePath = Path.Combine(outputDirectory, $"{SafeFileName(projectName)}.galpak");
-            temporaryPath = packagePath + ".export-" + Guid.NewGuid().ToString("N") + ".tmp";
-            ArgumentNullException.ThrowIfNull(resourceTypes);
-            ArgumentNullException.ThrowIfNull(galleryTypes);
-            stagingRoot = Path.Combine(Path.GetTempPath(), $"galnet-export-{Guid.NewGuid():N}");
-            await new ProjectContentBuilder(entryCatalog, resourceTypes)
-                .BuildAsync(projectRoot, stagingRoot, cancellationToken)
-                .ConfigureAwait(false);
-            var assets = await LoadAssetsAsync(Path.Combine(stagingRoot, "Assets"), resourceTypes, cancellationToken);
-            var gallery = new GalleryCatalogCompiler(resourceTypes, galleryTypes).Compile(assets.Select(asset => asset.Metadata));
-            var assetsPak = PakBuilder.Build("assets", assets, GalNet.Core.Assets.CompressionMode.Brotli, resourceTypes);
-            var contentFiles = BuildContentFiles(stagingRoot, gallery, cancellationToken);
-            var packageFiles = new[] { (AssetsPakPath, assetsPak) }.Concat(contentFiles).ToArray();
-            var packages = packageFiles.Select(file => new GalpakFileEntry(file.Item1, Hash(file.Item2), file.Item2.Length)).ToArray();
-            await using (var file = File.Create(temporaryPath))
-            using (var zip = new ZipArchive(file, ZipArchiveMode.Create, leaveOpen: false))
+            var source = Path.GetFullPath(projectRoot);
+            var target = Path.GetFullPath(outputDirectory);
+            ProjectContentBuilder.ValidateOutputPath(source, target);
+            if (Directory.Exists(target) || File.Exists(target)) throw new InvalidOperationException($"Export directory '{target}' already exists.");
+            var parent = Path.GetDirectoryName(target)!;
+            Directory.CreateDirectory(parent);
+            stage = Path.Combine(parent, ".content-" + Guid.NewGuid().ToString("N"));
+            publish = Path.Combine(parent, ".export-" + Guid.NewGuid().ToString("N"));
+            var prepared = await PrepareAsync(projectId, projectName, source, stage, resourceTypes, galleryTypes, entryCatalog, configurations, cancellationToken);
+            Directory.CreateDirectory(publish);
+            foreach (var file in prepared.Base.Concat(prepared.Stories))
             {
-                foreach (var packageFile in packageFiles)
-                    await WriteEntryAsync(zip, packageFile.Item1, packageFile.Item2, cancellationToken);
-                var manifest = new GalpakManifest(1, projectId, projectName, DateTimeOffset.UtcNow, packages);
-                await WriteEntryAsync(zip, $"{SafeFileName(projectName)}.galnet", JsonSerializer.SerializeToUtf8Bytes(manifest, JsonOptions), cancellationToken);
+                cancellationToken.ThrowIfCancellationRequested();
+                var destination = Safe(publish, file.Path);
+                Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
+                File.Copy(Safe(stage, file.StagedPath), destination);
             }
-            await VerifyAsync(temporaryPath, packages, resourceTypes, cancellationToken);
+            foreach (var directory in PackedGameDocuments.ExtensionDirectories(prepared.BuildId))
+                Directory.CreateDirectory(Safe(publish, directory));
+            await VerifyDirectoryAsync(publish, prepared.Base.Concat(prepared.Stories), resourceTypes, cancellationToken);
             cancellationToken.ThrowIfCancellationRequested();
-            File.Move(temporaryPath, packagePath, true);
-            return GamePackageExportResult.Succeeded(packagePath);
+            Directory.Move(publish, target);
+            publish = null;
+            return GameContentExportResult.Succeeded(target);
         }
-        catch (OperationCanceledException)
-        {
-            DeleteTemporary(temporaryPath);
-            return GamePackageExportResult.Failed("Export canceled.");
-        }
-        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException or JsonException or InvalidOperationException)
-        {
-            DeleteTemporary(temporaryPath);
-            return GamePackageExportResult.Failed(ex.Message);
-        }
-        finally
+        catch (OperationCanceledException) { return GameContentExportResult.Failed("Export canceled."); }
+        catch (Exception error) when (ExportError(error)) { return GameContentExportResult.Failed(error.Message); }
+        finally { Cleanup(stage); Cleanup(publish); }
+    }
+
+    public static async Task<GamePackageExportResult> ExportAsync(string projectId, string projectName, string projectRoot,
+        string outputDirectory, IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes, IEntryCatalog entryCatalog,
+        ProjectConfigurationSchema? configurations = null, CancellationToken cancellationToken = default)
+    {
+        string? stage = null;
+        string? temporary = null;
+        string? storyStage = null;
+        try
         {
-            if (stagingRoot is not null && Directory.Exists(stagingRoot)) Directory.Delete(stagingRoot, recursive: true);
+            var source = Path.GetFullPath(projectRoot);
+            var output = Path.GetFullPath(outputDirectory);
+            ProjectContentBuilder.ValidateOutputPath(source, output);
+            Directory.CreateDirectory(output);
+            stage = Path.Combine(output, ".content-" + Guid.NewGuid().ToString("N"));
+            var target = Path.Combine(output, SafeName(projectName) + ".galpak");
+            temporary = target + ".export-" + Guid.NewGuid().ToString("N") + ".tmp";
+            var prepared = await PrepareAsync(projectId, projectName, source, stage, resourceTypes, galleryTypes, entryCatalog, configurations, cancellationToken);
+            await using (var file = File.Create(temporary))
+            using (var zip = new ZipArchive(file, ZipArchiveMode.Create))
+            {
+                foreach (var payload in prepared.Base)
+                {
+                    var entry = zip.CreateEntry("pak/" + payload.Path, CompressionLevel.NoCompression);
+                    await using var input = File.OpenRead(Safe(stage, payload.StagedPath));
+                    await using var destination = entry.Open();
+                    await input.CopyToAsync(destination, cancellationToken);
+                }
+                zip.CreateEntry("pak/");
+                foreach (var directory in PackedGameDocuments.ExtensionDirectories(prepared.BuildId))
+                    zip.CreateEntry("pak/" + directory + "/");
+            }
+            await VerifyZipAsync(temporary, prepared.Base, resourceTypes, cancellationToken);
+            if (prepared.Stories.Length > 0)
+            {
+                var stories = Path.Combine(output, "StoryPatches");
+                Directory.CreateDirectory(stories);
+                var destination = Path.Combine(stories, prepared.BuildId);
+                if (!Directory.Exists(destination))
+                {
+                    storyStage = Path.Combine(stories, ".export-" + Guid.NewGuid().ToString("N"));
+                    Directory.CreateDirectory(storyStage);
+                    foreach (var payload in prepared.Stories)
+                    {
+                        cancellationToken.ThrowIfCancellationRequested();
+                        File.Copy(Safe(stage, payload.StagedPath), Path.Combine(storyStage, Path.GetFileName(payload.Path)));
+                    }
+                    Directory.Move(storyStage, destination);
+                    storyStage = null;
+                }
+                foreach (var payload in prepared.Stories)
+                    await VerifyFileAsync(Safe(output, payload.Path), payload, resourceTypes, cancellationToken);
+            }
+            Directory.CreateDirectory(Path.Combine(output, "StoryPatches", prepared.BuildId));
+            await File.WriteAllBytesAsync(Path.Combine(output, SafeName(projectName) + ".layout.json"), prepared.Layout, cancellationToken);
+            cancellationToken.ThrowIfCancellationRequested();
+            File.Move(temporary, target, true);
+            temporary = null;
+            return GamePackageExportResult.Succeeded(target);
         }
+        catch (OperationCanceledException) { return GamePackageExportResult.Failed("Export canceled."); }
+        catch (Exception error) when (ExportError(error)) { return GamePackageExportResult.Failed(error.Message); }
+        finally { Cleanup(stage); Cleanup(storyStage); if (temporary is not null && File.Exists(temporary)) File.Delete(temporary); }
     }
 
-    private static async Task<IReadOnlyList<IGameFile>> LoadAssetsAsync(string assetsPath, IResourceTypeCatalog resourceTypes, CancellationToken ct)
+    private static async Task<Prepared> PrepareAsync(string projectId, string projectName, string source, string stage,
+        IResourceTypeCatalog types, IGalleryTypeCatalog galleryTypes, IEntryCatalog catalog, ProjectConfigurationSchema? configurations, CancellationToken ct)
     {
-        using var provider = new LocalFileProvider(assetsPath, resourceTypes, optional: true);
-        using var archive = await provider.OpenArchiveAsync("assets", ct);
-        return archive.AssetIds.OrderBy(id => id, StringComparer.Ordinal).Select(id => archive.GetAsset(id)!).ToArray();
+        ArgumentException.ThrowIfNullOrWhiteSpace(projectId);
+        ArgumentNullException.ThrowIfNull(types);
+        ArgumentNullException.ThrowIfNull(galleryTypes);
+        ArgumentNullException.ThrowIfNull(catalog);
+        var (_, prepared) = await new ProjectContentBuilder(catalog, types, configurations).BuildPreparedAsync(source, stage, async (privateStage, token) =>
+        {
+            using var provider = new LocalFileProvider(Path.Combine(privateStage, "Assets"), types, optional: true);
+            using var archive = await provider.OpenArchiveAsync("assets", token);
+            var assets = archive.AssetIds.Select(id => archive.GetAsset(id)!).ToArray();
+            var gallery = new GalleryCatalogCompiler(types, galleryTypes).Compile(assets.Select(file => file.Metadata));
+            var story = StoryResourceCompiler.Compile(privateStage, catalog, token, assets);
+            var available = assets.Concat(story).ToArray();
+            var configuration = GalNet.Editor.Shared.Commands.DirectProjectPersistence.LoadSettings(privateStage);
+            var options = configuration.Read(ContentPackagingOptions.Section);
+            var roots = options.IncludeResources.Concat(gallery.Items.Select(item => item.ResourceId))
+                .Concat(configuration.Read(ResourceOverrideOptions.Section).AdditionalOriginals)
+                .Concat(configuration.ReadDefaultOptions().DefaultVisualPrograms.Values.Where(id => !string.IsNullOrWhiteSpace(id))).ToArray();
+            var complete = options.DeclaredCompleteResources.Select(id => available.Any(file => StringComparer.OrdinalIgnoreCase.Equals(file.Id, id)) ? id : StoryResourceIds.Group(id)).ToArray();
+            var plan = ContentPackagePlanner.Plan(available, roots, types, options.MaxPakBytes, complete, token);
+            var content = ContentFiles(privateStage, gallery).ToArray();
+            using var buildHash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
+            buildHash.AppendData(Encoding.UTF8.GetBytes(projectId + "\n"));
+            // The same logical resources can be split differently after a default/algorithm change.
+            // Keep immutable story directories distinct for those physical part sets as well.
+            buildHash.AppendData("galnet-content-v3/gpak-v3/documents-v1/brotli\n"u8);
+            buildHash.AppendData(JsonSerializer.SerializeToUtf8Bytes(plan.Paks.Select(part => new
+            {
+                part.PackageId,
+                part.PartIndex,
+                part.PartCount,
+                resources = part.Files.Select(file => file.Id)
+            }), JsonOptions));
+            var codec = new AssetMetaCodec(types);
+            foreach (var file in plan.Paks.SelectMany(part => part.Files).DistinctBy(file => file.Id, StringComparer.OrdinalIgnoreCase).OrderBy(file => file.Id, StringComparer.Ordinal))
+            {
+                token.ThrowIfCancellationRequested();
+                using var input = file.OpenRead();
+                buildHash.AppendData(Encoding.UTF8.GetBytes(file.Id + "\n" + CryptoHelper.HashSHA256(input) + "\n" + codec.Serialize(file.Metadata) + "\n"));
+            }
+            foreach (var file in content) buildHash.AppendData(Encoding.UTF8.GetBytes(file.Path + "\n" + CryptoHelper.HashSHA256(file.Data) + "\n"));
+            var buildId = Convert.ToHexStringLower(buildHash.GetHashAndReset());
+            var baseline = new List<Payload>();
+            var stories = new List<Payload>();
+            var storyEntries = new Dictionary<string, List<GalpakFileEntry>>(StringComparer.Ordinal);
+            var layout = new List<object>();
+            foreach (var part in plan.Paks)
+            {
+                token.ThrowIfCancellationRequested();
+                var path = part.PackageId.Length == 0 ? $"Assets/Paks/{part.PartIndex:D3}-base.pak"
+                    : $"StoryPatches/{buildId}/story-{CryptoHelper.HashSHA256(Encoding.UTF8.GetBytes(part.PackageId))[..16]}-{part.PartIndex:D3}.pak";
+                var bytes = PakBuilder.Build("assets", part.Files, types, descriptor: new()
+                {
+                    Kind = part.PackageId.Length == 0 ? "base" : "story",
+                    ProjectId = projectId,
+                    BuildId = buildId,
+                    PackageId = part.PackageId,
+                    PartIndex = part.PartIndex,
+                    PartCount = part.PartCount
+                });
+                var payload = Write(privateStage, path, bytes);
+                (part.PackageId.Length == 0 ? baseline : stories).Add(payload);
+                if (part.PackageId.Length > 0)
+                {
+                    if (!storyEntries.TryGetValue(part.PackageId, out var entries)) storyEntries.Add(part.PackageId, entries = []);
+                    entries.Add(payload.Entry);
+                }
+                foreach (var file in part.Files) layout.Add(new
+                {
+                    id = file.Id,
+                    file.Path,
+                    file.TypeId,
+                    package = part.PackageId,
+                    pak = path,
+                    dependencies = file.Metadata is IAssetDependencies dependencies ? dependencies.GetDependencies().Direct : [],
+                    root = roots.Contains(file.Id, StringComparer.OrdinalIgnoreCase) || file.Id == StoryResourceIds.Graph
+                });
+            }
+            var languageDocuments = new SortedDictionary<string, Dictionary<string, string>>(StringComparer.Ordinal);
+            foreach (var file in content.Where(file => file.Path.StartsWith("I18n/", StringComparison.Ordinal)
+                && !file.Path.StartsWith("I18n/catalog/", StringComparison.OrdinalIgnoreCase)))
+            {
+                var parts = file.Path.Split('/');
+                if (parts.Length < 3) throw new InvalidDataException("Built-in translations must be below a culture directory.");
+                var culture = CultureInfo.GetCultureInfo(parts[1]).Name;
+                if (culture.Length == 0) throw new InvalidDataException("Built-in translations require a named culture.");
+                if (!languageDocuments.TryGetValue(culture, out var text)) languageDocuments.Add(culture, text = new(StringComparer.Ordinal));
+                foreach (var pair in LocalizationJson.Texts(file.Data)) text[pair.Key] = pair.Value;
+            }
+            var languagePayload = Write(privateStage, PackedGameDocuments.LocalizationFileName,
+                PackedGameDocuments.Build(projectId, buildId, languageDocuments.Select(pair => new KeyValuePair<string, byte[]>(
+                    "texts/" + pair.Key + ".json", JsonSerializer.SerializeToUtf8Bytes(pair.Value.OrderBy(text => text.Key, StringComparer.Ordinal)
+                        .ToDictionary(text => text.Key, text => text.Value, StringComparer.Ordinal))))));
+            var descriptor = new GameContentManifest
+            {
+                Version = 3,
+                ProjectId = projectId,
+                BuildId = buildId,
+                BasePaks = baseline.Select(file => file.Entry).ToList(),
+                Stories = storyEntries.Select(pair => new StoryPackageManifest(pair.Key, pair.Value)).ToList(),
+                LocalizationPak = languagePayload.Entry
+            };
+            baseline.Add(languagePayload);
+            var manifest = new GalpakManifest(3, projectId, projectName, DateTimeOffset.UnixEpoch, baseline.Select(file => file.Entry).ToArray());
+            var report = JsonSerializer.SerializeToUtf8Bytes(new { buildId, resources = layout, unused = plan.Unused.Select(file => new { file.Id, file.Path, file.TypeId }) }, JsonOptions);
+            var documents = new Dictionary<string, byte[]>(StringComparer.Ordinal)
+            {
+                [GameContentManifest.FileName] = JsonSerializer.SerializeToUtf8Bytes(descriptor, CompactOptions),
+                [PackedGameDocuments.InstallationPath] = JsonSerializer.SerializeToUtf8Bytes(manifest, CompactOptions),
+                ["packaging-layout.json"] = report,
+                ["settings.json"] = content.FirstOrDefault(file => file.Path == "settings.json").Data ?? "{}"u8.ToArray(),
+                ["gallery.json"] = content.Single(file => file.Path == "gallery.json").Data,
+                ["characters.json"] = content.FirstOrDefault(file => file.Path == "I18n/catalog/characters.json").Data ?? "[]"u8.ToArray()
+            };
+            baseline.Add(Write(privateStage, PackedGameDocuments.GameFileName, PackedGameDocuments.Build(projectId, buildId,
+                documents.Select(pair => new KeyValuePair<string, byte[]>(pair.Key, CompactJson(pair.Value))))));
+            return new Prepared(baseline.ToArray(), stories.ToArray(), report, buildId);
+        }, ct);
+        return prepared;
     }
 
-    private static (string Path, byte[] Data)[] BuildContentFiles(string projectRoot, GalleryCatalog gallery, CancellationToken ct)
+    private static byte[] CompactJson(byte[] bytes)
     {
-        return Directory.EnumerateFiles(projectRoot, "*", SearchOption.AllDirectories)
-            .Select(path => Path.GetRelativePath(projectRoot, path).Replace('\\', '/'))
-            .Where(path => path is "settings.json" || path.StartsWith("Graph/", StringComparison.OrdinalIgnoreCase) || path.StartsWith("I18n/", StringComparison.OrdinalIgnoreCase))
-            .Where(path => !path.StartsWith("I18n/External/", StringComparison.OrdinalIgnoreCase))
-            .Where(path => !path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase) && !path.EndsWith(".tmp", StringComparison.OrdinalIgnoreCase))
-            .OrderBy(path => path, StringComparer.Ordinal)
-            .Select(path =>
-            {
-                ct.ThrowIfCancellationRequested();
-                return (path, File.ReadAllBytes(Path.Combine(projectRoot, path.Replace('/', Path.DirectorySeparatorChar))));
-            })
-            .Append(("gallery.json", JsonSerializer.SerializeToUtf8Bytes(new GalleryConfiguration { Types = gallery.Types.ToList(), Items = gallery.Items.ToList() }, JsonOptions)))
-            .ToArray();
+        using var document = JsonDocument.Parse(DecodeJson(bytes));
+        return JsonSerializer.SerializeToUtf8Bytes(document.RootElement);
     }
 
-    private static async Task WriteEntryAsync(ZipArchive zip, string path, byte[] data, CancellationToken ct)
+    private static string DecodeJson(byte[] bytes) => LocalizationJson.Decode(bytes);
+
+    private static Payload Write(string stage, string path, byte[] data)
     {
-        var entry = zip.CreateEntry(path, CompressionLevel.Optimal);
-        await using var stream = entry.Open();
-        await stream.WriteAsync(data, ct);
+        var staged = ".package/" + path;
+        var destination = Safe(stage, staged);
+        Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
+        File.WriteAllBytes(destination, data);
+        return new(path, staged, CryptoHelper.HashSHA256(data), data.LongLength);
     }
+    private static IEnumerable<(string Path, byte[] Data)> ContentFiles(string stage, GalleryCatalog gallery) =>
+        Directory.EnumerateFiles(stage, "*", SearchOption.AllDirectories).Select(path => Path.GetRelativePath(stage, path).Replace('\\', '/'))
+            .Where(path => path == "settings.json" || path.StartsWith("I18n/", StringComparison.OrdinalIgnoreCase)
+                && path.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
+            .Where(path => !path.StartsWith("I18n/External/", StringComparison.OrdinalIgnoreCase) && !path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase))
+            .Order(StringComparer.Ordinal).Select(path => (path, File.ReadAllBytes(Safe(stage, path))))
+            .Append(("gallery.json", JsonSerializer.SerializeToUtf8Bytes(new GalleryConfiguration { Types = gallery.Types.ToList(), Items = gallery.Items.ToList() }, JsonOptions)));
 
-    private static async Task VerifyAsync(string path, IReadOnlyList<GalpakFileEntry> packages, IResourceTypeCatalog resourceTypes, CancellationToken ct)
+    private static async Task VerifyDirectoryAsync(string root, IEnumerable<Payload> files, IResourceTypeCatalog types, CancellationToken ct)
+    { foreach (var file in files) await VerifyFileAsync(Safe(root, file.Path), file, types, ct); }
+    private static async Task VerifyFileAsync(string path, Payload file, IResourceTypeCatalog types, CancellationToken ct)
+    {
+        await using var input = File.OpenRead(path);
+        if (input.Length != file.Size || Convert.ToHexStringLower(await SHA256.HashDataAsync(input, ct)) != file.Sha256)
+            throw new InvalidDataException($"Checksum mismatch for '{file.Path}'.");
+        if (file.Path.EndsWith(".pak", StringComparison.OrdinalIgnoreCase))
+            VerifyPak(file.Path, await File.ReadAllBytesAsync(path, ct), types);
+    }
+    private static async Task VerifyZipAsync(string path, IEnumerable<Payload> files, IResourceTypeCatalog types, CancellationToken ct)
     {
-        await using var file = File.OpenRead(path);
-        using var zip = new ZipArchive(file, ZipArchiveMode.Read);
-        foreach (var package in packages)
+        using var zip = ZipFile.OpenRead(path);
+        foreach (var file in files)
         {
-            var entry = zip.GetEntry(package.Path) ?? throw new InvalidDataException($"Export package is missing '{package.Path}'.");
+            var entry = zip.GetEntry("pak/" + file.Path) ?? throw new InvalidDataException($"Missing ZIP entry 'pak/{file.Path}'.");
             await using var stream = entry.Open();
-            using var memory = new MemoryStream();
-            await stream.CopyToAsync(memory, ct);
-            var data = memory.ToArray();
-            if (!string.Equals(Hash(data), package.Sha256, StringComparison.Ordinal)) throw new InvalidDataException($"Checksum mismatch for '{package.Path}'.");
-            if (package.Path.EndsWith(".pak", StringComparison.OrdinalIgnoreCase))
+            if (entry.Length != file.Size || Convert.ToHexStringLower(await SHA256.HashDataAsync(stream, ct)) != file.Sha256)
+                throw new InvalidDataException($"Checksum mismatch for '{file.Path}'.");
+            if (file.Path.EndsWith(".pak", StringComparison.OrdinalIgnoreCase))
             {
-                using var archive = Archive.Deserialize(Path.GetFileNameWithoutExtension(package.Path), data, resourceTypes);
+                await using var source = entry.Open();
+                using var buffer = new MemoryStream();
+                await source.CopyToAsync(buffer, ct);
+                VerifyPak(file.Path, buffer.ToArray(), types);
             }
         }
     }
-
-    private static void DeleteTemporary(string? path) { if (path is not null && File.Exists(path)) File.Delete(path); }
-    private static string Hash(byte[] data) => Convert.ToHexString(SHA256.HashData(data)).ToLowerInvariant();
-    private static string SafeFileName(string name) => string.Concat(name.Select(ch => Path.GetInvalidFileNameChars().Contains(ch) ? '_' : ch));
-    private static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true };
+    private static void VerifyPak(string path, byte[] bytes, IResourceTypeCatalog types)
+    {
+        if (path == PackedGameDocuments.GameFileName) _ = PackedGameDocuments.ReadGame(bytes);
+        else if (path == PackedGameDocuments.LocalizationFileName) _ = PackedGameDocuments.Read(bytes);
+        else { using var archive = Archive.Deserialize("assets", bytes, types); }
+    }
+    private static bool ExportError(Exception error) => error is IOException or UnauthorizedAccessException or InvalidDataException or JsonException or InvalidOperationException or ArgumentException or KeyNotFoundException;
+    private static string Safe(string root, string relative) => FileSystemPaths.ResolveRelativeFile(root, relative);
+    private static string SafeName(string name) => string.Concat(name.Select(character => Path.GetInvalidFileNameChars().Contains(character) ? '_' : character));
+    private static void Cleanup(string? directory) { if (directory is not null && Directory.Exists(directory)) Directory.Delete(directory, true); }
 }
 
 public sealed record GamePackageExportResult(bool Success, string? PackagePath, string? Error)
@@ -135,3 +319,8 @@ public sealed record GamePackageExportResult(bool Success, string? PackagePath,
     public static GamePackageExportResult Succeeded(string path) => new(true, path, null);
     public static GamePackageExportResult Failed(string error) => new(false, null, error);
 }
+public sealed record GameContentExportResult(bool Success, string? ContentDirectory, string? Error)
+{
+    public static GameContentExportResult Succeeded(string path) => new(true, path, null);
+    public static GameContentExportResult Failed(string error) => new(false, null, error);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/GroupCompileService.cs b/src/Editor/GalNet.Editor.Shared/Services/GroupCompileService.cs
index e3e35f98..76333818 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/GroupCompileService.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/GroupCompileService.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GalNet.Assets;
 using GalNet.Core.Compilation;
 using GalNet.Editor.Abstraction.Commands;
 
@@ -28,11 +29,10 @@ public async Task<ToolResult> CompileAsync(GroupCompileRequest request, Cancella
             { diagnostics.Add(new("contract.load", "error", exception.Message, "Contracts/" + ProjectSchemaContext.AssemblyFileName)); return Result(null, diagnostics); }
             using (schema)
             {
-                var document = new ProjectValidationService(_reader.Root).ValidateGroup(source, diagnostics, schema.Catalog);
+                var document = new ProjectValidationService(_reader.Root).ValidateGroup(source, diagnostics, out var compiled, schema.Catalog);
                 if (document is null) return Result(null, diagnostics);
                 cancellationToken.ThrowIfCancellationRequested();
-                var compiled = GalgroupCompiler.Compile(document, schema.Catalog);
-                report = new(source, output, request.DryRun, document.Entries.Count, compiled.Document.Entries.Count, compiled.SourceMap, schema.Fingerprint);
+                report = new(source, output, request.DryRun, document.Entries.Count, compiled!.Document.Entries.Count, compiled.SourceMap, schema.Fingerprint);
                 if (request.DryRun) return Result(report, diagnostics);
                 ValidateOutputPath(output);
                 Directory.CreateDirectory(Path.GetDirectoryName(output)!);
@@ -91,16 +91,10 @@ private void ValidateOutputPath(string output)
         if (IsChild(output, _reader.Root) && !IsChild(output, Path.Combine(_reader.Root, "Output")))
             throw new InvalidDataException("Compiled output inside the project must remain under Output/; author files and Contracts are protected.");
         if (Directory.Exists(output)) throw new InvalidDataException("Compiled output is an existing directory.");
-        var current = Path.GetPathRoot(output)!;
-        foreach (var component in output[current.Length..].Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries))
-        {
-            current = Path.Combine(current, component);
-            if ((File.Exists(current) || Directory.Exists(current)) && (File.GetAttributes(current) & FileAttributes.ReparsePoint) != 0)
-                throw new InvalidDataException("Compiled output must not traverse filesystem links.");
-        }
+        FileSystemPaths.RequireNoLinks(output, "Compiled output must not traverse filesystem links.");
     }
     private static StringComparison PathComparison => OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
-    private static bool IsChild(string path, string parent) => path.Equals(parent, PathComparison) || path.StartsWith(Path.TrimEndingDirectorySeparator(parent) + Path.DirectorySeparatorChar, PathComparison);
+    private static bool IsChild(string path, string parent) => FileSystemPaths.IsSameOrChild(path, parent);
     private static ToolResult Result(GroupCompileReport? report, IReadOnlyList<ToolDiagnostic> diagnostics) =>
         new("group.compile", !diagnostics.Any(item => item.Severity == "error"), report, diagnostics);
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ImageVariantsAuthoring.cs b/src/Editor/GalNet.Editor.Shared/Services/ImageVariantsAuthoring.cs
index 85a0525e..8707bfea 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ImageVariantsAuthoring.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ImageVariantsAuthoring.cs
@@ -1,7 +1,7 @@
 using System.Text;
 using GalNet.Assets.Variants;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
-using GalNet.Core.Variants;
 
 namespace GalNet.Editor.Shared.Services;
 
diff --git a/src/Editor/GalNet.Editor.Shared/Services/LocalizationDocumentStore.cs b/src/Editor/GalNet.Editor.Shared/Services/LocalizationDocumentStore.cs
index ef2d5a64..14ee6b62 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/LocalizationDocumentStore.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/LocalizationDocumentStore.cs
@@ -1,3 +1,4 @@
+using GalNet.Contracts.Builtins;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
 
@@ -44,7 +45,7 @@ public LocalizationTextTarget CaptureText(string key, string? culture = null, st
     {
         RequireActive();
         ArgumentException.ThrowIfNullOrWhiteSpace(key);
-        culture = System.Globalization.CultureInfo.GetCultureInfo(culture ?? content.CaptureWorking().Settings.TargetLocale.Code).Name;
+        culture = System.Globalization.CultureInfo.GetCultureInfo(culture ?? content.CaptureWorking().Configuration.ReadDefaultOptions().TargetLocale.Code).Name;
         var source = query.Get()?.FindDirect(culture, key);
         var path = source?.File ?? newFile ?? $"I18n/{culture}/authoring.json";
         path = LocalizationJson.Path(path);
diff --git a/src/Editor/GalNet.Editor.Shared/Services/LocalizationReferenceIndex.cs b/src/Editor/GalNet.Editor.Shared/Services/LocalizationReferenceIndex.cs
index abb2a3c8..21734466 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/LocalizationReferenceIndex.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/LocalizationReferenceIndex.cs
@@ -1,6 +1,6 @@
 using System.Globalization;
-using System.Reflection;
 using System.Text.Json;
+using GalNet.Contracts.Builtins;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
 using GalNet.Editor.Abstraction.Documents;
@@ -8,9 +8,32 @@
 namespace GalNet.Editor.Shared.Services;
 
 public sealed record LocalizationSource(string Path, string Json);
-public sealed record LocalizationReference(string Owner, string? EntryId, string JsonPointer, string Key, FieldValueSemantic Semantic);
+public sealed record LocalizationReference(string Owner, string? EntryId, string JsonPointer, string Key, FieldValueSemantic Semantic)
+{
+    public PropertyPath? Path { get; init; }
+    public string LocationKey => Path?.ToLogicalPointer() ?? JsonPointer;
+    public JsonElement Rewrite(JsonElement parameters, string key)
+    {
+        var path = Path;
+        if (path is null)
+        {
+            path = PropertyPath.Empty; var current = parameters;
+            foreach (var segment in JsonPointer.Split('/').Skip(1).Select(PropertyPath.Unescape))
+            {
+                if (current.ValueKind == JsonValueKind.Array)
+                { var index = int.Parse(segment, CultureInfo.InvariantCulture); path = path.Index(index); current = current[index]; }
+                else { path = path.Member(segment); current = current.GetProperty(segment); }
+            }
+        }
+        return path.Replace(parameters, JsonSerializer.SerializeToElement(key));
+    }
+}
 public sealed record LocalizationText(string Culture, string Key, string Text, string File, string JsonPointer);
-public sealed record LocalizationIssue(string Code, string File, string JsonPointer, string Message);
+public sealed record LocalizationIssue(string Code, string File, string JsonPointer, string Message)
+{
+    public string? EntryId { get; init; }
+    public PropertyPath? Path { get; init; }
+}
 public sealed record LocalizationCharacter(string Id, string DisplayNameKey);
 
 /// <summary>Read-only, bounded analysis of one author snapshot. Never executes entries or changes keys.</summary>
@@ -21,13 +44,20 @@ public sealed class LocalizationReferenceIndex
     private readonly List<LocalizationReference> _references = [];
     private readonly List<LocalizationText> _texts = [];
     private readonly List<LocalizationIssue> _issues = [];
+    private readonly List<LocalizationIssue> _incompleteIssues = [];
     private readonly List<LocalizationCharacter> _characters = [];
     private readonly Dictionary<string, Dictionary<string, LocalizationText>> _effective = new(StringComparer.OrdinalIgnoreCase);
     private int _remaining = MaximumValues;
 
     public LocalizationReferenceIndex(EditorProjectDocument document, IEntryCatalog catalog, IEnumerable<LocalizationSource> sources,
         IEnumerable<LocalizationIssue>? sourceIssues = null)
+        : this(document, catalog, sources, sourceIssues, new()) { }
+
+    public LocalizationReferenceIndex(EditorProjectDocument document, IEntryCatalog catalog, IEnumerable<LocalizationSource> sources,
+        IEnumerable<LocalizationIssue>? sourceIssues, EntryParameterMetadata metadata)
     {
+        using var structures = new ValueStructureResolver();
+        var parameters = new EntryParameterStructures(document, metadata, catalog);
         foreach (var issue in sourceIssues ?? []) Issue(issue.Code, issue.File, issue.JsonPointer, issue.Message);
         foreach (var source in sources.OrderBy(source => source.Path, StringComparer.Ordinal)) ReadSource(source);
         foreach (var node in document.Graph.Nodes.Where(node => node.Type == "Group"))
@@ -37,16 +67,20 @@ public LocalizationReferenceIndex(EditorProjectDocument document, IEntryCatalog
             var identities = new HashSet<string>(StringComparer.Ordinal);
             foreach (var entry in entries)
             {
-                if (!Spend(groupId, "", 0)) break;
+                if (!Spend(groupId, "", 0, entry.StableId)) break;
                 if (string.IsNullOrWhiteSpace(entry.StableId) || !identities.Add(entry.StableId))
-                    Issue("entry.identity", groupId, "", "Entry identity is missing or duplicated.");
-                if (!catalog.TryGet(entry.Type, out var definition) || definition.DynamicParameters is null)
-                { Issue("schema.unavailable", groupId, "", $"No field schema for '{entry.Type}'."); continue; }
-                foreach (var name in entry.Parameters.Keys.Where(name => !definition.DynamicParameters.ContainsKey(name)))
-                    Issue("field.unknown", groupId, "/" + Escape(name), "Unknown author field cannot be analyzed.");
+                    Issue("entry.identity", groupId, "", "Entry identity is missing or duplicated.", entryId: entry.StableId);
+                if (!catalog.TryGet(entry.Type, out var definition))
+                {
+                    if (entry.Parameters.Values.Any(value => !IsEmpty(value)))
+                        Issue("schema.unavailable", groupId, "", $"No field schema for '{entry.Type}'.", entryId: entry.StableId);
+                    continue;
+                }
+                foreach (var name in entry.Parameters.Keys.Where(name => !definition.DynamicParameters.ContainsKey(name) && !IsEmpty(entry.Parameters[name])))
+                    Issue("field.unknown", groupId, "/" + Escape(name), "Unknown author field cannot be analyzed.", entryId: entry.StableId);
                 foreach (var field in definition.DynamicParameters.Fields)
                     if (entry.Parameters.TryGetValue(field.Id, out var value))
-                        Walk(field, value, groupId, entry.StableId, "/" + Escape(field.Id), 0);
+                        Walk(parameters.Describe(field, groupId, entry), value, groupId, entry.StableId, "/" + Escape(field.Id), structures, parameters, new EntryStructureContext(groupId, entry));
             }
         }
         foreach (var node in document.Graph.Nodes.Where(node => node.Type == "Branch" && node.BranchType == "Choice"))
@@ -56,91 +90,57 @@ public LocalizationReferenceIndex(EditorProjectDocument document, IEntryCatalog
                 Reference(node.Id, option.Id, "/text", option.Text, FieldValueSemantic.LocalizedText);
             }
         var ids = _characters.Select(character => character.Id).ToHashSet(StringComparer.Ordinal);
-        var defaultKeys = _texts.Where(text => text.Culture.Equals(document.Settings.TargetLocale.Code, StringComparison.OrdinalIgnoreCase))
+        var defaultCulture = document.Configuration.ReadDefaultOptions().TargetLocale.Code;
+        var defaultKeys = _texts.Where(text => text.Culture.Equals(defaultCulture, StringComparison.OrdinalIgnoreCase))
             .Select(text => text.Key).ToHashSet(StringComparer.Ordinal);
         foreach (var reference in _references)
             if (reference.Semantic == FieldValueSemantic.CharacterReference ? !ids.Contains(reference.Key) : !defaultKeys.Contains(reference.Key))
                 Issue(reference.Semantic == FieldValueSemantic.CharacterReference ? "character.unknown" : "text.defaultMissing",
-                    reference.Owner, reference.JsonPointer, $"Unresolved reference '{reference.Key}'.", incomplete: false);
-        References = _references.AsReadOnly(); Texts = _texts.AsReadOnly(); Issues = _issues.AsReadOnly(); Characters = _characters.AsReadOnly();
+                    reference.Owner, reference.JsonPointer, $"Unresolved reference '{reference.Key}'.", incomplete: false, entryId: reference.EntryId, path: reference.Path);
+        References = _references.AsReadOnly(); Texts = _texts.AsReadOnly(); Issues = _issues.AsReadOnly();
+        IncompleteIssues = _incompleteIssues.AsReadOnly(); Characters = _characters.AsReadOnly();
     }
 
     public IReadOnlyList<LocalizationReference> References { get; }
     /// <summary>All definitions in load order, including shadowed definitions.</summary>
     public IReadOnlyList<LocalizationText> Texts { get; }
     public IReadOnlyList<LocalizationIssue> Issues { get; }
+    /// <summary>Issues that make it unsafe to treat an absent reference as proof of non-use.</summary>
+    public IReadOnlyList<LocalizationIssue> IncompleteIssues { get; }
     public IReadOnlyList<LocalizationCharacter> Characters { get; }
     /// <summary>False means absence of a reference cannot establish that a character is unused.</summary>
     public bool Complete { get; private set; } = true;
     public LocalizationText? FindDirect(string culture, string key) => _effective.GetValueOrDefault(culture)?.GetValueOrDefault(key);
 
-    private void Walk(FieldDescriptor field, JsonElement value, string owner, string entryId, string pointer, int depth, JsonSerializerOptions? wireOptions = null)
+    private void Walk(FieldDescriptor field, JsonElement value, string owner, string entryId, string pointer, ValueStructureResolver structures,
+        IValueStructureProvider provider, object context)
     {
-        if (!Spend(owner, pointer, depth) || value.ValueKind == JsonValueKind.Null) return;
-        if (field.Semantic != FieldValueSemantic.None)
+        if (IsEmpty(value)) return;
+        using var document = new ValueDocument(field, value, structures, provider, context);
+        foreach (var property in document.GetIterator(new(MaximumDepth, Math.Max(1, _remaining))))
         {
-            if (value.ValueKind != JsonValueKind.String) Issue("field.stringRequired", owner, pointer, "Localized fields must contain string keys.");
-            else Reference(owner, entryId, pointer, value.GetString()!, field.Semantic);
-            return;
-        }
-        WalkValue(field.Value.ValueType, value, owner, entryId, pointer, depth, wireOptions ?? field.Value.JsonOptions);
-    }
-
-    private void WalkValue(Type type, JsonElement value, string owner, string entryId, string pointer, int depth, JsonSerializerOptions options)
-    {
-        if (value.ValueKind == JsonValueKind.Null) return;
-        var elementType = type.IsArray && type.GetArrayRank() == 1 ? type.GetElementType()
-            : type.IsGenericType && type.GetGenericTypeDefinition() is var generic &&
-              (generic == typeof(List<>) || generic == typeof(IList<>) || generic == typeof(IReadOnlyList<>) || generic == typeof(IEnumerable<>))
-                ? type.GetGenericArguments()[0] : null;
-        if (elementType is not null)
-        {
-            if (value.ValueKind != JsonValueKind.Array) { Issue("field.arrayRequired", owner, pointer, "Expected a list."); return; }
-            var index = 0;
-            foreach (var item in value.EnumerateArray())
+            var logical = PropertyPath.Empty.Member(field.Id);
+            foreach (var segment in property.Path) logical = logical.Append(segment);
+            var location = pointer + property.Path.ToJsonPointer();
+            if (!Spend(owner, location, property.Path.Count, entryId)) break;
+            if (property.Value is not { } provided || IsEmpty(provided)) continue;
+            // Root scalar validation is already owned by the field contract; this index adds nested coverage.
+            if (property.Path.Count == 0 && property.Issue?.Code.StartsWith("value.", StringComparison.Ordinal) == true) continue;
+            if (property.Issue is { } issue)
+                Issue(issue.Code, owner, location, issue.Message, entryId: entryId, path: logical);
+            else if (property.Field.Semantic != FieldValueSemantic.None)
             {
-                var child = pointer + "/" + index++;
-                if (!Spend(owner, child, depth + 1)) break;
-                WalkValue(elementType, item, owner, entryId, child, depth + 1, options);
+                if (provided.ValueKind != JsonValueKind.String)
+                    Issue("field.stringRequired", owner, location, "Localized fields must contain string keys.", entryId: entryId, path: logical);
+                else Reference(owner, entryId, location, provided.GetString()!, property.Field.Semantic, logical);
             }
         }
-        else if (typeof(IFieldDto).IsAssignableFrom(type))
-        {
-            if (value.ValueKind != JsonValueKind.Object) { Issue("field.objectRequired", owner, pointer, "Expected an object."); return; }
-            IReadOnlyList<FieldDescriptor>? fields;
-            try { fields = type.GetProperty("Schema", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)?.GetValue(null) as IReadOnlyList<FieldDescriptor>; }
-            catch (Exception error) when (error is TargetInvocationException or TypeInitializationException)
-            { Issue("schema.invalid", owner, pointer, error.Message); return; }
-            if (fields is null) { Issue("schema.unavailable", owner, pointer, "Nested DTO has no readable schema."); return; }
-            var names = new HashSet<string>(StringComparer.Ordinal);
-            foreach (var property in value.EnumerateObject())
-                if (!names.Add(property.Name)) Issue("field.duplicate", owner, pointer, "Duplicate author property.");
-            var properties = options.GetTypeInfo(type).Properties;
-            var mapped = fields.Select(field =>
-            {
-                var member = type.GetMembers(BindingFlags.Public | BindingFlags.Instance).FirstOrDefault(property => property is PropertyInfo or FieldInfo && property.GetCustomAttribute<FieldAttribute>() is not null &&
-                    (property.GetCustomAttribute<System.Text.Json.Serialization.JsonPropertyNameAttribute>()?.Name ?? JsonNamingPolicy.CamelCase.ConvertName(property.Name)) == field.Id);
-                var wire = properties.FirstOrDefault(property => property.AttributeProvider is MemberInfo info && info.Name == member?.Name)?.Name ?? field.Id;
-                return (Field: field, Wire: wire);
-            }).ToArray();
-            foreach (var member in mapped)
-                if (value.TryGetProperty(member.Wire, out var child)) Walk(member.Field, child, owner, entryId, pointer + "/" + Escape(member.Wire), depth + 1, options);
-            foreach (var name in names.Where(name => !mapped.Any(member => member.Wire == name)))
-                Issue("field.unknown", owner, pointer + "/" + Escape(name), "Unknown nested author field cannot be analyzed.");
-        }
-        else if (value.ValueKind is JsonValueKind.Object or JsonValueKind.Array)
-            Issue("field.opaque", owner, pointer, "Structured value has no traversable field schema.");
     }
 
-    private void Reference(string owner, string? entryId, string pointer, string key, FieldValueSemantic semantic)
+    private void Reference(string owner, string? entryId, string pointer, string key, FieldValueSemantic semantic, PropertyPath? path = null)
     {
-        if (key == string.Empty) return;
-        if (string.IsNullOrWhiteSpace(key))
-        {
-            if (semantic == FieldValueSemantic.LocalizedText) Issue("text.emptyKey", owner, pointer, "Text key is empty.", incomplete: false);
-            return;
-        }
-        _references.Add(new(owner, entryId, pointer, key, semantic));
+        if (string.IsNullOrWhiteSpace(key)) return;
+        _references.Add(new(owner, entryId, pointer, key, semantic) { Path = path });
     }
 
     private void ReadSource(LocalizationSource source)
@@ -208,17 +208,29 @@ private void Flatten(JsonElement element, string prefix, string pointer, string
         }
     }
 
-    private bool Spend(string file, string pointer, int depth)
+    private bool Spend(string file, string pointer, int depth, string? entryId = null)
     {
         if (_remaining <= 0) return false;
-        if (--_remaining == 0 || depth > MaximumDepth)
-        { Issue("analysis.limit", file, pointer, "Localization analysis exceeded its value/depth budget."); return false; }
+        if (--_remaining <= 0 || depth > MaximumDepth)
+        { Issue("analysis.limit", file, pointer, "Localization analysis exceeded its value/depth budget.", entryId: entryId); return false; }
         return true;
     }
-    private void Issue(string code, string file, string pointer, string message, bool incomplete = true)
+    private void Issue(string code, string file, string pointer, string message, bool incomplete = true, string? entryId = null, PropertyPath? path = null)
     {
-        if (incomplete) Complete = false;
-        _issues.Add(new(code, file, pointer, message));
+        var issue = new LocalizationIssue(code, file, pointer, message) { EntryId = entryId, Path = path };
+        _issues.Add(issue);
+        if (!incomplete) return;
+        Complete = false;
+        _incompleteIssues.Add(issue);
     }
+    private static bool IsEmpty(JsonElement value) => value.ValueKind switch
+    {
+        JsonValueKind.Undefined or JsonValueKind.Null => true,
+        JsonValueKind.String => string.IsNullOrWhiteSpace(value.GetString()),
+        JsonValueKind.Object => !value.EnumerateObject().Any(),
+        JsonValueKind.Array => value.GetArrayLength() == 0,
+        _ => false
+    };
+
     private static string Escape(string name) => name.Replace("~", "~0", StringComparison.Ordinal).Replace("/", "~1", StringComparison.Ordinal);
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Services/LocalizationValidation.cs b/src/Editor/GalNet.Editor.Shared/Services/LocalizationValidation.cs
index ac13772e..85fa1361 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/LocalizationValidation.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/LocalizationValidation.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GalNet.Contracts.Builtins;
 using GalNet.Core.Entry;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Abstraction.Documents;
@@ -14,30 +15,33 @@ public static IReadOnlyList<ToolDiagnostic> ValidateDisk(string root, IEntryCata
         try
         {
             var reader = new ProjectRawReader(root);
-            var settings = File.Exists(reader.Resolve("settings.json")) ? DirectProjectPersistence.LoadSettings(root) : new GalNet.Core.Settings.ProjectSettings();
-            var loaded = new EditorDocumentRepository(catalog, EditorDocumentValidation.Authoring).Load(root, "", settings);
-            var snapshot = new EditorProjectDocument { Graph = loaded.Document, GroupEntries = loaded.GroupEntries, Settings = settings };
+            var settings = File.Exists(reader.Resolve("settings.json")) ? DirectProjectPersistence.LoadSettings(root) : new GalNet.Core.Configuration.ProjectConfiguration();
+            var loaded = new EditorDocumentRepository(catalog, EditorDocumentValidation.Authoring).Load(root);
+            var snapshot = new EditorProjectDocument { Graph = loaded.Document, GroupEntries = loaded.GroupEntries, Configuration = settings };
             var paths = Directory.Exists(reader.Resolve("I18n")) ? reader.Files("I18n", diagnostics) : [];
             var sources = paths.Where(path => path.EndsWith(".json", StringComparison.OrdinalIgnoreCase) && !path.StartsWith("I18n/External/", StringComparison.OrdinalIgnoreCase))
                 .Select(path => new LocalizationSource(path, File.ReadAllText(reader.Resolve(path)))).ToArray();
-            var index = new LocalizationReferenceIndex(snapshot, catalog, sources);
+            var index = new LocalizationReferenceIndex(snapshot, catalog, sources, null, DiskEntryParameterMetadata.Capture(root, snapshot));
             foreach (var issue in index.Issues)
             {
                 var file = issue.File; var pointer = issue.JsonPointer;
                 var reference = index.References.FirstOrDefault(reference => reference.Owner == file && reference.JsonPointer == pointer && issue.Message.Contains("'" + reference.Key + "'", StringComparison.Ordinal));
+                var entryId = issue.EntryId ?? reference?.EntryId;
                 if (loaded.Document.Nodes.FirstOrDefault(node => node.Id == file) is { } owner)
                 {
                     file = owner.Type == "Group" ? "Graph/" + owner.File : "Graph/graph.json";
-                    if (reference is not null && owner.Type == "Group") pointer = "/entries/" + loaded.GroupEntries[owner.Id].FindIndex(entry => entry.StableId == reference.EntryId) + "/parameters" + pointer;
-                    else if (reference is not null && owner.Options is not null) pointer = "/nodes/" + loaded.Document.Nodes.IndexOf(owner) + "/options/" + owner.Options.FindIndex(option => option.Id == reference.EntryId) + pointer;
+                    if (entryId is not null && owner.Type == "Group" && loaded.GroupEntries[owner.Id].FindIndex(entry => entry.StableId == entryId) is var entryIndex && entryIndex >= 0)
+                        pointer = "/entries/" + entryIndex + "/parameters" + pointer;
+                    else if (entryId is not null && owner.Options is not null) pointer = "/nodes/" + loaded.Document.Nodes.IndexOf(owner) + "/options/" + owner.Options.FindIndex(option => option.Id == entryId) + pointer;
                 }
                 else if (file == "characters") file = LocalizationJson.CatalogPath;
                 var incomplete = issue.Code is "schema.unavailable" or "field.unknown" or "field.opaque" or "analysis.limit";
-                diagnostics.Add(new("localization." + issue.Code, incomplete ? "warning" : "error", issue.Message, file, reference?.EntryId, pointer));
+                diagnostics.Add(new("localization." + issue.Code, incomplete ? "warning" : "error", issue.Message, file, entryId, pointer));
             }
             if (!index.Complete) diagnostics.Add(new("localization.incomplete", "warning", "Localization analysis is incomplete; provide all custom field schemas."));
-            if (settings.AvailableLocales.Select(locale => locale.Code).Distinct(StringComparer.OrdinalIgnoreCase).Count() != settings.AvailableLocales.Count ||
-                !settings.AvailableLocales.Any(locale => locale.Code == settings.TargetLocale.Code))
+            var options = settings.ReadDefaultOptions();
+            if (options.AvailableLocales.Select(locale => locale.Code).Distinct(StringComparer.OrdinalIgnoreCase).Count() != options.AvailableLocales.Count ||
+                !options.AvailableLocales.Any(locale => locale.Code == options.TargetLocale.Code))
                 diagnostics.Add(new("localization.languages", "error", "Project languages must be unique and include the development language.", "settings.json"));
             var metadata = reader.Resolve(LocalizationJson.MetadataPath);
             if (File.Exists(metadata)) LocalizationJson.Validate(LocalizationJson.MetadataPath, File.ReadAllBytes(metadata));
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectAuthorIdentity.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectAuthorIdentity.cs
new file mode 100644
index 00000000..ebe258be
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectAuthorIdentity.cs
@@ -0,0 +1,20 @@
+using System.Security.Cryptography;
+using System.Text.Json;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Author identity shared by the compiler's source maps and the live debugger.</summary>
+public static class ProjectAuthorIdentity
+{
+    public static string Compute(EditorGraphDocument graph, IReadOnlyDictionary<string, List<EditorEntryData>> groups) =>
+        Convert.ToHexString(SHA256.HashData(JsonSerializer.SerializeToUtf8Bytes(new
+        {
+            Graph = graph,
+            Groups = groups.OrderBy(pair => pair.Key, StringComparer.Ordinal).Select(pair => new
+            {
+                pair.Key,
+                Entries = pair.Value.Select(entry => new { entry.StableId, entry.Type, entry.Condition, entry.Parameters })
+            })
+        })));
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectContentBaseline.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectContentBaseline.cs
new file mode 100644
index 00000000..7bd7a7b7
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectContentBaseline.cs
@@ -0,0 +1,64 @@
+using System.Text.Json;
+using GalNet.Core.Variable;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Owns a saved snapshot. Live comparisons never clone or serialize the project.</summary>
+internal sealed class ProjectContentBaseline
+{
+    private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web) { WriteIndented = true };
+    private EditorProjectDocument _saved = new();
+    public byte[] Bytes { get; private set; } = [];
+
+    public void Set(byte[] bytes)
+    {
+        _saved = JsonSerializer.Deserialize<EditorProjectDocument>(bytes, Json)!;
+        Bytes = bytes;
+    }
+
+    public bool Matches(EditorProjectDocument current) => Same(current, _saved);
+
+    private static bool Same(EditorProjectDocument a, EditorProjectDocument b) =>
+        a.Graph.Version == b.Graph.Version && a.Graph.Name == b.Graph.Name && a.Graph.RootNodeId == b.Graph.RootNodeId &&
+        Sequence(a.Graph.Nodes, b.Graph.Nodes, Node) && Sequence(a.Graph.Edges, b.Graph.Edges, Edge) &&
+        Sequence(a.Graph.PlayerVariables, b.Graph.PlayerVariables, Variable) && Sequence(a.Graph.SaveVariables, b.Graph.SaveVariables, Variable) &&
+        Map(a.Configuration.Sections, b.Configuration.Sections, (x, y) => x.Version == y.Version && JsonElement.DeepEquals(x.Data, y.Data)) &&
+        Map(a.GroupEntries, b.GroupEntries, (x, y) => Sequence(x, y, Entry)) && Map(a.Files, b.Files, File);
+
+    private static bool Node(EditorGraphNodeDto a, EditorGraphNodeDto b) =>
+        a.Id == b.Id && a.Type == b.Type && a.Name == b.Name && a.X.Equals(b.X) && a.Y.Equals(b.Y) && a.File == b.File && a.BranchType == b.BranchType && a.StoryPackage == b.StoryPackage &&
+        Sequence(a.Options, b.Options, (x, y) => x.Id == y.Id && x.Text == y.Text && x.Condition == y.Condition) &&
+        Sequence(a.Conditions, b.Conditions, (x, y) => x.Id == y.Id && x.Expression == y.Expression);
+    private static bool Edge(EditorGraphEdgeDto a, EditorGraphEdgeDto b) =>
+        a.Id == b.Id && a.FromNodeId == b.FromNodeId && a.FromOutlet == b.FromOutlet && a.ToNodeId == b.ToNodeId;
+    private static bool Entry(EditorEntryData a, EditorEntryData b) =>
+        a.StableId == b.StableId && a.Type == b.Type && a.Condition == b.Condition && Map(a.Parameters, b.Parameters, JsonElement.DeepEquals);
+    private static bool Variable(ProjectVariableDefinition a, ProjectVariableDefinition b) =>
+        a.Name == b.Name && a.Description == b.Description && a.DefaultValue.Uid == b.DefaultValue.Uid &&
+        a.DefaultValue.Name == b.DefaultValue.Name && a.DefaultValue.Type == b.DefaultValue.Type &&
+        (a.DefaultValue.Type switch
+        {
+            VariableType.Bool => a.DefaultValue.AsBool() == b.DefaultValue.AsBool(),
+            VariableType.Int => a.DefaultValue.AsInt() == b.DefaultValue.AsInt(),
+            VariableType.Float => a.DefaultValue.AsFloat().Equals(b.DefaultValue.AsFloat()),
+            _ => a.DefaultValue.AsString() == b.DefaultValue.AsString()
+        });
+    private static bool File(EditorFileDocument a, EditorFileDocument b) =>
+        a.Id == b.Id && a.Path == b.Path && a.Exists == b.Exists && a.ManagedContent == b.ManagedContent &&
+        (!a.Exists || a.Data.AsSpan().SequenceEqual(b.Data));
+
+    private static bool Sequence<T>(IReadOnlyList<T>? a, IReadOnlyList<T>? b, Func<T, T, bool> same)
+    {
+        if (a is null || b is null) return a is null && b is null;
+        if (a.Count != b.Count) return false;
+        for (var index = 0; index < a.Count; index++) if (!same(a[index], b[index])) return false;
+        return true;
+    }
+    private static bool Map<T>(IReadOnlyDictionary<string, T> a, IReadOnlyDictionary<string, T> b, Func<T, T, bool> same)
+    {
+        if (a.Count != b.Count) return false;
+        foreach (var (id, value) in a) if (!b.TryGetValue(id, out var other) || !same(value, other)) return false;
+        return true;
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectContentBuilder.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectContentBuilder.cs
index 5188bb9b..585fb1f0 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectContentBuilder.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectContentBuilder.cs
@@ -1,15 +1,20 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Assets;
+using GalNet.Contracts.Builtins.Assets;
 using GalNet.Core.Assets;
 using GalNet.Core.Compilation;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
 using GalNet.Core.Serialization;
 using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Commands;
 
 namespace GalNet.Editor.Shared.Services;
 
 /// <summary>Builds editable project content into the compiled directory layout consumed by Runtime.</summary>
-public sealed class ProjectContentBuilder(IEntryCatalog entryCatalog, IResourceTypeCatalog? resourceTypes = null)
+public sealed class ProjectContentBuilder(IEntryCatalog entryCatalog, IResourceTypeCatalog? resourceTypes = null,
+    ProjectConfigurationSchema? configurations = null)
 {
     private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
     {
@@ -24,6 +29,22 @@ public async Task<ProjectContentBuildResult> BuildAsync(
         string projectRoot,
         string? outputRoot = null,
         CancellationToken cancellationToken = default)
+    {
+        var (build, _) = await BuildPreparedAsync(projectRoot, outputRoot, (stage, token) =>
+        {
+            token.ThrowIfCancellationRequested();
+            var diagnostics = ImageVariantsValidation.Validate(stage, resourceTypes ?? BuiltinResourceTypes.CreateCatalog());
+            if (diagnostics.Any(item => item.Severity == "error"))
+                throw new InvalidDataException(string.Join("; ", diagnostics.Select(item => $"{item.File}{item.JsonPointer}: {item.Message}")));
+            return Task.FromResult(true);
+        }, cancellationToken).ConfigureAwait(false);
+        return build;
+    }
+
+    /// <summary>Prepares and validates assets from the private stage before publication; prepared values must own their bytes.</summary>
+    internal async Task<(ProjectContentBuildResult Build, T Prepared)> BuildPreparedAsync<T>(
+        string projectRoot, string? outputRoot, Func<string, CancellationToken, Task<T>> prepare,
+        CancellationToken cancellationToken)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(projectRoot);
         var sourceRoot = Path.GetFullPath(projectRoot);
@@ -33,9 +54,9 @@ public async Task<ProjectContentBuildResult> BuildAsync(
         var targetRoot = Path.GetFullPath(outputRoot ?? Path.Combine(sourceRoot, "Output"));
         ValidateOutputPath(sourceRoot, targetRoot);
         cancellationToken.ThrowIfCancellationRequested();
+        if (configurations is not null) configurations.Validate(DirectProjectPersistence.LoadSettings(sourceRoot));
         var validation = new ProjectValidationService(sourceRoot).Validate("graph");
         var diagnostics = validation.Diagnostics.ToList();
-        diagnostics.AddRange(ImageVariantsValidation.Validate(sourceRoot, resourceTypes ?? BuiltinResourceTypes.CreateCatalog()));
         diagnostics.AddRange(LocalizationValidation.ValidateDisk(sourceRoot, _entryCatalog));
         _ = new ProjectRawReader(sourceRoot).Files(null, diagnostics);
         if (!validation.Success || diagnostics.Any(item => item.Code == "file.linkSkipped" || item.Severity == "error"))
@@ -48,7 +69,8 @@ public async Task<ProjectContentBuildResult> BuildAsync(
         try
         {
             Directory.CreateDirectory(stageRoot);
-            var compiledGroups = await BuildStageAsync(sourceRoot, stageRoot, cancellationToken).ConfigureAwait(false);
+            var result = await BuildStageAsync(sourceRoot, stageRoot, cancellationToken).ConfigureAwait(false);
+            var prepared = await prepare(stageRoot, cancellationToken).ConfigureAwait(false);
             cancellationToken.ThrowIfCancellationRequested();
 
             Directory.CreateDirectory(Path.GetDirectoryName(targetRoot)!);
@@ -79,7 +101,7 @@ public async Task<ProjectContentBuildResult> BuildAsync(
                 backupRoot = null;
             }
 
-            return new ProjectContentBuildResult(targetRoot, compiledGroups) { Diagnostics = diagnostics.ToArray() };
+            return (result with { OutputPath = targetRoot, Diagnostics = diagnostics.ToArray() }, prepared);
         }
         finally
         {
@@ -90,7 +112,7 @@ public async Task<ProjectContentBuildResult> BuildAsync(
         }
     }
 
-    private async Task<int> BuildStageAsync(string sourceRoot, string stageRoot, CancellationToken cancellationToken)
+    private async Task<ProjectContentBuildResult> BuildStageAsync(string sourceRoot, string stageRoot, CancellationToken cancellationToken)
     {
         var sourceGraphRoot = Path.Combine(sourceRoot, "Graph");
         var sourceGraphPath = Path.Combine(sourceGraphRoot, "graph.json");
@@ -113,19 +135,30 @@ private async Task<int> BuildStageAsync(string sourceRoot, string stageRoot, Can
         var targetGroupsRoot = Path.Combine(targetGraphRoot, "groups");
         Directory.CreateDirectory(targetGroupsRoot);
 
+        var mappings = new List<ProjectCompiledSourceEntry>();
+        var authors = new Dictionary<string, List<EditorEntryData>>(StringComparer.Ordinal);
         foreach (var group in groups)
         {
             cancellationToken.ThrowIfCancellationRequested();
             var rawPath = sources[group.Id];
             var diagnostics = new List<GalNet.Editor.Abstraction.Commands.ToolDiagnostic>();
-            var raw = new ProjectValidationService(sourceRoot).ValidateGroup(DisplayPath(sourceRoot, rawPath), diagnostics, _entryCatalog)
+            var raw = new ProjectValidationService(sourceRoot).ValidateGroup(DisplayPath(sourceRoot, rawPath), diagnostics, out var compilation, _entryCatalog)
                 ?? throw new InvalidDataException(string.Join("; ", diagnostics.Select(item => $"{item.File}{item.JsonPointer}: {item.Message}")));
-            var compiled = GalgroupCompiler.Compile(raw, _entryCatalog).Document;
+            var compiled = compilation!.Document;
+            var offset = 0;
+            foreach (var entry in raw.Entries)
+            {
+                var primitives = compilation.SourceMap[entry.Id];
+                mappings.Add(new(group.Id, entry.Id, offset, offset + primitives.Count, Array.AsReadOnly(primitives.ToArray())));
+                offset += primitives.Count;
+            }
+            authors.Add(group.Id, raw.Entries.Select(entry => new EditorEntryData
+            { StableId = entry.Id, Type = entry.Type, Condition = entry.Condition, Parameters = entry.Parameters }).ToList());
             var targetPath = Path.Combine(targetGroupsRoot, $"{group.Id}.galgroup");
             await File.WriteAllTextAsync(targetPath, JsonSerializer.Serialize(compiled, JsonOptions), cancellationToken).ConfigureAwait(false);
         }
 
-        return groups.Length;
+        return new(stageRoot, groups.Length) { SourceEntries = mappings.AsReadOnly(), AuthorSignature = ProjectAuthorIdentity.Compute(graph, authors) };
     }
 
     private static Dictionary<string, string> ResolveGroupSources(string graphRoot, IEnumerable<EditorGraphNodeDto> groups)
@@ -195,26 +228,16 @@ private static void CopyOptionalDirectory(string sourceRoot, string targetRoot,
 
     internal static void ValidateOutputPath(string sourceRoot, string targetRoot)
     {
-        if (string.Equals(sourceRoot, targetRoot, StringComparison.OrdinalIgnoreCase) || IsSameOrChild(sourceRoot, targetRoot))
+        if (IsSameOrChild(sourceRoot, targetRoot))
             throw new InvalidDataException("Build output must not be the project directory or one of its ancestors.");
 
         foreach (var protectedDirectory in new[] { "Graph", "Assets", "I18n", ".galnet", "Temp", "Contracts", ".git" })
             if (IsSameOrChild(targetRoot, Path.Combine(sourceRoot, protectedDirectory)))
                 throw new InvalidDataException($"Build output must not be inside project '{protectedDirectory}/'.");
-        var current = Path.GetPathRoot(targetRoot)!;
-        foreach (var component in targetRoot[current.Length..].Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries))
-        {
-            current = Path.Combine(current, component);
-            if ((File.Exists(current) || Directory.Exists(current)) && (File.GetAttributes(current) & FileAttributes.ReparsePoint) != 0)
-                throw new InvalidDataException("Build/export output must not traverse filesystem links.");
-        }
+        FileSystemPaths.RequireNoLinks(targetRoot, "Build/export output must not traverse filesystem links.");
     }
 
-    private static bool IsSameOrChild(string candidate, string parent)
-    {
-        var relative = Path.GetRelativePath(parent, candidate);
-        return relative.Length == 0 || (!Path.IsPathRooted(relative) && !relative.Equals("..", StringComparison.Ordinal) && !relative.StartsWith($"..{Path.DirectorySeparatorChar}", StringComparison.Ordinal));
-    }
+    private static bool IsSameOrChild(string candidate, string parent) => FileSystemPaths.IsSameOrChild(candidate, parent);
 
     private static string DisplayPath(string basePath, string path) => Path.GetRelativePath(basePath, path).Replace('\\', '/');
 }
@@ -222,4 +245,8 @@ private static bool IsSameOrChild(string candidate, string parent)
 public sealed record ProjectContentBuildResult(string OutputPath, int CompiledGroupCount)
 {
     public IReadOnlyList<GalNet.Editor.Abstraction.Commands.ToolDiagnostic> Diagnostics { get; init; } = [];
+    [JsonIgnore] public IReadOnlyList<ProjectCompiledSourceEntry> SourceEntries { get; init; } = [];
+    [JsonIgnore] public string AuthorSignature { get; init; } = "";
 }
+
+public sealed record ProjectCompiledSourceEntry(string GroupId, string EntryId, int Start, int End, IReadOnlyList<string> PrimitiveIds);
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectContentSession.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectContentSession.cs
index 9ab1ad61..4d29be3c 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectContentSession.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectContentSession.cs
@@ -13,12 +13,16 @@ public sealed class ProjectContentSession(IEditorDocumentService documents, IEdi
     private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web) { WriteIndented = true };
     private readonly SemaphoreSlim _saveGate = new(1, 1);
     private GalProject? _project;
-    private byte[] _baseline = [];
+    private readonly ProjectContentBaseline _savedContent = new();
+    private byte[] BaselineBytes { get => _savedContent.Bytes; set => _savedContent.Set(value); }
     private byte[] _settingsBaseline = [];
-    private byte[]? _publicationContent;
+    private Dictionary<string, byte[]> _externalBaseline = new(ProjectFilePaths.Comparer);
+    private string _contractsFingerprint = "";
+    private ProjectContentBaseline? _publicationContent;
     private bool _suspended;
     private bool _disposed;
-    private readonly List<DraftRegistration> _drafts = [];
+    private readonly ProjectDraftRegistry _drafts = new();
+    private readonly List<Action<EditorProjectDocument, EditorProjectDocument, Action>> _structureTransitions = [];
     private readonly Dictionary<string, EditorFileDocument> _files = [];
     public IReadOnlyDictionary<string, EditorFileDocument> FileDocuments => _files;
     public EditorFileDocument TrackFile(string path, byte[]? textBytes = null)
@@ -30,9 +34,10 @@ public EditorFileDocument TrackFile(string path, byte[]? textBytes = null)
         if (IsPublishing) throw ProjectFilePaths.Error("busy", path);
         var file = new EditorFileDocument { Path = path, ManagedContent = textBytes is not null, Data = textBytes?.ToArray() ?? [] };
         _files.Add(file.Id, file);
-        var saved = JsonSerializer.Deserialize<EditorProjectDocument>(_baseline, JsonOptions)!;
+        var saved = JsonSerializer.Deserialize<EditorProjectDocument>(BaselineBytes, JsonOptions)!;
         saved.Files.Add(file.Id, EditorDocumentCloner.Clone(new EditorProjectDocument { Files = new() { [file.Id] = file } }).Files[file.Id]);
-        _baseline = Serialize(saved);
+        BaselineBytes = Serialize(saved);
+        if (textBytes is not null) _externalBaseline[path] = textBytes.ToArray();
         Refresh();
         return file;
     }
@@ -50,7 +55,8 @@ public EditorFileDocument TrackLocalizationFile(string path, byte[] textBytes)
         file.ManagedContent = true; file.Data = textBytes.ToArray();
         _files[file.Id] = file;
         saved.Files[file.Id] = new() { Id = file.Id, Path = path, ManagedContent = true, Data = textBytes.ToArray() };
-        _baseline = Serialize(saved);
+        BaselineBytes = Serialize(saved);
+        _externalBaseline[path] = textBytes.ToArray();
         Refresh();
         return file;
     }
@@ -65,30 +71,29 @@ public EditorFileDocument TrackLocalizationFile(string path, byte[] textBytes)
 
     public bool IsPublishing => !_disposed && _saveGate.CurrentCount == 0;
     public bool HasEditsSincePublication => IsPublishing && _publicationContent is { } captured &&
-        (_drafts.Any(draft => draft.HasChanges()) || !Serialize(Capture()).AsSpan().SequenceEqual(captured));
-    public bool IsDirty => _project is not null && (_drafts.Any(draft => draft.HasChanges()) || !ComparisonBytes(Capture()).AsSpan().SequenceEqual(ComparisonBytes(JsonSerializer.Deserialize<EditorProjectDocument>(_baseline, JsonOptions)!)));
+        (_drafts.HasChanges || !captured.Matches(CurrentContent()));
+    public bool IsDirty => _project is not null && (_drafts.HasChanges || !_savedContent.Matches(CurrentContent()));
     public bool RepairRequired { get; private set; }
     public Exception? LastError { get; private set; }
     public event Action? Changed;
+    public event Action? ExternalReloaded;
 
-    public IDisposable RegisterDraft(Func<bool> hasChanges, Func<Task> commit)
+    public IDisposable RegisterDraft(Func<bool> hasChanges, Func<Task> commit) => _drafts.Register(hasChanges, commit);
+    public IDisposable RegisterDraft(Func<bool> hasChanges, Func<Task> commit, Action discard) => _drafts.Register(hasChanges, commit, discard);
+    public IDisposable RegisterDraft(Func<bool> hasChanges, Func<ProjectDraftCommitContext, Task> commit, Action discard) =>
+        _drafts.Register(hasChanges, () => commit(default), discard, contextualCommit: commit);
+    public IDisposable RegisterStructureTransition(Action<EditorProjectDocument, EditorProjectDocument, Action> transition)
     {
-        var registration = new DraftRegistration(_drafts, hasChanges, commit);
-        _drafts.Add(registration);
-        return registration;
-    }
-    public IDisposable RegisterFileDraft(string fileId, Func<bool> hasChanges, Func<Task> commit, Action validate)
-    {
-        var registration = new DraftRegistration(_drafts, hasChanges, commit, fileId, validate);
-        _drafts.Add(registration);
-        return registration;
-    }
-    public async Task CommitFileDraftsAsync(string fileId)
-    {
-        var drafts = _drafts.Where(draft => draft.FileId == fileId && draft.HasChanges()).ToArray();
-        foreach (var draft in drafts) draft.Validate?.Invoke();
-        foreach (var draft in drafts) await draft.Commit();
+        _structureTransitions.Add(transition); return new StructureRegistration(_structureTransitions, transition);
     }
+    private sealed record StructureRegistration(List<Action<EditorProjectDocument, EditorProjectDocument, Action>> Owner,
+        Action<EditorProjectDocument, EditorProjectDocument, Action> Transition) : IDisposable
+    { public void Dispose() => Owner.Remove(Transition); }
+    public IDisposable RegisterFileDraft(string fileId, Func<bool> hasChanges, Func<Task> commit, Action validate) =>
+        _drafts.Register(hasChanges, commit, fileId: fileId, validate: validate);
+    public IDisposable RegisterFileDraft(string fileId, Func<bool> hasChanges, Func<Task> commit, Action validate, Action discard) =>
+        _drafts.Register(hasChanges, commit, discard, fileId, validate);
+    public Task CommitFileDraftsAsync(string fileId) => _drafts.CommitFileAsync(fileId);
 
     public IDisposable RegisterCaptureGuard(Func<bool, CancellationToken, Task<IDisposable>> acquire)
     {
@@ -102,24 +107,24 @@ private sealed class CaptureRegistration(ProjectContentSession owner) : IDisposa
         public void Dispose() => owner._captureGuard = null;
     }
 
-    public async Task CommitDraftsAsync()
-    {
-        foreach (var draft in _drafts.ToArray())
-            if (draft.HasChanges()) await draft.Commit();
-    }
-
-    private sealed record DraftRegistration(List<DraftRegistration> Owner, Func<bool> HasChanges, Func<Task> Commit,
-        string? FileId = null, Action? Validate = null) : IDisposable
-    {
-        public void Dispose() => Owner.Remove(this);
-    }
+    public Task CommitDraftsAsync() => _drafts.CommitAsync();
+    public Task CommitDraftsAsync(ProjectDraftCommitContext context) => _drafts.CommitAsync(context);
 
     public void Open(GalProject project)
     {
         if (_project is not null) throw new InvalidOperationException("The content session is already open.");
         ProjectFileOperation.CleanupOrphans(project.RootPath);
         _project = project;
-        _baseline = Serialize(Capture());
+        _externalBaseline = ExternalProjectSnapshotReader.ReadFiles(project.RootPath, []);
+        foreach (var pair in repository.SourceBaseline)
+            if (pair.Value is { } bytes) _externalBaseline[pair.Key] = bytes.ToArray();
+        foreach (var (path, bytes) in _externalBaseline.Where(pair => ExternalProjectSnapshotReader.IsLocalization(pair.Key)))
+        {
+            var file = new EditorFileDocument { Path = path, ManagedContent = true, Data = bytes.ToArray() };
+            _files.Add(file.Id, file);
+        }
+        _contractsFingerprint = ExternalProjectSnapshotReader.ContractsFingerprint(project.RootPath);
+        BaselineBytes = Serialize(Capture());
         _settingsBaseline = File.ReadAllBytes(Path.Combine(project.RootPath, "settings.json"));
         _recovery = new(project.RootPath, options ?? new());
         _closingRegistration = project.RegisterClosingCallback(async () =>
@@ -163,22 +168,93 @@ public void ReportError(Exception failure)
         Refresh();
     }
 
-    private EditorProjectDocument Capture()
+    private EditorProjectDocument CurrentContent()
     {
         var project = _project ?? throw new InvalidOperationException("No project is open.");
-        return EditorDocumentCloner.Clone(new()
+        return new()
         {
             Graph = documents.CurrentDocument,
-            Settings = project.Settings,
+            Configuration = project.Configuration,
             GroupEntries = documents.LoadedProject.GroupEntries,
             Files = _files
-        });
+        };
     }
 
+    private EditorProjectDocument Capture() => EditorDocumentCloner.Clone(CurrentContent());
+
     public EditorProjectDocument CaptureWorking() => Capture();
+
+    public async Task<ExternalReloadResult> ReloadExternalAsync(ExternalProjectSnapshot snapshot, bool discardLocalChanges = false, CancellationToken cancellationToken = default)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        if (_project is null || _suspended || RepairRequired) return ExternalReloadResult.Unavailable;
+        using var lease = await AcquirePlanAsync(false, cancellationToken);
+        try
+        {
+            if (_disposed || _suspended || RepairRequired) return ExternalReloadResult.Unavailable;
+            if (snapshot.ContractsFingerprint != _contractsFingerprint)
+                throw new EditorOperationException("project.externalContracts", "Project contracts changed. Reopen the project to load the new contract safely.");
+            if (!ExternalProjectSnapshotReader.IsCurrent(_project.RootPath, snapshot, _files.Values)) return ExternalReloadResult.Retry;
+            if (ExternalProjectSnapshotReader.Same(snapshot.Files, _externalBaseline)) return ExternalReloadResult.Unchanged;
+            _project.Configurations.Validate(snapshot.Configuration);
+            if (IsDirty && !discardLocalChanges) return ExternalReloadResult.LocalChanges;
+            if (discardLocalChanges)
+            {
+                var pending = _drafts.Pending;
+                if (pending.Any(draft => draft.Discard is null)) return ExternalReloadResult.LocalChanges;
+                CaptureRecovery();
+                foreach (var draft in pending) draft.Discard!();
+                // Composition/in-flight input may refuse cancellation. Keep the live version until it settles.
+                if (_drafts.HasChanges) return ExternalReloadResult.LocalChanges;
+            }
+            // All fallible disk inspection precedes the in-memory version transition.
+            repository.AdoptExternalBaseline(snapshot.AuthorSources);
+            _project.Configuration.ReplaceFrom(snapshot.Configuration);
+            foreach (var group in _files.Values.Where(file => file.ManagedContent).GroupBy(file => file.Path, ProjectFilePaths.Comparer))
+            {
+                var file = group.FirstOrDefault(file => file.Exists) ?? group.First();
+                foreach (var item in group) item.Exists = false;
+                file.Exists = snapshot.Files.TryGetValue(file.Path, out var bytes);
+                file.Data = bytes?.ToArray() ?? [];
+            }
+            foreach (var (path, bytes) in snapshot.Files.Where(pair => ExternalProjectSnapshotReader.IsLocalization(pair.Key)))
+                if (!_files.Values.Any(file => file.Exists && ProjectFilePaths.Comparer.Equals(file.Path, path)))
+                {
+                    var file = new EditorFileDocument { Path = path, ManagedContent = true, Data = bytes.ToArray() };
+                    _files.Add(file.Id, file);
+                }
+            documents.Reload(snapshot.Document);
+            _settingsBaseline = snapshot.Files["settings.json"].ToArray();
+            _externalBaseline = snapshot.Files.ToDictionary(pair => pair.Key, pair => pair.Value.ToArray(), ProjectFilePaths.Comparer);
+            BaselineBytes = Serialize(Capture());
+            LastError = null;
+            if (ExternalReloaded is not null)
+                foreach (Action observer in ExternalReloaded.GetInvocationList())
+                    try { observer(); }
+                    catch (Exception failure) { LastNotificationError = failure; Serilog.Log.Error(failure, "An external reload observer failed"); }
+            Refresh();
+            return ExternalReloadResult.Reloaded;
+        }
+        finally { _saveGate.Release(); Refresh(); }
+    }
+
+    private void AcceptPublication(ProjectSavePlan plan)
+    {
+        foreach (var pair in plan.Writes)
+            if (pair.Key == "settings.json" || pair.Key.StartsWith("Graph/", StringComparison.Ordinal) || _externalBaseline.ContainsKey(pair.Key) || ExternalProjectSnapshotReader.IsLocalization(pair.Key))
+                _externalBaseline[pair.Key] = pair.Value.ToArray();
+        foreach (var path in plan.DeletedFiles) _externalBaseline.Remove(path);
+        if (plan.Files is { } files)
+        {
+            foreach (var path in files.Writes.Keys.Concat(files.Copies.Keys).Where(path =>
+                path.StartsWith("Graph/", StringComparison.Ordinal) || path.StartsWith("I18n/", StringComparison.Ordinal) || _files.Values.Any(file => file.ManagedContent && file.Path == path)))
+                _externalBaseline[path] = File.ReadAllBytes(new ProjectRawReader(_project!.RootPath).Resolve(path));
+            foreach (var path in files.Deletes) _externalBaseline.Remove(path);
+        }
+    }
     public EditorProjectDocument CaptureSaved()
     {
-        var saved = JsonSerializer.Deserialize<EditorProjectDocument>(_baseline, JsonOptions)
+        var saved = JsonSerializer.Deserialize<EditorProjectDocument>(BaselineBytes, JsonOptions)
             ?? throw new InvalidOperationException("No saved author baseline is available.");
         foreach (var entries in saved.GroupEntries.Values)
             for (var index = 0; index < entries.Count; index++) entries[index].Id = index + 1;
@@ -195,18 +271,9 @@ private static byte[] Serialize(EditorProjectDocument document)
             entry.Id = 0;
             entry.Parameters = entry.Parameters.OrderBy(pair => pair.Key, StringComparer.Ordinal).ToDictionary(pair => pair.Key, pair => pair.Value);
         }
-        // Runtime's settings variable copies are derived, never a second author truth.
-        document.Settings.PlayerVariables = document.Graph.PlayerVariables.Select(item => item.Clone()).ToList();
-        document.Settings.SaveVariables = document.Graph.SaveVariables.Select(item => item.Clone()).ToList();
         return JsonSerializer.SerializeToUtf8Bytes(document, JsonOptions);
     }
 
-    private static byte[] ComparisonBytes(EditorProjectDocument document)
-    {
-        foreach (var file in document.Files.Values.Where(file => !file.Exists)) file.Data = [];
-        return Serialize(document);
-    }
-
     public async Task SaveAsync(CancellationToken cancellationToken = default)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
@@ -229,12 +296,14 @@ public async Task SaveAsync(CancellationToken cancellationToken = default)
                 var snapshot = Capture();
                 CheckTrackedFiles();
                 capturedContent = Serialize(snapshot);
-                _publicationContent = capturedContent;
+                _publicationContent = new();
+                _publicationContent.Set(capturedContent);
                 if (!File.ReadAllBytes(settingsPath).AsSpan().SequenceEqual(_settingsBaseline))
                     throw new EditorOperationException("project.externalSettings", "Project settings changed outside the editor. Reload before saving.");
                 var content = repository.PrepareSave(project.RootPath, snapshot.Graph,
                     snapshot.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value));
-                settings = JsonSerializer.SerializeToUtf8Bytes(snapshot.Settings, JsonOptions);
+                project.Configurations.Validate(snapshot.Configuration);
+                settings = JsonSerializer.SerializeToUtf8Bytes(snapshot.Configuration, JsonOptions);
                 var writes = new Dictionary<string, byte[]>(content.Writes)
                 {
                     ["settings.json"] = settings,
@@ -253,7 +322,8 @@ await Task.Run(() =>
                 repository.ApplySave(project.RootPath, plan, cancellationToken);
             }, cancellationToken);
             _settingsBaseline = settings;
-            _baseline = capturedContent;
+            BaselineBytes = capturedContent;
+            AcceptPublication(plan);
             LastError = null;
             Refresh();
         }
@@ -334,7 +404,7 @@ public async Task PublishStructureAsync(Func<EditorProjectDocument, EditorProjec
             if (_suspended || RepairRequired) throw new InvalidOperationException("Project writes are unavailable.");
             var project = _project ?? throw new InvalidOperationException("No project is open.");
             var working = Capture();
-            var saved = JsonSerializer.Deserialize<EditorProjectDocument>(_baseline, JsonOptions)!;
+            var saved = JsonSerializer.Deserialize<EditorProjectDocument>(BaselineBytes, JsonOptions)!;
             var change = prepare(working, saved);
             var nextWorking = EditorDocumentCloner.Clone(working);
             var nextSaved = EditorDocumentCloner.Clone(saved);
@@ -348,30 +418,38 @@ public async Task PublishStructureAsync(Func<EditorProjectDocument, EditorProjec
                 foreach (var pair in plan.Files!.ExpectedHashes) files.Files.ExpectedHashes[pair.Key] = pair.Value;
                 plan = plan with { Files = files.Files };
             }
-            repository.ApplySave(project.RootPath, plan);
-            try
-            {
-                change.Apply(new() { Graph = documents.CurrentDocument, Settings = project.Settings, GroupEntries = documents.LoadedProject.GroupEntries, Files = _files }, AuthorDocumentVersion.Working);
-                documents.SynchronizeGroups();
-            }
-            catch (Exception failure)
+            void Publish()
             {
+                repository.ApplySave(project.RootPath, plan);
                 try
                 {
-                    var restore = PrepareAuthorPlan(project, saved, checkSettingsBaseline: false);
-                    repository.ApplySave(project.RootPath, restore);
-                    _settingsBaseline = restore.Writes["settings.json"];
+                    change.Apply(new() { Graph = documents.CurrentDocument, Configuration = project.Configuration, GroupEntries = documents.LoadedProject.GroupEntries, Files = _files }, AuthorDocumentVersion.Working);
+                    documents.SynchronizeGroups();
                 }
-                catch (Exception compensation)
+                catch (Exception failure)
                 {
-                    BlockWrites(new AggregateException("Structure publication could not be compensated.", failure, compensation));
-                    throw new ProjectRepairRequiredException(Path.Combine(project.RootPath, ".galnet/editor"), LastError!);
+                    try
+                    {
+                        var restore = PrepareAuthorPlan(project, saved, checkSettingsBaseline: false);
+                        repository.ApplySave(project.RootPath, restore);
+                        _settingsBaseline = restore.Writes["settings.json"];
+                    }
+                    catch (Exception compensation)
+                    {
+                        BlockWrites(new AggregateException("Structure publication could not be compensated.", failure, compensation));
+                        throw new ProjectRepairRequiredException(Path.Combine(project.RootPath, ".galnet/editor"), LastError!);
+                    }
+                    throw;
                 }
-                throw;
+                BaselineBytes = Serialize(nextSaved);
+                _settingsBaseline = plan.Writes["settings.json"];
+                AcceptPublication(plan);
+                LastError = null;
             }
-            _baseline = Serialize(nextSaved);
-            _settingsBaseline = plan.Writes["settings.json"];
-            LastError = null;
+            Action publish = Publish;
+            foreach (var transition in _structureTransitions.ToArray().Reverse())
+            { var next = publish; publish = () => transition(working, nextWorking, next); }
+            publish();
             Refresh();
         }
         catch (Exception failure)
@@ -387,15 +465,16 @@ public async Task PublishStructureAsync(Func<EditorProjectDocument, EditorProjec
 
     private ProjectSavePlan PrepareAuthorPlan(GalProject project, EditorProjectDocument snapshot, bool checkSettingsBaseline = true)
     {
+        project.Configurations.Validate(snapshot.Configuration);
         if (checkSettingsBaseline) CheckTrackedFiles();
         if (checkSettingsBaseline && !File.ReadAllBytes(Path.Combine(project.RootPath, "settings.json")).AsSpan().SequenceEqual(_settingsBaseline))
             throw new EditorOperationException("project.externalSettings", "Project settings changed outside the editor.");
         _ = Serialize(snapshot);
         var content = repository.PrepareSave(project.RootPath, snapshot.Graph,
             snapshot.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value));
-        var writes = new Dictionary<string, byte[]>(content.Writes) { ["settings.json"] = JsonSerializer.SerializeToUtf8Bytes(snapshot.Settings, JsonOptions) };
+        var writes = new Dictionary<string, byte[]>(content.Writes) { ["settings.json"] = JsonSerializer.SerializeToUtf8Bytes(snapshot.Configuration, JsonOptions) };
         foreach (var file in snapshot.Files.Values.Where(file => file.Exists && file.ManagedContent)) writes[file.Path] = file.Data;
-        var previous = JsonSerializer.Deserialize<EditorProjectDocument>(_baseline, JsonOptions)!;
+        var previous = JsonSerializer.Deserialize<EditorProjectDocument>(BaselineBytes, JsonOptions)!;
         var removed = previous.Files.Values.Where(file => file.ManagedContent && file.Exists &&
             (!snapshot.Files.TryGetValue(file.Id, out var next) || !next.Exists || !ProjectFilePaths.Comparer.Equals(file.Path, next.Path))).Select(file => file.Path);
         return new(writes, content.DeletedFiles.Concat(removed).Distinct(ProjectFilePaths.Comparer).ToArray()) { Files = TrackedExpectations() };
@@ -404,7 +483,7 @@ private ProjectSavePlan PrepareAuthorPlan(GalProject project, EditorProjectDocum
     private ProjectFilePlan TrackedExpectations()
     {
         var plan = new ProjectFilePlan();
-        var saved = JsonSerializer.Deserialize<EditorProjectDocument>(_baseline, JsonOptions)!;
+        var saved = JsonSerializer.Deserialize<EditorProjectDocument>(BaselineBytes, JsonOptions)!;
         foreach (var file in TrackedFiles(saved))
             plan.ExpectedHashes[file.Path] = file.Exists ? Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(file.Data)) : null;
         return plan;
@@ -412,7 +491,7 @@ private ProjectFilePlan TrackedExpectations()
 
     private void CheckTrackedFiles()
     {
-        var saved = JsonSerializer.Deserialize<EditorProjectDocument>(_baseline, JsonOptions)!;
+        var saved = JsonSerializer.Deserialize<EditorProjectDocument>(BaselineBytes, JsonOptions)!;
         var reader = new ProjectRawReader(_project!.RootPath);
         foreach (var file in TrackedFiles(saved))
         {
@@ -468,6 +547,7 @@ public void Dispose()
         _lifetime.Cancel();
         _closingRegistration?.Dispose();
         _drafts.Clear();
+        _structureTransitions.Clear();
         _lifetime.Dispose();
         _saveGate.Dispose();
         GC.SuppressFinalize(this);
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectContractSource.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectContractSource.cs
new file mode 100644
index 00000000..a49864f0
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectContractSource.cs
@@ -0,0 +1,104 @@
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
+using System.Text.Json;
+using GalNet.Editor.Abstraction.Services;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Snapshots only a contract's managed dependency closure for project creation.</summary>
+public sealed class ProjectContractSource : IDisposable
+{
+    private static readonly HashSet<string> PlatformAssemblyNames = GetPlatformAssemblyNames();
+
+    private static HashSet<string> GetPlatformAssemblyNames()
+    {
+        // In self-contained deployments the runtime and app assemblies share a directory.
+        // The runtime pack's deps entry identifies framework files without excluding app dependencies.
+        var names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var depsFiles = ((string?)AppContext.GetData("APP_CONTEXT_DEPS_FILES") ?? "")
+            .Split(';', StringSplitOptions.RemoveEmptyEntries);
+        foreach (var path in depsFiles)
+        {
+            using var deps = JsonDocument.Parse(File.ReadAllBytes(path));
+            foreach (var target in deps.RootElement.GetProperty("targets").EnumerateObject())
+                foreach (var library in target.Value.EnumerateObject())
+                    if (library.Name.StartsWith("runtimepack.Microsoft.NETCore.App.Runtime.", StringComparison.Ordinal)
+                        && library.Value.TryGetProperty("runtime", out var runtime))
+                        foreach (var asset in runtime.EnumerateObject())
+                            if (asset.Name.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
+                                names.Add(Path.GetFileNameWithoutExtension(asset.Name));
+        }
+        if (names.Count != 0) return names;
+
+        return ((string?)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") ?? "")
+            .Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries)
+            .Where(path => Path.GetDirectoryName(path) == Path.GetDirectoryName(typeof(object).Assembly.Location))
+            .Select(path => Path.GetFileNameWithoutExtension(path)).ToHashSet(StringComparer.OrdinalIgnoreCase);
+    }
+
+    private ProjectContractSource(string directoryPath) => DirectoryPath = directoryPath;
+    public string DirectoryPath { get; }
+
+    public static string RequireApplication(string executable)
+    {
+        var path = Path.GetFullPath(executable.Trim());
+        if (!File.Exists(path) || !string.Equals(Path.GetExtension(path), ".exe", StringComparison.OrdinalIgnoreCase))
+            throw new EditorOperationException("project.applicationInvalid", "Select an existing game application EXE.");
+        return path;
+    }
+
+    public static string FindForApplication(string executable)
+    {
+        var root = Path.GetDirectoryName(RequireApplication(executable))!;
+        var candidates = new[] { root, Path.Combine(root, "lib") }
+            .Where(directory => File.Exists(Path.Combine(directory, ProjectSchemaContext.AssemblyFileName))).ToArray();
+        return candidates.Length switch
+        {
+            1 => candidates[0],
+            0 => throw new EditorOperationException("project.applicationContractMissing", "No project contract was found beside the application or in lib. Select a contract directory manually."),
+            _ => throw new EditorOperationException("project.applicationContractAmbiguous", "Multiple project contracts were found. Select a contract directory manually.")
+        };
+    }
+
+    public static ProjectContractSource Prepare(string sourceDirectory)
+    {
+        var reader = new ProjectRawReader(sourceDirectory);
+        var files = new Dictionary<string, byte[]>(StringComparer.OrdinalIgnoreCase);
+        ReadAssembly(ProjectSchemaContext.AssemblyFileName);
+        var snapshot = new ProjectContractSource(Path.Combine(Path.GetTempPath(), "GalNet-contracts-" + Guid.NewGuid().ToString("N")));
+        try
+        {
+            Directory.CreateDirectory(snapshot.DirectoryPath);
+            foreach (var (name, bytes) in files) File.WriteAllBytes(Path.Combine(snapshot.DirectoryPath, name), bytes);
+            using var validated = ProjectSchemaContext.LoadContractsDirectory(snapshot.DirectoryPath);
+            return snapshot;
+        }
+        catch
+        {
+            snapshot.Dispose();
+            throw;
+        }
+
+        void ReadAssembly(string fileName)
+        {
+            if (fileName != Path.GetFileName(fileName))
+                throw new InvalidDataException($"Invalid contract dependency name '{fileName}'.");
+            if (files.ContainsKey(fileName)) return;
+            var bytes = File.ReadAllBytes(reader.Resolve(fileName));
+            files.Add(fileName, bytes);
+            using var stream = new MemoryStream(bytes, writable: false);
+            using var pe = new PEReader(stream);
+            var metadata = pe.GetMetadataReader();
+            foreach (var handle in metadata.AssemblyReferences)
+            {
+                var name = metadata.GetString(metadata.GetAssemblyReference(handle).Name);
+                if (!PlatformAssemblyNames.Contains(name)) ReadAssembly(name + ".dll");
+            }
+        }
+    }
+
+    public void Dispose()
+    {
+        if (Directory.Exists(DirectoryPath)) Directory.Delete(DirectoryPath, recursive: true);
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectDebugPreparation.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectDebugPreparation.cs
new file mode 100644
index 00000000..395f13e6
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectDebugPreparation.cs
@@ -0,0 +1,52 @@
+using System.Diagnostics;
+using GalNet.Core.Entry;
+using GalNet.Debugging;
+using GalNet.Editor.Abstraction.Services;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Prepares compiled content and its matching source maps without depending on a panel or workspace.</summary>
+public sealed class ProjectDebugPreparation(IProjectService projects, IEntryCatalog catalog, ProjectSchemaSession schemas,
+    ExternalGameDebugClient client) : IDisposable
+{
+    private readonly CancellationTokenSource _lifetime = new();
+    private bool _disposed;
+
+    public async Task<ProjectContentBuildResult> PrepareAsync(Action<string>? reportStage = null)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        var token = _lifetime.Token;
+        await client.DisconnectAsync();
+        var project = projects.Current ?? throw new InvalidOperationException("No project.");
+        client.BeginDiagnostics(Path.Combine(project.RootPath, ".galnet", "debug-profile"));
+        var timer = Stopwatch.StartNew();
+        reportStage?.Invoke("Debug.SavingProject");
+        client.RecordDiagnostic("Saving project changes before building test content.");
+        await projects.SaveAsync();
+        RequireCurrent();
+        client.RecordDiagnostic($"Project save completed in {timer.ElapsedMilliseconds} ms.");
+        timer.Restart();
+        reportStage?.Invoke("Debug.BuildingContent");
+        var output = Path.Combine(project.RootPath, "Output", "Debug");
+        client.RecordDiagnostic($"Building test content at {output}.");
+        var result = await Task.Run(() => new ProjectContentBuilder(catalog, configurations: project.Configurations).BuildAsync(project.RootPath, output, token), token);
+        RequireCurrent();
+        client.RecordDiagnostic($"Test content and author source map built in {timer.ElapsedMilliseconds} ms for {result.CompiledGroupCount} Group(s).");
+        client.Listen(new(project.Id, DebugContentIdentity.Compute(result.OutputPath), schemas.Context.Fingerprint));
+        return result;
+
+        void RequireCurrent()
+        {
+            token.ThrowIfCancellationRequested();
+            if (!ReferenceEquals(projects.Current, project)) throw new OperationCanceledException("The debug project was closed.");
+        }
+    }
+
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _disposed = true;
+        _lifetime.Cancel();
+        _lifetime.Dispose();
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectDraftRegistry.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectDraftRegistry.cs
new file mode 100644
index 00000000..0044da0a
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectDraftRegistry.cs
@@ -0,0 +1,36 @@
+using GalNet.Editor.Abstraction.Services;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Project-owned input participants, independent of publication locks and saved baselines.</summary>
+internal sealed class ProjectDraftRegistry
+{
+    private readonly List<Registration> _items = [];
+    public bool HasChanges => _items.Any(item => item.HasChanges());
+    public Registration[] Pending => _items.Where(item => item.HasChanges()).ToArray();
+
+    public IDisposable Register(Func<bool> hasChanges, Func<Task> commit, Action? discard = null,
+        string? fileId = null, Action? validate = null, Func<ProjectDraftCommitContext, Task>? contextualCommit = null)
+    {
+        var registration = new Registration(_items, hasChanges, commit, fileId, validate, discard, contextualCommit);
+        _items.Add(registration);
+        return registration;
+    }
+    public async Task CommitAsync(ProjectDraftCommitContext context = default)
+    {
+        foreach (var item in _items.ToArray())
+            if (item.HasChanges()) await (item.ContextualCommit?.Invoke(context) ?? item.Commit());
+    }
+    public async Task CommitFileAsync(string fileId)
+    {
+        var pending = _items.Where(item => item.FileId == fileId && item.HasChanges()).ToArray();
+        foreach (var item in pending) item.Validate?.Invoke();
+        foreach (var item in pending) await item.Commit();
+    }
+    public void Clear() => _items.Clear();
+    internal sealed record Registration(List<Registration> Owner, Func<bool> HasChanges, Func<Task> Commit,
+        string? FileId, Action? Validate, Action? Discard, Func<ProjectDraftCommitContext, Task>? ContextualCommit) : IDisposable
+    {
+        public void Dispose() => Owner.Remove(this);
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectFileOperation.Variants.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectFileOperation.Variants.cs
index 06e72107..37114c80 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectFileOperation.Variants.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectFileOperation.Variants.cs
@@ -2,12 +2,14 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using GalNet.Assets.Variants;
+using GalNet.Editor.Abstraction.Documents;
 
 namespace GalNet.Editor.Shared.Services;
 
 public sealed partial class ProjectFileOperation
 {
     private readonly List<(string From, string To)> _variantCopies = [];
+    private readonly HashSet<string> _variantDescriptors = new(ProjectFilePaths.Comparer);
 
     private (Dictionary<string, string> Files, HashSet<string> Directories) AssetSnapshot()
     {
@@ -31,12 +33,14 @@ private void PrepareVariantRelations()
         foreach (var pair in snapshot.Files.Where(pair => IsVariants(pair.Key, snapshot.Files)).ToArray())
         {
             var destination = pair.Key;
+            _variantDescriptors.Add(destination);
             var origin = destination;
             (string From, string To)? copied = null;
             foreach (var move in _moves.Where(move => !move.From.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)))
                 if (ProjectFilePaths.Within(destination, move.To)) { origin = move.From + destination[move.To.Length..]; break; }
             foreach (var copy in _variantCopies)
                 if (ProjectFilePaths.Within(destination, copy.To)) { origin = copy.From + destination[copy.To.Length..]; copied = copy; break; }
+            _variantDescriptors.Add(origin);
             var bytes = File.ReadAllBytes(pair.Value);
             var source = ImageVariantsCodec.ReadSource(bytes);
             var oldFolder = "Assets/" + LocalAssetCompiler.ResolveFolder(origin[7..], source.Folder);
@@ -44,7 +48,7 @@ private void PrepareVariantRelations()
             var newFolder = Map(oldFolder, true);
             if (copied is { } relation && ProjectFilePaths.Within(oldFolder, relation.From))
                 newFolder = relation.To + oldFolder[relation.From.Length..];
-            if (ProjectFilePaths.Comparer.Equals(origin, destination) && ProjectFilePaths.Comparer.Equals(oldFolder, newFolder)) continue;
+            if (origin == destination && oldFolder == newFolder) continue;
             var parent = Path.GetDirectoryName(_reader.Resolve(destination))!;
             var relative = Path.GetRelativePath(parent, _reader.Resolve(newFolder)).Replace('\\', '/');
             var json = JsonNode.Parse(bytes)!.AsObject();
@@ -57,6 +61,19 @@ private void PrepareVariantRelations()
         }
     }
 
+    private void RebaseVariantBuffer(EditorFileDocument file, bool forward)
+    {
+        if (!_variantDescriptors.Contains(file.Path)) return;
+        var source = ImageVariantsCodec.ReadSource(file.Data);
+        var folder = ("Assets/" + LocalAssetCompiler.ResolveFolder(file.Path[7..], source.Folder)).TrimEnd('/');
+        var destination = Map(file.Path, forward);
+        var mappedFolder = Map(folder, forward);
+        if (file.Path == destination && folder == mappedFolder) return;
+        var json = JsonNode.Parse(file.Data)!.AsObject();
+        json["folder"] = Path.GetRelativePath(Path.GetDirectoryName(_reader.Resolve(destination))!, _reader.Resolve(mappedFolder)).Replace('\\', '/');
+        file.Data = Encoding.UTF8.GetBytes(json.ToJsonString(new JsonSerializerOptions { WriteIndented = true }));
+    }
+
     private bool IsVariants(string path, IReadOnlyDictionary<string, string> files)
     {
         if (path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)) return false;
@@ -66,7 +83,7 @@ private bool IsVariants(string path, IReadOnlyDictionary<string, string> files)
     }
 
     private void ValidateVariants(IReadOnlyDictionary<string, Snapshot> current, IReadOnlyDictionary<string, Snapshot> desired,
-        IReadOnlyCollection<string> currentDirectories, IReadOnlyCollection<string> desiredDirectories)
+        IReadOnlyCollection<string> currentDirectories, IReadOnlyCollection<string> desiredDirectories, EditorProjectDocument document)
     {
         if (!current.Keys.Concat(desired.Keys).Any(path => path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))) return;
         var snapshot = AssetSnapshot();
@@ -77,6 +94,19 @@ private void ValidateVariants(IReadOnlyDictionary<string, Snapshot> current, IRe
         snapshot.Directories.UnionWith(desiredDirectories.Where(path => path == "Assets" || path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase)));
         var files = snapshot.Files.ToDictionary(pair => pair.Key[7..], pair => pair.Value, StringComparer.OrdinalIgnoreCase);
         var directories = snapshot.Directories.Select(path => path == "Assets" ? "" : path[7..]).ToArray();
-        _ = LocalAssetCompiler.CompileAsync(files, directories, _types).GetAwaiter().GetResult();
+        var temporary = new List<string>();
+        try
+        {
+            foreach (var file in document.Files.Values.Where(file => file.ManagedContent && file.Exists
+                && file.Path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase) && IsVariants(file.Path, snapshot.Files)))
+            {
+                var path = Path.Combine(_retained, "validate-" + Guid.NewGuid().ToString("N"));
+                temporary.Add(path);
+                File.WriteAllBytes(path, file.Data);
+                files[file.Path[7..]] = path;
+            }
+            _ = LocalAssetCompiler.CompileAsync(files, directories, _types).GetAwaiter().GetResult();
+        }
+        finally { foreach (var path in temporary) File.Delete(path); }
     }
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectFileOperation.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectFileOperation.cs
index 535ab3cc..3d7393c1 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectFileOperation.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectFileOperation.cs
@@ -1,5 +1,7 @@
 using System.Globalization;
 using System.Text.Json;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
 using GalNet.Editor.Abstraction.Changes;
@@ -128,15 +130,14 @@ await publish((working, saved) =>
                 var expected = current.Keys.Where(path => ProjectFilePaths.Within(path, root)).ToHashSet(ProjectFilePaths.Comparer);
                 if (!actual.SetEquals(expected)) throw ProjectFilePaths.Error("changed", root);
             }
-            ValidateVariants(current, desired, currentDirectories, desiredDirectories);
             var files = new ProjectFilePlan();
             foreach (var pair in current.Where(pair => !_managed.Contains(pair.Key))) files.ExpectedHashes[pair.Key] = pair.Value.Hash;
             foreach (var path in desired.Keys.Where(path => !current.Keys.Contains(path, ProjectFilePaths.Comparer))) files.ExpectedHashes[path] = null;
             if (_caseOnly)
             {
                 foreach (var (from, to) in _moves) files.CaseRenames.Add(forward ? new(from, to) : new(to, from));
-                foreach (var pair in desired.Where(pair => pair.Key.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)
-                    || !current.TryGetValue(pair.Key, out var old) || old.Hash != pair.Value.Hash)) files.Writes[pair.Key] = File.ReadAllBytes(pair.Value.Backup);
+                foreach (var pair in desired.Where(pair => !_managed.Contains(pair.Key) && (pair.Key.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)
+                    || !current.TryGetValue(pair.Key, out var old) || old.Hash != pair.Value.Hash))) files.Writes[pair.Key] = File.ReadAllBytes(pair.Value.Backup);
             }
             else
             {
@@ -149,7 +150,15 @@ await publish((working, saved) =>
             {
                 removedWorking = CaptureRemoved(working); removedSaved = CaptureRemoved(saved);
             }
-            return new FileChange(this, forward, files, removedWorking ?? _removedWorking, removedSaved ?? _removedSaved);
+            var change = new FileChange(this, forward, files, removedWorking ?? _removedWorking, removedSaved ?? _removedSaved);
+            if (current.Keys.Concat(desired.Keys).Any(path => path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase)))
+                foreach (var (document, version) in new[] { (working, AuthorDocumentVersion.Working), (saved, AuthorDocumentVersion.Saved) })
+                {
+                    var next = Clone(document);
+                    change.Apply(next, version);
+                    ValidateVariants(current, desired, currentDirectories, desiredDirectories, next);
+                }
+            return change;
         });
         if (removedWorking is not null) { _removedWorking = removedWorking; _removedSaved = removedSaved; _removedBytes = JsonSerializer.SerializeToUtf8Bytes(new[] { removedWorking, removedSaved }).LongLength; }
     }
@@ -285,12 +294,12 @@ private IReadOnlyList<ProjectFileReference> FindReferences(EditorProjectDocument
                 foreach (var parameter in entry.Parameters)
                 {
                     var schema = _catalog.Definitions.FirstOrDefault(item => item.Type == entry.Type);
-                    var editor = schema?.DynamicParameters?.GetValueOrDefault(parameter.Key)?.Editor?.EditorId;
+                    var editor = schema?.DynamicParameters.GetValueOrDefault(parameter.Key)?.Editor?.EditorId;
                     foreach (var text in Strings(parameter.Value))
                         if (values.Any(value => text.Contains(value, StringComparison.OrdinalIgnoreCase))) references.Add(new("group/" + pair.Key + "/entry/" + entry.StableId, parameter.Key, values.Contains(text) && editor?.Contains("asset", StringComparison.OrdinalIgnoreCase) == true));
                 }
         }
-        if (Strings(JsonSerializer.SerializeToElement(document.Settings)).Any(text => values.Any(value => text.Contains(value, StringComparison.OrdinalIgnoreCase))))
+        if (Strings(JsonSerializer.SerializeToElement(document.Configuration)).Any(text => values.Any(value => text.Contains(value, StringComparison.OrdinalIgnoreCase))))
             references.Add(new("settings.json", "custom", false));
         foreach (var file in document.Files.Values.Where(file => file.Exists && file.ManagedContent && !_roots.Any(root => ProjectFilePaths.Within(file.Path, root))))
         {
@@ -327,26 +336,27 @@ private void AddMetadata(string destination, string? original, bool newId)
         }
         else
         {
-            var type = _types.TryGetByExtension(Path.GetExtension(destination), out var registration) ? registration : _types.Get("data");
+            var type = _types.TryGetByExtension(Path.GetExtension(destination), out var registration) ? registration : _types.Get(_types.DefaultTypeId ?? throw new InvalidDataException("No default resource type was selected."));
             meta = (AssetMeta)Activator.CreateInstance(type.MetaDtoType)!; meta.TypeId = type.TypeId; meta.Id = Guid.NewGuid().ToString("N");
         }
         if (newId) meta.Id = Guid.NewGuid().ToString("N");
-        if (newId && meta.Gallery is { Count: > 0 })
+        var annotations = meta.ReadGallery();
+        if (newId && annotations.Count > 0)
         {
             if (_galleryIds is null)
             {
                 _galleryIds = [];
                 if (Directory.Exists(_reader.Resolve("Assets")))
                     foreach (var path in Enumerate(_reader.Resolve("Assets")).Files.Where(path => path.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)))
-                        foreach (var item in _codec.Deserialize(File.ReadAllText(path), _reader.Relative(path)[7..^5]).Gallery ?? []) _galleryIds.Add(item.Id);
+                        foreach (var item in _codec.Deserialize(File.ReadAllText(path), _reader.Relative(path)[7..^5]).ReadGallery()) _galleryIds.Add(item.Id);
             }
-            meta.Gallery = meta.Gallery.Select(item =>
+            meta.SetGallery(annotations.Select(item =>
             {
                 if (item.Id <= 0) throw ProjectFilePaths.Error("galleryId", destination);
                 if (_galleryIds.Add(item.Id)) return item;
                 var id = 1; while (_galleryIds.Contains(id)) id = checked(id + 1);
                 _galleryIds.Add(id); return item with { Id = id };
-            }).ToList();
+            }));
         }
         meta.Path = destination[7..];
         if (_request.Action == ProjectFileAction.Metadata) { if (meta is SpriteAssetMeta sprite && _request.Filter is not null) sprite.Filter = _request.Filter; if (_request.Compression is not null) meta.Compress = _request.Compression; }
@@ -400,6 +410,7 @@ public void Apply(EditorProjectDocument document, AuthorDocumentVersion version)
             var removed = version == AuthorDocumentVersion.Working ? Working : Saved;
             foreach (var file in document.Files.Values)
             {
+                if (Owner.Action == ProjectFileAction.Move && file.Exists && file.ManagedContent) Owner.RebaseVariantBuffer(file, Forward);
                 if (Owner.Action == ProjectFileAction.Move) file.Path = Owner.Map(file.Path, Forward);
                 if (Owner.Action == ProjectFileAction.Delete && Owner._roots.Any(root => ProjectFilePaths.Within(file.Path, root)))
                 {
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectLocalizationQuery.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectLocalizationQuery.cs
index 1ce00b07..cb2f0bcc 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectLocalizationQuery.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectLocalizationQuery.cs
@@ -7,11 +7,14 @@ namespace GalNet.Editor.Shared.Services;
 
 /// <summary>Project-scoped localization snapshots, including untracked disk sources and unsaved managed files.</summary>
 public sealed class ProjectLocalizationQuery(IProjectContentSession content, IEditorDocumentService documents,
-    IEntryCatalog catalog, IProjectService projects) : IDisposable
+    IEntryCatalog catalog, IProjectService projects, IEntryParameterMetadataSource? parameterMetadata) : IDisposable
 {
+    public ProjectLocalizationQuery(IProjectContentSession content, IEditorDocumentService documents, IEntryCatalog catalog, IProjectService projects)
+        : this(content, documents, catalog, projects, null) { }
     private bool _disposed;
     private string? _snapshot;
     private LocalizationReferenceIndex? _index;
+    private long _metadataRevision = -1;
     public long Revision { get; private set; }
 
     public LocalizationReferenceIndex? Get()
@@ -60,9 +63,11 @@ public sealed class ProjectLocalizationQuery(IProjectContentSession content, IEd
                 !diagnostic.File.StartsWith("I18n/External", StringComparison.OrdinalIgnoreCase))
             .Select(diagnostic => new LocalizationIssue("source.enumeration", diagnostic.File ?? "I18n", diagnostic.JsonPointer ?? "", diagnostic.Message)));
         var snapshot = JsonSerializer.Serialize(new { Document = document, Sources = sources.Values.OrderBy(source => source.Path, StringComparer.Ordinal), Issues = issues });
-        if (snapshot != _snapshot)
+        if (snapshot != _snapshot || _metadataRevision != (parameterMetadata?.Revision ?? 0))
         {
-            _index = new(document, catalog, sources.Values, issues);
+            var metadata = parameterMetadata?.Capture(document) ?? new EntryParameterMetadata();
+            _index = new(document, catalog, sources.Values, issues, metadata);
+            _metadataRevision = metadata.Revision ?? parameterMetadata?.Revision ?? 0;
             _snapshot = snapshot; Revision++;
         }
         return _index;
@@ -73,7 +78,7 @@ private static bool IsSource(string path) => path.StartsWith("I18n/", StringComp
     private void Clear()
     {
         if (_snapshot is not null) Revision++;
-        _snapshot = null; _index = null;
+        _snapshot = null; _index = null; _metadataRevision = -1;
     }
     public void Dispose()
     {
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectRawReader.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectRawReader.cs
index 66aea480..da2bb77b 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectRawReader.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectRawReader.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GalNet.Assets;
 using GalNet.Editor.Abstraction.Commands;
 
 namespace GalNet.Editor.Shared.Services;
@@ -14,9 +15,7 @@ public ProjectRawReader(string projectDirectory)
     {
         Root = Path.TrimEndingDirectorySeparator(Path.GetFullPath(projectDirectory));
         if (!Directory.Exists(Root)) throw new DirectoryNotFoundException($"Project directory not found: '{Root}'.");
-        for (var directory = new DirectoryInfo(Root); directory is not null; directory = directory.Parent)
-            if (directory.Exists && (directory.Attributes & FileAttributes.ReparsePoint) != 0)
-                throw new InvalidDataException("Project root must not traverse a directory link.");
+        FileSystemPaths.RequireNoLinks(Root, "Project root must not traverse a directory link.");
     }
 
     public string Root { get; }
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectSchemaContext.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectSchemaContext.cs
index 0791968a..e9bd2488 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectSchemaContext.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectSchemaContext.cs
@@ -2,6 +2,7 @@
 using System.Runtime.Loader;
 using System.Security.Cryptography;
 using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
 
 namespace GalNet.Editor.Shared.Services;
@@ -17,14 +18,16 @@ public sealed class ProjectSchemaContext : IDisposable
     private SchemaLoadContext? _loadContext;
     private IEntryCatalog? _catalog;
 
-    private ProjectSchemaContext(string assemblyPath, string fingerprint, SchemaLoadContext context, IEntryCatalog catalog)
+    private ProjectSchemaContext(string assemblyPath, string fingerprint, SchemaLoadContext context, IEntryCatalog catalog, ProjectConfigurationSchema configurations)
     {
         AssemblyPath = assemblyPath;
         Fingerprint = fingerprint;
         _loadContext = context;
         _catalog = catalog;
+        Configurations = configurations;
     }
 
+    public ProjectConfigurationSchema Configurations { get; private set; }
     public string AssemblyPath { get; }
     public string Fingerprint { get; }
     public IEntryCatalog Catalog => _catalog ?? throw new ObjectDisposedException(nameof(ProjectSchemaContext));
@@ -67,7 +70,17 @@ public static ProjectSchemaContext LoadContractsDirectory(string contractsDirect
                 if (module is null || string.IsNullOrWhiteSpace(module.Id))
                     throw new InvalidDataException($"Null or empty schema module ID '{module?.Id}'.");
             }
-            return new ProjectSchemaContext(path, fingerprint, context, new TargetProfileEntryCatalog(modules));
+            var configurationProperty = type.GetProperty("Configurations", BindingFlags.Public | BindingFlags.Static);
+            var configurations = ProjectConfigurationSchema.Empty;
+            if (configurationProperty is not null)
+            {
+                if (configurationProperty.PropertyType != typeof(ProjectConfigurationSchema) ||
+                    configurationProperty.GetMethod is not { IsPublic: true, IsStatic: true } || configurationProperty.GetIndexParameters().Length != 0 ||
+                    configurationProperty.GetValue(null) is not ProjectConfigurationSchema declared)
+                    throw new InvalidDataException("ProjectSchemas.Configurations must return a nonnull ProjectConfigurationSchema.");
+                configurations = declared;
+            }
+            return new ProjectSchemaContext(path, fingerprint, context, new TargetProfileEntryCatalog(modules), configurations);
         }
         catch (Exception exception)
         {
@@ -79,6 +92,7 @@ public static ProjectSchemaContext LoadContractsDirectory(string contractsDirect
     public void Dispose()
     {
         _catalog = null;
+        Configurations = ProjectConfigurationSchema.Empty;
         var context = Interlocked.Exchange(ref _loadContext, null);
         context?.Unload();
     }
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectSchemaQueryService.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectSchemaQueryService.cs
index 78d5f2a0..aef79a58 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectSchemaQueryService.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectSchemaQueryService.cs
@@ -21,7 +21,7 @@ public static ToolResult Describe(ProjectSchemaContext context, string? type = n
             diagnostics.Add(new("object.notFound", "error", $"Entry schema '{type}' is not declared by this project.", context.AssemblyPath, type));
         var descriptions = definitions.Select(definition =>
         {
-            var parameters = definition.DynamicParameters?.Values.Select(parameter =>
+            var parameters = definition.DynamicParameters.Values.Select(parameter =>
             {
                 JsonElement? valueSchema = null;
                 try { valueSchema = ValueCodec.Describe(parameter.Value); }
@@ -29,7 +29,7 @@ public static ToolResult Describe(ProjectSchemaContext context, string? type = n
                 { diagnostics.Add(new("schema.descriptionLimited", "warning", $"Cannot fully describe '{definition.Type}.{parameter.Name}': {exception.Message}", context.AssemblyPath, definition.Type)); }
                 return new SchemaParameterDescription(parameter.Name, parameter.IsRequired, parameter.DefaultValue, parameter.Constraints,
                     valueSchema, valueSchema is not null, parameter.Editor, parameter.Field.Semantic.ToString());
-            }).ToArray() ?? [];
+            }).ToArray();
             return new SchemaEntryDescription(definition.Type, definition.Category, definition.Kind.ToString().ToLowerInvariant(), definition.IsReading, parameters,
                 "Schema descriptions do not serialize custom C# validators or Composite expansion code; full validation/compilation uses the DLL.");
         }).ToArray();
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectService.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectService.cs
index 25260e3b..44e9a78c 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectService.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectService.cs
@@ -4,9 +4,10 @@
 using System.Linq;
 using System.Text.Json;
 using System.Threading.Tasks;
-using GalNet.Core.Settings;
+using GalNet.Core.Configuration;
 using GalNet.Editor.Abstraction.Project;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Abstraction.Settings;
 using Microsoft.Extensions.DependencyInjection;
 using Serilog;
 
@@ -51,15 +52,16 @@ public async Task<GalProject> OpenAsync(string projectPath)
         Commands.ProjectAuthorFileTransaction.Recover(projectPath);
 
         var scope = _globalServices.CreateScope();
-        ProjectSettings settings;
+        ProjectConfiguration settings;
         EditorProjectState editorState;
         string name;
         try
         {
             scope.ServiceProvider.GetRequiredService<ProjectSchemaSession>().Open(projectPath);
             settings = Commands.DirectProjectPersistence.LoadSettings(projectPath);
+            scope.ServiceProvider.GetRequiredService<ProjectSchemaSession>().Context.Configurations.Validate(settings);
             editorState = await LoadEditorProjectStateAsync(projectPath);
-            var loaded = scope.ServiceProvider.GetRequiredService<IEditorDocumentRepository>().Load(projectPath, "", settings);
+            var loaded = scope.ServiceProvider.GetRequiredService<IEditorDocumentRepository>().Load(projectPath);
             if (loaded.Document.Nodes.Count(node => node.Type == "Entry") != 1 ||
                 !loaded.Document.Nodes.Any(node => node.Type == "Entry" && node.Id == loaded.Document.RootNodeId))
                 throw new InvalidDataException("The editor graph requires one explicit Entry root node.");
@@ -70,8 +72,10 @@ public async Task<GalProject> OpenAsync(string projectPath)
 
         var id = Path.GetFileName(projectPath);
 
-        var program = new GalProject(id, name, projectPath, settings, editorState, scope);
-        scope.ServiceProvider.GetService<IProjectContentSession>()?.Open(program);
+        var program = new GalProject(id, name, projectPath, settings, editorState, scope,
+            scope.ServiceProvider.GetRequiredService<ProjectSchemaSession>().Context.Configurations);
+        try { scope.ServiceProvider.GetService<IProjectContentSession>()?.Open(program); }
+        catch { await program.DisposeAsync(); throw; }
 
         _current = program;
 
@@ -95,7 +99,7 @@ public async Task<GalProject> OpenAsync(string projectPath)
         return program;
     }
 
-    public async Task<GalProject> CreateAsync(string projectPath, string name, ProjectSettings settings, string contractsDirectory)
+    public async Task<GalProject> CreateAsync(string projectPath, string name, ProjectConfiguration settings, string contractsDirectory)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(contractsDirectory);
         if (_current is not null) await CloseAsync();
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ProjectValidationService.cs b/src/Editor/GalNet.Editor.Shared/Services/ProjectValidationService.cs
index 18a01f57..eda43735 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/ProjectValidationService.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/ProjectValidationService.cs
@@ -1,6 +1,8 @@
 using System.Text.Json;
+using GalNet.Contracts.Builtins.Assets;
 using GalNet.Core.Assets;
 using GalNet.Core.Compilation;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
 using GalNet.Core.Serialization;
 using GalNet.Core.Variable;
@@ -15,10 +17,11 @@ public sealed class ProjectValidationService(string projectDirectory, string gra
 {
     private readonly string GraphFile = graphFile.Replace('\\', '/');
     private readonly ProjectRawReader _reader = new(projectDirectory);
+    private readonly GalNet.Editor.Shared.Visuals.VisualPresetResourceValidator _visuals = new(projectDirectory);
     private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);
 
     public ToolResult Validate(string scope = "project", GroupSelector? selector = null, bool structureOnly = false,
-        IEntryCatalog? catalog = null, string? contractSha256 = null)
+        IEntryCatalog? catalog = null, string? contractSha256 = null, ProjectConfigurationSchema? configurations = null)
     {
         if (scope is not ("project" or "graph" or "group")) throw new ArgumentException("Unknown validation scope.");
         _ = _reader.Resolve(GraphFile);
@@ -66,10 +69,20 @@ public ToolResult Validate(string scope = "project", GroupSelector? selector = n
         {
             if (!structureOnly && scope != "graph" && catalog is null)
             {
-                try { context = ProjectSchemaContext.Load(_reader.Root); catalog = context.Catalog; contractSha256 = context.Fingerprint; }
+                try { context = ProjectSchemaContext.Load(_reader.Root); catalog = context.Catalog; contractSha256 = context.Fingerprint; configurations = context.Configurations; }
                 catch (Exception exception) when (exception is IOException or InvalidDataException or UnauthorizedAccessException)
                 { Error(diagnostics, "contract.load", exception.Message, "Contracts/" + ProjectSchemaContext.AssemblyFileName, ""); }
             }
+            if (scope == "project")
+            {
+                try
+                {
+                    var configuration = DirectProjectPersistence.LoadSettings(_reader.Root);
+                    if (!structureOnly) configurations?.Validate(configuration);
+                }
+                catch (Exception error) when (error is IOException or JsonException or InvalidDataException or ArgumentException)
+                { Error(diagnostics, "configuration.invalid", error.Message, "settings.json", ""); }
+            }
             foreach (var file in groups.Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal))
             {
                 files.Add(file);
@@ -91,7 +104,9 @@ public ToolResult Validate(string scope = "project", GroupSelector? selector = n
         if (scope == "project") checks.AddRange(["settings-json", "metadata-guid-and-adjacent-file", "image-variants"]);
         if (!structureOnly) checks.Add("condition-syntax");
         if (!structureOnly && scope != "graph" && catalog is not null) checks.AddRange(["entry-parameters-and-contract-validator", "composite-compilation"]);
-        var skipped = new List<string> { "runtime-expression-evaluation", "custom-code-references", "asset-payloads", "settings-semantics" };
+        var skipped = new List<string> { "runtime-expression-evaluation", "custom-code-references", "asset-payloads" };
+        if (scope == "project" && !structureOnly && configurations is not null) checks.Add("configuration-schema");
+        else skipped.Add("configuration-schema");
         if (!structureOnly && scope == "project" && catalog is not null) checks.Add("localization-semantics");
         else skipped.Add("localization-semantics");
         if (structureOnly) skipped.AddRange(["condition-syntax", "entry-contracts", "graph-source-references"]);
@@ -103,13 +118,35 @@ public ToolResult Validate(string scope = "project", GroupSelector? selector = n
 
     /// <summary>Checks a selected source and returns a DTO only after its raw structure is accepted.</summary>
     public GroupDocument? ValidateGroup(string file, IList<ToolDiagnostic> diagnostics, IEntryCatalog? catalog = null, bool structureOnly = false)
+        => ValidateGroup(file, diagnostics, out _, catalog, structureOnly);
+
+    internal GroupDocument? ValidateGroup(string file, IList<ToolDiagnostic> diagnostics, out CompiledGroupResult? compilation,
+        IEntryCatalog? catalog = null, bool structureOnly = false)
     {
+        compilation = null;
         var content = _reader.Read(file, diagnostics);
-        return content is null ? null : ValidateGroupDocument(content.Value, file, diagnostics, catalog, structureOnly);
+        var document = content is null ? null : ValidateGroupDocument(content.Value, file, diagnostics, out compilation, catalog, structureOnly);
+        if (document is null || structureOnly || catalog is null) return document;
+        foreach (var entry in document.Entries)
+        {
+            try { _visuals.Validate(entry.Type, entry.Parameters); }
+            catch (Exception error) when (error is IOException or InvalidDataException or JsonException or ArgumentException or InvalidOperationException)
+            {
+                Error(diagnostics, "visual.programInvalid", error.Message, file, "/entries/" + document.Entries.IndexOf(entry) + "/parameters", entry.Id);
+                compilation = null;
+                return null;
+            }
+        }
+        return document;
     }
 
     public static GroupDocument? ValidateGroupDocument(JsonElement raw, string file, IList<ToolDiagnostic> diagnostics, IEntryCatalog? catalog = null, bool structureOnly = false)
+        => ValidateGroupDocument(raw, file, diagnostics, out _, catalog, structureOnly);
+
+    private static GroupDocument? ValidateGroupDocument(JsonElement raw, string file, IList<ToolDiagnostic> diagnostics,
+        out CompiledGroupResult? compilation, IEntryCatalog? catalog, bool structureOnly)
     {
+        compilation = null;
         var start = diagnostics.Count;
         if (!Shape(raw, file, "", diagnostics, ["version", "kind", "entries"])) return null;
         DuplicateProperties(raw, file, "", diagnostics);
@@ -131,20 +168,17 @@ public ToolResult Validate(string scope = "project", GroupSelector? selector = n
             var type = ProjectRawReader.Text(entry, "type");
             if (type is null || !catalog.TryGet(type, out var definition))
             { Error(diagnostics, "entry.typeUnknown", $"Entry '{type}' is not declared by the project contract.", file, pointer + "/type", ProjectRawReader.Text(entry, "id")); continue; }
-            try
-            {
-                if (definition.DynamicParameters is null) throw new InvalidDataException($"Entry '{type}' has no parameter contract.");
-                _ = PrimitiveArgumentHelper.Normalize(definition.DynamicParameters, parameters);
-            }
-            catch (Exception exception)
-            { Error(diagnostics, "entry.parametersInvalid", exception.Message, file, pointer + "/parameters", ProjectRawReader.Text(entry, "id")); }
         }
         if (diagnostics.Skip(start).Any(item => item.Severity == "error")) return null;
         var document = JsonSerializer.Deserialize<GroupDocument>(raw, JsonOptions)!;
         if (!structureOnly && catalog is not null)
-            foreach (var (entry, index) in document.Entries.Select((entry, index) => (entry, index)))
-                try { _ = GalgroupCompiler.Compile(new GroupDocument { Entries = [entry] }, catalog); }
-                catch (Exception exception) { Error(diagnostics, "entry.compileInvalid", exception.Message, file, $"/entries/{index}", entry.Id); }
+        {
+            var analysis = GalgroupCompiler.Analyze(document, catalog);
+            compilation = analysis.Compilation;
+            foreach (var issue in analysis.Issues)
+                Error(diagnostics, issue.IsParameterError ? "entry.parametersInvalid" : "entry.compileInvalid", issue.Message, file,
+                    $"/entries/{issue.SourceIndex}" + (issue.IsParameterError ? "/parameters" : ""), document.Entries[issue.SourceIndex].Id);
+        }
         return diagnostics.Skip(start).Any(item => item.Severity == "error") ? null : document;
     }
 
@@ -167,10 +201,10 @@ public void ValidateGraph(JsonElement? content, List<ToolDiagnostic> diagnostics
         for (var i = 0; i < nodes.Count; i++)
         {
             var node = nodes[i]; var pointer = $"/nodes/{i}";
-            if (!Shape(node, GraphFile, pointer, diagnostics, ["id", "type", "name", "x", "y", "file", "branchType", "options", "conditions"])) continue;
+            if (!Shape(node, GraphFile, pointer, diagnostics, ["id", "type", "name", "x", "y", "file", "storyPackage", "branchType", "options", "conditions"])) continue;
             Identity(node, "id", nodeIds, GraphFile, pointer, diagnostics);
             String(node, "name", GraphFile, pointer, diagnostics, required: true);
-            foreach (var key in new[] { "file", "branchType" })
+            foreach (var key in new[] { "file", "storyPackage", "branchType" })
                 if (node.TryGetProperty(key, out var optional) && optional.ValueKind != JsonValueKind.Null)
                     String(node, key, GraphFile, pointer, diagnostics);
             foreach (var key in new[] { "x", "y" })
@@ -257,8 +291,6 @@ public void ValidateGraph(JsonElement? content, List<ToolDiagnostic> diagnostics
         foreach (var (edge, index) in document.Edges.Select((edge, index) => (edge, index)))
         {
             if (!occupied.Add((edge.FromNodeId, edge.FromOutlet))) Error(diagnostics, "graph.outletDuplicate", "An outlet can have only one outgoing edge.", GraphFile, $"/edges/{index}", edge.Id);
-            if (edge.FromNodeId == edge.ToNodeId) Error(diagnostics, "graph.edge.selfConnection", "A node cannot connect to itself.", GraphFile, $"/edges/{index}", edge.Id);
-            if (document.Nodes.Any(node => node.Id == edge.ToNodeId && node.Type == "Entry")) Error(diagnostics, "graph.edge.entryInput", "Entry nodes cannot have incoming edges.", GraphFile, $"/edges/{index}", edge.Id);
         }
         foreach (var diagnostic in EditorDocumentValidator.Validate(new EditorProjectDocument { Graph = document }).Diagnostics)
         {
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ResourceOverrideExporter.cs b/src/Editor/GalNet.Editor.Shared/Services/ResourceOverrideExporter.cs
new file mode 100644
index 00000000..4638e80f
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/ResourceOverrideExporter.cs
@@ -0,0 +1,68 @@
+using GalNet.Assets;
+using GalNet.Assets.Provider;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Exports an independent resource PAK without compiling story or requiring a base export.</summary>
+public static class ResourceOverrideExporter
+{
+    public static async Task ExportAsync(string projectId, string projectRoot, ResourceOverrideDefinition definition,
+        string targetPath, IResourceTypeCatalog types, CancellationToken ct = default, Action? snapshotCaptured = null)
+    {
+        // Capture author edits before the first await. The caller may continue editing its own definition.
+        var captured = new ResourceOverrideDefinition
+        {
+            Id = definition.Id,
+            Name = definition.Name,
+            Priority = definition.Priority,
+            Mappings = new(definition.Mappings, StringComparer.OrdinalIgnoreCase),
+            IncludeResources = [.. definition.IncludeResources],
+            DeclaredCompleteResources = [.. definition.DeclaredCompleteResources]
+        };
+        var source = Path.GetFullPath(Path.Combine(projectRoot, "Assets"));
+        var target = Path.GetFullPath(targetPath);
+        if (!target.EndsWith(".pak", StringComparison.OrdinalIgnoreCase)) throw new ArgumentException("Resource patch output must end in .pak.", nameof(targetPath));
+        if (FileSystemPaths.IsSameOrChild(target, source)) throw new InvalidOperationException("Patch output cannot be inside author Assets.");
+        FileSystemPaths.RequireNoLinks(source, "Resource snapshot source cannot traverse links.");
+        Directory.CreateDirectory(Path.GetDirectoryName(target)!);
+        var stage = Path.Combine(Path.GetDirectoryName(target)!, ".override-" + Guid.NewGuid().ToString("N"));
+        var temporary = target + ".tmp-" + Guid.NewGuid().ToString("N");
+        try
+        {
+            Directory.CreateDirectory(stage);
+            // Reject links and copy the complete author resource tree to a private compilation snapshot.
+            Copy(source, stage, ct);
+            snapshotCaptured?.Invoke();
+            using var provider = new LocalFileProvider(stage, types);
+            using var archive = await provider.OpenArchiveAsync("assets", ct);
+            var files = archive.AssetIds.Select(id => archive.GetAsset(id)!).ToArray();
+            var bytes = ResourceOverrideBuilder.Build(projectId, captured, files, types, ct);
+            await File.WriteAllBytesAsync(temporary, bytes, ct);
+            using (var verified = Archive.Deserialize("assets", await File.ReadAllBytesAsync(temporary, ct), types))
+                foreach (var id in verified.AssetIds) _ = verified.GetAsset(id)!.ReadAllBytes();
+            ct.ThrowIfCancellationRequested();
+            File.Move(temporary, target, overwrite: true);
+        }
+        finally
+        {
+            if (File.Exists(temporary)) File.Delete(temporary);
+            if (Directory.Exists(stage)) Directory.Delete(stage, true);
+        }
+    }
+
+    private static void Copy(string source, string destination, CancellationToken ct)
+    {
+        ct.ThrowIfCancellationRequested();
+        if ((File.GetAttributes(source) & FileAttributes.ReparsePoint) != 0) throw new InvalidDataException("Resource snapshots cannot contain links.");
+        Directory.CreateDirectory(destination);
+        foreach (var path in Directory.EnumerateFileSystemEntries(source).Order(StringComparer.Ordinal))
+        {
+            ct.ThrowIfCancellationRequested();
+            if ((File.GetAttributes(path) & FileAttributes.ReparsePoint) != 0) throw new InvalidDataException("Resource snapshots cannot contain links.");
+            var target = Path.Combine(destination, Path.GetFileName(path));
+            if (Directory.Exists(path)) Copy(path, target, ct); else File.Copy(path, target);
+        }
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/ResourceReferenceIndex.cs b/src/Editor/GalNet.Editor.Shared/Services/ResourceReferenceIndex.cs
new file mode 100644
index 00000000..f42cc72e
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/ResourceReferenceIndex.cs
@@ -0,0 +1,82 @@
+using System.Text.Json;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+using GalNet.Core.Entry;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Services;
+
+public sealed record ResourceUse(string GroupId, string EntryId, string FieldPath, string? Through = null);
+public sealed record ResourceReferenceRow(string Id, string Path, string TypeId, bool Missing, IReadOnlyList<ResourceUse> Uses);
+
+/// <summary>Author snapshot resource references across every Group, plus declared/indirect resources.</summary>
+public sealed class ResourceReferenceIndex
+{
+    public IReadOnlyList<ResourceReferenceRow> Rows { get; }
+    public IReadOnlyList<string> Issues { get; }
+    public ResourceReferenceIndex(EditorProjectDocument document, IEntryCatalog catalog, IReadOnlyList<IGameFile> files, EntryParameterMetadata metadata)
+    {
+        var resources = files.ToDictionary(file => file.Id, StringComparer.OrdinalIgnoreCase);
+        var references = new Dictionary<string, (string? Type, List<ResourceUse> Uses)>(StringComparer.OrdinalIgnoreCase);
+        var issues = new HashSet<string>(StringComparer.Ordinal);
+        var provider = new EntryParameterStructures(document, metadata, catalog);
+        using var structures = new ValueStructureResolver();
+        foreach (var (groupId, entries) in document.GroupEntries)
+            foreach (var entry in entries)
+            {
+                if (!catalog.TryGet(entry.Type, out var definition)) { issues.Add(groupId + "/" + entry.StableId + ": schema unavailable"); continue; }
+                foreach (var field in definition.DynamicParameters.Fields)
+                {
+                    var value = entry.Parameters.GetValueOrDefault(field.Id);
+                    var effective = value.ValueKind == JsonValueKind.Undefined ? field.DefaultValue : value;
+                    if (effective is null) continue;
+                    using var tree = new ValueDocument(provider.Describe(field, groupId, entry), effective, structures, provider, new EntryStructureContext(groupId, entry));
+                    foreach (var property in tree.GetIterator(new(32, 100_000, IncludeMissing: true)))
+                    {
+                        var actual = property.Value ?? property.Field.DefaultValue;
+                        if (actual is null || Empty(actual.Value)) continue;
+                        if (property.Issue is not null) { issues.Add(groupId + "/" + entry.StableId + "/" + field.Id + ": " + property.Issue.Message); continue; }
+                        if (property.Field.ResourceTypeId is not { } type || actual.Value.ValueKind != JsonValueKind.String) continue;
+                        Add(actual.Value.GetString()!, type == "*" ? null : type, new(groupId, entry.StableId, "/" + field.Id + property.Path.ToLogicalPointer()), []);
+                    }
+                }
+            }
+        var overrides = document.Configuration.Read(ResourceOverrideOptions.Section);
+        foreach (var mapping in overrides.Packages.SelectMany(package => package.Mappings))
+            if (!resources.ContainsKey(mapping.Value)) issues.Add("Missing replacement resource: " + mapping.Value);
+        foreach (var id in document.Configuration.Read(ContentPackagingOptions.Section).IncludeResources
+                     .Concat(overrides.AdditionalOriginals).Concat(overrides.Packages.SelectMany(package => package.Mappings.Keys)))
+            Add(id, null, new("", "", "explicit"), []);
+        Rows = references.OrderBy(pair => resources.GetValueOrDefault(pair.Key)?.Path ?? pair.Key, StringComparer.OrdinalIgnoreCase)
+            .Select(pair => new ResourceReferenceRow(pair.Key, resources.GetValueOrDefault(pair.Key)?.Path ?? pair.Key,
+                resources.GetValueOrDefault(pair.Key)?.TypeId ?? pair.Value.Type ?? "", !resources.ContainsKey(pair.Key), pair.Value.Uses.Distinct().ToArray())).ToArray();
+        Issues = issues.Order(StringComparer.Ordinal).ToArray();
+
+        void Add(string id, string? type, ResourceUse use, HashSet<string> visited)
+        {
+            id = id.Trim(); if (id.Length == 0) return;
+            var file = resources.GetValueOrDefault(id);
+            id = file?.Id ?? id;
+            if (!visited.Add(id)) return;
+            if (file?.TypeId is "graph" or "group") return;
+            if (!references.TryGetValue(id, out var row)) references.Add(id, row = (type, []));
+            row.Uses.Add(use);
+            if (file is null) { issues.Add("Missing resource: " + id); return; }
+            if (type is not null && file.TypeId != type) issues.Add("Resource type mismatch: " + id);
+            if (file.Metadata is not IAssetDependencies dependencies) return;
+            var information = dependencies.GetDependencies();
+            if (!information.Complete) issues.Add("Incomplete resource dependencies: " + id);
+            foreach (var dependency in information.Direct)
+                Add(dependency.AssetId, dependency.ExpectedTypeId, use with { Through = id }, new(visited, StringComparer.OrdinalIgnoreCase));
+        }
+    }
+    private static bool Empty(JsonElement value) => value.ValueKind switch
+    {
+        JsonValueKind.Null or JsonValueKind.Undefined => true,
+        JsonValueKind.String => string.IsNullOrWhiteSpace(value.GetString()),
+        JsonValueKind.Object => !value.EnumerateObject().Any(),
+        JsonValueKind.Array => value.GetArrayLength() == 0,
+        _ => false
+    };
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneAuthoringIdentities.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneAuthoringIdentities.cs
index 8f122fa7..b977e3fb 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/SceneAuthoringIdentities.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneAuthoringIdentities.cs
@@ -1,81 +1,60 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
-using GalNet.Contracts.Builtins;
 using GalNet.Editor.Abstraction.Documents;
 
 namespace GalNet.Editor.Shared.Services;
 
-/// <summary>Explicit built-in identity slots. Never replaces unrelated author strings.</summary>
+/// <summary>Identity allocation and copying consume the same declarations as reference analysis.</summary>
 public static class SceneAuthoringIdentities
 {
     public static Dictionary<string, JsonElement> NewEntry(string type, Dictionary<string, JsonElement> parameters)
     {
-        if (CreationSlot(type) is { } slot) parameters[slot] = JsonSerializer.SerializeToElement(Guid.NewGuid().ToString("N"));
-        if (HasPlaybackSlot(type)) parameters["playbackHandleId"] = JsonSerializer.SerializeToElement(Guid.NewGuid().ToString("N"));
+        foreach (var output in SceneAuthoringSemantics.Find(type)?.Outputs ?? [])
+            WriteOutput(parameters, output, JsonSerializer.SerializeToElement(Guid.NewGuid().ToString("N")));
         return parameters;
     }
-    public static string? CreationSlot(string type) => type switch
+    public static string? CreationSlot(string type) => SceneAuthoringSemantics.Find(type)?.Outputs.FirstOrDefault(slot => slot.Container is null && slot.Domain == SceneIdentityDomain.Object)?.Field;
+    public static bool IsOutput(string type, string field) => SceneAuthoringSemantics.Find(type)?.Outputs.Any(slot => slot.Container is null && slot.Field == field) == true;
+    public static Dictionary<string, JsonElement> ChangeType(string previousType, IReadOnlyDictionary<string, JsonElement> previous, string type, Dictionary<string, JsonElement> parameters)
     {
-        BuiltinEntryIds.ShowLayer or BuiltinEntryIds.ShowColorLayer or BuiltinEntryIds.PlayVideo or BuiltinEntryIds.ShowVariants => "handleId",
-        BuiltinEntryIds.PlayParticleEmitter or BuiltinEntryIds.ApplyEffect => "instanceId",
-        BuiltinEntryIds.CrossFadeTransition or BuiltinEntryIds.BlindsTransition => "newHandleId",
-        BuiltinEntryIds.SlideTransition or BuiltinEntryIds.BlackFadeTransition or BuiltinEntryIds.WhiteFadeTransition or BuiltinEntryIds.ColorFadeTransition => "toLayerHandleId",
-        _ => null
-    };
-    private static bool HasPlaybackSlot(string type) => type is BuiltinEntryIds.Animate
-        or BuiltinEntryIds.CrossFadeTransition or BuiltinEntryIds.BlindsTransition or BuiltinEntryIds.SlideTransition
-        or BuiltinEntryIds.BlackFadeTransition or BuiltinEntryIds.WhiteFadeTransition or BuiltinEntryIds.ColorFadeTransition;
-    public static bool IsOutput(string type, string field) => CreationSlot(type) == field || field == "playbackHandleId" && HasPlaybackSlot(type);
-    public static void RemapCopy(IReadOnlyList<EditorEntryData> entries)
-    {
-        var roots = entries.Select(entry => (Entry: entry, Parameters: JsonSerializer.SerializeToNode(entry.Parameters)!.AsObject())).ToArray();
-        var replacements = new Dictionary<string, string>(StringComparer.Ordinal);
-        void Allocate(JsonObject obj, string slot)
-        {
-            if (obj[slot] is JsonValue value && value.TryGetValue<string>(out var id) && !string.IsNullOrWhiteSpace(id)) replacements.TryAdd(id, Guid.NewGuid().ToString("N"));
-        }
-        void Discover(string type, JsonObject parameters)
-        {
-            if (CreationSlot(type) is { } slot) Allocate(parameters, slot);
-            if (HasPlaybackSlot(type)) Allocate(parameters, "playbackHandleId");
-            if (type != BuiltinEntryIds.PlayTimeline || parameters["timeline"] is not JsonObject timeline) return;
-            foreach (var (key, _) in timeline.ToArray()) if (key.Equals("playbackHandleId", StringComparison.OrdinalIgnoreCase)) Allocate(timeline, key);
-            foreach (var (key, node) in timeline) if (key.Equals("events", StringComparison.OrdinalIgnoreCase) && node is JsonArray events)
-                foreach (var item in events.OfType<JsonObject>()) if (item.FirstOrDefault(pair => pair.Key.Equals("type", StringComparison.OrdinalIgnoreCase)).Value is JsonValue eventType && eventType.TryGetValue<string>(out var eventId)
-                    && item.FirstOrDefault(pair => pair.Key.Equals("parameters", StringComparison.OrdinalIgnoreCase)).Value is JsonObject eventParameters) Discover(eventId, eventParameters);
-        }
-        void Replace(JsonObject obj, string slot)
-        {
-            if (obj[slot] is JsonValue value && value.TryGetValue<string>(out var id) && replacements.TryGetValue(id, out var replacement)) obj[slot] = replacement;
-        }
-        void Rewrite(string type, JsonObject parameters)
+        NewEntry(type, parameters);
+        var oldOutputs = SceneAuthoringSemantics.Find(previousType)?.Outputs ?? [];
+        foreach (var output in SceneAuthoringSemantics.Find(type)?.Outputs ?? [])
         {
-            if (CreationSlot(type) is { } slot) Replace(parameters, slot);
-            if (HasPlaybackSlot(type)) Replace(parameters, "playbackHandleId");
-            foreach (var field in ReferenceSlots(type)) Replace(parameters, field);
-            if (type != BuiltinEntryIds.PlayTimeline || parameters["timeline"] is not JsonObject timeline) return;
-            foreach (var (key, node) in timeline.ToArray())
-            {
-                if (key.Equals("playbackHandleId", StringComparison.OrdinalIgnoreCase)) Replace(timeline, key);
-                if (key.Equals("tracks", StringComparison.OrdinalIgnoreCase) && node is JsonArray tracks)
-                    foreach (var track in tracks.OfType<JsonObject>()) foreach (var field in track.Select(pair => pair.Key).Where(name => name.Equals("handleId", StringComparison.OrdinalIgnoreCase)).ToArray()) Replace(track, field);
-                if (key.Equals("events", StringComparison.OrdinalIgnoreCase) && node is JsonArray events)
-                    foreach (var item in events.OfType<JsonObject>()) if (item.FirstOrDefault(pair => pair.Key.Equals("type", StringComparison.OrdinalIgnoreCase)).Value is JsonValue eventType && eventType.TryGetValue<string>(out var eventId)
-                        && item.FirstOrDefault(pair => pair.Key.Equals("parameters", StringComparison.OrdinalIgnoreCase)).Value is JsonObject eventParameters) Rewrite(eventId, eventParameters);
-            }
+            var compatible = oldOutputs.SingleOrDefault(slot => slot.Role == output.Role && slot.Domain == output.Domain && slot.Kind == output.Kind);
+            var identity = compatible is null ? default : ReadOutput(previous, compatible);
+            if (identity.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(identity.GetString())) WriteOutput(parameters, output, identity.Clone());
         }
-        foreach (var root in roots) Discover(root.Entry.Type, root.Parameters);
-        foreach (var root in roots) { Rewrite(root.Entry.Type, root.Parameters); root.Entry.Parameters = root.Parameters.ToDictionary(pair => pair.Key, pair => JsonSerializer.SerializeToElement(pair.Value)); }
+        return parameters;
+    }
+    private static JsonElement ReadOutput(IReadOnlyDictionary<string, JsonElement> parameters, SceneOutputSlot slot)
+    {
+        if (slot.Container is null) return parameters.GetValueOrDefault(slot.Field);
+        if (!parameters.TryGetValue(slot.Container, out var container) || container.ValueKind != JsonValueKind.Object) return default;
+        var matches = container.EnumerateObject().Where(property => property.Name.Equals(slot.Field, StringComparison.OrdinalIgnoreCase)).ToArray();
+        return matches.Length == 1 ? matches[0].Value : default;
+    }
+    private static void WriteOutput(Dictionary<string, JsonElement> parameters, SceneOutputSlot slot, JsonElement identity)
+    {
+        if (slot.Container is null) { parameters[slot.Field] = identity; return; }
+        if (!parameters.TryGetValue(slot.Container, out var container) || container.ValueKind != JsonValueKind.Object) return;
+        var matches = container.EnumerateObject().Where(property => property.Name.Equals(slot.Field, StringComparison.OrdinalIgnoreCase)).ToArray();
+        if (matches.Length > 1) return;
+        var root = JsonNode.Parse(container.GetRawText())!.AsObject();
+        root[matches.Length == 0 ? slot.Field : matches[0].Name] = JsonNode.Parse(identity.GetRawText());
+        parameters[slot.Container] = JsonSerializer.SerializeToElement(root);
     }
-    private static IEnumerable<string> ReferenceSlots(string type) => type switch
+    public static void RemapCopy(IReadOnlyList<EditorEntryData> entries)
     {
-        BuiltinEntryIds.Animate => ["handleId"],
-        BuiltinEntryIds.CrossFadeTransition or BuiltinEntryIds.BlindsTransition => ["oldHandleId"],
-        BuiltinEntryIds.SlideTransition or BuiltinEntryIds.BlackFadeTransition or BuiltinEntryIds.WhiteFadeTransition or BuiltinEntryIds.ColorFadeTransition => ["fromLayerHandleId"],
-        BuiltinEntryIds.StopAnimation => ["playbackHandleId"],
-        BuiltinEntryIds.HideLayer or BuiltinEntryIds.MoveLayer or BuiltinEntryIds.ReplaceLayer or BuiltinEntryIds.StopVideo or BuiltinEntryIds.SelectVariants => ["handleId"],
-        BuiltinEntryIds.StopEffect or BuiltinEntryIds.StopParticleEmitter => ["instanceId"],
-        BuiltinEntryIds.ApplyEffect => ["targetHandleId"],
-        _ => []
-    };
+        var roots = entries.Select(entry => (Entry: entry, Parameters: JsonSerializer.SerializeToNode(entry.Parameters)!.AsObject())).ToArray();
+        var slots = new List<SceneIdentitySlot>();
+        foreach (var root in roots) SceneIdentityWalker.Walk(root.Entry.Type, root.Parameters, slots.Add, _ => { });
+        var replacements = new Dictionary<(SceneIdentityDomain Domain, string? Qualifier, string Handle), string>();
+        foreach (var slot in slots.Where(slot => slot.Output is not null))
+            if (!string.IsNullOrWhiteSpace(slot.Handle) && (slot.Domain != SceneIdentityDomain.AudioEffect || slot.Qualifier is not null))
+                replacements.TryAdd((slot.Domain, slot.Qualifier, slot.Handle), Guid.NewGuid().ToString("N"));
+        foreach (var slot in slots)
+            if (slot.Handle is { } handle && replacements.TryGetValue((slot.Domain, slot.Qualifier, handle), out var replacement)) slot.Owner[slot.Field] = replacement;
+        foreach (var root in roots) root.Entry.Parameters = root.Parameters.ToDictionary(pair => pair.Key, pair => JsonSerializer.SerializeToElement(pair.Value));
+    }
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneAuthoringSemantics.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneAuthoringSemantics.cs
new file mode 100644
index 00000000..ac8c68da
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneAuthoringSemantics.cs
@@ -0,0 +1,51 @@
+using GalNet.Contracts.Builtins;
+
+namespace GalNet.Editor.Shared.Services;
+
+public enum SceneIdentityDomain { Object, Playback, AudioEffect }
+public sealed record SceneOutputSlot(string Field, string Role, SceneIdentityDomain Domain, SceneTargetKind Kind, string? Container = null);
+public sealed record SceneReferenceSlot(string Field, SceneIdentityDomain Domain, IReadOnlyList<SceneTargetKind> Kinds, bool RequiresVariants = false, bool AllowsGlobal = false, string? Container = null);
+public sealed record SceneEntrySemantics(IReadOnlyList<SceneOutputSlot> Outputs, IReadOnlyList<SceneReferenceSlot> References, bool SceneNeutral = false, bool Timeline = false);
+
+/// <summary>Built-in author relationships, independent of value schemas and runtime execution.</summary>
+public static class SceneAuthoringSemantics
+{
+    private static readonly SceneEntrySemantics Neutral = new([], [], SceneNeutral: true);
+    private static readonly IReadOnlyDictionary<string, SceneEntrySemantics> Entries = Create();
+    public static SceneEntrySemantics? Find(string type) => Entries.GetValueOrDefault(type);
+    public static SceneReferenceSlot? Reference(string type, string field) => Find(type)?.References.FirstOrDefault(slot => slot.Field == field);
+
+    private static IReadOnlyDictionary<string, SceneEntrySemantics> Create()
+    {
+        var entries = new Dictionary<string, SceneEntrySemantics>(StringComparer.Ordinal);
+        SceneOutputSlot Output(string field, string role, SceneTargetKind kind) => new(field, role, kind == SceneTargetKind.Playback ? SceneIdentityDomain.Playback : SceneIdentityDomain.Object, kind);
+        SceneReferenceSlot Reference(string field, params SceneTargetKind[] kinds) => new(field, kinds.Contains(SceneTargetKind.Playback) ? SceneIdentityDomain.Playback : SceneIdentityDomain.Object, Array.AsReadOnly(kinds));
+        void Add(string type, SceneOutputSlot[] outputs, SceneReferenceSlot[] references, bool timeline = false) => entries.Add(type, new(Array.AsReadOnly(outputs), Array.AsReadOnly(references), Timeline: timeline));
+        foreach (var type in new[] { BuiltinEntryIds.ShowLayer, BuiltinEntryIds.ShowColorLayer, BuiltinEntryIds.PlayVideo, BuiltinEntryIds.ShowVariants })
+            Add(type, [Output("handleId", "primaryLayer", SceneTargetKind.Layer)], []);
+        Add(BuiltinEntryIds.PlayParticleEmitter, [Output("instanceId", "particle", SceneTargetKind.Particle)], []);
+        Add(BuiltinEntryIds.ApplyEffect, [Output("instanceId", "effect", SceneTargetKind.Effect)], [Reference("targetHandleId", SceneTargetKind.Layer) with { AllowsGlobal = true }]);
+        foreach (var type in new[] { BuiltinEntryIds.HideLayer, BuiltinEntryIds.MoveLayer, BuiltinEntryIds.ReplaceLayer, BuiltinEntryIds.StopVideo })
+            Add(type, [], [Reference("handleId", SceneTargetKind.Layer)]);
+        Add(BuiltinEntryIds.SelectVariants, [], [Reference("handleId", SceneTargetKind.Layer) with { RequiresVariants = true }]);
+        Add(BuiltinEntryIds.StopParticleEmitter, [], [Reference("instanceId", SceneTargetKind.Particle)]);
+        Add(BuiltinEntryIds.StopEffect, [], [Reference("instanceId", SceneTargetKind.Effect)]);
+        Add(BuiltinEntryIds.Animate, [Output("playbackHandleId", "playback", SceneTargetKind.Playback)], [Reference("handleId", SceneTargetKind.Layer, SceneTargetKind.Particle, SceneTargetKind.Effect)]);
+        Add(BuiltinEntryIds.StopAnimation, [], [Reference("playbackHandleId", SceneTargetKind.Playback)]);
+        Add(BuiltinEntryIds.MotionPreset, [Output("playbackHandleId", "playback", SceneTargetKind.Playback)], [Reference("handleId", SceneTargetKind.Layer)]);
+        Add(BuiltinEntryIds.ShakePreset, [Output("playbackHandleId", "playback", SceneTargetKind.Playback)], [Reference("handleId", SceneTargetKind.Layer)]);
+        Add(BuiltinEntryIds.ImpactPreset, [Output("playbackHandleId", "playback", SceneTargetKind.Playback)], [Reference("handleId", SceneTargetKind.Layer)]);
+        Add(BuiltinEntryIds.SpeedLinesPreset, [Output("playbackHandleId", "playback", SceneTargetKind.Playback)], []);
+        foreach (var type in new[] { BuiltinEntryIds.CrossFadeTransition, BuiltinEntryIds.BlindsTransition, BuiltinEntryIds.SlideTransition, BuiltinEntryIds.BlackFadeTransition, BuiltinEntryIds.WhiteFadeTransition, BuiltinEntryIds.ColorFadeTransition, BuiltinEntryIds.RevealTransition, BuiltinEntryIds.BlurTransition })
+        {
+            var cross = type is BuiltinEntryIds.CrossFadeTransition or BuiltinEntryIds.BlindsTransition or BuiltinEntryIds.RevealTransition or BuiltinEntryIds.BlurTransition;
+            Add(type, [Output(cross ? "newHandleId" : "toLayerHandleId", "primaryLayer", SceneTargetKind.Layer), Output("playbackHandleId", "playback", SceneTargetKind.Playback)], [Reference(cross ? "oldHandleId" : "fromLayerHandleId", SceneTargetKind.Layer)]);
+        }
+        Add(BuiltinEntryIds.PlayTimeline, [Output("playbackHandleId", "playback", SceneTargetKind.Playback) with { Container = "timeline" }], [], timeline: true);
+        entries.Add(BuiltinEntryIds.ApplyAudioSEffect, new([new("instanceId", "audioEffect", SceneIdentityDomain.AudioEffect, SceneTargetKind.AudioEffect)], [], SceneNeutral: true));
+        foreach (var type in new[] { BuiltinEntryIds.StopAudioSEffect, BuiltinEntryIds.UpdateAudioSEffect })
+            entries.Add(type, new([], [new("instanceId", SceneIdentityDomain.AudioEffect, [SceneTargetKind.AudioEffect])], SceneNeutral: true));
+        foreach (var type in new[] { BuiltinEntryIds.Text, BuiltinEntryIds.ShowDialogue, BuiltinEntryIds.HideDialogue, BuiltinEntryIds.ShowNvl, BuiltinEntryIds.HideNvl, BuiltinEntryIds.ClearNvl, BuiltinEntryIds.AppendNvl, BuiltinEntryIds.TextVoice, BuiltinEntryIds.AppendVoiceNvl, BuiltinEntryIds.Wait, BuiltinEntryIds.SetVariable, BuiltinEntryIds.UnlockGallery, BuiltinEntryIds.PlayAudio, BuiltinEntryIds.StopAudio, BuiltinEntryIds.PauseAudio, BuiltinEntryIds.ResumeAudio, BuiltinEntryIds.NextAudio, BuiltinEntryIds.ClearAudio, BuiltinEntryIds.EnqueueAudio, BuiltinEntryIds.SetAudioLevel, BuiltinEntryIds.BurstParticles }) entries.Add(type, Neutral);
+        return entries;
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneIdentityWalker.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneIdentityWalker.cs
new file mode 100644
index 00000000..216b4295
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneIdentityWalker.cs
@@ -0,0 +1,92 @@
+using System.Text.Json.Nodes;
+using GalNet.Contracts.Builtins;
+
+namespace GalNet.Editor.Shared.Services;
+
+internal sealed record SceneIdentitySlot(JsonObject Owner, string Field, string Pointer, SceneIdentityDomain Domain, SceneOutputSlot? Output, SceneReferenceSlot? Reference, SceneTimelinePosition? Position, string? EventId)
+{
+    public string? Handle => Owner[Field] is JsonValue value && value.TryGetValue<string>(out var text) ? text : null;
+    public string? Qualifier => Domain == SceneIdentityDomain.AudioEffect ? AudioAuthoringTarget.Qualifier(Owner) : null;
+    public string? RequiredProperty { get; init; }
+}
+internal sealed record SceneCoverageGap(string Pointer, string Code);
+
+/// <summary>Walks only declared slots; unknown JSON is preserved, never searched for matching strings.</summary>
+internal static class SceneIdentityWalker
+{
+    public static void Walk(string type, JsonObject parameters, Action<SceneIdentitySlot> slot, Action<SceneCoverageGap> gap,
+        string pointer = "/parameters", SceneTimelinePosition? position = null, string? eventId = null, int depth = 0, Action? step = null)
+    {
+        step?.Invoke();
+        if (depth > 8) { gap(new(pointer, "scene.analysis.limit")); return; }
+        var semantics = SceneAuthoringSemantics.Find(type);
+        if (semantics is null) { gap(new(pointer, "scene.coverage.unknown")); return; }
+        foreach (var output in semantics.Outputs.Where(output => output.Container is null)) Visit(parameters, output.Field, pointer, output.Domain, output, null, position, eventId, slot, gap);
+        foreach (var reference in semantics.References)
+        {
+            if (reference.Domain == SceneIdentityDomain.AudioEffect && parameters["all"] is JsonValue all && all.TryGetValue<bool>(out var stopAll) && stopAll) continue;
+            if (reference.Container is null) Visit(parameters, reference.Field, pointer, reference.Domain, null, reference, position, eventId, slot, gap);
+            else if (parameters[reference.Container] is JsonArray array)
+                for (var index = 0; index < array.Count; index++)
+                {
+                    step?.Invoke();
+                    var path = pointer + "/" + Escape(reference.Container) + "/" + index;
+                    if (array[index] is JsonObject item) Visit(item, reference.Field, path, reference.Domain, null, reference, position, eventId, slot, gap);
+                    else gap(new(path, "scene.coverage.structure"));
+                }
+            else gap(new(pointer + "/" + reference.Container, "scene.coverage.structure"));
+        }
+        if (!semantics.Timeline) return;
+        if (parameters["timeline"] is not JsonObject timeline) { gap(new(pointer + "/timeline", "scene.coverage.structure")); return; }
+        var root = pointer + "/timeline";
+        var playback = Key(timeline, "playbackHandleId", root, gap);
+        if (playback is not null) Visit(timeline, playback, root, SceneIdentityDomain.Playback, semantics.Outputs.Single(output => output.Container == "timeline") with { Field = playback }, null, position, eventId, slot, gap);
+        var tracks = Key(timeline, "tracks", root, gap);
+        if (tracks is not null && timeline[tracks] is JsonArray trackArray)
+            for (var index = 0; index < trackArray.Count; index++)
+            {
+                step?.Invoke();
+                var path = root + "/" + Escape(tracks) + "/" + index;
+                if (trackArray[index] is not JsonObject track) { gap(new(path, "scene.coverage.structure")); continue; }
+                var handle = Key(track, "handleId", path, gap);
+                var propertyKey = Key(track, "property", path, gap);
+                var property = propertyKey is not null && track[propertyKey] is JsonValue propertyValue && propertyValue.TryGetValue<string>(out var propertyText) ? propertyText : "";
+                if (handle is not null) Visit(track, handle, path, SceneIdentityDomain.Object, null, new(handle, SceneIdentityDomain.Object, [SceneTargetKind.Layer, SceneTargetKind.Particle, SceneTargetKind.Effect]), new(0), null, slot, gap, property);
+            }
+        else if (tracks is not null) gap(new(root + "/" + Escape(tracks), "scene.coverage.structure"));
+        var events = Key(timeline, "events", root, gap);
+        if (events is not null && timeline[events] is JsonArray eventArray)
+            for (var index = 0; index < eventArray.Count; index++)
+            {
+                step?.Invoke();
+                var path = root + "/" + Escape(events) + "/" + index;
+                if (eventArray[index] is not JsonObject item) { gap(new(path, "scene.coverage.structure")); continue; }
+                var typeKey = Key(item, "type", path, gap); var parametersKey = Key(item, "parameters", path, gap);
+                var frameKey = Key(item, "frame", path, gap); var idKey = Key(item, "editorId", path, gap);
+                var frame = frameKey is not null && item[frameKey] is JsonValue frameValue && frameValue.TryGetValue<int>(out var number) && number >= 0 ? number : (int?)null;
+                var id = idKey is not null && item[idKey] is JsonValue idValue && idValue.TryGetValue<string>(out var text) ? text : null;
+                if (typeKey is not null && item[typeKey] is JsonValue typeValue && typeValue.TryGetValue<string>(out var eventType) && parametersKey is not null && item[parametersKey] is JsonObject eventParameters)
+                {
+                    // Nested Timelines are not executable event semantics. Still discover their declared slots for copy/index.
+                    if (!TimelineEventCapabilities.Supports(eventType) || frame is null) gap(new(path, "scene.coverage.structure"));
+                    Walk(eventType, eventParameters, slot, gap, path + "/" + Escape(parametersKey), frame is { } f ? new(f, index) : new(-1), id, depth + 1, step);
+                }
+                else gap(new(path, "scene.coverage.structure"));
+            }
+        else if (events is not null) gap(new(root + "/" + Escape(events), "scene.coverage.structure"));
+    }
+    private static void Visit(JsonObject owner, string field, string pointer, SceneIdentityDomain domain, SceneOutputSlot? output, SceneReferenceSlot? reference, SceneTimelinePosition? position, string? eventId, Action<SceneIdentitySlot> slot, Action<SceneCoverageGap> gap, string? requiredProperty = null)
+    {
+        if (!owner.ContainsKey(field)) return;
+        var value = new SceneIdentitySlot(owner, field, pointer + "/" + Escape(field), domain, output, reference, position, eventId) { RequiredProperty = requiredProperty };
+        if (value.Handle is null) gap(new(value.Pointer, "scene.coverage.structure"));
+        slot(value);
+    }
+    private static string? Key(JsonObject owner, string name, string pointer, Action<SceneCoverageGap> gap)
+    {
+        var matches = owner.Select(pair => pair.Key).Where(key => key.Equals(name, StringComparison.OrdinalIgnoreCase)).ToArray();
+        if (matches.Length > 1) { gap(new(pointer + "/" + name, "scene.coverage.structure")); return null; }
+        return matches.FirstOrDefault();
+    }
+    private static string Escape(string text) => text.Replace("~", "~0", StringComparison.Ordinal).Replace("/", "~1", StringComparison.Ordinal);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneReferenceIndex.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneReferenceIndex.cs
new file mode 100644
index 00000000..a88fdd9d
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneReferenceIndex.cs
@@ -0,0 +1,133 @@
+using System.Text.Json;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Services;
+
+public sealed record SceneAuthorAddress(string GroupId, string EntryId);
+public sealed record SceneIdentityDefinition(SceneAuthorAddress Owner, string JsonPointer, string Handle, SceneOutputSlot Slot, string? EventId)
+{ public string? Qualifier { get; init; } }
+public sealed record SceneIdentityReference(SceneAuthorAddress Owner, string JsonPointer, string Handle, SceneReferenceSlot Slot, SceneTimelinePosition? Position, string? EventId)
+{
+    public string? Qualifier { get; init; }
+    public string? RequiredProperty { get; init; }
+}
+public sealed record SceneReferenceDiagnostic(string Code, SceneAuthorAddress Owner, string JsonPointer, string? Handle = null, IReadOnlyList<SceneIdentityDefinition>? Candidates = null, long? Revision = null);
+
+/// <summary>Syntactic relationships include unreachable and unopened Groups. They do not prove a unique creator.</summary>
+public sealed class SceneReferenceIndex
+{
+    public IReadOnlyList<SceneIdentityDefinition> Definitions { get; }
+    public IReadOnlyList<SceneIdentityReference> References { get; }
+    public IReadOnlyList<SceneReferenceDiagnostic> Coverage { get; }
+    public bool Complete => Coverage.Count == 0;
+    public SceneReferenceIndex(IReadOnlyDictionary<string, List<EditorEntryData>> groups)
+    {
+        var definitions = new List<SceneIdentityDefinition>(); var references = new List<SceneIdentityReference>(); var coverage = new List<SceneReferenceDiagnostic>();
+        var remaining = 10000;
+        foreach (var (groupId, entries) in groups)
+            foreach (var entry in entries)
+            {
+                var owner = new SceneAuthorAddress(groupId, entry.StableId);
+                if (--remaining < 0) { coverage.Add(new("scene.analysis.limit", owner, "/parameters")); goto Finished; }
+                var root = JsonSerializer.SerializeToNode(entry.Parameters)!.AsObject();
+                try
+                {
+                    SceneIdentityWalker.Walk(entry.Type, root, slot =>
+                {
+                    if (--remaining < 0) throw new IndexBudgetExceededException();
+                    if (string.IsNullOrWhiteSpace(slot.Handle)) return;
+                    if (slot.Output is { } output) definitions.Add(new(owner, slot.Pointer, slot.Handle, output, slot.EventId) { Qualifier = slot.Qualifier });
+                    if (slot.Reference is { } reference) references.Add(new(owner, slot.Pointer, slot.Handle, reference, slot.Position, slot.EventId) { Qualifier = slot.Qualifier, RequiredProperty = slot.RequiredProperty });
+                }, gap => { if (--remaining < 0) throw new IndexBudgetExceededException(); coverage.Add(new(gap.Code, owner, gap.Pointer)); }, step: () => { if (--remaining < 0) throw new IndexBudgetExceededException(); });
+                }
+                catch (IndexBudgetExceededException) { coverage.Add(new("scene.analysis.limit", owner, "/parameters")); goto Finished; }
+            }
+    Finished:
+        Definitions = definitions.AsReadOnly(); References = references.AsReadOnly(); Coverage = coverage.Distinct().ToArray();
+    }
+    public IReadOnlyList<SceneIdentityDefinition> Candidates(SceneIdentityReference reference) => Definitions.Where(definition =>
+        definition.Handle == reference.Handle && definition.Slot.Domain == reference.Slot.Domain && definition.Qualifier == reference.Qualifier && reference.Slot.Kinds.Contains(definition.Slot.Kind)).ToArray();
+    private sealed class IndexBudgetExceededException : Exception { }
+}
+
+public sealed record SceneReferenceState(string Code, bool Complete, bool Reachable, IReadOnlyList<SceneTarget> Targets)
+{ public IReadOnlyList<AudioEffectTarget> AudioEffects { get; init; } = []; }
+public sealed record SceneReferenceChange(SceneIdentityReference Reference, SceneReferenceState Before, SceneReferenceState After);
+public sealed record SceneEditImpact(IReadOnlyList<SceneReferenceChange> References, IReadOnlyList<string> ChangedGroups, IReadOnlyList<SceneReferenceDiagnostic> Coverage, bool Complete)
+{
+    public int ArchivedInputs { get; init; }
+    public bool RequiresReview => References.Count != 0 || ChangedGroups.Count != 0 || !Complete || ArchivedInputs != 0;
+}
+
+/// <summary>Position analysis and operation previews share one classifier. Missing targets remain author warnings.</summary>
+public static class SceneReferenceAnalysis
+{
+    public static SceneReferenceState Resolve(SceneIdentityReference reference, SceneTargetAnalysis analysis)
+    {
+        var result = reference.Position is { } position ? analysis.AtTimeline(reference.Owner.GroupId, reference.Owner.EntryId, position)
+            : analysis.Before(reference.Owner.GroupId, reference.Owner.EntryId);
+        if (reference.Slot.Domain == SceneIdentityDomain.AudioEffect)
+        {
+            var effects = result.AudioEffects.Where(effect => effect.Key.InstanceId == reference.Handle &&
+                JsonSerializer.Serialize(new[] { effect.Key.Scope == GalNet.Contracts.Builtins.Audio.SEffectScope.Bus ? "bus" : "track", effect.Key.TargetId }) == reference.Qualifier).ToArray();
+            var audioCode = !result.Reachable ? "scene.reference.unreachable" : effects.Length == 0
+                ? result.AudioComplete ? "scene.reference.missing" : "scene.reference.uncertain"
+                : effects.Any(effect => effect.Presence == TargetPresence.Possible) ? "scene.reference.possible" : "scene.reference.resolved";
+            return new(audioCode, result.AudioComplete, result.Reachable, []) { AudioEffects = effects };
+        }
+        var candidates = (reference.Slot.Domain == SceneIdentityDomain.Playback ? result.Playbacks : result.Targets).Where(target => target.Handle == reference.Handle).ToArray();
+        var matching = candidates.Where(target => reference.Slot.Kinds.Contains(target.Kind) && (!reference.Slot.RequiresVariants || target.Variants is not null)).ToArray();
+        var code = !result.Reachable ? "scene.reference.unreachable" : matching.Length == 0
+            ? !result.Complete || candidates.Any(target => target.Kind == SceneTargetKind.Unresolved) ? "scene.reference.uncertain" : "scene.reference.missing"
+            : matching.Any(target => target.Presence == TargetPresence.Possible) ? "scene.reference.possible" : "scene.reference.resolved";
+        return new(code, result.Complete, result.Reachable, matching);
+    }
+    public static IReadOnlyList<SceneReferenceDiagnostic> Diagnose(SceneReferenceIndex index, SceneTargetAnalysis analysis)
+    {
+        var diagnostics = new List<SceneReferenceDiagnostic>(index.Coverage);
+        foreach (var reference in index.References)
+        {
+            var state = Resolve(reference, analysis);
+            var resolved = state.Code == "scene.reference.resolved";
+            // An unrelated metadata gap must not invalidate a fully described target.
+            var targetComplete = state.Targets.Count > 0 && state.Targets.All(target => target.CapabilitiesComplete
+                && (reference.RequiredProperty is null || target.Properties.Any(property => property.Name == reference.RequiredProperty)
+                    && target.Values.ContainsKey(reference.RequiredProperty)));
+            if (resolved && (state.Complete || targetComplete)) continue;
+            diagnostics.Add(new(resolved ? "scene.reference.uncertain" : state.Code,
+                reference.Owner, reference.JsonPointer, reference.Handle, index.Candidates(reference)));
+        }
+        return diagnostics.AsReadOnly();
+    }
+
+    public static SceneEditImpact Compare(EditorGraphDocument graph, IReadOnlyDictionary<string, List<EditorEntryData>> before, IReadOnlyDictionary<string, List<EditorEntryData>> after,
+        IReadOnlyDictionary<SceneAuthorAddress, SceneAuthorAddress>? originalOwners = null)
+    {
+        var oldIndex = new SceneReferenceIndex(before); var newIndex = new SceneReferenceIndex(after);
+        var oldAnalysis = new SceneTargetAnalysis(graph, before); var newAnalysis = new SceneTargetAnalysis(graph, after);
+        var changes = new List<SceneReferenceChange>(); var coverage = oldIndex.Coverage.Concat(newIndex.Coverage).Distinct().ToList();
+        var complete = oldIndex.Complete && newIndex.Complete;
+        var oldReferences = oldIndex.References.ToDictionary(reference => (reference.Owner, reference.JsonPointer));
+        // Remaining consumers only; references deleted in the same batch are intentionally excluded.
+        foreach (var reference in newIndex.References)
+        {
+            var original = originalOwners?.GetValueOrDefault(reference.Owner) ?? reference.Owner;
+            if (!oldReferences.TryGetValue((original, reference.JsonPointer), out var old)) continue;
+            var previous = Resolve(old, oldAnalysis); var next = Resolve(reference, newAnalysis);
+            complete &= (!previous.Reachable || previous.Complete) && (!next.Reachable || next.Complete);
+            if (Signature(previous) != Signature(next)) changes.Add(new(reference, previous, next));
+        }
+        var groups = new List<string>();
+        foreach (var group in after.Keys)
+        {
+            var previous = oldAnalysis.Before(group, null); var next = newAnalysis.Before(group, null);
+            // Unreachable groups are still indexed, but their execution state is not a proven effect.
+            if (!previous.Reachable && !next.Reachable) continue;
+            complete &= previous.Complete && next.Complete && previous.AudioComplete && next.AudioComplete;
+            if (ResultSignature(previous) != ResultSignature(next)) groups.Add(group);
+        }
+        return new(changes.AsReadOnly(), groups.AsReadOnly(), coverage.AsReadOnly(), complete);
+    }
+    private static string Signature(SceneReferenceState state) => JsonSerializer.Serialize(new { state.Code, state.Complete, state.Reachable, state.AudioEffects, Targets = state.Targets.OrderBy(target => target.Handle, StringComparer.Ordinal) });
+    private static string ResultSignature(SceneTargetResult result) => JsonSerializer.Serialize(new { result.Complete, result.Reachable, result.Targets, result.Playbacks, result.AudioComplete, result.AudioEffects });
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Audio.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Audio.cs
new file mode 100644
index 00000000..32e726ec
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Audio.cs
@@ -0,0 +1,69 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Services;
+
+public sealed partial class SceneTargetAnalysis
+{
+    private void TransferAudio(State state, string group, EditorEntryData entry)
+    {
+        if (entry.Type is not (BuiltinEntryIds.ApplyAudioSEffect or BuiltinEntryIds.StopAudioSEffect or BuiltinEntryIds.UpdateAudioSEffect))
+        {
+            if (SceneAuthoringSemantics.Find(entry.Type) is null) state.UncertainAudio();
+            return;
+        }
+        string Text(string key, string fallback = "") => entry.Parameters.TryGetValue(key, out var value)
+            && value.ValueKind != JsonValueKind.Null ? value.GetString() ?? fallback : fallback;
+        var scope = Text("scope", "track") switch { "track" => SEffectScope.Track, "bus" => SEffectScope.Bus, _ => throw new InvalidDataException("Invalid scope.") };
+        var targetId = Text("targetId");
+        if (string.IsNullOrWhiteSpace(targetId) || _audioConfiguration is not null && !_audioConfiguration.HasTarget(scope, targetId))
+            throw new InvalidDataException("Unknown audio target.");
+        var key = new AudioEffectKey(scope, targetId, Text("instanceId"));
+        if (entry.Type == BuiltinEntryIds.ApplyAudioSEffect)
+        {
+            if (string.IsNullOrWhiteSpace(key.InstanceId)) throw new InvalidDataException("An audio effect needs an instance identity.");
+            var type = Text("id");
+            var parameters = entry.Parameters.GetValueOrDefault("parameters", JsonSerializer.SerializeToElement(new { }));
+            var valid = _audioCatalog.Validate(type, scope, parameters).Count == 0;
+            // Unsupported metadata still has an author identity; stop can resolve and remove it.
+            state.AudioEffects[key] = new(key, valid ? TargetPresence.Definite : TargetPresence.Possible, [new(group, entry.StableId, "instanceId")], [type], valid);
+        }
+        else if (entry.Type == BuiltinEntryIds.StopAudioSEffect)
+        {
+            var all = entry.Parameters.TryGetValue("all", out var value) && value.GetBoolean();
+            if (all && key.InstanceId.Length != 0) throw new InvalidDataException("Conflicting stop selection.");
+            if (all)
+                foreach (var existing in state.AudioEffects.Keys.Where(existing => existing.Scope == scope && existing.TargetId == targetId).ToArray()) state.AudioEffects.Remove(existing);
+            else state.AudioEffects.Remove(key);
+        }
+        else if (entry.Parameters.TryGetValue("parameters", out var patch))
+        {
+            if (patch.ValueKind != JsonValueKind.Object) throw new InvalidDataException("Invalid effect patch.");
+            // Updates cannot create an absent instance or disambiguate its algorithm.
+            if (state.AudioEffects.TryGetValue(key, out var effect) && effect.Types.Count == 1 && _audioCatalog.TryGet(effect.Types[0], out var definition))
+            {
+                if (patch.EnumerateObject().Any(item => !definition.Parameters.Any(parameter => parameter.Name == item.Name)
+                    || GalNet.Core.Parameters.ValueValidation.Validate(definition.Parameters.Single(parameter => parameter.Name == item.Name).Field.Value, item.Value) is not null))
+                    state.AudioComplete = false;
+            }
+        }
+    }
+
+    private static void MergeAudio(Dictionary<AudioEffectKey, AudioEffectTarget> result, IReadOnlyList<Dictionary<AudioEffectKey, AudioEffectTarget>> domains)
+    {
+        foreach (var key in domains.SelectMany(domain => domain.Keys).Distinct())
+        {
+            var candidates = domains.Where(domain => domain.ContainsKey(key)).Select(domain => domain[key]).ToArray();
+            result[key] = new(key, candidates.Length == domains.Count && candidates.All(effect => effect.Presence == TargetPresence.Definite) ? TargetPresence.Definite : TargetPresence.Possible,
+                candidates.SelectMany(effect => effect.Sources).Distinct().OrderBy(source => source.GroupId, StringComparer.Ordinal).ThenBy(source => source.EntryId, StringComparer.Ordinal).ToArray(),
+                candidates.SelectMany(effect => effect.Types).Distinct(StringComparer.OrdinalIgnoreCase).Order(StringComparer.OrdinalIgnoreCase).ToArray(), candidates.All(effect => effect.MetadataComplete));
+        }
+    }
+    private static bool EqualAudio(IReadOnlyDictionary<AudioEffectKey, AudioEffectTarget> left, IReadOnlyDictionary<AudioEffectKey, AudioEffectTarget> right) => left.Count == right.Count
+        && left.All(pair => right.TryGetValue(pair.Key, out var other) && pair.Value.Presence == other.Presence && pair.Value.MetadataComplete == other.MetadataComplete
+            && pair.Value.Types.SequenceEqual(other.Types) && pair.Value.Sources.SequenceEqual(other.Sources));
+    public static bool EquivalentAudio(SceneTargetResult left, SceneTargetResult right) => left.AudioComplete == right.AudioComplete && left.Reachable == right.Reachable
+        && EqualAudio(left.AudioEffects.ToDictionary(effect => effect.Key), right.AudioEffects.ToDictionary(effect => effect.Key));
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Cache.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Cache.cs
new file mode 100644
index 00000000..97bacadf
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Cache.cs
@@ -0,0 +1,58 @@
+using System.Text.Json;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Services;
+
+public sealed partial class SceneTargetAnalysis
+{
+    // Checkpoints belong to this immutable analysis only. A new generation never retains the old analysis.
+    private const int CheckpointLimit = 128;
+    private readonly Dictionary<(string Group, int Index), State> _checkpoints = [];
+    public int EntryTransferCount { get; private set; }
+    public int ReusedGroupCount { get; private set; }
+    public int CheckpointCount => _checkpoints.Count;
+
+    private State TransferGroup(State input, string group, List<EditorEntryData> entries, SceneTargetAnalysis? previous)
+    {
+        foreach (var key in _checkpoints.Keys.Where(key => key.Group == group).ToArray()) _checkpoints.Remove(key);
+        if (previous is { _budgetExceeded: false } && previous._inputs.TryGetValue(group, out var oldInput) && Equal(input, oldInput)
+            && previous._groups.TryGetValue(group, out var oldEntries))
+        {
+            var common = 0;
+            while (common < Math.Min(entries.Count, oldEntries.Count) && SameEntry(entries[common], oldEntries[common])) common++;
+            foreach (var pair in previous._checkpoints.Where(pair => pair.Key.Group == group && pair.Key.Index <= common)) Remember(pair.Key, pair.Value);
+            if (common == entries.Count && common == oldEntries.Count && previous._outputs.TryGetValue(group, out var output))
+            { ReusedGroupCount++; return output.Clone(); }
+        }
+        return Prefix(input, group, entries, entries.Count);
+    }
+
+    private State Prefix(State input, string group, List<EditorEntryData> entries, int end)
+    {
+        var start = _checkpoints.Keys.Where(key => key.Group == group && key.Index <= end).Select(key => key.Index).DefaultIfEmpty(0).Max();
+        var state = start == 0 ? input.Clone() : _checkpoints[(group, start)].Clone();
+        for (var index = start; index < end; index++)
+        {
+            state = Apply(state, group, entries[index]);
+            if ((index + 1) % 64 == 0) Remember((group, index + 1), state);
+        }
+        Remember((group, end), state);
+        return state.Clone();
+    }
+
+    private void Remember((string Group, int Index) key, State state)
+    {
+        if (key.Index == 0) return;
+        if (!_checkpoints.ContainsKey(key) && _checkpoints.Count >= CheckpointLimit) _checkpoints.Remove(_checkpoints.Keys.First());
+        _checkpoints[key] = state.Clone();
+    }
+
+    public static bool SameEntry(EditorEntryData? left, EditorEntryData? right) => ReferenceEquals(left, right)
+        || left is not null && right is not null
+        && left.StableId == right.StableId && left.Type == right.Type && left.Condition == right.Condition
+        && left.Parameters.Count == right.Parameters.Count && left.Parameters.All(pair => right.Parameters.TryGetValue(pair.Key, out var value) && JsonElement.DeepEquals(pair.Value, value));
+
+    public static bool Equivalent(SceneTargetResult left, SceneTargetResult right) => left.Complete == right.Complete && left.Reachable == right.Reachable
+        && EqualDomain(left.Targets.ToDictionary(target => target.Handle), right.Targets.ToDictionary(target => target.Handle))
+        && EqualDomain(left.Playbacks.ToDictionary(target => target.Handle), right.Playbacks.ToDictionary(target => target.Handle));
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Effects.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Effects.cs
index 19646e30..80747dd9 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Effects.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Effects.cs
@@ -1,5 +1,5 @@
 using System.Text.Json;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Editor.Abstraction.Documents;
 
 namespace GalNet.Editor.Shared.Services;
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Playbacks.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Playbacks.cs
index b03bd762..954f73ad 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Playbacks.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Playbacks.cs
@@ -1,6 +1,6 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Editor.Abstraction.Documents;
 
 namespace GalNet.Editor.Shared.Services;
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Timeline.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Timeline.cs
index ee3900e0..2c7cd922 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Timeline.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Timeline.cs
@@ -2,7 +2,7 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Editor.Abstraction.Documents;
 
 namespace GalNet.Editor.Shared.Services;
@@ -29,7 +29,7 @@ private static (TimelineDefinition Timeline, JsonElement Raw) ReadTimeline(Edito
             var ids = new HashSet<string>(StringComparer.Ordinal);
             foreach (var item in events.EnumerateArray())
             {
-                foreach (var name in new[] { "frame", "type", "parameters" }) _ = Member(item, name);
+                foreach (var name in new[] { "frame", "type", "parameters", "execution" }) _ = Member(item, name);
                 if (Member(item, "editorId") is { } identity && (identity.ValueKind != JsonValueKind.String || string.IsNullOrWhiteSpace(identity.GetString()) || !ids.Add(identity.GetString()!)))
                     throw new InvalidDataException("Ambiguous event identity.");
             }
@@ -38,7 +38,11 @@ private static (TimelineDefinition Timeline, JsonElement Raw) ReadTimeline(Edito
     }
     private static SceneTargetResult Result(State state) => new(state.Targets.Values.OrderBy(target => target.Locator.GroupId, StringComparer.Ordinal)
         .ThenBy(target => target.Locator.EntryId, StringComparer.Ordinal).ThenBy(target => target.CreatedAtFrame).ThenBy(target => target.Locator.EventId, StringComparer.Ordinal).ToArray(), state.Complete && state.Targets.Values.All(target => target.CapabilitiesComplete), true)
-    { Playbacks = state.Playbacks.Values.OrderBy(target => target.Locator.GroupId, StringComparer.Ordinal).ThenBy(target => target.Locator.EntryId, StringComparer.Ordinal).ToArray() };
+    {
+        AudioEffects = state.AudioEffects.Values.OrderBy(effect => effect.Key.Scope).ThenBy(effect => effect.Key.TargetId, StringComparer.Ordinal).ThenBy(effect => effect.Key.InstanceId, StringComparer.Ordinal).ToArray(),
+        AudioComplete = state.AudioComplete && state.AudioEffects.Values.All(effect => effect.MetadataComplete),
+        Playbacks = state.Playbacks.Values.OrderBy(target => target.Locator.GroupId, StringComparer.Ordinal).ThenBy(target => target.Locator.EntryId, StringComparer.Ordinal).ToArray()
+    };
     public SceneTargetResult AtTimeline(string groupId, string entryId, SceneTimelinePosition position)
     {
         var state = StateBefore(groupId, entryId);
@@ -56,10 +60,11 @@ public SceneTargetResult AtTimeline(string groupId, string entryId, SceneTimelin
         catch (Exception error) when (error is JsonException or InvalidOperationException or ArgumentException or InvalidDataException or OverflowException) { state.Uncertain(); }
         return Result(state);
     }
-    private void TransferTimeline(State state, string group, EditorEntryData entry)
+    private void TransferTimeline(State state, string group, EditorEntryData entry, bool requireValidExpansion = false)
     {
         var (timeline, raw) = ReadTimeline(entry); var before = state.Clone();
         EvaluateTimeline(state, group, entry, timeline, raw, new(timeline.DurationFrames), terminal: true);
+        if (requireValidExpansion && !state.Complete) throw new InvalidDataException("Incomplete transition expansion.");
         if (timeline.LoopMode == AnimationLoopMode.Once && (timeline.Blocking || timeline.DurationFrames == 0)) return;
         // Later story positions cannot assume concurrent or cyclic presentation has finished.
         var merged = Merge([before, state]);
@@ -75,6 +80,7 @@ private void TransferTimeline(State state, string group, EditorEntryData entry)
             }
             catch (Exception error) when (error is JsonException or InvalidOperationException or ArgumentException or InvalidDataException or OverflowException) { merged.Complete = false; }
         }
+        if (requireValidExpansion && !merged.Complete) throw new InvalidDataException("Incomplete transition expansion.");
         state.Targets.Clear(); foreach (var pair in merged.Targets) state.Targets.Add(pair.Key, pair.Value);
         state.Playbacks.Clear(); foreach (var pair in merged.Playbacks) state.Playbacks.Add(pair.Key, pair.Value);
         state.Uncertain();
@@ -84,7 +90,8 @@ private void EvaluateTimeline(State state, string group, EditorEntryData owner,
     {
         var ordered = timeline.Events.Select((item, index) => (Item: item, Index: index)).OrderBy(pair => pair.Item.Frame).ThenBy(pair => pair.Index).ToArray();
         var touched = new HashSet<string>(StringComparer.Ordinal);
-        foreach (var (item, index) in ordered.Where(pair => pair.Item.Frame < position.Frame || pair.Item.Frame == position.Frame && (position.BeforeEventIndex is null || pair.Index < position.BeforeEventIndex)))
+        foreach (var (item, index) in ordered.Where(pair => (terminal || pair.Item.Execution != TimelineEventExecution.OnCompletion) &&
+            (pair.Item.Frame < position.Frame || pair.Item.Frame == position.Frame && (position.BeforeEventIndex is null || pair.Index < position.BeforeEventIndex))))
         {
             try
             {
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Transitions.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Transitions.cs
index 70871894..a5989c5c 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Transitions.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Transitions.cs
@@ -21,7 +21,7 @@ private EditorEntryData TransitionTimeline(EditorEntryData entry)
         {
             Entries = [new() { Id = entry.StableId, Type = entry.Type,
                 // Unknown author extensions remain on the original document, not in the strict compiler input.
-                Parameters = entry.Parameters.Where(pair => definition.Parameters.ContainsKey(pair.Key)).ToDictionary(pair => pair.Key, pair => pair.Value.Clone()) }]
+                Parameters = entry.Parameters.Where(pair => definition.DynamicParameters.ContainsKey(pair.Key)).ToDictionary(pair => pair.Key, pair => pair.Value.Clone()) }]
         };
         var expanded = GalgroupCompiler.Compile(source, TransitionCatalog.Value).Document.Entries.Single();
         if (expanded.TypeId != BuiltinEntryIds.PlayTimeline) throw new InvalidDataException("Unsupported transition expansion.");
@@ -40,15 +40,18 @@ private void TransferTransition(State state, string group, EditorEntryData entry
         // Timeline queries recover from individual event errors. A composite must not publish only
         // the successful half of its expansion. Track local validity separately from upstream uncertainty.
         candidate.Complete = true;
-        TransferTimeline(candidate, group, TransitionTimeline(entry));
-        if (!candidate.Complete) throw new InvalidDataException("Incomplete transition expansion.");
-        var slot = SceneAuthoringIdentities.CreationSlot(entry.Type)!;
-        var handle = entry.Parameters[slot].GetString()!;
-        if (candidate.Targets.TryGetValue(handle, out var target) && target.Locator.GroupId == group && target.Locator.EntryId == entry.StableId)
+        TransferTimeline(candidate, group, TransitionTimeline(entry), requireValidExpansion: true);
+        foreach (var (id, playback) in candidate.Playbacks.ToArray())
+            if (playback.Locator.GroupId == group && playback.Locator.EntryId == entry.StableId)
+                candidate.Playbacks[id] = playback with { Locator = new(group, entry.StableId, "playbackHandleId"), Resource = entry.Type };
+        var slot = SceneAuthoringIdentities.CreationSlot(entry.Type);
+        var handle = slot is null ? null : entry.Parameters[slot].GetString();
+        if (slot is not null && handle is not null && candidate.Targets.TryGetValue(handle, out var target) && target.Locator.GroupId == group && target.Locator.EntryId == entry.StableId)
             candidate.Targets[handle] = target with { Locator = new(group, entry.StableId, slot), CreatedAtFrame = null, IsFuture = false };
         state.Targets.Clear();
         foreach (var pair in candidate.Targets) state.Targets.Add(pair.Key, pair.Value);
         state.Playbacks.Clear();
         foreach (var pair in candidate.Playbacks) state.Playbacks.Add(pair.Key, pair.Value);
+        state.Complete &= candidate.Complete;
     }
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Variants.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Variants.cs
index fe8b321b..ecb23964 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Variants.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.Variants.cs
@@ -1,6 +1,6 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Variants;
+using GalNet.Contracts.Builtins.Variants;
 
 namespace GalNet.Editor.Shared.Services;
 
diff --git a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.cs b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.cs
index eb28e87d..877c7d1f 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/SceneTargetAnalysis.cs
@@ -1,14 +1,15 @@
 using System.Collections.ObjectModel;
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
-using GalNet.Core.Variants;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Editor.Abstraction.Documents;
 
 namespace GalNet.Editor.Shared.Services;
 
 public enum TargetPresence { Definite, Possible }
-public enum SceneTargetKind { Layer, Particle, Effect, Unresolved, Playback }
+public enum SceneTargetKind { Layer, Particle, Effect, Unresolved, Playback, AudioEffect }
 public sealed record SceneLocator(string GroupId, string EntryId, string Slot, string? EventId = null);
 public sealed record SceneTimelinePosition(int Frame, int? BeforeEventIndex = null, bool IncludeFuture = false);
 public sealed record SceneTarget(SceneLocator Locator, string Handle, SceneTargetKind Kind, string Resource,
@@ -19,6 +20,12 @@ public sealed record SceneTarget(SceneLocator Locator, string Handle, SceneTarge
 public sealed record SceneTargetResult(IReadOnlyList<SceneTarget> Targets, bool Complete, bool Reachable)
 {
     public IReadOnlyList<SceneTarget> Playbacks { get; init; } = [];
+    public IReadOnlyList<AudioEffectTarget> AudioEffects { get; init; } = [];
+    public bool AudioComplete { get; init; }
+    public long AudioRevision { get; init; }
+    public long Revision { get; init; }
+    public long ContextRevision { get; init; }
+    public long AuthorRevision { get; init; }
 }
 
 /// <summary>Pure, finite abstract interpretation. Never instantiates a game or executes an entry.</summary>
@@ -28,8 +35,16 @@ private sealed class State
     {
         public Dictionary<string, SceneTarget> Targets { get; } = new(StringComparer.Ordinal);
         public Dictionary<string, SceneTarget> Playbacks { get; } = new(StringComparer.Ordinal);
+        public Dictionary<AudioEffectKey, AudioEffectTarget> AudioEffects { get; } = [];
+        public bool AudioComplete { get; set; } = true;
         public bool Complete { get; set; } = true;
-        public State Clone() { var copy = new State { Complete = Complete }; foreach (var pair in Targets) copy.Targets.Add(pair.Key, pair.Value); foreach (var pair in Playbacks) copy.Playbacks.Add(pair.Key, pair.Value); return copy; }
+        public State Clone() { var copy = new State { Complete = Complete, AudioComplete = AudioComplete }; foreach (var pair in AudioEffects) copy.AudioEffects.Add(pair.Key, pair.Value); foreach (var pair in Targets) copy.Targets.Add(pair.Key, pair.Value); foreach (var pair in Playbacks) copy.Playbacks.Add(pair.Key, pair.Value); return copy; }
+        public void UncertainAudio()
+        {
+            AudioComplete = false;
+            foreach (var (key, effect) in AudioEffects.ToArray()) AudioEffects[key] = effect with { Presence = TargetPresence.Possible };
+        }
+        public void UncertainAll() { Uncertain(); UncertainAudio(); }
         public void Uncertain()
         {
             Complete = false;
@@ -42,17 +57,23 @@ public void Uncertain()
     private readonly IEffectCatalog? _effects;
     private readonly IReadOnlyDictionary<string, ImageVariantsDefinition?>? _variants;
     private readonly Dictionary<string, State> _inputs = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, State> _outputs = new(StringComparer.Ordinal);
+    private readonly AudioConfiguration? _audioConfiguration;
+    private readonly ISEffectCatalog _audioCatalog;
     private bool _budgetExceeded;
     public SceneTargetAnalysis(EditorGraphDocument graph, IReadOnlyDictionary<string, List<EditorEntryData>> groups, int budget = 10000,
         IReadOnlyDictionary<string, ShaderEffectDescriptor?>? programs = null, IEffectCatalog? effects = null,
-        IReadOnlyDictionary<string, ImageVariantsDefinition?>? variants = null)
+        IReadOnlyDictionary<string, ImageVariantsDefinition?>? variants = null, SceneTargetAnalysis? previousAnalysis = null, AudioConfiguration? audioConfiguration = null, ISEffectCatalog? audioCatalog = null)
     {
         // Caller owns the immutable snapshot for this generation.
-        _groups = groups;
+        _groups = groups; _audioConfiguration = audioConfiguration; _audioCatalog = audioCatalog ?? SEffectCatalog.Builtins;
         _programs = programs; _effects = effects; _variants = variants;
+        if (previousAnalysis is not null && (!ReferenceEquals(programs, previousAnalysis._programs)
+            || !ReferenceEquals(effects, previousAnalysis._effects) || !ReferenceEquals(variants, previousAnalysis._variants) || !ReferenceEquals(audioConfiguration, previousAnalysis._audioConfiguration)
+            || !ReferenceEquals(_audioCatalog, previousAnalysis._audioCatalog))) previousAnalysis = null;
         var nodes = graph.Nodes.ToDictionary(node => node.Id, StringComparer.Ordinal);
         if (!nodes.ContainsKey(graph.RootNodeId)) return;
-        var outputs = new Dictionary<string, State>(StringComparer.Ordinal);
+        var outputs = _outputs;
         var queue = new Queue<string>(); queue.Enqueue(graph.RootNodeId);
         var successors = graph.Edges.GroupBy(edge => edge.FromNodeId).ToDictionary(group => group.Key, group => group.Select(edge => edge.ToNodeId).Distinct().Where(nodes.ContainsKey).ToArray());
         var predecessors = graph.Edges.GroupBy(edge => edge.ToNodeId).ToDictionary(group => group.Key, group => group.Select(edge => edge.FromNodeId).Distinct().ToArray());
@@ -68,10 +89,10 @@ public SceneTargetAnalysis(EditorGraphDocument graph, IReadOnlyDictionary<string
             var node = nodes[id];
             if (node.Type == "Group")
             {
-                if (groups.TryGetValue(id, out var entries)) foreach (var entry in entries) output = Apply(output, id, entry);
-                else output.Uncertain();
+                if (groups.TryGetValue(id, out var entries)) output = TransferGroup(input, id, entries, previousAnalysis);
+                else output.UncertainAll();
             }
-            else if (node.Type is not ("Entry" or "Branch" or "Exit")) output.Uncertain();
+            else if (node.Type is not ("Entry" or "Branch" or "Exit")) output.UncertainAll();
             if (outputs.TryGetValue(id, out var old) && Equal(old, output)) continue;
             outputs[id] = output;
             if (successors.TryGetValue(id, out var next)) foreach (var target in next) queue.Enqueue(target);
@@ -82,11 +103,14 @@ public SceneTargetResult Before(string groupId, string? entryId)
     private State? StateBefore(string groupId, string? entryId)
     {
         if (!_inputs.TryGetValue(groupId, out var input) || !_groups.TryGetValue(groupId, out var entries)) return null;
+        var end = entryId is null ? entries.Count : entries.FindIndex(entry => entry.StableId == entryId);
+        if (end < 0) return null;
+        if (!_budgetExceeded) return Prefix(input, groupId, entries, end);
         var state = input.Clone();
         if (_budgetExceeded)
         {
             // Do not publish an unfinished fixed point as a definite fact.
-            state.Uncertain();
+            state.UncertainAll();
             foreach (var (id, group) in _groups) foreach (var entry in group)
             {
                 var candidate = Apply(new State(), id, entry);
@@ -101,12 +125,13 @@ public SceneTargetResult Before(string groupId, string? entryId)
             state = Apply(state, groupId, entry);
         }
         if (!found) return null;
-        if (_budgetExceeded) state.Uncertain();
+        if (_budgetExceeded) state.UncertainAll();
         return state;
     }
     private static State Merge(IReadOnlyList<State> states)
     {
-        var result = new State { Complete = states.All(state => state.Complete) };
+        var result = new State { Complete = states.All(state => state.Complete), AudioComplete = states.All(state => state.AudioComplete) };
+        MergeAudio(result.AudioEffects, states.Select(state => state.AudioEffects).ToArray());
         MergeDomain(result.Targets, states.Select(state => state.Targets).ToArray());
         MergeDomain(result.Playbacks, states.Select(state => state.Playbacks).ToArray());
         return result;
@@ -135,7 +160,7 @@ private static void MergeDomain(Dictionary<string, SceneTarget> result, IReadOnl
             };
         }
     }
-    private static bool Equal(State left, State right) => left.Complete == right.Complete && EqualDomain(left.Targets, right.Targets) && EqualDomain(left.Playbacks, right.Playbacks);
+    private static bool Equal(State left, State right) => left.Complete == right.Complete && left.AudioComplete == right.AudioComplete && EqualAudio(left.AudioEffects, right.AudioEffects) && EqualDomain(left.Targets, right.Targets) && EqualDomain(left.Playbacks, right.Playbacks);
     private static bool EqualDomain(Dictionary<string, SceneTarget> left, Dictionary<string, SceneTarget> right) => left.Count == right.Count && left.All(pair =>
         right.TryGetValue(pair.Key, out var other) && pair.Value.Locator == other.Locator && pair.Value.Kind == other.Kind && pair.Value.Resource == other.Resource
         && pair.Value.CreatedAtFrame == other.CreatedAtFrame && pair.Value.IsFuture == other.IsFuture
@@ -145,8 +170,11 @@ private static bool EqualDomain(Dictionary<string, SceneTarget> left, Dictionary
         && pair.Value.Values.Count == other.Values.Count && pair.Value.Values.All(value => other.Values.TryGetValue(value.Key, out var number) && number == value.Value));
     private State Apply(State before, string group, EditorEntryData entry)
     {
+        EntryTransferCount++;
         if (entry.Condition.Trim().Equals("false", StringComparison.OrdinalIgnoreCase)) return before.Clone();
         var after = before.Clone();
+        try { TransferAudio(after, group, entry); }
+        catch (Exception error) when (error is JsonException or InvalidOperationException or ArgumentException or InvalidDataException or OverflowException) { after.UncertainAudio(); }
         try { Transfer(after, group, entry); }
         catch (Exception error) when (error is JsonException or InvalidOperationException or ArgumentException or InvalidDataException or OverflowException) { after.Uncertain(); }
         return string.IsNullOrWhiteSpace(entry.Condition) || entry.Condition.Trim().Equals("true", StringComparison.OrdinalIgnoreCase) ? after : Merge([before, after]);
@@ -234,36 +262,19 @@ void Transform(string handle, bool create)
             case BuiltinEntryIds.BlindsTransition:
             case BuiltinEntryIds.BlackFadeTransition:
             case BuiltinEntryIds.WhiteFadeTransition:
+            case BuiltinEntryIds.RevealTransition:
+            case BuiltinEntryIds.BlurTransition:
+            case BuiltinEntryIds.MotionPreset:
+            case BuiltinEntryIds.ShakePreset:
+            case BuiltinEntryIds.SpeedLinesPreset:
+            case BuiltinEntryIds.ImpactPreset:
             case BuiltinEntryIds.ColorFadeTransition: TransferTransition(state, group, entry); break;
             case BuiltinEntryIds.Animate:
                 TransferAnimationPlayback(state, group, entry);
                 if (state.Targets.TryGetValue(Text("handleId"), out var animated)) state.Targets[animated.Handle] = animated with { Values = EmptyValues };
                 break;
             case BuiltinEntryIds.StopAnimation: StopPlayback(state, entry); break;
-            // Proven scene-neutral built-ins. Unknown/composite/Timeline semantics must never be neutral by default.
-            case BuiltinEntryIds.Text:
-            case BuiltinEntryIds.ShowDialogue:
-            case BuiltinEntryIds.HideDialogue:
-            case BuiltinEntryIds.ShowNvl:
-            case BuiltinEntryIds.HideNvl:
-            case BuiltinEntryIds.ClearNvl:
-            case BuiltinEntryIds.AppendNvl:
-            case BuiltinEntryIds.TextVoice:
-            case BuiltinEntryIds.AppendVoiceNvl:
-            case BuiltinEntryIds.Wait:
-            case BuiltinEntryIds.SetVariable:
-            case BuiltinEntryIds.UnlockGallery:
-            case BuiltinEntryIds.PlayAudio:
-            case BuiltinEntryIds.StopAudio:
-            case BuiltinEntryIds.PauseAudio:
-            case BuiltinEntryIds.ResumeAudio:
-            case BuiltinEntryIds.NextAudio:
-            case BuiltinEntryIds.ClearAudio:
-            case BuiltinEntryIds.EnqueueAudio:
-            case BuiltinEntryIds.ApplyAudioSEffect:
-            case BuiltinEntryIds.StopAudioSEffect:
-            case BuiltinEntryIds.BurstParticles: break;
-            default: state.Uncertain(); break;
+            default: if (SceneAuthoringSemantics.Find(entry.Type)?.SceneNeutral != true) state.Uncertain(); break;
         }
     }
 }
diff --git a/src/Editor/GalNet.Editor.Shared/Services/StoryResourceCompiler.cs b/src/Editor/GalNet.Editor.Shared/Services/StoryResourceCompiler.cs
new file mode 100644
index 00000000..4ac86066
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/StoryResourceCompiler.cs
@@ -0,0 +1,114 @@
+using System.Text;
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Assets;
+using GalNet.Core.Entry;
+using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
+using GalNet.Editor.Abstraction.Documents;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Adapts the compiled single-graph stage to ordinary addressable files.</summary>
+public static class StoryResourceCompiler
+{
+    public static IReadOnlyList<IGameFile> Compile(string stage, IEntryCatalog catalog, CancellationToken cancellationToken = default,
+        IReadOnlyList<IGameFile>? assets = null)
+    {
+        var graphBytes = File.ReadAllBytes(Path.Combine(stage, "Graph", "graph.json"));
+        var graph = JsonSerializer.Deserialize<EditorGraphDocument>(graphBytes, new JsonSerializerOptions(JsonSerializerDefaults.Web)
+        { Converters = { new System.Text.Json.Serialization.JsonStringEnumConverter() } })!;
+        byte[]? ReadGroup(string id)
+        {
+            var path = GalNet.Assets.FileSystemPaths.ResolveRelativeFile(stage, "Graph/groups/" + id + ".galgroup");
+            return File.Exists(path) ? File.ReadAllBytes(path) : null;
+        }
+        var document = new EditorProjectDocument
+        {
+            Graph = graph,
+            GroupEntries = graph.Nodes
+            .Where(node => node.Type is "Group" or "Entry").ToDictionary(node => node.Id, node => ReadGroup(node.Id) is { } bytes
+                ? Authors(JsonCodec.Deserialize<CompiledGroupDocument>(bytes)!, catalog) : [], StringComparer.Ordinal)
+        };
+        var programs = new Dictionary<string, ShaderEffectDescriptor?>(StringComparer.OrdinalIgnoreCase);
+        foreach (var file in (assets ?? []).Where(file => file.TypeId == "effect-program"))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (file.Length > 1024 * 1024) { programs[file.Id] = null; continue; }
+            var parsed = ShaderEffectMetadataParser.Parse(new(file.Id), Encoding.UTF8.GetString(file.ReadAllBytes()));
+            programs[file.Id] = parsed.Success ? parsed.Descriptor : null;
+        }
+        var metadata = new EntryParameterMetadata(Programs: programs);
+        return CompiledStoryResources.Create(graphBytes, ReadGroup,
+            (id, group) => Dependencies(group, catalog, document, metadata, id), cancellationToken);
+    }
+
+    public static AssetDependencyInfo Dependencies(CompiledGroupDocument group, IEntryCatalog catalog)
+    {
+        const string id = "main";
+        var document = new EditorProjectDocument
+        {
+            Graph = new() { RootNodeId = id, Nodes = [new() { Id = id, Type = "Group" }] },
+            GroupEntries = new() { [id] = Authors(group, catalog) }
+        };
+        return Dependencies(group, catalog, document, new(), id);
+    }
+
+    private static List<EditorEntryData> Authors(CompiledGroupDocument group, IEntryCatalog catalog) => group.Entries.Select(entry =>
+    {
+        var values = new Dictionary<string, JsonElement>(StringComparer.Ordinal);
+        catalog.TryGet(entry.TypeId, out var definition);
+        foreach (var value in entry.Arguments.EnumerateObject())
+        {
+            var field = definition?.DynamicParameters.Fields.FirstOrDefault(field => Wire(field) == value.Name);
+            values[field?.Id ?? value.Name] = value.Value.Clone();
+        }
+        return new EditorEntryData { StableId = entry.Id, Type = entry.TypeId, Condition = entry.Condition, Parameters = values };
+    }).ToList();
+
+    private static string Wire(FieldDescriptor field) => field.JsonPropertyName
+        ?? field.Value.JsonOptions.PropertyNamingPolicy?.ConvertName(field.MemberName ?? field.Id) ?? field.Id;
+
+    private static AssetDependencyInfo Dependencies(CompiledGroupDocument group, IEntryCatalog catalog,
+        EditorProjectDocument source, EntryParameterMetadata metadata, string groupId)
+    {
+        using var structures = new ValueStructureResolver();
+        var provider = new EntryParameterStructures(source, metadata, catalog);
+        var authors = source.GroupEntries[groupId].ToDictionary(entry => entry.StableId, StringComparer.Ordinal);
+        var references = new List<AssetDependency>();
+        var complete = true;
+        foreach (var entry in group.Entries)
+        {
+            if (!catalog.TryGet(entry.TypeId, out var definition)) { complete = false; continue; }
+            var author = authors[entry.Id];
+            foreach (var field in definition.DynamicParameters.Fields)
+            {
+                var provided = entry.Arguments.TryGetProperty(Wire(field), out var value) ? value : field.DefaultValue;
+                if (provided is null) continue;
+                using var tree = new ValueDocument(provider.Describe(field, groupId, author), provided, structures, provider,
+                    new EntryStructureContext(groupId, author));
+                foreach (var property in tree.GetIterator(new(32, 100_000, IncludeMissing: true)))
+                {
+                    if ((property.Value ?? property.Field.DefaultValue) is not { } actual || IsEmpty(actual)) continue;
+                    if (property.Issue is not null) { complete = false; continue; }
+                    if (property.Field.ResourceTypeId is not { } type) continue;
+                    if (actual.ValueKind != JsonValueKind.String) { complete = false; continue; }
+                    references.Add(new(actual.GetString()!.Trim(), type == "*" ? null : type));
+                }
+            }
+            // Calling arbitrary project code cannot establish a complete static resource set.
+            if (entry.TypeId == "custom.invoke") complete = false;
+        }
+        return new(references.Distinct().OrderBy(reference => reference.AssetId, StringComparer.Ordinal).ToArray(), complete);
+    }
+
+    private static bool IsEmpty(JsonElement value) => value.ValueKind switch
+    {
+        JsonValueKind.Null or JsonValueKind.Undefined => true,
+        JsonValueKind.String => string.IsNullOrWhiteSpace(value.GetString()),
+        JsonValueKind.Object => !value.EnumerateObject().Any(),
+        JsonValueKind.Array => value.GetArrayLength() == 0,
+        _ => false
+    };
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/TimelineValueStructure.cs b/src/Editor/GalNet.Editor.Shared/Services/TimelineValueStructure.cs
new file mode 100644
index 00000000..11f270e7
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Services/TimelineValueStructure.cs
@@ -0,0 +1,30 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Parameters;
+
+namespace GalNet.Editor.Shared.Services;
+
+/// <summary>Runtime DTO fields plus author-only timeline metadata; event payloads use their entry contract.</summary>
+internal static class TimelineValueStructure
+{
+    public const string EventParameters = "timeline.event.parameters";
+    private static readonly JsonSerializerOptions JsonOptions = BuiltinJson.CreateOptions(new JsonSerializerOptions { PropertyNameCaseInsensitive = true }, stringEnums: true);
+    private static readonly ValueStructure Tangents = ValueStructure.Object([
+        new("incoming", new(typeof(string))), new("outgoing", new(typeof(string))), new("linked", new(typeof(bool)))], ignoresCase: true);
+    private static readonly ValueStructure Key = ValueStructure.Object(TimelineKeyframeDefinition.Schema.Concat([
+        new FieldDescriptor("editorTangents", new ValueDescriptor(typeof(JsonElement)).WithStructure(Tangents))]), ignoresCase: true);
+    private static readonly ValueStructure Track = ValueStructure.Object(TimelineTrackDefinition.Schema.Select(field => field.Id == "keys"
+        ? Structure(field, List(Key)) : field), ignoresCase: true);
+    private static readonly ValueStructure Event = ValueStructure.Object(TimelineEventDefinition.Schema.Select(field => field.Id == "parameters"
+        ? Structure(field, ValueStructure.Dynamic(EventParameters)) : field).Concat([new FieldDescriptor("editorId", new(typeof(string)))]), ignoresCase: true);
+    private static readonly ValueStructure Timeline = ValueStructure.Object(TimelineDefinition.Schema.Select(field => field.Id switch
+    { "tracks" => Structure(field, List(Track)), "events" => Structure(field, List(Event)), _ => field }), ignoresCase: true);
+
+    public static FieldDescriptor Describe(FieldDescriptor field) => new(field.Id,
+        field.Value.WithJsonOptions(JsonOptions).WithStructure(Timeline),
+        field.IsRequired, field.DefaultValue, field.Editor, field.LabelKey, field.DescriptionKey, field.Semantic, field.ResourceTypeId);
+    private static ValueStructure List(ValueStructure element) => ValueStructure.Sequence(new("element", new ValueDescriptor(typeof(JsonElement)).WithStructure(element)));
+    private static FieldDescriptor Structure(FieldDescriptor field, ValueStructure structure) => new(field.Id, field.Value.WithStructure(structure),
+        field.IsRequired, field.DefaultValue, field.Editor, field.LabelKey, field.DescriptionKey, field.Semantic, field.ResourceTypeId);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Services/VariableDefinitionService.cs b/src/Editor/GalNet.Editor.Shared/Services/VariableDefinitionService.cs
index d043c5a6..934a2b65 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/VariableDefinitionService.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/VariableDefinitionService.cs
@@ -3,7 +3,7 @@
 
 namespace GalNet.Editor.Shared.Services;
 
-/// <summary>Read-only declaration snapshots and notifications for preview variable stores.</summary>
+/// <summary>Read-only declaration snapshots and notifications for authoring queries.</summary>
 public sealed class VariableDefinitionService(IEditorDocumentService documents) : IVariableDefinitionService
 {
     public event Action<VariableScope>? DefinitionsChanged;
diff --git a/src/Editor/GalNet.Editor.Shared/Services/VariableNameRules.cs b/src/Editor/GalNet.Editor.Shared/Services/VariableNameRules.cs
index aa302e5f..742f7f14 100644
--- a/src/Editor/GalNet.Editor.Shared/Services/VariableNameRules.cs
+++ b/src/Editor/GalNet.Editor.Shared/Services/VariableNameRules.cs
@@ -1,10 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Text;
 using System.Text.RegularExpressions;
-using GalNet.Core.Settings;
-using GalNet.Core.Variable;
-using Serilog;
 
 namespace GalNet.Editor.Shared.Services;
 
@@ -35,43 +31,6 @@ public static string Sanitize(string? name, string fallback = "var")
         return sanitized;
     }
 
-    public static void Normalize(ProjectSettings settings)
-    {
-        Normalize(settings.PlayerVariables, settings.SaveVariables);
-    }
-
-    public static void Normalize(
-        List<ProjectVariableDefinition> playerVariables,
-        List<ProjectVariableDefinition> saveVariables)
-    {
-        var usedNames = new HashSet<string>(StringComparer.Ordinal);
-        NormalizeDefinitions(playerVariables, usedNames, "player");
-        NormalizeDefinitions(saveVariables, usedNames, "save");
-    }
-
-    private static void NormalizeDefinitions(
-        List<ProjectVariableDefinition> variables,
-        HashSet<string> usedNames,
-        string scope)
-    {
-        for (var i = variables.Count - 1; i >= 0; i--)
-        {
-            var variable = variables[i];
-            var originalName = variable.Name;
-            variable.Name = Sanitize(variable.Name, $"var_{scope}_{i + 1}");
-            variable.DefaultValue.Name = variable.Name;
-
-            if (!string.Equals(originalName, variable.Name, StringComparison.Ordinal))
-                Log.Warning("Sanitized invalid {Scope} variable name from '{Original}' to '{Sanitized}'", scope, originalName, variable.Name);
-
-            if (usedNames.Add(variable.Name))
-                continue;
-
-            Log.Warning("Dropped duplicate {Scope} variable definition '{Name}' while normalizing project settings", scope, variable.Name);
-            variables.RemoveAt(i);
-        }
-    }
-
     [GeneratedRegex("^[A-Za-z0-9_]+$")]
     private static partial Regex ValidNameRegex();
 
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/DefaultVisualInstaller.cs b/src/Editor/GalNet.Editor.Shared/Visuals/DefaultVisualInstaller.cs
new file mode 100644
index 00000000..d448930e
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/DefaultVisualInstaller.cs
@@ -0,0 +1,63 @@
+using System.Security.Cryptography;
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Shared.Commands;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Shared.Visuals;
+
+public sealed record DefaultVisualInstallReport(bool DryRun, IReadOnlyList<string> AddedFiles, IReadOnlyDictionary<string, string> Programs);
+
+/// <summary>Explicit additive installation using the existing checked author-file transaction.</summary>
+public static class DefaultVisualInstaller
+{
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web) { WriteIndented = true };
+
+    public static async Task<ToolResult> InstallAsync(string root, IEntryCatalog catalog, ProjectConfigurationSchema configurations,
+        bool dryRun = false, CancellationToken cancellationToken = default)
+    {
+        const string operation = "project.visuals.install";
+        string? scratch = null;
+        try
+        {
+            if (!catalog.TryGet(BuiltinEntryIds.ApplyEffect, out _) || !configurations.Sections.Any(section => section.Id == DefaultProjectConfiguration.Section.Id && section.Fields.Any(field => field.Id == "defaultVisualPrograms")))
+                throw new InvalidDataException("This project contract does not declare default visual bindings and effect.apply. Rebuild/deploy its updated contract first.");
+            var reader = new ProjectRawReader(root);
+            var originalSettings = await File.ReadAllBytesAsync(reader.Resolve("settings.json"), cancellationToken);
+            var configuration = JsonSerializer.Deserialize<ProjectConfiguration>(originalSettings, JsonOptions) ?? throw new InvalidDataException("Invalid project settings.");
+            configurations.Validate(configuration);
+            var plan = DefaultVisualTemplate.Prepare(configuration);
+            var report = new DefaultVisualInstallReport(dryRun, plan.Files.Keys.Order(StringComparer.Ordinal).ToArray(), plan.Configuration.ReadDefaultOptions().DefaultVisualPrograms);
+            foreach (var path in plan.Files.Keys)
+                if (File.Exists(reader.Resolve(path)) || Directory.Exists(reader.Resolve(path)))
+                    throw new IOException($"Default visual path is occupied; preserve it and configure its binding explicitly: '{path}'.");
+            if (plan.Files.Count == 0) return new(operation, true, report, []);
+            scratch = Path.Combine(Path.GetTempPath(), "GalNet-visual-install-" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(scratch);
+            var writes = new List<ProjectApplyWrite>();
+            var payloads = plan.Files.Concat(new[] { new KeyValuePair<string, byte[]>("settings.json", JsonSerializer.SerializeToUtf8Bytes(plan.Configuration, JsonOptions)) });
+            foreach (var (path, bytes) in payloads)
+            {
+                var source = writes.Count.ToString(System.Globalization.CultureInfo.InvariantCulture) + ".data";
+                await File.WriteAllBytesAsync(Path.Combine(scratch, source), bytes, cancellationToken);
+                writes.Add(new()
+                {
+                    Path = path,
+                    Source = source,
+                    ContentHash = Convert.ToHexString(SHA256.HashData(bytes)),
+                    ExpectedHash = path == "settings.json" ? Convert.ToHexString(SHA256.HashData(originalSettings)) : null
+                });
+            }
+            var manifest = Path.Combine(scratch, "manifest.json");
+            await File.WriteAllBytesAsync(manifest, JsonSerializer.SerializeToUtf8Bytes(new ProjectApplyManifest { Version = 1, Writes = writes, Deletes = [] }, JsonOptions), cancellationToken);
+            var result = await new ProjectApplyService(root, catalog, configurations: configurations).ApplyAsync(manifest, dryRun, cancellationToken);
+            return result with { OperationId = operation, Data = result.Success ? report : result.Data };
+        }
+        catch (Exception error) when (error is IOException or UnauthorizedAccessException or JsonException or InvalidDataException or ArgumentException)
+        { return new(operation, false, null, [new("visual.installRejected", "error", error.Message)]); }
+        finally { if (scratch is not null && Directory.Exists(scratch)) Directory.Delete(scratch, true); }
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/DefaultVisualTemplate.cs b/src/Editor/GalNet.Editor.Shared/Visuals/DefaultVisualTemplate.cs
new file mode 100644
index 00000000..09b857ba
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/DefaultVisualTemplate.cs
@@ -0,0 +1,56 @@
+using System.Collections.ObjectModel;
+using System.Text;
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
+
+namespace GalNet.Editor.Shared.Visuals;
+
+/// <summary>Initialization source only. Playback loads the deployed project assets.</summary>
+public static class DefaultVisualTemplate
+{
+    private static readonly IReadOnlyDictionary<string, string> Programs = new ReadOnlyDictionary<string, string>(new Dictionary<string, string>(StringComparer.Ordinal)
+    {
+        ["bloom"] = "Bloom",
+        ["blur"] = "Blur",
+        ["vignette"] = "Vignette",
+        ["colorGrade"] = "ColorGrade",
+        ["depthBlur"] = "DepthBlur",
+        ["speedLines"] = "SpeedLines",
+        ["reveal"] = "Reveal",
+        ["maskReveal"] = "MaskReveal"
+    });
+
+    public static IReadOnlyDictionary<string, string> ProgramNames => Programs;
+
+    public static string ReadShader(string name)
+    {
+        if (!Programs.Values.Contains(name, StringComparer.Ordinal)) throw new ArgumentException("Unknown template shader.", nameof(name));
+        using var stream = typeof(DefaultVisualTemplate).Assembly.GetManifestResourceStream($"GalNet.Visuals.{name}.sksl")
+            ?? throw new InvalidOperationException($"Missing visual template '{name}'.");
+        using var reader = new StreamReader(stream, Encoding.UTF8);
+        return reader.ReadToEnd();
+    }
+
+    /// <summary>Builds an additive plan without writing or changing the caller's configuration.</summary>
+    public static DefaultVisualTemplatePlan Prepare(ProjectConfiguration configuration)
+    {
+        var result = configuration.Clone();
+        var options = result.ReadDefaultOptions();
+        var files = new Dictionary<string, byte[]>(StringComparer.Ordinal);
+        foreach (var (purpose, name) in Programs)
+        {
+            // An explicit author binding, including an empty selection, is never overwritten.
+            if (options.DefaultVisualPrograms.ContainsKey(purpose)) continue;
+            var id = Guid.NewGuid().ToString("N");
+            var path = $"Effects/Default/{name}.sksl";
+            files.Add("Assets/" + path, Encoding.UTF8.GetBytes(ReadShader(name)));
+            files.Add("Assets/" + path + ".meta", JsonSerializer.SerializeToUtf8Bytes(new { id, type = "effect-program", path }));
+            options.DefaultVisualPrograms.Add(purpose, id);
+        }
+        result.Set(DefaultProjectConfiguration.Section, options);
+        return new(result, files);
+    }
+}
+
+public sealed record DefaultVisualTemplatePlan(ProjectConfiguration Configuration, IReadOnlyDictionary<string, byte[]> Files);
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Bloom.sksl b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Bloom.sksl
new file mode 100644
index 00000000..5b24459a
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Bloom.sksl
@@ -0,0 +1,54 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer,scenePost
+
+@param strength
+  uniform: strength
+  type: float
+  default: 0
+  range: 0..5
+  animatable: true
+
+@param radius
+  uniform: radius
+  type: float
+  default: 16
+  range: 0..64
+  animatable: true
+
+@param threshold
+  uniform: threshold
+  type: float
+  default: 0.8
+  range: 0..1
+  animatable: true
+
+@param softKnee
+  uniform: softKnee
+  type: float
+  default: 0.1
+  range: 0.001..1
+  animatable: true
+*/
+uniform shader source;
+uniform float strength, radius, threshold, softKnee;
+half4 main(float2 p) {
+    half4 c = source.eval(p);
+    float3 glow = float3(0);
+    float weights = 0.0;
+    for (int y = -2; y <= 2; y++) {
+        for (int x = -2; x <= 2; x++) {
+            float3 rgb = float3(source.eval(p + float2(float(x),float(y))*radius*0.5).rgb);
+            float luma = dot(rgb,float3(0.2126,0.7152,0.0722));
+            float soft = clamp(luma-threshold+softKnee,0.0,2.0*softKnee);
+            soft = soft*soft/(4.0*max(softKnee,0.001));
+            float w = exp(-float(x*x+y*y)/4.5);
+            glow += rgb * (max(luma-threshold,soft)/max(luma,0.0001)) * w;
+            weights += w;
+        }
+    }
+    // Keep premultiplied RGB inside alpha for partially transparent layers.
+    float3 room = max(float3(c.a)-float3(c.rgb),float3(0));
+    return half4(half3(float3(c.rgb)+room*clamp(glow*strength/max(weights,0.001),0.0,1.0)),c.a);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Blur.sksl b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Blur.sksl
new file mode 100644
index 00000000..fd198451
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Blur.sksl
@@ -0,0 +1,34 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer,scenePost
+
+@param radius
+  uniform: radius
+  type: float
+  default: 0
+  range: 0..64
+  animatable: true
+
+@param direction
+  uniform: direction
+  type: vector2
+  default: [1,0]
+  animatable: false
+*/
+uniform shader source;
+uniform float radius;
+uniform float2 direction;
+half4 main(float2 p) {
+    if (radius <= 0.001) return source.eval(p);
+    float4 sum = float4(source.eval(p));
+    float weights = 1.0;
+    for (int i = 1; i <= 12; i++) {
+        float t = float(i) / 12.0;
+        float w = exp(-4.5 * t * t);
+        float2 d = direction * radius * t;
+        sum += (float4(source.eval(p+d)) + float4(source.eval(p-d))) * w;
+        weights += 2.0 * w;
+    }
+    return half4(sum / weights);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/ColorGrade.sksl b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/ColorGrade.sksl
new file mode 100644
index 00000000..3ef9be59
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/ColorGrade.sksl
@@ -0,0 +1,45 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer,scenePost
+
+@param exposure
+  uniform: exposure
+  type: float
+  default: 0
+  range: -4..4
+  animatable: true
+
+@param saturation
+  uniform: saturation
+  type: float
+  default: 1
+  range: 0..2
+  animatable: true
+
+@param contrast
+  uniform: contrast
+  type: float
+  default: 1
+  range: 0..2
+  animatable: true
+
+@param temperature
+  uniform: temperature
+  type: float
+  default: 0
+  range: -1..1
+  animatable: true
+*/
+uniform shader source;
+uniform float exposure, saturation, contrast, temperature;
+half4 main(float2 p) {
+    half4 c = source.eval(p);
+    if (c.a <= 0.0) return c;
+    float3 rgb = float3(c.rgb) / float(c.a);
+    rgb *= exp2(exposure);
+    rgb = mix(float3(dot(rgb,float3(0.2126,0.7152,0.0722))),rgb,saturation);
+    rgb = (rgb - 0.5) * contrast + 0.5;
+    rgb += temperature * float3(0.12,0.025,-0.12);
+    return half4(half3(clamp(rgb,0.0,1.0) * c.a), c.a);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/DepthBlur.sksl b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/DepthBlur.sksl
new file mode 100644
index 00000000..d4879d46
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/DepthBlur.sksl
@@ -0,0 +1,51 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer
+
+@param focusZ
+  uniform: focusZ
+  type: float
+  default: 0
+  animatable: true
+
+@param focusRange
+  uniform: focusRange
+  type: float
+  default: 0
+  range: 0..100000
+  animatable: true
+
+@param falloff
+  uniform: falloff
+  type: float
+  default: 0.1
+  range: 0..64
+  animatable: true
+
+@param maxRadius
+  uniform: maxRadius
+  type: float
+  default: 24
+  range: 0..64
+  animatable: true
+*/
+uniform shader source;
+uniform float layerZ;
+uniform float focusZ, focusRange, falloff, maxRadius;
+half4 main(float2 p) {
+    float r = clamp((abs(layerZ-focusZ)-focusRange)*falloff,0.0,maxRadius);
+    if (r <= 0.001) return source.eval(p);
+    float4 sum = float4(source.eval(p));
+    float weights = 1.0;
+    // A dense disk avoids the repeated-image grid produced by widely spaced square taps.
+    for (int i = 1; i <= 48; i++) {
+        float t = float(i)/48.0;
+        float angle = float(i)*2.39996323;
+        float2 offset = float2(cos(angle),sin(angle))*sqrt(t)*r;
+        float w = exp(-4.5*t);
+        sum += float4(source.eval(p+offset))*w;
+        weights += w;
+    }
+    return half4(sum/weights);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/MaskReveal.sksl b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/MaskReveal.sksl
new file mode 100644
index 00000000..345b8612
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/MaskReveal.sksl
@@ -0,0 +1,33 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer
+
+@param progress
+  uniform: progress
+  type: float
+  default: 0
+  range: 0..1
+  animatable: true
+
+@param softness
+  uniform: softness
+  type: float
+  default: 0.05
+  range: 0.001..1
+  animatable: true
+
+@texture mask
+  uniform: mask
+  required: true
+*/
+uniform shader source;
+uniform shader mask;
+uniform float progress, softness;
+half4 main(float2 p) {
+    if (progress <= 0.0) return half4(0);
+    if (progress >= 1.0) return source.eval(p);
+    float value = dot(float3(mask.eval(p).rgb),float3(0.2126,0.7152,0.0722));
+    float edge = mix(-softness,1.0+softness,progress);
+    return source.eval(p)*half(1.0-smoothstep(edge-softness,edge+softness,value));
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Reveal.sksl b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Reveal.sksl
new file mode 100644
index 00000000..819f8dd6
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Reveal.sksl
@@ -0,0 +1,66 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer
+
+@param progress
+  uniform: progress
+  type: float
+  default: 0
+  range: 0..1
+  animatable: true
+
+@param softness
+  uniform: softness
+  type: float
+  default: 0.05
+  range: 0.001..1
+  animatable: true
+
+@param mode
+  uniform: mode
+  type: enum
+  default: Wipe
+  options: Wipe,Radial,Noise,Blinds
+  animatable: false
+
+@param angle
+  uniform: angle
+  type: float
+  default: 0
+  range: -360..360
+  animatable: true
+
+@param count
+  uniform: count
+  type: float
+  default: 12
+  range: 1..256
+  animatable: true
+
+@param center
+  uniform: center
+  type: vector2
+  default: [0.5,0.5]
+  animatable: false
+*/
+uniform shader source;
+uniform float2 size, center;
+uniform float progress, softness, mode, angle, count;
+float hash(float2 v) { return fract(sin(dot(v,float2(127.1,311.7)))*43758.5453); }
+half4 main(float2 p) {
+    if (progress <= 0.0) return half4(0);
+    if (progress >= 1.0) return source.eval(p);
+    float2 uv = p/max(size,float2(1));
+    float a = angle*0.01745329252;
+    float2 axis = float2(cos(a),sin(a));
+    float value = dot(uv-0.5,axis)/max(abs(axis.x)+abs(axis.y),0.001)+0.5;
+    if (mode > 0.5 && mode < 1.5) {
+        float farthest = length(max(center,1.0-center));
+        value = length(uv-center)/max(farthest,0.001);
+    } else if (mode > 1.5 && mode < 2.5) value = hash(floor(uv*160.0));
+    else if (mode > 2.5) value = fract(value*count);
+    float edge = mix(-softness,1.0+softness,progress);
+    float alpha = 1.0-smoothstep(edge-softness,edge+softness,value);
+    return source.eval(p)*half(alpha);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/SpeedLines.sksl b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/SpeedLines.sksl
new file mode 100644
index 00000000..00960294
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/SpeedLines.sksl
@@ -0,0 +1,102 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer
+
+@param time
+  uniform: time
+  type: float
+  default: 0
+  animatable: true
+
+@param speed
+  uniform: speed
+  type: float
+  default: 2
+  range: -20..20
+  animatable: true
+
+@param density
+  uniform: density
+  type: float
+  default: 64
+  range: 4..256
+  animatable: true
+
+@param strength
+  uniform: strength
+  type: float
+  default: 1
+  range: 0..1
+  animatable: true
+
+@param flicker
+  uniform: flicker
+  type: float
+  default: 0.3
+  range: 0..1
+  animatable: true
+
+@param mode
+  uniform: mode
+  type: enum
+  default: Radial
+  options: Radial,Directional
+  animatable: false
+
+@param angle
+  uniform: angle
+  type: float
+  default: 0
+  range: -360..360
+  animatable: true
+
+@param center
+  uniform: center
+  type: vector2
+  default: [0.5,0.5]
+  animatable: false
+
+@param color
+  uniform: color
+  type: color
+  default: #FFFFFF
+  animatable: false
+*/
+uniform shader source;
+uniform float2 size, center;
+uniform float time, speed, density, strength, flicker, mode, angle;
+uniform float4 color;
+float hash(float x) { return fract(sin(x*127.1+311.7)*43758.5453); }
+half4 main(float2 p) {
+    float2 q = (p-center*size)/max(min(size.x,size.y),1.0);
+    float stroke;
+    if (mode < 0.5) {
+        float angular = (atan(q.y,q.x)+3.14159265)/6.2831853*floor(density);
+        float sector = floor(angular);
+        float noise = hash(sector);
+        float width = mix(0.035,0.14,hash(sector+71.0));
+        float across = 1.0-smoothstep(width,width+0.045,abs(fract(angular)-0.5));
+        float r = length(q);
+        float head = fract(time*speed*0.25+noise)*1.6;
+        float along = smoothstep(head-0.8,head-0.65,r)*(1.0-smoothstep(head,head+0.12,r));
+        stroke = across * along * smoothstep(0.08+noise*0.1,0.36,r);
+    } else {
+        float a = angle*0.01745329252;
+        float2 axis = float2(cos(a),sin(a));
+        float coordinate = dot(q,float2(-axis.y,axis.x))*density;
+        float lane = floor(coordinate);
+        float noise = hash(lane);
+        float width = mix(0.035,0.14,hash(lane+71.0));
+        float aa = max(0.02,0.5*density/max(min(size.x,size.y),1.0));
+        float across = 1.0-smoothstep(max(0.0,width-aa),width+aa,abs(fract(coordinate)-0.5));
+        float u = fract((dot(q,axis)-time*speed)*0.5+noise);
+        float along = smoothstep(0.1,0.2,u)*(1.0-smoothstep(0.8,0.9,u));
+        stroke = across * along;
+    }
+    float blink = 1.0-flicker*(0.5+0.5*sin(time*37.0));
+    float alpha = clamp(stroke*blink*strength*color.a,0.0,1.0);
+    // A shader-generated overlay; the transparent source is an explicit layer carrier.
+    half4 inputColor = source.eval(p);
+    return half4(half3(color.rgb*alpha),half(alpha)) + inputColor * half(1.0-alpha);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Vignette.sksl b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Vignette.sksl
new file mode 100644
index 00000000..14a249a7
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/Shaders/Vignette.sksl
@@ -0,0 +1,42 @@
+/*
+@gal.effect v=1
+@input source
+@targets layer,scenePost
+
+@param strength
+  uniform: strength
+  type: float
+  default: 0
+  range: 0..1
+  animatable: true
+
+@param radius
+  uniform: radius
+  type: float
+  default: 0.45
+  range: 0..2
+  animatable: true
+
+@param softness
+  uniform: softness
+  type: float
+  default: 0.4
+  range: 0.001..2
+  animatable: true
+
+@param center
+  uniform: center
+  type: vector2
+  default: [0.5,0.5]
+  animatable: false
+*/
+uniform shader source;
+uniform float2 size;
+uniform float strength, radius, softness;
+uniform float2 center;
+half4 main(float2 p) {
+    half4 c = source.eval(p);
+    float d = length((p / max(size,float2(1))) - center);
+    float fade = smoothstep(radius, radius + max(softness,0.001), d);
+    return half4(c.rgb * half(1.0 - strength * fade), c.a);
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/VisualPresetBindings.cs b/src/Editor/GalNet.Editor.Shared/Visuals/VisualPresetBindings.cs
new file mode 100644
index 00000000..e6a5c7f3
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/VisualPresetBindings.cs
@@ -0,0 +1,26 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
+
+namespace GalNet.Editor.Shared.Visuals;
+
+public static class VisualPresetBindings
+{
+    public static (string Field, string Purpose)? Binding(string type, IReadOnlyDictionary<string, JsonElement> parameters) => type switch
+    {
+        BuiltinEntryIds.SpeedLinesPreset or BuiltinEntryIds.ImpactPreset => ("program", "speedLines"),
+        BuiltinEntryIds.BlurTransition => ("blurProgram", "blur"),
+        BuiltinEntryIds.RevealTransition => ("program", parameters.TryGetValue("mode", out var mode) && mode.ValueKind == JsonValueKind.String && mode.GetString() == "Mask" ? "maskReveal" : "reveal"),
+        _ => null
+    };
+
+    /// <summary>Called only when creating/changing entry type. Never rewrites loaded or existing entries.</summary>
+    public static Dictionary<string, JsonElement> Fill(string type, Dictionary<string, JsonElement> parameters, ProjectConfiguration? configuration)
+    {
+        if (configuration is null || Binding(type, parameters) is not { } binding) return parameters;
+        if (parameters.TryGetValue(binding.Field, out var supplied) && supplied.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(supplied.GetString())) return parameters;
+        if (configuration.ReadDefaultOptions().DefaultVisualPrograms.TryGetValue(binding.Purpose, out var program) && !string.IsNullOrWhiteSpace(program))
+            parameters[binding.Field] = JsonSerializer.SerializeToElement(program);
+        return parameters;
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/Visuals/VisualPresetResourceValidator.cs b/src/Editor/GalNet.Editor.Shared/Visuals/VisualPresetResourceValidator.cs
new file mode 100644
index 00000000..dffb117f
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/Visuals/VisualPresetResourceValidator.cs
@@ -0,0 +1,98 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Shared.Visuals;
+
+/// <summary>Resource validation at the project boundary; the pure entry compiler does not load files.</summary>
+internal sealed class VisualPresetResourceValidator(string root)
+{
+    private Dictionary<string, (string Path, string Type)>? _assets;
+    private readonly ProjectRawReader _reader = new(root);
+
+    public void Validate(string type, IReadOnlyDictionary<string, JsonElement> parameters)
+    {
+        if (VisualPresetBindings.Binding(type, parameters) is not { } binding) return;
+        if (!parameters.TryGetValue(binding.Field, out var program) || program.ValueKind != JsonValueKind.String || string.IsNullOrWhiteSpace(program.GetString()))
+            throw new InvalidDataException($"Preset requires an explicit '{binding.Field}' resource ID.");
+        var asset = Asset(program.GetString()!);
+        if (asset.Type != "effect-program") throw new InvalidDataException("Preset shader must reference an effect-program asset.");
+        var parsed = ShaderEffectMetadataParser.Parse(new(program.GetString()!), File.ReadAllText(_reader.Resolve(asset.Path)));
+        if (!parsed.Success) throw new InvalidDataException(string.Join("; ", parsed.Diagnostics));
+        var descriptor = parsed.Descriptor!;
+        if (!descriptor.Supports(EffectStage.Layer)) throw new InvalidDataException("This preset requires a layer shader.");
+        void Need(string name, ShaderEffectParameterKind kind, bool animate = false)
+        {
+            var parameter = descriptor.Parameters.SingleOrDefault(parameter => parameter.Name == name);
+            if (parameter is null || parameter.Kind != kind || animate && !parameter.Animatable)
+                throw new InvalidDataException($"Preset shader requires {(animate ? "animatable " : "")}{kind} parameter '{name}'.");
+        }
+        float Number(string name, float fallback) => parameters.TryGetValue(name, out var value) && value.TryGetSingle(out var number) ? number : fallback;
+        void Range(string name, float minimum, float maximum)
+        {
+            var parameter = descriptor.Parameters.Single(parameter => parameter.Name == name);
+            if (parameter.Minimum is { } lower && minimum < lower || parameter.Maximum is { } upper && maximum > upper)
+                throw new InvalidDataException($"Preset values exceed shader parameter '{name}' range.");
+        }
+        if (type is BuiltinEntryIds.SpeedLinesPreset or BuiltinEntryIds.ImpactPreset)
+        {
+            Need("time", ShaderEffectParameterKind.Float, true);
+            Need("speed", ShaderEffectParameterKind.Float);
+            Need("flicker", ShaderEffectParameterKind.Float);
+            Range("time", 0, Number("durationFrames", 36) / Number("frameRate", 60));
+            Range("speed", Number("speed", 2), Number("speed", 2));
+            Range("flicker", Number("flicker", .3f), Number("flicker", .3f));
+        }
+        else if (type == BuiltinEntryIds.BlurTransition)
+        {
+            Need("radius", ShaderEffectParameterKind.Float, true);
+            Need("direction", ShaderEffectParameterKind.Vector2);
+            Range("radius", 0, Number("radius", 24));
+        }
+        else
+        {
+            Need("progress", ShaderEffectParameterKind.Float, true);
+            Need("softness", ShaderEffectParameterKind.Float);
+            Range("progress", 0, 1);
+            if (binding.Purpose == "maskReveal")
+            {
+                Need("mask", ShaderEffectParameterKind.Texture);
+                if (!parameters.TryGetValue("maskAsset", out var mask) || mask.ValueKind != JsonValueKind.String || string.IsNullOrWhiteSpace(mask.GetString()))
+                    throw new InvalidDataException("Mask reveal requires maskAsset.");
+                if (Asset(mask.GetString()!).Type != "sprite") throw new InvalidDataException("Mask must reference a sprite asset.");
+            }
+            else
+            {
+                Need("mode", ShaderEffectParameterKind.Enum);
+                var requested = parameters.TryGetValue("mode", out var mode) ? mode.GetString() : "Wipe";
+                if (descriptor.Parameters.Single(parameter => parameter.Name == "mode").Options?.Contains(requested, StringComparer.Ordinal) != true)
+                    throw new InvalidDataException($"Reveal shader does not support mode '{requested}'.");
+                Need("angle", ShaderEffectParameterKind.Float); Need("count", ShaderEffectParameterKind.Float); Need("center", ShaderEffectParameterKind.Vector2);
+            }
+        }
+    }
+
+    private (string Path, string Type) Asset(string id)
+    {
+        if (_assets is null)
+        {
+            _assets = new(StringComparer.OrdinalIgnoreCase);
+            var diagnostics = new List<GalNet.Editor.Abstraction.Commands.ToolDiagnostic>();
+            foreach (var file in _reader.Files("Assets", diagnostics).Where(file => file.EndsWith(".meta", StringComparison.OrdinalIgnoreCase)))
+            {
+                var meta = _reader.Read(file, diagnostics);
+                if (meta is null) continue;
+                var identity = ProjectRawReader.MetadataIdentity(meta.Value);
+                if (Guid.TryParse(identity.Id, out var guid) && meta.Value.TryGetProperty("type", out var type))
+                {
+                    if (!_assets.TryAdd(guid.ToString("N"), (file[..^5], type.GetString() ?? ""))) throw new InvalidDataException("Duplicate resource IDs.");
+                }
+            }
+            if (diagnostics.Any(diagnostic => diagnostic.Severity == "error")) throw new InvalidDataException("Preset resource inventory is unreadable.");
+        }
+        if (!Guid.TryParse(id, out var resourceId) || !_assets.TryGetValue(resourceId.ToString("N"), out var asset) || !File.Exists(_reader.Resolve(asset.Path)))
+            throw new InvalidDataException($"Preset resource '{id}' is missing.");
+        return asset;
+    }
+}
diff --git a/src/Editor/GalNet.Editor.Shared/packages.lock.WindowsReadyToRun.json b/src/Editor/GalNet.Editor.Shared/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..9dd4751c
--- /dev/null
+++ b/src/Editor/GalNet.Editor.Shared/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,71 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Serilog": {
+        "type": "Direct",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      },
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.debugging": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.editor.abstraction": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Editor/GalNet.Editor.Shared/packages.lock.json b/src/Editor/GalNet.Editor.Shared/packages.lock.json
index cc61d79f..54b99fde 100644
--- a/src/Editor/GalNet.Editor.Shared/packages.lock.json
+++ b/src/Editor/GalNet.Editor.Shared/packages.lock.json
@@ -16,6 +16,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -41,18 +42,11 @@
           "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )"
         }
       },
-      "galnet.presentation.abstractions": {
-        "type": "Project",
-        "dependencies": {
-          "GalNet.Core": "[1.0.0, )"
-        }
-      },
       "galnet.runtime": {
         "type": "Project",
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/src/Editor/GalNet.Editor/App.axaml.cs b/src/Editor/GalNet.Editor/App.axaml.cs
index dcca1cd3..b6b797b4 100644
--- a/src/Editor/GalNet.Editor/App.axaml.cs
+++ b/src/Editor/GalNet.Editor/App.axaml.cs
@@ -3,8 +3,7 @@
 using Avalonia;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Markup.Xaml;
-using GalNet.Core.Scene;
-using GalNet.Editor.Abstraction.Services;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Composition;
 using GalNet.Editor.Services;
@@ -12,40 +11,74 @@
 using GalNet.Editor.Views;
 using GameViewAssembly::GalNet.Avalonia.GameView.Presentation;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 
 namespace GalNet.Editor;
 
 public partial class App : Application
 {
+    internal EditorStartupPreparation? Preparation { get; init; }
     /// <summary>DI container for application-level services.</summary>
     public static IServiceProvider? ServiceProvider { get; private set; }
 
-    public static ISettingsService GetSettingsService() =>
-        ServiceProvider!.GetRequiredService<ISettingsService>();
 
     public override void Initialize()
     {
+#if BENCHMARK
+        using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.Xaml");
+#endif
         AvaloniaXamlLoader.Load(this);
     }
 
     public override void OnFrameworkInitializationCompleted()
     {
+#if BENCHMARK
+        using var frameworkMeasurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.FrameworkInitialization");
+#endif
         var services = new ServiceCollection();
-        services.AddSingleton<IEffectCatalog>(_ => AvaloniaEffectRuntime.CreateDefaultCatalog());
-        services.AddEditorServices();
+#if BENCHMARK
+        using (GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.RegisterServices"))
+#endif
+        {
+            services.AddSingleton<IEffectCatalog>(_ => AvaloniaEffectRuntime.CreateDefaultCatalog());
+            services.AddEditorServices();
+        }
+
+        if (Preparation is { } preparation)
+        {
+#if BENCHMARK
+            using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.WaitStartupPreparation");
+#endif
+            services.Replace(ServiceDescriptor.Singleton<IEditorSettingsService>(preparation.Settings.GetAwaiter().GetResult()));
+            var resources = preparation.Localization.GetAwaiter().GetResult();
+            services.Replace(ServiceDescriptor.Singleton<IEditorLocalizationService>(_ => new EditorLocalizationService(resources)));
+        }
 
-        ServiceProvider = services.BuildServiceProvider(new ServiceProviderOptions
         {
-            ValidateOnBuild = true,
-            ValidateScopes = true
-        });
+#if BENCHMARK
+            using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.BuildServiceProvider");
+#endif
+            ServiceProvider = services.BuildServiceProvider(new ServiceProviderOptions
+            {
+                ValidateOnBuild = true,
+                ValidateScopes = true
+            });
+        }
 
-        var editorSettings = ServiceProvider.GetRequiredService<IEditorSettingsService>().GetSettings();
-        ServiceProvider.GetRequiredService<IEditorLocalizationService>().ApplyLocale(editorSettings.UiLocale.Code);
-        ServiceProvider.GetRequiredService<IThemeService>().ApplyThemeByName(editorSettings.Theme);
+        {
+#if BENCHMARK
+            using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.SettingsLocaleTheme");
+#endif
+            var editorSettings = ServiceProvider.GetRequiredService<IEditorSettingsService>().GetSettings();
+            ServiceProvider.GetRequiredService<IEditorLocalizationService>().ApplyLocale(editorSettings.UiLocale.Code);
+            ServiceProvider.GetRequiredService<IThemeService>().ApplyThemeByName(editorSettings.Theme);
+        }
 
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
+#if BENCHMARK
+            using (GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.CreateMainWindow"))
+#endif
             desktop.MainWindow = ServiceProvider.GetRequiredService<MainWindow>();
             desktop.Exit += (_, _) =>
             {
diff --git a/src/Editor/GalNet.Editor/Commands/EntryTypeShortcutCommand.cs b/src/Editor/GalNet.Editor/Commands/EntryTypeShortcutCommand.cs
index 582fdd89..2fea8b6f 100644
--- a/src/Editor/GalNet.Editor/Commands/EntryTypeShortcutCommand.cs
+++ b/src/Editor/GalNet.Editor/Commands/EntryTypeShortcutCommand.cs
@@ -4,7 +4,6 @@
 using GalNet.Contracts.Builtins;
 using GalNet.Core.Entry;
 using GalNet.Core.I18n;
-using GalNet.Primitives.Builtins;
 
 namespace GalNet.Editor.Commands;
 
diff --git a/src/Editor/GalNet.Editor/Composition/EditorServiceCollectionExtensions.cs b/src/Editor/GalNet.Editor/Composition/EditorServiceCollectionExtensions.cs
index d4af549a..37db4bde 100644
--- a/src/Editor/GalNet.Editor/Composition/EditorServiceCollectionExtensions.cs
+++ b/src/Editor/GalNet.Editor/Composition/EditorServiceCollectionExtensions.cs
@@ -1,8 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Abstraction.Extensibility;
 using GalNet.Editor.Abstraction.Services;
@@ -19,8 +21,8 @@
 using GalNet.Editor.ViewModels;
 using GalNet.Editor.Views;
 using GalNet.Game.Controls.Forms;
-using GalNet.Primitives.Builtins;
-using GalNet.Runtime.Content;
+using GalNet.GameHost.Content;
+using GalNet.Rendering.Scene;
 using GalNet.Runtime.Variables;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -32,6 +34,7 @@ public static IServiceCollection AddEditorServices(this IServiceCollection servi
     {
         services.AddScoped<ProjectSchemaSession>();
         services.AddScoped<ExternalGameDebugClient>();
+        services.AddScoped<ProjectDebugPreparation>();
         services.AddScoped<ExternalDebugPanelViewModel>();
         services.AddScoped<IEntryCatalog>(sp => sp.GetRequiredService<ProjectSchemaSession>().Catalog);
         services.AddEditorCoreServices();
@@ -49,15 +52,12 @@ private static IServiceCollection AddEditorCoreServices(this IServiceCollection
         var resourceTypes = BuiltinResourceTypes.CreateCatalog();
         services.AddSingleton<IResourceTypeCatalog>(resourceTypes);
         services.AddSingleton<IGalleryTypeCatalog>(BuiltinGalleryTypes.CreateCatalog(resourceTypes));
-        services.AddSingleton<ISettingsService, SettingsService>();
         services.AddSingleton<IProjectService, ProjectService>();
         services.AddSingleton<IFileDialogService, FileDialogService>();
         services.AddSingleton<IEditorSettingsService, EditorSettingsService>();
         services.AddSingleton<IEditorLocalizationService, EditorLocalizationService>();
         services.AddSingleton<IThemeRegistry, ThemeRegistry>();
         services.AddSingleton<IThemeService, ThemeService>();
-        services.AddSingleton<IGameExitService, EditorGameExitService>();
-        services.AddScoped<IEditorPlayerVariableStore, EditorPlayerVariableStore>();
         services.AddScoped<GraphAuthoringService>();
         services.AddScoped<GroupEntryAuthoringService>();
         services.AddScoped<EntryFieldAuthoringService>();
@@ -67,6 +67,7 @@ private static IServiceCollection AddEditorCoreServices(this IServiceCollection
         services.AddScoped<ProblemsPanelViewModel>();
         services.AddScoped<TimelineEditSession>();
         services.AddScoped<ProjectSceneTargets>();
+        services.AddScoped<IEntryParameterMetadataSource>(sp => sp.GetRequiredService<ProjectSceneTargets>());
         services.AddScoped<ProjectLocalizationQuery>();
         services.AddScoped<LocalizationDocumentStore>();
         services.AddScoped<LocalizationAuthoringService>();
@@ -74,24 +75,33 @@ private static IServiceCollection AddEditorCoreServices(this IServiceCollection
         services.AddScoped<GameLocalizationPanelService>();
         services.AddScoped<LocalizationExchangeService>();
         services.AddScoped<GameLocalizationPanelViewModel>();
+        services.AddScoped<ResourceOverrideAuthoringService>();
+        services.AddScoped<ResourceOverridesPanelViewModel>();
         services.AddScoped<CharacterAuthoringService>();
+        services.AddScoped<CharacterPanelState>();
         services.AddTransient<CharactersPanelViewModel>();
         services.AddScoped<SceneTargetCatalog>();
         services.AddTransient<TimelinePanelViewModel>();
         services.AddScoped<VariableAuthoringService>();
+        services.AddScoped<VariablePanelState>();
         services.AddTransient<VariablesPanelViewModel>();
         services.AddScoped<EditorRegistry>(sp =>
         {
+            var definitions = sp.GetRequiredService<IVariableDefinitionService>();
+            IReadOnlyList<GalNet.Core.Variable.ProjectVariableDefinition> Variables() =>
+                [.. definitions.GetDefinitions(GalNet.Core.Variable.VariableScope.Player), .. definitions.GetDefinitions(GalNet.Core.Variable.VariableScope.Save)];
             var registry = EditorFieldEditors.CreateDefault(sp.GetRequiredService<SceneTargetCatalog>(), context =>
             {
                 if (context.IsEnabled && context.HostContext is Models.Graph.IEntryFieldOrigin { GroupId: { } groupId } origin)
                     sp.GetRequiredService<EditorDockFactory>().OpenTimeline(groupId, origin.EntryId);
-            }, sp.GetRequiredService<IAssetManager>(), sp.GetRequiredService<CharacterAuthoringService>(), sp.GetRequiredService<GameTextAuthoringService>());
+            }, sp.GetRequiredService<IAssetManager>(), sp.GetRequiredService<CharacterAuthoringService>(), sp.GetRequiredService<GameTextAuthoringService>(),
+                sp.GetRequiredService<IProjectContentSession>(), sp.GetRequiredService<ProjectSceneTargets>());
             registry.Replace("entry.expression", context => AuthoringExpressionFieldEditors.Expression(context,
-                () => sp.GetRequiredService<EditorWorkspaceViewModel>().GetConditionVariableSuggestions(),
-                () => sp.GetRequiredService<EditorWorkspaceViewModel>().AllProjectVariableDefinitions));
+                () => definitions.GetDefinitions(GalNet.Core.Variable.VariableScope.Player).Select(variable => new ConditionVariableSuggestion { Name = variable.Name, Scope = GalNet.Core.Variable.VariableScope.Player })
+                    .Concat(definitions.GetDefinitions(GalNet.Core.Variable.VariableScope.Save).Select(variable => new ConditionVariableSuggestion { Name = variable.Name, Scope = GalNet.Core.Variable.VariableScope.Save })).ToArray(),
+                Variables));
             registry.Replace("entry.variablename", context => AuthoringExpressionFieldEditors.Variable(context,
-                () => sp.GetRequiredService<EditorWorkspaceViewModel>().AllProjectVariableDefinitions.Select(variable => variable.Name).ToArray()));
+                () => Variables().Select(variable => variable.Name).ToArray()));
             return registry;
         });
         services.AddScoped<IGraphEditingService, GraphEditingService>();
@@ -102,6 +112,8 @@ private static IServiceCollection AddEditorCoreServices(this IServiceCollection
         services.AddScoped<ProjectFileAuthoringService>();
         services.AddScoped<IProjectFileCommandExecutor>(provider => provider.GetRequiredService<ProjectFileAuthoringService>());
         services.AddScoped<EditorHistories>();
+        services.AddScoped<ProjectExternalChanges>();
+        services.AddScoped<IProjectEditLifetime>(sp => sp.GetRequiredService<ProjectExternalChanges>());
         services.AddScoped<IProjectEditLifetime>(sp => sp.GetRequiredService<EditorHistories>());
         services.AddSingleton<IProjectClosePrompt, ProjectClosePrompt>();
         services.AddScoped<IProjectContentSession, ProjectContentSession>();
@@ -109,14 +121,9 @@ private static IServiceCollection AddEditorCoreServices(this IServiceCollection
         services.AddScoped<UndoRedoRouter>();
         services.AddScoped<IEditorDocumentRepository>(provider => new EditorDocumentRepository(provider.GetRequiredService<IEntryCatalog>(), EditorDocumentValidation.Authoring));
         services.AddScoped<IEditorDocumentService, EditorDocumentService>();
-        services.AddScoped<IEditorSaveCoordinator, EditorSaveCoordinator>();
         services.AddScoped<IProjectSaveScheduler, ProjectSaveScheduler>();
         services.AddScoped<IProjectEditLifetime>(sp => (ProjectSaveScheduler)sp.GetRequiredService<IProjectSaveScheduler>());
         services.AddScoped<IVariableDefinitionService, VariableDefinitionService>();
-        services.AddScoped<EditorVariableService>();
-        services.AddScoped<IVariableService>(sp => sp.GetRequiredService<EditorVariableService>());
-        services.AddSingleton<EditorGameDataProvider>();
-        services.AddSingleton<IGameContentProvider>(sp => sp.GetRequiredService<EditorGameDataProvider>());
         services.AddSingleton<IEditorExtensionRegistry>(_ =>
         {
             var registry = new EditorExtensionRegistry();
@@ -127,7 +134,12 @@ private static IServiceCollection AddEditorCoreServices(this IServiceCollection
         services.AddSingleton<DockLayoutSerializer>();
         services.AddSingleton<IAssetCatalogService, AssetCatalogService>();
         services.AddSingleton<EditorAssetManager>();
-        services.AddSingleton<IAssetManager>(sp => sp.GetRequiredService<EditorAssetManager>());
+        services.AddSingleton<IAssetManager>(sp =>
+        {
+            var assets = sp.GetRequiredService<EditorAssetManager>();
+            assets.RegisterDecoder<SceneTexture>("sprite", new SceneTextureAssetDecoder());
+            return assets;
+        });
         services.AddScoped<IGameExportService, GameExportService>();
 
         return services;
@@ -176,7 +188,6 @@ private static IServiceCollection AddEditorViews(this IServiceCollection service
         services.AddTransient<ExternalDebugPanelView>();
         services.AddTransient<InspectorHostView>();
         services.AddTransient<NodeInspectorControl>();
-        services.AddTransient<PreviewVariablesInspectorControl>();
         services.AddTransient<AssetInspectorControl>();
         services.AddTransient<ProjectSettingsWindow>();
         services.AddTransient<EditorSettingsWindow>();
@@ -202,7 +213,6 @@ private static IServiceCollection AddEditorViewModels(this IServiceCollection se
         services.AddTransient<ProjectSettingsPanelViewModel>();
         services.AddTransient<EditorSettingsPanelViewModel>();
         services.AddTransient<ExportPanelViewModel>();
-        services.AddTransient<GamePreviewPanelViewModel>();
         services.AddTransient<MainWindowViewModel>();
 
         return services;
diff --git a/src/Editor/GalNet.Editor/Controls/AssetFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/AssetFieldEditor.cs
index 76e66ebd..7c4ee611 100644
--- a/src/Editor/GalNet.Editor/Controls/AssetFieldEditor.cs
+++ b/src/Editor/GalNet.Editor/Controls/AssetFieldEditor.cs
@@ -1,7 +1,6 @@
 using System.ComponentModel;
 using System.Text.Json;
 using Avalonia;
-using Avalonia.Controls;
 using GalNet.Core.Assets;
 using GalNet.Editor.Models;
 using GalNet.Game.Controls.Forms;
@@ -31,6 +30,6 @@ async void Selected(object? sender, AvaloniaPropertyChangedEventArgs args)
             finally { Refresh(); }
         }
         Refresh(); context.PropertyChanged += Changed; picker.PropertyChanged += Selected;
-        return new(picker, () => { disposed = true; lifetime.Cancel(); context.PropertyChanged -= Changed; picker.PropertyChanged -= Selected; picker.FindControl<Avalonia.Controls.Button>("PickerButton")?.Flyout?.Hide(); picker.AssetManager = null; lifetime.Dispose(); });
+        return new(picker, () => { disposed = true; lifetime.Cancel(); context.PropertyChanged -= Changed; picker.PropertyChanged -= Selected; picker.Dispose(); picker.AssetManager = null; lifetime.Dispose(); });
     }
 }
diff --git a/src/Editor/GalNet.Editor/Controls/AssetPicker.axaml.cs b/src/Editor/GalNet.Editor/Controls/AssetPicker.axaml.cs
index 6702caa1..01a9180d 100644
--- a/src/Editor/GalNet.Editor/Controls/AssetPicker.axaml.cs
+++ b/src/Editor/GalNet.Editor/Controls/AssetPicker.axaml.cs
@@ -1,119 +1,179 @@
-using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Media.Imaging;
 using Avalonia.Threading;
 using GalNet.Core.Assets;
 using GalNet.Editor.Models;
+using GalNet.Editor.Services.Interfaces;
 using GalNet.Game.Controls.Forms;
 
 namespace GalNet.Editor.Controls;
 
-/// <summary>Editor-only ID-backed media picker. Game runtime UI never references this control.</summary>
-public partial class AssetPicker : UserControl
+/// <summary>Editor-only media picker. Only IDs are authored; paths and labels follow resource generations.</summary>
+public partial class AssetPicker : UserControl, IDisposable
 {
     public static readonly StyledProperty<string> SelectedAssetIdProperty = AvaloniaProperty.Register<AssetPicker, string>(nameof(SelectedAssetId), string.Empty, defaultBindingMode: Avalonia.Data.BindingMode.TwoWay);
     public static readonly StyledProperty<AssetPickerFilter> FilterProperty = AvaloniaProperty.Register<AssetPicker, AssetPickerFilter>(nameof(Filter));
     public static readonly StyledProperty<IAssetManager?> AssetManagerProperty = AvaloniaProperty.Register<AssetPicker, IAssetManager?>(nameof(AssetManager));
+    public static readonly StyledProperty<string?> ResourceTypeIdProperty = AvaloniaProperty.Register<AssetPicker, string?>(nameof(ResourceTypeId));
     public static readonly DirectProperty<AssetPicker, string> DisplayTextProperty = AvaloniaProperty.RegisterDirect<AssetPicker, string>(nameof(DisplayText), x => x.DisplayText);
     public static readonly DirectProperty<AssetPicker, string> DisplayIconProperty = AvaloniaProperty.RegisterDirect<AssetPicker, string>(nameof(DisplayIcon), x => x.DisplayIcon);
     public static readonly DirectProperty<AssetPicker, string> DetailPathProperty = AvaloniaProperty.RegisterDirect<AssetPicker, string>(nameof(DetailPath), x => x.DetailPath);
-
     private string _displayText = "None", _displayIcon = "—", _detailPath = string.Empty;
-    private IReadOnlyList<AssetPickerItem> _allItems = [];
-    private AssetPickerItem? _current;
-    private int _resolveVersion;
-    private bool _flyoutOpen;
-
+    private readonly Dictionary<string, Task<AssetPickerItem>> _cache = new(StringComparer.OrdinalIgnoreCase);
+    private CancellationTokenSource _lifetime = new();
+    private IEditorAssetChanges? _changes;
+    private int _generation, _resolveVersion, _listVersion, _thumbnailCount;
+    private bool _flyoutOpen, _attached, _disposed;
     public ObservableCollection<AssetPickerItem> Items { get; } = [];
     public string SelectedAssetId { get => GetValue(SelectedAssetIdProperty); set => SetValue(SelectedAssetIdProperty, value ?? string.Empty); }
     public AssetPickerFilter Filter { get => GetValue(FilterProperty); set => SetValue(FilterProperty, value); }
     public IAssetManager? AssetManager { get => GetValue(AssetManagerProperty); set => SetValue(AssetManagerProperty, value); }
+    public string? ResourceTypeId { get => GetValue(ResourceTypeIdProperty); set => SetValue(ResourceTypeIdProperty, value); }
     public string DisplayText => _displayText;
     public string DisplayIcon => _displayIcon;
     public string DetailPath => _detailPath;
-
+    public ResourcePickerPanel ResourcePanel => PickerPanel;
     static AssetPicker()
     {
         SelectedAssetIdProperty.Changed.AddClassHandler<AssetPicker>((picker, args) => { _ = picker.ResolveCurrentAsync(); });
-        AssetManagerProperty.Changed.AddClassHandler<AssetPicker>((picker, args) => { _ = picker.ResolveCurrentAsync(); });
+        AssetManagerProperty.Changed.AddClassHandler<AssetPicker>((picker, args) => picker.ManagerChanged());
         FilterProperty.Changed.AddClassHandler<AssetPicker>((picker, args) => { if (picker._flyoutOpen) _ = picker.LoadItemsAsync(); });
+        ResourceTypeIdProperty.Changed.AddClassHandler<AssetPicker>((picker, args) => { if (picker._flyoutOpen) _ = picker.LoadItemsAsync(); });
     }
-
     public AssetPicker()
     {
         InitializeComponent();
         PickerPanel.Search.PlaceholderText = "Search assets";
         PickerPanel.Confirmed += () =>
         {
-            if (PickerPanel.Selected is not { } item) return;
+            if (PickerPanel.Selected is not { } item || _disposed) return;
+            // The source may already have changed before its UI notification was processed.
+            if (_loadedRevision != (AssetManager as IEditorAssetChanges)?.Revision) { RefreshResources(); return; }
             SelectedAssetId = item.Id; PickerButton.Flyout?.Hide();
         };
         PickerPanel.Cancelled += () => PickerButton.Flyout?.Hide();
     }
-    public ResourcePickerPanel ResourcePanel => PickerPanel;
-
+    private long? _loadedRevision;
+    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        base.OnAttachedToVisualTree(e); _attached = true;
+        if (!_disposed) ManagerChanged();
+    }
+    protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        _attached = false; Unsubscribe(); PickerButton.Flyout?.Hide(); if (!_disposed) ClearCache();
+        base.OnDetachedFromVisualTree(e);
+    }
+    private void Unsubscribe() { if (_changes is not null) _changes.Changed -= OnAssetChanges; _changes = null; }
+    private void ManagerChanged()
+    {
+        if (_disposed) return;
+        Unsubscribe();
+        if (_attached && AssetManager is IEditorAssetChanges changes) { _changes = changes; changes.Changed += OnAssetChanges; }
+        RefreshResources();
+    }
+    private void OnAssetChanges() => Dispatcher.UIThread.Post(() => { if (!_disposed && _attached) RefreshResources(); });
+    private void RefreshResources()
+    {
+        ClearCache();
+        if (_disposed) return;
+        _ = ResolveCurrentAsync();
+        if (_flyoutOpen) _ = LoadItemsAsync();
+    }
+    private void ClearCache()
+    {
+        _generation++; _resolveVersion++; _listVersion++; _loadedRevision = null;
+        _lifetime.Cancel(); _lifetime.Dispose(); _lifetime = new();
+        Items.Clear(); PickerPanel.SetItems([]);
+        foreach (var task in _cache.Values) if (task.IsCompletedSuccessfully) task.Result.Dispose();
+        _cache.Clear(); _thumbnailCount = 0;
+    }
     private async void OnFlyoutOpened(object? sender, EventArgs e)
     {
-        _flyoutOpen = true;
-        await LoadItemsAsync();
-        Dispatcher.UIThread.Post(() => PickerPanel.Search.Focus());
+        _flyoutOpen = true; await LoadItemsAsync();
+        if (_flyoutOpen && !_disposed) Dispatcher.UIThread.Post(() => { if (_flyoutOpen && !_disposed) PickerPanel.Search.Focus(); });
+    }
+    private void OnFlyoutClosed(object? sender, EventArgs e) { _flyoutOpen = false; _listVersion++; }
+    private bool Current(int generation, IAssetManager? manager, long? revision) => !_disposed && generation == _generation
+        && ReferenceEquals(manager, AssetManager) && revision == (manager as IEditorAssetChanges)?.Revision;
+    private Task<AssetPickerItem> ItemAsync(IGameFile file)
+    {
+        if (_cache.TryGetValue(file.Id, out var cached)) return cached;
+        var thumbnail = file.TypeId == "sprite" && _thumbnailCount++ < 128;
+        return _cache[file.Id] = CreateItemAsync(file, thumbnail, _generation, _lifetime.Token);
+    }
+    private async Task<AssetPickerItem> CreateItemAsync(IGameFile file, bool thumbnail, int generation, CancellationToken ct)
+    {
+        var item = await AssetPickerItem.CreateAsync(file, thumbnail, ct);
+        if (_disposed || generation != _generation) { item.Dispose(); throw new OperationCanceledException(); }
+        return item;
     }
-
-    private void OnFlyoutClosed(object? sender, EventArgs e) => _flyoutOpen = false;
-
     private async Task ResolveCurrentAsync()
     {
-        var version = Interlocked.Increment(ref _resolveVersion);
-        var assetId = SelectedAssetId;
-        var assetManager = AssetManager;
-        AssetPickerItem? current = null;
-        if (!string.IsNullOrWhiteSpace(assetId) && assetManager is not null)
+        if (_disposed) return;
+        var version = ++_resolveVersion; var generation = _generation; var manager = AssetManager;
+        var revision = (manager as IEditorAssetChanges)?.Revision; var id = SelectedAssetId; var ct = _lifetime.Token;
+        try
+        {
+            AssetPickerItem? current = null;
+            if (!string.IsNullOrWhiteSpace(id) && manager is not null)
+            {
+                Display("Loading…", "…", id);
+                var file = await manager.GetFileAsync(id, ct);
+                if (!Current(generation, manager, revision) || version != _resolveVersion) return;
+                if (file is not null) current = await ItemAsync(file);
+            }
+            if (!Current(generation, manager, revision) || version != _resolveVersion) return;
+            Display(string.IsNullOrWhiteSpace(id) ? "None" : current?.Name ?? "Missing!", string.IsNullOrWhiteSpace(id) ? "—" : current?.Icon ?? "!", current?.Path ?? id);
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception error)
         {
-            var file = await assetManager.GetFileAsync(assetId);
-            if (file is not null) current = await AssetPickerItem.CreateAsync(file);
+            if (Current(generation, manager, revision) && version == _resolveVersion) Display("Unable to load", "!", error.Message);
         }
-        if (version != _resolveVersion || !string.Equals(assetId, SelectedAssetId, StringComparison.Ordinal)) return;
-        _current = current;
-        NotifyDisplay(assetId);
     }
-
     private async Task LoadItemsAsync()
     {
-        var assetManager = AssetManager;
-        if (assetManager is null) { _allItems = []; ApplyFilter(null); return; }
-        var type = Filter switch { AssetPickerFilter.Image => "sprite", AssetPickerFilter.Audio => "audio", AssetPickerFilter.Video => "video", AssetPickerFilter.EffectProgram => "effect-program", AssetPickerFilter.ImageVariants => "image-variants", _ => null };
-        var files = await assetManager.GetFilesAsync(type);
-        if (Filter == AssetPickerFilter.All) files = files.Where(x => x.TypeId is "sprite" or "audio" or "video" or "effect-program" or "image-variants").ToArray();
-        else if (Filter == AssetPickerFilter.Text) files = files.Where(x => IsTextPath(x.Path)).ToArray();
-        _allItems = await Task.WhenAll(files.Select(AssetPickerItem.CreateAsync));
-        ApplyFilter(null);
+        if (_disposed) return;
+        var version = ++_listVersion; var generation = _generation; var manager = AssetManager;
+        var revision = (manager as IEditorAssetChanges)?.Revision; var filter = Filter; var ct = _lifetime.Token;
+        try
+        {
+            if (manager is null) { Items.Clear(); PickerPanel.SetItems([]); return; }
+            var type = ResourceTypeId is { } declared ? declared == "*" ? null : declared : filter switch { AssetPickerFilter.Image => "sprite", AssetPickerFilter.Audio => "audio", AssetPickerFilter.Video => "video", AssetPickerFilter.EffectProgram => "effect-program", AssetPickerFilter.ImageVariants => "image-variants", _ => null };
+            var files = await manager.GetFilesAsync(type, ct);
+            if (!Current(generation, manager, revision) || version != _listVersion) return;
+            if (ResourceTypeId is not null) files = files.Where(file => file.TypeId is not ("graph" or "group")).ToArray();
+            else if (filter == AssetPickerFilter.All) files = files.Where(file => file.TypeId is "sprite" or "audio" or "video" or "effect-program" or "image-variants").ToArray();
+            else if (filter == AssetPickerFilter.Text) files = files.Where(file => IsTextPath(file.Path)).ToArray();
+            var items = await Task.WhenAll(files.Select(ItemAsync));
+            if (!Current(generation, manager, revision) || version != _listVersion) return;
+            Items.Clear(); Items.Add(AssetPickerItem.Empty); foreach (var item in items) Items.Add(item);
+            PickerPanel.Hint = "";
+            PickerPanel.SetItems(Items.Select(item => new ResourcePickerItem(item.File?.Id ?? "", item.Name, item.Path, item.Icon, item.Thumbnail)).ToArray());
+            _loadedRevision = revision;
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception error)
+        {
+            if (Current(generation, manager, revision) && version == _listVersion) { Items.Clear(); PickerPanel.SetItems([]); PickerPanel.Hint = error.Message; }
+        }
     }
-
     internal static bool IsTextPath(string path) => AssetPickerTextFileExtensions.IsSupported(path);
-
-    private void ApplyFilter(string? search)
+    private void Display(string text, string icon, string path)
     {
-        Items.Clear(); Items.Add(AssetPickerItem.Empty);
-        foreach (var item in _allItems) Items.Add(item);
-        PickerPanel.SetItems(Items.Select(item => new ResourcePickerItem(item.File?.Id ?? "", item.Name, item.Path, item.Icon, item.Thumbnail)).ToArray());
+        SetAndRaise(DisplayTextProperty, ref _displayText, text); SetAndRaise(DisplayIconProperty, ref _displayIcon, icon); SetAndRaise(DetailPathProperty, ref _detailPath, path);
     }
-
-    private void NotifyDisplay(string assetId)
+    public void Dispose()
     {
-        SetAndRaise(DisplayTextProperty, ref _displayText, string.IsNullOrWhiteSpace(assetId) ? "None" : _current?.Name ?? "Missing!");
-        SetAndRaise(DisplayIconProperty, ref _displayIcon, string.IsNullOrWhiteSpace(assetId) ? "—" : _current is null ? "!" : _current.Icon);
-        SetAndRaise(DetailPathProperty, ref _detailPath, _current?.Path ?? string.Empty);
+        if (_disposed) return;
+        _disposed = true; Unsubscribe(); PickerButton.Flyout?.Hide(); ClearCache(); _lifetime.Dispose(); GC.SuppressFinalize(this);
     }
 }
 
-public sealed class AssetPickerItem
+public sealed class AssetPickerItem : IDisposable
 {
     public static AssetPickerItem Empty { get; } = new(null, "None", string.Empty, "×", null);
     private AssetPickerItem(IGameFile? file, string name, string path, string icon, Bitmap? thumbnail) { File = file; Name = name; Path = path; Icon = file is not null && AssetPicker.IsTextPath(path) ? "T" : icon; Thumbnail = thumbnail; }
@@ -123,13 +183,16 @@ public sealed class AssetPickerItem
     public string Icon { get; }
     public Bitmap? Thumbnail { get; }
     public bool HasThumbnail => Thumbnail is not null;
-    public static async Task<AssetPickerItem> CreateAsync(IGameFile file)
+    public static async Task<AssetPickerItem> CreateAsync(IGameFile file, bool thumbnail = true, CancellationToken ct = default)
     {
         Bitmap? bitmap = null;
-        if (file.TypeId == "sprite")
+        if (thumbnail && file.TypeId == "sprite")
         {
-            try { var bytes = await file.ReadAllBytesAsync(); using var stream = new MemoryStream(bytes); bitmap = new Bitmap(stream); } catch { }
+            try { var bytes = await file.ReadAllBytesAsync(ct); using var stream = new MemoryStream(bytes); bitmap = Bitmap.DecodeToWidth(stream, 128); }
+            catch (OperationCanceledException) { throw; }
+            catch (Exception error) when (error is IOException or ArgumentException or InvalidDataException or UnauthorizedAccessException) { }
         }
         return new(file, System.IO.Path.GetFileName(file.Path), file.Path, file.TypeId switch { "audio" => "♪", "video" => "▶", _ => "▣" }, bitmap);
     }
+    public void Dispose() => Thumbnail?.Dispose();
 }
diff --git a/src/Editor/GalNet.Editor/Controls/AudioEffectFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/AudioEffectFieldEditor.cs
new file mode 100644
index 00000000..661321e5
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Controls/AudioEffectFieldEditor.cs
@@ -0,0 +1,99 @@
+using System.ComponentModel;
+using System.Text.Json;
+using Avalonia.Controls;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Game.Controls.Forms;
+
+namespace GalNet.Editor.Controls;
+
+internal static class AudioEffectFieldEditor
+{
+    private sealed record Option(string Id, string Label, SEffectDefinition? Definition = null, AudioFieldChoice? Choice = null)
+    { public override string ToString() => Label; }
+
+    public static FieldEditorLease Type(FieldEditorContext context, SceneTargetCatalog? catalog)
+        => Create(context, catalog, type: true);
+    public static FieldEditorLease Instance(FieldEditorContext context, SceneTargetCatalog? catalog)
+        => Create(context, catalog, type: false);
+
+    private static FieldEditorLease Create(FieldEditorContext context, SceneTargetCatalog? catalog, bool type)
+    {
+        var input = new ComboBox { Name = type ? "AudioEffectTypeInput" : "AudioEffectInstanceInput", HorizontalAlignment = global::Avalonia.Layout.HorizontalAlignment.Stretch };
+        var panel = new StackPanel { Spacing = 4 }; panel.Children.Add(input);
+        var hint = new TextBlock { TextWrapping = global::Avalonia.Media.TextWrapping.Wrap }; panel.Children.Add(hint);
+        var lifetime = new CancellationTokenSource(); var disposed = false; var updating = false; var busy = false;
+        var effects = catalog?.AudioCatalog ?? SEffectCatalog.Builtins;
+        void Refresh()
+        {
+            if (disposed) return;
+            updating = true;
+            try
+            {
+                var origin = context.HostContext as IEntryParameterPatchOrigin;
+                var scope = origin?.Parameters.GetValueOrDefault("scope") is { ValueKind: JsonValueKind.String } raw && raw.GetString() == "bus" ? SEffectScope.Bus : SEffectScope.Track;
+                var rows = type ? effects.Definitions.Where(definition => definition.SupportedScopes.Contains(scope))
+                    .Select(definition => new Option(definition.Id, catalog?.AudioTypeName(definition.Id) ?? PropertyEditorSupport.Text("Audio.Type." + definition.Id), definition)).ToList()
+                    : (origin?.GroupId is { } group && catalog is not null ? catalog.FieldOptions(group, origin.EntryId, origin.EntryType, "instanceId") ?? [] : context.Options)
+                    .Where(option => option.Label is AudioFieldChoice).Select(option => new Option(option.Id, option.Label.ToString()!, Choice: (AudioFieldChoice)option.Label)).ToList();
+                Option? selected;
+                if (type) selected = rows.FirstOrDefault(row => row.Id == (context.EffectiveValue is { ValueKind: JsonValueKind.String } typeValue ? typeValue.GetString() : null));
+                else
+                {
+                    var all = origin?.Parameters.GetValueOrDefault("all") is { ValueKind: JsonValueKind.True };
+                    selected = rows.FirstOrDefault(row => all ? row.Choice?.All == true : row.Choice is { All: false, Target: { } target }
+                        && context.Value.Json is { ValueKind: JsonValueKind.String } value && target.Key.InstanceId == value.GetString());
+                }
+                if (selected is null && context.Value.Json is { ValueKind: JsonValueKind.String } unresolved && !string.IsNullOrEmpty(unresolved.GetString()))
+                { selected = new("unresolved", PropertyEditorSupport.Text("Scene.Unresolved")); rows.Add(selected); }
+                input.ItemsSource = rows; input.SelectedItem = selected;
+                input.IsEnabled = context.IsEnabled && origin is not null && !busy;
+                hint.Text = !type && rows.Select(row => row.Choice).OfType<AudioFieldChoice>().Any(choice => !choice.Snapshot.Complete)
+                    ? PropertyEditorSupport.Text("Audio.AnalysisIncomplete") : null;
+                hint.IsVisible = hint.Text is not null;
+            }
+            finally { updating = false; }
+        }
+        input.SelectionChanged += async (_, _) =>
+        {
+            if (disposed || updating || busy || !context.IsEnabled || input.SelectedItem is not Option option || context.HostContext is not IEntryParameterPatchOrigin origin) return;
+            if (!type && (option.Choice is null || catalog is null || !catalog.IsCurrent(option.Choice.Snapshot)))
+            { context.ReportIssue(new("entry.obsolete", PropertyEditorSupport.Text("Scene.Stale"))); Refresh(); return; }
+            var patch = new Dictionary<string, FieldValue>();
+            if (type)
+            {
+                if (option.Definition is null) return;
+                patch["id"] = new(JsonSerializer.SerializeToElement(option.Definition.Id));
+                patch["parameters"] = new(option.Definition.DefaultParameters);
+            }
+            else
+            {
+                patch["instanceId"] = option.Choice!.All ? default : new(JsonSerializer.SerializeToElement(option.Choice.Target!.Key.InstanceId));
+                if (origin.EntryType == BuiltinEntryIds.StopAudioSEffect) patch["all"] = new(JsonSerializer.SerializeToElement(option.Choice.All));
+                // A new update target starts a fresh patch; never transplant parameters from another algorithm.
+                if (origin.EntryType == BuiltinEntryIds.UpdateAudioSEffect) patch["parameters"] = new(JsonSerializer.SerializeToElement(new { }));
+            }
+            busy = true;
+            try
+            {
+                input.IsEnabled = false;
+                if (await origin.CommitPatchAsync(patch, lifetime.Token) is { } issue && !disposed) context.ReportIssue(issue);
+            }
+            catch (OperationCanceledException) { }
+            catch (Exception error) { if (!disposed) context.ReportIssue(new("field.commit", error.Message)); }
+            finally { busy = false; Refresh(); }
+        };
+        void Changed(object? sender, PropertyChangedEventArgs args) => Refresh();
+        context.PropertyChanged += Changed;
+        if (catalog is not null) catalog.Changed += Refresh;
+        var locale = PropertyEditorSupport.Localize(Refresh);
+        input.DropDownOpened += (_, _) => Refresh(); Refresh();
+        return new(panel, () =>
+        {
+            disposed = true; lifetime.Cancel(); lifetime.Dispose(); locale.Dispose(); context.PropertyChanged -= Changed;
+            if (catalog is not null) catalog.Changed -= Refresh;
+        });
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Controls/AudioEffectParametersFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/AudioEffectParametersFieldEditor.cs
new file mode 100644
index 00000000..2be1fb45
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Controls/AudioEffectParametersFieldEditor.cs
@@ -0,0 +1,137 @@
+using System.ComponentModel;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using Avalonia.Controls;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Game.Controls.Forms;
+
+namespace GalNet.Editor.Controls;
+
+internal static class AudioEffectParametersFieldEditor
+{
+    public static FieldEditorLease Create(FieldEditorContext context, SceneTargetCatalog? catalog)
+    {
+        var panel = new StackPanel { Name = "AudioEffectParameters", Spacing = 6 };
+        var rows = new StackPanel { Spacing = 6 }; panel.Children.Add(rows);
+        var notice = new TextBlock { TextWrapping = global::Avalonia.Media.TextWrapping.Wrap }; panel.Children.Add(notice);
+        var repair = PropertyEditorSupport.Repair(context); panel.Children.Add(repair.Button);
+        var children = new List<(FieldEditorContext Context, MemberBinding Binding, FieldEditorLease Lease, TextBlock Label)>();
+        var disposed = false; var submitting = false; var refreshing = false; string? currentKey = null; var baseline = context.Value;
+        var effects = catalog?.AudioCatalog ?? SEffectCatalog.Builtins;
+        string? baseNotice = null;
+        void Issues(object? sender, PropertyChangedEventArgs args)
+        {
+            notice.Text = children.Select(child => child.Context.IssueMessage).FirstOrDefault(message => message is not null) ?? baseNotice;
+            notice.IsVisible = notice.Text is not null;
+        }
+        void Clear() { foreach (var child in children) { child.Context.PropertyChanged -= Issues; child.Lease.Dispose(); child.Context.Dispose(); } children.Clear(); rows.Children.Clear(); }
+        void Refresh()
+        {
+            if (disposed || refreshing) return;
+            refreshing = true;
+            try
+            {
+                var origin = context.HostContext as IEntryParameterPatchOrigin;
+                var update = origin?.EntryType == BuiltinEntryIds.UpdateAudioSEffect;
+                var type = origin?.Parameters.GetValueOrDefault("id") is { ValueKind: JsonValueKind.String } raw ? raw.GetString() : null;
+                if (update)
+                {
+                    type = null;
+                    if (catalog is not null && origin?.GroupId is { } group && origin.Parameters.GetValueOrDefault("instanceId") is { ValueKind: JsonValueKind.String } instance)
+                    {
+                        var target = catalog.QueryAudio(group, origin.EntryId).Targets.FirstOrDefault(target => target.Key.InstanceId == instance.GetString());
+                        if (target?.Types.Count == 1) type = target.Types[0];
+                    }
+                }
+                string Part(string name) => origin?.Parameters.GetValueOrDefault(name) is { ValueKind: JsonValueKind.String } value ? value.GetString() ?? "" : "";
+                var key = JsonSerializer.Serialize(new[] { type, Part("scope"), Part("targetId"), Part("instanceId") });
+                if (key != currentKey)
+                {
+                    foreach (var child in children) child.Context.RevertDraft();
+                    Clear(); currentKey = key;
+                    if (type is not null && effects.TryGet(type, out var definition))
+                        foreach (var parameter in definition.Parameters)
+                        {
+                            var sourceField = parameter.Field;
+                            var field = new FieldDescriptor(parameter.Name, sourceField.Value, !update && sourceField.IsRequired,
+                                update ? null : sourceField.DefaultValue, sourceField.Editor, "Audio.Parameter." + parameter.Name, sourceField.DescriptionKey);
+                            var binding = new MemberBinding(context, field, () => disposed || !context.IsEnabled, async value =>
+                            {
+                                submitting = true;
+                                try
+                                {
+                                    var root = Read(context);
+                                    if (value.Json is { } json) root[field.Id] = JsonNode.Parse(json.GetRawText()); else root.Remove(field.Id);
+                                    return await context.CommitAsync(new(JsonSerializer.SerializeToElement(root))) ? null : context.Issue ?? new("audio.parameters", "Cannot update audio parameters.");
+                                }
+                                finally { submitting = false; }
+                            });
+                            var child = new FieldEditorContext(field, binding, context.Registry);
+                            var lease = (context.Registry?.Resolve(field) ?? NumericFieldEditors.CreateUpDown)(child); lease.Control.Name = "AudioParameter_" + field.Id;
+                            var label = new TextBlock { Width = 105, TextWrapping = global::Avalonia.Media.TextWrapping.Wrap, VerticalAlignment = global::Avalonia.Layout.VerticalAlignment.Center };
+                            var row = new Grid { ColumnDefinitions = new("Auto,*"), ColumnSpacing = 8 };
+                            row.Children.Add(label); Grid.SetColumn(lease.Control, 1); row.Children.Add(lease.Control); rows.Children.Add(row);
+                            children.Add((child, binding, lease, label));
+                            child.PropertyChanged += Issues;
+                        }
+                }
+                var current = context.Value;
+                var changed = baseline.IsProvided != current.IsProvided || baseline.IsProvided && !JsonElement.DeepEquals(baseline.Json!.Value, current.Json!.Value);
+                baseline = current;
+                foreach (var child in children)
+                {
+                    child.Label.Text = PropertyEditorSupport.Text("Audio.Parameter." + child.Context.Field.Id);
+                    if (changed && !submitting) child.Context.RevertDraft();
+                    child.Binding.Refresh();
+                }
+                var invalid = type is null || !effects.TryGet(type, out var selected);
+                try
+                {
+                    var parameters = Read(context);
+                    invalid |= type is not null && effects.TryGet(type, out selected) && parameters.Any(pair => !selected.Parameters.Any(parameter => parameter.Name == pair.Key));
+                }
+                catch (InvalidDataException) { invalid = true; }
+                repair.Button.IsVisible = invalid;
+                baseNotice = invalid ? PropertyEditorSupport.Text("Audio.SelectEffect") : update ? PropertyEditorSupport.Text("Audio.UnchangedParameters") : null;
+                Issues(null, new(null));
+                panel.IsEnabled = context.IsEnabled;
+            }
+            finally { refreshing = false; }
+        }
+        void Changed(object? sender, PropertyChangedEventArgs args) => Refresh();
+        context.PropertyChanged += Changed;
+        if (catalog is not null) catalog.Changed += Refresh;
+        var locale = PropertyEditorSupport.Localize(Refresh); Refresh();
+        return new(panel, () =>
+        {
+            disposed = true; context.PropertyChanged -= Changed;
+            if (catalog is not null) catalog.Changed -= Refresh;
+            Clear(); repair.Lifetime.Dispose(); locale.Dispose();
+        });
+    }
+    private static JsonObject Read(FieldEditorContext context)
+    {
+        if (context.EffectiveValue is not { } value) return new();
+        if (value.ValueKind != JsonValueKind.Object || value.EnumerateObject().GroupBy(property => property.Name, StringComparer.Ordinal).Any(group => group.Count() > 1))
+            throw new InvalidDataException("Effect parameters must be an object with unique fields.");
+        return JsonNode.Parse(value.GetRawText())!.AsObject();
+    }
+    private sealed class MemberBinding(FieldEditorContext parent, FieldDescriptor field, Func<bool> unavailable, Func<FieldValue, Task<ValueIssue?>> commit) : IFieldBinding
+    {
+        public FieldDraftState? Draft => parent.DraftState?.Child?.Invoke(@field, @field.Id);
+        public bool IsEnabled => !unavailable();
+        public FieldValue Read()
+        {
+            try { return AudioEffectParametersFieldEditor.Read(parent).TryGetPropertyValue(field.Id, out var value) ? new(JsonSerializer.SerializeToElement(value)) : default; }
+            catch (InvalidDataException) { return new(JsonSerializer.SerializeToElement("?")); }
+        }
+        public event EventHandler? Changed;
+        public void Refresh() => Changed?.Invoke(this, EventArgs.Empty);
+        public Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken token)
+        { token.ThrowIfCancellationRequested(); return IsEnabled ? commit(value) : Task.FromResult<ValueIssue?>(new("entry.obsolete", "Entry is unavailable.")); }
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Controls/AudioTrackFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/AudioTrackFieldEditor.cs
new file mode 100644
index 00000000..82717268
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Controls/AudioTrackFieldEditor.cs
@@ -0,0 +1,65 @@
+using System.ComponentModel;
+using System.Text.Json;
+using Avalonia.Controls;
+using GalNet.Contracts.Builtins;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Models.Graph;
+using GalNet.Game.Controls.Forms;
+
+namespace GalNet.Editor.Controls;
+
+internal static class AudioTrackFieldEditor
+{
+    public static FieldEditorLease Create(FieldEditorContext context, IProjectContentSession? content, bool target = false)
+    {
+        var input = new ComboBox { Name = "AudioTrackInput", HorizontalAlignment = global::Avalonia.Layout.HorizontalAlignment.Stretch };
+        var disposed = false; var updating = false; var busy = false;
+        void Refresh()
+        {
+            if (disposed) return;
+            updating = true;
+            try
+            {
+                var snapshot = content?.CaptureWorking();
+                var options = snapshot?.Configuration.ReadDefaultOptions();
+                var bus = target && context.HostContext is IEntryFieldOrigin { GroupId: { } group } origin && snapshot is not null &&
+                    snapshot.GroupEntries.TryGetValue(group, out var entries) &&
+                    entries.FirstOrDefault(entry => entry.StableId == origin.EntryId)?.Parameters.TryGetValue("scope", out var scope) == true &&
+                    scope.ValueKind == JsonValueKind.String && scope.GetString() == "bus";
+                var rows = bus
+                    ? options!.AudioBuses.Select(item => new TrackOption(item.Id, string.IsNullOrEmpty(item.Name) ? item.Id : $"{item.Name} ({item.Id})")).ToList()
+                    : (options?.AudioTracks ?? []).Select(item => new TrackOption(item.Id, string.IsNullOrEmpty(item.Name) ? item.Id : $"{item.Name} ({item.Id})")).ToList();
+                var value = context.EffectiveValue;
+                var id = value is { ValueKind: JsonValueKind.String } json ? json.GetString() : null;
+                // Keep unresolved author IDs visible without selecting a replacement on refresh.
+                if (id is not null && rows.All(row => row.Id != id)) rows.Add(new(id, id));
+                if (input.ItemsSource is not List<TrackOption> existing || !existing.SequenceEqual(rows)) input.ItemsSource = rows;
+                input.SelectedItem = input.Items.Cast<TrackOption>().FirstOrDefault(row => row.Id == id);
+                input.IsEnabled = context.IsEnabled && !busy;
+            }
+            finally { updating = false; }
+        }
+        void Changed(object? sender, PropertyChangedEventArgs args) => Refresh();
+        input.SelectionChanged += async (_, _) =>
+        {
+            if (updating || disposed || busy || !context.IsEnabled || input.SelectedItem is not TrackOption selected) return;
+            busy = true;
+            try { await context.CommitAsync(new(JsonSerializer.SerializeToElement(selected.Id))); }
+            finally { busy = false; Refresh(); }
+        };
+        input.DropDownOpened += (_, _) => Refresh();
+        context.PropertyChanged += Changed;
+        if (content is not null) content.Changed += Refresh;
+        Refresh();
+        return new(input, () =>
+        {
+            disposed = true; context.PropertyChanged -= Changed;
+            if (content is not null) content.Changed -= Refresh;
+        });
+    }
+
+    private sealed record TrackOption(string Id, string Label)
+    {
+        public override string ToString() => Label;
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Controls/AuthorFormStyles.axaml b/src/Editor/GalNet.Editor/Controls/AuthorFormStyles.axaml
index 6880310c..2e0f4e03 100644
--- a/src/Editor/GalNet.Editor/Controls/AuthorFormStyles.axaml
+++ b/src/Editor/GalNet.Editor/Controls/AuthorFormStyles.axaml
@@ -12,6 +12,11 @@
             <Setter Property="RevertText" Value="{loc:Localize Form.Revert}" />
         </Style>
         <Style Selector="Expander.structured-field">
+            <Setter Property="forms:StructuredFieldEditor.TitleText" Value="{loc:Localize Label, FallbackPath=Field.Id}" />
+            <Setter Property="forms:StructuredFieldEditor.KeyText" Value="{loc:Localize Form.MapKey}" />
+            <Setter Property="forms:StructuredFieldEditor.DuplicateKeyText" Value="{loc:Localize Form.MapKeyDuplicate}" />
+            <Setter Property="forms:StructuredFieldEditor.ChildIndent" Value="12" />
+            <Setter Property="forms:StructuredFieldEditor.ItemSpacing" Value="6" />
             <Setter Property="forms:StructuredFieldEditor.ExpandByDefault" Value="True" />
             <Setter Property="forms:StructuredFieldEditor.ObjectText" Value="{loc:Localize Form.Object}" />
             <Setter Property="forms:StructuredFieldEditor.ListText" Value="{loc:Localize Form.List}" />
diff --git a/src/Editor/GalNet.Editor/Controls/BranchOptionListEditorControl.axaml b/src/Editor/GalNet.Editor/Controls/BranchOptionListEditorControl.axaml
index 20438cbe..05c4e9a2 100644
--- a/src/Editor/GalNet.Editor/Controls/BranchOptionListEditorControl.axaml
+++ b/src/Editor/GalNet.Editor/Controls/BranchOptionListEditorControl.axaml
@@ -4,6 +4,28 @@
     <Button ToolTip.Tip="{loc:Localize Graph.Branch.Add}" AutomationProperties.Name="{loc:Localize Graph.Branch.Add}" HorizontalAlignment="Left" Command="{Binding AddCommand, ElementName=Root}">
       <TextBlock Text="{loc:Localize Graph.Branch.Add}" />
     </Button>
-    <ListBox x:Name="ItemsListBox" Grid.Row="1" ItemsSource="{Binding ItemsSource, ElementName=Root}" Background="Transparent"><ListBox.ItemTemplate><DataTemplate x:DataType="models:BranchOptionEditorItemViewModel"><Border Margin="0,4" Padding="8" Background="{DynamicResource SemiColorBackground1}" BorderBrush="{DynamicResource SemiColorBorder}" BorderThickness="1" CornerRadius="6"><Grid ColumnDefinitions="Auto,*,*,Auto" ColumnSpacing="6"><Border Padding="6,0" VerticalAlignment="Center" Background="Transparent" Cursor="SizeAll" PointerPressed="OnDragHandlePressed"><TextBlock Text="::" /></Border><controls:GameTextBox Grid.Column="1" Binding="{Binding TextBinding}" Authoring="{Binding GameTexts}" AutomationProperties.Name="{loc:Localize Graph.Branch.Text}" /><controls:ConditionEditorControl ToolTip.Tip="{loc:Localize Graph.Branch.Condition}" AutomationProperties.Name="{loc:Localize Graph.Branch.Condition}" Grid.Column="2" Text="{Binding Condition}" Suggestions="{Binding ConditionSuggestions, ElementName=Root}" ValidationVariables="{Binding ValidationVariables, ElementName=Root}" /><Button Grid.Column="3" ToolTip.Tip="{loc:Localize Graph.Branch.Remove}" AutomationProperties.Name="{loc:Localize Graph.Branch.Remove}" Command="{Binding RemoveCommand, ElementName=Root}" CommandParameter="{Binding}"><TextBlock Text="×" /></Button></Grid></Border></DataTemplate></ListBox.ItemTemplate></ListBox>
+    <ListBox x:Name="ItemsListBox" Grid.Row="1" ItemsSource="{Binding ItemsSource, ElementName=Root}"
+             Background="Transparent">
+      <ListBox.ItemTemplate>
+        <DataTemplate x:DataType="models:BranchOptionEditorItemViewModel">
+          <Border Margin="0,4" Padding="8" Background="{DynamicResource SemiColorBackground1}" BorderBrush="{DynamicResource SemiColorBorder}" BorderThickness="1" CornerRadius="6">
+            <Grid ColumnDefinitions="Auto,*,*,Auto" ColumnSpacing="6">
+              <Border Padding="6,0" Height="32" VerticalAlignment="Center" Background="Transparent" Cursor="SizeAll" PointerPressed="OnDragHandlePressed">
+                <TextBlock Text="::" />
+              </Border>
+              <controls:GameTextBox Grid.Column="1" Binding="{Binding TextBinding}" Authoring="{Binding GameTexts}"
+                                   VerticalAlignment="Top" AutomationProperties.Name="{loc:Localize Graph.Branch.Text}" />
+              <controls:ConditionEditorControl ToolTip.Tip="{loc:Localize Graph.Branch.Condition}" AutomationProperties.Name="{loc:Localize Graph.Branch.Condition}" Grid.Column="2"
+                                               VerticalAlignment="Top"
+                                               Text="{Binding Condition}" Suggestions="{Binding ConditionSuggestions, ElementName=Root}"
+                                               ValidationVariables="{Binding ValidationVariables, ElementName=Root}" />
+              <Button Grid.Column="3" Height="32" VerticalAlignment="Top" ToolTip.Tip="{loc:Localize Graph.Branch.Remove}" AutomationProperties.Name="{loc:Localize Graph.Branch.Remove}" Command="{Binding RemoveCommand, ElementName=Root}" CommandParameter="{Binding}">
+                <TextBlock Text="×" />
+              </Button>
+            </Grid>
+          </Border>
+        </DataTemplate>
+      </ListBox.ItemTemplate>
+    </ListBox>
   </Grid>
 </controls:ReorderableListControl>
diff --git a/src/Editor/GalNet.Editor/Controls/ColorFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/ColorFieldEditor.cs
index 46d39c18..7b262e1d 100644
--- a/src/Editor/GalNet.Editor/Controls/ColorFieldEditor.cs
+++ b/src/Editor/GalNet.Editor/Controls/ColorFieldEditor.cs
@@ -12,7 +12,8 @@ namespace GalNet.Editor.Controls;
 
 internal static class ColorFieldEditor
 {
-    public static FieldEditorLease Create(FieldEditorContext context)
+    public static FieldEditorLease Create(FieldEditorContext context) => Create(context, false);
+    public static FieldEditorLease Create(FieldEditorContext context, bool rgba)
     {
         var panel = new Grid { Name = "ColorEditor", ColumnDefinitions = new("Auto,*"), RowDefinitions = new("Auto,Auto"), ColumnSpacing = 8 };
         var swatch = new Border { Width = 24, Height = 18, BorderThickness = new(1), BorderBrush = Brushes.Gray };
@@ -37,7 +38,7 @@ void Refresh()
             try
             {
                 input.Text = context.Text;
-                var valid = Color.TryParse(context.Text, out var color);
+                var valid = TryHex(context.Text, rgba, out var color);
                 swatch.Background = valid ? new SolidColorBrush(color) : Brushes.Transparent;
                 panel.IsEnabled = context.IsEnabled;
                 ShowError(context.Text.Length > 0 && !valid ? PropertyEditorSupport.Text("Form.ColorInvalid") : context.Issue?.Message);
@@ -48,8 +49,8 @@ async Task CommitText()
         {
             if (disposed || opened || !context.HasDraft) return;
             if (context.Text.Length == 0 && context.CanOmit) { await context.OmitAsync(); return; }
-            if (!TryHex(context.Text, out var color)) { ShowError(PropertyEditorSupport.Text("Form.ColorInvalid")); return; }
-            await context.CommitValueAsync(Hex(color)); Refresh();
+            if (!TryHex(context.Text, rgba, out var color)) { ShowError(PropertyEditorSupport.Text("Form.ColorInvalid")); return; }
+            await context.CommitValueAsync(Hex(color, rgba)); Refresh();
         }
         void Changed(object? sender, PropertyChangedEventArgs args) => Refresh();
         input.TextChanged += (_, _) => { if (!syncing) { context.Text = input.Text ?? ""; } };
@@ -62,14 +63,14 @@ async Task CommitText()
         flyout.Opened += (_, _) =>
         {
             context.RevertDraft(); baseline = context.Value; opened = true;
-            picker.Color = Color.TryParse(context.Text, out var color) ? color : Colors.Transparent;
+            picker.Color = TryHex(context.Text, rgba, out var color) ? color : Colors.Transparent;
         };
         flyout.Closed += (_, _) => { opened = false; Refresh(); };
         apply.Click += async (_, _) =>
         {
             if (!opened || disposed || !context.IsEnabled || !Same(baseline, context.Value)) { flyout.Hide(); return; }
             ownCommit = true;
-            try { if (await context.CommitValueAsync(Hex(picker.Color))) flyout.Hide(); }
+            try { if (await context.CommitValueAsync(Hex(picker.Color, rgba))) flyout.Hide(); }
             finally { ownCommit = false; Refresh(); }
         };
         cancel.Click += (_, _) => flyout.Hide();
@@ -83,10 +84,13 @@ async Task CommitText()
         return new(panel, () => { disposed = true; flyout.Hide(); context.PropertyChanged -= Changed; locale.Dispose(); });
     }
     private static bool Same(FieldValue a, FieldValue b) => a.IsProvided == b.IsProvided && (!a.IsProvided || JsonElement.DeepEquals(a.Json!.Value, b.Json!.Value));
-    private static bool TryHex(string text, out Color color)
+    private static bool TryHex(string text, bool rgba, out Color color)
     {
         color = default;
-        return text.Length is 7 or 9 && text[0] == '#' && uint.TryParse(text.AsSpan(1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out _) && Color.TryParse(text, out color);
+        if (text.Length is not (7 or 9) || text[0] != '#' || !uint.TryParse(text.AsSpan(1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out _)) return false;
+        var value = rgba && text.Length == 9 ? "#" + text[7..9] + text[1..7] : text;
+        return Color.TryParse(value, out color);
     }
-    private static string Hex(Color color) => color.A == 255 ? $"#{color.R:X2}{color.G:X2}{color.B:X2}" : $"#{color.A:X2}{color.R:X2}{color.G:X2}{color.B:X2}";
+    private static string Hex(Color color, bool rgba) => color.A == 255 ? $"#{color.R:X2}{color.G:X2}{color.B:X2}"
+        : rgba ? $"#{color.R:X2}{color.G:X2}{color.B:X2}{color.A:X2}" : $"#{color.A:X2}{color.R:X2}{color.G:X2}{color.B:X2}";
 }
diff --git a/src/Editor/GalNet.Editor/Controls/ConditionEditorControl.axaml b/src/Editor/GalNet.Editor/Controls/ConditionEditorControl.axaml
index b8214410..19a67149 100644
--- a/src/Editor/GalNet.Editor/Controls/ConditionEditorControl.axaml
+++ b/src/Editor/GalNet.Editor/Controls/ConditionEditorControl.axaml
@@ -6,6 +6,7 @@
              x:Name="Root">
     <Grid RowDefinitions="Auto,Auto">
         <TextBox x:Name="EditorBox"
+                 MinHeight="32" VerticalContentAlignment="Center"
                  Text="{Binding Text, ElementName=Root, Mode=TwoWay}"
                  PlaceholderText="{loc:Localize Condition.Placeholder}" />
         <Border x:Name="ValidationBorder"
diff --git a/src/Editor/GalNet.Editor/Controls/EditorFieldEditors.cs b/src/Editor/GalNet.Editor/Controls/EditorFieldEditors.cs
index 2e6ebbc7..9ef4f433 100644
--- a/src/Editor/GalNet.Editor/Controls/EditorFieldEditors.cs
+++ b/src/Editor/GalNet.Editor/Controls/EditorFieldEditors.cs
@@ -2,8 +2,9 @@
 using Avalonia.Controls.Templates;
 using Avalonia.Data;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Parameters;
-using GalNet.Core.Scene;
+using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.MarkupExtensions;
 using GalNet.Editor.Models.Graph;
 using GalNet.Editor.Services;
@@ -14,9 +15,12 @@ namespace GalNet.Editor.Controls;
 /// <summary>Editor-owned presentation extensions; value conversion and submission stay in the shared factory.</summary>
 public static class EditorFieldEditors
 {
-    public static EditorRegistry CreateDefault(SceneTargetCatalog? scenes = null, Action<FieldEditorContext>? openTimeline = null, GalNet.Core.Assets.IAssetManager? assets = null, CharacterAuthoringService? characters = null, GameTextAuthoringService? texts = null)
+    public static EditorRegistry CreateDefault(SceneTargetCatalog? scenes = null, Action<FieldEditorContext>? openTimeline = null, GalNet.Core.Assets.IAssetManager? assets = null, CharacterAuthoringService? characters = null, GameTextAuthoringService? texts = null, IProjectContentSession? content = null, ProjectSceneTargets? shaderPrograms = null)
     {
-        var registry = EditorRegistry.CreateDefault(emptyInputClearsOptionalFields: true, copyValue: texts is null ? null : texts.StageCopy);
+        var registry = EditorRegistry.CreateDefault(emptyInputClearsOptionalFields: true, copyValue: texts is null ? null : texts.StageCopy,
+            formatIssue: (field, issue) => EditorProblemText.Value(field, issue));
+        registry.Replace(ValueEditorIds.Numeric, NumericFieldEditors.CreateUpDown);
+        registry.Replace(ValueEditorIds.Slider, NumericFieldEditors.CreateSliderWithInput);
         if (characters is not null) registry.RegisterSemantic(FieldValueSemantic.CharacterReference, context => CharacterFieldEditor.Create(context, characters));
         if (texts is not null) registry.RegisterSemantic(FieldValueSemantic.LocalizedText, context => GameTextFieldEditor.Create(context, texts));
         registry.Register("entry.imageasset", context => AssetFieldEditor.Create(context, assets, Models.AssetPickerFilter.Image));
@@ -24,11 +28,36 @@ public static EditorRegistry CreateDefault(SceneTargetCatalog? scenes = null, Ac
         registry.Register("entry.effectprogramasset", context => AssetFieldEditor.Create(context, assets, Models.AssetPickerFilter.EffectProgram));
         registry.Register("entry.audioasset", context => AssetFieldEditor.Create(context, assets, Models.AssetPickerFilter.Audio));
         registry.Register("entry.videoasset", context => AssetFieldEditor.Create(context, assets, Models.AssetPickerFilter.Video));
+        registry.Register("shader.color", context => ColorFieldEditor.Create(context, rgba: true));
+        registry.Register("shader.vector2", context => ShaderVectorFieldEditor.Create(context, 2));
+        registry.Register("shader.vector3", context => ShaderVectorFieldEditor.Create(context, 3));
+        registry.Register("shader.vector4", context => ShaderVectorFieldEditor.Create(context, 4));
         foreach (var id in new[] { "entry.autocomplete", "entry.multilinetext" })
             registry.Register(id, context => DefaultFieldEditors.CreateText(context));
         registry.Register("entry.expression", context => AuthoringExpressionFieldEditors.Expression(context, () => [], () => []));
         registry.Register("entry.variablename", context => AuthoringExpressionFieldEditors.Variable(context, () => []));
         registry.RegisterDefault<LayerTransform>(TransformFieldEditor.Create);
+        registry.RegisterMember<MotionPresetOptions>(value => value.Transform, TransformFieldEditor.Create);
+        registry.RegisterMember<RevealTransitionOptions>(value => value.Center, context => ShaderVectorFieldEditor.Create(context, 2));
+        registry.RegisterMember<SpeedLinesPresetOptions>(value => value.Parameters, context => PresetShaderParametersFieldEditor.Create(context, shaderPrograms));
+        registry.RegisterMember<ImpactPresetOptions>(value => value.Parameters, context => PresetShaderParametersFieldEditor.Create(context, shaderPrograms));
+        registry.RegisterMember<LayerShowOptions>(value => value.Flipbook, FlipbookFieldEditor.Create);
+        FieldEditorLease Track(FieldEditorContext context) => AudioTrackFieldEditor.Create(context, content);
+        registry.RegisterMember<AudioTrackOptions>(value => value.TrackId, Track);
+        registry.RegisterMember<AudioStopOptions>(value => value.TrackId, Track);
+        registry.RegisterMember<AudioPlayOptions>(value => value.TrackId, Track);
+        FieldEditorLease AudioTarget(FieldEditorContext context) => AudioTrackFieldEditor.Create(context, content, target: true);
+        registry.RegisterMember<AudioSEffectOptions>(value => value.TargetId, AudioTarget);
+        registry.RegisterMember<AudioSEffectStopOptions>(value => value.TargetId, AudioTarget);
+        registry.RegisterMember<AudioSEffectUpdateOptions>(value => value.TargetId, AudioTarget);
+        registry.RegisterMember<AudioSEffectOptions>(value => value.Id, context => AudioEffectFieldEditor.Type(context, scenes));
+        registry.RegisterMember<AudioSEffectOptions>(value => value.Parameters, context => AudioEffectParametersFieldEditor.Create(context, scenes));
+        registry.RegisterMember<AudioSEffectUpdateOptions>(value => value.Parameters, context => AudioEffectParametersFieldEditor.Create(context, scenes));
+        registry.RegisterMember<AudioSEffectStopOptions>(value => value.InstanceId, context => AudioEffectFieldEditor.Instance(context, scenes));
+        registry.RegisterMember<AudioSEffectUpdateOptions>(value => value.InstanceId, context => AudioEffectFieldEditor.Instance(context, scenes));
+        registry.RegisterMember<AudioLevelOptions>(value => value.TargetId, AudioTarget);
+        registry.RegisterMember<TextVoiceOptions>(value => value.TrackId, Track);
+        registry.RegisterMember<NvlVoiceOptions>(value => value.TrackId, Track);
         registry.RegisterMember<LayerShowOptions>(value => value.Transform, TransformFieldEditor.Create);
         registry.RegisterMember<VariantsShowOptions>(value => value.Transform, TransformFieldEditor.Create);
         registry.RegisterMember<LayerColorOptions>(value => value.Transform, TransformFieldEditor.Create);
@@ -71,6 +100,8 @@ public static EditorRegistry CreateDefault(SceneTargetCatalog? scenes = null, Ac
             registry.RegisterMember<VariantsSelectOptions>(options => options.Dimension, context => VariantFieldEditor.Create(context, scenes, selection: false, dimension: true));
             registry.RegisterMember<VariantsSelectOptions>(options => options.Value, context => VariantFieldEditor.Create(context, scenes, selection: false));
             FieldEditorLease Target(FieldEditorContext context) => SceneTargetFieldEditor.Create(context, scenes);
+            registry.RegisterMember<ShakePresetOptions>(options => options.HandleId, Target);
+            registry.RegisterMember<ImpactPresetOptions>(options => options.HandleId, Target);
             registry.RegisterMember<LayerHandleOptions>(options => options.HandleId, Target);
             registry.RegisterMember<LayerMoveOptions>(options => options.HandleId, Target);
             registry.RegisterMember<LayerReplaceOptions>(options => options.HandleId, Target);
diff --git a/src/Editor/GalNet.Editor/Controls/EntryListEditorControl.axaml b/src/Editor/GalNet.Editor/Controls/EntryListEditorControl.axaml
index 81278a18..3b6d2079 100644
--- a/src/Editor/GalNet.Editor/Controls/EntryListEditorControl.axaml
+++ b/src/Editor/GalNet.Editor/Controls/EntryListEditorControl.axaml
@@ -10,16 +10,25 @@
              MoveCommand="{Binding ReorderEntryCommand}" Focusable="True">
     <controls:ReorderableListControl.Styles>
         <StyleInclude Source="avares://GalNet.Editor/Controls/AuthorFormStyles.axaml"/>
+        <Style Selector="controls|EntryTypePicker">
+            <Setter Property="MinWidth" Value="140" />
+        </Style>
         <Style Selector="Border.debugEntry"><Setter Property="BorderBrush" Value="{DynamicResource SemiColorBorder}"/><Setter Property="BorderThickness" Value="1"/></Style>
         <Style Selector="Border.debugEntry.debugCurrent"><Setter Property="BorderBrush" Value="{DynamicResource SemiColorSuccess}"/><Setter Property="BorderThickness" Value="3"/></Style>
+        <Style Selector="Border.pendingMove"><Setter Property="Opacity" Value="0.65"/></Style>
+        <Style Selector="Button.entryProblems"><Setter Property="Foreground" Value="{DynamicResource SemiColorWarning}"/></Style>
+        <Style Selector="Button.entryProblems.error"><Setter Property="Foreground" Value="{DynamicResource SemiColorDanger}"/></Style>
     </controls:ReorderableListControl.Styles>
     <Grid RowDefinitions="Auto,*,Auto">
         <WrapPanel x:Name="EntryToolbar" Orientation="Horizontal">
+            <StackPanel Orientation="Horizontal">
+                <TextBlock Text="{Binding MoveStatus}" VerticalAlignment="Center" Margin="0,0,6,0" TextWrapping="Wrap"/>
+                <Button Name="CancelEntryMove" Content="{loc:Localize Entry.MoveCancel}" Command="{Binding CancelPendingMoveCommand}" IsVisible="{Binding HasPendingMove}" Margin="0,0,6,0"/>
+            </StackPanel>
             <TextBox Width="170" Text="{Binding SearchText}" PlaceholderText="{loc:Localize Uiux.Entry.Search}" Margin="0,0,6,0" />
-            <Button Theme="{DynamicResource EditorIconButton}" ToolTip.Tip="{loc:Localize Entry.Add}" AutomationProperties.Name="{loc:Localize Entry.Add}" Command="{Binding AddEntryCommand}" Margin="0,0,6,0"><PathIcon Width="16" Height="16" Data="{StaticResource AddIcon}"/></Button>
-            <Button Content="{loc:Localize Entry.AppendBatch}" Command="{Binding AppendEntriesCommand}" Margin="0,0,6,0" />
+            <controls:EntryTypePicker x:Name="InsertPicker" ButtonLabel="{loc:Localize Entry.Add}" Options="{Binding EntryTypes}" ShortcutService="{Binding ShortcutService}" Opened="OnInsertPickerOpened" Closed="OnInsertPickerClosed" TypeConfirmed="OnInsertTypeConfirmed" Margin="0,0,6,0" />
+            <controls:EntryTypePicker x:Name="AppendPicker" ButtonLabel="{loc:Localize Entry.AppendBatch}" Options="{Binding EntryTypes}" ShortcutService="{Binding ShortcutService}" TypeConfirmed="OnAppendTypeConfirmed" Margin="0,0,6,0" />
             <NumericUpDown x:Name="BatchCount" Width="90" Minimum="1" Maximum="1000" Increment="1" FormatString="0" Value="{Binding BatchAddCount,Mode=TwoWay}" Margin="0,0,6,0" ToolTip.Tip="{loc:Localize Entry.BatchCount}" />
-            <controls:EntryTypePicker x:Name="InsertPicker" MinWidth="180" MinHeight="32" VerticalAlignment="Center" Options="{Binding EntryTypes}" ShortcutService="{Binding ShortcutService}" SelectedValue="{Binding InsertionType,Mode=OneWay}" Opened="OnInsertPickerOpened" Closed="OnInsertPickerClosed" TypeConfirmed="OnInsertTypeConfirmed" />
             <Button Theme="{DynamicResource EditorIconButton}" ToolTip.Tip="{loc:Localize Uiux.Entry.ExpandAll}" AutomationProperties.Name="{loc:Localize Uiux.Entry.ExpandAll}" Command="{Binding ExpandAllCommand}" Margin="0,0,6,0"><PathIcon Width="16" Height="16" Data="{StaticResource ChevronDownRegular}"/></Button>
             <Button Theme="{DynamicResource EditorIconButton}" ToolTip.Tip="{loc:Localize Uiux.Entry.CollapseAll}" AutomationProperties.Name="{loc:Localize Uiux.Entry.CollapseAll}" Command="{Binding CollapseAllCommand}" Margin="0,0,6,0"><PathIcon Width="16" Height="16" Data="{StaticResource ChevronUpRegular}"/></Button>
         </WrapPanel>
@@ -36,12 +45,14 @@
                 <DataTemplate x:DataType="models:EntryEditorItemViewModel">
                     <Border Margin="0,3"
                             Classes="debugEntry"
+                            Classes.pendingMove="{Binding IsPendingMove}"
                             Classes.debugCurrent="{Binding IsDebugCurrent}"
                             Padding="6"
                             Background="{DynamicResource SemiColorBackground1}"
                             CornerRadius="6">
                         <StackPanel>
-                        <Grid ColumnDefinitions="Auto,48,140,*,Auto,Auto"
+                        <!-- Match the field editors' 130-DIP label column plus 8-DIP spacing. -->
+                        <Grid ColumnDefinitions="24,98,Auto,*,Auto,Auto"
                               ColumnSpacing="8">
                             <Border Padding="6,0"
                                     VerticalAlignment="Center"
@@ -57,7 +68,7 @@
                                                       Options="{Binding #Root.DataContext.EntryTypes}"
                                                       ShortcutService="{Binding #Root.DataContext.ShortcutService}"
                                                       SelectedValue="{Binding Type, Mode=OneWay}" TypeConfirmed="OnEntryTypeConfirmed"
-                                                      MinHeight="32" VerticalAlignment="Center" HorizontalAlignment="Stretch" />
+                                                      MinWidth="140" MinHeight="32" VerticalAlignment="Center" HorizontalAlignment="Left" />
                             <controls:ConditionEditorControl Grid.Column="3"
                                                              IsVisible="{Binding !#Root.UseCommonFields}"
                                                              Text="{Binding Condition}"
@@ -67,7 +78,7 @@
                                 <TextBlock Text="{Binding Summary}" Margin="0,0,32,0" TextTrimming="CharacterEllipsis" ToolTip.Tip="{Binding Summary}" />
                                 <TextBlock Text="{Binding Condition}" IsVisible="{Binding HasCondition}" FontSize="11" Foreground="{DynamicResource SemiColorText2}" TextTrimming="CharacterEllipsis" />
                             </StackPanel>
-                            <Button Grid.Column="3" HorizontalAlignment="Right" Content="{Binding ProblemCount}" IsVisible="{Binding HasProblems}" Foreground="{DynamicResource SemiColorDanger}"
+                            <Button Grid.Column="3" HorizontalAlignment="Right" Content="{Binding ProblemCount}" IsVisible="{Binding HasProblems}" Classes="entryProblems" Classes.error="{Binding HasProblemErrors}"
                                     ToolTip.Tip="{loc:Localize Uiux.Problems}" Command="{Binding #Root.DataContext.ShowEntryProblemsCommand}" CommandParameter="{Binding}"/>
                             <ToggleButton Name="ParametersToggle" Grid.Column="4"
                                           Theme="{DynamicResource EditorIconToggleButton}"
@@ -93,6 +104,8 @@
                                     CommandParameter="{Binding}"><PathIcon Width="16" Height="16" Data="{StaticResource DeleteRegularIcon}" /></Button>
                         </Grid>
                         <StackPanel Margin="0,6,0,0" Spacing="4" IsVisible="{Binding #ParametersToggle.IsChecked}">
+                            <forms:DtoEditorHost Item="{Binding EffectInlineForm.Item}" Registry="{Binding #Root.DataContext.FieldEditors}" IsVisible="{Binding IsEffectApply}" />
+                            <StackPanel IsVisible="{Binding !IsEffectApply}">
                             <forms:DtoEditorHost Item="{Binding DetailForm.Item}" Registry="{Binding #Root.DataContext.FieldEditors}" DisplayMode="Common" IsVisible="{Binding #Root.UseCommonFields}" />
                             <StackPanel IsVisible="{Binding !#Root.UseCommonFields}">
                             <TextBlock Text="{loc:Localize Entry.UnknownTypePreserved}" IsVisible="{Binding IsUnknownType}" TextWrapping="Wrap" />
@@ -119,6 +132,7 @@
                             <TextBlock Text="{Binding EffectHint}" Opacity="0.72" TextWrapping="Wrap" IsVisible="{Binding !HasEffectDiagnostic}" />
                             <TextBlock Text="{Binding EffectDiagnostic}" Foreground="{DynamicResource SystemControlErrorTextForegroundBrush}" TextWrapping="Wrap" IsVisible="{Binding HasEffectDiagnostic}" />
                             </StackPanel>
+                            </StackPanel>
 
                         </StackPanel>
                         </StackPanel>
diff --git a/src/Editor/GalNet.Editor/Controls/EntryListEditorControl.axaml.cs b/src/Editor/GalNet.Editor/Controls/EntryListEditorControl.axaml.cs
index aec93960..f8c8138a 100644
--- a/src/Editor/GalNet.Editor/Controls/EntryListEditorControl.axaml.cs
+++ b/src/Editor/GalNet.Editor/Controls/EntryListEditorControl.axaml.cs
@@ -93,14 +93,16 @@ private void OnInsertPickerClosed(object? sender, System.EventArgs args)
         (DataContext as GroupEditorPanelViewModel)?.CancelInsertion();
         if (_quickInsert) ItemsListBox.Focus(); _quickInsert = false;
     }
+    private void OnAppendTypeConfirmed(object? sender, EntryTypeConfirmedEventArgs args)
+    { if (DataContext is GroupEditorPanelViewModel vm) vm.InsertChosenType(args.Type, null); ScrollSelectionIntoView(); }
     private void OnInsertTypeConfirmed(object? sender, EntryTypeConfirmedEventArgs args)
     {
-        if (DataContext is GroupEditorPanelViewModel vm) vm.InsertType(args.Type, _insertAnchor);
+        if (DataContext is GroupEditorPanelViewModel vm) { if (_quickInsert) vm.InsertType(args.Type, _insertAnchor); else vm.InsertChosenType(args.Type, _insertAnchor); }
         ScrollSelectionIntoView();
     }
-    private void OnEntryTypeConfirmed(object? sender, EntryTypeConfirmedEventArgs args)
+    private async void OnEntryTypeConfirmed(object? sender, EntryTypeConfirmedEventArgs args)
     {
-        if (sender is Control { DataContext: EntryEditorItemViewModel entry } && DataContext is GroupEditorPanelViewModel vm) vm.ChangeType(entry, args.Type);
+        if (sender is Control { DataContext: EntryEditorItemViewModel entry }) await RunEntryAction(vm => vm.ChangeTypeAsync(entry, args.Type));
     }
 
     private async void OnListKeyDown(object? sender, KeyEventArgs e)
@@ -121,11 +123,12 @@ private async void OnListKeyDown(object? sender, KeyEventArgs e)
         if (e.Key == Key.Delete && e.KeyModifiers == KeyModifiers.None)
         {
             e.Handled = true;
-            await RunEntryAction(vm => { vm.DeleteSelection(); return Task.CompletedTask; });
+            await RunEntryAction(vm => vm.DeleteSelectionAsync());
             return;
         }
         if (e.Key == Key.Escape && e.KeyModifiers == KeyModifiers.None)
         {
+            viewModel.CancelPendingMove();
             viewModel.SetSelection([]); e.Handled = true; return;
         }
 
@@ -145,13 +148,15 @@ private async void OnListKeyDown(object? sender, KeyEventArgs e)
 
     public Task CopySelectionAsync(bool cut = false) => RunEntryAction(async vm =>
     {
-        var ids = vm.SelectedEntries.Select(entry => entry.StableId).ToArray();
-        var text = vm.CopySelection();
+        var offer = cut ? vm.PrepareCutSelection() : null;
+        var text = cut ? offer?.Text ?? "" : vm.CopySelection();
         if (text.Length == 0) return;
         await WriteClipboardAsync(text);
-        // A failed clipboard write must never remove the originals. A late completion
-        // after the page/project closes must not modify a replacement project.
-        if (cut && !vm.IsDisposed && ReferenceEquals(DataContext, vm)) vm.DeleteCopiedEntries(ids, text);
+        if (!vm.IsDisposed && ReferenceEquals(DataContext, vm))
+        {
+            if (offer is not null) vm.BeginCut(offer);
+            else vm.CancelPendingMove();
+        }
     });
 
     public Task PasteSelectionAsync() => RunEntryAction(async vm =>
@@ -207,7 +212,7 @@ void Add(string key, string gesture, Func<Task> action, bool enabled = true)
         Add("Entry.Menu.Cut", "Ctrl+X", () => CopySelectionAsync(cut: true), selected);
         Add("Entry.Menu.Paste", "Ctrl+V", PasteSelectionAsync);
         Add("Entry.Menu.Duplicate", "Ctrl+D", () => RunEntryAction(model => model.DuplicateSelectionAsync()), selected);
-        Add("Entry.Menu.Delete", "Delete", () => RunEntryAction(model => { model.DeleteSelection(); return Task.CompletedTask; }), selected);
+        Add("Entry.Menu.Delete", "Delete", () => RunEntryAction(model => model.DeleteSelectionAsync()), selected);
         menu.Items.Add(new Separator());
         Add("Entry.Menu.SelectAll", "Ctrl+A", () => { ItemsListBox.SelectAll(); return Task.CompletedTask; });
         menu.ShowAt((Control?)row ?? ItemsListBox); args.Handled = true;
diff --git a/src/Editor/GalNet.Editor/Controls/EntryTypePicker.axaml b/src/Editor/GalNet.Editor/Controls/EntryTypePicker.axaml
index c1cc6d3f..c2c8aa68 100644
--- a/src/Editor/GalNet.Editor/Controls/EntryTypePicker.axaml
+++ b/src/Editor/GalNet.Editor/Controls/EntryTypePicker.axaml
@@ -4,14 +4,18 @@
              xmlns:loc="using:GalNet.Editor.MarkupExtensions"
              x:Class="GalNet.Editor.Controls.EntryTypePicker"
              x:Name="Root"
+             HorizontalContentAlignment="Stretch"
              Focusable="True">
     <Grid>
         <ToggleButton x:Name="OpenButton"
                       IsChecked="{Binding #PickerPopup.IsOpen, Mode=TwoWay}"
+                      HorizontalAlignment="Stretch"
                       HorizontalContentAlignment="Stretch">
             <Grid ColumnDefinitions="*,Auto" ColumnSpacing="8">
-                <TextBlock Text="{Binding SelectedDisplayName,ElementName=Root}" />
-                <TextBlock Grid.Column="1" Text="{Binding SelectedGestureText, ElementName=Root}"
+                <TextBlock Text="{Binding SelectedDisplayName,ElementName=Root}" IsVisible="{Binding !#Root.IsButtonMode}"
+                           HorizontalAlignment="Left" TextAlignment="Left" />
+                <TextBlock Text="{Binding ButtonLabel,ElementName=Root}" IsVisible="{Binding #Root.IsButtonMode}" />
+                <TextBlock Grid.Column="1" Text="{Binding SelectedGestureText, ElementName=Root}" IsVisible="{Binding !#Root.IsButtonMode}"
                            Foreground="{DynamicResource SemiColorText2}" FontSize="11" />
             </Grid>
         </ToggleButton>
diff --git a/src/Editor/GalNet.Editor/Controls/EntryTypePicker.axaml.cs b/src/Editor/GalNet.Editor/Controls/EntryTypePicker.axaml.cs
index c4141d85..38d2ccac 100644
--- a/src/Editor/GalNet.Editor/Controls/EntryTypePicker.axaml.cs
+++ b/src/Editor/GalNet.Editor/Controls/EntryTypePicker.axaml.cs
@@ -18,7 +18,6 @@
 using GalNet.Editor.Commands;
 using GalNet.Editor.Models.Graph;
 using GalNet.Editor.Services;
-using GalNet.Primitives.Builtins;
 
 namespace GalNet.Editor.Controls;
 
@@ -28,6 +27,13 @@ public sealed class EntryTypeConfirmedEventArgs(string type) : EventArgs { publi
 
 public partial class EntryTypePicker : UserControl
 {
+    public static readonly DirectProperty<EntryTypePicker, bool> IsButtonModeProperty =
+        AvaloniaProperty.RegisterDirect<EntryTypePicker, bool>(nameof(IsButtonMode), picker => picker.IsButtonMode);
+    public static readonly StyledProperty<string?> ButtonLabelProperty =
+        AvaloniaProperty.Register<EntryTypePicker, string?>(nameof(ButtonLabel));
+    public string? ButtonLabel { get => GetValue(ButtonLabelProperty); set => SetValue(ButtonLabelProperty, value); }
+    public bool IsButtonMode => ButtonLabel is not null;
+
     public static readonly StyledProperty<IEnumerable?> OptionsProperty =
         AvaloniaProperty.Register<EntryTypePicker, IEnumerable?>(nameof(Options));
     public static readonly StyledProperty<string> SelectedValueProperty =
@@ -71,7 +77,9 @@ public EntryTypePicker()
     protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
     {
         base.OnPropertyChanged(change);
-        if (change.Property == ShortcutServiceProperty)
+        if (change.Property == ButtonLabelProperty)
+            RaisePropertyChanged(IsButtonModeProperty, change.OldValue is not null, change.NewValue is not null);
+        else if (change.Property == ShortcutServiceProperty)
         {
             SubscribeToShortcuts(change.NewValue as EditorShortcutService);
             RebuildCategories();
diff --git a/src/Editor/GalNet.Editor/Controls/FlipbookFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/FlipbookFieldEditor.cs
new file mode 100644
index 00000000..ad81df84
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Controls/FlipbookFieldEditor.cs
@@ -0,0 +1,92 @@
+using System.ComponentModel;
+using System.Text.Json;
+using Avalonia.Controls;
+using GalNet.Core.Parameters;
+using GalNet.Game.Controls.Forms;
+
+namespace GalNet.Editor.Controls;
+
+/// <summary>Numeric flipbook fields patch the author object without rewriting extension data.</summary>
+internal static class FlipbookFieldEditor
+{
+    public static FieldEditorLease Create(FieldEditorContext context)
+    {
+        var resolver = new ValueStructureResolver();
+        using var structure = new ValueDocument(context.Field, null, resolver);
+        var specs = structure.Root.Structure.Members;
+        if (specs.Count == 0) { resolver.Dispose(); throw new NotSupportedException("Flipbook metadata is unavailable."); }
+        var panel = new StackPanel { Name = "FlipbookEditor", Spacing = 6 };
+        var children = new List<(FieldEditorContext Context, PropertyFieldBinding Binding, FieldEditorLease Lease, TextBlock Label)>();
+        var disposed = false; var submitting = false; var baseline = context.Value;
+        foreach (var spec in specs)
+        {
+            var field = spec.Field;
+            var binding = new PropertyFieldBinding(context, field, spec.WireName, () => !disposed, async (candidate, token) =>
+            {
+                submitting = true;
+                try
+                {
+                    if (!Valid(context.Field, candidate.Json))
+                        return new("flipbook.invalid", PropertyEditorSupport.Text("Form.FlipbookInvalid"));
+                    return await context.CommitAsync(candidate, token) ? null
+                        : context.Issue ?? new("flipbook.invalid", PropertyEditorSupport.Text("Form.FlipbookInvalid"));
+                }
+                catch (Exception error) when (error is JsonException or InvalidDataException or InvalidOperationException or FormatException)
+                { return new("flipbook.invalid", PropertyEditorSupport.Text("Form.FlipbookInvalid")); }
+                finally { submitting = false; }
+            }, resolver);
+            var child = new FieldEditorContext(field, binding, context.Registry);
+            var lease = (context.Registry?.Resolve(field) ?? NumericFieldEditors.CreateUpDown)(child); lease.Control.Name = "Flipbook" + spec.Field.LabelKey!.Split('.')[^1];
+            var label = new TextBlock { Width = 90, TextWrapping = global::Avalonia.Media.TextWrapping.Wrap, VerticalAlignment = global::Avalonia.Layout.VerticalAlignment.Center };
+            var row = new Grid { ColumnDefinitions = new("Auto,*"), ColumnSpacing = 8 };
+            row.Children.Add(label); Grid.SetColumn(lease.Control, 1); row.Children.Add(lease.Control); panel.Children.Add(row);
+            children.Add((child, binding, lease, label));
+        }
+        var repair = PropertyEditorSupport.Repair(context); panel.Children.Add(repair.Button);
+        var issue = new TextBlock { TextWrapping = global::Avalonia.Media.TextWrapping.Wrap }; panel.Children.Add(issue);
+        void Issues(object? sender, PropertyChangedEventArgs args)
+        {
+            var invalid = false;
+            try { invalid = !Valid(context.Field, context.EffectiveValue); }
+            catch (Exception error) when (error is JsonException or InvalidDataException or InvalidOperationException) { invalid = true; }
+            repair.Button.IsVisible = invalid;
+            issue.Text = children.Select(child => child.Context.IssueMessage).FirstOrDefault(message => message is not null)
+                ?? (invalid ? PropertyEditorSupport.Text("Form.FlipbookInvalid") : null);
+            issue.IsVisible = issue.Text is not null;
+        }
+        foreach (var child in children) child.Context.PropertyChanged += Issues;
+        var locale = PropertyEditorSupport.Localize(() =>
+        {
+            for (var index = 0; index < children.Count; index++) children[index].Label.Text = PropertyEditorSupport.Text(specs[index].Field.LabelKey!);
+            Issues(null, new(null));
+        });
+        void Refresh(object? sender, PropertyChangedEventArgs args)
+        {
+            if (disposed) return;
+            var current = context.Value;
+            var changed = baseline.IsProvided != current.IsProvided || baseline.IsProvided && !JsonElement.DeepEquals(baseline.Json!.Value, current.Json!.Value);
+            baseline = current;
+            foreach (var child in children)
+            {
+                if (changed && !submitting) child.Context.RevertDraft();
+                child.Binding.Refresh();
+            }
+            panel.IsEnabled = context.IsEnabled; Issues(null, new(null));
+        }
+        context.PropertyChanged += Refresh; Refresh(null, new(null));
+        return new(panel, () =>
+        {
+            disposed = true; context.PropertyChanged -= Refresh; repair.Lifetime.Dispose(); locale.Dispose();
+            foreach (var child in children) { child.Context.PropertyChanged -= Issues; child.Lease.Dispose(); child.Context.Dispose(); }
+            resolver.Dispose();
+        });
+    }
+    private static bool Valid(FieldDescriptor field, JsonElement? value)
+    {
+        using var document = new ValueDocument(field, value);
+        if (document.GetIterator().Any(property => property.Issue is { Code: not "field.unknown" })) return false;
+        double Number(string name, double fallback) => document.FindProperty([name])?.Value is { } json ? json.GetDouble() : fallback;
+        var columns = Number("columns", 1); var rows = Number("rows", 1); var count = Number("frameCount", 1);
+        return columns * rows <= int.MaxValue && count <= columns * rows;
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Controls/GameTextBox.cs b/src/Editor/GalNet.Editor/Controls/GameTextBox.cs
index dcb05897..7337266c 100644
--- a/src/Editor/GalNet.Editor/Controls/GameTextBox.cs
+++ b/src/Editor/GalNet.Editor/Controls/GameTextBox.cs
@@ -27,7 +27,8 @@ private void Rebuild()
         if (Binding is null || Authoring is null) return;
         _context = new(new("text", new(typeof(string), allowNull: false), isRequired: true, semantic: FieldValueSemantic.LocalizedText), Binding);
         _lease = GameTextFieldEditor.Create(_context, Authoring);
-        Content = new FieldEditorRow { Context = _context, Editor = _lease.Control, ShowLabel = false };
+        HorizontalContentAlignment = Avalonia.Layout.HorizontalAlignment.Stretch;
+        Content = new FieldEditorRow { Context = _context, Editor = _lease.Control, ShowLabel = false, RowSpacing = 0 };
     }
     private void Release() { Content = null; _lease?.Dispose(); _context?.Dispose(); _lease = null; _context = null; }
 }
diff --git a/src/Editor/GalNet.Editor/Controls/GameTextFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/GameTextFieldEditor.cs
index f4b5299b..47a367ab 100644
--- a/src/Editor/GalNet.Editor/Controls/GameTextFieldEditor.cs
+++ b/src/Editor/GalNet.Editor/Controls/GameTextFieldEditor.cs
@@ -18,7 +18,14 @@ internal static class GameTextFieldEditor
     public static FieldEditorLease Create(FieldEditorContext context, GameTextAuthoringService texts)
     {
         var multiline = context.Field.Editor?.EditorId?.Contains("multiline", StringComparison.OrdinalIgnoreCase) == true;
-        var input = new TextBox { Name = "GameTextInput", AcceptsReturn = multiline, TextWrapping = multiline ? Avalonia.Media.TextWrapping.Wrap : Avalonia.Media.TextWrapping.NoWrap, MinHeight = multiline ? 80 : 0 };
+        var input = new TextBox
+        {
+            Name = "GameTextInput",
+            AcceptsReturn = multiline,
+            TextWrapping = multiline ? Avalonia.Media.TextWrapping.Wrap : Avalonia.Media.TextWrapping.NoWrap,
+            MinHeight = multiline ? 80 : 32,
+            VerticalContentAlignment = multiline ? Avalonia.Layout.VerticalAlignment.Top : Avalonia.Layout.VerticalAlignment.Center
+        };
         var hint = new TextBlock { Name = "GameTextHint", TextWrapping = Avalonia.Media.TextWrapping.Wrap, FontSize = 11 };
         var panel = new StackPanel { Children = { input, hint }, Spacing = 4 };
         var disposed = false; var updating = false; var dirty = false; var busy = false;
diff --git a/src/Editor/GalNet.Editor/Controls/PresetShaderParametersFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/PresetShaderParametersFieldEditor.cs
new file mode 100644
index 00000000..bf64605e
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Controls/PresetShaderParametersFieldEditor.cs
@@ -0,0 +1,129 @@
+using System.ComponentModel;
+using System.Text.Json;
+using Avalonia.Controls;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Game.Controls.Forms;
+
+namespace GalNet.Editor.Controls;
+
+/// <summary>Projects a preset's shader metadata onto its parameters object without exposing a raw JSON editor.</summary>
+internal static class PresetShaderParametersFieldEditor
+{
+    private static readonly HashSet<string> Generated = new(StringComparer.Ordinal) { "time", "speed", "flicker" };
+
+    public static FieldEditorLease Create(FieldEditorContext context, ProjectSceneTargets? programs)
+    {
+        var panel = new StackPanel { Name = "PresetShaderParameters", Spacing = 6 };
+        var rows = new StackPanel { Spacing = 6 }; panel.Children.Add(rows);
+        var notice = new TextBlock { TextWrapping = global::Avalonia.Media.TextWrapping.Wrap }; panel.Children.Add(notice);
+        var children = new List<(FieldEditorContext Context, MemberBinding Binding, FieldEditorLease Lease)>();
+        var disposed = false; var refreshing = false; var submitting = false;
+        var selectedProgram = "";
+        ShaderEffectDescriptor? selectedDescriptor = null;
+        var baseline = context.Value;
+
+        void Clear()
+        {
+            foreach (var child in children) { child.Lease.Dispose(); child.Context.Dispose(); }
+            children.Clear(); rows.Children.Clear();
+        }
+        void Refresh()
+        {
+            if (disposed || refreshing) return;
+            refreshing = true;
+            try
+            {
+                var program = CurrentProgram(context);
+                var descriptor = programs?.ProgramDescriptor(program);
+                if (program != selectedProgram || !ReferenceEquals(descriptor, selectedDescriptor))
+                {
+                    Clear(); selectedProgram = program; selectedDescriptor = descriptor;
+                    if (descriptor is not null)
+                        foreach (var parameter in descriptor.Parameters.Where(parameter => !Generated.Contains(parameter.Name)))
+                        {
+                            var field = ShaderEffectFields.Create(parameter);
+                            var boundProgram = program;
+                            var binding = new MemberBinding(context, field,
+                                () => disposed || !context.IsEnabled || CurrentProgram(context) != boundProgram || !TryRead(context, out _),
+                                async value =>
+                                {
+                                    if (!TryRead(context, out var values)) return new("shader.parameters", "Shader parameters must be an object.");
+                                    if (value.Json is { } json) values[field.Id] = json.Clone(); else values.Remove(field.Id);
+                                    submitting = true;
+                                    try
+                                    {
+                                        return await context.CommitAsync(new(JsonSerializer.SerializeToElement(values))) ? null
+                                            : context.Issue ?? new("shader.parameters", "The shader parameters could not be saved.");
+                                    }
+                                    finally { submitting = false; }
+                                });
+                            var child = new FieldEditorContext(field, binding, context.Registry);
+                            var lease = context.Registry!.Resolve(field)(child);
+                            var row = new Grid { ColumnDefinitions = new("120,*"), ColumnSpacing = 8 };
+                            row.Children.Add(new TextBlock
+                            {
+                                Text = string.IsNullOrWhiteSpace(parameter.Group) ? parameter.DisplayName ?? parameter.Name
+                                    : parameter.Group + " / " + (parameter.DisplayName ?? parameter.Name),
+                                TextWrapping = global::Avalonia.Media.TextWrapping.Wrap
+                            });
+                            Grid.SetColumn(lease.Control, 1); row.Children.Add(lease.Control); rows.Children.Add(row);
+                            children.Add((child, binding, lease));
+                        }
+                }
+                var current = context.Value;
+                var changed = baseline.IsProvided != current.IsProvided || baseline.IsProvided && !JsonElement.DeepEquals(baseline.Json!.Value, current.Json!.Value);
+                baseline = current;
+                foreach (var child in children)
+                {
+                    if (changed && !submitting) child.Context.RevertDraft();
+                    child.Binding.Refresh();
+                }
+                notice.Text = descriptor is null ? PropertyEditorSupport.Text("Entry.ShaderMetadataUnavailable")
+                    : !TryRead(context, out _) ? "Shader parameters must be an object." : null;
+                notice.IsVisible = notice.Text is not null;
+                panel.IsEnabled = context.IsEnabled;
+            }
+            finally { refreshing = false; }
+        }
+        void Changed(object? sender, PropertyChangedEventArgs args) => Refresh();
+        context.PropertyChanged += Changed;
+        if (programs is not null) programs.Changed += Refresh;
+        Refresh();
+        return new(panel, () =>
+        {
+            disposed = true; context.PropertyChanged -= Changed;
+            if (programs is not null) programs.Changed -= Refresh;
+            Clear();
+        });
+    }
+
+    private static string CurrentProgram(FieldEditorContext context)
+    {
+        var origin = context.HostContext as IEntryParameterPatchOrigin;
+        return origin?.Parameters.GetValueOrDefault("program") is { ValueKind: JsonValueKind.String } id ? id.GetString() ?? "" : "";
+    }
+
+    private static bool TryRead(FieldEditorContext context, out Dictionary<string, JsonElement> values)
+    {
+        values = new(StringComparer.Ordinal);
+        if (context.EffectiveValue is not { ValueKind: JsonValueKind.Object } root) return false;
+        foreach (var property in root.EnumerateObject())
+            if (!values.TryAdd(property.Name, property.Value.Clone())) return false;
+        return true;
+    }
+
+    private sealed class MemberBinding(FieldEditorContext parent, FieldDescriptor descriptor, Func<bool> unavailable,
+        Func<FieldValue, Task<ValueIssue?>> commit) : IFieldBinding
+    {
+        public FieldDraftState? Draft => parent.DraftState?.Child?.Invoke(descriptor, descriptor.Id);
+        public bool IsEnabled => !unavailable();
+        public FieldValue Read() => TryRead(parent, out var values) && values.TryGetValue(descriptor.Id, out var value) ? new(value) : default;
+        public event EventHandler? Changed;
+        public void Refresh() => Changed?.Invoke(this, EventArgs.Empty);
+        public Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken token)
+        { token.ThrowIfCancellationRequested(); return IsEnabled ? commit(value) : Task.FromResult<ValueIssue?>(new("entry.obsolete", "Shader selection changed.")); }
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Controls/ShaderVectorFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/ShaderVectorFieldEditor.cs
new file mode 100644
index 00000000..a5a30fdd
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Controls/ShaderVectorFieldEditor.cs
@@ -0,0 +1,126 @@
+using System.ComponentModel;
+using System.Text.Json;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using GalNet.Core.Parameters;
+using GalNet.Game.Controls.Forms;
+
+namespace GalNet.Editor.Controls;
+
+/// <summary>Edits a fixed-size shader vector as one parameter value.</summary>
+internal static class ShaderVectorFieldEditor
+{
+    private static readonly string[] Components = ["X", "Y", "Z", "W"];
+
+    public static FieldEditorLease Create(FieldEditorContext context, int dimension)
+    {
+        if (dimension is < 2 or > 4) throw new ArgumentOutOfRangeException(nameof(dimension));
+        var panel = new StackPanel { Name = "ShaderVectorEditor", Spacing = 6 };
+        var fields = new Grid { ColumnDefinitions = new(string.Join(',', Enumerable.Repeat("*", dimension))), ColumnSpacing = 6 };
+        panel.Children.Add(fields);
+        var repair = PropertyEditorSupport.Repair(context);
+        panel.Children.Add(repair.Button);
+        var issue = new TextBlock { TextWrapping = global::Avalonia.Media.TextWrapping.Wrap };
+        panel.Children.Add(issue);
+        var children = new List<(FieldEditorContext Context, ComponentBinding Binding, FieldEditorLease Lease)>();
+        var disposed = false;
+        var submitting = false;
+        var baseline = context.Value;
+        for (var index = 0; index < dimension; index++)
+        {
+            var component = index;
+            var name = Components[index];
+            var field = new FieldDescriptor(name, new(typeof(float)));
+            var binding = new ComponentBinding(context, field, () => disposed, dimension, component, async value =>
+            {
+                if (value.Json is not { } json || !json.TryGetSingle(out var number) || !float.IsFinite(number))
+                    return new("shader.vector", "Enter a finite number.");
+                if (!TryRead(context, dimension, out var values))
+                    return new("shader.vector", "Repair the vector JSON value before editing its components.");
+                values[component] = number;
+                submitting = true;
+                try
+                {
+                    return await context.CommitAsync(new(JsonSerializer.SerializeToElement(values))) ? null
+                        : context.Issue ?? new("shader.vector", "The vector could not be saved.");
+                }
+                finally { submitting = false; }
+            });
+            var child = new FieldEditorContext(field, binding, context.Registry);
+            var lease = (context.Registry?.Resolve(field) ?? NumericFieldEditors.CreateUpDown)(child);
+            lease.Control.Name = "ShaderVector" + name;
+            var cell = new Grid { ColumnDefinitions = new("Auto,*"), ColumnSpacing = 4 };
+            cell.Children.Add(new TextBlock { Text = name, VerticalAlignment = VerticalAlignment.Center });
+            Grid.SetColumn(lease.Control, 1);
+            cell.Children.Add(lease.Control);
+            Grid.SetColumn(cell, index);
+            fields.Children.Add(cell);
+            children.Add((child, binding, lease));
+        }
+
+        void Issues(object? sender, PropertyChangedEventArgs args)
+        {
+            var valid = TryRead(context, dimension, out _);
+            repair.Button.IsVisible = !valid;
+            issue.Text = children.Select(child => child.Context.IssueMessage).FirstOrDefault(message => message is not null)
+                ?? (!valid ? "Repair the vector JSON value before editing its components." : context.Issue?.Message);
+            issue.IsVisible = issue.Text is not null;
+        }
+        void Refresh(object? sender, PropertyChangedEventArgs args)
+        {
+            if (disposed) return;
+            var current = context.Value;
+            var changed = baseline.IsProvided != current.IsProvided || baseline.IsProvided && !JsonElement.DeepEquals(baseline.Json!.Value, current.Json!.Value);
+            baseline = current;
+            foreach (var child in children)
+            {
+                if (changed && !submitting) child.Context.RevertDraft();
+                child.Binding.Refresh();
+            }
+            Issues(null, new(null));
+            panel.IsEnabled = context.IsEnabled;
+        }
+        context.PropertyChanged += Refresh;
+        foreach (var child in children) child.Context.PropertyChanged += Issues;
+        Refresh(null, new(null));
+        return new(panel, () =>
+        {
+            disposed = true;
+            context.PropertyChanged -= Refresh;
+            repair.Lifetime.Dispose();
+            foreach (var child in children)
+            {
+                child.Context.PropertyChanged -= Issues;
+                child.Lease.Dispose();
+                child.Context.Dispose();
+            }
+        });
+    }
+
+    private static bool TryRead(FieldEditorContext context, int dimension, out float[] values)
+    {
+        values = [];
+        if (context.EffectiveValue is not { ValueKind: JsonValueKind.Array } json || json.GetArrayLength() != dimension) return false;
+        var items = new float[dimension];
+        for (var index = 0; index < dimension; index++)
+            if (json[index].ValueKind != JsonValueKind.Number || !json[index].TryGetSingle(out items[index]) || !float.IsFinite(items[index])) return false;
+        values = items;
+        return true;
+    }
+
+    private sealed class ComponentBinding(FieldEditorContext parent, FieldDescriptor descriptor, Func<bool> disposed,
+        int dimension, int component, Func<FieldValue, Task<ValueIssue?>> commit) : IFieldBinding
+    {
+        public FieldDraftState? Draft => parent.DraftState?.Child?.Invoke(descriptor, descriptor.Id);
+        public bool IsEnabled => !disposed() && parent.IsEnabled && TryRead(parent, dimension, out _);
+        public FieldValue Read() => TryRead(parent, dimension, out var values)
+            ? new(JsonSerializer.SerializeToElement(values[component])) : default;
+        public event EventHandler? Changed;
+        public void Refresh() => Changed?.Invoke(this, EventArgs.Empty);
+        public Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken token)
+        {
+            token.ThrowIfCancellationRequested();
+            return IsEnabled ? commit(value) : Task.FromResult<ValueIssue?>(new("shader.vector", "The vector is unavailable."));
+        }
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Controls/TransformFieldEditor.cs b/src/Editor/GalNet.Editor/Controls/TransformFieldEditor.cs
index 7bce96be..23bcdfea 100644
--- a/src/Editor/GalNet.Editor/Controls/TransformFieldEditor.cs
+++ b/src/Editor/GalNet.Editor/Controls/TransformFieldEditor.cs
@@ -1,10 +1,8 @@
 using System.ComponentModel;
 using System.Text.Json;
-using System.Text.Json.Nodes;
 using Avalonia.Controls;
 using Avalonia.Layout;
 using GalNet.Core.Parameters;
-using GalNet.Core.Scene;
 using GalNet.Game.Controls.Forms;
 
 namespace GalNet.Editor.Controls;
@@ -14,38 +12,36 @@ internal static class TransformFieldEditor
 {
     public static FieldEditorLease Create(FieldEditorContext context)
     {
-        var defaults = new LayerTransform();
-        var specs = new[] { ("X", defaults.X), ("Y", defaults.Y), ("RotationDegrees", defaults.RotationDegrees), ("ScaleX", defaults.ScaleX), ("ScaleY", defaults.ScaleY) };
+        var resolver = new ValueStructureResolver();
+        using var structure = new ValueDocument(context.Field, null, resolver);
+        var specs = structure.Root.Structure.Members;
+        if (specs.Count == 0) { resolver.Dispose(); throw new NotSupportedException("Transform metadata is unavailable."); }
         var panel = new Grid { Name = "TransformEditor", ColumnDefinitions = new("*,Auto"), ColumnSpacing = 6 };
         var values = new Grid { ColumnDefinitions = new("*,*"), RowDefinitions = new("Auto,Auto,Auto"), RowSpacing = 6, ColumnSpacing = 8 };
         panel.Children.Add(values);
         var repair = PropertyEditorSupport.Repair(context); repair.Button.VerticalAlignment = VerticalAlignment.Top;
         Grid.SetColumn(repair.Button, 1); panel.Children.Add(repair.Button);
         var issueLabel = new TextBlock { TextWrapping = global::Avalonia.Media.TextWrapping.Wrap };
-        var children = new List<(FieldEditorContext Context, MemberBinding Binding, FieldEditorLease Lease, TextBlock Label)>();
+        var children = new List<(FieldEditorContext Context, PropertyFieldBinding Binding, FieldEditorLease Lease, TextBlock Label)>();
         var disposed = false; var submitting = false; var baseline = context.Value;
-        for (var index = 0; index < specs.Length; index++)
+        for (var index = 0; index < specs.Count; index++)
         {
-            var (name, fallback) = specs[index];
-            var field = new FieldDescriptor(name, new(typeof(float)), defaultValue: JsonSerializer.SerializeToElement(fallback));
-            var binding = new MemberBinding(context, name, () => disposed, async value =>
+            var name = specs[index].WireName;
+            var field = specs[index].Field;
+            var binding = new PropertyFieldBinding(context, field, name, () => !disposed, async (candidate, token) =>
             {
                 submitting = true;
                 try
                 {
-                    var (root, encoded) = Read(context);
-                    var key = Wire(root, name);
-                    if (value.Json is { } json) root[key] = JsonNode.Parse(json.GetRawText()); else root.Remove(key);
-                    var candidate = encoded ? JsonSerializer.SerializeToElement(root.ToJsonString()) : JsonSerializer.SerializeToElement(root);
-                    return await context.CommitAsync(new(candidate)) ? null : context.Issue ?? new("transform.invalid", PropertyEditorSupport.Text("Form.TransformInvalid"));
+                    return await context.CommitAsync(candidate, token) ? null : context.Issue ?? new("transform.invalid", PropertyEditorSupport.Text("Form.TransformInvalid"));
                 }
                 catch (Exception error) when (error is JsonException or InvalidDataException or InvalidOperationException)
                 { return new("transform.invalid", PropertyEditorSupport.Text("Form.TransformInvalid")); }
                 finally { submitting = false; }
-            });
+            }, resolver);
             var child = new FieldEditorContext(field, binding, context.Registry);
-            var lease = DefaultFieldEditors.CreateNumeric(child);
-            lease.Control.Name = "Transform" + name;
+            var lease = (context.Registry?.Resolve(field) ?? NumericFieldEditors.CreateUpDown)(child);
+            lease.Control.Name = "Transform" + field.LabelKey!.Split('.')[^1];
             var label = new TextBlock { VerticalAlignment = VerticalAlignment.Center, Width = 72, TextWrapping = global::Avalonia.Media.TextWrapping.Wrap };
             var cell = new Grid { ColumnDefinitions = new("Auto,*"), ColumnSpacing = 6 };
             cell.Children.Add(label); Grid.SetColumn(lease.Control, 1); cell.Children.Add(lease.Control);
@@ -61,20 +57,19 @@ void ChildChanged(object? sender, PropertyChangedEventArgs args)
             var invalid = false;
             try
             {
-                var (root, _) = Read(context);
-                invalid = specs.Any(spec => root.TryGetPropertyValue(Wire(root, spec.Item1), out var node) &&
-                    ValueValidation.Validate(new(typeof(float)), JsonSerializer.SerializeToElement(node)) is not null);
+                using var snapshot = new ValueDocument(context.Field, context.EffectiveValue, resolver);
+                invalid = snapshot.GetIterator().Any(property => property.Issue is { Code: not "field.unknown" });
             }
             catch (Exception error) when (error is JsonException or InvalidDataException or InvalidOperationException) { invalid = true; }
             repair.Button.IsVisible = invalid;
             panel.ColumnSpacing = invalid ? 6 : 0;
-            issueLabel.Text = children.Select(child => child.Context.Issue?.Message).FirstOrDefault(message => message is not null)
+            issueLabel.Text = children.Select(child => child.Context.IssueMessage).FirstOrDefault(message => message is not null)
                 ?? (invalid ? PropertyEditorSupport.Text("Form.TransformInvalid") : null);
             issueLabel.IsVisible = issueLabel.Text is not null;
         }
         var locale = PropertyEditorSupport.Localize(() =>
         {
-            for (var index = 0; index < children.Count; index++) children[index].Label.Text = PropertyEditorSupport.Text("Form.Transform." + specs[index].Item1);
+            for (var index = 0; index < children.Count; index++) children[index].Label.Text = PropertyEditorSupport.Text(specs[index].Field.LabelKey!);
             ChildChanged(null, new(null));
         });
         void Refresh(object? sender, PropertyChangedEventArgs args)
@@ -96,43 +91,7 @@ void Refresh(object? sender, PropertyChangedEventArgs args)
         {
             disposed = true; context.PropertyChanged -= Refresh; repair.Lifetime.Dispose(); locale.Dispose();
             foreach (var child in children) { child.Context.PropertyChanged -= ChildChanged; child.Context.Dispose(); child.Lease.Dispose(); }
+            resolver.Dispose();
         });
     }
-    private static (JsonObject Root, bool Encoded) Read(FieldEditorContext context)
-    {
-        var json = context.EffectiveValue;
-        if (json is null || json.Value.ValueKind == JsonValueKind.Null) return (new(), false);
-        var encoded = json.Value.ValueKind == JsonValueKind.String;
-        return (JsonNode.Parse(encoded ? json.Value.GetString()! : json.Value.GetRawText()) as JsonObject
-            ?? throw new InvalidDataException(), encoded);
-    }
-    private static string Wire(JsonObject root, string name)
-    {
-        var matches = root.Select(pair => pair.Key).Where(key => key.Equals(name, StringComparison.OrdinalIgnoreCase)).ToArray();
-        if (matches.Length > 1) throw new InvalidDataException();
-        // Existing runtime Transform uses CLR property names, with case-insensitive reads.
-        return matches.SingleOrDefault() ?? name;
-    }
-    private sealed class MemberBinding(FieldEditorContext parent, string name, Func<bool> disposed, Func<FieldValue, Task<ValueIssue?>> commit) : IFieldBinding
-    {
-        public FieldDraftState? Draft => parent.DraftState?.Child?.Invoke(new FieldDescriptor(name, new(typeof(float))), name);
-        public bool IsEnabled => !disposed() && parent.IsEnabled;
-        public FieldValue Read()
-        {
-            try
-            {
-                var (root, _) = TransformFieldEditor.Read(parent);
-                return root.TryGetPropertyValue(Wire(root, name), out var node) ? new(JsonSerializer.SerializeToElement(node)) : default;
-            }
-            catch (Exception error) when (error is JsonException or InvalidDataException or InvalidOperationException)
-            { return new(JsonSerializer.SerializeToElement(PropertyEditorSupport.Text("Form.TransformInvalid"))); }
-        }
-        public event EventHandler? Changed;
-        public void Refresh() => Changed?.Invoke(this, EventArgs.Empty);
-        public Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken token)
-        {
-            token.ThrowIfCancellationRequested();
-            return IsEnabled ? commit(value) : Task.FromResult<ValueIssue?>(new("entry.obsolete", "Entry schema has changed."));
-        }
-    }
 }
diff --git a/src/Editor/GalNet.Editor/Controls/VariableListEditorControl.axaml b/src/Editor/GalNet.Editor/Controls/VariableListEditorControl.axaml
deleted file mode 100644
index 28fcd001..00000000
--- a/src/Editor/GalNet.Editor/Controls/VariableListEditorControl.axaml
+++ /dev/null
@@ -1,29 +0,0 @@
-<UserControl xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:vm="using:GalNet.Editor.ViewModels"
-             x:Class="GalNet.Editor.Controls.VariableListEditorControl"
-             x:Name="Root"
-             x:DataType="vm:VariableListEditorViewModel">
-    <ItemsControl ItemsSource="{Binding Items}">
-        <ItemsControl.ItemTemplate>
-            <DataTemplate x:DataType="vm:VariableEditorItemViewModel">
-                <Border Margin="0,4" Padding="8" CornerRadius="6"
-                        Background="{DynamicResource SemiColorBackground1}"
-                        BorderBrush="{DynamicResource SemiColorBorder}" BorderThickness="1">
-                    <Grid ColumnDefinitions="*,80,*,*" ColumnSpacing="8">
-                        <TextBlock Text="{Binding Name}" VerticalAlignment="Center" />
-                        <TextBlock Grid.Column="1" Text="{Binding SelectedType}" VerticalAlignment="Center" />
-                        <TextBlock Grid.Column="2" Text="{Binding DefaultValueText}" VerticalAlignment="Center" />
-                        <Grid Grid.Column="3" IsVisible="{Binding #Root.DataContext.ShowCurrentValue}"
-                              IsEnabled="{Binding CanEditCurrentValue}">
-                            <CheckBox IsVisible="{Binding IsBool}" IsChecked="{Binding CurrentBoolValue}" />
-                            <NumericUpDown IsVisible="{Binding IsInt}" Value="{Binding CurrentIntValue}" />
-                            <NumericUpDown IsVisible="{Binding IsFloat}" Increment="0.1" Value="{Binding CurrentFloatValue}" />
-                            <TextBox IsVisible="{Binding IsString}" Text="{Binding CurrentStringValue}" />
-                        </Grid>
-                    </Grid>
-                </Border>
-            </DataTemplate>
-        </ItemsControl.ItemTemplate>
-    </ItemsControl>
-</UserControl>
diff --git a/src/Editor/GalNet.Editor/Controls/VariableListEditorControl.axaml.cs b/src/Editor/GalNet.Editor/Controls/VariableListEditorControl.axaml.cs
deleted file mode 100644
index 7da31351..00000000
--- a/src/Editor/GalNet.Editor/Controls/VariableListEditorControl.axaml.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using Avalonia.Controls;
-
-namespace GalNet.Editor.Controls;
-
-public partial class VariableListEditorControl : UserControl
-{
-    public VariableListEditorControl()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/Editor/GalNet.Editor/Dock/BuiltInDockContributions.cs b/src/Editor/GalNet.Editor/Dock/BuiltInDockContributions.cs
index 10bf89b4..bc9f1c21 100644
--- a/src/Editor/GalNet.Editor/Dock/BuiltInDockContributions.cs
+++ b/src/Editor/GalNet.Editor/Dock/BuiltInDockContributions.cs
@@ -1,7 +1,7 @@
 using System;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Scene;
 using GalNet.Editor.Abstraction.Extensibility;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Commands;
@@ -18,7 +18,6 @@ namespace GalNet.Editor.Dock;
 public static class EditorDockPanelIds
 {
     public const string NodeGraph = "NodeGraph";
-    public const string GamePreview = "GamePreview";
     public const string Assets = "Assets";
     public const string Log = "Log";
     public const string GroupEditor = "GroupEditor";
@@ -27,6 +26,7 @@ public static class EditorDockPanelIds
     public const string Variables = "Variables";
     public const string Characters = "Characters";
     public const string Localization = "Localization";
+    public const string ResourceOverrides = "ResourceOverrides";
     public const string Timeline = "Timeline";
     public const string ExternalDebug = "ExternalDebug";
     public const string Problems = "Problems";
@@ -45,12 +45,17 @@ public static void Register(IEditorExtensionRegistry registry)
         registry.RegisterDockPanel(new DelegateDockPanelContribution<GameLocalizationPanelViewModel>(
             EditorDockPanelIds.Localization, "Dock.Panel.Localization", DockPanelPlacement.MainDocument, true, true, true, false, true,
             sp => sp.GetRequiredService<GameLocalizationPanelViewModel>(), typeof(GameLocalizationPanelView), null));
+        registry.RegisterDockPanel(new DelegateDockPanelContribution<ResourceOverridesPanelViewModel>(
+            EditorDockPanelIds.ResourceOverrides, "Packaging.Panel", DockPanelPlacement.MainDocument, true, true, true, false, true,
+            sp => sp.GetRequiredService<ResourceOverridesPanelViewModel>(), typeof(ResourceOverridesPanelView), null));
         registry.RegisterDockPanel(new DelegateDockPanelContribution<CharactersPanelViewModel>(
             EditorDockPanelIds.Characters, "Dock.Panel.Characters", DockPanelPlacement.MainDocument, true, true, true, false, true,
             sp => sp.GetRequiredService<CharactersPanelViewModel>(), typeof(CharactersPanelView), null));
         registry.RegisterDockPanel(new DelegateDockPanelContribution<TimelinePanelViewModel>(
             EditorDockPanelIds.Timeline, "Dock.Panel.Timeline", DockPanelPlacement.BottomDocument, true, true, true, false, true,
-            sp => sp.GetRequiredService<TimelinePanelViewModel>(), typeof(TimelinePanelView), null));
+            sp => sp.GetRequiredService<TimelinePanelViewModel>(), typeof(TimelinePanelView),
+            new DelegateInspectorContribution<TimelinePanelViewModel, TimelineEventInspectorViewModel>(
+                (sp, page) => new TimelineEventInspectorViewModel(page), typeof(TimelineEventInspectorView))));
         registry.RegisterDockPanel(new DelegateDockPanelContribution<VariablesPanelViewModel>(
             EditorDockPanelIds.Variables, "Dock.Panel.Variables", DockPanelPlacement.MainDocument, true, true, true, false, true,
             sp => { var vm = sp.GetRequiredService<VariablesPanelViewModel>(); vm.Navigation = sp.GetService<AuthorNavigationService>(); return vm; }, typeof(VariablesPanelView), null));
@@ -81,7 +86,8 @@ public static void Register(IEditorExtensionRegistry registry)
                 sp.GetRequiredService<EntrySelectionContext>(),
                 sp.GetRequiredService<GalNet.Game.Controls.Forms.EditorRegistry>()),
             typeof(GroupEditorPanelView), new DelegateInspectorContribution<GroupEditorPanelViewModel, EntryInspectorViewModel>(
-                (sp, page) => new EntryInspectorViewModel(page, sp.GetService<AuthorNavigationService>()), typeof(EntryInspectorView))));
+                (sp, page) => new EntryInspectorViewModel(page, sp.GetService<AuthorNavigationService>(),
+                    sp.GetRequiredService<ProjectSceneTargets>(), sp.GetRequiredService<IAssetManager>()), typeof(EntryInspectorView))));
         registry.RegisterDockPanel(new DelegateDockPanelContribution<FileDocumentPanelViewModel, string>(
             EditorDockPanelIds.FileEditor, "Files.Document", DockPanelPlacement.MainDocument, false, true, true, false, false,
             (sp, id) => new FileDocumentPanelViewModel(sp.GetRequiredService<ProjectTextFiles>().Get(id)), typeof(FileDocumentPanelView), null));
diff --git a/src/Editor/GalNet.Editor/Dock/EditorDockFactory.cs b/src/Editor/GalNet.Editor/Dock/EditorDockFactory.cs
index 9dcc5679..c8218e2e 100644
--- a/src/Editor/GalNet.Editor/Dock/EditorDockFactory.cs
+++ b/src/Editor/GalNet.Editor/Dock/EditorDockFactory.cs
@@ -581,7 +581,7 @@ private void CloseDocument(IDockable document)
         _inspector.RemoveInspectorAndRecover(document, () => FindActiveInspectableDockable(FactoryExtensions.GetActiveRoot(this)));
         _panelByDockable.Remove(document);
         // Localization drafts belong to the project scope and survive dock closure.
-        if (document.Context is not (GameLocalizationPanelViewModel or AssetPanelViewModel or ProblemsPanelViewModel or EditorWorkspaceViewModel))
+        if (document.Context is not (GameLocalizationPanelViewModel or ResourceOverridesPanelViewModel or AssetPanelViewModel or ProblemsPanelViewModel or EditorWorkspaceViewModel))
             (document.Context as IDisposable)?.Dispose();
         LayoutChanged?.Invoke();
     }
diff --git a/src/Editor/GalNet.Editor/GalNet.Editor.csproj b/src/Editor/GalNet.Editor/GalNet.Editor.csproj
index f05d312c..5e3de862 100644
--- a/src/Editor/GalNet.Editor/GalNet.Editor.csproj
+++ b/src/Editor/GalNet.Editor/GalNet.Editor.csproj
@@ -6,9 +6,12 @@
         <Nullable>enable</Nullable>
         <ApplicationManifest>app.manifest</ApplicationManifest>
         <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
+        <DefaultContractsOutputRoot Condition="'$(Benchmark)' == 'true'">benchmark/</DefaultContractsOutputRoot>
+        <DefaultContractsOutputRoot Condition="'$(PublishProfile)' == 'WindowsReadyToRun' And '$(Benchmark)' != 'true'">publish/WindowsReadyToRun/</DefaultContractsOutputRoot>
     </PropertyGroup>
 
     <ItemGroup>
+        <InternalsVisibleTo Include="GalNet.Editor.Tests" />
     <ProjectReference Include="../../Infrastructure/GalNet.Media.LibVlc/GalNet.Media.LibVlc.csproj" />
         <Folder Include="Models\" />
         <AvaloniaResource Include="Assets\**" />
@@ -47,19 +50,17 @@
     <ItemGroup>
       <EmbeddedResource Include="Localization\*.json" />
       <ProjectReference Include="..\GalNet.Editor.DefaultContracts\GalNet.Editor.DefaultContracts.csproj" ReferenceOutputAssembly="false" GlobalPropertiesToRemove="OutputPath;OutDir" />
-      <Content Include="..\GalNet.Editor.DefaultContracts\bin\$(Configuration)\net10.0\GalNet.Project.Contracts.dll"
+      <Content Include="..\GalNet.Editor.DefaultContracts\bin\$(DefaultContractsOutputRoot)$(Configuration)\net10.0\GalNet.Project.Contracts.dll"
                Link="DefaultContracts\GalNet.Project.Contracts.dll" CopyToOutputDirectory="PreserveNewest" CopyToPublishDirectory="PreserveNewest" />
     </ItemGroup>
 
     <ItemGroup>
       <ProjectReference Include="..\GalNet.Editor.Abstraction\GalNet.Editor.Abstraction.csproj" />
       <ProjectReference Include="..\..\Shared\GalNet.Assets\GalNet.Assets.csproj" />
-      <ProjectReference Include="..\..\Presentation\GalNet.Avalonia.Themes\GalNet.Avalonia.Themes.csproj" Aliases="ThemesAssembly" />
       <ProjectReference Include="..\..\Presentation\GalNet.Avalonia.Controls\GalNet.Avalonia.Controls.csproj" />
       <ProjectReference Include="..\..\Presentation\GalNet.Avalonia.Rendering\GalNet.Avalonia.Rendering.csproj" />
       <ProjectReference Include="..\..\Presentation\GalNet.Avalonia.GameView\GalNet.Avalonia.GameView.csproj" Aliases="GameViewAssembly" />
       <ProjectReference Include="..\..\Shared\GalNet.Core\GalNet.Core.csproj" />
-      <ProjectReference Include="..\..\Shared\GalNet.Primitives.Builtins\GalNet.Primitives.Builtins.csproj" />
       <ProjectReference Include="..\..\Shared\GalNet.Contracts.Builtins\GalNet.Contracts.Builtins.csproj" />
       <ProjectReference Include="..\GalNet.Editor.Shared\GalNet.Editor.Shared.csproj" />
       <ProjectReference Include="..\..\Shared\GalNet.Presentation.Abstractions\GalNet.Presentation.Abstractions.csproj" />
@@ -77,9 +78,6 @@
       <Compile Update="Views\EditorSettingsPanelView.axaml.cs">
         <DependentUpon>EditorSettingsPanelView.axaml</DependentUpon>
       </Compile>
-      <Compile Update="Views\GamePreviewPanelView.axaml.cs">
-        <DependentUpon>GamePreviewPanelView.axaml</DependentUpon>
-      </Compile>
       <Compile Update="Views\ProjectSettingsWindow.axaml.cs">
         <DependentUpon>ProjectSettingsWindow.axaml</DependentUpon>
       </Compile>
@@ -93,4 +91,8 @@
         <DependentUpon>InspectorHostView.axaml</DependentUpon>
       </Compile>
     </ItemGroup>
+  <ItemGroup Condition="'$(Benchmark)' == 'true'">
+    <ProjectReference Include="../../Shared/GalNet.Diagnostics/GalNet.Diagnostics.csproj" />
+  </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../Shared/GalNet.GameHost/GalNet.GameHost.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Editor/GalNet.Editor/History/AuthorChangeJournal.cs b/src/Editor/GalNet.Editor/History/AuthorChangeJournal.cs
new file mode 100644
index 00000000..de09431b
--- /dev/null
+++ b/src/Editor/GalNet.Editor/History/AuthorChangeJournal.cs
@@ -0,0 +1,70 @@
+using GalNet.Editor.Abstraction.Changes;
+
+namespace GalNet.Editor.History;
+
+/// <summary>Accumulates domain changes inside the history gate and publishes only a completed transaction.</summary>
+public sealed class AuthorChangeJournal
+{
+    private List<AuthorGroupChange>? _pending;
+    private readonly List<AuthorEntryMove> _moves = [];
+    private readonly List<Action> _rollback = [];
+    public long Revision { get; private set; }
+    public Exception? LastNotificationError { get; private set; }
+    public event Action<AuthorChangeSet>? Committed;
+    internal bool IsRecording => _pending is not null;
+
+    internal void Begin() { _pending = []; _moves.Clear(); _rollback.Clear(); }
+    internal void OnRollback(Action rollback)
+    {
+        if (_pending is null) throw new InvalidOperationException("Rollback callbacks require an active author transaction.");
+        _rollback.Add(rollback);
+    }
+    internal void Cancel()
+    {
+        _pending = null; _moves.Clear();
+        var callbacks = _rollback.ToArray(); _rollback.Clear();
+        List<Exception> failures = [];
+        foreach (var callback in callbacks.Reverse()) try { callback(); } catch (Exception failure) { failures.Add(failure); }
+        if (failures.Count != 0) throw new HistoryRepairRequiredException("Author input rollback failed.", new AggregateException(failures));
+    }
+    public void RecordMove(AuthorEntryMove move)
+    {
+        if (_pending is null) throw new InvalidOperationException("Author moves must belong to a history transaction.");
+        _moves.Add(move);
+    }
+
+    public void Record(string groupId, int firstIndex, GroupChangeKind kind, IEnumerable<string> entryIds)
+    {
+        if (_pending is null) throw new InvalidOperationException("Author changes must belong to a history transaction.");
+        _pending.Add(new(groupId, Math.Max(0, firstIndex), kind, Array.AsReadOnly(entryIds.Distinct(StringComparer.Ordinal).ToArray())));
+    }
+
+    internal AuthorChangeSet Complete(AuthorChangeCause cause, bool knownScope)
+    {
+        var groups = (_pending ?? throw new InvalidOperationException("No author transaction is active."))
+            .GroupBy(change => change.GroupId, StringComparer.Ordinal).Select(group => new AuthorGroupChange(group.Key,
+                group.Min(change => change.FirstIndex), group.Aggregate(GroupChangeKind.None, (kind, change) => kind | change.Kind),
+                Array.AsReadOnly(group.SelectMany(change => change.EntryIds).Distinct(StringComparer.Ordinal).ToArray()))).ToArray();
+        _pending = null;
+        _rollback.Clear();
+        return new(++Revision, cause, Array.AsReadOnly(groups), !knownScope || groups.Length == 0) { Moves = Array.AsReadOnly(_moves.ToArray()) };
+    }
+
+    internal void Publish(AuthorChangeSet change)
+    {
+        if (Committed is null) return;
+        foreach (Action<AuthorChangeSet> observer in Committed.GetInvocationList())
+            try { observer(change); }
+            catch (Exception failure)
+            {
+                LastNotificationError = failure;
+                Serilog.Log.Error(failure, "An author change observer failed at revision {Revision}", change.Revision);
+            }
+    }
+}
+
+/// <summary>Implemented only when an edit records all its author impacts, including composite children.</summary>
+public interface IAuthorScopedEdit
+{
+    bool HasKnownAuthorScope => true;
+}
diff --git a/src/Editor/GalNet.Editor/History/EditorHistories.cs b/src/Editor/GalNet.Editor/History/EditorHistories.cs
index 6d75eb84..50e36dde 100644
--- a/src/Editor/GalNet.Editor/History/EditorHistories.cs
+++ b/src/Editor/GalNet.Editor/History/EditorHistories.cs
@@ -21,6 +21,7 @@ public EditorHistories(IProjectContentSession? session = null, ProjectSessionOpt
             Content.BindContent(() => session.IsDirty, () => session.RepairRequired);
             _captureRegistration = session.RegisterCaptureGuard(Content.AcquireCaptureAsync);
             Content.Changed += OnContentChanged;
+            session.ExternalReloaded += Clear;
         }
     }
 
@@ -30,6 +31,7 @@ public EditorHistories(IProjectContentSession? session = null, ProjectSessionOpt
     public void Dispose()
     {
         Content.Changed -= OnContentChanged;
+        if (_session is not null) _session.ExternalReloaded -= Clear;
         _captureRegistration?.Dispose();
         Content.Dispose();
         GC.SuppressFinalize(this);
diff --git a/src/Editor/GalNet.Editor/History/UndoRedoHistory.cs b/src/Editor/GalNet.Editor/History/UndoRedoHistory.cs
index bee74deb..67a7d53c 100644
--- a/src/Editor/GalNet.Editor/History/UndoRedoHistory.cs
+++ b/src/Editor/GalNet.Editor/History/UndoRedoHistory.cs
@@ -3,6 +3,7 @@
 using System.Collections.ObjectModel;
 using System.Threading;
 using System.Threading.Tasks;
+using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Services;
 
 namespace GalNet.Editor.History;
@@ -56,6 +57,7 @@ public interface IUndoRedoTarget
 
 public sealed class UndoRedoHistory(int capacity = 200, long byteBudget = 1024L * 1024 * 1024) : IUndoRedoHistory, IDisposable
 {
+    public AuthorChangeJournal AuthorChanges { get; } = new();
     private readonly List<IAsyncUndoableEdit> _edits = [];
     private readonly SemaphoreSlim _gate = new(1, 1);
     private readonly AsyncLocal<bool> _executing = new();
@@ -82,7 +84,7 @@ public sealed class UndoRedoHistory(int capacity = 200, long byteBudget = 1024L
 
     public void Execute(IUndoableEdit edit)
     {
-        RunSync(() => { edit.Redo(); Append(new SyncEdit(edit)); });
+        RunSync(() => { edit.Redo(); Append(new SyncEdit(edit)); }, AuthorChangeCause.Execute, KnownScope(edit));
     }
 
     public void BindContent(Func<bool> dirty, Func<bool> repair)
@@ -117,24 +119,42 @@ private void Append(IAsyncUndoableEdit edit)
     public void Undo()
     {
         if (!CanUndo) return;
-        RunSync(() => { RequireSync(_edits[_position - 1]).Undo(); _position--; });
+        RunSync(() => { RequireSync(_edits[_position - 1]).Undo(); _position--; }, AuthorChangeCause.Undo, KnownScope(_edits[_position - 1]));
     }
 
     public void Redo()
     {
         if (!CanRedo) return;
-        RunSync(() => { RequireSync(_edits[_position]).Redo(); _position++; });
+        RunSync(() => { RequireSync(_edits[_position]).Redo(); _position++; }, AuthorChangeCause.Redo, KnownScope(_edits[_position]));
     }
 
     private static IUndoableEdit RequireSync(IAsyncUndoableEdit edit) => edit is SyncEdit sync
         ? sync.Edit : throw new InvalidOperationException("Use the asynchronous history API for this edit.");
 
-    private void RunSync(Action operation)
+    internal static bool KnownScope(object edit) => edit is IAuthorScopedEdit { HasKnownAuthorScope: true };
+
+    private void RunSync(Action operation, AuthorChangeCause cause, bool knownScope)
     {
         if (!_gate.Wait(0)) throw new InvalidOperationException("An edit is already executing.");
-        try { EnsureWritable(); IsBusy = true; operation(); }
+        AuthorChangeSet? committed = null;
+        try
+        {
+            EnsureWritable(); _executing.Value = true; IsBusy = true; AuthorChanges.Begin();
+            operation(); committed = AuthorChanges.Complete(cause, knownScope);
+        }
         catch (HistoryRepairRequiredException) { RepairRequired = true; throw; }
-        finally { IsBusy = false; _gate.Release(); NotifyChanged(); }
+        finally
+        {
+            try { AuthorChanges.Cancel(); }
+            catch (HistoryRepairRequiredException) { RepairRequired = true; throw; }
+            finally
+            {
+                IsBusy = false;
+                // Publish with the new history cursor, while reentrant edits are still excluded.
+                if (committed is not null) AuthorChanges.Publish(committed);
+                _executing.Value = false; _gate.Release(); NotifyChanged();
+            }
+        }
     }
 
     private void EnsureWritable()
@@ -148,42 +168,59 @@ public Task ExecuteAsync(IAsyncUndoableEdit edit) => RunAsync(async () =>
     {
         await edit.RedoAsync();
         Append(edit);
-    });
+        return true;
+    }, AuthorChangeCause.Execute, () => KnownScope(edit));
 
     public Task ExecuteAsync(IUndoableEdit edit) => ExecuteAsync(new SyncEdit(edit));
 
     public Task UndoAsync() => RunAsync(async () =>
     {
-        if (_position == 0) return;
+        if (_position == 0) return false;
         await _edits[_position - 1].UndoAsync();
         _position--;
-    });
+        return true;
+    }, AuthorChangeCause.Undo, () => _position > 0 && KnownScope(_edits[_position - 1]));
 
     public Task RedoAsync() => RunAsync(async () =>
     {
-        if (_position == _edits.Count) return;
+        if (_position == _edits.Count) return false;
         await _edits[_position].RedoAsync();
         _position++;
-    });
+        return true;
+    }, AuthorChangeCause.Redo, () => _position < _edits.Count && KnownScope(_edits[_position]));
 
-    private async Task RunAsync(Func<Task> operation)
+    private async Task RunAsync(Func<Task<bool>> operation, AuthorChangeCause cause, Func<bool> scope)
     {
         if (_executing.Value) throw new InvalidOperationException("History operations cannot reenter history.");
         await _gate.WaitAsync();
+        AuthorChangeSet? committed = null;
         try
         {
             EnsureWritable();
             _executing.Value = true;
             IsBusy = true;
+            AuthorChanges.Begin();
+            var knownScope = scope();
             NotifyChanged();
-            await operation();
+            if (await operation()) committed = AuthorChanges.Complete(cause, knownScope);
         }
         catch (HistoryRepairRequiredException) { RepairRequired = true; throw; }
-        finally { _executing.Value = false; IsBusy = false; _gate.Release(); NotifyChanged(); }
+        finally
+        {
+            try { AuthorChanges.Cancel(); }
+            catch (HistoryRepairRequiredException) { RepairRequired = true; throw; }
+            finally
+            {
+                IsBusy = false;
+                if (committed is not null) AuthorChanges.Publish(committed);
+                _executing.Value = false; _gate.Release(); NotifyChanged();
+            }
+        }
     }
 
-    private sealed record SyncEdit(IUndoableEdit Edit) : IAsyncUndoableEdit, IDisposable
+    private sealed record SyncEdit(IUndoableEdit Edit) : IAsyncUndoableEdit, IDisposable, IAuthorScopedEdit
     {
+        public bool HasKnownAuthorScope => KnownScope(Edit);
         public string Description => Edit.Description;
         public EditorText DisplayText => Edit.DisplayText;
         public long RetainedBytes => Edit.RetainedBytes;
@@ -231,7 +268,7 @@ public void Dispose()
 
     public void Clear()
     {
-        if (IsBusy) throw new InvalidOperationException("Cannot clear executing history.");
+        if (IsBusy || _executing.Value) throw new InvalidOperationException("Cannot clear executing history.");
         foreach (var edit in _edits) Release(edit);
         _edits.Clear();
         _position = 0;
@@ -264,8 +301,9 @@ private void NotifyChanged()
 
 public sealed class HistoryRepairRequiredException(string message, Exception innerException) : Exception(message, innerException);
 
-public sealed class AsyncCompositeEdit(string description, IReadOnlyList<IAsyncUndoableEdit> edits, EditorText? display = null) : IAsyncUndoableEdit, IDisposable
+public sealed class AsyncCompositeEdit(string description, IReadOnlyList<IAsyncUndoableEdit> edits, EditorText? display = null) : IAsyncUndoableEdit, IDisposable, IAuthorScopedEdit
 {
+    public bool HasKnownAuthorScope => edits.All(UndoRedoHistory.KnownScope);
     public string Description { get; } = description;
     public EditorText DisplayText => display ?? EditorText.History(Description);
     public long RetainedBytes => edits.Sum(edit => edit.RetainedBytes);
@@ -303,8 +341,9 @@ public async ValueTask UndoAsync()
     }
 }
 
-public sealed class AsyncEditAdapter(IUndoableEdit edit) : IAsyncUndoableEdit
+public sealed class AsyncEditAdapter(IUndoableEdit edit) : IAsyncUndoableEdit, IAuthorScopedEdit
 {
+    public bool HasKnownAuthorScope => UndoRedoHistory.KnownScope(edit);
     public string Description => edit.Description;
     public EditorText DisplayText => edit.DisplayText;
     public long RetainedBytes => edit.RetainedBytes;
@@ -347,8 +386,9 @@ public sealed class CollectionMoveEdit<T>(string description, ObservableCollecti
     public void Redo() => collection.Move(before, after);
 }
 
-public sealed class CompositeEdit(string description, IReadOnlyList<IUndoableEdit> edits) : IUndoableEdit, IDisposable
+public sealed class CompositeEdit(string description, IReadOnlyList<IUndoableEdit> edits) : IUndoableEdit, IDisposable, IAuthorScopedEdit
 {
+    public bool HasKnownAuthorScope => edits.All(UndoRedoHistory.KnownScope);
     public string Description { get; } = description;
     public long RetainedBytes => edits.Sum(edit => edit.RetainedBytes);
     public void Dispose()
diff --git a/src/Editor/GalNet.Editor/Inspector/ViewModels/AssetInspectorControlViewModel.cs b/src/Editor/GalNet.Editor/Inspector/ViewModels/AssetInspectorControlViewModel.cs
index 9bc3dc90..c1518138 100644
--- a/src/Editor/GalNet.Editor/Inspector/ViewModels/AssetInspectorControlViewModel.cs
+++ b/src/Editor/GalNet.Editor/Inspector/ViewModels/AssetInspectorControlViewModel.cs
@@ -49,6 +49,7 @@ public sealed partial class AssetInspectorControlViewModel : ObservableObject, I
     public bool IsSelectedAssetImage => InspectedAsset?.IsImage == true;
     public bool IsSelectedAssetAudio => InspectedAsset?.IsAudio == true;
     public bool IsSelectedAssetVideo => InspectedAsset?.IsVideo == true;
+    public bool HasPreview => IsSelectedAssetImage || IsSelectedAssetAudio || Variants is not null;
     public IReadOnlyList<string> FilterOptions { get; } = ["point", "bilinear"];
     public IReadOnlyList<string> CompressionOptions { get; } = ["none", "deflate", "gzip", "brotli"];
     public string AudioPreviewActionText => _localization[IsAudioPreviewPlaying ? "Inspector.Asset.Pause" : "Inspector.Asset.Play"];
@@ -134,6 +135,7 @@ private void SetAsset(AssetEntry? asset)
         OnPropertyChanged(nameof(IsSelectedAssetImage));
         OnPropertyChanged(nameof(IsSelectedAssetAudio));
         OnPropertyChanged(nameof(IsSelectedAssetVideo));
+        OnPropertyChanged(nameof(HasPreview));
     }
 
     private void Load()
diff --git a/src/Editor/GalNet.Editor/Inspector/ViewModels/EntryInspectorViewModel.cs b/src/Editor/GalNet.Editor/Inspector/ViewModels/EntryInspectorViewModel.cs
index e0997476..d1c5bbdd 100644
--- a/src/Editor/GalNet.Editor/Inspector/ViewModels/EntryInspectorViewModel.cs
+++ b/src/Editor/GalNet.Editor/Inspector/ViewModels/EntryInspectorViewModel.cs
@@ -1,6 +1,12 @@
 using System.Collections.Specialized;
 using System.ComponentModel;
+using System.Text.Json;
+using Avalonia.Media.Imaging;
+using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Assets;
 using GalNet.Editor.Abstraction.Extensibility;
 using GalNet.Editor.History;
 using GalNet.Editor.Models.Graph;
@@ -16,10 +22,26 @@ public sealed class EntryInspectorViewModel : ObservableObject, IInspectorContro
     private bool _locked;
     private string? _entryId;
     private readonly AuthorNavigationService? _navigation;
+    private readonly ProjectSceneTargets? _sceneTargets;
+    private readonly IAssetManager? _assets;
+    private CancellationTokenSource? _previewCancellation;
+    private EntryEditorItemViewModel? _previewOwner;
+    private string? _previewKey;
+    private bool _disposed;
     public string? RequestedField { get; private set; }
+    public IReadOnlyList<string>? RequestedFieldPath { get; private set; }
     public EntryParameterFormBinding? Form { get; private set; }
+    public ShaderParameterFormBinding? ShaderForm { get; private set; }
+    public bool IsShaderMode { get; private set; }
+    public bool ShaderUnavailable => IsShaderMode && ShaderForm is null;
+    public Bitmap? ShaderPreview { get; private set; }
+    public string? ShaderPreviewError { get; private set; }
+    public bool IsShaderPreviewLoading { get; private set; }
+    public Task PreviewLoading { get; private set; } = Task.CompletedTask;
     private EntryEditorItemViewModel? _formOwner;
     private string? _formType;
+    private string? _shaderProgram;
+    private ShaderEffectDescriptor? _shaderDescriptor;
     public EntryEditorItemViewModel? Entry => Page.Workspace.Nodes.FirstOrDefault(node => node.Id == Page.GroupId)?.Entries.FirstOrDefault(entry => entry.StableId == _entryId);
     public EditorRegistry FieldEditors => Page.FieldEditors;
     public bool IsAvailable => Entry is not null;
@@ -27,14 +49,18 @@ public sealed class EntryInspectorViewModel : ObservableObject, IInspectorContro
     public string TargetDescription => Entry is { } entry ? $"{Page.Workspace.Nodes.FirstOrDefault(node => node.Id == Page.GroupId)?.Name} / {entry.Id} · {entry.Type}" : "";
     public bool HasMultipleSelection => Page.SelectedEntries.Count > 1;
     public int SelectionCount => Page.SelectedEntries.Count;
-    public EntryInspectorViewModel(GroupEditorPanelViewModel page, AuthorNavigationService? navigation = null)
+    public EntryInspectorViewModel(GroupEditorPanelViewModel page, AuthorNavigationService? navigation = null,
+        ProjectSceneTargets? sceneTargets = null, IAssetManager? assets = null)
     {
         Page = page;
         _navigation = navigation;
+        _sceneTargets = sceneTargets;
+        _assets = assets;
         if (_navigation is not null) _navigation.Requested += Navigate;
+        if (_sceneTargets is not null) _sceneTargets.Changed += Refresh;
         Page.PropertyChanged += PageChanged;
         Page.SelectedEntries.CollectionChanged += SelectionChanged;
-        Page.Workspace.Nodes.CollectionChanged += NodesChanged;
+        ((INotifyCollectionChanged)Page.Workspace.Nodes).CollectionChanged += NodesChanged;
         Page.Workspace.UndoRedoHistory!.Changed += Refresh;
         Sync();
     }
@@ -43,32 +69,106 @@ private void PageChanged(object? sender, PropertyChangedEventArgs args)
     private void NodesChanged(object? sender, NotifyCollectionChangedEventArgs args) => Refresh();
     private void SelectionChanged(object? sender, NotifyCollectionChangedEventArgs args)
     { OnPropertyChanged(nameof(HasMultipleSelection)); OnPropertyChanged(nameof(SelectionCount)); }
+    private void EntryChanged(object? sender, PropertyChangedEventArgs args)
+    { if (args.PropertyName is nameof(EntryEditorItemViewModel.Parameters) or nameof(EntryEditorItemViewModel.Type)) Refresh(); }
     private void Sync() { _entryId = Page.SelectedEntry?.StableId; Refresh(); }
     private void Navigate(AuthorNavigationTarget target)
     {
         if (target.NodeId != Page.GroupId || target.EntryId != _entryId) return;
-        RequestedField = target.FieldId; OnPropertyChanged(nameof(RequestedField));
+        RequestedFieldPath = target.FieldPath; RequestedField = target.FieldId; OnPropertyChanged(nameof(RequestedField));
     }
     private void Refresh()
     {
+        if (_disposed) return;
         var entry = Entry;
-        if (!ReferenceEquals(entry, _formOwner) || entry?.Type != _formType)
+        var ownerChanged = !ReferenceEquals(entry, _formOwner);
+        var program = entry?.Type == BuiltinEntryIds.ApplyEffect && entry.Source.Parameters.TryGetValue("program", out var selected)
+            && selected.ValueKind == System.Text.Json.JsonValueKind.String ? selected.GetString() : null;
+        var shaderMode = !string.IsNullOrWhiteSpace(program);
+        if (ownerChanged || entry?.Type != _formType || shaderMode != IsShaderMode)
         {
-            Form?.Dispose(); Form = null; _formOwner = entry; _formType = entry?.Type;
-            if (entry?.DetailForm is { } form) Form = new EntryParameterFormBinding(entry, form.Fields, entry.ParameterDtoType);
+            if (_formOwner is not null) _formOwner.PropertyChanged -= EntryChanged;
+            Form?.Dispose(); Form = null;
+            _formOwner = entry; _formType = entry?.Type; IsShaderMode = shaderMode;
+            if (entry is not null) entry.PropertyChanged += EntryChanged;
+            if (entry?.DetailForm is { } form)
+            {
+                Form = new EntryParameterFormBinding(entry, shaderMode ? form.Fields.Where(field => field.Id is not ("id" or "parameters")).ToArray() : form.Fields, entry.ParameterDtoType);
+            }
             OnPropertyChanged(nameof(Form));
+            OnPropertyChanged(nameof(IsShaderMode));
+        }
+        var descriptor = shaderMode && _sceneTargets is not null ? _sceneTargets.ProgramDescriptor(program!) : null;
+        if (ownerChanged || _shaderProgram != program || !ReferenceEquals(_shaderDescriptor, descriptor))
+        {
+            ShaderForm?.Dispose(); ShaderForm = null;
+            _shaderProgram = program; _shaderDescriptor = descriptor;
+            if (entry is not null && descriptor is not null && entry.DetailForm?.Fields.FirstOrDefault(field => field.Id == "parameters") is { } root)
+                ShaderForm = new ShaderParameterFormBinding(entry, root, descriptor);
+            OnPropertyChanged(nameof(ShaderForm));
+            OnPropertyChanged(nameof(ShaderUnavailable));
         }
         Form?.Refresh();
+        ShaderForm?.Refresh();
+        RefreshPreview(entry, program);
         OnPropertyChanged(nameof(Entry)); OnPropertyChanged(nameof(IsAvailable)); OnPropertyChanged(nameof(TargetDescription));
     }
+    private void RefreshPreview(EntryEditorItemViewModel? entry, string? program)
+    {
+        var parameters = entry?.Source.Parameters.GetValueOrDefault("parameters") ?? default;
+        var json = parameters.ValueKind == JsonValueKind.Undefined ? "{}" : parameters.GetRawText();
+        var key = !string.IsNullOrWhiteSpace(program) && _assets is not null
+            ? program + "\n" + json + "\n" + (_sceneTargets?.ResourceEpoch ?? 0) : null;
+        if (ReferenceEquals(entry, _previewOwner) && key == _previewKey) return;
+        _previewOwner = entry; _previewKey = key;
+        _previewCancellation?.Cancel(); _previewCancellation?.Dispose(); _previewCancellation = null;
+        var old = ShaderPreview; ShaderPreview = null; old?.Dispose();
+        ShaderPreviewError = null; IsShaderPreviewLoading = key is not null;
+        OnPropertyChanged(nameof(ShaderPreview)); OnPropertyChanged(nameof(ShaderPreviewError)); OnPropertyChanged(nameof(IsShaderPreviewLoading));
+        if (key is null) { PreviewLoading = Task.CompletedTask; return; }
+        var cancellation = new CancellationTokenSource(); _previewCancellation = cancellation;
+        PreviewLoading = RenderPreviewAsync(program!, json, cancellation);
+    }
+    private async Task RenderPreviewAsync(string program, string parameters, CancellationTokenSource cancellation)
+    {
+        try
+        {
+            var png = await Task.Run(() => ShaderEffectPreviewRenderer.RenderAsync(_assets!, program, parameters, cancellation.Token), cancellation.Token);
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                if (_disposed || !ReferenceEquals(_previewCancellation, cancellation)) return;
+                using var stream = new MemoryStream(png, writable: false);
+                ShaderPreview = new Bitmap(stream);
+                IsShaderPreviewLoading = false;
+                OnPropertyChanged(nameof(ShaderPreview)); OnPropertyChanged(nameof(IsShaderPreviewLoading));
+            });
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception error)
+        {
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                if (_disposed || !ReferenceEquals(_previewCancellation, cancellation)) return;
+                ShaderPreviewError = error.Message;
+                IsShaderPreviewLoading = false;
+                OnPropertyChanged(nameof(ShaderPreviewError)); OnPropertyChanged(nameof(IsShaderPreviewLoading));
+            });
+        }
+    }
     public void SetLocked(bool isLocked) { _locked = isLocked; if (!_locked) Sync(); }
     public void Dispose()
     {
+        _disposed = true;
+        _previewCancellation?.Cancel(); _previewCancellation?.Dispose(); _previewCancellation = null;
+        ShaderPreview?.Dispose(); ShaderPreview = null;
         Form?.Dispose();
+        ShaderForm?.Dispose();
+        if (_formOwner is not null) _formOwner.PropertyChanged -= EntryChanged;
         if (_navigation is not null) _navigation.Requested -= Navigate;
+        if (_sceneTargets is not null) _sceneTargets.Changed -= Refresh;
         Page.PropertyChanged -= PageChanged;
         Page.SelectedEntries.CollectionChanged -= SelectionChanged;
-        Page.Workspace.Nodes.CollectionChanged -= NodesChanged;
+        ((INotifyCollectionChanged)Page.Workspace.Nodes).CollectionChanged -= NodesChanged;
         Page.Workspace.UndoRedoHistory!.Changed -= Refresh;
     }
 }
diff --git a/src/Editor/GalNet.Editor/Inspector/ViewModels/ImageVariantsInspector.cs b/src/Editor/GalNet.Editor/Inspector/ViewModels/ImageVariantsInspector.cs
index 8ae83022..920b0c6e 100644
--- a/src/Editor/GalNet.Editor/Inspector/ViewModels/ImageVariantsInspector.cs
+++ b/src/Editor/GalNet.Editor/Inspector/ViewModels/ImageVariantsInspector.cs
@@ -7,8 +7,8 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using GalNet.Assets.Variants;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
-using GalNet.Core.Variants;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Services;
 using GalNet.Editor.Services.Interfaces;
@@ -16,11 +16,11 @@
 
 namespace GalNet.Editor.Inspector.ViewModels;
 
-public sealed partial class VariantDimensionRow(Action changed) : ObservableObject
+public sealed partial class VariantDimensionRow(string key, Action changed) : ObservableObject
 {
-    [ObservableProperty] private string _key = "";
+    public string Key { get; } = key;
+    [ObservableProperty] private string _heading = "";
     [ObservableProperty] private string _label = "";
-    partial void OnKeyChanged(string value) => changed();
     partial void OnLabelChanged(string value) => changed();
 }
 
@@ -48,9 +48,9 @@ public sealed partial class ImageVariantsInspector : ObservableObject, IDisposab
     private IReadOnlyList<string> _protected = [];
     private bool _refreshing, _disposed;
     private int _generation, _imageGeneration;
-    private string? _originalKeys;
     private static readonly JsonSerializerOptions Json = new() { WriteIndented = true };
     public ProjectTextBuffer Buffer { get; }
+    public Task ConfigurationSaving { get; private set; } = Task.CompletedTask;
     public Task PreviewLoading { get; private set; } = Task.CompletedTask;
     public ObservableCollection<VariantDimensionRow> Dimensions { get; } = [];
     public ObservableCollection<VariantPreviewRow> PreviewRows { get; } = [];
@@ -60,7 +60,6 @@ public sealed partial class ImageVariantsInspector : ObservableObject, IDisposab
     [ObservableProperty] private string _default = "";
     [ObservableProperty] private IReadOnlyList<string> _variantKeys = [];
     [ObservableProperty] private string _diagnostics = "";
-    [ObservableProperty] private string _impact = "";
     [ObservableProperty] private string _requested = "";
     [ObservableProperty] private string _actual = "";
     [ObservableProperty] private string _fallback = "";
@@ -75,12 +74,23 @@ public ImageVariantsInspector(string root, ProjectTextBuffer buffer, IProjectSer
     private bool Current => !_disposed && _projects.Current?.RootPath == _root && !Buffer.IsReadOnly;
     partial void OnFolderChanged(string value) { if (!_refreshing && CanConfigure) { _source!.Folder = value; Write(); } }
     partial void OnDefaultChanged(string value) { OnPropertyChanged(nameof(DefaultChoice)); if (!_refreshing && CanConfigure && value is not null) { _source!.Default = value; Write(); } }
-    partial void OnVariantKeysChanged(IReadOnlyList<string> value) => OnPropertyChanged(nameof(DefaultChoice));
-    private void Write() { if (Current && _source is not null) Buffer.Text = JsonSerializer.Serialize(_source, Json); }
+    partial void OnVariantKeysChanged(IReadOnlyList<string> value) { OnPropertyChanged(nameof(DefaultChoice)); }
+    private void Write()
+    {
+        if (!Current || _source is null) return;
+        Buffer.Text = JsonSerializer.Serialize(_source, Json);
+        ConfigurationSaving = CommitConfigurationAsync(ConfigurationSaving);
+    }
+    private async Task CommitConfigurationAsync(Task previous)
+    {
+        await previous;
+        if (!Current) return;
+        try { await Buffer.CommitAsync(); }
+        catch (Exception error) { if (Current) Diagnostics = error.Message; }
+    }
     private void BufferChanged(object? sender, PropertyChangedEventArgs args) { if (args.PropertyName is nameof(ProjectTextBuffer.Text) or nameof(ProjectTextBuffer.Path) or nameof(ProjectTextBuffer.IsReadOnly)) Refresh(); }
     private void ResourcesChanged() => Dispatcher.UIThread.Post(() => { if (Current) Refresh(); });
     private void LocaleChanged(object? sender, PropertyChangedEventArgs args) { if (args.PropertyName == "Item[]" && Current) Refresh(); }
-    [RelayCommand]
     public void Refresh()
     {
         if (!Current) { OnPropertyChanged(nameof(CanConfigure)); return; }
@@ -98,19 +108,36 @@ public void Refresh()
                 Diagnostics = string.Join("\n", _snapshot.Build.Diagnostics.Select(item => $"{item.Path} [{item.Code}]: {item.Message}"));
                 Dimensions.Clear(); _source = null; return;
             }
-            var dimensions = _source.Dimensions ?? _snapshot.Build.Definition?.Dimensions.Select(item => new ImageVariantDimensionSource { Key = item.Key, Label = item.Label }).ToList() ?? [];
-            while (Dimensions.Count > dimensions.Count) Dimensions.RemoveAt(Dimensions.Count - 1);
-            while (Dimensions.Count < dimensions.Count) Dimensions.Add(new(DimensionsChanged));
-            for (var i = 0; i < dimensions.Count; i++) { Dimensions[i].Key = dimensions[i].Key; Dimensions[i].Label = dimensions[i].Label ?? ""; }
-            var keys = string.Join("\n", dimensions.Select(item => item.Key)); _originalKeys ??= keys;
-            Impact = keys == _originalKeys ? "" : _text["Variants.IdentityWarning"];
+            // Even a missing default must leave the default picker and names editable.
+            var definitionForNames = _snapshot.Build.Definition ?? ImageVariantsBuilder.Build(new ImageVariantsSource
+            {
+                Folder = _source.Folder,
+                Default = VariantKeys.FirstOrDefault() ?? "",
+                Dimensions = _source.Dimensions
+            }, _snapshot.Files).Definition;
+            var dimensions = definitionForNames?.Dimensions ?? [];
+            if (!Dimensions.Select(row => row.Key).SequenceEqual(dimensions.Select(item => item.Key)))
+            {
+                Dimensions.Clear();
+                foreach (var item in dimensions) Dimensions.Add(new(item.Key, DimensionsChanged));
+            }
+            for (var i = 0; i < dimensions.Count; i++)
+            {
+                Dimensions[i].Heading = _text.Format("Variants.Dimension", i + 1);
+                Dimensions[i].Label = ConfiguredLabel(i) ?? "";
+            }
             Diagnostics = string.Join("\n", _snapshot.Build.Diagnostics.Select(item => $"{item.Path} [{item.Code}]: {item.Message}"));
             if (_snapshot.Build.Definition is { } definition)
             {
                 _selection = _request is null ? ImageVariantsResolver.Initialize(definition) : ImageVariantsResolver.Resolve(definition, _request, _protected);
                 _request = _selection.Request;
-                foreach (var dimension in definition.Dimensions)
-                    PreviewRows.Add(new(dimension.Key, dimension.Label ?? dimension.Key, dimension.Options, _request.GetValueOrDefault(dimension.Key), (key, value) => { if (generation == _generation && Current) Select(key, value); }));
+                for (var i = 0; i < definition.Dimensions.Count; i++)
+                {
+                    var dimension = definition.Dimensions[i];
+                    var label = ConfiguredLabel(i);
+                    PreviewRows.Add(new(dimension.Key, string.IsNullOrWhiteSpace(label) ? _text.Format("Variants.Dimension", i + 1) : label,
+                        dimension.Options, _request.GetValueOrDefault(dimension.Key), (key, value) => { if (generation == _generation && Current) Select(key, value); }));
+                }
                 ShowResult();
             }
         }
@@ -118,15 +145,36 @@ public void Refresh()
         { Diagnostics = error.Message; }
         finally { _refreshing = false; OnPropertyChanged(nameof(CanConfigure)); }
     }
+    private string? ConfiguredLabel(int position) => _source?.Dimensions is { } names && position < names.Count ? names[position]?.Label : null;
     private void DimensionsChanged()
     {
         if (_refreshing || !CanConfigure) return;
-        _source!.Dimensions = Dimensions.Select(row => new ImageVariantDimensionSource { Key = row.Key, Label = row.Label }).ToList(); Write();
+        // Preserve dormant position names so temporarily removing the longest file is reversible.
+        _source!.Dimensions = Dimensions.Select(row => new ImageVariantDimensionSource { Key = row.Key, Label = string.IsNullOrWhiteSpace(row.Label) ? null : row.Label })
+            .Concat(_source.Dimensions?.Skip(Dimensions.Count) ?? []).ToList();
+        Write();
+    }
+    [RelayCommand]
+    private async Task BrowseFolderAsync()
+    {
+        if (!CanConfigure || _projects.Current?.Services.GetService(typeof(IFileDialogService)) is not IFileDialogService dialogs) return;
+        var generation = _generation;
+        var selected = await dialogs.OpenFolderPickerAsync(_text["Variants.Folder"]);
+        if (!Current || generation != _generation || string.IsNullOrWhiteSpace(selected)) return;
+        try
+        {
+            var reader = new ProjectRawReader(_root);
+            var relative = reader.Relative(selected);
+            if (relative != "Assets" && !relative.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
+                throw new InvalidDataException("Image folder must be inside Assets.");
+            _ = reader.Resolve(relative);
+            var folder = Path.GetRelativePath(Path.GetDirectoryName(Path.Combine(_root, Buffer.Path))!, selected).Replace('\\', '/');
+            if (folder == Folder) Refresh(); else Folder = folder;
+            await ConfigurationSaving;
+        }
+        catch (Exception error) when (error is IOException or InvalidDataException or ArgumentException or UnauthorizedAccessException)
+        { if (Current) Diagnostics = error.Message; }
     }
-    [RelayCommand] private void AddDimension() { if (!CanConfigure) return; var index = 1; while (Dimensions.Any(row => row.Key == "d" + index)) index++; _refreshing = true; Dimensions.Add(new(DimensionsChanged) { Key = "d" + index }); _refreshing = false; DimensionsChanged(); }
-    [RelayCommand] private void RemoveDimension(VariantDimensionRow row) { if (CanConfigure && Dimensions.Remove(row)) DimensionsChanged(); }
-    [RelayCommand] private void MoveUp(VariantDimensionRow row) { var index = Dimensions.IndexOf(row); if (CanConfigure && index > 0) { Dimensions.Move(index, index - 1); DimensionsChanged(); } }
-    [RelayCommand] private void InferDimensions() { if (CanConfigure) { _source!.Dimensions = null; Write(); } }
     [RelayCommand] private void ResetPreview() { if (Current) { _request = null; _protected = []; Refresh(); } }
     public void Select(string key, string value)
     {
@@ -134,13 +182,14 @@ public void Select(string key, string value)
         try { _selection = ImageVariantsResolver.Select(definition, _request, key, value); _request = _selection.Request; _protected = _selection.ProtectedDimensions; ShowResult(); }
         catch (ArgumentException error) { Diagnostics = error.Message; }
     }
+    private string DisplayDimension(string key) => PreviewRows.FirstOrDefault(row => row.Key == key)?.Label ?? key;
     private void ShowResult()
     {
         if (_selection is not { } result) return;
         var previous = Preview; Preview = null; previous?.Dispose();
-        Requested = string.Join(" · ", result.Request.Select(pair => pair.Key + "=" + pair.Value));
+        Requested = string.Join(" · ", result.Request.Select(pair => DisplayDimension(pair.Key) + "=" + pair.Value));
         Actual = result.Variant.Key + " · " + _text["Variants.Reason." + result.Reason];
-        Fallback = string.Join("\n", result.Candidates.Select(item => string.Join(" · ", item.Selection.Select(pair => pair.Key + "=" + pair.Value)) + " → " + (item.Match?.Key ?? "∅")));
+        Fallback = string.Join("\n", result.Candidates.Select(item => string.Join(" · ", item.Selection.Select(pair => DisplayDimension(pair.Key) + "=" + pair.Value)) + " → " + (item.Match?.Key ?? "∅")));
         if (_snapshot!.ImagePaths.TryGetValue(result.Variant.AssetId, out var path)) PreviewLoading = LoadPreviewAsync(path, ++_imageGeneration);
     }
     private async Task LoadPreviewAsync(string path, int generation)
@@ -155,7 +204,6 @@ private async Task LoadPreviewAsync(string path, int generation)
         catch (Exception error) when (error is IOException or ArgumentException or InvalidDataException or UnauthorizedAccessException)
         { if (Current && generation == _imageGeneration) Diagnostics = error.Message; }
     }
-    [RelayCommand] private async Task ApplyAsync() { if (!Current) return; try { await Buffer.CommitAsync(); Refresh(); } catch (Exception error) { Diagnostics = error.Message; } }
     public void Dispose()
     {
         if (_disposed) return; _disposed = true; _generation++; _imageGeneration++;
diff --git a/src/Editor/GalNet.Editor/Inspector/ViewModels/NodeInspectorControlViewModel.cs b/src/Editor/GalNet.Editor/Inspector/ViewModels/NodeInspectorControlViewModel.cs
index f1a0af18..2ee06e46 100644
--- a/src/Editor/GalNet.Editor/Inspector/ViewModels/NodeInspectorControlViewModel.cs
+++ b/src/Editor/GalNet.Editor/Inspector/ViewModels/NodeInspectorControlViewModel.cs
@@ -28,6 +28,8 @@ public sealed partial class NodeInspectorControlViewModel : ObservableObject, II
     public bool IsAvailable => InspectedEdge is null;
     public bool HasSelectedNode => InspectedNode is not null;
     public bool IsLinearGroupSelected => InspectedNode?.NodeKind == GraphNodeKind.LinearGroup;
+    public IReadOnlyList<string> StoryPackageNames => Workspace.Nodes.Select(node => node.Source.StoryPackage)
+        .Where(name => !string.IsNullOrEmpty(name)).Select(name => name!).Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal).ToArray();
     public bool IsChoiceBranchSelected => InspectedNode?.NodeKind == GraphNodeKind.ChoiceBranch;
     public bool IsConditionBranchSelected => InspectedNode?.NodeKind == GraphNodeKind.ConditionBranch;
     public IReadOnlyList<ConditionVariableSuggestion> ConditionSuggestions => Workspace.GetConditionVariableSuggestions();
@@ -40,7 +42,7 @@ public NodeInspectorControlViewModel(EditorWorkspaceViewModel workspace, IEditor
         _localization = localization;
         SyncSelection();
         Workspace.PropertyChanged += OnWorkspacePropertyChanged;
-        Workspace.Nodes.CollectionChanged += OnNodesChanged;
+        ((System.Collections.Specialized.INotifyCollectionChanged)Workspace.Nodes).CollectionChanged += OnNodesChanged;
         Workspace.VariableDefinitionsChanged += OnVariableDefinitionsChanged;
         _localization.PropertyChanged += OnLocalizationPropertyChanged;
     }
@@ -106,6 +108,7 @@ private void RaiseSelectionPropertiesChanged()
         OnPropertyChanged(nameof(IsChoiceBranchSelected));
         OnPropertyChanged(nameof(IsConditionBranchSelected));
         OnPropertyChanged(nameof(EntryCountText));
+        OnPropertyChanged(nameof(StoryPackageNames));
     }
 
     private void OnVariableDefinitionsChanged()
@@ -123,7 +126,7 @@ private void OnLocalizationPropertyChanged(object? sender, PropertyChangedEventA
     public void Dispose()
     {
         Workspace.PropertyChanged -= OnWorkspacePropertyChanged;
-        Workspace.Nodes.CollectionChanged -= OnNodesChanged;
+        ((System.Collections.Specialized.INotifyCollectionChanged)Workspace.Nodes).CollectionChanged -= OnNodesChanged;
         Workspace.VariableDefinitionsChanged -= OnVariableDefinitionsChanged;
         _localization.PropertyChanged -= OnLocalizationPropertyChanged;
     }
diff --git a/src/Editor/GalNet.Editor/Inspector/ViewModels/PreviewVariablesInspectorControlViewModel.cs b/src/Editor/GalNet.Editor/Inspector/ViewModels/PreviewVariablesInspectorControlViewModel.cs
deleted file mode 100644
index b5cb2d87..00000000
--- a/src/Editor/GalNet.Editor/Inspector/ViewModels/PreviewVariablesInspectorControlViewModel.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using CommunityToolkit.Mvvm.ComponentModel;
-using GalNet.Editor.Abstraction.Extensibility;
-using GalNet.Editor.ViewModels;
-
-namespace GalNet.Editor.Inspector.ViewModels;
-
-public sealed class PreviewVariablesInspectorControlViewModel : ObservableObject, IInspectorControlViewModel
-{
-    public GamePreviewPanelViewModel Preview { get; }
-    public bool IsAvailable => true;
-    public PreviewVariablesInspectorControlViewModel(GamePreviewPanelViewModel preview) => Preview = preview;
-    public void Dispose() { }
-}
diff --git a/src/Editor/GalNet.Editor/Inspector/ViewModels/ShaderEffectPreviewRenderer.cs b/src/Editor/GalNet.Editor/Inspector/ViewModels/ShaderEffectPreviewRenderer.cs
new file mode 100644
index 00000000..b054249e
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Inspector/ViewModels/ShaderEffectPreviewRenderer.cs
@@ -0,0 +1,85 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Assets;
+using GalNet.Rendering.Scene;
+using SkiaSharp;
+
+namespace GalNet.Editor.Inspector.ViewModels;
+
+/// <summary>Renders an author's shader with the production texture effect on a fixed sample image.</summary>
+internal static class ShaderEffectPreviewRenderer
+{
+    public const int Size = 192;
+    private const int MaximumProgramBytes = 1024 * 1024;
+
+    public static async Task<byte[]> RenderAsync(IAssetManager assets, string programId, string parameters, CancellationToken token)
+    {
+        var file = await assets.GetFileAsync(programId, token) ?? throw new InvalidDataException("Shader resource was not found.");
+        if (file.TypeId != "effect-program" || file.Length > MaximumProgramBytes)
+            throw new InvalidDataException("The selected resource is not a supported shader program.");
+        var bytes = await file.ReadAllBytesAsync(token);
+        token.ThrowIfCancellationRequested();
+        if (bytes.Length > MaximumProgramBytes) throw new InvalidDataException("The shader program is too large to preview.");
+        var source = new System.Text.UTF8Encoding(false, true).GetString(bytes);
+        var resource = new EffectProgramResource(programId);
+        var compiled = SkiaShaderEffectProgramLoader.Load(resource, source);
+        if (!compiled.IsUsable)
+            throw new InvalidDataException(string.Join(Environment.NewLine, compiled.Diagnostics));
+        using var runtimeEffect = compiled.RuntimeEffect!;
+        var stage = compiled.Descriptor!.Supports(EffectStage.Layer) ? EffectStage.Layer : EffectStage.ScenePost;
+        var factory = new ShaderProgramTextureEffectFactory(programId, stage, resource, compiled);
+        using var textures = new ShaderTextureBindings();
+        using var document = JsonDocument.Parse(parameters);
+        if (document.RootElement.ValueKind != JsonValueKind.Object)
+            throw new InvalidDataException("Shader parameters must be a JSON object.");
+        foreach (var parameter in compiled.Descriptor.Parameters.Where(item => item.Kind == ShaderEffectParameterKind.Texture))
+        {
+            token.ThrowIfCancellationRequested();
+            var id = document.RootElement.TryGetProperty(parameter.Name, out var value) && value.ValueKind == JsonValueKind.String
+                ? value.GetString() : null;
+            if (string.IsNullOrWhiteSpace(id))
+            {
+                if (parameter.Required) throw new InvalidDataException($"Shader texture '{parameter.Name}' is required.");
+                continue;
+            }
+            var lease = await assets.AcquireAsync<SceneTexture>(id, token)
+                ?? throw new InvalidDataException($"Shader texture '{id}' could not be loaded.");
+            textures.Add(parameter.Name, lease);
+        }
+        token.ThrowIfCancellationRequested();
+        using var sourceBitmap = CreateSample();
+        using var output = new SKBitmap(Size, Size);
+        using (var canvas = new SKCanvas(output))
+        using (var instance = new SceneEffectInstance("editor-preview", factory, "editor-preview", 0, parameters, textures: textures))
+        {
+            canvas.Clear(SKColors.Transparent);
+            instance.Effect.Render(canvas, sourceBitmap, instance);
+            canvas.Flush();
+        }
+        using var image = SKImage.FromBitmap(output);
+        using var encoded = image.Encode(SKEncodedImageFormat.Png, 100)
+            ?? throw new InvalidDataException("The shader preview could not be encoded.");
+        return encoded.ToArray();
+    }
+
+    private static SKBitmap CreateSample()
+    {
+        var image = new SKBitmap(Size, Size);
+        using var canvas = new SKCanvas(image);
+        canvas.Clear(SKColors.White);
+        using var paint = new SKPaint { IsAntialias = true };
+        for (var y = 0; y < 4; y++)
+            for (var x = 0; x < 4; x++)
+            {
+                paint.Color = (x + y) % 2 == 0 ? new SKColor(235, 238, 245) : new SKColor(205, 213, 228);
+                canvas.DrawRect(x * 48, y * 48, 48, 48, paint);
+            }
+        paint.Color = new SKColor(235, 78, 98);
+        canvas.DrawCircle(64, 67, 45, paint);
+        paint.Color = new SKColor(44, 137, 228);
+        canvas.DrawRoundRect(new SKRect(99, 31, 167, 125), 12, 12, paint);
+        paint.Color = new SKColor(245, 190, 60);
+        canvas.DrawRect(26, 139, 166, 170, paint);
+        return image;
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Inspector/ViewModels/ShaderParameterFormBinding.cs b/src/Editor/GalNet.Editor/Inspector/ViewModels/ShaderParameterFormBinding.cs
new file mode 100644
index 00000000..ccaec983
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Inspector/ViewModels/ShaderParameterFormBinding.cs
@@ -0,0 +1,72 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Models.Graph;
+using GalNet.Game.Controls.Forms;
+
+namespace GalNet.Editor.Inspector.ViewModels;
+
+/// <summary>Projects shader metadata onto one effect.apply parameters object without owning author data.</summary>
+public sealed class ShaderParameterFormBinding : IDisposable
+{
+    private readonly EntryEditorItemViewModel _owner;
+    private readonly FieldDescriptor _root;
+    private readonly string _program;
+    private EventHandler? _changed;
+    private bool _disposed;
+
+    public ShaderParameterFormBinding(EntryEditorItemViewModel owner, FieldDescriptor root, ShaderEffectDescriptor shader)
+    {
+        _owner = owner;
+        _root = root;
+        _program = shader.Resource.Value;
+        var definitions = shader.Parameters.Select(parameter => (Parameter: parameter, Field: ShaderEffectFields.Create(parameter))).ToArray();
+        var bindings = definitions.ToDictionary(item => item.Field.Id,
+            item => (IFieldBinding)new ParameterBinding(this, item.Parameter, item.Field), StringComparer.Ordinal);
+        Item = new(owner.StableId + "/shader", null, definitions.Select(item => item.Field).ToArray(), field => bindings[field.Id]);
+    }
+
+    public DtoEditorItem Item { get; }
+    private bool IsCurrent => !_disposed && _owner.IsCurrent && _owner.Type == BuiltinEntryIds.ApplyEffect
+        && _owner.Source.Parameters.TryGetValue("program", out var program) && program.ValueKind == JsonValueKind.String
+        && program.GetString() == _program;
+
+    public void Refresh() { if (!_disposed) _changed?.Invoke(this, EventArgs.Empty); }
+    public void Dispose() { _disposed = true; _changed = null; }
+
+    private sealed class ParameterBinding(ShaderParameterFormBinding form, ShaderEffectParameterDescriptor parameter, FieldDescriptor descriptor) : IFieldBinding
+    {
+        public FieldDraftState? Draft => form.IsCurrent ? form._owner.EditSession?.Get(form._owner, form._root).Child?.Invoke(descriptor, descriptor.Id) : null;
+        public object? Label => string.IsNullOrWhiteSpace(parameter.Group) ? parameter.DisplayName ?? descriptor.Id
+            : parameter.Group + " / " + (parameter.DisplayName ?? descriptor.Id);
+        public bool IsEnabled => form.IsCurrent;
+        public FieldValue Read()
+        {
+            if (form._owner.Source.Parameters.TryGetValue("parameters", out var root)
+                && root.ValueKind == JsonValueKind.Object && root.TryGetProperty(descriptor.Id, out var value)) return new(value);
+            return default;
+        }
+        public event EventHandler? Changed
+        {
+            add { ObjectDisposedException.ThrowIf(form._disposed, form); form._changed += value; }
+            remove { form._changed -= value; }
+        }
+        public async Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (!form.IsCurrent) return new("shader.obsolete", "The shader selection changed.", descriptor.Id);
+            if (value.Json is not { } && descriptor.IsRequired && descriptor.DefaultValue is null)
+                return new("shader.required", "A value is required.", descriptor.Id);
+            if (value.Json is { } candidate && ValueValidation.Validate(descriptor.Value, candidate) is { } issue) return issue;
+            var source = form._owner.Source.Parameters.GetValueOrDefault("parameters");
+            if (source.ValueKind is not (JsonValueKind.Undefined or JsonValueKind.Object))
+                return new("shader.parameters", "Shader parameters must be an object.");
+            var values = source.ValueKind == JsonValueKind.Object
+                ? source.EnumerateObject().ToDictionary(item => item.Name, item => item.Value.Clone(), StringComparer.Ordinal)
+                : new Dictionary<string, JsonElement>(StringComparer.Ordinal);
+            if (value.Json is { } json) values[descriptor.Id] = json.Clone(); else values.Remove(descriptor.Id);
+            return await form._owner.CommitParameterAsync(form._root, new(JsonSerializer.SerializeToElement(values)), cancellationToken);
+        }
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Inspector/ViewModels/TimelineEventInspectorViewModel.cs b/src/Editor/GalNet.Editor/Inspector/ViewModels/TimelineEventInspectorViewModel.cs
new file mode 100644
index 00000000..1cc22eeb
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Inspector/ViewModels/TimelineEventInspectorViewModel.cs
@@ -0,0 +1,59 @@
+using System.ComponentModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GalNet.Editor.Abstraction.Extensibility;
+using GalNet.Editor.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Game.Controls.Timeline;
+
+namespace GalNet.Editor.Inspector.ViewModels;
+
+public sealed partial class TimelineEventInspectorViewModel : ObservableObject, IInspectorControlViewModel, IInspectorLockAware
+{
+    private readonly TimelinePanelViewModel _page;
+    private bool _locked, _updating, _disposed;
+    public TimelineEventEdit? Draft { get; private set; }
+    public string Label { get; private set; } = "";
+    public bool IsAvailable => Draft is { IsCurrent: true };
+    public GalNet.Game.Controls.Forms.EditorRegistry FieldEditors => _page.FieldEditors;
+    public TimelineEventInspectorViewModel(TimelinePanelViewModel page)
+    {
+        _page = page;
+        page.Session.EventCanvas.PropertyChanged += SelectionChanged;
+        page.Session.PropertyChanged += SessionChanged;
+        Sync();
+    }
+    private void SelectionChanged(object? sender, PropertyChangedEventArgs e)
+    { if (e.PropertyName == nameof(TimelineCanvasModel.Selection) && !_locked) Sync(); }
+    private void SessionChanged(object? sender, PropertyChangedEventArgs e)
+    { if (Draft is not null && !Draft.IsCurrent) { Draft.Dispose(); Draft = null; Notify(); } }
+    private void Sync()
+    {
+        if (_updating || _disposed) return;
+        _updating = true;
+        try
+        {
+            var rows = _page.Session.Events.Where(row => row.IsSelected).ToArray();
+            var row = rows.Length == 1 && rows[0].CanEdit ? rows[0] : null;
+            Label = row?.Label ?? "";
+            if (row is null || Draft is not { IsCurrent: true } draft || draft.Index != row.Index)
+            {
+                Draft?.Dispose();
+                Draft = row is null ? null : _page.Session.CreateInspectorEventEdit(row);
+            }
+            Notify();
+        }
+        finally { _updating = false; }
+    }
+    private void Notify() { OnPropertyChanged(nameof(Draft)); OnPropertyChanged(nameof(Label)); OnPropertyChanged(nameof(IsAvailable)); }
+    [RelayCommand] private void Apply() { if (Draft?.Apply() == true) { Draft?.Dispose(); Draft = null; if (!_locked) Sync(); else Notify(); } }
+    [RelayCommand] private void Cancel() { Draft?.Dispose(); Draft = null; if (!_locked) Sync(); else Notify(); }
+    public void SetLocked(bool isLocked) { _locked = isLocked; if (!isLocked) Sync(); }
+    public void Dispose()
+    {
+        _disposed = true;
+        _page.Session.EventCanvas.PropertyChanged -= SelectionChanged;
+        _page.Session.PropertyChanged -= SessionChanged;
+        Draft?.Dispose(); Draft = null;
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/AssetInspectorControl.axaml b/src/Editor/GalNet.Editor/Inspector/Views/AssetInspectorControl.axaml
index fcfac266..d2ac129c 100644
--- a/src/Editor/GalNet.Editor/Inspector/Views/AssetInspectorControl.axaml
+++ b/src/Editor/GalNet.Editor/Inspector/Views/AssetInspectorControl.axaml
@@ -1,31 +1,35 @@
 <UserControl xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:vm="using:GalNet.Editor.Inspector.ViewModels" xmlns:views="using:GalNet.Editor.Inspector.Views" xmlns:converters="using:Avalonia.Data.Converters" xmlns:loc="using:GalNet.Editor.MarkupExtensions" x:Class="GalNet.Editor.Inspector.Views.AssetInspectorControl" x:DataType="vm:AssetInspectorControlViewModel">
- <ScrollViewer>
-  <StackPanel Margin="12" Spacing="10">
-   
-   <StackPanel Spacing="8" IsVisible="{Binding HasSelectedAsset}">
-   <TextBlock Text="{loc:Localize Inspector.Asset.Title}" FontWeight="SemiBold" />
-   <TextBlock Text="{Binding InspectedAsset.Name}" />
-   <TextBlock Text="{loc:Localize Inspector.Asset.Id}" />
-   <TextBlock Text="{Binding InspectedAsset.Id}" FontFamily="Consolas" FontSize="12" />
-   <TextBlock Text="{loc:Localize Inspector.Asset.Path}" />
-   <TextBlock Text="{Binding InspectedAsset.RelativePath}" />
-   
-   <Panel Margin="5"></Panel>
-   <Panel IsVisible="{Binding Variants, Converter={x:Static converters:ObjectConverters.IsNotNull}}"><views:ImageVariantsEditor DataContext="{Binding Variants}"/></Panel>
-   
-   <StackPanel IsVisible="{Binding IsSelectedAssetImage}" Spacing="6">
-    <TextBlock Text="{loc:Localize Inspector.Asset.ImagePreview}" FontWeight="SemiBold" Foreground="{DynamicResource SemiColorText2}" />
-    <Image Source="{Binding ImagePreview}" MaxHeight="220" Stretch="Uniform" />
-    <TextBlock Text="{Binding ImagePreviewError}" Foreground="OrangeRed" TextWrapping="Wrap" />
-    
-    <TextBlock Text="{loc:Localize Inspector.Asset.Filter}" />
-    <ComboBox ItemsSource="{Binding FilterOptions}" SelectedItem="{Binding AssetFilter}" />
-    
-    <TextBlock Text="{loc:Localize Inspector.Asset.Compression}" />
-    <ComboBox ItemsSource="{Binding CompressionOptions}" SelectedItem="{Binding AssetCompression}" />
+ <Grid RowDefinitions="*,Auto,Auto">
+  <ScrollViewer x:Name="AssetProperties" HorizontalScrollBarVisibility="Disabled">
+   <StackPanel Margin="12" Spacing="10" IsVisible="{Binding HasSelectedAsset}">
+    <TextBlock Text="{loc:Localize Inspector.Asset.Title}" FontWeight="SemiBold"/>
+    <SelectableTextBlock Text="{Binding InspectedAsset.Name}" TextWrapping="Wrap"/>
+    <TextBlock Text="{loc:Localize Inspector.Asset.Id}" Foreground="{DynamicResource SemiColorText2}"/>
+    <SelectableTextBlock Text="{Binding InspectedAsset.Id}" FontFamily="Consolas" FontSize="12" TextWrapping="Wrap"/>
+    <TextBlock Text="{loc:Localize Inspector.Asset.Path}" Foreground="{DynamicResource SemiColorText2}"/>
+    <SelectableTextBlock Text="{Binding InspectedAsset.RelativePath}" TextWrapping="Wrap"/>
+    <StackPanel IsVisible="{Binding IsSelectedAssetImage}" Spacing="6">
+     <TextBlock Text="{loc:Localize Inspector.Asset.Filter}"/>
+     <ComboBox ItemsSource="{Binding FilterOptions}" SelectedItem="{Binding AssetFilter}" HorizontalAlignment="Stretch"/>
+     <TextBlock Text="{loc:Localize Inspector.Asset.Compression}"/>
+     <ComboBox ItemsSource="{Binding CompressionOptions}" SelectedItem="{Binding AssetCompression}" HorizontalAlignment="Stretch"/>
+    </StackPanel>
+    <StackPanel IsVisible="{Binding IsSelectedAssetVideo}" Spacing="6">
+     <TextBlock Text="{loc:Localize Inspector.Asset.Compression}"/>
+     <ComboBox ItemsSource="{Binding CompressionOptions}" SelectedItem="{Binding AssetCompression}" HorizontalAlignment="Stretch"/>
+    </StackPanel>
+    <Panel IsVisible="{Binding Variants, Converter={x:Static converters:ObjectConverters.IsNotNull}}"><views:ImageVariantsEditor DataContext="{Binding Variants}"/></Panel>
    </StackPanel>
-   
+  </ScrollViewer>
+  <GridSplitter Grid.Row="1" Height="6" ResizeDirection="Rows" HorizontalAlignment="Stretch" Background="Transparent" IsVisible="{Binding HasPreview}"/>
+  <Expander x:Name="AssetPreview" Grid.Row="2" Header="{loc:Localize Uiux.Inspector.Preview}" IsExpanded="True" IsVisible="{Binding HasPreview}" HorizontalAlignment="Stretch" MaxHeight="300">
+   <ScrollViewer HorizontalScrollBarVisibility="Disabled" Margin="12,4,12,12">
+    <StackPanel Spacing="8">
+     <StackPanel IsVisible="{Binding IsSelectedAssetImage}" Spacing="6">
+      <Image x:Name="AssetImagePreview" Source="{Binding ImagePreview}" MaxHeight="220" Stretch="Uniform"/>
+      <TextBlock Text="{Binding ImagePreviewError}" Foreground="{DynamicResource SystemControlErrorTextForegroundBrush}" TextWrapping="Wrap"/>
+     </StackPanel>
    <StackPanel IsVisible="{Binding IsSelectedAssetAudio}" Spacing="6">
     <TextBlock Text="{loc:Localize Inspector.Asset.AudioPreview}" />
     <Grid ColumnDefinitions="Auto,*,Auto" ColumnSpacing="8">
@@ -37,13 +41,9 @@
     <TextBlock Text="{Binding AudioPreviewError}" Foreground="OrangeRed" TextWrapping="Wrap" />
    </StackPanel>
    
-   <StackPanel IsVisible="{Binding IsSelectedAssetVideo}" Spacing="6">
-    <TextBlock Text="{loc:Localize Inspector.Asset.VideoPreview}" />
-    <TextBlock Text="{loc:Localize Inspector.Asset.Compression}" />
-    <ComboBox ItemsSource="{Binding CompressionOptions}" SelectedItem="{Binding AssetCompression}" />
-   </StackPanel>
-
-  </StackPanel>
- </StackPanel>
- </ScrollViewer>
+     <Panel IsVisible="{Binding Variants, Converter={x:Static converters:ObjectConverters.IsNotNull}}"><views:ImageVariantsPreview DataContext="{Binding Variants}"/></Panel>
+    </StackPanel>
+   </ScrollViewer>
+  </Expander>
+ </Grid>
 </UserControl>
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/AssetInspectorControl.axaml.cs b/src/Editor/GalNet.Editor/Inspector/Views/AssetInspectorControl.axaml.cs
index 89fa30f0..1c27446c 100644
--- a/src/Editor/GalNet.Editor/Inspector/Views/AssetInspectorControl.axaml.cs
+++ b/src/Editor/GalNet.Editor/Inspector/Views/AssetInspectorControl.axaml.cs
@@ -5,7 +5,11 @@ namespace GalNet.Editor.Inspector.Views;
 
 public partial class AssetInspectorControl : UserControl
 {
-    public AssetInspectorControl() => InitializeComponent();
+    public AssetInspectorControl()
+    {
+        InitializeComponent();
+        SizeChanged += (_, _) => AssetPreview.MaxHeight = Math.Max(40, Bounds.Height * 0.5);
+    }
     private void OnAudioSeekStarted(object? sender, PointerPressedEventArgs e) => (DataContext as AssetInspectorControlViewModel)?.BeginAudioSeek();
     private void OnAudioSeekCompleted(object? sender, PointerReleasedEventArgs e) { if (sender is Slider slider) (DataContext as AssetInspectorControlViewModel)?.EndAudioSeek(slider.Value); }
 }
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/EntryInspectorView.axaml b/src/Editor/GalNet.Editor/Inspector/Views/EntryInspectorView.axaml
index 3ab25b30..b825653c 100644
--- a/src/Editor/GalNet.Editor/Inspector/Views/EntryInspectorView.axaml
+++ b/src/Editor/GalNet.Editor/Inspector/Views/EntryInspectorView.axaml
@@ -4,15 +4,30 @@
  x:Class="GalNet.Editor.Inspector.Views.EntryInspectorView" x:DataType="vm:EntryInspectorViewModel"
  Background="{DynamicResource SemiColorBackground0}" Foreground="{DynamicResource SemiColorText0}">
  <UserControl.Styles><StyleInclude Source="avares://GalNet.Editor/Controls/AuthorFormStyles.axaml"/></UserControl.Styles>
- <ScrollViewer HorizontalScrollBarVisibility="Disabled">
+ <Grid RowDefinitions="*,Auto,Auto">
+ <ScrollViewer Grid.Row="0" HorizontalScrollBarVisibility="Disabled">
   <StackPanel Margin="10" Spacing="8">
    <SelectableTextBlock Text="{Binding TargetDescription}" TextWrapping="Wrap" FontWeight="SemiBold"/>
    <StackPanel Orientation="Horizontal" Spacing="6" IsVisible="{Binding HasMultipleSelection}"><TextBlock Text="{loc:Localize Uiux.Entry.Selected}"/><TextBlock Text="{Binding SelectionCount}"/><TextBlock Text="{loc:Localize Uiux.Entry.ActiveOnly}"/></StackPanel>
    <TextBlock Text="{loc:Localize Uiux.Entry.Condition}"/>
-   <controls:ConditionEditorControl Text="{Binding Entry.Condition}" Suggestions="{Binding Page.ConditionSuggestions}" ValidationVariables="{Binding Page.ValidationVariables}"/>
+   <controls:ConditionEditorControl Name="EntryConditionInput" Text="{Binding Entry.Condition}" Suggestions="{Binding Page.ConditionSuggestions}" ValidationVariables="{Binding Page.ValidationVariables}"/>
    <TextBlock Text="{loc:Localize Entry.UnknownTypePreserved}" IsVisible="{Binding Entry.IsUnknownType}" TextWrapping="Wrap"/>
    <TextBlock Text="{loc:Localize Entry.UnknownParametersPreserved}" IsVisible="{Binding Entry.HasUnknownParameters}" TextWrapping="Wrap"/>
    <forms:DtoEditorHost Name="EntryDetails" Item="{Binding Form.Item}" Registry="{Binding FieldEditors}"/>
+   <TextBlock Text="{loc:Localize Entry.ShaderParameters}" IsVisible="{Binding IsShaderMode}" FontWeight="SemiBold"/>
+   <forms:DtoEditorHost Name="ShaderParameters" Item="{Binding ShaderForm.Item}" Registry="{Binding FieldEditors}" IsVisible="{Binding IsShaderMode}"/>
+   <TextBlock Text="{loc:Localize Entry.ShaderMetadataUnavailable}" IsVisible="{Binding ShaderUnavailable}" TextWrapping="Wrap"/>
   </StackPanel>
  </ScrollViewer>
+ <GridSplitter Grid.Row="1" Height="6" ResizeDirection="Rows" HorizontalAlignment="Stretch" Background="Transparent" IsVisible="{Binding IsShaderMode}"/>
+ <Expander x:Name="ShaderPreviewPanel" Grid.Row="2" Header="{loc:Localize Uiux.Inspector.Preview}" IsExpanded="True" IsVisible="{Binding IsShaderMode}" HorizontalAlignment="Stretch" MaxHeight="300">
+  <ScrollViewer HorizontalScrollBarVisibility="Disabled" Margin="12,4,12,12">
+   <StackPanel Spacing="8">
+    <ProgressBar IsIndeterminate="True" IsVisible="{Binding IsShaderPreviewLoading}" Height="3"/>
+    <Image Name="ShaderEffectPreview" Source="{Binding ShaderPreview}" MaxHeight="220" Stretch="Uniform"/>
+    <TextBlock Text="{Binding ShaderPreviewError}" Foreground="{DynamicResource SystemControlErrorTextForegroundBrush}" TextWrapping="Wrap"/>
+   </StackPanel>
+  </ScrollViewer>
+ </Expander>
+ </Grid>
 </UserControl>
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/EntryInspectorView.axaml.cs b/src/Editor/GalNet.Editor/Inspector/Views/EntryInspectorView.axaml.cs
index 9dc45c2e..ffa32060 100644
--- a/src/Editor/GalNet.Editor/Inspector/Views/EntryInspectorView.axaml.cs
+++ b/src/Editor/GalNet.Editor/Inspector/Views/EntryInspectorView.axaml.cs
@@ -12,20 +12,53 @@ public partial class EntryInspectorView : UserControl
     public EntryInspectorView()
     {
         InitializeComponent();
+        SizeChanged += (_, _) => ShaderPreviewPanel.MaxHeight = Math.Max(40, Bounds.Height * 0.5);
         DataContextChanged += (_, _) => Connect();
         AttachedToVisualTree += (_, _) => Connect();
         DetachedFromVisualTree += (_, _) => Disconnect();
     }
     private void Disconnect() { if (_model is not null) _model.PropertyChanged -= Changed; _model = null; }
-    private void Connect() { Disconnect(); _model = DataContext as EntryInspectorViewModel; if (_model is not null) _model.PropertyChanged += Changed; }
+    private void Connect() { Disconnect(); _model = DataContext as EntryInspectorViewModel; if (_model is not null) { _model.PropertyChanged += Changed; FocusRequestedField(); } }
     private void Changed(object? sender, System.ComponentModel.PropertyChangedEventArgs args)
     {
         if (args.PropertyName != nameof(EntryInspectorViewModel.RequestedField)) return;
+        FocusRequestedField();
+    }
+    private void FocusRequestedField()
+    {
+        var model = _model;
+        var entryId = model?.Entry?.StableId;
+        if (model?.RequestedField is not { } field) return;
+        var path = model.RequestedFieldPath;
         Dispatcher.UIThread.Post(() =>
         {
-            var row = this.GetVisualDescendants().OfType<FieldEditorRow>().FirstOrDefault(item => item.Context?.Field.Id == _model?.RequestedField);
+            if (!ReferenceEquals(model, _model) || model.Entry?.StableId != entryId || model.RequestedField != field || !ReferenceEquals(path, model.RequestedFieldPath)) return;
+            if (field == "condition")
+            {
+                EntryConditionInput.BringIntoView();
+                EntryConditionInput.GetVisualDescendants().OfType<Avalonia.Input.InputElement>().FirstOrDefault(input => input.Focusable)?.Focus();
+                return;
+            }
+            var row = this.GetVisualDescendants().OfType<FieldEditorRow>().FirstOrDefault(item => item.Context?.Field.Id == field);
             if (row is null) return;
-            row.BringIntoView(); row.GetVisualDescendants().OfType<Avalonia.Input.InputElement>().FirstOrDefault(input => input.Focusable && input.IsEffectivelyVisible)?.Focus();
+            foreach (var expander in row.GetVisualDescendants().OfType<Expander>()) expander.IsExpanded = true;
+            row.BringIntoView();
+            var editor = row.Editor;
+            if (editor is not null && path is { Count: > 0 })
+            {
+                var candidates = editor.GetVisualDescendants().OfType<Control>()
+                    .Where(control => control is NumericUpDown or TextBox or ComboBox or CheckBox && control.DataContext is FieldEditorContext).ToArray();
+                var matches = candidates.Where(control => ((FieldEditorContext)control.DataContext!).PropertySegments is { } segments && segments.SequenceEqual(path, StringComparer.Ordinal))
+                    .GroupBy(control => control.DataContext).ToArray();
+                if (matches.Length == 0)
+                    matches = candidates.Where(control => ((FieldEditorContext)control.DataContext!).PropertySegments is null &&
+                        string.Equals(((FieldEditorContext)control.DataContext!).Field.Id, path[^1], StringComparison.OrdinalIgnoreCase))
+                        .GroupBy(control => control.DataContext).ToArray();
+                if (matches.Length == 1) { editor = matches[0].First(); editor.BringIntoView(); }
+            }
+            var input = editor as Avalonia.Input.InputElement;
+            if (input?.Focusable != true) input = editor?.GetVisualDescendants().OfType<Avalonia.Input.InputElement>().FirstOrDefault(input => input.Focusable && input.IsEffectivelyVisible);
+            input?.Focus();
         }, DispatcherPriority.Loaded);
     }
 }
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsEditor.axaml b/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsEditor.axaml
index 404d54d7..00f98a50 100644
--- a/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsEditor.axaml
+++ b/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsEditor.axaml
@@ -5,47 +5,22 @@
   <TextBlock Text="{loc:Localize Variants.Title}" FontWeight="SemiBold"/>
   <StackPanel Spacing="6" IsEnabled="{Binding CanConfigure}">
    <TextBlock Text="{loc:Localize Variants.Folder}"/>
-   <TextBox Name="VariantsFolder" Text="{Binding Folder}"/>
+   <Grid ColumnDefinitions="*,Auto" ColumnSpacing="6">
+    <TextBox Name="VariantsFolder" Text="{Binding Folder}" IsReadOnly="True"/>
+    <Button Grid.Column="1" Content="{loc:Localize Common.Browse}" Command="{Binding BrowseFolderCommand}"/>
+   </Grid>
    <TextBlock Text="{loc:Localize Variants.Default}"/>
-   <TextBox Name="VariantsDefault" Text="{Binding Default}"/>
-   <ComboBox Name="VariantsDefaultChoices" ItemsSource="{Binding VariantKeys}" SelectedItem="{Binding DefaultChoice}" PlaceholderText="{loc:Localize Variants.Default}"/>
+   <ComboBox Name="VariantsDefaultChoices" ItemsSource="{Binding VariantKeys}" SelectedItem="{Binding DefaultChoice}"/>
    <ItemsControl ItemsSource="{Binding Dimensions}">
     <ItemsControl.ItemTemplate><DataTemplate x:DataType="vm:VariantDimensionRow">
-     <Grid ColumnDefinitions="*,*,Auto,Auto" ColumnSpacing="4" Margin="0,2">
-      <TextBox Name="VariantsDimensionKey" Text="{Binding Key}" PlaceholderText="key"/>
-      <TextBox Grid.Column="1" Text="{Binding Label}" PlaceholderText="{loc:Localize Variants.Label}"/>
-      <Button Grid.Column="2" Content="↑" Command="{Binding #Root.DataContext.MoveUpCommand}" CommandParameter="{Binding}"/>
-      <Button Grid.Column="3" Content="×" Command="{Binding #Root.DataContext.RemoveDimensionCommand}" CommandParameter="{Binding}"/>
+     <Grid ColumnDefinitions="Auto,*" ColumnSpacing="8" Margin="0,2">
+      <TextBlock Name="VariantsDimensionHeading" Text="{Binding Heading}" VerticalAlignment="Center"/>
+      <TextBox Name="VariantsDimensionLabel" Grid.Column="1" Text="{Binding Label}" PlaceholderText="{loc:Localize Variants.Label}"/>
      </Grid>
     </DataTemplate></ItemsControl.ItemTemplate>
    </ItemsControl>
-   <WrapPanel>
-    <Button Content="{loc:Localize Variants.AddDimension}" Command="{Binding AddDimensionCommand}"/>
-    <Button Content="{loc:Localize Variants.Infer}" Command="{Binding InferDimensionsCommand}"/>
-   </WrapPanel>
   </StackPanel>
-  <TextBlock Text="{Binding Impact}" TextWrapping="Wrap" Foreground="DarkOrange"/>
-  <WrapPanel>
-   <Button Name="VariantsApply" Content="{loc:Localize Variants.Apply}" Command="{Binding ApplyCommand}"/>
-   <Button Name="VariantsRefresh" Content="{loc:Localize Variants.Refresh}" Command="{Binding RefreshCommand}"/>
-   <Button Content="{loc:Localize Variants.ResetPreview}" Command="{Binding ResetPreviewCommand}"/>
-  </WrapPanel>
   <TextBlock Text="{Binding Diagnostics}" TextWrapping="Wrap" Foreground="OrangeRed"/>
   <TextBlock Text="{Binding Buffer.Error}" TextWrapping="Wrap" Foreground="OrangeRed"/>
-  <ItemsControl ItemsSource="{Binding PreviewRows}">
-   <ItemsControl.ItemTemplate><DataTemplate x:DataType="vm:VariantPreviewRow">
-    <Grid ColumnDefinitions="*,*" Margin="0,2">
-     <TextBlock Text="{Binding Label}" VerticalAlignment="Center"/>
-     <ComboBox Name="VariantsPreviewChoice" Grid.Column="1" ItemsSource="{Binding Options}" SelectedItem="{Binding Value}"/>
-    </Grid>
-   </DataTemplate></ItemsControl.ItemTemplate>
-  </ItemsControl>
-  <TextBlock Text="{loc:Localize Variants.Requested}" FontWeight="SemiBold"/>
-  <TextBlock Text="{Binding Requested}" TextWrapping="Wrap"/>
-  <TextBlock Text="{loc:Localize Variants.Actual}" FontWeight="SemiBold"/>
-  <TextBlock Text="{Binding Actual}" TextWrapping="Wrap"/>
-  <Image Source="{Binding Preview}" MaxHeight="300" Stretch="Uniform"/>
-  <TextBlock Text="{Binding Fallback}" TextWrapping="Wrap"/>
-  <Expander Header="JSON"><TextBox Name="VariantsJson" Text="{Binding Buffer.Text}" AcceptsReturn="True" TextWrapping="Wrap" MinHeight="140" IsReadOnly="{Binding Buffer.IsReadOnly}"/></Expander>
  </StackPanel>
 </UserControl>
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsPreview.axaml b/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsPreview.axaml
new file mode 100644
index 00000000..323fee0e
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsPreview.axaml
@@ -0,0 +1,21 @@
+<UserControl xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+ xmlns:vm="using:GalNet.Editor.Inspector.ViewModels" xmlns:loc="using:GalNet.Editor.MarkupExtensions"
+ x:Class="GalNet.Editor.Inspector.Views.ImageVariantsPreview" x:DataType="vm:ImageVariantsInspector">
+ <StackPanel Spacing="6">
+  <Button Content="{loc:Localize Variants.ResetPreview}" Command="{Binding ResetPreviewCommand}" HorizontalAlignment="Left"/>
+  <ItemsControl ItemsSource="{Binding PreviewRows}">
+   <ItemsControl.ItemTemplate><DataTemplate x:DataType="vm:VariantPreviewRow">
+    <Grid ColumnDefinitions="*,*" Margin="0,2">
+     <TextBlock Text="{Binding Label}" VerticalAlignment="Center"/>
+     <ComboBox Name="VariantsPreviewChoice" Grid.Column="1" ItemsSource="{Binding Options}" SelectedItem="{Binding Value}"/>
+    </Grid>
+   </DataTemplate></ItemsControl.ItemTemplate>
+  </ItemsControl>
+  <TextBlock Text="{loc:Localize Variants.Requested}" FontWeight="SemiBold"/>
+  <TextBlock Text="{Binding Requested}" TextWrapping="Wrap"/>
+  <TextBlock Text="{loc:Localize Variants.Actual}" FontWeight="SemiBold"/>
+  <TextBlock Text="{Binding Actual}" TextWrapping="Wrap"/>
+  <Image Source="{Binding Preview}" MaxHeight="300" Stretch="Uniform"/>
+  <Expander Header="{loc:Localize Variants.Details}"><TextBlock Text="{Binding Fallback}" TextWrapping="Wrap"/></Expander>
+ </StackPanel>
+</UserControl>
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsPreview.axaml.cs b/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsPreview.axaml.cs
new file mode 100644
index 00000000..c6645f2a
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Inspector/Views/ImageVariantsPreview.axaml.cs
@@ -0,0 +1,8 @@
+using Avalonia.Controls;
+
+namespace GalNet.Editor.Inspector.Views;
+
+public partial class ImageVariantsPreview : UserControl
+{
+    public ImageVariantsPreview() => InitializeComponent();
+}
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/NodeInspectorControl.axaml b/src/Editor/GalNet.Editor/Inspector/Views/NodeInspectorControl.axaml
index 1af51e5b..d661f84c 100644
--- a/src/Editor/GalNet.Editor/Inspector/Views/NodeInspectorControl.axaml
+++ b/src/Editor/GalNet.Editor/Inspector/Views/NodeInspectorControl.axaml
@@ -8,7 +8,7 @@
       <TextBlock Text="{loc:Localize Inspector.Node.Name}" /><TextBox Text="{Binding InspectedNode.Name}" />
       <TextBlock Text="{loc:Localize Inspector.Node.Type}" /><Border Background="{DynamicResource SemiColorFill0}" BorderBrush="{DynamicResource SemiColorBorder}" BorderThickness="1" CornerRadius="4" Padding="8,5"><TextBlock Text="{loc:Localize Path=InspectedNode.KindLabelKey}" Foreground="{DynamicResource SemiColorText1}" TextTrimming="CharacterEllipsis" /></Border>
       <TextBlock Text="{loc:Localize Inspector.Node.Id}" /><Border Background="{DynamicResource SemiColorFill0}" BorderBrush="{DynamicResource SemiColorBorder}" BorderThickness="1" CornerRadius="4" Padding="8,5"><TextBlock Text="{Binding InspectedNode.Id}" FontFamily="Consolas" FontSize="12" Foreground="{DynamicResource SemiColorText2}" TextTrimming="CharacterEllipsis" /></Border>
-      <StackPanel Spacing="6" IsVisible="{Binding IsLinearGroupSelected}"><TextBlock Text="{loc:Localize Inspector.Node.LinearGroup}" FontWeight="SemiBold" /><TextBlock Text="{Binding EntryCountText}" Foreground="{DynamicResource SemiColorText2}" /><Button Content="{loc:Localize Inspector.Node.OpenGroupEditor}" HorizontalAlignment="Left" Command="{Binding OpenGroupEditorCommand}" /></StackPanel>
+      <StackPanel Spacing="6" IsVisible="{Binding IsLinearGroupSelected}"><TextBlock Text="{loc:Localize Inspector.Node.LinearGroup}" FontWeight="SemiBold" /><TextBlock Text="{Binding EntryCountText}" Foreground="{DynamicResource SemiColorText2}" /><TextBlock Text="{loc:Localize Packaging.StoryPackage}" /><AutoCompleteBox Name="StoryPackageInput" ItemsSource="{Binding StoryPackageNames}" Text="{Binding InspectedNode.StoryPackage, Mode=TwoWay, UpdateSourceTrigger=LostFocus}" Watermark="{loc:Localize Packaging.BaseGroup}" /><Button Content="{loc:Localize Inspector.Node.OpenGroupEditor}" HorizontalAlignment="Left" Command="{Binding OpenGroupEditorCommand}" /></StackPanel>
       <StackPanel Spacing="6" IsVisible="{Binding IsChoiceBranchSelected}"><TextBlock Text="{loc:Localize Inspector.Node.Options}" FontWeight="SemiBold" /><controls:BranchOptionListEditorControl ItemsSource="{Binding InspectedNode.Options}" AddCommand="{Binding AddChoiceOptionCommand}" RemoveCommand="{Binding RemoveChoiceOptionCommand}" MoveCommand="{Binding ReorderChoiceOptionCommand}" ConditionSuggestions="{Binding ConditionSuggestions}" ValidationVariables="{Binding ValidationVariables}" /></StackPanel>
       <StackPanel Spacing="6" IsVisible="{Binding IsConditionBranchSelected}"><TextBlock Text="{loc:Localize Inspector.Node.Conditions}" FontWeight="SemiBold" /><controls:BranchConditionListEditorControl ItemsSource="{Binding InspectedNode.Conditions}" AddCommand="{Binding AddConditionCommand}" RemoveCommand="{Binding RemoveConditionCommand}" MoveCommand="{Binding ReorderConditionCommand}" ConditionSuggestions="{Binding ConditionSuggestions}" ValidationVariables="{Binding ValidationVariables}" /></StackPanel>
     </StackPanel>
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/PreviewVariablesInspectorControl.axaml b/src/Editor/GalNet.Editor/Inspector/Views/PreviewVariablesInspectorControl.axaml
deleted file mode 100644
index cd7a176c..00000000
--- a/src/Editor/GalNet.Editor/Inspector/Views/PreviewVariablesInspectorControl.axaml
+++ /dev/null
@@ -1,8 +0,0 @@
-<UserControl xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:controls="using:GalNet.Editor.Controls" xmlns:vm="using:GalNet.Editor.Inspector.ViewModels" xmlns:loc="using:GalNet.Editor.MarkupExtensions"
-             x:Class="GalNet.Editor.Inspector.Views.PreviewVariablesInspectorControl" x:DataType="vm:PreviewVariablesInspectorControlViewModel">
-  <ScrollViewer><StackPanel Margin="12" Spacing="10">
-    <Expander Header="{loc:Localize Inspector.Preview.PlayerVariables}" IsExpanded="True"><controls:VariableListEditorControl DataContext="{Binding Preview.PlayerVariables}" /></Expander>
-    <Expander Header="{loc:Localize Inspector.Preview.SaveVariables}" IsExpanded="True"><controls:VariableListEditorControl DataContext="{Binding Preview.SaveVariables}" /></Expander>
-  </StackPanel></ScrollViewer>
-</UserControl>
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/PreviewVariablesInspectorControl.axaml.cs b/src/Editor/GalNet.Editor/Inspector/Views/PreviewVariablesInspectorControl.axaml.cs
deleted file mode 100644
index d88a761e..00000000
--- a/src/Editor/GalNet.Editor/Inspector/Views/PreviewVariablesInspectorControl.axaml.cs
+++ /dev/null
@@ -1,4 +0,0 @@
-using Avalonia.Controls;
-namespace GalNet.Editor.Inspector.Views;
-
-public partial class PreviewVariablesInspectorControl : UserControl { public PreviewVariablesInspectorControl() => InitializeComponent(); }
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/TimelineEventInspectorView.axaml b/src/Editor/GalNet.Editor/Inspector/Views/TimelineEventInspectorView.axaml
new file mode 100644
index 00000000..86bcb34c
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Inspector/Views/TimelineEventInspectorView.axaml
@@ -0,0 +1,13 @@
+<UserControl xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+ xmlns:vm="using:GalNet.Editor.Inspector.ViewModels" xmlns:forms="using:GalNet.Game.Controls.Forms"
+ xmlns:loc="using:GalNet.Editor.MarkupExtensions" x:Class="GalNet.Editor.Inspector.Views.TimelineEventInspectorView" x:DataType="vm:TimelineEventInspectorViewModel">
+ <UserControl.Styles><StyleInclude Source="avares://GalNet.Editor/Controls/AuthorFormStyles.axaml"/></UserControl.Styles>
+ <ScrollViewer HorizontalScrollBarVisibility="Disabled"><StackPanel Margin="10" Spacing="8">
+  <TextBlock Text="{Binding Label}" TextWrapping="Wrap" FontWeight="SemiBold"/>
+  <forms:DtoEditorHost Name="TimelineEventForm" Item="{Binding Draft.Item}" Registry="{Binding FieldEditors}"/>
+  <StackPanel Orientation="Horizontal" Spacing="8">
+   <Button Name="ApplyTimelineEvent" Content="{loc:Localize Timeline.Event.Apply}" Command="{Binding ApplyCommand}"/>
+   <Button Name="CancelTimelineEvent" Content="{loc:Localize Timeline.Event.Cancel}" Command="{Binding CancelCommand}"/>
+  </StackPanel>
+ </StackPanel></ScrollViewer>
+</UserControl>
diff --git a/src/Editor/GalNet.Editor/Inspector/Views/TimelineEventInspectorView.axaml.cs b/src/Editor/GalNet.Editor/Inspector/Views/TimelineEventInspectorView.axaml.cs
new file mode 100644
index 00000000..a6cd3a37
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Inspector/Views/TimelineEventInspectorView.axaml.cs
@@ -0,0 +1,8 @@
+using Avalonia.Controls;
+
+namespace GalNet.Editor.Inspector.Views;
+
+public partial class TimelineEventInspectorView : UserControl
+{
+    public TimelineEventInspectorView() => InitializeComponent();
+}
diff --git a/src/Editor/GalNet.Editor/Localization/en-US.json b/src/Editor/GalNet.Editor/Localization/en-US.json
index b3d9f11a..3b0308dc 100644
--- a/src/Editor/GalNet.Editor/Localization/en-US.json
+++ b/src/Editor/GalNet.Editor/Localization/en-US.json
@@ -1,4 +1,46 @@
 {
+  "Packaging.Panel": "Resource patches",
+  "Packaging.HistoryGroup": "Change Group story package",
+  "Packaging.HistoryOverrides": "Change resource patches",
+  "Error.graph.groupRequired": "Only Groups can declare a story package.",
+  "Error.graph.packageName": "Story package names must be at most 128 characters without control characters, and cannot differ only by case.",
+  "Packaging.StoryPackage": "Story package",
+  "Packaging.BaseGroup": "Empty: base game",
+  "Packaging.Create": "New patch column",
+  "Packaging.NewPatch": "Resource patch",
+  "Packaging.Dependencies": "Show indirect resources",
+  "Packaging.AddOriginal": "Add original resource",
+  "Packaging.Original": "Original resource",
+  "Packaging.PriorityLabel": "Priority",
+  "Packaging.Locate": "Locate original resource",
+  "Packaging.Search": "Search resources…",
+  "Packaging.Name": "Patch name",
+  "Packaging.Priority": "Priority (larger wins)",
+  "Packaging.Export": "Export PAK",
+  "Packaging.Delete": "Delete",
+  "Packaging.Cancel": "Cancel export",
+  "Packaging.Canceled": "Export canceled.",
+  "Packaging.Exported": "Resource patch exported:",
+  "Packaging.Missing": "Missing",
+  "Entry.Parameter.playbackMode": "Playback mode",
+  "Entry.Option.Timed": "Timed",
+  "Entry.Option.UntilStopped": "Until stopped",
+  "Entry.Type.transition.reveal": "Shader reveal",
+  "Entry.Type.transition.blur": "Blur crossfade",
+  "Entry.Type.preset.motion": "Character motion",
+  "Entry.Type.preset.shake": "Screen shake",
+  "Entry.Type.preset.speedLines": "Dynamic speed lines",
+  "Entry.Type.preset.impact": "Impact",
+  "Entry.Category.Preset": "Performance presets",
+  "External.Reload": "Reload from disk",
+  "External.Retry": "Check again",
+  "External.Publishing": "Waiting for an external file transaction to finish. If the external tool stopped unexpectedly, inspect its transaction recovery material before continuing.",
+  "External.Reloaded": "External changes loaded; previous undo history cleared.",
+  "External.LocalChanges": "Files changed externally. Your unsaved content and input are retained. Reload from disk to discard them, or reconcile the external files and check again.",
+  "External.Invalid": "External files could not be loaded. Current content is retained; loading will retry when the files change.",
+  "External.ContractsChanged": "Project contracts changed. Reopen the project to load the new contract.",
+  "External.DiscardQuestion": "Reload the project content from disk and discard unsaved author changes and pending input? A recovery snapshot of applied content will be retained. Undo history will be cleared; open panels and layout are kept.",
+  "External.DiscardReload": "Discard changes and reload",
   "Error.text.changed": "The text reference changed. Reload this draft.",
   "Error.text.conflict": "Conflicting edits target the same shared text.",
   "History.GameText": "Game text: {0}",
@@ -18,13 +60,16 @@
   "Characters.Revert": "Revert draft",
   "Characters.Delete": "Delete unused character",
   "Characters.Incomplete": "Reference analysis is incomplete. Deleting characters and changing keys are unavailable.",
+  "Characters.IncompleteReason": "• {0} — {1}: {2}",
+  "Characters.IncompleteMore": "{0} more issue(s) are hidden; the log records the first {1}.",
+  "Characters.IncompleteReasonUnavailable": "No diagnostic details are available. Check the log and Problems panel.",
   "Characters.SpeakerHint": "Enter a name or key, or select a character; an unmatched value creates one on focus loss",
   "Error.character.name": "Enter the development-language character name.",
   "Error.character.key": "The character key cannot be empty.",
   "Error.character.duplicate": "This character key already exists.",
   "Error.character.changed": "The character or name changed. Revert the draft and retry.",
   "Error.character.inUse": "This character is still used and cannot be deleted.",
-  "Error.character.incomplete": "Reference analysis is incomplete; this operation cannot be performed safely.",
+  "Error.character.incomplete": "Reference analysis is incomplete; this operation cannot be performed safely. Cause: {0}",
   "Error.character.ambiguous": "Several characters share this name. Select a specific key from the suggestions.",
   "Error.character.obsolete": "The project or entry changed. This input is no longer current.",
   "Entry.AppendBatch": "Append entries",
@@ -65,7 +110,6 @@
   "Editor.Menu.ProjectExplorer": "Project Explorer",
   "Editor.Menu.Inspector": "Inspector",
   "Editor.Menu.Log": "Log Panel",
-  "Editor.Menu.GamePreview": "Game Preview",
   "Editor.Menu.SaveLayout": "Save Window Layout",
   "Editor.Menu.LoadLayout": "Load Window Layout",
   "Editor.Menu.DeleteLayout": "Delete Window Layout",
@@ -80,10 +124,16 @@
   "Settings.Saved": "Saved",
   "Settings.SaveFailed": "Save failed",
   "Settings.ThemeChanged": "Switched to {0}",
+  "Settings.Project.DefaultWidth": "Default width",
+  "Settings.Project.DefaultHeight": "Default height",
+  "Settings.Project.DefaultVisualPrograms": "Default visual programs",
+  "Settings.Project.PlaybackOrder": "Playback order",
+  "Settings.Project.Repeat": "Repeat mode",
+  "Settings.Project.OverflowPolicy": "Voice overflow policy",
+  "Settings.Project.QueueOverflowPolicy": "Queue overflow policy",
   "Settings.Project.Title": "Project Settings",
   "Settings.Project.DefaultResolution": "Default Resolution",
   "Settings.Project.SaveSlotCount": "Save Slot Count",
-  "Settings.Project.SfxChannelCount": "SFX Channel Count",
   "Settings.Project.TargetLanguage": "Target Language",
   "Settings.Project.Unsaved": "(unsaved changes)",
   "Theme.Default": "System Default",
@@ -94,7 +144,6 @@
   "Language.zh-CN": "简体中文",
   "Language.en-US": "English",
   "Dock.Panel.NodeGraph": "Node Graph",
-  "Dock.Panel.GamePreview": "Game Preview",
   "Dock.Panel.Assets": "Project Files",
   "Dock.Panel.Log": "Log",
   "Dock.Panel.GroupEditor": "Group: {0}",
@@ -113,9 +162,6 @@
   "Inspector.Node.OpenGroupEditor": "Open Group Editor",
   "Inspector.Node.Options": "Options",
   "Inspector.Node.Conditions": "Conditions",
-  "Inspector.Preview.PlayerVariables": "Player Variables",
-  "Inspector.Preview.SaveVariables": "Save Variables",
-  "Inspector.Preview.SystemVariables": "Generated system variables (read-only)",
   "Inspector.Asset.Title": "Asset",
   "Inspector.Asset.Id": "Id",
   "Inspector.Asset.Path": "Path",
@@ -303,9 +349,21 @@
   "Export.Package": "Package",
   "Export.Action": "Export",
   "Export.SelectDirectory": "Select export directory",
-  "Export.Success": "Game package exported successfully.",
+  "Export.Success": "Package created successfully.",
   "Export.Failed": "Export failed.",
   "Export.Unavailable": "A project and output directory are required.",
+  "Export.Mode": "Package type",
+  "Export.Mode.Galpak": "Galpak archive",
+  "Export.Mode.Editor": "Editor release",
+  "Export.Mode.Sample": "Sample runtime",
+  "Export.Mode.IntegratedSample": "Sample + expanded game content",
+  "Export.ReleaseOutput": "Release output root",
+  "Export.Version": "Release version",
+  "Export.IntegrationSource": "Game content (.galpak or current project)",
+  "Export.ProjectDefault": "Empty uses the current project",
+  "Export.SelectGalpakButton": "Choose .galpak...",
+  "Export.SelectGalpak": "Select a .galpak file",
+  "Export.ReleaseUnavailable": "Open a project in a GalNet repository checkout to build release packages.",
   "Export.Progress.Title": "Exporting game",
   "Export.Progress.Working": "Building the game package...",
   "Export.Progress.Cancel": "Cancel",
@@ -351,6 +409,8 @@
   "Entry.Parameter.value": "Value",
   "Entry.Parameter.type": "Effect type",
   "Entry.Parameter.parameters": "Parameters (JSON)",
+  "Entry.ShaderParameters": "Shader parameters",
+  "Entry.ShaderMetadataUnavailable": "Shader metadata is loading or unavailable.",
   "Entry.Parameter.target": "Target",
   "Entry.Parameter.valueType": "Value type",
   "Entry.Parameter.expression": "Expression",
@@ -448,8 +508,14 @@
   "Entry.Option.ReplaceAll": "Replace all",
   "NewProject.Name": "Name",
   "NewProject.Parent": "Parent folder",
+  "NewProject.Application": "Game App (optional)",
+  "NewProject.ApplicationHint": "Select an EXE to find its contracts and use it for project debugging",
+  "NewProject.BrowseApplication": "Select game App",
+  "Error.project.applicationInvalid": "Select an existing game App EXE file.",
+  "Error.project.applicationContractMissing": "No project contract was found beside the App or in lib. Select a contract directory manually.",
+  "Error.project.applicationContractAmbiguous": "Multiple project contracts were found. Select a contract directory manually.",
   "NewProject.Contracts": "Custom contract directory (optional)",
-  "NewProject.ContractsHint": "Leave empty to use built-in contracts",
+  "NewProject.ContractsHint": "Without an App, leave empty to use built-in contracts",
   "NewProject.Resolution": "Design resolution",
   "NewProject.Create": "Create project",
   "NewProject.BrowseContracts": "Select built project contract directory",
@@ -602,7 +668,7 @@
   "Files.OpenExternal": "Open externally",
   "Files.Missing": "File deleted. Undo deletion to continue editing.",
   "Files.ReadOnly": "Read-only: system file, binary, large file or unsupported encoding. You can open it externally.",
-  "Files.ExternalChange": "File changed externally. Your edits are retained; saving will not overwrite external content. Close the project, reconcile both versions, and reopen.",
+  "Files.ExternalChange": "File changed externally. Your edits are retained. Use the editor's external-change controls to reload from disk, or reconcile the versions and check again.",
   "History.TextFile": "Edit file: {0}",
   "Error.files.busy": "Saving in progress. Open this file again shortly: {0}",
   "Error.files.galleryId": "Invalid Gallery item ID; no changes were made: {0}",
@@ -727,6 +793,9 @@
   "Timeline.Create": "Create timeline",
   "Timeline.Editing": "Editing timeline",
   "Timeline.Invalid": "Invalid timeline. Repair its JSON in the entry parameters.",
+  "Timeline.ResizeSections": "Drag to resize object tracks and events",
+  "Timeline.CurrentFrame": "{0} frames",
+  "Timeline.ObjectTracks": "Object tracks",
   "Timeline.Frame": "Frame",
   "Timeline.Duration": "End frame",
   "Timeline.Empty": "No editable objects or existing tracks here. Create a scene object before this entry.",
@@ -947,12 +1016,9 @@
   "Variants.Title": "Image variants",
   "Variants.Folder": "Image folder (relative to descriptor)",
   "Variants.Default": "Default image",
+  "Variants.Details": "Matching details",
+  "Variants.Dimension": "Dimension {0}",
   "Variants.Label": "Display name",
-  "Variants.AddDimension": "Add dimension",
-  "Variants.Infer": "Infer dimensions",
-  "Variants.IdentityWarning": "Changed keys or order may invalidate story references. Check existing entries; references are not migrated automatically.",
-  "Variants.Apply": "Apply configuration",
-  "Variants.Refresh": "Rescan",
   "Variants.ResetPreview": "Reset preview selection",
   "Variants.Requested": "Requested selection",
   "Variants.Actual": "Actual image",
@@ -1010,5 +1076,147 @@
   "Uiux.Severity.info": "Info",
   "Uiux.Severity.error": "Error",
   "Uiux.Entry.Selected": "Selected",
-  "Uiux.Entry.ActiveOnly": "items; details edit the active entry only"
+  "Uiux.Entry.ActiveOnly": "items; details edit the active entry only",
+  "Uiux.Panel.Search": "Search name or description…",
+  "Uiux.Panel.NoResults": "No items or no matching results",
+  "Uiux.Panel.SelectItem": "Select an item to edit, or use + to add one.",
+  "Uiux.Panel.MissingSelection": "The selected variable was removed. Undo its removal to recover, or discard the retained draft.",
+  "Uiux.Panel.Unapplied": "Unapplied",
+  "Uiux.Panel.DeleteBlocked": "The character is referenced, or reference analysis is incomplete",
+  "Uiux.I18n.Languages": "Manage languages",
+  "Uiux.I18n.Search": "Search source, translation or context…",
+  "Uiux.I18n.All": "All states",
+  "Uiux.I18n.Missing": "Missing",
+  "Uiux.I18n.Review": "Needs review",
+  "Uiux.I18n.Drafts": "With drafts",
+  "Uiux.I18n.Exchange": "Translation exchange",
+  "Uiux.Inspector.Preview": "Preview",
+  "Uiux.I18n.VisibleColumns": "Show checked language columns",
+  "Uiux.I18n.SearchLanguage": "Search language name or code…",
+  "Uiux.I18n.RemoveLanguage": "Remove from project languages",
+  "Uiux.I18n.RemoveHint": "Translations are retained when a language is removed.",
+  "Uiux.I18n.RemoveSource": "Switch the development language before removing it.",
+  "Uiux.I18n.LanguageActions": "Language actions",
+  "Uiux.I18n.ReloadCell": "Discard unsuccessful input and reload",
+  "Uiux.I18n.SourceChanged": "Source text changed",
+  "Form.Flipbook.Columns": "Columns",
+  "Form.Flipbook.Rows": "Rows",
+  "Form.Flipbook.FrameCount": "Frame count",
+  "Form.Flipbook.Index": "Frame index (from 0)",
+  "Form.FlipbookInvalid": "Rows, columns and frame count must be positive integers; frame count cannot exceed the grid capacity.",
+  "Entry.Parameter.loopCount": "Play count (0 = infinite)",
+  "Entry.Parameter.completion": "On completion",
+  "Entry.Option.discard": "Discard item",
+  "Entry.Option.requeueTail": "Requeue at tail",
+  "Scene.Impact.Title": "Review scene effects",
+  "Scene.Impact.Message": "This operation changes scene availability or references. Existing references will be kept; missing targets remain warnings and can be saved.",
+  "Scene.Impact.Continue": "Continue",
+  "Scene.Impact.Groups": "Availability changes in {0} Group(s).",
+  "Scene.Impact.Incomplete": "Analysis is incomplete. Other references or effects may exist.",
+  "Scene.Diagnostic.scene.reference.resolved": "Target is available at this position.",
+  "Scene.Diagnostic.scene.reference.missing": "No matching target is available at this position.",
+  "Scene.Diagnostic.scene.reference.possible": "Target may only exist on some paths.",
+  "Scene.Diagnostic.scene.reference.uncertain": "Target availability could not be fully determined.",
+  "Scene.Diagnostic.scene.reference.unreachable": "This Group is unreachable from the current root.",
+  "Scene.Diagnostic.scene.coverage.unknown": "This Entry has no built-in scene relationship declaration.",
+  "Scene.Diagnostic.scene.coverage.structure": "Scene relationship structure could not be fully analyzed.",
+  "Scene.Diagnostic.scene.analysis.limit": "Scene analysis reached its safety limit.",
+  "Error.entry.impactChanged": "Author content changed during review. Review the operation again.",
+  "Entry.MovePending": "Entries are marked for moving. Paste to move them.",
+  "Entry.MoveFallback": "The move was unavailable or expired; pasted a copy with new identities.",
+  "Entry.MoveCancel": "Cancel move",
+  "Scene.Impact.Inputs": "{0} unsubmitted input(s) will be archived in Problems. They will not block saving.",
+  "Uiux.Draft.Archived": "Archived input: its target is absent or no longer matches. Copy its text before discarding.",
+  "Uiux.Draft.Recoverable": "Archived input can be restored through a new field binding. It does not block saving.",
+  "Uiux.Draft.RestoreRequested": "Restore requested. Open or expand the corresponding field to recover its input.",
+  "Uiux.Draft.Restore": "Restore input",
+  "Error.entry.archiveFull": "Input recovery is full. Copy or discard archived inputs in Problems before removing more entries.",
+  "Error.entry.archiveUnavailable": "Input recovery is unavailable. Preserve and repair .galnet/editor/input-archive.json first.",
+  "Error.entry.archiveChanged": "The archived input no longer matches its author target. Copy its text before discarding it.",
+  "Settings.Project.AudioBuses": "Audio buses",
+  "Settings.Project.AddGroup": "Add group",
+  "Settings.Project.RemoveGroup": "Remove group",
+  "Settings.Project.GroupId": "Group ID (optional)",
+  "Settings.Project.PreserveAudio": "Preserve after catch-up",
+  "Entry.Parameter.targetId": "Target ID",
+  "Entry.Parameter.scope": "Scope",
+  "Entry.Option.track": "Track",
+  "Entry.Option.bus": "Bus",
+  "Settings.Project.BusId": "Bus ID (optional)",
+  "Audio.Effect": "Audio effect",
+  "Audio.EffectType": "Effect type",
+  "Audio.Target": "Target",
+  "Audio.Parameters": "Effect parameters",
+  "Audio.AllEffects": "All effects",
+  "Audio.AnalysisIncomplete": "Analysis is incomplete; some effects may be missing.",
+  "Audio.SelectEffect": "Select an effect with a known type. Unknown data is preserved.",
+  "Audio.UnchangedParameters": "Unspecified parameters remain unchanged.",
+  "Entry.Type.audio.seffect.update": "Update audio effect",
+  "Audio.Type.seffect.gain": "Gain",
+  "Audio.Type.seffect.lowPass": "Low pass",
+  "Audio.Type.seffect.highPass": "High pass",
+  "Audio.Type.seffect.reverb": "Reverb",
+  "Audio.Parameter.gain": "Gain",
+  "Audio.Parameter.cutoffHz": "Cutoff (Hz)",
+  "Audio.Parameter.q": "Q",
+  "Audio.Parameter.roomSize": "Room size",
+  "Audio.Parameter.decaySeconds": "Decay (seconds)",
+  "Audio.Parameter.damping": "Damping",
+  "Audio.Parameter.mix": "Dry/wet mix",
+  "Problem.Value.Required": "Enter a value for “{0}”, then press Enter or leave the field.",
+  "Problem.Value.Type": "“{0}” needs {1}. Check the input format.",
+  "Problem.Value.Range": "“{0}” is out of range. Enter a value between {2} and {3}.",
+  "Problem.Value.Finite": "“{0}” needs a finite number. Reduce the value or check the exponent.",
+  "Problem.Value.Null": "“{0}” cannot be null. Enter a value or reset the field.",
+  "Problem.Value.Option": "“{0}” is not an available option. Choose another value.",
+  "Problem.Value.Length": "Check the length or number of items in “{0}”.",
+  "Problem.Value.Spin": "“{0}” cannot use this step. Enter an exact number instead.",
+  "Problem.Value.Conflict": "The source of “{0}” changed. Keep any text you need, then cancel the old input and edit again.",
+  "Problem.Value.Invalid": "“{0}” cannot be used yet. Check its contents; technical details are available.",
+  "Problem.Kind.Number": "a number (for example, 0.3)",
+  "Problem.Kind.Integer": "an integer",
+  "Problem.Kind.Text": "text",
+  "Problem.Kind.Boolean": "a Boolean value",
+  "Problem.Kind.Json": "a complete value of the expected type",
+  "Problem.Source.Entry": "{0} / Entry {1} · {2}",
+  "Problem.Entry.Compile": "This entry cannot compile. Check its parameters and technical details.",
+  "Problem.Entry.UnknownType": "This entry type is not in the project contract. Choose a type or check the contract.",
+  "Problem.Condition": "The condition cannot be parsed. Check brackets, operators and variable names.",
+  "Problem.Generic": "This content failed validation. Check its location and technical details.",
+  "Problem.Localization.Opaque": "Text or character references inside this field could not be checked because its field schema is unavailable. This does not mean the value is invalid.",
+  "Problem.Details": "Technical details",
+  "Problem.Navigate": "Go to this issue",
+  "Problem.Unavailable": "The original location is unavailable. Check again.",
+  "Problem.Checking": "Checking automatically…",
+  "Problem.CheckFailed": "The check could not finish. Try again; technical details are available.",
+  "Problem.NumericFallback": "Exact text input is used because this type or range cannot safely use a slider or step control.",
+  "Problem.Value.Minimum": "“{0}” must be at least {2}. Adjust the value.",
+  "Problem.Value.Maximum": "“{0}” must be at most {3}. Adjust the value.",
+  "Form.MapKey": "Key",
+  "Form.MapKeyDuplicate": "A key with this name already exists. Choose a different name.",
+  "Entry.Type.custom.invoke": "Custom action",
+  "Entry.Type.audio.mix.set": "Set audio mix level",
+  "Entry.Category.custom": "Custom",
+  "Settings.ExpandNewEntries": "Expand parameters for new entries",
+  "Entry.Parameter.action": "Action",
+  "Entry.Parameter.argument": "Argument",
+  "Entry.Parameter.muted": "Muted",
+  "Entry.Category.variants": "Image variants",
+  "Entry.Parameter.all": "All",
+  "Entry.Parameter.amplitude": "Amplitude",
+  "Entry.Parameter.anchorX": "Anchor X",
+  "Entry.Parameter.anchorY": "Anchor Y",
+  "Entry.Parameter.angle": "Angle",
+  "Entry.Parameter.cycles": "Cycles",
+  "Entry.Parameter.flashOpacity": "Flash opacity",
+  "Entry.Parameter.flicker": "Flicker",
+  "Entry.Parameter.maskAsset": "Mask asset",
+  "Entry.Parameter.radius": "Radius",
+  "Entry.Parameter.rotationDegrees": "Rotation",
+  "Entry.Parameter.scale": "Scale",
+  "Entry.Parameter.softness": "Softness",
+  "Entry.Parameter.speed": "Speed",
+  "Entry.Parameter.motion": "Motion",
+  "Entry.Parameter.center": "Center",
+  "Entry.Parameter.blurProgram": "Blur program"
 }
diff --git a/src/Editor/GalNet.Editor/Localization/ja-JP.json b/src/Editor/GalNet.Editor/Localization/ja-JP.json
index 806e206c..3abc2ef8 100644
--- a/src/Editor/GalNet.Editor/Localization/ja-JP.json
+++ b/src/Editor/GalNet.Editor/Localization/ja-JP.json
@@ -1,4 +1,46 @@
 {
+  "Packaging.Panel": "リソースパッチ",
+  "Packaging.HistoryGroup": "Group のストーリーパックを変更",
+  "Packaging.HistoryOverrides": "リソースパッチを変更",
+  "Error.graph.groupRequired": "ストーリーパックを設定できるのは Group のみです。",
+  "Error.graph.packageName": "パック名は制御文字を含まない128文字以内にしてください。大文字と小文字だけが異なる名前は使用できません。",
+  "Packaging.StoryPackage": "ストーリーパック名",
+  "Packaging.BaseGroup": "空欄：ゲーム本体",
+  "Packaging.Create": "パッチ列を追加",
+  "Packaging.NewPatch": "リソースパッチ",
+  "Packaging.Dependencies": "間接参照リソースを表示",
+  "Packaging.AddOriginal": "元リソースを追加",
+  "Packaging.Original": "元リソース",
+  "Packaging.PriorityLabel": "優先度",
+  "Packaging.Locate": "元リソースを表示",
+  "Packaging.Search": "リソースを検索…",
+  "Packaging.Name": "パッチ名",
+  "Packaging.Priority": "優先度（大きい値を優先）",
+  "Packaging.Export": "PAK をエクスポート",
+  "Packaging.Delete": "削除",
+  "Packaging.Cancel": "出力を中止",
+  "Packaging.Canceled": "出力を中止しました。",
+  "Packaging.Exported": "リソースパッチを出力しました：",
+  "Packaging.Missing": "見つかりません",
+  "Entry.Parameter.playbackMode": "再生方式",
+  "Entry.Option.Timed": "指定時間",
+  "Entry.Option.UntilStopped": "停止するまで継続",
+  "Entry.Type.transition.reveal": "シェーダー切り替え",
+  "Entry.Type.transition.blur": "ぼかしクロスフェード",
+  "Entry.Type.preset.motion": "キャラクター動作",
+  "Entry.Type.preset.shake": "画面振動",
+  "Entry.Type.preset.speedLines": "動的集中線",
+  "Entry.Type.preset.impact": "衝撃演出",
+  "Entry.Category.Preset": "演出プリセット",
+  "External.Reload": "ディスクから再読み込み",
+  "External.Retry": "再確認",
+  "External.Publishing": "外部ファイルの更新完了を待っています。ツールが異常終了した場合は、トランザクションの復元データを確認してください。",
+  "External.Reloaded": "外部の変更を読み込み、以前の取り消し履歴をクリアしました。",
+  "External.LocalChanges": "ファイルが外部で変更されました。未保存の内容と入力は保持されています。再読み込みで破棄するか、外部ファイルを確認して再試行してください。",
+  "External.Invalid": "外部ファイルを読み込めません。現在の内容を保持し、ファイルの変更後に再試行します。",
+  "External.ContractsChanged": "プロジェクトの契約が変更されました。プロジェクトを開き直してください。",
+  "External.DiscardQuestion": "未保存の編集と入力を破棄し、ディスクから再読み込みしますか？適用済み内容の復元スナップショットを保存し、取り消し履歴をクリアします。パネルとレイアウトは保持されます。",
+  "External.DiscardReload": "変更を破棄して再読み込み",
   "Error.text.changed": "テキスト参照が変更されました。下書きを再読み込みしてください。",
   "Error.text.conflict": "同じ共有テキストに競合する変更があります。",
   "History.GameText": "ゲームテキスト：{0}",
@@ -18,13 +60,16 @@
   "Characters.Revert": "下書きを戻す",
   "Characters.Delete": "未使用の登場人物を削除",
   "Characters.Incomplete": "参照解析が不完全なため、削除とキー変更は利用できません。",
+  "Characters.IncompleteReason": "• {0} — {1}：{2}",
+  "Characters.IncompleteMore": "ほかに {0} 件あります。ログには先頭 {1} 件を記録しました。",
+  "Characters.IncompleteReasonUnavailable": "表示できる診断情報がありません。ログと問題パネルを確認してください。",
   "Characters.SpeakerHint": "名前またはキーを入力して選択。一致しない場合はフォーカスを外すと作成します",
   "Error.character.name": "開発言語の名前を入力してください。",
   "Error.character.key": "登場人物のキーは空にできません。",
   "Error.character.duplicate": "このキーは既に使われています。",
   "Error.character.changed": "登場人物または名前が変更されました。下書きを戻して再試行してください。",
   "Error.character.inUse": "使用中の登場人物は削除できません。",
-  "Error.character.incomplete": "参照解析が不完全なため、安全に操作できません。",
+  "Error.character.incomplete": "参照解析が不完全なため、安全に操作できません。原因：{0}",
   "Error.character.ambiguous": "同名の登場人物が複数います。候補からキーを選択してください。",
   "Error.character.obsolete": "プロジェクトまたは項目が変更され、この入力は無効になりました。",
   "Entry.AppendBatch": "エントリを追加",
@@ -65,7 +110,6 @@
   "Editor.Menu.ProjectExplorer": "プロジェクト エクスプローラー",
   "Editor.Menu.Inspector": "インスペクター",
   "Editor.Menu.Log": "ログ パネル",
-  "Editor.Menu.GamePreview": "ゲーム プレビュー",
   "Editor.Menu.SaveLayout": "ウィンドウ レイアウトを保存",
   "Editor.Menu.LoadLayout": "ウィンドウ レイアウトを読み込み",
   "Editor.Menu.DeleteLayout": "ウィンドウ レイアウトを削除",
@@ -80,10 +124,16 @@
   "Settings.Saved": "保存しました",
   "Settings.SaveFailed": "保存に失敗しました",
   "Settings.ThemeChanged": "{0} に切り替えました",
+  "Settings.Project.DefaultWidth": "既定の幅",
+  "Settings.Project.DefaultHeight": "既定の高さ",
+  "Settings.Project.DefaultVisualPrograms": "既定のビジュアルプログラム",
+  "Settings.Project.PlaybackOrder": "再生順",
+  "Settings.Project.Repeat": "リピートモード",
+  "Settings.Project.OverflowPolicy": "音声超過時の処理",
+  "Settings.Project.QueueOverflowPolicy": "キュー超過時の処理",
   "Settings.Project.Title": "プロジェクト設定",
   "Settings.Project.DefaultResolution": "既定の解像度",
   "Settings.Project.SaveSlotCount": "セーブスロット数",
-  "Settings.Project.SfxChannelCount": "効果音チャンネル数",
   "Settings.Project.TargetLanguage": "対象言語",
   "Settings.Project.Unsaved": "（未保存の変更があります）",
   "Theme.Default": "システム設定",
@@ -94,7 +144,6 @@
   "Language.zh-CN": "簡体字中国語",
   "Language.en-US": "英語",
   "Dock.Panel.NodeGraph": "Node Graph",
-  "Dock.Panel.GamePreview": "Game Preview",
   "Dock.Panel.Assets": "プロジェクトファイル",
   "Dock.Panel.Log": "Log",
   "Dock.Panel.GroupEditor": "Group: {0}",
@@ -113,9 +162,6 @@
   "Inspector.Node.OpenGroupEditor": "Open Group Editor",
   "Inspector.Node.Options": "Options",
   "Inspector.Node.Conditions": "Conditions",
-  "Inspector.Preview.PlayerVariables": "Player Variables",
-  "Inspector.Preview.SaveVariables": "Save Variables",
-  "Inspector.Preview.SystemVariables": "Generated system variables (read-only)",
   "Inspector.Asset.Title": "Asset",
   "Inspector.Asset.Id": "Id",
   "Inspector.Asset.Path": "Path",
@@ -303,9 +349,21 @@
   "Export.Package": "パッケージ",
   "Export.Action": "書き出す",
   "Export.SelectDirectory": "出力先を選択",
-  "Export.Success": "ゲームを書き出しました。",
+  "Export.Success": "パッケージを作成しました。",
   "Export.Failed": "書き出しに失敗しました。",
   "Export.Unavailable": "プロジェクトと出力先が必要です。",
+  "Export.Mode": "パッケージの種類",
+  "Export.Mode.Galpak": "Galpak アーカイブ",
+  "Export.Mode.Editor": "Editor リリース",
+  "Export.Mode.Sample": "Sample ランタイム",
+  "Export.Mode.IntegratedSample": "Sample + 展開済みゲームコンテンツ",
+  "Export.ReleaseOutput": "リリース出力先",
+  "Export.Version": "リリースバージョン",
+  "Export.IntegrationSource": "ゲームコンテンツ（.galpak または現在のプロジェクト）",
+  "Export.ProjectDefault": "空欄の場合は現在のプロジェクトを使用",
+  "Export.SelectGalpakButton": ".galpak を選択...",
+  "Export.SelectGalpak": ".galpak ファイルを選択",
+  "Export.ReleaseUnavailable": "GalNet リポジトリ内でプロジェクトを開くとリリースパッケージを作成できます。",
   "Export.Progress.Title": "ゲームを書き出しています",
   "Export.Progress.Working": "ゲームパッケージを作成しています...",
   "Export.Progress.Cancel": "キャンセル",
@@ -351,6 +409,8 @@
   "Entry.Parameter.value": "値",
   "Entry.Parameter.type": "エフェクト種類",
   "Entry.Parameter.parameters": "パラメーター（JSON）",
+  "Entry.ShaderParameters": "シェーダーパラメーター",
+  "Entry.ShaderMetadataUnavailable": "シェーダーのメタデータを読み込み中、または利用できません。",
   "Entry.Parameter.target": "対象",
   "Entry.Parameter.valueType": "値の種類",
   "Entry.Parameter.expression": "式",
@@ -448,8 +508,14 @@
   "Entry.Option.ReplaceAll": "すべて置き換え",
   "NewProject.Name": "名前",
   "NewProject.Parent": "親フォルダー",
+  "NewProject.Application": "ゲーム App（任意）",
+  "NewProject.ApplicationHint": "EXE を選択して契約を検索し、プロジェクトのデバッグに使用",
+  "NewProject.BrowseApplication": "ゲーム App を選択",
+  "Error.project.applicationInvalid": "存在するゲーム App の EXE ファイルを選択してください。",
+  "Error.project.applicationContractMissing": "App と同じフォルダーまたは lib に契約が見つかりません。契約フォルダーを手動で選択してください。",
+  "Error.project.applicationContractAmbiguous": "複数の契約が見つかりました。契約フォルダーを手動で選択してください。",
   "NewProject.Contracts": "カスタム契約フォルダー（任意）",
-  "NewProject.ContractsHint": "空欄で内蔵契約を使用",
+  "NewProject.ContractsHint": "App 未選択時は空欄で内蔵契約を使用",
   "NewProject.Resolution": "設計解像度",
   "NewProject.Create": "プロジェクトを作成",
   "NewProject.BrowseContracts": "ビルド済み契約フォルダーを選択",
@@ -602,7 +668,7 @@
   "Files.OpenExternal": "外部で開く",
   "Files.Missing": "ファイルは削除されました。削除を元に戻すと編集できます。",
   "Files.ReadOnly": "読み取り専用：システム、バイナリ、大容量、または未対応の文字コードです。外部で開けます。",
-  "Files.ExternalChange": "外部で変更されました。編集内容は保持され、保存で外部の内容を上書きしません。プロジェクトを閉じて両方を確認し、開き直してください。",
+  "Files.ExternalChange": "ファイルが外部で変更されました。編集内容は保持されています。エディターの外部変更通知から再読み込みするか、両方の内容を確認して再試行してください。",
   "History.TextFile": "ファイル編集：{0}",
   "Error.files.busy": "保存中です。少し待ってから開いてください：{0}",
   "Error.files.galleryId": "Gallery 項目 ID が無効なため変更しませんでした：{0}",
@@ -727,6 +793,9 @@
   "Timeline.Create": "タイムラインを作成",
   "Timeline.Editing": "タイムライン編集中",
   "Timeline.Invalid": "内容が無効です。項目の JSON パラメーターを修正してください。",
+  "Timeline.ResizeSections": "ドラッグしてオブジェクトトラックとイベント領域の比率を調整",
+  "Timeline.CurrentFrame": "{0} フレーム",
+  "Timeline.ObjectTracks": "オブジェクトトラック",
   "Timeline.Frame": "現在のフレーム",
   "Timeline.Duration": "終了フレーム",
   "Timeline.Empty": "編集可能なオブジェクトや既存トラックがありません。このエントリの前にシーンオブジェクトを作成してください。",
@@ -947,12 +1016,9 @@
   "Variants.Title": "画像差分セット",
   "Variants.Folder": "画像フォルダー（定義からの相対パス）",
   "Variants.Default": "既定の画像",
+  "Variants.Details": "照合の詳細",
+  "Variants.Dimension": "次元 {0}",
   "Variants.Label": "表示名",
-  "Variants.AddDimension": "次元を追加",
-  "Variants.Infer": "次元を再推定",
-  "Variants.IdentityWarning": "キーや順序の変更はシナリオの参照に影響します。既存の項目を確認してください。参照は自動移行されません。",
-  "Variants.Apply": "設定を適用",
-  "Variants.Refresh": "再スキャン",
   "Variants.ResetPreview": "プレビュー選択をリセット",
   "Variants.Requested": "要求した選択",
   "Variants.Actual": "実際の画像",
@@ -1010,5 +1076,147 @@
   "Uiux.Severity.info": "情報",
   "Uiux.Severity.error": "エラー",
   "Uiux.Entry.Selected": "選択数",
-  "Uiux.Entry.ActiveOnly": "件・詳細は現在の項目のみ編集"
+  "Uiux.Entry.ActiveOnly": "件・詳細は現在の項目のみ編集",
+  "Uiux.Panel.Search": "名前または説明を検索…",
+  "Uiux.Panel.NoResults": "項目がないか、一致する結果がありません",
+  "Uiux.Panel.SelectItem": "項目を選択するか、＋で追加してください。",
+  "Uiux.Panel.MissingSelection": "選択した変数は削除されました。削除を取り消すか、保持された下書きを破棄してください。",
+  "Uiux.Panel.Unapplied": "未適用",
+  "Uiux.Panel.DeleteBlocked": "キャラクターが参照されているか、参照分析が完了していません",
+  "Uiux.I18n.Languages": "言語の管理",
+  "Uiux.I18n.Search": "原文、訳文、コンテキストを検索…",
+  "Uiux.I18n.All": "すべての状態",
+  "Uiux.I18n.Missing": "未翻訳",
+  "Uiux.I18n.Review": "要確認",
+  "Uiux.I18n.Drafts": "下書きあり",
+  "Uiux.I18n.Exchange": "翻訳のインポート・エクスポート",
+  "Uiux.Inspector.Preview": "プレビュー",
+  "Uiux.I18n.VisibleColumns": "表示する言語列を選択",
+  "Uiux.I18n.SearchLanguage": "言語名またはコードを検索…",
+  "Uiux.I18n.RemoveLanguage": "プロジェクトの言語から除外",
+  "Uiux.I18n.RemoveHint": "言語を除外しても翻訳ファイルは保持されます。",
+  "Uiux.I18n.RemoveSource": "除外する前に開発言語を切り替えてください。",
+  "Uiux.I18n.LanguageActions": "言語の操作",
+  "Uiux.I18n.ReloadCell": "失敗した入力を破棄して再読み込み",
+  "Uiux.I18n.SourceChanged": "原文が変更されました",
+  "Form.Flipbook.Columns": "列数",
+  "Form.Flipbook.Rows": "行数",
+  "Form.Flipbook.FrameCount": "総フレーム数",
+  "Form.Flipbook.Index": "現在のフレーム（0 始まり）",
+  "Form.FlipbookInvalid": "行数・列数・フレーム数は正の整数で、フレーム数はグリッド容量以下である必要があります。",
+  "Entry.Parameter.loopCount": "再生回数（0 は無限）",
+  "Entry.Parameter.completion": "再生完了時",
+  "Entry.Option.discard": "項目を破棄",
+  "Entry.Option.requeueTail": "キューの末尾に戻す",
+  "Scene.Impact.Title": "シーンへの影響を確認",
+  "Scene.Impact.Message": "この操作はシーンの対象や参照の利用可能性を変えます。既存の参照は保持され、対象の欠落は保存可能な警告になります。",
+  "Scene.Impact.Continue": "操作を続行",
+  "Scene.Impact.Groups": "{0} 個の Group の終了時の状態が変わります。",
+  "Scene.Impact.Incomplete": "解析は不完全です。他の参照や影響がある可能性があります。",
+  "Scene.Diagnostic.scene.reference.resolved": "この位置で対象を利用できます。",
+  "Scene.Diagnostic.scene.reference.missing": "この位置で一致する対象がありません。",
+  "Scene.Diagnostic.scene.reference.possible": "対象は一部の実行経路でのみ存在する可能性があります。",
+  "Scene.Diagnostic.scene.reference.uncertain": "対象の利用可能性を完全には判断できません。",
+  "Scene.Diagnostic.scene.reference.unreachable": "現在のルートからこの Group に到達できません。",
+  "Scene.Diagnostic.scene.coverage.unknown": "この Entry の組み込みシーン関係宣言がありません。",
+  "Scene.Diagnostic.scene.coverage.structure": "シーン関係の構造を完全には解析できません。",
+  "Scene.Diagnostic.scene.analysis.limit": "シーン解析が安全上限に達しました。",
+  "Error.entry.impactChanged": "確認中に編集内容が変わりました。操作の影響を再確認してください。",
+  "Entry.MovePending": "項目を移動待ちにしました。貼り付けで移動します。",
+  "Entry.MoveFallback": "移動情報が無効か別のプロジェクトのものです。新しい識別子でコピーしました。",
+  "Entry.MoveCancel": "移動をキャンセル",
+  "Scene.Impact.Inputs": "未確定の入力 {0} 件を Problems に保管します。保存は妨げません。",
+  "Uiux.Draft.Archived": "保管済み入力：対象がないか基準値が一致しません。破棄前にテキストをコピーできます。",
+  "Uiux.Draft.Recoverable": "新しいフィールド接続で入力を復元できます。保管済み入力は保存を妨げません。",
+  "Uiux.Draft.RestoreRequested": "復元を要求しました。対応するフィールドを開くか展開してください。",
+  "Uiux.Draft.Restore": "入力を復元",
+  "Error.entry.archiveFull": "入力保管領域が満杯です。Problems でコピーまたは破棄してから項目を削除してください。",
+  "Error.entry.archiveUnavailable": "入力保管領域を利用できません。.galnet/editor/input-archive.json を保全して修復してください。",
+  "Error.entry.archiveChanged": "保管済み入力が現在の対象と一致しません。破棄前にテキストをコピーしてください。",
+  "Settings.Project.AudioBuses": "音声バス",
+  "Settings.Project.AddGroup": "グループを追加",
+  "Settings.Project.RemoveGroup": "グループを削除",
+  "Settings.Project.GroupId": "グループ ID（省略可）",
+  "Settings.Project.PreserveAudio": "早送り後も再生を保持",
+  "Entry.Parameter.targetId": "対象 ID",
+  "Entry.Parameter.scope": "適用先",
+  "Entry.Option.track": "トラック",
+  "Entry.Option.bus": "バス",
+  "Settings.Project.BusId": "バス ID（省略可）",
+  "Audio.Effect": "音声エフェクト",
+  "Audio.EffectType": "エフェクトの種類",
+  "Audio.Target": "対象",
+  "Audio.Parameters": "エフェクトパラメーター",
+  "Audio.AllEffects": "すべてのエフェクト",
+  "Audio.AnalysisIncomplete": "解析が不完全なため、一部の候補が表示されない場合があります。",
+  "Audio.SelectEffect": "種類が明確なエフェクトを選択してください。未知のデータは保持されます。",
+  "Audio.UnchangedParameters": "未指定のパラメーターは変更しません。",
+  "Entry.Type.audio.seffect.update": "音声エフェクトを更新",
+  "Audio.Type.seffect.gain": "ゲイン",
+  "Audio.Type.seffect.lowPass": "ローパス",
+  "Audio.Type.seffect.highPass": "ハイパス",
+  "Audio.Type.seffect.reverb": "リバーブ",
+  "Audio.Parameter.gain": "ゲイン",
+  "Audio.Parameter.cutoffHz": "カットオフ (Hz)",
+  "Audio.Parameter.q": "Q",
+  "Audio.Parameter.roomSize": "部屋の大きさ",
+  "Audio.Parameter.decaySeconds": "減衰時間 (秒)",
+  "Audio.Parameter.damping": "ダンピング",
+  "Audio.Parameter.mix": "ドライ／ウェット",
+  "Problem.Value.Required": "「{0}」を入力し、Enter またはフォーカス移動で確定してください。",
+  "Problem.Value.Type": "「{0}」には{1}が必要です。入力形式を確認してください。",
+  "Problem.Value.Range": "「{0}」は範囲外です。{2} から {3} の値を入力してください。",
+  "Problem.Value.Finite": "「{0}」には有限の数値が必要です。値や指数を確認してください。",
+  "Problem.Value.Null": "「{0}」は null にできません。値を入力するかリセットしてください。",
+  "Problem.Value.Option": "「{0}」は選択肢にありません。選び直してください。",
+  "Problem.Value.Length": "「{0}」の長さまたは項目数を確認してください。",
+  "Problem.Value.Spin": "「{0}」はこの刻み幅で調整できません。直接入力してください。",
+  "Problem.Value.Conflict": "「{0}」の元データが変わりました。必要な入力を控えてから取り消し、再編集してください。",
+  "Problem.Value.Invalid": "「{0}」を使用できません。内容と技術情報を確認してください。",
+  "Problem.Kind.Number": "数値（例：0.3）",
+  "Problem.Kind.Integer": "整数",
+  "Problem.Kind.Text": "テキスト",
+  "Problem.Kind.Boolean": "真偽値",
+  "Problem.Kind.Json": "正しい型の完全な値",
+  "Problem.Source.Entry": "{0} / 項目 {1} · {2}",
+  "Problem.Entry.Compile": "この項目をコンパイルできません。パラメーターと技術情報を確認してください。",
+  "Problem.Entry.UnknownType": "この項目の型はプロジェクト契約にありません。型または契約を確認してください。",
+  "Problem.Condition": "条件式を解析できません。括弧、演算子、変数名を確認してください。",
+  "Problem.Generic": "検証に失敗しました。該当箇所と技術情報を確認してください。",
+  "Problem.Localization.Opaque": "フィールド構造の定義がないため、内部のテキストやキャラクター参照を確認できません。値が不正であることを意味するものではありません。",
+  "Problem.Details": "技術情報",
+  "Problem.Navigate": "問題の箇所へ移動",
+  "Problem.Unavailable": "元の箇所が存在しないか開けません。再検証してください。",
+  "Problem.Checking": "自動検証中…",
+  "Problem.CheckFailed": "検証が完了しませんでした。技術情報を確認し、再実行してください。",
+  "Problem.NumericFallback": "この型や範囲は安全にスライダー・刻み調整できないため、直接入力を使用します。",
+  "Problem.Value.Minimum": "「{0}」は {2} 以上にしてください。",
+  "Problem.Value.Maximum": "「{0}」は {3} 以下にしてください。",
+  "Form.MapKey": "キー",
+  "Form.MapKeyDuplicate": "同じ名前のキーが既にあります。別の名前を入力してください。",
+  "Entry.Type.custom.invoke": "カスタム操作を実行",
+  "Entry.Type.audio.mix.set": "音声ミックス音量を設定",
+  "Entry.Category.custom": "カスタム",
+  "Settings.ExpandNewEntries": "新しい項目のパラメーターを展開",
+  "Entry.Parameter.action": "操作",
+  "Entry.Parameter.argument": "引数",
+  "Entry.Parameter.muted": "ミュート",
+  "Entry.Category.variants": "画像差分",
+  "Entry.Parameter.all": "すべて",
+  "Entry.Parameter.amplitude": "振幅",
+  "Entry.Parameter.anchorX": "アンカー X",
+  "Entry.Parameter.anchorY": "アンカー Y",
+  "Entry.Parameter.angle": "角度",
+  "Entry.Parameter.cycles": "周期数",
+  "Entry.Parameter.flashOpacity": "フラッシュの不透明度",
+  "Entry.Parameter.flicker": "点滅",
+  "Entry.Parameter.maskAsset": "マスク素材",
+  "Entry.Parameter.radius": "半径",
+  "Entry.Parameter.rotationDegrees": "回転",
+  "Entry.Parameter.scale": "拡大率",
+  "Entry.Parameter.softness": "柔らかさ",
+  "Entry.Parameter.speed": "速度",
+  "Entry.Parameter.motion": "動作",
+  "Entry.Parameter.center": "中心",
+  "Entry.Parameter.blurProgram": "ぼかしプログラム"
 }
diff --git a/src/Editor/GalNet.Editor/Localization/ko-KR.json b/src/Editor/GalNet.Editor/Localization/ko-KR.json
index 9139e8f2..1bbfbaac 100644
--- a/src/Editor/GalNet.Editor/Localization/ko-KR.json
+++ b/src/Editor/GalNet.Editor/Localization/ko-KR.json
@@ -1,4 +1,46 @@
 {
+  "Packaging.Panel": "리소스 패치",
+  "Packaging.HistoryGroup": "Group 스토리 패키지 변경",
+  "Packaging.HistoryOverrides": "리소스 패치 변경",
+  "Error.graph.groupRequired": "Group에만 스토리 패키지를 설정할 수 있습니다.",
+  "Error.graph.packageName": "패키지 이름은 제어 문자 없이 128자 이하여야 하며 대소문자만 달라서는 안 됩니다.",
+  "Packaging.StoryPackage": "스토리 패키지 이름",
+  "Packaging.BaseGroup": "비워 두면 게임 본편",
+  "Packaging.Create": "패치 열 추가",
+  "Packaging.NewPatch": "리소스 패치",
+  "Packaging.Dependencies": "간접 참조 리소스 표시",
+  "Packaging.AddOriginal": "원본 리소스 추가",
+  "Packaging.Original": "원본 리소스",
+  "Packaging.PriorityLabel": "우선순위",
+  "Packaging.Locate": "원본 리소스 찾기",
+  "Packaging.Search": "리소스 검색…",
+  "Packaging.Name": "패치 이름",
+  "Packaging.Priority": "우선순위 (큰 값 우선)",
+  "Packaging.Export": "PAK 내보내기",
+  "Packaging.Delete": "삭제",
+  "Packaging.Cancel": "내보내기 취소",
+  "Packaging.Canceled": "내보내기가 취소되었습니다.",
+  "Packaging.Exported": "리소스 패치를 내보냈습니다:",
+  "Packaging.Missing": "없음",
+  "Entry.Parameter.playbackMode": "재생 방식",
+  "Entry.Option.Timed": "지정 시간",
+  "Entry.Option.UntilStopped": "중지할 때까지",
+  "Entry.Type.transition.reveal": "셰이더 전환",
+  "Entry.Type.transition.blur": "블러 크로스페이드",
+  "Entry.Type.preset.motion": "캐릭터 동작",
+  "Entry.Type.preset.shake": "화면 흔들림",
+  "Entry.Type.preset.speedLines": "동적 집중선",
+  "Entry.Type.preset.impact": "충격 연출",
+  "Entry.Category.Preset": "연출 프리셋",
+  "External.Reload": "디스크에서 다시 불러오기",
+  "External.Retry": "다시 확인",
+  "External.Publishing": "외부 파일 트랜잭션이 끝나기를 기다립니다. 도구가 비정상 종료되었다면 트랜잭션 복구 자료를 먼저 확인하세요.",
+  "External.Reloaded": "외부 변경을 불러오고 이전 실행 취소 기록을 지웠습니다.",
+  "External.LocalChanges": "파일이 외부에서 변경되었습니다. 저장하지 않은 내용과 입력은 보존됩니다. 다시 불러와 폐기하거나 외부 파일을 확인한 뒤 다시 시도하세요.",
+  "External.Invalid": "외부 파일을 불러올 수 없습니다. 현재 내용을 보존하고 파일 변경 후 다시 시도합니다.",
+  "External.ContractsChanged": "프로젝트 계약이 변경되었습니다. 프로젝트를 다시 열어 주세요.",
+  "External.DiscardQuestion": "저장하지 않은 편집과 입력을 폐기하고 디스크에서 다시 불러올까요? 적용된 내용의 복구 스냅샷을 보관하고 실행 취소 기록을 지웁니다. 패널과 레이아웃은 유지됩니다.",
+  "External.DiscardReload": "변경을 폐기하고 다시 불러오기",
   "Error.text.changed": "텍스트 참조가 변경되었습니다. 초안을 다시 불러오세요.",
   "Error.text.conflict": "동일한 공유 텍스트의 수정 내용이 충돌합니다.",
   "History.GameText": "게임 텍스트: {0}",
@@ -18,13 +60,16 @@
   "Characters.Revert": "초안 되돌리기",
   "Characters.Delete": "사용하지 않는 등장인물 삭제",
   "Characters.Incomplete": "참조 분석이 불완전하여 삭제와 키 변경을 사용할 수 없습니다.",
+  "Characters.IncompleteReason": "• {0} — {1}: {2}",
+  "Characters.IncompleteMore": "표시되지 않은 항목이 {0}개 더 있습니다. 로그에는 처음 {1}개를 기록했습니다.",
+  "Characters.IncompleteReasonUnavailable": "표시할 진단 정보가 없습니다. 로그와 문제 패널을 확인하세요.",
   "Characters.SpeakerHint": "이름이나 키를 입력하거나 선택하세요. 일치하지 않으면 포커스를 잃을 때 생성합니다",
   "Error.character.name": "개발 언어 등장인물 이름을 입력하세요.",
   "Error.character.key": "등장인물 키는 비워 둘 수 없습니다.",
   "Error.character.duplicate": "이미 존재하는 등장인물 키입니다.",
   "Error.character.changed": "등장인물이나 이름이 변경되었습니다. 초안을 되돌린 후 다시 시도하세요.",
   "Error.character.inUse": "사용 중인 등장인물은 삭제할 수 없습니다.",
-  "Error.character.incomplete": "참조 분석이 불완전하여 안전하게 작업할 수 없습니다.",
+  "Error.character.incomplete": "참조 분석이 불완전하여 안전하게 작업할 수 없습니다. 원인: {0}",
   "Error.character.ambiguous": "이름이 같은 등장인물이 여럿입니다. 제안 목록에서 키를 선택하세요.",
   "Error.character.obsolete": "프로젝트나 항목이 변경되어 이 입력은 더 이상 유효하지 않습니다.",
   "Entry.AppendBatch": "엔트리 추가",
@@ -65,7 +110,6 @@
   "Editor.Menu.ProjectExplorer": "프로젝트 탐색기",
   "Editor.Menu.Inspector": "속성 패널",
   "Editor.Menu.Log": "로그 패널",
-  "Editor.Menu.GamePreview": "게임 미리보기",
   "Editor.Menu.SaveLayout": "창 레이아웃 저장",
   "Editor.Menu.LoadLayout": "창 레이아웃 불러오기",
   "Editor.Menu.DeleteLayout": "창 레이아웃 삭제",
@@ -80,10 +124,16 @@
   "Settings.Saved": "저장됨",
   "Settings.SaveFailed": "저장 실패",
   "Settings.ThemeChanged": "{0}(으)로 전환됨",
+  "Settings.Project.DefaultWidth": "기본 너비",
+  "Settings.Project.DefaultHeight": "기본 높이",
+  "Settings.Project.DefaultVisualPrograms": "기본 비주얼 프로그램",
+  "Settings.Project.PlaybackOrder": "재생 순서",
+  "Settings.Project.Repeat": "반복 모드",
+  "Settings.Project.OverflowPolicy": "음성 초과 정책",
+  "Settings.Project.QueueOverflowPolicy": "대기열 초과 정책",
   "Settings.Project.Title": "프로젝트 설정",
   "Settings.Project.DefaultResolution": "기본 해상도",
   "Settings.Project.SaveSlotCount": "저장 슬롯 수",
-  "Settings.Project.SfxChannelCount": "효과음 채널 수",
   "Settings.Project.TargetLanguage": "대상 언어",
   "Settings.Project.Unsaved": "(저장되지 않은 변경 사항)",
   "Theme.Default": "시스템 기본값",
@@ -94,7 +144,6 @@
   "Language.zh-CN": "중국어 간체",
   "Language.en-US": "영어",
   "Dock.Panel.NodeGraph": "Node Graph",
-  "Dock.Panel.GamePreview": "Game Preview",
   "Dock.Panel.Assets": "프로젝트 파일",
   "Dock.Panel.Log": "Log",
   "Dock.Panel.GroupEditor": "Group: {0}",
@@ -113,9 +162,6 @@
   "Inspector.Node.OpenGroupEditor": "Open Group Editor",
   "Inspector.Node.Options": "Options",
   "Inspector.Node.Conditions": "Conditions",
-  "Inspector.Preview.PlayerVariables": "Player Variables",
-  "Inspector.Preview.SaveVariables": "Save Variables",
-  "Inspector.Preview.SystemVariables": "Generated system variables (read-only)",
   "Inspector.Asset.Title": "Asset",
   "Inspector.Asset.Id": "Id",
   "Inspector.Asset.Path": "Path",
@@ -303,9 +349,21 @@
   "Export.Package": "패키지",
   "Export.Action": "내보내기",
   "Export.SelectDirectory": "출력 디렉터리 선택",
-  "Export.Success": "게임 패키지를 내보냈습니다.",
+  "Export.Success": "패키지를 만들었습니다.",
   "Export.Failed": "내보내기에 실패했습니다.",
   "Export.Unavailable": "프로젝트와 출력 디렉터리가 필요합니다.",
+  "Export.Mode": "패키지 종류",
+  "Export.Mode.Galpak": "Galpak 아카이브",
+  "Export.Mode.Editor": "Editor 릴리스",
+  "Export.Mode.Sample": "Sample 런타임",
+  "Export.Mode.IntegratedSample": "Sample + 압축 해제된 게임 콘텐츠",
+  "Export.ReleaseOutput": "릴리스 출력 경로",
+  "Export.Version": "릴리스 버전",
+  "Export.IntegrationSource": "게임 콘텐츠 (.galpak 또는 현재 프로젝트)",
+  "Export.ProjectDefault": "비우면 현재 프로젝트 사용",
+  "Export.SelectGalpakButton": ".galpak 선택...",
+  "Export.SelectGalpak": ".galpak 파일 선택",
+  "Export.ReleaseUnavailable": "GalNet 저장소 체크아웃에서 프로젝트를 열면 릴리스 패키지를 만들 수 있습니다.",
   "Export.Progress.Title": "게임 내보내는 중",
   "Export.Progress.Working": "게임 패키지를 빌드하는 중...",
   "Export.Progress.Cancel": "취소",
@@ -351,6 +409,8 @@
   "Entry.Parameter.value": "값",
   "Entry.Parameter.type": "효과 유형",
   "Entry.Parameter.parameters": "매개변수(JSON)",
+  "Entry.ShaderParameters": "셰이더 매개변수",
+  "Entry.ShaderMetadataUnavailable": "셰이더 메타데이터를 불러오는 중이거나 사용할 수 없습니다.",
   "Entry.Parameter.target": "대상",
   "Entry.Parameter.valueType": "값 유형",
   "Entry.Parameter.expression": "식",
@@ -448,8 +508,14 @@
   "Entry.Option.ReplaceAll": "모두 바꾸기",
   "NewProject.Name": "이름",
   "NewProject.Parent": "상위 폴더",
+  "NewProject.Application": "게임 App (선택 사항)",
+  "NewProject.ApplicationHint": "EXE를 선택하여 계약을 찾고 프로젝트 디버깅에 사용",
+  "NewProject.BrowseApplication": "게임 App 선택",
+  "Error.project.applicationInvalid": "존재하는 게임 App EXE 파일을 선택하세요.",
+  "Error.project.applicationContractMissing": "App 폴더 또는 lib에서 프로젝트 계약을 찾지 못했습니다. 계약 폴더를 직접 선택하세요.",
+  "Error.project.applicationContractAmbiguous": "프로젝트 계약이 여러 개 발견되었습니다. 계약 폴더를 직접 선택하세요.",
   "NewProject.Contracts": "사용자 계약 폴더 (선택)",
-  "NewProject.ContractsHint": "비워 두면 기본 계약 사용",
+  "NewProject.ContractsHint": "App을 선택하지 않은 경우 비워 두면 기본 계약 사용",
   "NewProject.Resolution": "설계 해상도",
   "NewProject.Create": "프로젝트 만들기",
   "NewProject.BrowseContracts": "빌드된 프로젝트 계약 폴더 선택",
@@ -602,7 +668,7 @@
   "Files.OpenExternal": "외부에서 열기",
   "Files.Missing": "파일이 삭제되었습니다. 삭제를 실행 취소하면 편집할 수 있습니다.",
   "Files.ReadOnly": "읽기 전용: 시스템 파일, 바이너리, 대용량 또는 지원하지 않는 인코딩입니다. 외부에서 열 수 있습니다.",
-  "Files.ExternalChange": "외부에서 파일이 변경되었습니다. 편집 내용은 유지되며 저장 시 외부 내용을 덮어쓰지 않습니다. 프로젝트를 닫고 두 버전을 확인한 뒤 다시 여세요.",
+  "Files.ExternalChange": "파일이 외부에서 변경되었습니다. 편집 내용은 유지됩니다. 편집기의 외부 변경 알림에서 디스크 내용을 다시 불러오거나 두 버전을 확인한 뒤 다시 시도하세요.",
   "History.TextFile": "파일 편집: {0}",
   "Error.files.busy": "저장 중입니다. 잠시 후 파일을 다시 여세요: {0}",
   "Error.files.galleryId": "Gallery 항목 ID가 유효하지 않아 변경하지 않았습니다: {0}",
@@ -727,6 +793,9 @@
   "Timeline.Create": "타임라인 만들기",
   "Timeline.Editing": "타임라인 편집 중",
   "Timeline.Invalid": "내용이 잘못되었습니다. 항목 매개변수의 JSON을 수정하세요.",
+  "Timeline.ResizeSections": "드래그하여 오브젝트 트랙과 이벤트 영역 비율 조정",
+  "Timeline.CurrentFrame": "{0} 프레임",
+  "Timeline.ObjectTracks": "오브젝트 트랙",
   "Timeline.Frame": "현재 프레임",
   "Timeline.Duration": "끝 프레임",
   "Timeline.Empty": "편집할 객체나 기존 트랙이 없습니다. 이 항목 앞에 장면 객체를 만드세요.",
@@ -947,12 +1016,9 @@
   "Variants.Title": "이미지 차분 모음",
   "Variants.Folder": "이미지 폴더 (설명 파일 기준 상대 경로)",
   "Variants.Default": "기본 이미지",
+  "Variants.Details": "매칭 세부 정보",
+  "Variants.Dimension": "차원 {0}",
   "Variants.Label": "표시 이름",
-  "Variants.AddDimension": "차원 추가",
-  "Variants.Infer": "차원 다시 추론",
-  "Variants.IdentityWarning": "키 또는 순서 변경으로 이야기 참조가 무효화될 수 있습니다. 기존 항목을 확인하세요. 참조는 자동 이전되지 않습니다.",
-  "Variants.Apply": "설정 적용",
-  "Variants.Refresh": "다시 스캔",
   "Variants.ResetPreview": "미리보기 선택 초기화",
   "Variants.Requested": "요청한 선택",
   "Variants.Actual": "실제 이미지",
@@ -1010,5 +1076,147 @@
   "Uiux.Severity.info": "정보",
   "Uiux.Severity.error": "오류",
   "Uiux.Entry.Selected": "선택됨",
-  "Uiux.Entry.ActiveOnly": "개; 현재 항목의 매개변수만 편집"
+  "Uiux.Entry.ActiveOnly": "개; 현재 항목의 매개변수만 편집",
+  "Uiux.Panel.Search": "이름 또는 설명 검색…",
+  "Uiux.Panel.NoResults": "항목이 없거나 일치하는 결과가 없습니다",
+  "Uiux.Panel.SelectItem": "항목을 선택하거나 +로 추가하세요.",
+  "Uiux.Panel.MissingSelection": "선택한 변수가 삭제되었습니다. 삭제를 실행 취소하거나 보관된 초안을 버리세요.",
+  "Uiux.Panel.Unapplied": "적용되지 않음",
+  "Uiux.Panel.DeleteBlocked": "캐릭터가 참조되거나 참조 분석이 완료되지 않았습니다",
+  "Uiux.I18n.Languages": "언어 관리",
+  "Uiux.I18n.Search": "원문, 번역 또는 문맥 검색…",
+  "Uiux.I18n.All": "모든 상태",
+  "Uiux.I18n.Missing": "번역 누락",
+  "Uiux.I18n.Review": "검토 필요",
+  "Uiux.I18n.Drafts": "초안 있음",
+  "Uiux.I18n.Exchange": "번역 가져오기 및 내보내기",
+  "Uiux.Inspector.Preview": "미리 보기",
+  "Uiux.I18n.VisibleColumns": "표시할 언어 열 선택",
+  "Uiux.I18n.SearchLanguage": "언어 이름 또는 코드 검색…",
+  "Uiux.I18n.RemoveLanguage": "프로젝트 언어에서 제거",
+  "Uiux.I18n.RemoveHint": "언어를 제거해도 번역 파일은 유지됩니다.",
+  "Uiux.I18n.RemoveSource": "제거하기 전에 개발 언어를 변경하세요.",
+  "Uiux.I18n.LanguageActions": "언어 작업",
+  "Uiux.I18n.ReloadCell": "실패한 입력을 버리고 다시 읽기",
+  "Uiux.I18n.SourceChanged": "원문 변경됨",
+  "Form.Flipbook.Columns": "열 수",
+  "Form.Flipbook.Rows": "행 수",
+  "Form.Flipbook.FrameCount": "전체 프레임 수",
+  "Form.Flipbook.Index": "현재 프레임 (0부터)",
+  "Form.FlipbookInvalid": "행, 열 및 프레임 수는 양의 정수여야 하며 프레임 수는 격자 용량을 초과할 수 없습니다.",
+  "Entry.Parameter.loopCount": "재생 횟수 (0 = 무한)",
+  "Entry.Parameter.completion": "재생 완료 시",
+  "Entry.Option.discard": "항목 제거",
+  "Entry.Option.requeueTail": "대기열 끝으로 이동",
+  "Scene.Impact.Title": "장면 영향 검토",
+  "Scene.Impact.Message": "이 작업은 장면 대상이나 참조의 사용 가능 여부를 바꿉니다. 기존 참조는 유지되며, 대상이 없어도 경고로 표시하고 저장할 수 있습니다.",
+  "Scene.Impact.Continue": "작업 계속",
+  "Scene.Impact.Groups": "{0}개 Group의 종료 상태가 바뀝니다.",
+  "Scene.Impact.Incomplete": "분석이 완료되지 않았습니다. 다른 참조나 영향이 있을 수 있습니다.",
+  "Scene.Diagnostic.scene.reference.resolved": "이 위치에서 대상을 사용할 수 있습니다.",
+  "Scene.Diagnostic.scene.reference.missing": "이 위치에 일치하는 대상이 없습니다.",
+  "Scene.Diagnostic.scene.reference.possible": "일부 실행 경로에만 대상이 존재할 수 있습니다.",
+  "Scene.Diagnostic.scene.reference.uncertain": "대상의 사용 가능 여부를 완전히 판단할 수 없습니다.",
+  "Scene.Diagnostic.scene.reference.unreachable": "현재 루트에서 이 Group에 도달할 수 없습니다.",
+  "Scene.Diagnostic.scene.coverage.unknown": "이 Entry에 대한 기본 장면 관계 선언이 없습니다.",
+  "Scene.Diagnostic.scene.coverage.structure": "장면 관계 구조를 완전히 분석할 수 없습니다.",
+  "Scene.Diagnostic.scene.analysis.limit": "장면 분석이 안전 한도에 도달했습니다.",
+  "Error.entry.impactChanged": "검토 중 편집 내용이 바뀌었습니다. 작업의 영향을 다시 확인하세요.",
+  "Entry.MovePending": "항목을 이동 대기로 표시했습니다. 붙여넣으면 이동합니다.",
+  "Entry.MoveFallback": "이동 정보가 만료되었거나 다른 프로젝트의 정보입니다. 새 식별자로 복사했습니다.",
+  "Entry.MoveCancel": "이동 취소",
+  "Scene.Impact.Inputs": "제출하지 않은 입력 {0}개를 Problems에 보관합니다. 저장을 막지 않습니다.",
+  "Uiux.Draft.Archived": "보관된 입력: 대상이 없거나 기준값이 다릅니다. 버리기 전에 텍스트를 복사할 수 있습니다.",
+  "Uiux.Draft.Recoverable": "새 필드 바인딩으로 입력을 복원할 수 있습니다. 보관된 입력은 저장을 막지 않습니다.",
+  "Uiux.Draft.RestoreRequested": "복원을 요청했습니다. 해당 필드를 열거나 펼쳐 주세요.",
+  "Uiux.Draft.Restore": "입력 복원",
+  "Error.entry.archiveFull": "입력 보관 영역이 가득 찼습니다. Problems에서 복사하거나 버린 후 항목을 삭제하세요.",
+  "Error.entry.archiveUnavailable": "입력 보관 영역을 사용할 수 없습니다. .galnet/editor/input-archive.json을 보존하고 복구하세요.",
+  "Error.entry.archiveChanged": "보관된 입력이 현재 대상과 일치하지 않습니다. 버리기 전에 텍스트를 복사하세요.",
+  "Settings.Project.AudioBuses": "오디오 버스",
+  "Settings.Project.AddGroup": "그룹 추가",
+  "Settings.Project.RemoveGroup": "그룹 삭제",
+  "Settings.Project.GroupId": "그룹 ID (선택 사항)",
+  "Settings.Project.PreserveAudio": "빨리 감기 후 재생 유지",
+  "Entry.Parameter.targetId": "대상 ID",
+  "Entry.Parameter.scope": "적용 범위",
+  "Entry.Option.track": "트랙",
+  "Entry.Option.bus": "버스",
+  "Settings.Project.BusId": "버스 ID (선택 사항)",
+  "Audio.Effect": "오디오 효과",
+  "Audio.EffectType": "효과 종류",
+  "Audio.Target": "대상",
+  "Audio.Parameters": "효과 매개변수",
+  "Audio.AllEffects": "모든 효과",
+  "Audio.AnalysisIncomplete": "분석이 불완전하여 일부 효과가 표시되지 않을 수 있습니다.",
+  "Audio.SelectEffect": "종류가 명확한 효과를 선택하세요. 알 수 없는 데이터는 보존됩니다.",
+  "Audio.UnchangedParameters": "지정하지 않은 매개변수는 유지됩니다.",
+  "Entry.Type.audio.seffect.update": "오디오 효과 업데이트",
+  "Audio.Type.seffect.gain": "게인",
+  "Audio.Type.seffect.lowPass": "로우 패스",
+  "Audio.Type.seffect.highPass": "하이 패스",
+  "Audio.Type.seffect.reverb": "리버브",
+  "Audio.Parameter.gain": "게인",
+  "Audio.Parameter.cutoffHz": "차단 주파수 (Hz)",
+  "Audio.Parameter.q": "Q",
+  "Audio.Parameter.roomSize": "공간 크기",
+  "Audio.Parameter.decaySeconds": "감쇠 시간 (초)",
+  "Audio.Parameter.damping": "댐핑",
+  "Audio.Parameter.mix": "드라이/웨트 믹스",
+  "Problem.Value.Required": "“{0}” 값을 입력한 뒤 Enter를 누르거나 다른 곳을 선택하세요.",
+  "Problem.Value.Type": "“{0}”에는 {1}이 필요합니다. 입력 형식을 확인하세요.",
+  "Problem.Value.Range": "“{0}” 값이 범위를 벗어났습니다. {2}~{3} 사이의 값을 입력하세요.",
+  "Problem.Value.Finite": "“{0}”에는 유한한 숫자가 필요합니다. 값이나 지수를 확인하세요.",
+  "Problem.Value.Null": "“{0}”은 null일 수 없습니다. 값을 입력하거나 초기화하세요.",
+  "Problem.Value.Option": "“{0}” 값은 사용할 수 있는 옵션이 아닙니다. 다시 선택하세요.",
+  "Problem.Value.Length": "“{0}”의 길이나 항목 수를 확인하세요.",
+  "Problem.Value.Spin": "“{0}”은 현재 간격으로 조절할 수 없습니다. 정확한 값을 입력하세요.",
+  "Problem.Value.Conflict": "“{0}”의 원본이 변경되었습니다. 필요한 텍스트를 보관한 뒤 이전 입력을 취소하고 다시 편집하세요.",
+  "Problem.Value.Invalid": "“{0}”을 아직 사용할 수 없습니다. 내용과 기술 세부 정보를 확인하세요.",
+  "Problem.Kind.Number": "숫자(예: 0.3)",
+  "Problem.Kind.Integer": "정수",
+  "Problem.Kind.Text": "텍스트",
+  "Problem.Kind.Boolean": "불리언 값",
+  "Problem.Kind.Json": "올바른 형식의 완전한 값",
+  "Problem.Source.Entry": "{0} / 항목 {1} · {2}",
+  "Problem.Entry.Compile": "이 항목을 컴파일할 수 없습니다. 매개변수와 기술 세부 정보를 확인하세요.",
+  "Problem.Entry.UnknownType": "이 항목의 형식이 프로젝트 계약에 없습니다. 형식이나 계약을 확인하세요.",
+  "Problem.Condition": "조건식을 해석할 수 없습니다. 괄호, 연산자, 변수 이름을 확인하세요.",
+  "Problem.Generic": "검증에 실패했습니다. 해당 위치와 기술 세부 정보를 확인하세요.",
+  "Problem.Localization.Opaque": "필드 구조 정의가 없어 내부의 텍스트나 캐릭터 참조를 확인할 수 없습니다. 값이 잘못되었다는 뜻은 아닙니다.",
+  "Problem.Details": "기술 세부 정보",
+  "Problem.Navigate": "문제 위치로 이동",
+  "Problem.Unavailable": "원래 위치가 없거나 열 수 없습니다. 다시 검사하세요.",
+  "Problem.Checking": "자동 검사 중…",
+  "Problem.CheckFailed": "검사를 완료하지 못했습니다. 기술 세부 정보를 확인한 뒤 다시 시도하세요.",
+  "Problem.NumericFallback": "이 형식이나 범위는 슬라이더 또는 간격 조절에 적합하지 않아 정확한 텍스트 입력을 사용합니다.",
+  "Problem.Value.Minimum": "“{0}”은 {2} 이상이어야 합니다. 값을 조정하세요.",
+  "Problem.Value.Maximum": "“{0}”은 {3} 이하여야 합니다. 값을 조정하세요.",
+  "Form.MapKey": "키",
+  "Form.MapKeyDuplicate": "같은 이름의 키가 이미 있습니다. 다른 이름을 입력하세요.",
+  "Entry.Type.custom.invoke": "사용자 지정 동작 실행",
+  "Entry.Type.audio.mix.set": "오디오 믹스 음량 설정",
+  "Entry.Category.custom": "사용자 지정",
+  "Settings.ExpandNewEntries": "새 항목의 매개변수 펼치기",
+  "Entry.Parameter.action": "동작",
+  "Entry.Parameter.argument": "인수",
+  "Entry.Parameter.muted": "음소거",
+  "Entry.Category.variants": "이미지 변형",
+  "Entry.Parameter.all": "전체",
+  "Entry.Parameter.amplitude": "진폭",
+  "Entry.Parameter.anchorX": "앵커 X",
+  "Entry.Parameter.anchorY": "앵커 Y",
+  "Entry.Parameter.angle": "각도",
+  "Entry.Parameter.cycles": "반복 횟수",
+  "Entry.Parameter.flashOpacity": "섬광 불투명도",
+  "Entry.Parameter.flicker": "깜빡임",
+  "Entry.Parameter.maskAsset": "마스크 에셋",
+  "Entry.Parameter.radius": "반경",
+  "Entry.Parameter.rotationDegrees": "회전",
+  "Entry.Parameter.scale": "크기",
+  "Entry.Parameter.softness": "부드러움",
+  "Entry.Parameter.speed": "속도",
+  "Entry.Parameter.motion": "동작",
+  "Entry.Parameter.center": "중심",
+  "Entry.Parameter.blurProgram": "블러 프로그램"
 }
diff --git a/src/Editor/GalNet.Editor/Localization/zh-CN.json b/src/Editor/GalNet.Editor/Localization/zh-CN.json
index c3355d76..236c7893 100644
--- a/src/Editor/GalNet.Editor/Localization/zh-CN.json
+++ b/src/Editor/GalNet.Editor/Localization/zh-CN.json
@@ -1,4 +1,46 @@
 {
+  "Packaging.Panel": "资源补丁",
+  "Packaging.HistoryGroup": "修改 Group 剧情包",
+  "Packaging.HistoryOverrides": "修改资源补丁",
+  "Error.graph.groupRequired": "只有 Group 可以设置剧情包。",
+  "Error.graph.packageName": "剧情包名称最多 128 字符，不能包含控制字符，不能只有大小写不同。",
+  "Packaging.StoryPackage": "剧情包名称",
+  "Packaging.BaseGroup": "留空：游戏本体",
+  "Packaging.Create": "新建补丁列",
+  "Packaging.NewPatch": "资源补丁",
+  "Packaging.Dependencies": "显示间接资源",
+  "Packaging.AddOriginal": "补充原资源",
+  "Packaging.Original": "原资源",
+  "Packaging.PriorityLabel": "优先级",
+  "Packaging.Locate": "定位原资源",
+  "Packaging.Search": "搜索资源…",
+  "Packaging.Name": "补丁名称",
+  "Packaging.Priority": "优先级（越大越优先）",
+  "Packaging.Export": "导出 PAK",
+  "Packaging.Delete": "删除",
+  "Packaging.Cancel": "取消导出",
+  "Packaging.Canceled": "导出已取消。",
+  "Packaging.Exported": "资源补丁已导出：",
+  "Packaging.Missing": "缺失",
+  "Entry.Parameter.playbackMode": "播放方式",
+  "Entry.Option.Timed": "指定时长",
+  "Entry.Option.UntilStopped": "持续到停止",
+  "Entry.Type.transition.reveal": "Shader 遮罩转场",
+  "Entry.Type.transition.blur": "模糊交叉淡化",
+  "Entry.Type.preset.motion": "人物动作",
+  "Entry.Type.preset.shake": "震屏",
+  "Entry.Type.preset.speedLines": "动态集中线",
+  "Entry.Type.preset.impact": "冲击演出",
+  "Entry.Category.Preset": "演出预设",
+  "External.Reload": "从磁盘重新加载",
+  "External.Retry": "重新检查",
+  "External.Publishing": "正在等待外部文件事务完成。如果外部工具异常退出，请先检查事务恢复材料。",
+  "External.Reloaded": "已加载外部修改，之前的撤销历史已清除。",
+  "External.LocalChanges": "磁盘文件已被外部修改。未保存内容和输入已保留；可从磁盘重新加载并放弃这些修改，或核对外部文件后重新检查。",
+  "External.Invalid": "外部文件暂时无法加载。当前内容已保留，文件变化后会自动重试。",
+  "External.ContractsChanged": "项目契约已变化，请重新打开项目以加载新契约。",
+  "External.DiscardQuestion": "是否从磁盘重新加载项目内容，并放弃未保存的作者修改和待提交输入？已应用内容会保留恢复快照，撤销历史将清除；打开的面板和布局保留。",
+  "External.DiscardReload": "放弃修改并重新加载",
   "Error.text.changed": "文本引用已改变，请重新载入草稿。",
   "Error.text.conflict": "同一共享文本收到互相冲突的修改。",
   "History.GameText": "游戏文本：{0}",
@@ -18,13 +60,16 @@
   "Characters.Revert": "还原草稿",
   "Characters.Delete": "删除未使用角色",
   "Characters.Incomplete": "引用分析不完整，暂不能删除角色或更改 key。",
+  "Characters.IncompleteReason": "• {0} — {1}：{2}",
+  "Characters.IncompleteMore": "另有 {0} 条未显示；日志记录了前 {1} 条原因。",
+  "Characters.IncompleteReasonUnavailable": "当前没有可显示的诊断项，请查看日志和问题面板。",
   "Characters.SpeakerHint": "输入角色名或 key，选择已有角色；未匹配时失焦创建",
   "Error.character.name": "请输入开发语言角色名。",
   "Error.character.key": "角色 key 不能为空。",
   "Error.character.duplicate": "角色 key 已存在。",
   "Error.character.changed": "角色或姓名已改变，请还原草稿后重试。",
   "Error.character.inUse": "角色仍被使用，不能删除。",
-  "Error.character.incomplete": "引用分析不完整，无法安全执行此操作。",
+  "Error.character.incomplete": "引用分析不完整，无法安全执行此操作。原因：{0}",
   "Error.character.ambiguous": "存在同名角色，请从候选中选择具体 key。",
   "Error.character.obsolete": "项目或条目已改变，此次输入已失效。",
   "Entry.AppendBatch": "追加条目",
@@ -65,7 +110,6 @@
   "Editor.Menu.ProjectExplorer": "项目浏览器",
   "Editor.Menu.Inspector": "属性面板",
   "Editor.Menu.Log": "日志面板",
-  "Editor.Menu.GamePreview": "游戏预览",
   "Editor.Menu.SaveLayout": "保存窗口布局",
   "Editor.Menu.LoadLayout": "加载窗口布局",
   "Editor.Menu.DeleteLayout": "删除窗口布局",
@@ -80,10 +124,16 @@
   "Settings.Saved": "已保存",
   "Settings.SaveFailed": "保存失败",
   "Settings.ThemeChanged": "已切换到 {0}",
+  "Settings.Project.DefaultWidth": "默认宽度",
+  "Settings.Project.DefaultHeight": "默认高度",
+  "Settings.Project.DefaultVisualPrograms": "默认视觉程序",
+  "Settings.Project.PlaybackOrder": "播放顺序",
+  "Settings.Project.Repeat": "循环模式",
+  "Settings.Project.OverflowPolicy": "声音超限策略",
+  "Settings.Project.QueueOverflowPolicy": "队列超限策略",
   "Settings.Project.Title": "项目设置",
   "Settings.Project.DefaultResolution": "默认分辨率",
   "Settings.Project.SaveSlotCount": "存档槽位数",
-  "Settings.Project.SfxChannelCount": "音效通道数",
   "Settings.Project.TargetLanguage": "目标语言",
   "Settings.Project.Unsaved": "（有未保存的修改）",
   "Theme.Default": "跟随系统",
@@ -94,7 +144,6 @@
   "Language.zh-CN": "简体中文",
   "Language.en-US": "英语",
   "Dock.Panel.NodeGraph": "节点图",
-  "Dock.Panel.GamePreview": "游戏预览",
   "Dock.Panel.Assets": "项目文件",
   "Dock.Panel.Log": "日志",
   "Dock.Panel.GroupEditor": "组：{0}",
@@ -113,9 +162,6 @@
   "Inspector.Node.OpenGroupEditor": "打开组编辑器",
   "Inspector.Node.Options": "选项",
   "Inspector.Node.Conditions": "条件",
-  "Inspector.Preview.PlayerVariables": "玩家变量",
-  "Inspector.Preview.SaveVariables": "存档变量",
-  "Inspector.Preview.SystemVariables": "内置生成变量（只读）",
   "Inspector.Asset.Title": "资源",
   "Inspector.Asset.Id": "ID",
   "Inspector.Asset.Path": "路径",
@@ -303,9 +349,21 @@
   "Export.Package": "输出包",
   "Export.Action": "导出",
   "Export.SelectDirectory": "选择导出目录",
-  "Export.Success": "游戏包导出成功。",
+  "Export.Success": "发布包已生成。",
   "Export.Failed": "导出失败。",
   "Export.Unavailable": "需要先打开项目并选择输出目录。",
+  "Export.Mode": "发布包类型",
+  "Export.Mode.Galpak": "Galpak 游戏包",
+  "Export.Mode.Editor": "Editor 发布包",
+  "Export.Mode.Sample": "纯 Sample 运行包",
+  "Export.Mode.IntegratedSample": "Sample + 展开后的游戏内容",
+  "Export.ReleaseOutput": "发布输出根目录",
+  "Export.Version": "发布版本号",
+  "Export.IntegrationSource": "整合内容（.galpak 或当前项目）",
+  "Export.ProjectDefault": "留空时使用当前项目",
+  "Export.SelectGalpakButton": "选择 .galpak...",
+  "Export.SelectGalpak": "选择 .galpak 文件",
+  "Export.ReleaseUnavailable": "请在 GalNet 仓库检出目录中打开项目后再生成发布包。",
   "Export.Progress.Title": "正在导出游戏",
   "Export.Progress.Working": "正在构建游戏包...",
   "Export.Progress.Cancel": "取消",
@@ -351,6 +409,8 @@
   "Entry.Parameter.value": "值",
   "Entry.Parameter.type": "特效类型",
   "Entry.Parameter.parameters": "参数（JSON）",
+  "Entry.ShaderParameters": "Shader 参数",
+  "Entry.ShaderMetadataUnavailable": "Shader 元数据正在加载或不可用。",
   "Entry.Parameter.target": "目标",
   "Entry.Parameter.valueType": "值类型",
   "Entry.Parameter.expression": "表达式",
@@ -448,8 +508,14 @@
   "Entry.Option.ReplaceAll": "全部替换",
   "NewProject.Name": "名称",
   "NewProject.Parent": "父目录",
+  "NewProject.Application": "游戏 App（可选）",
+  "NewProject.ApplicationHint": "选择 EXE，自动查找契约并用于项目调试",
+  "NewProject.BrowseApplication": "选择游戏 App",
+  "Error.project.applicationInvalid": "请选择存在的游戏 App EXE 文件。",
+  "Error.project.applicationContractMissing": "未在 App 同级目录或 lib 中找到项目契约，请手动选择契约目录。",
+  "Error.project.applicationContractAmbiguous": "找到多份项目契约，请手动选择契约目录。",
   "NewProject.Contracts": "自定义契约目录（可选）",
-  "NewProject.ContractsHint": "留空使用内置契约",
+  "NewProject.ContractsHint": "未选择 App 时，留空使用内置契约",
   "NewProject.Resolution": "设计分辨率",
   "NewProject.Create": "创建项目",
   "NewProject.BrowseContracts": "选择已构建的项目契约目录",
@@ -602,7 +668,7 @@
   "Files.OpenExternal": "外部打开",
   "Files.Missing": "文件已删除，撤销删除后可继续编辑。",
   "Files.ReadOnly": "只读：系统文件、二进制、大文件或无法无损识别的编码。可外部打开。",
-  "Files.ExternalChange": "磁盘文件已被外部修改。当前编辑已保留；保存不会覆盖外部内容。请关闭项目并检查两个版本后重新打开。",
+  "Files.ExternalChange": "磁盘文件已被外部修改，当前编辑已保留。可在编辑器外部变化提示中从磁盘重新加载，或核对两个版本后重新检查。",
   "History.TextFile": "编辑文件：{0}",
   "Error.files.busy": "正在保存，请稍后再打开新文件：{0}",
   "Error.files.galleryId": "Gallery 条目标识无效，未执行操作：{0}",
@@ -727,6 +793,9 @@
   "Timeline.Create": "创建时间轴",
   "Timeline.Editing": "正在编辑时间轴",
   "Timeline.Invalid": "时间轴内容无效，请在条目参数中修复 JSON。",
+  "Timeline.ResizeSections": "拖动调整对象轨道与事件区域比例",
+  "Timeline.CurrentFrame": "{0} 帧",
+  "Timeline.ObjectTracks": "对象轨道",
   "Timeline.Frame": "当前帧",
   "Timeline.Duration": "结束帧",
   "Timeline.Empty": "此位置没有可编辑对象或已有轨道，请先在前文创建场景对象。",
@@ -947,12 +1016,9 @@
   "Variants.Title": "图片差分图集",
   "Variants.Folder": "图片目录（相对描述文件）",
   "Variants.Default": "默认图片",
+  "Variants.Details": "匹配详情",
+  "Variants.Dimension": "维度 {0}",
   "Variants.Label": "显示名称",
-  "Variants.AddDimension": "添加维度",
-  "Variants.Infer": "重新推断维度",
-  "Variants.IdentityWarning": "维度键或顺序变化可能使剧情引用失效，请核对已有条目。不会自动迁移引用。",
-  "Variants.Apply": "应用配置",
-  "Variants.Refresh": "重新扫描",
   "Variants.ResetPreview": "重置预览选择",
   "Variants.Requested": "请求选择",
   "Variants.Actual": "实际图片",
@@ -1010,5 +1076,147 @@
   "Uiux.Severity.info": "提示",
   "Uiux.Severity.error": "错误",
   "Uiux.Entry.Selected": "已选择",
-  "Uiux.Entry.ActiveOnly": "项；详情仅编辑当前条目"
+  "Uiux.Entry.ActiveOnly": "项；详情仅编辑当前条目",
+  "Uiux.Panel.Search": "搜索名称或说明…",
+  "Uiux.Panel.NoResults": "暂无条目，或没有匹配结果",
+  "Uiux.Panel.SelectItem": "选择一个条目开始编辑，或点击＋新增。",
+  "Uiux.Panel.MissingSelection": "原选中变量已删除；草稿保留，可撤销删除恢复，或放弃草稿。",
+  "Uiux.Panel.Unapplied": "未应用",
+  "Uiux.Panel.DeleteBlocked": "角色仍被引用，或引用检查尚未完成",
+  "Uiux.I18n.Languages": "管理语言",
+  "Uiux.I18n.Search": "搜索原文、译文或上下文…",
+  "Uiux.I18n.All": "全部状态",
+  "Uiux.I18n.Missing": "缺译",
+  "Uiux.I18n.Review": "待复核",
+  "Uiux.I18n.Drafts": "有草稿",
+  "Uiux.I18n.Exchange": "翻译交换",
+  "Uiux.Inspector.Preview": "预览",
+  "Uiux.I18n.VisibleColumns": "勾选要显示的语言列",
+  "Uiux.I18n.SearchLanguage": "搜索语言名称或代码…",
+  "Uiux.I18n.RemoveLanguage": "从项目语言列表移除",
+  "Uiux.I18n.RemoveHint": "移除语言会保留已有翻译文件。",
+  "Uiux.I18n.RemoveSource": "请先切换开发语言，再移除此语言。",
+  "Uiux.I18n.LanguageActions": "语言操作",
+  "Uiux.I18n.ReloadCell": "放弃失败输入并重新读取",
+  "Uiux.I18n.SourceChanged": "原文已变更",
+  "Form.Flipbook.Columns": "列数",
+  "Form.Flipbook.Rows": "行数",
+  "Form.Flipbook.FrameCount": "总帧数",
+  "Form.Flipbook.Index": "当前帧（从 0 开始）",
+  "Form.FlipbookInvalid": "行列数和帧数必须为正整数，总帧数不能超过网格容量。",
+  "Entry.Parameter.loopCount": "播放次数（0 为无限）",
+  "Entry.Parameter.completion": "播放结束后",
+  "Entry.Option.discard": "丢弃播放项",
+  "Entry.Option.requeueTail": "放回队尾",
+  "Scene.Impact.Title": "检查场景影响",
+  "Scene.Impact.Message": "此操作会改变场景对象或引用的可用性。已有引用会保留；缺少目标仍是警告，可以保存。",
+  "Scene.Impact.Continue": "继续操作",
+  "Scene.Impact.Groups": "{0} 个 Group 的出口状态将改变。",
+  "Scene.Impact.Incomplete": "分析尚不完整，可能还有其他引用或影响。",
+  "Scene.Diagnostic.scene.reference.resolved": "此位置的目标可用。",
+  "Scene.Diagnostic.scene.reference.missing": "此位置没有可匹配的目标。",
+  "Scene.Diagnostic.scene.reference.possible": "目标可能只在部分执行路径中存在。",
+  "Scene.Diagnostic.scene.reference.uncertain": "无法完整判断目标的可用性。",
+  "Scene.Diagnostic.scene.reference.unreachable": "当前根节点无法到达此 Group。",
+  "Scene.Diagnostic.scene.coverage.unknown": "此 Entry 尚无内置场景关系声明。",
+  "Scene.Diagnostic.scene.coverage.structure": "场景关系结构无法完整分析。",
+  "Scene.Diagnostic.scene.analysis.limit": "场景分析已达到安全上限。",
+  "Error.entry.impactChanged": "检查期间作者内容已改变，请重新检查操作影响。",
+  "Entry.MovePending": "条目已标记待移动，粘贴后完成移动。",
+  "Entry.MoveFallback": "移动凭据已失效或不属于本项目，本次按复制粘贴并分配新身份。",
+  "Entry.MoveCancel": "取消移动",
+  "Scene.Impact.Inputs": "{0} 项未提交输入将归档到 Problems，不再阻止保存。",
+  "Uiux.Draft.Archived": "输入已归档：目标不存在或基线不匹配。可复制文本后明确丢弃。",
+  "Uiux.Draft.Recoverable": "目标已恢复，可通过新字段绑定恢复输入；归档不阻止保存。",
+  "Uiux.Draft.RestoreRequested": "已请求恢复。打开或展开对应字段即可恢复输入。",
+  "Uiux.Draft.Restore": "恢复输入",
+  "Error.entry.archiveFull": "输入恢复区已满，请先在 Problems 中复制或丢弃归档，再删除更多条目。",
+  "Error.entry.archiveUnavailable": "输入恢复区不可用，请先保留并修复 .galnet/editor/input-archive.json。",
+  "Error.entry.archiveChanged": "归档输入与当前作者目标不匹配，请先复制文本再丢弃。",
+  "Settings.Project.AudioBuses": "音频总线",
+  "Settings.Project.AddGroup": "添加分组",
+  "Settings.Project.RemoveGroup": "删除分组",
+  "Settings.Project.GroupId": "分组 ID（可留空）",
+  "Settings.Project.PreserveAudio": "快进回放后保留音频",
+  "Entry.Parameter.targetId": "目标 ID",
+  "Entry.Parameter.scope": "作用范围",
+  "Entry.Option.track": "轨道",
+  "Entry.Option.bus": "总线",
+  "Settings.Project.BusId": "总线 ID（可留空）",
+  "Audio.Effect": "音频效果",
+  "Audio.EffectType": "效果类型",
+  "Audio.Target": "作用目标",
+  "Audio.Parameters": "效果参数",
+  "Audio.AllEffects": "全部效果",
+  "Audio.AnalysisIncomplete": "分析不完整，列表可能不包含全部效果。",
+  "Audio.SelectEffect": "请选择类型明确的效果；未知数据已保留。",
+  "Audio.UnchangedParameters": "未指定的参数保持不变。",
+  "Entry.Type.audio.seffect.update": "更新音频效果",
+  "Audio.Type.seffect.gain": "增益",
+  "Audio.Type.seffect.lowPass": "低通",
+  "Audio.Type.seffect.highPass": "高通",
+  "Audio.Type.seffect.reverb": "混响",
+  "Audio.Parameter.gain": "增益",
+  "Audio.Parameter.cutoffHz": "截止频率 (Hz)",
+  "Audio.Parameter.q": "Q 值",
+  "Audio.Parameter.roomSize": "空间大小",
+  "Audio.Parameter.decaySeconds": "衰减时间 (秒)",
+  "Audio.Parameter.damping": "高频阻尼",
+  "Audio.Parameter.mix": "干湿比例",
+  "Problem.Value.Required": "请填写“{0}”，然后按 Enter 或移开焦点确认。",
+  "Problem.Value.Type": "“{0}”需要{1}，请检查输入格式。",
+  "Problem.Value.Range": "“{0}”超出范围，请输入 {2} 到 {3} 之间的值。",
+  "Problem.Value.Finite": "“{0}”需要有限数值，请减小数值或检查指数。",
+  "Problem.Value.Null": "“{0}”不能为 null，请填写有效值或重置字段。",
+  "Problem.Value.Option": "“{0}”的值不在可用选项中，请重新选择。",
+  "Problem.Value.Length": "“{0}”的内容长度或数量不符合要求，请检查字段内容。",
+  "Problem.Value.Spin": "“{0}”无法按当前步长调整，请直接输入精确数值。",
+  "Problem.Value.Conflict": "“{0}”的来源已变化。请保留需要的文字，再取消旧输入后重新编辑。",
+  "Problem.Value.Invalid": "“{0}”暂时无法使用，请检查内容；详细原因可在技术详情中查看。",
+  "Problem.Kind.Number": "数字（例如 0.3）",
+  "Problem.Kind.Integer": "整数",
+  "Problem.Kind.Text": "文本",
+  "Problem.Kind.Boolean": "布尔值",
+  "Problem.Kind.Json": "完整且类型正确的值",
+  "Problem.Source.Entry": "{0} / 第 {1} 条 · {2}",
+  "Problem.Entry.Compile": "此条目的参数或组合配置无法编译，请检查参数及技术详情。",
+  "Problem.Entry.UnknownType": "此条目的类型不在当前项目契约中，请重新选择类型或检查契约。",
+  "Problem.Condition": "条件表达式无法解析，请检查括号、运算符和变量写法。",
+  "Problem.Generic": "当前内容未通过检查，请检查对应位置及技术详情。",
+  "Problem.Localization.Opaque": "无法检查此字段内部的文本或角色引用：缺少字段结构定义。这不代表字段值有错。",
+  "Problem.Details": "技术详情",
+  "Problem.Navigate": "定位到问题位置",
+  "Problem.Unavailable": "原位置已不存在或当前无法打开；请重新检查。",
+  "Problem.Checking": "正在自动检查…",
+  "Problem.CheckFailed": "检查未能完成，请重新检查；详细原因见技术详情。",
+  "Problem.NumericFallback": "此字段使用精确文字输入；当前类型或范围不适合滑块/步长调整。",
+  "Problem.Value.Minimum": "“{0}”不能小于 {2}，请调整数值。",
+  "Problem.Value.Maximum": "“{0}”不能大于 {3}，请调整数值。",
+  "Form.MapKey": "键",
+  "Form.MapKeyDuplicate": "已存在相同名称的键，请换一个名称。",
+  "Entry.Type.custom.invoke": "调用自定义操作",
+  "Entry.Type.audio.mix.set": "设置音频混音音量",
+  "Entry.Category.custom": "自定义",
+  "Settings.ExpandNewEntries": "新条目默认展开参数",
+  "Entry.Parameter.action": "操作",
+  "Entry.Parameter.argument": "参数",
+  "Entry.Parameter.muted": "静音",
+  "Entry.Category.variants": "图片差分",
+  "Entry.Parameter.all": "全部",
+  "Entry.Parameter.amplitude": "振幅",
+  "Entry.Parameter.anchorX": "锚点 X",
+  "Entry.Parameter.anchorY": "锚点 Y",
+  "Entry.Parameter.angle": "角度",
+  "Entry.Parameter.cycles": "循环次数",
+  "Entry.Parameter.flashOpacity": "闪光不透明度",
+  "Entry.Parameter.flicker": "闪烁",
+  "Entry.Parameter.maskAsset": "遮罩资源",
+  "Entry.Parameter.radius": "半径",
+  "Entry.Parameter.rotationDegrees": "旋转",
+  "Entry.Parameter.scale": "缩放",
+  "Entry.Parameter.softness": "柔和度",
+  "Entry.Parameter.speed": "速度",
+  "Entry.Parameter.motion": "动作",
+  "Entry.Parameter.center": "中心",
+  "Entry.Parameter.blurProgram": "模糊程序"
 }
diff --git a/src/Editor/GalNet.Editor/Models/Graph/EntryParameterSchema.cs b/src/Editor/GalNet.Editor/Models/Graph/EntryParameterSchema.cs
index 532aca70..9336f1ae 100644
--- a/src/Editor/GalNet.Editor/Models/Graph/EntryParameterSchema.cs
+++ b/src/Editor/GalNet.Editor/Models/Graph/EntryParameterSchema.cs
@@ -7,6 +7,7 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
+using GalNet.Editor.Abstraction.Schemas;
 using GalNet.Editor.Models;
 using GalNet.Editor.Services;
 using GalNet.Game.Controls.Forms;
@@ -22,6 +23,14 @@ public interface IEntryFieldOrigin
     string EntryId { get; }
 }
 
+/// <summary>Dependent fields submit one author intent, preserving sibling and extension values.</summary>
+public interface IEntryParameterPatchOrigin : IEntryFieldOrigin
+{
+    string EntryType { get; }
+    IReadOnlyDictionary<string, JsonElement> Parameters { get; }
+    Task<ValueIssue?> CommitPatchAsync(IReadOnlyDictionary<string, FieldValue> patch, CancellationToken token);
+}
+
 /// <summary>Schema-driven edits read the author document directly; no DTO snapshot or synchronization is needed.</summary>
 public sealed class EntryParameterFormBinding : IDisposable
 {
@@ -49,12 +58,17 @@ public EntryParameterFormBinding(EntryEditorItemViewModel owner, IReadOnlyList<F
     public void Refresh() { if (!_disposed) _changed?.Invoke(this, EventArgs.Empty); }
     public void Dispose() { _disposed = true; _changed = null; }
 
-    private sealed class DocumentField(EntryParameterFormBinding form, FieldDescriptor field) : IFieldBinding, IEntryFieldOrigin
+    private sealed class DocumentField(EntryParameterFormBinding form, FieldDescriptor field) : IFieldBinding, IEntryParameterPatchOrigin
     {
         public FieldDraftState? Draft => GetDraft();
-        private FieldDraftState? GetDraft() => form._owner.EditSession?.Get(form._owner, field);
+        private FieldDraftState? GetDraft() => form.IsCurrent ? form._owner.EditSession?.Get(form._owner, field) : null;
         public string? GroupId => form._owner.AuthorGroupId;
         public string EntryId => form._owner.StableId;
+        public string EntryType => form._owner.Type;
+        public IReadOnlyDictionary<string, JsonElement> Parameters => form._owner.Source.Parameters;
+        public Task<ValueIssue?> CommitPatchAsync(IReadOnlyDictionary<string, FieldValue> patch, CancellationToken token) => !form.IsCurrent
+            ? Task.FromResult<ValueIssue?>(new("entry.obsolete", "Entry schema has changed."))
+            : form._owner.CommitParametersAsync(patch.ToDictionary(pair => pair.Key, pair => (form.Fields.Single(field => field.Id == pair.Key), pair.Value)), token);
         public object HostContext => this;
         public object? Label => SceneFieldSemantics.Label(form._owner.Type, @field.Id) ?? @field.LabelKey ?? "Entry.Parameter." + @field.Id;
         public bool IsEnabled => form.IsCurrent;
@@ -131,10 +145,15 @@ public virtual void RefreshValue(string value)
 
 /// <summary>Field adapter submits through the project's explicit Entry intent.</summary>
 public sealed class SchemaEntryParameterEditorItemViewModel(EntryParameterDefinition definition, EntryEditorItemViewModel owner,
-    Action<string, string> set) : EntryParameterEditorItemViewModel(definition, "", [], set), IFieldBinding, IEntryFieldOrigin
+    Action<string, string> set) : EntryParameterEditorItemViewModel(definition, "", [], set), IFieldBinding, IEntryParameterPatchOrigin
 {
     public string? GroupId => owner.AuthorGroupId;
     public string EntryId => owner.StableId;
+    public string EntryType => owner.Type;
+    public IReadOnlyDictionary<string, JsonElement> Parameters => owner.Source.Parameters;
+    public Task<ValueIssue?> CommitPatchAsync(IReadOnlyDictionary<string, FieldValue> patch, CancellationToken token) => !IsEnabled
+        ? Task.FromResult<ValueIssue?>(new("entry.obsolete", "Entry schema has changed."))
+        : owner.CommitParametersAsync(patch.ToDictionary(pair => pair.Key, pair => (owner.DetailForm!.Fields.Single(field => field.Id == pair.Key), pair.Value)), token);
     public object HostContext => this;
     public bool IsEnabled => owner.IsCurrent && owner.Type == _type && owner.ParameterFields.Contains(this);
     public bool CanReset => owner.Type != GalNet.Contracts.Builtins.BuiltinEntryIds.PlayTimeline || Id != "timeline" || Definition.Field.DefaultValue is not null;
diff --git a/src/Editor/GalNet.Editor/Models/Graph/GraphPresentationModels.cs b/src/Editor/GalNet.Editor/Models/Graph/GraphPresentationModels.cs
index fdde0b5e..3cfcb58d 100644
--- a/src/Editor/GalNet.Editor/Models/Graph/GraphPresentationModels.cs
+++ b/src/Editor/GalNet.Editor/Models/Graph/GraphPresentationModels.cs
@@ -9,16 +9,16 @@
 using Avalonia.Media;
 using CommunityToolkit.Mvvm.ComponentModel;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
 using GalNet.Core.Graph;
 using GalNet.Core.Parameters;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
 using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Abstraction.Schemas;
 using GalNet.Editor.Controls;
 using GalNet.Editor.Services;
 using GalNet.Game.Controls.Forms;
-using GalNet.Primitives.Builtins;
 
 namespace GalNet.Editor.Models.Graph;
 
@@ -54,6 +54,18 @@ public partial class GraphNode : ObservableObject
     private double _y;
 
     private string _name = "";
+    private string _storyPackage = "";
+    public Action<string>? StoryPackageRequested { get; set; }
+    public string StoryPackage
+    {
+        get => _storyPackage;
+        set
+        {
+            if (_storyPackage == value) return;
+            if (StoryPackageRequested is { } update) { update(value); return; }
+            if (SetProperty(ref _storyPackage, value)) Source.StoryPackage = value.Length == 0 ? null : value;
+        }
+    }
     public Action<string>? RenameRequested { get; set; }
     public string Name
     {
@@ -99,6 +111,7 @@ private void RefreshBranchItems()
     public void RefreshAuthorValues()
     {
         SetProperty(ref _name, Source.Name, nameof(Name));
+        SetProperty(ref _storyPackage, Source.StoryPackage ?? "", nameof(StoryPackage));
         X = Source.X;
         Y = Source.Y;
         RefreshBranchItems();
@@ -158,6 +171,7 @@ public GraphNode(EditorGraphNodeDto source, GraphNodeKind nodeKind)
         Source = source;
         NodeKind = nodeKind;
         _name = source.Name;
+        _storyPackage = source.StoryPackage ?? "";
         _x = source.X;
         _y = source.Y;
 
@@ -357,6 +371,15 @@ public EntryEditorItemViewModel(EditorEntryData source, IEntryCatalog catalog)
     private string? _groupId;
     private SceneTargetCatalog? _scenes;
     private int _schemaGeneration;
+    internal Guid DraftIncarnation { get; private set; } = Guid.NewGuid();
+    internal Func<EntryEditorItemViewModel> DraftOwnerFactory()
+    {
+        var source = Source; var catalog = _authorCatalog; var authoring = _authoring; var group = _groupId;
+        var incarnation = DraftIncarnation; var parameters = _formParameters;
+        // Capture only neutral author data and project services, never this projection or its forms.
+        return () => new EntryEditorItemViewModel(source, catalog!) { _authoring = authoring, _groupId = group, DraftIncarnation = incarnation, _formParameters = parameters };
+    }
+    internal void RefreshSummary() { OnPropertyChanged(nameof(Summary)); ParameterForm?.Refresh(); _detailForm?.Refresh(); _effectInlineForm?.Refresh(); }
     internal void BindAuthoring(string groupId, EntryFieldAuthoringService authoring, SceneTargetCatalog? scenes) { _groupId = groupId; _authoring = authoring; _scenes = scenes; }
     internal IReadOnlyList<FieldEditorOption>? SceneOptions(string field) => _scenes?.FieldOptions(_groupId!, StableId, Type, field);
     internal bool IsSceneOutput(string field) => SceneFieldSemantics.IsOutput(Type, field);
@@ -364,17 +387,20 @@ public EntryEditorItemViewModel(EditorEntryData source, IEntryCatalog catalog)
     internal bool IsCurrent => !_disposed && (_authoring is null || _authoring.IsCurrent(_groupId!, Source));
     internal void RefreshAuthorReferences(IEntryCatalog catalog)
     {
+        SetProperty(ref _id, Source.Id, nameof(Id));
         var values = Source.GetParameterText(catalog);
         var parametersChanged = !_parameters.OrderBy(pair => pair.Key).SequenceEqual(values.OrderBy(pair => pair.Key));
         _parameters = values;
-        if (_type != Source.Type) InvalidateParameterFields();
+        if (_type != Source.Type) InvalidateAuthorBindings();
         SetProperty(ref _type, Source.Type, nameof(Type));
+        OnPropertyChanged(nameof(IsEffectApply));
         SetProperty(ref _condition, Source.Condition, nameof(Condition));
         if (parametersChanged) OnPropertyChanged(nameof(Parameters));
         OnPropertyChanged(nameof(HasUnknownParameters));
         foreach (var field in ParameterFields) field.RefreshValue(Parameters.GetValueOrDefault(field.Id, field.Definition.DefaultValue));
         ParameterForm?.Refresh();
         _detailForm?.Refresh();
+        _effectInlineForm?.Refresh();
         OnPropertyChanged(nameof(DetailForm));
         OnPropertyChanged(nameof(Summary));
         OnPropertyChanged(nameof(HasCondition));
@@ -392,12 +418,12 @@ public string Type
         set
         {
             if (Type == value) return;
-            if (_authoring is not null) ChangeAuthorType(value, _authorCatalog!.Create(value).Values);
+            if (_authoring is not null) ChangeAuthorType(value, EditorEntryData.CreateParameters(_authorCatalog!, value));
             else { Source.Type = value; SetProperty(ref _type, value); }
         }
     }
-    internal void ChangeAuthorType(string type, IReadOnlyDictionary<string, string> parameters) =>
-        _authoring!.SetType(_groupId!, Source, type, EditorEntryData.ParseParameters(_authorCatalog!, type, parameters));
+    internal void ChangeAuthorType(string type, IReadOnlyDictionary<string, JsonElement> parameters) =>
+        _authoring!.SetType(_groupId!, Source, type, parameters.ToDictionary(pair => pair.Key, pair => pair.Value.Clone(), StringComparer.Ordinal));
     public string Condition
     {
         get => Source.Condition;
@@ -432,11 +458,16 @@ public Dictionary<string, string> Parameters
     private DynamicParameterTable? _formParameters;
     [ObservableProperty] private EntryParameterFormBinding? _parameterForm;
     private EntryParameterFormBinding? _detailForm;
+    private EntryParameterFormBinding? _effectInlineForm;
     public EntryParameterFormBinding? DetailForm => ParameterForm ?? _detailForm;
-    public string Summary => EditSession?.Summary(this) ?? string.Join(" · ", Source.Parameters.Where(pair => pair.Key is "content" or "speaker" or "asset" or "assetId" or "target" or "expression" or "handleId")
-        .Select(pair => pair.Value.ValueKind == JsonValueKind.String ? pair.Value.GetString() : pair.Value.GetRawText()).Where(value => !string.IsNullOrEmpty(value))).Replace('\n', ' ');
+    public EntryParameterFormBinding? EffectInlineForm => _effectInlineForm;
+    public bool IsEffectApply => Type == BuiltinEntryIds.ApplyEffect;
+    public string Summary => EditSession?.Summary(this) ?? FormatSummary();
+    internal string FormatSummary(Func<string, string?>? text = null) => EntrySummaryFormatter.Build(Source, text, _scenes, _groupId);
     public bool HasCondition => !string.IsNullOrWhiteSpace(Condition);
     [ObservableProperty] private int _problemCount;
+    [ObservableProperty] private bool _hasProblemErrors;
+    [ObservableProperty] private bool _isPendingMove;
     public bool HasProblems => ProblemCount > 0;
     partial void OnProblemCountChanged(int value) => OnPropertyChanged(nameof(HasProblems));
     public bool HasParameterForm => ParameterForm is not null;
@@ -445,7 +476,7 @@ public Dictionary<string, string> Parameters
 
     public ObservableCollection<EntryParameterEditorItemViewModel> ParameterFields { get; } = [];
     public bool IsUnknownType => _authorCatalog is not null && !_authorCatalog.TryGet(Type, out _);
-    public bool HasUnknownParameters => _authorCatalog is not null && _authorCatalog.TryGet(Type, out var schema) && Source.Parameters.Keys.Any(key => !schema.Parameters.ContainsKey(key));
+    public bool HasUnknownParameters => _authorCatalog is not null && _authorCatalog.TryGet(Type, out var schema) && Source.Parameters.Keys.Any(key => !schema.DynamicParameters.ContainsKey(key));
     /// <summary>Builds the editor projection from the Core registry, the single schema source.</summary>
     public void ConfigureParameterFields(IEntryCatalog catalog, IReadOnlyList<string> speakers, IReadOnlyList<string> variableNames, IEffectCatalog? effectCatalog = null)
     {
@@ -455,6 +486,7 @@ public void ConfigureParameterFields(IEntryCatalog catalog, IReadOnlyList<string
         ParameterForm?.Dispose();
         ParameterForm = null;
         _detailForm?.Dispose(); _detailForm = null;
+        _effectInlineForm?.Dispose(); _effectInlineForm = null;
         _formParameters = null;
         _effectCatalog = effectCatalog;
         _schemaGeneration++;
@@ -462,14 +494,17 @@ public void ConfigureParameterFields(IEntryCatalog catalog, IReadOnlyList<string
         OnPropertyChanged(nameof(IsUnknownType));
         OnPropertyChanged(nameof(HasUnknownParameters));
         if (!catalog.TryGet(Type, out var schema)) { UpdateEffectHints(); return; }
-        var parameters = schema.DynamicParameters ?? EntrySchema.DynamicParameters(schema.Parameters, schema.Defaults, schema.Options);
+        var parameters = schema.DynamicParameters;
         _detailForm = new EntryParameterFormBinding(this, parameters.Fields, schema.FieldDataType);
+        if (IsEffectApply && parameters.Fields.FirstOrDefault(field => field.Id == "program") is { } program)
+            _effectInlineForm = new EntryParameterFormBinding(this, [program], schema.FieldDataType);
         OnPropertyChanged(nameof(DetailForm));
+        OnPropertyChanged(nameof(EffectInlineForm));
 
         if (schema.FieldDataType is not null)
         {
             _formParameters = parameters;
-            if (!schema.Parameters.Any(pair => UsesDedicatedEditor(parameters[pair.Key].Field, pair.Value)))
+            if (!parameters.Values.Any(parameter => UsesDedicatedEditor(parameter.Field, EntrySchema.GetEditorType(parameter))))
             {
                 ParameterForm = new EntryParameterFormBinding(this, parameters.Fields, schema.FieldDataType);
                 UpdateEffectHints();
@@ -477,12 +512,15 @@ public void ConfigureParameterFields(IEntryCatalog catalog, IReadOnlyList<string
             }
         }
 
-        foreach (var (id, type) in schema.Parameters)
+        foreach (var parameter in parameters.Values)
         {
-            var defaultValue = schema.Defaults.GetValueOrDefault(id, "");
+            var id = parameter.Name;
+            var type = EntrySchema.GetEditorType(parameter);
+            var defaultValue = parameter.DefaultValue is { } fallback ? ValueCodec.ToEditorText(parameter.Value, fallback) : "";
             var options = (Type == BuiltinEntryIds.ApplyEffect && id == "id" && effectCatalog is not null
                     ? effectCatalog.Definitions.Select(definition => definition.Id).ToArray()
-                    : schema.Options.GetValueOrDefault(id, []))
+                    : parameter.TryGetConstraint("enum", out var choices) ? choices.EnumerateArray().Select(value => ValueCodec.ToEditorText(parameter.Value, value)).ToArray()
+                        : parameter.ValueType == typeof(bool) ? new[] { "true", "false" } : [])
                 .Select(value => new EntrySelectOption(value, $"Entry.Option.{(value.Length == 0 ? "None" : value)}"))
                 .ToArray();
             var source = parameters[id].Field;
@@ -495,14 +533,21 @@ public void ConfigureParameterFields(IEntryCatalog catalog, IReadOnlyList<string
         UpdateEffectHints();
     }
 
+    internal void InvalidateAuthorBindings()
+    {
+        DraftIncarnation = Guid.NewGuid();
+        InvalidateParameterFields();
+    }
     internal void InvalidateParameterFields()
     {
         _detailForm?.Dispose(); _detailForm = null;
+        _effectInlineForm?.Dispose(); _effectInlineForm = null;
         _schemaGeneration++;
         ParameterForm?.Dispose();
         ParameterForm = null;
         ParameterFields.Clear();
         OnPropertyChanged(nameof(DetailForm));
+        OnPropertyChanged(nameof(EffectInlineForm));
     }
 
     private static bool UsesDedicatedEditor(FieldDescriptor field, EntryParameterType type) =>
@@ -533,7 +578,7 @@ private EntryParameterEditorItemViewModel CreateField(EntryParameterDefinition d
     private void SetParameter(string id, string value)
     {
         var updated = Source.Parameters.ToDictionary(pair => pair.Key, pair => pair.Value.Clone(), StringComparer.Ordinal);
-        var field = _authorCatalog!.Get(Type).DynamicParameters![id].Field;
+        var field = _authorCatalog!.Get(Type).DynamicParameters[id].Field;
         if (value.Length == 0 && (!field.IsRequired || field.DefaultValue is not null) &&
             field.Editor?.EditorId is "entry.imageasset" or "entry.audioasset" or "entry.videoasset" or "entry.effectprogramasset") updated.Remove(id);
         else updated[id] = ValueCodec.ParseEditorText(field.Value, value);
@@ -600,6 +645,7 @@ public void Dispose()
         if (_disposed) return;
         _disposed = true;
         _detailForm?.Dispose();
+        _effectInlineForm?.Dispose();
         ParameterForm?.Dispose();
         ParameterFields.Clear();
         GC.SuppressFinalize(this);
diff --git a/src/Editor/GalNet.Editor/Models/ProjectFileItem.cs b/src/Editor/GalNet.Editor/Models/ProjectFileItem.cs
index 1035d672..407e136f 100644
--- a/src/Editor/GalNet.Editor/Models/ProjectFileItem.cs
+++ b/src/Editor/GalNet.Editor/Models/ProjectFileItem.cs
@@ -14,7 +14,21 @@ public sealed partial class ProjectFileItem : ObservableObject, IDisposable
     public DateTime WriteTimeUtc { get; init; }
     public string ProtectionReason { get; init; } = "";
     public bool CanEdit => ProtectionReason.Length == 0;
-    public string Icon => IsDirectory ? "📁" : Type == "sprite" ? "▧" : Type == "audio" ? "♫" : Type == "video" ? "▷" : "▤";
+    public Avalonia.Media.Geometry IconGeometry => Avalonia.Media.Geometry.Parse("F0 " + (IsDirectory ? DirectoryIcon(Name) : Type switch
+    {
+        "sprite" => "M3 3H21V21H3ZM5 17L9 12L12 15L15 11L19 17Z",
+        "audio" => "M10 4L20 2V15A3 3 0 1 1 18 12.2V6L12 7V17A3 3 0 1 1 10 14.2Z",
+        "video" => "M3 5H21V19H3ZM10 8V16L16 12Z",
+        _ when Name.Equals("settings.json", StringComparison.OrdinalIgnoreCase) => "M12 2L14 4L17 4L18 7L21 9L20 12L21 15L18 17L17 20L14 20L12 22L10 20L7 20L6 17L3 15L4 12L3 9L6 7L7 4L10 4ZM12 8A4 4 0 1 0 12 16A4 4 0 1 0 12 8Z",
+        _ => "M4 3H15L20 8V21H4ZM14 4V9H19ZM7 12H17V14H7ZM7 16H17V18H7Z"
+    }));
+    internal static string DirectoryIcon(string name) => name.ToLowerInvariant() switch
+    {
+        "assets" => "M2 5H10L12 7H22V19H2ZM7 16L10 12L12 14L15 11L19 16Z",
+        "contracts" => "M2 5H10L12 7H22V19H2ZM8 10H16V12H8ZM8 14H16V16H8Z",
+        "i18n" => "M2 5H10L12 7H22V19H2ZM8 10H16V12H8ZM11 9H13V17H11Z",
+        _ => "M2 5H10L12 7H22V19H2Z"
+    };
     [ObservableProperty] private Bitmap? _thumbnail;
     [ObservableProperty] private bool _isRenaming;
     [ObservableProperty] private bool _isDropTarget;
@@ -25,6 +39,7 @@ public sealed partial class ProjectDirectoryNode(string path, string name, Func<
 {
     public string Path { get; } = path;
     public string Name { get; } = name;
+    public Avalonia.Media.Geometry IconGeometry => Avalonia.Media.Geometry.Parse("F0 " + ProjectFileItem.DirectoryIcon(Name));
     public ObservableCollection<ProjectDirectoryNode> Children { get; } = hasChildren ? [new(path, "…", _ => [], false)] : [];
     private bool _loaded = !hasChildren;
     [ObservableProperty] private bool _isExpanded;
diff --git a/src/Editor/GalNet.Editor/Program.cs b/src/Editor/GalNet.Editor/Program.cs
index 0f16d0e4..fb7d8ccd 100644
--- a/src/Editor/GalNet.Editor/Program.cs
+++ b/src/Editor/GalNet.Editor/Program.cs
@@ -16,36 +16,61 @@ sealed class Program
     [STAThread]
     public static void Main(string[] args)
     {
-        Log.Logger = new LoggerConfiguration()
-            .MinimumLevel.Debug()
-            .WriteTo.Console(
-                formatProvider: CultureInfo.InvariantCulture,
-                outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
-            .WriteTo.Debug(
-                formatProvider: CultureInfo.InvariantCulture,
-                outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
-            .WriteTo.Sink(EditorLogSink.Instance)
-            .CreateLogger();
+#if BENCHMARK
+        GalNet.Diagnostics.StartupBenchmark.Start();
+#endif
+        {
+#if BENCHMARK
+            using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.Logging");
+#endif
+            Log.Logger = new LoggerConfiguration()
+                .MinimumLevel.Debug()
+                .WriteTo.Console(
+                    formatProvider: CultureInfo.InvariantCulture,
+                    outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
+                .WriteTo.Debug(
+                    formatProvider: CultureInfo.InvariantCulture,
+                    outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
+                .WriteTo.Sink(EditorLogSink.Instance)
+                .CreateLogger();
+        }
 
         try
         {
             Log.Information("GalNet Editor starting");
-            BuildAvaloniaApp()
-                .StartWithClassicDesktopLifetime(args);
+            using var preparation = new EditorStartupPreparation();
+            AppBuilder app;
+#if BENCHMARK
+            using (GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.ConfigureAvalonia"))
+#endif
+            app = ConfigureApp(AppBuilder.Configure(() => new App { Preparation = preparation }));
+#if BENCHMARK
+            GalNet.Diagnostics.CpuProfiler.Shared.Mark("Editor.RunAvalonia");
+#endif
+            app.StartWithClassicDesktopLifetime(args);
         }
         catch (Exception ex)
         {
             Log.Fatal(ex, "Application terminated unexpectedly");
+#if BENCHMARK
+            GalNet.Diagnostics.StartupBenchmark.Complete(false);
+#endif
         }
         finally
         {
             Log.CloseAndFlush();
+#if BENCHMARK
+            if (GalNet.Diagnostics.StartupBenchmark.Failed) Environment.ExitCode = 1;
+#endif
         }
     }
 
     // Avalonia configuration, don't remove; also used by visual designer.
     public static AppBuilder BuildAvaloniaApp()
-        => AppBuilder.Configure<App>()
+        => ConfigureApp(AppBuilder.Configure<App>());
+
+    private static AppBuilder ConfigureApp(AppBuilder builder)
+        => builder
             .UsePlatformDetect()
             .UseManagedWindows(false)
             .UseFloatingWindowHostMode(DockFloatingWindowHostMode.Native)
diff --git a/src/Editor/GalNet.Editor/Properties/PublishProfiles/WindowsReadyToRun.pubxml b/src/Editor/GalNet.Editor/Properties/PublishProfiles/WindowsReadyToRun.pubxml
new file mode 100644
index 00000000..c7276fff
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Properties/PublishProfiles/WindowsReadyToRun.pubxml
@@ -0,0 +1,10 @@
+<Project>
+  <PropertyGroup>
+    <Configuration>Release</Configuration>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <SelfContained>false</SelfContained>
+    <PublishReadyToRun>true</PublishReadyToRun>
+    <PublishSingleFile>false</PublishSingleFile>
+    <PublishTrimmed>false</PublishTrimmed>
+  </PropertyGroup>
+</Project>
diff --git a/src/Editor/GalNet.Editor/Services/AssetCatalogService.cs b/src/Editor/GalNet.Editor/Services/AssetCatalogService.cs
index 16d81d43..5f43e880 100644
--- a/src/Editor/GalNet.Editor/Services/AssetCatalogService.cs
+++ b/src/Editor/GalNet.Editor/Services/AssetCatalogService.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using GalNet.Contracts.Builtins.Assets;
 using GalNet.Core.Assets;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Models;
@@ -60,8 +61,13 @@ public async Task RefreshAsync(CancellationToken cancellationToken = default)
         await _refreshGate.WaitAsync(cancellationToken);
         try
         {
-            var root = RootOrNull(); if (root is null) return;
-            while (_projects.Current?.Services.GetService(typeof(IProjectContentSession)) is IProjectContentSession { IsPublishing: true }) await Task.Delay(25, cancellationToken);
+            var project = _projects.Current; if (project is null) return;
+            IProjectContentSession? content;
+            try { content = project.Services.GetService(typeof(IProjectContentSession)) as IProjectContentSession; }
+            catch (ObjectDisposedException) { return; }
+            while (ReferenceEquals(_projects.Current, project) && (content is { IsPublishing: true } || Shared.Services.ExternalProjectSnapshotReader.HasPendingTransaction(project.RootPath)))
+                await Task.Delay(25, cancellationToken);
+            if (!ReferenceEquals(_projects.Current, project)) return;
             Changed?.Invoke();
         }
         finally { _refreshGate.Release(); }
@@ -110,7 +116,7 @@ private AssetEntry CreateFile(string fullPath)
         try
         {
             var metaPath = file + ".meta";
-            return File.Exists(metaPath) ? _metaCodec.Deserialize(File.ReadAllText(metaPath)) : null;
+            return File.Exists(metaPath) ? _metaCodec.Deserialize(File.ReadAllText(metaPath), Relative(file)) : null;
         }
         catch { return null; }
     }
diff --git a/src/Editor/GalNet.Editor/Services/AuthorNavigationService.cs b/src/Editor/GalNet.Editor/Services/AuthorNavigationService.cs
index a5fbb483..102fcfa4 100644
--- a/src/Editor/GalNet.Editor/Services/AuthorNavigationService.cs
+++ b/src/Editor/GalNet.Editor/Services/AuthorNavigationService.cs
@@ -1,25 +1,41 @@
 using GalNet.Editor.Dock;
+using GalNet.Editor.Services.Interfaces;
 using GalNet.Editor.ViewModels;
 
 namespace GalNet.Editor.Services;
 
-public sealed record AuthorNavigationTarget(string? NodeId = null, string? EntryId = null, string? FieldId = null, string? File = null, long? Revision = null);
+public sealed record AuthorNavigationTarget(string? NodeId = null, string? EntryId = null, string? FieldId = null, string? File = null, long? Revision = null,
+    IReadOnlyList<string>? FieldPath = null);
 
 /// <summary>Resolves stable author identities at navigation time; never follows an old row index.</summary>
-public sealed class AuthorNavigationService(EditorWorkspaceViewModel workspace, EditorDockFactory dock, ProjectTextFiles files)
+public sealed class AuthorNavigationService(EditorWorkspaceViewModel workspace, EditorDockFactory dock, ProjectTextFiles files, IEditorWindowFactory? windows = null)
 {
     public event Action<AuthorNavigationTarget>? Requested;
+    public bool CanNavigate(AuthorNavigationTarget target)
+    {
+        if (target.NodeId is { } nodeId)
+        {
+            var node = workspace.Nodes.FirstOrDefault(item => item.Id == nodeId);
+            return node is not null && (target.EntryId is null || node.Entries.Any(item => item.StableId == target.EntryId));
+        }
+        return target.File is { } path && files.CanOpen(path);
+    }
     public bool Navigate(AuthorNavigationTarget target)
     {
+        if (!CanNavigate(target)) return false;
         if (target.NodeId is { } nodeId)
         {
             var node = workspace.Nodes.FirstOrDefault(item => item.Id == nodeId);
             if (node is null || target.EntryId is { } entryId && !node.Entries.Any(item => item.StableId == entryId)) return false;
+            var entry = node.Entries.FirstOrDefault(item => item.StableId == target.EntryId);
+            if (entry is not null) entry.IsParametersExpanded = true;
             dock.NavigateLocalization(nodeId, target.EntryId);
             dock.ShowInspector();
         }
         else if (target.File is { } path)
         {
+            if (path.Replace('\\', '/') == "Graph/graph.json") { dock.OpenPanel(EditorDockPanelIds.NodeGraph); Requested?.Invoke(target); return true; }
+            if (path == "settings.json" && windows is not null) { windows.CreateProjectSettingsWindow().Show(); Requested?.Invoke(target); return true; }
             try { var file = files.Open(path); dock.OpenFileEditor(file); }
             catch (Exception error) when (error is IOException or UnauthorizedAccessException or InvalidDataException or GalNet.Editor.Abstraction.Services.EditorOperationException)
             { return false; }
diff --git a/src/Editor/GalNet.Editor/Services/CharacterAuthoringService.cs b/src/Editor/GalNet.Editor/Services/CharacterAuthoringService.cs
index cf486fa8..52555db0 100644
--- a/src/Editor/GalNet.Editor/Services/CharacterAuthoringService.cs
+++ b/src/Editor/GalNet.Editor/Services/CharacterAuthoringService.cs
@@ -1,5 +1,6 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
+using GalNet.Contracts.Builtins;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
 using GalNet.Editor.Abstraction.Documents;
@@ -19,15 +20,18 @@ public sealed class CharacterAuthoringService(LocalizationDocumentStore store, P
     IProjectContentSession content, IEditorDocumentService documents, IEntryCatalog catalog,
     LocalizationAuthoringService authoring, IEditorLocalizationService text, GameTextAuthoringService texts)
 {
+    private const int DisplayedIncompleteIssueLimit = 5;
+    private const int LoggedIncompleteIssueLimit = 20;
     private readonly SemaphoreSlim _gate = new(1, 1);
     public IEditorLocalizationService Text => text;
     public event Action? Changed { add => content.Changed += value; remove => content.Changed -= value; }
     private LocalizationReferenceIndex Index => query.Get() ?? throw Error("character.obsolete");
     public bool Complete => query.Get()?.Complete == true;
+    public string IncompleteDetails => FormatIncompleteDetails(query.Get());
     public IReadOnlyList<CharacterRow> Rows()
     {
         var index = Index;
-        var culture = content.CaptureWorking().Settings.TargetLocale.Code;
+        var culture = content.CaptureWorking().Configuration.ReadDefaultOptions().TargetLocale.Code;
         var counts = index.References.Where(reference => reference.Semantic == FieldValueSemantic.CharacterReference)
             .GroupBy(reference => reference.Key, StringComparer.Ordinal).ToDictionary(group => group.Key, group => group.Count(), StringComparer.Ordinal);
         return index.Characters.Select(character => new CharacterRow(character.Id, character.DisplayNameKey,
@@ -35,6 +39,24 @@ public IReadOnlyList<CharacterRow> Rows()
             counts.GetValueOrDefault(character.Id))).ToArray();
     }
     private EditorOperationException Error(string code) => new(code, text["Error." + code]);
+    private string FormatIncompleteDetails(LocalizationReferenceIndex? index)
+    {
+        if (index is null) return text["Characters.IncompleteReasonUnavailable"];
+        if (index.Complete) return "";
+        var issues = index.IncompleteIssues;
+        if (issues.Count == 0) return text["Characters.IncompleteReasonUnavailable"];
+        var lines = issues.Take(DisplayedIncompleteIssueLimit).Select(issue =>
+        {
+            var location = issue.File;
+            if (!string.IsNullOrWhiteSpace(issue.EntryId)) location += " / " + issue.EntryId;
+            if (!string.IsNullOrWhiteSpace(issue.JsonPointer)) location += " " + issue.JsonPointer;
+            return text.Format("Characters.IncompleteReason", issue.Code, location, issue.Message);
+        }).ToList();
+        if (issues.Count > DisplayedIncompleteIssueLimit)
+            lines.Add(text.Format("Characters.IncompleteMore", issues.Count - DisplayedIncompleteIssueLimit,
+                Math.Min(issues.Count, LoggedIncompleteIssueLimit)));
+        return string.Join(Environment.NewLine, lines);
+    }
     private static JsonArray ReadCatalog(LocalizationFileSnapshot snapshot)
     {
         LocalizationJson.Validate(snapshot.Path, snapshot.Data);
@@ -43,13 +65,31 @@ private static JsonArray ReadCatalog(LocalizationFileSnapshot snapshot)
     private static JsonObject Find(JsonArray array, string id) => array.Select(node => node!.AsObject()).Single(node => node["id"]!.GetValue<string>() == id);
     private async Task EnsureFilesAsync()
     {
-        var locale = content.CaptureWorking().Settings.TargetLocale.Code;
+        var locale = content.CaptureWorking().Configuration.ReadDefaultOptions().TargetLocale.Code;
         var files = new[] { store.CaptureFile(LocalizationJson.CatalogPath), store.CaptureFile($"I18n/{locale}/characters.json") };
         var missing = files.Where(file => !file.Exists).Select(file => new LocalizationFilePatch(file, file.Data)).ToArray();
         if (missing.Length > 0) await store.Prepare(missing).ApplyAsync(true);
     }
     private void ValidateName(string name) { if (string.IsNullOrWhiteSpace(name)) throw Error("character.name"); }
-    private void RequireComplete() { if (!Complete) throw Error("character.incomplete"); }
+    private void RequireComplete(string operation, string characterId)
+    {
+        var index = query.Get();
+        if (index?.Complete == true) return;
+        var issues = index?.IncompleteIssues ?? [];
+        var causes = issues.Take(LoggedIncompleteIssueLimit).Select(issue => new
+        {
+            issue.Code,
+            issue.File,
+            issue.EntryId,
+            issue.JsonPointer,
+            issue.Message
+        }).ToArray();
+        Serilog.Log.Warning(
+            "Blocked character operation {Operation} for {CharacterId}: reference analysis is incomplete. IssueCount={IssueCount}, LoggedIssueCount={LoggedIssueCount}, Causes={@Causes}",
+            operation, characterId, issues.Count, causes.Length, causes);
+        var details = FormatIncompleteDetails(index);
+        throw new EditorOperationException("character.incomplete", text.Format("Error.character.incomplete", details), details);
+    }
 
     public async Task<CharacterRow> CreateAsync(string name, string? key = null)
     {
@@ -70,7 +110,7 @@ private async Task<CharacterRow> CreateCoreAsync(string name, string? key)
         if (array.Any(node => node!["id"]!.GetValue<string>() == key)) throw Error("character.duplicate");
         var nameKey = "character." + Guid.NewGuid().ToString("N") + ".name";
         array.Add(new JsonObject { ["id"] = key, ["displayNameKey"] = nameKey });
-        var target = store.CaptureText(nameKey, newFile: $"I18n/{content.CaptureWorking().Settings.TargetLocale.Code}/characters.json");
+        var target = store.CaptureText(nameKey, newFile: $"I18n/{content.CaptureWorking().Configuration.ReadDefaultOptions().TargetLocale.Code}/characters.json");
         await content.CommitFileDraftsAsync(target.File.Id);
         var patches = new[] { new LocalizationFilePatch(file, LocalizationJson.WriteLike(file.Data, array)), store.PrepareText(target, name) };
         await authoring.ApplyAsync(store.Prepare(patches), key, "History.Character");
@@ -85,7 +125,7 @@ public async Task UpdateAsync(CharacterRow expected, string key, string name)
             ValidateName(name);
             if (string.IsNullOrWhiteSpace(key)) throw Error("character.key");
             if (Rows().Any(row => row.Id == key && row.Id != expected.Id)) throw Error("character.duplicate");
-            if (key != expected.Id) RequireComplete();
+            if (key != expected.Id) RequireComplete("change-id", expected.Id);
             var before = store.CaptureFile(LocalizationJson.CatalogPath);
             var array = ReadCatalog(before);
             var row = Rows().SingleOrDefault(row => row.Id == expected.Id);
@@ -107,7 +147,7 @@ public async Task DeleteAsync(CharacterRow expected)
         await _gate.WaitAsync();
         try
         {
-            RequireComplete();
+            RequireComplete("delete", expected.Id);
             var row = Rows().SingleOrDefault(row => row.Id == expected.Id);
             if (row is null || row.DisplayNameKey != expected.DisplayNameKey || row.Name != expected.Name) throw Error("character.changed");
             if (row.Uses > 0) throw Error("character.inUse");
@@ -123,8 +163,8 @@ public async Task<bool> CommitParametersAsync(string groupId, EditorEntryData ex
     {
         var before = expected.Parameters.ToDictionary(pair => pair.Key, pair => pair.Value.Clone(), StringComparer.Ordinal);
         var candidate = new EditorEntryData { StableId = expected.StableId, Type = type, Parameters = updated };
-        var oldRefs = References(groupId, expected).ToDictionary(reference => reference.JsonPointer, reference => reference.Key, StringComparer.Ordinal);
-        var changed = References(groupId, candidate).Where(reference => oldRefs.GetValueOrDefault(reference.JsonPointer) != reference.Key).ToArray();
+        var oldRefs = References(groupId, expected).ToDictionary(reference => reference.LocationKey, reference => reference.Key, StringComparer.Ordinal);
+        var changed = References(groupId, candidate).Where(reference => oldRefs.GetValueOrDefault(reference.LocationKey) != reference.Key).ToArray();
         if (changed.Length == 0) return false;
         await _gate.WaitAsync(cancellationToken);
         try
@@ -143,7 +183,7 @@ void Current()
                 var exact = rows.SingleOrDefault(row => row.Id == reference.Key);
                 var names = rows.Where(row => row.Name == reference.Key).ToArray();
                 if (exact is null && names.Length > 1) throw Error("character.ambiguous");
-                if (exact is not null || names.Length == 1) Set(root, reference.JsonPointer, (exact ?? names[0]).Id);
+                if (exact is not null || names.Length == 1) Set(root, reference, (exact ?? names[0]).Id);
                 else needed.TryAdd(reference.Key, "");
             }
             var filePatches = new List<LocalizationFilePatch>();
@@ -152,7 +192,7 @@ void Current()
                 await EnsureFilesAsync();
                 foreach (var name in needed.Keys.ToArray()) { needed[name] = await store.ReserveCharacterKeyAsync(); Current(); }
                 var file = store.CaptureFile(LocalizationJson.CatalogPath); var array = ReadCatalog(file);
-                var nameFile = store.CaptureFile($"I18n/{content.CaptureWorking().Settings.TargetLocale.Code}/characters.json");
+                var nameFile = store.CaptureFile($"I18n/{content.CaptureWorking().Configuration.ReadDefaultOptions().TargetLocale.Code}/characters.json");
                 await content.CommitFileDraftsAsync(nameFile.Id); Current(); nameFile = store.CaptureFile(nameFile.Path);
                 var namesBytes = nameFile.Data;
                 foreach (var (name, id) in needed)
@@ -162,7 +202,7 @@ void Current()
                     namesBytes = LocalizationJson.SetText(namesBytes, nameKey, name);
                 }
                 filePatches.Add(new(file, LocalizationJson.WriteLike(file.Data, array))); filePatches.Add(new(nameFile, namesBytes));
-                foreach (var reference in changed.Where(reference => needed.ContainsKey(reference.Key))) Set(root, reference.JsonPointer, needed[reference.Key]);
+                foreach (var reference in changed.Where(reference => needed.ContainsKey(reference.Key))) Set(root, reference, needed[reference.Key]);
             }
             Current();
             var after = root.Deserialize<Dictionary<string, JsonElement>>()!;
@@ -186,7 +226,7 @@ private IReadOnlyList<LocalizationEntryPatch> ReferencePatches(string from, stri
         {
             var entry = documents.Groups[group.Key.Owner].Entries.Single(entry => entry.StableId == group.Key.EntryId);
             var node = JsonSerializer.SerializeToNode(entry.Parameters)!.AsObject();
-            foreach (var reference in group) Set(node, reference.JsonPointer, to);
+            foreach (var reference in group) Set(node, reference, to);
             var after = node.Deserialize<Dictionary<string, JsonElement>>()!;
             ValidateParameters(entry.Type, after, entry.Parameters);
             patches.Add(new(group.Key.Owner, entry.StableId, entry.Type, entry.Parameters, after));
@@ -199,12 +239,10 @@ private void ValidateParameters(string type, IReadOnlyDictionary<string, JsonEle
         schema?.ValidatePartialArguments(JsonSerializer.SerializeToElement(values.Where(pair => schema.ContainsKey(pair.Key) &&
             (!before.TryGetValue(pair.Key, out var previous) || !JsonElement.DeepEquals(previous, pair.Value))).ToDictionary(pair => pair.Key, pair => pair.Value)));
     }
-    private static void Set(JsonNode root, string pointer, string value)
+    private static void Set(JsonNode root, LocalizationReference reference, string value)
     {
-        var parts = pointer.Split('/').Skip(1).Select(part => part.Replace("~1", "/", StringComparison.Ordinal).Replace("~0", "~", StringComparison.Ordinal)).ToArray();
-        var parent = root;
-        foreach (var part in parts.SkipLast(1)) parent = parent is JsonArray array ? array[int.Parse(part, System.Globalization.CultureInfo.InvariantCulture)]! : parent[part]!;
-        if (parent is JsonArray list) list[int.Parse(parts[^1], System.Globalization.CultureInfo.InvariantCulture)] = value;
-        else parent[parts[^1]] = value;
+        var updated = reference.Rewrite(JsonSerializer.SerializeToElement(root), value);
+        var target = root.AsObject(); target.Clear();
+        foreach (var member in updated.EnumerateObject()) target.Add(member.Name, JsonNode.Parse(member.Value.GetRawText()));
     }
 }
diff --git a/src/Editor/GalNet.Editor/Services/CharacterPanelState.cs b/src/Editor/GalNet.Editor/Services/CharacterPanelState.cs
new file mode 100644
index 00000000..2a04579c
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/CharacterPanelState.cs
@@ -0,0 +1,13 @@
+namespace GalNet.Editor.Services;
+
+/// <summary>Project-owned character drafts. Shared name-text keys never merge character identities.</summary>
+public sealed class CharacterPanelState
+{
+    public string? SelectedNameKey { get; set; }
+    public string? SelectedId { get; set; }
+    public HashSet<string> AmbiguousNameKeys { get; } = [];
+    public Dictionary<(string Id, string NameKey), CharacterPanelDraft> Drafts { get; } = [];
+    public CharacterPanelDraft? NewDraft { get; set; }
+}
+
+public sealed record CharacterPanelDraft(CharacterRow? Baseline, string Name, string Key);
diff --git a/src/Editor/GalNet.Editor/Services/ConfigurationSectionEditor.cs b/src/Editor/GalNet.Editor/Services/ConfigurationSectionEditor.cs
new file mode 100644
index 00000000..a6f67db7
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/ConfigurationSectionEditor.cs
@@ -0,0 +1,139 @@
+using System.Text.Json;
+using GalNet.Core.Configuration;
+using GalNet.Core.Parameters;
+using GalNet.Game.Controls.Forms;
+using GalNet.Contracts.Builtins.Audio;
+
+namespace GalNet.Editor.Services;
+
+/// <summary>Schema fields stage JSON in a dialog draft; publication and history belong to the project.</summary>
+public sealed class ConfigurationSectionEditor : IDisposable
+{
+    private readonly ConfigurationSection _section;
+    private readonly ProjectConfiguration _configuration;
+    private readonly ProjectSectionData? _baseline;
+    private readonly JsonElement _resolved;
+    private readonly Func<bool> _isCurrent;
+    private readonly Action _changed;
+    private readonly Dictionary<string, Field> _fields;
+    private bool _disposed;
+    public string Id => _section.Id;
+    public DtoEditorItem Item { get; }
+    public EditorRegistry Registry { get; }
+    public bool HasChanges => _fields.Values.Any(item => item.Draft.IsDirty || item.Pending is { } value && !Equal(item.Source(_baseline), value));
+
+    public ConfigurationSectionEditor(ConfigurationSection section, ProjectConfiguration configuration, EditorRegistry registry,
+        Func<bool> isCurrent, Action changed, Func<FieldDescriptor, bool> canEdit)
+    {
+        _section = section; _configuration = configuration; _baseline = configuration.Sections.GetValueOrDefault(section.Id);
+        try { _resolved = section.Resolve(_baseline); }
+        catch (Exception error) when (error is System.IO.InvalidDataException or JsonException or ArgumentException)
+        { _resolved = JsonSerializer.SerializeToElement(new { }); }
+        _isCurrent = isCurrent; _changed = changed; Registry = registry;
+        // Ordinary object/list DTOs use the shared JSON editor; no second reflection-based configuration form.
+        var fields = section.Fields.Where(field => section.Id != "galnet.project" || field.Id is not ("targetLocale" or "availableLocales"))
+            .Select(Decorate).Select(field => field.Editor is null && !IsScalar(field.Value.ValueType)
+            ? new FieldDescriptor(field.Id, field.Value, field.IsRequired, field.DefaultValue, new(ValueEditorIds.Json), field.LabelKey, field.DescriptionKey, field.Semantic, field.ResourceTypeId)
+            : field).ToArray();
+        _fields = fields.ToDictionary(field => field.Id, field => new Field(this, field, canEdit(field)), StringComparer.Ordinal);
+        Item = new(section.Id, null, fields, Binding, async (patch, token) =>
+        {
+            foreach (var (id, value) in patch)
+                if (await Binding(fields.Single(field => field.Id == id)).CommitAsync(value, token) is { } issue) return issue;
+            return null;
+        });
+    }
+    private FieldDescriptor Decorate(FieldDescriptor field)
+    {
+        if (_section.Id != "galnet.project") return field;
+        var label = field.Id switch
+        {
+            "defaultWidth" => "Settings.Project.DefaultWidth",
+            "defaultHeight" => "Settings.Project.DefaultHeight",
+            "defaultVisualPrograms" => "Settings.Project.DefaultVisualPrograms",
+            "saveSlotCount" => "Settings.Project.SaveSlotCount",
+            "audioBuses" => "Settings.Project.AudioBuses",
+            "audioTracks" => "Settings.Project.AudioTracks",
+            _ => field.LabelKey
+        };
+        if (field.Id == "defaultVisualPrograms")
+        {
+            var map = field.Value.WithStructure(ValueStructure.Map(new("value", new ValueDescriptor(typeof(string)))));
+            return new(field.Id, map, field.IsRequired, field.DefaultValue, new("structure"), label, field.DescriptionKey, field.Semantic, field.ResourceTypeId);
+        }
+        if (field.Id is not ("audioBuses" or "audioTracks"))
+            return new(field.Id, field.Value, field.IsRequired, field.DefaultValue, field.Editor, label, field.DescriptionKey, field.Semantic, field.ResourceTypeId);
+        var type = field.Id == "audioBuses" ? typeof(AudioBusDefinition) : typeof(AudioTrackDefinition);
+        var options = field.Value.JsonOptions;
+        var members = type.GetProperties().Select(property =>
+        {
+            var id = JsonNamingPolicy.CamelCase.ConvertName(property.Name);
+            var key = id switch
+            {
+                "id" => type == typeof(AudioBusDefinition) ? "Settings.Project.GroupId" : "Settings.Project.TrackId", "name" => "Settings.Project.TrackName",
+                "busId" => "Settings.Project.BusId", "defaultGain" => "Settings.Project.Gain",
+                "maxVoices" => "Settings.Project.Voices", "maxQueuedItems" => "Settings.Project.Queue",
+                "preserveDuringCatchUp" => "Settings.Project.PreserveAudio",
+                "playbackOrder" => "Settings.Project.PlaybackOrder", "repeat" => "Settings.Project.Repeat",
+                "overflowPolicy" => "Settings.Project.OverflowPolicy", "queueOverflowPolicy" => "Settings.Project.QueueOverflowPolicy", _ => null
+            };
+            return new FieldDescriptor(id, new ValueDescriptor(property.PropertyType, jsonOptions: options), labelKey: key);
+        }).ToArray();
+        var element = new FieldDescriptor("element", new ValueDescriptor(type, jsonOptions: options).WithStructure(ValueStructure.Object(members)));
+        var value = field.Value.WithStructure(ValueStructure.Sequence(element));
+        return new(field.Id, value, field.IsRequired, field.DefaultValue, new("structure"), label, field.DescriptionKey, field.Semantic, field.ResourceTypeId);
+    }
+    private static bool IsScalar(Type type) => type.IsPrimitive || type.IsEnum || type == typeof(string) || type == typeof(decimal);
+    public IFieldBinding Binding(FieldDescriptor field) => _fields[field.Id];
+    public async Task FlushAsync()
+    {
+        foreach (var field in _fields.Values.Where(field => field.Draft.IsDirty))
+        {
+            using var context = new FieldEditorContext(field.Descriptor, field, Registry);
+            if (!await context.CommitTextAsync()) throw new EditorOperationException("settings.invalid", context.Issue?.Message ?? "Finish or cancel the field input before saving.");
+        }
+    }
+    public void Apply(ProjectConfiguration candidate)
+    {
+        var changes = _fields.Values.Where(field => field.Pending is { } value && !Equal(field.Source(_baseline), value)).ToArray();
+        if (changes.Length == 0) return;
+        var current = _configuration.Sections.GetValueOrDefault(Id);
+        if (current?.Version != _baseline?.Version || changes.Any(field => !Equal(field.Source(current), field.Source(_baseline))))
+            throw new EditorOperationException("settings.changed", "Configuration fields changed. Cancel the draft and retry.");
+        candidate.Patch(_section, changes.Where(field => field.Pending!.Value.Json is not null).ToDictionary(field => field.Descriptor.Id, field => field.Pending!.Value.Json!.Value),
+            changes.Where(field => !field.Pending!.Value.IsProvided).Select(field => field.Descriptor.Id).ToArray());
+    }
+    public static bool Equal(ProjectSectionData? left, ProjectSectionData? right) => left is null ? right is null
+        : right is not null && left.Version == right.Version && JsonElement.DeepEquals(left.Data, right.Data);
+    private static bool Equal(FieldValue left, FieldValue right) => left.Json is { } a ? right.Json is { } b && JsonElement.DeepEquals(a, b) : right.Json is null;
+    public void Dispose() { _disposed = true; foreach (var field in _fields.Values) field.Dispose(); }
+
+    private sealed class Field : IFieldBinding, IDisposable
+    {
+        private readonly ConfigurationSectionEditor _owner;
+        private readonly bool _canEdit;
+        public FieldDescriptor Descriptor { get; }
+        public FieldValue? Pending { get; private set; }
+        public FieldDraftState Draft { get; }
+        public bool IsEnabled => _canEdit && !_owner._disposed && _owner._isCurrent();
+        public object? Label => Descriptor.LabelKey ?? Descriptor.Id;
+        public event EventHandler? Changed;
+        public Field(ConfigurationSectionEditor owner, FieldDescriptor descriptor, bool canEdit)
+        {
+            _owner = owner; Descriptor = descriptor; _canEdit = canEdit;
+            Draft = new(() => Source(owner._configuration.Sections.GetValueOrDefault(owner.Id)).Json?.GetRawText() ?? "<absent>");
+            Draft.Changed += owner._changed;
+        }
+        public FieldValue Source(ProjectSectionData? section) => section is not null && section.Data.TryGetProperty(Descriptor.Id, out var value) ? new(value) : default;
+        public FieldValue Read() => Pending ?? (Source(_owner._baseline) is { IsProvided: true } source ? source
+            : _owner._resolved.TryGetProperty(Descriptor.Id, out var value) ? new(value) : default);
+        public Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (!IsEnabled) return Task.FromResult<ValueIssue?>(new("settings.obsolete", "Configuration field is unavailable."));
+            Pending = value; _owner._changed(); Changed?.Invoke(this, EventArgs.Empty);
+            return Task.FromResult<ValueIssue?>(null);
+        }
+        public void Dispose() { Draft.Changed -= _owner._changed; Changed = null; }
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/EditorAssetManager.cs b/src/Editor/GalNet.Editor/Services/EditorAssetManager.cs
index a6cd48bf..6f8496ba 100644
--- a/src/Editor/GalNet.Editor/Services/EditorAssetManager.cs
+++ b/src/Editor/GalNet.Editor/Services/EditorAssetManager.cs
@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
 using GalNet.Assets;
 using GalNet.Assets.Provider;
 using GalNet.Assets.Variants;
@@ -11,41 +7,182 @@
 
 namespace GalNet.Editor.Services;
 
-/// <summary>Project-aware bridge from the editor's Assets directory to the shared asset manager contract.</summary>
-public sealed class EditorAssetManager : IAssetManager
+/// <summary>ID-indexed editor resources. A generation shares one index and outlives its active readers and leases.</summary>
+public sealed class EditorAssetManager : IAssetManager, IEditorAssetChanges
 {
     private readonly IProjectService _projects;
     private readonly IAssetCatalogService _catalog;
     private readonly IResourceTypeCatalog _resourceTypes;
-    private AssetManager _inner = new();
+    private readonly object _gate = new();
+    private readonly Dictionary<(string, Type), Action<AssetManager>> _decoders = [];
+    private readonly List<SharedProvider> _providers = [];
+    private Generation _current = new([], []);
+    private long _revision;
+    private bool _disposed;
+    public event Action? Changed;
+    public long Revision { get { lock (_gate) return _revision; } }
+
     public EditorAssetManager(IProjectService projects, IAssetCatalogService catalog, IResourceTypeCatalog resourceTypes)
     {
-        _projects = projects;
-        _catalog = catalog;
-        _resourceTypes = resourceTypes;
-        _projects.CurrentChanged += OnProjectChanged;
-        _catalog.Changed += OnCatalogChanged;
-        Rebuild(_projects.Current);
-    }
-    private void OnProjectChanged(Abstraction.Project.GalProject? project) => Rebuild(project);
-    private void OnCatalogChanged() => Rebuild(_projects.Current);
-    private void Rebuild(Abstraction.Project.GalProject? project)
-    {
-        var next = project is null ? new AssetManager() : new AssetManager([new LocalFileProvider(project.AssetsPath, _resourceTypes, optional: true)]);
-        next.RegisterImageVariantsDecoder();
-        var previous = Interlocked.Exchange(ref _inner, next);
-        previous.Dispose();
-    }
-    public Task<IGameFile?> GetFileAsync(string assetId, CancellationToken ct = default) => _inner.GetFileAsync(assetId, ct);
-    public Task<IReadOnlyList<IGameFile>> GetFilesAsync(string? typeId = null, CancellationToken ct = default) => _inner.GetFilesAsync(typeId, ct);
-    public Task<AssetHandle<T>?> AcquireAsync<T>(string assetId, CancellationToken ct = default) where T : class => _inner.AcquireAsync<T>(assetId, ct);
-    public Task<AssetHandle<T>?> AcquireByPathAsync<T>(string path, CancellationToken ct = default) where T : class => _inner.AcquireByPathAsync<T>(path, ct);
-    public void RegisterDecoder<T>(string resourceTypeId, IAssetDecoder<T> decoder) where T : class => _inner.RegisterDecoder(resourceTypeId, decoder);
-    public void RegisterProvider(IAssetProvider provider) => _inner.RegisterProvider(provider);
+        _projects = projects; _catalog = catalog; _resourceTypes = resourceTypes;
+        _projects.CurrentChanged += OnProjectChanged; _catalog.Changed += OnCatalogChanged;
+        Rebuild();
+    }
+    private void OnProjectChanged(Abstraction.Project.GalProject? project) => Rebuild();
+    private void OnCatalogChanged() => Rebuild();
+    private void Rebuild()
+    {
+        Generation previous;
+        lock (_gate)
+        {
+            if (_disposed) return;
+            var providers = new List<IAssetProvider>();
+            if (_projects.Current is { } project) providers.Add(new LocalFileProvider(project.AssetsPath, _resourceTypes, optional: true));
+            providers.AddRange(_providers.Select(provider => provider.Borrow()));
+            previous = _current;
+            _current = new(providers, _decoders.Values);
+            _revision++;
+        }
+        Release(previous);
+        Changed?.Invoke();
+    }
+    private Generation Retain()
+    {
+        lock (_gate)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            _current.Readers++;
+            return _current;
+        }
+    }
+    private void Release(Generation generation)
+    {
+        bool dispose;
+        lock (_gate) dispose = --generation.Readers == 0;
+        if (dispose) generation.Manager.Dispose();
+    }
+    private async Task<AssetIndex> IndexAsync(Generation generation, CancellationToken ct)
+    {
+        Task<AssetIndex> task;
+        lock (_gate)
+        {
+            if (generation.Index is null || generation.Index.IsFaulted || generation.Index.IsCanceled)
+            {
+                generation.Readers++;
+                generation.Index = Task.Run(() => LoadIndexAsync(generation));
+            }
+            task = generation.Index;
+        }
+        return await task.WaitAsync(ct).ConfigureAwait(false);
+    }
+    private async Task<AssetIndex> LoadIndexAsync(Generation generation)
+    {
+        try
+        {
+            var files = new Dictionary<string, IGameFile>(StringComparer.OrdinalIgnoreCase);
+            foreach (var provider in generation.Providers)
+            {
+                if (!provider.Exists("assets")) continue;
+                using var archive = await provider.OpenArchiveAsync("assets").ConfigureAwait(false);
+                foreach (var id in archive.AssetIds)
+                    if (archive.GetAsset(id) is { } file && !files.TryAdd(file.Id, file))
+                        throw new InvalidDataException($"Duplicate resource ID '{file.Id}'.");
+            }
+            return new(files, files.Values.OrderBy(file => file.Path, StringComparer.OrdinalIgnoreCase).ToArray());
+        }
+        finally { Release(generation); }
+    }
+    public async Task<IGameFile?> GetFileAsync(string assetId, CancellationToken ct = default)
+    {
+        var generation = Retain();
+        try { return string.IsNullOrWhiteSpace(assetId) ? null : (await IndexAsync(generation, ct).ConfigureAwait(false)).ById.GetValueOrDefault(assetId.Trim()); }
+        finally { Release(generation); }
+    }
+    public async Task<IReadOnlyList<IGameFile>> GetFilesAsync(string? typeId = null, CancellationToken ct = default)
+    {
+        var generation = Retain();
+        try
+        {
+            var index = await IndexAsync(generation, ct).ConfigureAwait(false);
+            return typeId is null ? index.Files : index.Files.Where(file => file.TypeId.Equals(typeId.Trim(), StringComparison.OrdinalIgnoreCase)).ToArray();
+        }
+        finally { Release(generation); }
+    }
+    public Task<AssetHandle<T>?> AcquireAsync<T>(string assetId, CancellationToken ct = default) where T : class
+        => AcquireAsync<T>(manager => manager.AcquireAsync<T>(assetId, ct));
+    public Task<AssetHandle<T>?> AcquireByPathAsync<T>(string path, CancellationToken ct = default) where T : class
+        => AcquireAsync<T>(manager => manager.AcquireByPathAsync<T>(path, ct));
+    private async Task<AssetHandle<T>?> AcquireAsync<T>(Func<AssetManager, Task<AssetHandle<T>?>> acquire) where T : class
+    {
+        var generation = Retain();
+        var transferred = false;
+        try
+        {
+            var handle = await acquire(generation.Manager).ConfigureAwait(false);
+            if (handle is null) return null;
+            var result = new AssetHandle<T>(handle.AssetId, handle.TypeId, handle.Value, () => { try { handle.Dispose(); } finally { Release(generation); } });
+            transferred = true;
+            return result;
+        }
+        finally { if (!transferred) Release(generation); }
+    }
+    public void RegisterDecoder<T>(string resourceTypeId, IAssetDecoder<T> decoder) where T : class
+    {
+        lock (_gate)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            _current.Manager.RegisterDecoder(resourceTypeId, decoder);
+            _decoders[(resourceTypeId.Trim().ToLowerInvariant(), typeof(T))] = manager => manager.RegisterDecoder(resourceTypeId, decoder);
+        }
+    }
+    public void RegisterProvider(IAssetProvider provider)
+    {
+        ArgumentNullException.ThrowIfNull(provider);
+        lock (_gate) { ObjectDisposedException.ThrowIf(_disposed, this); _providers.Add(new(provider)); }
+        Rebuild();
+    }
     public void Dispose()
     {
-        _projects.CurrentChanged -= OnProjectChanged;
-        _catalog.Changed -= OnCatalogChanged;
-        _inner.Dispose();
+        Generation current;
+        SharedProvider[] providers;
+        lock (_gate)
+        {
+            if (_disposed) return;
+            _disposed = true;
+            _projects.CurrentChanged -= OnProjectChanged; _catalog.Changed -= OnCatalogChanged;
+            current = _current; Changed = null;
+            providers = _providers.ToArray();
+            _providers.Clear();
+        }
+        Release(current);
+        foreach (var provider in providers) provider.Release();
+    }
+    private sealed record AssetIndex(IReadOnlyDictionary<string, IGameFile> ById, IReadOnlyList<IGameFile> Files);
+    private sealed class Generation
+    {
+        public Generation(IReadOnlyList<IAssetProvider> providers, IEnumerable<Action<AssetManager>> decoders)
+        {
+            Providers = providers; Manager = new(providers); Manager.RegisterImageVariantsDecoder();
+            foreach (var register in decoders) register(Manager);
+        }
+        public AssetManager Manager { get; }
+        public IReadOnlyList<IAssetProvider> Providers { get; }
+        public Task<AssetIndex>? Index { get; set; }
+        public int Readers { get; set; } = 1;
+    }
+    private sealed class SharedProvider(IAssetProvider provider)
+    {
+        private int _references = 1;
+        public BorrowedProvider Borrow() { Interlocked.Increment(ref _references); return new BorrowedProvider(provider, Release); }
+        public void Release() { if (Interlocked.Decrement(ref _references) == 0 && provider is IDisposable disposable) disposable.Dispose(); }
+    }
+    private sealed class BorrowedProvider(IAssetProvider provider, Action release) : IAssetProvider, IDisposable
+    {
+        private Action? _release = release;
+        public string Name => provider.Name;
+        public bool Exists(string name) => provider.Exists(name);
+        public IArchive OpenArchive(string name) => provider.OpenArchive(name);
+        public Task<IArchive> OpenArchiveAsync(string name, CancellationToken ct = default) => provider.OpenArchiveAsync(name, ct);
+        public void Dispose() => Interlocked.Exchange(ref _release, null)?.Invoke();
     }
 }
diff --git a/src/Editor/GalNet.Editor/Services/EditorGameDataProvider.cs b/src/Editor/GalNet.Editor/Services/EditorGameDataProvider.cs
deleted file mode 100644
index b382e5b0..00000000
--- a/src/Editor/GalNet.Editor/Services/EditorGameDataProvider.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-using System;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using GalNet.Assets.Provider;
-using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
-using GalNet.Editor.Abstraction.Services;
-using GalNet.Editor.ViewModels;
-using GalNet.Runtime.Content;
-using GalNet.Runtime.Loader;
-using GalNet.Storage.FileSystem;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace GalNet.Editor.Services;
-
-/// <summary>
-/// Editor implementation of IGameContentProvider.
-/// Generates preview data from the current editor workspace state.
-/// </summary>
-public sealed class EditorGameDataProvider : IGameContentProvider
-{
-    private readonly IProjectService _projectService;
-    private readonly IResourceTypeCatalog _resourceTypes;
-    private readonly IGalleryTypeCatalog _galleryTypes;
-
-    public EditorGameDataProvider(IProjectService projectService, IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes)
-    {
-        _projectService = projectService;
-        _resourceTypes = resourceTypes;
-        _galleryTypes = galleryTypes;
-    }
-
-    public Task<GameContent> LoadAsync(CancellationToken cancellationToken = default)
-    {
-        var project = _projectService.Current ?? throw new InvalidOperationException("A project must be open before preview data is requested.");
-        var directory = project.Services.GetRequiredService<EditorWorkspaceViewModel>().BuildPreviewData();
-        var graph = GraphLoader.LoadFromJson(File.ReadAllText(Path.Combine(directory, "graph.json")));
-        foreach (var group in graph.Nodes.OfType<GalNet.Core.Graph.Group>())
-        {
-            var file = Path.Combine(directory, $"{group.Id}.galgroup");
-            if (File.Exists(file)) GalgroupLoader.LoadIntoGroupFromContent(group, File.ReadAllText(file));
-        }
-        using var assets = new LocalFileProvider(project.AssetsPath, _resourceTypes, optional: true);
-        using var archive = assets.OpenArchive("assets");
-        var gallery = new GalleryCatalogCompiler(_resourceTypes, _galleryTypes).Compile(archive.AssetIds.Select(id => archive.GetAsset(id)!.Metadata));
-        return Task.FromResult(new GameContent { Graph = graph, AssetRoot = project.AssetsPath, Gallery = gallery });
-    }
-}
diff --git a/src/Editor/GalNet.Editor/Services/EditorGameSettingsService.cs b/src/Editor/GalNet.Editor/Services/EditorGameSettingsService.cs
deleted file mode 100644
index 0983c10a..00000000
--- a/src/Editor/GalNet.Editor/Services/EditorGameSettingsService.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-using GalNet.Core.Settings;
-using GalNet.Editor.Abstraction.Services;
-
-namespace GalNet.Editor.Services;
-
-public sealed class SettingsService : ISettingsService
-{
-    private readonly GameSettings _settings = new();
-    public event Action? Changed;
-    public float BgmVolume { get => _settings.BgmVolume; set { _settings.BgmVolume = value; Changed?.Invoke(); } }
-    public float SfxVolume { get => _settings.SfxVolume; set { _settings.SfxVolume = value; Changed?.Invoke(); } }
-    public float VoiceVolume { get => _settings.VoiceVolume; set { _settings.VoiceVolume = value; Changed?.Invoke(); } }
-    public float TextSpeed { get => _settings.TextSpeed; set { _settings.TextSpeed = value; Changed?.Invoke(); } }
-    public bool Fullscreen { get => _settings.Fullscreen; set { _settings.Fullscreen = value; Changed?.Invoke(); } }
-    public GameSettings GetSnapshot() => new()
-    {
-        BgmVolume = BgmVolume,
-        SfxVolume = SfxVolume,
-        VoiceVolume = VoiceVolume,
-        TextSpeed = TextSpeed,
-        Fullscreen = Fullscreen
-    };
-    public void ApplySnapshot(GameSettings settings)
-    {
-        _settings.BgmVolume = settings.BgmVolume;
-        _settings.SfxVolume = settings.SfxVolume;
-        _settings.VoiceVolume = settings.VoiceVolume;
-        _settings.TextSpeed = settings.TextSpeed;
-        _settings.Fullscreen = settings.Fullscreen;
-        Changed?.Invoke();
-    }
-    public Task LoadAsync(string path) => Task.CompletedTask;
-    public Task SaveAsync(string path) => Task.CompletedTask;
-}
diff --git a/src/Editor/GalNet.Editor/Services/EditorGroupProjectionStore.cs b/src/Editor/GalNet.Editor/Services/EditorGroupProjectionStore.cs
index 4f89b8d5..f4752224 100644
--- a/src/Editor/GalNet.Editor/Services/EditorGroupProjectionStore.cs
+++ b/src/Editor/GalNet.Editor/Services/EditorGroupProjectionStore.cs
@@ -1,7 +1,9 @@
 using System.Collections.ObjectModel;
 using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
 using GalNet.Editor.Models.Graph;
 
 namespace GalNet.Editor.Services;
@@ -11,33 +13,56 @@ public sealed class EditorGroupProjectionStore : IDisposable
 {
     public IEnumerable<EditorGroupProjection> Loaded => _groups.Values;
     private readonly Dictionary<string, EditorGroupProjection> _groups = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, WeakReference<EditorGroupProjection>> _retired = new(StringComparer.Ordinal);
     private readonly IEditorDocumentService documents;
     private readonly IEntryCatalog catalog;
     private readonly EntryFieldAuthoringService authoring;
     private readonly SceneTargetCatalog? scenes;
-    private readonly History.EditorHistories? histories;
+    private readonly AuthorChangeJournal changes;
     private readonly EntryEditSession? edits;
     public EditorGroupProjectionStore(IEditorDocumentService documents, IEntryCatalog catalog, EntryFieldAuthoringService authoring, SceneTargetCatalog? scenes = null, History.EditorHistories? histories = null, EntryEditSession? edits = null)
     {
         this.documents = documents;
         this.catalog = catalog;
         this.authoring = authoring;
-        this.scenes = scenes; this.histories = histories; this.edits = edits;
+        this.scenes = scenes; this.changes = histories?.Content.AuthorChanges ?? authoring.Changes; this.edits = edits;
         documents.DocumentChanged += Synchronize;
-        authoring.Changed += RefreshFields;
-        if (histories is not null) histories.Changed += Synchronize;
+        changes.Committed += OnCommitted;
+        if (scenes is not null) { scenes.Changed += RefreshSummaries; scenes.Text.PropertyChanged += OnLocale; }
+    }
+    public Exception? LastNotificationError { get; private set; }
+    private void OnCommitted(AuthorChangeSet change)
+    {
+        if (change.UnknownScope) { Synchronize(); return; }
+        foreach (var group in change.Groups)
+            if (_groups.TryGetValue(group.GroupId, out var projection)) projection.Synchronize(catalog, group);
     }
-    private void RefreshFields(string groupId) { if (_groups.TryGetValue(groupId, out var group)) group.Synchronize(catalog); }
     private void Synchronize()
     {
-        foreach (var group in _groups.Values) group.Synchronize(catalog);
+        foreach (var (id, group) in _groups.ToArray())
+            if (documents.Groups.TryGetValue(id, out var source)) { group.Rebind(source); group.Synchronize(catalog); }
+            else
+            {
+                group.Detach(); _groups.Remove(id);
+                foreach (var key in _retired.Where(pair => !pair.Value.TryGetTarget(out _)).Select(pair => pair.Key).ToArray()) _retired.Remove(key);
+                if (_retired.Count >= 64) _retired.Remove(_retired.Keys.First());
+                _retired[id] = new(group);
+            }
     }
+    private void OnLocale(object? sender, System.ComponentModel.PropertyChangedEventArgs args) { if (args.PropertyName == "Item[]") RefreshSummaries(); }
+    private void RefreshSummaries() { foreach (var group in _groups.Values) foreach (var entry in group.Entries) entry.RefreshSummary(); }
 
     public EditorGroupProjection Get(string groupId, string? sourcePath = null)
     {
         if (_groups.TryGetValue(groupId, out var existing)) return existing;
         var source = documents.GetOrCreateGroup(groupId, "Graph/" + (sourcePath ?? $"groups/{groupId}.rawgalgroup"));
-        var projection = new EditorGroupProjection(source, catalog, authoring, scenes, edits);
+        if (_retired.Remove(groupId, out var cached) && cached.TryGetTarget(out var restored))
+        { restored.Rebind(source); restored.Synchronize(catalog); _groups.Add(groupId, restored); return restored; }
+        var projection = new EditorGroupProjection(source, catalog, authoring, scenes, edits, failure =>
+        {
+            LastNotificationError = failure;
+            Serilog.Log.Error(failure, "A Group projection observer failed for {GroupId}", groupId);
+        });
         _groups.Add(groupId, projection);
         return projection;
     }
@@ -45,77 +70,135 @@ public EditorGroupProjection Get(string groupId, string? sourcePath = null)
     public void Dispose()
     {
         documents.DocumentChanged -= Synchronize;
-        authoring.Changed -= RefreshFields;
-        if (histories is not null) histories.Changed -= Synchronize;
+        changes.Committed -= OnCommitted;
+        if (scenes is not null) { scenes.Changed -= RefreshSummaries; scenes.Text.PropertyChanged -= OnLocale; }
         foreach (var group in _groups.Values) group.Dispose();
+        foreach (var cached in _retired.Values) if (cached.TryGetTarget(out var group)) group.Dispose();
+        _retired.Clear();
         _groups.Clear();
     }
 }
 
 public sealed class EditorGroupProjection : IDisposable
 {
-    public EditorGroupDocument Document { get; }
+    public EditorGroupDocument Document { get; private set; }
     public ObservableCollection<EntryEditorItemViewModel> Entries { get; }
-    private readonly HashSet<EntryEditorItemViewModel> _allEntries = [];
-    private bool _synchronizing;
+    private readonly List<WeakReference<EntryEditorItemViewModel>> _retiredEntries = [];
+    private readonly ProjectionEntryCollection _entries;
     private readonly EntryFieldAuthoringService _authoring;
     private readonly SceneTargetCatalog? _scenes;
     private readonly EntryEditSession? _edits;
+    private readonly Action<Exception> _report;
 
-    internal EditorGroupProjection(EditorGroupDocument document, IEntryCatalog catalog, EntryFieldAuthoringService authoring, SceneTargetCatalog? scenes, EntryEditSession? edits = null)
+    internal EditorGroupProjection(EditorGroupDocument document, IEntryCatalog catalog, EntryFieldAuthoringService authoring, SceneTargetCatalog? scenes, EntryEditSession? edits, Action<Exception> report)
     {
         Document = document;
         _authoring = authoring;
         _scenes = scenes; _edits = edits;
-        Entries = new(document.Entries.Select(entry => new EntryEditorItemViewModel(entry, catalog)));
-        _allEntries.UnionWith(Entries);
+        _report = report;
+        _entries = new(document.Entries.Select(entry => new EntryEditorItemViewModel(entry, catalog)), report);
+        Entries = _entries;
         foreach (var entry in Entries) Bind(entry);
-        Entries.CollectionChanged += OnEntriesChanged;
     }
-
-    private void OnEntriesChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs args)
+    internal void Rebind(EditorGroupDocument source) => Document = source;
+    internal void Detach()
     {
-        if (_synchronizing) return;
-        if (args.OldItems is not null)
-            foreach (EntryEditorItemViewModel entry in args.OldItems)
-                if (!Entries.Contains(entry)) entry.InvalidateParameterFields();
-        _allEntries.UnionWith(Entries);
-        foreach (var entry in Entries) Bind(entry);
-        Document.Entries.Clear();
-        Document.Entries.AddRange(Entries.Select(entry => entry.Source));
+        foreach (var entry in Entries.ToArray()) Retire(entry);
+        Document = new(Document.Id, Document.RelativePath, []);
+        _entries.Update(Entries.Clear);
+    }
+    private void Retire(EntryEditorItemViewModel entry)
+    {
+        try { entry.InvalidateAuthorBindings(); } catch (Exception failure) { _report(failure); }
+        _retiredEntries.RemoveAll(reference => !reference.TryGetTarget(out _));
+        if (_retiredEntries.Count >= 512) _retiredEntries.RemoveAt(0);
+        _retiredEntries.Add(new(entry));
     }
 
-    public void Synchronize(IEntryCatalog catalog)
+    public void Synchronize(IEntryCatalog catalog, AuthorGroupChange? change = null)
     {
         if (Document.Entries.SequenceEqual(Entries.Select(entry => entry.Source)))
         {
-            foreach (var entry in Entries) entry.RefreshAuthorReferences(catalog);
+            foreach (var entry in Entries.Where(entry => change is null || change.EntryIds.Contains(entry.StableId) || entry.Id != entry.Source.Id)) Refresh(entry, catalog);
             return;
         }
         var previous = Entries.ToArray();
         var current = Document.Entries.ToArray();
-        foreach (var entry in previous.Where(entry => !current.Contains(entry.Source))) entry.InvalidateParameterFields();
-        _synchronizing = true;
-        try
+        foreach (var entry in previous.Where(entry => !current.Contains(entry.Source)))
+            Retire(entry);
+        var active = previous.ToDictionary(entry => entry.Source, entry => entry);
+        _entries.Update(() =>
         {
-            Entries.Clear();
-            foreach (var source in current)
+            for (var index = 0; index < current.Length; index++)
             {
-                var entry = previous.FirstOrDefault(entry => ReferenceEquals(entry.Source, source)) ?? new EntryEditorItemViewModel(source, catalog);
-                Entries.Add(entry);
+                var source = current[index];
+                var entry = active.GetValueOrDefault(source) ?? _retiredEntries.Select(reference => reference.TryGetTarget(out var item) ? item : null)
+                    .FirstOrDefault(item => ReferenceEquals(item?.Source, source)) ?? new EntryEditorItemViewModel(source, catalog);
                 Bind(entry);
-                _allEntries.Add(entry);
+                if (Entries.Contains(entry)) { if (Entries.IndexOf(entry) != index) Entries.Move(Entries.IndexOf(entry), index); }
+                else Entries.Insert(index, entry);
+                Refresh(entry, catalog);
             }
-        }
-        finally { _synchronizing = false; }
+            while (Entries.Count > current.Length) Entries.RemoveAt(Entries.Count - 1);
+        });
+    }
+
+    private void Refresh(EntryEditorItemViewModel entry, IEntryCatalog catalog)
+    {
+        try { entry.RefreshAuthorReferences(catalog); }
+        catch (Exception failure) { _report(failure); }
     }
 
     private void Bind(EntryEditorItemViewModel entry) { entry.EditSession = _edits; entry.BindAuthoring(Document.Id, _authoring, _scenes); }
 
     public void Dispose()
     {
-        Entries.CollectionChanged -= OnEntriesChanged;
-        foreach (var entry in _allEntries) entry.Dispose();
-        _allEntries.Clear();
+        foreach (var entry in Entries) entry.Dispose();
+        foreach (var reference in _retiredEntries) if (reference.TryGetTarget(out var entry)) entry.Dispose();
+        _retiredEntries.Clear();
+    }
+}
+
+/// <summary>Read-only to consumers. One failed UI subscriber cannot interrupt projection reconciliation.</summary>
+internal sealed class ProjectionEntryCollection(IEnumerable<EntryEditorItemViewModel> initial, Action<Exception> report)
+    : ObservableCollection<EntryEditorItemViewModel>(initial)
+{
+    private bool _updating;
+    private bool _notifying;
+    public void Update(Action update)
+    {
+        _updating = true;
+        try { update(); }
+        finally { _updating = false; }
+    }
+    private void EnsureUpdating() { if (!_updating || _notifying) throw new InvalidOperationException("Edit Group entries through the authoring service."); }
+    protected override void InsertItem(int index, EntryEditorItemViewModel item) { EnsureUpdating(); base.InsertItem(index, item); }
+    protected override void RemoveItem(int index) { EnsureUpdating(); base.RemoveItem(index); }
+    protected override void SetItem(int index, EntryEditorItemViewModel item) { EnsureUpdating(); base.SetItem(index, item); }
+    protected override void MoveItem(int oldIndex, int newIndex) { EnsureUpdating(); base.MoveItem(oldIndex, newIndex); }
+    protected override void ClearItems() { EnsureUpdating(); base.ClearItems(); }
+    public override event System.Collections.Specialized.NotifyCollectionChangedEventHandler? CollectionChanged;
+    protected override event System.ComponentModel.PropertyChangedEventHandler? PropertyChanged;
+    protected override void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs args)
+    {
+        if (CollectionChanged is null) return;
+        _notifying = true;
+        try
+        {
+            foreach (System.Collections.Specialized.NotifyCollectionChangedEventHandler observer in CollectionChanged.GetInvocationList())
+                try { observer(this, args); } catch (Exception failure) { report(failure); }
+        }
+        finally { _notifying = false; }
+    }
+    protected override void OnPropertyChanged(System.ComponentModel.PropertyChangedEventArgs args)
+    {
+        if (PropertyChanged is null) return;
+        _notifying = true;
+        try
+        {
+            foreach (System.ComponentModel.PropertyChangedEventHandler observer in PropertyChanged.GetInvocationList())
+                try { observer(this, args); } catch (Exception failure) { report(failure); }
+        }
+        finally { _notifying = false; }
     }
 }
diff --git a/src/Editor/GalNet.Editor/Services/EditorLocalizationService.cs b/src/Editor/GalNet.Editor/Services/EditorLocalizationService.cs
index 05a34cf6..a55ee095 100644
--- a/src/Editor/GalNet.Editor/Services/EditorLocalizationService.cs
+++ b/src/Editor/GalNet.Editor/Services/EditorLocalizationService.cs
@@ -39,26 +39,35 @@ public string this[string key]
         }
     }
 
-    public EditorLocalizationService()
+    public EditorLocalizationService() : this(Resources.Load()) { }
+
+    internal EditorLocalizationService(Resources resources)
     {
         _cultureService = new CultureService();
         Current = this;
 
-        var provider = new JsonLocalizationProvider();
-        provider.Initialize(new JsonLocalizationProviderOptions
-        {
-            BasePath = "Localization",
-            UseEmbeddedResources = true,
-            Assembly = typeof(MainWindow).Assembly
-        });
-
-        _cultureService.RegisterProvider(provider);
-        var assembly = typeof(MainWindow).Assembly;
-        using var stream = assembly.GetManifestResourceStream(assembly.GetManifestResourceNames().Single(name => name.EndsWith("Localization.zh-CN.json", StringComparison.Ordinal)))!;
-        _fallback = JsonSerializer.Deserialize<Dictionary<string, string>>(stream)!;
+        _cultureService.RegisterProvider(resources.Provider);
+        _fallback = resources.Fallback;
         ApplyLocale(DefaultLocale);
     }
 
+    internal sealed record Resources(JsonLocalizationProvider Provider, Dictionary<string, string> Fallback)
+    {
+        internal static Resources Load()
+        {
+            var assembly = typeof(MainWindow).Assembly;
+            var provider = new JsonLocalizationProvider();
+            provider.Initialize(new JsonLocalizationProviderOptions
+            {
+                BasePath = "Localization",
+                UseEmbeddedResources = true,
+                Assembly = assembly
+            });
+            using var stream = assembly.GetManifestResourceStream(assembly.GetManifestResourceNames().Single(name => name.EndsWith("Localization.zh-CN.json", StringComparison.Ordinal)))!;
+            return new(provider, JsonSerializer.Deserialize<Dictionary<string, string>>(stream)!);
+        }
+    }
+
     public string Format(string key, params object[] args)
     {
         var template = this[key];
diff --git a/src/Editor/GalNet.Editor/Services/EditorPreviewHost.cs b/src/Editor/GalNet.Editor/Services/EditorPreviewHost.cs
deleted file mode 100644
index 7517e7fb..00000000
--- a/src/Editor/GalNet.Editor/Services/EditorPreviewHost.cs
+++ /dev/null
@@ -1,389 +0,0 @@
-extern alias GameViewAssembly;
-extern alias ThemesAssembly;
-using System.Collections.ObjectModel;
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Media;
-using Avalonia.Media.Imaging;
-using CommunityToolkit.Mvvm.ComponentModel;
-using GalNet.Core.Assets;
-using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
-using GalNet.Core.Runtime;
-using GalNet.Core.Settings;
-using GalNet.Media.LibVlc;
-using GalNet.Presentation.Abstractions.Runtime;
-using GalNet.Presentation.Abstractions.View;
-using GalNet.Primitives.Builtins;
-using GalNet.Rendering.Scene;
-using GalNet.Runtime.Content;
-using GalNet.Runtime.Engine;
-using GalNet.Runtime.Gallery;
-using GalNet.Runtime.Persistence;
-using GalNet.Runtime.Progress;
-using GalNet.Runtime.Runtime;
-using GalNet.Runtime.Variables;
-using GameViewAssembly::GalNet.Avalonia.GameView.Composition;
-using GameViewAssembly::GalNet.Avalonia.GameView.Navigation;
-using GameViewAssembly::GalNet.Avalonia.GameView.Page;
-using GameViewAssembly::GalNet.Avalonia.GameView.Presentation;
-using GameViewAssembly::GalNet.Avalonia.GameView.Services;
-using GameViewAssembly::GalNet.Avalonia.GameView.ViewModels;
-using Microsoft.Extensions.DependencyInjection;
-using Serilog;
-
-namespace GalNet.Editor.Services;
-
-/// <summary>Owns one isolated editor-preview DI container, game scope and engine lifetime.</summary>
-public sealed class EditorPreviewHost : IAsyncDisposable
-{
-    private readonly ServiceProvider _services;
-    private readonly AsyncServiceScope _scope;
-    private readonly EditorPreviewSessionService _session;
-    private bool _disposed;
-
-    public GameShell Shell { get; }
-    public IGameRuntime? Runtime => _session.Runtime;
-
-    public EditorPreviewHost(EditorPreviewContext context)
-    {
-        var services = new ServiceCollection();
-        services.AddSingleton(context);
-        services.AddAvaloniaGameViewPages(new ThemesAssembly::GalNet.Avalonia.Themes.ClassicTheme());
-        services.AddScoped<EditorPreviewSessionService>();
-        services.AddScoped<IGameSessionService>(provider => provider.GetRequiredService<EditorPreviewSessionService>());
-        _services = services.BuildServiceProvider(new ServiceProviderOptions { ValidateScopes = true });
-        _scope = _services.CreateAsyncScope();
-
-        var provider = _scope.ServiceProvider;
-        provider.GetRequiredService<IGameNavigationService>().ResetTo<GamePageViewModel>();
-        Shell = provider.GetRequiredService<GameShell>();
-        _session = provider.GetRequiredService<EditorPreviewSessionService>();
-    }
-
-    public Task StartAsync()
-    {
-        ObjectDisposedException.ThrowIf(_disposed, this);
-        return _session.StartNewGameAsync();
-    }
-
-    public async ValueTask DisposeAsync()
-    {
-        if (_disposed) return;
-        _disposed = true;
-        await _session.StopAsync();
-        await _scope.DisposeAsync();
-        await _services.DisposeAsync();
-    }
-}
-
-public sealed record EditorPreviewContext(
-    string Title,
-    IEntryCatalog Catalog,
-    IAssetManager Assets,
-    IGameContentProvider Content,
-    IVariableService Variables,
-    ISaveService Saves,
-    IGameProgressService Progress,
-    Action<IGameRuntime> RuntimeCreated,
-    Action GameStarted,
-    Action GameEnded,
-    Action<Exception> GameFailed);
-
-internal sealed partial class EditorPreviewSessionService : ObservableObject, IGameSessionService, IGameGallerySession, IDisposable
-{
-    private readonly EditorPreviewContext _context;
-    private readonly GamePageViewModel _gameplay;
-    private readonly GamePage _page;
-    private readonly ObservableCollection<GameSaveSlot> _slots = [];
-    private readonly ReadOnlyObservableCollection<GameSaveSlot> _readOnlySlots;
-    private readonly NullGameView _fallback = new();
-    private AvaloniaGamePresenters? _pageView;
-    private EditorPreviewLayerFactory? _layers;
-    private AvaloniaEffectRuntime? _effects;
-    private LibVlcAudioPlaybackHost? _audio;
-    private GameEngine? _engine;
-    private readonly Dictionary<string, AssetHandle<SceneTexture>> _preloadedTextures = new(StringComparer.OrdinalIgnoreCase);
-    private readonly SemaphoreSlim _lifecycle = new(1, 1);
-    private readonly GameRunCoordinator _run = new();
-    private bool _disposed;
-
-    public EditorPreviewSessionService(EditorPreviewContext context, GamePageViewModel gameplay, GamePage page)
-    {
-        _context = context;
-        _gameplay = gameplay;
-        _page = page;
-        _readOnlySlots = new(_slots);
-    }
-
-    public IGameRuntime? Runtime => _engine?.Runtime;
-    public IGalleryDataSource? GalleryDataSource { get; private set; }
-    public IGalleryResourceResolver? GalleryResources { get; private set; }
-    public string GameTitle => _context.Title;
-    public bool IsReady => true;
-    public ReadOnlyObservableCollection<GameSaveSlot> SaveSlots => _readOnlySlots;
-    [ObservableProperty] private string _statusMessage = "Ready";
-    [ObservableProperty] private bool _isPlaying;
-    [ObservableProperty] private bool _canContinue;
-
-    public Task StartNewGameAsync(CancellationToken cancellationToken = default) =>
-        RestartAsync(null, cancellationToken);
-
-    public async Task ContinueAsync(CancellationToken cancellationToken = default)
-    {
-        var slot = _slots
-            .Where(candidate => !candidate.IsEmpty && !candidate.IsCorrupt)
-            .OrderByDescending(candidate => candidate.Timestamp)
-            .FirstOrDefault();
-        if (slot is not null) await LoadAsync(slot.SlotIndex, cancellationToken);
-    }
-
-    public async Task StopAsync(CancellationToken cancellationToken = default)
-    {
-        if (_disposed) return;
-        await _lifecycle.WaitAsync(cancellationToken);
-        try
-        {
-            if (!_disposed) await StopCurrentRunAsync();
-        }
-        finally { _lifecycle.Release(); }
-    }
-
-    public async Task SaveAsync(int slotIndex, CancellationToken cancellationToken = default)
-    {
-        await _lifecycle.WaitAsync(cancellationToken);
-        try
-        {
-            await EnsureEngineAsync(cancellationToken);
-            await _context.Saves.SaveAsync(slotIndex, new SaveRequest { Snapshot = _engine!.CreateSaveData() }, cancellationToken);
-            await RefreshSlotsAsync(cancellationToken);
-        }
-        finally { _lifecycle.Release(); }
-    }
-
-    public async Task LoadAsync(int slotIndex, CancellationToken cancellationToken = default)
-    {
-        await _lifecycle.WaitAsync(cancellationToken);
-        try
-        {
-            var snapshot = await _context.Saves.LoadAsync(slotIndex, cancellationToken);
-            if (snapshot is null)
-            {
-                StatusMessage = $"Slot {slotIndex} is empty or invalid.";
-                return;
-            }
-
-            await StopCurrentRunAsync();
-            DisposeEngine();
-            await EnsureEngineAsync(cancellationToken);
-            _engine!.RestoreFrom(snapshot);
-            StartRun();
-            StatusMessage = $"Loaded slot {slotIndex}.";
-        }
-        finally { _lifecycle.Release(); }
-    }
-
-    public void Dispose()
-    {
-        if (_disposed) return;
-        try { StopAsync().GetAwaiter().GetResult(); }
-        finally
-        {
-            _disposed = true;
-            DisposeEngine();
-            (_context.Progress as IDisposable)?.Dispose();
-            (_context.Saves as IDisposable)?.Dispose();
-        }
-    }
-
-    private async Task RestartAsync(GameSnapshot? snapshot, CancellationToken cancellationToken)
-    {
-        await _lifecycle.WaitAsync(cancellationToken);
-        try
-        {
-            await StopCurrentRunAsync();
-            DisposeEngine();
-            await EnsureEngineAsync(cancellationToken);
-            if (snapshot is not null) _engine!.RestoreFrom(snapshot);
-            StartRun();
-        }
-        finally { _lifecycle.Release(); }
-        await AwaitCurrentRunAsync(cancellationToken);
-    }
-
-    private void StartRun()
-    {
-        _run.Start(cancellationToken => RunEngineAsync(_engine!, cancellationToken));
-    }
-
-    private async Task RunEngineAsync(GameEngine engine, CancellationToken cancellationToken)
-    {
-        try
-        {
-            IsPlaying = true;
-            _context.GameStarted();
-            StatusMessage = "Running";
-            await engine.AdvanceAsync(cancellationToken);
-            StatusMessage = "Ready";
-            _context.GameEnded();
-        }
-        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
-        {
-            StatusMessage = "Stopped";
-        }
-        catch (Exception exception)
-        {
-            StatusMessage = $"Preview failed: {exception.Message}";
-            _context.GameFailed(exception);
-        }
-        finally
-        {
-            IsPlaying = false;
-            await RefreshSlotsAsync(CancellationToken.None);
-        }
-    }
-
-    private async Task StopCurrentRunAsync()
-    {
-        await _run.StopAsync();
-    }
-
-    private Task AwaitCurrentRunAsync(CancellationToken cancellationToken) =>
-        _run.WaitAsync(cancellationToken);
-
-    private void DisposeEngine()
-    {
-        (GalleryResources as IDisposable)?.Dispose();
-        GalleryResources = null;
-        _gameplay.AdvanceRequested -= OnAdvanceRequested;
-        _gameplay.BindPlayback(null);
-        _engine?.Dispose();
-        _pageView?.Dispose();
-        _layers?.Dispose();
-        _effects?.Dispose();
-        _audio?.Dispose();
-        foreach (var handle in _preloadedTextures.Values) handle.Dispose();
-        _preloadedTextures.Clear();
-        _pageView = null;
-        _layers = null;
-        _effects = null;
-        _audio = null;
-        _engine = null;
-    }
-
-    private async Task EnsureEngineAsync(CancellationToken cancellationToken)
-    {
-        if (_engine is not null) return;
-        var content = await _context.Content.LoadAsync(cancellationToken);
-        var imageVariants = await GalNet.Assets.Variants.ImageVariantsCatalogLoader.LoadImageVariantsCatalogAsync(_context.Assets, cancellationToken);
-        _context.Assets.RegisterDecoder<SceneTexture>("sprite", new SceneTextureAssetDecoder());
-        var spriteFiles = await _context.Assets.GetFilesAsync("sprite", cancellationToken);
-        var textures = await Task.WhenAll(spriteFiles.Select(file => _context.Assets.AcquireAsync<SceneTexture>(file.Id, cancellationToken)));
-        foreach (var handle in textures.OfType<AssetHandle<SceneTexture>>()) _preloadedTextures.Add(handle.AssetId, handle);
-        _context.Variables.ConfigureSystemVariables(GalleryUnlockVariable.CreateDefinitions(content.Gallery));
-        GalleryDataSource = new GalleryDataSource(content.Gallery, _context.Variables);
-        GalleryResources = await AssetGalleryResourceResolver.CreateAsync(_context.Assets, content.Gallery, cancellationToken);
-        OnPropertyChanged(nameof(GalleryDataSource));
-        OnPropertyChanged(nameof(GalleryResources));
-        _layers = new EditorPreviewLayerFactory(_preloadedTextures);
-        _pageView = new AvaloniaGamePresenters(_gameplay, _page, _layers);
-        _effects = new AvaloniaEffectRuntime(_gameplay);
-        _audio = new LibVlcAudioPlaybackHost(_context.Assets);
-        using var registration = new GameRegistration().UseCatalog(_context.Catalog);
-        var view = registration.AddBuiltinImplementations(_context.Catalog,
-            _pageView.DialoguePresenter,
-            _pageView.LayerPresenter,
-            _pageView.AnimationPresenter,
-            _effects,
-            content.Gallery,
-            _pageView.ParticlePresenter,
-            _pageView.NvlPresenter,
-            _audio, imageVariants: imageVariants).BuildView();
-        try { view.RequireInstructions(content.Graph.Nodes.OfType<GalNet.Core.Graph.Group>().SelectMany(group => group.Entries).Select(entry => entry.Type)); }
-        catch { view.Dispose(); throw; }
-        var runtime = new GameRuntime(null, content.Graph.RootNodeId, new SettingsContainer(), _context.Variables);
-        _engine = new GameEngine(content.Graph, runtime, view, _context.Progress, _pageView.ChoicePresenter);
-        _gameplay.BindPlayback(_engine);
-        _gameplay.AdvanceRequested += OnAdvanceRequested;
-        _context.RuntimeCreated(runtime);
-        await RefreshSlotsAsync(cancellationToken);
-    }
-
-    private void OnAdvanceRequested()
-    {
-        if (_engine is { } engine)
-            _ = AdvanceEngineAsync(engine);
-    }
-
-    private static async Task AdvanceEngineAsync(GameEngine engine)
-    {
-        try { await engine.AdvanceAsync(); }
-        catch (Exception exception) { Log.Error(exception, "Preview advance failed"); }
-    }
-
-    private async Task RefreshSlotsAsync(CancellationToken cancellationToken)
-    {
-        var slots = await _context.Saves.ListSlotsAsync(cancellationToken);
-        _slots.Clear();
-        foreach (var slot in slots)
-            _slots.Add(new(slot.SlotIndex, slot.Timestamp,
-                slot.IsCorrupt ? "Corrupt save" : slot.Description ?? (slot.Timestamp == default ? "Empty" : "Saved game"),
-                slot.Timestamp == default && !slot.IsCorrupt, slot.IsCorrupt));
-        CanContinue = _slots.Any(slot => !slot.IsEmpty && !slot.IsCorrupt);
-    }
-}
-
-internal sealed class EditorPreviewLayerFactory(IReadOnlyDictionary<string, AssetHandle<SceneTexture>> textures) : IGamePageLayerFactory, IDisposable
-{
-    private readonly IReadOnlyDictionary<string, AssetHandle<SceneTexture>> _texturesById = textures;
-    private readonly Dictionary<string, SceneTexture> _textures = new(StringComparer.OrdinalIgnoreCase);
-    private readonly HashSet<SceneTexture> _fallbacks = [];
-
-    public SceneTexture ResolveTexture(string assetId)
-    {
-        if (_textures.TryGetValue(assetId, out var texture)) return texture;
-        texture = LoadTexture(assetId);
-        _textures.Add(assetId, texture);
-        return texture;
-    }
-
-    private SceneTexture LoadTexture(string assetId)
-    {
-        try
-        {
-            if (_texturesById.TryGetValue(assetId, out var handle) && !handle.IsReleased)
-                return handle.Value;
-        }
-        catch (Exception exception)
-        {
-            ReportMissing(assetId, exception);
-            return CreateFallback();
-        }
-
-        ReportMissing(assetId, null);
-        return CreateFallback();
-    }
-
-    private SceneTexture CreateFallback()
-    {
-        var fallback = new SceneTexture(LayerImageFallback.MissingImage);
-        _fallbacks.Add(fallback);
-        return fallback;
-    }
-
-    public void Dispose()
-    {
-        foreach (var fallback in _fallbacks) fallback.Dispose();
-        _fallbacks.Clear();
-        _textures.Clear();
-    }
-
-    private static void ReportMissing(string assetId, Exception? exception)
-    {
-        if (!LayerImageFallback.ShouldReport(assetId)) return;
-        if (exception is null)
-            Log.Warning("Layer asset was not found; rendering built-in fallback: {AssetId}", assetId);
-        else
-            Log.Warning(exception, "Layer asset could not be read; rendering built-in fallback: {AssetId}", assetId);
-    }
-}
diff --git a/src/Editor/GalNet.Editor/Services/EditorProblemText.cs b/src/Editor/GalNet.Editor/Services/EditorProblemText.cs
new file mode 100644
index 00000000..514f0174
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/EditorProblemText.cs
@@ -0,0 +1,48 @@
+using GalNet.Core.Parameters;
+using GalNet.Editor.Abstraction.Services;
+
+namespace GalNet.Editor.Services;
+
+/// <summary>Author-facing descriptions; raw validator details stay available separately.</summary>
+internal static class EditorProblemText
+{
+    public static string Label(FieldDescriptor field, IEditorLocalizationService? text = null) =>
+        Lookup(field.LabelKey ?? "Entry.Parameter." + field.Id, field.Id, text);
+
+    public static string Lookup(string key, string fallback, IEditorLocalizationService? text = null)
+    {
+        var value = (text ?? EditorLocalizationService.Current)?[key];
+        return string.IsNullOrEmpty(value) || value == key || value == "[" + key + "]" || value == "#" + key + "#" ? fallback : value;
+    }
+
+    public static string Value(FieldDescriptor field, ValueIssue issue, IEditorLocalizationService? text = null)
+    {
+        text ??= EditorLocalizationService.Current;
+        if (text is null) return issue.Message;
+        if (issue.Code == "editor.numericFallback") return text["Problem.NumericFallback"];
+        var key = issue.Code switch
+        {
+            "field.required" => "Required",
+            "value.type" => "Type",
+            "value.range" => "Range",
+            "value.finite" => "Finite",
+            "value.null" => "Null",
+            "value.option" => "Option",
+            "value.length" or "value.items" => "Length",
+            "value.spin" => "Spin",
+            "field.conflict" => "Conflict",
+            _ => "Invalid"
+        };
+        var minimum = field.Value.TryGetConstraint("minimum", out var min) ? min.GetRawText() : "−∞";
+        var maximum = field.Value.TryGetConstraint("maximum", out var max) ? max.GetRawText() : "+∞";
+        if (key == "Range" && minimum == "−∞") key = "Maximum";
+        else if (key == "Range" && maximum == "+∞") key = "Minimum";
+        var type = Nullable.GetUnderlyingType(field.Value.ValueType) ?? field.Value.ValueType;
+        var kind = type == typeof(float) || type == typeof(double) || type == typeof(decimal) ? "Number"
+            : DefaultNumeric(type) ? "Integer" : type == typeof(string) ? "Text" : type == typeof(bool) ? "Boolean" : "Json";
+        return text.Format("Problem.Value." + key, Label(field, text), text["Problem.Kind." + kind], minimum, maximum);
+    }
+
+    private static bool DefaultNumeric(Type type) => type == typeof(byte) || type == typeof(sbyte) || type == typeof(short)
+        || type == typeof(ushort) || type == typeof(int) || type == typeof(uint) || type == typeof(long) || type == typeof(ulong);
+}
diff --git a/src/Editor/GalNet.Editor/Services/EditorStartupPreparation.cs b/src/Editor/GalNet.Editor/Services/EditorStartupPreparation.cs
new file mode 100644
index 00000000..1e3667e1
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/EditorStartupPreparation.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Threading.Tasks;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+/// <summary>Two data-only tasks overlapped with platform initialization.</summary>
+internal sealed class EditorStartupPreparation : IDisposable
+{
+    internal Task<EditorSettingsService> Settings { get; }
+    internal Task<EditorLocalizationService.Resources> Localization { get; }
+
+    internal EditorStartupPreparation(string? settingsPath = null)
+    {
+        Settings = Task.Run(() =>
+        {
+#if BENCHMARK
+            using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.PrepareSettings");
+#endif
+            var settings = new EditorSettingsService(settingsPath);
+            settings.GetSettings();
+            return settings;
+        });
+        Localization = Task.Run(() =>
+        {
+#if BENCHMARK
+            using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.PrepareLocalization");
+#endif
+            return EditorLocalizationService.Resources.Load();
+        });
+    }
+
+    public void Dispose()
+    {
+        // Also observe both tasks if platform initialization fails before consumption.
+        try { Task.WhenAll(Settings, Localization).GetAwaiter().GetResult(); }
+        catch (Exception error) { Serilog.Log.Warning(error, "Startup data preparation failed"); }
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/EditorText.cs b/src/Editor/GalNet.Editor/Services/EditorText.cs
index 1ae82bbb..b34cadf9 100644
--- a/src/Editor/GalNet.Editor/Services/EditorText.cs
+++ b/src/Editor/GalNet.Editor/Services/EditorText.cs
@@ -21,6 +21,8 @@ public static EditorText Error(Exception error) => error is EditorOperationExcep
         "Delete nodes and Group sources" => new("History.DeleteNodes"),
         "Create node and source" => new("History.CreateNode"),
         "Change project name and settings" => new("History.Settings"),
+        "Change Group story package" => new("Packaging.HistoryGroup"),
+        "Change resource patches" => new("Packaging.HistoryOverrides"),
         "Add choice option" => new("History.AddChoice"),
         "Delete choice option" => new("History.DeleteChoice"),
         "Move choice option" => new("History.MoveChoice"),
diff --git a/src/Editor/GalNet.Editor/Services/EditorViewFactory.cs b/src/Editor/GalNet.Editor/Services/EditorViewFactory.cs
index be904cb2..6aca9eb4 100644
--- a/src/Editor/GalNet.Editor/Services/EditorViewFactory.cs
+++ b/src/Editor/GalNet.Editor/Services/EditorViewFactory.cs
@@ -22,7 +22,6 @@ public sealed class EditorViewFactory : IEditorViewFactory
         [typeof(TimelinePanelViewModel)] = typeof(TimelinePanelView),
         [typeof(FileDocumentPanelViewModel)] = typeof(FileDocumentPanelView),
         [typeof(NewProjectPanelViewModel)] = typeof(NewProjectPanelView),
-        [typeof(GamePreviewPanelViewModel)] = typeof(GamePreviewPanelView),
         [typeof(LogPanelViewModel)] = typeof(LogPanelView)
         ,
         [typeof(AssetPanelViewModel)] = typeof(AssetPanelView)
diff --git a/src/Editor/GalNet.Editor/Services/EditorWindowFactory.cs b/src/Editor/GalNet.Editor/Services/EditorWindowFactory.cs
index 71b310d4..14ad3661 100644
--- a/src/Editor/GalNet.Editor/Services/EditorWindowFactory.cs
+++ b/src/Editor/GalNet.Editor/Services/EditorWindowFactory.cs
@@ -1,4 +1,11 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
+using CommunityToolkit.Mvvm.Input;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.ViewModels;
 using GalNet.Editor.Views;
@@ -39,4 +46,42 @@ public ExportWindow CreateExportWindow()
         window.DataContext = ProjectServices.GetRequiredService<ExportPanelViewModel>();
         return window;
     }
+    public async Task<string?> RequestLayoutNameAsync(IEditorLocalizationService L)
+    {
+        var owner = (Application.Current?.ApplicationLifetime as IClassicDesktopStyleApplicationLifetime)?.MainWindow;
+        if (owner is null) return null;
+        var input = new TextBox { MinWidth = 260, PlaceholderText = L["Layout.Name"] };
+        var dialog = new Window
+        {
+            Title = L["Editor.Menu.SaveLayout"],
+            Width = 360,
+            Height = 140,
+            WindowStartupLocation = WindowStartupLocation.CenterOwner
+        };
+        dialog.Content = new StackPanel
+        {
+            Margin = new Thickness(16),
+            Spacing = 12,
+            Children =
+            {
+                input,
+                new StackPanel
+                {
+                    Orientation = Avalonia.Layout.Orientation.Horizontal,
+                    HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Right,
+                    Spacing = 8,
+                    Children =
+                    {
+                        new Button { Content = L["Common.Cancel"], Command = new RelayCommand(() => dialog.Close(null)) },
+                        new Button { Content = L["Common.Save"], Command = new RelayCommand(() => dialog.Close(input.Text)) }
+                    }
+                }
+            }
+        };
+        var bindings = new List<IDisposable> { LocalizedBindings.Bind(dialog, Window.TitleProperty, L, "Editor.Menu.SaveLayout"), LocalizedBindings.Bind(input, TextBox.PlaceholderTextProperty, L, "Layout.Name") };
+        foreach (var button in ((StackPanel)dialog.Content!).Children.OfType<StackPanel>().SelectMany(panel => panel.Children).OfType<Button>())
+            bindings.Add(LocalizedBindings.Bind(button, ContentControl.ContentProperty, L, button.Content?.ToString() == L["Common.Cancel"] ? "Common.Cancel" : "Common.Save"));
+        dialog.Closed += (_, _) => { foreach (var binding in bindings) binding.Dispose(); };
+        return await dialog.ShowDialog<string?>(owner);
+    }
 }
diff --git a/src/Editor/GalNet.Editor/Services/EditorWorkspacePersistence.cs b/src/Editor/GalNet.Editor/Services/EditorWorkspacePersistence.cs
index 6a5d08b3..831d6e75 100644
--- a/src/Editor/GalNet.Editor/Services/EditorWorkspacePersistence.cs
+++ b/src/Editor/GalNet.Editor/Services/EditorWorkspacePersistence.cs
@@ -11,20 +11,17 @@ public sealed class EditorWorkspacePersistence
     private readonly IProjectService _projects;
     private readonly IEditorDocumentRepository _repository;
     private readonly IEditorDocumentService _documents;
-    private readonly IEditorSaveCoordinator _saveCoordinator;
     private readonly EditorGroupProjectionStore? _groups;
 
     public EditorWorkspacePersistence(
         IProjectService projects,
         IEditorDocumentRepository repository,
         IEditorDocumentService documents,
-        IEditorSaveCoordinator saveCoordinator,
         EditorGroupProjectionStore? groups = null)
     {
         _projects = projects;
         _repository = repository;
         _documents = documents;
-        _saveCoordinator = saveCoordinator;
         _groups = groups;
     }
 
@@ -36,7 +33,7 @@ public EditorWorkspacePersistence(
         }
 
         if (!_documents.IsLoaded)
-            _documents.Load(_repository.Load(project.RootPath, project.Name, project.Settings));
+            _documents.Load(_repository.Load(project.RootPath));
         return GraphDocumentMapper.Load(_documents.LoadedProject, _groups);
     }
 
@@ -51,30 +48,4 @@ public async Task<bool> SaveCurrentProjectAsync()
         return true;
     }
 
-    public string BuildPreviewData(
-        string previewPath,
-        IEnumerable<GraphNode> nodes,
-        IEnumerable<GraphEdge> edges)
-    {
-        if (_projects.Current is not { } project)
-            throw new InvalidOperationException("No project is currently open.");
-
-        var document = CreateDocument(project.Name, nodes, edges);
-        return _saveCoordinator.BuildPreviewData(
-            previewPath,
-            document,
-            GraphDocumentMapper.CreateGroupEntriesSnapshot(nodes));
-    }
-
-    private EditorGraphDocument CreateDocument(
-        string projectName,
-        IEnumerable<GraphNode> nodes,
-        IEnumerable<GraphEdge> edges) =>
-        GraphDocumentMapper.CreateDocument(
-            projectName,
-            _documents.CurrentDocument.Version,
-            nodes,
-            edges,
-            _documents.CurrentDocument.PlayerVariables,
-            _documents.CurrentDocument.SaveVariables);
 }
diff --git a/src/Editor/GalNet.Editor/Services/EntryDraftArchiveStore.cs b/src/Editor/GalNet.Editor/Services/EntryDraftArchiveStore.cs
new file mode 100644
index 00000000..a63ae24d
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/EntryDraftArchiveStore.cs
@@ -0,0 +1,44 @@
+using System.Text.Json;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+public sealed record ArchivedEntryDraft(string Id, SceneAuthorAddress Owner, string Type, string RootId, string[] Path,
+    string FieldType, string Baseline, string Text, bool JsonText, ValueIssue? Issue, bool Conflicted);
+public sealed record EntryDraftArchiveLimits(int Count = 1000, int Bytes = 16 * 1024 * 1024);
+
+/// <summary>Durable input recovery, independent of author files and the bounded undo stack.</summary>
+internal sealed class EntryDraftArchiveStore(string root, EntryDraftArchiveLimits limits)
+{
+    private const string RelativePath = ".galnet/editor/input-archive.json";
+    private sealed record ArchiveFile(int Version, IReadOnlyList<ArchivedEntryDraft> Drafts);
+    public IReadOnlyList<ArchivedEntryDraft> Read()
+    {
+        var path = new ProjectRawReader(root).Resolve(RelativePath);
+        if (!File.Exists(path)) return [];
+        if (new FileInfo(path).Length > limits.Bytes) throw new InvalidDataException("Entry input recovery exceeds its budget. Preserve the recovery file before repairing it.");
+        var file = JsonSerializer.Deserialize<ArchiveFile>(File.ReadAllBytes(path)) ?? throw new InvalidDataException("Entry input recovery is empty.");
+        if (file.Version != 1 || file.Drafts is null || file.Drafts.Count > limits.Count || file.Drafts.Any(draft => draft is null || string.IsNullOrWhiteSpace(draft.Id)
+            || draft.Owner is null || draft.Owner.GroupId is null || draft.Owner.EntryId is null || draft.Type is null || draft.RootId is null || draft.Path is null
+            || draft.Path.Any(segment => segment is null) || draft.FieldType is null || draft.Baseline is null || draft.Text is null)
+            || file.Drafts.Select(draft => draft.Id).Distinct(StringComparer.Ordinal).Count() != file.Drafts.Count)
+            throw new InvalidDataException("Entry input recovery is corrupt or has an unsupported version.");
+        return file.Drafts;
+    }
+    public static byte[] Encode(IReadOnlyList<ArchivedEntryDraft> drafts, EntryDraftArchiveLimits limits)
+    {
+        var bytes = JsonSerializer.SerializeToUtf8Bytes(new ArchiveFile(1, drafts));
+        if (drafts.Count > limits.Count || bytes.Length > limits.Bytes)
+            throw new GalNet.Editor.Abstraction.Services.EditorOperationException("entry.archiveFull", "Input recovery is full. Copy or discard archived inputs in Problems before removing more entries.");
+        return bytes;
+    }
+    public void Write(byte[] bytes)
+    {
+        var path = new ProjectRawReader(root).Resolve(RelativePath);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        var temporary = path + "." + Guid.NewGuid().ToString("N") + ".tmp";
+        try { File.WriteAllBytes(temporary, bytes); File.Move(temporary, path, true); }
+        finally { if (File.Exists(temporary)) File.Delete(temporary); }
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/EntryDraftLifecycleEdit.cs b/src/Editor/GalNet.Editor/Services/EntryDraftLifecycleEdit.cs
new file mode 100644
index 00000000..24c15da9
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/EntryDraftLifecycleEdit.cs
@@ -0,0 +1,17 @@
+using GalNet.Editor.History;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+public sealed record EntryAddressTransition(SceneAuthorAddress Before, SceneAuthorAddress After);
+
+/// <summary>Content and input lifecycle share the history gate. Observers run only after both are stable.</summary>
+internal sealed class EntryDraftLifecycleEdit(EntryEditSession inputs, IUndoableEdit edit, IReadOnlyList<EntryAddressTransition> addresses, AuthorChangeJournal journal) : IUndoableEdit, IAuthorScopedEdit
+{
+    public bool HasKnownAuthorScope => UndoRedoHistory.KnownScope(edit);
+    public string Description => edit.Description;
+    public EditorText DisplayText => edit.DisplayText;
+    public long RetainedBytes => edit.RetainedBytes;
+    public void Redo() => inputs.ApplyAuthorEdit(addresses, edit.Redo, journal);
+    public void Undo() => inputs.ApplyAuthorEdit(addresses.Select(address => new EntryAddressTransition(address.After, address.Before)).ToArray(), edit.Undo, journal);
+}
diff --git a/src/Editor/GalNet.Editor/Services/EntryEditSession.Archives.cs b/src/Editor/GalNet.Editor/Services/EntryEditSession.Archives.cs
new file mode 100644
index 00000000..6542e810
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/EntryEditSession.Archives.cs
@@ -0,0 +1,134 @@
+using System.Text.Json;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+public sealed partial class EntryEditSession
+{
+    private readonly IEditorDocumentService? _documents;
+    private readonly IProjectService? _projects;
+    private readonly EntryDraftArchiveLimits _limits;
+    private readonly List<ArchivedEntryDraft> _archives = [];
+    private readonly HashSet<string> _restoreRequested = new(StringComparer.Ordinal);
+    private EntryDraftArchiveStore? _archiveStore;
+    private bool _archiveLoaded;
+    public long Revision { get; private set; }
+    public Exception? ArchiveError { get; private set; }
+    public IReadOnlyList<ArchivedEntryDraft> Archives { get { if (!_disposed) LoadArchive(); return _archives.AsReadOnly(); } }
+    public int CountPending(IEnumerable<SceneAuthorAddress> addresses)
+    {
+        var selected = addresses.ToHashSet();
+        return Pending.Count(draft => selected.Contains(Address(draft)));
+    }
+    private static SceneAuthorAddress Address(Draft draft) => new(draft.Owner.AuthorGroupId!, draft.Owner.StableId);
+    private void LoadArchive()
+    {
+        if (_archiveLoaded) return;
+        if (_projects?.Current is not { } project) { if (_projects is null) _archiveLoaded = true; return; }
+        _archiveLoaded = true;
+        try { _archiveStore = new(project.RootPath, _limits); _archives.AddRange(_archiveStore.Read()); }
+        catch (Exception failure) when (failure is IOException or UnauthorizedAccessException or JsonException or InvalidDataException)
+        { ArchiveError = failure; }
+    }
+    private void WriteArchive(IReadOnlyList<ArchivedEntryDraft> records)
+    {
+        LoadArchive();
+        if (ArchiveError is not null) throw new EditorOperationException("entry.archiveUnavailable", "Input recovery is unavailable. Preserve and repair .galnet/editor/input-archive.json first.");
+        var bytes = EntryDraftArchiveStore.Encode(records, _limits);
+        _archiveStore?.Write(bytes);
+    }
+    internal void ApplyAuthorEdit(IReadOnlyList<EntryAddressTransition> addresses, Action apply, AuthorChangeJournal? journal)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        LoadArchive();
+        var moves = addresses.ToDictionary(address => address.Before, address => address.After);
+        var affected = _drafts.Where(pair => moves.ContainsKey(Address(pair.Value))).ToArray();
+        var added = affected.Select(pair => pair.Value).Where(draft => draft.State.IsDirty || !draft.State.CanCommit).Select(draft =>
+            new ArchivedEntryDraft(Guid.NewGuid().ToString("N"), moves[Address(draft)], draft.Type, draft.Root.Id, draft.Path.ToArray(),
+                draft.Field.Value.ValueType.FullName ?? draft.Field.Value.ValueType.Name, draft.State.Baseline ?? Baseline(draft), draft.State.Text, draft.State.JsonText, draft.State.Issue, draft.State.IsConflicted)).ToArray();
+        var before = _archives.ToArray();
+        var after = before.Select(record => moves.TryGetValue(record.Owner, out var target) ? record with { Owner = target } : record).Concat(added).ToArray();
+        var changed = added.Length != 0 || !before.SequenceEqual(after);
+        // Input recovery is published first. If the domain step fails, restore the previous recovery file.
+        // A failed recovery write cannot destroy author content or detach its live inputs.
+        if (changed) WriteArchive(after);
+        try { apply(); }
+        catch (Exception failure)
+        {
+            if (changed)
+                try { WriteArchive(before); }
+                catch (Exception rollback) { throw new HistoryRepairRequiredException("Entry input recovery rollback failed.", new AggregateException(failure, rollback)); }
+            throw;
+        }
+        if (changed) { _archives.Clear(); _archives.AddRange(after); }
+        List<Action> restoreDrafts = [];
+        foreach (var (key, draft) in affected)
+        {
+            var commit = draft.State.Commit; var child = draft.State.Child;
+            draft.State.Changed -= draft.OnChanged;
+            draft.State.Child = null;
+            draft.State.Commit = () => Task.FromResult<GalNet.Core.Parameters.ValueIssue?>(Error("Conflict"));
+            var blocked = draft.State.RegisterGuard(() => false);
+            _drafts.Remove(key);
+            restoreDrafts.Add(() =>
+            {
+                blocked.Dispose(); draft.State.Commit = commit; draft.State.Child = child;
+                _drafts[key] = draft; draft.State.Changed += draft.OnChanged;
+            });
+        }
+        if (journal?.IsRecording == true) journal.OnRollback(() =>
+        {
+            if (changed) WriteArchive(before);
+            _archives.Clear(); _archives.AddRange(before);
+            foreach (var restore in restoreDrafts) restore();
+            Revision++;
+        });
+        Revision++;
+        // Content/Problems notification follows the completed history commit, never this intermediate step.
+    }
+    private string? Source(ArchivedEntryDraft record)
+    {
+        if (_documents?.IsLoaded != true || !_documents.CurrentDocument.Nodes.Any(node => node.Id == record.Owner.GroupId && node.Type == "Group")
+            || !_documents.Groups.TryGetValue(record.Owner.GroupId, out var group)
+            || group.Entries.FirstOrDefault(entry => entry.StableId == record.Owner.EntryId) is not { } entry || entry.Type != record.Type) return null;
+        var value = entry.Parameters.GetValueOrDefault(record.RootId);
+        // Localized text drafts include the source text in their captured baseline.
+        return value.GetRawTextSafe() + (record.Baseline.Contains('\n') && value.ValueKind == JsonValueKind.String ? "\n" + _texts.Read(value.GetString()!) : "");
+    }
+    private string Baseline(Draft draft)
+    {
+        var value = draft.Owner.Source.Parameters.GetValueOrDefault(draft.Root.Id);
+        return value.GetRawTextSafe() + (draft.Root.Semantic == GalNet.Core.Parameters.FieldValueSemantic.LocalizedText && value.ValueKind == JsonValueKind.String ? "\n" + _texts.Read(value.GetString()!) : "");
+    }
+    public bool CanRestore(ArchivedEntryDraft record) => !_disposed && _archives.Contains(record) && !record.Conflicted && Source(record) == record.Baseline
+        && !_drafts.Values.Any(draft => Address(draft) == record.Owner && draft.Root.Id == record.RootId && draft.Path.SequenceEqual(record.Path) && (draft.State.IsDirty || !draft.State.CanCommit));
+    public bool IsRestoreRequested(ArchivedEntryDraft record) => _restoreRequested.Contains(record.Id);
+    public void RequestRestore(ArchivedEntryDraft record)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        if (!CanRestore(record)) throw new EditorOperationException("entry.archiveChanged", "The archived input no longer matches its author target. Copy its text before discarding it.");
+        _restoreRequested.Add(record.Id);
+        foreach (var draft in _drafts.Values.ToArray()) TryRestore(draft);
+        NotifyChanged();
+    }
+    private void TryRestore(Draft draft)
+    {
+        LoadArchive();
+        var record = _archives.FirstOrDefault(record => _restoreRequested.Contains(record.Id) && record.Owner == Address(draft)
+            && record.Type == draft.Type && record.RootId == draft.Root.Id && record.Path.SequenceEqual(draft.Path)
+            && record.FieldType == (draft.Field.Value.ValueType.FullName ?? draft.Field.Value.ValueType.Name));
+        if (record is null || !CanRestore(record) || !draft.Owner.IsCurrent || draft.Owner.DraftIncarnation != draft.Incarnation) return;
+        draft.State.Update(record.Text, true, record.Issue, record.JsonText);
+        RemoveArchive(record);
+    }
+    public void RemoveArchive(ArchivedEntryDraft record)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        if (!_archives.Contains(record)) return;
+        var after = _archives.Where(item => item.Id != record.Id).ToArray();
+        WriteArchive(after);
+        _archives.Remove(record); _restoreRequested.Remove(record.Id); Revision++; NotifyChanged();
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/EntryEditSession.Repository.cs b/src/Editor/GalNet.Editor/Services/EntryEditSession.Repository.cs
new file mode 100644
index 00000000..76021e90
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/EntryEditSession.Repository.cs
@@ -0,0 +1,47 @@
+using GalNet.Editor.Models.Graph;
+
+namespace GalNet.Editor.Services;
+
+public sealed partial class EntryEditSession
+{
+    internal sealed class DraftOwner(EntryEditorItemViewModel owner)
+    {
+        private readonly WeakReference<EntryEditorItemViewModel> _view = new(owner);
+        private readonly Func<EntryEditorItemViewModel> _create = owner.DraftOwnerFactory();
+        public EntryEditorItemViewModel Get() => _view.TryGetTarget(out var view) ? view : _create();
+    }
+
+    // A mounted field owns its clean state. Only unfinished input is strongly retained by the project.
+    private sealed class DraftRepository
+    {
+        private readonly Dictionary<DraftKey, WeakReference<Draft>> _items = [];
+        private readonly HashSet<Draft> _pending = [];
+        public IEnumerable<Draft> Values => Live().Select(pair => pair.Value);
+        public IEnumerable<KeyValuePair<DraftKey, Draft>> Where(Func<KeyValuePair<DraftKey, Draft>, bool> predicate) => Live().Where(predicate);
+        public bool TryGetValue(DraftKey key, out Draft value)
+        {
+            if (_items.TryGetValue(key, out var reference) && reference.TryGetTarget(out value!)) return true;
+            value = null!; return false;
+        }
+        public void Add(DraftKey key, Draft value)
+        {
+            Prune(); _items.Add(key, new(value)); Track(value);
+        }
+        public Draft this[DraftKey key] { set { _items[key] = new(value); Track(value); } }
+        public void Track(Draft draft)
+        { if (draft.State.IsDirty || !draft.State.CanCommit) _pending.Add(draft); else _pending.Remove(draft); }
+        public void Remove(DraftKey key)
+        { if (TryGetValue(key, out var value)) _pending.Remove(value); _items.Remove(key); }
+        public void Clear() { _items.Clear(); _pending.Clear(); }
+        private IEnumerable<KeyValuePair<DraftKey, Draft>> Live()
+        {
+            _pending.RemoveWhere(draft => !draft.State.IsDirty && draft.State.CanCommit);
+            foreach (var pair in _items.ToArray()) if (pair.Value.TryGetTarget(out var draft)) yield return new(pair.Key, draft);
+        }
+        private void Prune()
+        {
+            _pending.RemoveWhere(draft => !draft.State.IsDirty && draft.State.CanCommit);
+            foreach (var key in _items.Where(pair => !pair.Value.TryGetTarget(out _)).Select(pair => pair.Key).ToArray()) _items.Remove(key);
+        }
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/EntryEditSession.cs b/src/Editor/GalNet.Editor/Services/EntryEditSession.cs
index 0f46113c..f88c7bff 100644
--- a/src/Editor/GalNet.Editor/Services/EntryEditSession.cs
+++ b/src/Editor/GalNet.Editor/Services/EntryEditSession.cs
@@ -1,5 +1,4 @@
 using System.Text.Json;
-using System.Text.Json.Nodes;
 using GalNet.Core.Parameters;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Models.Graph;
@@ -8,17 +7,32 @@
 namespace GalNet.Editor.Services;
 
 /// <summary>Project-owned drafts. Closing a view never releases unsubmitted author input.</summary>
-public sealed class EntryEditSession : IDisposable
+public sealed partial class EntryEditSession : IDisposable
 {
-    private readonly Dictionary<string, Draft> _drafts = new(StringComparer.Ordinal);
+    private sealed record DraftKey(string GroupId, string EntryId, string RootId, string Path, Guid Incarnation);
+    private readonly DraftRepository _drafts = new();
+    private bool _disposed;
     private readonly IDisposable _registration;
+    private readonly IDisposable _structureRegistration;
     private readonly IProjectContentSession _content;
     private readonly GameTextAuthoringService _texts;
     private readonly IEditorLocalizationService _localization;
-    public EntryEditSession(IProjectContentSession content, GameTextAuthoringService texts, IEditorLocalizationService localization)
+    public EntryEditSession(IProjectContentSession content, GameTextAuthoringService texts, IEditorLocalizationService localization,
+        IEditorDocumentService? documents = null, IProjectService? projects = null, EntryDraftArchiveLimits? limits = null, GalNet.Editor.History.EditorHistories? histories = null)
     {
         _content = content; _texts = texts; _localization = localization;
-        _registration = content.RegisterDraft(() => PendingCount > 0, CommitAsync);
+        _documents = documents; _projects = projects; _limits = limits ?? new();
+        _registration = content.RegisterDraft(() => PendingCount > 0, context => CommitAsync(context), DiscardDrafts);
+        _structureRegistration = content.RegisterStructureTransition((before, after, publish) =>
+        {
+            var surviving = after.Graph.Nodes.Where(node => node.Type == "Group").Select(node => node.Id).ToHashSet(StringComparer.Ordinal);
+            var removed = before.GroupEntries.Where(pair => !surviving.Contains(pair.Key)).SelectMany(pair => pair.Value.Select(entry =>
+            { var address = new GalNet.Editor.Shared.Services.SceneAuthorAddress(pair.Key, entry.StableId); return new EntryAddressTransition(address, address); })).ToArray();
+            if (removed.Length == 0) publish();
+            else
+                try { ApplyAuthorEdit(removed, publish, histories?.Content.AuthorChanges); }
+                catch (GalNet.Editor.History.HistoryRepairRequiredException failure) { content.BlockWrites(failure); throw; }
+        });
         content.Changed += CheckSources;
     }
     public event Action? Changed;
@@ -26,39 +40,57 @@ public EntryEditSession(IProjectContentSession content, GameTextAuthoringService
     public IEnumerable<Draft> Pending => _drafts.Values.Where(draft => draft.State.IsDirty || !draft.State.CanCommit);
 
     public FieldDraftState Get(EntryEditorItemViewModel owner, FieldDescriptor field) => Get(owner, field, field, []);
-    private FieldDraftState Get(EntryEditorItemViewModel owner, FieldDescriptor root, FieldDescriptor field, string[] path)
+    private FieldDraftState Get(EntryEditorItemViewModel owner, FieldDescriptor root, FieldDescriptor field, string[] path) => Get(new DraftOwner(owner), root, field, path);
+    private FieldDraftState Get(DraftOwner ownership, FieldDescriptor root, FieldDescriptor field, string[] path)
     {
-        var key = owner.AuthorGroupId + "/" + owner.StableId + "/" + root.Id + "/" + string.Join("/", path);
-        // The author object is a generation boundary: undo may restore the same ID with a new source.
-        key += "/" + owner.Type + "/" + System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(owner.Source);
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        var owner = ownership.Get();
+        var incarnation = owner.DraftIncarnation;
+        var key = new DraftKey(owner.AuthorGroupId!, owner.StableId, root.Id, JsonSerializer.Serialize(path), incarnation);
         if (_drafts.TryGetValue(key, out var found)) return found.State;
         var type = owner.Type;
         string Snapshot()
         {
-            if (!owner.IsCurrent || owner.Source.Type != type) return "<obsolete>";
-            var value = owner.Source.Parameters.GetValueOrDefault(root.Id);
+            var current = ownership.Get();
+            if (!current.IsCurrent || current.Source.Type != type || current.DraftIncarnation != incarnation) return "<obsolete>";
+            var value = current.Source.Parameters.GetValueOrDefault(root.Id);
             return value.GetRawTextSafe() + (root.Semantic == FieldValueSemantic.LocalizedText && value.ValueKind == JsonValueKind.String ? "\n" + _texts.Read(value.GetString()!) : "");
         }
         var state = new FieldDraftState(Snapshot);
-        var draft = new Draft(owner, root, field, path, type, state);
+        var draft = new Draft(ownership, root, field, path, type, state, incarnation);
         _drafts.Add(key, draft);
-        state.Child = (child, segment) => Get(owner, root, child, [.. path, segment]);
+        state.Child = (child, segment) => Get(ownership, root, child, [.. path, segment]);
         state.Commit = () => CommitAsync(draft);
-        state.Changed += OnChanged;
+        draft.OnChanged = () => { _drafts.Track(draft); OnChanged(); };
+        state.Changed += draft.OnChanged;
+        TryRestore(draft);
         return state;
     }
-    private void OnChanged() { _content.Refresh(); Changed?.Invoke(); }
+    private void OnChanged() { Revision++; _content.Refresh(); NotifyChanged(); }
+    private void NotifyChanged()
+    {
+        if (Changed is null) return;
+        foreach (Action observer in Changed.GetInvocationList())
+            try { observer(); } catch (Exception failure) { Serilog.Log.Error(failure, "An entry input observer failed"); }
+    }
     private void CheckSources()
     {
         foreach (var draft in _drafts.Values) draft.State.CheckSource();
+        NotifyChanged();
+    }
+    private void DiscardDrafts()
+    {
+        foreach (var draft in _drafts.Values) draft.State.Clear();
+        Changed?.Invoke();
     }
     private ValueIssue Error(string code) => new(code, _localization["Uiux.Draft." + code]);
     private async Task<ValueIssue?> CommitAsync(Draft draft)
     {
+        if (_disposed) return Error("Conflict");
         var state = draft.State;
         if (!state.CanCommit) return Error("Composing");
         if (!state.IsDirty) return null;
-        if (state.IsConflicted || !draft.Owner.IsCurrent || draft.Owner.Type != draft.Type) return Error("Conflict");
+        if (state.IsConflicted || !draft.Owner.IsCurrent || draft.Owner.Type != draft.Type || draft.Owner.DraftIncarnation != draft.Incarnation) return Error("Conflict");
         try
         {
             FieldValue candidate;
@@ -68,6 +100,11 @@ private void CheckSources()
                 if (draft.Field.Semantic == FieldValueSemantic.LocalizedText)
                 {
                     var key = draft.Owner.Source.Parameters.GetValueOrDefault(draft.Root.Id);
+                    if (draft.Path.Length > 0)
+                    {
+                        using var snapshot = new ValueDocument(draft.Root, key);
+                        key = snapshot.FindProperty(draft.Path)?.Value ?? default;
+                    }
                     textDraft = _texts.Register(_texts.Capture(key.ValueKind == JsonValueKind.String ? key.GetString()! : "", draft.Owner.StableId), state.Text);
                     candidate = new(JsonSerializer.SerializeToElement(textDraft.Token));
                 }
@@ -79,22 +116,10 @@ private void CheckSources()
                 if (draft.Path.Length > 0)
                 {
                     var source = draft.Owner.Source.Parameters.GetValueOrDefault(draft.Root.Id);
-                    var encoded = source.ValueKind == JsonValueKind.String;
-                    var root = source.ValueKind is JsonValueKind.Undefined or JsonValueKind.Null ? new JsonObject()
-                        : JsonNode.Parse(encoded ? source.GetString()! : source.GetRawText())!;
-                    JsonNode node = root;
-                    foreach (var segment in draft.Path[..^1])
-                    {
-                        var child = Child(node, segment);
-                        if (child is null && node is JsonObject obj) { child = new JsonObject(); obj[Wire(obj, segment)] = child; }
-                        node = child ?? throw new InvalidDataException("The draft's object or list target is no longer available.");
-                    }
-                    var last = draft.Path[^1];
-                    var replacement = candidate.Json is { } json ? JsonNode.Parse(json.GetRawText()) : null;
-                    if (node is JsonArray array) array[int.Parse(last, System.Globalization.CultureInfo.InvariantCulture)] = replacement;
-                    else if (candidate.IsProvided) node[Wire(node, last)] = replacement;
-                    else ((JsonObject)node).Remove(Wire(node, last));
-                    candidate = new(encoded ? JsonSerializer.SerializeToElement(root.ToJsonString()) : JsonSerializer.SerializeToElement(root));
+                    using var document = new ValueDocument(draft.Root, source);
+                    var patch = document.Patch(draft.Path, candidate.Json);
+                    if (patch.Issue is not null) return patch.Issue;
+                    candidate = new(patch.Value);
                 }
                 var result = await draft.Owner.CommitParameterAsync(draft.Root, candidate, CancellationToken.None);
                 if (result is null) state.Clear();
@@ -105,17 +130,11 @@ private void CheckSources()
         catch (Exception exception) when (exception is JsonException or ArgumentException or InvalidOperationException or InvalidDataException)
         { return new("field.draft", exception.Message); }
     }
-    private static string Wire(JsonNode node, string name)
-    {
-        if (node is not JsonObject obj) return name;
-        var matches = obj.Select(pair => pair.Key).Where(key => key.Equals(name, StringComparison.OrdinalIgnoreCase)).ToArray();
-        return matches.Length > 1 ? throw new InvalidDataException("The draft's property name is ambiguous.") : matches.SingleOrDefault() ?? name;
-    }
-    private static JsonNode? Child(JsonNode node, string name) => node is JsonArray array ? array[int.Parse(name, System.Globalization.CultureInfo.InvariantCulture)] : node[Wire(node, name)];
-    public async Task CommitAsync()
+    public Task CommitAsync() => CommitAsync(default(ProjectDraftCommitContext));
+    private async Task CommitAsync(ProjectDraftCommitContext context)
     {
         var failures = new List<string>();
-        foreach (var draft in Pending.ToArray())
+        foreach (var draft in Pending.Where(draft => context.RemovingGroups?.Contains(draft.Owner.AuthorGroupId!) != true).ToArray())
             if (await CommitAsync(draft) is { } issue)
             {
                 draft.State.Update(draft.State.Text, draft.State.IsDirty, issue, draft.State.JsonText);
@@ -125,17 +144,28 @@ public async Task CommitAsync()
     }
     public void Dispose()
     {
+        _disposed = true;
         _registration.Dispose();
+        _structureRegistration.Dispose();
         _content.Changed -= CheckSources;
-        foreach (var draft in _drafts.Values) draft.State.Changed -= OnChanged;
-        _drafts.Clear(); Changed = null;
+        foreach (var draft in _drafts.Values) draft.State.Changed -= draft.OnChanged;
+        _drafts.Clear(); _archives.Clear(); _restoreRequested.Clear(); Changed = null;
+    }
+    public sealed class Draft
+    {
+        private readonly DraftOwner _owner;
+        internal Draft(DraftOwner owner, FieldDescriptor root, FieldDescriptor field, string[] path, string type, FieldDraftState state, Guid incarnation)
+        { _owner = owner; Root = root; Field = field; Path = path; Type = type; State = state; Incarnation = incarnation; }
+        public EntryEditorItemViewModel Owner => _owner.Get();
+        public FieldDescriptor Root { get; }
+        public FieldDescriptor Field { get; }
+        public string[] Path { get; }
+        public string Type { get; }
+        public FieldDraftState State { get; }
+        public Guid Incarnation { get; }
+        internal Action? OnChanged { get; set; }
     }
-    public sealed record Draft(EntryEditorItemViewModel Owner, FieldDescriptor Root, FieldDescriptor Field, string[] Path, string Type, FieldDraftState State);
-    internal string Summary(EntryEditorItemViewModel owner) => string.Join(" · ", owner.Source.Parameters
-        .Where(pair => pair.Key is "content" or "speaker" or "asset" or "assetId" or "target" or "expression" or "handleId")
-        .Select(pair => pair.Key == "content" && pair.Value.ValueKind == JsonValueKind.String ? _texts.Read(pair.Value.GetString()!) ?? pair.Value.GetString()
-            : pair.Value.ValueKind == JsonValueKind.String ? pair.Value.GetString() : pair.Value.GetRawText())
-        .Where(value => !string.IsNullOrWhiteSpace(value))).Replace('\n', ' ');
+    internal string Summary(EntryEditorItemViewModel owner) => owner.FormatSummary(_texts.Read);
 }
 
 internal static class DraftJson
diff --git a/src/Editor/GalNet.Editor/Services/EntryFieldAuthoringService.cs b/src/Editor/GalNet.Editor/Services/EntryFieldAuthoringService.cs
index 06227784..1bb1a9aa 100644
--- a/src/Editor/GalNet.Editor/Services/EntryFieldAuthoringService.cs
+++ b/src/Editor/GalNet.Editor/Services/EntryFieldAuthoringService.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
@@ -6,9 +7,9 @@
 namespace GalNet.Editor.Services;
 
 /// <summary>Entry field intents retain author values and stable IDs, never a page or control.</summary>
-public sealed class EntryFieldAuthoringService(IEditorDocumentService documents, EditorHistories histories, CharacterAuthoringService? characters = null, GameTextAuthoringService? texts = null)
+public sealed class EntryFieldAuthoringService(IEditorDocumentService documents, EditorHistories histories, CharacterAuthoringService? characters = null, GameTextAuthoringService? texts = null, EntryEditSession? edits = null, IProjectContentSession? content = null)
 {
-    public event Action<string>? Changed;
+    internal AuthorChangeJournal Changes => histories.Content.AuthorChanges;
     internal bool IsCurrent(string groupId, EditorEntryData expected) => documents.IsLoaded
         && documents.CurrentDocument.Nodes.Any(node => node.Id == groupId && node.Type == "Group")
         && documents.Groups.TryGetValue(groupId, out var group) && group.Entries.Any(entry => ReferenceEquals(entry, expected));
@@ -29,15 +30,32 @@ public async Task SetParametersAsync(string groupId, EditorEntryData expected, s
     }
 
     public void SetType(string groupId, EditorEntryData expected, string type, Dictionary<string, JsonElement> parameters) =>
-        Update(groupId, expected, expected.Type, new(type, expected.Condition, GalNet.Editor.Shared.Services.SceneAuthoringIdentities.NewEntry(type, Clone(parameters))), "Edit Type");
+        Update(groupId, expected, expected.Type, TypeValue(expected, type, parameters), "Edit Type");
+
+    private EntryValue TypeValue(EditorEntryData entry, string type, Dictionary<string, JsonElement> parameters) =>
+        new(type, entry.Condition, GalNet.Editor.Shared.Services.SceneAuthoringIdentities.ChangeType(entry.Type, entry.Parameters, type,
+            GalNet.Editor.Shared.Visuals.VisualPresetBindings.Fill(type, Clone(parameters), content?.CaptureWorking().Configuration)));
+
+    public PreparedEntryEdit PrepareType(string groupId, EditorEntryData expected, string type, Dictionary<string, JsonElement> parameters)
+    {
+        if (!IsCurrent(groupId, expected)) throw Obsolete();
+        var after = TypeValue(expected, type, parameters);
+        var address = new GalNet.Editor.Shared.Services.SceneAuthorAddress(groupId, expected.StableId);
+        var draftRevision = edits?.Revision;
+        return new(documents, histories, Wrap(new FieldEdit(this, groupId, expected.StableId, Capture(expected), after, "Edit Type")),
+            candidate => Write(candidate.GroupEntries[groupId].Single(entry => entry.StableId == expected.StableId), after),
+            edits?.CountPending([address]) ?? 0, () => edits?.Revision == draftRevision);
+    }
 
     private void Update(string groupId, EditorEntryData expected, string expectedType, EntryValue after, string description)
     {
         var entry = Find(groupId, expected.StableId);
         if (!ReferenceEquals(entry, expected) || entry.Type != expectedType) throw Obsolete();
         var before = Capture(entry);
-        if (!Equal(before, after)) histories.Content.Execute(new FieldEdit(this, groupId, entry.StableId, before, after, description));
+        if (!Equal(before, after)) histories.Content.Execute(Wrap(new FieldEdit(this, groupId, entry.StableId, before, after, description)));
     }
+    private IUndoableEdit Wrap(FieldEdit edit) => edit.Before.Type != edit.After.Type && edits is not null
+        ? new EntryDraftLifecycleEdit(edits, edit, [new(new(edit.GroupId, edit.EntryId), new(edit.GroupId, edit.EntryId))], Changes) : edit;
 
     private EditorEntryData Find(string groupId, string id)
     {
@@ -45,6 +63,7 @@ private EditorEntryData Find(string groupId, string id)
             || !documents.Groups.TryGetValue(groupId, out var group)) throw Obsolete();
         return group.Entries.SingleOrDefault(entry => entry.StableId == id) ?? throw Obsolete();
     }
+    private int IndexOf(string groupId, EditorEntryData entry) => documents.Groups[groupId].Entries.IndexOf(entry);
 
     private sealed record EntryValue(string Type, string Condition, Dictionary<string, JsonElement> Parameters);
     private static Dictionary<string, JsonElement> Clone(IReadOnlyDictionary<string, JsonElement> values) =>
@@ -56,7 +75,7 @@ private static void Write(EditorEntryData entry, EntryValue value)
     { entry.Type = value.Type; entry.Condition = value.Condition; entry.Parameters = Clone(value.Parameters); }
     private static EditorOperationException Obsolete() => new("entry.obsolete", "The entry or its schema is no longer current.");
 
-    private sealed record FieldEdit(EntryFieldAuthoringService Owner, string GroupId, string EntryId, EntryValue Before, EntryValue After, string Description) : IUndoableEdit
+    private sealed record FieldEdit(EntryFieldAuthoringService Owner, string GroupId, string EntryId, EntryValue Before, EntryValue After, string Description) : IUndoableEdit, IAuthorScopedEdit
     {
         public EditorText DisplayText => new(Description switch
         {
@@ -71,13 +90,11 @@ private void Apply(EntryValue expected, EntryValue value)
         {
             var entry = Owner.Find(GroupId, EntryId);
             if (!Equal(Capture(entry), expected)) throw new EditorOperationException("entry.changed", "The entry changed outside this edit.");
-            try { Write(entry, value); Owner.Changed?.Invoke(GroupId); }
-            catch (Exception failure)
-            {
-                try { Write(entry, expected); Owner.Changed?.Invoke(GroupId); }
-                catch (Exception compensation) { throw new HistoryRepairRequiredException("Entry field compensation failed.", new AggregateException(failure, compensation)); }
-                throw;
-            }
+            Write(entry, value);
+            var kind = (expected.Type != value.Type ? GroupChangeKind.EntryType : GroupChangeKind.None)
+                | (expected.Condition != value.Condition ? GroupChangeKind.Condition : GroupChangeKind.None)
+                | (!Equal(expected with { Type = value.Type, Condition = value.Condition }, value) ? GroupChangeKind.Parameters : GroupChangeKind.None);
+            Owner.Changes.Record(GroupId, Owner.IndexOf(GroupId, entry), kind, [EntryId]);
         }
     }
 }
diff --git a/src/Editor/GalNet.Editor/Services/EntrySummaryFormatter.cs b/src/Editor/GalNet.Editor/Services/EntrySummaryFormatter.cs
new file mode 100644
index 00000000..0de5441c
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/EntrySummaryFormatter.cs
@@ -0,0 +1,39 @@
+using System.Text.Json;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+internal static class EntrySummaryFormatter
+{
+    public static string Build(EditorEntryData entry, Func<string, string?>? text = null, SceneTargetCatalog? scenes = null, string? group = null)
+    {
+        List<string> parts = [];
+        if (entry.Type is GalNet.Contracts.Builtins.BuiltinEntryIds.ApplyAudioSEffect or GalNet.Contracts.Builtins.BuiltinEntryIds.StopAudioSEffect or GalNet.Contracts.Builtins.BuiltinEntryIds.UpdateAudioSEffect)
+        {
+            if (entry.Parameters.GetValueOrDefault("targetId") is { ValueKind: JsonValueKind.String } target) parts.Add(target.GetString() ?? "");
+            if (entry.Type == GalNet.Contracts.Builtins.BuiltinEntryIds.ApplyAudioSEffect && entry.Parameters.GetValueOrDefault("id") is { ValueKind: JsonValueKind.String } effectType)
+                parts.Add(scenes?.AudioTypeName(effectType.GetString() ?? "") ?? effectType.GetString() ?? "");
+            if (entry.Type == GalNet.Contracts.Builtins.BuiltinEntryIds.StopAudioSEffect && entry.Parameters.GetValueOrDefault("all").ValueKind == JsonValueKind.True)
+                parts.Add(scenes?.Text["Audio.AllEffects"] ?? "All effects");
+        }
+        foreach (var (field, value) in entry.Parameters)
+        {
+            if (field is not ("content" or "speaker" or "asset" or "assetId" or "expression" or "toAssetId" or "program")) continue;
+            if (SceneAuthoringSemantics.Reference(entry.Type, field) is not null || SceneAuthoringIdentities.IsOutput(entry.Type, field)) continue;
+            var raw = value.ValueKind == JsonValueKind.String ? value.GetString() ?? "" : value.GetRawText();
+            if (field == "content" && text is not null) raw = text(raw) ?? raw;
+            else if (field is "asset" or "assetId" or "toAssetId" or "program") raw = scenes?.ResourceLabel(raw) ?? (Guid.TryParse(raw, out _) ? "" : raw);
+            if (!string.IsNullOrWhiteSpace(raw)) parts.Add(raw);
+        }
+        if (scenes is not null && group is not null)
+            foreach (var slot in SceneAuthoringSemantics.Find(entry.Type)?.References ?? [])
+            {
+                if (!entry.Parameters.TryGetValue(slot.Field, out var value) || value.ValueKind != JsonValueKind.String) continue;
+                var raw = value.GetString();
+                if (string.IsNullOrWhiteSpace(raw)) { if (slot.AllowsGlobal) parts.Add(scenes.Text["Scene.Global"]); continue; }
+                parts.Add(scenes.ReferenceLabel(group, entry.StableId, slot, raw!));
+            }
+        return string.Join(" · ", parts.Distinct(StringComparer.Ordinal)).Replace('\n', ' ');
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/GameExportService.cs b/src/Editor/GalNet.Editor/Services/GameExportService.cs
index 0f24bf6a..c325c36f 100644
--- a/src/Editor/GalNet.Editor/Services/GameExportService.cs
+++ b/src/Editor/GalNet.Editor/Services/GameExportService.cs
@@ -1,8 +1,8 @@
 using System.Threading;
 using System.Threading.Tasks;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Services.Interfaces;
 using GalNet.Editor.Shared.Services;
@@ -19,8 +19,12 @@ public async Task<GameExportResult> ExportAsync(string outputDirectory, Cancella
     {
         var project = projects.Current;
         if (project is null) return GameExportResult.Failed("Open a project before exporting.");
+        await project.Services.GetRequiredService<IProjectContentSession>().SaveAsync(cancellationToken);
+        using var capture = await project.Services.GetRequiredService<GalNet.Editor.History.EditorHistories>().Content
+            .AcquireCaptureAsync(cancellationToken: cancellationToken);
+        if (!ReferenceEquals(project, projects.Current)) return GameExportResult.Failed("The project was closed.");
         var catalog = project.Services.GetRequiredService<IEntryCatalog>();
-        var result = await GamePackageExporter.ExportAsync(project.Id, project.Name, project.RootPath, outputDirectory, resourceTypes, galleryTypes, catalog, cancellationToken);
+        var result = await Task.Run(() => GamePackageExporter.ExportAsync(project.Id, project.Name, project.RootPath, outputDirectory, resourceTypes, galleryTypes, catalog, project.Configurations, cancellationToken), cancellationToken);
         return new GameExportResult(result.Success, result.PackagePath, result.Error);
     }
 }
diff --git a/src/Editor/GalNet.Editor/Services/GameLocalizationPanelService.cs b/src/Editor/GalNet.Editor/Services/GameLocalizationPanelService.cs
index 85e30b55..01b202f6 100644
--- a/src/Editor/GalNet.Editor/Services/GameLocalizationPanelService.cs
+++ b/src/Editor/GalNet.Editor/Services/GameLocalizationPanelService.cs
@@ -1,5 +1,6 @@
 using System.Globalization;
 using System.Text.Json.Nodes;
+using GalNet.Contracts.Builtins;
 using GalNet.Core.I18n;
 using GalNet.Core.Parameters;
 using GalNet.Editor.Abstraction.Services;
@@ -10,7 +11,14 @@
 namespace GalNet.Editor.Services;
 
 public sealed record LocalizationCategory(string Id, string Name);
-public sealed record LocalizationTableRow(string Key, string Context, IReadOnlyList<LocalizationReference> References);
+public sealed record LocalizationRowContext(string Title, string Slot, string Details, LocalizationReference Reference)
+{
+    public string DisplayDetails { get; init; } = Details;
+}
+public sealed record LocalizationTableRow(string Key, string Context, IReadOnlyList<LocalizationReference> References)
+{
+    public IReadOnlyList<LocalizationRowContext> Locations { get; init; } = [];
+}
 public sealed record LocalizationTableSnapshot(string Source, IReadOnlyList<string> Languages,
     IReadOnlyList<LocalizationCategory> Categories, IReadOnlyList<LocalizationTableRow> Rows, LocalizationReferenceIndex Index, byte[] Metadata);
 public sealed record LocalizationCellDraft(string Category, LocalizationTextTarget Target, string SourceLocale, string? SourceText);
@@ -29,8 +37,13 @@ public void Navigate(LocalizationTableRow row)
         if (row.References.FirstOrDefault() is { } reference)
             projects.Current!.Services.GetRequiredService<GalNet.Editor.Dock.EditorDockFactory>().NavigateLocalization(reference.Owner, reference.EntryId);
     }
-    private string Source => content.CaptureWorking().Settings.TargetLocale.Code;
-    public IReadOnlyList<string> Languages => new[] { Source }.Concat(content.CaptureWorking().Settings.AvailableLocales.Select(locale => locale.Code))
+    public void Navigate(LocalizationReference reference)
+    {
+        Active();
+        projects.Current!.Services.GetRequiredService<GalNet.Editor.Dock.EditorDockFactory>().NavigateLocalization(reference.Owner, reference.EntryId);
+    }
+    private string Source => content.CaptureWorking().Configuration.ReadDefaultOptions().TargetLocale.Code;
+    public IReadOnlyList<string> Languages => new[] { Source }.Concat(content.CaptureWorking().Configuration.ReadDefaultOptions().AvailableLocales.Select(locale => locale.Code))
         .Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
     private void Active() { _ = store.CaptureFile(LocalizationJson.MetadataPath); }
     private static string Normalize(string value)
@@ -51,30 +64,49 @@ private IReadOnlyList<LocalizationReference> References(LocalizationReferenceInd
     }
     public LocalizationTableSnapshot Snapshot(string category)
     {
-        Active(); var document = content.CaptureWorking(); var index = query.Get()!;
+        Active(); var document = content.CaptureWorking(); var index = query.Get()!; var source = document.Configuration.ReadDefaultOptions().TargetLocale.Code;
         var categories = new List<LocalizationCategory> { new("characters", text["I18n.Characters"]) };
         categories.AddRange(document.Graph.Nodes.Where(node => node.Type == "Group").Select(node => new LocalizationCategory(node.Id, node.Name)));
         categories.Add(new("branches", text["I18n.Branches"]));
-        var contexts = new Dictionary<(string Owner, string? Entry), string>();
-        if (category == "characters")
-            foreach (var (character, position) in index.Characters.Select((character, position) => (character, position)))
-                contexts.TryAdd(("characters", character.Id), text.Format("I18n.CharacterRow", position + 1));
-        else if (category == "branches")
-            foreach (var node in document.Graph.Nodes.Where(node => node.Type == "Branch" && node.BranchType == "Choice"))
-                foreach (var (option, position) in (node.Options ?? []).Select((option, position) => (option, position)))
-                    contexts.TryAdd((node.Id, option.Id), node.Name + " · " + text.Format("I18n.OptionRow", position + 1));
-        else if (document.GroupEntries.TryGetValue(category, out var entries))
-            foreach (var (entry, position) in entries.Select((entry, position) => (entry, position)))
-                contexts.TryAdd((category, entry.StableId), text.Format("I18n.EntryRow", position + 1, ""));
+        LocalizationRowContext Context(LocalizationReference reference)
+        {
+            var id = reference.EntryId ?? reference.Owner;
+            var title = id.Length > 12 ? id[..8] + "…" + id[^4..] : id;
+            var slot = reference.LocationKey.TrimStart('/');
+            var details = reference.Owner + "/" + id + reference.LocationKey;
+            var displayDetails = details;
+            if (category == "characters")
+            {
+                var character = index.Characters.FirstOrDefault(item => item.Id == reference.EntryId);
+                title = character is null ? id : index.FindDirect(source, character.DisplayNameKey)?.Text ?? id;
+                slot = "";
+            }
+            else if (category == "branches")
+            {
+                var node = document.Graph.Nodes.FirstOrDefault(item => item.Id == reference.Owner);
+                title = node?.Name ?? reference.Owner;
+                slot = id + " · " + slot;
+            }
+            else
+            {
+                var entry = reference.EntryId is { } entryId
+                    ? document.GroupEntries.GetValueOrDefault(reference.Owner)?.FirstOrDefault(item => item.StableId == entryId)
+                    : null;
+                if (entry is not null)
+                {
+                    title = $"Entry{entry.Id}";
+                    displayDetails = $"Entry{entry.Id}{reference.LocationKey}";
+                }
+            }
+            return new(title, slot, details, reference) { DisplayDetails = displayDetails };
+        }
         var rows = References(index, category).GroupBy(reference => reference.Key, StringComparer.Ordinal).Select(group =>
         {
-            var refs = group.ToArray(); var first = refs[0];
-            var context = contexts.GetValueOrDefault((first.Owner, first.EntryId), "");
-            if (category is not ("characters" or "branches")) context += first.JsonPointer;
-            if (refs.Length > 1) context += " · " + text.Format("GameText.Shared", refs.Length);
-            return new LocalizationTableRow(group.Key, context, refs);
+            var refs = group.ToArray(); var locations = refs.Select(Context).ToArray();
+            var context = string.Join(" · ", locations.Select(location => location.Title + " " + location.Slot + " " + location.DisplayDetails));
+            return new LocalizationTableRow(group.Key, context, refs) { Locations = locations };
         }).ToArray();
-        return new(Source, Languages, categories, rows, index, store.CaptureFile(LocalizationJson.MetadataPath).Data);
+        return new(source, Languages, categories, rows, index, store.CaptureFile(LocalizationJson.MetadataPath).Data);
     }
     private void Current(LocalizationCellDraft draft)
     {
@@ -143,6 +175,14 @@ public Task MoveLanguageAsync(string code, int direction)
         (languages[position], languages[next]) = (languages[next], languages[position]);
         return SetLanguagesAsync(Source, languages);
     }
+    public Task RemoveLanguageAsync(string value)
+    {
+        Active(); var code = Normalize(value);
+        if (code == Source) throw new EditorOperationException("i18n.source", text["Uiux.I18n.RemoveSource"]);
+        if (!Languages.Contains(code, StringComparer.OrdinalIgnoreCase)) throw new EditorOperationException("i18n.stale", text["I18n.Stale"]);
+        // Only remove support from settings. Retain translations and evidence for re-adding/undo.
+        return SetLanguagesAsync(Source, Languages.Where(language => !language.Equals(code, StringComparison.OrdinalIgnoreCase)).ToArray());
+    }
     public DevelopmentLanguagePreview Preview(string value)
     {
         Active(); var target = Normalize(value);
@@ -159,10 +199,11 @@ public Task ChangeDevelopmentLanguageAsync(DevelopmentLanguagePreview preview)
     }
     private Task SetLanguagesAsync(string source, IReadOnlyList<string> languages, Action? validate = null)
     {
-        Active(); var settings = projects.Current!.Settings;
-        return histories.Content.ExecuteAsync(new LanguageEdit(settings, settings.TargetLocale.Code, settings.AvailableLocales.Select(locale => locale.Code).ToArray(), source, languages.ToArray(), Active, validate));
+        Active(); var configuration = projects.Current!.Configuration;
+        var settings = configuration.ReadDefaultOptions();
+        return histories.Content.ExecuteAsync(new LanguageEdit(configuration, settings.TargetLocale.Code, settings.AvailableLocales.Select(locale => locale.Code).ToArray(), source, languages.ToArray(), Active, validate));
     }
-    private sealed record LanguageEdit(GalNet.Core.Settings.ProjectSettings Settings, string BeforeSource, string[] Before, string AfterSource, string[] After, Action Active, Action? Validate) : IUndoableEdit
+    private sealed record LanguageEdit(GalNet.Core.Configuration.ProjectConfiguration Configuration, string BeforeSource, string[] Before, string AfterSource, string[] After, Action Active, Action? Validate) : IUndoableEdit
     {
         public string Description => "Change project languages";
         public EditorText DisplayText => new("History.Languages");
@@ -172,9 +213,11 @@ private sealed record LanguageEdit(GalNet.Core.Settings.ProjectSettings Settings
         private void Apply(string expectedSource, string[] expected, string source, string[] value)
         {
             Active();
-            if (Settings.TargetLocale.Code != expectedSource || !Settings.AvailableLocales.Select(locale => locale.Code).SequenceEqual(expected))
+            var settings = Configuration.ReadDefaultOptions();
+            if (settings.TargetLocale.Code != expectedSource || !settings.AvailableLocales.Select(locale => locale.Code).SequenceEqual(expected))
                 throw new EditorOperationException("i18n.stale", "Project languages changed.");
-            Settings.TargetLocale = new I18nLocale(source); Settings.AvailableLocales = value.Select(code => new I18nLocale(code)).ToList();
+            settings.TargetLocale = new I18nLocale(source); settings.AvailableLocales = value.Select(code => new I18nLocale(code)).ToList();
+            Configuration.Set(DefaultProjectConfiguration.Section, settings);
         }
     }
 }
diff --git a/src/Editor/GalNet.Editor/Services/GameTextAuthoringService.cs b/src/Editor/GalNet.Editor/Services/GameTextAuthoringService.cs
index 18f7dd25..db72f466 100644
--- a/src/Editor/GalNet.Editor/Services/GameTextAuthoringService.cs
+++ b/src/Editor/GalNet.Editor/Services/GameTextAuthoringService.cs
@@ -1,5 +1,6 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
+using GalNet.Contracts.Builtins;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
 using GalNet.Core.Primitives;
@@ -25,7 +26,7 @@ public sealed class GameTextAuthoringService(LocalizationDocumentStore store, Pr
     private readonly Dictionary<string, GameTextDraft> _drafts = new(StringComparer.Ordinal);
     public IEditorLocalizationService Text => text;
     public event Action? Changed { add => content.Changed += value; remove => content.Changed -= value; }
-    public string Culture => content.CaptureWorking().Settings.TargetLocale.Code;
+    public string Culture => content.CaptureWorking().Configuration.ReadDefaultOptions().TargetLocale.Code;
     public string? Read(string key) => string.IsNullOrEmpty(key) ? null : query.Get()?.FindDirect(Culture, key)?.Text;
     public int Uses(string key) => query.Get()?.References.Count(reference => reference.Semantic == FieldValueSemantic.LocalizedText && reference.Key == key) ?? 0;
     public LocalizationTextTarget Capture(string key, string owner) => store.CaptureText(key.Length == 0 ? NewKey(owner) : key, newFile: $"I18n/{Culture}/authoring.json");
@@ -58,7 +59,7 @@ public Task<IReadOnlyList<LocalizationFilePatch>> PrepareTextAsync(LocalizationT
         var drafts = references.Select(reference => _drafts[reference.Key]).DistinctBy(draft => draft.Token).ToArray();
         var files = await PrepareFilesAsync(drafts, existing, current);
         var root = JsonSerializer.SerializeToNode(parameters)!;
-        foreach (var reference in references) Set(root, reference.JsonPointer, _drafts[reference.Key].Key);
+        foreach (var reference in references) Set(root, reference, _drafts[reference.Key].Key);
         return new(root.Deserialize<Dictionary<string, JsonElement>>()!, files);
     }
     public async Task<bool> CommitEntryAsync(string group, EditorEntryData entry, string type, Dictionary<string, JsonElement> parameters, Func<bool> isCurrent, CancellationToken token)
@@ -71,7 +72,7 @@ void Current()
         }
         Current(); var change = await PrepareEntryAsync(group, entry, parameters, [], Current);
         if (change is null) return false;
-        Current(); catalog.Get(type).DynamicParameters?.ValidatePartialArguments(JsonSerializer.SerializeToElement(change.Parameters.Where(pair => catalog.Get(type).Parameters.ContainsKey(pair.Key) &&
+        Current(); catalog.Get(type).DynamicParameters.ValidatePartialArguments(JsonSerializer.SerializeToElement(change.Parameters.Where(pair => catalog.Get(type).DynamicParameters.ContainsKey(pair.Key) &&
             (!before.TryGetValue(pair.Key, out var previous) || !JsonElement.DeepEquals(previous, pair.Value))).ToDictionary(pair => pair.Key, pair => pair.Value)));
         if (change.Files.Count == 0 && LocalizationEditOperation.Same(before, change.Parameters)) return true;
         await authoring.ApplyAsync(store.PrepareWithEntries(change.Files, [new(group, entry.StableId, type, before, change.Parameters)]), entry.StableId, "History.GameText");
@@ -201,7 +202,7 @@ public static void ValidateClipboard(GameTextClipboard value)
         foreach (var entry in entries)
         {
             var root = JsonSerializer.SerializeToNode(entry.Parameters)!;
-            foreach (var reference in References("clipboard", entry)) Set(root, reference.JsonPointer, map[reference.Key]);
+            foreach (var reference in References("clipboard", entry)) Set(root, reference, map[reference.Key]);
             entry.Parameters = root.Deserialize<Dictionary<string, JsonElement>>()!;
         }
         foreach (var option in options.SelectMany(node => node.Options ?? [])) if (map.TryGetValue(option.Text, out var key)) option.Text = key;
@@ -225,7 +226,7 @@ public FieldCopy StageCopy(ValueDescriptor descriptor, JsonElement value)
             JsonElement? state = metadata.RootElement.TryGetProperty("textStates", out var states) && states.TryGetProperty(group.Key, out var existing) ? existing.Clone() : null;
             var target = store.CaptureText(key); var draft = Register(target, translations.GetValueOrDefault(Culture) ?? "") with { Translations = translations, State = state, WriteSource = translations.ContainsKey(Culture) };
             _drafts[draft.Token] = draft; drafts.Add(draft);
-            foreach (var reference in group) Set(root, reference.JsonPointer, draft.Token);
+            foreach (var reference in group) Set(root, reference, draft.Token);
         }
         return new(root["value"]!.Deserialize<JsonElement>(), () => { foreach (var draft in drafts) Release(draft); });
     }
@@ -254,6 +255,12 @@ private sealed class OptionBinding(GameTextAuthoringService owner, string node,
         private void Refresh() => _changed?.Invoke(this, EventArgs.Empty);
         public Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken cancellationToken) => owner.CommitOptionAsync(node, option, value, cancellationToken);
     }
+    public static void Set(JsonNode root, LocalizationReference reference, string value)
+    {
+        var updated = reference.Rewrite(JsonSerializer.SerializeToElement(root), value);
+        var target = root.AsObject(); target.Clear();
+        foreach (var member in updated.EnumerateObject()) target.Add(member.Name, JsonNode.Parse(member.Value.GetRawText()));
+    }
     public static void Set(JsonNode root, string pointer, string value)
     {
         var parts = pointer.Split('/').Skip(1).Select(part => part.Replace("~1", "/", StringComparison.Ordinal).Replace("~0", "~", StringComparison.Ordinal)).ToArray();
diff --git a/src/Editor/GalNet.Editor/Services/GraphAuthoringService.cs b/src/Editor/GalNet.Editor/Services/GraphAuthoringService.cs
index 74a34a38..022c372e 100644
--- a/src/Editor/GalNet.Editor/Services/GraphAuthoringService.cs
+++ b/src/Editor/GalNet.Editor/Services/GraphAuthoringService.cs
@@ -3,6 +3,7 @@
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
+using GalNet.Editor.Shared.Commands;
 
 namespace GalNet.Editor.Services;
 
@@ -12,7 +13,7 @@ public sealed partial class GraphAuthoringService(IEditorDocumentService documen
     public async Task<string> AddNodeAsync(GraphNodeKind kind, double x, double y, string? fromId = null, int outlet = 0, string? fromItemId = null)
     {
         if (kind == GraphNodeKind.Entry) throw new EditorOperationException("graph.rootExists", "The project already owns its Entry root.");
-        if (!double.IsFinite(x) || !double.IsFinite(y)) throw new EditorOperationException("graph.coordinates", "Node coordinates must be finite.");
+        if (!GraphEditRules.IsFinitePosition(x, y)) throw new EditorOperationException("graph.coordinates", "Node coordinates must be finite.");
         var id = Guid.NewGuid().ToString("N");
         var node = new EditorGraphNodeDto
         {
@@ -49,6 +50,7 @@ public Task DeleteNodesAsync(IEnumerable<string> nodeIds)
     public void Rename(string id, string value)
     {
         if (string.IsNullOrWhiteSpace(value)) throw new EditorOperationException("graph.nameRequired", "Node name is required.");
+        value = GraphEditRules.NormalizeName(value);
         var before = Find(id).Name;
         if (before != value) histories.Content.Execute(new NameEdit(documents, id, before, value));
     }
@@ -58,12 +60,37 @@ public void Move(IReadOnlyDictionary<string, (double X, double Y)> positions)
         var changes = positions.Select(pair =>
         {
             var node = Find(pair.Key);
-            if (!double.IsFinite(pair.Value.X) || !double.IsFinite(pair.Value.Y)) throw new EditorOperationException("graph.coordinates", "Node coordinates must be finite.");
+            if (!GraphEditRules.IsFinitePosition(pair.Value.X, pair.Value.Y)) throw new EditorOperationException("graph.coordinates", "Node coordinates must be finite.");
             return new Position(pair.Key, node.X, node.Y, pair.Value.X, pair.Value.Y);
         }).Where(item => item.X != item.NextX || item.Y != item.NextY).ToArray();
         if (changes.Length > 0) histories.Content.Execute(new MoveEdit(documents, changes));
     }
 
+    public void SetStoryPackage(string id, string value)
+    {
+        var node = Find(id);
+        if (node.Type != "Group") throw new EditorOperationException("graph.groupRequired", "Only Groups may declare a story package.");
+        value = value.Trim();
+        if (value.Length > 128 || value.Any(char.IsControl)) throw new EditorOperationException("graph.packageName", "Story package names must be at most 128 characters without control characters.");
+        if (documents.CurrentDocument.Nodes.Any(other => other.Id != id && string.Equals(other.StoryPackage, value, StringComparison.OrdinalIgnoreCase)
+                && other.StoryPackage != value)) throw new EditorOperationException("graph.packageName", "Story package names cannot differ only by case.");
+        if ((node.StoryPackage ?? "") != value) histories.Content.Execute(new StoryPackageEdit(documents, id, node.StoryPackage, value.Length == 0 ? null : value));
+    }
+
+    private sealed record StoryPackageEdit(IEditorDocumentService Source, string Id, string? Before, string? After) : IUndoableEdit
+    {
+        public string Description => "Change Group story package";
+        public long RetainedBytes => ((Before?.Length ?? 0) + (After?.Length ?? 0) + Id.Length) * 2L;
+        public void Undo() => Apply(After, Before);
+        public void Redo() => Apply(Before, After);
+        private void Apply(string? expected, string? value)
+        {
+            var node = Source.CurrentDocument.Nodes.Single(node => node.Id == Id);
+            if (node.StoryPackage != expected) throw new EditorOperationException("graph.changed", "The Group story package changed outside this edit.");
+            node.StoryPackage = value; Changed(Source);
+        }
+    }
+
     public void Connect(string fromId, int outlet, string toId)
     {
         ValidateConnection(fromId, outlet, Find(toId));
@@ -84,10 +111,8 @@ public void DeleteEdge(string id)
     private void ValidateConnection(string fromId, int outlet, EditorGraphNodeDto to)
     {
         var from = Find(fromId);
-        var count = from.BranchType == "Choice" ? from.Options?.Count ?? 0
-            : from.BranchType == "Condition" ? from.Conditions?.Count ?? 0 : 1;
-        if (from.Id == to.Id || to.Type == "Entry" || outlet < 0 || outlet >= count)
-            throw new EditorOperationException("graph.connection", "Invalid graph connection.");
+        if (GraphEditRules.ConnectionError(from, outlet, to) is { } issue)
+            throw new EditorOperationException(issue.Code, issue.Message);
     }
 
     private static int ResolveOutlet(EditorGraphNodeDto? from, int outlet, string? itemId) => from is null ? -1 : itemId is null ? outlet
@@ -181,8 +206,7 @@ IProjectStructureChange Prepare(EditorProjectDocument working, EditorProjectDocu
                     var from = working.Graph.Nodes.SingleOrDefault(node => node.Id == fromId)
                         ?? throw new EditorOperationException("graph.targetRemoved", "The starting node was removed before this edit.");
                     if (fromItemId is not null) outlet = from.BranchType == "Choice" ? from.Options!.FindIndex(item => item.Id == fromItemId) : from.Conditions!.FindIndex(item => item.Id == fromItemId);
-                    var count = from.BranchType == "Choice" ? from.Options?.Count ?? 0
-                        : from.BranchType == "Condition" ? from.Conditions?.Count ?? 0 : 1;
+                    var count = GraphEditRules.OutputCount(from);
                     if (outlet < 0 || outlet >= count) throw new EditorOperationException("graph.targetRemoved", "The starting outlet changed before this edit.");
                 }
                 // Capture only after publication is available: an earlier save may advance Saved while we wait.
diff --git a/src/Editor/GalNet.Editor/Services/GraphEditingService.cs b/src/Editor/GalNet.Editor/Services/GraphEditingService.cs
index a4bf9ea4..dfafb228 100644
--- a/src/Editor/GalNet.Editor/Services/GraphEditingService.cs
+++ b/src/Editor/GalNet.Editor/Services/GraphEditingService.cs
@@ -1,4 +1,4 @@
-using System.Collections.ObjectModel;
+using System.Collections.Generic;
 using System.Linq;
 using GalNet.Editor.ViewModels;
 
@@ -6,7 +6,7 @@ namespace GalNet.Editor.Services;
 
 public sealed class GraphEditingService : IGraphEditingService
 {
-    public void UpdateConnectorStates(ObservableCollection<GraphNode> nodes, ObservableCollection<GraphEdge> edges)
+    public void UpdateConnectorStates(IEnumerable<GraphNode> nodes, IEnumerable<GraphEdge> edges)
     {
         foreach (var connector in nodes.SelectMany(node => node.InputConnectors.Concat(node.OutputConnectors)))
             connector.IsConnected = false;
diff --git a/src/Editor/GalNet.Editor/Services/GroupEntryAuthoringService.Moves.cs b/src/Editor/GalNet.Editor/Services/GroupEntryAuthoringService.Moves.cs
new file mode 100644
index 00000000..8e32e656
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/GroupEntryAuthoringService.Moves.cs
@@ -0,0 +1,167 @@
+using System.Text.Json;
+using GalNet.Editor.Abstraction.Changes;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+public sealed class EntryCutOffer
+{
+    public string Text { get; }
+    internal string Token { get; }
+    internal string GroupId { get; }
+    internal string[] Ids { get; }
+    internal string Source { get; }
+    internal object Session { get; }
+    internal long SourceVersion { get; }
+    internal object Document { get; }
+    internal EntryCutOffer(object session, string groupId, string[] ids, string source, string token, string text, long sourceVersion, object document)
+    { Session = session; GroupId = groupId; Ids = ids; Source = source; Token = token; Text = text; SourceVersion = sourceVersion; Document = document; }
+}
+
+public sealed partial class GroupEntryAuthoringService
+{
+    private readonly object _moveSession = new();
+    private EntryCutOffer? _pendingMove;
+    private bool _observingMoves;
+    private bool _disposed;
+    private readonly Dictionary<string, long> _moveVersions = new(StringComparer.Ordinal);
+    public bool LastPasteCopiedMove { get; private set; }
+    public event Action? PendingMoveChanged;
+    public bool HasPendingMove => _pendingMove is not null;
+    public bool IsPendingMove(string groupId, string id) => _pendingMove is { } cut && cut.GroupId == groupId && cut.Ids.Contains(id, StringComparer.Ordinal);
+    public EntryCutOffer? PrepareCut(string groupId, IEnumerable<string> ids)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        ObserveMoves();
+        _moveVersions.TryAdd(groupId, 0);
+        var selected = ids.ToHashSet(StringComparer.Ordinal);
+        var ordered = Group(groupId).Entries.Where(entry => selected.Contains(entry.StableId)).Select(entry => entry.StableId).ToArray();
+        var source = Copy(groupId, ordered);
+        if (source.Length == 0) return null;
+        var token = Guid.NewGuid().ToString("N");
+        var clip = JsonSerializer.Deserialize<EntryClipboard>(source)!;
+        return new(_moveSession, groupId, ordered, source, token, JsonSerializer.Serialize(clip with { MoveToken = token }), _moveVersions[groupId], documents.CurrentDocument);
+    }
+    public void BeginCut(EntryCutOffer offer)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        if (!ReferenceEquals(offer.Session, _moveSession) || !CutIsCurrent(offer)) throw new EditorOperationException("entry.cutChanged", "The source entries changed while writing the clipboard.");
+        _pendingMove = offer; NotifyPendingMove();
+    }
+    private void ObserveMoves()
+    {
+        if (_observingMoves) return;
+        histories.Content.AuthorChanges.Committed += CheckPendingMove;
+        documents.DocumentChanged += InvalidateMoves;
+        _observingMoves = true;
+    }
+    private bool CutIsCurrent(EntryCutOffer offer)
+    {
+        if (_disposed || !documents.IsLoaded || !ReferenceEquals(documents.CurrentDocument, offer.Document) || _moveVersions.GetValueOrDefault(offer.GroupId) != offer.SourceVersion) return false;
+        try { return Copy(offer.GroupId, offer.Ids) == offer.Source; }
+        catch (EditorOperationException) { return false; }
+    }
+    private void CheckPendingMove(AuthorChangeSet change)
+    {
+        foreach (var groupId in _moveVersions.Keys.ToArray())
+            if (change.UnknownScope || change.Groups.Any(group => group.GroupId == groupId)) _moveVersions[groupId]++;
+        if (_pendingMove is { } cut && !CutIsCurrent(cut)) CancelPendingMove();
+    }
+    private void InvalidateMoves()
+    {
+        foreach (var groupId in _moveVersions.Keys.ToArray()) _moveVersions[groupId]++;
+        CancelPendingMove();
+    }
+    public void CancelPendingMove() { if (_pendingMove is null) return; _pendingMove = null; NotifyPendingMove(); }
+    private void NotifyPendingMove()
+    {
+        if (PendingMoveChanged is null) return;
+        foreach (Action observer in PendingMoveChanged.GetInvocationList())
+            try { observer(); } catch (Exception failure) { Serilog.Log.Error(failure, "A pending entry move observer failed"); }
+    }
+    private sealed record PreparedMove(PreparedEntryEdit Edit, HashSet<string> TargetIds);
+    private bool TryPrepareMove(string targetId, string text, string? anchorId, out PreparedMove? prepared)
+    {
+        prepared = null;
+        if (_pendingMove is not { } cut) return false;
+        if (text != cut.Text || !CutIsCurrent(cut)) { CancelPendingMove(); return false; }
+        var source = Group(cut.GroupId); var target = Group(targetId);
+        var boundary = anchorId is null ? target.Entries.Count : target.Entries.FindIndex(entry => entry.StableId == anchorId) + 1;
+        if (anchorId is not null && boundary == 0) throw new EditorOperationException("entry.anchorMissing", "The insertion target was removed.");
+        var moving = source.Entries.Where(entry => cut.Ids.Contains(entry.StableId, StringComparer.Ordinal)).ToArray();
+        if (source == target)
+        {
+            if (anchorId is not null && cut.Ids.Contains(anchorId, StringComparer.Ordinal)) { CancelPendingMove(); return true; }
+            var before = source.Entries.Select(entry => entry.StableId).ToArray();
+            var after = before.Where(id => !cut.Ids.Contains(id, StringComparer.Ordinal)).ToList();
+            var offset = before.Take(boundary).Count(id => !cut.Ids.Contains(id, StringComparer.Ordinal));
+            after.InsertRange(offset, cut.Ids);
+            if (before.SequenceEqual(after)) { CancelPendingMove(); return true; }
+            var edit = new OrderEdit(this, source.Id, before, after.ToArray());
+            prepared = new(new(documents, histories, edit, candidate =>
+            {
+                var entries = candidate.GroupEntries[source.Id].ToDictionary(entry => entry.StableId);
+                candidate.GroupEntries[source.Id] = after.Select(id => entries[id]).ToList();
+            }, precondition: () => ReferenceEquals(_pendingMove, cut) && CutIsCurrent(cut)), cut.Ids.ToHashSet(StringComparer.Ordinal));
+            return true;
+        }
+        var usedIds = target.Entries.Select(entry => entry.StableId).ToHashSet(StringComparer.Ordinal);
+        var copies = moving.Select(entry => JsonSerializer.Deserialize<EditorEntryData>(JsonSerializer.Serialize(entry))!).ToArray();
+        foreach (var copy in copies)
+        {
+            while (!usedIds.Add(copy.StableId)) copy.StableId = Guid.NewGuid().ToString("N");
+        }
+        var transitions = moving.Zip(copies).Select(pair => new EntryAddressTransition(new(source.Id, pair.First.StableId), new(target.Id, pair.Second.StableId))).ToArray();
+        var oldSource = source.Entries.ToArray(); var oldTarget = target.Entries.ToArray();
+        var nextSource = oldSource.Except(moving).ToArray(); var nextTarget = oldTarget.ToList(); nextTarget.InsertRange(boundary, copies);
+        IUndoableEdit operation = new TransferEdit(this, source.Id, target.Id, oldSource, oldTarget, nextSource, nextTarget.ToArray(), transitions);
+        if (edits is not null) operation = new EntryDraftLifecycleEdit(edits, operation, transitions, histories.Content.AuthorChanges);
+        var draftRevision = edits?.Revision;
+        prepared = new(new(documents, histories, operation, candidate =>
+        {
+            candidate.GroupEntries[source.Id].RemoveAll(entry => cut.Ids.Contains(entry.StableId, StringComparer.Ordinal));
+            candidate.GroupEntries[target.Id].InsertRange(boundary, copies);
+        }, edits?.CountPending(transitions.Select(address => address.Before)) ?? 0,
+            () => ReferenceEquals(_pendingMove, cut) && CutIsCurrent(cut) && edits?.Revision == draftRevision,
+            transitions.ToDictionary(address => address.After, address => address.Before)), copies.Select(entry => entry.StableId).ToHashSet(StringComparer.Ordinal));
+        return true;
+    }
+    private sealed record TransferEdit(GroupEntryAuthoringService Owner, string SourceId, string TargetId,
+        EditorEntryData[] OldSource, EditorEntryData[] OldTarget, EditorEntryData[] NextSource, EditorEntryData[] NextTarget,
+        EntryAddressTransition[] Addresses) : IUndoableEdit, IAuthorScopedEdit
+    {
+        public string Description => "Move entries between Groups";
+        public EditorText DisplayText => new("History.MoveEntries");
+        public long RetainedBytes => JsonSerializer.SerializeToUtf8Bytes(new[] { OldSource, OldTarget, NextSource, NextTarget }).LongLength;
+        public void Redo() => Apply(true);
+        public void Undo() => Apply(false);
+        private void Apply(bool forward)
+        {
+            var source = Owner.Group(SourceId).Entries; var target = Owner.Group(TargetId).Entries;
+            var expectedSource = forward ? OldSource : NextSource; var expectedTarget = forward ? OldTarget : NextTarget;
+            if (!source.SequenceEqual(expectedSource) || !target.SequenceEqual(expectedTarget)) throw new EditorOperationException("entry.changed", "Group membership changed outside this move.");
+            var firstSource = CommonPrefix(source, forward ? NextSource : OldSource); var firstTarget = CommonPrefix(target, forward ? NextTarget : OldTarget);
+            source.Clear(); source.AddRange(forward ? NextSource : OldSource); target.Clear(); target.AddRange(forward ? NextTarget : OldTarget);
+            Renumber(source); Renumber(target);
+            Owner.Record(SourceId, firstSource, GroupChangeKind.Membership, Addresses.Select(address => address.Before.EntryId));
+            Owner.Record(TargetId, firstTarget, GroupChangeKind.Membership, Addresses.Select(address => address.After.EntryId));
+            foreach (var address in Addresses)
+            {
+                var from = forward ? address.Before : address.After; var to = forward ? address.After : address.Before;
+                Owner.RecordMove(new(from.GroupId, from.EntryId, to.GroupId, to.EntryId));
+            }
+        }
+        private static int CommonPrefix(IEnumerable<EditorEntryData> before, IEnumerable<EditorEntryData> after) => before.Zip(after).TakeWhile(pair => ReferenceEquals(pair.First, pair.Second)).Count();
+    }
+    private void RecordMove(AuthorEntryMove move) => histories.Content.AuthorChanges.RecordMove(move);
+    public void Dispose()
+    {
+        _disposed = true; _pendingMove = null;
+        if (_observingMoves) { histories.Content.AuthorChanges.Committed -= CheckPendingMove; documents.DocumentChanged -= InvalidateMoves; }
+        _moveVersions.Clear();
+        PendingMoveChanged = null;
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/GroupEntryAuthoringService.cs b/src/Editor/GalNet.Editor/Services/GroupEntryAuthoringService.cs
index 0023d4c2..d3e97c0e 100644
--- a/src/Editor/GalNet.Editor/Services/GroupEntryAuthoringService.cs
+++ b/src/Editor/GalNet.Editor/Services/GroupEntryAuthoringService.cs
@@ -1,50 +1,54 @@
-using System.Collections.ObjectModel;
 using System.Text;
 using System.Text.Json;
 using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
-using GalNet.Editor.Models.Graph;
 using GalNet.Editor.Shared.Services;
 
 namespace GalNet.Editor.Services;
 
 /// <summary>Project-owned batch entry intents. History never retains a Group page.</summary>
-public sealed class GroupEntryAuthoringService(EditorGroupProjectionStore groups, IEditorDocumentService documents, IEntryCatalog catalog, EditorHistories histories, GameTextAuthoringService? texts = null)
+public sealed partial class GroupEntryAuthoringService(IEditorDocumentService documents, IEntryCatalog catalog, EditorHistories histories, GameTextAuthoringService? texts = null, EntryEditSession? edits = null, IProjectContentSession? content = null) : IDisposable
 {
-    public IReadOnlyList<EntryEditorItemViewModel> Insert(string groupId, int index, int count, string? type)
+    public IReadOnlyList<string> Insert(string groupId, int index, int count, string? type)
     {
         var group = Group(groupId);
         type ??= GalNet.Contracts.Builtins.BuiltinEntryIds.Text;
         if (!catalog.TryGet(type, out _)) return [];
         index = Math.Clamp(index, 0, group.Entries.Count);
-        var inserted = Enumerable.Range(0, Math.Clamp(count, 1, MaximumEntries)).Select(_ => new EntryEditorItemViewModel(new EditorEntryData
+        var configuration = content?.CaptureWorking().Configuration;
+        var inserted = Enumerable.Range(0, Math.Clamp(count, 1, MaximumEntries)).Select(_ => new EditorEntryData
         {
             StableId = Guid.NewGuid().ToString("N"),
             Type = type,
-            Parameters = SceneAuthoringIdentities.NewEntry(type, EditorEntryData.ParseParameters(catalog, type, catalog.Create(type).Values))
-        }, catalog)).ToArray();
-        histories.Content.Execute(new PresenceEdit(this, groupId, inserted.Select((entry, offset) => new PositionedEntry(index + offset, entry)).ToArray(), true,
+            Parameters = SceneAuthoringIdentities.NewEntry(type, GalNet.Editor.Shared.Visuals.VisualPresetBindings.Fill(type,
+                EditorEntryData.CreateParameters(catalog, type), configuration))
+        }).ToArray();
+        histories.Content.Execute(Presence(groupId, inserted.Select((entry, offset) => new PositionedEntry(index + offset, entry)).ToArray(), true,
             new("History.AddEntries", inserted.Length)));
-        return inserted;
+        return inserted.Select(entry => entry.StableId).ToArray();
     }
-    private sealed record EntryClipboard(string Kind, int Version, List<EditorEntryData> Entries, GameTextClipboard Texts);
+    private sealed record EntryClipboard(string Kind, int Version, List<EditorEntryData> Entries, GameTextClipboard Texts, string? MoveToken = null);
     private const string ClipboardKind = "GalNet.Entries";
     private const int MaximumEntries = 1000;
     private const int MaximumBytes = 16 * 1024 * 1024;
 
-    private EditorGroupProjection Group(string id)
+    private EditorGroupDocument Group(string id)
     {
         if (!documents.CurrentDocument.Nodes.Any(node => node.Id == id && node.Type == "Group"))
             throw new EditorOperationException("entry.groupMissing", "The Group no longer exists.");
-        return groups.Get(id);
+        if (!documents.Groups.TryGetValue(id, out var group)) throw new EditorOperationException("entry.groupMissing", "The Group source no longer exists.");
+        return group;
     }
 
+    private void Record(string groupId, int first, GroupChangeKind kind, IEnumerable<string> ids) => histories.Content.AuthorChanges.Record(groupId, first, kind, ids);
+
     public string Copy(string groupId, IEnumerable<string> ids)
     {
         var selected = ids.ToHashSet(StringComparer.Ordinal);
-        var entries = Group(groupId).Entries.Where(entry => selected.Contains(entry.StableId)).Select(entry => entry.Source).ToList();
+        var entries = Group(groupId).Entries.Where(entry => selected.Contains(entry.StableId)).ToList();
         if (entries.Count == 0) return "";
         if (entries.Count > MaximumEntries) throw InvalidClipboard();
         var text = JsonSerializer.Serialize(new EntryClipboard(ClipboardKind, 2, entries, texts?.CaptureCopies(entries) ?? new(new(), new())));
@@ -52,8 +56,17 @@ public string Copy(string groupId, IEnumerable<string> ids)
         return text;
     }
 
-    public async Task<IReadOnlyList<EntryEditorItemViewModel>> PasteAsync(string groupId, string text, string? anchorId)
+    public async Task<IReadOnlyList<string>> PasteAsync(string groupId, string text, string? anchorId, Func<PreparedEntryEdit, Task<bool>>? review = null)
     {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        LastPasteCopiedMove = false;
+        if (TryPrepareMove(groupId, text, anchorId, out var move))
+        {
+            if (move is null) return [];
+            if (review is not null && !await review(move.Edit)) return [];
+            move.Edit.Commit(); CancelPendingMove();
+            return Group(groupId).Entries.Where(entry => move.TargetIds.Contains(entry.StableId)).Select(entry => entry.StableId).ToArray();
+        }
         var group = Group(groupId);
         var index = anchorId is null ? group.Entries.Count : group.Entries.ToList().FindIndex(entry => entry.StableId == anchorId) + 1;
         if (anchorId is not null && index == 0) throw new EditorOperationException("entry.anchorMissing", "The insertion target was removed.");
@@ -65,6 +78,7 @@ public async Task<IReadOnlyList<EntryEditorItemViewModel>> PasteAsync(string gro
             if (clip.Kind != ClipboardKind || clip.Version != 2 || clip.Entries is not { Count: > 0 and <= MaximumEntries }
                 || clip.Entries.Any(entry => entry is null || string.IsNullOrWhiteSpace(entry.Type) || entry.Condition is null || entry.Parameters is null)) throw new JsonException();
             GameTextAuthoringService.ValidateClipboard(clip.Texts);
+            LastPasteCopiedMove = clip.MoveToken is not null;
             // Check the entire payload before creating any live projection. Keep incomplete drafts;
             // full semantic validation belongs to compile/check, not clipboard insertion.
             foreach (var entry in clip.Entries)
@@ -80,19 +94,35 @@ public async Task<IReadOnlyList<EntryEditorItemViewModel>> PasteAsync(string gro
             if (anchorId is not null && !group.Entries.Any(entry => entry.StableId == anchorId)) throw new EditorOperationException("entry.anchorMissing", "The insertion target was removed.");
         });
         index = anchorId is null ? group.Entries.Count : group.Entries.ToList().FindIndex(entry => entry.StableId == anchorId) + 1;
-        var inserted = clip.Entries.Select(entry => new EntryEditorItemViewModel(entry, catalog)).ToArray();
+        var inserted = clip.Entries.ToArray();
         var positions = inserted.Select((entry, offset) => new PositionedEntry(index + offset, entry)).ToArray();
-        var presence = new PresenceEdit(this, groupId, positions, true, new("History.PasteEntries", inserted.Length));
+        var presence = Presence(groupId, positions, true, new("History.PasteEntries", inserted.Length));
         if (copy is null) histories.Content.Execute(presence);
         else await histories.Content.ExecuteAsync(new AsyncCompositeEdit("Paste entries", [copy, new AsyncEditAdapter(presence)], new("History.PasteEntries", inserted.Length)));
-        return inserted;
+        return inserted.Select(entry => entry.StableId).ToArray();
     }
 
     public void Delete(string groupId, IEnumerable<string> ids)
     {
         var selected = ids.ToHashSet(StringComparer.Ordinal);
         var entries = Group(groupId).Entries.Select((entry, index) => new PositionedEntry(index, entry)).Where(item => selected.Contains(item.Entry.StableId)).ToArray();
-        if (entries.Length > 0) histories.Content.Execute(new PresenceEdit(this, groupId, entries, false, new("History.DeleteEntries", entries.Length)));
+        if (entries.Length > 0) histories.Content.Execute(Presence(groupId, entries, false, new("History.DeleteEntries", entries.Length)));
+    }
+
+    public PreparedEntryEdit? PrepareDelete(string groupId, IEnumerable<string> ids)
+    {
+        var selected = ids.ToHashSet(StringComparer.Ordinal);
+        var entries = Group(groupId).Entries.Select((entry, index) => new PositionedEntry(index, entry)).Where(item => selected.Contains(item.Entry.StableId)).ToArray();
+        var revision = edits?.Revision;
+        return entries.Length == 0 ? null : new(documents, histories,
+            Presence(groupId, entries, false, new("History.DeleteEntries", entries.Length)),
+            candidate => candidate.GroupEntries[groupId].RemoveAll(entry => selected.Contains(entry.StableId)),
+            edits?.CountPending(entries.Select(item => new SceneAuthorAddress(groupId, item.Entry.StableId))) ?? 0, () => edits?.Revision == revision);
+    }
+    private IUndoableEdit Presence(string groupId, PositionedEntry[] entries, bool insert, EditorText display)
+    {
+        var edit = new PresenceEdit(this, groupId, entries, insert, display);
+        return edits is null ? edit : new EntryDraftLifecycleEdit(edits, edit, entries.Select(item => new EntryAddressTransition(new(groupId, item.Entry.StableId), new(groupId, item.Entry.StableId))).ToArray(), histories.Content.AuthorChanges);
     }
 
     public void Move(string groupId, IEnumerable<string> ids, string draggedId, int newIndex)
@@ -110,33 +140,32 @@ public void Move(string groupId, IEnumerable<string> ids, string draggedId, int
         if (!before.SequenceEqual(after)) histories.Content.Execute(new OrderEdit(this, groupId, before, after.ToArray()));
     }
 
-    private sealed record PositionedEntry(int Index, EntryEditorItemViewModel Entry);
-    private sealed record PresenceEdit(GroupEntryAuthoringService Owner, string GroupId, PositionedEntry[] Entries, bool Insert, EditorText DisplayText) : IUndoableEdit
+    private sealed record PositionedEntry(int Index, EditorEntryData Entry);
+    private sealed record PresenceEdit(GroupEntryAuthoringService Owner, string GroupId, PositionedEntry[] Entries, bool Insert, EditorText DisplayText) : IUndoableEdit, IAuthorScopedEdit
     {
         public string Description => Insert ? "Paste entries" : "Delete entries";
-        public long RetainedBytes => Entries.Sum(item => (long)JsonSerializer.SerializeToUtf8Bytes(item.Entry.Source).Length);
+        public long RetainedBytes => Entries.Sum(item => (long)JsonSerializer.SerializeToUtf8Bytes(item.Entry).Length);
         public void Redo() => Apply(Insert);
         public void Undo() => Apply(!Insert);
         private void Apply(bool present)
         {
             var entries = Owner.Group(GroupId).Entries;
-            ApplyAtomically(entries, () =>
+            if (present)
             {
-                if (present)
-                {
-                    if (Entries.Any(item => entries.Any(entry => entry.StableId == item.Entry.StableId))) throw new InvalidOperationException("Entry already exists.");
-                    foreach (var item in Entries) entries.Insert(Math.Min(item.Index, entries.Count), item.Entry);
-                }
-                else
-                {
-                    if (Entries.Any(item => !entries.Contains(item.Entry))) throw new InvalidOperationException("Entry no longer exists.");
-                    foreach (var item in Entries.Reverse()) entries.Remove(item.Entry);
-                }
-            });
+                if (Entries.Any(item => entries.Any(entry => entry.StableId == item.Entry.StableId))) throw new InvalidOperationException("Entry already exists.");
+                foreach (var item in Entries) entries.Insert(Math.Min(item.Index, entries.Count), item.Entry);
+            }
+            else
+            {
+                if (Entries.Any(item => !entries.Contains(item.Entry))) throw new InvalidOperationException("Entry no longer exists.");
+                foreach (var item in Entries.Reverse()) entries.Remove(item.Entry);
+            }
+            Renumber(entries);
+            Owner.Record(GroupId, Entries.Min(item => item.Index), GroupChangeKind.Membership, Entries.Select(item => item.Entry.StableId));
         }
     }
 
-    private sealed record OrderEdit(GroupEntryAuthoringService Owner, string GroupId, string[] Before, string[] After) : IUndoableEdit
+    private sealed record OrderEdit(GroupEntryAuthoringService Owner, string GroupId, string[] Before, string[] After) : IUndoableEdit, IAuthorScopedEdit
     {
         public string Description => "Move entries";
         public EditorText DisplayText => new("History.MoveEntries");
@@ -148,42 +177,13 @@ private void Apply(string[] order)
             var entries = Owner.Group(GroupId).Entries;
             var map = entries.ToDictionary(entry => entry.StableId);
             if (map.Count != order.Length || order.Any(id => !map.ContainsKey(id))) throw new InvalidOperationException("Entry order has changed.");
-            ApplyAtomically(entries, () =>
-            {
-                for (var index = 0; index < order.Length; index++)
-                    if (!ReferenceEquals(entries[index], map[order[index]])) entries.Move(entries.IndexOf(map[order[index]]), index);
-            });
-        }
-    }
-
-    private static void ApplyAtomically(ObservableCollection<EntryEditorItemViewModel> entries, Action apply)
-    {
-        var before = entries.ToArray();
-        try { apply(); Renumber(entries); }
-        catch (Exception failure)
-        {
-            try
-            {
-                // ObservableCollection mutates before notifying. A failing observer can
-                // therefore leave even its current operation applied; reconcile the
-                // actual collection rather than counting completed calls.
-                var retained = before.ToHashSet();
-                for (var index = entries.Count - 1; index >= 0; index--)
-                    if (!retained.Contains(entries[index])) entries.RemoveAt(index);
-                for (var index = 0; index < before.Length; index++)
-                {
-                    var current = entries.IndexOf(before[index]);
-                    if (current < 0) entries.Insert(index, before[index]);
-                    else if (current != index) entries.Move(current, index);
-                }
-                Renumber(entries);
-            }
-            catch (Exception compensation) { throw new HistoryRepairRequiredException("Entry edit compensation failed.", new AggregateException(failure, compensation)); }
-            throw;
+            var first = entries.Select(entry => entry.StableId).Zip(order).TakeWhile(pair => pair.First == pair.Second).Count();
+            entries.Clear(); entries.AddRange(order.Select(id => map[id])); Renumber(entries);
+            Owner.Record(GroupId, first, GroupChangeKind.Order, order.Skip(first));
         }
     }
 
-    private static void Renumber(IEnumerable<EntryEditorItemViewModel> entries)
+    private static void Renumber(IEnumerable<EditorEntryData> entries)
     {
         var index = 0;
         foreach (var entry in entries) entry.Id = ++index;
diff --git a/src/Editor/GalNet.Editor/Services/Interfaces/IEditorAssetChanges.cs b/src/Editor/GalNet.Editor/Services/Interfaces/IEditorAssetChanges.cs
new file mode 100644
index 00000000..c9e846ee
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/Interfaces/IEditorAssetChanges.cs
@@ -0,0 +1,8 @@
+namespace GalNet.Editor.Services.Interfaces;
+
+/// <summary>Editor resource generations; paths and labels are attributes of an ID.</summary>
+public interface IEditorAssetChanges
+{
+    long Revision { get; }
+    event Action? Changed;
+}
diff --git a/src/Editor/GalNet.Editor/Services/Interfaces/IEditorWindowFactory.cs b/src/Editor/GalNet.Editor/Services/Interfaces/IEditorWindowFactory.cs
index a000c3c1..265ac0c4 100644
--- a/src/Editor/GalNet.Editor/Services/Interfaces/IEditorWindowFactory.cs
+++ b/src/Editor/GalNet.Editor/Services/Interfaces/IEditorWindowFactory.cs
@@ -7,4 +7,5 @@ public interface IEditorWindowFactory
     ProjectSettingsWindow CreateProjectSettingsWindow();
     EditorSettingsWindow CreateEditorSettingsWindow();
     ExportWindow CreateExportWindow();
+    Task<string?> RequestLayoutNameAsync(GalNet.Editor.Abstraction.Services.IEditorLocalizationService localization);
 }
diff --git a/src/Editor/GalNet.Editor/Services/Interfaces/IGraphEditingService.cs b/src/Editor/GalNet.Editor/Services/Interfaces/IGraphEditingService.cs
index 1fba4580..5c8ca5c4 100644
--- a/src/Editor/GalNet.Editor/Services/Interfaces/IGraphEditingService.cs
+++ b/src/Editor/GalNet.Editor/Services/Interfaces/IGraphEditingService.cs
@@ -1,9 +1,9 @@
-using System.Collections.ObjectModel;
+using System.Collections.Generic;
 using GalNet.Editor.ViewModels;
 
 namespace GalNet.Editor.Services.Interfaces;
 
 public interface IGraphEditingService
 {
-    void UpdateConnectorStates(ObservableCollection<GraphNode> nodes, ObservableCollection<GraphEdge> edges);
+    void UpdateConnectorStates(IEnumerable<GraphNode> nodes, IEnumerable<GraphEdge> edges);
 }
diff --git a/src/Editor/GalNet.Editor/Services/LocalizationExchangeService.cs b/src/Editor/GalNet.Editor/Services/LocalizationExchangeService.cs
index c9d57f60..f758d3e4 100644
--- a/src/Editor/GalNet.Editor/Services/LocalizationExchangeService.cs
+++ b/src/Editor/GalNet.Editor/Services/LocalizationExchangeService.cs
@@ -1,6 +1,7 @@
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
+using GalNet.Contracts.Builtins;
 using GalNet.Core.Parameters;
 using GalNet.Editor.Abstraction.Project;
 using GalNet.Editor.Abstraction.Services;
@@ -17,21 +18,21 @@ public sealed class LocalizationExchangeService(IProjectService projects, IProje
 {
     private GalProject Active()
     { _ = store.CaptureFile(LocalizationJson.MetadataPath); return projects.Current!; }
-    private string Source => content.CaptureWorking().Settings.TargetLocale.Code;
+    private string Source => content.CaptureWorking().Configuration.ReadDefaultOptions().TargetLocale.Code;
     private string? Identity => JsonNode.Parse(LocalizationJson.Decode(store.CaptureFile(LocalizationJson.MetadataPath).Data))!["exchangeProjectId"]?.GetValue<string>() is { } identity ? Guid.Parse(identity).ToString("N") : null;
     private string Evidence()
     {
         Active(); var index = query.Get()!; var meta = JsonNode.Parse(LocalizationJson.Decode(store.CaptureFile(LocalizationJson.MetadataPath).Data))!.AsObject();
         meta.Remove("characterHighWater");
-        return LocalizationTextState.Fingerprint(JsonSerializer.Serialize(new { Source, Languages = content.CaptureWorking().Settings.AvailableLocales.Select(locale => locale.Code), index.References, index.Texts, Metadata = meta }));
+        return LocalizationTextState.Fingerprint(JsonSerializer.Serialize(new { Source, Languages = content.CaptureWorking().Configuration.ReadDefaultOptions().AvailableLocales.Select(locale => locale.Code), index.References, index.Texts, Metadata = meta }));
     }
     public async Task<string> ExportAsync(string culture, string? category, bool runtime)
     {
         Active(); culture = LocalizationExchange.Culture(culture);
         await content.CommitDraftsAsync(); Active();
-        if (!content.CaptureWorking().Settings.AvailableLocales.Any(locale => locale.Code == culture)) throw new EditorOperationException("exchange.language", "Language is not supported.");
+        if (!content.CaptureWorking().Configuration.ReadDefaultOptions().AvailableLocales.Any(locale => locale.Code == culture)) throw new EditorOperationException("exchange.language", "Language is not supported.");
         var identity = runtime ? "" : await store.EnsureExchangeIdentityAsync(); Active();
-        var snapshot = content.CaptureWorking(); var index = query.Get()!; var sourceLocale = snapshot.Settings.TargetLocale.Code;
+        var snapshot = content.CaptureWorking(); var index = query.Get()!; var sourceLocale = snapshot.Configuration.ReadDefaultOptions().TargetLocale.Code;
         var branches = snapshot.Graph.Nodes.Where(node => node.Type == "Branch").Select(node => node.Id).ToHashSet(StringComparer.Ordinal);
         var references = index.References.Where(reference => reference.Semantic == FieldValueSemantic.LocalizedText &&
             (category is null || (category == "branches" ? branches.Contains(reference.Owner) : reference.Owner == category)));
@@ -39,7 +40,7 @@ public async Task<string> ExportAsync(string culture, string? category, bool run
         {
             var source = index.FindDirect(sourceLocale, group.Key)?.Text;
             return new LocalizationExchangeRow(group.Key, source, source is null ? null : LocalizationTextState.Fingerprint(source),
-                group.Select(reference => $"{reference.Owner}/{reference.EntryId}{reference.JsonPointer}").ToArray(), index.FindDirect(culture, group.Key)?.Text);
+                group.Select(reference => $"{reference.Owner}/{reference.EntryId}{reference.LocationKey}").ToArray(), index.FindDirect(culture, group.Key)?.Text);
         }).ToArray();
         return runtime ? JsonSerializer.Serialize(rows.Where(row => row.Translation is not null).ToDictionary(row => row.Key, row => row.Translation), new JsonSerializerOptions { WriteIndented = true })
             : LocalizationExchange.Write(new(1, identity, sourceLocale, culture, rows, index.Complete));
@@ -48,7 +49,7 @@ public LocalizationImportPreview Preview(string json, string flatLanguage)
     {
         var project = Active(); var input = LocalizationExchange.Parse(json, flatLanguage);
         if (input.ProjectId is not null && (input.ProjectId != Identity || input.SourceLocale != Source)) throw new EditorOperationException("exchange.project", "Template project or source language does not match.");
-        if (input.TargetLocale == Source || !content.CaptureWorking().Settings.AvailableLocales.Any(locale => locale.Code == input.TargetLocale))
+        if (input.TargetLocale == Source || !content.CaptureWorking().Configuration.ReadDefaultOptions().AvailableLocales.Any(locale => locale.Code == input.TargetLocale))
             throw new EditorOperationException("exchange.language", "Import requires a supported translation language other than the development language.");
         var index = query.Get()!; var sourceLocale = Source;
         var known = index.References.Where(reference => reference.Semantic == FieldValueSemantic.LocalizedText).Select(reference => reference.Key).ToHashSet(StringComparer.Ordinal);
@@ -62,7 +63,7 @@ private void Check(LocalizationImportPreview preview)
         => Check(preview.Project, preview.Culture, preview.SourceLocale, preview.Evidence);
     private void Check(GalProject project, string culture, string sourceLocale, string evidence)
     {
-        if (!ReferenceEquals(Active(), project) || sourceLocale != Source || culture == Source || !content.CaptureWorking().Settings.AvailableLocales.Any(locale => locale.Code == culture) || Evidence() != evidence)
+        if (!ReferenceEquals(Active(), project) || sourceLocale != Source || culture == Source || !content.CaptureWorking().Configuration.ReadDefaultOptions().AvailableLocales.Any(locale => locale.Code == culture) || Evidence() != evidence)
             throw new EditorOperationException("exchange.stale", "Import preview changed. Preview the file again.");
     }
     public async Task ApplyAsync(LocalizationImportPreview preview, IReadOnlyCollection<string> selected, bool allowEmpty)
diff --git a/src/Editor/GalNet.Editor/Services/PreparedEntryEdit.cs b/src/Editor/GalNet.Editor/Services/PreparedEntryEdit.cs
new file mode 100644
index 00000000..9f60a575
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/PreparedEntryEdit.cs
@@ -0,0 +1,62 @@
+using System.Text.Json;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+/// <summary>An edit tied to its source snapshot, with optional impact analysis.</summary>
+public sealed class PreparedEntryEdit
+{
+    private readonly IEditorDocumentService _documents;
+    private readonly EditorHistories _histories;
+    private readonly IUndoableEdit _edit;
+    private readonly string _source;
+    private readonly EditorGraphDocument _document;
+    private readonly Func<bool>? _precondition;
+    private bool _committed;
+    private readonly Lazy<SceneEditImpact> _impact;
+    public SceneEditImpact Impact => _impact.Value;
+    internal PreparedEntryEdit(IEditorDocumentService documents, EditorHistories histories, IUndoableEdit edit, Action<EditorProjectDocument> apply, int archivedInputs = 0, Func<bool>? precondition = null,
+        IReadOnlyDictionary<SceneAuthorAddress, SceneAuthorAddress>? originalOwners = null)
+    {
+        _documents = documents; _histories = histories; _edit = edit;
+        _document = documents.CurrentDocument;
+        _precondition = precondition;
+        _source = Capture(documents);
+        var source = _source;
+        _impact = new(() =>
+        {
+            var before = JsonSerializer.Deserialize<EditorProjectDocument>(source)!;
+            var after = JsonSerializer.Deserialize<EditorProjectDocument>(source)!;
+            apply(after);
+            return SceneReferenceAnalysis.Compare(before.Graph, before.GroupEntries, after.GroupEntries, originalOwners) with { ArchivedInputs = archivedInputs };
+        });
+    }
+    public void Commit()
+    {
+        if (_committed) throw Stale();
+        _histories.Content.Execute(new PreviewedEdit(_documents, _document, _source, _edit, _precondition));
+        _committed = true;
+    }
+    private static string Capture(IEditorDocumentService documents) => JsonSerializer.Serialize(new EditorProjectDocument
+    { Graph = documents.CurrentDocument, GroupEntries = documents.Groups.ToDictionary(pair => pair.Key, pair => pair.Value.Entries) });
+    private static EditorOperationException Stale() => new("entry.impactChanged", "Author content changed while reviewing this operation. Review its effects again.");
+    private sealed class PreviewedEdit(IEditorDocumentService documents, EditorGraphDocument document, string source, IUndoableEdit edit, Func<bool>? precondition) : IUndoableEdit, IAuthorScopedEdit
+    {
+        private string? _expected = source;
+        private EditorGraphDocument? _expectedDocument = document;
+        private Func<bool>? _precondition = precondition;
+        public bool HasKnownAuthorScope => edit is IAuthorScopedEdit { HasKnownAuthorScope: true };
+        public string Description => edit.Description;
+        public EditorText DisplayText => edit.DisplayText;
+        public long RetainedBytes => edit.RetainedBytes;
+        public void Redo()
+        {
+            if (_expected is { } expected && (!documents.IsLoaded || !ReferenceEquals(documents.CurrentDocument, _expectedDocument) || Capture(documents) != expected || _precondition?.Invoke() == false)) throw Stale();
+            edit.Redo(); _expected = null; _expectedDocument = null; _precondition = null;
+        }
+        public void Undo() => edit.Undo();
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/ProjectExternalChanges.cs b/src/Editor/GalNet.Editor/Services/ProjectExternalChanges.cs
new file mode 100644
index 00000000..2f17c249
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/ProjectExternalChanges.cs
@@ -0,0 +1,133 @@
+using Avalonia.Threading;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+public enum ExternalProjectState { Ready, Reloaded, Publishing, LocalChanges, Invalid, ContractsChanged }
+
+/// <summary>Source-independent disk reconciliation. Watcher events are hints, never author content.</summary>
+public sealed class ProjectExternalChanges(IProjectService projects, IProjectContentSession content, IEntryCatalog catalog,
+    EditorHistories histories, IVariableDefinitionService variables) : IProjectEditLifetime, IDisposable
+{
+    private readonly SemaphoreSlim _gate = new(1, 1);
+    private readonly CancellationTokenSource _lifetime = new();
+    private FileSystemWatcher? _watcher;
+    private DispatcherTimer? _timer;
+    private IReadOnlyDictionary<string, byte[]>? _observedFiles;
+    private string? _observedContracts;
+    private string? _root;
+    private bool _disposed;
+    private bool _suspended;
+    private int _requested = 1;
+    private long _lastNotification;
+    private DateTime _lastScan = DateTime.MinValue;
+    private Task? _running;
+    public ExternalProjectState State { get; private set; }
+    public string Details { get; private set; } = "";
+    public bool HasIssue => State is ExternalProjectState.LocalChanges or ExternalProjectState.Invalid or ExternalProjectState.ContractsChanged or ExternalProjectState.Publishing;
+    public bool CanReload => State is not (ExternalProjectState.ContractsChanged or ExternalProjectState.Publishing);
+    public event Action? Changed;
+
+    public void Start()
+    {
+        if (_disposed || _watcher is not null) return;
+        _root = projects.Current?.RootPath ?? throw new InvalidOperationException("No project is open.");
+        _watcher = new(_root) { IncludeSubdirectories = true, NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite | NotifyFilters.Size };
+        _watcher.Changed += OnFile; _watcher.Created += OnFile; _watcher.Deleted += OnFile; _watcher.Renamed += OnFile;
+        _watcher.Error += (_, _) => Interlocked.Exchange(ref _requested, 1);
+        _watcher.EnableRaisingEvents = true;
+        content.Changed += RequestScan;
+        _timer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(400) };
+        _timer.Tick += OnTick; _timer.Start();
+    }
+
+    private void RequestScan() { if (HasIssue) Interlocked.Exchange(ref _requested, 1); }
+    private void OnFile(object sender, FileSystemEventArgs args)
+    {
+        var path = Path.GetRelativePath(_root!, args.FullPath).Replace('\\', '/');
+        var first = path.Split('/')[0];
+        if (new[] { ".git", "Output", "Temp", "bin", "obj", ".vs", ".idea" }.Contains(first, StringComparer.OrdinalIgnoreCase)) return;
+        if (first.Equals(".galnet", StringComparison.OrdinalIgnoreCase) && !path.StartsWith(".galnet/editor/transactions/", StringComparison.OrdinalIgnoreCase)) return;
+        Interlocked.Exchange(ref _lastNotification, Environment.TickCount64);
+        Interlocked.Exchange(ref _requested, 1);
+    }
+
+    private async void OnTick(object? sender, EventArgs args)
+    {
+        if (_disposed || _suspended || _running is { IsCompleted: false } || content.IsPublishing || histories.Content.IsBusy) return;
+        if (Environment.TickCount64 - Interlocked.Read(ref _lastNotification) < 600) return;
+        if (Interlocked.Exchange(ref _requested, 0) == 0 && DateTime.UtcNow - _lastScan < TimeSpan.FromSeconds(5)) return;
+        _running = CheckNowAsync();
+        await _running;
+    }
+
+    public async Task<ExternalReloadResult> CheckNowAsync(bool discardLocalChanges = false)
+    {
+        if (_disposed || _suspended || projects.Current is null) return ExternalReloadResult.Unavailable;
+        var acquired = false;
+        try
+        {
+            await _gate.WaitAsync(_lifetime.Token); acquired = true;
+            if (_disposed || _suspended || content.IsPublishing || histories.Content.IsBusy) return ExternalReloadResult.Retry;
+            _root ??= projects.Current.RootPath;
+            _lastScan = DateTime.UtcNow;
+            var tracked = content.FileDocuments.Values.Select(file => new EditorFileDocument { Path = file.Path, ManagedContent = file.ManagedContent }).ToArray();
+            var read = await Task.Run(() =>
+            {
+                if (ExternalProjectSnapshotReader.HasPendingTransaction(_root)) return (Files: (Dictionary<string, byte[]>?)null, Contracts: "", Snapshot: (ExternalProjectSnapshot?)null);
+                var files = ExternalProjectSnapshotReader.ReadFiles(_root, tracked);
+                var contracts = ExternalProjectSnapshotReader.ContractsFingerprint(_root);
+                var unchanged = !discardLocalChanges && _observedFiles is not null && contracts == _observedContracts && ExternalProjectSnapshotReader.Same(files, _observedFiles);
+                return (Files: files, Contracts: contracts, Snapshot: unchanged ? null : ExternalProjectSnapshotReader.Read(_root, tracked, catalog));
+            }, _lifetime.Token);
+            if (_disposed || _suspended) return ExternalReloadResult.Unavailable;
+            _lastScan = DateTime.UtcNow;
+            if (read.Files is null) { SetState(ExternalProjectState.Publishing); Interlocked.Exchange(ref _requested, 1); return ExternalReloadResult.Retry; }
+            if (read.Snapshot is null) { if (HasIssue) SetState(ExternalProjectState.Ready); return ExternalReloadResult.Unchanged; }
+            var result = await content.ReloadExternalAsync(read.Snapshot, discardLocalChanges, _lifetime.Token);
+            if (result is ExternalReloadResult.Reloaded or ExternalReloadResult.Unchanged)
+            {
+                _observedFiles = read.Snapshot.Files; _observedContracts = read.Contracts;
+                SetState(result == ExternalReloadResult.Reloaded ? ExternalProjectState.Reloaded : ExternalProjectState.Ready);
+                if (result == ExternalReloadResult.Reloaded) variables.ResetFromDocument();
+            }
+            else if (result == ExternalReloadResult.LocalChanges) SetState(ExternalProjectState.LocalChanges);
+            else if (result == ExternalReloadResult.Retry) Interlocked.Exchange(ref _requested, 1);
+            return result;
+        }
+        catch (OperationCanceledException) when (_lifetime.IsCancellationRequested) { return ExternalReloadResult.Unavailable; }
+        catch (Exception error) when (error is IOException or InvalidDataException or UnauthorizedAccessException or ArgumentException or System.Text.Json.JsonException or InvalidOperationException or NotSupportedException)
+        {
+            if (!_disposed && !_suspended) SetState(error is EditorOperationException { Code: "project.externalContracts" } ? ExternalProjectState.ContractsChanged : ExternalProjectState.Invalid, error.Message);
+            return ExternalReloadResult.Retry;
+        }
+        finally { if (acquired) _gate.Release(); }
+    }
+
+    private void SetState(ExternalProjectState state, string details = "")
+    {
+        if (State == state && Details == details) return;
+        State = state; Details = details; Changed?.Invoke();
+    }
+
+    public async Task SuspendAsync()
+    {
+        _suspended = true; _timer?.Stop();
+        await _gate.WaitAsync(); _gate.Release();
+    }
+    public void ResumeEditing() { if (_disposed) return; _suspended = false; _timer?.Start(); }
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _disposed = true; _suspended = true;
+        _timer?.Stop(); if (_timer is not null) _timer.Tick -= OnTick;
+        _watcher?.Dispose(); content.Changed -= RequestScan;
+        _lifetime.Cancel();
+        // An in-flight read owns these until its continuation has observed cancellation.
+        GC.SuppressFinalize(this);
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/ProjectFileAuthoringService.cs b/src/Editor/GalNet.Editor/Services/ProjectFileAuthoringService.cs
index 14953b42..c50813aa 100644
--- a/src/Editor/GalNet.Editor/Services/ProjectFileAuthoringService.cs
+++ b/src/Editor/GalNet.Editor/Services/ProjectFileAuthoringService.cs
@@ -19,7 +19,8 @@ public ProjectFileImpact Analyze(ProjectFileRequest request)
     public async Task ExecuteAsync(ProjectFileRequest request)
     {
         var project = projects.Current ?? throw new InvalidOperationException("No project is open.");
-        await content.CommitDraftsAsync();
+        var removing = request.Action == ProjectFileAction.Delete && request.DeleteGroups ? Analyze(request).Groups.ToHashSet(StringComparer.Ordinal) : null;
+        await content.CommitDraftsAsync(new(removing));
         var operation = new ProjectFileOperation(project.RootPath, request, catalog, types);
         try { await histories.Content.ExecuteAsync(new FileEdit(operation, content, assets)); }
         catch { operation.Dispose(); throw; }
diff --git a/src/Editor/GalNet.Editor/Services/ProjectReloadPrompt.cs b/src/Editor/GalNet.Editor/Services/ProjectReloadPrompt.cs
new file mode 100644
index 00000000..565838a2
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/ProjectReloadPrompt.cs
@@ -0,0 +1,35 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Layout;
+using GalNet.Editor.Abstraction.Services;
+
+namespace GalNet.Editor.Services;
+
+public static class ProjectReloadPrompt
+{
+    public static Task<bool> ConfirmAsync(IEditorLocalizationService localization)
+    {
+        var owner = (Application.Current?.ApplicationLifetime as IClassicDesktopStyleApplicationLifetime)?.Windows.FirstOrDefault(window => window.IsActive);
+        return owner is null ? Task.FromResult(false) : CreateDialog(localization).ShowDialog<bool>(owner);
+    }
+
+    public static Window CreateDialog(IEditorLocalizationService localization)
+    {
+        var bindings = new List<IDisposable>();
+        var dialog = new Window { Width = 600, MinHeight = 200, SizeToContent = SizeToContent.Height, CanResize = true, WindowStartupLocation = WindowStartupLocation.CenterOwner };
+        bindings.Add(LocalizedBindings.Bind(dialog, Window.TitleProperty, localization, "External.Reload"));
+        var question = new TextBlock { TextWrapping = Avalonia.Media.TextWrapping.Wrap };
+        bindings.Add(LocalizedBindings.Bind(question, TextBlock.TextProperty, localization, "External.DiscardQuestion"));
+        var buttons = new WrapPanel { HorizontalAlignment = HorizontalAlignment.Right, Orientation = Orientation.Horizontal };
+        foreach (var (key, accept) in new[] { ("External.DiscardReload", true), ("Common.Cancel", false) })
+        {
+            var button = new Button { Name = accept ? "ReloadExternal" : "CancelReload", Margin = new Thickness(4) };
+            bindings.Add(LocalizedBindings.Bind(button, ContentControl.ContentProperty, localization, key));
+            button.Click += (_, _) => dialog.Close(accept); buttons.Children.Add(button);
+        }
+        dialog.Content = new StackPanel { Margin = new Thickness(20), Spacing = 20, Children = { question, buttons } };
+        dialog.Closed += (_, _) => { foreach (var binding in bindings) binding.Dispose(); };
+        return dialog;
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/ProjectSceneTargets.cs b/src/Editor/GalNet.Editor/Services/ProjectSceneTargets.cs
index 501f0151..43b20634 100644
--- a/src/Editor/GalNet.Editor/Services/ProjectSceneTargets.cs
+++ b/src/Editor/GalNet.Editor/Services/ProjectSceneTargets.cs
@@ -3,26 +3,34 @@
 using Avalonia.Threading;
 using GalNet.Assets.Variants;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
-using GalNet.Core.Scene;
-using GalNet.Core.Variants;
+using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
 using GalNet.Editor.Services.Interfaces;
 using GalNet.Editor.Shared.Services;
 
 namespace GalNet.Editor.Services;
 
 /// <summary>One immutable author snapshot plus asynchronously loaded resource declarations per project scope.</summary>
-public sealed class ProjectSceneTargets : IDisposable
+public sealed class ProjectSceneTargets : IDisposable, IEntryParameterMetadataSource
 {
     private readonly IEditorDocumentService _documents;
     private readonly IAssetManager? _assets;
     private readonly IEffectCatalog? _effects;
+    public ISEffectCatalog AudioCatalog { get; }
+    private AudioConfiguration? _audioConfiguration;
+    private string _audioConfigurationFingerprint = "";
     private readonly IAssetCatalogService? _resources;
     private readonly IProjectContentSession? _content;
     private readonly IProjectService? _projects;
     private readonly IResourceTypeCatalog? _types;
+    private readonly AuthorChangeJournal? _changes;
+    private readonly UndoRedoHistory? _history;
     private string _workingFingerprint = "";
     private readonly object _gate = new();
     private CancellationTokenSource _resourceLifetime = new();
@@ -30,30 +38,78 @@ public sealed class ProjectSceneTargets : IDisposable
     private string? _snapshot;
     private EditorProjectDocument? _frozen;
     private SceneTargetAnalysis? _analysis;
+    private SceneTargetAnalysis? _previousAnalysis;
+    private bool _captureDirty = true;
+    private object? _documentIdentity;
+    private AuthorChangeSet? _pendingChange;
+    private readonly Dictionary<(string Group, string? Entry, SceneTimelinePosition? Position), SceneTargetResult> _queries = [];
+    private readonly Dictionary<(string Group, string? Entry, SceneTimelinePosition? Position), EditorEntryData?> _queryOwners = [];
+    private readonly Dictionary<(string Group, string? Entry, SceneTimelinePosition? Position), EditorEntryData?> _querySources = [];
+    private long _queryRevision;
+    public int AuthorCaptureCount { get; private set; }
+    public int AnalysisEntryTransferCount { get { lock (_gate) return _analysis?.EntryTransferCount ?? 0; } }
     private IReadOnlyDictionary<string, ShaderEffectDescriptor?> _programs = new Dictionary<string, ShaderEffectDescriptor?>(StringComparer.Ordinal);
     private IReadOnlyDictionary<string, ImageVariantsDefinition?> _variants = new Dictionary<string, ImageVariantsDefinition?>(StringComparer.OrdinalIgnoreCase);
     private Task? _loading;
     private long _resourceEpoch;
+    internal long ResourceEpoch { get { lock (_gate) return _resourceEpoch; } }
     public event Action? Changed;
     public long Revision { get; private set; }
     public bool IsAvailable { get { lock (_gate) return !_disposed && _documents.IsLoaded; } }
-    internal (object? Author, long Resources) PreparationStamp { get { lock (_gate) return (Capture() ? _frozen : null, _resourceEpoch); } }
+    internal (long Author, long Resources) PreparationStamp(string group, string entry, SceneTimelinePosition? position)
+    { lock (_gate) return (Query(group, entry, position).AuthorRevision, _resourceEpoch); }
 
     public ProjectSceneTargets(IEditorDocumentService documents, IAssetManager? assets = null,
         IEffectCatalog? effects = null, IAssetCatalogService? resources = null, IProjectContentSession? content = null,
-        IProjectService? projects = null, IResourceTypeCatalog? types = null)
+        IProjectService? projects = null, IResourceTypeCatalog? types = null, EditorHistories? histories = null, ISEffectCatalog? audioEffects = null)
     {
-        _documents = documents; _assets = assets; _effects = effects; _resources = resources;
+        _documents = documents; _assets = assets; _effects = effects; AudioCatalog = audioEffects ?? SEffectCatalog.Builtins; _resources = resources;
         _content = content; _projects = projects; _types = types;
+        _history = histories?.Content; _changes = _history?.AuthorChanges;
+        if (_changes is not null) _changes.Committed += OnAuthorCommitted;
+        _documents.DocumentChanged += OnDocumentChanged;
         if (_content is not null) _content.Changed += OnContentChanged;
         if (_resources is not null) _resources.Changed += OnResourcesChanged;
     }
+    private void OnAuthorCommitted(AuthorChangeSet change)
+    {
+        bool changed;
+        lock (_gate) { _captureDirty = true; _pendingChange = change; if (!Capture(true)) return; QueuePreparation(); changed = RefreshQueries(); }
+        if (changed) NotifyChanged();
+    }
+    private void OnDocumentChanged()
+    {
+        lock (_gate)
+        {
+            _captureDirty = true; _pendingChange = null;
+            if (_history?.IsBusy == true) return;
+            Capture(); RefreshQueries();
+        }
+        NotifyChanged();
+    }
     public ImageVariantsDefinition? VariantDefinition(string id)
     {
         lock (_gate) { if (!Capture()) return null; QueuePreparation(); return _variants.GetValueOrDefault(id.Trim()); }
     }
+    public ShaderEffectDescriptor? ProgramDescriptor(string id)
+    {
+        if (string.IsNullOrWhiteSpace(id)) return null;
+        lock (_gate) { if (!Capture()) return null; QueuePreparation(); return _programs.GetValueOrDefault(id.Trim()); }
+    }
+    EntryParameterMetadata IEntryParameterMetadataSource.Capture(EditorProjectDocument document)
+    {
+        lock (_gate)
+        {
+            if (!Capture()) return new(Revision: Revision);
+            QueuePreparation();
+            // Capture declarations and revision together; a completed load must not relabel an older snapshot.
+            return new(_effects, AudioCatalog, EntryParameterMetadata.ProgramIds(document).Take(256)
+                .ToDictionary(id => id, id => _programs.GetValueOrDefault(id.Trim()), StringComparer.Ordinal), Revision);
+        }
+    }
     private void OnContentChanged()
     {
+        lock (_gate) RefreshAudioConfiguration();
         var fingerprint = string.Join("\n", _content!.FileDocuments.Values.Where(file => file.Exists && file.ManagedContent && file.Path.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
             .OrderBy(file => file.Id, StringComparer.Ordinal).Select(file => file.Id + ":" + file.Path + ":" + Convert.ToBase64String(file.Data)));
         if (fingerprint == _workingFingerprint) return;
@@ -61,17 +117,80 @@ private void OnContentChanged()
     }
 
     public SceneTargetResult Before(string groupId, string? entryId) => Query(groupId, entryId, null);
+    internal SceneTargetResult InspectBefore(string groupId, string entryId) => Query(groupId, entryId, null, retain: false);
     public SceneTargetResult AtTimeline(string groupId, string entryId, SceneTimelinePosition position) => Query(groupId, entryId, position);
-    private SceneTargetResult Query(string groupId, string? entryId, SceneTimelinePosition? position)
+    public IReadOnlyList<SceneReferenceDiagnostic> Diagnostics()
+    {
+        lock (_gate)
+        {
+            if (!Capture()) return [];
+            QueuePreparation();
+            EnsureAnalysis();
+            return SceneReferenceAnalysis.Diagnose(new SceneReferenceIndex(_frozen!.GroupEntries), _analysis).Select(diagnostic => diagnostic with { Revision = Revision }).ToArray();
+        }
+    }
+    private SceneTargetResult Query(string groupId, string? entryId, SceneTimelinePosition? position, bool retain = true)
     {
         lock (_gate)
         {
             if (!Capture()) return new([], false, false);
             QueuePreparation();
-            _analysis ??= new(_frozen!.Graph, _frozen.GroupEntries, programs: _assets is null ? null : _programs, effects: _effects, variants: _variants);
-            return position is null ? _analysis.Before(groupId, entryId) : entryId is null ? new([], false, false) : _analysis.AtTimeline(groupId, entryId, position);
+            RefreshAudioConfiguration();
+            EnsureAnalysis();
+            var key = (groupId, entryId, position);
+            if (!retain) return Evaluate(key);
+            if (!_queries.ContainsKey(key) && _queries.Count >= 256) { var oldest = _queries.Keys.First(); _queries.Remove(oldest); _queryOwners.Remove(oldest); _querySources.Remove(oldest); }
+            return UpdateQuery(key);
         }
     }
+    private void RefreshAudioConfiguration()
+    {
+        if (_content is null || _disposed || !_documents.IsLoaded) return;
+        var options = (_projects?.Current?.Configuration ?? _content.CaptureWorking().Configuration).ReadDefaultOptions();
+        var fingerprint = JsonSerializer.Serialize(new { options.AudioTracks, options.AudioBuses });
+        if (fingerprint == _audioConfigurationFingerprint) return;
+        _audioConfigurationFingerprint = fingerprint;
+        try { _audioConfiguration = new(options.AudioTracks, options.AudioBuses); }
+        catch (InvalidDataException) { _audioConfiguration = AudioConfiguration.Empty; }
+        _analysis = null; _previousAnalysis = null;
+        Revision++;
+        RefreshQueries();
+        NotifyChanged();
+    }
+    private void EnsureAnalysis()
+    {
+        if (_analysis is not null || _frozen is null) return;
+        _analysis = new(_frozen.Graph, _frozen.GroupEntries, programs: _assets is null ? null : _programs, effects: _effects, variants: _variants, previousAnalysis: _previousAnalysis, audioConfiguration: _audioConfiguration, audioCatalog: AudioCatalog);
+        _previousAnalysis = null;
+    }
+    private SceneTargetResult Evaluate((string Group, string? Entry, SceneTimelinePosition? Position) key) => key.Position is null
+        ? _analysis!.Before(key.Group, key.Entry) : key.Entry is null ? new([], false, false) : _analysis!.AtTimeline(key.Group, key.Entry, key.Position);
+    private bool RefreshQueries(bool author = true)
+    {
+        if (_queries.Count == 0) return true;
+        var changed = false;
+        EnsureAnalysis();
+        foreach (var key in _queries.Keys.ToArray())
+        {
+            var previous = _queries[key];
+            var next = UpdateQuery(key, author);
+            changed |= previous.AudioRevision != next.AudioRevision || previous.Revision != next.Revision || previous.ContextRevision != next.ContextRevision || previous.AuthorRevision != next.AuthorRevision;
+        }
+        return changed;
+    }
+    private SceneTargetResult UpdateQuery((string Group, string? Entry, SceneTimelinePosition? Position) key, bool author = true)
+    {
+        var next = _analysis is null ? new SceneTargetResult([], false, false) : Evaluate(key);
+        var owner = _frozen?.GroupEntries.GetValueOrDefault(key.Group)?.FirstOrDefault(entry => entry.StableId == key.Entry);
+        var source = _documents.Groups.GetValueOrDefault(key.Group)?.Entries.FirstOrDefault(entry => entry.StableId == key.Entry);
+        _queries.TryGetValue(key, out var previous);
+        var version = previous is not null && SceneTargetAnalysis.Equivalent(previous, next) ? previous.Revision : ++_queryRevision;
+        var audioVersion = previous is not null && SceneTargetAnalysis.EquivalentAudio(previous, next) ? previous.AudioRevision : ++_queryRevision;
+        var context = previous is not null && ReferenceEquals(_querySources.GetValueOrDefault(key), source) && SceneTargetAnalysis.SameEntry(_queryOwners.GetValueOrDefault(key), owner) ? previous.ContextRevision : ++_queryRevision;
+        var dependency = previous is not null && (!author || version == previous.Revision && context == previous.ContextRevision) ? previous.AuthorRevision : ++_queryRevision;
+        _queryOwners[key] = owner; _querySources[key] = source;
+        return _queries[key] = next with { Revision = version, AudioRevision = audioVersion, ContextRevision = context, AuthorRevision = dependency };
+    }
 
     // Only the caller's wait is cancelled; resource IO belongs to the project/refresh generation.
     public async Task PrepareAsync(CancellationToken token = default)
@@ -85,13 +204,26 @@ public async Task PrepareAsync(CancellationToken token = default)
         }
     }
 
-    private bool Capture()
+    private bool Capture(bool committed = false)
     {
         if (_disposed) return false;
         if (!_documents.IsLoaded)
         {
             if (_snapshot is not null) Revision++;
-            _snapshot = null; _frozen = null; _analysis = null; return false;
+            _snapshot = null; _frozen = null; _analysis = null; _previousAnalysis = null; _queries.Clear(); _queryOwners.Clear(); _querySources.Clear(); _captureDirty = true; return false;
+        }
+        // Managed projects publish mutations through the author journal/document notification. Standalone callers retain the legacy snapshot fallback.
+        if (_changes is not null && !_captureDirty) return true;
+        if (!committed && _history?.IsBusy == true && _frozen is not null) return true;
+        if (_changes is not null && ReferenceEquals(_documentIdentity, _documents.CurrentDocument) && _frozen is not null && _pendingChange is { UnknownScope: false } change)
+        {
+            var groups = _frozen.GroupEntries.ToDictionary(pair => pair.Key, pair => pair.Value);
+            foreach (var group in change.Groups)
+                if (_documents.Groups.TryGetValue(group.GroupId, out var source)) groups[group.GroupId] = JsonSerializer.Deserialize<List<EditorEntryData>>(JsonSerializer.Serialize(source.Entries))!;
+                else groups.Remove(group.GroupId);
+            _frozen = new() { Graph = _frozen.Graph, GroupEntries = groups };
+            _snapshot = null; _previousAnalysis = _analysis; _analysis = null; _captureDirty = false; _pendingChange = null; AuthorCaptureCount++; Revision++;
+            return true;
         }
         var snapshot = JsonSerializer.Serialize(new EditorProjectDocument
         {
@@ -101,8 +233,9 @@ private bool Capture()
         if (snapshot != _snapshot)
         {
             _frozen = JsonSerializer.Deserialize<EditorProjectDocument>(snapshot)!;
-            _snapshot = snapshot; _analysis = null; Revision++;
+            _snapshot = snapshot; _previousAnalysis = _analysis; _analysis = null; AuthorCaptureCount++; Revision++;
         }
+        _captureDirty = false; _pendingChange = null; _documentIdentity = _documents.CurrentDocument;
         return true;
     }
 
@@ -110,7 +243,7 @@ private bool Capture()
     {
         if (_assets is null || _frozen is null || _disposed) return null;
         if (_loading is not null) return _loading;
-        var ids = Programs(_frozen).Distinct(StringComparer.Ordinal).Take(256).Where(id => !_programs.ContainsKey(id)).ToArray();
+        var ids = EntryParameterMetadata.ProgramIds(_frozen).Take(256).Where(id => !_programs.ContainsKey(id)).ToArray();
         var variants = Variants(_frozen).Distinct(StringComparer.OrdinalIgnoreCase).Take(256).Where(id => !_variants.ContainsKey(id)).ToArray();
         if (ids.Length == 0 && variants.Length == 0) return null;
         var epoch = _resourceEpoch;
@@ -135,7 +268,7 @@ private async Task LoadAsync(string[] ids, string[] variants, long epoch, Cancel
                 {
                     var file = await _assets!.GetFileAsync(id, token);
                     if (file is null || file.TypeId != "effect-program" || file.Length > 1024 * 1024) continue;
-                    var bytes = await file.ReadAllBytesAsync(token);
+                    var bytes = working.TryGetValue("Assets/" + file.Path, out var author) ? author : await file.ReadAllBytesAsync(token);
                     if (bytes.Length > 1024 * 1024) continue;
                     var source = new UTF8Encoding(false, true).GetString(bytes);
                     var parsed = ShaderEffectMetadataParser.Parse(new EffectProgramResource(id), source);
@@ -169,13 +302,13 @@ private async Task LoadAsync(string[] ids, string[] variants, long epoch, Cancel
             lock (_gate)
             {
                 if (_disposed || epoch != _resourceEpoch || _frozen is null) return;
-                var referenced = Programs(_frozen!).Distinct(StringComparer.Ordinal).Take(256).ToHashSet(StringComparer.Ordinal);
+                var referenced = EntryParameterMetadata.ProgramIds(_frozen!).Take(256).ToHashSet(StringComparer.Ordinal);
                 var merged = _programs.Where(pair => referenced.Contains(pair.Key)).ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.Ordinal);
                 foreach (var pair in loaded.Where(pair => referenced.Contains(pair.Key))) merged[pair.Key] = pair.Value;
                 var referencedVariants = Variants(_frozen).Distinct(StringComparer.OrdinalIgnoreCase).Take(256).ToHashSet(StringComparer.OrdinalIgnoreCase);
                 var mergedVariants = _variants.Where(pair => referencedVariants.Contains(pair.Key)).ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.OrdinalIgnoreCase);
                 foreach (var pair in loadedVariants.Where(pair => referencedVariants.Contains(pair.Key))) mergedVariants[pair.Key] = pair.Value;
-                _programs = merged; _variants = mergedVariants; _analysis = null; Revision++;
+                _programs = merged; _variants = mergedVariants; _analysis = null; _previousAnalysis = null; Revision++; RefreshQueries(false);
             }
             NotifyChanged();
         }
@@ -187,27 +320,6 @@ private static IEnumerable<string> Variants(EditorProjectDocument project) => pr
         .Where(entry => entry.Type == BuiltinEntryIds.ShowVariants).Select(entry => entry.Parameters.GetValueOrDefault("assetId"))
         .Where(value => value.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(value.GetString())).Select(value => value.GetString()!.Trim());
 
-    private static IEnumerable<string> Programs(EditorProjectDocument project)
-    {
-        foreach (var entry in project.GroupEntries.Values.SelectMany(entries => entries))
-        {
-            if (entry.Type == "effect.apply" && entry.Parameters.TryGetValue("program", out var program)
-                && program.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(program.GetString())) yield return program.GetString()!;
-            if (entry.Type != "timeline.play" || !entry.Parameters.TryGetValue("timeline", out var timeline) || timeline.ValueKind != JsonValueKind.Object) continue;
-            var events = Member(timeline, "events");
-            if (events.ValueKind != JsonValueKind.Array) continue;
-            foreach (var item in events.EnumerateArray())
-            {
-                if (item.ValueKind != JsonValueKind.Object || Member(item, "type") is not { ValueKind: JsonValueKind.String } type || type.GetString() != "effect.apply") continue;
-                var parameters = Member(item, "parameters");
-                if (parameters.ValueKind == JsonValueKind.Object && parameters.TryGetProperty("program", out program)
-                    && program.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(program.GetString())) yield return program.GetString()!;
-            }
-        }
-    }
-
-    private static JsonElement Member(JsonElement element, string name) => element.EnumerateObject()
-        .FirstOrDefault(property => string.Equals(property.Name, name, StringComparison.OrdinalIgnoreCase)).Value;
     private void OnResourcesChanged() => Dispatcher.UIThread.Post(InvalidateResources);
     public void InvalidateResources()
     {
@@ -215,9 +327,9 @@ public void InvalidateResources()
         {
             if (_disposed) return;
             _resourceEpoch++; _resourceLifetime.Cancel(); _resourceLifetime.Dispose(); _resourceLifetime = new();
-            _programs = new Dictionary<string, ShaderEffectDescriptor?>(StringComparer.Ordinal); _loading = null; _analysis = null; Revision++;
+            _programs = new Dictionary<string, ShaderEffectDescriptor?>(StringComparer.Ordinal); _loading = null; _analysis = null; _previousAnalysis = null; Revision++;
             _variants = new Dictionary<string, ImageVariantsDefinition?>(StringComparer.OrdinalIgnoreCase);
-            if (Capture()) QueuePreparation();
+            if (Capture()) { QueuePreparation(); RefreshQueries(false); }
         }
         NotifyChanged();
     }
@@ -230,7 +342,9 @@ public void Dispose()
             _disposed = true; _resourceEpoch++; _resourceLifetime.Cancel(); _resourceLifetime.Dispose();
             if (_resources is not null) _resources.Changed -= OnResourcesChanged;
             if (_content is not null) _content.Changed -= OnContentChanged;
-            _snapshot = null; _frozen = null; _analysis = null; _programs = new Dictionary<string, ShaderEffectDescriptor?>(); Revision++; Changed = null;
+            if (_changes is not null) _changes.Committed -= OnAuthorCommitted;
+            _documents.DocumentChanged -= OnDocumentChanged;
+            _snapshot = null; _frozen = null; _analysis = null; _previousAnalysis = null; _queries.Clear(); _queryOwners.Clear(); _querySources.Clear(); _programs = new Dictionary<string, ShaderEffectDescriptor?>(); Revision++; Changed = null;
             _variants = new Dictionary<string, ImageVariantsDefinition?>();
         }
     }
diff --git a/src/Editor/GalNet.Editor/Services/ProjectTextFiles.cs b/src/Editor/GalNet.Editor/Services/ProjectTextFiles.cs
index 9e36bbb9..42aaec55 100644
--- a/src/Editor/GalNet.Editor/Services/ProjectTextFiles.cs
+++ b/src/Editor/GalNet.Editor/Services/ProjectTextFiles.cs
@@ -14,6 +14,14 @@ namespace GalNet.Editor.Services;
 public sealed class ProjectTextFiles(IProjectService projects, IProjectContentSession content, EditorHistories histories, IEditorLocalizationService localization, IResourceTypeCatalog? resourceTypes = null) : IDisposable
 {
     private readonly Dictionary<string, ProjectTextBuffer> _buffers = [];
+    public bool CanOpen(string path)
+    {
+        if (projects.Current is null) return false;
+        var document = content.FileDocuments.Values.FirstOrDefault(file => ProjectFilePaths.Comparer.Equals(file.Path, path));
+        if (document is not null) return document.Exists;
+        try { return File.Exists(new ProjectRawReader(projects.Current.RootPath).Resolve(path)); }
+        catch (Exception error) when (error is IOException or ArgumentException or UnauthorizedAccessException) { return false; }
+    }
     public ProjectTextBuffer Get(string id) => _buffers[id];
     public ProjectTextBuffer Open(string path)
     {
@@ -78,7 +86,7 @@ public sealed partial class ProjectTextBuffer : ObservableObject, IDisposable
     private readonly IProjectContentSession _content;
     private readonly EditorHistories _histories;
     private readonly IEditorLocalizationService _localization;
-    private readonly Encoding? _encoding;
+    private Encoding? _encoding;
     private readonly string _root;
     private readonly bool _canEdit;
     private readonly IDisposable _draft;
@@ -90,7 +98,7 @@ public sealed partial class ProjectTextBuffer : ObservableObject, IDisposable
     public string Id => _document.Id;
     public string Path => _document.Path;
     public string Title => System.IO.Path.GetFileName(Path) + (IsDirty ? " *" : "");
-    public bool IsReadOnly => _disposed || !_canEdit || !_document.ManagedContent || !_document.Exists || _content.RepairRequired;
+    public bool IsReadOnly => _disposed || !_canEdit || _encoding is null || !_document.ManagedContent || !_document.Exists || _content.RepairRequired;
     public bool IsDirty => _document.Exists && _document.ManagedContent && (HasDraft || !_content.CaptureSaved().Files.TryGetValue(Id, out var saved) || !saved.Data.AsSpan().SequenceEqual(_document.Data));
     private bool HasDraft => !IsReadOnly && Text != Decode(_observed);
     public string Information => !_document.Exists ? _localization["Files.Missing"] : IsReadOnly ? _localization["Files.ReadOnly"] : _encoding!.WebName;
@@ -104,10 +112,21 @@ public ProjectTextBuffer(EditorFileDocument document, IProjectContentSession con
         _document = document; _content = content; _histories = histories; _localization = localization; _encoding = encoding; _root = root;
         _canEdit = canEdit;
         _text = document.ManagedContent && encoding is not null ? Decode(document.Data) : text; _observed = document.Data.ToArray();
-        _draft = content.RegisterFileDraft(document.Id, () => HasDraft, CommitAsync, ValidateStructuredDraft);
+        _draft = content.RegisterFileDraft(document.Id, () => HasDraft, CommitAsync, ValidateStructuredDraft, Cancel);
         content.Changed += OnChanged; localization.PropertyChanged += OnLocale;
+        content.ExternalReloaded += OnExternalReload;
+    }
+    private string Decode(byte[] bytes) => bytes.Length < _encoding!.GetPreamble().Length ? "" : _encoding.GetString(bytes, _encoding.GetPreamble().Length, bytes.Length - _encoding.GetPreamble().Length);
+    private void OnExternalReload()
+    {
+        _failure = null; _externalChange = false; Error = "";
+        var full = new ProjectRawReader(_root).Resolve(Path);
+        if (!_document.ManagedContent) _document.Exists = File.Exists(full);
+        var bytes = _document.ManagedContent ? _document.Data : _document.Exists && new FileInfo(full).Length <= 2 * 1024 * 1024 ? File.ReadAllBytes(full) : [];
+        if (!ProjectTextFiles.TryDecode(bytes, out _encoding, out var text)) { _encoding = null; text = ""; }
+        _observed = _document.Data.ToArray(); Text = text;
+        OnChanged();
     }
-    private string Decode(byte[] bytes) => _encoding!.GetString(bytes, _encoding.GetPreamble().Length, bytes.Length - _encoding.GetPreamble().Length);
     partial void OnTextChanged(string value) { if (!_disposed) _content.Refresh(); OnPropertyChanged(nameof(Title)); }
     private void OnLocale(object? sender, PropertyChangedEventArgs args)
     {
@@ -183,5 +202,5 @@ private void Apply(byte[] expected, byte[] next)
         public void Redo() => Apply(Before, After);
         public void Undo() => Apply(After, Before);
     }
-    public void Dispose() { if (_disposed) return; _disposed = true; _content.Changed -= OnChanged; _localization.PropertyChanged -= OnLocale; _draft.Dispose(); OnPropertyChanged(nameof(IsReadOnly)); }
+    public void Dispose() { if (_disposed) return; _disposed = true; _content.Changed -= OnChanged; _content.ExternalReloaded -= OnExternalReload; _localization.PropertyChanged -= OnLocale; _draft.Dispose(); OnPropertyChanged(nameof(IsReadOnly)); }
 }
diff --git a/src/Editor/GalNet.Editor/Services/ResourceOverrideAuthoringService.cs b/src/Editor/GalNet.Editor/Services/ResourceOverrideAuthoringService.cs
new file mode 100644
index 00000000..79e30c39
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/ResourceOverrideAuthoringService.cs
@@ -0,0 +1,106 @@
+using GalNet.Assets;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+using GalNet.Editor.Abstraction.Changes;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+public sealed class ResourceOverrideAuthoringService(IProjectService projects, IProjectContentSession content,
+    EditorHistories histories, IAssetManager assets, IResourceTypeCatalog types, GalNet.Core.Entry.IEntryCatalog catalog,
+    IEntryParameterMetadataSource metadata)
+{
+    public IProjectContentSession Content => content;
+    public IAssetManager Assets => assets;
+    public EditorHistories Histories => histories;
+    public ResourceOverrideOptions Read() => projects.Current?.Configuration.Read(ResourceOverrideOptions.Section) ?? new();
+    public async Task<ResourceReferenceIndex> SnapshotAsync(CancellationToken ct)
+    {
+        var document = content.CaptureWorking();
+        var fields = metadata.Capture(document);
+        var files = await assets.GetFilesAsync(ct: ct);
+        ct.ThrowIfCancellationRequested();
+        return new(document, catalog, files, fields);
+    }
+    public async Task<string> CreateAsync(string name)
+    {
+        var id = Guid.NewGuid().ToString("N");
+        await UpdateAsync(options => options.Packages.Add(new() { Id = id, Name = Name(name) }));
+        return id;
+    }
+    public Task SetHeaderAsync(string id, string name, int priority) => UpdateAsync(options =>
+    {
+        var package = Package(options, id);
+        package.Name = Name(name); package.Priority = priority;
+    });
+    public Task DeleteAsync(string id) => UpdateAsync(options => options.Packages.Remove(Package(options, id)));
+    public async Task AddOriginalAsync(string id)
+    {
+        var project = projects.Current;
+        var file = await assets.GetFileAsync(id) ?? throw new InvalidDataException("Original resource is missing.");
+        if (!ReferenceEquals(projects.Current, project) || file.TypeId is "graph" or "group") throw new InvalidDataException("Original resource is unavailable.");
+        await UpdateAsync(options => { if (!options.AdditionalOriginals.Contains(file.Id, StringComparer.OrdinalIgnoreCase)) options.AdditionalOriginals.Add(file.Id); });
+    }
+    public async Task SetMappingAsync(string packageId, string sourceId, string targetId, string? expected)
+    {
+        var project = projects.Current;
+        var revision = (assets as Interfaces.IEditorAssetChanges)?.Revision;
+        targetId = targetId.Trim();
+        if (targetId.Length != 0)
+        {
+            var original = await assets.GetFileAsync(sourceId) ?? throw new InvalidDataException("Original resource is missing.");
+            var replacement = await assets.GetFileAsync(targetId) ?? throw new InvalidDataException("Replacement resource is missing.");
+            if (StringComparer.OrdinalIgnoreCase.Equals(original.Id, replacement.Id)) throw new InvalidDataException("Choose a different replacement resource, or clear this cell.");
+            ResourceOverrideBuilder.ValidateCompatibility(original, replacement);
+        }
+        if (!ReferenceEquals(project, projects.Current) || revision != (assets as Interfaces.IEditorAssetChanges)?.Revision)
+            throw new InvalidOperationException("Resources changed while selecting the replacement. Choose again.");
+        await UpdateAsync(options =>
+        {
+            var package = Package(options, packageId);
+            if (package.Mappings.GetValueOrDefault(sourceId) != expected) throw new InvalidOperationException("This override cell changed. Choose again.");
+            if (targetId.Length == 0) package.Mappings.Remove(sourceId); else package.Mappings[sourceId] = targetId;
+        });
+    }
+    public async Task ExportAsync(string id, string target, CancellationToken ct)
+    {
+        var project = projects.Current ?? throw new InvalidOperationException("Open a project first.");
+        using var capture = await histories.Content.AcquireCaptureAsync(cancellationToken: ct);
+        if (!ReferenceEquals(projects.Current, project)) throw new InvalidOperationException("The project was closed.");
+        var definition = Package(content.CaptureSaved().Configuration.Read(ResourceOverrideOptions.Section), id);
+        // The capture lease protects disk publication only until the private resource copy exists.
+        await Task.Run(() => ResourceOverrideExporter.ExportAsync(project.Id, project.RootPath, definition, target, types, ct, capture.Dispose), ct);
+    }
+    private static ResourceOverrideDefinition Package(ResourceOverrideOptions options, string id) => options.Packages.SingleOrDefault(package => package.Id == id)
+        ?? throw new InvalidOperationException("This resource patch no longer exists.");
+    private static string Name(string value) => string.IsNullOrWhiteSpace(value) ? throw new ArgumentException("Patch name is required.") : value.Trim();
+    private async Task UpdateAsync(Action<ResourceOverrideOptions> change)
+    {
+        var configuration = projects.Current?.Configuration ?? throw new InvalidOperationException("Open a project first.");
+        var before = configuration.Sections.GetValueOrDefault(ResourceOverrideOptions.Section.Id);
+        var next = configuration.Clone();
+        var options = next.Read(ResourceOverrideOptions.Section); change(options); next.Set(ResourceOverrideOptions.Section, options);
+        var after = next.Sections[ResourceOverrideOptions.Section.Id];
+        if (!ConfigurationSectionEditor.Equal(before, after)) await histories.Content.ExecuteAsync(new DefinitionEdit(content, before, after));
+    }
+    private sealed record DefinitionEdit(IProjectContentSession Content, ProjectSectionData? Before, ProjectSectionData After) : IAsyncUndoableEdit
+    {
+        public string Description => "Change resource patches";
+        public long RetainedBytes => (Before?.Data.GetRawText().Length ?? 0) * 2L + After.Data.GetRawText().Length * 2L;
+        public ValueTask UndoAsync() => new(Content.PublishStructureAsync(new SectionChange(After, Before)));
+        public ValueTask RedoAsync() => new(Content.PublishStructureAsync(new SectionChange(Before, After)));
+    }
+    private sealed record SectionChange(ProjectSectionData? Expected, ProjectSectionData? Value) : IProjectStructureChange
+    {
+        public void Apply(EditorProjectDocument document, AuthorDocumentVersion version)
+        {
+            var configuration = document.Configuration;
+            if (version == AuthorDocumentVersion.Working && !ConfigurationSectionEditor.Equal(configuration.Sections.GetValueOrDefault(ResourceOverrideOptions.Section.Id), Expected))
+                throw new InvalidOperationException("Resource patch definitions changed outside this edit.");
+            if (Value is null) configuration.Remove(ResourceOverrideOptions.Section.Id); else configuration.SetRaw(ResourceOverrideOptions.Section.Id, Value);
+        }
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Services/SceneSourceDescriptions.cs b/src/Editor/GalNet.Editor/Services/SceneSourceDescriptions.cs
new file mode 100644
index 00000000..4762fd37
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/SceneSourceDescriptions.cs
@@ -0,0 +1,63 @@
+using Avalonia.Threading;
+using GalNet.Core.Assets;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Services;
+
+/// <summary>Shared source names. Metadata IO is project-owned and bounded; reads never block the UI.</summary>
+internal sealed class SceneSourceDescriptions(IEditorDocumentService documents, IAssetManager assets, IEditorLocalizationService text) : IDisposable
+{
+    private readonly object _gate = new();
+    private CancellationTokenSource _lifetime = new();
+    private bool _disposed;
+    private readonly Dictionary<string, string> _paths = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, Task> _loading = new(StringComparer.Ordinal);
+    private long _epoch;
+    public event Action? Changed;
+    public string Resource(string id)
+    {
+        if (string.IsNullOrWhiteSpace(id)) return "";
+        string? path; lock (_gate) path = _paths.GetValueOrDefault(id);
+        if (path is null) _ = PrepareAsync(id);
+        return !string.IsNullOrEmpty(path) ? Path.GetFileName(path) : Guid.TryParse(id, out _) ? text["Scene.Unresolved"] : id;
+    }
+    public string Origin(SceneTarget target)
+        => Origin(target.Locator);
+    public string Origin(SceneLocator locator)
+    {
+        var group = documents.CurrentDocument.Nodes.FirstOrDefault(node => node.Id == locator.GroupId);
+        var entry = documents.Groups.GetValueOrDefault(locator.GroupId)?.Entries.FirstOrDefault(item => item.StableId == locator.EntryId);
+        return (group?.Name ?? "") + " / " + entry?.Id;
+    }
+    public Task PrepareAsync(string id)
+    {
+        lock (_gate)
+        {
+            if (_disposed || _paths.ContainsKey(id)) return Task.CompletedTask;
+            if (_loading.TryGetValue(id, out var pending)) return pending;
+            if (_loading.Count >= 64) return Task.CompletedTask;
+            var epoch = _epoch;
+            var token = _lifetime.Token;
+            return _loading[id] = Task.Run(async () =>
+            {
+                string path = "";
+                try { path = (await assets.GetFileAsync(id, token))?.Path ?? ""; }
+                catch (OperationCanceledException) when (token.IsCancellationRequested) { return; }
+                catch (Exception failure) { Serilog.Log.Debug(failure, "Cannot describe scene resource {Resource}", id); }
+                lock (_gate)
+                {
+                    if (_disposed || epoch != _epoch) return;
+                    _loading.Remove(id);
+                    if (_paths.Count >= 512) _paths.Remove(_paths.Keys.First());
+                    _paths[id] = path;
+                }
+                if (path.Length != 0) Dispatcher.UIThread.Post(() => { if (!_disposed && epoch == _epoch) Changed?.Invoke(); });
+            });
+        }
+    }
+    public void Invalidate()
+    { lock (_gate) { if (_disposed) return; _epoch++; _lifetime.Cancel(); _lifetime.Dispose(); _lifetime = new(); _paths.Clear(); _loading.Clear(); } }
+    public void Dispose()
+    { lock (_gate) { if (_disposed) return; _disposed = true; _lifetime.Cancel(); _lifetime.Dispose(); _paths.Clear(); _loading.Clear(); Changed = null; } }
+}
diff --git a/src/Editor/GalNet.Editor/Services/SceneTargetCatalog.Audio.cs b/src/Editor/GalNet.Editor/Services/SceneTargetCatalog.Audio.cs
new file mode 100644
index 00000000..15edf2ec
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/SceneTargetCatalog.Audio.cs
@@ -0,0 +1,45 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Editor.Shared.Services;
+using GalNet.Game.Controls.Forms;
+
+namespace GalNet.Editor.Services;
+
+public sealed record AudioEffectSnapshot(string GroupId, string EntryId, SEffectScope Scope, string TargetId,
+    long Revision, long ContextRevision, bool Complete, IReadOnlyList<AudioEffectTarget> Targets);
+public sealed record AudioFieldChoice(AudioEffectSnapshot Snapshot, AudioEffectTarget? Target, string Label, bool All = false)
+{ public override string ToString() => Label; }
+
+public sealed partial class SceneTargetCatalog
+{
+    public ISEffectCatalog AudioCatalog => query.AudioCatalog;
+    public string AudioTypeName(string type) => localization["Audio.Type." + type] is { } label && label != "Audio.Type." + type ? label : type;
+    public AudioEffectSnapshot QueryAudio(string groupId, string entryId, bool retain = true)
+    {
+        var entry = documents.Groups.GetValueOrDefault(groupId)?.Entries.FirstOrDefault(entry => entry.StableId == entryId);
+        var scope = entry?.Parameters.GetValueOrDefault("scope") is { ValueKind: JsonValueKind.String } value && value.GetString() == "bus" ? SEffectScope.Bus : SEffectScope.Track;
+        var targetId = entry?.Parameters.GetValueOrDefault("targetId") is { ValueKind: JsonValueKind.String } target ? target.GetString() ?? "" : "";
+        var result = retain ? query.Before(groupId, entryId) : query.InspectBefore(groupId, entryId);
+        return new(groupId, entryId, scope, targetId, result.AudioRevision, result.ContextRevision, result.Reachable && result.AudioComplete,
+            result.AudioEffects.Where(effect => effect.Key.Scope == scope && effect.Key.TargetId == targetId).ToArray());
+    }
+    public bool IsCurrent(AudioEffectSnapshot snapshot)
+    {
+        if (!query.IsAvailable) return false;
+        var current = QueryAudio(snapshot.GroupId, snapshot.EntryId);
+        return current.Revision == snapshot.Revision && current.ContextRevision == snapshot.ContextRevision && current.Scope == snapshot.Scope && current.TargetId == snapshot.TargetId;
+    }
+    private IReadOnlyList<FieldEditorOption> AudioFieldOptions(string groupId, string entryId, string type)
+    {
+        var snapshot = QueryAudio(groupId, entryId);
+        var options = snapshot.Targets.Select(target => new FieldEditorOption(JsonSerializer.Serialize(target.Key),
+            new AudioFieldChoice(snapshot, target, AudioDescription(target)
+                + " · " + localization[target.Presence == TargetPresence.Definite ? "Timeline.Definite" : "Timeline.Possible"]),
+            JsonSerializer.SerializeToElement(target.Key.InstanceId))).ToList();
+        if (type == BuiltinEntryIds.StopAudioSEffect)
+            options.Insert(0, new("all", new AudioFieldChoice(snapshot, null, localization["Audio.AllEffects"], All: true), JsonSerializer.SerializeToElement<object?>(null)));
+        return options;
+    }
+    private string AudioDescription(AudioEffectTarget target) => string.Join(" / ", target.Types.Select(AudioTypeName)) + " · " + string.Join("; ", target.Sources.Select(_descriptions.Origin));
+}
diff --git a/src/Editor/GalNet.Editor/Services/SceneTargetCatalog.cs b/src/Editor/GalNet.Editor/Services/SceneTargetCatalog.cs
index d95bb62c..971966d5 100644
--- a/src/Editor/GalNet.Editor/Services/SceneTargetCatalog.cs
+++ b/src/Editor/GalNet.Editor/Services/SceneTargetCatalog.cs
@@ -1,7 +1,7 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
-using GalNet.Core.Variants;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Models.Graph;
 using GalNet.Editor.Shared.Services;
@@ -10,20 +10,32 @@
 namespace GalNet.Editor.Services;
 
 public sealed record SceneTargetChoice(SceneTarget Target, ResourcePickerItem Item);
-public sealed record SceneTargetSnapshot(string GroupId, string EntryId, long Revision, bool Complete, IReadOnlyList<SceneTargetChoice> Choices, Func<SceneTarget, bool>? Filter = null, SceneTimelinePosition? Position = null, bool Playback = false);
+public sealed record SceneTargetSnapshot(string GroupId, string EntryId, long Revision, bool Complete, IReadOnlyList<SceneTargetChoice> Choices, Func<SceneTarget, bool>? Filter = null, SceneTimelinePosition? Position = null, bool Playback = false, long ContextRevision = 0);
 public sealed record SceneFieldChoice(SceneTargetSnapshot Snapshot, SceneTargetChoice? Choice, ResourcePickerItem Item, string? EmptyLabelKey = null)
 { public override string ToString() => Item.Label; }
 public sealed record VariantFieldSource(SceneTargetSnapshot Snapshot, ImageVariantsDefinition? Definition, string? Dimension);
 
 /// <summary>Editor adapter: stable locator choices resolve to opaque runtime handles only at commit.</summary>
-public sealed class SceneTargetCatalog(ProjectSceneTargets query, IEditorDocumentService documents, IAssetManager assets, IEditorLocalizationService localization)
+public sealed partial class SceneTargetCatalog : IDisposable
 {
-    private readonly Dictionary<string, string> _paths = new(StringComparer.Ordinal);
+    private readonly ProjectSceneTargets query;
+    private readonly IEditorDocumentService documents;
+    private readonly IEditorLocalizationService localization;
+    private readonly SceneSourceDescriptions _descriptions;
+    private long _resourceEpoch;
+    public SceneTargetCatalog(ProjectSceneTargets query, IEditorDocumentService documents, IAssetManager assets, IEditorLocalizationService localization)
+    {
+        this.query = query; this.documents = documents; this.localization = localization;
+        _descriptions = new(documents, assets, localization); _resourceEpoch = query.ResourceEpoch;
+        query.Changed += OnQueryChanged;
+    }
+    private void OnQueryChanged() { if (_resourceEpoch != query.ResourceEpoch) { _resourceEpoch = query.ResourceEpoch; _descriptions.Invalidate(); } }
     public IEditorLocalizationService Text => localization;
-    public event Action? Changed { add => query.Changed += value; remove => query.Changed -= value; }
-    internal (object? Author, long Resources) PreparationStamp => query.PreparationStamp;
-    internal bool IsSamePreparation((object? Author, long Resources) stamp)
-    { var current = query.PreparationStamp; return query.IsAvailable && ReferenceEquals(current.Author, stamp.Author) && current.Resources == stamp.Resources; }
+    public event Action? Changed { add { query.Changed += value; _descriptions.Changed += value; } remove { query.Changed -= value; _descriptions.Changed -= value; } }
+    internal string ResourceLabel(string id) => _descriptions.Resource(id);
+    internal (long Author, long Resources) PreparationStamp(SceneTargetSnapshot snapshot) => query.PreparationStamp(snapshot.GroupId, snapshot.EntryId, snapshot.Position);
+    internal bool IsSamePreparation(SceneTargetSnapshot snapshot, (long Author, long Resources) stamp)
+    { var current = PreparationStamp(snapshot); return query.IsAvailable && current == stamp; }
     public VariantFieldSource? VariantsSource(IEntryFieldOrigin? origin)
     {
         if (origin?.GroupId is not { } groupId || !documents.Groups.TryGetValue(groupId, out var group)
@@ -36,24 +48,37 @@ internal bool IsSamePreparation((object? Author, long Resources) stamp)
     public SceneTargetSnapshot Query(string groupId, string entryId, Func<SceneTarget, bool>? filter = null, SceneTimelinePosition? position = null, bool playback = false)
     {
         var result = position is null ? query.Before(groupId, entryId) : query.AtTimeline(groupId, entryId, position);
-        var choices = (playback ? result.Playbacks : result.Targets).Where(target => target.Kind != SceneTargetKind.Unresolved && (filter?.Invoke(target) ?? true)).Select(target =>
+        var choices = (playback ? result.Playbacks : result.Targets).Where(target => target.Kind != SceneTargetKind.Unresolved && (filter?.Invoke(target) ?? true)).Select(target => Describe(target, playback)).ToArray();
+        return new(groupId, entryId, result.Revision, result.Complete, choices, filter, position, playback, result.ContextRevision);
+    }
+    internal string ReferenceLabel(string group, string entry, SceneReferenceSlot slot, string raw)
+    {
+        if (slot.Domain == SceneIdentityDomain.AudioEffect)
         {
-            var group = documents.CurrentDocument.Nodes.FirstOrDefault(node => node.Id == target.Locator.GroupId);
-            var entry = documents.Groups.TryGetValue(target.Locator.GroupId, out var source) ? source.Entries.FirstOrDefault(item => item.StableId == target.Locator.EntryId) : null;
-            var origin = (group?.Name ?? "") + " / " + entry?.Id;
-            var resourceId = string.IsNullOrWhiteSpace(target.Resource) && target.Variants is { AssetIds.Count: 1 } variants ? variants.AssetIds[0] : target.Resource;
-            var resource = playback ? localization["Entry.Type." + target.Resource] : _paths.GetValueOrDefault(resourceId, resourceId);
-            var kind = localization[playback ? "Scene.Playback" : "Timeline.Kind." + target.Kind];
-            var name = playback ? resource : string.IsNullOrWhiteSpace(resource) || Guid.TryParse(resource, out _) ? kind : Path.GetFileName(resource);
-            var detail = playback ? resource + " · " + target.Resource : resource;
-            if (target.Variants is { Definite: false }) detail += " · " + localization["Variants.AmbiguousSource"];
-            if (target.CreatedAtFrame is { } created && !target.IsFuture) origin += " · " + localization.Format("Scene.CreatedAt", created);
-            var presence = target.IsFuture ? localization.Format("Scene.FutureAt", target.CreatedAtFrame) : localization[target.Presence == TargetPresence.Definite ? "Timeline.Definite" : "Timeline.Possible"];
-            return new SceneTargetChoice(target, new(JsonSerializer.Serialize(target.Locator), name + " · " + origin,
-                kind + " · " + detail + " · " + origin + " · " + presence,
-                playback ? "▶" : target.Kind == SceneTargetKind.Particle ? "✦" : target.Kind == SceneTargetKind.Effect ? "◈" : "▣", Badge: presence));
-        }).ToArray();
-        return new(groupId, entryId, query.Revision, result.Complete, choices, filter, position, playback);
+            var snapshot = QueryAudio(group, entry, retain: false);
+            var effect = snapshot.Targets.FirstOrDefault(effect => effect.Key.InstanceId == raw);
+            return effect is null ? localization["Scene.Unresolved"] : AudioDescription(effect);
+        }
+        var result = query.InspectBefore(group, entry);
+        var playback = slot.Domain == SceneIdentityDomain.Playback;
+        var target = (playback ? result.Playbacks : result.Targets).FirstOrDefault(target => target.Handle == raw && slot.Kinds.Contains(target.Kind)
+            && (!slot.RequiresVariants || target.Variants is not null));
+        return target is null ? localization["Scene.Unresolved"] : Describe(target, playback).Item.Label;
+    }
+    private SceneTargetChoice Describe(SceneTarget target, bool playback)
+    {
+        var origin = _descriptions.Origin(target);
+        var resourceId = string.IsNullOrWhiteSpace(target.Resource) && target.Variants is { AssetIds.Count: 1 } variants ? variants.AssetIds[0] : target.Resource;
+        var resource = playback ? localization["Entry.Type." + target.Resource] : _descriptions.Resource(resourceId);
+        var kind = localization[playback ? "Scene.Playback" : "Timeline.Kind." + target.Kind];
+        var name = playback ? resource : string.IsNullOrWhiteSpace(resource) || Guid.TryParse(resource, out _) ? kind : Path.GetFileName(resource);
+        var detail = playback ? resource + " · " + target.Resource : resource;
+        if (target.Variants is { Definite: false }) detail += " · " + localization["Variants.AmbiguousSource"];
+        if (target.CreatedAtFrame is { } created && !target.IsFuture) origin += " · " + localization.Format("Scene.CreatedAt", created);
+        var presence = target.IsFuture ? localization.Format("Scene.FutureAt", target.CreatedAtFrame) : localization[target.Presence == TargetPresence.Definite ? "Timeline.Definite" : "Timeline.Possible"];
+        return new SceneTargetChoice(target, new(JsonSerializer.Serialize(target.Locator), name + " · " + origin,
+            kind + " · " + detail + " · " + origin + " · " + presence,
+            playback ? "▶" : target.Kind == SceneTargetKind.Particle ? "✦" : target.Kind == SceneTargetKind.Effect ? "◈" : "▣", Badge: presence));
     }
     public async Task PrepareAsync(string groupId, string entryId, SceneTimelinePosition? position = null, CancellationToken token = default)
     {
@@ -63,12 +88,11 @@ public async Task PrepareAsync(string groupId, string entryId, SceneTimelinePosi
         foreach (var resource in resources)
         {
             token.ThrowIfCancellationRequested();
-            var file = await assets.GetFileAsync(resource, token);
-            if (file is not null) _paths[resource] = file.Path;
+            await _descriptions.PrepareAsync(resource).WaitAsync(token);
         }
     }
     public bool IsCurrent(SceneTargetSnapshot snapshot)
-    { if (snapshot.Position is null) query.Before(snapshot.GroupId, snapshot.EntryId); else query.AtTimeline(snapshot.GroupId, snapshot.EntryId, snapshot.Position); return query.IsAvailable && query.Revision == snapshot.Revision; }
+    { var current = snapshot.Position is null ? query.Before(snapshot.GroupId, snapshot.EntryId) : query.AtTimeline(snapshot.GroupId, snapshot.EntryId, snapshot.Position); return query.IsAvailable && current.Revision == snapshot.Revision && current.ContextRevision == snapshot.ContextRevision; }
     public SceneTarget? Resolve(SceneTargetSnapshot snapshot, string id)
     {
         if (!snapshot.Choices.Any(choice => choice.Item.Id == id) || !IsCurrent(snapshot)) return null;
@@ -76,29 +100,37 @@ public bool IsCurrent(SceneTargetSnapshot snapshot)
     }
     public IReadOnlyList<FieldEditorOption>? FieldOptions(string groupId, string entryId, string type, string field, SceneTimelinePosition? position = null)
     {
+        if (type == BuiltinEntryIds.Animate && field == "property")
+        {
+            if (!documents.Groups.TryGetValue(groupId, out var group) || group.Entries.FirstOrDefault(entry => entry.StableId == entryId) is not { } entry
+                || !entry.Parameters.TryGetValue("handleId", out var handleValue) || handleValue.ValueKind != JsonValueKind.String)
+                return [];
+            var handle = handleValue.GetString();
+            var target = Query(groupId, entryId, position: position).Choices.FirstOrDefault(choice => choice.Target.Handle == handle)?.Target;
+            return target?.Properties.Select(property =>
+            {
+                var key = "Timeline.Property." + property.Name;
+                var label = localization[key];
+                return new FieldEditorOption(property.Name, label == "[" + key + "]" ? property.Name : label, JsonSerializer.SerializeToElement(property.Name));
+            }).ToArray() ?? [];
+        }
+        if (SceneAuthoringSemantics.Reference(type, field)?.Domain == SceneIdentityDomain.AudioEffect) return AudioFieldOptions(groupId, entryId, type);
         var kinds = SceneFieldSemantics.TargetKinds(type, field); if (kinds is null) return null;
-        var snapshot = Query(groupId, entryId, target => kinds.Contains(target.Kind) && (type != BuiltinEntryIds.SelectVariants || target.Variants is not null), position, type == BuiltinEntryIds.StopAnimation);
-        var noneKey = type == BuiltinEntryIds.ApplyEffect ? "Scene.Global" : "Scene.None";
+        var snapshot = Query(groupId, entryId, target => kinds.Contains(target.Kind) && (SceneAuthoringSemantics.Reference(type, field)?.RequiresVariants != true || target.Variants is not null), position, SceneAuthoringSemantics.Reference(type, field)?.Domain == SceneIdentityDomain.Playback);
+        var noneKey = SceneAuthoringSemantics.Reference(type, field)?.AllowsGlobal == true ? "Scene.Global" : "Scene.None";
         var none = new ResourcePickerItem("none", localization[noneKey], "", "×");
         return new[] { new FieldEditorOption("none", new SceneFieldChoice(snapshot, null, none, noneKey), JsonSerializer.SerializeToElement("")) }
             .Concat(snapshot.Choices.Select(choice => new FieldEditorOption(choice.Item.Id, new SceneFieldChoice(snapshot, choice, choice.Item), JsonSerializer.SerializeToElement(choice.Target.Handle)))).ToArray();
     }
+    public void Dispose() { query.Changed -= OnQueryChanged; _descriptions.Dispose(); }
 }
 
 internal static class SceneFieldSemantics
 {
-    public static SceneTargetKind[]? TargetKinds(string type, string field) => (type, field) switch
-    {
-        (BuiltinEntryIds.StopAnimation, "playbackHandleId") => [SceneTargetKind.Playback],
-        (BuiltinEntryIds.HideLayer or BuiltinEntryIds.MoveLayer or BuiltinEntryIds.ReplaceLayer or BuiltinEntryIds.StopVideo or BuiltinEntryIds.SelectVariants, "handleId") => [SceneTargetKind.Layer],
-        (BuiltinEntryIds.Animate, "handleId") => [SceneTargetKind.Layer, SceneTargetKind.Particle, SceneTargetKind.Effect],
-        (BuiltinEntryIds.ApplyEffect, "targetHandleId") => [SceneTargetKind.Layer],
-        (BuiltinEntryIds.CrossFadeTransition or BuiltinEntryIds.BlindsTransition, "oldHandleId") => [SceneTargetKind.Layer],
-        (BuiltinEntryIds.SlideTransition or BuiltinEntryIds.BlackFadeTransition or BuiltinEntryIds.WhiteFadeTransition or BuiltinEntryIds.ColorFadeTransition, "fromLayerHandleId") => [SceneTargetKind.Layer],
-        (BuiltinEntryIds.StopEffect, "instanceId") => [SceneTargetKind.Effect],
-        (BuiltinEntryIds.StopParticleEmitter, "instanceId") => [SceneTargetKind.Particle],
-        _ => null
-    };
-    public static bool IsOutput(string type, string field) => SceneAuthoringIdentities.IsOutput(type, field);
-    public static string? Label(string type, string field) => TargetKinds(type, field) is null ? null : type == BuiltinEntryIds.StopAnimation ? "Scene.Playback" : "Scene.Target";
+    public static IReadOnlyList<SceneTargetKind>? TargetKinds(string type, string field) => SceneAuthoringSemantics.Reference(type, field)?.Kinds;
+    public static bool IsOutput(string type, string field) => SceneAuthoringIdentities.IsOutput(type, field) || type == GalNet.Contracts.Builtins.BuiltinEntryIds.StopAudioSEffect && field == "all";
+    public static string? Label(string type, string field) => type is GalNet.Contracts.Builtins.BuiltinEntryIds.ApplyAudioSEffect or GalNet.Contracts.Builtins.BuiltinEntryIds.StopAudioSEffect or GalNet.Contracts.Builtins.BuiltinEntryIds.UpdateAudioSEffect
+        ? field switch { "id" => "Audio.EffectType", "targetId" => "Audio.Target", "parameters" => "Audio.Parameters", "instanceId" => "Audio.Effect", _ => null }
+        : TargetKinds(type, field) is null ? null : SceneAuthoringSemantics.Reference(type, field)?.Domain switch
+        { SceneIdentityDomain.Playback => "Scene.Playback", _ => "Scene.Target" };
 }
diff --git a/src/Editor/GalNet.Editor/Services/SceneTargetSelection.cs b/src/Editor/GalNet.Editor/Services/SceneTargetSelection.cs
index 035c40d4..b4227ab8 100644
--- a/src/Editor/GalNet.Editor/Services/SceneTargetSelection.cs
+++ b/src/Editor/GalNet.Editor/Services/SceneTargetSelection.cs
@@ -19,9 +19,9 @@ public sealed class SceneTargetSelection(SceneTargetCatalog catalog, SceneTarget
     public async Task PrepareAsync()
     {
         if (!IsCurrent) return;
-        var stamp = catalog.PreparationStamp;
+        var stamp = catalog.PreparationStamp(Snapshot);
         await catalog.PrepareAsync(Snapshot.GroupId, Snapshot.EntryId, Snapshot.Position, _lifetime.Token);
-        if (!_disposed && catalog.IsSamePreparation(stamp))
+        if (!_disposed && catalog.IsSamePreparation(Snapshot, stamp))
             Snapshot = catalog.Query(Snapshot.GroupId, Snapshot.EntryId, Snapshot.Filter, Snapshot.Position, Snapshot.Playback);
     }
     public void RefreshLabels()
diff --git a/src/Editor/GalNet.Editor/Services/TimelineCurveEditing.cs b/src/Editor/GalNet.Editor/Services/TimelineCurveEditing.cs
index 439dd62b..4f5df6cc 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineCurveEditing.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineCurveEditing.cs
@@ -1,5 +1,5 @@
 using System.Text.Json;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Game.Controls.Timeline;
 
 namespace GalNet.Editor.Services;
diff --git a/src/Editor/GalNet.Editor/Services/TimelineDocument.Curves.cs b/src/Editor/GalNet.Editor/Services/TimelineDocument.Curves.cs
index 37d16e89..b44616dd 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineDocument.Curves.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineDocument.Curves.cs
@@ -1,6 +1,6 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Editor.Services;
 
diff --git a/src/Editor/GalNet.Editor/Services/TimelineDocument.Keys.cs b/src/Editor/GalNet.Editor/Services/TimelineDocument.Keys.cs
index 0bfd1cae..5ef020e3 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineDocument.Keys.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineDocument.Keys.cs
@@ -3,7 +3,7 @@
 using System.Linq;
 using System.Text.Json;
 using System.Text.Json.Nodes;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Editor.Services;
 
diff --git a/src/Editor/GalNet.Editor/Services/TimelineDocument.TangentModes.cs b/src/Editor/GalNet.Editor/Services/TimelineDocument.TangentModes.cs
index b6a2be91..e955f1a6 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineDocument.TangentModes.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineDocument.TangentModes.cs
@@ -1,6 +1,6 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Game.Controls.Timeline;
 
 namespace GalNet.Editor.Services;
diff --git a/src/Editor/GalNet.Editor/Services/TimelineDocument.cs b/src/Editor/GalNet.Editor/Services/TimelineDocument.cs
index 4b6b6292..871d532b 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineDocument.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineDocument.cs
@@ -4,7 +4,7 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Editor.Services;
 
diff --git a/src/Editor/GalNet.Editor/Services/TimelineEditSession.cs b/src/Editor/GalNet.Editor/Services/TimelineEditSession.cs
index 02a222fe..b058a619 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineEditSession.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineEditSession.cs
@@ -5,8 +5,9 @@
 using System.Text.Json;
 using CommunityToolkit.Mvvm.ComponentModel;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
-using GalNet.Core.Scene;
+using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
@@ -46,13 +47,14 @@ public sealed partial class TimelineEditSession : ObservableObject, IDisposable
     [ObservableProperty] private int _frameRate = 60;
     public bool HasNoRows => CanEdit && VisibleNodes.Count == 0;
     public bool AnalysisIncomplete => CanEdit && !_scene.Complete;
+    public string CurrentFrameText => _localization.Format("Timeline.CurrentFrame", Frame);
     public int Frame
     {
         get => _frame;
         set
         {
             var next = Math.Clamp(value, 0, Duration);
-            if (SetProperty(ref _frame, next)) { Canvas.Cancel(); BuildRows(); }
+            if (SetProperty(ref _frame, next)) { OnPropertyChanged(nameof(CurrentFrameText)); Canvas.Cancel(); BuildRows(); }
         }
     }
     public TimelineEditSession(EntrySelectionContext selection, IEditorDocumentService documents, EntryFieldAuthoringService authoring,
@@ -62,16 +64,21 @@ public TimelineEditSession(EntrySelectionContext selection, IEditorDocumentServi
         _sceneQuery = sceneQuery;
         _targets = targets;
         InitializeCanvas();
-        selection.Changed += OnSelection; documents.DocumentChanged += Refresh; histories.Changed += Refresh;
+        selection.Changed += OnSelection; documents.DocumentChanged += Refresh; histories.Content.AuthorChanges.Committed += OnAuthorCommitted;
         _sceneQuery.Changed += Refresh;
         localization.PropertyChanged += OnLocale;
         InitializeEvents();
         Refresh();
     }
-    private void OnSelection() { ClearObjectDrafts(); _frame = 0; OnPropertyChanged(nameof(Frame)); Refresh(); }
+    private void OnAuthorCommitted(AuthorChangeSet change)
+    {
+        if (change.UnknownScope || _selection.Current is { } target && change.Groups.Any(group => group.GroupId == target.GroupId)) Refresh();
+    }
+    private void OnSelection() { ClearObjectDrafts(); _frame = 0; OnPropertyChanged(nameof(Frame)); OnPropertyChanged(nameof(CurrentFrameText)); Refresh(); }
     private void OnLocale(object? sender, PropertyChangedEventArgs args)
     {
         if (args.PropertyName != "Item[]") return;
+        OnPropertyChanged(nameof(CurrentFrameText));
         foreach (var row in Rows) row.RefreshLabel();
         foreach (var node in Tree.SelectMany(node => node.Descendants())) node.RefreshLabel();
         foreach (var row in Events) row.RefreshLabel();
@@ -87,11 +94,11 @@ private void Refresh()
         var root = next?.Parameters.TryGetValue("timeline", out var value) == true ? (JsonElement?)value.Clone() : null;
         var scene = next is null ? new SceneTargetResult([], false, false) : _sceneQuery.Before(_selection.Current!.GroupId, next.StableId);
         if (next?.Type == BuiltinEntryIds.PlayTimeline) scene = _sceneQuery.AtTimeline(_selection.Current!.GroupId, next.StableId, new(Frame, IncludeFuture: true));
-        var sceneSignature = JsonSerializer.Serialize(scene);
+        var sceneSignature = JsonSerializer.Serialize(scene with { Revision = 0, ContextRevision = 0, AuthorRevision = 0 });
         var sameValue = _baseline is { } previous ? root is { } current && JsonElement.DeepEquals(previous, current) : root is null;
-        if (_target == _selection.Current && ReferenceEquals(_entry, next) && _type == next?.Type && sameValue && sceneSignature == _sceneSignature && _sceneRevision == _sceneQuery.Revision)
+        if (_target == _selection.Current && ReferenceEquals(_entry, next) && _type == next?.Type && sameValue && sceneSignature == _sceneSignature && _sceneRevision == scene.Revision)
         { RefreshSource(); foreach (var node in Tree.SelectMany(node => node.Descendants())) node.RefreshLabel(); return; }
-        EndObjectEdit(); _scene = scene; _sceneSignature = sceneSignature; _sceneRevision = _sceneQuery.Revision;
+        EndObjectEdit(); _scene = scene; _sceneSignature = sceneSignature; _sceneRevision = scene.Revision;
         SaveExpansion(); DetachTree(); InvalidateKeyDocument(); _generation++; Rows.Clear(); Tree.Clear(); _document = null; _baseline = null; Message = "";
         InvalidateEvents();
         _target = _selection.Current; _entry = next; _type = next?.Type; _baseline = root;
@@ -99,7 +106,7 @@ private void Refresh()
         RefreshSource();
         StatusKey = _entry is null ? "Timeline.SelectEntry" : "Timeline.Unsupported";
         if (_entry?.Type != BuiltinEntryIds.PlayTimeline || !_catalog.TryGet(_entry.Type, out var schema)
-            || schema.DynamicParameters?.TryGetValue("timeline", out var field) != true || field.Value.ValueType != typeof(JsonElement))
+            || schema.DynamicParameters.TryGetValue("timeline", out var field) != true || field.Value.ValueType != typeof(JsonElement))
         { NotifyState(); return; }
         if (!_entry.Parameters.TryGetValue("timeline", out var json) || json.ValueKind == JsonValueKind.Null)
         { CanCreate = true; StatusKey = "Timeline.Missing"; NotifyState(); return; }
@@ -107,7 +114,7 @@ private void Refresh()
         try
         {
             _document = new(json); Duration = _document.Duration; FrameRate = _document.FrameRate; CanEdit = true; StatusKey = "Timeline.Editing";
-            _frame = Math.Clamp(_frame, 0, Duration); OnPropertyChanged(nameof(Frame)); BuildRows();
+            _frame = Math.Clamp(_frame, 0, Duration); OnPropertyChanged(nameof(Frame)); OnPropertyChanged(nameof(CurrentFrameText)); BuildRows();
         }
         catch (Exception error) when (error is JsonException or InvalidOperationException or ArgumentException or InvalidDataException or OverflowException)
         { CanEdit = false; _document = null; Rows.Clear(); Tree.Clear(); StatusKey = "Timeline.Invalid"; NotifyState(); }
@@ -121,7 +128,7 @@ private void BuildRows()
         if (_document is not null && CanEdit && _target?.EntryId is { } id)
         {
             _scene = _sceneQuery.AtTimeline(_target.GroupId, id, new(Frame, IncludeFuture: true));
-            _sceneSignature = JsonSerializer.Serialize(_scene);
+            _sceneSignature = JsonSerializer.Serialize(_scene with { Revision = 0, ContextRevision = 0, AuthorRevision = 0 }); _sceneRevision = _scene.Revision;
             zero = Frame == 0 ? _scene : _sceneQuery.AtTimeline(_target.GroupId, id, new(0));
         }
         PruneObjectDrafts();
@@ -176,8 +183,7 @@ internal bool Commit(TimelineValueRow row, int generation, int index, int frame,
     }
     private bool Submit(JsonElement value)
     {
-        if (_target?.EntryId is { } entryId) _sceneQuery.Before(_target.GroupId, entryId);
-        if (_sceneRevision != _sceneQuery.Revision) { Refresh(); return false; }
+        if (_target?.EntryId is { } entryId && _sceneRevision != _sceneQuery.AtTimeline(_target.GroupId, entryId, new(Frame, IncludeFuture: true)).Revision) { Refresh(); return false; }
         if (_entry is null || !ReferenceEquals(_entry, Find(_target)) || _entry.Type != BuiltinEntryIds.PlayTimeline || _selection.Current != _target) return false;
         var current = _entry.Parameters.TryGetValue("timeline", out var json) ? (JsonElement?)json : null;
         if (_baseline is { } expected ? current is not { } actual || !JsonElement.DeepEquals(expected, actual)
@@ -186,7 +192,7 @@ private bool Submit(JsonElement value)
         parameters["timeline"] = value.Clone();
         try
         {
-            _catalog.Get(_entry.Type).DynamicParameters!.ValidatePartialArguments(JsonSerializer.SerializeToElement(parameters));
+            _catalog.Get(_entry.Type).DynamicParameters.ValidatePartialArguments(JsonSerializer.SerializeToElement(parameters));
             _authoring.SetParameters(_target!.GroupId, _entry, _entry.Type, parameters); return true;
         }
         catch (Exception error) { Message = EditorText.Error(error).Render(_localization); return false; }
@@ -197,7 +203,7 @@ public void Dispose()
         DisposeEvents();
         Canvas.PropertyChanged -= OnCanvasSelection; KeyEdit = null;
         if (_disposed) return; EndObjectEdit(); _disposed = true; DetachTree(); InvalidateKeyDocument(); _generation++; Rows.Clear(); Tree.Clear();
-        _selection.Changed -= OnSelection; _documents.DocumentChanged -= Refresh; _histories.Changed -= Refresh;
+        _selection.Changed -= OnSelection; _documents.DocumentChanged -= Refresh; _histories.Content.AuthorChanges.Committed -= OnAuthorCommitted;
         _sceneQuery.Changed -= Refresh;
         _localization.PropertyChanged -= OnLocale; _entry = null; _document = null;
     }
diff --git a/src/Editor/GalNet.Editor/Services/TimelineEventEdit.cs b/src/Editor/GalNet.Editor/Services/TimelineEventEdit.cs
index 70c838ef..ce4deaab 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineEventEdit.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineEventEdit.cs
@@ -11,6 +11,7 @@ public sealed class TimelineEventEdit : IDisposable
     private readonly Dictionary<string, JsonElement> _values;
     private readonly Dictionary<string, EventField> _fields;
     private bool _disposed;
+    internal bool Independent { get; }
     internal TimelineDocument Document { get; }
     internal int Generation { get; }
     internal int Frame { get; }
@@ -18,8 +19,9 @@ public sealed class TimelineEventEdit : IDisposable
     internal Dictionary<string, FieldValue> Patch { get; } = new(StringComparer.Ordinal);
     public bool IsCurrent => !_disposed && _owner.IsEventEditCurrent(this);
     public DtoEditorItem Item { get; }
-    internal TimelineEventEdit(TimelineEditSession owner, TimelineDocument document, int generation, int frame, int index, string type, Type? dtoType, IReadOnlyList<FieldDescriptor> fields)
+    internal TimelineEventEdit(TimelineEditSession owner, TimelineDocument document, int generation, int frame, int index, string type, Type? dtoType, IReadOnlyList<FieldDescriptor> fields, bool independent = false)
     {
+        Independent = independent;
         _owner = owner; Document = document; Generation = generation; Frame = frame; Index = index;
         var raw = document.Events[index].Raw;
         var parameters = raw.EnumerateObject().FirstOrDefault(pair => pair.Name.Equals("parameters", StringComparison.OrdinalIgnoreCase)).Value;
diff --git a/src/Editor/GalNet.Editor/Services/TimelineEventEditing.cs b/src/Editor/GalNet.Editor/Services/TimelineEventEditing.cs
index 32db3da2..8c4de963 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineEventEditing.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineEventEditing.cs
@@ -100,7 +100,7 @@ public Func<string, bool> CaptureEventInsertion()
     public bool AddEvent(string type)
     {
         if (_disposed || !CanEdit || _document is null || !TimelineEventCapabilities.Supports(type) || !_catalog.TryGet(type, out var schema)) return false;
-        var parameters = schema.DynamicParameters!.Values.Where(parameter => parameter.DefaultValue is not null).ToDictionary(parameter => parameter.Name, parameter => parameter.DefaultValue!.Value.Clone());
+        var parameters = schema.DynamicParameters.Values.Where(parameter => parameter.DefaultValue is not null).ToDictionary(parameter => parameter.Name, parameter => parameter.DefaultValue!.Value.Clone());
         parameters = SceneAuthoringIdentities.NewEntry(type, parameters);
         var index = _document.Events.Count;
         if (!Submit(_document.AddEvent(type, Frame, parameters))) return false;
@@ -137,13 +137,20 @@ public void OrderEvent(TimelineEventRow row, int direction)
     public TimelineEventEdit? BeginEventEdit(TimelineEventRow row)
     {
         EndEventEdit();
-        if (_disposed || !CanEdit || _document is null || !Events.Contains(row) || !TimelineEventCapabilities.Supports(row.Type) || !_catalog.TryGet(row.Type, out var schema) || schema.DynamicParameters is null) return null;
-        EventCanvas.Cancel(); Canvas.Cancel(); SelectEvent(row);
+        if (_disposed || !CanEdit || _document is null || !Events.Contains(row) || !TimelineEventCapabilities.Supports(row.Type) || !_catalog.TryGet(row.Type, out var schema)) return null;
+        EventCanvas.Cancel(); Canvas.Cancel();
+        if (EventCanvas.Selection.Count != 1 || !EventCanvas.Selection.Contains(row.Id)) SelectEvent(row);
         try { EventEdit = new(this, _document, _generation, Frame, row.Index, row.Type, schema.FieldDataType, schema.DynamicParameters.Fields); }
         catch (Exception error) when (error is JsonException or InvalidDataException or InvalidOperationException or ArgumentException) { EditError(error); return null; }
         OnPropertyChanged(nameof(EventEdit)); return EventEdit;
     }
-    internal bool IsEventEditCurrent(TimelineEventEdit draft) => !_disposed && CanEdit && ReferenceEquals(EventEdit, draft) && ReferenceEquals(_document, draft.Document) && draft.Generation == _generation && draft.Frame == Frame && _target == _selection.Current;
+    public TimelineEventEdit? CreateInspectorEventEdit(TimelineEventRow row)
+    {
+        if (_disposed || !CanEdit || _document is null || !Events.Contains(row) || !TimelineEventCapabilities.Supports(row.Type) || !_catalog.TryGet(row.Type, out var schema)) return null;
+        try { return new(this, _document, _generation, Frame, row.Index, row.Type, schema.FieldDataType, schema.DynamicParameters.Fields, independent: true); }
+        catch (Exception error) when (error is JsonException or InvalidDataException or InvalidOperationException or ArgumentException) { EditError(error); return null; }
+    }
+    internal bool IsEventEditCurrent(TimelineEventEdit draft) => !_disposed && CanEdit && (draft.Independent || ReferenceEquals(EventEdit, draft)) && ReferenceEquals(_document, draft.Document) && draft.Generation == _generation && draft.Frame == Frame && _target == _selection.Current;
     internal IReadOnlyList<GalNet.Game.Controls.Forms.FieldEditorOption>? EventFieldOptions(int index, string type, string field) => _target?.EntryId is { } id && _document is not null
         ? _targets.FieldOptions(_target.GroupId, id, type, field, new(_document.Events[index].Frame, index)) : null;
     internal bool ApplyEvent(TimelineEventEdit draft) => IsEventEditCurrent(draft) && Submit(draft.Document.PatchEvent(draft.Index, draft.Patch));
diff --git a/src/Editor/GalNet.Editor/Services/TimelineKeyDetails.cs b/src/Editor/GalNet.Editor/Services/TimelineKeyDetails.cs
index 8cde3855..6fdc883e 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineKeyDetails.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineKeyDetails.cs
@@ -1,7 +1,7 @@
 using System.ComponentModel;
 using System.Text.Json;
 using CommunityToolkit.Mvvm.ComponentModel;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Editor.Services;
 
diff --git a/src/Editor/GalNet.Editor/Services/TimelineKeyEditing.cs b/src/Editor/GalNet.Editor/Services/TimelineKeyEditing.cs
index 6dabeceb..b584b96c 100644
--- a/src/Editor/GalNet.Editor/Services/TimelineKeyEditing.cs
+++ b/src/Editor/GalNet.Editor/Services/TimelineKeyEditing.cs
@@ -124,7 +124,7 @@ public void NavigateKey(int direction)
     {
         if (_document is null) return;
         var tracks = SelectedTracks(); if (tracks.Length == 0) tracks = Enumerable.Range(0, _document.Tracks.Count).ToArray();
-        var frames = tracks.SelectMany(track => _document.Tracks[track].Keys.Select(key => key.Frame));
+        var frames = tracks.SelectMany(track => _document.Tracks[track].Keys.Select(key => key.Frame)).Concat(_document.Events.Select(item => item.Frame));
         var next = direction < 0 ? frames.Where(frame => frame < Frame).DefaultIfEmpty(0).Max() : frames.Where(frame => frame > Frame).DefaultIfEmpty(Duration).Min(); Frame = next;
     }
     public void CancelTimingInput(bool frameRate)
diff --git a/src/Editor/GalNet.Editor/Services/VariableAuthoringService.cs b/src/Editor/GalNet.Editor/Services/VariableAuthoringService.cs
index 155ece21..6e32f8bb 100644
--- a/src/Editor/GalNet.Editor/Services/VariableAuthoringService.cs
+++ b/src/Editor/GalNet.Editor/Services/VariableAuthoringService.cs
@@ -2,10 +2,11 @@
 using System.Text;
 using System.Text.Json;
 using System.Text.RegularExpressions;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Core.Variable;
 using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Abstraction.Schemas;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
 
@@ -108,7 +109,8 @@ void Add(Slot slot, string text, bool expression, bool direct, string location)
                 catalog.TryGet(entry.Type, out var schema);
                 foreach (var pair in entry.Parameters)
                 {
-                    var kind = schema?.Parameters.GetValueOrDefault(pair.Key);
+                    var kind = schema?.DynamicParameters.TryGetValue(pair.Key, out var descriptor) == true
+                        ? EntrySchema.GetEditorType(descriptor) : (EntryParameterType?)null;
                     var text = pair.Value.ValueKind == JsonValueKind.String ? pair.Value.GetString()! : pair.Value.GetRawText();
                     Add(new(node.Id, entry.StableId, null, "parameter:" + pair.Key), text,
                         pair.Value.ValueKind == JsonValueKind.String && kind == EntryParameterType.Expression,
diff --git a/src/Editor/GalNet.Editor/Services/VariablePanelState.cs b/src/Editor/GalNet.Editor/Services/VariablePanelState.cs
new file mode 100644
index 00000000..95a2b673
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Services/VariablePanelState.cs
@@ -0,0 +1,14 @@
+using GalNet.Core.Variable;
+
+namespace GalNet.Editor.Services;
+
+/// <summary>Project-owned editing state, independent of a dock page or recycled list row.</summary>
+public sealed class VariablePanelState
+{
+    public int ScopeIndex { get; set; }
+    public string Search { get; set; } = "";
+    public Dictionary<VariableScope, string> Selection { get; } = [];
+    public Dictionary<(VariableScope Scope, string Uid), VariablePanelDraft> Drafts { get; } = [];
+}
+
+public sealed record VariablePanelDraft(ProjectVariableDefinition Baseline, string Name, VariableType Type, string Default, string Description);
diff --git a/src/Editor/GalNet.Editor/Shell/EditorLayoutSession.cs b/src/Editor/GalNet.Editor/Shell/EditorLayoutSession.cs
new file mode 100644
index 00000000..989fac42
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Shell/EditorLayoutSession.cs
@@ -0,0 +1,188 @@
+using Avalonia.Threading;
+using Dock.Model.Controls;
+using Dock.Model.Core;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Dock;
+using GalNet.Editor.Services;
+using Serilog;
+
+namespace GalNet.Editor.Shell;
+
+/// <summary>Owns layout restoration, named layouts and debounced persistence for one project shell.</summary>
+public sealed class EditorLayoutSession : IDisposable
+{
+    private readonly EditorDockFactory _dockFactory;
+    private readonly DockLayoutSerializer _dockLayoutSerializer;
+    private readonly IEditorSettingsService _editorSettingsService;
+    private readonly DispatcherTimer _layoutSaveTimer = new() { Interval = TimeSpan.FromSeconds(2) };
+    private bool _disposed;
+    private bool _savingLayout;
+    private bool _layoutSavePending;
+    public IRootDock? Layout { get; private set; }
+    public EditorText? Status { get; private set; }
+    public IEnumerable<string> Names => _editorSettingsService.GetSettings().DockLayouts.Keys.OrderBy(name => name, StringComparer.OrdinalIgnoreCase);
+    public event Action? Changed;
+    public event Action? NamesChanged;
+    public EditorLayoutSession(EditorDockFactory dockFactory, DockLayoutSerializer serializer, IEditorSettingsService settings)
+    {
+        _dockFactory = dockFactory; _dockLayoutSerializer = serializer; _editorSettingsService = settings;
+        _layoutSaveTimer.Tick += OnLayoutSaveTimerTick;
+        _dockFactory.LayoutChanged += OnDockLayoutChanged;
+    }
+    private void SetLayoutStatus(EditorText text) { Status = text; Changed?.Invoke(); }
+    public void Initialize()
+    {
+        var settings = _editorSettingsService.GetSettings();
+        Layout = TryLoadLayout(settings.LastDockLayout);
+        if (Layout is null && !string.IsNullOrWhiteSpace(settings.LastDockLayout))
+        {
+            // A previous implementation could persist the host Window back-reference.
+            // Discard that malformed global value once so every subsequent start is clean.
+            settings.LastDockLayout = null;
+            _editorSettingsService.SaveSettings();
+            SetLayoutStatus(new("Status.LayoutReset"));
+        }
+        if (Layout is null)
+        {
+            Layout = _dockFactory.CreateLayout();
+            _dockFactory.InitLayout(Layout);
+        }
+        Changed?.Invoke();
+    }
+
+    public async Task SaveAsync(Func<Task<string?>> requestName)
+    {
+        if (Layout is null)
+            return;
+        var name = await requestName();
+        if (string.IsNullOrWhiteSpace(name)) return;
+        name = name.Trim();
+        if (string.Equals(name, "Default", StringComparison.OrdinalIgnoreCase))
+        {
+            SetLayoutStatus(new("Layout.Reserved"));
+            return;
+        }
+        var settings = _editorSettingsService.GetSettings();
+        settings.DockLayouts[name] = SerializeLayout(Layout);
+        _editorSettingsService.SaveSettings();
+        SetLayoutStatus(new("Layout.Saved", name));
+        NamesChanged?.Invoke();
+    }
+
+    public void Load(string? name)
+    {
+        if (string.Equals(name, "Default", StringComparison.OrdinalIgnoreCase))
+        {
+            Reset();
+            return;
+        }
+        var settings = _editorSettingsService.GetSettings();
+        if (string.IsNullOrWhiteSpace(name) || !settings.DockLayouts.TryGetValue(name, out var serialized))
+        {
+            SetLayoutStatus(new("Layout.None"));
+            return;
+        }
+        var layout = TryLoadLayout(serialized);
+        if (layout is null)
+        {
+            SetLayoutStatus(new("Layout.LoadFailed", name));
+            return;
+        }
+        Layout = layout;
+        Changed?.Invoke();
+        SetLayoutStatus(new("Layout.Loaded", name));
+    }
+
+    public void Reset()
+    {
+        Layout = _dockFactory.CreateLayout();
+        _dockFactory.InitLayout(Layout);
+        Changed?.Invoke();
+        SetLayoutStatus(new("Layout.Reset"));
+    }
+
+    public void Delete(string? name)
+    {
+        if (string.IsNullOrWhiteSpace(name) || string.Equals(name, "Default", StringComparison.OrdinalIgnoreCase)) return;
+        var settings = _editorSettingsService.GetSettings();
+        if (!settings.DockLayouts.Remove(name)) return;
+        _editorSettingsService.SaveSettings();
+        SetLayoutStatus(new("Layout.Deleted", name));
+        NamesChanged?.Invoke();
+    }
+
+    private IRootDock? TryLoadLayout(string? serialized)
+    {
+        if (string.IsNullOrWhiteSpace(serialized)) return null;
+        try
+        {
+            var layout = DockLayoutSerializer.Deserialize(serialized);
+            if (layout is null)
+                return null;
+
+            _dockFactory.InitLayout(layout);
+            return _dockFactory.PrepareRestoredLayout(layout) ? layout : null;
+        }
+        catch (Exception exception)
+        {
+            Log.Warning(exception, "Failed to restore editor dock layout");
+            return null;
+        }
+    }
+
+    private void OnDockLayoutChanged()
+    {
+        if (Layout is null) return;
+        _layoutSavePending = true;
+        _layoutSaveTimer.Stop();
+        _layoutSaveTimer.Start();
+        Changed?.Invoke();
+    }
+
+    private void OnLayoutSaveTimerTick(object? sender, EventArgs e)
+    {
+        _layoutSaveTimer.Stop();
+        PersistLayoutNow();
+    }
+
+    private void PersistLayoutCore()
+    {
+        if (_savingLayout || Layout is null || _dockFactory.IsMaximized) return;
+        try
+        {
+            _savingLayout = true;
+            var serialized = SerializeLayout(Layout);
+            _editorSettingsService.GetSettings().LastDockLayout = serialized;
+            _editorSettingsService.SaveSettings();
+        }
+        catch (Exception exception)
+        {
+            SetLayoutStatus(new("Layout.SaveFailed"));
+            Log.Error(exception, "Failed to persist editor dock layout");
+        }
+        finally { _savingLayout = false; }
+    }
+
+    /// <summary>Called after splitter interaction; persistence is debounced to avoid disk writes during dragging.</summary>
+    public void PersistLayout() => OnDockLayoutChanged();
+
+    /// <summary>Flushes a pending layout change. Called during application shutdown.</summary>
+    public void PersistLayoutNow()
+    {
+        _layoutSaveTimer.Stop();
+        if (!_layoutSavePending && Layout is null) return;
+        _layoutSavePending = false;
+        PersistLayoutCore();
+    }
+
+    private string SerializeLayout(IRootDock layout) => _dockLayoutSerializer.Serialize(layout);
+
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _disposed = true;
+        PersistLayoutNow();
+        _layoutSaveTimer.Tick -= OnLayoutSaveTimerTick;
+        _dockFactory.LayoutChanged -= OnDockLayoutChanged;
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Shell/EditorMenuBuilder.cs b/src/Editor/GalNet.Editor/Shell/EditorMenuBuilder.cs
new file mode 100644
index 00000000..cecd6ce4
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Shell/EditorMenuBuilder.cs
@@ -0,0 +1,131 @@
+using System.Windows.Input;
+using Avalonia.Collections;
+using Avalonia.Input;
+using CommunityToolkit.Mvvm.Input;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Commands;
+using GalNet.Editor.Dock;
+using GalNet.Editor.Models;
+using GalNet.Editor.ViewModels;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GalNet.Editor.Shell;
+
+internal sealed record EditorMenuCommands(ICommand Undo, ICommand Redo, ICommand TogglePanel, ICommand SaveLayout,
+    ICommand LoadLayout, ICommand ShowExport, ICommand ShowProjectSettings, ICommand ShowEditorSettings);
+
+/// <summary>Builds shell menus from commands and registered panels without owning project content.</summary>
+internal sealed class EditorMenuBuilder(EditorShortcutService shortcuts, EditorDockFactory dock,
+    EditorLayoutSession layouts, IProjectService projects, EditorMenuCommands commands)
+{
+    public AvaloniaList<MenuData> Build()
+    {
+        var closeCmd = shortcuts.GetCommand<CloseProjectCommand>();
+        var saveCmd = shortcuts.GetCommand<SaveProjectCommand>();
+        ICommand DebugAction(Func<ExternalDebugPanelViewModel, Task> action) => new AsyncRelayCommand(async () =>
+        {
+            if (projects.Current is not { } project) return;
+            if (!dock.HasGlobalPanel(EditorDockPanelIds.ExternalDebug)) commands.TogglePanel.Execute(EditorDockPanelIds.ExternalDebug);
+            await action(project.Services.GetRequiredService<ExternalDebugPanelViewModel>());
+        });
+
+        var items = new AvaloniaList<MenuData>
+        {
+            new()
+            {
+                HeaderKey = "Editor.Menu.File",
+                Children = new AvaloniaList<MenuData>
+                {
+                    new() { HeaderKey = "Command.SaveProject", Command = saveCmd.Command, InputGesture = saveCmd.Gesture },
+                    new() { HeaderKey = "Editor.Menu.Export", Command = commands.ShowExport },
+                    new() { HeaderKey = "Command.CloseProject", Command = closeCmd.Command, InputGesture = closeCmd.Gesture },
+                    new() { IsSeparator = true },
+                    new() { HeaderKey = "Editor.Menu.Exit", InputGesture = new Avalonia.Input.KeyGesture(Key.F4, KeyModifiers.Alt), IsEnabled = false },
+                }
+            },
+            new()
+            {
+                HeaderKey = "Editor.Menu.Edit",
+                Children = new AvaloniaList<MenuData>
+                {
+                    new() { HeaderKey = "Editor.Menu.Undo", InputGesture = new Avalonia.Input.KeyGesture(Key.Z, KeyModifiers.Control), Command = commands.Undo },
+                    new() { HeaderKey = "Editor.Menu.Redo", InputGesture = new Avalonia.Input.KeyGesture(Key.Y, KeyModifiers.Control), Command = commands.Redo },
+                }
+            },
+            new()
+            {
+                HeaderKey = "Editor.Menu.Settings",
+                Children = new AvaloniaList<MenuData>
+                {
+                    new() { HeaderKey = "Editor.Menu.ProjectSettings", Command = commands.ShowProjectSettings },
+                    new() { HeaderKey = "Editor.Menu.EditorSettings", Command = commands.ShowEditorSettings },
+                }
+            },
+            new()
+            {
+                HeaderKey = "Editor.Menu.View",
+                Children = BuildViewMenuItems()
+            },
+            new()
+            {
+                HeaderKey = "Editor.Menu.Window",
+                Children = new AvaloniaList<MenuData>
+                {
+                    new() { HeaderKey = "Uiux.Layout.Writing", Command = new RelayCommand(() => dock.ApplyWorkspacePreset("Writing")) },
+                    new() { HeaderKey = "Uiux.Layout.Animation", Command = new RelayCommand(() => dock.ApplyWorkspacePreset("Animation")) },
+                    new() { HeaderKey = "Uiux.Layout.Debug", Command = new RelayCommand(() => dock.ApplyWorkspacePreset("Debug")) },
+                    new() { HeaderKey = "Uiux.Layout.Maximize", Command = new RelayCommand(dock.ToggleMaximizeActive) },
+                    new() { HeaderKey = "Editor.Menu.SaveLayout", Command = commands.SaveLayout },
+                    new() { HeaderKey = "Editor.Menu.LoadLayout", Children = BuildLoadLayoutItems() },
+                    new() { HeaderKey = "Editor.Menu.DeleteLayout", Children = BuildDeleteLayoutItems() },
+                }
+            },
+            new()
+            {
+                HeaderKey = "Debug.Menu",
+                Children = new AvaloniaList<MenuData>
+                {
+                    new() { HeaderKey = "Debug.Launch", Command = DebugAction(vm => vm.LaunchCommand.ExecuteAsync(null)) },
+                    new() { HeaderKey = "Debug.Wait", Command = DebugAction(vm => vm.WaitForApplicationCommand.ExecuteAsync(null)) },
+                    new() { HeaderKey = "Debug.Start", Command = DebugAction(vm => vm.StartGameCommand.ExecuteAsync(null)) },
+                    new() { HeaderKey = "Debug.Stop", Command = DebugAction(vm => vm.StopGameCommand.ExecuteAsync(null)) },
+                    new() { HeaderKey = "Debug.GroupEnd", Command = DebugAction(vm => vm.GroupEndCommand.ExecuteAsync(null)) },
+                    new() { HeaderKey = "Debug.Panel", Command = commands.TogglePanel, CommandParameter = EditorDockPanelIds.ExternalDebug }
+                }
+            },
+            new()
+            {
+                HeaderKey = "Editor.Menu.Help",
+                Children = new AvaloniaList<MenuData>
+                {
+                    new() { HeaderKey = "Editor.Menu.About", IsEnabled = false },
+                }
+            },
+        };
+
+        return items;
+    }
+
+    private AvaloniaList<MenuData> BuildViewMenuItems() => new(
+        dock.ViewMenuPanels.Select(panel => new MenuData
+        {
+            HeaderKey = panel.TitleKey,
+            Command = commands.TogglePanel,
+            CommandParameter = panel.PanelId,
+            IsCheckable = panel.IsGlobal,
+            IsChecked = panel.IsGlobal && dock.HasGlobalPanel(panel.PanelId)
+        }));
+
+    private AvaloniaList<MenuData> BuildLoadLayoutItems()
+    {
+        var items = new AvaloniaList<MenuData> { new() { Header = "Default", Command = commands.LoadLayout, CommandParameter = "Default" } };
+        foreach (var name in layouts.Names)
+            items.Add(new MenuData { Header = name, Command = commands.LoadLayout, CommandParameter = name });
+        return items;
+    }
+
+    private AvaloniaList<MenuData> BuildDeleteLayoutItems() => new(
+        layouts.Names
+            .Select(name => new MenuData { Header = name, Command = new RelayCommand<string>(layouts.Delete), CommandParameter = name }));
+
+}
diff --git a/src/Editor/GalNet.Editor/Themes/AuthoringPanelResources.axaml b/src/Editor/GalNet.Editor/Themes/AuthoringPanelResources.axaml
new file mode 100644
index 00000000..3c9145d6
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Themes/AuthoringPanelResources.axaml
@@ -0,0 +1,15 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <ResourceDictionary.MergedDictionaries>
+    <ResourceInclude Source="avares://GalNet.Editor/Themes/EditorButtons.axaml"/>
+    <ResourceInclude Source="avares://GalNet.Editor/Assets/icons.axaml"/>
+  </ResourceDictionary.MergedDictionaries>
+  <StreamGeometry x:Key="PanelApplyIcon">M3 12L5 10L10 15L19 5L21 7L10 19Z</StreamGeometry>
+  <StreamGeometry x:Key="PanelCancelIcon">M6 4L12 10L18 4L20 6L14 12L20 18L18 20L12 14L6 20L4 18L10 12L4 6Z</StreamGeometry>
+  <StreamGeometry x:Key="PanelNavigateIcon">M4 4H11V6H6V18H18V13H20V20H4Z M13 3H22V12H20V6.5L11 15.5L9.5 14L18.5 5H13Z</StreamGeometry>
+  <StreamGeometry x:Key="PanelImportIcon">M11 2H13V10L16 7L18 9L12 15L6 9L8 7L11 10Z M3 15H5V20H19V15H21V22H3Z</StreamGeometry>
+  <StreamGeometry x:Key="PanelExportIcon">M11 14H13V6L16 9L18 7L12 1L6 7L8 9L11 6Z M3 15H5V20H19V15H21V22H3Z</StreamGeometry>
+  <StreamGeometry x:Key="PanelLanguageIcon">M12 2A10 10 0 1 0 12 22A10 10 0 0 0 12 2Z M11 4.3V8H8.3C8.9 6.1 9.9 4.8 11 4.3Z M13 4.3C14.1 4.8 15.1 6.1 15.7 8H13Z M6.2 6.5C5.7 7 5.3 7.5 5 8H6.2C6.4 7.4 6.6 6.9 6.8 6.3Z M17.2 6.3C17.4 6.9 17.6 7.4 17.8 8H19C18.5 7.3 17.9 6.7 17.2 6.3Z M4.3 10H5.8A17 17 0 0 0 5.8 14H4.3A8 8 0 0 1 4.3 10Z M7.8 10H11V14H7.8A15 15 0 0 1 7.8 10Z M13 10H16.2A15 15 0 0 1 16.2 14H13Z M18.2 10H19.7A8 8 0 0 1 19.7 14H18.2A17 17 0 0 0 18.2 10Z M5 16H6.2C6.4 16.6 6.6 17.1 6.8 17.7C6.1 17.3 5.5 16.7 5 16Z M8.3 16H11V19.7C9.9 19.2 8.9 17.9 8.3 16Z M13 16H15.7C15.1 17.9 14.1 19.2 13 19.7Z M17.8 16H19C18.5 16.7 17.9 17.3 17.2 17.7C17.4 17.1 17.6 16.6 17.8 16Z</StreamGeometry>
+  <StreamGeometry x:Key="PanelMoreIcon">M4 10A2 2 0 1 0 4 14A2 2 0 0 0 4 10Z M12 10A2 2 0 1 0 12 14A2 2 0 0 0 12 10Z M20 10A2 2 0 1 0 20 14A2 2 0 0 0 20 10Z</StreamGeometry>
+  <StreamGeometry x:Key="PanelLeftIcon">M14 4L6 12L14 20L16 18L10 12L16 6Z</StreamGeometry>
+  <StreamGeometry x:Key="PanelRightIcon">M8 4L16 12L8 20L6 18L12 12L6 6Z</StreamGeometry>
+</ResourceDictionary>
diff --git a/src/Editor/GalNet.Editor/ViewModels/AssetPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/AssetPanelViewModel.cs
index c7525775..156ad055 100644
--- a/src/Editor/GalNet.Editor/ViewModels/AssetPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/AssetPanelViewModel.cs
@@ -187,6 +187,7 @@ public void Refresh()
         if (_content is { IsPublishing: true }) { _timer.Change(100, Timeout.Infinite); return; }
         try
         {
+            if (ExternalProjectSnapshotReader.HasPendingTransaction(ProjectRoot)) { _timer.Change(100, Timeout.Infinite); return; }
             while (!_index.DirectoryExists(CurrentDirectory) && CurrentDirectory.Length > 0) CurrentDirectory = Path.GetDirectoryName(CurrentDirectory)?.Replace('\\', '/') ?? "";
             var expanded = Directories.SelectMany(Expanded).Select(node => node.Path).ToHashSet(ProjectFilePaths.Comparer);
             var root = new ProjectDirectoryNode("", _projects.Current.Name, _index.Directories) { IsExpanded = true };
@@ -201,10 +202,12 @@ public void Refresh()
     private void LoadEntries()
     {
         if (_disposed) return;
+        if (_content is { IsPublishing: true }) { _timer.Change(100, Timeout.Infinite); return; }
         var selected = SelectedEntries.Select(item => item.Path).ToHashSet(ProjectFilePaths.Comparer);
         _thumbnails?.Cancel(); _thumbnails?.Dispose(); _thumbnails = new();
         try
         {
+            if (ExternalProjectSnapshotReader.HasPendingTransaction(ProjectRoot)) { _timer.Change(100, Timeout.Infinite); return; }
             var candidates = (HasSearch ? _index.Search(SearchText) : _index.Read(CurrentDirectory)).ToArray();
             bool Matches(ProjectFileItem item) => TypeFilterIndex switch
             {
diff --git a/src/Editor/GalNet.Editor/ViewModels/CharactersPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/CharactersPanelViewModel.cs
index e61cb7f9..003febe5 100644
--- a/src/Editor/GalNet.Editor/ViewModels/CharactersPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/CharactersPanelViewModel.cs
@@ -10,6 +10,7 @@ namespace GalNet.Editor.ViewModels;
 public sealed partial class CharactersPanelViewModel : ObservableObject, IUndoRedoTarget, IDisposable
 {
     private readonly CharacterAuthoringService _characters;
+    private readonly CharacterPanelState _state;
     private CharacterRow? _baseline;
     private bool _refreshing, _disposed, _new;
     private EditorText? _error;
@@ -24,58 +25,117 @@ public sealed partial class CharactersPanelViewModel : ObservableObject, IUndoRe
     public bool CanEdit => !Busy && (_new || Selected is not null);
     public bool CanDelete => !Busy && Selected is { Uses: 0 } && _characters.Complete;
     public bool Incomplete => !_characters.Complete;
-    private bool HasDraft => _new || _baseline is not null && (DraftName != _baseline.Name || DraftKey != _baseline.Id);
-    public CharactersPanelViewModel(CharacterAuthoringService characters, EditorHistories histories)
+    public string IncompleteDetails => _characters.IncompleteDetails;
+    public bool HasDraft => _new || _baseline is not null && (DraftName != _baseline.Name || DraftKey != _baseline.Id);
+    public bool HasRows => Rows.Count > 0;
+    public bool HasEditor => _new || Selected is not null;
+    public string DeleteHintKey => CanDelete ? "Characters.Delete" : "Uiux.Panel.DeleteBlocked";
+    public CharactersPanelViewModel(CharacterAuthoringService characters, EditorHistories histories, CharacterPanelState state)
     {
-        _characters = characters; UndoRedoHistory = histories.Content;
+        _characters = characters; _state = state; UndoRedoHistory = histories.Content;
         characters.Changed += Refresh; characters.Text.PropertyChanged += OnLocale;
         Refresh();
     }
     partial void OnSearchChanged(string value) => Refresh();
-    partial void OnBusyChanged(bool value) { OnPropertyChanged(nameof(CanEdit)); OnPropertyChanged(nameof(CanDelete)); }
+    partial void OnBusyChanged(bool value) { OnPropertyChanged(nameof(CanEdit)); OnPropertyChanged(nameof(CanDelete)); OnPropertyChanged(nameof(DeleteHintKey)); }
+    partial void OnDraftNameChanged(string value) => OnPropertyChanged(nameof(HasDraft));
+    partial void OnDraftKeyChanged(string value) => OnPropertyChanged(nameof(HasDraft));
+    partial void OnSelectedChanging(CharacterRow? value) { if (!_refreshing) SaveDraft(); }
     partial void OnSelectedChanged(CharacterRow? value)
     {
-        if (!_refreshing) { _new = false; Load(); }
-        OnPropertyChanged(nameof(CanEdit)); OnPropertyChanged(nameof(CanDelete));
+        if (!_refreshing)
+        {
+            _new = false;
+            _state.SelectedNameKey = value?.DisplayNameKey; _state.SelectedId = value?.Id; Load();
+        }
+        OnPropertyChanged(nameof(CanEdit)); OnPropertyChanged(nameof(CanDelete)); OnPropertyChanged(nameof(HasEditor)); OnPropertyChanged(nameof(DeleteHintKey));
+    }
+    private void Load(bool clearError = true)
+    {
+        var draft = _new ? _state.NewDraft : Selected is { } selected ? _state.Drafts.GetValueOrDefault((selected.Id, selected.DisplayNameKey)) : null;
+        _baseline = draft?.Baseline ?? Selected; DraftName = draft?.Name ?? _baseline?.Name ?? ""; DraftKey = draft?.Key ?? _baseline?.Id ?? "";
+        if (clearError) _error = null;
+        Render(); OnPropertyChanged(nameof(CanEdit)); OnPropertyChanged(nameof(HasEditor)); OnPropertyChanged(nameof(HasDraft));
     }
-    private void Load()
+    private void SaveDraft()
     {
-        _baseline = Selected; DraftName = _baseline?.Name ?? ""; DraftKey = _baseline?.Id ?? "";
-        _error = null; Render(); OnPropertyChanged(nameof(CanEdit));
+        if (_new) _state.NewDraft = new(null, DraftName, DraftKey);
+        else if (_baseline is { } baseline)
+        {
+            var id = Selected?.Id ?? baseline.Id;
+            if (HasDraft) _state.Drafts[(id, baseline.DisplayNameKey)] = new(baseline, DraftName, DraftKey);
+            else _state.Drafts.Remove((id, baseline.DisplayNameKey));
+        }
     }
     private void Refresh()
     {
         if (_disposed) return;
-        var preserve = HasDraft; var id = Selected?.Id;
+        SaveDraft();
         _refreshing = true;
         try
         {
+            var all = _characters.Rows();
+            _state.AmbiguousNameKeys.UnionWith(all.GroupBy(row => row.DisplayNameKey).Where(group => group.Count() > 1).Select(group => group.Key));
+            foreach (var pair in _state.Drafts.ToArray())
+            {
+                if (_state.AmbiguousNameKeys.Contains(pair.Key.NameKey) || all.Any(row => row.Id == pair.Key.Id && row.DisplayNameKey == pair.Key.NameKey)) continue;
+                var replacement = all.SingleOrDefault(row => row.DisplayNameKey == pair.Key.NameKey);
+                if (replacement is not null && _state.Drafts.TryAdd((replacement.Id, replacement.DisplayNameKey), pair.Value)) _state.Drafts.Remove(pair.Key);
+            }
+            var selection = all.FirstOrDefault(row => row.Id == _state.SelectedId && row.DisplayNameKey == _state.SelectedNameKey);
+            if (selection is null && _state.SelectedNameKey is { } nameKey && !_state.AmbiguousNameKeys.Contains(nameKey))
+                selection = all.SingleOrDefault(row => row.DisplayNameKey == nameKey);
+            if (selection is not null) _state.SelectedId = selection.Id;
             Rows.Clear();
-            foreach (var row in _characters.Rows().Where(row => row.Id.Contains(Search, StringComparison.OrdinalIgnoreCase) || row.DisplayName.Contains(Search, StringComparison.OrdinalIgnoreCase))) Rows.Add(row);
-            Selected = Rows.FirstOrDefault(row => row.Id == id);
-            if (!preserve) Load();
+            foreach (var row in all.Where(row => row.Id.Contains(Search, StringComparison.OrdinalIgnoreCase) || row.DisplayName.Contains(Search, StringComparison.OrdinalIgnoreCase))) Rows.Add(row);
+            Selected = Rows.FirstOrDefault(row => row.Id == selection?.Id && row.DisplayNameKey == selection.DisplayNameKey);
+            _new = _state.NewDraft is not null && _state.SelectedNameKey is null;
+            Load(clearError: false);
         }
         finally { _refreshing = false; }
-        OnPropertyChanged(nameof(CanEdit)); OnPropertyChanged(nameof(CanDelete)); OnPropertyChanged(nameof(Incomplete));
+        OnPropertyChanged(nameof(CanEdit)); OnPropertyChanged(nameof(CanDelete)); OnPropertyChanged(nameof(Incomplete)); OnPropertyChanged(nameof(IncompleteDetails)); OnPropertyChanged(nameof(HasRows)); OnPropertyChanged(nameof(DeleteHintKey));
     }
     [RelayCommand]
     private void Add()
     {
-        Selected = null; _new = true; _baseline = null; DraftName = ""; DraftKey = "";
-        _error = null; Render(); OnPropertyChanged(nameof(CanEdit));
+        if (_disposed || Busy) return;
+        SaveDraft(); _refreshing = true; Selected = null; _refreshing = false;
+        _new = true; _baseline = null; _state.SelectedNameKey = null; _state.SelectedId = null;
+        _state.NewDraft ??= new(null, "", ""); Load();
     }
     [RelayCommand]
     private async Task ApplyAsync() => await Run(async () =>
     {
         if (!_new && _baseline is null) return;
-        var key = DraftKey;
-        if (_new) key = (await _characters.CreateAsync(DraftName, string.IsNullOrWhiteSpace(key) ? null : key)).Id;
-        else if (_baseline is not null) await _characters.UpdateAsync(_baseline, key, DraftName);
+        var submittedNew = _new; var submittedBaseline = _baseline; var submittedName = DraftName; var submittedKey = DraftKey;
+        var key = submittedKey;
+        if (submittedNew) key = (await _characters.CreateAsync(submittedName, string.IsNullOrWhiteSpace(key) ? null : key)).Id;
+        else if (submittedBaseline is not null) await _characters.UpdateAsync(submittedBaseline, key, submittedName);
+        void ClearSubmitted((string Id, string NameKey) identity)
+        {
+            if (_state.Drafts.TryGetValue(identity, out var draft) && draft.Baseline == submittedBaseline && draft.Name == submittedName && draft.Key == submittedKey)
+                _state.Drafts.Remove(identity);
+        }
+        if (submittedBaseline is { } baseline)
+        { ClearSubmitted((baseline.Id, baseline.DisplayNameKey)); ClearSubmitted((key, baseline.DisplayNameKey)); }
+        if (submittedNew && _state.NewDraft is { } fresh && fresh.Name == submittedName && fresh.Key == submittedKey) _state.NewDraft = null;
         if (_disposed) return;
-        _new = false; _baseline = null; Refresh(); Selected = Rows.FirstOrDefault(row => row.Id == key); Load();
+        var stillEditingSubmitted = submittedNew ? _new : !_new && submittedBaseline is { } submitted
+            && _state.SelectedNameKey == submitted.DisplayNameKey && (_state.SelectedId == submitted.Id || _state.SelectedId == key);
+        if (!stillEditingSubmitted) { Refresh(); return; }
+        _new = false; _baseline = null; Search = "";
+        _state.SelectedNameKey = _characters.Rows().FirstOrDefault(row => row.Id == key)?.DisplayNameKey;
+        _state.SelectedId = key;
+        Refresh(); Load();
     });
     [RelayCommand] private async Task DeleteAsync() => await Run(async () => { if (Selected is { } row) await _characters.DeleteAsync(row); });
-    [RelayCommand] private void Revert() { _new = false; Load(); }
+    [RelayCommand]
+    private void Revert()
+    {
+        if (_baseline is { } baseline) _state.Drafts.Remove((Selected?.Id ?? baseline.Id, baseline.DisplayNameKey));
+        if (_new) _state.NewDraft = null;
+        _new = false; Load();
+    }
     private async Task Run(Func<Task> action)
     {
         if (_disposed || Busy) return;
@@ -84,11 +144,15 @@ private async Task Run(Func<Task> action)
         catch (Exception error) { _error = EditorText.Error(error); }
         finally { Busy = false; if (!_disposed) { Refresh(); Render(); } }
     }
-    private void OnLocale(object? sender, PropertyChangedEventArgs args) { if (!_disposed) Render(); }
+    private void OnLocale(object? sender, PropertyChangedEventArgs args)
+    {
+        if (_disposed) return;
+        Render(); OnPropertyChanged(nameof(IncompleteDetails));
+    }
     private void Render() => Message = _error?.Render(_characters.Text) ?? "";
     public void Dispose()
     {
-        if (_disposed) return; _disposed = true;
+        if (_disposed) return; SaveDraft(); _disposed = true;
         _characters.Changed -= Refresh; _characters.Text.PropertyChanged -= OnLocale;
     }
 }
diff --git a/src/Editor/GalNet.Editor/ViewModels/EditorPageViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/EditorPageViewModel.cs
index 3d5bb818..ef3af2b2 100644
--- a/src/Editor/GalNet.Editor/ViewModels/EditorPageViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/EditorPageViewModel.cs
@@ -16,12 +16,14 @@
 using Dock.Model.Core;
 using GalNet.Editor.Abstraction.Project;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Abstraction.Settings;
 using GalNet.Editor.Commands;
 using GalNet.Editor.Dock;
 using GalNet.Editor.History;
 using GalNet.Editor.Models;
 using GalNet.Editor.Services;
 using GalNet.Editor.Shared.Services;
+using GalNet.Editor.Shell;
 using Microsoft.Extensions.DependencyInjection;
 using Serilog;
 
@@ -32,12 +34,30 @@ public partial class EditorPageViewModel : PageViewModelBase, IMenuProvider, IDi
     private readonly IProjectService _projectService;
     private readonly EditorShortcutService _shortcutService;
     private readonly EditorDockFactory _dockFactory;
-    private readonly DockLayoutSerializer _dockLayoutSerializer;
+    private readonly EditorLayoutSession _layouts;
     private readonly IEditorWindowFactory _windowFactory;
-    private readonly IEditorSettingsService _editorSettingsService;
     private readonly PropertyChangedEventHandler _localizationChangedHandler;
     private readonly EditorHistories _histories;
     private readonly IProjectContentSession _content;
+    private readonly ProjectExternalChanges? _externalChanges;
+    public bool HasExternalIssue => _externalChanges?.HasIssue == true;
+    public bool CanReloadExternal => _externalChanges?.CanReload == true;
+    public string ExternalDetails => _externalChanges?.Details ?? "";
+    public string ExternalStatus => L[_externalChanges?.State switch
+    {
+        ExternalProjectState.LocalChanges => "External.LocalChanges",
+        ExternalProjectState.Publishing => "External.Publishing",
+        ExternalProjectState.ContractsChanged => "External.ContractsChanged",
+        ExternalProjectState.Invalid => "External.Invalid",
+        ExternalProjectState.Reloaded => "External.Reloaded",
+        _ => "Editor.Status.Ready"
+    }];
+    public ICommand RetryExternalChangesCommand => new AsyncRelayCommand(async () => { if (_externalChanges is not null) await _externalChanges.CheckNowAsync(); });
+    public ICommand ReloadExternalChangesCommand => new AsyncRelayCommand(async () =>
+    {
+        if (_externalChanges is null) return;
+        if (!_content.IsDirty || await ProjectReloadPrompt.ConfirmAsync(L)) await _externalChanges.CheckNowAsync(discardLocalChanges: true);
+    });
 
     public IEditorLocalizationService L { get; }
 
@@ -54,18 +74,13 @@ public partial class EditorPageViewModel : PageViewModelBase, IMenuProvider, IDi
 
     public IList<MenuData> MenuItems { get; } = new AvaloniaList<MenuData>();
 
-    public IRootDock? Layout { get; private set; }
+    public IRootDock? Layout => _layouts.Layout;
 
     public ICommand UndoCommand { get; }
     public ICommand RedoCommand { get; }
     public ICommand TogglePanelCommand { get; }
 
-    private EditorText? _layoutStatus;
-    private void SetLayoutStatus(EditorText text) { _layoutStatus = text; StatusText = text.Render(L); }
-    private bool _savingLayout;
     private bool _disposed;
-    private bool _layoutSavePending;
-    private readonly DispatcherTimer _layoutSaveTimer;
     public ICommand SaveLayoutCommand { get; }
     public ICommand LoadLayoutCommand { get; }
     public ICommand ResetLayoutCommand { get; }
@@ -80,38 +95,38 @@ public EditorPageViewModel(
         IEditorSettingsService editorSettingsService,
         IEditorLocalizationService localization,
         EditorHistories histories,
-        IProjectContentSession content)
+        IProjectContentSession content, ProjectExternalChanges? externalChanges = null)
     {
         _projectService = projectService;
         _histories = histories;
         _content = content;
+        _externalChanges = externalChanges;
         _content.Changed += OnContentChanged;
         _shortcutService = shortcutService;
         _dockFactory = dockFactory;
-        _dockLayoutSerializer = dockLayoutSerializer;
+        _layouts = new(dockFactory, dockLayoutSerializer, editorSettingsService);
+        _layouts.Changed += OnLayoutChanged;
+        _layouts.NamesChanged += BuildMenuItems;
         _windowFactory = windowFactory;
-        _editorSettingsService = editorSettingsService;
         L = localization;
 
         UndoCommand = _shortcutService.GetCommand<UndoEditorCommand>().Command;
         RedoCommand = _shortcutService.GetCommand<RedoEditorCommand>().Command;
 
         TogglePanelCommand = new RelayCommand<string>(TogglePanel);
-        SaveLayoutCommand = new AsyncRelayCommand(SaveLayoutAsync);
-        LoadLayoutCommand = new RelayCommand<string>(LoadLayout);
-        ResetLayoutCommand = new RelayCommand(ResetLayout);
-        _layoutSaveTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(2) };
-        _layoutSaveTimer.Tick += OnLayoutSaveTimerTick;
+        SaveLayoutCommand = new AsyncRelayCommand(() => _layouts.SaveAsync(() => _windowFactory.RequestLayoutNameAsync(L)));
+        LoadLayoutCommand = new RelayCommand<string>(_layouts.Load);
+        ResetLayoutCommand = new RelayCommand(_layouts.Reset);
 
         var project = _projectService.Current
             ?? throw new InvalidOperationException("EditorPageViewModel requires an open project");
+        if (_externalChanges is not null) { _externalChanges.Changed += OnExternalChanged; _externalChanges.Start(); }
 
         UpdateLocalizedText();
-        InitializeDock();
+        _layouts.Initialize();
         BuildMenuItems();
         _histories.Changed += OnHistoryChanged;
         OnHistoryChanged();
-        _dockFactory.LayoutChanged += OnDockLayoutChanged;
         _projectService.CurrentChanged += OnCurrentProjectChanged;
 
         _localizationChangedHandler = OnLocalizationChanged;
@@ -142,7 +157,14 @@ private void OnContentChanged()
         if (_content.RepairRequired) StatusText = L["Status.Repair"];
         else if (_content.LastError is { } error) StatusText = L.Format("Status.SaveFailed", EditorText.Error(error).Render(L));
         else if (_content.LastRecoveryError is { } recovery) StatusText = L.Format("Status.RecoveryFailed", EditorText.Error(recovery).Render(L));
-        else if (_layoutStatus is not null) StatusText = _layoutStatus.Render(L);
+        else if (_externalChanges?.State == ExternalProjectState.Reloaded) StatusText = ExternalStatus;
+        else if (_layouts.Status is { } layoutStatus) StatusText = layoutStatus.Render(L);
+    }
+
+    private void OnExternalChanged()
+    {
+        OnPropertyChanged(nameof(HasExternalIssue)); OnPropertyChanged(nameof(CanReloadExternal)); OnPropertyChanged(nameof(ExternalStatus)); OnPropertyChanged(nameof(ExternalDetails));
+        OnContentChanged();
     }
 
     public bool TryExecuteShortcut(KeyEventArgs args, string context = "Global") =>
@@ -152,7 +174,7 @@ public bool TryExecuteShortcut(KeyEventArgs args, string context = "Global") =>
     private void OnLocalizationChanged(object? sender, PropertyChangedEventArgs e)
     {
         if (e.PropertyName == "Item[]")
-            OnHistoryChanged();
+        { OnHistoryChanged(); OnExternalChanged(); }
     }
 
     private void UpdateLocalizedText()
@@ -164,26 +186,6 @@ private void UpdateLocalizedText()
             : L.Format("Editor.Status.Project", project.Name, project.RootPath);
     }
 
-    private void InitializeDock()
-    {
-        var settings = _editorSettingsService.GetSettings();
-        Layout = TryLoadLayout(settings.LastDockLayout);
-        if (Layout is null && !string.IsNullOrWhiteSpace(settings.LastDockLayout))
-        {
-            // A previous implementation could persist the host Window back-reference.
-            // Discard that malformed global value once so every subsequent start is clean.
-            settings.LastDockLayout = null;
-            _editorSettingsService.SaveSettings();
-            SetLayoutStatus(new("Status.LayoutReset"));
-        }
-        if (Layout is null)
-        {
-            Layout = _dockFactory.CreateLayout();
-            _dockFactory.InitLayout(Layout);
-        }
-        OnPropertyChanged(nameof(Layout));
-    }
-
     private void TogglePanel(string? panelId)
     {
         if (string.IsNullOrWhiteSpace(panelId))
@@ -194,133 +196,6 @@ private void TogglePanel(string? panelId)
         else _dockFactory.OpenPanel(panelId);
     }
 
-    private async Task SaveLayoutAsync()
-    {
-        if (Layout is null)
-            return;
-        var name = await RequestLayoutNameAsync();
-        if (string.IsNullOrWhiteSpace(name)) return;
-        name = name.Trim();
-        if (string.Equals(name, "Default", StringComparison.OrdinalIgnoreCase))
-        {
-            SetLayoutStatus(new("Layout.Reserved"));
-            return;
-        }
-        var settings = _editorSettingsService.GetSettings();
-        settings.DockLayouts[name] = SerializeLayout(Layout);
-        _editorSettingsService.SaveSettings();
-        SetLayoutStatus(new("Layout.Saved", name));
-        BuildMenuItems();
-    }
-
-    private void LoadLayout(string? name)
-    {
-        if (string.Equals(name, "Default", StringComparison.OrdinalIgnoreCase))
-        {
-            ResetLayout();
-            return;
-        }
-        var settings = _editorSettingsService.GetSettings();
-        if (string.IsNullOrWhiteSpace(name) || !settings.DockLayouts.TryGetValue(name, out var serialized))
-        {
-            SetLayoutStatus(new("Layout.None"));
-            return;
-        }
-        var layout = TryLoadLayout(serialized);
-        if (layout is null)
-        {
-            SetLayoutStatus(new("Layout.LoadFailed", name));
-            return;
-        }
-        Layout = layout;
-        OnPropertyChanged(nameof(Layout));
-        SetLayoutStatus(new("Layout.Loaded", name));
-    }
-
-    private void ResetLayout()
-    {
-        Layout = _dockFactory.CreateLayout();
-        _dockFactory.InitLayout(Layout);
-        OnPropertyChanged(nameof(Layout));
-        SetLayoutStatus(new("Layout.Reset"));
-    }
-
-    private void DeleteLayout(string? name)
-    {
-        if (string.IsNullOrWhiteSpace(name) || string.Equals(name, "Default", StringComparison.OrdinalIgnoreCase)) return;
-        var settings = _editorSettingsService.GetSettings();
-        if (!settings.DockLayouts.Remove(name)) return;
-        _editorSettingsService.SaveSettings();
-        SetLayoutStatus(new("Layout.Deleted", name));
-        BuildMenuItems();
-    }
-
-    private IRootDock? TryLoadLayout(string? serialized)
-    {
-        if (string.IsNullOrWhiteSpace(serialized)) return null;
-        try
-        {
-            var layout = DockLayoutSerializer.Deserialize(serialized);
-            if (layout is null)
-                return null;
-
-            _dockFactory.InitLayout(layout);
-            return _dockFactory.PrepareRestoredLayout(layout) ? layout : null;
-        }
-        catch (Exception exception)
-        {
-            Log.Warning(exception, "Failed to restore editor dock layout");
-            return null;
-        }
-    }
-
-    private void OnDockLayoutChanged()
-    {
-        if (Layout is null) return;
-        _layoutSavePending = true;
-        _layoutSaveTimer.Stop();
-        _layoutSaveTimer.Start();
-        RefreshViewMenuChecks();
-    }
-
-    private void OnLayoutSaveTimerTick(object? sender, EventArgs e)
-    {
-        _layoutSaveTimer.Stop();
-        PersistLayoutNow();
-    }
-
-    private void PersistLayoutCore()
-    {
-        if (_savingLayout || Layout is null || _dockFactory.IsMaximized) return;
-        try
-        {
-            _savingLayout = true;
-            var serialized = SerializeLayout(Layout);
-            _editorSettingsService.GetSettings().LastDockLayout = serialized;
-            _editorSettingsService.SaveSettings();
-        }
-        catch (Exception exception)
-        {
-            SetLayoutStatus(new("Layout.SaveFailed"));
-            Log.Error(exception, "Failed to persist editor dock layout");
-        }
-        finally { _savingLayout = false; }
-    }
-
-    /// <summary>Called after splitter interaction; persistence is debounced to avoid disk writes during dragging.</summary>
-    public void PersistLayout() => OnDockLayoutChanged();
-
-    /// <summary>Flushes a pending layout change. Called during application shutdown.</summary>
-    public void PersistLayoutNow()
-    {
-        _layoutSaveTimer.Stop();
-        if (!_layoutSavePending && Layout is null) return;
-        _layoutSavePending = false;
-        PersistLayoutCore();
-    }
-
-    private string SerializeLayout(IRootDock layout) => _dockLayoutSerializer.Serialize(layout);
-
     [RelayCommand]
     private async Task ShowProjectSettingsAsync()
     {
@@ -358,92 +233,12 @@ private async Task ShowExportAsync()
 
     private void BuildMenuItems()
     {
-        var closeCmd = _shortcutService.GetCommand<CloseProjectCommand>();
-        var saveCmd = _shortcutService.GetCommand<SaveProjectCommand>();
-        ICommand DebugAction(Func<ExternalDebugPanelViewModel, Task> action) => new AsyncRelayCommand(async () =>
-        {
-            if (_projectService.Current is not { } project) return;
-            if (!_dockFactory.HasGlobalPanel(EditorDockPanelIds.ExternalDebug)) TogglePanel(EditorDockPanelIds.ExternalDebug);
-            await action(project.Services.GetRequiredService<ExternalDebugPanelViewModel>());
-        });
-
-        var items = new AvaloniaList<MenuData>
-        {
-            new()
-            {
-                HeaderKey = "Editor.Menu.File",
-                Children = new AvaloniaList<MenuData>
-                {
-                    new() { HeaderKey = "Command.SaveProject", Command = saveCmd.Command, InputGesture = saveCmd.Gesture },
-                    new() { HeaderKey = "Editor.Menu.Export", Command = ShowExportCommand },
-                    new() { HeaderKey = "Command.CloseProject", Command = closeCmd.Command, InputGesture = closeCmd.Gesture },
-                    new() { IsSeparator = true },
-                    new() { HeaderKey = "Editor.Menu.Exit", InputGesture = new Avalonia.Input.KeyGesture(Key.F4, KeyModifiers.Alt), IsEnabled = false },
-                }
-            },
-            new()
-            {
-                HeaderKey = "Editor.Menu.Edit",
-                Children = new AvaloniaList<MenuData>
-                {
-                    new() { HeaderKey = "Editor.Menu.Undo", InputGesture = new Avalonia.Input.KeyGesture(Key.Z, KeyModifiers.Control), Command = UndoCommand },
-                    new() { HeaderKey = "Editor.Menu.Redo", InputGesture = new Avalonia.Input.KeyGesture(Key.Y, KeyModifiers.Control), Command = RedoCommand },
-                }
-            },
-            new()
-            {
-                HeaderKey = "Editor.Menu.Settings",
-                Children = new AvaloniaList<MenuData>
-                {
-                    new() { HeaderKey = "Editor.Menu.ProjectSettings", Command = ShowProjectSettingsCommand },
-                    new() { HeaderKey = "Editor.Menu.EditorSettings", Command = ShowEditorSettingsCommand },
-                }
-            },
-            new()
-            {
-                HeaderKey = "Editor.Menu.View",
-                Children = BuildViewMenuItems()
-            },
-            new()
-            {
-                HeaderKey = "Editor.Menu.Window",
-                Children = new AvaloniaList<MenuData>
-                {
-                    new() { HeaderKey = "Uiux.Layout.Writing", Command = new RelayCommand(() => _dockFactory.ApplyWorkspacePreset("Writing")) },
-                    new() { HeaderKey = "Uiux.Layout.Animation", Command = new RelayCommand(() => _dockFactory.ApplyWorkspacePreset("Animation")) },
-                    new() { HeaderKey = "Uiux.Layout.Debug", Command = new RelayCommand(() => _dockFactory.ApplyWorkspacePreset("Debug")) },
-                    new() { HeaderKey = "Uiux.Layout.Maximize", Command = new RelayCommand(_dockFactory.ToggleMaximizeActive) },
-                    new() { HeaderKey = "Editor.Menu.SaveLayout", Command = SaveLayoutCommand },
-                    new() { HeaderKey = "Editor.Menu.LoadLayout", Children = BuildLoadLayoutItems() },
-                    new() { HeaderKey = "Editor.Menu.DeleteLayout", Children = BuildDeleteLayoutItems() },
-                }
-            },
-            new()
-            {
-                HeaderKey = "Debug.Menu",
-                Children = new AvaloniaList<MenuData>
-                {
-                    new() { HeaderKey = "Debug.Launch", Command = DebugAction(vm => vm.LaunchCommand.ExecuteAsync(null)) },
-                    new() { HeaderKey = "Debug.Wait", Command = DebugAction(vm => vm.WaitForApplicationCommand.ExecuteAsync(null)) },
-                    new() { HeaderKey = "Debug.Start", Command = DebugAction(vm => vm.StartGameCommand.ExecuteAsync(null)) },
-                    new() { HeaderKey = "Debug.Stop", Command = DebugAction(vm => vm.StopGameCommand.ExecuteAsync(null)) },
-                    new() { HeaderKey = "Debug.GroupEnd", Command = DebugAction(vm => vm.GroupEndCommand.ExecuteAsync(null)) },
-                    new() { HeaderKey = "Debug.Panel", Command = TogglePanelCommand, CommandParameter = EditorDockPanelIds.ExternalDebug }
-                }
-            },
-            new()
-            {
-                HeaderKey = "Editor.Menu.Help",
-                Children = new AvaloniaList<MenuData>
-                {
-                    new() { HeaderKey = "Editor.Menu.About", IsEnabled = false },
-                }
-            },
-        };
-
+        var items = new EditorMenuBuilder(_shortcutService, _dockFactory, _layouts, _projectService,
+            new(UndoCommand, RedoCommand, TogglePanelCommand, SaveLayoutCommand, LoadLayoutCommand,
+                ShowExportCommand, ShowProjectSettingsCommand, ShowEditorSettingsCommand)).Build();
         MenuItems.Clear();
-        foreach (var item in items)
-            MenuItems.Add(item);
+        foreach (var item in items) MenuItems.Add(item);
+        OnHistoryChanged();
     }
 
     public void Dispose()
@@ -452,39 +247,17 @@ public void Dispose()
             return;
 
         _disposed = true;
-        PersistLayoutNow();
-        _layoutSaveTimer.Tick -= OnLayoutSaveTimerTick;
-        _dockFactory.LayoutChanged -= OnDockLayoutChanged;
+        _layouts.Changed -= OnLayoutChanged;
+        _layouts.NamesChanged -= BuildMenuItems;
+        _layouts.Dispose();
         _projectService.CurrentChanged -= OnCurrentProjectChanged;
         _histories.Changed -= OnHistoryChanged;
         _content.Changed -= OnContentChanged;
+        if (_externalChanges is not null) _externalChanges.Changed -= OnExternalChanged;
         L.PropertyChanged -= _localizationChangedHandler;
         GC.SuppressFinalize(this);
     }
 
-    private AvaloniaList<MenuData> BuildViewMenuItems() => new(
-        _dockFactory.ViewMenuPanels.Select(panel => new MenuData
-        {
-            HeaderKey = panel.TitleKey,
-            Command = TogglePanelCommand,
-            CommandParameter = panel.PanelId,
-            IsCheckable = panel.IsGlobal,
-            IsChecked = panel.IsGlobal && _dockFactory.HasGlobalPanel(panel.PanelId)
-        }));
-
-    private AvaloniaList<MenuData> BuildLoadLayoutItems()
-    {
-        var items = new AvaloniaList<MenuData> { new() { Header = "Default", Command = LoadLayoutCommand, CommandParameter = "Default" } };
-        foreach (var name in _editorSettingsService.GetSettings().DockLayouts.Keys.OrderBy(name => name, StringComparer.OrdinalIgnoreCase))
-            items.Add(new MenuData { Header = name, Command = LoadLayoutCommand, CommandParameter = name });
-        return items;
-    }
-
-    private AvaloniaList<MenuData> BuildDeleteLayoutItems() => new(
-        _editorSettingsService.GetSettings().DockLayouts.Keys
-            .OrderBy(name => name, StringComparer.OrdinalIgnoreCase)
-            .Select(name => new MenuData { Header = name, Command = new RelayCommand<string>(DeleteLayout), CommandParameter = name }));
-
     private void RefreshViewMenuChecks()
     {
         var view = MenuItems.FirstOrDefault(item => item.HeaderKey == "Editor.Menu.View");
@@ -496,42 +269,12 @@ private void RefreshViewMenuChecks()
         }
     }
 
-    private async Task<string?> RequestLayoutNameAsync()
+    private void OnLayoutChanged()
     {
-        var owner = GetMainWindow();
-        if (owner is null) return null;
-        var input = new TextBox { MinWidth = 260, PlaceholderText = L["Layout.Name"] };
-        var dialog = new Window
-        {
-            Title = L["Editor.Menu.SaveLayout"],
-            Width = 360,
-            Height = 140,
-            WindowStartupLocation = WindowStartupLocation.CenterOwner
-        };
-        dialog.Content = new StackPanel
-        {
-            Margin = new Thickness(16),
-            Spacing = 12,
-            Children =
-            {
-                input,
-                new StackPanel
-                {
-                    Orientation = Avalonia.Layout.Orientation.Horizontal,
-                    HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Right,
-                    Spacing = 8,
-                    Children =
-                    {
-                        new Button { Content = L["Common.Cancel"], Command = new RelayCommand(() => dialog.Close(null)) },
-                        new Button { Content = L["Common.Save"], Command = new RelayCommand(() => dialog.Close(input.Text)) }
-                    }
-                }
-            }
-        };
-        var bindings = new List<IDisposable> { LocalizedBindings.Bind(dialog, Window.TitleProperty, L, "Editor.Menu.SaveLayout"), LocalizedBindings.Bind(input, TextBox.PlaceholderTextProperty, L, "Layout.Name") };
-        foreach (var button in ((StackPanel)dialog.Content!).Children.OfType<StackPanel>().SelectMany(panel => panel.Children).OfType<Button>())
-            bindings.Add(LocalizedBindings.Bind(button, ContentControl.ContentProperty, L, button.Content?.ToString() == L["Common.Cancel"] ? "Common.Cancel" : "Common.Save"));
-        dialog.Closed += (_, _) => { foreach (var binding in bindings) binding.Dispose(); };
-        return await dialog.ShowDialog<string?>(owner);
+        OnPropertyChanged(nameof(Layout));
+        RefreshViewMenuChecks();
+        OnContentChanged();
     }
+    public void PersistLayout() => _layouts.PersistLayout();
+    public void PersistLayoutNow() => _layouts.PersistLayoutNow();
 }
diff --git a/src/Editor/GalNet.Editor/ViewModels/EditorSettingsPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/EditorSettingsPanelViewModel.cs
index 779f8925..235583a7 100644
--- a/src/Editor/GalNet.Editor/ViewModels/EditorSettingsPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/EditorSettingsPanelViewModel.cs
@@ -39,6 +39,9 @@ public partial class EditorSettingsPanelViewModel : ObservableObject, IDisposabl
     [ObservableProperty]
     private bool _autoSaveProject = true;
 
+    [ObservableProperty]
+    private bool _expandNewEntries = true;
+
     public ObservableCollection<ThemeSelectionItem> AvailableThemes { get; } = [];
     public ObservableCollection<CultureInfo> AvailableCultures { get; } = [];
     public ObservableCollection<ShortcutSettingItemViewModel> Shortcuts { get; } = [];
@@ -97,6 +100,7 @@ private void LoadFromSettings()
                           ?? AvailableCultures.FirstOrDefault(culture => culture.Name == "zh-CN")
                           ?? AvailableCultures.FirstOrDefault();
         AutoSaveProject = settings.AutoSaveProject;
+        ExpandNewEntries = settings.ExpandNewEntries;
         _loading = false;
     }
 
@@ -170,6 +174,14 @@ partial void OnSelectedCultureChanged(CultureInfo? value)
         SetStatus(new("Settings.Saved"));
     }
 
+    partial void OnExpandNewEntriesChanged(bool value)
+    {
+        if (_loading) return;
+        _editorSettings.GetSettings().ExpandNewEntries = value;
+        _editorSettings.SaveSettings();
+        SetStatus(new("Settings.Saved"));
+    }
+
     partial void OnAutoSaveProjectChanged(bool value)
     {
         if (_loading) return;
diff --git a/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.Preview.cs b/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.Preview.cs
deleted file mode 100644
index e5b7d1e6..00000000
--- a/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.Preview.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using GalNet.Core.Variable;
-using GalNet.Editor.Abstraction.Services;
-
-namespace GalNet.Editor.ViewModels;
-
-public partial class EditorWorkspaceViewModel
-{
-    private readonly IEditorDocumentService _documentService;
-    public IReadOnlyList<ProjectVariableDefinition> AllProjectVariableDefinitions =>
-        [.. _documentService.CurrentDocument.PlayerVariables, .. _documentService.CurrentDocument.SaveVariables];
-
-    public IReadOnlyList<ConditionVariableSuggestion> GetConditionVariableSuggestions()
-    {
-        return _documentService.CurrentDocument.PlayerVariables
-                .Select(v => new ConditionVariableSuggestion { Name = v.Name, Scope = VariableScope.Player })
-                .Concat(_documentService.CurrentDocument.SaveVariables.Select(v => new ConditionVariableSuggestion { Name = v.Name, Scope = VariableScope.Save }))
-                .ToList();
-    }
-
-    public string BuildPreviewData()
-    {
-        if (_projectService.Current is not { } project)
-            throw new InvalidOperationException("No project is currently open.");
-
-        var previewPath = Path.Combine(project.TempPath, "preview");
-        return _persistence.BuildPreviewData(previewPath, Nodes, Edges);
-    }
-}
diff --git a/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.Variables.cs b/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.Variables.cs
new file mode 100644
index 00000000..9438204e
--- /dev/null
+++ b/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.Variables.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using GalNet.Core.Variable;
+using GalNet.Editor.Abstraction.Services;
+
+namespace GalNet.Editor.ViewModels;
+
+public partial class EditorWorkspaceViewModel
+{
+    private readonly IEditorDocumentService _documentService;
+    public IReadOnlyList<ProjectVariableDefinition> AllProjectVariableDefinitions =>
+        [.. _variableDefinitionService.GetDefinitions(VariableScope.Player), .. _variableDefinitionService.GetDefinitions(VariableScope.Save)];
+
+    public IReadOnlyList<ConditionVariableSuggestion> GetConditionVariableSuggestions()
+    {
+        return _variableDefinitionService.GetDefinitions(VariableScope.Player)
+                .Select(v => new ConditionVariableSuggestion { Name = v.Name, Scope = VariableScope.Player })
+                .Concat(_variableDefinitionService.GetDefinitions(VariableScope.Save).Select(v => new ConditionVariableSuggestion { Name = v.Name, Scope = VariableScope.Save }))
+                .ToList();
+    }
+
+}
diff --git a/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.cs
index 96a6d7fc..cc7ae110 100644
--- a/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/EditorWorkspaceViewModel.cs
@@ -27,6 +27,7 @@ public partial class EditorWorkspaceViewModel : ObservableObject, IDisposable, I
     private readonly GraphSelectionState _selection;
     private readonly EditorWorkspacePersistence _persistence;
     private readonly IEditorSettingsService _editorSettings;
+    public bool ExpandNewEntries => _editorSettings.GetSettings().ExpandNewEntries;
     private readonly IEditorLocalizationService _localization;
     private readonly IVariableDefinitionService _variableDefinitionService;
     private readonly Action<GalProject?> _projectChangedHandler;
@@ -51,18 +52,17 @@ private void OnCultureChanged(object? sender, System.ComponentModel.PropertyChan
     [ObservableProperty]
     private GraphEdge? _selectedEdge;
 
-    [ObservableProperty]
-    private GamePreviewPanelViewModel? _activePreview;
-
     [ObservableProperty]
     private AssetEntry? _selectedAsset;
 
     [ObservableProperty]
     private string _statusText = "Ready";
 
-    public ObservableCollection<GraphNode> Nodes { get; } = [];
+    private readonly ObservableCollection<GraphNode> _nodes = [];
+    public ReadOnlyObservableCollection<GraphNode> Nodes { get; }
     public ExternalDebugPanelViewModel? ExternalDebug => _projectService.Current?.Services.GetService<ExternalDebugPanelViewModel>();
-    public ObservableCollection<GraphEdge> Edges { get; } = [];
+    private readonly ObservableCollection<GraphEdge> _edges = [];
+    public ReadOnlyObservableCollection<GraphEdge> Edges { get; }
     public ObservableCollection<GraphNode> SelectedNodes => _selection.SelectedNodes;
     public GraphViewportState GraphViewport => _projectService.Current?.EditorState.GraphViewport ?? _fallbackViewport;
     public bool HasMultipleNodeSelection => _selection.HasMultipleNodes;
@@ -83,6 +83,8 @@ public EditorWorkspaceViewModel(
         GraphSelectionState selection,
         EditorWorkspacePersistence persistence, GraphAuthoringService graphAuthoring, GroupEntryAuthoringService entryAuthoring)
     {
+        Nodes = new(_nodes);
+        Edges = new(_edges);
         _projectService = projectService;
         _histories = histories;
         _dockFactory = dockFactory;
@@ -106,8 +108,6 @@ public EditorWorkspaceViewModel(
         _projectService.CurrentChanged += _projectChangedHandler;
         _variableDefinitionService.DefinitionsChanged += _definitionsChangedHandler;
         _histories.Changed += OnHistoryChanged;
-        Nodes.CollectionChanged += OnGraphCollectionChanged;
-        Edges.CollectionChanged += OnGraphCollectionChanged;
         SetStatus(_statusMessage);
         LoadCurrentProjectGraph();
         _documentService.DocumentChanged += SynchronizeGraph;
@@ -123,10 +123,8 @@ public void Dispose()
         _variableDefinitionService.DefinitionsChanged -= _definitionsChangedHandler;
         _histories.Changed -= OnHistoryChanged;
         _documentService.DocumentChanged -= SynchronizeGraph;
-        foreach (var node in Nodes) { node.RenameRequested = null; node.BranchValueRequested = null; }
+        foreach (var node in Nodes) { node.RenameRequested = null; node.StoryPackageRequested = null; node.BranchValueRequested = null; }
         foreach (var edge in Edges) edge.Dispose();
-        Nodes.CollectionChanged -= OnGraphCollectionChanged;
-        Edges.CollectionChanged -= OnGraphCollectionChanged;
         GC.SuppressFinalize(this);
     }
 
@@ -305,10 +303,10 @@ private void LoadCurrentProjectGraph()
     {
         _isLoadingGraph = true;
         ClearSelection();
-        foreach (var node in Nodes) { node.RenameRequested = null; node.BranchValueRequested = null; }
+        foreach (var node in Nodes) { node.RenameRequested = null; node.StoryPackageRequested = null; node.BranchValueRequested = null; }
         foreach (var edge in Edges) edge.Dispose();
-        Nodes.Clear();
-        Edges.Clear();
+        _nodes.Clear();
+        _edges.Clear();
 
         try
         {
@@ -323,10 +321,10 @@ private void LoadCurrentProjectGraph()
             {
                 node.IsRoot = node.NodeKind == GraphNodeKind.Entry;
                 TrackNode(node);
-                Nodes.Add(node);
+                _nodes.Add(node);
             }
             foreach (var edge in graph.Edges)
-                Edges.Add(edge);
+                _edges.Add(edge);
 
             UpdateConnectorStates();
             SelectNode(EntryNode ?? Nodes.FirstOrDefault());
@@ -335,8 +333,8 @@ private void LoadCurrentProjectGraph()
         {
             Log.Error(ex, "Failed to load project graph");
             ClearSelection();
-            Nodes.Clear();
-            Edges.Clear();
+            _nodes.Clear();
+            _edges.Clear();
             SetStatus(new("Status.GraphLoadFailed", EditorText.Error(ex)));
             throw;
         }
@@ -358,22 +356,22 @@ private void SynchronizeGraph()
             foreach (var node in Nodes.ToArray())
                 if (!source.Nodes.Any(dto => ReferenceEquals(dto, node.Source)))
                 {
-                    node.RenameRequested = null; node.BranchValueRequested = null;
-                    Nodes.Remove(node);
+                    node.RenameRequested = null; node.StoryPackageRequested = null; node.BranchValueRequested = null;
+                    _nodes.Remove(node);
                     if (node.NodeKind == GraphNodeKind.LinearGroup) _dockFactory.CloseGroupEditor(node.Id);
                 }
             for (var index = 0; index < source.Nodes.Count; index++)
             {
                 var dto = source.Nodes[index];
                 var node = Nodes.FirstOrDefault(node => ReferenceEquals(node.Source, dto));
-                if (node is null) { node = _persistence.ProjectNode(dto); Nodes.Insert(index, node); }
-                else if (Nodes.IndexOf(node) != index) Nodes.Move(Nodes.IndexOf(node), index);
+                if (node is null) { node = _persistence.ProjectNode(dto); _nodes.Insert(index, node); }
+                else if (Nodes.IndexOf(node) != index) _nodes.Move(Nodes.IndexOf(node), index);
                 node.RefreshAuthorValues();
                 TrackNode(node);
             }
             foreach (var edge in Edges.ToArray())
                 if (!source.Edges.Any(dto => ReferenceEquals(dto, edge.Source)) || !Nodes.Contains(edge.From) || !Nodes.Contains(edge.To))
-                { Edges.Remove(edge); edge.Dispose(); }
+                { _edges.Remove(edge); edge.Dispose(); }
             for (var index = 0; index < source.Edges.Count; index++)
             {
                 var dto = source.Edges[index];
@@ -381,9 +379,9 @@ private void SynchronizeGraph()
                 if (edge is null)
                 {
                     edge = new GraphEdge(Nodes.Single(node => node.Id == dto.FromNodeId), Nodes.Single(node => node.Id == dto.ToNodeId), dto);
-                    Edges.Insert(index, edge);
+                    _edges.Insert(index, edge);
                 }
-                else if (Edges.IndexOf(edge) != index) Edges.Move(Edges.IndexOf(edge), index);
+                else if (Edges.IndexOf(edge) != index) _edges.Move(Edges.IndexOf(edge), index);
                 edge.Outlet = dto.FromOutlet;
             }
             UpdateConnectorStates();
@@ -394,13 +392,6 @@ private void SynchronizeGraph()
         finally { _isLoadingGraph = false; }
     }
 
-    private void OnGraphCollectionChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs args)
-    {
-        if (_isLoadingGraph) return;
-        _documentService.CurrentDocument.Nodes = Nodes.Select(node => node.Source).ToList();
-        _documentService.CurrentDocument.Edges = Edges.Select(edge => edge.Source).ToList();
-    }
-
     private void ScheduleAutoSave()
     {
         if (!_editorSettings.GetSettings().AutoSaveProject)
@@ -421,7 +412,11 @@ private void OnHistoryChanged()
     }
 
     public IReadOnlyList<EntryEditorItemViewModel> InsertEntriesInto(GraphNode groupNode, int index, int count, string? type = null) =>
-        groupNode.NodeKind == GraphNodeKind.LinearGroup ? _entryAuthoring.Insert(groupNode.Id, index, count, type) : [];
+        groupNode.NodeKind == GraphNodeKind.LinearGroup
+            ? ResolveEntries(groupNode, _entryAuthoring.Insert(groupNode.Id, index, count, type)) : [];
+
+    private static IReadOnlyList<EntryEditorItemViewModel> ResolveEntries(GraphNode group, IReadOnlyList<string> ids) =>
+        group.Entries.Where(entry => ids.Contains(entry.StableId)).ToArray();
 
     public bool RemoveEntryFrom(GraphNode groupNode, EntryEditorItemViewModel entry)
     {
@@ -430,7 +425,7 @@ public bool RemoveEntryFrom(GraphNode groupNode, EntryEditorItemViewModel entry)
         return true;
     }
 
-    public void ChangeEntryType(GraphNode groupNode, EntryEditorItemViewModel entry, string type, IReadOnlyDictionary<string, string> parameters)
+    public void ChangeEntryType(GraphNode groupNode, EntryEditorItemViewModel entry, string type, IReadOnlyDictionary<string, System.Text.Json.JsonElement> parameters)
     {
         if (!groupNode.Entries.Contains(entry) || entry.Type == type) return;
         entry.ChangeAuthorType(type, parameters);
@@ -441,6 +436,7 @@ private void TrackNode(GraphNode node)
         node.GameTexts = _projectService.Current?.Services.GetService<GameTextAuthoringService>();
         foreach (var option in node.Options) option.BindText(node.GameTexts, node.Id);
         node.RenameRequested = value => { try { _graphAuthoring.Rename(node.Id, value); } catch (Exception failure) { ReportGraphError(failure); } };
+        node.StoryPackageRequested = value => { try { _graphAuthoring.SetStoryPackage(node.Id, value); } catch (Exception failure) { ReportGraphError(failure); } };
         node.BranchValueRequested = (itemId, field, value) => EditBranch(() => _graphAuthoring.SetBranchValue(node.Id, itemId, field, value));
     }
 
diff --git a/src/Editor/GalNet.Editor/ViewModels/ExportPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/ExportPanelViewModel.cs
index 7dc58232..8a284cc9 100644
--- a/src/Editor/GalNet.Editor/ViewModels/ExportPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/ExportPanelViewModel.cs
@@ -1,4 +1,4 @@
-using System;
+using System.Diagnostics;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -6,24 +6,205 @@
 using CommunityToolkit.Mvvm.Input;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Services.Interfaces;
+
 namespace GalNet.Editor.ViewModels;
 
 public sealed partial class ExportPanelViewModel : ObservableObject
 {
-    private readonly IProjectService _projects; private readonly IFileDialogService _dialogs; private readonly IGameExportService _exporter;
+    private readonly IProjectService _projects;
+    private readonly IFileDialogService _dialogs;
+    private readonly IGameExportService _exporter;
+    private readonly string? _repositoryRoot;
+
     public IEditorLocalizationService L { get; }
-    [ObservableProperty] private string _outputDirectory = ""; [ObservableProperty] private bool _isExporting;
-    public string PackageName => $"{_projects.Current?.Name ?? "game"}.galpak"; public string PackagePath => Path.Combine(OutputDirectory, PackageName);
-    public ExportPanelViewModel(IProjectService projects, IFileDialogService dialogs, IGameExportService exporter, IEditorLocalizationService localization) { _projects = projects; _dialogs = dialogs; _exporter = exporter; L = localization; OutputDirectory = projects.Current?.OutputPath ?? ""; }
-    [RelayCommand] private async Task BrowseAsync() { var path = await _dialogs.OpenFolderPickerAsync(L["Export.SelectDirectory"]); if (!string.IsNullOrWhiteSpace(path)) OutputDirectory = path; }
+    public IReadOnlyList<ExportModeOption> Modes { get; }
+
+    [ObservableProperty] private string _outputDirectory = "";
+    [ObservableProperty] private string _releaseOutputRoot = "";
+    [ObservableProperty] private string _releaseVersion = "0.1.0-dev";
+    [ObservableProperty] private string _galpakPath = "";
+    [ObservableProperty] private bool _isExporting;
+    [ObservableProperty] private ExportModeOption _selectedMode;
+
+    public string PackageName => $"{_projects.Current?.Name ?? "game"}.galpak";
+    public string PackagePath => IsPackageMode ? Path.Combine(OutputDirectory, PackageName) : ReleasePackagePath;
+    public string ReleasePackagePath
+    {
+        get
+        {
+            var prefix = SelectedMode.Key switch
+            {
+                "editor" => "GalNet-Editor",
+                "sample" => "GalNet-Sample",
+                "sample-integrated" => "GalNet-Sample-GameTestCase",
+                _ => "GalNet-Package"
+            };
+            return Path.Combine(ReleaseOutputRoot, ReleaseVersion, $"{prefix}-{ReleaseVersion}-win-x64.zip");
+        }
+    }
+
+    public bool IsPackageMode => SelectedMode.Key == "package";
+    public bool IsReleaseMode => !IsPackageMode;
+    public bool IsIntegratedSample => SelectedMode.Key == "sample-integrated";
+
+    public ExportPanelViewModel(IProjectService projects, IFileDialogService dialogs, IGameExportService exporter, IEditorLocalizationService localization)
+    {
+        _projects = projects;
+        _dialogs = dialogs;
+        _exporter = exporter;
+        L = localization;
+        _repositoryRoot = FindRepositoryRoot(projects.Current?.RootPath);
+        OutputDirectory = projects.Current?.OutputPath ?? "";
+        ReleaseOutputRoot = _repositoryRoot is null ? "" : Path.Combine(_repositoryRoot, "out", "release");
+        Modes =
+        [
+            new("package", L["Export.Mode.Galpak"]),
+            new("editor", L["Export.Mode.Editor"]),
+            new("sample", L["Export.Mode.Sample"]),
+            new("sample-integrated", L["Export.Mode.IntegratedSample"])
+        ];
+        _selectedMode = Modes[0];
+    }
+
+    [RelayCommand]
+    private async Task BrowseAsync()
+    {
+        var path = await _dialogs.OpenFolderPickerAsync(L["Export.SelectDirectory"]);
+        if (string.IsNullOrWhiteSpace(path)) return;
+        if (IsPackageMode) OutputDirectory = path;
+        else ReleaseOutputRoot = path;
+    }
+
+    [RelayCommand]
+    private async Task BrowseGalpakAsync()
+    {
+        var paths = await _dialogs.OpenFilePickerAsync(L["Export.SelectGalpak"], allowMultiple: false);
+        if (paths.Count > 0 && Path.GetExtension(paths[0]).Equals(".galpak", StringComparison.OrdinalIgnoreCase))
+            GalpakPath = paths[0];
+    }
+
     public async Task<GameExportResult> ExportAsync(CancellationToken cancellationToken)
     {
-        if (!CanExport()) return GameExportResult.Failed(L["Export.Unavailable"]);
+        if (IsPackageMode)
+        {
+            if (!CanExportPackage()) return GameExportResult.Failed(L["Export.Unavailable"]);
+            IsExporting = true;
+            try { return await _exporter.ExportAsync(OutputDirectory, cancellationToken); }
+            catch (Exception ex) { return GameExportResult.Failed(ex.Message); }
+            finally { IsExporting = false; }
+        }
+
+        if (!CanPublish()) return GameExportResult.Failed(L["Export.ReleaseUnavailable"]);
         IsExporting = true;
-        try { return await _exporter.ExportAsync(OutputDirectory, cancellationToken); }
+        try { return await PublishAsync(cancellationToken); }
+        catch (OperationCanceledException) { return GameExportResult.Failed("Release packaging canceled."); }
         catch (Exception ex) { return GameExportResult.Failed(ex.Message); }
         finally { IsExporting = false; }
     }
-    private bool CanExport() => !IsExporting && !string.IsNullOrWhiteSpace(OutputDirectory) && _projects.Current is not null;
+
+    private async Task<GameExportResult> PublishAsync(CancellationToken cancellationToken)
+    {
+        var script = Path.Combine(_repositoryRoot!, "scripts", "release", "Publish.ps1");
+        using var process = new Process
+        {
+            StartInfo = new ProcessStartInfo("powershell.exe")
+            {
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true
+            },
+            EnableRaisingEvents = true
+        };
+        foreach (var argument in new[]
+                 {
+                     "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", script,
+                     "-Package", SelectedMode.Key switch
+                     {
+                         "editor" => "Editor",
+                         "sample" => "Sample",
+                         "sample-integrated" => "SampleIntegrated",
+                         _ => throw new InvalidOperationException("Unsupported release package type.")
+                     },
+                     "-Version", ReleaseVersion,
+                     "-OutputRoot", ReleaseOutputRoot
+                 })
+            process.StartInfo.ArgumentList.Add(argument);
+
+        if (IsIntegratedSample)
+        {
+            if (string.IsNullOrWhiteSpace(GalpakPath))
+            {
+                process.StartInfo.ArgumentList.Add("-ProjectDirectory");
+                process.StartInfo.ArgumentList.Add(_projects.Current!.RootPath);
+            }
+            else
+            {
+                process.StartInfo.ArgumentList.Add("-Galpak");
+                process.StartInfo.ArgumentList.Add(GalpakPath);
+            }
+        }
+
+        process.Start();
+        using var registration = cancellationToken.Register(() =>
+        {
+            try { if (!process.HasExited) process.Kill(entireProcessTree: true); }
+            catch (InvalidOperationException) { }
+        });
+        var stdoutTask = process.StandardOutput.ReadToEndAsync(cancellationToken);
+        var stderrTask = process.StandardError.ReadToEndAsync(cancellationToken);
+        await process.WaitForExitAsync(cancellationToken);
+        var output = await stdoutTask;
+        var error = await stderrTask;
+        if (process.ExitCode != 0)
+        {
+            var details = string.Join(Environment.NewLine, new[] { output.Trim(), error.Trim() }.Where(value => value.Length > 0));
+            return GameExportResult.Failed(string.IsNullOrWhiteSpace(details) ? $"Publish script failed with exit code {process.ExitCode}." : details);
+        }
+        return GameExportResult.Succeeded(ReleasePackagePath);
+    }
+
+    private bool CanExportPackage() => !IsExporting && !string.IsNullOrWhiteSpace(OutputDirectory) && _projects.Current is not null;
+
+    private bool CanPublish() => !IsExporting && _projects.Current is not null && _repositoryRoot is not null &&
+        File.Exists(Path.Combine(_repositoryRoot, "scripts", "release", "Publish.ps1")) &&
+        !string.IsNullOrWhiteSpace(ReleaseOutputRoot) && !string.IsNullOrWhiteSpace(ReleaseVersion) &&
+        (!IsIntegratedSample || string.IsNullOrWhiteSpace(GalpakPath) || File.Exists(GalpakPath));
+
+    private static string? FindRepositoryRoot(string? startPath)
+    {
+        if (string.IsNullOrWhiteSpace(startPath)) return null;
+        var current = new DirectoryInfo(Path.GetFullPath(startPath));
+        while (current is not null)
+        {
+            if (File.Exists(Path.Combine(current.FullName, "scripts", "release", "Publish.ps1"))) return current.FullName;
+            current = current.Parent;
+        }
+        return null;
+    }
+
     partial void OnOutputDirectoryChanged(string value) => OnPropertyChanged(nameof(PackagePath));
+    partial void OnReleaseOutputRootChanged(string value)
+    {
+        OnPropertyChanged(nameof(ReleasePackagePath));
+        OnPropertyChanged(nameof(PackagePath));
+    }
+    partial void OnReleaseVersionChanged(string value)
+    {
+        OnPropertyChanged(nameof(ReleasePackagePath));
+        OnPropertyChanged(nameof(PackagePath));
+    }
+    partial void OnGalpakPathChanged(string value) => OnPropertyChanged(nameof(IsIntegratedSample));
+    partial void OnSelectedModeChanged(ExportModeOption value)
+    {
+        OnPropertyChanged(nameof(IsPackageMode));
+        OnPropertyChanged(nameof(IsReleaseMode));
+        OnPropertyChanged(nameof(IsIntegratedSample));
+        OnPropertyChanged(nameof(PackagePath));
+    }
+}
+
+public sealed record ExportModeOption(string Key, string Label)
+{
+    public override string ToString() => Label;
 }
diff --git a/src/Editor/GalNet.Editor/ViewModels/ExternalDebugPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/ExternalDebugPanelViewModel.cs
index 51cef6d3..1cbaf1ec 100644
--- a/src/Editor/GalNet.Editor/ViewModels/ExternalDebugPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/ExternalDebugPanelViewModel.cs
@@ -19,7 +19,9 @@
 using GalNet.Core.Serialization;
 using GalNet.Core.Variable;
 using GalNet.Debugging;
+using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
 using GalNet.Editor.Models.Graph;
 using GalNet.Editor.Shared.Services;
 using GalNet.Runtime.Engine;
@@ -33,8 +35,9 @@ public partial class ExternalDebugPanelViewModel : ObservableObject
     private readonly ExternalGameDebugClient _client;
     private readonly IProjectService _projects;
     private readonly IEditorDocumentService _documents;
-    private readonly IEntryCatalog _catalog;
+    private readonly ProjectDebugPreparation _preparation;
     private readonly EditorWorkspaceViewModel _workspace;
+    private readonly AuthorChangeJournal _authorChanges;
     private readonly IFileDialogService _files;
     private readonly Dictionary<(string Group, string Primitive), string> _sources = [];
     private readonly Dictionary<(string Group, string Source), int> _positions = [];
@@ -60,8 +63,10 @@ public partial class ExternalDebugPanelViewModel : ObservableObject
     partial void OnErrorChanged(string value)
     {
         OnPropertyChanged(nameof(HasError));
-        if (!string.IsNullOrWhiteSpace(value) && !_closed)
-            _projects.Current?.Services.GetService<ProblemsPanelViewModel>()?.Report("error", value, "Debug");
+        if (_closed) return;
+        var problems = _projects.Current?.Services.GetService<ProblemsPanelViewModel>();
+        problems?.ClearReports("Debug");
+        if (!string.IsNullOrWhiteSpace(value)) problems?.Report("error", value, "Debug");
     }
     [ObservableProperty] private bool _busy;
     [ObservableProperty] private bool _contentChanged;
@@ -79,9 +84,9 @@ partial void OnErrorChanged(string value)
     public GameDebugState? RuntimeState => _client.State;
 
     public ExternalDebugPanelViewModel(ExternalGameDebugClient client, IProjectService projects, IEditorDocumentService documents,
-        IEntryCatalog catalog, EditorWorkspaceViewModel workspace, IFileDialogService files, IEditorLocalizationService localization)
+        ProjectDebugPreparation preparation, EditorWorkspaceViewModel workspace, IFileDialogService files, IEditorLocalizationService localization, EditorHistories histories)
     {
-        _client = client; _projects = projects; _documents = documents; _catalog = catalog; _workspace = workspace; _files = files; L = localization;
+        _client = client; _projects = projects; _documents = documents; _preparation = preparation; _workspace = workspace; _files = files; L = localization;
         if (projects.Current is { } project)
         {
             try
@@ -92,6 +97,8 @@ public ExternalDebugPanelViewModel(ExternalGameDebugClient client, IProjectServi
             catch (Exception error) when (error is IOException or JsonException or UnauthorizedAccessException) { Error = error.Message; }
             _closing = project.RegisterClosingCallback(CloseProjectAsync);
         }
+        _authorChanges = histories.Content.AuthorChanges;
+        _authorChanges.Committed += OnAuthorCommitted;
         _client.Changed += OnClientChanged;
         _documents.DocumentChanged += OnAuthorChanged;
         Refresh();
@@ -115,6 +122,7 @@ private void OnClientChanged() => Dispatcher.UIThread.Post(() =>
         Refresh();
         if (Busy && _operationStatus is { } operationStatus) Status = operationStatus;
     });
+    private void OnAuthorCommitted(AuthorChangeSet _) => OnAuthorChanged();
     private void OnAuthorChanged()
     {
         if (_authorSignature is not null) ContentChanged = Signature() != _authorSignature;
@@ -239,63 +247,20 @@ private Task WaitForApplicationAsync() => RunAsync(async () =>
     });
     private async Task<string> PrepareAsync()
     {
-        await _client.DisconnectAsync();
-        var project = _projects.Current ?? throw new InvalidOperationException("No project.");
-        var profileRoot = Path.Combine(project.RootPath, ".galnet", "debug-profile");
-        _client.BeginDiagnostics(profileRoot);
-        var preparation = Stopwatch.StartNew();
-        SetOperationStatus(L["Debug.SavingProject"]);
-        _client.RecordDiagnostic("Saving project changes before building test content.");
-        await _projects.SaveAsync();
-        _client.RecordDiagnostic($"Project save completed in {preparation.ElapsedMilliseconds} ms.");
-        preparation.Restart();
-        var output = Path.Combine(project.RootPath, "Output", "Debug");
-        SetOperationStatus(L["Debug.BuildingContent"]);
-        _client.RecordDiagnostic($"Building test content at {output}.");
-        var builder = new ProjectContentBuilder(_catalog);
-        // BuildAsync performs substantial synchronous validation before its first await.
-        // Keep that CPU and filesystem work off Avalonia's UI thread.
-        await Task.Run(() => builder.BuildAsync(project.RootPath, output));
-        _client.RecordDiagnostic($"Test content build completed in {preparation.ElapsedMilliseconds} ms.");
-        preparation.Restart();
-        SetOperationStatus(L["Debug.PreparingSourceMap"]);
-        var authorGroups = _documents.Groups.Values
-            .Select(group => (Id: group.Id, Entries: group.Entries.ToArray()))
-            .ToArray();
-        var sourceMap = await Task.Run(() =>
-        {
-            var sources = new Dictionary<(string Group, string Primitive), string>();
-            var positions = new Dictionary<(string Group, string Source), int>();
-            var spans = new Dictionary<(string Group, string Source), GameDebugSpan>();
-            var repository = new EditorDocumentRepository(_catalog);
-            foreach (var group in authorGroups)
-            {
-                var result = GalgroupCompiler.Compile(new GroupDocument { Kind = GroupDocumentKind.Raw, Entries = group.Entries.Select(repository.SerializeEntry).ToList() }, _catalog);
-                var offset = 0;
-                foreach (var entry in group.Entries)
-                {
-                    positions[(group.Id, entry.StableId)] = offset;
-                    foreach (var primitive in result.SourceMap[entry.StableId]) { sources[(group.Id, primitive)] = entry.StableId; offset++; }
-                    spans[(group.Id, entry.StableId)] = new(group.Id, positions[(group.Id, entry.StableId)], offset);
-                }
-            }
-            return (sources, positions, spans);
-        });
+        var result = await _preparation.PrepareAsync(key => SetOperationStatus(L[key]));
+        if (_closed) throw new OperationCanceledException("The debug project was closed.");
         _sources.Clear(); _positions.Clear(); _spans.Clear(); _breakpointRun = null;
-        foreach (var pair in sourceMap.sources) _sources.Add(pair.Key, pair.Value);
-        foreach (var pair in sourceMap.positions) _positions.Add(pair.Key, pair.Value);
-        foreach (var pair in sourceMap.spans) _spans.Add(pair.Key, pair.Value);
-        _client.RecordDiagnostic($"Author source map prepared in {preparation.ElapsedMilliseconds} ms for {authorGroups.Length} Group(s).");
-        _authorSignature = Signature(); ContentChanged = false;
-        var identity = new DebugIdentity(project.Id, DebugContentIdentity.Compute(output), project.Services.GetRequiredService<ProjectSchemaSession>().Context.Fingerprint);
-        _client.Listen(identity);
-        return output;
+        foreach (var entry in result.SourceEntries)
+        {
+            _positions[(entry.GroupId, entry.EntryId)] = entry.Start;
+            _spans[(entry.GroupId, entry.EntryId)] = new(entry.GroupId, entry.Start, entry.End);
+            foreach (var primitive in entry.PrimitiveIds) _sources[(entry.GroupId, primitive)] = entry.EntryId;
+        }
+        _authorSignature = result.AuthorSignature;
+        ContentChanged = Signature() != _authorSignature;
+        return result.OutputPath;
     }
-    private string Signature() => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new
-    {
-        Graph = _documents.CurrentDocument,
-        Groups = _documents.Groups.Select(pair => new { pair.Key, Entries = pair.Value.Entries.Select(entry => new { entry.StableId, entry.Type, entry.Condition, entry.Parameters }) }).ToArray()
-    }))));
+    private string Signature() => ProjectAuthorIdentity.Compute(_documents.CurrentDocument, _documents.LoadedProject.GroupEntries);
     [RelayCommand] private Task StartGameAsync() => CommandAsync("start");
     [RelayCommand] private Task StopGameAsync() => CommandAsync("stop");
     [RelayCommand] private Task PauseAsync() => CommandAsync("pause");
@@ -390,7 +355,7 @@ public Task SeekAsync(string group, string? sourceEntry = null, bool initialScen
     }
     private async Task CloseProjectAsync()
     {
-        _closed = true; _client.Changed -= OnClientChanged; _documents.DocumentChanged -= OnAuthorChanged;
+        _closed = true; _client.Changed -= OnClientChanged; _documents.DocumentChanged -= OnAuthorChanged; _authorChanges.Committed -= OnAuthorCommitted;
         foreach (var row in PlayerVariables.Concat(SaveVariables)) row.Invalidate();
         await _client.DisconnectAsync(); _closing?.Dispose();
     }
diff --git a/src/Editor/GalNet.Editor/ViewModels/GameLocalizationPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/GameLocalizationPanelViewModel.cs
index 1d665b62..3c6fe629 100644
--- a/src/Editor/GalNet.Editor/ViewModels/GameLocalizationPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/GameLocalizationPanelViewModel.cs
@@ -1,6 +1,6 @@
 using System.Collections.ObjectModel;
 using System.ComponentModel;
-using System.Text.Json.Nodes;
+using System.Globalization;
 using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
@@ -11,9 +11,26 @@
 
 namespace GalNet.Editor.ViewModels;
 
-public sealed record LocalizationGridRow(LocalizationTableRow Source, IReadOnlyList<LocalizationGridCell> Cells)
+public sealed class LocalizationGridRow(LocalizationTableRow source, IReadOnlyList<LocalizationGridCell> cells) : ObservableObject
 {
+    public LocalizationTableRow Source { get; private set; } = source;
+    public IReadOnlyList<LocalizationGridCell> Cells { get; } = cells;
     public string Context => Source.Context;
+    public string Title => Source.Locations.FirstOrDefault()?.Title ?? "";
+    public string Slot => Source.Locations.FirstOrDefault()?.Slot ?? "";
+    public string Details => string.Join("\n", Source.Locations.Select(location => location.DisplayDetails));
+    public string ReferenceCount => Source.References.Count > 1 ? "×" + Source.References.Count : "";
+    public void Update(LocalizationTableRow value)
+    {
+        Source = value;
+        OnPropertyChanged(nameof(Title)); OnPropertyChanged(nameof(Slot));
+        OnPropertyChanged(nameof(Details)); OnPropertyChanged(nameof(ReferenceCount));
+    }
+}
+
+public sealed record LocalizationLanguageSuggestion(string Code, string NativeName)
+{
+    public string DisplayText => $"{Code} — {NativeName}";
 }
 
 public sealed partial class LocalizationImportRowViewModel : ObservableObject
@@ -28,7 +45,7 @@ public sealed partial class LocalizationImportRowViewModel : ObservableObject
     public LocalizationImportRowViewModel(LocalizationImportCandidate candidate, IEditorLocalizationService text)
     {
         Candidate = candidate; Source = candidate.CurrentSource ?? candidate.Row.SourceText ?? text["I18n.Missing"];
-        Status = text[!candidate.Known ? "Exchange.Unknown" : candidate.Row.Translation is null ? "Exchange.Skip" : candidate.Row.Translation.Length == 0 ? "Exchange.Clear" : candidate.SourceChanged ? "I18n.Review" : candidate.Target?.Text == candidate.Row.Translation ? "Exchange.Unchanged" : "Exchange.Change"];
+        Status = text[!candidate.Known ? "Exchange.Unknown" : candidate.Row.Translation is null ? "Exchange.Skip" : candidate.Row.Translation.Length == 0 ? "Exchange.Clear" : candidate.SourceChanged ? "Uiux.I18n.SourceChanged" : candidate.Target?.Text == candidate.Row.Translation ? "Exchange.Unchanged" : "Exchange.Change"];
         Include = CanInclude && candidate.Row.Translation!.Length > 0 && (candidate.SourceChanged || candidate.Target?.Text != candidate.Row.Translation);
     }
 }
@@ -36,74 +53,115 @@ public LocalizationImportRowViewModel(LocalizationImportCandidate candidate, IEd
 public sealed partial class LocalizationGridCell : ObservableObject
 {
     private readonly GameLocalizationPanelViewModel _panel;
-    private LocalizationCellDraft? _draft;
+    private LocalizationCellDraft? _target;
     private bool _loading;
     private string? _value;
     private bool _pending;
-    private string _sourceLocale = "";
-    private string? _sourceText;
-    private string? _baselineValue;
-    private string _baselineLocale = "";
-    private string? _baselineSource;
+    private Task? _write;
+    private Exception? _writeError;
+    private string _submittingText = "";
     public string Category { get; }
     public string Key { get; }
     public string Culture { get; }
     [ObservableProperty] private string _text = "";
-    [ObservableProperty] private string _status = "";
     [ObservableProperty] private string _message = "";
+    public bool HasMessage => Message.Length > 0;
+    partial void OnMessageChanged(string value) => OnPropertyChanged(nameof(HasMessage));
     [ObservableProperty] private bool _busy;
     public bool IsDirty => _pending;
-    public bool Enabled => !_panel.IsDisposed;
+    public bool IsMissing { get; private set; }
+    public string DisplayText => IsMissing && Text.Length == 0 ? _panel.Service.Text["I18n.Missing"] : Text;
+    public double Width => _panel.ColumnWidth(Culture);
+    public void WidthChanged() => OnPropertyChanged(nameof(Width));
+    public bool Enabled => !_panel.IsDisposed && _panel.Languages.Contains(Culture);
     public LocalizationGridCell(GameLocalizationPanelViewModel panel, string category, string key, string culture)
     { _panel = panel; Category = category; Key = key; Culture = culture; }
-    partial void OnBusyChanged(bool value) => OnPropertyChanged(nameof(Enabled));
     partial void OnTextChanged(string value)
     {
+        OnPropertyChanged(nameof(DisplayText));
         if (_loading) return;
-        if (!IsDirty)
+        if (!_pending)
         {
-            _pending = true; _baselineValue = _value; _baselineLocale = _sourceLocale; _baselineSource = _sourceText;
-            try { _draft = _panel.Service.Capture(Category, Key, Culture); }
-            catch (Exception error) { Message = EditorText.Error(error).Render(_panel.Service.Text); return; }
+            if (_value == value) return;
+            _pending = true;
+            try { _target = _panel.Service.Capture(Category, Key, Culture); }
+            catch (Exception error) { SetError(error); _panel.DraftChanged(); return; }
+            _panel.DraftChanged();
+        }
+        else if (!Busy && value == _value)
+        {
+            _pending = false; _target = null; _writeError = null; Message = "";
             _panel.DraftChanged();
         }
-        if (_baselineValue is not null && value == _baselineValue) { _pending = false; _draft = null; Message = ""; _panel.DraftChanged(); }
     }
-    public void Refresh(LocalizationTableSnapshot snapshot, JsonObject? revision)
+    public void Refresh(LocalizationTableSnapshot snapshot)
     {
         _value = snapshot.Index.FindDirect(Culture, Key)?.Text;
-        _sourceLocale = snapshot.Source; _sourceText = snapshot.Index.FindDirect(snapshot.Source, Key)?.Text;
-        var state = _value is null ? "Missing" : _value.Length == 0 ? "Empty" : "";
-        var review = _value is null || Culture == snapshot.Source ? "" : LocalizationTextState.NeedsReview(revision, Culture, snapshot.Source)
-            switch
-        { true => "Review", false => "", null => "Unknown" };
-        Status = string.Join(" · ", new[] { state, review }.Where(value => value.Length > 0).Select(value => _panel.Service.Text["I18n." + value]));
+        IsMissing = _value is null;
+        OnPropertyChanged(nameof(DisplayText)); OnPropertyChanged(nameof(IsMissing)); OnPropertyChanged(nameof(Enabled));
         if (!IsDirty)
         {
             _loading = true;
             try { Text = _value ?? ""; } finally { _loading = false; }
         }
     }
-    public async Task CommitAsync(bool explicitValue = false)
+    private void SetError(Exception error)
+    { _writeError = error; Message = EditorText.Error(error).Render(_panel.Service.Text); }
+    private async Task WriteAsync()
     {
-        if (Busy || _panel.IsDisposed || !IsDirty && !explicitValue) return;
-        Busy = true; Message = "";
+        var value = Text; var captured = _target;
+        _submittingText = value;
+        Busy = true; Message = ""; _writeError = null;
+        // Publish the task before beginning work: Save All and a second input can join it.
+        await Task.Yield();
         try
         {
-            if (!IsDirty) { _pending = true; _baselineValue = _value; _baselineLocale = _sourceLocale; _baselineSource = _sourceText; }
-            _draft ??= _panel.Service.Capture(Category, Key, Culture);
-            if (_draft.Target.Text != _baselineValue || _draft.SourceLocale != _baselineLocale || _draft.SourceText != _baselineSource)
-                throw new GalNet.Editor.Abstraction.Services.EditorOperationException("i18n.stale", _panel.Service.Text["I18n.Stale"]);
-            await _panel.Service.SetAsync(_draft, Text);
-            _pending = false; _draft = null;
+            if (_pending && !_panel.IsDisposed)
+            {
+                var target = captured ?? throw new EditorOperationException("i18n.stale", _panel.Service.Text["I18n.Stale"]);
+                await _panel.WriteCellAsync(target, value);
+                _value = value;
+                if (Text == value) { _pending = false; _target = null; }
+                else
+                {
+                    var next = _panel.Service.Capture(Category, Key, Culture);
+                    // Source editing advances its own baseline. A translation must keep its original source.
+                    if (Culture != target.SourceLocale && (next.SourceLocale != target.SourceLocale || next.SourceText != target.SourceText))
+                        throw new EditorOperationException("i18n.stale", _panel.Service.Text["I18n.Stale"]);
+                    _target = next;
+                }
+            }
+        }
+        catch (Exception error) { SetError(error); }
+        finally { Busy = false; _panel.Refresh(); _panel.DraftChanged(); }
+    }
+    public async Task CommitAsync(bool explicitValue = false)
+    {
+        if (_panel.IsDisposed) return;
+        if (Busy && _write is { } inFlight) await inFlight;
+        if (_panel.IsDisposed) return;
+        if (!Busy && explicitValue && !_pending && IsMissing)
+        { _pending = true; _target = _panel.Service.Capture(Category, Key, Culture); }
+        if (!Busy && _pending) _write = WriteAsync();
+        if (_write is { } write) await write;
+        if (_writeError is { } error) throw error;
+    }
+    // Uncommitted input can be discarded; successful updates use project undo.
+    public void Revert()
+    {
+        if (Busy)
+        {
+            _loading = true;
+            try { Text = _submittingText; }
+            finally { _loading = false; }
+            return;
         }
-        catch (Exception error) { Message = EditorText.Error(error).Render(_panel.Service.Text); throw; }
-        finally { Busy = false; _panel.Refresh(); }
+        _pending = false; _target = null; _writeError = null; Message = "";
+        _panel.Refresh(); _panel.DraftChanged();
     }
-    public void Revert() { _pending = false; _draft = null; Message = ""; _panel.Refresh(); _panel.DraftChanged(); }
 }
 
-/// <summary>Project-scoped to retain cell drafts when the dock view closes or categories change.</summary>
+/// <summary>Project-scoped resource table and view preferences; text commits on blur or explicit save.</summary>
 public sealed partial class GameLocalizationPanelViewModel : ObservableObject, IUndoRedoTarget, IDisposable
 {
     public GameLocalizationPanelService Service { get; }
@@ -111,9 +169,56 @@ public sealed partial class GameLocalizationPanelViewModel : ObservableObject, I
     public ObservableCollection<LocalizationCategory> Categories { get; } = [];
     public ObservableCollection<string> Languages { get; } = [];
     public ObservableCollection<LocalizationGridRow> Rows { get; } = [];
+    private LocalizationGridRow[] _allRows = [];
+    [ObservableProperty] private string _search = "";
+    [ObservableProperty] private bool _onlyMissing;
+    private readonly HashSet<string> _hiddenLanguages = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, double> _columnWidths = new(StringComparer.OrdinalIgnoreCase);
+    private readonly SemaphoreSlim _writes = new(1, 1);
+    public IReadOnlyList<string> VisibleLanguages => Languages.Where(IsLanguageVisible).ToArray();
+    public bool IsLanguageVisible(string code) => code == Languages.FirstOrDefault() || !_hiddenLanguages.Contains(code);
+    public double ColumnWidth(string code) => _columnWidths.GetValueOrDefault(code, 244);
+    public void SetColumnWidth(string code, double width)
+    {
+        _columnWidths[code] = Math.Clamp(width, 140, 720);
+        foreach (var cell in _cells.Values.Where(cell => cell.Culture == code)) cell.WidthChanged();
+    }
+    public void SetLanguageVisible(string code, bool visible)
+    {
+        if (code == Languages.FirstOrDefault()) return;
+        if (visible) _hiddenLanguages.Remove(code); else _hiddenLanguages.Add(code);
+        Refresh(); StructureChanged?.Invoke();
+    }
+    public async Task WriteCellAsync(LocalizationCellDraft target, string value)
+    {
+        await _writes.WaitAsync();
+        try { if (!IsDisposed) await Service.SetAsync(target, value); }
+        finally { _writes.Release(); }
+    }
+    public IReadOnlyList<string> LanguageSuggestions { get; private set; } = [];
+    public IReadOnlyList<LocalizationLanguageSuggestion> LanguageOptions { get; private set; } = [];
+    partial void OnNewLanguageChanged(string value) => UpdateLanguageSuggestions();
+    private void UpdateLanguageSuggestions()
+    {
+        LanguageOptions = CultureInfo.GetCultures(CultureTypes.NeutralCultures | CultureTypes.SpecificCultures)
+            .Where(culture => culture.Name.Length > 0 && !Languages.Contains(culture.Name, StringComparer.OrdinalIgnoreCase))
+            .Where(culture => string.IsNullOrWhiteSpace(NewLanguage) || new[] { culture.Name, culture.NativeName, culture.EnglishName }
+                .Any(name => name.Contains(NewLanguage.Trim().Replace('_', '-'), StringComparison.OrdinalIgnoreCase)))
+            .OrderBy(culture => culture.Name is "en-US" or "zh-CN" or "ja-JP" or "ko-KR" ? 0 : 1)
+            .ThenBy(culture => culture.Name, StringComparer.OrdinalIgnoreCase)
+            .Select(culture => new LocalizationLanguageSuggestion(culture.Name, culture.NativeName)).ToArray();
+        // Keep the display-only list for existing callers; UI selection binds to LanguageOptions.Code.
+        LanguageSuggestions = LanguageOptions.Select(option => option.DisplayText).ToArray();
+        OnPropertyChanged(nameof(LanguageOptions));
+        OnPropertyChanged(nameof(LanguageSuggestions));
+    }
+    public bool HasRows => Rows.Count > 0;
+    partial void OnSearchChanged(string value) => ProjectRows();
+    partial void OnOnlyMissingChanged(bool value) => ProjectRows();
     private readonly Dictionary<(string Category, string Key, string Culture), LocalizationGridCell> _cells = [];
     private readonly IDisposable _draftRegistration;
     private bool _refreshing;
+    private bool _notifyingDraft;
     public bool IsDisposed { get; private set; }
     public event Action? StructureChanged;
     private readonly LocalizationExchangeService _exchange;
@@ -139,7 +244,8 @@ public GameLocalizationPanelViewModel(GameLocalizationPanelService service, Edit
     {
         _exchange = exchange; _dialogs = dialogs;
         Service = service; UndoRedoHistory = histories.Content;
-        _draftRegistration = service.Content.RegisterDraft(() => _cells.Values.Any(cell => cell.IsDirty), CommitDraftsAsync);
+        _draftRegistration = service.Content.RegisterDraft(() => _cells.Values.Any(cell => cell.IsDirty), CommitDraftsAsync,
+            () => { foreach (var cell in _cells.Values.Where(cell => cell.IsDirty).ToArray()) cell.Revert(); });
         service.Content.Changed += ContentChanged; service.Text.PropertyChanged += LocaleChanged;
         Refresh();
     }
@@ -176,13 +282,20 @@ private Task ApplyImportAsync() => RunAsync(async () =>
     partial void OnSelectedChanged(LocalizationCategory? value) { if (!_refreshing) Refresh(); }
     partial void OnDevelopmentLanguageChanged(string? value) { _preview = null; PreviewMessage = ""; OnPropertyChanged(nameof(CanChangeDevelopmentLanguage)); }
     private void ContentChanged()
-    { if (Dispatcher.UIThread.CheckAccess()) Refresh(); else Dispatcher.UIThread.Post(Refresh); }
+    { if (_notifyingDraft) return; if (Dispatcher.UIThread.CheckAccess()) Refresh(); else Dispatcher.UIThread.Post(Refresh); }
     private void LocaleChanged(object? sender, PropertyChangedEventArgs args)
     {
         void Update() { Refresh(); if (!IsDisposed) StructureChanged?.Invoke(); }
         if (Dispatcher.UIThread.CheckAccess()) Update(); else Dispatcher.UIThread.Post(Update);
     }
-    public void DraftChanged() { if (!_refreshing && !IsDisposed) Service.Content.Refresh(); }
+    public void DraftChanged()
+    {
+        if (_refreshing || IsDisposed) return;
+        // Notify project dirty/save state without rebuilding this table for local input.
+        _notifyingDraft = true;
+        try { Service.Content.Refresh(); }
+        finally { _notifyingDraft = false; }
+    }
     public void Refresh()
     {
         if (_refreshing || IsDisposed) return;
@@ -198,22 +311,37 @@ public void Refresh()
             }
             if (Selected?.Id != category) snapshot = Service.Snapshot(Selected!.Id);
             var changed = !Languages.SequenceEqual(snapshot.Languages);
-            if (changed) { Languages.Clear(); foreach (var language in snapshot.Languages) Languages.Add(language); }
+            if (changed)
+            {
+                Languages.Clear(); foreach (var language in snapshot.Languages) Languages.Add(language);
+                CancelImport(); DevelopmentLanguage = null; UpdateLanguageSuggestions();
+            }
             if (ExchangeLanguage is null || !Languages.Contains(ExchangeLanguage)) ExchangeLanguage = Languages.FirstOrDefault(language => language != snapshot.Source) ?? snapshot.Source;
-            var states = JsonNode.Parse(LocalizationJson.Decode(snapshot.Metadata))?["textStates"];
-            var rows = snapshot.Rows.Select(row => new LocalizationGridRow(row, snapshot.Languages.Select(culture =>
+            var rows = snapshot.Rows.Select(row => new LocalizationGridRow(row, VisibleLanguages.Select(culture =>
             {
                 var identity = (Selected!.Id, row.Key, culture);
                 if (!_cells.TryGetValue(identity, out var cell)) _cells.Add(identity, cell = new(this, identity.Id, row.Key, culture));
-                cell.Refresh(snapshot, states?[row.Key] as JsonObject); return cell;
+                cell.Refresh(snapshot); return cell;
             }).ToArray())).ToArray();
-            if (changed || Rows.Count != rows.Length || !Rows.Zip(rows).All(pair => pair.First.Context == pair.Second.Context && pair.First.Cells.SequenceEqual(pair.Second.Cells)))
-            { Rows.Clear(); foreach (var row in rows) Rows.Add(row); }
+            var previousRows = _allRows.ToDictionary(row => row.Source.Key, StringComparer.Ordinal);
+            _allRows = rows.Select(row =>
+            {
+                if (!previousRows.TryGetValue(row.Source.Key, out var existing) || !existing.Cells.SequenceEqual(row.Cells)) return row;
+                existing.Update(row.Source); return existing;
+            }).ToArray(); ProjectRows();
             if (changed) StructureChanged?.Invoke();
         }
         catch (Exception error) { Message = EditorText.Error(error).Render(Service.Text); }
         finally { _refreshing = false; }
     }
+    private void ProjectRows()
+    {
+        var rows = _allRows.Where(row => (string.IsNullOrWhiteSpace(Search) || row.Context.Contains(Search, StringComparison.OrdinalIgnoreCase) || row.Cells.Any(cell => cell.Text.Contains(Search, StringComparison.OrdinalIgnoreCase)))
+            && (!OnlyMissing || row.Cells.Any(cell => cell.Culture != Languages[0] && cell.IsMissing))).ToArray();
+        if (Rows.Count != rows.Length || !Rows.Zip(rows).All(pair => pair.First.Context == pair.Second.Context && pair.First.Cells.SequenceEqual(pair.Second.Cells)))
+        { Rows.Clear(); foreach (var row in rows) Rows.Add(row); }
+        OnPropertyChanged(nameof(HasRows));
+    }
     public async Task CommitDraftsAsync()
     {
         foreach (var cell in _cells.Values.Where(cell => cell.IsDirty).ToArray()) await cell.CommitAsync();
@@ -225,7 +353,21 @@ public async Task RunAsync(Func<Task> action)
         catch (Exception error) { Message = EditorText.Error(error).Render(Service.Text); }
         finally { Refresh(); }
     }
-    [RelayCommand] private Task AddLanguageAsync() => RunAsync(async () => { await Service.AddLanguageAsync(NewLanguage); NewLanguage = ""; });
+    [RelayCommand]
+    private Task AddLanguageAsync() => RunAsync(async () =>
+    {
+        // AutoCompleteBox uses ValueMemberBinding to put the canonical code in NewLanguage.
+        // Also resolve an existing display string for callers that set it directly.
+        var code = LanguageOptions.FirstOrDefault(option => string.Equals(option.DisplayText, NewLanguage, StringComparison.Ordinal))?.Code
+            ?? NewLanguage.Split(" — ", 2, StringSplitOptions.None)[0].Trim().Replace('_', '-');
+        await Service.AddLanguageAsync(code); _hiddenLanguages.Remove(code); NewLanguage = "";
+    });
+    public Task RemoveLanguageAsync(string code) => RunAsync(async () =>
+    {
+        if (ApplyImportCommand.IsRunning) throw new EditorOperationException("i18n.stale", Service.Text["I18n.Stale"]);
+        foreach (var cell in _cells.Values.Where(cell => cell.Culture == code).ToArray()) await cell.CommitAsync();
+        CancelImport(); await Service.RemoveLanguageAsync(code);
+    });
     [RelayCommand]
     private void PreviewDevelopmentLanguage()
     {
@@ -245,7 +387,6 @@ private Task ChangeDevelopmentLanguageAsync() => RunAsync(async () =>
         await Service.ChangeDevelopmentLanguageAsync(preview); _preview = null; PreviewMessage = "";
         OnPropertyChanged(nameof(CanChangeDevelopmentLanguage));
     });
-    [RelayCommand] private void RevertDrafts() { foreach (var cell in _cells.Values.ToArray()) if (cell.IsDirty) cell.Revert(); }
     public void Dispose()
     {
         if (IsDisposed) return; IsDisposed = true; _draftRegistration.Dispose();
diff --git a/src/Editor/GalNet.Editor/ViewModels/GamePreviewPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/GamePreviewPanelViewModel.cs
deleted file mode 100644
index a3fc0e8d..00000000
--- a/src/Editor/GalNet.Editor/ViewModels/GamePreviewPanelViewModel.cs
+++ /dev/null
@@ -1,341 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Avalonia.Controls;
-using CommunityToolkit.Mvvm.ComponentModel;
-using CommunityToolkit.Mvvm.Input;
-using GalNet.Core.Assets;
-using GalNet.Core.Entry;
-using GalNet.Core.Runtime;
-using GalNet.Core.Variable;
-using GalNet.Editor.Abstraction.Project;
-using GalNet.Editor.Abstraction.Services;
-using GalNet.Editor.Services;
-using GalNet.Editor.Shared.Services;
-using GalNet.Runtime.Content;
-using GalNet.Storage.FileSystem;
-using Microsoft.Extensions.DependencyInjection;
-using Serilog;
-using Serilog.Context;
-
-namespace GalNet.Editor.ViewModels;
-
-public partial class GamePreviewPanelViewModel : ObservableObject, IDisposable, IAsyncDisposable
-{
-    private readonly EditorWorkspaceViewModel _workspace;
-    private readonly IProjectService _projectService;
-    private readonly EditorVariableService _variableService;
-    private readonly IVariableDefinitionService _variableDefinitions;
-    private readonly IGameContentProvider _contentProvider;
-    private readonly IAssetManager _assets;
-
-    private IGameRuntime? _runtime;
-    private EditorPreviewHost? _previewHost;
-    private readonly SemaphoreSlim _lifecycleGate = new(1, 1);
-    private IDisposable? _projectClosingRegistration;
-    private bool _disposed;
-
-    [ObservableProperty]
-    private string _statusText = "Ready";
-
-    [ObservableProperty]
-    private bool _isGameStarted;
-
-    private Control? _previewShell;
-    public Control? PreviewShell
-    {
-        get => _previewShell;
-        private set => SetProperty(ref _previewShell, value);
-    }
-
-    [ObservableProperty]
-    private VariableListEditorViewModel? _playerVariables;
-
-    [ObservableProperty]
-    private VariableListEditorViewModel? _saveVariables;
-
-    public int DesignWidth => _projectService.Current?.Settings.DefaultWidth ?? 1920;
-    public int DesignHeight => _projectService.Current?.Settings.DefaultHeight ?? 1080;
-
-    public ObservableCollection<string> OutputLines { get; } = [];
-
-    public GamePreviewPanelViewModel(
-        EditorWorkspaceViewModel workspace,
-        IProjectService projectService,
-        EditorVariableService variableService,
-        IVariableDefinitionService variableDefinitions,
-        IGameContentProvider contentProvider,
-        IAssetManager assets)
-    {
-        _workspace = workspace;
-        _projectService = projectService;
-        _variableService = variableService;
-        _variableDefinitions = variableDefinitions;
-        _contentProvider = contentProvider;
-        _assets = assets;
-        _workspace.ActivePreview = this;
-        _projectClosingRegistration = _projectService.Current?.RegisterClosingCallback(DisposePreviewForProjectCloseAsync);
-
-        _projectService.CurrentChanged += OnProjectChanged;
-        _variableService.VariableChanged += OnVariableServiceChanged;
-        _variableDefinitions.DefinitionsChanged += OnDefinitionsChanged;
-
-        ReloadEditors();
-        _ = RestartPreviewAsync();
-    }
-
-    [RelayCommand]
-    private async Task RestartPreviewAsync()
-    {
-        await _lifecycleGate.WaitAsync();
-        try
-        {
-            if (_disposed || _projectService.Current is not { } project)
-            {
-                StatusText = "No project";
-                return;
-            }
-
-            StatusText = "Restarting...";
-            await StopPreviewAsync();
-            if (_disposed || !ReferenceEquals(_projectService.Current, project))
-                return;
-
-            using var gameLogContext = LogContext.PushProperty("LogChannel", "Game");
-            var profileDirectory = Path.Combine(project.EditorStateDirectory, "player");
-            var context = new EditorPreviewContext(
-                project.Name,
-                project.Services.GetRequiredService<IEntryCatalog>(),
-                _assets,
-                _contentProvider,
-                _variableService,
-                new FileSaveService(profileDirectory, project.Settings.SaveSlotCount),
-                new FileGameProgressService(profileDirectory),
-                OnRuntimeCreated,
-                OnGameStarted,
-                OnGameEnded,
-                OnGameFailed);
-            var host = new EditorPreviewHost(context);
-            _previewHost = host;
-            PreviewShell = host.Shell;
-            _ = host.StartAsync();
-            ReloadEditors();
-            OutputLines.Insert(0, $"Preview restarted at {DateTime.Now:T}");
-            StatusText = "Ready";
-        }
-        finally { _lifecycleGate.Release(); }
-    }
-
-    public Task RestartAsync() => RestartPreviewAsync();
-
-    public async Task ResetPlayerAsync()
-    {
-        _variableService.ResetAll();
-        if (_projectService.Current is { } project)
-        {
-            var playerDirectory = Path.Combine(project.EditorStateDirectory, "player");
-            var savesDirectory = Path.Combine(playerDirectory, "saves");
-            if (Directory.Exists(savesDirectory)) Directory.Delete(savesDirectory, true);
-            var progressPath = Path.Combine(playerDirectory, "progress.json");
-            if (File.Exists(progressPath)) File.Delete(progressPath);
-        }
-        await RestartPreviewAsync();
-    }
-
-    private void OnVariableServiceChanged(VariableScope scope, string name, Variable variable)
-    {
-        Log.Debug(
-            "Preview variable synchronized: {Scope}.{VariableName} = {VariableValue} ({VariableType})",
-            scope, name, GetRawValue(variable), variable.Type);
-
-        // Update runtime as well when editor modifies player variables. VariableStore
-        // ignores equal values, so runtime-originated notifications are not echoed.
-        if (scope == VariableScope.Player)
-            _runtime?.SetVariable(name, GetRawValue(variable));
-
-        Avalonia.Threading.Dispatcher.UIThread.Post(() =>
-        {
-            if (_disposed)
-                return;
-
-            var editor = scope == VariableScope.Player ? PlayerVariables : SaveVariables;
-            editor?.UpdateCurrentValue(name, variable);
-        });
-    }
-
-    private void OnDefinitionsChanged(VariableScope scope)
-    {
-        if (Avalonia.Threading.Dispatcher.UIThread.CheckAccess()) ReloadEditors();
-        else Avalonia.Threading.Dispatcher.UIThread.Post(ReloadEditors);
-    }
-
-    private void ReloadEditors()
-    {
-        PlayerVariables?.SetCurrentValueVisibility(false);
-        SaveVariables?.SetCurrentValueVisibility(false);
-        if (_disposed || _projectService.Current is null)
-        {
-            PlayerVariables = null;
-            SaveVariables = null;
-            return;
-        }
-
-        PlayerVariables = new VariableListEditorViewModel(
-            _variableDefinitions.GetDefinitions(VariableScope.Player),
-            showCurrentValue: true,
-            name => _variableService.GetSnapshot(VariableScope.Player).TryGetValue(name, out var v) ? CloneVariable(v, name) : null,
-            (name, value) =>
-            {
-                _variableService.GetSnapshot(VariableScope.Player).TryGetValue(name, out var existing);
-
-                var v = existing is not null ? CloneVariable(existing, name) : new Variable { Name = name };
-                v.SetValue(value);
-                _variableService.NotifyVariableChanged(VariableScope.Player, name, v);
-            });
-
-        SaveVariables = new VariableListEditorViewModel(
-            _variableDefinitions.GetDefinitions(VariableScope.Save),
-            showCurrentValue: IsGameStarted,
-            name => _variableService.GetSnapshot(VariableScope.Save).TryGetValue(name, out var v) ? CloneVariable(v, name) : null,
-            (name, value) =>
-            {
-                if (_runtime is null) return;
-                _runtime.SetVariable(name, value);
-            });
-
-        OnPropertyChanged(nameof(PlayerVariables));
-        OnPropertyChanged(nameof(SaveVariables));
-    }
-
-    private void OnRuntimeCreated(IGameRuntime runtime)
-    {
-        _runtime = runtime;
-    }
-
-    private void OnGameStarted()
-    {
-        Avalonia.Threading.Dispatcher.UIThread.Post(() =>
-        {
-            if (_disposed) return;
-            IsGameStarted = true;
-            StatusText = "Running";
-        });
-    }
-
-    private void OnGameEnded()
-    {
-        Avalonia.Threading.Dispatcher.UIThread.Post(() =>
-        {
-            if (_disposed) return;
-            _runtime = null;
-            IsGameStarted = false;
-            StatusText = "Ready";
-        });
-    }
-
-    private void OnGameFailed(Exception exception)
-    {
-        Avalonia.Threading.Dispatcher.UIThread.Post(() =>
-        {
-            if (_disposed) return;
-            _runtime = null;
-            IsGameStarted = false;
-            StatusText = $"Preview failed: {exception.Message}";
-        });
-    }
-
-    partial void OnIsGameStartedChanged(bool value)
-    {
-        SaveVariables?.SetCurrentValueVisibility(value);
-    }
-
-    private async Task StopPreviewAsync()
-    {
-        IsGameStarted = false;
-        _runtime = null;
-        PreviewShell = null;
-        var host = _previewHost;
-        _previewHost = null;
-        if (host is not null)
-            await host.DisposeAsync();
-        ReloadEditors();
-    }
-
-    public async ValueTask DisposeAsync()
-    {
-        await DisposePreviewForProjectCloseAsync();
-        GC.SuppressFinalize(this);
-    }
-
-    /// <summary>
-    /// Dock.Model disposes document contexts synchronously. Start the same idempotent
-    /// cleanup path without blocking the UI thread that owns the document close.
-    /// </summary>
-    public void Dispose()
-    {
-        _ = DisposeAsync().AsTask();
-        GC.SuppressFinalize(this);
-    }
-
-    private async Task DisposePreviewForProjectCloseAsync()
-    {
-        await _lifecycleGate.WaitAsync();
-        try
-        {
-            if (_disposed) return;
-            _disposed = true;
-            _projectClosingRegistration?.Dispose();
-            _projectClosingRegistration = null;
-            _projectService.CurrentChanged -= OnProjectChanged;
-            _variableService.VariableChanged -= OnVariableServiceChanged;
-            _variableDefinitions.DefinitionsChanged -= OnDefinitionsChanged;
-            if (ReferenceEquals(_workspace.ActivePreview, this)) _workspace.ActivePreview = null;
-            await StopPreviewAsync();
-        }
-        finally { _lifecycleGate.Release(); }
-    }
-
-    private void OnProjectChanged(GalProject? project)
-    {
-        OnPropertyChanged(nameof(DesignWidth));
-        OnPropertyChanged(nameof(DesignHeight));
-        if (!_disposed)
-            _ = StopPreviewForProjectChangeAsync();
-    }
-
-    private async Task StopPreviewForProjectChangeAsync()
-    {
-        await _lifecycleGate.WaitAsync();
-        try
-        {
-            if (!_disposed)
-                await StopPreviewAsync();
-        }
-        finally { _lifecycleGate.Release(); }
-    }
-
-    private static Variable CloneVariable(Variable variable, string name)
-    {
-        var clone = new Variable { Name = name };
-        clone.SetValue(variable.Type switch
-        {
-            VariableType.Bool => variable.AsBool(),
-            VariableType.Int => variable.AsInt(),
-            VariableType.Float => variable.AsFloat(),
-            _ => variable.AsString()
-        });
-        return clone;
-    }
-
-    private static object GetRawValue(Variable variable) => variable.Type switch
-    {
-        VariableType.Bool => variable.AsBool(),
-        VariableType.Int => variable.AsInt(),
-        VariableType.Float => variable.AsFloat(),
-        _ => variable.AsString()
-    };
-}
diff --git a/src/Editor/GalNet.Editor/ViewModels/GroupEditorPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/GroupEditorPanelViewModel.cs
index f77a50e0..9a439e1a 100644
--- a/src/Editor/GalNet.Editor/ViewModels/GroupEditorPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/GroupEditorPanelViewModel.cs
@@ -7,14 +7,15 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Scene;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Commands;
 using GalNet.Editor.Controls;
 using GalNet.Editor.History;
 using GalNet.Editor.Services;
+using GalNet.Editor.Shared.Services;
 using GalNet.Game.Controls.Forms;
 
 namespace GalNet.Editor.ViewModels;
@@ -60,7 +61,7 @@ private void RenderError()
         try { ErrorText = _localization is null ? _errorMessage.Key ?? "" : _errorMessage.Render(_localization); }
         finally { _renderingError = false; }
     }
-    private void OnLocaleChanged(object? sender, PropertyChangedEventArgs args) { if (args.PropertyName == "Item[]") RenderError(); }
+    private void OnLocaleChanged(object? sender, PropertyChangedEventArgs args) { if (args.PropertyName == "Item[]") { RenderError(); OnPropertyChanged(nameof(MoveStatus)); } }
     public IReadOnlyList<ConditionVariableSuggestion> ConditionSuggestions => Workspace.GetConditionVariableSuggestions();
     public IReadOnlyList<GalNet.Core.Variable.ProjectVariableDefinition> ValidationVariables => Workspace.AllProjectVariableDefinitions;
     public IAssetManager AssetManager { get; }
@@ -115,15 +116,35 @@ public void UpdateActiveSelection(EntryEditorItemViewModel? added)
     public bool IsDisposed => _disposed;
     public void PublishSelection() { if (!_disposed) _selection.Select(_selectionOwner, GroupId, SelectedEntry?.StableId); }
     public string CopySelection() => _authoring.Copy(GroupId, SelectedEntries.Select(entry => entry.StableId));
+    public EntryCutOffer? PrepareCutSelection() => _authoring.PrepareCut(GroupId, SelectedEntries.Select(entry => entry.StableId));
+    public void BeginCut(EntryCutOffer offer) { if (!_disposed) { _authoring.CancelPendingMove(); _authoring.BeginCut(offer); } }
+    public bool HasPendingMove => _authoring.HasPendingMove;
+    private bool _copiedMove;
+    public string MoveStatus => HasPendingMove ? _localization?["Entry.MovePending"] ?? "" : _copiedMove ? _localization?["Entry.MoveFallback"] ?? "" : "";
+    [RelayCommand] public void CancelPendingMove() { _authoring.CancelPendingMove(); _copiedMove = false; OnPropertyChanged(nameof(MoveStatus)); }
+    private void PendingMoveChanged()
+    {
+        foreach (var entry in _entries) entry.IsPendingMove = _authoring.IsPendingMove(GroupId, entry.StableId);
+        OnPropertyChanged(nameof(HasPendingMove)); OnPropertyChanged(nameof(MoveStatus));
+    }
     public void DeleteEntries(IEnumerable<string> ids) { if (!_disposed) _authoring.Delete(GroupId, ids); }
     public void DeleteSelection() => DeleteEntries(SelectedEntries.Select(entry => entry.StableId).ToArray());
-    public void DeleteCopiedEntries(string[] ids, string text)
+    private Task CommitAsync(PreparedEntryEdit? edit)
+    {
+        if (!_disposed) edit?.Commit();
+        return Task.CompletedTask;
+    }
+    public Task DeleteEntriesAsync(IEnumerable<string> ids) => _disposed ? Task.CompletedTask : CommitAsync(_authoring.PrepareDelete(GroupId, ids));
+    public Task DeleteSelectionAsync() => DeleteEntriesAsync(SelectedEntries.Select(entry => entry.StableId).ToArray());
+    public async Task PasteAsync(string text, string? anchor)
     {
         if (_disposed) return;
-        if (_authoring.Copy(GroupId, ids) != text) throw new EditorOperationException("entry.cutChanged", "The source entries changed while writing the clipboard. They were not removed.");
-        DeleteEntries(ids);
+        var pasted = await _authoring.PasteAsync(GroupId, text, anchor);
+        if (_disposed) return;
+        _copiedMove = _authoring.LastPasteCopiedMove;
+        if (pasted.Count > 0) SetSelection(_entries.Where(entry => pasted.Contains(entry.StableId)));
+        OnPropertyChanged(nameof(MoveStatus));
     }
-    public async Task PasteAsync(string text, string? anchor) { if (!_disposed) { var pasted = await _authoring.PasteAsync(GroupId, text, anchor); if (!_disposed) SetSelection(pasted); } }
     public async Task DuplicateSelectionAsync()
     {
         var text = CopySelection();
@@ -139,6 +160,7 @@ public GroupEditorPanelViewModel(EditorWorkspaceViewModel workspace, string grou
         GroupId = groupId;
         _entries = GroupNode.Entries;
         _authoring = authoring;
+        _authoring.PendingMoveChanged += PendingMoveChanged;
         _projects = projects;
         _effects = effects;
         _catalog = catalog;
@@ -151,7 +173,7 @@ public GroupEditorPanelViewModel(EditorWorkspaceViewModel workspace, string grou
         EntryTypes = catalog.Definitions.Select(definition => new EntryTypeOption(definition.Type, definition.Category, $"Entry.Type.{definition.Type}")).ToArray();
         Workspace.VariableDefinitionsChanged += OnVariableDefinitionsChanged;
         _entries.CollectionChanged += OnEntriesChanged;
-        foreach (var entry in _entries) Attach(entry);
+        foreach (var entry in _entries) Attach(entry, isNew: false);
     }
 
     [RelayCommand]
@@ -174,6 +196,13 @@ private void AppendEntries()
     }
 
     private int BatchCount => (int)Math.Clamp(BatchAddCount, 1, 1000);
+    public void InsertChosenType(string type, string? anchorId)
+    {
+        if (_disposed || !EntryTypes.Any(item => item.Value == type)) return;
+        var index = anchorId is null ? GroupNode.Entries.Count : GroupNode.Entries.ToList().FindIndex(entry => entry.StableId == anchorId) + 1;
+        if (anchorId is not null && index == 0) { ErrorText = EditorLocalizationService.Current?["Entry.AnchorMissing"] ?? "The insertion target was removed."; return; }
+        InsertionType = type; InsertEntries(index, BatchCount);
+    }
     public void InsertType(string type, string? anchorId)
     {
         if (_disposed) return;
@@ -186,7 +215,14 @@ public void InsertType(string type, string? anchorId)
     }
     public void ChangeType(EntryEditorItemViewModel entry, string type)
     {
-        if (!_disposed && EntryTypes.Any(item => item.Value == type)) Workspace.ChangeEntryType(GroupNode, entry, type, _catalog.Create(type).Values);
+        if (!_disposed && EntryTypes.Any(item => item.Value == type)) Workspace.ChangeEntryType(GroupNode, entry, type, GalNet.Editor.Abstraction.Documents.EditorEntryData.CreateParameters(_catalog, type));
+    }
+    public Task ChangeTypeAsync(EntryEditorItemViewModel entry, string type)
+    {
+        if (_disposed || entry.Type == type || !GroupNode.Entries.Contains(entry) || !EntryTypes.Any(item => item.Value == type)) return Task.CompletedTask;
+        var fields = _projects.Current?.Services.GetService(typeof(EntryFieldAuthoringService)) as EntryFieldAuthoringService;
+        if (fields is null) throw new InvalidOperationException("Entry authoring is unavailable.");
+        return CommitAsync(fields.PrepareType(GroupId, entry.Source, type, GalNet.Editor.Abstraction.Documents.EditorEntryData.CreateParameters(_catalog, type)));
     }
     private void InsertEntries(int index, int count, string? anchorId = null)
     {
@@ -199,12 +235,12 @@ private void InsertEntries(int index, int count, string? anchorId = null)
     }
 
     [RelayCommand]
-    private void RemoveEntry(EntryEditorItemViewModel? entry)
+    private async Task RemoveEntryAsync(EntryEditorItemViewModel? entry)
     {
         if (entry is null)
             return;
 
-        try { _authoring.Delete(GroupId, [entry.StableId]); }
+        try { await DeleteEntriesAsync([entry.StableId]); }
         catch (Exception error) { ReportError(error); }
     }
 
@@ -255,15 +291,17 @@ private void OnEntriesChanged(object? sender, NotifyCollectionChangedEventArgs e
         OnPropertyChanged(nameof(VisibleEntries));
         if (e.Action == NotifyCollectionChangedAction.Move) return;
         foreach (var entry in _attached.Where(entry => !_entries.Contains(entry)).ToArray()) { entry.PropertyChanged -= OnEntryPropertyChanged; _attached.Remove(entry); }
-        foreach (var entry in _entries.Where(entry => !_attached.Contains(entry)).ToArray()) Attach(entry);
+        foreach (var entry in _entries.Where(entry => !_attached.Contains(entry)).ToArray()) Attach(entry, isNew: true);
         foreach (var entry in SelectedEntries.Where(entry => !_entries.Contains(entry)).ToArray()) SelectedEntries.Remove(entry);
         UpdateActiveSelection(null);
     }
 
-    private void Attach(EntryEditorItemViewModel entry)
+    private void Attach(EntryEditorItemViewModel entry, bool isNew)
     {
         if (!_attached.Add(entry)) return;
-        entry.IsParametersExpanded = _expanded.GetValueOrDefault(entry.StableId, true);
+        entry.IsPendingMove = _authoring.IsPendingMove(GroupId, entry.StableId);
+        entry.IsParametersExpanded = _expanded.GetValueOrDefault(entry.StableId, !isNew || Workspace.ExpandNewEntries);
+        _expanded[entry.StableId] = entry.IsParametersExpanded;
         entry.PropertyChanged += OnEntryPropertyChanged;
         Configure(entry);
     }
@@ -273,6 +311,7 @@ private void OnEntryPropertyChanged(object? sender, PropertyChangedEventArgs e)
         if (sender is not EntryEditorItemViewModel entry) return;
         if (e.PropertyName == nameof(EntryEditorItemViewModel.IsParametersExpanded)) _expanded[entry.StableId] = entry.IsParametersExpanded;
         if (e.PropertyName == nameof(EntryEditorItemViewModel.Type)) Configure(entry);
+        if (e.PropertyName is nameof(EntryEditorItemViewModel.Type) or nameof(EntryEditorItemViewModel.Summary) or nameof(EntryEditorItemViewModel.Condition) or nameof(EntryEditorItemViewModel.Id)) OnPropertyChanged(nameof(VisibleEntries));
     }
 
     private void Configure(EntryEditorItemViewModel entry) => entry.ConfigureParameterFields(
@@ -285,6 +324,7 @@ public void Dispose()
     {
         if (_disposed) return;
         _disposed = true;
+        _authoring.PendingMoveChanged -= PendingMoveChanged;
         _selection.Clear(_selectionOwner);
         if (_localization is not null) _localization.PropertyChanged -= OnLocaleChanged;
         Workspace.VariableDefinitionsChanged -= OnVariableDefinitionsChanged;
diff --git a/src/Editor/GalNet.Editor/ViewModels/NewProjectPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/NewProjectPanelViewModel.cs
index 31f79ebd..9bf36e4d 100644
--- a/src/Editor/GalNet.Editor/ViewModels/NewProjectPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/NewProjectPanelViewModel.cs
@@ -4,10 +4,11 @@
 using System.Threading.Tasks;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
-using GalNet.Core.Settings;
+using GalNet.Contracts.Builtins;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Services;
 using GalNet.Editor.Services.Interfaces;
+using GalNet.Editor.Shared.Services;
 
 namespace GalNet.Editor.ViewModels;
 
@@ -39,6 +40,21 @@ public partial class NewProjectPanelViewModel : PageViewModelBase, IDisposable
     [ObservableProperty]
     private string _contractsDirectory = "";
 
+    [ObservableProperty]
+    private string _applicationPath = "";
+
+    partial void OnApplicationPathChanged(string value)
+    {
+        _error = null;
+        Message = "";
+        if (string.IsNullOrWhiteSpace(value) || !string.IsNullOrWhiteSpace(ContractsDirectory)) return;
+        try { ContractsDirectory = ProjectContractSource.FindForApplication(value); }
+        catch (Exception error)
+        {
+            _error = error;
+            Message = EditorText.Error(error).Render(_localization);
+        }
+    }
 
     private readonly IEditorLocalizationService _localization;
     private Exception? _error;
@@ -85,10 +101,22 @@ private async Task CreateAsync()
             var projectPath = Path.Combine(ProjectRoot, ProjectName);
             if (!TryParseResolution(Resolution, out var width, out var height))
                 throw new EditorOperationException("project.resolutionInvalid", "Resolution must be in the form width×height.");
+            var application = string.IsNullOrWhiteSpace(ApplicationPath) ? null : ProjectContractSource.RequireApplication(ApplicationPath);
+            var useDefaultContracts = application is null && string.IsNullOrWhiteSpace(ContractsDirectory);
             var contracts = string.IsNullOrWhiteSpace(ContractsDirectory)
-                ? Path.Combine(AppContext.BaseDirectory, "DefaultContracts")
-                : ContractsDirectory;
-            await _projectService.CreateAsync(projectPath, ProjectName, new ProjectSettings { DefaultWidth = width, DefaultHeight = height }, contracts);
+                ? application is null ? Path.Combine(AppContext.BaseDirectory, "DefaultContracts") : ProjectContractSource.FindForApplication(application)
+                : ContractsDirectory.Trim();
+            using var prepared = useDefaultContracts ? null : await Task.Run(() => ProjectContractSource.Prepare(contracts));
+            var audio = GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create();
+            var project = await _projectService.CreateAsync(projectPath, ProjectName, new DefaultProjectOptions
+            {
+                DefaultWidth = width,
+                DefaultHeight = height,
+                AudioBuses = audio.Buses.ToList(),
+                AudioTracks = audio.Tracks.ToList()
+            }.ToConfiguration(), prepared?.DirectoryPath ?? contracts);
+            if (application is not null)
+                ExternalGameDebugClient.SaveSettings(project.RootPath, new(application, []));
             _navigation.NavigateTo(_editorPageFactory.CreateEditorPage());
         }
         catch (Exception ex)
@@ -102,11 +130,23 @@ private async Task CreateAsync()
         }
     }
 
+    [RelayCommand]
+    private async Task BrowseApplicationAsync()
+    {
+        var selected = await _dialogs.OpenFilePickerAsync(_localization["NewProject.BrowseApplication"], false);
+        if (selected.Count > 0) ApplicationPath = selected[0];
+    }
+
     [RelayCommand]
     private async Task BrowseContractsAsync()
     {
         var directory = await _dialogs.OpenFolderPickerAsync(_localization["NewProject.BrowseContracts"]);
-        if (directory is not null) ContractsDirectory = directory;
+        if (directory is not null)
+        {
+            ContractsDirectory = directory;
+            _error = null;
+            Message = "";
+        }
     }
 
     [RelayCommand]
diff --git a/src/Editor/GalNet.Editor/ViewModels/ProblemsPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/ProblemsPanelViewModel.cs
index 0a44da4f..6cfed31e 100644
--- a/src/Editor/GalNet.Editor/ViewModels/ProblemsPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/ProblemsPanelViewModel.cs
@@ -1,9 +1,12 @@
 using System.Collections.ObjectModel;
 using System.Text.Json;
+using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using GalNet.Core.Entry;
+using GalNet.Core.Parameters;
 using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
 using GalNet.Editor.Services;
@@ -13,6 +16,19 @@ namespace GalNet.Editor.ViewModels;
 
 public sealed record AuthorProblem(string Severity, string Message, string Source, AuthorNavigationTarget? Target, Action? Discard = null)
 {
+    public string? Code { get; init; }
+    public FieldDescriptor? Field { get; init; }
+    public IReadOnlyList<string>? FieldPath { get; init; }
+    public PropertyPath? ValuePath { get; init; }
+    public string? Details { get; init; }
+    public bool HasDetails => !string.IsNullOrEmpty(Details);
+    public bool CanNavigate { get; init; }
+    public string? NavigationHint { get; init; }
+    public SceneReferenceDiagnostic? SceneReference { get; init; }
+    public Action? Restore { get; init; }
+    public string? InputText { get; init; }
+    public bool HasRestore => Restore is not null;
+    public bool HasInputText => InputText is not null;
     public bool HasDiscard => Discard is not null;
     public bool IsError => Severity == "error";
     public bool IsWarning => Severity == "warning";
@@ -30,9 +46,18 @@ public sealed partial class ProblemsPanelViewModel : ObservableObject, IDisposab
     private readonly AuthorNavigationService _navigation;
     private readonly EditorGroupProjectionStore _groups;
     private readonly ProjectLocalizationQuery _localization;
+    private readonly ProjectSceneTargets? _scenes;
+    private IReadOnlyList<SceneReferenceDiagnostic> _sceneDiagnostics = [];
     private readonly List<AuthorProblem> _external = [];
-    private string _signature;
+    private long _authorRevision;
+    private readonly IEditorDocumentService? _documents;
     private bool _incomplete;
+    private bool _disposed, _checking;
+    private readonly object _analysisGate = new();
+    private CancellationTokenSource? _checkCancellation;
+    private long _checkGeneration;
+    private string _fileStamp = "";
+    public Task ValidationTask { get; private set; } = Task.CompletedTask;
     [ObservableProperty] private bool _onlyErrors;
     public IEnumerable<AuthorProblem> VisibleProblems => Problems.Where(problem => !OnlyErrors || problem.IsError).OrderBy(problem => problem.IsError ? 0 : problem.IsWarning ? 1 : 2);
     partial void OnOnlyErrorsChanged(bool value) => OnPropertyChanged(nameof(VisibleProblems));
@@ -41,45 +66,154 @@ public sealed partial class ProblemsPanelViewModel : ObservableObject, IDisposab
     private long? _validatedRevision;
     public ObservableCollection<AuthorProblem> Problems { get; } = [];
     public int Count => Problems.Count;
-    public string Status => _text[_validatedRevision is null ? "Uiux.Validation.Unchecked" : _validatedRevision != _revision ? "Uiux.Validation.Stale"
-        : _validation.Any(problem => problem.Severity == "error") ? "Uiux.Validation.Failed" : _incomplete ? "Uiux.Validation.Incomplete" : "Uiux.Validation.Passed"];
+    public string Status => _text[_checking ? "Problem.Checking" : _validatedRevision is null ? "Uiux.Validation.Unchecked" : _validatedRevision != _revision ? "Uiux.Validation.Stale"
+        : Problems.Any(problem => problem.IsError) ? "Uiux.Validation.Failed" : _incomplete || _sceneDiagnostics.Any(diagnostic => diagnostic.Code is "scene.reference.uncertain" or "scene.coverage.unknown" or "scene.coverage.structure" or "scene.analysis.limit") ? "Uiux.Validation.Incomplete" : "Uiux.Validation.Passed"];
     public ProblemsPanelViewModel(EntryEditSession edits, IProjectContentSession content, IProjectService projects, IEntryCatalog catalog,
-        EditorHistories histories, IEditorLocalizationService text, AuthorNavigationService navigation, EditorGroupProjectionStore groups, ProjectLocalizationQuery localization)
+        EditorHistories histories, IEditorLocalizationService text, AuthorNavigationService navigation, EditorGroupProjectionStore groups, ProjectLocalizationQuery localization, ProjectSceneTargets? scenes = null, IEditorDocumentService? documents = null)
     {
         _edits = edits; _content = content; _projects = projects; _catalog = catalog; _histories = histories; _text = text; _navigation = navigation;
         _groups = groups;
-        _localization = localization; _signature = JsonSerializer.Serialize(content.CaptureWorking());
-        edits.Changed += Refresh; histories.Changed += ContentChanged; text.PropertyChanged += LocaleChanged; Refresh();
+        _scenes = scenes;
+        if (scenes is not null) scenes.Changed += SceneChanged;
+        _localization = localization; _authorRevision = histories.Content.AuthorChanges.Revision; _documents = documents;
+        content.ExternalReloaded += ExternalReloaded;
+        content.Changed += FilesChanged;
+        edits.Changed += Refresh; histories.Changed += ContentChanged; text.PropertyChanged += LocaleChanged;
+        _sceneDiagnostics = scenes?.Diagnostics() ?? [];
+        ScheduleValidation();
     }
     private void LocaleChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs args) => Refresh();
+    private void SceneChanged()
+    {
+        if (!Dispatcher.UIThread.CheckAccess()) { Dispatcher.UIThread.Post(SceneChanged); return; }
+        if (_disposed || _scenes is null) return;
+        _sceneDiagnostics = _scenes.Diagnostics();
+        ScheduleValidation();
+    }
     private void ContentChanged()
     {
-        var signature = JsonSerializer.Serialize(_content.CaptureWorking());
-        if (signature != _signature) { _signature = signature; _revision++; }
+        var revision = _histories.Content.AuthorChanges.Revision;
+        if (revision != _authorRevision)
+        {
+            _authorRevision = revision;
+            if (_scenes is not null) _sceneDiagnostics = _scenes.Diagnostics();
+        }
+        ScheduleValidation();
+    }
+    private void ExternalReloaded() { if (_scenes is not null) _sceneDiagnostics = _scenes.Diagnostics(); ScheduleValidation(); }
+    private void FilesChanged()
+    {
+        var stamp = string.Join("\n", _content.FileDocuments.Values.OrderBy(file => file.Id, StringComparer.Ordinal)
+            .Select(file => $"{file.Id}:{file.Path}:{file.Exists}:{System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(file.Data)}"));
+        if (stamp == _fileStamp) return;
+        _fileStamp = stamp; ScheduleValidation();
+    }
+    private void ScheduleValidation()
+    {
+        if (_disposed) return;
+        _revision++; _checking = true;
+        _checkCancellation?.Cancel(); _checkCancellation?.Dispose();
+        var cancellation = _checkCancellation = new();
+        var generation = ++_checkGeneration;
+        ValidationTask = CheckLaterAsync(generation, cancellation.Token);
         Refresh();
     }
+    private async Task CheckLaterAsync(long generation, CancellationToken token)
+    {
+        try
+        {
+            await Task.Delay(220, token);
+            var input = await Dispatcher.UIThread.InvokeAsync(() =>
+                _disposed || generation != _checkGeneration || _projects.Current is null ? null
+                    : new ValidationInput(_content.CaptureWorking(), _projects.Current.RootPath, _revision, _localization.Get()));
+            if (input is null) return;
+            var results = await Task.Run(() => { lock (_analysisGate) { token.ThrowIfCancellationRequested(); return Analyze(input.Snapshot, input.Root, input.Revision); } }, token);
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                if (!_disposed && generation == _checkGeneration) CompleteValidation(results, input.Localization, input.Snapshot, input.Revision);
+            });
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception error)
+        {
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                if (_disposed || generation != _checkGeneration) return;
+                _validation = [new("error", _text["Problem.CheckFailed"], "", null) { Details = error.Message }];
+                _incomplete = true; _validatedRevision = _revision; _checking = false; Refresh();
+            });
+        }
+    }
+    private sealed record ValidationInput(EditorProjectDocument Snapshot, string Root, long Revision, LocalizationReferenceIndex? Localization);
+    private bool IsPresent(AuthorNavigationTarget? target) => _documents is null || target?.NodeId is null
+        || _documents.CurrentDocument.Nodes.Any(node => node.Id == target.NodeId) && (target.EntryId is null
+            || _documents.Groups.TryGetValue(target.NodeId, out var group) && group.Entries.Any(entry => entry.StableId == target.EntryId));
     private void Refresh()
     {
+        if (_disposed) return;
         Problems.Clear();
         foreach (var draft in _edits.Pending)
-            Problems.Add(new(draft.State.IsConflicted || draft.State.Issue is not null ? "error" : "info", draft.State.IsConflicted ? _text["Uiux.Draft.Conflict"] : draft.State.Issue?.Message ?? _text["Uiux.Draft.Pending"],
-                $"{draft.Owner.Type} / {draft.Owner.Id} / {draft.Root.Id}", new(draft.Owner.AuthorGroupId, draft.Owner.StableId, draft.Root.Id, Revision: _revision), draft.State.Clear));
-        foreach (var problem in _validation) Problems.Add(problem);
-        foreach (var problem in _external) Problems.Add(problem);
+            Problems.Add(Present(new(draft.State.IsConflicted || draft.State.Issue is not null ? "error" : "info", draft.State.IsConflicted ? _text["Uiux.Draft.Conflict"] : draft.State.Issue?.Message ?? _text["Uiux.Draft.Pending"],
+                Source(new(draft.Owner.AuthorGroupId, draft.Owner.StableId, draft.Root.Id)), new(draft.Owner.AuthorGroupId, draft.Owner.StableId, draft.Root.Id, Revision: _revision, FieldPath: draft.Path), draft.State.Clear)
+            {
+                Field = draft.Field,
+                FieldPath = draft.Path,
+                Code = draft.State.IsConflicted ? "field.conflict" : draft.State.Issue?.Code,
+                Details = draft.State.Issue?.Message,
+                ValuePath = DraftValuePath(draft),
+            }));
+        foreach (var archive in _edits.Archives)
+        {
+            var target = new AuthorNavigationTarget(archive.Owner.GroupId, archive.Owner.EntryId, archive.RootId, FieldPath: archive.Path);
+            var ready = _edits.CanRestore(archive);
+            Problems.Add(Present(new("info", _text[_edits.IsRestoreRequested(archive) ? "Uiux.Draft.RestoreRequested" : ready ? "Uiux.Draft.Recoverable" : "Uiux.Draft.Archived"],
+                archive.Type + " / " + archive.RootId + (archive.Path.Length == 0 ? "" : "/" + string.Join("/", archive.Path)), target, () => _edits.RemoveArchive(archive))
+            {
+                InputText = archive.Text,
+                FieldPath = archive.Path,
+                Restore = ready ? () => { _edits.RequestRestore(archive); _navigation.Navigate(target); }
+                : null
+            }));
+        }
+        if (_edits.ArchiveError is not null) Problems.Add(new("error", _text["Error.entry.archiveUnavailable"], ".galnet/editor/input-archive.json", null));
+        if (_validatedRevision == _revision)
+            foreach (var problem in _validation.Where(problem => IsPresent(problem.Target))) Problems.Add(Present(problem));
+        foreach (var diagnostic in _sceneDiagnostics)
+            Problems.Add(Present(new("warning", _text["Scene.Diagnostic." + diagnostic.Code], diagnostic.Owner.GroupId + diagnostic.JsonPointer,
+                new(diagnostic.Owner.GroupId, diagnostic.Owner.EntryId, diagnostic.JsonPointer.Split('/').ElementAtOrDefault(2), Revision: _revision))
+            { SceneReference = diagnostic, Details = diagnostic.Code + "\n" + diagnostic.JsonPointer }));
+        foreach (var problem in _external) Problems.Add(Present(problem));
+        var distinct = Problems.DistinctBy(problem => (problem.Severity, problem.Message, problem.Source, problem.Target?.NodeId, problem.Target?.EntryId, problem.Target?.FieldId, problem.Target?.File, problem.InputText)).ToArray();
+        Problems.Clear(); foreach (var problem in distinct) Problems.Add(problem);
         foreach (var group in _groups.Loaded)
-            foreach (var entry in group.Entries) entry.ProblemCount = Problems.Count(problem => problem.Target?.NodeId == group.Document.Id && problem.Target?.EntryId == entry.StableId);
+            foreach (var entry in group.Entries)
+            {
+                var active = Problems.Where(problem => problem.InputText is null && (problem.IsError || problem.IsWarning) && (problem.Target?.Revision is null || problem.Target.Revision == _revision) && problem.Target?.NodeId == group.Document.Id && problem.Target?.EntryId == entry.StableId).ToArray();
+                entry.ProblemCount = active.Length; entry.HasProblemErrors = active.Any(problem => problem.IsError);
+            }
         OnPropertyChanged(nameof(Count)); OnPropertyChanged(nameof(Status)); OnPropertyChanged(nameof(VisibleProblems));
     }
     [RelayCommand]
     private void Validate()
     {
+        _checkCancellation?.Cancel(); ++_checkGeneration;
         var snapshot = _content.CaptureWorking();
-        _signature = JsonSerializer.Serialize(snapshot);
+        List<AuthorProblem> results;
+        lock (_analysisGate) results = Analyze(snapshot, _projects.Current!.RootPath, _revision);
+        CompleteValidation(results, _localization.Get(), snapshot, _revision);
+    }
+    private List<AuthorProblem> Analyze(EditorProjectDocument snapshot, string root, long revision)
+    {
         var diagnostics = new List<ToolDiagnostic>();
-        var validator = new ProjectValidationService(_projects.Current!.RootPath);
+        var validator = new ProjectValidationService(root);
         validator.ValidateGraph(JsonSerializer.SerializeToElement(snapshot.Graph), diagnostics, checkSourceReferences: false);
         var results = new List<AuthorProblem>();
-        foreach (var diagnostic in diagnostics) results.Add(new(diagnostic.Severity, diagnostic.Message, diagnostic.File ?? "Graph", new(diagnostic.ObjectId, Revision: _revision)));
+        foreach (var diagnostic in diagnostics)
+        {
+            var segments = diagnostic.JsonPointer?.Split('/') ?? [];
+            var nodeId = segments.Length > 2 && segments[1] == "nodes" && int.TryParse(segments[2], out var index) && index < snapshot.Graph.Nodes.Count ? snapshot.Graph.Nodes[index].Id : null;
+            results.Add(new(diagnostic.Severity, diagnostic.Message, diagnostic.File ?? "Graph", new(nodeId, File: nodeId is null ? "Graph/graph.json" : null, Revision: revision)) { Code = diagnostic.Code, Details = diagnostic.Message });
+        }
         foreach (var pair in snapshot.GroupEntries)
         {
             var node = snapshot.Graph.Nodes.FirstOrDefault(item => item.Id == pair.Key);
@@ -87,37 +221,141 @@ private void Validate()
             var raw = JsonSerializer.SerializeToElement(new { version = GalNet.Core.Serialization.GroupDocument.CurrentVersion, kind = "Raw", entries = pair.Value.Select(entry => new { id = entry.StableId, type = entry.Type, condition = entry.Condition, parameters = entry.Parameters }) });
             diagnostics.Clear();
             ProjectValidationService.ValidateGroupDocument(raw, path, diagnostics, _catalog);
+            var fieldProblems = new HashSet<string>(StringComparer.Ordinal);
+            foreach (var entry in pair.Value)
+                if (_catalog.TryGet(entry.Type, out var schema))
+                    foreach (var field in schema.DynamicParameters.Fields)
+                    {
+                        var issue = entry.Parameters.TryGetValue(field.Id, out var value) ? ValueValidation.Validate(field.Value, value)
+                            : field.IsRequired && field.DefaultValue is null ? new ValueIssue("field.required", "Field must be provided.") : null;
+                        if (issue is null) continue;
+                        fieldProblems.Add(entry.StableId);
+                        results.Add(new("error", issue.Message, path, new(pair.Key, entry.StableId, field.Id, Revision: revision)) { Code = issue.Code, Field = field, Details = issue.Message });
+                    }
             foreach (var diagnostic in diagnostics)
             {
                 var segments = diagnostic.JsonPointer?.Split('/') ?? [];
                 var index = segments.Length > 2 && int.TryParse(segments[2], out var parsed) ? parsed : -1;
                 var entry = index >= 0 && index < pair.Value.Count ? pair.Value[index] : null;
-                var field = segments.Length > 4 && segments[3] == "parameters" ? segments[4] : null;
-                results.Add(new(diagnostic.Severity, diagnostic.Message, path, new(pair.Key, diagnostic.ObjectId ?? entry?.StableId, field, Revision: _revision)));
+                if (diagnostic.Code == "entry.parametersInvalid" && entry is not null && fieldProblems.Contains(entry.StableId)) continue;
+                var field = segments.Length > 4 && segments[3] == "parameters" ? segments[4] : segments.LastOrDefault() == "condition" ? "condition" : null;
+                results.Add(new(diagnostic.Severity, diagnostic.Message, path, new(pair.Key, diagnostic.ObjectId ?? entry?.StableId, field, Revision: revision)) { Code = diagnostic.Code, Details = diagnostic.Message });
             }
-            foreach (var entry in pair.Value)
-                if (_catalog.TryGet(entry.Type, out var schema) && schema.DynamicParameters is { } parameters)
-                    foreach (var field in parameters.Fields)
-                    {
-                        var issue = entry.Parameters.TryGetValue(field.Id, out var value) ? GalNet.Core.Parameters.ValueValidation.Validate(field.Value, value)
-                            : field.IsRequired && field.DefaultValue is null ? new GalNet.Core.Parameters.ValueIssue("field.required", _text["Uiux.Draft.Invalid"]) : null;
-                        if (issue is not null) results.Add(new("error", issue.Message, path, new(pair.Key, entry.StableId, field.Id, Revision: _revision)));
-                    }
         }
-        var localization = _localization.Get(); _incomplete = localization?.Complete != true;
+        return results;
+    }
+    private void CompleteValidation(List<AuthorProblem> results, LocalizationReferenceIndex? localization, EditorProjectDocument snapshot, long revision)
+    {
+        _incomplete = localization?.Complete != true;
         foreach (var issue in localization?.Issues ?? [])
         {
-            var reference = localization!.References.FirstOrDefault(item => item.Owner == issue.File && item.JsonPointer == issue.JsonPointer);
             var node = snapshot.Graph.Nodes.FirstOrDefault(item => item.Id == issue.File);
-            var field = issue.JsonPointer.Split('/').LastOrDefault();
+            var segments = issue.Path is { } propertyPath
+                ? propertyPath.Where(segment => segment.Kind != PropertySegmentKind.JsonString).Select(segment => segment.Value).ToArray()
+                : issue.JsonPointer.Split('/').Skip(1).Select(PropertyPath.Unescape).ToArray();
+            var field = segments.FirstOrDefault();
+            var fieldPath = segments.Skip(1).ToArray();
+            FieldDescriptor? leaf = null;
+            var code = "localization." + issue.Code;
+            if (issue.Code.StartsWith("value.", StringComparison.Ordinal) || issue.Code == "field.stringRequired")
+            {
+                var entry = node is not null && snapshot.GroupEntries.TryGetValue(node.Id, out var entries)
+                    ? entries.FirstOrDefault(entry => entry.StableId == issue.EntryId) : null;
+                if (entry is not null && _catalog.TryGet(entry.Type, out var schema) && schema.DynamicParameters.Fields.FirstOrDefault(member => member.Id == field) is { } root)
+                {
+                    using var document = new ValueDocument(root, entry.Parameters.GetValueOrDefault(root.Id));
+                    leaf = document.FindProperty(fieldPath)?.Field;
+                    code = issue.Code;
+                }
+            }
             results.Add(new(issue.Code is "schema.unavailable" or "field.unknown" or "field.opaque" or "analysis.limit" ? "warning" : "error", issue.Message, issue.File,
-                node is not null ? new(node.Id, reference?.EntryId, field, Revision: _revision) : new(File: issue.File, Revision: _revision)));
+                node is not null ? new(node.Id, issue.EntryId, field, Revision: revision, FieldPath: fieldPath) : new(File: issue.File, Revision: revision))
+            { Details = issue.Message, Code = code, Field = leaf, FieldPath = node is not null ? fieldPath : null, ValuePath = issue.Path });
         }
-        _validation = results; _validatedRevision = _revision; Refresh();
+        _validation = results; _validatedRevision = revision; _checking = false; Refresh();
     }
     public void Report(string severity, string message, string source, AuthorNavigationTarget? target = null)
     { if (!_external.Any(problem => problem.Source == source && problem.Message == message)) _external.Add(new(severity, message, source, target)); Refresh(); }
-    [RelayCommand] private void Navigate(AuthorProblem? problem) { if (problem?.Target is { } target) _navigation.Navigate(target); }
-    [RelayCommand] private void Discard(AuthorProblem? problem) => problem?.Discard?.Invoke();
-    public void Dispose() { _edits.Changed -= Refresh; _histories.Changed -= ContentChanged; _text.PropertyChanged -= LocaleChanged; }
+    public void ClearReports(string source)
+    { if (_external.RemoveAll(problem => problem.Source == source) != 0) Refresh(); }
+    private string Source(AuthorNavigationTarget? target)
+    {
+        if (target?.NodeId is not { } nodeId) return target?.File ?? "";
+        var group = _groups.Loaded.FirstOrDefault(group => group.Document.Id == nodeId);
+        var node = _documents?.CurrentDocument.Nodes.FirstOrDefault(node => node.Id == nodeId);
+        var entry = group?.Entries.FirstOrDefault(entry => entry.StableId == target.EntryId);
+        var data = entry?.Source;
+        if (data is null && _documents?.Groups.TryGetValue(nodeId, out var document) == true) data = document.Entries.FirstOrDefault(entry => entry.StableId == target.EntryId);
+        var source = data is null ? node?.Name ?? ""
+            : _text.Format("Problem.Source.Entry", node?.Name ?? "", data.Id,
+                EditorProblemText.Lookup("Entry.Type." + data.Type, data.Type, _text));
+        if (target.FieldId is { } id)
+        {
+            var field = entry?.DetailForm?.Fields.FirstOrDefault(field => field.Id == id);
+            if (field is null && data is not null && _catalog.TryGet(data.Type, out var schema)) field = schema.DynamicParameters.Fields.FirstOrDefault(field => field.Id == id);
+            source += " / " + (id == "condition" ? _text["Uiux.Entry.Condition"] : field is null ? EditorProblemText.Lookup("Entry.Parameter." + id, id, _text) : EditorProblemText.Label(field, _text));
+        }
+        return source;
+    }
+    private AuthorProblem Present(AuthorProblem problem)
+    {
+        var message = problem.Field is { } field && problem.Code is { } code
+            ? EditorProblemText.Value(field, new(code, problem.Message), _text)
+            : problem.Code switch
+            {
+                "condition.syntaxInvalid" => _text["Problem.Condition"],
+                "entry.typeUnknown" => _text["Problem.Entry.UnknownType"],
+                "entry.parametersInvalid" or "entry.compileInvalid" => _text["Problem.Entry.Compile"],
+                "localization.field.opaque" => _text["Problem.Localization.Opaque"],
+                { } other when !other.StartsWith("scene.", StringComparison.Ordinal) => _text["Problem.Generic"],
+                _ => problem.Message
+            };
+        var source = Source(problem.Target);
+        if (problem.FieldPath is { Count: > 0 } path)
+        {
+            var typed = problem.ValuePath?.Where(segment => segment.Kind != PropertySegmentKind.JsonString).Skip(1).ToArray();
+            source += " / " + string.Join(" / ", path.Select((segment, depth) =>
+                typed is not null && depth < typed.Length && typed[depth].Kind == PropertySegmentKind.MapKey ? "[" + JsonSerializer.Serialize(segment) + "]"
+                : (typed is null || depth < typed.Length && typed[depth].Kind == PropertySegmentKind.Index) && int.TryParse(segment, out var index) ? "#" + (index + 1)
+                : depth == path.Count - 1 && problem.Field is { } nestedField ? EditorProblemText.Label(nestedField, _text)
+                : EditorProblemText.Lookup("Entry.Parameter." + segment, segment, _text)));
+        }
+        var canNavigate = problem.Target is { } target && _navigation.CanNavigate(target);
+        return problem with
+        {
+            Message = message,
+            Source = source.Length > 0 ? source : problem.Source,
+            CanNavigate = canNavigate,
+            NavigationHint = _text[canNavigate ? "Problem.Navigate" : "Problem.Unavailable"]
+        };
+    }
+    [RelayCommand]
+    private void Navigate(AuthorProblem? problem)
+    {
+        if (problem?.Target is not { } target) return;
+        if (!_navigation.Navigate(target)) { Refresh(); Report("info", _text["Problem.Unavailable"], problem.Source); }
+    }
+    private static PropertyPath? DraftValuePath(EntryEditSession.Draft draft)
+    {
+        if (draft.Path.Length == 0 || !draft.Owner.IsCurrent) return null;
+        using var document = new ValueDocument(draft.Root, draft.Owner.Source.Parameters.GetValueOrDefault(draft.Root.Id));
+        if (document.FindProperty(draft.Path)?.Path is not { } relative) return null;
+        var path = PropertyPath.Empty.Member(draft.Root.Id);
+        foreach (var segment in relative) path = path.Append(segment);
+        return path;
+    }
+    [RelayCommand] private void Discard(AuthorProblem? problem) => ChangeArchive(problem?.Discard);
+    [RelayCommand] private void Restore(AuthorProblem? problem) => ChangeArchive(problem?.Restore);
+    private void ChangeArchive(Action? action)
+    {
+        try { action?.Invoke(); }
+        catch (Exception failure) { Report("error", EditorText.Error(failure).Render(_text), ".galnet/editor/input-archive.json"); }
+    }
+    public void Dispose()
+    {
+        _disposed = true; ++_checkGeneration; _checkCancellation?.Cancel(); _checkCancellation?.Dispose();
+        lock (_analysisGate) { } // Finish any contract callback before the project unloads its schema assembly.
+        _edits.Changed -= Refresh; _histories.Changed -= ContentChanged; _content.ExternalReloaded -= ExternalReloaded;
+        _content.Changed -= FilesChanged; _text.PropertyChanged -= LocaleChanged; if (_scenes is not null) _scenes.Changed -= SceneChanged;
+    }
 }
diff --git a/src/Editor/GalNet.Editor/ViewModels/ProjectSettingsPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/ProjectSettingsPanelViewModel.cs
index 8476fa8b..818572b3 100644
--- a/src/Editor/GalNet.Editor/ViewModels/ProjectSettingsPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/ProjectSettingsPanelViewModel.cs
@@ -1,364 +1,213 @@
-using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Threading.Tasks;
+using System.Text.Json;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
-using GalNet.Core.Audio;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Project;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
 using GalNet.Editor.Services;
 using GalNet.Editor.Shared.Services;
+using GalNet.Game.Controls.Forms;
 using Microsoft.Extensions.DependencyInjection;
-using Serilog;
 
 namespace GalNet.Editor.ViewModels;
 
 public partial class ProjectSettingsPanelViewModel : ObservableObject, IDisposable, IUndoRedoTarget
 {
-    public IReadOnlyList<string> ResolutionPresets { get; } = NewProjectPanelViewModel.ResolutionPresets;
-    public IReadOnlyList<string> AudioBuses { get; } = [GalNet.Core.Audio.AudioBuses.Bgm, GalNet.Core.Audio.AudioBuses.Sfx, GalNet.Core.Audio.AudioBuses.Vocal];
-    public ObservableCollection<AudioTrackEditorItem> AudioTracks { get; } = [];
-    private readonly IProjectService _projectService;
+    private readonly IProjectService _projects;
     private readonly EditorHistories _histories;
-    private bool _isLoading;
-    private bool _hasDraft;
-    private readonly IDisposable _draftRegistration;
     private readonly IProjectContentSession _session;
+    private readonly IDisposable _registration;
+    private readonly SemaphoreSlim _commitGate = new(1, 1);
+    private GalProject? _project;
+    private string _originalName = "";
+    private bool _loading, _disposed;
+    private Exception? _validationError;
+    public ObservableCollection<ConfigurationSectionEditor> Sections { get; } = [];
+    public EditorRegistry FieldEditors { get; }
     public IUndoRedoHistory UndoRedoHistory => _histories.Content;
-
     public IEditorLocalizationService L { get; }
     public event Action? DraftReset;
-
-    [ObservableProperty]
-    private int _defaultWidth = 1920;
-
-    [ObservableProperty]
-    private int _defaultHeight = 1080;
-
-    [ObservableProperty]
-    private int _saveSlotCount = 60;
-
-    [ObservableProperty]
-    private int _sfxChannelCount = 4;
-
-    [ObservableProperty]
-    private string _targetLocale = "zh-CN";
-
-    [ObservableProperty]
-    private string _isDirtyText = "";
-
-    [ObservableProperty]
-    private string _resolution = "1920×1080";
-
-    [ObservableProperty]
-    private string _projectName = "";
+    [ObservableProperty] private string _projectName = "";
+    [ObservableProperty] private string _isDirtyText = "";
     [ObservableProperty] private string _debugExecutable = "";
     [ObservableProperty] private string _debugArguments = "";
     [ObservableProperty] private string _debugWorkingDirectory = "";
     [ObservableProperty] private string _debugConfigurationMessage = "";
+    [ObservableProperty] private string _targetLocale = "";
+
+    partial void OnDebugExecutableChanged(string value) => SaveDebugAutomatically();
+    partial void OnDebugArgumentsChanged(string value) => SaveDebugAutomatically();
+    partial void OnDebugWorkingDirectoryChanged(string value) => SaveDebugAutomatically();
+    private void SaveDebugAutomatically() { if (!_loading && IsCurrent) SaveDebugConfiguration(); }
 
     [RelayCommand]
-    private void SaveDebugConfiguration()
+    private async Task BrowseDebugExecutableAsync()
     {
-        try
-        {
-            if (_projectService.Current is not { } project) return;
-            ExternalGameDebugClient.SaveSettings(project.RootPath, new(DebugExecutable.Trim(),
-                DebugArguments.Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries),
-                string.IsNullOrWhiteSpace(DebugWorkingDirectory) ? null : DebugWorkingDirectory.Trim()));
-            DebugConfigurationMessage = "";
-        }
-        catch (Exception error) { DebugConfigurationMessage = error.Message; }
+        if (_projects.Current?.Services.GetService<IFileDialogService>() is not { } dialogs) return;
+        var paths = await dialogs.OpenFilePickerAsync(L["Debug.Executable"], false);
+        if (paths.Count > 0 && IsCurrent) DebugExecutable = paths[0];
     }
 
-    public ProjectSettingsPanelViewModel(
-        IProjectService projectService,
-        EditorHistories histories,
-        IEditorLocalizationService localization,
-        IProjectContentSession session)
+    [RelayCommand]
+    private async Task BrowseDebugWorkingDirectoryAsync()
     {
-        _projectService = projectService;
-        _histories = histories;
-        _session = session;
-        _draftRegistration = session.RegisterDraft(() => HasDraftChanges, CommitDraftAsync);
-        L = localization;
-        L.PropertyChanged += OnLocalizationChanged;
+        if (_projects.Current?.Services.GetService<IFileDialogService>() is not { } dialogs) return;
+        var path = await dialogs.OpenFolderPickerAsync(L["Debug.WorkingDirectory"]);
+        if (path is not null && IsCurrent) DebugWorkingDirectory = path;
+    }
 
-        _projectService.CurrentChanged += OnProjectChanged;
-        _histories.Content.Changed += OnHistoryChanged;
+    public ProjectSettingsPanelViewModel(IProjectService projects, EditorHistories histories,
+        IEditorLocalizationService localization, IProjectContentSession session, EditorRegistry fieldEditors)
+    {
+        _projects = projects; _histories = histories; _session = session; L = localization; FieldEditors = fieldEditors;
+        _registration = session.RegisterDraft(() => HasDraft, CommitDraftAsync, LoadFromProject);
+        projects.CurrentChanged += OnProjectChanged;
+        histories.Content.Changed += OnHistoryChanged;
+        session.ExternalReloaded += LoadFromProject;
+        L.PropertyChanged += OnLocalizationChanged;
         LoadFromProject();
     }
 
-    public void Dispose()
+    private bool IsCurrent => !_disposed && _project is not null && ReferenceEquals(_project, _projects.Current);
+    private bool HasDraft => IsCurrent && (ProjectName != _originalName || Sections.Any(section => section.HasChanges));
+    partial void OnProjectNameChanged(string value) => RefreshDirty();
+    private void RefreshDirty()
     {
-        _projectService.CurrentChanged -= OnProjectChanged;
-        _draftRegistration.Dispose();
-        _histories.Content.Changed -= OnHistoryChanged;
-        L.PropertyChanged -= OnLocalizationChanged;
-        foreach (var track in AudioTracks) { track.Changed -= TriggerAutoSave; track.RemoveRequested = null; }
-        GC.SuppressFinalize(this);
+        if (_loading || _disposed) return;
+        UpdateStatus();
+        _session.Refresh();
     }
-
+    private void UpdateStatus() => IsDirtyText = _validationError is { } error
+        ? L.Format("Settings.Project.ApplyFailed", EditorText.Error(error).Render(L))
+        : HasDraft || _histories.Content.IsDirty ? L["Settings.Project.Unsaved"] : "";
+    private void OnLocalizationChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs args)
+    { if (args.PropertyName == "Item[]") UpdateStatus(); }
+    private void OnProjectChanged(GalProject? _) => LoadFromProject();
+    private void OnHistoryChanged() { if (!_histories.Content.IsBusy && !HasDraft) LoadFromProject(); }
     private void LoadFromProject()
     {
-        if (_projectService.Current is not { } project) return;
-        var settings = project.Settings;
-
-        _isLoading = true;
-        ProjectName = project.Name;
-        try
+        if (_disposed) return;
+        _loading = true;
+        _validationError = null;
+        foreach (var section in Sections) section.Dispose();
+        Sections.Clear();
+        _project = _projects.Current;
+        _originalName = _project?.Name ?? ""; ProjectName = _originalName;
+        TargetLocale = "";
+        DebugExecutable = DebugArguments = DebugWorkingDirectory = DebugConfigurationMessage = "";
+        if (_project is { } project)
         {
-            if (ExternalGameDebugClient.LoadSettings(project.RootPath) is { } launch)
+            if (project.Configurations.Sections.Any(section => section.Id == DefaultProjectConfiguration.Section.Id))
             {
-                DebugExecutable = launch.Executable;
-                DebugArguments = string.Join(Environment.NewLine, launch.Arguments ?? []);
-                DebugWorkingDirectory = launch.WorkingDirectory ?? "";
+                try { TargetLocale = project.Configuration.ReadDefaultOptions().TargetLocale.Code; }
+                catch (Exception error) when (error is System.IO.InvalidDataException or JsonException or ArgumentException) { }
             }
+            foreach (var section in project.Configurations.Sections)
+                Sections.Add(new(section, project.Configuration, FieldEditors, () => IsCurrent, RefreshDirty,
+                    field => section.Id != DefaultProjectConfiguration.Section.Id || field.Id is not ("targetLocale" or "availableLocales")));
+            try
+            {
+                if (ExternalGameDebugClient.LoadSettings(project.RootPath) is { } launch)
+                {
+                    DebugExecutable = launch.Executable; DebugArguments = string.Join(Environment.NewLine, launch.Arguments ?? []);
+                    DebugWorkingDirectory = launch.WorkingDirectory ?? "";
+                }
+            }
+            catch (Exception error) when (error is System.IO.IOException or JsonException or UnauthorizedAccessException)
+            { DebugConfigurationMessage = error.Message; }
         }
-        catch (Exception error) when (error is System.IO.IOException or System.Text.Json.JsonException or UnauthorizedAccessException) { DebugConfigurationMessage = error.Message; }
-        DefaultWidth = settings.DefaultWidth;
-        DefaultHeight = settings.DefaultHeight;
-        Resolution = $"{DefaultWidth}×{DefaultHeight}";
-        SaveSlotCount = settings.SaveSlotCount;
-        SfxChannelCount = settings.SfxChannelCount;
-        TargetLocale = settings.TargetLocale.Code;
-        foreach (var track in AudioTracks) track.Changed -= TriggerAutoSave;
-        AudioTracks.Clear();
-        foreach (var track in settings.AudioTracks)
-        {
-            var item = AttachTrack(AudioTrackEditorItem.From(track));
-            AudioTracks.Add(item);
-        }
-        _isLoading = false;
-        _hasDraft = false;
-        _validationError = null;
-        UpdateDirtyText();
-        DraftReset?.Invoke();
-    }
-
-    private Exception? _validationError;
-    private void UpdateDirtyText()
-    {
-        IsDirtyText = _validationError is { } error ? L.Format("Settings.Project.ApplyFailed", EditorText.Error(error).Render(L))
-            : _histories.Content.IsDirty ? L["Settings.Project.Unsaved"] : "";
+        _loading = false; RefreshDirty(); DraftReset?.Invoke();
     }
 
     [RelayCommand]
     private async Task SaveSettingsAsync()
     {
+        try { await CommitDraftAsync(); }
+        catch (Exception error) { _validationError = error; UpdateStatus(); }
+    }
+    public async Task CommitDraftAsync()
+    {
+        await _commitGate.WaitAsync();
+        try { await CommitDraftCoreAsync(); }
+        finally { _commitGate.Release(); }
+    }
+    private async Task CommitDraftCoreAsync()
+    {
+        if (!HasDraft) return;
         try
         {
-            if (_projectService.Current is not { } project) return;
             if (string.IsNullOrWhiteSpace(ProjectName)) throw new EditorOperationException("project.nameRequired", "Project name is required.");
-            string locale;
-            try { locale = new Core.I18n.I18nLocale(TargetLocale).Code; }
-            catch (Exception failure) when (failure is ArgumentException or FormatException)
-            { throw new EditorOperationException("settings.localeInvalid", failure.Message, TargetLocale); }
-            if (locale != project.Settings.TargetLocale.Code)
-                throw new EditorOperationException("i18n.development", L["I18n.UsePanel"]);
-            var before = SettingsSnapshot.From(project.Name, project.Settings);
-            var after = new SettingsSnapshot(ProjectName.Trim(), DefaultWidth, DefaultHeight, SaveSlotCount, SfxChannelCount, locale, AudioTracks.Select(item => item.ToDefinition()).ToArray());
-            ValidateTracks(after.AudioTracks);
-            if (before.Matches(after)) { LoadFromProject(); return; }
-            if (!NewProjectPanelViewModel.TryParseResolution($"{DefaultWidth}×{DefaultHeight}", out _, out _) || SaveSlotCount <= 0 || SfxChannelCount <= 0)
-                throw new EditorOperationException("settings.invalid", "Invalid project dimensions or channel/slot count.");
+            var project = _project!;
+            foreach (var section in Sections) await section.FlushAsync();
+            if (!IsCurrent) throw new EditorOperationException("settings.obsolete", "The project was closed.");
+            var next = project.Configuration.Clone();
+            foreach (var section in Sections) section.Apply(next);
             var graph = project.Services.GetRequiredService<IEditorDocumentService>().CurrentDocument;
-            await _histories.Content.ExecuteAsync(new SettingsEdit(project.Settings, graph, before, after));
+            var rename = ProjectName.Trim() != _originalName;
+            if (rename && graph.Name != _originalName) throw new EditorOperationException("settings.changed", "Project name changed. Cancel the draft and retry.");
+            var changes = Sections.Where(section => section.HasChanges).Select(section => section.Id).Distinct()
+                .Select(id => new SectionChange(id, project.Configuration.Sections.GetValueOrDefault(id), next.Sections.GetValueOrDefault(id))).ToArray();
+            if (rename || changes.Length != 0)
+                await _histories.Content.ExecuteAsync(new SettingsEdit(project.Configuration, graph, graph.Name,
+                    rename ? ProjectName.Trim() : graph.Name, changes));
             LoadFromProject();
-            UpdateDirtyText();
-            Log.Information("Project settings updated");
         }
-        catch (Exception ex)
+        catch (Exception error)
         {
-            _validationError = ex;
-            UpdateDirtyText();
-            Log.Error(ex, "Failed to save project settings");
+            _validationError = error; UpdateStatus();
+            throw;
         }
     }
-
-    partial void OnDefaultWidthChanged(int value) => TriggerAutoSave();
-    partial void OnProjectNameChanged(string value) => TriggerAutoSave();
-    partial void OnDefaultHeightChanged(int value) => TriggerAutoSave();
-    partial void OnResolutionChanged(string value)
-    {
-        if (_isLoading || !NewProjectPanelViewModel.TryParseResolution(value, out var width, out var height)) return;
-        _isLoading = true; DefaultWidth = width; DefaultHeight = height; _isLoading = false; TriggerAutoSave();
-    }
-    partial void OnSaveSlotCountChanged(int value) => TriggerAutoSave();
-    partial void OnSfxChannelCountChanged(int value) => TriggerAutoSave();
-    partial void OnTargetLocaleChanged(string value) => TriggerAutoSave();
-
+    [RelayCommand] private void CancelDraft() => LoadFromProject();
     [RelayCommand]
-    private void AddAudioTrack()
+    private void SaveDebugConfiguration()
     {
-        var item = new AudioTrackEditorItem
+        if (!IsCurrent) return;
+        try
         {
-            Id = $"track_{AudioTracks.Count + 1}",
-            Name = "New track",
-            Bus = GalNet.Core.Audio.AudioBuses.Sfx,
-            DefaultGain = 1,
-            MaxVoices = 1,
-            MaxQueuedItems = 0
-        };
-        AudioTracks.Add(AttachTrack(item));
-        TriggerAutoSave();
-    }
-
-    [RelayCommand]
-    private void RemoveAudioTrack(AudioTrackEditorItem? item)
-    {
-        if (item is null || !AudioTracks.Remove(item)) return;
-        item.Changed -= TriggerAutoSave;
-        TriggerAutoSave();
-    }
-
-    private AudioTrackEditorItem AttachTrack(AudioTrackEditorItem item)
-    {
-        item.Changed += TriggerAutoSave;
-        item.RemoveRequested = RemoveAudioTrack;
-        return item;
-    }
-
-    private static void ValidateTracks(IReadOnlyList<AudioTrackDefinition> tracks)
-    {
-        if (tracks.Count == 0) throw new EditorOperationException("settings.tracksRequired", "At least one audio track is required.");
-        if (tracks.Any(track => string.IsNullOrWhiteSpace(track.Id)) || tracks.Select(track => track.Id).Distinct(StringComparer.Ordinal).Count() != tracks.Count)
-            throw new EditorOperationException("settings.trackIds", "Audio track IDs must be non-empty and unique.");
-        if (tracks.Any(track => !GalNet.Core.Audio.AudioBuses.IsValid(track.Bus) || !float.IsFinite(track.DefaultGain) || track.DefaultGain < 0 || track.DefaultGain > 1 || track.MaxVoices <= 0 || track.MaxQueuedItems < 0))
-            throw new EditorOperationException("settings.trackInvalid", "Audio track configuration contains an invalid bus, gain, or voice limit.");
-    }
-
-    private void TriggerAutoSave()
-    {
-        if (_isLoading || _projectService.Current is null)
-            return;
-        _hasDraft = true;
-        if (HasDraftChanges) IsDirtyText = L["Settings.Project.Unsaved"];
-        else UpdateDirtyText();
-        _session.Refresh();
-    }
-
-    private void OnProjectChanged(Abstraction.Project.GalProject? _) => LoadFromProject();
-
-    private void OnHistoryChanged()
-    {
-        if (!_histories.Content.IsBusy && !HasDraftChanges) LoadFromProject();
-    }
-
-    private void OnLocalizationChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs args)
-    {
-        if (args.PropertyName == "Item[]") UpdateDirtyText();
+            ExternalGameDebugClient.SaveSettings(_project!.RootPath, new(DebugExecutable.Trim(),
+                DebugArguments.Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries),
+                string.IsNullOrWhiteSpace(DebugWorkingDirectory) ? null : DebugWorkingDirectory.Trim()));
+            DebugConfigurationMessage = "";
+        }
+        catch (Exception error) { DebugConfigurationMessage = error.Message; }
     }
-
-    [RelayCommand]
-    private void CancelDraft() { LoadFromProject(); _session.Refresh(); }
-
-    public async Task CommitDraftAsync()
+    public void Dispose()
     {
-        if (!HasDraftChanges) return;
-        await SaveSettingsAsync();
-        if (_hasDraft) throw _validationError ?? new EditorOperationException("settings.invalid", "Invalid settings draft.");
+        if (_disposed) return; _disposed = true;
+        _registration.Dispose(); _projects.CurrentChanged -= OnProjectChanged;
+        _histories.Content.Changed -= OnHistoryChanged; _session.ExternalReloaded -= LoadFromProject;
+        L.PropertyChanged -= OnLocalizationChanged;
+        foreach (var section in Sections) section.Dispose();
+        Sections.Clear(); _project = null;
+        GC.SuppressFinalize(this);
     }
 
-    private bool HasDraftChanges => _hasDraft && _projectService.Current is { } project &&
-        !SettingsSnapshot.From(project.Name, project.Settings).Matches(new((ProjectName ?? "").Trim(), DefaultWidth, DefaultHeight, SaveSlotCount,
-            SfxChannelCount, TargetLocale, AudioTracks.Select(item => item.ToDefinition()).ToArray()));
-
-    private sealed record SettingsEdit(Core.Settings.ProjectSettings Settings, EditorGraphDocument Graph, SettingsSnapshot Before, SettingsSnapshot After) : IUndoableEdit
+    private sealed record SectionChange(string Id, ProjectSectionData? Before, ProjectSectionData? After);
+    private sealed record SettingsEdit(ProjectConfiguration Configuration, EditorGraphDocument Graph,
+        string BeforeName, string AfterName, SectionChange[] Changes) : IUndoableEdit
     {
-        public long RetainedBytes => System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(Before).LongLength + System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(After).LongLength;
         public string Description => "Change project name and settings";
-        public void Undo() => Apply(After, Before);
-        public void Redo() => Apply(Before, After);
-        private void Apply(SettingsSnapshot expected, SettingsSnapshot value)
-        {
-            if (!SettingsSnapshot.From(Graph.Name, Settings).Matches(expected))
-                throw new EditorOperationException("settings.changed", "Project settings changed before this edit. Review the current values and retry.");
-            value.Apply(Settings);
-            Graph.Name = value.Name;
-        }
-    }
-
-    private sealed record SettingsSnapshot(string Name, int Width, int Height, int SaveSlots, int SfxChannels, string Locale, IReadOnlyList<AudioTrackDefinition> AudioTracks)
-    {
-        public static SettingsSnapshot From(string name, Core.Settings.ProjectSettings settings) =>
-            new(name, settings.DefaultWidth, settings.DefaultHeight, settings.SaveSlotCount, settings.SfxChannelCount, settings.TargetLocale.Code, settings.AudioTracks.Select(CopyTrack).ToArray());
-        public bool Matches(SettingsSnapshot other) =>
-            Name == other.Name && Width == other.Width && Height == other.Height && SaveSlots == other.SaveSlots && SfxChannels == other.SfxChannels && Locale == other.Locale &&
-            AudioTracks.Count == other.AudioTracks.Count && AudioTracks.Zip(other.AudioTracks).All(pair => Same(pair.First, pair.Second));
-        public void Apply(Core.Settings.ProjectSettings settings)
+        public long RetainedBytes => JsonSerializer.SerializeToUtf8Bytes(Changes).LongLength + (BeforeName.Length + AfterName.Length) * 2L;
+        public void Undo() => Apply(false);
+        public void Redo() => Apply(true);
+        private void Apply(bool forward)
         {
-            var locale = new Core.I18n.I18nLocale(Locale);
-            var tracks = AudioTracks.Select(CopyTrack).ToList();
-            settings.DefaultWidth = Width; settings.DefaultHeight = Height; settings.SaveSlotCount = SaveSlots;
-            settings.SfxChannelCount = SfxChannels; settings.TargetLocale = locale;
-            settings.AudioTracks = tracks;
+            if (BeforeName != AfterName && Graph.Name != (forward ? BeforeName : AfterName) ||
+                Changes.Any(change => !ConfigurationSectionEditor.Equal(Configuration.Sections.GetValueOrDefault(change.Id), forward ? change.Before : change.After)))
+                throw new EditorOperationException("settings.changed", "Project settings changed. Review the current values and retry.");
+            var next = Configuration.Clone();
+            foreach (var change in Changes)
+            {
+                if ((forward ? change.After : change.Before) is { } value) next.SetRaw(change.Id, value);
+                else next.Remove(change.Id);
+            }
+            Configuration.ReplaceFrom(next);
+            if (BeforeName != AfterName) Graph.Name = forward ? AfterName : BeforeName;
         }
-
-        private static bool Same(AudioTrackDefinition left, AudioTrackDefinition right) =>
-            left.Id == right.Id && left.Name == right.Name && left.Bus == right.Bus && left.DefaultGain == right.DefaultGain &&
-            left.MaxVoices == right.MaxVoices && left.MaxQueuedItems == right.MaxQueuedItems &&
-            left.OverflowPolicy == right.OverflowPolicy && left.QueueOverflowPolicy == right.QueueOverflowPolicy;
-        private static AudioTrackDefinition CopyTrack(AudioTrackDefinition track) => new()
-        {
-            Id = track.Id,
-            Name = track.Name,
-            Bus = track.Bus,
-            DefaultGain = track.DefaultGain,
-            MaxVoices = track.MaxVoices,
-            MaxQueuedItems = track.MaxQueuedItems,
-            OverflowPolicy = track.OverflowPolicy,
-            QueueOverflowPolicy = track.QueueOverflowPolicy
-        };
     }
 }
-
-public sealed partial class AudioTrackEditorItem : ObservableObject
-{
-    public event Action? Changed;
-    public Action<AudioTrackEditorItem>? RemoveRequested { get; set; }
-    [ObservableProperty] private string _id = "";
-    [ObservableProperty] private string _name = "";
-    [ObservableProperty] private string _bus = AudioBuses.Sfx;
-    [ObservableProperty] private double _defaultGain = 1;
-    [ObservableProperty] private int _maxVoices = 1;
-    [ObservableProperty] private int _maxQueuedItems;
-    [ObservableProperty] private AudioOverflowPolicy _overflowPolicy;
-    [ObservableProperty] private AudioQueueOverflowPolicy _queueOverflowPolicy;
-
-    public static AudioTrackEditorItem From(AudioTrackDefinition track) => new()
-    {
-        Id = track.Id,
-        Name = track.Name,
-        Bus = track.Bus,
-        DefaultGain = track.DefaultGain,
-        MaxVoices = track.MaxVoices,
-        MaxQueuedItems = track.MaxQueuedItems,
-        OverflowPolicy = track.OverflowPolicy,
-        QueueOverflowPolicy = track.QueueOverflowPolicy
-    };
-    public AudioTrackDefinition ToDefinition() => new()
-    {
-        Id = Id,
-        Name = Name,
-        Bus = Bus,
-        DefaultGain = (float)DefaultGain,
-        MaxVoices = MaxVoices,
-        MaxQueuedItems = MaxQueuedItems,
-        OverflowPolicy = OverflowPolicy,
-        QueueOverflowPolicy = QueueOverflowPolicy
-    };
-
-    [RelayCommand]
-    private void Remove() => RemoveRequested?.Invoke(this);
-
-    partial void OnIdChanged(string value) => Changed?.Invoke();
-    partial void OnNameChanged(string value) => Changed?.Invoke();
-    partial void OnBusChanged(string value) => Changed?.Invoke();
-    partial void OnDefaultGainChanged(double value) => Changed?.Invoke();
-    partial void OnMaxVoicesChanged(int value) => Changed?.Invoke();
-    partial void OnMaxQueuedItemsChanged(int value) => Changed?.Invoke();
-}
diff --git a/src/Editor/GalNet.Editor/ViewModels/ResourceOverridesPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/ResourceOverridesPanelViewModel.cs
new file mode 100644
index 00000000..a179ccaf
--- /dev/null
+++ b/src/Editor/GalNet.Editor/ViewModels/ResourceOverridesPanelViewModel.cs
@@ -0,0 +1,186 @@
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using Avalonia.Threading;
+using CommunityToolkit.Mvvm.ComponentModel;
+using GalNet.Core.Configuration;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Services;
+using GalNet.Editor.Services.Interfaces;
+using GalNet.Editor.Shared.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GalNet.Editor.ViewModels;
+
+public sealed class ResourcePatchColumn : ObservableObject
+{
+    public ResourceOverrideDefinition Definition { get; private set; }
+    public IReadOnlyDictionary<string, string> Mappings { get; private set; }
+    public string Id => Definition.Id;
+    public string Name => Definition.Name;
+    public int Priority => Definition.Priority;
+    public ResourcePatchColumn(ResourceOverrideDefinition definition)
+    { Definition = definition; Mappings = definition.Mappings; }
+    public void Accept(ResourceOverrideDefinition definition)
+    {
+        var nameChanged = Name != definition.Name;
+        var priorityChanged = Priority != definition.Priority;
+        Mappings = definition.Mappings;
+        Definition = definition;
+        if (nameChanged) OnPropertyChanged(nameof(Name));
+        if (priorityChanged) OnPropertyChanged(nameof(Priority));
+    }
+}
+
+public sealed partial class ResourceOverridesPanelViewModel : ObservableObject, IUndoRedoTarget, IDisposable
+{
+    private readonly IProjectService _projects;
+    private readonly IFileDialogService _dialogs;
+    private readonly SemaphoreSlim _actions = new(1, 1);
+    private readonly IEditorAssetChanges? _assetChanges;
+    private CancellationTokenSource? _refresh, _export;
+    private Task? _refreshTask;
+    private bool _disposed;
+    private long _revision;
+    private string _analysisMessage = "";
+    private string _structureKey = "";
+    public ResourceOverrideAuthoringService Service { get; }
+    public IEditorLocalizationService L { get; }
+    public IUndoRedoHistory UndoRedoHistory => Service.Histories.Content;
+    public ObservableCollection<ResourcePatchColumn> Columns { get; } = [];
+    public ObservableCollection<ResourceReferenceRow> Rows { get; } = [];
+    public event Action? StructureChanged;
+    [ObservableProperty] private string _message = "";
+    [ObservableProperty] private bool _busy;
+    public bool CanExport => !Busy;
+    partial void OnBusyChanged(bool value) => OnPropertyChanged(nameof(CanExport));
+    [ObservableProperty] private bool _showDependencies = true;
+    [ObservableProperty] private string _search = "";
+    private IReadOnlyList<ResourceReferenceRow> _allRows = [];
+    public ResourceOverridesPanelViewModel(ResourceOverrideAuthoringService service, IProjectService projects,
+        IFileDialogService dialogs, IEditorLocalizationService text)
+    {
+        Service = service; _projects = projects; _dialogs = dialogs; L = text;
+        service.Content.Changed += OnContentChanged;
+        _assetChanges = service.Assets as IEditorAssetChanges;
+        if (_assetChanges is not null) _assetChanges.Changed += RequestRefresh;
+        projects.CurrentChanged += ProjectChanged; L.PropertyChanged += LanguageChanged;
+        RequestRefresh();
+    }
+    partial void OnShowDependenciesChanged(bool value) => ShowRows();
+    partial void OnSearchChanged(string value) => ShowRows();
+    private void OnContentChanged() => RequestRefresh();
+    private void ProjectChanged(GalNet.Editor.Abstraction.Project.GalProject? _) => RequestRefresh();
+    private void LanguageChanged(object? sender, PropertyChangedEventArgs args) { if (args.PropertyName == "Item[]") StructureChanged?.Invoke(); }
+    public void RequestRefresh()
+    {
+        Interlocked.Increment(ref _revision);
+        Dispatcher.UIThread.Post(async () => await RefreshAsync());
+    }
+    public Task RefreshAsync()
+    {
+        if (_disposed) return Task.CompletedTask;
+        return _refreshTask is { IsCompleted: false } pending ? pending : _refreshTask = RefreshLoopAsync();
+    }
+    private async Task RefreshLoopAsync()
+    {
+        await Task.Yield();
+        if (_disposed) return;
+        _refresh?.Dispose(); var request = _refresh = new();
+        try
+        {
+            while (!_disposed)
+            {
+                var revision = Volatile.Read(ref _revision);
+                if (_projects.Current is null) { Columns.Clear(); Rows.Clear(); StructureChanged?.Invoke(); return; }
+                var snapshot = await Service.SnapshotAsync(request.Token);
+                if (_disposed || request.IsCancellationRequested) return;
+                if (revision != Volatile.Read(ref _revision)) continue;
+                var definitions = Service.Read().Packages;
+                foreach (var column in Columns.Where(column => definitions.All(definition => definition.Id != column.Id)).ToArray()) Columns.Remove(column);
+                foreach (var definition in definitions)
+                {
+                    var column = Columns.FirstOrDefault(column => column.Id == definition.Id);
+                    if (column is null) Columns.Add(new(definition)); else column.Accept(definition);
+                }
+                _allRows = snapshot.Rows; ShowRows();
+                var analysis = string.Join("\n", snapshot.Issues);
+                if (analysis.Length > 0 || Message == _analysisMessage) Message = analysis;
+                _analysisMessage = analysis;
+                return;
+            }
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception error) { if (!_disposed && !request.IsCancellationRequested) Message = EditorText.Error(error).Render(L); }
+    }
+    private void ShowRows()
+    {
+        var visible = _allRows.Where(row => (ShowDependencies || row.Uses.Any(use => use.Through is null)) &&
+            (row.Path.Contains(Search.Trim(), StringComparison.OrdinalIgnoreCase) || row.Id.Contains(Search.Trim(), StringComparison.OrdinalIgnoreCase))).ToArray();
+        var key = System.Text.Json.JsonSerializer.Serialize(new
+        {
+            rows = visible,
+            columns = Columns.Select(column => new
+            {
+                column.Id,
+                mappings = column.Mappings.OrderBy(pair => pair.Key, StringComparer.Ordinal).ToArray()
+            }),
+            ShowDependencies
+        });
+        if (key == _structureKey) return;
+        _structureKey = key;
+        Rows.Clear(); foreach (var row in visible) Rows.Add(row);
+        StructureChanged?.Invoke();
+    }
+    public async Task<bool> RunAsync(Func<Task> action, bool serialize = true)
+    {
+        if (_disposed) return false;
+        if (serialize) await _actions.WaitAsync();
+        try { if (_disposed) return false; Message = ""; await action(); return true; }
+        catch (OperationCanceledException) { Message = L["Packaging.Canceled"]; return false; }
+        catch (Exception error) { Message = EditorText.Error(error).Render(L); return false; }
+        finally { if (serialize) _actions.Release(); }
+    }
+    public async Task SetHeaderAsync(ResourcePatchColumn column, string name, int priority)
+    {
+        await RunAsync(() => Service.SetHeaderAsync(column.Id, name, priority));
+        await RefreshAsync();
+    }
+    public async Task CreateAsync() { await RunAsync(async () => await Service.CreateAsync(L["Packaging.NewPatch"])); }
+    public async Task DeleteAsync(string id) { await RunAsync(() => Service.DeleteAsync(id)); }
+    public Task AddOriginalAsync(string id) => RunAsync(() => Service.AddOriginalAsync(id));
+    public async Task SetMappingAsync(ResourcePatchColumn column, ResourceReferenceRow row, string target)
+    {
+        var expected = column.Mappings.GetValueOrDefault(row.Id);
+        await RunAsync(() => Service.SetMappingAsync(column.Id, row.Id, target, expected));
+        await RefreshAsync();
+    }
+    public async Task ExportAsync(string id)
+    {
+        if (Busy) return;
+        var target = await _dialogs.SaveFilePickerAsync(L["Packaging.Export"], "resource-" + id + ".pak");
+        if (target is null || _disposed) return;
+        _export = new(); Busy = true;
+        await _actions.WaitAsync(); _actions.Release();
+        await RunAsync(async () => { await Service.ExportAsync(id, target, _export.Token); Message = L["Packaging.Exported"] + " " + target; }, serialize: false);
+        Busy = false; _export.Dispose(); _export = null;
+    }
+    public void CancelExport() => _export?.Cancel();
+    public void Locate(ResourceReferenceRow row)
+    {
+        if (_projects.Current is not { } project || row.Missing) return;
+        var panel = project.Services.GetRequiredService<AssetPanelViewModel>();
+        project.Services.GetRequiredService<GalNet.Editor.Dock.EditorDockFactory>().OpenPanel(GalNet.Editor.Dock.EditorDockPanelIds.Assets);
+        panel.Navigate(Path.GetDirectoryName("Assets/" + row.Path)?.Replace('\\', '/') ?? "Assets");
+        if (panel.Entries.FirstOrDefault(item => item.Path == "Assets/" + row.Path) is { } entry) panel.Select(entry);
+    }
+    public void Dispose()
+    {
+        if (_disposed) return; _disposed = true;
+        _refresh?.Cancel(); _refresh?.Dispose(); _export?.Cancel();
+        Service.Content.Changed -= OnContentChanged;
+        if (_assetChanges is not null) _assetChanges.Changed -= RequestRefresh;
+        _projects.CurrentChanged -= ProjectChanged; L.PropertyChanged -= LanguageChanged;
+        StructureChanged = null;
+    }
+}
diff --git a/src/Editor/GalNet.Editor/ViewModels/TimelinePanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/TimelinePanelViewModel.cs
index 96d42795..dd37c65f 100644
--- a/src/Editor/GalNet.Editor/ViewModels/TimelinePanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/TimelinePanelViewModel.cs
@@ -15,7 +15,5 @@ public sealed partial class TimelinePanelViewModel(TimelineEditSession session,
     [RelayCommand] private void DeleteKeys() => Session.DeleteSelectedKeys();
     [RelayCommand] private void PreviousKey() => Session.NavigateKey(-1);
     [RelayCommand] private void NextKey() => Session.NavigateKey(1);
-    [RelayCommand] private void ReplaceCollisions() => Session.ReplaceKeyCollisions();
-    [RelayCommand] private void CancelMove() => Session.Canvas.Cancel();
     public void Dispose() => Session.CancelInput();
 }
diff --git a/src/Editor/GalNet.Editor/ViewModels/VariableListEditorViewModels.cs b/src/Editor/GalNet.Editor/ViewModels/VariableListEditorViewModels.cs
deleted file mode 100644
index 1bbfcf20..00000000
--- a/src/Editor/GalNet.Editor/ViewModels/VariableListEditorViewModels.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-using CommunityToolkit.Mvvm.ComponentModel;
-using GalNet.Core.Variable;
-
-namespace GalNet.Editor.ViewModels;
-
-/// <summary>Preview values only. Declaration editing belongs to the project Variables panel.</summary>
-public sealed class VariableListEditorViewModel : ObservableObject
-{
-    public IReadOnlyList<VariableEditorItemViewModel> Items { get; }
-    public bool ShowCurrentValue { get; private set; }
-
-    public VariableListEditorViewModel(IReadOnlyList<ProjectVariableDefinition> definitions, bool showCurrentValue,
-        Func<string, Variable?> getCurrentValue, Action<string, object> setCurrentValue)
-    {
-        ShowCurrentValue = showCurrentValue;
-        Items = definitions.Select(definition =>
-        {
-            var name = definition.Name;
-            return new VariableEditorItemViewModel(definition, showCurrentValue,
-                getCurrentValue(name), value => setCurrentValue(name, value));
-        }).ToArray();
-    }
-
-    public void SetCurrentValueVisibility(bool visible)
-    {
-        ShowCurrentValue = visible;
-        OnPropertyChanged(nameof(ShowCurrentValue));
-        foreach (var item in Items) item.SetCurrentValueVisible(visible);
-    }
-
-    public void UpdateCurrentValue(string name, Variable variable) =>
-        Items.FirstOrDefault(item => item.Name == name)?.SetCurrentValue(variable);
-}
-
-/// <summary>Detached declaration metadata and an editable copy of a runtime value.</summary>
-public sealed class VariableEditorItemViewModel : ObservableObject
-{
-    private readonly Action<object> _write;
-    private Variable _currentValue;
-    public string Name { get; }
-    public VariableType SelectedType { get; }
-    public string DefaultValueText { get; }
-    public bool CanEditCurrentValue { get; private set; }
-    public bool IsBool => SelectedType == VariableType.Bool;
-    public bool IsInt => SelectedType == VariableType.Int;
-    public bool IsFloat => SelectedType == VariableType.Float;
-    public bool IsString => SelectedType == VariableType.String;
-
-    public VariableEditorItemViewModel(ProjectVariableDefinition definition, bool showCurrentValue,
-        Variable? currentValue, Action<object> write)
-    {
-        Name = definition.Name;
-        SelectedType = definition.Type;
-        DefaultValueText = definition.DefaultValue.Value.Serialize();
-        _currentValue = (currentValue ?? definition.DefaultValue).Clone();
-        CanEditCurrentValue = showCurrentValue;
-        _write = write;
-    }
-
-    public bool CurrentBoolValue { get => _currentValue.AsBool(); set => Commit(value); }
-    public decimal CurrentIntValue { get => _currentValue.AsInt(); set => Commit((int)value); }
-    public decimal CurrentFloatValue { get => (decimal)_currentValue.AsFloat(); set => Commit((float)value); }
-    public string CurrentStringValue { get => _currentValue.AsString(); set => Commit(value ?? string.Empty); }
-
-    private void Commit(object value)
-    {
-        if (!CanEditCurrentValue) return;
-        _currentValue.SetValue(value);
-        _write(value);
-    }
-
-    public void SetCurrentValueVisible(bool visible)
-    {
-        CanEditCurrentValue = visible;
-        OnPropertyChanged(nameof(CanEditCurrentValue));
-    }
-
-    public void SetCurrentValue(Variable variable)
-    {
-        _currentValue = variable.Clone();
-        OnPropertyChanged(nameof(CurrentBoolValue));
-        OnPropertyChanged(nameof(CurrentIntValue));
-        OnPropertyChanged(nameof(CurrentFloatValue));
-        OnPropertyChanged(nameof(CurrentStringValue));
-    }
-}
diff --git a/src/Editor/GalNet.Editor/ViewModels/VariablesPanelViewModel.cs b/src/Editor/GalNet.Editor/ViewModels/VariablesPanelViewModel.cs
index aedc7d2c..04ce43f1 100644
--- a/src/Editor/GalNet.Editor/ViewModels/VariablesPanelViewModel.cs
+++ b/src/Editor/GalNet.Editor/ViewModels/VariablesPanelViewModel.cs
@@ -10,7 +10,7 @@
 
 namespace GalNet.Editor.ViewModels;
 
-public sealed record VariableDefinitionRow(string Uid, string Name, string Description);
+public sealed record VariableDefinitionRow(string Uid, string Name, string Description, string Type);
 public sealed record VariableTypeOption(VariableType Value, string LabelKey);
 
 public sealed partial class VariablesPanelViewModel : ObservableObject, IUndoRedoTarget, IDisposable
@@ -20,6 +20,7 @@ public sealed partial class VariablesPanelViewModel : ObservableObject, IUndoRed
     private readonly VariableAuthoringService _authoring;
     private readonly IVariableDefinitionService _definitions;
     private readonly IEditorLocalizationService _localization;
+    private readonly VariablePanelState _state;
     public IUndoRedoHistory UndoRedoHistory { get; }
     private ProjectVariableDefinition? _baseline;
     private bool _refreshing;
@@ -36,7 +37,11 @@ public sealed partial class VariablesPanelViewModel : ObservableObject, IUndoRed
     [ObservableProperty] private string _draftDescription = "";
     [ObservableProperty] private VariableTypeOption? _draftType;
     [ObservableProperty] private string _messageText = "";
+    [ObservableProperty] private string _search = "";
     public bool HasSelection => Selected is not null;
+    public bool HasRows => Rows.Count > 0;
+    public bool HasChanges => HasDraftChanges;
+    public bool MissingSelection => _state.Selection.TryGetValue(Scope, out var uid) && _state.Drafts.ContainsKey((Scope, uid)) && !_authoring.Get(Scope).Any(item => item.DefaultValue.Uid == uid);
     public string ScopeHintKey => ScopeIndex == 0 ? "Variables.PlayerHint" : "Variables.SaveHint";
     public string DefaultHintKey => "Variables.DefaultHint." + (DraftType?.Value ?? VariableType.String);
     public bool IsBooleanDefault => DraftType?.Value == VariableType.Bool;
@@ -46,21 +51,44 @@ public sealed partial class VariablesPanelViewModel : ObservableObject, IUndoRed
     public bool DraftBoolean
     {
         get => bool.TryParse(DraftDefault, out var value) && value;
-        set => DraftDefault = value ? "true" : "false";
+        set { if (IsBooleanDefault && !_refreshing) DraftDefault = value ? "true" : "false"; }
+    }
+    public string? NumericDefaultText
+    {
+        get => IsNumericDefault ? DraftDefault : "";
+        set { if (IsNumericDefault && !_refreshing) DraftDefault = value ?? ""; }
+    }
+    public string? StringDefaultText
+    {
+        get => IsTextDefault ? DraftDefault : "";
+        set { if (IsTextDefault && !_refreshing) DraftDefault = value ?? ""; }
     }
     private VariableScope Scope => ScopeIndex == 0 ? VariableScope.Player : VariableScope.Save;
-    public VariablesPanelViewModel(VariableAuthoringService authoring, IVariableDefinitionService definitions, IEditorLocalizationService localization, EditorHistories histories)
+    public VariablesPanelViewModel(VariableAuthoringService authoring, IVariableDefinitionService definitions, IEditorLocalizationService localization, EditorHistories histories, VariablePanelState state)
     {
-        _authoring = authoring; _definitions = definitions; _localization = localization; UndoRedoHistory = histories.Content;
+        _authoring = authoring; _definitions = definitions; _localization = localization; _state = state; UndoRedoHistory = histories.Content;
+        _refreshing = true; ScopeIndex = state.ScopeIndex; Search = state.Search; _refreshing = false;
         definitions.DefinitionsChanged += OnDefinitionsChanged;
         localization.PropertyChanged += OnLocaleChanged;
         Refresh();
     }
-    partial void OnScopeIndexChanged(int value) { if (!_refreshing) { _baseline = null; Selected = null; Refresh(); OnPropertyChanged(nameof(ScopeHintKey)); } }
+    partial void OnScopeIndexChanging(int value) { if (!_refreshing) SaveDraft(); }
+    partial void OnScopeIndexChanged(int value)
+    {
+        if (_refreshing) return;
+        _state.ScopeIndex = value; _refreshing = true; _baseline = null; Selected = null; _refreshing = false;
+        Refresh(); OnPropertyChanged(nameof(ScopeHintKey)); _message = null; RenderMessage();
+    }
+    partial void OnSearchChanged(string value) { if (!_refreshing) { _state.Search = value; Refresh(); } }
+    partial void OnSelectedChanging(VariableDefinitionRow? value) { if (!_refreshing) SaveDraft(); }
     partial void OnSelectedChanged(VariableDefinitionRow? value)
     {
         OnPropertyChanged(nameof(HasSelection));
-        if (!_refreshing) { LoadDraft(); RefreshReferences(); _message = null; RenderMessage(); }
+        if (!_refreshing)
+        {
+            if (value is not null) _state.Selection[Scope] = value.Uid;
+            LoadDraft(); RefreshReferences(); _message = null; RenderMessage();
+        }
     }
     partial void OnDraftTypeChanged(VariableTypeOption? value)
     {
@@ -70,23 +98,39 @@ partial void OnDraftTypeChanged(VariableTypeOption? value)
         OnPropertyChanged(nameof(IsNumericDefault));
         OnPropertyChanged(nameof(IsTextDefault));
         OnPropertyChanged(nameof(DefaultIncrement));
+        OnPropertyChanged(nameof(NumericDefaultText)); OnPropertyChanged(nameof(StringDefaultText));
+        DraftChanged();
     }
-    partial void OnDraftDefaultChanged(string value) => OnPropertyChanged(nameof(DraftBoolean));
+    partial void OnDraftDefaultChanged(string value)
+    { OnPropertyChanged(nameof(DraftBoolean)); OnPropertyChanged(nameof(NumericDefaultText)); OnPropertyChanged(nameof(StringDefaultText)); DraftChanged(); }
+    partial void OnDraftNameChanged(string value) => DraftChanged();
+    partial void OnDraftDescriptionChanged(string value) => DraftChanged();
+    private void DraftChanged() { OnPropertyChanged(nameof(HasChanges)); }
     private bool HasDraftChanges => _baseline is not null && (DraftName != _baseline.Name || DraftDescription != _baseline.Description || DraftType?.Value != _baseline.Type || DraftDefault != VariableAuthoringService.DefaultText(_baseline));
     private void OnDefinitionsChanged(VariableScope _) => Refresh();
     private void Refresh()
     {
         if (_disposed) return;
-        var uid = Selected?.Uid; var preserve = !_applying && HasDraftChanges;
+        if (!_applying) SaveDraft();
+        _state.Selection.TryGetValue(Scope, out var uid);
         _refreshing = true;
         try
         {
-            Rows.Clear(); foreach (var value in _authoring.Get(Scope)) Rows.Add(new(value.DefaultValue.Uid, value.Name, value.Description));
+            Rows.Clear(); foreach (var value in _authoring.Get(Scope).Where(item => item.Name.Contains(Search, StringComparison.OrdinalIgnoreCase) || item.Description.Contains(Search, StringComparison.OrdinalIgnoreCase)))
+                Rows.Add(new(value.DefaultValue.Uid, value.Name, value.Description, value.Type.ToString()));
             Selected = Rows.FirstOrDefault(row => row.Uid == uid);
-            if (!preserve || Selected is null) LoadDraft();
+            LoadDraft();
         }
         finally { _refreshing = false; }
         RefreshReferences();
+        OnPropertyChanged(nameof(HasRows)); OnPropertyChanged(nameof(MissingSelection));
+    }
+    private void SaveDraft()
+    {
+        if (Selected is null || _baseline is null) return;
+        var key = (Scope, Selected.Uid);
+        if (HasDraftChanges) _state.Drafts[key] = new(_baseline.Clone(), DraftName, DraftType!.Value, DraftDefault, DraftDescription);
+        else _state.Drafts.Remove(key);
     }
     private void LoadDraft()
     {
@@ -94,27 +138,40 @@ private void LoadDraft()
         try
         {
             _baseline = _authoring.Get(Scope).FirstOrDefault(item => item.DefaultValue.Uid == Selected?.Uid)?.Clone();
+            var draft = Selected is not null ? _state.Drafts.GetValueOrDefault((Scope, Selected.Uid)) : null;
+            if (draft is not null) _baseline = draft.Baseline.Clone();
             DraftName = _baseline?.Name ?? ""; DraftDescription = _baseline?.Description ?? "";
             DraftType = Types.Single(item => item.Value == (_baseline?.Type ?? VariableType.String));
             DraftDefault = _baseline is null ? "" : VariableAuthoringService.DefaultText(_baseline);
+            if (draft is not null)
+            { DraftName = draft.Name; DraftDescription = draft.Description; DraftType = Types.Single(item => item.Value == draft.Type); DraftDefault = draft.Default; }
         }
         finally { _refreshing = wasRefreshing; }
+        DraftChanged();
     }
     [RelayCommand]
     private void AddVariable() => Run(() =>
     {
+        Search = "";
         var value = _authoring.Add(Scope); Refresh(); Selected = Rows.Single(row => row.Uid == value.DefaultValue.Uid);
     });
     [RelayCommand]
     private void Apply() => Run(() =>
     {
         if (Selected is null || _baseline is null) return;
-        var warnings = _authoring.Update(Scope, Selected.Uid, DraftName, DraftType!.Value, DraftDefault, DraftDescription, JsonSerializer.Serialize(_baseline));
-        LoadDraft();
+        var uid = Selected.Uid;
+        var warnings = _authoring.Update(Scope, uid, DraftName, DraftType!.Value, DraftDefault, DraftDescription, JsonSerializer.Serialize(_baseline));
+        _state.Drafts.Remove((Scope, uid)); Search = ""; Refresh();
         if (warnings.Count > 0) { References.Clear(); foreach (var warning in warnings) References.Add(warning); _message = new("Variables.Candidates", warnings.Count); }
     });
     [RelayCommand] private void DeleteVariable() => Run(() => { if (Selected is not null) _authoring.Delete(Scope, Selected.Uid); });
-    [RelayCommand] private void Revert() { LoadDraft(); _message = null; RenderMessage(); RefreshReferences(); }
+    [RelayCommand]
+    private void Revert()
+    {
+        if (Selected is not null) _state.Drafts.Remove((Scope, Selected.Uid));
+        else if (_state.Selection.Remove(Scope, out var uid)) _state.Drafts.Remove((Scope, uid));
+        LoadDraft(); _message = null; RenderMessage(); RefreshReferences(); OnPropertyChanged(nameof(MissingSelection));
+    }
     [RelayCommand] private void CheckReferences() => RefreshReferences();
     private void RefreshReferences()
     {
@@ -124,7 +181,7 @@ private void RefreshReferences()
     private void Run(Action action)
     {
         if (_disposed) return;
-        _applying = true; _message = null;
+        SaveDraft(); _applying = true; _message = null;
         try { action(); }
         catch (Exception failure) { _message = EditorText.Error(failure); }
         finally { _applying = false; RenderMessage(); }
@@ -133,7 +190,7 @@ private void Run(Action action)
     private void RenderMessage() => MessageText = _message?.Render(_localization) ?? "";
     public void Dispose()
     {
-        if (_disposed) return; _disposed = true;
+        if (_disposed) return; SaveDraft(); _disposed = true;
         _definitions.DefinitionsChanged -= OnDefinitionsChanged; _localization.PropertyChanged -= OnLocaleChanged;
     }
 }
diff --git a/src/Editor/GalNet.Editor/Views/AssetPanelView.axaml b/src/Editor/GalNet.Editor/Views/AssetPanelView.axaml
index 3330edda..8f56488e 100644
--- a/src/Editor/GalNet.Editor/Views/AssetPanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/AssetPanelView.axaml
@@ -49,7 +49,7 @@
         <TreeView.Styles><Style Selector="TreeViewItem"><Setter Property="IsExpanded" Value="{ReflectionBinding IsExpanded,Mode=TwoWay}" /></Style></TreeView.Styles>
         <TreeView.DataTemplates>
           <TreeDataTemplate DataType="model:ProjectDirectoryNode" ItemsSource="{Binding Children}">
-            <Border Padding="3" DragDrop.AllowDrop="True" DragDrop.DragOver="OnTargetDragOver" DragDrop.DragLeave="OnTargetDragLeave" DragDrop.Drop="OnTargetDrop"><TextBlock Text="{Binding Name}" /></Border>
+            <Border Padding="3" DragDrop.AllowDrop="True" DragDrop.DragOver="OnTargetDragOver" DragDrop.DragLeave="OnTargetDragLeave" DragDrop.Drop="OnTargetDrop"><StackPanel Orientation="Horizontal" Spacing="5"><PathIcon Data="{Binding IconGeometry}" Width="16" Height="16"/><TextBlock Text="{Binding Name}" /></StackPanel></Border>
           </TreeDataTemplate>
         </TreeView.DataTemplates>
       </TreeView>
@@ -89,8 +89,8 @@
               <MenuItem Header="{loc:Localize Asset.Menu.OpenInExplorer}" Command="{Binding #Root.DataContext.ShowInExplorerCommand}" CommandParameter="{Binding}" />
             </ContextMenu></Border.ContextMenu>
             <Grid RowDefinitions="*,Auto">
-              <Border Background="{DynamicResource SemiColorFill0}" CornerRadius="4" IsVisible="{Binding !#Root.DataContext.IsListView}"><Grid><TextBlock Text="{Binding Icon}" FontSize="38" HorizontalAlignment="Center" VerticalAlignment="Center" /><Image Source="{Binding Thumbnail}" Stretch="Uniform" /></Grid></Border>
-              <TextBlock Text="{Binding Path}" IsVisible="{Binding #Root.DataContext.IsListView}" TextTrimming="CharacterEllipsis" Foreground="{DynamicResource SemiColorText2}" FontSize="11"/>
+              <Border Background="{DynamicResource SemiColorFill0}" CornerRadius="4" IsVisible="{Binding !#Root.DataContext.IsListView}"><Grid><PathIcon Data="{Binding IconGeometry}" Width="38" Height="38" HorizontalAlignment="Center" VerticalAlignment="Center" /><Image Source="{Binding Thumbnail}" Stretch="Uniform" /></Grid></Border>
+              <StackPanel Orientation="Horizontal" Spacing="5" IsVisible="{Binding #Root.DataContext.IsListView}"><PathIcon Data="{Binding IconGeometry}" Width="16" Height="16"/><TextBlock Text="{Binding Path}" TextTrimming="CharacterEllipsis" Foreground="{DynamicResource SemiColorText2}" FontSize="11"/></StackPanel>
               <TextBlock Grid.Row="1" Text="{Binding Name}" TextTrimming="CharacterEllipsis" HorizontalAlignment="Center" IsVisible="{Binding !IsRenaming}" />
               <TextBox Grid.Row="1" Text="{Binding #Root.DataContext.RenameText,Mode=TwoWay}" IsVisible="{Binding IsRenaming}" AttachedToVisualTree="OnRenameAttached" PropertyChanged="OnRenamePropertyChanged" KeyDown="OnRenameKeyDown" LostFocus="OnRenameLostFocus" />
             </Grid>
diff --git a/src/Editor/GalNet.Editor/Views/CharactersPanelView.axaml b/src/Editor/GalNet.Editor/Views/CharactersPanelView.axaml
index 62f39554..5c4f0f43 100644
--- a/src/Editor/GalNet.Editor/Views/CharactersPanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/CharactersPanelView.axaml
@@ -3,27 +3,36 @@
              xmlns:loc="clr-namespace:GalNet.Editor.MarkupExtensions"
              x:Class="GalNet.Editor.Views.CharactersPanelView" x:DataType="vm:CharactersPanelViewModel">
   <Grid RowDefinitions="Auto,Auto,*,Auto,Auto" Margin="12" RowSpacing="8">
-    <DockPanel><Button x:Name="AddCharacter" DockPanel.Dock="Right" Content="{loc:Localize Characters.Add}" Command="{Binding AddCommand}"/>
+    <Grid.Resources><ResourceDictionary><ResourceDictionary.MergedDictionaries><ResourceInclude Source="avares://GalNet.Editor/Themes/AuthoringPanelResources.axaml"/></ResourceDictionary.MergedDictionaries></ResourceDictionary></Grid.Resources>
+    <DockPanel><Button x:Name="AddCharacter" DockPanel.Dock="Right" Theme="{StaticResource EditorIconButton}" Command="{Binding AddCommand}" ToolTip.Tip="{loc:Localize Characters.Add}" AutomationProperties.Name="{loc:Localize Characters.Add}" Click="OnCharacterAdded"><PathIcon Width="16" Height="16" Data="{StaticResource AddIcon}"/></Button>
       <TextBox x:Name="CharacterSearch" Text="{Binding Search}" PlaceholderText="{loc:Localize Characters.Search}" Margin="0,0,8,0"/>
     </DockPanel>
-    <Grid Grid.Row="1" ColumnDefinitions="*,*"><TextBlock Text="{loc:Localize Characters.Name}"/><TextBlock Grid.Column="1" Text="{loc:Localize Characters.Key}"/></Grid>
-    <ListBox x:Name="CharacterRows" Grid.Row="2" ItemsSource="{Binding Rows}" SelectedItem="{Binding Selected}">
+    <TextBlock Grid.Row="1" Text="{loc:Localize Characters.Name}" Foreground="{DynamicResource SemiColorText2}"/>
+    <Grid Grid.Row="2">
+    <ListBox x:Name="CharacterRows" ItemsSource="{Binding Rows}" SelectedItem="{Binding Selected}">
       <ListBox.Styles><Style Selector="ListBoxItem"><Setter Property="HorizontalContentAlignment" Value="Stretch"/></Style></ListBox.Styles>
-      <ListBox.ItemTemplate><DataTemplate x:DataType="services:CharacterRow"><Grid ColumnDefinitions="*,*" ColumnSpacing="12">
-        <TextBlock Text="{Binding DisplayName}" TextWrapping="Wrap"/><TextBlock Grid.Column="1" Text="{Binding Id}" TextWrapping="Wrap"/>
-      </Grid></DataTemplate></ListBox.ItemTemplate>
+      <ListBox.ItemTemplate><DataTemplate x:DataType="services:CharacterRow"><StackPanel Spacing="2">
+        <TextBlock Text="{Binding DisplayName}" TextTrimming="CharacterEllipsis" ToolTip.Tip="{Binding DisplayName}"/><TextBlock Text="{Binding Id}" Foreground="{DynamicResource SemiColorText2}" FontSize="11" TextTrimming="CharacterEllipsis" ToolTip.Tip="{Binding Id}"/>
+      </StackPanel></DataTemplate></ListBox.ItemTemplate>
     </ListBox>
+    <TextBlock Text="{loc:Localize Uiux.Panel.NoResults}" IsVisible="{Binding !HasRows}" VerticalAlignment="Center" HorizontalAlignment="Center" TextWrapping="Wrap" Margin="8" Foreground="{DynamicResource SemiColorText2}"/>
+    </Grid>
     <StackPanel Grid.Row="3" Spacing="6">
       <TextBlock Text="{loc:Localize Characters.Incomplete}" IsVisible="{Binding Incomplete}" TextWrapping="Wrap"/>
-      <Grid ColumnDefinitions="*,*" ColumnSpacing="12" IsEnabled="{Binding CanEdit}">
-        <TextBox x:Name="CharacterName" Text="{Binding DraftName}" PlaceholderText="{loc:Localize Characters.Name}"/>
-        <TextBox x:Name="CharacterKey" Grid.Column="1" Text="{Binding DraftKey}" PlaceholderText="{loc:Localize Characters.AutoKey}"/>
-      </Grid>
-      <WrapPanel>
-        <Button x:Name="ApplyCharacter" Content="{loc:Localize Characters.Apply}" Command="{Binding ApplyCommand}" IsEnabled="{Binding CanEdit}" Margin="0,0,8,0"/>
-        <Button Content="{loc:Localize Characters.Revert}" Command="{Binding RevertCommand}" Margin="0,0,8,0"/>
-        <Button x:Name="DeleteCharacter" Content="{loc:Localize Characters.Delete}" Command="{Binding DeleteCommand}" IsEnabled="{Binding CanDelete}"/>
-      </WrapPanel>
+      <TextBlock Text="{Binding IncompleteDetails}" IsVisible="{Binding Incomplete}" TextWrapping="Wrap" FontSize="11" Foreground="{DynamicResource SemiColorText2}"/>
+      <TextBlock Text="{loc:Localize Uiux.Panel.SelectItem}" IsVisible="{Binding !HasEditor}" TextWrapping="Wrap" Foreground="{DynamicResource SemiColorText2}"/>
+      <StackPanel IsVisible="{Binding HasEditor}" Spacing="6" IsEnabled="{Binding CanEdit}">
+        <TextBlock Text="{loc:Localize Characters.Name}" FontSize="12"/>
+        <TextBox x:Name="CharacterName" Text="{Binding DraftName}"/>
+        <TextBlock Text="{loc:Localize Characters.Key}" FontSize="12"/>
+        <TextBox x:Name="CharacterKey" Text="{Binding DraftKey}" PlaceholderText="{loc:Localize Characters.AutoKey}"/>
+      </StackPanel>
+      <StackPanel Orientation="Horizontal" Spacing="4" IsVisible="{Binding HasEditor}">
+        <Button x:Name="ApplyCharacter" Theme="{StaticResource EditorIconButton}" Command="{Binding ApplyCommand}" IsEnabled="{Binding CanEdit}" ToolTip.Tip="{loc:Localize Characters.Apply}" AutomationProperties.Name="{loc:Localize Characters.Apply}"><PathIcon Width="16" Height="16" Data="{StaticResource PanelApplyIcon}"/></Button>
+        <Button Theme="{StaticResource EditorIconButton}" Command="{Binding RevertCommand}" ToolTip.Tip="{loc:Localize Characters.Revert}" AutomationProperties.Name="{loc:Localize Characters.Revert}"><PathIcon Width="16" Height="16" Data="{StaticResource ResetIcon}"/></Button>
+        <Button x:Name="DeleteCharacter" Theme="{StaticResource EditorIconButton}" Command="{Binding DeleteCommand}" IsEnabled="{Binding CanDelete}" ToolTip.Tip="{loc:Localize DeleteHintKey}" AutomationProperties.Name="{loc:Localize Characters.Delete}"><PathIcon Width="16" Height="16" Data="{StaticResource DeleteRegularIcon}"/></Button>
+        <TextBlock Text="{loc:Localize Uiux.Panel.Unapplied}" IsVisible="{Binding HasDraft}" VerticalAlignment="Center" Foreground="{DynamicResource SemiColorText2}"/>
+      </StackPanel>
     </StackPanel>
     <TextBlock Grid.Row="4" Text="{Binding Message}" TextWrapping="Wrap" Foreground="{DynamicResource SystemControlErrorTextForegroundBrush}"/>
   </Grid>
diff --git a/src/Editor/GalNet.Editor/Views/CharactersPanelView.axaml.cs b/src/Editor/GalNet.Editor/Views/CharactersPanelView.axaml.cs
index 00b3c6c5..9d56db77 100644
--- a/src/Editor/GalNet.Editor/Views/CharactersPanelView.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/CharactersPanelView.axaml.cs
@@ -1,8 +1,11 @@
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Threading;
 
 namespace GalNet.Editor.Views;
 
 public partial class CharactersPanelView : UserControl
 {
     public CharactersPanelView() => InitializeComponent();
+    private void OnCharacterAdded(object? sender, RoutedEventArgs e) => Dispatcher.UIThread.Post(() => { CharacterName.Focus(); CharacterName.SelectAll(); });
 }
diff --git a/src/Editor/GalNet.Editor/Views/EditorPageView.axaml b/src/Editor/GalNet.Editor/Views/EditorPageView.axaml
index b4465ead..9dac9540 100644
--- a/src/Editor/GalNet.Editor/Views/EditorPageView.axaml
+++ b/src/Editor/GalNet.Editor/Views/EditorPageView.axaml
@@ -8,13 +8,20 @@
              x:Class="GalNet.Editor.Views.EditorPageView"
              x:DataType="vm:EditorPageViewModel">
 
-    <Grid RowDefinitions="*,Auto" Background="{DynamicResource SemiColorBackground0}">
+    <Grid RowDefinitions="*,Auto,Auto" Background="{DynamicResource SemiColorBackground0}">
         <DockControl Name="DockHost" Grid.Row="0"
                      Margin="0,30,0,0"
                      Layout="{Binding Layout}"
                      Background="{DynamicResource SemiColorBackground0}" />
 
-        <Border Grid.Row="1"
+        <Border Grid.Row="1" IsVisible="{Binding HasExternalIssue}" Padding="12,8" Background="{DynamicResource SemiColorBackground1}">
+            <Grid ColumnDefinitions="*,Auto,Auto" ColumnSpacing="12">
+                <StackPanel Spacing="3"><TextBlock Text="{Binding ExternalStatus}" TextWrapping="Wrap"/><TextBlock Text="{Binding ExternalDetails}" TextWrapping="Wrap" FontSize="11"/></StackPanel>
+                <Button Grid.Column="1" Command="{Binding RetryExternalChangesCommand}" Content="{Binding L[External.Retry]}" VerticalAlignment="Center"/>
+                <Button Grid.Column="2" Command="{Binding ReloadExternalChangesCommand}" IsEnabled="{Binding CanReloadExternal}" Content="{Binding L[External.Reload]}" VerticalAlignment="Center"/>
+            </Grid>
+        </Border>
+        <Border Grid.Row="2"
                 Background="{DynamicResource SemiColorBackground1}"
                 BorderBrush="{DynamicResource SemiColorBorder}"
                 BorderThickness="0,1,0,0"
diff --git a/src/Editor/GalNet.Editor/Views/EditorSettingsPanelView.axaml b/src/Editor/GalNet.Editor/Views/EditorSettingsPanelView.axaml
index 113f548f..6a899eec 100644
--- a/src/Editor/GalNet.Editor/Views/EditorSettingsPanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/EditorSettingsPanelView.axaml
@@ -44,6 +44,7 @@
                         </DataTemplate>
                     </ComboBox.ItemTemplate>
                 </ComboBox>
+                <CheckBox Name="ExpandNewEntries" Content="{loc:Localize Settings.ExpandNewEntries}" IsChecked="{Binding ExpandNewEntries,Mode=TwoWay}"/>
                 <!-- Auto-save is intentionally forced on for the current editor experience. -->
 
                 <Separator Margin="0,10,0,6" />
diff --git a/src/Editor/GalNet.Editor/Views/ExportPanelView.axaml b/src/Editor/GalNet.Editor/Views/ExportPanelView.axaml
index 1ae7379f..dcaa2750 100644
--- a/src/Editor/GalNet.Editor/Views/ExportPanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/ExportPanelView.axaml
@@ -1 +1,52 @@
-<UserControl xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:loc="using:GalNet.Editor.MarkupExtensions" xmlns:vm="using:GalNet.Editor.ViewModels" x:Class="GalNet.Editor.Views.ExportPanelView" x:DataType="vm:ExportPanelViewModel" Background="{DynamicResource SemiColorBackground0}"><Grid RowDefinitions="Auto,Auto,Auto,*,Auto" Margin="16"><TextBlock Text="{loc:Localize Export.Title}" FontSize="16" FontWeight="Bold" /><TextBlock Grid.Row="1" Margin="0,14,0,4" Text="{loc:Localize Export.OutputDirectory}" Foreground="{DynamicResource SemiColorText2}" /><Grid Grid.Row="2" ColumnDefinitions="*,Auto" ColumnSpacing="8"><TextBox Text="{Binding OutputDirectory}" IsEnabled="{Binding !IsExporting}" /><Button Grid.Column="1" Content="{loc:Localize Export.Browse}" Command="{Binding BrowseCommand}" IsEnabled="{Binding !IsExporting}" /></Grid><StackPanel Grid.Row="3" Margin="0,12,0,0" Spacing="4"><TextBlock Text="{loc:Localize Export.Package}" Foreground="{DynamicResource SemiColorText2}" /><TextBlock Text="{Binding PackagePath}" TextWrapping="Wrap" /></StackPanel><Grid Grid.Row="4" ColumnDefinitions="*,Auto" Margin="0,14,0,0"><Button Grid.Column="1" Content="{loc:Localize Export.Action}" Click="OnExportClicked" IsEnabled="{Binding !IsExporting}" /></Grid></Grid></UserControl>
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:loc="using:GalNet.Editor.MarkupExtensions"
+             xmlns:vm="using:GalNet.Editor.ViewModels"
+             x:Class="GalNet.Editor.Views.ExportPanelView"
+             x:DataType="vm:ExportPanelViewModel"
+             Background="{DynamicResource SemiColorBackground0}">
+    <Grid RowDefinitions="Auto,Auto,Auto,Auto,Auto,Auto,Auto,*,Auto"
+          RowSpacing="5"
+          Margin="16">
+        <TextBlock Text="{loc:Localize Export.Title}" FontSize="16" FontWeight="Bold" />
+
+        <TextBlock Grid.Row="1" Margin="0,8,0,0" Text="{loc:Localize Export.Mode}" Foreground="{DynamicResource SemiColorText2}" />
+        <ComboBox Grid.Row="2"
+                  ItemsSource="{Binding Modes}"
+                  SelectedItem="{Binding SelectedMode}"
+                  IsEnabled="{Binding !IsExporting}" />
+
+        <TextBlock Grid.Row="3" Margin="0,8,0,0" Text="{loc:Localize Export.OutputDirectory}" Foreground="{DynamicResource SemiColorText2}" IsVisible="{Binding IsPackageMode}" />
+        <TextBlock Grid.Row="3" Margin="0,8,0,0" Text="{loc:Localize Export.ReleaseOutput}" Foreground="{DynamicResource SemiColorText2}" IsVisible="{Binding IsReleaseMode}" />
+        <Grid Grid.Row="4" ColumnDefinitions="*,Auto" ColumnSpacing="8" IsVisible="{Binding IsPackageMode}">
+            <TextBox Text="{Binding OutputDirectory}" IsEnabled="{Binding !IsExporting}" />
+            <Button Grid.Column="1" Content="{loc:Localize Export.Browse}" Command="{Binding BrowseCommand}" IsEnabled="{Binding !IsExporting}" />
+        </Grid>
+        <Grid Grid.Row="4" ColumnDefinitions="*,Auto" ColumnSpacing="8" IsVisible="{Binding IsReleaseMode}">
+            <TextBox Text="{Binding ReleaseOutputRoot}" IsEnabled="{Binding !IsExporting}" />
+            <Button Grid.Column="1" Content="{loc:Localize Export.Browse}" Command="{Binding BrowseCommand}" IsEnabled="{Binding !IsExporting}" />
+        </Grid>
+
+        <StackPanel Grid.Row="5" Spacing="5" IsVisible="{Binding IsReleaseMode}">
+            <TextBlock Text="{loc:Localize Export.Version}" Foreground="{DynamicResource SemiColorText2}" />
+            <TextBox Text="{Binding ReleaseVersion}" IsEnabled="{Binding !IsExporting}" />
+        </StackPanel>
+
+        <StackPanel Grid.Row="6" Spacing="5" IsVisible="{Binding IsIntegratedSample}">
+            <TextBlock Text="{loc:Localize Export.IntegrationSource}" Foreground="{DynamicResource SemiColorText2}" />
+            <Grid ColumnDefinitions="*,Auto" ColumnSpacing="8">
+                <TextBox Text="{Binding GalpakPath}" PlaceholderText="{loc:Localize Export.ProjectDefault}" IsEnabled="{Binding !IsExporting}" />
+                <Button Grid.Column="1" Content="{loc:Localize Export.SelectGalpakButton}" Command="{Binding BrowseGalpakCommand}" IsEnabled="{Binding !IsExporting}" />
+            </Grid>
+        </StackPanel>
+
+        <StackPanel Grid.Row="7" Margin="0,8,0,0" Spacing="4">
+            <TextBlock Text="{loc:Localize Export.Package}" Foreground="{DynamicResource SemiColorText2}" />
+            <TextBlock Text="{Binding PackagePath}" TextWrapping="Wrap" />
+        </StackPanel>
+
+        <Grid Grid.Row="8" ColumnDefinitions="*,Auto" Margin="0,10,0,0">
+            <Button Grid.Column="1" Content="{loc:Localize Export.Action}" Click="OnExportClicked" IsEnabled="{Binding !IsExporting}" />
+        </Grid>
+    </Grid>
+</UserControl>
diff --git a/src/Editor/GalNet.Editor/Views/ExportWindow.axaml b/src/Editor/GalNet.Editor/Views/ExportWindow.axaml
index 972fbda3..1d69800e 100644
--- a/src/Editor/GalNet.Editor/Views/ExportWindow.axaml
+++ b/src/Editor/GalNet.Editor/Views/ExportWindow.axaml
@@ -1 +1 @@
-<u:UrsaWindow xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:u="https://irihi.tech/ursa" xmlns:loc="using:GalNet.Editor.MarkupExtensions" xmlns:views="using:GalNet.Editor.Views" xmlns:vm="using:GalNet.Editor.ViewModels" x:Class="GalNet.Editor.Views.ExportWindow" x:DataType="vm:ExportPanelViewModel" Title="{loc:Localize Export.Title}" Width="560" Height="220" WindowStartupLocation="CenterOwner" TransparencyLevelHint="AcrylicBlur" Background="Transparent"><views:ExportPanelView /></u:UrsaWindow>
+<u:UrsaWindow xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:u="https://irihi.tech/ursa" xmlns:loc="using:GalNet.Editor.MarkupExtensions" xmlns:views="using:GalNet.Editor.Views" xmlns:vm="using:GalNet.Editor.ViewModels" x:Class="GalNet.Editor.Views.ExportWindow" x:DataType="vm:ExportPanelViewModel" Title="{loc:Localize Export.Title}" Width="600" Height="500" WindowStartupLocation="CenterOwner" TransparencyLevelHint="AcrylicBlur" Background="Transparent"><views:ExportPanelView /></u:UrsaWindow>
diff --git a/src/Editor/GalNet.Editor/Views/ExportWindow.axaml.cs b/src/Editor/GalNet.Editor/Views/ExportWindow.axaml.cs
index 3c9bbc2a..a4fbb3d8 100644
--- a/src/Editor/GalNet.Editor/Views/ExportWindow.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/ExportWindow.axaml.cs
@@ -1,3 +1,4 @@
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using GalNet.Editor.ViewModels;
@@ -13,25 +14,33 @@ public async Task ExportAsync(ExportPanelViewModel viewModel)
         using var cancellation = new CancellationTokenSource();
         var progressViewModel = new ExportProgressViewModel(viewModel.L, cancellation.Cancel);
         var progressWindow = new ExportProgressWindow { DataContext = progressViewModel };
-        progressWindow.Closing += (_, _) => cancellation.Cancel();
-        _ = progressWindow.ShowDialog(this);
-
-        var result = await viewModel.ExportAsync(cancellation.Token);
-        if (result.Success)
+        void OnClosing(object? sender, Avalonia.Controls.WindowClosingEventArgs e) => cancellation.Cancel();
+        progressWindow.Closing += OnClosing;
+        try
         {
-            var mainWindow = Owner as MainWindow;
-            progressWindow.Close();
-            Close();
-            mainWindow?.ShowSuccessToast(viewModel.L["Export.Success"]);
-            return;
-        }
+            _ = progressWindow.ShowDialog(this);
+
+            var result = await viewModel.ExportAsync(cancellation.Token);
+            if (result.Success)
+            {
+                var mainWindow = Owner as MainWindow;
+                progressWindow.Close();
+                Close();
+                mainWindow?.ShowSuccessToast($"{viewModel.L["Export.Success"]} {Path.GetFileName(result.PackagePath)}");
+                return;
+            }
 
-        if (cancellation.IsCancellationRequested)
+            if (cancellation.IsCancellationRequested)
+            {
+                progressWindow.Close();
+                return;
+            }
+
+            progressViewModel.CompleteFailure(result.Error ?? viewModel.L["Export.Failed"]);
+        }
+        finally
         {
-            progressWindow.Close();
-            return;
+            progressWindow.Closing -= OnClosing;
         }
-
-        progressViewModel.CompleteFailure(result.Error ?? viewModel.L["Export.Failed"]);
     }
 }
diff --git a/src/Editor/GalNet.Editor/Views/GameLocalizationPanelView.axaml b/src/Editor/GalNet.Editor/Views/GameLocalizationPanelView.axaml
index 182db76e..2f37275a 100644
--- a/src/Editor/GalNet.Editor/Views/GameLocalizationPanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/GameLocalizationPanelView.axaml
@@ -2,29 +2,79 @@
              xmlns:vm="using:GalNet.Editor.ViewModels" xmlns:services="using:GalNet.Editor.Services"
              xmlns:loc="clr-namespace:GalNet.Editor.MarkupExtensions"
              x:Class="GalNet.Editor.Views.GameLocalizationPanelView" x:DataType="vm:GameLocalizationPanelViewModel">
-  <Grid ColumnDefinitions="190,*" ColumnSpacing="12" Margin="12">
+  <UserControl.Resources><ResourceDictionary><ResourceDictionary.MergedDictionaries><ResourceInclude Source="avares://GalNet.Editor/Themes/AuthoringPanelResources.axaml"/></ResourceDictionary.MergedDictionaries></ResourceDictionary></UserControl.Resources>
+  <UserControl.Styles>
+    <Style Selector="TextBox.localizationCell">
+      <Setter Property="Background" Value="Transparent"/>
+      <Setter Property="BorderBrush" Value="Transparent"/>
+      <Setter Property="Padding" Value="6,4"/>
+      <Setter Property="HorizontalContentAlignment" Value="Left"/>
+      <Setter Property="VerticalContentAlignment" Value="Top"/>
+      <Setter Property="TextAlignment" Value="Left"/>
+      <Setter Property="MinHeight" Value="44"/>
+      <Setter Property="MaxHeight" Value="44"/>
+    </Style>
+    <Style Selector="TextBox.localizationCell:focus">
+      <Setter Property="MinHeight" Value="76"/>
+      <Setter Property="MaxHeight" Value="240"/>
+      <Setter Property="BorderBrush" Value="{DynamicResource SemiColorPrimary}"/>
+    </Style>
+  </UserControl.Styles>
+  <Grid x:Name="LocalizationColumns" ColumnDefinitions="160,6,*" Margin="8">
     <ListBox x:Name="LocalizationCategories" ItemsSource="{Binding Categories}" SelectedItem="{Binding Selected}">
-      <ListBox.ItemTemplate><DataTemplate x:DataType="services:LocalizationCategory"><TextBlock Text="{Binding Name}" TextWrapping="Wrap"/></DataTemplate></ListBox.ItemTemplate>
+      <ListBox.ItemTemplate><DataTemplate x:DataType="services:LocalizationCategory"><TextBlock Text="{Binding Name}" TextTrimming="CharacterEllipsis" ToolTip.Tip="{Binding Name}"/></DataTemplate></ListBox.ItemTemplate>
     </ListBox>
-    <Grid Grid.Column="1" RowDefinitions="Auto,Auto,Auto,*,Auto" RowSpacing="8">
-      <StackPanel Spacing="6"><WrapPanel>
-        <TextBox x:Name="NewLocalizationLanguage" Width="130" Text="{Binding NewLanguage}" PlaceholderText="{loc:Localize I18n.LanguageCode}"/>
-        <Button x:Name="AddLocalizationLanguage" Content="{loc:Localize I18n.Add}" Command="{Binding AddLanguageCommand}" Margin="8,0"/>
-        <Button Content="{loc:Localize I18n.RevertDrafts}" Command="{Binding RevertDraftsCommand}"/>
-      </WrapPanel>
-      <WrapPanel IsEnabled="{Binding !ApplyImportCommand.IsRunning}">
-        <ComboBox x:Name="ExchangeLanguage" ItemsSource="{Binding Languages}" SelectedItem="{Binding ExchangeLanguage}" Width="130"/>
-        <CheckBox Content="{loc:Localize Exchange.All}" IsChecked="{Binding ExportAll}" Margin="8,0"/>
-        <CheckBox Content="{loc:Localize Exchange.Runtime}" IsChecked="{Binding ExportRuntime}" Margin="8,0"/>
-        <Button x:Name="ExportLocalization" Content="{loc:Localize Exchange.Export}" Command="{Binding ExportCommand}" Margin="8,0"/>
-        <Button x:Name="ImportLocalization" Content="{loc:Localize Exchange.Import}" Command="{Binding PreviewImportCommand}"/>
-      </WrapPanel>
-      <StackPanel IsVisible="{Binding HasImport}" IsEnabled="{Binding !ApplyImportCommand.IsRunning}" Spacing="6">
+    <GridSplitter x:Name="CategorySplitter" Grid.Column="1" ResizeDirection="Columns" HorizontalAlignment="Stretch" Background="Transparent"/>
+    <Grid Grid.Column="2" RowDefinitions="Auto,Auto,Auto,*,Auto" RowSpacing="6">
+      <Grid ColumnDefinitions="*,Auto" ColumnSpacing="4">
+        <TextBox x:Name="LocalizationSearch" Text="{Binding Search}" PlaceholderText="{loc:Localize Uiux.I18n.Search}" MinWidth="0"/>
+        <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="2">
+          <ToggleButton x:Name="OnlyMissingTranslations" Theme="{StaticResource EditorIconToggleButton}" IsChecked="{Binding OnlyMissing}" ToolTip.Tip="{loc:Localize Uiux.I18n.Missing}" AutomationProperties.Name="{loc:Localize Uiux.I18n.Missing}"><PathIcon Width="16" Height="16" Data="{StaticResource FilterIcon}"/></ToggleButton>
+          <Button x:Name="ManageLanguages" Theme="{StaticResource EditorIconButton}" ToolTip.Tip="{loc:Localize Uiux.I18n.Languages}" AutomationProperties.Name="{loc:Localize Uiux.I18n.Languages}">
+            <PathIcon Width="16" Height="16" Data="{StaticResource PanelLanguageIcon}"/>
+            <Button.Flyout><Flyout><ScrollViewer MaxHeight="480"><StackPanel Width="350" Spacing="8">
+              <TextBlock Text="{loc:Localize Uiux.I18n.Languages}" FontWeight="SemiBold"/>
+              <TextBlock Text="{loc:Localize Uiux.I18n.VisibleColumns}" Foreground="{DynamicResource SemiColorText2}" FontSize="12"/>
+              <StackPanel x:Name="LanguageManagerRows" Spacing="2"/>
+              <Grid ColumnDefinitions="*,Auto" ColumnSpacing="4">
+                <AutoCompleteBox x:Name="NewLocalizationLanguage" Text="{Binding NewLanguage, Mode=TwoWay}" ItemsSource="{Binding LanguageOptions}" ValueMemberBinding="{Binding Code}" FilterMode="None" IsTextCompletionEnabled="False" MinimumPrefixLength="0" MaxDropDownHeight="220" PlaceholderText="{loc:Localize Uiux.I18n.SearchLanguage}">
+                  <AutoCompleteBox.ItemTemplate><DataTemplate x:DataType="vm:LocalizationLanguageSuggestion"><TextBlock Text="{Binding DisplayText}"/></DataTemplate></AutoCompleteBox.ItemTemplate>
+                </AutoCompleteBox>
+                <Button x:Name="AddLocalizationLanguage" Grid.Column="1" Theme="{StaticResource EditorIconButton}" Command="{Binding AddLanguageCommand}" ToolTip.Tip="{loc:Localize I18n.Add}" AutomationProperties.Name="{loc:Localize I18n.Add}"><PathIcon Width="16" Height="16" Data="{StaticResource AddIcon}"/></Button>
+              </Grid>
+              <TextBlock Text="{loc:Localize Uiux.I18n.RemoveHint}" TextWrapping="Wrap" Foreground="{DynamicResource SemiColorText2}" FontSize="12"/>
+              <StackPanel IsVisible="{Binding CanChangeDevelopmentLanguage}" Spacing="6">
+                <TextBlock Text="{Binding PreviewMessage}" TextWrapping="Wrap"/>
+                <Button x:Name="ApplyDevelopmentLanguage" Content="{loc:Localize I18n.ApplyDevelopment}" Command="{Binding ChangeDevelopmentLanguageCommand}"/>
+              </StackPanel>
+            </StackPanel></ScrollViewer></Flyout></Button.Flyout>
+          </Button>
+          <Button x:Name="ImportLocalization" Theme="{StaticResource EditorIconButton}" IsEnabled="{Binding !ApplyImportCommand.IsRunning}" ToolTip.Tip="{loc:Localize Exchange.Import}" AutomationProperties.Name="{loc:Localize Exchange.Import}">
+            <PathIcon Width="16" Height="16" Data="{StaticResource PanelImportIcon}"/>
+            <Button.Flyout><Flyout><StackPanel Width="260" Spacing="8">
+              <TextBlock Text="{loc:Localize Uiux.I18n.Exchange}" FontWeight="SemiBold"/>
+              <ComboBox x:Name="ExchangeLanguage" ItemsSource="{Binding Languages}" SelectedItem="{Binding ExchangeLanguage}" HorizontalAlignment="Stretch"/>
+              <Button x:Name="ChooseLocalizationImport" Content="{loc:Localize Exchange.Import}" Command="{Binding PreviewImportCommand}"/>
+            </StackPanel></Flyout></Button.Flyout>
+          </Button>
+          <Button x:Name="ExportOptions" Theme="{StaticResource EditorIconButton}" ToolTip.Tip="{loc:Localize Exchange.Export}" AutomationProperties.Name="{loc:Localize Exchange.Export}">
+            <PathIcon Width="16" Height="16" Data="{StaticResource PanelExportIcon}"/>
+            <Button.Flyout><Flyout><StackPanel Width="260" Spacing="8" IsEnabled="{Binding !ApplyImportCommand.IsRunning}">
+              <TextBlock Text="{loc:Localize Uiux.I18n.Exchange}" FontWeight="SemiBold"/>
+              <ComboBox ItemsSource="{Binding Languages}" SelectedItem="{Binding ExchangeLanguage}" HorizontalAlignment="Stretch"/>
+              <CheckBox Content="{loc:Localize Exchange.All}" IsChecked="{Binding ExportAll}"/>
+              <CheckBox Content="{loc:Localize Exchange.Runtime}" IsChecked="{Binding ExportRuntime}"/>
+              <Button x:Name="ExportLocalization" Content="{loc:Localize Exchange.Export}" Command="{Binding ExportCommand}"/>
+            </StackPanel></Flyout></Button.Flyout>
+          </Button>
+        </StackPanel>
+      </Grid>
+      <StackPanel Grid.Row="1" IsVisible="{Binding HasImport}" IsEnabled="{Binding !ApplyImportCommand.IsRunning}" Spacing="6">
         <WrapPanel><CheckBox x:Name="AllowEmptyImport" Content="{loc:Localize Exchange.AllowEmpty}" IsChecked="{Binding AllowEmpty}"/>
           <Button x:Name="ApplyLocalizationImport" Content="{loc:Localize Exchange.Apply}" Command="{Binding ApplyImportCommand}" Margin="8,0"/>
           <Button Content="{loc:Localize Exchange.Cancel}" Command="{Binding CancelImportCommand}"/>
         </WrapPanel>
-        <ListBox x:Name="LocalizationImportRows" ItemsSource="{Binding ImportRows}" MaxHeight="200">
+        <ListBox x:Name="LocalizationImportRows" ItemsSource="{Binding ImportRows}" MaxHeight="160">
           <ListBox.ItemTemplate><DataTemplate x:DataType="vm:LocalizationImportRowViewModel"><Grid ColumnDefinitions="Auto,*,*,Auto" ColumnSpacing="8">
             <CheckBox IsChecked="{Binding Include}" IsEnabled="{Binding CanInclude}"/>
             <TextBlock Grid.Column="1" Text="{Binding Source}" ToolTip.Tip="{Binding ExportedSource}" TextWrapping="Wrap" MaxWidth="300"/>
@@ -32,25 +82,27 @@
             <TextBlock Grid.Column="3" Text="{Binding Status}" TextWrapping="Wrap"/>
           </Grid></DataTemplate></ListBox.ItemTemplate>
         </ListBox>
-      </StackPanel></StackPanel>
-      <WrapPanel Grid.Row="1">
-        <TextBlock Text="{loc:Localize I18n.Development}" VerticalAlignment="Center" Margin="0,0,8,0"/>
-        <ComboBox x:Name="DevelopmentLanguageChoice" ItemsSource="{Binding Languages}" SelectedItem="{Binding DevelopmentLanguage}" Width="130"/>
-        <Button x:Name="PreviewDevelopmentLanguage" Content="{loc:Localize I18n.PreviewAction}" Command="{Binding PreviewDevelopmentLanguageCommand}" Margin="8,0"/>
-        <Button x:Name="ApplyDevelopmentLanguage" Content="{loc:Localize I18n.ApplyDevelopment}" Command="{Binding ChangeDevelopmentLanguageCommand}" IsEnabled="{Binding CanChangeDevelopmentLanguage}"/>
-      </WrapPanel>
-      <StackPanel Grid.Row="2">
-        <TextBlock Text="{Binding PreviewMessage}" TextWrapping="Wrap"/>
+      </StackPanel>
+      <StackPanel Grid.Row="2" Spacing="4">
+        <ComboBox x:Name="CompactLocalizationCategory" ItemsSource="{Binding Categories}" SelectedItem="{Binding Selected}" IsVisible="False" HorizontalAlignment="Stretch">
+          <ComboBox.ItemTemplate><DataTemplate x:DataType="services:LocalizationCategory"><TextBlock Text="{Binding Name}"/></DataTemplate></ComboBox.ItemTemplate>
+        </ComboBox>
         <TextBlock Text="{loc:Localize I18n.Incomplete}" IsVisible="{Binding Incomplete}" TextWrapping="Wrap"/>
       </StackPanel>
-      <ScrollViewer Grid.Row="3" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Disabled">
-        <Grid RowDefinitions="Auto,*">
-          <StackPanel x:Name="LanguageHeaders" Orientation="Horizontal"/>
-          <ListBox x:Name="LocalizationRows" Grid.Row="1" ItemsSource="{Binding Rows}" Padding="0" HorizontalAlignment="Left">
-            <ListBox.Styles><Style Selector="ListBoxItem"><Setter Property="Padding" Value="0"/><Setter Property="HorizontalContentAlignment" Value="Stretch"/></Style></ListBox.Styles>
-          </ListBox>
-        </Grid>
-      </ScrollViewer>
+      <Grid Grid.Row="3" Background="{DynamicResource SemiColorBackground0}">
+        <ScrollViewer x:Name="LocalizationTableScroll" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Disabled" ScrollChanged="OnTableScroll">
+          <Grid RowDefinitions="Auto,*">
+            <Grid x:Name="LocalizationHeader" HorizontalAlignment="Left" ClipToBounds="True">
+              <StackPanel x:Name="LanguageHeaders" Orientation="Horizontal" Margin="188,0,0,0"/>
+              <Border x:Name="ContextHeader" Width="188" HorizontalAlignment="Left" Background="{DynamicResource SemiColorBackground0}" ZIndex="1"/>
+            </Grid>
+            <ListBox x:Name="LocalizationRows" Grid.Row="1" ItemsSource="{Binding Rows}" Padding="0" HorizontalAlignment="Left">
+              <ListBox.Styles><Style Selector="ListBoxItem"><Setter Property="Padding" Value="0"/><Setter Property="HorizontalContentAlignment" Value="Stretch"/></Style></ListBox.Styles>
+            </ListBox>
+          </Grid>
+        </ScrollViewer>
+        <TextBlock Text="{loc:Localize Uiux.Panel.NoResults}" IsVisible="{Binding !HasRows}" VerticalAlignment="Center" HorizontalAlignment="Center" Margin="16" Foreground="{DynamicResource SemiColorText2}"/>
+      </Grid>
       <TextBlock Grid.Row="4" Text="{Binding Message}" TextWrapping="Wrap" Foreground="{DynamicResource SystemControlErrorTextForegroundBrush}"/>
     </Grid>
   </Grid>
diff --git a/src/Editor/GalNet.Editor/Views/GameLocalizationPanelView.axaml.cs b/src/Editor/GalNet.Editor/Views/GameLocalizationPanelView.axaml.cs
index 57e1f088..0cff2960 100644
--- a/src/Editor/GalNet.Editor/Views/GameLocalizationPanelView.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/GameLocalizationPanelView.axaml.cs
@@ -1,12 +1,15 @@
+using System.Globalization;
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
 using Avalonia.Data;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.Styling;
 using Avalonia.Threading;
 using Avalonia.VisualTree;
 using GalNet.Editor.ViewModels;
@@ -16,9 +19,21 @@ namespace GalNet.Editor.Views;
 public partial class GameLocalizationPanelView : UserControl
 {
     private GameLocalizationPanelViewModel? _model;
+    private readonly TranslateTransform _contextOffset = new();
+    private bool? _narrow;
     public GameLocalizationPanelView()
     {
         InitializeComponent();
+        ContextHeader.RenderTransform = _contextOffset;
+        SizeChanged += (_, _) =>
+        {
+            var narrow = Bounds.Width < 650;
+            if (_narrow == narrow) return;
+            _narrow = narrow;
+            LocalizationColumns.ColumnDefinitions = new(narrow ? "0,0,*" : "160,6,*");
+            LocalizationCategories.IsVisible = CategorySplitter.IsVisible = !narrow;
+            CompactLocalizationCategory.IsVisible = narrow;
+        };
         LocalizationRows.ItemTemplate = new FuncDataTemplate<LocalizationGridRow>((row, _) => row is null ? new Border() : CreateRow(row));
         DataContextChanged += (_, _) => Connect();
         AttachedToVisualTree += (_, _) => Connect();
@@ -33,65 +48,182 @@ private void Connect()
     private void Headers()
     {
         if (_model is not { } model) return;
-        LanguageHeaders.Children.Clear();
-        LanguageHeaders.Children.Add(new TextBlock { Width = 180, Text = model.Service.Text["I18n.Context"], Margin = new Thickness(4) });
+        LanguageHeaders.Children.Clear(); LanguageManagerRows.Children.Clear();
         foreach (var language in model.Languages)
         {
-            var panel = new StackPanel { Orientation = Orientation.Horizontal, Width = 244, Spacing = 4 };
-            panel.Children.Add(new TextBlock { Text = language, VerticalAlignment = VerticalAlignment.Center });
-            if (language != model.Languages[0])
+            var source = language == model.Languages[0];
+            var culture = CultureInfo.GetCultureInfo(language);
+            var languageName = culture.NativeName + " · " + language;
+            var manager = new Grid { ColumnDefinitions = new("*,Auto,Auto"), ColumnSpacing = 4 };
+            var visible = new CheckBox { Content = languageName, IsChecked = model.IsLanguageVisible(language), IsEnabled = !source, MinWidth = 0 };
+            ToolTip.SetTip(visible, model.Service.Text["Uiux.I18n.VisibleColumns"]);
+            visible.IsCheckedChanged += (_, _) => model.SetLanguageVisible(language, visible.IsChecked == true);
+            manager.Children.Add(visible);
+            if (source)
+            {
+                var label = new TextBlock { Text = model.Service.Text["I18n.Source"], VerticalAlignment = VerticalAlignment.Center, FontSize = 12 };
+                Grid.SetColumn(label, 1); Grid.SetColumnSpan(label, 2); manager.Children.Add(label);
+            }
+            else
             {
+                var more = IconButton("PanelMoreIcon", model.Service.Text["Uiux.I18n.LanguageActions"]);
+                var actions = new StackPanel { Spacing = 4 };
                 foreach (var direction in new[] { -1, 1 })
                 {
-                    var button = new Button { Content = direction < 0 ? "←" : "→", Name = (direction < 0 ? "LanguageLeft_" : "LanguageRight_") + language.Replace('-', '_') };
+                    var move = new Button { Content = model.Service.Text[direction < 0 ? "I18n.MoveLeft" : "I18n.MoveRight"], HorizontalAlignment = HorizontalAlignment.Stretch };
+                    move.Name = (direction < 0 ? "LanguageLeft_" : "LanguageRight_") + language.Replace('-', '_');
                     var index = model.Languages.IndexOf(language);
-                    button.IsEnabled = direction < 0 ? index > 1 : index < model.Languages.Count - 1;
-                    ToolTip.SetTip(button, model.Service.Text[direction < 0 ? "I18n.MoveLeft" : "I18n.MoveRight"]);
-                    button.Click += async (_, _) => await model.RunAsync(() => model.Service.MoveLanguageAsync(language, direction));
-                    panel.Children.Add(button);
+                    move.IsEnabled = direction < 0 ? index > 1 : index < model.Languages.Count - 1;
+                    move.Click += async (_, _) => { more.Flyout?.Hide(); await model.RunAsync(() => model.Service.MoveLanguageAsync(language, direction)); };
+                    actions.Children.Add(move);
                 }
+                var development = new Button { Content = model.Service.Text["I18n.ApplyDevelopment"], HorizontalAlignment = HorizontalAlignment.Stretch };
+                development.Click += (_, _) =>
+                {
+                    model.DevelopmentLanguage = language; model.PreviewDevelopmentLanguageCommand.Execute(null); more.Flyout?.Hide();
+                };
+                actions.Children.Add(development); more.Flyout = new Flyout { Content = actions };
+                Grid.SetColumn(more, 1); manager.Children.Add(more);
+                var remove = IconButton("DeleteRegularIcon", model.Service.Text["Uiux.I18n.RemoveLanguage"]);
+                remove.Name = "RemoveLanguage_" + language.Replace('-', '_');
+                remove.Click += async (_, _) => await model.RemoveLanguageAsync(language);
+                Grid.SetColumn(remove, 2); manager.Children.Add(remove);
             }
-            else panel.Children.Add(new TextBlock { Text = model.Service.Text["I18n.Source"], VerticalAlignment = VerticalAlignment.Center });
-            LanguageHeaders.Children.Add(panel);
+            LanguageManagerRows.Children.Add(manager);
+            if (!model.IsLanguageVisible(language)) continue;
+            var header = new Grid { Width = model.ColumnWidth(language), ColumnDefinitions = new("*,6"), MinHeight = 34 };
+            var title = new TextBlock { Text = language + (source ? " · " + model.Service.Text["I18n.Source"] : ""), Margin = new Thickness(8, 4), VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis };
+            ToolTip.SetTip(title, languageName); header.Children.Add(title);
+            var resize = new Thumb { Name = "ResizeLanguage_" + language.Replace('-', '_'), Cursor = new Cursor(StandardCursorType.SizeWestEast), Background = Brushes.Transparent, Template = new FuncControlTemplate<Thumb>((_, _) => new Border { Background = Brushes.Transparent }) };
+            Grid.SetColumn(resize, 1); header.Children.Add(resize);
+            resize.DragDelta += (_, args) =>
+            {
+                model.SetColumnWidth(language, header.Width + args.Vector.X); header.Width = model.ColumnWidth(language); TableWidth();
+            };
+            LanguageHeaders.Children.Add(header);
         }
-        LocalizationRows.Width = 188 + model.Languages.Count * 244;
+        TableWidth();
+    }
+    private void TableWidth()
+    {
+        if (_model is not { } model) return;
+        LocalizationRows.Width = 188 + model.VisibleLanguages.Sum(model.ColumnWidth);
+        LocalizationHeader.Width = LocalizationRows.Width;
+    }
+    private void OnTableScroll(object? sender, ScrollChangedEventArgs args) => _contextOffset.X = LocalizationTableScroll.Offset.X;
+    private Button IconButton(string icon, string label)
+    {
+        var button = new Button { Theme = (ControlTheme)this.FindResource("EditorIconButton")!, Content = new PathIcon { Width = 16, Height = 16, Data = (Geometry)this.FindResource(icon)! } };
+        ToolTip.SetTip(button, label); global::Avalonia.Automation.AutomationProperties.SetName(button, label);
+        return button;
     }
     private Control CreateRow(LocalizationGridRow row)
     {
-        var panel = new StackPanel { Orientation = Orientation.Horizontal };
-        var context = new StackPanel { Width = 188, Margin = new Thickness(0, 4) };
-        context.Children.Add(new TextBlock { Text = row.Context, TextWrapping = TextWrapping.Wrap, Margin = new Thickness(4) });
-        var navigate = new Button { Content = _model?.Service.Text["I18n.Navigate"], Margin = new Thickness(4) };
-        navigate.Click += (_, _) => _model?.Service.Navigate(row.Source);
-        context.Children.Add(navigate); panel.Children.Add(context);
-        foreach (var cell in row.Cells) panel.Children.Add(CreateCell(cell));
+        var panel = new Grid { ColumnDefinitions = new("188,*"), ClipToBounds = true, DataContext = row };
+        panel.Bind(BackgroundProperty, this.GetResourceObservable("SemiColorBackground0"));
+        var context = new Grid { ColumnDefinitions = new("*,Auto"), Margin = new Thickness(8, 4), MinHeight = 44 };
+        var labels = new StackPanel { Spacing = 2, VerticalAlignment = VerticalAlignment.Center };
+        var title = new TextBlock { TextTrimming = TextTrimming.CharacterEllipsis };
+        title.Bind(TextBlock.TextProperty, new Binding(nameof(row.Title))); labels.Children.Add(title);
+        var slot = new TextBlock { FontSize = 11, TextTrimming = TextTrimming.CharacterEllipsis };
+        slot.Bind(TextBlock.TextProperty, new Binding(nameof(row.Slot)));
+        slot.Bind(TextBlock.ForegroundProperty, this.GetResourceObservable("SemiColorText2"));
+        slot.IsVisible = row.Slot.Length > 0; labels.Children.Add(slot);
+        context.Bind(ToolTip.TipProperty, new Binding(nameof(row.Details))); context.Children.Add(labels);
+        var navigate = IconButton("PanelNavigateIcon", _model?.Service.Text["I18n.Navigate"] ?? "");
+        navigate.Name = "LocalizationNavigate";
+        navigate.VerticalAlignment = VerticalAlignment.Center; Grid.SetColumn(navigate, 1); context.Children.Add(navigate);
+        navigate.Click += (_, _) =>
+        {
+            if (_model is not { } model) return;
+            if (row.Source.Locations.Count <= 1) { model.Service.Navigate(row.Source); return; }
+            var locations = new StackPanel { Spacing = 2, MaxWidth = 420 };
+            foreach (var location in row.Source.Locations)
+            {
+                var target = new Button { Content = location.Title + " · " + location.Slot, HorizontalAlignment = HorizontalAlignment.Stretch };
+                ToolTip.SetTip(target, location.DisplayDetails);
+                target.Click += (_, _) => { navigate.Flyout?.Hide(); model.Service.Navigate(location.Reference); };
+                locations.Children.Add(target);
+            }
+            navigate.Flyout = new Flyout { Content = new ScrollViewer { Content = locations, MaxHeight = 300 } };
+            navigate.Flyout.ShowAt(navigate);
+        };
+        var count = new TextBlock { FontSize = 10, HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Top, IsHitTestVisible = false };
+        count.Bind(TextBlock.TextProperty, new Binding(nameof(row.ReferenceCount))); Grid.SetColumn(count, 1); context.Children.Add(count);
+        var frozen = new Border { Name = "LocalizationContext", Child = context, RenderTransform = _contextOffset, ZIndex = 1 };
+        frozen.Bind(BackgroundProperty, this.GetResourceObservable("SemiColorBackground0"));
+        var cells = new StackPanel { Orientation = Orientation.Horizontal };
+        Grid.SetColumn(cells, 1); panel.Children.Add(cells); panel.Children.Add(frozen);
+        foreach (var cell in row.Cells) cells.Children.Add(CreateCell(cell));
         return panel;
     }
     private Control CreateCell(LocalizationGridCell cell)
     {
-        var box = new StackPanel { Width = 244, Margin = new Thickness(0, 4), Spacing = 4, DataContext = cell };
-        var input = new TextBox { Name = "LocalizationCellInput", AcceptsReturn = true, TextWrapping = TextWrapping.Wrap, MinHeight = 64, MaxHeight = 160, Margin = new Thickness(4, 0) };
-        input.Bind(TextBox.TextProperty, new Binding(nameof(cell.Text)) { Mode = BindingMode.TwoWay });
+        var box = new StackPanel { Margin = new Thickness(0, 4), DataContext = cell };
+        box.Bind(WidthProperty, new Binding(nameof(cell.Width)));
+        var content = new Grid(); box.Children.Add(content);
+        var input = new TextBox { Name = "LocalizationCellInput", AcceptsReturn = true, TextWrapping = TextWrapping.Wrap, Margin = new Thickness(4, 0), Opacity = 0 };
+        input.Classes.Add("localizationCell");
+        input.Bind(TextBox.TextProperty, new Binding(nameof(cell.Text)) { Mode = BindingMode.OneWay });
         input.Bind(IsEnabledProperty, new Binding(nameof(cell.Enabled)));
-        input.Bind(TextBox.IsReadOnlyProperty, new Binding(nameof(cell.Busy)));
+        var preview = new TextBlock { Margin = new Thickness(10, 4), MaxLines = 2, TextWrapping = TextWrapping.Wrap, TextTrimming = TextTrimming.CharacterEllipsis, VerticalAlignment = VerticalAlignment.Top, IsHitTestVisible = false };
+        preview.Bind(TextBlock.TextProperty, new Binding(nameof(cell.DisplayText)));
+        input.Bind(TextBox.PlaceholderTextProperty, new Binding(nameof(cell.IsMissing)) { Converter = new MissingTranslationConverter(_model?.Service.Text["I18n.Missing"] ?? "") });
+        content.Children.Add(input); content.Children.Add(preview);
         bool Composing() => input.GetVisualDescendants().OfType<TextPresenter>().Any(presenter => !string.IsNullOrEmpty(presenter.PreeditText));
-        async Task Commit(bool force = false)
+        async Task Update(bool explicitValue = false)
         {
             if (_model is not { } model || Composing()) return;
-            await model.RunAsync(() => cell.CommitAsync(force));
+            if (input.Text != cell.Text) cell.Text = input.Text ?? "";
+            await model.RunAsync(() => cell.CommitAsync(explicitValue));
+        }
+        void InputChanged()
+        {
+            if (_model is not null && !Composing() && input.Text != cell.Text) cell.Text = input.Text ?? "";
         }
-        input.LostFocus += (_, _) => Dispatcher.UIThread.Post(async () => { if (!input.IsFocused) await Commit(); }, DispatcherPriority.Background);
-        input.TextInput += (_, _) => { if (!input.IsFocused) Dispatcher.UIThread.Post(async () => await Commit(), DispatcherPriority.Background); };
+        input.TextChanging += (_, _) => InputChanged();
+        input.TextInput += (_, _) => Dispatcher.UIThread.Post(InputChanged, DispatcherPriority.Background);
+        input.GotFocus += (_, _) =>
+        {
+            input.Opacity = 1; preview.IsVisible = false;
+            Dispatcher.UIThread.Post(() =>
+            {
+                if (_model is null || !input.IsFocused || input.TranslatePoint(default, LocalizationTableScroll) is not { } point) return;
+                var left = 188d; var right = LocalizationTableScroll.Viewport.Width;
+                var offset = LocalizationTableScroll.Offset;
+                var delta = point.X < left || right < left + input.Bounds.Width ? point.X - left : Math.Max(0, point.X + input.Bounds.Width - right);
+                LocalizationTableScroll.Offset = new(Math.Max(0, offset.X + delta), offset.Y);
+            }, DispatcherPriority.Background);
+        };
+        input.LostFocus += (_, _) => Dispatcher.UIThread.Post(async () =>
+        {
+            if (input.IsFocused) return;
+            await Update(); input.Opacity = 0; preview.IsVisible = true;
+        }, DispatcherPriority.Background);
         input.AddHandler(InputElement.KeyDownEvent, async (_, args) =>
         {
-            if (args.Key == Key.Escape && !Composing()) { args.Handled = true; cell.Revert(); }
-            else if (args.Key == Key.Enter && args.KeyModifiers.HasFlag(KeyModifiers.Control) && !Composing()) { args.Handled = true; await Commit(true); }
+            if (Composing()) return;
+            if (args.Key == Key.Escape)
+            {
+                args.Handled = true;
+                cell.Revert();
+                input.Text = cell.Text;
+                LocalizationSearch.Focus();
+            }
+            else if (args.Key == Key.Enter && args.KeyModifiers.HasFlag(KeyModifiers.Control)) { args.Handled = true; await Update(true); }
         }, RoutingStrategies.Tunnel);
-        box.Children.Add(input);
-        var status = new TextBlock { Margin = new Thickness(4, 0), TextWrapping = TextWrapping.Wrap };
-        status.Bind(TextBlock.TextProperty, new Binding(nameof(cell.Status))); box.Children.Add(status);
-        var error = new TextBlock { Margin = new Thickness(4, 0), TextWrapping = TextWrapping.Wrap };
-        error.Bind(TextBlock.TextProperty, new Binding(nameof(cell.Message))); box.Children.Add(error);
+        var errors = new Grid { ColumnDefinitions = new("*,Auto") };
+        errors.Bind(IsVisibleProperty, new Binding(nameof(cell.HasMessage)));
+        var error = new TextBlock { Margin = new Thickness(8, 0), TextWrapping = TextWrapping.Wrap };
+        error.Bind(TextBlock.ForegroundProperty, this.GetResourceObservable("SystemControlErrorTextForegroundBrush"));
+        error.Bind(TextBlock.TextProperty, new Binding(nameof(cell.Message))); errors.Children.Add(error);
+        var reset = IconButton("ResetIcon", _model?.Service.Text["Uiux.I18n.ReloadCell"] ?? "");
+        reset.Click += (_, _) => cell.Revert(); Grid.SetColumn(reset, 1); errors.Children.Add(reset); box.Children.Add(errors);
         return box;
     }
+    private sealed class MissingTranslationConverter(string label) : Avalonia.Data.Converters.IValueConverter
+    {
+        public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) => value is true ? label : "";
+        public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) => throw new NotSupportedException();
+    }
 }
diff --git a/src/Editor/GalNet.Editor/Views/GamePreviewPanelView.axaml b/src/Editor/GalNet.Editor/Views/GamePreviewPanelView.axaml
deleted file mode 100644
index 18d6a93f..00000000
--- a/src/Editor/GalNet.Editor/Views/GamePreviewPanelView.axaml
+++ /dev/null
@@ -1,42 +0,0 @@
-<UserControl xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:vm="using:GalNet.Editor.ViewModels"
-             xmlns:controls="using:GalNet.Game.Controls"
-             x:Class="GalNet.Editor.Views.GamePreviewPanelView"
-             x:DataType="vm:GamePreviewPanelViewModel"
-             MinHeight="300"
-             MinWidth="300"
-             Background="{DynamicResource SemiColorBackground0}">
-    <Grid RowDefinitions="Auto,*" Margin="4">
-        <Border Grid.Row="0"
-                Background="{DynamicResource SemiColorBackground1}"
-                BorderBrush="{DynamicResource SemiColorBorder}"
-                BorderThickness="0,0,0,1"
-                Padding="8,6">
-            <Grid ColumnDefinitions="Auto,Auto,*,Auto">
-                <Button Content="Restart"
-                        Command="{Binding RestartPreviewCommand}" />
-                <Button Grid.Column="1"
-                        Margin="8,0,0,0"
-                        Content="Reset Player"
-                        Click="OnResetPlayerClick" />
-                <TextBlock Grid.Column="2"
-                           Text="{Binding StatusText}"
-                           VerticalAlignment="Center"
-                           Foreground="{DynamicResource SemiColorText2}" />
-            </Grid>
-        </Border>
-
-        <Border Grid.Row="1"
-                Background="Black"
-                BorderBrush="{DynamicResource SemiColorBorder}"
-                BorderThickness="1"
-                CornerRadius="4"
-                Margin="4,2"
-                ClipToBounds="True">
-            <controls:GameCanvasHost x:Name="GameViewHost"
-                                     DesignWidth="{Binding DesignWidth}"
-                                     DesignHeight="{Binding DesignHeight}" />
-        </Border>
-    </Grid>
-</UserControl>
diff --git a/src/Editor/GalNet.Editor/Views/GamePreviewPanelView.axaml.cs b/src/Editor/GalNet.Editor/Views/GamePreviewPanelView.axaml.cs
deleted file mode 100644
index 3837eae1..00000000
--- a/src/Editor/GalNet.Editor/Views/GamePreviewPanelView.axaml.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-using System;
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.Interactivity;
-using GalNet.Editor.ViewModels;
-using Ursa.Controls;
-
-namespace GalNet.Editor.Views;
-
-public partial class GamePreviewPanelView : UserControl
-{
-    private GamePreviewPanelViewModel? _vm;
-
-    public GamePreviewPanelView()
-    {
-        InitializeComponent();
-        DetachedFromVisualTree += OnDetachedFromVisualTree;
-    }
-
-    private async void OnDetachedFromVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
-    {
-        if (_vm is not null)
-            await _vm.DisposeAsync();
-    }
-
-    protected override void OnDataContextChanged(EventArgs e)
-    {
-        if (_vm is not null)
-        {
-            _vm.PropertyChanged -= OnVmPropertyChanged;
-        }
-
-        _vm = DataContext as GamePreviewPanelViewModel;
-        if (_vm is not null)
-        {
-            _vm.PropertyChanged += OnVmPropertyChanged;
-            SyncPageHost();
-        }
-
-        base.OnDataContextChanged(e);
-    }
-
-    private void OnVmPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
-    {
-        if (e.PropertyName == nameof(GamePreviewPanelViewModel.PreviewShell))
-            SyncPageHost();
-    }
-
-    private async void OnResetPlayerClick(object? sender, RoutedEventArgs e)
-    {
-        if (_vm is null)
-            return;
-
-        var owner = TopLevel.GetTopLevel(this) as Window;
-        if (owner is null)
-            return;
-
-        var result = await MessageBox.ShowAsync(
-            owner,
-            "Reset all player variables to their default values?",
-            "Reset Player",
-            button: MessageBoxButton.OKCancel);
-
-        if (result == MessageBoxResult.OK)
-            await _vm.ResetPlayerAsync();
-    }
-
-    private void SyncPageHost()
-    {
-        if (_vm?.PreviewShell is null)
-        {
-            GameViewHost.GameContent = null;
-            return;
-        }
-
-        if (ReferenceEquals(GameViewHost.GameContent, _vm.PreviewShell))
-            return;
-
-        GameViewHost.GameContent = _vm.PreviewShell;
-    }
-}
diff --git a/src/Editor/GalNet.Editor/Views/MainWindow.axaml.cs b/src/Editor/GalNet.Editor/Views/MainWindow.axaml.cs
index 4b74ffe8..c268214a 100644
--- a/src/Editor/GalNet.Editor/Views/MainWindow.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/MainWindow.axaml.cs
@@ -29,12 +29,16 @@ public MainWindow(MainWindowViewModel viewModel, IEditorViewFactory viewFactory,
         _navigation.CurrentPageChanged += OnCurrentPageChanged;
         Closed += OnClosed;
         Closing += OnClosing;
+#if BENCHMARK
+        Opened += (_, _) => GalNet.Diagnostics.CpuProfiler.Shared.Mark("Editor.Window.Opened");
+        Loaded += (_, _) => GalNet.Diagnostics.CpuProfiler.Shared.Mark("Editor.Window.Loaded");
+#endif
 
-        Loaded += (_, _) =>
-        {
-            Log.Information("=== GalNet Editor starting ===");
-            _navigation.NavigateTo<StartupPageViewModel>();
-        };
+        Log.Information("=== GalNet Editor starting ===");
+#if BENCHMARK
+        using var startupMeasurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.NavigateStartup");
+#endif
+        _navigation.NavigateTo<StartupPageViewModel>();
     }
 
     public void ShowSuccessToast(string message) =>
diff --git a/src/Editor/GalNet.Editor/Views/NewProjectPanelView.axaml b/src/Editor/GalNet.Editor/Views/NewProjectPanelView.axaml
index 42bba4b2..90d3f2b7 100644
--- a/src/Editor/GalNet.Editor/Views/NewProjectPanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/NewProjectPanelView.axaml
@@ -20,6 +20,12 @@
                 <Button Grid.Column="1" Content="{loc:Localize Common.Browse}" Command="{Binding BrowseProjectRootCommand}" Margin="8,0,0,0" />
             </Grid>
 
+            <TextBlock Text="{loc:Localize NewProject.Application}" />
+            <Grid ColumnDefinitions="*,Auto">
+                <TextBox Name="ApplicationPathInput" Text="{Binding ApplicationPath}" PlaceholderText="{loc:Localize NewProject.ApplicationHint}" />
+                <Button Name="BrowseApplicationButton" Grid.Column="1" Content="{loc:Localize Common.Browse}" Command="{Binding BrowseApplicationCommand}" Margin="8,0,0,0" />
+            </Grid>
+
             <TextBlock Text="{loc:Localize NewProject.Contracts}" />
             <Grid ColumnDefinitions="*,Auto">
                 <TextBox Name="ContractsDirectoryInput" Text="{Binding ContractsDirectory}" PlaceholderText="{loc:Localize NewProject.ContractsHint}" />
diff --git a/src/Editor/GalNet.Editor/Views/NodeGraphPanelView.axaml.cs b/src/Editor/GalNet.Editor/Views/NodeGraphPanelView.axaml.cs
index 45d15920..acd2264c 100644
--- a/src/Editor/GalNet.Editor/Views/NodeGraphPanelView.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/NodeGraphPanelView.axaml.cs
@@ -600,7 +600,7 @@ await RunGraphAction(async workspace =>
     public void FrameNodes(bool selectionOnly)
     {
         if (Workspace is not { } workspace) return;
-        var nodes = (selectionOnly && workspace.SelectedNodes.Count > 0 ? workspace.SelectedNodes : workspace.Nodes).ToArray();
+        var nodes = (selectionOnly && workspace.SelectedNodes.Count > 0 ? workspace.SelectedNodes.AsEnumerable() : workspace.Nodes).ToArray();
         if (nodes.Length == 0) return;
         var left = nodes.Min(node => node.X); var top = nodes.Min(node => node.Y);
         var right = nodes.Max(node => node.X + GraphLayoutMetrics.NodeWidth); var bottom = nodes.Max(node => node.Y + node.LayoutHeight);
diff --git a/src/Editor/GalNet.Editor/Views/ProblemsPanelView.axaml b/src/Editor/GalNet.Editor/Views/ProblemsPanelView.axaml
index a644b3b0..347fafd4 100644
--- a/src/Editor/GalNet.Editor/Views/ProblemsPanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/ProblemsPanelView.axaml
@@ -7,15 +7,27 @@
   <Style Selector="TextBlock.severity.warning"><Setter Property="Foreground" Value="{DynamicResource SemiColorWarning}"/></Style>
  </UserControl.Styles>
  <Grid RowDefinitions="Auto,*" Margin="8" RowSpacing="6">
-  <WrapPanel><Button Content="{loc:Localize Uiux.Validation.Check}" Command="{Binding ValidateCommand}" Margin="0,0,8,0"/><TextBlock Text="{Binding Status}" VerticalAlignment="Center" Margin="0,0,8,0"/><CheckBox Content="{loc:Localize Log.ErrorsOnly}" IsChecked="{Binding OnlyErrors}"/></WrapPanel>
+  <WrapPanel>
+   <Button Content="{loc:Localize Uiux.Validation.Check}" Command="{Binding ValidateCommand}" Margin="0,0,8,0"/><TextBlock Text="{Binding Status}" VerticalAlignment="Center" Margin="0,0,8,0"/>
+   <CheckBox VerticalAlignment="Center" Content="{loc:Localize Log.ErrorsOnly}" IsChecked="{Binding OnlyErrors}"/>
+  </WrapPanel>
   <ListBox Grid.Row="1" ItemsSource="{Binding VisibleProblems}">
    <ListBox.ItemTemplate><DataTemplate x:DataType="vm:AuthorProblem">
-    <Grid ColumnDefinitions="Auto,*,Auto" ColumnSpacing="8">
+    <Grid ColumnDefinitions="Auto,*,Auto" RowDefinitions="Auto,Auto" ColumnSpacing="8" RowSpacing="4">
      <TextBlock Text="{loc:Localize SeverityKey}" Classes="severity" Classes.error="{Binding IsError}" Classes.warning="{Binding IsWarning}"/>
-     <Button Grid.Column="1" Command="{Binding #Root.DataContext.NavigateCommand}" CommandParameter="{Binding}" HorizontalContentAlignment="Left" Background="Transparent">
-      <StackPanel><TextBlock Text="{Binding Message}" TextWrapping="Wrap"/><TextBlock Text="{Binding Source}" FontSize="11" Foreground="{DynamicResource SemiColorText2}"/></StackPanel>
-     </Button>
-     <Button Grid.Column="2" Content="{loc:Localize Files.CancelDraft}" Command="{Binding #Root.DataContext.DiscardCommand}" CommandParameter="{Binding}" IsVisible="{Binding HasDiscard}"/>
+     <StackPanel Grid.Column="1" Spacing="4">
+      <Button Command="{Binding #Root.DataContext.NavigateCommand}" CommandParameter="{Binding}" IsVisible="{Binding CanNavigate}" ToolTip.Tip="{Binding NavigationHint}" HorizontalAlignment="Stretch" HorizontalContentAlignment="Stretch" Background="Transparent">
+       <StackPanel Spacing="4" HorizontalAlignment="Stretch"><TextBlock Text="{Binding Message}" TextWrapping="Wrap" TextAlignment="Left"/><TextBlock Text="{Binding Source}" FontSize="11" Foreground="{DynamicResource SemiColorText2}" TextWrapping="Wrap" TextAlignment="Left"/></StackPanel>
+      </Button>
+      <TextBlock Text="{Binding Message}" TextWrapping="Wrap" IsVisible="{Binding !CanNavigate}" ToolTip.Tip="{Binding NavigationHint}"/>
+      <TextBlock Text="{Binding Source}" FontSize="11" Foreground="{DynamicResource SemiColorText2}" TextWrapping="Wrap" IsVisible="{Binding !CanNavigate}"/>
+      <Expander Header="{loc:Localize Problem.Details}" IsVisible="{Binding HasDetails}"><SelectableTextBlock Text="{Binding Details}" TextWrapping="Wrap"/></Expander>
+     </StackPanel>
+     <StackPanel Grid.Column="2" Spacing="4">
+      <Button Content="{loc:Localize Uiux.Draft.Restore}" Command="{Binding #Root.DataContext.RestoreCommand}" CommandParameter="{Binding}" IsVisible="{Binding HasRestore}"/>
+      <Button Content="{loc:Localize Files.CancelDraft}" Command="{Binding #Root.DataContext.DiscardCommand}" CommandParameter="{Binding}" IsVisible="{Binding HasDiscard}"/>
+     </StackPanel>
+     <TextBox Grid.Row="1" Grid.ColumnSpan="3" Text="{Binding InputText, Mode=OneWay}" IsReadOnly="True" IsVisible="{Binding HasInputText}" AcceptsReturn="True" MaxHeight="120" TextWrapping="Wrap"/>
     </Grid>
    </DataTemplate></ListBox.ItemTemplate>
   </ListBox>
diff --git a/src/Editor/GalNet.Editor/Views/ProjectSettingsPanelView.axaml b/src/Editor/GalNet.Editor/Views/ProjectSettingsPanelView.axaml
index 9ac9cbe9..19bcfe35 100644
--- a/src/Editor/GalNet.Editor/Views/ProjectSettingsPanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/ProjectSettingsPanelView.axaml
@@ -2,92 +2,63 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:loc="using:GalNet.Editor.MarkupExtensions"
              xmlns:vm="using:GalNet.Editor.ViewModels"
+             xmlns:services="using:GalNet.Editor.Services"
+             xmlns:forms="using:GalNet.Game.Controls.Forms"
              x:Class="GalNet.Editor.Views.ProjectSettingsPanelView"
              x:DataType="vm:ProjectSettingsPanelViewModel"
              Background="{DynamicResource SemiColorBackground0}">
+    <UserControl.Styles><StyleInclude Source="/Controls/AuthorFormStyles.axaml" /></UserControl.Styles>
     <Grid RowDefinitions="Auto,*,Auto" Margin="12">
-        <TextBlock Grid.Row="0" Text="{loc:Localize Settings.Project.Title}"
+        <TextBlock Name="ProjectSettingsTitle" Grid.Row="0" Text="{loc:Localize Settings.Project.Title}"
                    FontSize="16" FontWeight="Bold"
                    Foreground="{DynamicResource SemiColorText0}"
                    Margin="0,0,0,12" />
 
-        <ScrollViewer Grid.Row="1">
+        <TabControl Grid.Row="1" TabStripPlacement="Left">
+          <TabItem Header="{loc:Localize Settings.Project.Title}">
+        <ScrollViewer Name="SettingsForm" LostFocus="OnSettingsFocusLost">
             <StackPanel Spacing="8">
                 <TextBlock Text="{loc:Localize Settings.Project.Name}" />
                 <TextBox Name="ProjectNameInput" Text="{Binding ProjectName}" />
-                <TextBlock Text="{loc:Localize Settings.Project.DefaultResolution}"
-                           Foreground="{DynamicResource SemiColorText2}"
-                           FontSize="12" />
-                <ComboBox ItemsSource="{Binding ResolutionPresets}"
-                          Text="{Binding Resolution}"
-                          IsEditable="True"
-                          Foreground="{DynamicResource SemiColorText0}" />
-
-                <TextBlock Text="{loc:Localize Settings.Project.SaveSlotCount}"
-                           Foreground="{DynamicResource SemiColorText2}"
-                           FontSize="12"
-                           Margin="0,4,0,0" />
-                <NumericUpDown Value="{Binding SaveSlotCount}"
-                               Minimum="1" Maximum="999" Increment="1"
-                               Foreground="{DynamicResource SemiColorText0}" />
-
-                <TextBlock Text="{loc:Localize Settings.Project.SfxChannelCount}"
-                           Foreground="{DynamicResource SemiColorText2}"
-                           FontSize="12"
-                           Margin="0,4,0,0" />
-                <NumericUpDown Value="{Binding SfxChannelCount}"
-                               Minimum="1" Maximum="16" Increment="1"
-                               Foreground="{DynamicResource SemiColorText0}" />
-
-                <Grid ColumnDefinitions="*,Auto" Margin="0,8,0,0">
-                    <TextBlock Text="{loc:Localize Settings.Project.AudioTracks}" Foreground="{DynamicResource SemiColorText2}" FontSize="12" />
-                    <Button Grid.Column="1" Content="{loc:Localize Settings.Project.AddTrack}" Command="{Binding AddAudioTrackCommand}" />
-                </Grid>
-                <ItemsControl ItemsSource="{Binding AudioTracks}">
+                <TextBlock Text="{loc:Localize Settings.Project.TargetLanguage}" />
+                <TextBox Text="{Binding TargetLocale}" IsReadOnly="True" ToolTip.Tip="{loc:Localize I18n.UsePanel}" />
+                <ItemsControl ItemsSource="{Binding Sections}">
                     <ItemsControl.ItemTemplate>
-                        <DataTemplate x:DataType="vm:AudioTrackEditorItem">
-                            <Grid ColumnDefinitions="*,*,110,80,70,70,Auto" ColumnSpacing="6" Margin="0,2">
-                                <TextBox Grid.Column="0" Text="{Binding Id}" PlaceholderText="{loc:Localize Settings.Project.TrackId}" />
-                                <TextBox Grid.Column="1" Text="{Binding Name}" PlaceholderText="{loc:Localize Settings.Project.TrackName}" />
-                                <TextBox Grid.Column="2" Text="{Binding Bus}" PlaceholderText="bgm / sfx / vocal" />
-                                <NumericUpDown Grid.Column="3" Value="{Binding DefaultGain}" ToolTip.Tip="{loc:Localize Settings.Project.Gain}" AutomationProperties.Name="{loc:Localize Settings.Project.Gain}" Minimum="0" Maximum="1" Increment="0.05" />
-                                <NumericUpDown Grid.Column="4" Value="{Binding MaxVoices}" ToolTip.Tip="{loc:Localize Settings.Project.Voices}" AutomationProperties.Name="{loc:Localize Settings.Project.Voices}" Minimum="1" Maximum="32" Increment="1" />
-                                <NumericUpDown Grid.Column="5" Value="{Binding MaxQueuedItems}" ToolTip.Tip="{loc:Localize Settings.Project.Queue}" AutomationProperties.Name="{loc:Localize Settings.Project.Queue}" Minimum="0" Maximum="256" Increment="1" />
-                                <Button Grid.Column="6" Content="×" Command="{Binding RemoveCommand}" ToolTip.Tip="{loc:Localize Settings.Project.RemoveTrack}" AutomationProperties.Name="{loc:Localize Settings.Project.RemoveTrack}" />
-                            </Grid>
+                        <DataTemplate x:DataType="services:ConfigurationSectionEditor">
+                            <Expander Header="{Binding Id}" IsExpanded="True" HorizontalAlignment="Stretch">
+                                <forms:DtoEditorHost Item="{Binding Item}" Registry="{Binding Registry}" />
+                            </Expander>
                         </DataTemplate>
                     </ItemsControl.ItemTemplate>
                 </ItemsControl>
-
-                <TextBlock Text="{loc:Localize Settings.Project.TargetLanguage}"
-                           Foreground="{DynamicResource SemiColorText2}"
-                           FontSize="12"
-                           Margin="0,4,0,0" />
-                <TextBox Text="{Binding TargetLocale}" IsReadOnly="True" ToolTip.Tip="{loc:Localize I18n.UsePanel}"
-                         Foreground="{DynamicResource SemiColorText0}"
-                         PlaceholderText="zh-CN" />
-                <Expander Header="{loc:Localize Debug.Configuration}">
+            </StackPanel>
+        </ScrollViewer>
+          </TabItem>
+          <TabItem Header="{loc:Localize Debug.Configuration}">
+              <ScrollViewer>
+                <StackPanel Margin="12" Spacing="6">
+                <TextBlock Text="{loc:Localize Debug.Configuration}" FontWeight="SemiBold" Margin="0,8,0,0"/>
                     <StackPanel Spacing="6">
-                        <TextBox Text="{Binding DebugExecutable}" PlaceholderText="{loc:Localize Debug.Executable}"/>
+                        <Grid ColumnDefinitions="*,Auto" ColumnSpacing="6">
+                            <TextBox Text="{Binding DebugExecutable}" PlaceholderText="{loc:Localize Debug.Executable}"/>
+                            <Button Grid.Column="1" Content="…" Command="{Binding BrowseDebugExecutableCommand}" ToolTip.Tip="{loc:Localize Debug.Executable}"/>
+                        </Grid>
                         <TextBox Text="{Binding DebugArguments}" PlaceholderText="{loc:Localize Debug.Arguments}" AcceptsReturn="True" MinHeight="50"/>
-                        <TextBox Text="{Binding DebugWorkingDirectory}" PlaceholderText="{loc:Localize Debug.WorkingDirectory}"/>
-                        <Button Content="{loc:Localize Debug.SaveConfiguration}" Command="{Binding SaveDebugConfigurationCommand}"/>
+                        <Grid ColumnDefinitions="*,Auto" ColumnSpacing="6">
+                            <TextBox Text="{Binding DebugWorkingDirectory}" PlaceholderText="{loc:Localize Debug.WorkingDirectory}"/>
+                            <Button Grid.Column="1" Content="…" Command="{Binding BrowseDebugWorkingDirectoryCommand}" ToolTip.Tip="{loc:Localize Debug.WorkingDirectory}"/>
+                        </Grid>
                         <TextBlock Text="{Binding DebugConfigurationMessage}" TextWrapping="Wrap"/>
                     </StackPanel>
-                </Expander>
             </StackPanel>
         </ScrollViewer>
+          </TabItem>
+        </TabControl>
 
-        <Grid Grid.Row="2" ColumnDefinitions="*,Auto" Margin="0,12,0,0">
+        <Grid Grid.Row="2" ColumnDefinitions="*" Margin="0,12,0,0">
             <TextBlock Grid.Column="0" Text="{Binding IsDirtyText}"
                        Foreground="{DynamicResource SemiColorText2}"
                        VerticalAlignment="Center" />
-            <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="8">
-                <Button Content="{loc:Localize Settings.Project.Cancel}" Command="{Binding CancelDraftCommand}" />
-                <Button Name="ApplySettingsButton"
-                        Content="{loc:Localize Settings.Project.Apply}"
-                        Command="{Binding SaveSettingsCommand}" />
-            </StackPanel>
         </Grid>
     </Grid>
 </UserControl>
diff --git a/src/Editor/GalNet.Editor/Views/ProjectSettingsPanelView.axaml.cs b/src/Editor/GalNet.Editor/Views/ProjectSettingsPanelView.axaml.cs
index f5933e8c..2891a66a 100644
--- a/src/Editor/GalNet.Editor/Views/ProjectSettingsPanelView.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/ProjectSettingsPanelView.axaml.cs
@@ -1,6 +1,8 @@
 using Avalonia.Controls;
 using Avalonia.Input;
+using Avalonia.Interactivity;
 using Avalonia.VisualTree;
+using Avalonia.Threading;
 using GalNet.Editor.ViewModels;
 
 namespace GalNet.Editor.Views;
@@ -39,6 +41,16 @@ private void ResetTextUndo()
         }
     }
 
+    private void OnSettingsFocusLost(object? sender, RoutedEventArgs args)
+    {
+        Dispatcher.UIThread.Post(async () =>
+        {
+            if (SettingsForm.IsKeyboardFocusWithin || DataContext is not ProjectSettingsPanelViewModel viewModel) return;
+            try { await viewModel.CommitDraftAsync(); }
+            catch (Exception) { /* The view model keeps the draft and displays the validation error. */ }
+        });
+    }
+
     private async void OnKeyDown(object? sender, KeyEventArgs args)
     {
         if (args.Handled || DataContext is not ProjectSettingsPanelViewModel viewModel) return;
@@ -47,11 +59,12 @@ private async void OnKeyDown(object? sender, KeyEventArgs args)
             viewModel.CancelDraftCommand.Execute(null);
             args.Handled = true;
         }
-        else if (args.Key == Key.Enter && args.KeyModifiers == KeyModifiers.None)
+        else if (args.Key == Key.Enter && args.KeyModifiers == KeyModifiers.None &&
+                 args.Source is not TextBox { AcceptsReturn: true })
         {
             args.Handled = true;
             try { await viewModel.CommitDraftAsync(); }
-            catch (System.IO.InvalidDataException) { }
+            catch (Exception) { /* The view model displays the validation error. */ }
         }
     }
 }
diff --git a/src/Editor/GalNet.Editor/Views/ProjectSettingsWindow.axaml.cs b/src/Editor/GalNet.Editor/Views/ProjectSettingsWindow.axaml.cs
index c815ce13..d9012646 100644
--- a/src/Editor/GalNet.Editor/Views/ProjectSettingsWindow.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/ProjectSettingsWindow.axaml.cs
@@ -15,7 +15,7 @@ public ProjectSettingsWindow()
             if (_approved || DataContext is not ProjectSettingsPanelViewModel viewModel) return;
             args.Cancel = true;
             try { await viewModel.CommitDraftAsync(); _approved = true; Close(); }
-            catch (System.IO.InvalidDataException) { }
+            catch (System.Exception) { /* The view model displays the validation error. */ }
         };
         Closed += (_, _) => (DataContext as System.IDisposable)?.Dispose();
     }
diff --git a/src/Editor/GalNet.Editor/Views/ResourceOverridesPanelView.axaml b/src/Editor/GalNet.Editor/Views/ResourceOverridesPanelView.axaml
new file mode 100644
index 00000000..8dd440c4
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Views/ResourceOverridesPanelView.axaml
@@ -0,0 +1,50 @@
+<UserControl xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="using:GalNet.Editor.ViewModels" xmlns:controls="using:GalNet.Editor.Controls"
+             xmlns:loc="clr-namespace:GalNet.Editor.MarkupExtensions"
+             x:Class="GalNet.Editor.Views.ResourceOverridesPanelView" x:DataType="vm:ResourceOverridesPanelViewModel">
+  <UserControl.Resources><ResourceDictionary><ResourceDictionary.MergedDictionaries><ResourceInclude Source="avares://GalNet.Editor/Themes/AuthoringPanelResources.axaml"/></ResourceDictionary.MergedDictionaries></ResourceDictionary></UserControl.Resources>
+  <UserControl.Styles>
+    <Style Selector="TextBox.patchName">
+      <Setter Property="Background" Value="Transparent"/><Setter Property="BorderBrush" Value="Transparent"/>
+      <Setter Property="FontWeight" Value="SemiBold"/><Setter Property="Padding" Value="6,4"/>
+    </Style>
+    <Style Selector="TextBox.patchName:focus"><Setter Property="BorderBrush" Value="{DynamicResource SemiColorPrimary}"/></Style>
+  </UserControl.Styles>
+  <Grid RowDefinitions="Auto,*,Auto" Margin="8" RowSpacing="8">
+    <Grid ColumnDefinitions="*,Auto,Auto,Auto,Auto" ColumnSpacing="8">
+      <TextBox x:Name="ResourcePatchSearch" Text="{Binding Search}" PlaceholderText="{loc:Localize Packaging.Search}" MinWidth="80" VerticalContentAlignment="Center"/>
+      <CheckBox x:Name="ShowResourceDependencies" Grid.Column="1" Content="{loc:Localize Packaging.Dependencies}" IsChecked="{Binding ShowDependencies}"
+                VerticalAlignment="Center" VerticalContentAlignment="Center"/>
+      <Button x:Name="ManageResourceOriginals" Grid.Column="2" Theme="{StaticResource EditorIconButton}" VerticalAlignment="Center"
+              ToolTip.Tip="{loc:Localize Packaging.AddOriginal}" AutomationProperties.Name="{loc:Localize Packaging.AddOriginal}">
+        <PathIcon Width="16" Height="16" Data="{StaticResource PanelImportIcon}"/>
+        <Button.Flyout><Flyout><StackPanel Width="300" Spacing="8">
+          <TextBlock Text="{loc:Localize Packaging.AddOriginal}" FontWeight="SemiBold"/>
+          <Grid ColumnDefinitions="*,Auto" ColumnSpacing="4">
+            <controls:AssetPicker x:Name="AdditionalOriginal" AssetManager="{Binding Service.Assets}" ResourceTypeId="*" VerticalAlignment="Center"/>
+            <Button x:Name="AddResourceOriginal" Grid.Column="1" Theme="{StaticResource EditorIconButton}" Click="AddOriginal"
+                    ToolTip.Tip="{loc:Localize Packaging.AddOriginal}" AutomationProperties.Name="{loc:Localize Packaging.AddOriginal}">
+              <PathIcon Width="16" Height="16" Data="{StaticResource AddIcon}"/>
+            </Button>
+          </Grid>
+        </StackPanel></Flyout></Button.Flyout>
+      </Button>
+      <Button x:Name="CancelResourceExport" Grid.Column="3" Theme="{StaticResource EditorIconButton}" IsVisible="{Binding Busy}" Click="CancelExport"
+              ToolTip.Tip="{loc:Localize Packaging.Cancel}" AutomationProperties.Name="{loc:Localize Packaging.Cancel}" VerticalAlignment="Center">
+        <PathIcon Width="16" Height="16" Data="{StaticResource PanelCancelIcon}"/>
+      </Button>
+      <Button x:Name="CreateResourcePatch" Grid.Column="4" Theme="{StaticResource EditorIconButton}" Click="CreatePatch"
+              ToolTip.Tip="{loc:Localize Packaging.Create}" AutomationProperties.Name="{loc:Localize Packaging.Create}" VerticalAlignment="Center">
+        <PathIcon Width="16" Height="16" Data="{StaticResource AddIcon}"/>
+      </Button>
+    </Grid>
+    <Grid Grid.Row="1" Background="{DynamicResource SemiColorBackground0}">
+      <ScrollViewer x:Name="ResourcePatchHorizontalScroll" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Disabled">
+        <Grid x:Name="ResourcePatchTable" RowDefinitions="Auto,*" HorizontalAlignment="Left"/>
+      </ScrollViewer>
+      <TextBlock x:Name="ResourcePatchEmpty" Text="{loc:Localize Uiux.Panel.NoResults}" IsHitTestVisible="False"
+                 HorizontalAlignment="Center" VerticalAlignment="Center" Foreground="{DynamicResource SemiColorText2}"/>
+    </Grid>
+    <TextBlock Grid.Row="2" Text="{Binding Message}" TextWrapping="Wrap" MaxHeight="100" Foreground="{DynamicResource SystemControlErrorTextForegroundBrush}"/>
+  </Grid>
+</UserControl>
diff --git a/src/Editor/GalNet.Editor/Views/ResourceOverridesPanelView.axaml.cs b/src/Editor/GalNet.Editor/Views/ResourceOverridesPanelView.axaml.cs
new file mode 100644
index 00000000..a0844ae3
--- /dev/null
+++ b/src/Editor/GalNet.Editor/Views/ResourceOverridesPanelView.axaml.cs
@@ -0,0 +1,143 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Templates;
+using Avalonia.Data;
+using Avalonia.Input;
+using Avalonia.Layout;
+using Avalonia.Styling;
+using GalNet.Editor.Controls;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.ViewModels;
+
+namespace GalNet.Editor.Views;
+
+/// <summary>One source column and one editable column per independent resource patch.</summary>
+public sealed partial class ResourceOverridesPanelView : UserControl
+{
+    private ResourceOverridesPanelViewModel? _model;
+    public ResourceOverridesPanelView()
+    {
+        InitializeComponent();
+        DataContextChanged += (_, _) => Connect();
+        AttachedToVisualTree += (_, _) => Connect();
+        DetachedFromVisualTree += (_, _) => Disconnect();
+    }
+    private void Disconnect() { if (_model is { } model) model.StructureChanged -= Rebuild; _model = null; }
+    private void Connect()
+    {
+        Disconnect(); _model = DataContext as ResourceOverridesPanelViewModel;
+        if (_model is { } model) { model.StructureChanged += Rebuild; Rebuild(); }
+    }
+    private void Rebuild()
+    {
+        if (_model is not { } model) return;
+        var columns = model.Columns.ToArray();
+        var table = ResourcePatchTable; table.Children.Clear();
+        table.Width = 300 + 260 * columns.Length;
+        ResourcePatchEmpty.IsVisible = model.Rows.Count == 0;
+        var headers = new StackPanel { Orientation = Orientation.Horizontal };
+        headers.Children.Add(new TextBlock { Text = model.L["Packaging.Original"], Width = 292, Margin = new Thickness(4), VerticalAlignment = VerticalAlignment.Center });
+        foreach (var column in columns)
+        {
+            var header = new Grid { Width = 260, RowDefinitions = new("Auto,Auto"), Margin = new Thickness(0, 0, 0, 6), RowSpacing = 4 };
+            var top = new Grid { ColumnDefinitions = new("*,Auto,Auto"), ColumnSpacing = 2 };
+            var name = new TextBox { Name = "PatchName_" + column.Id, Text = column.Name, MinWidth = 0, VerticalContentAlignment = VerticalAlignment.Center };
+            name.Classes.Add("patchName"); ToolTip.SetTip(name, model.L["Packaging.Name"]);
+            var priority = new NumericUpDown
+            {
+                Name = "PatchPriority_" + column.Id,
+                Minimum = int.MinValue,
+                Maximum = int.MaxValue,
+                Increment = 1,
+                FormatString = "0",
+                ParsingNumberStyle = System.Globalization.NumberStyles.Integer,
+                Value = column.Priority,
+                Width = 108,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+            async Task SaveHeader()
+            {
+                if (name.Text == column.Name && priority.Value == column.Priority) return;
+                await model.SetHeaderAsync(column, name.Text ?? "", (int)(priority.Value ?? column.Priority));
+                name.Text = column.Name; priority.Value = column.Priority;
+            }
+            name.LostFocus += async (_, _) => await SaveHeader();
+            name.KeyDown += async (_, args) => { if (args.Key == Key.Enter) { args.Handled = true; await SaveHeader(); } };
+            priority.ValueChanged += async (_, _) => await SaveHeader();
+            name.Bind(TextBox.TextProperty, new Binding(nameof(ResourcePatchColumn.Name)) { Source = column, Mode = BindingMode.OneWay });
+            priority.Bind(NumericUpDown.ValueProperty, new Binding(nameof(ResourcePatchColumn.Priority)) { Source = column, Mode = BindingMode.OneWay });
+            var export = IconButton("PanelExportIcon", model.L["Packaging.Export"], "ExportPatch_" + column.Id);
+            export.Bind(IsEnabledProperty, new Binding(nameof(ResourceOverridesPanelViewModel.CanExport)) { Source = model });
+            export.Click += async (_, _) => await model.ExportAsync(column.Id);
+            var delete = IconButton("DeleteRegularIcon", model.L["Packaging.Delete"], "DeletePatch_" + column.Id);
+            delete.Click += async (_, _) => await model.DeleteAsync(column.Id);
+            top.Children.Add(name); Grid.SetColumn(export, 1); top.Children.Add(export); Grid.SetColumn(delete, 2); top.Children.Add(delete);
+            header.Children.Add(top);
+            var bottom = new Grid { ColumnDefinitions = new("*,Auto"), Margin = new Thickness(6, 0, 6, 0) };
+            bottom.Children.Add(new TextBlock { Text = model.L["Packaging.PriorityLabel"], FontSize = 12, VerticalAlignment = VerticalAlignment.Center });
+            ToolTip.SetTip(bottom, model.L["Packaging.Priority"]);
+            Grid.SetColumn(priority, 1); bottom.Children.Add(priority); Grid.SetRow(bottom, 1); header.Children.Add(bottom);
+            headers.Children.Add(header);
+        }
+        table.Children.Add(headers);
+        var rows = new ListBox
+        {
+            Name = "ResourcePatchRows",
+            ItemsSource = model.Rows.ToArray(),
+            ItemTemplate = new FuncDataTemplate<ResourceReferenceRow>((row, _) => CreateRow(model, columns, row!))
+        };
+        rows.Styles.Add(new Avalonia.Styling.Style(selector => selector.OfType<ListBoxItem>())
+        {
+            Setters = { new Setter(ListBoxItem.PaddingProperty, new Thickness(0)),
+                new Setter(ListBoxItem.HorizontalContentAlignmentProperty, HorizontalAlignment.Stretch) }
+        });
+        Grid.SetRow(rows, 1); table.Children.Add(rows);
+    }
+    private async void CreatePatch(object? sender, Avalonia.Interactivity.RoutedEventArgs args) { if (_model is { } model) await model.CreateAsync(); }
+    private async void AddOriginal(object? sender, Avalonia.Interactivity.RoutedEventArgs args)
+    { if (_model is { } model && AdditionalOriginal.SelectedAssetId.Length > 0) await model.AddOriginalAsync(AdditionalOriginal.SelectedAssetId); }
+    private void CancelExport(object? sender, Avalonia.Interactivity.RoutedEventArgs args) => _model?.CancelExport();
+    private Button IconButton(string icon, string label, string name)
+    {
+        var button = new Button
+        {
+            Name = name,
+            Theme = (ControlTheme)this.FindResource("EditorIconButton")!,
+            VerticalAlignment = VerticalAlignment.Center,
+            Content = new PathIcon { Width = 16, Height = 16, Data = (Avalonia.Media.Geometry)this.FindResource(icon)! }
+        };
+        ToolTip.SetTip(button, label); Avalonia.Automation.AutomationProperties.SetName(button, label); return button;
+    }
+    private Control CreateRow(ResourceOverridesPanelViewModel model, ResourcePatchColumn[] columns, ResourceReferenceRow row)
+    {
+        var panel = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 0, MinHeight = 40 };
+        var source = new Grid { Width = 300, ColumnDefinitions = new("*,Auto"), Margin = new Thickness(0, 0, 0, 2) };
+        var description = new StackPanel { Margin = new Thickness(6, 4), VerticalAlignment = VerticalAlignment.Center, Spacing = 2 };
+        description.Children.Add(new TextBlock { Text = Path.GetFileName(row.Path), TextTrimming = Avalonia.Media.TextTrimming.CharacterEllipsis });
+        var type = new TextBlock { Text = row.TypeId + (row.Missing ? " · " + model.L["Packaging.Missing"] : ""), FontSize = 11 };
+        type.Bind(ForegroundProperty, this.GetResourceObservable("SemiColorText2")); description.Children.Add(type); source.Children.Add(description);
+        ToolTip.SetTip(source, row.Path + "\n" + row.Id + "\n" + string.Join("\n", row.Uses.Select(use => use.GroupId + "/" + use.EntryId + use.FieldPath + (use.Through is null ? "" : " ← " + use.Through))));
+        var locate = IconButton("PanelNavigateIcon", model.L["Packaging.Locate"], "Locate_" + row.Id);
+        locate.IsEnabled = !row.Missing; locate.Margin = new Thickness(4, 0); locate.Click += (_, _) => model.Locate(row);
+        Grid.SetColumn(locate, 1); source.Children.Add(locate); panel.Children.Add(source);
+        foreach (var column in columns)
+        {
+            var picker = new AssetPicker
+            {
+                Name = "Replacement_" + column.Id + "_" + row.Id,
+                Width = 250,
+                Margin = new Thickness(0, 0, 10, 0),
+                AssetManager = model.Service.Assets,
+                ResourceTypeId = row.TypeId.Length == 0 ? "*" : row.TypeId,
+                SelectedAssetId = column.Mappings.GetValueOrDefault(row.Id) ?? ""
+            };
+            picker.PropertyChanged += async (_, args) =>
+            {
+                if (args.Property == AssetPicker.SelectedAssetIdProperty)
+                    await model.SetMappingAsync(column, row, picker.SelectedAssetId);
+            };
+            panel.Children.Add(picker);
+        }
+        return panel;
+    }
+}
diff --git a/src/Editor/GalNet.Editor/Views/StartupPageView.axaml.cs b/src/Editor/GalNet.Editor/Views/StartupPageView.axaml.cs
index 56a55020..ec51cced 100644
--- a/src/Editor/GalNet.Editor/Views/StartupPageView.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/StartupPageView.axaml.cs
@@ -6,6 +6,20 @@ public partial class StartupPageView : UserControl
 {
     public StartupPageView()
     {
+#if BENCHMARK
+        using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Editor.CreateStartupView");
+#endif
         InitializeComponent();
+#if BENCHMARK
+        Loaded += (_, _) =>
+        {
+            GalNet.Diagnostics.CpuProfiler.Shared.Mark("Editor.Startup.Loaded");
+            Avalonia.Threading.Dispatcher.UIThread.Post(() =>
+            {
+                if (GalNet.Diagnostics.StartupBenchmark.Complete())
+                    (TopLevel.GetTopLevel(this) as Window)?.Close();
+            }, Avalonia.Threading.DispatcherPriority.Background);
+        };
+#endif
     }
 }
diff --git a/src/Editor/GalNet.Editor/Views/TimelinePanelView.Events.cs b/src/Editor/GalNet.Editor/Views/TimelinePanelView.Events.cs
index ed758b4d..2b710f1c 100644
--- a/src/Editor/GalNet.Editor/Views/TimelinePanelView.Events.cs
+++ b/src/Editor/GalNet.Editor/Views/TimelinePanelView.Events.cs
@@ -11,7 +11,6 @@ namespace GalNet.Editor.Views;
 
 public partial class TimelinePanelView
 {
-    private Flyout? _eventFlyout;
     private Func<string, bool>? _eventInsertion;
     private void OnEventTypeOpened(object? sender, EventArgs args)
     { if (DataContext is ViewModels.TimelinePanelViewModel vm) _eventInsertion = vm.Session.CaptureEventInsertion(); }
@@ -22,39 +21,6 @@ private void OnEventPointerPressed(object? sender, PointerPressedEventArgs args)
         if (sender is not Control { DataContext: TimelineEventRow row } || DataContext is not ViewModels.TimelinePanelViewModel vm) return;
         if (args.GetCurrentPoint(this).Properties.IsLeftButtonPressed) vm.Session.SelectEvent(row, args.KeyModifiers.HasFlag(KeyModifiers.Control) || args.KeyModifiers.HasFlag(KeyModifiers.Meta));
     }
-    private void OnEditEvent(object? sender, RoutedEventArgs args)
-    { if (sender is Control { DataContext: TimelineEventRow row } control) OpenEventEditor(control, row); }
-    private void OpenEventEditor(Control anchor, TimelineEventRow row)
-    {
-        _eventFlyout?.Hide();
-        if (DataContext is not ViewModels.TimelinePanelViewModel vm || vm.Session.BeginEventEdit(row) is not { } draft) return;
-        var host = new DtoEditorHost { Name = "TimelineEventForm", Item = draft.Item, Registry = vm.FieldEditors };
-        var apply = new Button { Name = "ApplyTimelineEvent", Content = vm.Session.SceneText["Timeline.Event.Apply"] };
-        var cancel = new Button { Name = "CancelTimelineEvent", Content = vm.Session.SceneText["Timeline.Event.Cancel"] };
-        var body = new StackPanel { Width = 520, Margin = new(10), Spacing = 8 };
-        body.Styles.Add(new Avalonia.Markup.Xaml.Styling.StyleInclude(new Uri("avares://GalNet.Editor/")) { Source = new Uri("avares://GalNet.Editor/Controls/AuthorFormStyles.axaml") });
-        var heading = new TextBlock { Text = row.Label, TextWrapping = Avalonia.Media.TextWrapping.Wrap };
-        body.Children.Add(heading);
-        body.Children.Add(new ScrollViewer { MaxHeight = 450, HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled, Content = host });
-        body.Children.Add(new StackPanel { Orientation = Avalonia.Layout.Orientation.Horizontal, Spacing = 8, Children = { apply, cancel } });
-        var flyout = new Flyout { Content = body }; _eventFlyout = flyout;
-        FlyoutBase.SetAttachedFlyout(anchor, flyout);
-        void Changed(object? sender, PropertyChangedEventArgs args) { if (!draft.IsCurrent) flyout.Hide(); }
-        vm.Session.PropertyChanged += Changed;
-        void LocaleChanged(object? sender, PropertyChangedEventArgs args)
-        { heading.Text = row.Label; apply.Content = vm.Session.SceneText["Timeline.Event.Apply"]; cancel.Content = vm.Session.SceneText["Timeline.Event.Cancel"]; }
-        vm.Session.SceneText.PropertyChanged += LocaleChanged;
-        apply.Click += (_, _) => { if (draft.Apply()) flyout.Hide(); };
-        cancel.Click += (_, _) => flyout.Hide();
-        flyout.Closed += (_, _) =>
-        {
-            vm.Session.PropertyChanged -= Changed; vm.Session.SceneText.PropertyChanged -= LocaleChanged; host.Item = null; host.Registry = null; flyout.Content = null;
-            if (ReferenceEquals(vm.Session.EventEdit, draft)) vm.Session.EndEventEdit(); else draft.Dispose();
-            if (ReferenceEquals(_eventFlyout, flyout)) _eventFlyout = null;
-            if (ReferenceEquals(FlyoutBase.GetAttachedFlyout(anchor), flyout)) FlyoutBase.SetAttachedFlyout(anchor, null);
-        };
-        flyout.ShowAt(anchor);
-    }
     private void OnEventContextRequested(object? sender, ContextRequestedEventArgs args)
     {
         if (sender is not Control { DataContext: TimelineEventRow row } control || DataContext is not ViewModels.TimelinePanelViewModel vm) return;
@@ -72,7 +38,6 @@ void Add(string name, string key, Action action)
         { var item = new MenuItem { Name = name, Header = vm.Session.SceneText[key] }; item.Click += (_, _) => action(); menu.Items.Add(item); }
         if (rows.Length == 1)
         {
-            if (rows[0].CanEdit) Add("EditTimelineEventMenu", "Timeline.Event.Edit", () => OpenEventEditor(anchor, rows[0]));
             Add("EarlierTimelineEvent", "Timeline.Event.Earlier", () => vm.Session.OrderEvent(rows[0], -1));
             Add("LaterTimelineEvent", "Timeline.Event.Later", () => vm.Session.OrderEvent(rows[0], 1));
         }
diff --git a/src/Editor/GalNet.Editor/Views/TimelinePanelView.axaml b/src/Editor/GalNet.Editor/Views/TimelinePanelView.axaml
index 344cf907..b63a481f 100644
--- a/src/Editor/GalNet.Editor/Views/TimelinePanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/TimelinePanelView.axaml
@@ -15,101 +15,107 @@
       <Setter Property="Interval" Value="30"/>
     </Style>
   </UserControl.Styles>
-  <Grid Margin="10" RowDefinitions="Auto,Auto,Auto,Auto,Auto,*,Auto,Auto" RowSpacing="6">
-    <TextBlock Text="{Binding Session.Source}" Opacity="0.7" TextWrapping="Wrap"/>
-    <StackPanel Grid.Row="1" Orientation="Horizontal" Spacing="8">
+  <Grid Margin="8,6,8,4" RowDefinitions="Auto,Auto,*,Auto,Auto,Auto">
+    <Grid ColumnDefinitions="*,Auto" ColumnSpacing="12" Margin="0,0,0,4">
+      <TextBlock Text="{Binding Session.Source}" Opacity="0.7" TextTrimming="CharacterEllipsis" ToolTip.Tip="{Binding Session.Source}" VerticalAlignment="Center"/>
+      <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="6" IsVisible="{Binding Session.CanEdit}">
+        <TextBlock Text="{loc:Localize Timeline.Duration}" VerticalAlignment="Center"/>
+        <NumericUpDown Name="TimelineDurationDraft" Width="95" Minimum="{Binding Session.MinimumDuration}" Maximum="2147483647" Increment="1" FormatString="0" Value="{Binding Session.TimingDurationDraft,Mode=TwoWay}" LostFocus="OnTimingLostFocus"/>
+        <TextBlock Text="FPS" VerticalAlignment="Center"/>
+        <NumericUpDown Name="TimelineFpsDraft" Width="75" Minimum="1" Maximum="240" Increment="1" FormatString="0" Value="{Binding Session.TimingFrameRateDraft,Mode=TwoWay}" LostFocus="OnTimingLostFocus"/>
+        <Button Name="TimelinePreviousKey" Theme="{DynamicResource EditorIconButton}" Command="{Binding PreviousKeyCommand}" ToolTip.Tip="{loc:Localize Timeline.PreviousKey}" AutomationProperties.Name="{loc:Localize Timeline.PreviousKey}"><PathIcon Width="16" Height="16" Data="M4 4H6V20H4Z M17 4L9 12L17 20L19 18L13 12L19 6Z"/></Button>
+        <Button Name="TimelineNextKey" Theme="{DynamicResource EditorIconButton}" Command="{Binding NextKeyCommand}" ToolTip.Tip="{loc:Localize Timeline.NextKey}" AutomationProperties.Name="{loc:Localize Timeline.NextKey}"><PathIcon Width="16" Height="16" Data="M18 4H20V20H18Z M7 4L15 12L7 20L5 18L11 12L5 6Z"/></Button>
+        <Button Name="TimelineAddKey" Theme="{DynamicResource EditorIconButton}" Command="{Binding AddKeyCommand}" ToolTip.Tip="{loc:Localize Timeline.AddKey}" AutomationProperties.Name="{loc:Localize Timeline.AddKey}"><PathIcon Width="16" Height="16" Data="{StaticResource AddIcon}"/></Button>
+        <Button Name="TimelineDeleteKeys" Theme="{DynamicResource EditorIconButton}" Command="{Binding DeleteKeysCommand}" ToolTip.Tip="{loc:Localize Timeline.DeleteKeys}" AutomationProperties.Name="{loc:Localize Timeline.DeleteKeys}"><PathIcon Width="16" Height="16" Data="{StaticResource DeleteRegularIcon}"/></Button>
+      </StackPanel>
+    </Grid>
+    <StackPanel Grid.Row="1" Orientation="Horizontal" Spacing="8" IsVisible="{Binding !Session.CanEdit}">
       <TextBlock x:Name="TimelineStatus" Text="{loc:Localize Path=Session.StatusKey}" VerticalAlignment="Center"/>
       <Button x:Name="CreateTimeline" Content="{loc:Localize Timeline.Create}" Command="{Binding CreateCommand}" IsVisible="{Binding Session.CanCreate}"/>
     </StackPanel>
-    <WrapPanel Grid.Row="2" IsVisible="{Binding Session.CanEdit}">
-      <Button Name="AddTimelineObject" Content="＋" ToolTip.Tip="{loc:Localize Scene.AddObject}" Click="OnAddObject" Margin="0,0,6,0"/>
-      <TextBlock Text="{loc:Localize Timeline.Event.Add}" VerticalAlignment="Center" Margin="0,0,6,0"/>
-      <controls:EntryTypePicker Name="TimelineEventType" Options="{Binding Session.EventTypes}" SelectedValue="layer.show" Opened="OnEventTypeOpened" Closed="OnEventTypeClosed" TypeConfirmed="OnEventTypeConfirmed" Margin="0,0,8,0"/>
-      <TextBlock Margin="0,0,6,0" Text="{loc:Localize Timeline.Frame}" VerticalAlignment="Center"/>
-      <NumericUpDown x:Name="TimelineFrame" Width="90" Minimum="0" Maximum="{Binding Session.Duration}" Increment="1" FormatString="0" Value="{Binding Session.Frame,Mode=TwoWay}"/>
-      <Button Margin="6,0" Content="{loc:Localize Timeline.PreviousKey}" Command="{Binding PreviousKeyCommand}"/>
-      <Button Content="{loc:Localize Timeline.NextKey}" Command="{Binding NextKeyCommand}"/>
-      <Button Margin="6,0" Content="{loc:Localize Timeline.AddKey}" Command="{Binding AddKeyCommand}"/>
-      <Button Content="{loc:Localize Timeline.DeleteKeys}" Command="{Binding DeleteKeysCommand}"/>
-    </WrapPanel>
-    <WrapPanel Grid.Row="3" IsVisible="{Binding Session.CanEdit}">
-      <TextBlock Margin="0,0,6,0" Text="{loc:Localize Timeline.Duration}" VerticalAlignment="Center"/>
-      <NumericUpDown Name="TimelineDurationDraft" Width="95" Minimum="{Binding Session.MinimumDuration}" Maximum="2147483647" Increment="1" FormatString="0" Value="{Binding Session.TimingDurationDraft,Mode=TwoWay}" LostFocus="OnTimingLostFocus"/>
-      <TextBlock Margin="6,0" Text="FPS" VerticalAlignment="Center"/>
-      <NumericUpDown Name="TimelineFpsDraft" Width="75" Minimum="1" Maximum="240" Increment="1" FormatString="0" Value="{Binding Session.TimingFrameRateDraft,Mode=TwoWay}" LostFocus="OnTimingLostFocus"/>
-    </WrapPanel>
-    <Grid Grid.Row="4" RowDefinitions="28,Auto" IsVisible="{Binding Session.CanEdit}"><Grid.ColumnDefinitions><ColumnDefinition Width="{Binding #Root.TreeColumnWidth,Mode=TwoWay}" MinWidth="180" MaxWidth="600"/><ColumnDefinition Width="5"/><ColumnDefinition Width="*"/></Grid.ColumnDefinitions>
-      <TextBlock Text="{loc:Localize Timeline.Event.Title}" Opacity="0.7"/>
-      <timeline:TimelineCanvas Grid.Column="2" Name="TimelineRuler" IsRuler="True" Model="{Binding Session.Canvas}"/>
-      <ScrollViewer Grid.Row="1" Grid.ColumnSpan="3" MaxHeight="190" HorizontalScrollBarVisibility="Disabled" VerticalScrollBarVisibility="Auto">
-        <Grid><Grid.ColumnDefinitions><ColumnDefinition Width="{Binding #Root.TreeColumnWidth,Mode=TwoWay}" MinWidth="180" MaxWidth="600"/><ColumnDefinition Width="5"/><ColumnDefinition Width="*"/></Grid.ColumnDefinitions>
-          <ItemsControl Name="TimelineEvents" ItemsSource="{Binding Session.Events}">
-            <ItemsControl.ItemTemplate><DataTemplate x:DataType="services:TimelineEventRow">
-              <Border Name="TimelineEventRow" Height="38" Background="Transparent" PointerPressed="OnEventPointerPressed" ContextRequested="OnEventContextRequested">
-                <Grid ColumnDefinitions="20,*,Auto" Margin="4,0,6,0">
-                  <TextBlock Text="◆" Foreground="DodgerBlue" IsVisible="{Binding IsSelected}" VerticalAlignment="Center"/>
-                  <TextBlock Grid.Column="1" Text="{Binding Label}" ToolTip.Tip="{Binding Label}" TextTrimming="CharacterEllipsis" VerticalAlignment="Center"/>
-                  <Button Grid.Column="2" Name="EditTimelineEvent" Content="{loc:Localize Timeline.Event.Edit}" IsEnabled="{Binding CanEdit}" Click="OnEditEvent"/>
-                </Grid>
-              </Border>
-            </DataTemplate></ItemsControl.ItemTemplate>
-          </ItemsControl>
-          <timeline:TimelineCanvas Grid.Column="2" Name="TimelineEventKeys" KeyContextRequested="OnEventKeyContextRequested" Model="{Binding Session.EventCanvas}" Height="{Binding Session.EventCanvas.ContentHeight}" VerticalAlignment="Top"/>
+    <Grid Grid.Row="2" IsVisible="{Binding Session.CanEdit}">
+      <Grid.RowDefinitions><RowDefinition Height="*" MinHeight="64"/><RowDefinition Height="6"/><RowDefinition Height="*" MinHeight="64"/></Grid.RowDefinitions>
+      <Grid Name="TimelineObjectsSection" RowDefinitions="32,*" IsVisible="{Binding Session.CanEdit}"><Grid.ColumnDefinitions><ColumnDefinition Width="{Binding #Root.TreeColumnWidth,Mode=TwoWay}" MinWidth="180" MaxWidth="600"/><ColumnDefinition Width="5"/><ColumnDefinition Width="*"/></Grid.ColumnDefinitions>
+        <Grid ColumnDefinitions="*,Auto" Margin="4,0,6,0">
+          <TextBlock Text="{loc:Localize Timeline.ObjectTracks}" FontWeight="SemiBold" VerticalAlignment="Center"/>
+          <Button Grid.Column="1" Name="AddTimelineObject" Theme="{DynamicResource EditorIconButton}" ToolTip.Tip="{loc:Localize Scene.AddObject}" AutomationProperties.Name="{loc:Localize Scene.AddObject}" Click="OnAddObject"><PathIcon Width="16" Height="16" Data="{StaticResource AddIcon}"/></Button>
         </Grid>
-      </ScrollViewer>
-      <GridSplitter Grid.Column="1" Grid.RowSpan="3" Width="3" MinWidth="0" HorizontalAlignment="Center" ResizeDirection="Columns"/>
-    </Grid>
-    <Grid Grid.Row="5" RowDefinitions="28,*,Auto" IsVisible="{Binding Session.CanEdit}"><Grid.ColumnDefinitions><ColumnDefinition Width="{Binding #Root.TreeColumnWidth,Mode=TwoWay}" MinWidth="180" MaxWidth="600"/><ColumnDefinition Width="5"/><ColumnDefinition Width="*"/></Grid.ColumnDefinitions>
-      <TextBlock Text="{loc:Localize Timeline.CanvasHint}" TextTrimming="CharacterEllipsis" ToolTip.Tip="{loc:Localize Timeline.CanvasHint}" FontSize="11" VerticalAlignment="Center"/>
-      <ScrollViewer Name="TimelineVertical" Grid.Row="1" Grid.ColumnSpan="3" HorizontalScrollBarVisibility="Disabled" VerticalScrollBarVisibility="Auto">
-        <Grid><Grid.ColumnDefinitions><ColumnDefinition Width="{Binding #Root.TreeColumnWidth,Mode=TwoWay}" MinWidth="180" MaxWidth="600"/><ColumnDefinition Width="5"/><ColumnDefinition Width="*"/></Grid.ColumnDefinitions>
-          <ItemsControl Name="TimelinePropertyTree" ItemsSource="{Binding Session.VisibleNodes}">
-            <ItemsControl.ItemTemplate><DataTemplate x:DataType="services:TimelineTreeNode">
-              <Grid Name="TimelineTreeRow" Height="{Binding Height}" ColumnDefinitions="*,180" Background="Transparent" PointerPressed="OnTreeRowPointerPressed" ContextRequested="OnTreeContextRequested">
-                <Grid ColumnDefinitions="Auto,24,18,*" Height="38" VerticalAlignment="Top">
-                  <Border Width="{Binding Indent}"/>
-                  <Button Grid.Column="1" Name="AddTimelineProperty" Width="24" MinWidth="0" Padding="0" Content="＋" ToolTip.Tip="{loc:Localize Scene.AddProperty}" IsVisible="{Binding IsObject}" IsEnabled="{Binding CanAddProperties}" Click="OnAddProperty"/>
-                  <ToggleButton Grid.Column="2" Name="TimelineExpand" Width="18" MinWidth="0" Height="26" Padding="0" Content="{Binding ExpandGlyph}" IsVisible="{Binding CanExpand}" IsChecked="{Binding IsExpanded,Mode=TwoWay}"/>
-                  <TextBlock Grid.Column="3" Text="{Binding Label}" ToolTip.Tip="{Binding Label}" TextTrimming="CharacterEllipsis" VerticalAlignment="Center" Margin="3,0"/>
+        <timeline:TimelineCanvas Grid.Column="2" Name="TimelineRuler" IsRuler="True" Model="{Binding Session.Canvas}"/>
+        <ScrollViewer Name="TimelineVertical" Grid.Row="1" Grid.ColumnSpan="3" HorizontalScrollBarVisibility="Disabled" VerticalScrollBarVisibility="Auto">
+          <Grid><Grid.ColumnDefinitions><ColumnDefinition Width="{Binding #Root.TreeColumnWidth,Mode=TwoWay}" MinWidth="180" MaxWidth="600"/><ColumnDefinition Width="5"/><ColumnDefinition Width="*"/></Grid.ColumnDefinitions>
+            <ItemsControl Name="TimelinePropertyTree" ItemsSource="{Binding Session.VisibleNodes}">
+              <ItemsControl.ItemTemplate><DataTemplate x:DataType="services:TimelineTreeNode">
+                <Grid Name="TimelineTreeRow" Height="{Binding Height}" ColumnDefinitions="*,180" Background="Transparent" PointerPressed="OnTreeRowPointerPressed" ContextRequested="OnTreeContextRequested">
+                  <Grid ColumnDefinitions="Auto,24,18,*" Height="38" VerticalAlignment="Top">
+                    <Border Width="{Binding Indent}"/>
+                    <Button Grid.Column="1" Name="AddTimelineProperty" Theme="{DynamicResource EditorIconButton}" Width="24" Padding="4" ToolTip.Tip="{loc:Localize Scene.AddProperty}" AutomationProperties.Name="{loc:Localize Scene.AddProperty}" IsVisible="{Binding IsObject}" IsEnabled="{Binding CanAddProperties}" Click="OnAddProperty"><PathIcon Width="14" Height="14" Data="{StaticResource AddIcon}"/></Button>
+                    <ToggleButton Grid.Column="2" Name="TimelineExpand" Width="18" MinWidth="0" Height="26" Padding="0" Content="{Binding ExpandGlyph}" IsVisible="{Binding CanExpand}" IsChecked="{Binding IsExpanded,Mode=TwoWay}"/>
+                    <TextBlock Grid.Column="3" Text="{Binding Label}" ToolTip.Tip="{Binding Label}" TextTrimming="CharacterEllipsis" VerticalAlignment="Center" Margin="3,0"/>
+                  </Grid>
+                  <StackPanel Grid.ColumnSpan="2" Margin="30,44,10,0" VerticalAlignment="Top" IsVisible="{Binding HasCurve}" Spacing="6">
+                    <TextBlock Text="{loc:Localize Timeline.Curve.Hint}" Width="380" TextWrapping="Wrap" Opacity="0.65"/>
+                    <Button Name="FitTimelineCurve" Content="{loc:Localize Timeline.Curve.Fit}" Click="OnFitCurve" HorizontalAlignment="Left"/>
+                  </StackPanel>
+                  <ContentControl Height="38" VerticalAlignment="Top" Grid.Column="1" Content="{Binding Value}" IsVisible="{Binding IsLeaf}">
+                    <ContentControl.ContentTemplate><DataTemplate x:DataType="services:TimelineValueRow">
+                      <Grid ColumnDefinitions="90,*" ColumnSpacing="4">
+                        <NumericUpDown Name="TimelineValue" Value="{Binding DraftValue,Mode=TwoWay}" Increment="0.1" FormatString="G9" IsEnabled="{Binding IsEditable}" LostFocus="OnValueLostFocus">
+                          <ToolTip.Tip><StackPanel MaxWidth="420"><TextBlock Text="{Binding Hint}" TextWrapping="Wrap"/><TextBlock Text="{loc:Localize Timeline.InputHint}" TextWrapping="Wrap"/></StackPanel></ToolTip.Tip>
+                        </NumericUpDown>
+                        <ComboBox Grid.Column="1" Name="TimelineBlendMode" SelectedIndex="{Binding BlendModeIndex,Mode=OneWay}" SelectionChanged="OnBlendModeSelectionChanged" VerticalAlignment="Center" ToolTip.Tip="{loc:Localize Timeline.ModeHint}">
+                          <ComboBoxItem Content="{loc:Localize Timeline.Absolute}"/>
+                          <ComboBoxItem Content="{loc:Localize Timeline.Offset}"/>
+                        </ComboBox>
+                      </Grid>
+                    </DataTemplate></ContentControl.ContentTemplate>
+                  </ContentControl>
                 </Grid>
-                <StackPanel Grid.ColumnSpan="2" Margin="30,44,10,0" VerticalAlignment="Top" IsVisible="{Binding HasCurve}" Spacing="6">
-                  <TextBlock Text="{loc:Localize Timeline.Curve.Hint}" Width="380" TextWrapping="Wrap" Opacity="0.65"/>
-                  <Button Name="FitTimelineCurve" Content="{loc:Localize Timeline.Curve.Fit}" Click="OnFitCurve" HorizontalAlignment="Left"/>
-                </StackPanel>
-                <ContentControl Height="38" VerticalAlignment="Top" Grid.Column="1" Content="{Binding Value}" IsVisible="{Binding IsLeaf}">
-                  <ContentControl.ContentTemplate><DataTemplate x:DataType="services:TimelineValueRow">
-                    <Grid ColumnDefinitions="90,*" ColumnSpacing="4">
-                      <NumericUpDown Name="TimelineValue" Value="{Binding DraftValue,Mode=TwoWay}" Increment="0.1" FormatString="G9" IsEnabled="{Binding IsEditable}" LostFocus="OnValueLostFocus">
-                        <ToolTip.Tip><StackPanel MaxWidth="420"><TextBlock Text="{Binding Hint}" TextWrapping="Wrap"/><TextBlock Text="{loc:Localize Timeline.InputHint}" TextWrapping="Wrap"/></StackPanel></ToolTip.Tip>
-                      </NumericUpDown>
-                      <ComboBox Grid.Column="1" Name="TimelineBlendMode" SelectedIndex="{Binding BlendModeIndex,Mode=OneWay}" SelectionChanged="OnBlendModeSelectionChanged" VerticalAlignment="Center" ToolTip.Tip="{loc:Localize Timeline.ModeHint}">
-                        <ComboBoxItem Content="{loc:Localize Timeline.Absolute}"/>
-                        <ComboBoxItem Content="{loc:Localize Timeline.Offset}"/>
-                      </ComboBox>
-                    </Grid>
-                  </DataTemplate></ContentControl.ContentTemplate>
-                </ContentControl>
-              </Grid>
-            </DataTemplate></ItemsControl.ItemTemplate>
-          </ItemsControl>
-          <timeline:TimelineCanvas Grid.Column="2" Name="TimelineKeys" KeyContextRequested="OnKeyContextRequested" Model="{Binding Session.Canvas}" Height="{Binding Session.Canvas.ContentHeight}" VerticalAlignment="Top"/>
-          <TextBlock Text="{loc:Localize Timeline.Empty}" IsVisible="{Binding Session.HasNoRows}" TextWrapping="Wrap" Margin="4"/>
+              </DataTemplate></ItemsControl.ItemTemplate>
+            </ItemsControl>
+            <timeline:TimelineCanvas Grid.Column="2" Name="TimelineKeys" KeyContextRequested="OnKeyContextRequested" Model="{Binding Session.Canvas}" Height="{Binding Session.Canvas.ContentHeight}" VerticalAlignment="Top"/>
+            <TextBlock Text="{loc:Localize Timeline.Empty}" IsVisible="{Binding Session.HasNoRows}" TextWrapping="Wrap" Margin="4"/>
+          </Grid>
+        </ScrollViewer>
+        <GridSplitter Grid.Column="1" Grid.RowSpan="2" Width="3" MinWidth="0" HorizontalAlignment="Center" ResizeDirection="Columns"/>
+      </Grid>
+      <GridSplitter Name="TimelineSectionsSplitter" Grid.Row="1" Height="6" MinHeight="0" HorizontalAlignment="Stretch" ResizeDirection="Rows" ResizeBehavior="PreviousAndNext" Background="{DynamicResource SemiColorBorder}" ToolTip.Tip="{loc:Localize Timeline.ResizeSections}" AutomationProperties.Name="{loc:Localize Timeline.ResizeSections}"/>
+      <Grid Name="TimelineEventsSection" Grid.Row="2" RowDefinitions="32,*" IsVisible="{Binding Session.CanEdit}"><Grid.ColumnDefinitions><ColumnDefinition Width="{Binding #Root.TreeColumnWidth,Mode=TwoWay}" MinWidth="180" MaxWidth="600"/><ColumnDefinition Width="5"/><ColumnDefinition Width="*"/></Grid.ColumnDefinitions>
+        <Grid ColumnDefinitions="*,Auto" Margin="4,0,6,0">
+          <TextBlock Text="{loc:Localize Timeline.Event.Title}" FontWeight="SemiBold" VerticalAlignment="Center"/>
+          <controls:EntryTypePicker Grid.Column="1" Name="TimelineEventType" ButtonLabel="{loc:Localize Timeline.Event.Add}" Options="{Binding Session.EventTypes}" SelectedValue="layer.show" ToolTip.Tip="{loc:Localize Timeline.Event.Add}" AutomationProperties.Name="{loc:Localize Timeline.Event.Add}" Opened="OnEventTypeOpened" Closed="OnEventTypeClosed" TypeConfirmed="OnEventTypeConfirmed"/>
         </Grid>
-      </ScrollViewer>
-      <WrapPanel Grid.Row="2">
-        <Button Content="{loc:Localize Uiux.Timeline.Fit}" Click="OnFitTimeline"/><Button Content="{loc:Localize Uiux.Timeline.Playhead}" Click="OnLocatePlayhead"/><TextBlock Text="{Binding Session.Canvas.PixelsPerFrame}" VerticalAlignment="Center"/><TextBlock Text="{loc:Localize Timeline.Zoom}" VerticalAlignment="Center"/>
-        <Slider Name="TimelineZoom" Width="140" Minimum="0.001" Maximum="64" Value="{Binding Session.Canvas.PixelsPerFrame,Mode=TwoWay}"/>
-      </WrapPanel>
-      <ScrollBar Grid.Row="2" Grid.Column="2" Name="TimelineScroll" VerticalAlignment="Bottom" Orientation="Horizontal" Minimum="0" Maximum="{Binding Session.Duration}" SmallChange="1" LargeChange="10" Value="{Binding Session.Canvas.StartFrame,Mode=TwoWay}"/>
-      <GridSplitter Grid.Column="1" Grid.RowSpan="3" Width="3" MinWidth="0" HorizontalAlignment="Center" ResizeDirection="Columns"/>
+        <timeline:TimelineCanvas Grid.Column="2" Name="TimelineEventRuler" IsRuler="True" Model="{Binding Session.Canvas}"/>
+        <ScrollViewer Grid.Row="1" Grid.ColumnSpan="3" HorizontalScrollBarVisibility="Disabled" VerticalScrollBarVisibility="Auto">
+          <Grid><Grid.ColumnDefinitions><ColumnDefinition Width="{Binding #Root.TreeColumnWidth,Mode=TwoWay}" MinWidth="180" MaxWidth="600"/><ColumnDefinition Width="5"/><ColumnDefinition Width="*"/></Grid.ColumnDefinitions>
+            <ItemsControl Name="TimelineEvents" ItemsSource="{Binding Session.Events}">
+              <ItemsControl.ItemTemplate><DataTemplate x:DataType="services:TimelineEventRow">
+                <Border Name="TimelineEventRow" Height="38" Background="Transparent" PointerPressed="OnEventPointerPressed" ContextRequested="OnEventContextRequested">
+                  <Grid ColumnDefinitions="20,*,Auto" Margin="4,0,6,0">
+                    <TextBlock Text="◆" Foreground="DodgerBlue" IsVisible="{Binding IsSelected}" VerticalAlignment="Center"/>
+                    <TextBlock Grid.Column="1" Text="{Binding Label}" ToolTip.Tip="{Binding Label}" TextTrimming="CharacterEllipsis" VerticalAlignment="Center"/>
+
+                  </Grid>
+                </Border>
+              </DataTemplate></ItemsControl.ItemTemplate>
+            </ItemsControl>
+            <timeline:TimelineCanvas Grid.Column="2" Name="TimelineEventKeys" KeyContextRequested="OnEventKeyContextRequested" Model="{Binding Session.EventCanvas}" Height="{Binding Session.EventCanvas.ContentHeight}" VerticalAlignment="Top"/>
+          </Grid>
+        </ScrollViewer>
+        <GridSplitter Grid.Column="1" Grid.RowSpan="2" Width="3" MinWidth="0" HorizontalAlignment="Center" ResizeDirection="Columns"/>
+      </Grid>
     </Grid>
-    <StackPanel Grid.Row="6" Spacing="4">
-      <TextBlock Text="{loc:Localize Timeline.AnalysisIncomplete}" IsVisible="{Binding Session.AnalysisIncomplete}" TextWrapping="Wrap" Opacity="0.7"/>
-      <StackPanel Orientation="Horizontal" Spacing="6" IsVisible="{Binding Session.Canvas.HasPendingMove}">
-        <Button Content="{loc:Localize Timeline.ReplaceCollisions}" Command="{Binding ReplaceCollisionsCommand}"/>
-        <Button Content="{loc:Localize Timeline.CancelMove}" Command="{Binding CancelMoveCommand}"/>
+    <Grid Grid.Row="3" IsVisible="{Binding Session.CanEdit}"><Grid.ColumnDefinitions><ColumnDefinition Width="{Binding #Root.TreeColumnWidth,Mode=TwoWay}" MinWidth="180" MaxWidth="600"/><ColumnDefinition Width="5"/><ColumnDefinition Width="*"/></Grid.ColumnDefinitions>
+      <ScrollBar Grid.Column="2" Name="TimelineScroll" Orientation="Horizontal" Minimum="0" Maximum="{Binding Session.Duration}" SmallChange="1" LargeChange="10" Value="{Binding Session.Canvas.StartFrame,Mode=TwoWay}"/>
+    </Grid>
+    <Grid Grid.Row="4" ColumnDefinitions="Auto,*,Auto" Margin="0,2,0,0" IsVisible="{Binding Session.CanEdit}">
+      <StackPanel Orientation="Horizontal" Spacing="6">
+        <Button Content="{loc:Localize Uiux.Timeline.Fit}" Click="OnFitTimeline"/>
       </StackPanel>
-    </StackPanel>
-    <TextBlock Grid.Row="7" Text="{Binding Session.Message}" TextWrapping="Wrap" Foreground="{DynamicResource SystemControlErrorTextForegroundBrush}"/>
+      <StackPanel Grid.Column="2" Orientation="Horizontal" Spacing="12">
+        <TextBlock Name="TimelineCurrentFrame" Text="{Binding Session.CurrentFrameText}" VerticalAlignment="Center"/>
+        <Slider Name="TimelineZoom" Width="140" Minimum="0.001" Maximum="64" Value="{Binding Session.Canvas.PixelsPerFrame,Mode=TwoWay}" ToolTip.Tip="{loc:Localize Timeline.Zoom}" AutomationProperties.Name="{loc:Localize Timeline.Zoom}"/>
+      </StackPanel>
+    </Grid>
+    <TextBlock Grid.Row="5" Margin="0,4,0,0" Text="{Binding Session.Message}" IsVisible="{Binding !!Session.Message.Length}" TextWrapping="Wrap" Foreground="{DynamicResource SystemControlErrorTextForegroundBrush}"/>
   </Grid>
 </UserControl>
diff --git a/src/Editor/GalNet.Editor/Views/TimelinePanelView.axaml.cs b/src/Editor/GalNet.Editor/Views/TimelinePanelView.axaml.cs
index c34e7df0..f7128902 100644
--- a/src/Editor/GalNet.Editor/Views/TimelinePanelView.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/TimelinePanelView.axaml.cs
@@ -18,11 +18,6 @@ private void OnFitTimeline(object? sender, RoutedEventArgs args)
         vm.Session.Canvas.PixelsPerFrame = Math.Max(1, TimelineKeys.Bounds.Width - 20) / Math.Max(1, vm.Session.Duration);
         vm.Session.Canvas.StartFrame = 0;
     }
-    private void OnLocatePlayhead(object? sender, RoutedEventArgs args)
-    {
-        if (DataContext is ViewModels.TimelinePanelViewModel vm)
-            vm.Session.Canvas.StartFrame = Math.Max(0, vm.Session.Frame - TimelineKeys.Bounds.Width / vm.Session.Canvas.PixelsPerFrame / 2);
-    }
     private Flyout? _objectFlyout;
     private Flyout? _keyFlyout;
     public TimelinePanelView() { InitializeComponent(); AddHandler(KeyDownEvent, OnValueKeyDown, RoutingStrategies.Tunnel); }
@@ -120,10 +115,10 @@ MenuItem Item(string name, string label, Action action, bool selected = false)
             item.Click += (_, _) => { action(); menu.Hide(); }; return item;
         }
         var interpolation = new MenuItem { Header = text["Timeline.Curve.Interpolation"] };
-        foreach (var mode in Enum.GetValues<GalNet.Core.Scene.AnimationInterpolation>())
+        foreach (var mode in Enum.GetValues<GalNet.Contracts.Builtins.Scene.AnimationInterpolation>())
         {
             var captured = mode;
-            interpolation.Items.Add(Item("TimelineInterpolation" + mode, mode == GalNet.Core.Scene.AnimationInterpolation.CubicHermite ? "Timeline.Curve.Hermite" : "Timeline.Key." + mode,
+            interpolation.Items.Add(Item("TimelineInterpolation" + mode, mode == GalNet.Contracts.Builtins.Scene.AnimationInterpolation.CubicHermite ? "Timeline.Curve.Hermite" : "Timeline.Key." + mode,
                 () => { draft.InterpolationIndex = (int)captured; draft.CommitInterpolation(); }, draft.InterpolationIndex == (int)mode));
         }
         menu.Items.Add(interpolation);
@@ -160,5 +155,5 @@ MenuItem Item(string name, string label, Action action, bool selected = false)
         menu.Closed += (_, _) => { if (ReferenceEquals(Avalonia.Controls.Primitives.FlyoutBase.GetAttachedFlyout(anchor), menu)) Avalonia.Controls.Primitives.FlyoutBase.SetAttachedFlyout(anchor, null); };
         menu.ShowAt(anchor, true);
     }
-    protected override void OnDetachedFromVisualTree(Avalonia.VisualTreeAttachmentEventArgs e) { _objectFlyout?.Hide(); _keyFlyout?.Hide(); _eventFlyout?.Hide(); _eventInsertion = null; base.OnDetachedFromVisualTree(e); }
+    protected override void OnDetachedFromVisualTree(Avalonia.VisualTreeAttachmentEventArgs e) { _objectFlyout?.Hide(); _keyFlyout?.Hide(); _eventInsertion = null; base.OnDetachedFromVisualTree(e); }
 }
diff --git a/src/Editor/GalNet.Editor/Views/VariablesPanelView.axaml b/src/Editor/GalNet.Editor/Views/VariablesPanelView.axaml
index 85350814..83382dad 100644
--- a/src/Editor/GalNet.Editor/Views/VariablesPanelView.axaml
+++ b/src/Editor/GalNet.Editor/Views/VariablesPanelView.axaml
@@ -3,20 +3,42 @@
              xmlns:loc="clr-namespace:GalNet.Editor.MarkupExtensions"
              xmlns:globalization="clr-namespace:System.Globalization;assembly=System.Runtime"
              x:Class="GalNet.Editor.Views.VariablesPanelView" x:Name="Root" x:DataType="vm:VariablesPanelViewModel">
+  <UserControl.Resources><ResourceDictionary><ResourceDictionary.MergedDictionaries><ResourceInclude Source="avares://GalNet.Editor/Themes/AuthoringPanelResources.axaml"/></ResourceDictionary.MergedDictionaries></ResourceDictionary></UserControl.Resources>
   <Grid RowDefinitions="Auto,Auto,*,Auto" Margin="12" RowSpacing="8">
     <TabControl x:Name="ScopeTabs" Height="44" SelectedIndex="{Binding ScopeIndex}">
       <TabItem Header="{loc:Localize Variables.Player}" />
       <TabItem Header="{loc:Localize Variables.Save}" />
     </TabControl>
     <TextBlock Grid.Row="1" Text="{loc:Localize ScopeHintKey}" TextWrapping="Wrap" Opacity="0.75" />
-    <Grid Grid.Row="2" ColumnDefinitions="240,12,*">
-      <Grid RowDefinitions="*,Auto" RowSpacing="8">
-        <ListBox x:Name="VariableRows" ItemsSource="{Binding Rows}" SelectedItem="{Binding Selected}">
-          <ListBox.ItemTemplate><DataTemplate x:DataType="vm:VariableDefinitionRow"><StackPanel><TextBlock Text="{Binding Name}"/><TextBlock Text="{Binding Description}" Opacity="0.65" TextWrapping="Wrap"/></StackPanel></DataTemplate></ListBox.ItemTemplate>
-        </ListBox>
-        <Button x:Name="AddVariableButton" Grid.Row="1" Content="{loc:Localize Variables.Add}" Command="{Binding AddVariableCommand}" />
+    <Grid x:Name="VariableColumns" Grid.Row="2" ColumnDefinitions="220,10,*">
+      <Grid RowDefinitions="Auto,*" RowSpacing="6">
+        <Grid ColumnDefinitions="*,Auto" ColumnSpacing="4">
+          <TextBox Text="{Binding Search}" PlaceholderText="{loc:Localize Uiux.Panel.Search}" MinWidth="0"/>
+          <Button x:Name="AddVariableButton" Grid.Column="1" Theme="{StaticResource EditorIconButton}" Command="{Binding AddVariableCommand}" ToolTip.Tip="{loc:Localize Variables.Add}" AutomationProperties.Name="{loc:Localize Variables.Add}" Click="OnVariableAdded"><PathIcon Width="16" Height="16" Data="{StaticResource AddIcon}"/></Button>
+        </Grid>
+        <Grid Grid.Row="1">
+          <ListBox x:Name="VariableRows" ItemsSource="{Binding Rows}" SelectedItem="{Binding Selected}">
+            <ListBox.Styles><Style Selector="ListBoxItem"><Setter Property="HorizontalContentAlignment" Value="Stretch"/></Style></ListBox.Styles>
+            <ListBox.ItemTemplate><DataTemplate x:DataType="vm:VariableDefinitionRow"><Grid ColumnDefinitions="*,Auto" RowDefinitions="Auto,Auto" ColumnSpacing="6"><TextBlock Text="{Binding Name}" TextTrimming="CharacterEllipsis" ToolTip.Tip="{Binding Name}"/><TextBlock Grid.Column="1" Text="{Binding Type}" FontSize="11" Foreground="{DynamicResource SemiColorText2}"/><TextBlock Grid.Row="1" Grid.ColumnSpan="2" Text="{Binding Description}" Foreground="{DynamicResource SemiColorText2}" TextTrimming="CharacterEllipsis" ToolTip.Tip="{Binding Description}"/></Grid></DataTemplate></ListBox.ItemTemplate>
+          </ListBox>
+          <TextBlock Text="{loc:Localize Uiux.Panel.NoResults}" IsVisible="{Binding !HasRows}" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="8" TextWrapping="Wrap" Foreground="{DynamicResource SemiColorText2}"/>
+        </Grid>
       </Grid>
-      <ScrollViewer Grid.Column="2" HorizontalScrollBarVisibility="Disabled">
+      <GridSplitter Grid.Column="1" ResizeDirection="Columns" HorizontalAlignment="Stretch" Background="Transparent"/>
+      <Grid Grid.Column="2" RowDefinitions="Auto,*">
+      <StackPanel Grid.RowSpan="2" IsVisible="{Binding !HasSelection}" VerticalAlignment="Center" Margin="8" Spacing="8">
+        <TextBlock Text="{loc:Localize Uiux.Panel.SelectItem}" TextWrapping="Wrap" Foreground="{DynamicResource SemiColorText2}"/>
+        <TextBlock Text="{loc:Localize Uiux.Panel.MissingSelection}" IsVisible="{Binding MissingSelection}" TextWrapping="Wrap"/>
+        <Button Content="{loc:Localize Variables.Revert}" Command="{Binding RevertCommand}" IsVisible="{Binding MissingSelection}"/>
+      </StackPanel>
+          <StackPanel Orientation="Horizontal" Spacing="4" IsVisible="{Binding HasSelection}" Margin="0,0,0,6">
+            <Button x:Name="ApplyVariableButton" Theme="{StaticResource EditorIconButton}" Command="{Binding ApplyCommand}" ToolTip.Tip="{loc:Localize Variables.Apply}" AutomationProperties.Name="{loc:Localize Variables.Apply}"><PathIcon Width="16" Height="16" Data="{StaticResource PanelApplyIcon}"/></Button>
+            <Button Theme="{StaticResource EditorIconButton}" Command="{Binding RevertCommand}" ToolTip.Tip="{loc:Localize Variables.Revert}" AutomationProperties.Name="{loc:Localize Variables.Revert}"><PathIcon Width="16" Height="16" Data="{StaticResource ResetIcon}"/></Button>
+            <Button x:Name="DeleteVariableButton" Theme="{StaticResource EditorIconButton}" Command="{Binding DeleteVariableCommand}" ToolTip.Tip="{loc:Localize Variables.Delete}" AutomationProperties.Name="{loc:Localize Variables.Delete}"><PathIcon Width="16" Height="16" Data="{StaticResource DeleteRegularIcon}"/></Button>
+            <Button Theme="{StaticResource EditorIconButton}" Command="{Binding CheckReferencesCommand}" ToolTip.Tip="{loc:Localize Variables.References}" AutomationProperties.Name="{loc:Localize Variables.References}"><PathIcon Width="16" Height="16" Data="{StaticResource PanelNavigateIcon}"/></Button>
+            <TextBlock Text="{loc:Localize Uiux.Panel.Unapplied}" IsVisible="{Binding HasChanges}" VerticalAlignment="Center" Foreground="{DynamicResource SemiColorText2}" TextWrapping="Wrap"/>
+          </StackPanel>
+      <ScrollViewer Grid.Row="1" HorizontalScrollBarVisibility="Disabled" IsVisible="{Binding HasSelection}">
         <StackPanel Spacing="8" IsEnabled="{Binding HasSelection}">
           <TextBlock Text="{loc:Localize Variables.Name}"/><TextBox x:Name="NameInput" Text="{Binding DraftName}" />
           <TextBlock Text="{loc:Localize Variables.Type}"/>
@@ -25,9 +47,9 @@
           </ComboBox>
           <TextBlock Text="{loc:Localize Variables.Default}"/>
           <Grid>
-            <TextBox x:Name="DefaultInput" IsVisible="{Binding IsTextDefault}" Text="{Binding DraftDefault}" />
+            <TextBox x:Name="DefaultInput" IsVisible="{Binding IsTextDefault}" Text="{Binding StringDefaultText}" />
             <NumericUpDown x:Name="NumericDefaultInput" IsVisible="{Binding IsNumericDefault}"
-                           Text="{Binding DraftDefault, Mode=TwoWay}" Increment="{Binding DefaultIncrement}"
+                           Text="{Binding NumericDefaultText, Mode=TwoWay}" Increment="{Binding DefaultIncrement}"
                            NumberFormat="{x:Static globalization:NumberFormatInfo.InvariantInfo}" ParsingNumberStyle="Float"
                            AutomationProperties.Name="{loc:Localize Variables.Default}" />
             <CheckBox x:Name="BooleanDefaultInput" IsVisible="{Binding IsBooleanDefault}"
@@ -35,16 +57,12 @@
           </Grid>
           <TextBlock Text="{loc:Localize DefaultHintKey}" Opacity="0.65" TextWrapping="Wrap"/>
           <TextBlock Text="{loc:Localize Variables.Description}"/><TextBox x:Name="DescriptionInput" Text="{Binding DraftDescription}" AcceptsReturn="True" TextWrapping="Wrap" MinHeight="70"/>
-          <WrapPanel>
-            <Button x:Name="ApplyVariableButton" Content="{loc:Localize Variables.Apply}" Command="{Binding ApplyCommand}" Margin="0,0,8,0"/>
-            <Button Content="{loc:Localize Variables.Revert}" Command="{Binding RevertCommand}" Margin="0,0,8,0"/>
-            <Button x:Name="DeleteVariableButton" Content="{loc:Localize Variables.Delete}" Command="{Binding DeleteVariableCommand}"/>
-          </WrapPanel>
-          <Button Content="{loc:Localize Variables.References}" Command="{Binding CheckReferencesCommand}"/>
+
           <TextBlock Text="{loc:Localize Variables.ReferenceHint}" TextWrapping="Wrap" Opacity="0.65"/>
           <ItemsControl ItemsSource="{Binding References}"><ItemsControl.ItemTemplate><DataTemplate x:DataType="services:VariableReference"><StackPanel Margin="0,4"><Button Background="Transparent" Command="{Binding #Root.DataContext.NavigateReferenceCommand}" CommandParameter="{Binding}" HorizontalContentAlignment="Left"><TextBlock Text="{Binding Location}" TextWrapping="Wrap"/></Button><TextBlock Text="{loc:Localize Variables.Certain}" IsVisible="{Binding Certain}"/><TextBlock Text="{loc:Localize Variables.Possible}" IsVisible="{Binding !Certain}" Opacity="0.65"/></StackPanel></DataTemplate></ItemsControl.ItemTemplate></ItemsControl>
         </StackPanel>
       </ScrollViewer>
+      </Grid>
     </Grid>
     <TextBlock Grid.Row="3" Text="{Binding MessageText}" TextWrapping="Wrap" Foreground="{DynamicResource SystemControlErrorTextForegroundBrush}"/>
   </Grid>
diff --git a/src/Editor/GalNet.Editor/Views/VariablesPanelView.axaml.cs b/src/Editor/GalNet.Editor/Views/VariablesPanelView.axaml.cs
index 3c2a8fcc..13347742 100644
--- a/src/Editor/GalNet.Editor/Views/VariablesPanelView.axaml.cs
+++ b/src/Editor/GalNet.Editor/Views/VariablesPanelView.axaml.cs
@@ -1,8 +1,31 @@
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Threading;
+using GalNet.Editor.ViewModels;
 
 namespace GalNet.Editor.Views;
 
 public partial class VariablesPanelView : UserControl
 {
-    public VariablesPanelView() => InitializeComponent();
+    private bool? _narrow;
+    public VariablesPanelView()
+    {
+        InitializeComponent();
+        SizeChanged += (_, _) =>
+        {
+            var narrow = Bounds.Width < 560;
+            if (_narrow == narrow) return;
+            _narrow = narrow;
+            VariableColumns.ColumnDefinitions = new(narrow ? "*" : "220,10,*");
+            VariableColumns.RowDefinitions = new(narrow ? "160,8,*" : "*");
+            for (var i = 0; i < VariableColumns.Children.Count; i++)
+            { Grid.SetColumn(VariableColumns.Children[i], narrow ? 0 : i); Grid.SetRow(VariableColumns.Children[i], narrow ? i : 0); }
+            if (VariableColumns.Children[1] is GridSplitter splitter) splitter.ResizeDirection = narrow ? GridResizeDirection.Rows : GridResizeDirection.Columns;
+        };
+    }
+    private void OnVariableAdded(object? sender, RoutedEventArgs e) => Dispatcher.UIThread.Post(() =>
+    {
+        if (DataContext is not VariablesPanelViewModel { Selected: { } selected }) return;
+        VariableRows.ScrollIntoView(selected); NameInput.Focus(); NameInput.SelectAll();
+    });
 }
diff --git a/src/Editor/GalNet.Editor/packages.lock.WindowsReadyToRun.json b/src/Editor/GalNet.Editor/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..c22560bf
--- /dev/null
+++ b/src/Editor/GalNet.Editor/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,672 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
+        "dependencies": {
+          "Avalonia.BuildServices": "11.3.2",
+          "Avalonia.Remote.Protocol": "12.0.5",
+          "MicroCom.Runtime": "0.11.4"
+        }
+      },
+      "Avalonia.Controls.ColorPicker": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "EmYXjNZq5wevvvvbLTNvnDBnZfQ6YuFBPOwDc6IXMFFIFLY4WAfpi3Dr94/qmt55shDcMceogaUiNy0yyLf5NQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Remote.Protocol": "12.0.5"
+        }
+      },
+      "Avalonia.Desktop": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "L4bTMshYrhjSKu09Q60OHN1+Lfr9z7JsyRL6rfj3iQfjWm+5gsTl2viz5gyzDUgc/U5A7gf57e1spEX+nE/7zg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.HarfBuzz": "12.0.5",
+          "Avalonia.Native": "12.0.5",
+          "Avalonia.Skia": "12.0.5",
+          "Avalonia.Win32": "12.0.5",
+          "Avalonia.X11": "12.0.5"
+        }
+      },
+      "Avalonia.Fonts.Inter": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Themes.Fluent": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "AvaloniaUI.DiagnosticsSupport": {
+        "type": "Direct",
+        "requested": "[2.2.3, )",
+        "resolved": "2.2.3",
+        "contentHash": "kQCInYusi2c9tjd9hV05Lln6Csbo07kiC672M3G7dsalDBe2j+pOk3We2nzdyy5ptQYy/9gQiC8ZaHhb6u/5Kw==",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
+          "Microsoft.IO.RecyclableMemoryStream": "3.0.1"
+        }
+      },
+      "CommunityToolkit.Mvvm": {
+        "type": "Direct",
+        "requested": "[8.4.1, )",
+        "resolved": "8.4.1",
+        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
+      },
+      "Dock.Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.0.2, )",
+        "resolved": "12.0.0.2",
+        "contentHash": "ET8Fr9bUi81ifs7LOWcD99jLOZChdp3yCjebja4qnFguy0KURMFPuBj0RXnd76SZRp5LFjBXaXb348KtZLPemQ==",
+        "dependencies": {
+          "Avalonia": "12.0.0",
+          "Dock.Controls.DeferredContentControl": "12.0.0.2",
+          "Dock.Controls.ProportionalStackPanel": "12.0.0.2",
+          "Dock.Controls.Recycling": "12.0.0.2",
+          "Dock.MarkupExtension": "12.0.0.2",
+          "Dock.Model": "12.0.0.2",
+          "Dock.Settings": "12.0.0.2"
+        }
+      },
+      "Dock.Avalonia.Themes.Fluent": {
+        "type": "Direct",
+        "requested": "[12.0.0.2, )",
+        "resolved": "12.0.0.2",
+        "contentHash": "DhCyhsM7eMfWmmNUknlDwFVD4JN0+A/GwtDGtWhfPF8VraC1lYaXY7QfUPtjRrLOu2DlP8AlNaMXlHvZzi74bQ==",
+        "dependencies": {
+          "Avalonia": "12.0.0",
+          "Dock.Avalonia": "12.0.0.2"
+        }
+      },
+      "Dock.Model": {
+        "type": "Direct",
+        "requested": "[12.0.0.2, )",
+        "resolved": "12.0.0.2",
+        "contentHash": "yLD28SMkaGMVdv/kVkO1t+GkBbFWRPKlNoXh+KZ/lPjwCJKg8vm0xmdqdgszMZGbpcWPT7T2LZk/JuwECndftA==",
+        "dependencies": {
+          "Dock.Controls.Recycling.Model": "12.0.0.2"
+        }
+      },
+      "Dock.Model.Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.0.2, )",
+        "resolved": "12.0.0.2",
+        "contentHash": "UpEGrHAKzVBG8sirc+f0oRNZ0clKNNCeGdIlhczL8HHJ2NcuUm9V/kfiMEn2u/1oT2HH1VO10bZi0GemCJ1Y2g==",
+        "dependencies": {
+          "Avalonia": "12.0.0",
+          "Dock.Avalonia": "12.0.0.2",
+          "Dock.Model": "12.0.0.2",
+          "Dock.Settings": "12.0.0.2"
+        }
+      },
+      "Dock.Model.Mvvm": {
+        "type": "Direct",
+        "requested": "[12.0.0.2, )",
+        "resolved": "12.0.0.2",
+        "contentHash": "+lK3PWXjSUiyWB8a++/9y1MwPFCs67zsNANNX9JKB9ZxpoeRzmamGAH5AYam31dLhluW2dul8r7FACGXyJsyYw==",
+        "dependencies": {
+          "CommunityToolkit.Mvvm": "8.4.0",
+          "Dock.Model": "12.0.0.2"
+        }
+      },
+      "Dock.Settings": {
+        "type": "Direct",
+        "requested": "[12.0.0.2, )",
+        "resolved": "12.0.0.2",
+        "contentHash": "t/e37uzDSzwQ3hvbluhZJ9dOIe2ZVpROdiJYTw0A6E8zeVoN1wlDjHJGm1wIAgUpJLkjqF+MEbd/rmUm5vAmmg==",
+        "dependencies": {
+          "Avalonia": "12.0.0",
+          "Dock.Model": "12.0.0.2"
+        }
+      },
+      "DynamicLocalization.Core": {
+        "type": "Direct",
+        "requested": "[2.1.2, )",
+        "resolved": "2.1.2",
+        "contentHash": "UdDvJeBnNoif/bi73CBDi7GiOhGUB9EkKl3v0JTNdVcPhCqWY+Jy9qr4IqNS9bQ5Xwn6uTYimYLDqGNxEEDjqw==",
+        "dependencies": {
+          "System.Text.Json": "[6.0.10, 10.0.0)",
+          "YamlDotNet": "[11.0.1, 19.0.0)"
+        }
+      },
+      "Irihi.Ursa": {
+        "type": "Direct",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "G2wAmenCgMZkBOqs5MYRtlurhU2tAKKmcNJzjjaA9Mj5v3YIivuv7wyNpIpgYZ602sOZhFtQwYrCaLVUhn9Htw==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Avalonia.Shared": "0.4.0",
+          "Irihi.Avalonia.Shared.Contracts": "0.4.0"
+        }
+      },
+      "Irihi.Ursa.Themes.Semi": {
+        "type": "Direct",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "vz7iA6YcAqJ9Z34CXGtapsROERLjZ7vD1CqblO7V5NWQyrJ5igbAYSuFFWnZnPVFKkyKM/c43oGmcWjiDBLoHA==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Ursa": "2.1.0",
+          "Semi.Avalonia": "12.0.1"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "Direct",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "f0RBabswJq+gRu5a+hWIobrLWiUYPKMhCD9WO3sYBAdSy3FFH14LMvLVFZc2kPSCimBLxSuitUhsd6tb0TAY6A==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Direct",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      },
+      "Semi.Avalonia.ColorPicker": {
+        "type": "Direct",
+        "requested": "[12.0.3, )",
+        "resolved": "12.0.3",
+        "contentHash": "utax9usoViLNTUwSSLb+UkdnpvDbyG1MWrGobL/pKORmumfYJqUoEX4OP9TUWzxn+VINwAa1EvGXImKK3T3vSQ==",
+        "dependencies": {
+          "Avalonia.Controls.ColorPicker": "12.0.3",
+          "Irihi.Avalonia.Shared": "0.4.0"
+        }
+      },
+      "Semi.Avalonia.Dock": {
+        "type": "Direct",
+        "requested": "[12.0.0.2, )",
+        "resolved": "12.0.0.2",
+        "contentHash": "0GeLQBHzaeqdcBT6BX9b1YKQa77u0n+Xlqs3+an+aeuseekj6Aqdkwvp9VKeN43NVXcU16id33uBG6b2f97avg==",
+        "dependencies": {
+          "Dock.Avalonia": "12.0.0.2",
+          "Irihi.Avalonia.Shared": "0.4.0"
+        }
+      },
+      "Serilog": {
+        "type": "Direct",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      },
+      "Serilog.Sinks.Console": {
+        "type": "Direct",
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "fQGWqVMClCP2yEyTXPIinSr5c+CBGUvBybPxjAGcf7ctDhadFhrQw03Mv8rJ07/wR5PDfFjewf2LimvXCDzpbA==",
+        "dependencies": {
+          "Serilog": "4.0.0"
+        }
+      },
+      "Serilog.Sinks.Debug": {
+        "type": "Direct",
+        "requested": "[3.0.0, )",
+        "resolved": "3.0.0",
+        "contentHash": "4BzXcdrgRX7wde9PmHuYd9U6YqycCC28hhpKonK7hx0wb19eiuRj16fPcPSVp0o/Y1ipJuNLYQ00R3q2Zs8FDA==",
+        "dependencies": {
+          "Serilog": "4.0.0"
+        }
+      },
+      "VideoLAN.LibVLC.Windows": {
+        "type": "Direct",
+        "requested": "[3.0.23.1, )",
+        "resolved": "3.0.23.1",
+        "contentHash": "yTGNrzj+Q/t72VNKK0d64jZ+8BGu5Vcp2nxpZ2ll350LkRWKSwqShGpZWcVxXVP8TiMbeGML09+Jzz3hNsIcqA=="
+      },
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "Avalonia.Angle.Windows.Natives": {
+        "type": "Transitive",
+        "resolved": "2.1.27548.20260419",
+        "contentHash": "l17nI3XVDN3oMnpjf2pnmJg0YTwK4m6NLsn/itAjDMdObTFxN77D5F1M9sRMSfViSY3KKcse1ROczwgoWLJsnA=="
+      },
+      "Avalonia.BuildServices": {
+        "type": "Transitive",
+        "resolved": "11.3.2",
+        "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
+      },
+      "Avalonia.FreeDesktop": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "51IiLrfyJdMtmVTiXiEi1q1nXS5KAMYvFNeovlwKSuTgY/agBevnfBTY+DnKnIjZMdXWWKVGJJh7MldMkPc14w==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Tmds.DBus.Protocol": "0.92.0"
+        }
+      },
+      "Avalonia.FreeDesktop.AtSpi": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "IrsjB1QpzXwgdnkpG6ejGxSaHp0sRrq3rZlrzRyhwEGllAxcOeUuQpq8/OrO3OUJLxXtxlsM4ku17v+7q7xGKQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.HarfBuzz": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "jR8i/fgrmAKEp0T3iLqfKCoEDJV9ODVzN+8bofM2guEr05eaXbx6iXZxcjh0nDK4UbK0akYDgBfAgyHoatqGjg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3"
+        }
+      },
+      "Avalonia.Native": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "m6qn0UGMI/b4cFfJ8id8sPYLotc7szhZdexPCKY+kIvGlx6Ln0VjNejRMiJDZ4S91q6nbKJL/YmfPd8UruTNjQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Remote.Protocol": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
+      },
+      "Avalonia.Win32": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "ZY1ZLXQdQqlz9GUZGXK+73kTFgKzygPbGk/gHfROUWLr2aBh1kOA1KY5xB7/cSSY+egDr+IGSjsQbgS8eSu9Tg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Angle.Windows.Natives": "2.1.27548.20260419"
+        }
+      },
+      "Avalonia.X11": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "6OyZa5ehNbzd7JWiVbGdjuzdsgy2Rgibtwczmh7hKnePxLmOqeSL+hQ6vHanSx246TpSBKDPvjqwW7NuQrmAJg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.FreeDesktop": "12.0.5",
+          "Avalonia.FreeDesktop.AtSpi": "12.0.5",
+          "Avalonia.Skia": "12.0.5"
+        }
+      },
+      "Dock.Controls.DeferredContentControl": {
+        "type": "Transitive",
+        "resolved": "12.0.0.2",
+        "contentHash": "CV7jl3rIQ5kO2wZ7fe3VPH+kW6m1vU4nqegp4gnxSdZMjTW4OPOwWh/p5tNKAi/7blTqxmpPOH2xWSgtxrLCJg==",
+        "dependencies": {
+          "Avalonia": "12.0.0"
+        }
+      },
+      "Dock.Controls.ProportionalStackPanel": {
+        "type": "Transitive",
+        "resolved": "12.0.0.2",
+        "contentHash": "5vcR2J92LKdjK3DlRFicWZnoz96JK+34GHJi7Y6ZokoSE+tojHyzW0cNEC5v8Q/iYwRH78Aj0+8nKrPuarqL7A==",
+        "dependencies": {
+          "Avalonia": "12.0.0"
+        }
+      },
+      "Dock.Controls.Recycling": {
+        "type": "Transitive",
+        "resolved": "12.0.0.2",
+        "contentHash": "nEo0p/CtWjzM0Ayt1wtw4w11oheyd/2epJXw+WzwW8xMJvk2r7LFEexbgFXhYodvylQUtxQHCh41mLXURC9aCQ==",
+        "dependencies": {
+          "Avalonia": "12.0.0",
+          "Dock.Controls.Recycling.Model": "12.0.0.2"
+        }
+      },
+      "Dock.Controls.Recycling.Model": {
+        "type": "Transitive",
+        "resolved": "12.0.0.2",
+        "contentHash": "klVsAStNW7SyvIvV6060o3Rx0Rgzo2Dus3MPJD7Td87FJyK0X7djki8m/EOtD6qi3RyZaRZTLOEjskNk12Q/3Q=="
+      },
+      "Dock.MarkupExtension": {
+        "type": "Transitive",
+        "resolved": "12.0.0.2",
+        "contentHash": "EAxNAllVDuyP3Oj2i8s3+nsFYWvhMbTqBlkd5dGSNMd75bgM/uLmGSOOpXTZuUWFiWn1vDRWragvPcUmj6EJwQ==",
+        "dependencies": {
+          "Avalonia": "12.0.0"
+        }
+      },
+      "HarfBuzzSharp": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "NGZ2+ZVNPM+NdHB/asW0/ykWngyHWwcqjrbN2nDeH1B/aptPGlCUl8wkQ2cSJxw5fdWgdmIPmNuTPWpLwNVXWg==",
+        "dependencies": {
+          "HarfBuzzSharp.NativeAssets.Win32": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.macOS": "8.3.1.3"
+        }
+      },
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "w2QfdNm9Uz/sUa0B5D+OnVQhyq3G/fBq6ibQMdWBlQqqwh0g0/5j3RFvYqZAmRZ5+RzvjVe8o8SFFnWYUSkuxA=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "Irihi.Avalonia.Shared": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "T6+jezCUjisJNz6zkNcNLVNI2ttWznbyQnW6MS9L45EXhePqRCIxB3xV/5L8gFAJ83JrhiCIokMOxRWdq9/1Zg==",
+        "dependencies": {
+          "Avalonia": "12.0.0"
+        }
+      },
+      "Irihi.Avalonia.Shared.Contracts": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "Du8DY2YqlSmCmywqZtuOhgwLkgklMeE1ajZ4Dd/iqVz6HmAKptjVTqA1oloZX5ihqsdKRiNuUGCdYPe1rekf2Q=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.IO.RecyclableMemoryStream": {
+        "type": "Transitive",
+        "resolved": "3.0.1",
+        "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g=="
+      },
+      "SkiaSharp": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "53NOSUZ1Us+91Sm0uCkIivh/k7jOowRErZT2sIWwPFN9mLUvdxnE6rS4sWo4255+Rd2MWUSF+j0NMZHD6Cke+Q==",
+        "dependencies": {
+          "SkiaSharp.NativeAssets.Win32": "3.119.4",
+          "SkiaSharp.NativeAssets.macOS": "3.119.4"
+        }
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "S1HOxtBbD4bYDtA2e9WH5TX+lxqRrTPvKjrjttRhxnHNNu7YY8VFo/LeCP7tNqoTA6PV+8vsvNbmRUEC2ip8RQ=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      },
+      "System.Text.Json": {
+        "type": "Transitive",
+        "resolved": "6.0.10",
+        "contentHash": "NSB0kDipxn2ychp88NXWfFRFlmi1bst/xynOutbnpEfRCT9JZkZ7KOmF/I/hNKo2dILiMGnqblm+j1sggdLB9g=="
+      },
+      "Tmds.DBus.Protocol": {
+        "type": "Transitive",
+        "resolved": "0.92.0",
+        "contentHash": "h7IMakm0PF2jxiagoysoAjrzzLQ0UBdnSXQL5kb17YW0Fvyo12Tg96A99QkzwktWRrd7H+Uw9EzjasNLUfGYlA=="
+      },
+      "YamlDotNet": {
+        "type": "Transitive",
+        "resolved": "11.0.1",
+        "contentHash": "UvICfSN4gJfAmOsuY/go0hb5SFfr3ZYCXb7jg66yT7kh+wSJEt7tUiwuoCNMpt8ScEXLDwXttpFoWKWeirYU1A=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.controls": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.gameview": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "CommunityToolkit.Mvvm": "[8.4.1, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "Irihi.Ursa": "[2.1.0, )",
+          "LibVLCSharp": "[3.10.0, )",
+          "LibVLCSharp.Avalonia": "[3.10.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.avalonia.rendering": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.debugging": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.editor.abstraction": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )"
+        }
+      },
+      "galnet.editor.shared": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Debugging": "[1.0.0, )",
+          "GalNet.Editor.Abstraction": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.media.libvlc": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "LibVLCSharp": "[3.10.0, )"
+        }
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.storage.filesystem": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "Avalonia.Skia": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "cSLTpvzsm5JpUA1tQvuht3qN6oiy1PNRgbrp1g7jCSzAFf+OKZecSne+KT1apBQUkevciaHxwtAxLolPGD9izg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3",
+          "SkiaSharp": "3.119.4",
+          "SkiaSharp.NativeAssets.Linux": "3.119.4",
+          "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "LibVLCSharp": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
+      },
+      "LibVLCSharp.Avalonia": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "juoBLjh37+07kWDblbHLaWTQx1HsXOIJHU7aeH5/95xjN6dXfZMVE8ltg8NyaNL6vr2B4QgR3EiRBsEa+fPvlQ==",
+        "dependencies": {
+          "Avalonia": "11.3.13",
+          "LibVLCSharp": "3.10.0"
+        }
+      },
+      "Semi.Avalonia": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.1, )",
+        "resolved": "12.0.1",
+        "contentHash": "WAjB/Clu8eD+AjLbCUV/fNwHdCk5iSwLoFyWG7UeBBbr8zP7GWQHDqr4EcDgY9vbTpynYFoOql72FCHxOPHjPA==",
+        "dependencies": {
+          "Avalonia": "12.0.1",
+          "Irihi.Avalonia.Shared": "0.4.0"
+        }
+      }
+    },
+    "net10.0/win-x64": {
+      "Avalonia.Angle.Windows.Natives": {
+        "type": "Transitive",
+        "resolved": "2.1.27548.20260419",
+        "contentHash": "l17nI3XVDN3oMnpjf2pnmJg0YTwK4m6NLsn/itAjDMdObTFxN77D5F1M9sRMSfViSY3KKcse1ROczwgoWLJsnA=="
+      },
+      "Avalonia.Native": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "m6qn0UGMI/b4cFfJ8id8sPYLotc7szhZdexPCKY+kIvGlx6Ln0VjNejRMiJDZ4S91q6nbKJL/YmfPd8UruTNjQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/Editor/GalNet.Editor/packages.lock.json b/src/Editor/GalNet.Editor/packages.lock.json
index 4a8d6f3f..bbeaeefc 100644
--- a/src/Editor/GalNet.Editor/packages.lock.json
+++ b/src/Editor/GalNet.Editor/packages.lock.json
@@ -455,6 +455,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -462,6 +463,7 @@
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -473,6 +475,7 @@
           "GalNet.Assets": "[1.0.0, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Irihi.Ursa": "[2.1.0, )",
@@ -487,17 +490,10 @@
         "dependencies": {
           "Avalonia": "[12.0.5, )",
           "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
-      "galnet.avalonia.themes": {
-        "type": "Project",
-        "dependencies": {
-          "Avalonia.Themes.Fluent": "[12.0.5, )",
-          "GalNet.Avalonia.Controls": "[1.0.0, )",
-          "GalNet.Avalonia.GameView": "[1.0.0, )"
-        }
-      },
       "galnet.contracts.builtins": {
         "type": "Project",
         "dependencies": {
@@ -535,6 +531,7 @@
       "galnet.gamehost": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
@@ -544,24 +541,17 @@
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "LibVLCSharp": "[3.10.0, )"
         }
       },
       "galnet.presentation.abstractions": {
-        "type": "Project",
-        "dependencies": {
-          "GalNet.Core": "[1.0.0, )"
-        }
-      },
-      "galnet.primitives.builtins": {
         "type": "Project",
         "dependencies": {
           "GalNet.Contracts.Builtins": "[1.0.0, )",
-          "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
-          "GalNet.Runtime": "[1.0.0, )"
+          "GalNet.Core": "[1.0.0, )"
         }
       },
       "galnet.runtime": {
@@ -569,7 +559,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
@@ -577,6 +566,7 @@
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
diff --git a/src/Infrastructure/GalNet.Media.Audio/AudioPorts.cs b/src/Infrastructure/GalNet.Media.Audio/AudioPorts.cs
new file mode 100644
index 00000000..ff9867bb
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Audio/AudioPorts.cs
@@ -0,0 +1,30 @@
+namespace GalNet.Media.Audio;
+
+public delegate void AudioRenderCallback(Span<float> output);
+
+/// <summary>Platform output pulls interleaved float32 stereo at 48 kHz.</summary>
+public interface IAudioOutput : IDisposable
+{
+    void Start(AudioRenderCallback render);
+}
+
+/// <summary>Optional device lifecycle, called outside the render callback. Suspend waits for rendering to stop; resume retains the render callback.</summary>
+public interface IAudioOutputLifecycle
+{
+    void SuspendOutput();
+    void ResumeOutput();
+}
+
+/// <summary>Blocking decoder. Called only by the source's background producer.</summary>
+public interface IAudioPcmDecoder : IDisposable
+{
+    double DurationSeconds { get; }
+    int Read(Span<float> samples);
+}
+
+public interface IAudioPcmSource
+{
+    double DurationSeconds { get; }
+    bool IsFinished { get; }
+    int Read(Span<float> samples);
+}
diff --git a/src/Infrastructure/GalNet.Media.Audio/GalNet.Media.Audio.csproj b/src/Infrastructure/GalNet.Media.Audio/GalNet.Media.Audio.csproj
new file mode 100644
index 00000000..21796baf
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Audio/GalNet.Media.Audio.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup><TargetFramework>net10.0</TargetFramework></PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" />
+    <ProjectReference Include="../../Shared/GalNet.Core/GalNet.Core.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/Infrastructure/GalNet.Media.Audio/PcmAudioPlaybackHost.cs b/src/Infrastructure/GalNet.Media.Audio/PcmAudioPlaybackHost.cs
new file mode 100644
index 00000000..06425303
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Audio/PcmAudioPlaybackHost.cs
@@ -0,0 +1,229 @@
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Assets;
+
+namespace GalNet.Media.Audio;
+
+/// <summary>Owns streaming sources and terminal delivery, independently of UI and device APIs.</summary>
+public class PcmAudioPlaybackHost : IAudioPlaybackHost, IAsyncDisposable
+{
+    private readonly object _gate = new();
+    private readonly IAssetFileMaterializer _files;
+    private readonly Func<string, IAudioPcmDecoder> _decode;
+    private readonly IAudioOutput _output;
+    private readonly PcmMixer _mixer = new();
+    private readonly CancellationTokenSource _shutdown = new();
+    private readonly Dictionary<string, Playback> _playbacks = new(StringComparer.Ordinal);
+    private readonly List<Task> _loads = [];
+    private readonly System.Collections.Concurrent.ConcurrentQueue<Exception> _cleanupErrors = new();
+    private readonly Dictionary<string, (long Generation, CancellationTokenSource Cancel)> _pending = new(StringComparer.Ordinal);
+    private readonly Task _terminalWorker;
+    private Task? _dispose;
+    private bool _disposed;
+    private Exception? _renderError;
+    private bool _outputSuspended;
+    public AudioBackendCapabilities Capabilities { get; }
+    public ISEffectCatalog SEffects => SEffectCatalog.Builtins;
+    public string? InitializationError { get; }
+    public event Action<AudioBackendEvent>? EventReceived;
+    public bool SupportsOutputSuspension => _output is IAudioOutputLifecycle;
+
+    /// <summary>Stops device pulls without changing story pauses, voice positions or DSP state.</summary>
+    public void SuspendOutput()
+    {
+        lock (_gate)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            if (InitializationError is not null) throw new InvalidOperationException(InitializationError);
+            if (_output is not IAudioOutputLifecycle lifecycle) throw new NotSupportedException("This audio output does not support suspension.");
+            if (_outputSuspended) return;
+            lifecycle.SuspendOutput();
+            _outputSuspended = true;
+        }
+    }
+
+    public void ResumeOutput()
+    {
+        lock (_gate)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            if (InitializationError is not null) throw new InvalidOperationException(InitializationError);
+            if (_output is not IAudioOutputLifecycle lifecycle) throw new NotSupportedException("This audio output does not support suspension.");
+            if (!_outputSuspended) return;
+            lifecycle.ResumeOutput();
+            _outputSuspended = false;
+        }
+    }
+
+    public PcmAudioPlaybackHost(IAssetFileMaterializer files, Func<string, IAudioPcmDecoder> decode, IAudioOutput output)
+    {
+        _files = files; _decode = decode; _output = output;
+        Capabilities = new(true, true, true, true); // DSP contracts remain valid without a physical device.
+        try { output.Start(Render); }
+        catch (Exception error) { InitializationError = error.Message; output.Dispose(); }
+        _terminalWorker = Task.Run(TerminalsAsync);
+    }
+    public Task ApplyAsync(AudioBackendRequest request, CancellationToken cancellationToken = default)
+    {
+        lock (_gate)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            cancellationToken.ThrowIfCancellationRequested();
+            if (request.Action == AudioBackendAction.Start)
+            {
+                if (_pending.TryGetValue(request.VoiceId, out var old)) old.Cancel.Cancel();
+                var pending = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdown.Token);
+                _pending[request.VoiceId] = (request.Generation, pending);
+                var load = Task.Run(() => StartAsync(request, pending), CancellationToken.None);
+                _loads.RemoveAll(task => task.IsCompleted); _loads.Add(load); return load;
+            }
+            switch (request.Action)
+            {
+                case AudioBackendAction.Configure: _mixer.Configure(request.Configuration ?? throw new InvalidDataException("Missing audio configuration.")); break;
+                case AudioBackendAction.SetMix: _mixer.ApplyMix(request.Mix ?? new()); break;
+                case AudioBackendAction.ResetMixer:
+                    foreach (var pending in _pending.Values) pending.Cancel.Cancel();
+                    foreach (var oldPlayback in _playbacks.Values) oldPlayback.Voice.Abandon();
+                    _mixer.Reset(); Volatile.Write(ref _renderError, null); break;
+                case AudioBackendAction.ApplySEffect:
+                    var parameters = request.SEffectParameters ?? throw new InvalidDataException("Missing audio effect parameters.");
+                    var diagnostics = SEffects.Validate(request.SEffectId ?? "", request.Scope, parameters);
+                    if (diagnostics.Count != 0) throw new InvalidDataException(string.Join(" ", diagnostics));
+                    _mixer.Target(request.Scope, request.TrackId).ApplyEffect(new(request.TrackId, request.SEffectInstanceId ?? "", request.SEffectId!, parameters, request.Scope)); break;
+                case AudioBackendAction.StopSEffect: _mixer.Target(request.Scope, request.TrackId).StopEffect(request.SEffectInstanceId ?? ""); break;
+                case AudioBackendAction.SetLevel: _mixer.Target(request.Scope, request.TrackId).ContentLevel = new(request.Gain, request.Muted); break;
+                default:
+                    if (request.Action == AudioBackendAction.Stop && _pending.TryGetValue(request.VoiceId, out var loading) && loading.Generation == request.Generation) loading.Cancel.Cancel();
+                    if (_playbacks.TryGetValue(request.VoiceId, out var playback) && playback.Voice.Request.Generation == request.Generation)
+                        switch (request.Action)
+                        {
+                            case AudioBackendAction.Stop: playback.Voice.Stop(request.FadeSeconds); break;
+                            case AudioBackendAction.Pause: playback.Voice.Paused = true; break;
+                            case AudioBackendAction.Resume: playback.Voice.Paused = false; break;
+                            case AudioBackendAction.SetGain: playback.Voice.Gain = request.Gain; break;
+                        }
+                    break;
+            }
+            return Task.CompletedTask;
+        }
+    }
+    private async Task StartAsync(AudioBackendRequest request, CancellationTokenSource pending)
+    {
+        var linked = pending;
+        AssetFileLease? lease = null;
+        StreamingAudioSource? source = null;
+        try
+        {
+            if (InitializationError is not null) throw new InvalidOperationException(InitializationError);
+            if (Volatile.Read(ref _renderError) is { } renderError) throw new InvalidOperationException("Audio rendering failed.", renderError);
+            if (string.IsNullOrWhiteSpace(request.AssetId) || string.IsNullOrWhiteSpace(request.VoiceId) ||
+                !float.IsFinite(request.Gain) || request.Gain < 0 || !float.IsFinite(request.FadeSeconds) || request.FadeSeconds < 0 ||
+                !float.IsFinite(request.FadeOutSeconds) || request.FadeOutSeconds < 0) throw new InvalidDataException("Invalid audio voice request.");
+            lease = await _files.AcquireAsync(request.AssetId ?? "", linked.Token).ConfigureAwait(false);
+            linked.Token.ThrowIfCancellationRequested();
+            source = new StreamingAudioSource(_decode(lease.Path), _shutdown.Token);
+            await source.PrepareAsync(linked.Token).ConfigureAwait(false);
+            Playback playback;
+            lock (_gate)
+            {
+                linked.Token.ThrowIfCancellationRequested();
+                ObjectDisposedException.ThrowIf(_disposed, this);
+                var voice = new PcmVoice(request, _mixer.Target(SEffectScope.Track, request.TrackId), source);
+                playback = new(voice, source, lease);
+                _playbacks.Add(request.VoiceId, playback);
+                _mixer.Add(voice); source = null; lease = null;
+            }
+            Raise(new(AudioBackendEventKind.Started, request.TrackId, request.VoiceId, request.Generation));
+            Volatile.Write(ref playback.Started, 1);
+        }
+        catch (OperationCanceledException) when (linked.IsCancellationRequested)
+        {
+            if (!_shutdown.IsCancellationRequested) Raise(new(AudioBackendEventKind.Ended, request.TrackId, request.VoiceId, request.Generation));
+        }
+        catch (Exception error) { Raise(new(AudioBackendEventKind.Failed, request.TrackId, request.VoiceId, request.Generation, error.Message)); }
+        finally
+        {
+            await ReleaseAsync(source, lease).ConfigureAwait(false);
+            lock (_gate)
+                if (_pending.TryGetValue(request.VoiceId, out var loading) && ReferenceEquals(loading.Cancel, pending)) _pending.Remove(request.VoiceId);
+            pending.Dispose();
+        }
+    }
+    private void Render(Span<float> output)
+    {
+        if (Volatile.Read(ref _renderError) is not null) { output.Clear(); return; }
+        try { _mixer.Render(output); }
+        catch (Exception error) { output.Clear(); Interlocked.CompareExchange(ref _renderError, error, null); }
+    }
+    private async Task TerminalsAsync()
+    {
+        try
+        {
+            while (true)
+            {
+                await Task.Delay(5, _shutdown.Token).ConfigureAwait(false);
+                Playback[] ended;
+                lock (_gate)
+                {
+                    if (Volatile.Read(ref _renderError) is not null)
+                        foreach (var playback in _playbacks.Values) playback.Voice.Abandon();
+                    ended = _playbacks.Values.Where(playback => Volatile.Read(ref playback.Started) != 0 && playback.Voice.Ended).ToArray();
+                    foreach (var playback in ended) { _playbacks.Remove(playback.Voice.Request.VoiceId); _mixer.Remove(playback.Voice); }
+                }
+                foreach (var playback in ended)
+                {
+                    var request = playback.Voice.Request;
+                    var cleanup = await ReleaseAsync(playback.Source, playback.Lease).ConfigureAwait(false);
+                    var error = playback.Source.Error ?? Volatile.Read(ref _renderError) ?? cleanup;
+                    Raise(new(error is null ? AudioBackendEventKind.Ended : AudioBackendEventKind.Failed,
+                        request.TrackId, request.VoiceId, request.Generation, error?.Message));
+                }
+            }
+        }
+        catch (OperationCanceledException) when (_shutdown.IsCancellationRequested) { }
+    }
+    private async Task<Exception?> ReleaseAsync(StreamingAudioSource? source, AssetFileLease? lease)
+    {
+        Exception? error = null;
+        try { if (source is not null) await source.DisposeAsync().ConfigureAwait(false); }
+        catch (Exception failure) { error = failure; _cleanupErrors.Enqueue(failure); }
+        try { lease?.Dispose(); }
+        catch (Exception failure) { error ??= failure; _cleanupErrors.Enqueue(failure); }
+        return error;
+    }
+    private void Raise(AudioBackendEvent value)
+    {
+        foreach (var handler in EventReceived?.GetInvocationList() ?? [])
+            try { ((Action<AudioBackendEvent>)handler)(value); } catch (Exception) { /* Observers cannot interrupt owned cleanup. */ }
+    }
+    public void Dispose() => _ = DisposeAsync().AsTask();
+    public ValueTask DisposeAsync()
+    {
+        lock (_gate)
+        {
+            if (_dispose is not null) return new(_dispose);
+            _disposed = true;
+            _shutdown.Cancel();
+            _dispose = FinishAsync(_loads.ToArray());
+            return new(_dispose);
+        }
+    }
+    private async Task FinishAsync(Task[] loads)
+    {
+        await Task.Yield();
+        try { await Task.WhenAll(loads.Append(_terminalWorker)).ConfigureAwait(false); }
+        catch (Exception error) { _cleanupErrors.Enqueue(error); }
+        finally
+        {
+            try { _output.Dispose(); } // Waits for the last render callback before releasing sources.
+            catch (Exception error) { _cleanupErrors.Enqueue(error); }
+            foreach (var playback in _playbacks.Values)
+                await ReleaseAsync(playback.Source, playback.Lease).ConfigureAwait(false);
+            _playbacks.Clear(); _mixer.Reset(); _shutdown.Dispose();
+        }
+        if (!_cleanupErrors.IsEmpty) throw new AggregateException("Audio cleanup failed.", _cleanupErrors);
+    }
+    private sealed record Playback(PcmVoice Voice, StreamingAudioSource Source, AssetFileLease Lease)
+    {
+        public int Started;
+    }
+}
diff --git a/src/Infrastructure/GalNet.Media.Audio/PcmEffect.cs b/src/Infrastructure/GalNet.Media.Audio/PcmEffect.cs
new file mode 100644
index 00000000..6e6a199d
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Audio/PcmEffect.cs
@@ -0,0 +1,157 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins.Audio;
+
+namespace GalNet.Media.Audio;
+
+/// <summary>Persistent audio-thread DSP state; control thread publishes immutable parameters.</summary>
+internal sealed class PcmEffect
+{
+    private Parameters _parameters;
+    private int _enabled = 1;
+    private float _blend;
+    private readonly Biquad? _filter;
+    private readonly Reverb? _reverb;
+    private float _gain = 1;
+    public string InstanceId { get; }
+    public string Id { get; }
+    public bool Enabled { get => Volatile.Read(ref _enabled) != 0; set => Volatile.Write(ref _enabled, value ? 1 : 0); }
+    public bool IsBypassed => Volatile.Read(ref _blend) == 0;
+
+    public PcmEffect(string instanceId, string id, JsonElement parameters)
+    {
+        InstanceId = instanceId; Id = id;
+        _parameters = Parse(parameters);
+        switch (id.ToLowerInvariant())
+        {
+            case "seffect.lowpass": _filter = new(false, _parameters.Cutoff, _parameters.Q); break;
+            case "seffect.highpass": _filter = new(true, _parameters.Cutoff, _parameters.Q); break;
+            case "seffect.reverb": _reverb = new(_parameters); break;
+            case "seffect.gain": break;
+            default: throw new InvalidDataException($"Unsupported PCM effect '{id}'.");
+        }
+    }
+    public void Update(JsonElement parameters) => Volatile.Write(ref _parameters, Parse(parameters));
+    private Parameters Parse(JsonElement parameters) => new(Value(parameters, "cutoffHz", Id.Equals("seffect.highPass", StringComparison.OrdinalIgnoreCase) ? SEffectDefaults.HighPassCutoff : SEffectDefaults.LowPassCutoff), Value(parameters, "q", SEffectDefaults.Q),
+        Value(parameters, "gain", SEffectDefaults.Gain), Value(parameters, "roomSize", SEffectDefaults.RoomSize), Value(parameters, "decaySeconds", SEffectDefaults.DecaySeconds), Value(parameters, "damping", SEffectDefaults.Damping), Value(parameters, "mix", SEffectDefaults.Mix));
+    private static float Value(JsonElement parameters, string name, float fallback) => parameters.TryGetProperty(name, out var value) ? value.GetSingle() : fallback;
+    public void Process(Span<float> samples)
+    {
+        var enabled = Enabled;
+        if (!enabled && _blend == 0) return;
+        var parameters = Volatile.Read(ref _parameters);
+        _reverb?.Prepare(parameters);
+        for (var index = 0; index < samples.Length; index += 2)
+        {
+            _blend = PcmMixer.Smooth(_blend, enabled ? 1 : 0);
+            var dryLeft = samples[index]; var dryRight = samples[index + 1];
+            float left, right;
+            if (_filter is not null) _filter.Process(dryLeft, dryRight, parameters, out left, out right);
+            else if (_reverb is not null) _reverb.Process(dryLeft, dryRight, parameters, out left, out right);
+            else { _gain = PcmMixer.Smooth(_gain, parameters.Gain); left = dryLeft * _gain; right = dryRight * _gain; }
+            samples[index] = dryLeft + (left - dryLeft) * _blend;
+            samples[index + 1] = dryRight + (right - dryRight) * _blend;
+        }
+    }
+    private sealed record Parameters(float Cutoff, float Q, float Gain, float Room, float Decay, float Damping, float Mix);
+
+    // RBJ low/high pass, transposed direct form II, separate state for each channel.
+    private sealed class Biquad(bool highPass, float cutoff, float q)
+    {
+        private double _cutoff = cutoff, _q = q;
+        private double _b0, _b1, _b2, _a1, _a2, _z1L, _z2L, _z1R, _z2R;
+        private int _counter;
+        public void Process(float left, float right, Parameters target, out float resultLeft, out float resultRight)
+        {
+            _cutoff += (target.Cutoff - _cutoff) / 960;
+            _q += (target.Q - _q) / 960;
+            if ((_counter++ & 15) == 0)
+            {
+                var omega = 2 * Math.PI * Math.Clamp(_cutoff, 20, PcmMixer.SampleRate * .49) / PcmMixer.SampleRate;
+                var cosine = Math.Cos(omega); var alpha = Math.Sin(omega) / (2 * Math.Clamp(_q, .1, 10));
+                var a0 = 1 + alpha;
+                _b0 = (highPass ? 1 + cosine : 1 - cosine) / (2 * a0);
+                _b1 = (highPass ? -(1 + cosine) : 1 - cosine) / a0;
+                _b2 = _b0; _a1 = -2 * cosine / a0; _a2 = (1 - alpha) / a0;
+            }
+            resultLeft = Filter(left, ref _z1L, ref _z2L); resultRight = Filter(right, ref _z1R, ref _z2R);
+        }
+        private float Filter(float value, ref double z1, ref double z2)
+        {
+            var output = _b0 * value + z1;
+            z1 = _b1 * value - _a1 * output + z2; z2 = _b2 * value - _a2 * output;
+            if (Math.Abs(z1) < 1e-25) z1 = 0;
+            if (Math.Abs(z2) < 1e-25) z2 = 0;
+            return (float)output;
+        }
+    }
+
+    // Four parallel damped combs per channel, followed by two all-pass diffusers.
+    private sealed class Reverb
+    {
+        private readonly Delay[][] _combs = [CreateCombs(0), CreateCombs(.0007f)];
+        private readonly AllPass[][] _diffusers = [CreateDiffusers(0), CreateDiffusers(23)];
+        private readonly float[] _feedback = new float[4];
+        private float _room, _damping, _mix;
+        public Reverb(Parameters parameters) { _room = parameters.Room; _damping = parameters.Damping; _mix = parameters.Mix; }
+        private static Delay[] CreateCombs(float offset) => new[] { .0297f, .0371f, .0411f, .0437f }.Select(seconds => new Delay(seconds + offset)).ToArray();
+        private static AllPass[] CreateDiffusers(int offset) => [new(241 + offset), new(83 + offset)];
+        public void Prepare(Parameters parameters)
+        {
+            for (var index = 0; index < 4; index++)
+                _feedback[index] = MathF.Pow(.001f, _combs[0][index].Seconds * (.5f + _room * 1.5f) / Math.Clamp(parameters.Decay, .1f, 20));
+        }
+        public void Process(float left, float right, Parameters parameters, out float resultLeft, out float resultRight)
+        {
+            _room += (parameters.Room - _room) / 2400;
+            _damping += (parameters.Damping - _damping) / 960;
+            _mix = PcmMixer.Smooth(_mix, parameters.Mix);
+            // Feed both channels into the space, retaining a stereo difference.
+            var wetLeft = Channel((left * .8f + right * .2f) * .25f, 0);
+            var wetRight = Channel((right * .8f + left * .2f) * .25f, 1);
+            resultLeft = left * (1 - _mix) + wetLeft * _mix;
+            resultRight = right * (1 - _mix) + wetRight * _mix;
+        }
+        private float Channel(float input, int channel)
+        {
+            var wet = 0f;
+            for (var index = 0; index < 4; index++) wet += _combs[channel][index].Process(input, .5f + _room * 1.5f, _feedback[index], _damping * .95f);
+            foreach (var diffuser in _diffusers[channel]) wet = diffuser.Process(wet);
+            return wet;
+        }
+        private sealed class Delay(float seconds)
+        {
+            private readonly float[] _buffer = new float[(int)(PcmMixer.SampleRate * .1f) + 2];
+            private int _position;
+            private float _low;
+            private float _feedback;
+            public float Seconds { get; } = seconds;
+            public float Process(float input, float scale, float feedback, float damping)
+            {
+                var read = _position - (double)Seconds * PcmMixer.SampleRate * scale;
+                if (read < 0) read += _buffer.Length;
+                if (read >= _buffer.Length) read -= _buffer.Length;
+                var first = (int)read; var fraction = read - first;
+                var output = (float)(_buffer[first] + (_buffer[(first + 1) % _buffer.Length] - _buffer[first]) * fraction);
+                _low = output * (1 - damping) + _low * damping;
+                if (MathF.Abs(_low) < 1e-20f) _low = 0;
+                _feedback += (feedback - _feedback) / 960;
+                _buffer[_position] = input + _low * _feedback;
+                if (++_position == _buffer.Length) _position = 0;
+                return output;
+            }
+        }
+        private sealed class AllPass(int length)
+        {
+            private readonly float[] _buffer = new float[length];
+            private int _position;
+            public float Process(float input)
+            {
+                var buffered = _buffer[_position];
+                var output = buffered - input;
+                _buffer[_position] = input + buffered * .5f;
+                if (++_position == _buffer.Length) _position = 0;
+                return output;
+            }
+        }
+    }
+}
diff --git a/src/Infrastructure/GalNet.Media.Audio/PcmMixer.cs b/src/Infrastructure/GalNet.Media.Audio/PcmMixer.cs
new file mode 100644
index 00000000..cbc090fd
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Audio/PcmMixer.cs
@@ -0,0 +1,184 @@
+using GalNet.Contracts.Builtins.Audio;
+
+namespace GalNet.Media.Audio;
+
+/// <summary>Single audio consumer; control calls are serialized by the owning host.</summary>
+public sealed class PcmMixer
+{
+    public const int SampleRate = 48_000;
+    private const int BlockSamples = 2048;
+    private Graph _graph = new([], [], []);
+    private float _master = 1;
+    private float _masterTarget = 1;
+    public IReadOnlyList<PcmVoice> Voices => Volatile.Read(ref _graph).Voices;
+
+    public void Configure(AudioConfiguration configuration)
+    {
+        var buses = configuration.Buses.Select(bus => new PcmChannel(bus.Id, bus.DefaultGain)).ToArray();
+        var tracks = configuration.Tracks.Select(track => new PcmChannel(track.Id, track.DefaultGain,
+            buses.FirstOrDefault(bus => bus.Id == track.BusId))).ToArray();
+        if (Voices.Count > 0) throw new InvalidOperationException("Reset active audio before replacing its configuration.");
+        Volatile.Write(ref _graph, new(tracks, buses, []));
+    }
+    public void Reset()
+    {
+        Volatile.Write(ref _graph, new([], [], []));
+    }
+    public void Add(PcmVoice voice)
+    { var graph = Volatile.Read(ref _graph); Volatile.Write(ref _graph, graph with { Voices = [.. graph.Voices, voice] }); }
+    public void Remove(PcmVoice voice)
+    { var graph = Volatile.Read(ref _graph); Volatile.Write(ref _graph, graph with { Voices = graph.Voices.Where(item => !ReferenceEquals(item, voice)).ToArray() }); }
+    public PcmChannel Target(SEffectScope scope, string id)
+    {
+        var graph = Volatile.Read(ref _graph);
+        return (scope == SEffectScope.Track ? graph.Tracks : scope == SEffectScope.Bus ? graph.Buses : [])
+            .FirstOrDefault(target => target.Id == id) ?? throw new InvalidDataException($"Unknown {scope} audio target '{id}'.");
+    }
+    public void ApplyMix(AudioMixOptions options)
+    {
+        options = options.Snapshot();
+        Volatile.Write(ref _masterTarget, options.MasterMuted ? 0 : options.MasterGain);
+        var graph = Volatile.Read(ref _graph);
+        foreach (var track in graph.Tracks) track.PlayerLevel = options.Tracks.GetValueOrDefault(track.Id) ?? new();
+        foreach (var bus in graph.Buses) bus.PlayerLevel = options.Buses.GetValueOrDefault(bus.Id) ?? new();
+    }
+    public void Render(Span<float> output)
+    {
+        output.Clear();
+        if (output.Length % 2 != 0) return;
+        var graph = Volatile.Read(ref _graph);
+        var voices = graph.Voices;
+        while (!output.IsEmpty)
+        {
+            var block = output[..Math.Min(output.Length, BlockSamples)];
+            foreach (var track in graph.Tracks) track.Buffer.AsSpan(0, block.Length).Clear();
+            foreach (var bus in graph.Buses) bus.Buffer.AsSpan(0, block.Length).Clear();
+            foreach (var voice in voices) voice.Render(block.Length);
+            foreach (var track in graph.Tracks)
+            {
+                track.Process(block.Length);
+                Add(track.Buffer.AsSpan(0, block.Length), track.Bus is { } bus ? bus.Buffer.AsSpan(0, block.Length) : block);
+            }
+            foreach (var bus in graph.Buses) { bus.Process(block.Length); Add(bus.Buffer.AsSpan(0, block.Length), block); }
+            var masterTarget = Volatile.Read(ref _masterTarget);
+            for (var index = 0; index < block.Length; index += 2)
+            {
+                _master = Smooth(_master, masterTarget);
+                block[index] = Limit(block[index] * _master);
+                block[index + 1] = Limit(block[index + 1] * _master);
+            }
+            output = output[block.Length..];
+        }
+    }
+    private static float Limit(float value) => float.IsNaN(value) ? 0 : Math.Clamp(value, -1, 1);
+    internal static float Smooth(float value, float target) => value + Math.Clamp(target - value, -1f / 480, 1f / 480);
+    private static void Add(ReadOnlySpan<float> source, Span<float> target)
+    { for (var index = 0; index < source.Length; index++) target[index] += source[index]; }
+    private sealed record Graph(PcmChannel[] Tracks, PcmChannel[] Buses, PcmVoice[] Voices);
+}
+
+public sealed class PcmChannel(string id, float defaultGain = 1, PcmChannel? bus = null)
+{
+    private PcmEffect[] _effects = [];
+    private AudioMixLevel _playerLevel = new();
+    private AudioMixLevel _contentLevel = new();
+    private float _gain = defaultGain;
+    private readonly float _defaultGain = defaultGain;
+    public string Id { get; } = id;
+    public PcmChannel? Bus { get; } = bus;
+    internal float[] Buffer { get; } = new float[2048];
+    public AudioMixLevel PlayerLevel { set => Volatile.Write(ref _playerLevel, value); }
+    public AudioMixLevel ContentLevel { set => Volatile.Write(ref _contentLevel, value); }
+
+    public void ApplyEffect(AudioSEffectState state)
+    {
+        var effects = Volatile.Read(ref _effects);
+        var existing = effects.FirstOrDefault(effect => effect.Enabled && effect.InstanceId == state.InstanceId && StringComparer.OrdinalIgnoreCase.Equals(effect.Id, state.SEffectId));
+        if (existing is not null)
+        {
+            foreach (var effect in effects)
+                if (effect.InstanceId == state.InstanceId && !ReferenceEquals(effect, existing)) effect.Enabled = false;
+            existing.Update(state.Parameters); existing.Enabled = true; return;
+        }
+        var processor = new PcmEffect(state.InstanceId, state.SEffectId, state.Parameters);
+        // A changed type crossfades the old instance out, then the replacement in at the same position.
+        var previous = effects.FirstOrDefault(effect => effect.InstanceId == state.InstanceId && effect.Enabled);
+        if (previous is not null) previous.Enabled = false;
+        var list = effects.Where(effect => effect.Enabled || !effect.IsBypassed).ToList();
+        if (list.Count(effect => effect.Enabled) >= 64) throw new InvalidOperationException("An audio target supports at most 64 active effect nodes.");
+        var position = previous is null ? list.Count : list.IndexOf(previous) + 1;
+        list.Insert(position, processor);
+        Volatile.Write(ref _effects, list.ToArray());
+    }
+    public void StopEffect(string instanceId)
+    { foreach (var effect in Volatile.Read(ref _effects)) if (effect.InstanceId == instanceId) effect.Enabled = false; }
+    internal void Process(int count)
+    {
+        var samples = Buffer.AsSpan(0, count);
+        foreach (var effect in Volatile.Read(ref _effects)) effect.Process(samples);
+        var player = Volatile.Read(ref _playerLevel);
+        var content = Volatile.Read(ref _contentLevel);
+        var gain = player.Muted || content.Muted ? 0 : (float)Math.Min((double)_defaultGain * player.Gain * content.Gain, float.MaxValue);
+        for (var index = 0; index < count; index += 2)
+        {
+            _gain = PcmMixer.Smooth(_gain, gain);
+            samples[index] *= _gain; samples[index + 1] *= _gain;
+        }
+    }
+}
+
+public sealed class PcmVoice(AudioBackendRequest request, PcmChannel track, IAudioPcmSource source)
+{
+    private readonly float[] _buffer = new float[2048];
+    private float _gain = request.Gain;
+    private float _targetGain = request.Gain;
+    private int _paused;
+    private int _stopFrames = -1;
+    private int _stopRemaining = -1;
+    private int _stopTotal;
+    private long _position;
+    private int _ended;
+    public AudioBackendRequest Request { get; } = request;
+    public bool Ended => Volatile.Read(ref _ended) != 0;
+    public void Abandon() => Volatile.Write(ref _ended, 1);
+    public bool Paused { set => Volatile.Write(ref _paused, value ? 1 : 0); }
+    public float Gain { set => Volatile.Write(ref _targetGain, value); }
+    public void Stop(float seconds)
+    {
+        if (!float.IsFinite(seconds) || seconds < 0) throw new ArgumentOutOfRangeException(nameof(seconds));
+        Volatile.Write(ref _stopFrames, (int)Math.Min((double)seconds * PcmMixer.SampleRate, int.MaxValue));
+    }
+    internal void Render(int count)
+    {
+        if (Ended) return;
+        var stop = Interlocked.Exchange(ref _stopFrames, -1);
+        if (stop >= 0) { _stopRemaining = stop; _stopTotal = stop; }
+        if (_stopRemaining == 0) { Volatile.Write(ref _ended, 1); return; }
+        // A stopped paused voice must still retire; its source position remains paused.
+        if (Volatile.Read(ref _paused) != 0)
+        {
+            if (_stopRemaining > 0) _stopRemaining = Math.Max(0, _stopRemaining - count / 2);
+            if (_stopRemaining == 0) Volatile.Write(ref _ended, 1);
+            return;
+        }
+        var read = source.Read(_buffer.AsSpan(0, count));
+        var fadeIn = Request.FadeSeconds * PcmMixer.SampleRate;
+        var fadeOut = Request.FadeOutSeconds * PcmMixer.SampleRate;
+        var length = source.DurationSeconds * PcmMixer.SampleRate;
+        var targetGain = Volatile.Read(ref _targetGain);
+        for (var index = 0; index < read; index += 2)
+        {
+            double envelope = fadeIn > 0 ? Math.Min(1, _position / fadeIn) : 1;
+            if (fadeOut > 0 && length > 0) envelope *= Math.Clamp((length - _position) / fadeOut, 0, 1);
+            if (_stopRemaining >= 0) envelope *= _stopTotal > 0 ? (float)_stopRemaining / _stopTotal : 0;
+            _gain = PcmMixer.Smooth(_gain, targetGain);
+            var gain = (float)(envelope * _gain);
+            track.Buffer[index] += _buffer[index] * gain; track.Buffer[index + 1] += _buffer[index + 1] * gain;
+            _position++;
+            if (_stopRemaining > 0) _stopRemaining--;
+            if (_stopRemaining == 0) break;
+        }
+        if (_stopRemaining > 0 && read < count) _stopRemaining = Math.Max(0, _stopRemaining - (count - read) / 2);
+        if (_stopRemaining == 0 || source.IsFinished) Volatile.Write(ref _ended, 1);
+    }
+}
diff --git a/src/Infrastructure/GalNet.Media.Audio/StreamingAudioSource.cs b/src/Infrastructure/GalNet.Media.Audio/StreamingAudioSource.cs
new file mode 100644
index 00000000..8c25b7b2
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Audio/StreamingAudioSource.cs
@@ -0,0 +1,74 @@
+namespace GalNet.Media.Audio;
+
+/// <summary>One producer, one consumer. No file I/O, waits, or allocations on Read.</summary>
+public sealed class StreamingAudioSource : IAudioPcmSource, IAsyncDisposable
+{
+    private readonly float[] _ring = new float[PcmMixer.SampleRate * 2 * 2];
+    private readonly CancellationTokenSource _cancel;
+    private readonly TaskCompletionSource _ready = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    private readonly Task _producer;
+    private long _read;
+    private long _written;
+    private int _finished;
+    public double DurationSeconds { get; }
+    public Exception? Error { get; private set; }
+    public bool IsFinished => Volatile.Read(ref _finished) != 0 && Volatile.Read(ref _written) == Volatile.Read(ref _read);
+
+    public StreamingAudioSource(IAudioPcmDecoder decoder, CancellationToken cancellationToken = default)
+    {
+        DurationSeconds = decoder.DurationSeconds;
+        _cancel = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        _producer = Task.Run(() => ProduceAsync(decoder), CancellationToken.None);
+    }
+
+    public Task PrepareAsync(CancellationToken token) => _ready.Task.WaitAsync(token);
+
+    private async Task ProduceAsync(IAudioPcmDecoder decoder)
+    {
+        using (decoder)
+        {
+            var buffer = new float[4096];
+            try
+            {
+                while (true)
+                {
+                    _cancel.Token.ThrowIfCancellationRequested();
+                    var written = Volatile.Read(ref _written);
+                    var free = _ring.Length - (int)(written - Volatile.Read(ref _read));
+                    if (free < buffer.Length) { await Task.Delay(5, _cancel.Token).ConfigureAwait(false); continue; }
+                    var count = decoder.Read(buffer);
+                    if (count < 0 || count > buffer.Length || count % 2 != 0) throw new InvalidDataException("Decoder returned invalid stereo PCM.");
+                    if (count == 0) break;
+                    var offset = (int)(written % _ring.Length);
+                    var first = Math.Min(count, _ring.Length - offset);
+                    buffer.AsSpan(0, first).CopyTo(_ring.AsSpan(offset));
+                    buffer.AsSpan(first, count - first).CopyTo(_ring);
+                    Volatile.Write(ref _written, written + count);
+                    _ready.TrySetResult();
+                }
+            }
+            catch (OperationCanceledException) when (_cancel.IsCancellationRequested) { _ready.TrySetCanceled(_cancel.Token); }
+            catch (Exception error) { Error = error; _ready.TrySetException(error); }
+            finally { Volatile.Write(ref _finished, 1); _ready.TrySetResult(); }
+        }
+    }
+
+    public int Read(Span<float> samples)
+    {
+        var read = Volatile.Read(ref _read);
+        var count = (int)Math.Min(samples.Length, Volatile.Read(ref _written) - read);
+        var offset = (int)(read % _ring.Length);
+        var first = Math.Min(count, _ring.Length - offset);
+        _ring.AsSpan(offset, first).CopyTo(samples);
+        _ring.AsSpan(0, count - first).CopyTo(samples[first..]);
+        Volatile.Write(ref _read, read + count);
+        return count;
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        await _cancel.CancelAsync().ConfigureAwait(false);
+        await _producer.ConfigureAwait(false);
+        _cancel.Dispose();
+    }
+}
diff --git a/src/Infrastructure/GalNet.Media.Audio/packages.lock.WindowsReadyToRun.json b/src/Infrastructure/GalNet.Media.Audio/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..9fb490d8
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Audio/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,17 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Infrastructure/GalNet.Media.Audio/packages.lock.json b/src/Infrastructure/GalNet.Media.Audio/packages.lock.json
new file mode 100644
index 00000000..af322323
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Audio/packages.lock.json
@@ -0,0 +1,16 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/Infrastructure/GalNet.Media.LibVlc/GalNet.Media.LibVlc.csproj b/src/Infrastructure/GalNet.Media.LibVlc/GalNet.Media.LibVlc.csproj
index f5adf485..6a149d19 100644
--- a/src/Infrastructure/GalNet.Media.LibVlc/GalNet.Media.LibVlc.csproj
+++ b/src/Infrastructure/GalNet.Media.LibVlc/GalNet.Media.LibVlc.csproj
@@ -6,4 +6,5 @@
     <ProjectReference Include="../../Shared/GalNet.Assets/GalNet.Assets.csproj" />
     <ProjectReference Include="../../Shared/GalNet.Presentation.Abstractions/GalNet.Presentation.Abstractions.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Infrastructure/GalNet.Media.LibVlc/LibVlcAudioPlaybackHost.cs b/src/Infrastructure/GalNet.Media.LibVlc/LibVlcAudioPlaybackHost.cs
deleted file mode 100644
index 6d6bcc94..00000000
--- a/src/Infrastructure/GalNet.Media.LibVlc/LibVlcAudioPlaybackHost.cs
+++ /dev/null
@@ -1,383 +0,0 @@
-using System.Threading.Channels;
-using GalNet.Assets;
-using GalNet.Core.Assets;
-using GalNet.Core.Audio;
-using GalNet.Presentation.Abstractions.Audio;
-using LibVLCSharp.Shared;
-using LibVlcMedia = LibVLCSharp.Shared.Media;
-
-namespace GalNet.Media.LibVlc;
-
-/// <summary>LibVLC-backed audio host. Logical queue and track ownership remains in AudioRuntime.</summary>
-public sealed class LibVlcAudioPlaybackHost : IAudioPlaybackHost, IAsyncDisposable
-{
-    private readonly object _gate = new();
-    private readonly IAssetFileMaterializer _files;
-    private readonly bool _ownsFiles;
-    private readonly Dictionary<string, Voice> _voices = new(StringComparer.Ordinal);
-    private readonly Dictionary<string, AssetFileLease> _paths = new(StringComparer.OrdinalIgnoreCase);
-    private readonly Dictionary<string, PendingLoad> _pending = new(StringComparer.Ordinal);
-    private readonly List<Task> _loads = [];
-    private readonly CancellationTokenSource _shutdown = new();
-    private readonly SemaphoreSlim _materialization = new(1, 1);
-    private readonly Channel<(Voice Voice, AudioBackendEventKind Kind, string? Message)> _terminalEvents =
-        Channel.CreateUnbounded<(Voice, AudioBackendEventKind, string?)>(new UnboundedChannelOptions { SingleReader = true });
-    private readonly Task _terminalWorker;
-    private Task? _disposeTask;
-    private readonly LibVlcAudioSEffectRegistry _effects;
-    private readonly LibVLC? _libVlc;
-    private readonly bool _ownsLibVlc;
-    private bool _disposed;
-
-    public LibVlcAudioPlaybackHost(IAssetManager assets, IEnumerable<IAudioSEffectProcessor>? effectProcessors = null,
-        IAssetFileMaterializer? files = null, LibVLC? sharedLibVlc = null)
-    {
-        _files = files ?? new AssetFileMaterializer(assets);
-        _ownsFiles = files is null;
-        _ownsLibVlc = sharedLibVlc is null;
-        _effects = new LibVlcAudioSEffectRegistry(LibVlcAudioSEffectRegistry.DefaultProcessors.Concat(effectProcessors ?? []));
-        if (sharedLibVlc is not null)
-        {
-            _libVlc = sharedLibVlc;
-            Capabilities = new(true, true, true);
-            SEffects = _effects.Catalog;
-        }
-        else
-        {
-            try
-            {
-                LibVLCSharp.Shared.Core.Initialize();
-                _libVlc = new LibVLC("--no-video-title-show");
-                Capabilities = new(true, true, true);
-                SEffects = _effects.Catalog;
-            }
-            catch (Exception exception)
-            {
-                InitializationError = exception.Message;
-                Capabilities = AudioBackendCapabilities.None;
-                SEffects = SEffectCatalog.Empty;
-            }
-        }
-        _terminalWorker = Task.Run(DrainTerminalEventsAsync);
-    }
-
-    public AudioBackendCapabilities Capabilities { get; }
-    public ISEffectCatalog SEffects { get; }
-    public string? InitializationError { get; }
-    public event Action<AudioBackendEvent>? EventReceived;
-
-    public async Task ApplyAsync(AudioBackendRequest request, CancellationToken cancellationToken = default)
-    {
-        ObjectDisposedException.ThrowIf(_disposed, this);
-        switch (request.Action)
-        {
-            case AudioBackendAction.Start:
-                await StartTrackedAsync(request, cancellationToken).ConfigureAwait(false);
-                break;
-            case AudioBackendAction.Stop:
-                Stop(request, request.FadeSeconds);
-                break;
-            case AudioBackendAction.Pause:
-                WithVoice(request, voice => voice.Player.Pause());
-                break;
-            case AudioBackendAction.Resume:
-                WithVoice(request, voice => voice.Player.Play());
-                break;
-            case AudioBackendAction.SetGain:
-                WithVoice(request, voice => { voice.BaseGain = request.Gain; SetVolume(voice); });
-                break;
-            case AudioBackendAction.ApplySEffect:
-                ApplySEffect(request);
-                break;
-            case AudioBackendAction.StopSEffect:
-                StopSEffect(request);
-                break;
-        }
-    }
-
-    public void Dispose() => _ = DisposeAsync().AsTask();
-
-    public ValueTask DisposeAsync()
-    {
-        lock (_gate)
-        {
-            if (_disposeTask is not null) return new ValueTask(_disposeTask);
-            _disposed = true;
-            _shutdown.Cancel();
-            foreach (var voice in _voices.Values) voice.Dispose();
-            _voices.Clear();
-            _terminalEvents.Writer.TryComplete();
-            _disposeTask = FinishDisposalAsync(_loads.ToArray());
-            return new ValueTask(_disposeTask);
-        }
-    }
-
-    private async Task FinishDisposalAsync(Task[] loads)
-    {
-        // Ensure cancellation callbacks have left the disposal lock before cleanup.
-        await Task.Yield();
-        try { await Task.WhenAll(loads.Append(_terminalWorker)).ConfigureAwait(false); }
-        finally
-        {
-            foreach (var lease in _paths.Values) lease.Dispose();
-            _paths.Clear();
-            if (_ownsLibVlc) _libVlc?.Dispose();
-            _materialization.Dispose();
-            _shutdown.Dispose();
-            if (_ownsFiles) await _files.DisposeAsync().ConfigureAwait(false);
-        }
-    }
-
-    private Task StartTrackedAsync(AudioBackendRequest request, CancellationToken cancellationToken)
-    {
-        lock (_gate)
-        {
-            ObjectDisposedException.ThrowIf(_disposed, this);
-            if (_pending.TryGetValue(request.VoiceId, out var previous)) previous.Cancellation.Cancel();
-            var pending = new PendingLoad(request.Generation,
-                CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdown.Token));
-            _pending[request.VoiceId] = pending;
-            var task = ObserveStartAsync(request, pending);
-            _loads.RemoveAll(load => load.IsCompleted);
-            _loads.Add(task);
-            return task;
-        }
-    }
-
-    private async Task ObserveStartAsync(AudioBackendRequest request, PendingLoad pending)
-    {
-        try { await StartAsync(request, pending.Cancellation.Token).ConfigureAwait(false); }
-        catch (OperationCanceledException) when (pending.Cancellation.IsCancellationRequested) { }
-        finally
-        {
-            lock (_gate)
-                if (_pending.TryGetValue(request.VoiceId, out var current) && ReferenceEquals(current, pending))
-                    _pending.Remove(request.VoiceId);
-            pending.Cancellation.Dispose();
-        }
-    }
-
-    private async Task StartAsync(AudioBackendRequest request, CancellationToken cancellationToken)
-    {
-        if (_libVlc is null || string.IsNullOrWhiteSpace(request.AssetId))
-        {
-            Raise(new(AudioBackendEventKind.Failed, request.TrackId, request.VoiceId, request.Generation,
-                InitializationError ?? "LibVLC audio is unavailable."));
-            return;
-        }
-
-        string path;
-        try { path = await MaterializeAsync(request.AssetId, cancellationToken).ConfigureAwait(false); }
-        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
-        catch (Exception exception)
-        {
-            Raise(new(AudioBackendEventKind.Failed, request.TrackId, request.VoiceId, request.Generation, exception.Message));
-            return;
-        }
-
-        Voice voice;
-        lock (_gate)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            if (_disposed) return;
-            RemoveVoice(request.VoiceId);
-            var player = new MediaPlayer(_libVlc);
-            voice = new Voice(request, player);
-            player.EndReached += (_, _) => Ended(voice);
-            player.EncounteredError += (_, _) => Failed(voice, "LibVLC could not play the audio asset.");
-            _voices.Add(request.VoiceId, voice);
-            voice.BaseGain = request.Gain;
-            voice.FadeGain = request.FadeSeconds > 0 ? 0 : 1;
-            ReapplySEffects(voice);
-            using var media = new LibVlcMedia(_libVlc, path);
-            player.Play(media);
-        }
-        Raise(new(AudioBackendEventKind.Started, request.TrackId, request.VoiceId, request.Generation));
-        if (request.FadeSeconds > 0) _ = FadeAsync(voice, 0, 1, request.FadeSeconds, stopWhenDone: false);
-    }
-
-    private async Task<string> MaterializeAsync(string assetId, CancellationToken cancellationToken)
-    {
-        await _materialization.WaitAsync(cancellationToken).ConfigureAwait(false);
-        try
-        {
-            lock (_gate)
-                if (_paths.TryGetValue(assetId, out var existing)) return existing.Path;
-            var lease = await _files.AcquireAsync(assetId, cancellationToken).ConfigureAwait(false);
-            lock (_gate)
-            {
-                if (_disposed) { lease.Dispose(); throw new ObjectDisposedException(nameof(LibVlcAudioPlaybackHost)); }
-                _paths.Add(assetId, lease);
-                return lease.Path;
-            }
-        }
-        finally { _materialization.Release(); }
-    }
-
-    private void Stop(AudioBackendRequest request, float fadeSeconds)
-    {
-        lock (_gate)
-            if (_pending.TryGetValue(request.VoiceId, out var pending) && pending.Generation == request.Generation)
-                pending.Cancellation.Cancel();
-        WithVoice(request, voice =>
-        {
-            if (fadeSeconds <= 0)
-            {
-                voice.Player.Stop();
-                RemoveVoice(voice.Request.VoiceId);
-                return;
-            }
-            _ = FadeAsync(voice, voice.FadeGain, 0, fadeSeconds, stopWhenDone: true);
-        });
-    }
-
-    private void ApplySEffect(AudioBackendRequest request) => WithVoice(request, voice =>
-    {
-        if (string.IsNullOrWhiteSpace(request.SEffectId) || string.IsNullOrWhiteSpace(request.SEffectInstanceId) || request.SEffectParameters is not { } parameters || !_effects.TryGet(request.SEffectId, out _)) return;
-        voice.Effects[request.SEffectInstanceId] = new(request.SEffectId, parameters);
-        ReapplySEffects(voice);
-    });
-
-    private void StopSEffect(AudioBackendRequest request) => WithVoice(request, voice =>
-    {
-        if (!string.IsNullOrWhiteSpace(request.SEffectInstanceId) && voice.Effects.Remove(request.SEffectInstanceId)) ReapplySEffects(voice);
-    });
-
-    private async Task FadeAsync(Voice voice, float from, float to, float seconds, bool stopWhenDone)
-    {
-        const int steps = 20;
-        CancellationToken cancellation;
-        lock (_gate)
-        {
-            if (_disposed || !_voices.TryGetValue(voice.Request.VoiceId, out var current) || !ReferenceEquals(current, voice)) return;
-            cancellation = voice.BeginFade();
-        }
-        try
-        {
-            for (var index = 1; index <= steps; index++)
-            {
-                await Task.Delay(TimeSpan.FromSeconds(seconds / steps), cancellation).ConfigureAwait(false);
-                lock (_gate)
-                {
-                    if (_disposed || !_voices.TryGetValue(voice.Request.VoiceId, out var current) || !ReferenceEquals(current, voice)) return;
-                    voice.FadeGain = from + (to - from) * index / steps;
-                    SetVolume(voice);
-                }
-            }
-            if (stopWhenDone)
-            {
-                lock (_gate)
-                {
-                    if (_voices.TryGetValue(voice.Request.VoiceId, out var current) && ReferenceEquals(current, voice))
-                    {
-                        voice.Player.Stop();
-                        RemoveVoice(voice.Request.VoiceId);
-                    }
-                }
-            }
-        }
-        catch (OperationCanceledException) { }
-    }
-
-    private void WithVoice(AudioBackendRequest request, Action<Voice> action)
-    {
-        lock (_gate)
-            if (_voices.TryGetValue(request.VoiceId, out var voice) && voice.Request.Generation == request.Generation) action(voice);
-    }
-
-    private void Ended(Voice voice)
-    {
-        _terminalEvents.Writer.TryWrite((voice, AudioBackendEventKind.Ended, null));
-    }
-
-    private void Failed(Voice voice, string message)
-    {
-        _terminalEvents.Writer.TryWrite((voice, AudioBackendEventKind.Failed, message));
-    }
-
-    private async Task DrainTerminalEventsAsync()
-    {
-        // LibVLC callbacks must not Stop/Dispose a player or wait for our gate:
-        // player disposal can itself wait for the native callback to return.
-        await foreach (var item in _terminalEvents.Reader.ReadAllAsync().ConfigureAwait(false))
-        {
-            lock (_gate)
-            {
-                if (_disposed || !_voices.TryGetValue(item.Voice.Request.VoiceId, out var current) ||
-                    !ReferenceEquals(current, item.Voice)) continue;
-                RemoveVoice(item.Voice.Request.VoiceId);
-            }
-            Raise(new(item.Kind, item.Voice.Request.TrackId, item.Voice.Request.VoiceId,
-                item.Voice.Request.Generation, item.Message));
-        }
-    }
-
-    private void RemoveVoice(string voiceId)
-    {
-        if (_voices.Remove(voiceId, out var voice)) voice.Dispose();
-    }
-
-    private void ReapplySEffects(Voice voice)
-    {
-        using var equalizer = new Equalizer();
-        var state = new LibVlcAudioSEffectState(Enumerable.Range(0, (int)equalizer.BandCount).Select(index => equalizer.BandFrequency((uint)index)).ToArray());
-        foreach (var effect in voice.Effects.Values)
-            if (_effects.TryGet(effect.Id, out var processor)) processor.Apply(effect.Parameters, state);
-        voice.EffectGain = state.Gain;
-        var bandGains = Enumerable.Range(0, state.EqualizerBandFrequencies.Count)
-            .Select(state.BandGain)
-            .ToArray();
-        if (state.HasEqualizerAdjustment)
-        {
-            if (!voice.EqualizerApplied || voice.EqualizerBandGains?.SequenceEqual(bandGains) != true)
-            {
-                for (var index = 0; index < bandGains.Length; index++) equalizer.SetAmp(bandGains[index], (uint)index);
-                if (voice.Player.SetEqualizer(equalizer))
-                {
-                    voice.EqualizerApplied = true;
-                    voice.EqualizerBandGains = bandGains;
-                }
-            }
-        }
-        else if (voice.EqualizerApplied && voice.Player.UnsetEqualizer())
-        {
-            voice.EqualizerApplied = false;
-            voice.EqualizerBandGains = null;
-        }
-        SetVolume(voice);
-    }
-
-    private static float CurrentGain(Voice voice) => voice.BaseGain * voice.FadeGain * voice.EffectGain;
-    private static int ToVolume(float gain) => (int)Math.Round(Math.Clamp(gain, 0f, 1f) * 100);
-    private static void SetVolume(Voice voice) => voice.Player.Volume = ToVolume(CurrentGain(voice));
-    private void Raise(AudioBackendEvent @event) => EventReceived?.Invoke(@event);
-
-    private sealed class Voice(AudioBackendRequest request, MediaPlayer player) : IDisposable
-    {
-        public AudioBackendRequest Request { get; } = request;
-        public MediaPlayer Player { get; } = player;
-        public float BaseGain { get; set; }
-        public float FadeGain { get; set; } = 1;
-        public float EffectGain { get; set; } = 1;
-        public bool EqualizerApplied { get; set; }
-        public float[]? EqualizerBandGains { get; set; }
-        public Dictionary<string, ActiveSEffect> Effects { get; } = new(StringComparer.Ordinal);
-        private CancellationTokenSource FadeCancellation { get; set; } = new();
-        public CancellationToken BeginFade()
-        {
-            FadeCancellation.Cancel();
-            FadeCancellation.Dispose();
-            FadeCancellation = new CancellationTokenSource();
-            return FadeCancellation.Token;
-        }
-        public void Dispose()
-        {
-            FadeCancellation.Cancel();
-            FadeCancellation.Dispose();
-            Player.Dispose();
-        }
-    }
-
-    private sealed record ActiveSEffect(string Id, System.Text.Json.JsonElement Parameters);
-    private sealed record PendingLoad(long Generation, CancellationTokenSource Cancellation);
-}
diff --git a/src/Infrastructure/GalNet.Media.LibVlc/LibVlcAudioSEffects.cs b/src/Infrastructure/GalNet.Media.LibVlc/LibVlcAudioSEffects.cs
deleted file mode 100644
index c5b7d281..00000000
--- a/src/Infrastructure/GalNet.Media.LibVlc/LibVlcAudioSEffects.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-using System.Text.Json;
-using GalNet.Core.Audio;
-
-namespace GalNet.Media.LibVlc;
-
-/// <summary>Platform processor registered by a LibVLC audio host for one stable SEffect ID.</summary>
-public interface IAudioSEffectProcessor
-{
-    SEffectDefinition Definition { get; }
-    void Apply(JsonElement parameters, LibVlcAudioSEffectState state);
-}
-
-/// <summary>Immutable construction-time registry for the effect processors a host can execute.</summary>
-public sealed class LibVlcAudioSEffectRegistry
-{
-    private readonly IReadOnlyDictionary<string, IAudioSEffectProcessor> _byId;
-
-    public LibVlcAudioSEffectRegistry(IEnumerable<IAudioSEffectProcessor> processors)
-    {
-        _byId = processors.ToDictionary(processor => processor.Definition.Id, StringComparer.OrdinalIgnoreCase);
-        Catalog = new SEffectCatalog(_byId.Values.Select(processor => processor.Definition));
-    }
-
-    public ISEffectCatalog Catalog { get; }
-    public static IReadOnlyList<IAudioSEffectProcessor> DefaultProcessors { get; } = [new GainSEffectProcessor(), new LowPassSEffectProcessor(), new HighPassSEffectProcessor()];
-    public bool TryGet(string id, out IAudioSEffectProcessor processor) => _byId.TryGetValue(id, out processor!);
-}
-
-/// <summary>Aggregates output-gain and LibVLC equalizer contributions from active track effects.</summary>
-public sealed class LibVlcAudioSEffectState(IReadOnlyList<float> equalizerBandFrequencies)
-{
-    private readonly float[] _bandGains = new float[equalizerBandFrequencies.Count];
-
-    public IReadOnlyList<float> EqualizerBandFrequencies { get; } = equalizerBandFrequencies;
-    public float Gain { get; private set; } = 1;
-    public bool HasEqualizerAdjustment => _bandGains.Any(gain => MathF.Abs(gain) > .001f);
-    public float BandGain(int index) => _bandGains[index];
-
-    public void MultiplyGain(float gain) => Gain *= Math.Clamp(gain, 0, 1);
-    public void AttenuateAbove(float cutoffHz, float attenuationDb) => Attenuate(cutoffHz, attenuationDb, above: true);
-    public void AttenuateBelow(float cutoffHz, float attenuationDb) => Attenuate(cutoffHz, attenuationDb, above: false);
-
-    private void Attenuate(float cutoffHz, float attenuationDb, bool above)
-    {
-        for (var index = 0; index < EqualizerBandFrequencies.Count; index++)
-        {
-            var frequency = EqualizerBandFrequencies[index];
-            if (frequency <= 0 || above && frequency <= cutoffHz || !above && frequency >= cutoffHz) continue;
-            var octaves = above ? MathF.Log2(frequency / cutoffHz) : MathF.Log2(cutoffHz / frequency);
-            _bandGains[index] = Math.Clamp(_bandGains[index] + attenuationDb * Math.Clamp(octaves, 0, 1), -20, 20);
-        }
-    }
-}
-
-public sealed class GainSEffectProcessor : IAudioSEffectProcessor
-{
-    public SEffectDefinition Definition { get; } = SEffectCatalog.Builtins.Definitions.Single(value => value.Id == "seffect.gain");
-    public void Apply(JsonElement parameters, LibVlcAudioSEffectState state) => state.MultiplyGain(Value(parameters, "gain", 1));
-    internal static float Value(JsonElement parameters, string name, float fallback) => parameters.TryGetProperty(name, out var value) && value.TryGetSingle(out var result) ? result : fallback;
-}
-
-public sealed class LowPassSEffectProcessor : IAudioSEffectProcessor
-{
-    public SEffectDefinition Definition { get; } = SEffectCatalog.Builtins.Definitions.Single(value => value.Id == "seffect.lowPass");
-    public void Apply(JsonElement parameters, LibVlcAudioSEffectState state) => state.AttenuateAbove(GainSEffectProcessor.Value(parameters, "cutoffHz", 20_000), GainSEffectProcessor.Value(parameters, "attenuationDb", -20));
-}
-
-public sealed class HighPassSEffectProcessor : IAudioSEffectProcessor
-{
-    public SEffectDefinition Definition { get; } = SEffectCatalog.Builtins.Definitions.Single(value => value.Id == "seffect.highPass");
-    public void Apply(JsonElement parameters, LibVlcAudioSEffectState state) => state.AttenuateBelow(GainSEffectProcessor.Value(parameters, "cutoffHz", 20), GainSEffectProcessor.Value(parameters, "attenuationDb", -20));
-}
diff --git a/src/Infrastructure/GalNet.Media.LibVlc/LibVlcRuntime.cs b/src/Infrastructure/GalNet.Media.LibVlc/LibVlcRuntime.cs
index a85d879d..94d87d15 100644
--- a/src/Infrastructure/GalNet.Media.LibVlc/LibVlcRuntime.cs
+++ b/src/Infrastructure/GalNet.Media.LibVlc/LibVlcRuntime.cs
@@ -8,12 +8,17 @@ public sealed class LibVlcRuntime : IDisposable
     public LibVLC? Instance { get; }
     public string? InitializationError { get; }
 
-    public LibVlcRuntime()
+    /// <param name="create">Optional platform initialization and factory. The runtime owns the returned instance.</param>
+    public LibVlcRuntime(Func<LibVLC>? create = null)
     {
         try
         {
-            LibVLCSharp.Shared.Core.Initialize();
-            Instance = new LibVLC("--no-video-title-show", "--avcodec-hw=none");
+            if (create is null)
+            {
+                LibVLCSharp.Shared.Core.Initialize();
+                Instance = new LibVLC("--no-video-title-show", "--avcodec-hw=none");
+            }
+            else Instance = create() ?? throw new InvalidOperationException("The LibVLC factory returned null.");
         }
         catch (Exception exception)
         {
diff --git a/src/Infrastructure/GalNet.Media.LibVlc/packages.lock.WindowsReadyToRun.json b/src/Infrastructure/GalNet.Media.LibVlc/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..9b0a553f
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.LibVlc/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,37 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "LibVLCSharp": {
+        "type": "Direct",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Infrastructure/GalNet.Media.LibVlc/packages.lock.json b/src/Infrastructure/GalNet.Media.LibVlc/packages.lock.json
index 58c89792..2acfac8f 100644
--- a/src/Infrastructure/GalNet.Media.LibVlc/packages.lock.json
+++ b/src/Infrastructure/GalNet.Media.LibVlc/packages.lock.json
@@ -9,6 +9,13 @@
         "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
       },
       "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
         "type": "Project",
         "dependencies": {
           "GalNet.Core": "[1.0.0, )"
@@ -20,6 +27,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       }
diff --git a/src/Infrastructure/GalNet.Media.Miniaudio/GalNet.Media.Miniaudio.csproj b/src/Infrastructure/GalNet.Media.Miniaudio/GalNet.Media.Miniaudio.csproj
new file mode 100644
index 00000000..56bea8a9
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/GalNet.Media.Miniaudio.csproj
@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DefineConstants Condition="'$(GalNetMiniaudioStaticLink)' == 'true'">$(DefineConstants);GALNET_MINIAUDIO_STATIC</DefineConstants>
+    <GalNetMiniaudioRid Condition="'$(RuntimeIdentifier)' != ''">$(RuntimeIdentifier)</GalNetMiniaudioRid>
+    <GalNetMiniaudioRid Condition="'$(GalNetMiniaudioRid)' == ''">$(NETCoreSdkRuntimeIdentifier)</GalNetMiniaudioRid>
+    <GalNetBuildMiniaudio Condition="'$(GalNetBuildMiniaudio)' == '' And '$(GalNetMiniaudioNativePath)' == '' And $([MSBuild]::IsOSPlatform('Windows')) And ('$(GalNetMiniaudioRid)' == 'win-x64' Or '$(GalNetMiniaudioRid)' == 'win-arm64')">true</GalNetBuildMiniaudio>
+    <GalNetMiniaudioArchitecture Condition="'$(GalNetMiniaudioRid)' == 'win-x64'">x64</GalNetMiniaudioArchitecture>
+    <GalNetMiniaudioArchitecture Condition="'$(GalNetMiniaudioRid)' == 'win-arm64'">arm64</GalNetMiniaudioArchitecture>
+    <GalNetMiniaudioNativePath Condition="'$(GalNetMiniaudioNativePath)' == '' And '$(GalNetBuildMiniaudio)' == 'true'">$(MSBuildProjectDirectory)/obj/native/$(GalNetMiniaudioRid)/galnet_miniaudio.dll</GalNetMiniaudioNativePath>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" />
+    <ProjectReference Include="../../Shared/GalNet.Core/GalNet.Core.csproj" />
+    <ProjectReference Include="../GalNet.Media.Audio/GalNet.Media.Audio.csproj" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(GalNetMiniaudioNativePath)' != '' And '$(GalNetMiniaudioStaticLink)' != 'true'">
+    <Content Include="$(GalNetMiniaudioNativePath)" Link="$([System.IO.Path]::GetFileName('$(GalNetMiniaudioNativePath)'))" CopyToOutputDirectory="PreserveNewest" CopyToPublishDirectory="PreserveNewest" />
+  </ItemGroup>
+  <Target Name="BuildMiniaudio" BeforeTargets="PrepareForBuild" Condition="'$(GalNetBuildMiniaudio)' == 'true'" Inputs="native/miniaudio.h;native/stb_vorbis.c;native/galnet_miniaudio.c;native/build.ps1" Outputs="$(GalNetMiniaudioNativePath)">
+    <Error Condition="'$(GalNetMiniaudioArchitecture)' == ''" Text="The automatic miniaudio build supports win-x64/win-arm64. Supply GalNetMiniaudioNativePath for other targets." />
+    <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(MSBuildProjectDirectory)/native/build.ps1&quot; -OutputDirectory &quot;$([System.IO.Path]::GetDirectoryName('$(GalNetMiniaudioNativePath)'))&quot; -Architecture $(GalNetMiniaudioArchitecture)" />
+  </Target>
+</Project>
diff --git a/src/Infrastructure/GalNet.Media.Miniaudio/MiniaudioAudioPlaybackHost.cs b/src/Infrastructure/GalNet.Media.Miniaudio/MiniaudioAudioPlaybackHost.cs
new file mode 100644
index 00000000..d05d7e1d
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/MiniaudioAudioPlaybackHost.cs
@@ -0,0 +1,157 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using GalNet.Core.Assets;
+using GalNet.Media.Audio;
+
+namespace GalNet.Media.Miniaudio;
+
+public sealed class MiniaudioAudioPlaybackHost(IAssetFileMaterializer files)
+    : PcmAudioPlaybackHost(files, path => new MiniaudioDecoder(path), new MiniaudioOutput());
+
+public sealed unsafe class MiniaudioDecoder : IAudioPcmDecoder
+{
+    private nint _decoder;
+    public double DurationSeconds { get; }
+    public MiniaudioDecoder(string path)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(path);
+        if (path.Contains('\0')) throw new ArgumentException("Audio paths cannot contain a null character.", nameof(path));
+        Native.EnsureCompatible();
+        _decoder = Native.gn_decoder_create(path);
+        if (_decoder == 0) throw new InvalidDataException($"miniaudio could not decode '{Path.GetFileName(path)}' (supported: WAV, MP3, Ogg Vorbis, FLAC).");
+        DurationSeconds = Native.gn_decoder_duration(_decoder);
+    }
+    public int Read(Span<float> samples)
+    {
+        ObjectDisposedException.ThrowIf(_decoder == 0, this);
+        fixed (float* output = samples)
+        {
+            var frames = Native.gn_decoder_read(_decoder, output, (uint)(samples.Length / 2));
+            if (frames < 0) throw new InvalidDataException("miniaudio PCM decoding failed.");
+            return frames * 2;
+        }
+    }
+    public void Dispose() { if (_decoder != 0) { Native.gn_decoder_destroy(_decoder); _decoder = 0; } }
+}
+
+public sealed unsafe class MiniaudioOutput : IAudioOutput, IAudioOutputLifecycle
+{
+    private readonly object _gate = new();
+    private nint _device;
+    private GCHandle _context;
+    private bool _disposed;
+    public void Start(AudioRenderCallback render)
+    {
+        ArgumentNullException.ThrowIfNull(render);
+        lock (_gate)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            if (_context.IsAllocated) throw new InvalidOperationException("The audio output has already been started.");
+            Native.EnsureCompatible();
+            _context = GCHandle.Alloc(render);
+            try
+            {
+                OpenDevice();
+            }
+            catch { Release(); throw; }
+        }
+    }
+
+    public void SuspendOutput()
+    {
+        lock (_gate)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            if (!_context.IsAllocated) throw new InvalidOperationException("The audio output has not been started.");
+            // Release the endpoint while retaining the callback and the host's PCM/DSP state.
+            CloseDevice();
+        }
+    }
+
+    public void ResumeOutput()
+    {
+        lock (_gate)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            if (!_context.IsAllocated) throw new InvalidOperationException("The audio output has not been started.");
+            if (_device == 0) OpenDevice(); // Resolve the current default endpoint after an interruption.
+        }
+    }
+
+    private void OpenDevice()
+    {
+        _device = Native.gn_device_create(&Render, GCHandle.ToIntPtr(_context));
+        if (_device == 0) throw new InvalidOperationException("miniaudio could not open the default audio device.");
+        if (Native.gn_device_start(_device) != 0)
+        {
+            CloseDevice();
+            throw new InvalidOperationException("miniaudio could not start the audio device.");
+        }
+    }
+
+    private void CloseDevice()
+    {
+        if (_device != 0) { Native.gn_device_destroy(_device); _device = 0; }
+    }
+
+    [UnmanagedCallersOnly(CallConvs = [typeof(CallConvCdecl)])]
+    private static void Render(nint context, float* samples, uint count)
+    {
+        var output = new Span<float>(samples, (int)count);
+        try { ((AudioRenderCallback)GCHandle.FromIntPtr(context).Target!)(output); }
+        catch (Exception) { output.Clear(); } // Never unwind through a native callback.
+    }
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            if (_disposed) return;
+            _disposed = true;
+            Release();
+        }
+    }
+    private void Release()
+    {
+        // Uninitializing the device waits for callbacks before the context can be freed.
+        CloseDevice();
+        if (_context.IsAllocated) _context.Free();
+    }
+}
+
+internal static unsafe partial class Native
+{
+#if GALNET_MINIAUDIO_STATIC
+    private const string Library = "__Internal";
+#else
+    private const string Library = "galnet_miniaudio";
+#endif
+    internal static void EnsureCompatible()
+    {
+        if (gn_abi_version() != 2) throw new InvalidOperationException("The miniaudio native library must use GalNet ABI 2. Rebuild and deploy it with the managed adapter.");
+    }
+
+    [LibraryImport(Library)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    private static partial int gn_abi_version();
+    [LibraryImport(Library)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial nint gn_device_create(delegate* unmanaged[Cdecl]<nint, float*, uint, void> render, nint context);
+    [LibraryImport(Library)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial int gn_device_start(nint device);
+    [LibraryImport(Library)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial void gn_device_destroy(nint device);
+    [LibraryImport(Library, StringMarshalling = StringMarshalling.Utf8)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial nint gn_decoder_create(string path);
+    [LibraryImport(Library)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial int gn_decoder_read(nint decoder, float* output, uint frames);
+    [LibraryImport(Library)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial double gn_decoder_duration(nint decoder);
+    [LibraryImport(Library)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    internal static partial void gn_decoder_destroy(nint decoder);
+}
diff --git a/src/Infrastructure/GalNet.Media.Miniaudio/native/CMakeLists.txt b/src/Infrastructure/GalNet.Media.Miniaudio/native/CMakeLists.txt
new file mode 100644
index 00000000..00d558b5
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/native/CMakeLists.txt
@@ -0,0 +1,36 @@
+cmake_minimum_required(VERSION 3.22)
+project(galnet_miniaudio LANGUAGES C)
+
+# Shared libraries for desktop/Android; a static archive for an iOS NativeReference.
+option(GALNET_MINIAUDIO_STATIC "Build for static linking (including iOS)" OFF)
+if(CMAKE_SYSTEM_NAME STREQUAL "iOS" AND NOT GALNET_MINIAUDIO_STATIC)
+    message(FATAL_ERROR "iOS requires -DGALNET_MINIAUDIO_STATIC=ON and a host NativeReference")
+endif()
+if(GALNET_MINIAUDIO_STATIC)
+    add_library(galnet_miniaudio STATIC galnet_miniaudio.c)
+else()
+    add_library(galnet_miniaudio SHARED galnet_miniaudio.c)
+endif()
+set_target_properties(galnet_miniaudio PROPERTIES
+    C_STANDARD 99
+    C_STANDARD_REQUIRED YES
+    C_VISIBILITY_PRESET hidden
+    POSITION_INDEPENDENT_CODE YES)
+
+# A missing real output must fail, rather than silently selecting the null device.
+target_compile_definitions(galnet_miniaudio PRIVATE MA_NO_NULL)
+if(MSVC)
+    set_property(TARGET galnet_miniaudio PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+elseif(APPLE)
+    target_link_libraries(galnet_miniaudio PRIVATE "-framework CoreFoundation" "-framework CoreAudio" "-framework AudioToolbox")
+elseif(ANDROID)
+    target_link_libraries(galnet_miniaudio PRIVATE log android OpenSLES m ${CMAKE_DL_LIBS})
+elseif(UNIX)
+    find_package(Threads REQUIRED)
+    target_link_libraries(galnet_miniaudio PRIVATE Threads::Threads m ${CMAKE_DL_LIBS})
+endif()
+
+install(TARGETS galnet_miniaudio
+    RUNTIME DESTINATION .
+    LIBRARY DESTINATION .
+    ARCHIVE DESTINATION .)
diff --git a/src/Infrastructure/GalNet.Media.Miniaudio/native/README.md b/src/Infrastructure/GalNet.Media.Miniaudio/native/README.md
new file mode 100644
index 00000000..081ea94e
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/native/README.md
@@ -0,0 +1,9 @@
+# Vendored miniaudio
+
+`miniaudio.h`: https://github.com/mackron/miniaudio/blob/0.11.23/miniaudio.h
+
+SHA256: `7e4f3f13c8fe66df2080ac3dd12a89193e3c2463cb7f067c798abd7331cd8ee6`.
+
+The upstream Public Domain / MIT No Attribution license is included at the end of the header. The wrapper is GalNet code. Windows builds use MSVC x64 with the static CRT; the generated DLL is copied transitively to output/publish. End users do not need a compiler. Only Windows x64 is currently supported by this adapter. Decoder support: WAV, MP3, Ogg Vorbis, FLAC. Unsupported formats fail explicitly.
+
+`stb_vorbis.c` comes from https://github.com/nothings/stb/blob/f0569113c93ad095470c54bf34a17b36646bbbb5/stb_vorbis.c (Public Domain / MIT license included in the source). SHA256: `4c7cb2ff1f7011e9d67950446b7eb9ca044f2e464d76bfbb0b84dd2e23e65636`.
diff --git a/src/Infrastructure/GalNet.Media.Miniaudio/native/build.ps1 b/src/Infrastructure/GalNet.Media.Miniaudio/native/build.ps1
new file mode 100644
index 00000000..5a4ac40a
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/native/build.ps1
@@ -0,0 +1,45 @@
+param(
+    [Parameter(Mandatory=$true)][string]$OutputDirectory,
+    [ValidateSet('x64', 'arm64')][string]$Architecture = 'x64'
+)
+$ErrorActionPreference = 'Stop'
+$vswhere = Join-Path ${env:ProgramFiles(x86)} 'Microsoft Visual Studio/Installer/vswhere.exe'
+$installations = @(& $vswhere -all -products '*' -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath)
+if (!$installations) { throw 'The Windows audio backend requires MSVC C++ build tools.' }
+# Side-by-side installations can have ARM64 tools only in an older toolset.
+$candidates = foreach ($installationRoot in $installations) {
+    $toolsRoot = Join-Path $installationRoot 'VC/Tools/MSVC'
+    foreach ($tools in Get-ChildItem -LiteralPath $toolsRoot -Directory -ErrorAction SilentlyContinue) {
+        if ($tools.Name -notmatch '^\d+(\.\d+){1,3}$') { continue }
+        $compiler = Join-Path $tools.FullName "bin/Hostx64/$Architecture/cl.exe"
+        $runtime = Join-Path $tools.FullName "lib/$Architecture/libcmt.lib"
+        $header = Join-Path $tools.FullName 'include/vcruntime.h'
+        if ((Test-Path -LiteralPath $compiler) -and (Test-Path -LiteralPath $runtime) -and (Test-Path -LiteralPath $header)) {
+            [pscustomobject]@{ Installation = $installationRoot; Version = [version]$tools.Name }
+        }
+    }
+}
+$toolset = $candidates | Sort-Object Version -Descending | Select-Object -First 1
+if (!$toolset) { throw "No complete MSVC $Architecture toolset was found. Install the matching C++ build tools, including static runtime libraries." }
+$vcvars = Join-Path $toolset.Installation 'VC/Auxiliary/Build/vcvarsall.bat'
+$toolsetVersion = $toolset.Version.ToString()
+Write-Host "Building miniaudio for Windows $Architecture with MSVC $toolsetVersion."
+$target = if ($Architecture -eq 'arm64') { 'x64_arm64' } else { 'x64' }
+New-Item -ItemType Directory -Force -Path $OutputDirectory | Out-Null
+$source = Join-Path $PSScriptRoot 'galnet_miniaudio.c'
+$dll = Join-Path $OutputDirectory 'galnet_miniaudio.dll'
+$obj = Join-Path $OutputDirectory 'galnet_miniaudio.obj'
+$lib = Join-Path $OutputDirectory 'galnet_miniaudio.lib'
+$job = Join-Path $OutputDirectory 'build.cmd'
+@"
+@echo off
+call "$vcvars" $target -vcvars_ver=$toolsetVersion >nul
+if errorlevel 1 exit /b %errorlevel%
+if not exist "%VCToolsInstallDir%lib\$Architecture\libcmt.lib" (
+  echo Missing MSVC $Architecture static runtime libraries. Install the matching C++ build tools. 1>&2
+  exit /b 1
+)
+cl /nologo /O2 /MT /DMA_NO_NULL /LD "$source" /Fo"$obj" /link /OUT:"$dll" /IMPLIB:"$lib"
+"@ | Set-Content -LiteralPath $job -Encoding ASCII
+& $env:ComSpec /d /c "call `"$job`""
+if ($LASTEXITCODE -ne 0) { throw "miniaudio native build failed: $LASTEXITCODE" }
diff --git a/src/Infrastructure/GalNet.Media.Miniaudio/native/galnet_miniaudio.c b/src/Infrastructure/GalNet.Media.Miniaudio/native/galnet_miniaudio.c
new file mode 100644
index 00000000..91c06b41
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/native/galnet_miniaudio.c
@@ -0,0 +1,99 @@
+/* Thin opaque C ABI. All decoder I/O is called by a background worker, never the device callback. */
+#define STB_VORBIS_HEADER_ONLY
+#include "stb_vorbis.c"
+#define MINIAUDIO_IMPLEMENTATION
+#include "miniaudio.h"
+#undef STB_VORBIS_HEADER_ONLY
+#include "stb_vorbis.c"
+
+#ifdef _WIN32
+#define GN_API __declspec(dllexport)
+#else
+#define GN_API __attribute__((visibility("default")))
+#endif
+
+/* ABI 2 uses UTF-8 paths and a context-bearing, AOT-safe render callback. */
+GN_API int gn_abi_version(void) { return 2; }
+typedef void (*gn_render)(void*, float*, unsigned);
+typedef struct { ma_device device; gn_render render; void* context; } gn_device;
+static void gn_callback(ma_device* device, void* output, const void* input, ma_uint32 frames)
+{
+    gn_device* owner = (gn_device*)device->pUserData;
+    owner->render(owner->context, (float*)output, frames * 2);
+    (void)input;
+}
+GN_API void* gn_device_create(gn_render render, void* context)
+{
+    gn_device* device = (gn_device*)calloc(1, sizeof(gn_device));
+    if (!device || !render) { free(device); return NULL; }
+    device->render = render;
+    device->context = context;
+    ma_device_config config = ma_device_config_init(ma_device_type_playback);
+    config.playback.format = ma_format_f32;
+    config.playback.channels = 2;
+    config.sampleRate = 48000;
+    config.periodSizeInFrames = 480;
+    config.dataCallback = gn_callback;
+    config.pUserData = device;
+    if (ma_device_init(NULL, &config, &device->device) != MA_SUCCESS) { free(device); return NULL; }
+    return device;
+}
+GN_API int gn_device_start(gn_device* device) { return ma_device_start(&device->device); }
+GN_API void gn_device_destroy(gn_device* device)
+{
+    if (!device) return;
+    ma_device_uninit(&device->device);
+    free(device);
+}
+typedef struct { ma_decoder decoder; double duration; } gn_decoder;
+GN_API void* gn_decoder_create(const char* path)
+{
+    gn_decoder* decoder = (gn_decoder*)calloc(1, sizeof(gn_decoder));
+    ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 2, 48000);
+    ma_result result;
+    FILE* file = NULL;
+    if (!decoder || !path) { free(decoder); return NULL; }
+#ifdef _WIN32
+    /* miniaudio's narrow Windows fopen uses the ANSI code page, not UTF-8. */
+    int count = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, path, -1, NULL, 0);
+    wchar_t* wide = count > 0 ? (wchar_t*)malloc((size_t)count * sizeof(wchar_t)) : NULL;
+    if (!wide) { free(decoder); return NULL; }
+    if (!MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, path, -1, wide, count)) { free(wide); free(decoder); return NULL; }
+    result = ma_decoder_init_file_w(wide, &config, &decoder->decoder);
+    if (result == MA_SUCCESS) file = _wfopen(wide, L"rb");
+    free(wide);
+#else
+    result = ma_decoder_init_file(path, &config, &decoder->decoder);
+    if (result == MA_SUCCESS) file = fopen(path, "rb");
+#endif
+    if (result != MA_SUCCESS) { free(decoder); return NULL; }
+    ma_uint64 length = 0;
+    if (ma_decoder_get_length_in_pcm_frames(&decoder->decoder, &length) == MA_SUCCESS) decoder->duration = (double)length / 48000;
+    /* miniaudio's callback-based Vorbis adapter cannot report length. Probe using a separate seekable file. */
+    if (decoder->duration == 0 && file) {
+        stb_vorbis* vorbis = stb_vorbis_open_file(file, 0, NULL, NULL);
+        if (vorbis) {
+            stb_vorbis_info info = stb_vorbis_get_info(vorbis);
+            if (info.sample_rate) decoder->duration = (double)stb_vorbis_stream_length_in_samples(vorbis) / info.sample_rate;
+            stb_vorbis_close(vorbis);
+        }
+    }
+    if (file) fclose(file);
+    return decoder;
+}
+GN_API int gn_decoder_read(gn_decoder* decoder, float* output, unsigned frames)
+{
+    ma_uint64 read = 0;
+    ma_result result = ma_decoder_read_pcm_frames(&decoder->decoder, output, frames, &read);
+    return result == MA_SUCCESS || result == MA_AT_END ? (int)read : -1;
+}
+GN_API double gn_decoder_duration(gn_decoder* decoder)
+{
+    return decoder->duration;
+}
+GN_API void gn_decoder_destroy(gn_decoder* decoder)
+{
+    if (!decoder) return;
+    ma_decoder_uninit(&decoder->decoder);
+    free(decoder);
+}
diff --git a/src/Infrastructure/GalNet.Media.Miniaudio/native/miniaudio.h b/src/Infrastructure/GalNet.Media.Miniaudio/native/miniaudio.h
new file mode 100644
index 00000000..1e4e2c65
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/native/miniaudio.h
@@ -0,0 +1,95649 @@
+/*
+Audio playback and capture library. Choice of public domain or MIT-0. See license statements at the end of this file.
+miniaudio - v0.11.23 - 2025-09-11
+
+David Reid - mackron@gmail.com
+
+Website:       https://miniaud.io
+Documentation: https://miniaud.io/docs
+GitHub:        https://github.com/mackron/miniaudio
+*/
+
+/*
+1. Introduction
+===============
+To use miniaudio, just include "miniaudio.h" like any other header and add "miniaudio.c" to your
+source tree. If you don't want to add it to your source tree you can compile and link to it like
+any other library. Note that ABI compatibility is not guaranteed between versions, even with bug
+fix releases, so take care if compiling as a shared object.
+
+miniaudio includes both low level and high level APIs. The low level API is good for those who want
+to do all of their mixing themselves and only require a light weight interface to the underlying
+audio device. The high level API is good for those who have complex mixing and effect requirements.
+
+In miniaudio, objects are transparent structures. Unlike many other libraries, there are no handles
+to opaque objects which means you need to allocate memory for objects yourself. In the examples
+presented in this documentation you will often see objects declared on the stack. You need to be
+careful when translating these examples to your own code so that you don't accidentally declare
+your objects on the stack and then cause them to become invalid once the function returns. In
+addition, you must ensure the memory address of your objects remain the same throughout their
+lifetime. You therefore cannot be making copies of your objects.
+
+A config/init pattern is used throughout the entire library. The idea is that you set up a config
+object and pass that into the initialization routine. The advantage to this system is that the
+config object can be initialized with logical defaults and new properties added to it without
+breaking the API. The config object can be allocated on the stack and does not need to be
+maintained after initialization of the corresponding object.
+
+
+1.1. Low Level API
+------------------
+The low level API gives you access to the raw audio data of an audio device. It supports playback,
+capture, full-duplex and loopback (WASAPI only). You can enumerate over devices to determine which
+physical device(s) you want to connect to.
+
+The low level API uses the concept of a "device" as the abstraction for physical devices. The idea
+is that you choose a physical device to emit or capture audio from, and then move data to/from the
+device when miniaudio tells you to. Data is delivered to and from devices asynchronously via a
+callback which you specify when initializing the device.
+
+When initializing the device you first need to configure it. The device configuration allows you to
+specify things like the format of the data delivered via the callback, the size of the internal
+buffer and the ID of the device you want to emit or capture audio from.
+
+Once you have the device configuration set up you can initialize the device. When initializing a
+device you need to allocate memory for the device object beforehand. This gives the application
+complete control over how the memory is allocated. In the example below we initialize a playback
+device on the stack, but you could allocate it on the heap if that suits your situation better.
+
+    ```c
+    void data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
+    {
+        // In playback mode copy data to pOutput. In capture mode read data from pInput. In full-duplex mode, both
+        // pOutput and pInput will be valid and you can move data from pInput into pOutput. Never process more than
+        // frameCount frames.
+    }
+
+    int main()
+    {
+        ma_device_config config = ma_device_config_init(ma_device_type_playback);
+        config.playback.format   = ma_format_f32;   // Set to ma_format_unknown to use the device's native format.
+        config.playback.channels = 2;               // Set to 0 to use the device's native channel count.
+        config.sampleRate        = 48000;           // Set to 0 to use the device's native sample rate.
+        config.dataCallback      = data_callback;   // This function will be called when miniaudio needs more data.
+        config.pUserData         = pMyCustomData;   // Can be accessed from the device object (device.pUserData).
+
+        ma_device device;
+        if (ma_device_init(NULL, &config, &device) != MA_SUCCESS) {
+            return -1;  // Failed to initialize the device.
+        }
+
+        ma_device_start(&device);     // The device is sleeping by default so you'll need to start it manually.
+
+        // Do something here. Probably your program's main loop.
+
+        ma_device_uninit(&device);
+        return 0;
+    }
+    ```
+
+In the example above, `data_callback()` is where audio data is written and read from the device.
+The idea is in playback mode you cause sound to be emitted from the speakers by writing audio data
+to the output buffer (`pOutput` in the example). In capture mode you read data from the input
+buffer (`pInput`) to extract sound captured by the microphone. The `frameCount` parameter tells you
+how many frames can be written to the output buffer and read from the input buffer. A "frame" is
+one sample for each channel. For example, in a stereo stream (2 channels), one frame is 2
+samples: one for the left, one for the right. The channel count is defined by the device config.
+The size in bytes of an individual sample is defined by the sample format which is also specified
+in the device config. Multi-channel audio data is always interleaved, which means the samples for
+each frame are stored next to each other in memory. For example, in a stereo stream the first pair
+of samples will be the left and right samples for the first frame, the second pair of samples will
+be the left and right samples for the second frame, etc.
+
+The configuration of the device is defined by the `ma_device_config` structure. The config object
+is always initialized with `ma_device_config_init()`. It's important to always initialize the
+config with this function as it initializes it with logical defaults and ensures your program
+doesn't break when new members are added to the `ma_device_config` structure. The example above
+uses a fairly simple and standard device configuration. The call to `ma_device_config_init()` takes
+a single parameter, which is whether or not the device is a playback, capture, duplex or loopback
+device (loopback devices are not supported on all backends). The `config.playback.format` member
+sets the sample format which can be one of the following (all formats are native-endian):
+
+    +---------------+----------------------------------------+---------------------------+
+    | Symbol        | Description                            | Range                     |
+    +---------------+----------------------------------------+---------------------------+
+    | ma_format_f32 | 32-bit floating point                  | [-1, 1]                   |
+    | ma_format_s16 | 16-bit signed integer                  | [-32768, 32767]           |
+    | ma_format_s24 | 24-bit signed integer (tightly packed) | [-8388608, 8388607]       |
+    | ma_format_s32 | 32-bit signed integer                  | [-2147483648, 2147483647] |
+    | ma_format_u8  | 8-bit unsigned integer                 | [0, 255]                  |
+    +---------------+----------------------------------------+---------------------------+
+
+The `config.playback.channels` member sets the number of channels to use with the device. The
+channel count cannot exceed MA_MAX_CHANNELS. The `config.sampleRate` member sets the sample rate
+(which must be the same for both playback and capture in full-duplex configurations). This is
+usually set to 44100 or 48000, but can be set to anything. It's recommended to keep this between
+8000 and 384000, however.
+
+Note that leaving the format, channel count and/or sample rate at their default values will result
+in the internal device's native configuration being used which is useful if you want to avoid the
+overhead of miniaudio's automatic data conversion.
+
+In addition to the sample format, channel count and sample rate, the data callback and user data
+pointer are also set via the config. The user data pointer is not passed into the callback as a
+parameter, but is instead set to the `pUserData` member of `ma_device` which you can access
+directly since all miniaudio structures are transparent.
+
+Initializing the device is done with `ma_device_init()`. This will return a result code telling you
+what went wrong, if anything. On success it will return `MA_SUCCESS`. After initialization is
+complete the device will be in a stopped state. To start it, use `ma_device_start()`.
+Uninitializing the device will stop it, which is what the example above does, but you can also stop
+the device with `ma_device_stop()`. To resume the device simply call `ma_device_start()` again.
+Note that it's important to never stop or start the device from inside the callback. This will
+result in a deadlock. Instead you set a variable or signal an event indicating that the device
+needs to stop and handle it in a different thread. The following APIs must never be called inside
+the callback:
+
+    ```c
+    ma_device_init()
+    ma_device_init_ex()
+    ma_device_uninit()
+    ma_device_start()
+    ma_device_stop()
+    ```
+
+You must never try uninitializing and reinitializing a device inside the callback. You must also
+never try to stop and start it from inside the callback. There are a few other things you shouldn't
+do in the callback depending on your requirements, however this isn't so much a thread-safety
+thing, but rather a real-time processing thing which is beyond the scope of this introduction.
+
+The example above demonstrates the initialization of a playback device, but it works exactly the
+same for capture. All you need to do is change the device type from `ma_device_type_playback` to
+`ma_device_type_capture` when setting up the config, like so:
+
+    ```c
+    ma_device_config config = ma_device_config_init(ma_device_type_capture);
+    config.capture.format   = MY_FORMAT;
+    config.capture.channels = MY_CHANNEL_COUNT;
+    ```
+
+In the data callback you just read from the input buffer (`pInput` in the example above) and leave
+the output buffer alone (it will be set to NULL when the device type is set to
+`ma_device_type_capture`).
+
+These are the available device types and how you should handle the buffers in the callback:
+
+    +-------------------------+--------------------------------------------------------+
+    | Device Type             | Callback Behavior                                      |
+    +-------------------------+--------------------------------------------------------+
+    | ma_device_type_playback | Write to output buffer, leave input buffer untouched.  |
+    | ma_device_type_capture  | Read from input buffer, leave output buffer untouched. |
+    | ma_device_type_duplex   | Read from input buffer, write to output buffer.        |
+    | ma_device_type_loopback | Read from input buffer, leave output buffer untouched. |
+    +-------------------------+--------------------------------------------------------+
+
+You will notice in the example above that the sample format and channel count is specified
+separately for playback and capture. This is to support different data formats between the playback
+and capture devices in a full-duplex system. An example may be that you want to capture audio data
+as a monaural stream (one channel), but output sound to a stereo speaker system. Note that if you
+use different formats between playback and capture in a full-duplex configuration you will need to
+convert the data yourself. There are functions available to help you do this which will be
+explained later.
+
+The example above did not specify a physical device to connect to which means it will use the
+operating system's default device. If you have multiple physical devices connected and you want to
+use a specific one you will need to specify the device ID in the configuration, like so:
+
+    ```c
+    config.playback.pDeviceID = pMyPlaybackDeviceID;    // Only if requesting a playback or duplex device.
+    config.capture.pDeviceID = pMyCaptureDeviceID;      // Only if requesting a capture, duplex or loopback device.
+    ```
+
+To retrieve the device ID you will need to perform device enumeration, however this requires the
+use of a new concept called the "context". Conceptually speaking the context sits above the device.
+There is one context to many devices. The purpose of the context is to represent the backend at a
+more global level and to perform operations outside the scope of an individual device. Mainly it is
+used for performing run-time linking against backend libraries, initializing backends and
+enumerating devices. The example below shows how to enumerate devices.
+
+    ```c
+    ma_context context;
+    if (ma_context_init(NULL, 0, NULL, &context) != MA_SUCCESS) {
+        // Error.
+    }
+
+    ma_device_info* pPlaybackInfos;
+    ma_uint32 playbackCount;
+    ma_device_info* pCaptureInfos;
+    ma_uint32 captureCount;
+    if (ma_context_get_devices(&context, &pPlaybackInfos, &playbackCount, &pCaptureInfos, &captureCount) != MA_SUCCESS) {
+        // Error.
+    }
+
+    // Loop over each device info and do something with it. Here we just print the name with their index. You may want
+    // to give the user the opportunity to choose which device they'd prefer.
+    for (ma_uint32 iDevice = 0; iDevice < playbackCount; iDevice += 1) {
+        printf("%d - %s\n", iDevice, pPlaybackInfos[iDevice].name);
+    }
+
+    ma_device_config config = ma_device_config_init(ma_device_type_playback);
+    config.playback.pDeviceID = &pPlaybackInfos[chosenPlaybackDeviceIndex].id;
+    config.playback.format    = MY_FORMAT;
+    config.playback.channels  = MY_CHANNEL_COUNT;
+    config.sampleRate         = MY_SAMPLE_RATE;
+    config.dataCallback       = data_callback;
+    config.pUserData          = pMyCustomData;
+
+    ma_device device;
+    if (ma_device_init(&context, &config, &device) != MA_SUCCESS) {
+        // Error
+    }
+
+    ...
+
+    ma_device_uninit(&device);
+    ma_context_uninit(&context);
+    ```
+
+The first thing we do in this example is initialize a `ma_context` object with `ma_context_init()`.
+The first parameter is a pointer to a list of `ma_backend` values which are used to override the
+default backend priorities. When this is NULL, as in this example, miniaudio's default priorities
+are used. The second parameter is the number of backends listed in the array pointed to by the
+first parameter. The third parameter is a pointer to a `ma_context_config` object which can be
+NULL, in which case defaults are used. The context configuration is used for setting the logging
+callback, custom memory allocation callbacks, user-defined data and some backend-specific
+configurations.
+
+Once the context has been initialized you can enumerate devices. In the example above we use the
+simpler `ma_context_get_devices()`, however you can also use a callback for handling devices by
+using `ma_context_enumerate_devices()`. When using `ma_context_get_devices()` you provide a pointer
+to a pointer that will, upon output, be set to a pointer to a buffer containing a list of
+`ma_device_info` structures. You also provide a pointer to an unsigned integer that will receive
+the number of items in the returned buffer. Do not free the returned buffers as their memory is
+managed internally by miniaudio.
+
+The `ma_device_info` structure contains an `id` member which is the ID you pass to the device
+config. It also contains the name of the device which is useful for presenting a list of devices
+to the user via the UI.
+
+When creating your own context you will want to pass it to `ma_device_init()` when initializing the
+device. Passing in NULL, like we do in the first example, will result in miniaudio creating the
+context for you, which you don't want to do since you've already created a context. Note that
+internally the context is only tracked by it's pointer which means you must not change the location
+of the `ma_context` object. If this is an issue, consider using `malloc()` to allocate memory for
+the context.
+
+
+1.2. High Level API
+-------------------
+The high level API consists of three main parts:
+
+  * Resource management for loading and streaming sounds.
+  * A node graph for advanced mixing and effect processing.
+  * A high level "engine" that wraps around the resource manager and node graph.
+
+The resource manager (`ma_resource_manager`) is used for loading sounds. It supports loading sounds
+fully into memory and also streaming. It will also deal with reference counting for you which
+avoids the same sound being loaded multiple times.
+
+The node graph is used for mixing and effect processing. The idea is that you connect a number of
+nodes into the graph by connecting each node's outputs to another node's inputs. Each node can
+implement its own effect. By chaining nodes together, advanced mixing and effect processing can
+be achieved.
+
+The engine encapsulates both the resource manager and the node graph to create a simple, easy to
+use high level API. The resource manager and node graph APIs are covered in more later sections of
+this manual.
+
+The code below shows how you can initialize an engine using its default configuration.
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+
+    result = ma_engine_init(NULL, &engine);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to initialize the engine.
+    }
+    ```
+
+This creates an engine instance which will initialize a device internally which you can access with
+`ma_engine_get_device()`. It will also initialize a resource manager for you which can be accessed
+with `ma_engine_get_resource_manager()`. The engine itself is a node graph (`ma_node_graph`) which
+means you can pass a pointer to the engine object into any of the `ma_node_graph` APIs (with a
+cast). Alternatively, you can use `ma_engine_get_node_graph()` instead of a cast.
+
+Note that all objects in miniaudio, including the `ma_engine` object in the example above, are
+transparent structures. There are no handles to opaque structures in miniaudio which means you need
+to be mindful of how you declare them. In the example above we are declaring it on the stack, but
+this will result in the struct being invalidated once the function encapsulating it returns. If
+allocating the engine on the heap is more appropriate, you can easily do so with a standard call
+to `malloc()` or whatever heap allocation routine you like:
+
+    ```c
+    ma_engine* pEngine = malloc(sizeof(*pEngine));
+    ```
+
+The `ma_engine` API uses the same config/init pattern used all throughout miniaudio. To configure
+an engine, you can fill out a `ma_engine_config` object and pass it into the first parameter of
+`ma_engine_init()`:
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+    ma_engine_config engineConfig;
+
+    engineConfig = ma_engine_config_init();
+    engineConfig.pResourceManager = &myCustomResourceManager;   // <-- Initialized as some earlier stage.
+
+    result = ma_engine_init(&engineConfig, &engine);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+    ```
+
+This creates an engine instance using a custom config. In this particular example it's showing how
+you can specify a custom resource manager rather than having the engine initialize one internally.
+This is particularly useful if you want to have multiple engine's share the same resource manager.
+
+The engine must be uninitialized with `ma_engine_uninit()` when it's no longer needed.
+
+By default the engine will be started, but nothing will be playing because no sounds have been
+initialized. The easiest but least flexible way of playing a sound is like so:
+
+    ```c
+    ma_engine_play_sound(&engine, "my_sound.wav", NULL);
+    ```
+
+This plays what miniaudio calls an "inline" sound. It plays the sound once, and then puts the
+internal sound up for recycling. The last parameter is used to specify which sound group the sound
+should be associated with which will be explained later. This particular way of playing a sound is
+simple, but lacks flexibility and features. A more flexible way of playing a sound is to first
+initialize a sound:
+
+    ```c
+    ma_result result;
+    ma_sound sound;
+
+    result = ma_sound_init_from_file(&engine, "my_sound.wav", 0, NULL, NULL, &sound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    ma_sound_start(&sound);
+    ```
+
+This returns a `ma_sound` object which represents a single instance of the specified sound file. If
+you want to play the same file multiple times simultaneously, you need to create one sound for each
+instance.
+
+Sounds should be uninitialized with `ma_sound_uninit()`.
+
+Sounds are not started by default. Start a sound with `ma_sound_start()` and stop it with
+`ma_sound_stop()`. When a sound is stopped, it is not rewound to the start. Use
+`ma_sound_seek_to_pcm_frame(&sound, 0)` to seek back to the start of a sound. By default, starting
+and stopping sounds happens immediately, but sometimes it might be convenient to schedule the sound
+to be started and/or stopped at a specific time. This can be done with the following functions:
+
+    ```c
+    ma_sound_set_start_time_in_pcm_frames()
+    ma_sound_set_start_time_in_milliseconds()
+    ma_sound_set_stop_time_in_pcm_frames()
+    ma_sound_set_stop_time_in_milliseconds()
+    ```
+
+The start/stop time needs to be specified based on the absolute timer which is controlled by the
+engine. The current global time in PCM frames can be retrieved with
+`ma_engine_get_time_in_pcm_frames()`. The engine's global time can be changed with
+`ma_engine_set_time_in_pcm_frames()` for synchronization purposes if required. Note that scheduling
+a start time still requires an explicit call to `ma_sound_start()` before anything will play:
+
+    ```c
+    ma_sound_set_start_time_in_pcm_frames(&sound, ma_engine_get_time_in_pcm_frames(&engine) + (ma_engine_get_sample_rate(&engine) * 2);
+    ma_sound_start(&sound);
+    ```
+
+The third parameter of `ma_sound_init_from_file()` is a set of flags that control how the sound be
+loaded and a few options on which features should be enabled for that sound. By default, the sound
+is synchronously loaded fully into memory straight from the file system without any kind of
+decoding. If you want to decode the sound before storing it in memory, you need to specify the
+`MA_SOUND_FLAG_DECODE` flag. This is useful if you want to incur the cost of decoding at an earlier
+stage, such as a loading stage. Without this option, decoding will happen dynamically at mixing
+time which might be too expensive on the audio thread.
+
+If you want to load the sound asynchronously, you can specify the `MA_SOUND_FLAG_ASYNC` flag. This
+will result in `ma_sound_init_from_file()` returning quickly, but the sound will not start playing
+until the sound has had some audio decoded.
+
+The fourth parameter is a pointer to sound group. A sound group is used as a mechanism to organise
+sounds into groups which have their own effect processing and volume control. An example is a game
+which might have separate groups for sfx, voice and music. Each of these groups have their own
+independent volume control. Use `ma_sound_group_init()` or `ma_sound_group_init_ex()` to initialize
+a sound group.
+
+Sounds and sound groups are nodes in the engine's node graph and can be plugged into any `ma_node`
+API. This makes it possible to connect sounds and sound groups to effect nodes to produce complex
+effect chains.
+
+A sound can have its volume changed with `ma_sound_set_volume()`. If you prefer decibel volume
+control you can use `ma_volume_db_to_linear()` to convert from decibel representation to linear.
+
+Panning and pitching is supported with `ma_sound_set_pan()` and `ma_sound_set_pitch()`. If you know
+a sound will never have its pitch changed with `ma_sound_set_pitch()` or via the doppler effect,
+you can specify the `MA_SOUND_FLAG_NO_PITCH` flag when initializing the sound for an optimization.
+
+By default, sounds and sound groups have spatialization enabled. If you don't ever want to
+spatialize your sounds, initialize the sound with the `MA_SOUND_FLAG_NO_SPATIALIZATION` flag. The
+spatialization model is fairly simple and is roughly on feature parity with OpenAL. HRTF and
+environmental occlusion are not currently supported, but planned for the future. The supported
+features include:
+
+  * Sound and listener positioning and orientation with cones
+  * Attenuation models: none, inverse, linear and exponential
+  * Doppler effect
+
+Sounds can be faded in and out with `ma_sound_set_fade_in_pcm_frames()`.
+
+To check if a sound is currently playing, you can use `ma_sound_is_playing()`. To check if a sound
+is at the end, use `ma_sound_at_end()`. Looping of a sound can be controlled with
+`ma_sound_set_looping()`. Use `ma_sound_is_looping()` to check whether or not the sound is looping.
+
+
+
+2. Building
+===========
+miniaudio should work cleanly out of the box without the need to download or install any
+dependencies. See below for platform-specific details.
+
+This library has been designed to be added directly to your source tree which is the preferred way
+of using it, but you can compile it as a normal library if that's your preference. Be careful if
+compiling as a shared object because miniaudio is not ABI compatible between any release, including
+bug fix releases. It's recommended you link statically.
+
+Note that GCC and Clang require `-msse2`, `-mavx2`, etc. for SIMD optimizations.
+
+If you get errors about undefined references to `__sync_val_compare_and_swap_8`, `__atomic_load_8`,
+etc. you need to link with `-latomic`.
+
+
+2.1. Windows
+------------
+The Windows build should compile cleanly on all popular compilers without the need to configure any
+include paths nor link to any libraries.
+
+The UWP build may require linking to mmdevapi.lib if you get errors about an unresolved external
+symbol for `ActivateAudioInterfaceAsync()`.
+
+
+2.2. macOS and iOS
+------------------
+The macOS build should compile cleanly without the need to download any dependencies nor link to
+any libraries or frameworks. The iOS build needs to be compiled as Objective-C and will need to
+link the relevant frameworks but should compile cleanly out of the box with Xcode. Compiling
+through the command line requires linking to `-lpthread` and `-lm`.
+
+Due to the way miniaudio links to frameworks at runtime, your application may not pass Apple's
+notarization process. To fix this there are two options. The first is to compile with
+`-DMA_NO_RUNTIME_LINKING` which in turn will require linking with
+`-framework CoreFoundation -framework CoreAudio -framework AudioToolbox`. If you get errors about
+AudioToolbox, try with `-framework AudioUnit` instead. You may get this when using older versions
+of iOS. Alternatively, if you would rather keep using runtime linking you can add the following to
+your entitlements.xcent file:
+
+    ```
+    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    ```
+
+See this discussion for more info: https://github.com/mackron/miniaudio/issues/203.
+
+
+2.3. Linux
+----------
+The Linux build only requires linking to `-ldl`, `-lpthread` and `-lm`. You do not need any
+development packages. You may need to link with `-latomic` if you're compiling for 32-bit ARM.
+
+
+2.4. BSD
+--------
+The BSD build only requires linking to `-lpthread` and `-lm`. NetBSD uses audio(4), OpenBSD uses
+sndio and FreeBSD uses OSS. You may need to link with `-latomic` if you're compiling for 32-bit
+ARM.
+
+
+2.5. Android
+------------
+AAudio is the highest priority backend on Android. This should work out of the box without needing
+any kind of compiler configuration. Support for AAudio starts with Android 8 which means older
+versions will fall back to OpenSL|ES which requires API level 16+.
+
+There have been reports that the OpenSL|ES backend fails to initialize on some Android based
+devices due to `dlopen()` failing to open "libOpenSLES.so". If this happens on your platform
+you'll need to disable run-time linking with `MA_NO_RUNTIME_LINKING` and link with -lOpenSLES.
+
+
+2.6. Emscripten
+---------------
+The Emscripten build emits Web Audio JavaScript directly and should compile cleanly out of the box.
+You cannot use `-std=c*` compiler flags, nor `-ansi`.
+
+You can enable the use of AudioWorklets by defining `MA_ENABLE_AUDIO_WORKLETS` and then compiling
+with the following options:
+
+    -sAUDIO_WORKLET=1 -sWASM_WORKERS=1 -sASYNCIFY
+
+An example for compiling with AudioWorklet support might look like this:
+
+    emcc program.c -o bin/program.html -DMA_ENABLE_AUDIO_WORKLETS -sAUDIO_WORKLET=1 -sWASM_WORKERS=1 -sASYNCIFY
+
+To run locally, you'll need to use emrun:
+
+    emrun bin/program.html
+
+
+
+2.7. Build Options
+------------------
+`#define` these options before including miniaudio.c, or pass them as compiler flags:
+
+    +----------------------------------+--------------------------------------------------------------------+
+    | Option                           | Description                                                        |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_WASAPI                     | Disables the WASAPI backend.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_DSOUND                     | Disables the DirectSound backend.                                  |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_WINMM                      | Disables the WinMM backend.                                        |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_ALSA                       | Disables the ALSA backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_PULSEAUDIO                 | Disables the PulseAudio backend.                                   |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_JACK                       | Disables the JACK backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_COREAUDIO                  | Disables the Core Audio backend.                                   |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_SNDIO                      | Disables the sndio backend.                                        |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_AUDIO4                     | Disables the audio(4) backend.                                     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_OSS                        | Disables the OSS backend.                                          |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_AAUDIO                     | Disables the AAudio backend.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_OPENSL                     | Disables the OpenSL|ES backend.                                    |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_WEBAUDIO                   | Disables the Web Audio backend.                                    |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_CUSTOM                     | Disables support for custom backends.                              |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_NULL                       | Disables the null backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_ONLY_SPECIFIC_BACKENDS | Disables all backends by default and requires `MA_ENABLE_*` to     |
+    |                                  | enable specific backends.                                          |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_WASAPI                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the WASAPI backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_DSOUND                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the DirectSound backend.                                    |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_WINMM                  | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the WinMM backend.                                          |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_ALSA                   | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the ALSA backend.                                           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_PULSEAUDIO             | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the PulseAudio backend.                                     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_JACK                   | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the JACK backend.                                           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_COREAUDIO              | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the Core Audio backend.                                     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_SNDIO                  | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the sndio backend.                                          |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_AUDIO4                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the audio(4) backend.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_OSS                    | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the OSS backend.                                            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_AAUDIO                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the AAudio backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_OPENSL                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the OpenSL|ES backend.                                      |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_WEBAUDIO               | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the Web Audio backend.                                      |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_CUSTOM                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable custom backends.                                            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_NULL                   | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the null backend.                                           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_DECODING                   | Disables decoding APIs.                                            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_ENCODING                   | Disables encoding APIs.                                            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_WAV                        | Disables the built-in WAV decoder and encoder.                     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_FLAC                       | Disables the built-in FLAC decoder.                                |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_MP3                        | Disables the built-in MP3 decoder.                                 |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_DEVICE_IO                  | Disables playback and recording. This will disable `ma_context`    |
+    |                                  | and `ma_device` APIs. This is useful if you only want to use       |
+    |                                  | miniaudio's data conversion and/or decoding APIs.                  |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_RESOURCE_MANAGER           | Disables the resource manager. When using the engine this will     |
+    |                                  | also disable the following functions:                              |
+    |                                  |                                                                    |
+    |                                  | ```                                                                |
+    |                                  | ma_sound_init_from_file()                                          |
+    |                                  | ma_sound_init_from_file_w()                                        |
+    |                                  | ma_sound_init_copy()                                               |
+    |                                  | ma_engine_play_sound_ex()                                          |
+    |                                  | ma_engine_play_sound()                                             |
+    |                                  | ```                                                                |
+    |                                  |                                                                    |
+    |                                  | The only way to initialize a `ma_sound` object is to initialize it |
+    |                                  | from a data source.                                                |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_NODE_GRAPH                 | Disables the node graph API. This will also disable the engine API |
+    |                                  | because it depends on the node graph.                              |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_ENGINE                     | Disables the engine API.                                           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_THREADING                  | Disables the `ma_thread`, `ma_mutex`, `ma_semaphore` and           |
+    |                                  | `ma_event` APIs. This option is useful if you only need to use     |
+    |                                  | miniaudio for data conversion, decoding and/or encoding. Some      |
+    |                                  | families of APIs require threading which means the following       |
+    |                                  | options must also be set:                                          |
+    |                                  |                                                                    |
+    |                                  |     ```                                                            |
+    |                                  |     MA_NO_DEVICE_IO                                                |
+    |                                  |     ```                                                            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_GENERATION                 | Disables generation APIs such a `ma_waveform` and `ma_noise`.      |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_SSE2                       | Disables SSE2 optimizations.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_AVX2                       | Disables AVX2 optimizations.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_NEON                       | Disables NEON optimizations.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_RUNTIME_LINKING            | Disables runtime linking. This is useful for passing Apple's       |
+    |                                  | notarization process. When enabling this, you may need to avoid    |
+    |                                  | using `-std=c89` or `-std=c99` on Linux builds or else you may end |
+    |                                  | up with compilation errors due to conflicts with `timespec` and    |
+    |                                  | `timeval` data types.                                              |
+    |                                  |                                                                    |
+    |                                  | You may need to enable this if your target platform does not allow |
+    |                                  | runtime linking via `dlopen()`.                                    |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_USE_STDINT                    | (Pass this in as a compiler flag. Do not `#define` this before     |
+    |                                  | miniaudio.c) Forces the use of stdint.h for sized types.           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_DEBUG_OUTPUT                  | Enable `printf()` output of debug logs (`MA_LOG_LEVEL_DEBUG`).     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_COINIT_VALUE                  | Windows only. The value to pass to internal calls to               |
+    |                                  | `CoInitializeEx()`. Defaults to `COINIT_MULTITHREADED`.            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_FORCE_UWP                     | Windows only. Affects only the WASAPI backend. Will force the      |
+    |                                  | WASAPI backend to use the UWP code path instead of the regular     |
+    |                                  | desktop path. This is normally auto-detected and should rarely be  |
+    |                                  | needed to be used explicitly, but can be useful for debugging.     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ON_THREAD_ENTRY               | Defines some code that will be executed as soon as an internal     |
+    |                                  | miniaudio-managed thread is created. This will be the first thing  |
+    |                                  | to be executed by the thread entry point.                          |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ON_THREAD_EXIT                | Defines some code that will be executed from the entry point of an |
+    |                                  | internal miniaudio-managed thread upon exit. This will be the last |
+    |                                  | thing to be executed before the thread's entry point exits.        |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_THREAD_DEFAULT_STACK_SIZE     | If set, specifies the default stack size used by miniaudio-managed |
+    |                                  | threads.                                                           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_API                           | Controls how public APIs should be decorated. Default is `extern`. |
+    +----------------------------------+--------------------------------------------------------------------+
+
+
+3. Definitions
+==============
+This section defines common terms used throughout miniaudio. Unfortunately there is often ambiguity
+in the use of terms throughout the audio space, so this section is intended to clarify how miniaudio
+uses each term.
+
+3.1. Sample
+-----------
+A sample is a single unit of audio data. If the sample format is f32, then one sample is one 32-bit
+floating point number.
+
+3.2. Frame / PCM Frame
+----------------------
+A frame is a group of samples equal to the number of channels. For a stereo stream a frame is 2
+samples, a mono frame is 1 sample, a 5.1 surround sound frame is 6 samples, etc. The terms "frame"
+and "PCM frame" are the same thing in miniaudio. Note that this is different to a compressed frame.
+If ever miniaudio needs to refer to a compressed frame, such as a FLAC frame, it will always
+clarify what it's referring to with something like "FLAC frame".
+
+3.3. Channel
+------------
+A stream of monaural audio that is emitted from an individual speaker in a speaker system, or
+received from an individual microphone in a microphone system. A stereo stream has two channels (a
+left channel, and a right channel), a 5.1 surround sound system has 6 channels, etc. Some audio
+systems refer to a channel as a complex audio stream that's mixed with other channels to produce
+the final mix - this is completely different to miniaudio's use of the term "channel" and should
+not be confused.
+
+3.4. Sample Rate
+----------------
+The sample rate in miniaudio is always expressed in Hz, such as 44100, 48000, etc. It's the number
+of PCM frames that are processed per second.
+
+3.5. Formats
+------------
+Throughout miniaudio you will see references to different sample formats:
+
+    +---------------+----------------------------------------+---------------------------+
+    | Symbol        | Description                            | Range                     |
+    +---------------+----------------------------------------+---------------------------+
+    | ma_format_f32 | 32-bit floating point                  | [-1, 1]                   |
+    | ma_format_s16 | 16-bit signed integer                  | [-32768, 32767]           |
+    | ma_format_s24 | 24-bit signed integer (tightly packed) | [-8388608, 8388607]       |
+    | ma_format_s32 | 32-bit signed integer                  | [-2147483648, 2147483647] |
+    | ma_format_u8  | 8-bit unsigned integer                 | [0, 255]                  |
+    +---------------+----------------------------------------+---------------------------+
+
+All formats are native-endian.
+
+
+
+4. Data Sources
+===============
+The data source abstraction in miniaudio is used for retrieving audio data from some source. A few
+examples include `ma_decoder`, `ma_noise` and `ma_waveform`. You will need to be familiar with data
+sources in order to make sense of some of the higher level concepts in miniaudio.
+
+The `ma_data_source` API is a generic interface for reading from a data source. Any object that
+implements the data source interface can be plugged into any `ma_data_source` function.
+
+To read data from a data source:
+
+    ```c
+    ma_result result;
+    ma_uint64 framesRead;
+
+    result = ma_data_source_read_pcm_frames(pDataSource, pFramesOut, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to read data from the data source.
+    }
+    ```
+
+If you don't need the number of frames that were successfully read you can pass in `NULL` to the
+`pFramesRead` parameter. If this returns a value less than the number of frames requested it means
+the end of the file has been reached. `MA_AT_END` will be returned only when the number of frames
+read is 0.
+
+When calling any data source function, with the exception of `ma_data_source_init()` and
+`ma_data_source_uninit()`, you can pass in any object that implements a data source. For example,
+you could plug in a decoder like so:
+
+    ```c
+    ma_result result;
+    ma_uint64 framesRead;
+    ma_decoder decoder;   // <-- This would be initialized with `ma_decoder_init_*()`.
+
+    result = ma_data_source_read_pcm_frames(&decoder, pFramesOut, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to read data from the decoder.
+    }
+    ```
+
+If you want to seek forward you can pass in `NULL` to the `pFramesOut` parameter. Alternatively you
+can use `ma_data_source_seek_pcm_frames()`.
+
+To seek to a specific PCM frame:
+
+    ```c
+    result = ma_data_source_seek_to_pcm_frame(pDataSource, frameIndex);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to seek to PCM frame.
+    }
+    ```
+
+You can retrieve the total length of a data source in PCM frames, but note that some data sources
+may not have the notion of a length, such as noise and waveforms, and others may just not have a
+way of determining the length such as some decoders. To retrieve the length:
+
+    ```c
+    ma_uint64 length;
+
+    result = ma_data_source_get_length_in_pcm_frames(pDataSource, &length);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to retrieve the length.
+    }
+    ```
+
+Care should be taken when retrieving the length of a data source where the underlying decoder is
+pulling data from a data stream with an undefined length, such as internet radio or some kind of
+broadcast. If you do this, `ma_data_source_get_length_in_pcm_frames()` may never return.
+
+The current position of the cursor in PCM frames can also be retrieved:
+
+    ```c
+    ma_uint64 cursor;
+
+    result = ma_data_source_get_cursor_in_pcm_frames(pDataSource, &cursor);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to retrieve the cursor.
+    }
+    ```
+
+You will often need to know the data format that will be returned after reading. This can be
+retrieved like so:
+
+    ```c
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_channel channelMap[MA_MAX_CHANNELS];
+
+    result = ma_data_source_get_data_format(pDataSource, &format, &channels, &sampleRate, channelMap, MA_MAX_CHANNELS);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to retrieve data format.
+    }
+    ```
+
+If you do not need a specific data format property, just pass in NULL to the respective parameter.
+
+There may be cases where you want to implement something like a sound bank where you only want to
+read data within a certain range of the underlying data. To do this you can use a range:
+
+    ```c
+    result = ma_data_source_set_range_in_pcm_frames(pDataSource, rangeBegInFrames, rangeEndInFrames);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to set the range.
+    }
+    ```
+
+This is useful if you have a sound bank where many sounds are stored in the same file and you want
+the data source to only play one of those sub-sounds. Note that once the range is set, everything
+that takes a position, such as cursors and loop points, should always be relative to the start of
+the range. When the range is set, any previously defined loop point will be reset.
+
+Custom loop points can also be used with data sources. By default, data sources will loop after
+they reach the end of the data source, but if you need to loop at a specific location, you can do
+the following:
+
+    ```c
+    result = ma_data_source_set_loop_point_in_pcm_frames(pDataSource, loopBegInFrames, loopEndInFrames);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to set the loop point.
+    }
+    ```
+
+The loop point is relative to the current range.
+
+It's sometimes useful to chain data sources together so that a seamless transition can be achieved.
+To do this, you can use chaining:
+
+    ```c
+    ma_decoder decoder1;
+    ma_decoder decoder2;
+
+    // ... initialize decoders with ma_decoder_init_*() ...
+
+    result = ma_data_source_set_next(&decoder1, &decoder2);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to set the next data source.
+    }
+
+    result = ma_data_source_read_pcm_frames(&decoder1, pFramesOut, frameCount, pFramesRead);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to read from the decoder.
+    }
+    ```
+
+In the example above we're using decoders. When reading from a chain, you always want to read from
+the top level data source in the chain. In the example above, `decoder1` is the top level data
+source in the chain. When `decoder1` reaches the end, `decoder2` will start seamlessly without any
+gaps.
+
+Note that when looping is enabled, only the current data source will be looped. You can loop the
+entire chain by linking in a loop like so:
+
+    ```c
+    ma_data_source_set_next(&decoder1, &decoder2);  // decoder1 -> decoder2
+    ma_data_source_set_next(&decoder2, &decoder1);  // decoder2 -> decoder1 (loop back to the start).
+    ```
+
+Note that setting up chaining is not thread safe, so care needs to be taken if you're dynamically
+changing links while the audio thread is in the middle of reading.
+
+Do not use `ma_decoder_seek_to_pcm_frame()` as a means to reuse a data source to play multiple
+instances of the same sound simultaneously. This can be extremely inefficient depending on the type
+of data source and can result in glitching due to subtle changes to the state of internal filters.
+Instead, initialize multiple data sources for each instance.
+
+
+4.1. Custom Data Sources
+------------------------
+You can implement a custom data source by implementing the functions in `ma_data_source_vtable`.
+Your custom object must have `ma_data_source_base` as it's first member:
+
+    ```c
+    struct my_data_source
+    {
+        ma_data_source_base base;
+        ...
+    };
+    ```
+
+In your initialization routine, you need to call `ma_data_source_init()` in order to set up the
+base object (`ma_data_source_base`):
+
+    ```c
+    static ma_result my_data_source_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+    {
+        // Read data here. Output in the same format returned by my_data_source_get_data_format().
+    }
+
+    static ma_result my_data_source_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+    {
+        // Seek to a specific PCM frame here. Return MA_NOT_IMPLEMENTED if seeking is not supported.
+    }
+
+    static ma_result my_data_source_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+    {
+        // Return the format of the data here.
+    }
+
+    static ma_result my_data_source_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+    {
+        // Retrieve the current position of the cursor here. Return MA_NOT_IMPLEMENTED and set *pCursor to 0 if there is no notion of a cursor.
+    }
+
+    static ma_result my_data_source_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+    {
+        // Retrieve the length in PCM frames here. Return MA_NOT_IMPLEMENTED and set *pLength to 0 if there is no notion of a length or if the length is unknown.
+    }
+
+    static ma_data_source_vtable g_my_data_source_vtable =
+    {
+        my_data_source_read,
+        my_data_source_seek,
+        my_data_source_get_data_format,
+        my_data_source_get_cursor,
+        my_data_source_get_length
+    };
+
+    ma_result my_data_source_init(my_data_source* pMyDataSource)
+    {
+        ma_result result;
+        ma_data_source_config baseConfig;
+
+        baseConfig = ma_data_source_config_init();
+        baseConfig.vtable = &g_my_data_source_vtable;
+
+        result = ma_data_source_init(&baseConfig, &pMyDataSource->base);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        // ... do the initialization of your custom data source here ...
+
+        return MA_SUCCESS;
+    }
+
+    void my_data_source_uninit(my_data_source* pMyDataSource)
+    {
+        // ... do the uninitialization of your custom data source here ...
+
+        // You must uninitialize the base data source.
+        ma_data_source_uninit(&pMyDataSource->base);
+    }
+    ```
+
+Note that `ma_data_source_init()` and `ma_data_source_uninit()` are never called directly outside
+of the custom data source. It's up to the custom data source itself to call these within their own
+init/uninit functions.
+
+
+
+5. Engine
+=========
+The `ma_engine` API is a high level API for managing and mixing sounds and effect processing. The
+`ma_engine` object encapsulates a resource manager and a node graph, both of which will be
+explained in more detail later.
+
+Sounds are called `ma_sound` and are created from an engine. Sounds can be associated with a mixing
+group called `ma_sound_group` which are also created from the engine. Both `ma_sound` and
+`ma_sound_group` objects are nodes within the engine's node graph.
+
+When the engine is initialized, it will normally create a device internally. If you would rather
+manage the device yourself, you can do so and just pass a pointer to it via the engine config when
+you initialize the engine. You can also just use the engine without a device, which again can be
+configured via the engine config.
+
+The most basic way to initialize the engine is with a default config, like so:
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+
+    result = ma_engine_init(NULL, &engine);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to initialize the engine.
+    }
+    ```
+
+This will result in the engine initializing a playback device using the operating system's default
+device. This will be sufficient for many use cases, but if you need more flexibility you'll want to
+configure the engine with an engine config:
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+    ma_engine_config engineConfig;
+
+    engineConfig = ma_engine_config_init();
+    engineConfig.pDevice = &myDevice;
+
+    result = ma_engine_init(&engineConfig, &engine);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to initialize the engine.
+    }
+    ```
+
+In the example above we're passing in a pre-initialized device. Since the caller is the one in
+control of the device's data callback, it's their responsibility to manually call
+`ma_engine_read_pcm_frames()` from inside their data callback:
+
+    ```c
+    void playback_data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
+    {
+        ma_engine_read_pcm_frames(&g_Engine, pOutput, frameCount, NULL);
+    }
+    ```
+
+You can also use the engine independent of a device entirely:
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+    ma_engine_config engineConfig;
+
+    engineConfig = ma_engine_config_init();
+    engineConfig.noDevice   = MA_TRUE;
+    engineConfig.channels   = 2;        // Must be set when not using a device.
+    engineConfig.sampleRate = 48000;    // Must be set when not using a device.
+
+    result = ma_engine_init(&engineConfig, &engine);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to initialize the engine.
+    }
+    ```
+
+Note that when you're not using a device, you must set the channel count and sample rate in the
+config or else miniaudio won't know what to use (miniaudio will use the device to determine this
+normally). When not using a device, you need to use `ma_engine_read_pcm_frames()` to process audio
+data from the engine. This kind of setup is useful if you want to do something like offline
+processing or want to use a different audio system for playback such as SDL.
+
+When a sound is loaded it goes through a resource manager. By default the engine will initialize a
+resource manager internally, but you can also specify a pre-initialized resource manager:
+
+    ```c
+    ma_result result;
+    ma_engine engine1;
+    ma_engine engine2;
+    ma_engine_config engineConfig;
+
+    engineConfig = ma_engine_config_init();
+    engineConfig.pResourceManager = &myResourceManager;
+
+    ma_engine_init(&engineConfig, &engine1);
+    ma_engine_init(&engineConfig, &engine2);
+    ```
+
+In this example we are initializing two engines, both of which are sharing the same resource
+manager. This is especially useful for saving memory when loading the same file across multiple
+engines. If you were not to use a shared resource manager, each engine instance would use their own
+which would result in any sounds that are used between both engine's being loaded twice. By using
+a shared resource manager, it would only be loaded once. Using multiple engine's is useful when you
+need to output to multiple playback devices, such as in a local multiplayer game where each player
+is using their own set of headphones.
+
+By default an engine will be in a started state. To make it so the engine is not automatically
+started you can configure it as such:
+
+    ```c
+    engineConfig.noAutoStart = MA_TRUE;
+
+    // The engine will need to be started manually.
+    ma_engine_start(&engine);
+
+    // Later on the engine can be stopped with ma_engine_stop().
+    ma_engine_stop(&engine);
+    ```
+
+The concept of starting or stopping an engine is only relevant when using the engine with a
+device. Attempting to start or stop an engine that is not associated with a device will result in
+`MA_INVALID_OPERATION`.
+
+The master volume of the engine can be controlled with `ma_engine_set_volume()` which takes a
+linear scale, with 0 resulting in silence and anything above 1 resulting in amplification. If you
+prefer decibel based volume control, use `ma_volume_db_to_linear()` to convert from dB to linear.
+
+When a sound is spatialized, it is done so relative to a listener. An engine can be configured to
+have multiple listeners which can be configured via the config:
+
+    ```c
+    engineConfig.listenerCount = 2;
+    ```
+
+The maximum number of listeners is restricted to `MA_ENGINE_MAX_LISTENERS`. By default, when a
+sound is spatialized, it will be done so relative to the closest listener. You can also pin a sound
+to a specific listener which will be explained later. Listener's have a position, direction, cone,
+and velocity (for doppler effect). A listener is referenced by an index, the meaning of which is up
+to the caller (the index is 0 based and cannot go beyond the listener count, minus 1). The
+position, direction and velocity are all specified in absolute terms:
+
+    ```c
+    ma_engine_listener_set_position(&engine, listenerIndex, worldPosX, worldPosY, worldPosZ);
+    ```
+
+The direction of the listener represents it's forward vector. The listener's up vector can also be
+specified and defaults to +1 on the Y axis.
+
+    ```c
+    ma_engine_listener_set_direction(&engine, listenerIndex, forwardX, forwardY, forwardZ);
+    ma_engine_listener_set_world_up(&engine, listenerIndex, 0, 1, 0);
+    ```
+
+The engine supports directional attenuation. The listener can have a cone the controls how sound is
+attenuated based on the listener's direction. When a sound is between the inner and outer cones, it
+will be attenuated between 1 and the cone's outer gain:
+
+    ```c
+    ma_engine_listener_set_cone(&engine, listenerIndex, innerAngleInRadians, outerAngleInRadians, outerGain);
+    ```
+
+When a sound is inside the inner code, no directional attenuation is applied. When the sound is
+outside of the outer cone, the attenuation will be set to `outerGain` in the example above. When
+the sound is in between the inner and outer cones, the attenuation will be interpolated between 1
+and the outer gain.
+
+The engine's coordinate system follows the OpenGL coordinate system where positive X points right,
+positive Y points up and negative Z points forward.
+
+The simplest and least flexible way to play a sound is like so:
+
+    ```c
+    ma_engine_play_sound(&engine, "my_sound.wav", pGroup);
+    ```
+
+This is a "fire and forget" style of function. The engine will manage the `ma_sound` object
+internally. When the sound finishes playing, it'll be put up for recycling. For more flexibility
+you'll want to initialize a sound object:
+
+    ```c
+    ma_sound sound;
+
+    result = ma_sound_init_from_file(&engine, "my_sound.wav", flags, pGroup, NULL, &sound);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to load sound.
+    }
+    ```
+
+Sounds need to be uninitialized with `ma_sound_uninit()`.
+
+The example above loads a sound from a file. If the resource manager has been disabled you will not
+be able to use this function and instead you'll need to initialize a sound directly from a data
+source:
+
+    ```c
+    ma_sound sound;
+
+    result = ma_sound_init_from_data_source(&engine, &dataSource, flags, pGroup, &sound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+    ```
+
+Each `ma_sound` object represents a single instance of the sound. If you want to play the same
+sound multiple times at the same time, you need to initialize a separate `ma_sound` object.
+
+For the most flexibility when initializing sounds, use `ma_sound_init_ex()`. This uses miniaudio's
+standard config/init pattern:
+
+    ```c
+    ma_sound sound;
+    ma_sound_config soundConfig;
+
+    soundConfig = ma_sound_config_init();
+    soundConfig.pFilePath   = NULL; // Set this to load from a file path.
+    soundConfig.pDataSource = NULL; // Set this to initialize from an existing data source.
+    soundConfig.pInitialAttachment = &someNodeInTheNodeGraph;
+    soundConfig.initialAttachmentInputBusIndex = 0;
+    soundConfig.channelsIn  = 1;
+    soundConfig.channelsOut = 0;    // Set to 0 to use the engine's native channel count.
+
+    result = ma_sound_init_ex(&soundConfig, &sound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+    ```
+
+In the example above, the sound is being initialized without a file nor a data source. This is
+valid, in which case the sound acts as a node in the middle of the node graph. This means you can
+connect other sounds to this sound and allow it to act like a sound group. Indeed, this is exactly
+what a `ma_sound_group` is.
+
+When loading a sound, you specify a set of flags that control how the sound is loaded and what
+features are enabled for that sound. When no flags are set, the sound will be fully loaded into
+memory in exactly the same format as how it's stored on the file system. The resource manager will
+allocate a block of memory and then load the file directly into it. When reading audio data, it
+will be decoded dynamically on the fly. In order to save processing time on the audio thread, it
+might be beneficial to pre-decode the sound. You can do this with the `MA_SOUND_FLAG_DECODE` flag:
+
+    ```c
+    ma_sound_init_from_file(&engine, "my_sound.wav", MA_SOUND_FLAG_DECODE, pGroup, NULL, &sound);
+    ```
+
+By default, sounds will be loaded synchronously, meaning `ma_sound_init_*()` will not return until
+the sound has been fully loaded. If this is prohibitive you can instead load sounds asynchronously
+by specifying the `MA_SOUND_FLAG_ASYNC` flag:
+
+    ```c
+    ma_sound_init_from_file(&engine, "my_sound.wav", MA_SOUND_FLAG_DECODE | MA_SOUND_FLAG_ASYNC, pGroup, NULL, &sound);
+    ```
+
+This will result in `ma_sound_init_*()` returning quickly, but the sound won't yet have been fully
+loaded. When you start the sound, it won't output anything until some sound is available. The sound
+will start outputting audio before the sound has been fully decoded when the `MA_SOUND_FLAG_DECODE`
+is specified.
+
+If you need to wait for an asynchronously loaded sound to be fully loaded, you can use a fence. A
+fence in miniaudio is a simple synchronization mechanism which simply blocks until it's internal
+counter hit's zero. You can specify a fence like so:
+
+    ```c
+    ma_result result;
+    ma_fence fence;
+    ma_sound sounds[4];
+
+    result = ma_fence_init(&fence);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    // Load some sounds asynchronously.
+    for (int iSound = 0; iSound < 4; iSound += 1) {
+        ma_sound_init_from_file(&engine, mySoundFilesPaths[iSound], MA_SOUND_FLAG_DECODE | MA_SOUND_FLAG_ASYNC, pGroup, &fence, &sounds[iSound]);
+    }
+
+    // ... do some other stuff here in the mean time ...
+
+    // Wait for all sounds to finish loading.
+    ma_fence_wait(&fence);
+    ```
+
+If loading the entire sound into memory is prohibitive, you can also configure the engine to stream
+the audio data:
+
+    ```c
+    ma_sound_init_from_file(&engine, "my_sound.wav", MA_SOUND_FLAG_STREAM, pGroup, NULL, &sound);
+    ```
+
+When streaming sounds, 2 seconds worth of audio data is stored in memory. Although it should work
+fine, it's inefficient to use streaming for short sounds. Streaming is useful for things like music
+tracks in games.
+
+When loading a sound from a file path, the engine will reference count the file to prevent it from
+being loaded if it's already in memory. When you uninitialize a sound, the reference count will be
+decremented, and if it hits zero, the sound will be unloaded from memory. This reference counting
+system is not used for streams. The engine will use a 64-bit hash of the file name when comparing
+file paths which means there's a small chance you might encounter a name collision. If this is an
+issue, you'll need to use a different name for one of the colliding file paths, or just not load
+from files and instead load from a data source.
+
+You can use `ma_sound_init_copy()` to initialize a copy of another sound. Note, however, that this
+only works for sounds that were initialized with `ma_sound_init_from_file()` and without the
+`MA_SOUND_FLAG_STREAM` flag.
+
+When you initialize a sound, if you specify a sound group the sound will be attached to that group
+automatically. If you set it to NULL, it will be automatically attached to the engine's endpoint.
+If you would instead rather leave the sound unattached by default, you can specify the
+`MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT` flag. This is useful if you want to set up a complex node
+graph.
+
+Sounds are not started by default. To start a sound, use `ma_sound_start()`. Stop a sound with
+`ma_sound_stop()`.
+
+Sounds can have their volume controlled with `ma_sound_set_volume()` in the same way as the
+engine's master volume.
+
+Sounds support stereo panning and pitching. Set the pan with `ma_sound_set_pan()`. Setting the pan
+to 0 will result in an unpanned sound. Setting it to -1 will shift everything to the left, whereas
++1 will shift it to the right. The pitch can be controlled with `ma_sound_set_pitch()`. A larger
+value will result in a higher pitch. The pitch must be greater than 0.
+
+The engine supports 3D spatialization of sounds. By default sounds will have spatialization
+enabled, but if a sound does not need to be spatialized it's best to disable it. There are two ways
+to disable spatialization of a sound:
+
+    ```c
+    // Disable spatialization at initialization time via a flag:
+    ma_sound_init_from_file(&engine, "my_sound.wav", MA_SOUND_FLAG_NO_SPATIALIZATION, NULL, NULL, &sound);
+
+    // Dynamically disable or enable spatialization post-initialization:
+    ma_sound_set_spatialization_enabled(&sound, isSpatializationEnabled);
+    ```
+
+By default sounds will be spatialized based on the closest listener. If a sound should always be
+spatialized relative to a specific listener it can be pinned to one:
+
+    ```c
+    ma_sound_set_pinned_listener_index(&sound, listenerIndex);
+    ```
+
+Like listeners, sounds have a position. By default, the position of a sound is in absolute space,
+but it can be changed to be relative to a listener:
+
+    ```c
+    ma_sound_set_positioning(&sound, ma_positioning_relative);
+    ```
+
+Note that relative positioning of a sound only makes sense if there is either only one listener, or
+the sound is pinned to a specific listener. To set the position of a sound:
+
+    ```c
+    ma_sound_set_position(&sound, posX, posY, posZ);
+    ```
+
+The direction works the same way as a listener and represents the sound's forward direction:
+
+    ```c
+    ma_sound_set_direction(&sound, forwardX, forwardY, forwardZ);
+    ```
+
+Sound's also have a cone for controlling directional attenuation. This works exactly the same as
+listeners:
+
+    ```c
+    ma_sound_set_cone(&sound, innerAngleInRadians, outerAngleInRadians, outerGain);
+    ```
+
+The velocity of a sound is used for doppler effect and can be set as such:
+
+    ```c
+    ma_sound_set_velocity(&sound, velocityX, velocityY, velocityZ);
+    ```
+
+The engine supports different attenuation models which can be configured on a per-sound basis. By
+default the attenuation model is set to `ma_attenuation_model_inverse` which is the equivalent to
+OpenAL's `AL_INVERSE_DISTANCE_CLAMPED`. Configure the attenuation model like so:
+
+    ```c
+    ma_sound_set_attenuation_model(&sound, ma_attenuation_model_inverse);
+    ```
+
+The supported attenuation models include the following:
+
+    +----------------------------------+----------------------------------------------+
+    | ma_attenuation_model_none        | No distance attenuation.                     |
+    +----------------------------------+----------------------------------------------+
+    | ma_attenuation_model_inverse     | Equivalent to `AL_INVERSE_DISTANCE_CLAMPED`. |
+    +----------------------------------+----------------------------------------------+
+    | ma_attenuation_model_linear      | Linear attenuation.                          |
+    +----------------------------------+----------------------------------------------+
+    | ma_attenuation_model_exponential | Exponential attenuation.                     |
+    +----------------------------------+----------------------------------------------+
+
+To control how quickly a sound rolls off as it moves away from the listener, you need to configure
+the rolloff:
+
+    ```c
+    ma_sound_set_rolloff(&sound, rolloff);
+    ```
+
+You can control the minimum and maximum gain to apply from spatialization:
+
+    ```c
+    ma_sound_set_min_gain(&sound, minGain);
+    ma_sound_set_max_gain(&sound, maxGain);
+    ```
+
+Likewise, in the calculation of attenuation, you can control the minimum and maximum distances for
+the attenuation calculation. This is useful if you want to ensure sounds don't drop below a certain
+volume after the listener moves further away and to have sounds play a maximum volume when the
+listener is within a certain distance:
+
+    ```c
+    ma_sound_set_min_distance(&sound, minDistance);
+    ma_sound_set_max_distance(&sound, maxDistance);
+    ```
+
+The engine's spatialization system supports doppler effect. The doppler factor can be configure on
+a per-sound basis like so:
+
+    ```c
+    ma_sound_set_doppler_factor(&sound, dopplerFactor);
+    ```
+
+You can fade sounds in and out with `ma_sound_set_fade_in_pcm_frames()` and
+`ma_sound_set_fade_in_milliseconds()`. Set the volume to -1 to use the current volume as the
+starting volume:
+
+    ```c
+    // Fade in over 1 second.
+    ma_sound_set_fade_in_milliseconds(&sound, 0, 1, 1000);
+
+    // ... sometime later ...
+
+    // Fade out over 1 second, starting from the current volume.
+    ma_sound_set_fade_in_milliseconds(&sound, -1, 0, 1000);
+    ```
+
+By default sounds will start immediately, but sometimes for timing and synchronization purposes it
+can be useful to schedule a sound to start or stop:
+
+    ```c
+    // Start the sound in 1 second from now.
+    ma_sound_set_start_time_in_pcm_frames(&sound, ma_engine_get_time_in_pcm_frames(&engine) + (ma_engine_get_sample_rate(&engine) * 1));
+
+    // Stop the sound in 2 seconds from now.
+    ma_sound_set_stop_time_in_pcm_frames(&sound, ma_engine_get_time_in_pcm_frames(&engine) + (ma_engine_get_sample_rate(&engine) * 2));
+    ```
+
+Note that scheduling a start time still requires an explicit call to `ma_sound_start()` before
+anything will play.
+
+The time is specified in global time which is controlled by the engine. You can get the engine's
+current time with `ma_engine_get_time_in_pcm_frames()`. The engine's global time is incremented
+automatically as audio data is read, but it can be reset with `ma_engine_set_time_in_pcm_frames()`
+in case it needs to be resynchronized for some reason.
+
+To determine whether or not a sound is currently playing, use `ma_sound_is_playing()`. This will
+take the scheduled start and stop times into account.
+
+Whether or not a sound should loop can be controlled with `ma_sound_set_looping()`. Sounds will not
+be looping by default. Use `ma_sound_is_looping()` to determine whether or not a sound is looping.
+
+Use `ma_sound_at_end()` to determine whether or not a sound is currently at the end. For a looping
+sound this should never return true. Alternatively, you can configure a callback that will be fired
+when the sound reaches the end. Note that the callback is fired from the audio thread which means
+you cannot be uninitializing sound from the callback. To set the callback you can use
+`ma_sound_set_end_callback()`. Alternatively, if you're using `ma_sound_init_ex()`, you can pass it
+into the config like so:
+
+    ```c
+    soundConfig.endCallback = my_end_callback;
+    soundConfig.pEndCallbackUserData = pMyEndCallbackUserData;
+    ```
+
+The end callback is declared like so:
+
+    ```c
+    void my_end_callback(void* pUserData, ma_sound* pSound)
+    {
+        ...
+    }
+    ```
+
+Internally a sound wraps around a data source. Some APIs exist to control the underlying data
+source, mainly for convenience:
+
+    ```c
+    ma_sound_seek_to_pcm_frame(&sound, frameIndex);
+    ma_sound_get_data_format(&sound, &format, &channels, &sampleRate, pChannelMap, channelMapCapacity);
+    ma_sound_get_cursor_in_pcm_frames(&sound, &cursor);
+    ma_sound_get_length_in_pcm_frames(&sound, &length);
+    ```
+
+Sound groups have the same API as sounds, only they are called `ma_sound_group`, and since they do
+not have any notion of a data source, anything relating to a data source is unavailable.
+
+Internally, sound data is loaded via the `ma_decoder` API which means by default it only supports
+file formats that have built-in support in miniaudio. You can extend this to support any kind of
+file format through the use of custom decoders. To do this you'll need to use a self-managed
+resource manager and configure it appropriately. See the "Resource Management" section below for
+details on how to set this up.
+
+
+6. Resource Management
+======================
+Many programs will want to manage sound resources for things such as reference counting and
+streaming. This is supported by miniaudio via the `ma_resource_manager` API.
+
+The resource manager is mainly responsible for the following:
+
+  * Loading of sound files into memory with reference counting.
+  * Streaming of sound data.
+
+When loading a sound file, the resource manager will give you back a `ma_data_source` compatible
+object called `ma_resource_manager_data_source`. This object can be passed into any
+`ma_data_source` API which is how you can read and seek audio data. When loading a sound file, you
+specify whether or not you want the sound to be fully loaded into memory (and optionally
+pre-decoded) or streamed. When loading into memory, you can also specify whether or not you want
+the data to be loaded asynchronously.
+
+The example below is how you can initialize a resource manager using it's default configuration:
+
+    ```c
+    ma_resource_manager_config config;
+    ma_resource_manager resourceManager;
+
+    config = ma_resource_manager_config_init();
+    result = ma_resource_manager_init(&config, &resourceManager);
+    if (result != MA_SUCCESS) {
+        ma_device_uninit(&device);
+        printf("Failed to initialize the resource manager.");
+        return -1;
+    }
+    ```
+
+You can configure the format, channels and sample rate of the decoded audio data. By default it
+will use the file's native data format, but you can configure it to use a consistent format. This
+is useful for offloading the cost of data conversion to load time rather than dynamically
+converting at mixing time. To do this, you configure the decoded format, channels and sample rate
+like the code below:
+
+    ```c
+    config = ma_resource_manager_config_init();
+    config.decodedFormat     = device.playback.format;
+    config.decodedChannels   = device.playback.channels;
+    config.decodedSampleRate = device.sampleRate;
+    ```
+
+In the code above, the resource manager will be configured so that any decoded audio data will be
+pre-converted at load time to the device's native data format. If instead you used defaults and
+the data format of the file did not match the device's data format, you would need to convert the
+data at mixing time which may be prohibitive in high-performance and large scale scenarios like
+games.
+
+Internally the resource manager uses the `ma_decoder` API to load sounds. This means by default it
+only supports decoders that are built into miniaudio. It's possible to support additional encoding
+formats through the use of custom decoders. To do so, pass in your `ma_decoding_backend_vtable`
+vtables into the resource manager config:
+
+    ```c
+    ma_decoding_backend_vtable* pCustomBackendVTables[] =
+    {
+        &g_ma_decoding_backend_vtable_libvorbis,
+        &g_ma_decoding_backend_vtable_libopus
+    };
+
+    ...
+
+    resourceManagerConfig.ppCustomDecodingBackendVTables = pCustomBackendVTables;
+    resourceManagerConfig.customDecodingBackendCount     = sizeof(pCustomBackendVTables) / sizeof(pCustomBackendVTables[0]);
+    resourceManagerConfig.pCustomDecodingBackendUserData = NULL;
+    ```
+
+This system can allow you to support any kind of file format. See the "Decoding" section for
+details on how to implement custom decoders. The miniaudio repository includes examples for Opus
+via libopus and libopusfile and Vorbis via libvorbis and libvorbisfile.
+
+Asynchronicity is achieved via a job system. When an operation needs to be performed, such as the
+decoding of a page, a job will be posted to a queue which will then be processed by a job thread.
+By default there will be only one job thread running, but this can be configured, like so:
+
+    ```c
+    config = ma_resource_manager_config_init();
+    config.jobThreadCount = MY_JOB_THREAD_COUNT;
+    ```
+
+By default job threads are managed internally by the resource manager, however you can also self
+manage your job threads if, for example, you want to integrate the job processing into your
+existing job infrastructure, or if you simply don't like the way the resource manager does it. To
+do this, just set the job thread count to 0 and process jobs manually. To process jobs, you first
+need to retrieve a job using `ma_resource_manager_next_job()` and then process it using
+`ma_job_process()`:
+
+    ```c
+    config = ma_resource_manager_config_init();
+    config.jobThreadCount = 0;                            // Don't manage any job threads internally.
+    config.flags = MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING; // Optional. Makes `ma_resource_manager_next_job()` non-blocking.
+
+    // ... Initialize your custom job threads ...
+
+    void my_custom_job_thread(...)
+    {
+        for (;;) {
+            ma_job job;
+            ma_result result = ma_resource_manager_next_job(pMyResourceManager, &job);
+            if (result != MA_SUCCESS) {
+                if (result == MA_NO_DATA_AVAILABLE) {
+                    // No jobs are available. Keep going. Will only get this if the resource manager was initialized
+                    // with MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING.
+                    continue;
+                } else if (result == MA_CANCELLED) {
+                    // MA_JOB_TYPE_QUIT was posted. Exit.
+                    break;
+                } else {
+                    // Some other error occurred.
+                    break;
+                }
+            }
+
+            ma_job_process(&job);
+        }
+    }
+    ```
+
+In the example above, the `MA_JOB_TYPE_QUIT` event is the used as the termination
+indicator, but you can use whatever you would like to terminate the thread. The call to
+`ma_resource_manager_next_job()` is blocking by default, but can be configured to be non-blocking
+by initializing the resource manager with the `MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING` configuration
+flag. Note that the `MA_JOB_TYPE_QUIT` will never be removed from the job queue. This
+is to give every thread the opportunity to catch the event and terminate naturally.
+
+When loading a file, it's sometimes convenient to be able to customize how files are opened and
+read instead of using standard `fopen()`, `fclose()`, etc. which is what miniaudio will use by
+default. This can be done by setting `pVFS` member of the resource manager's config:
+
+    ```c
+    // Initialize your custom VFS object. See documentation for VFS for information on how to do this.
+    my_custom_vfs vfs = my_custom_vfs_init();
+
+    config = ma_resource_manager_config_init();
+    config.pVFS = &vfs;
+    ```
+
+This is particularly useful in programs like games where you want to read straight from an archive
+rather than the normal file system. If you do not specify a custom VFS, the resource manager will
+use the operating system's normal file operations.
+
+To load a sound file and create a data source, call `ma_resource_manager_data_source_init()`. When
+loading a sound you need to specify the file path and options for how the sounds should be loaded.
+By default a sound will be loaded synchronously. The returned data source is owned by the caller
+which means the caller is responsible for the allocation and freeing of the data source. Below is
+an example for initializing a data source:
+
+    ```c
+    ma_resource_manager_data_source dataSource;
+    ma_result result = ma_resource_manager_data_source_init(pResourceManager, pFilePath, flags, &dataSource);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    // ...
+
+    // A ma_resource_manager_data_source object is compatible with the `ma_data_source` API. To read data, just call
+    // the `ma_data_source_read_pcm_frames()` like you would with any normal data source.
+    result = ma_data_source_read_pcm_frames(&dataSource, pDecodedData, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        // Failed to read PCM frames.
+    }
+
+    // ...
+
+    ma_resource_manager_data_source_uninit(&dataSource);
+    ```
+
+The `flags` parameter specifies how you want to perform loading of the sound file. It can be a
+combination of the following flags:
+
+    ```
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING
+    ```
+
+When no flags are specified (set to 0), the sound will be fully loaded into memory, but not
+decoded, meaning the raw file data will be stored in memory, and then dynamically decoded when
+`ma_data_source_read_pcm_frames()` is called. To instead decode the audio data before storing it in
+memory, use the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE` flag. By default, the sound file will
+be loaded synchronously, meaning `ma_resource_manager_data_source_init()` will only return after
+the entire file has been loaded. This is good for simplicity, but can be prohibitively slow. You
+can instead load the sound asynchronously using the `MA_RESOURCE_MANAGER_DATA_SOURCE_ASYNC` flag.
+This will result in `ma_resource_manager_data_source_init()` returning quickly, but no data will be
+returned by `ma_data_source_read_pcm_frames()` until some data is available. When no data is
+available because the asynchronous decoding hasn't caught up, `MA_BUSY` will be returned by
+`ma_data_source_read_pcm_frames()`.
+
+For large sounds, it's often prohibitive to store the entire file in memory. To mitigate this, you
+can instead stream audio data which you can do by specifying the
+`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag. When streaming, data will be decoded in 1
+second pages. When a new page needs to be decoded, a job will be posted to the job queue and then
+subsequently processed in a job thread.
+
+The `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING` flag can be used so that the sound will loop
+when it reaches the end by default. It's recommended you use this flag when you want to have a
+looping streaming sound. If you try loading a very short sound as a stream, you will get a glitch.
+This is because the resource manager needs to pre-fill the initial buffer at initialization time,
+and if you don't specify the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING` flag, the resource
+manager will assume the sound is not looping and will stop filling the buffer when it reaches the
+end, therefore resulting in a discontinuous buffer.
+
+For in-memory sounds, reference counting is used to ensure the data is loaded only once. This means
+multiple calls to `ma_resource_manager_data_source_init()` with the same file path will result in
+the file data only being loaded once. Each call to `ma_resource_manager_data_source_init()` must be
+matched up with a call to `ma_resource_manager_data_source_uninit()`. Sometimes it can be useful
+for a program to register self-managed raw audio data and associate it with a file path. Use the
+`ma_resource_manager_register_*()` and `ma_resource_manager_unregister_*()` APIs to do this.
+`ma_resource_manager_register_decoded_data()` is used to associate a pointer to raw, self-managed
+decoded audio data in the specified data format with the specified name. Likewise,
+`ma_resource_manager_register_encoded_data()` is used to associate a pointer to raw self-managed
+encoded audio data (the raw file data) with the specified name. Note that these names need not be
+actual file paths. When `ma_resource_manager_data_source_init()` is called (without the
+`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag), the resource manager will look for these
+explicitly registered data buffers and, if found, will use it as the backing data for the data
+source. Note that the resource manager does *not* make a copy of this data so it is up to the
+caller to ensure the pointer stays valid for its lifetime. Use
+`ma_resource_manager_unregister_data()` to unregister the self-managed data. You can also use
+`ma_resource_manager_register_file()` and `ma_resource_manager_unregister_file()` to register and
+unregister a file. It does not make sense to use the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM`
+flag with a self-managed data pointer.
+
+
+6.1. Asynchronous Loading and Synchronization
+---------------------------------------------
+When loading asynchronously, it can be useful to poll whether or not loading has finished. Use
+`ma_resource_manager_data_source_result()` to determine this. For in-memory sounds, this will
+return `MA_SUCCESS` when the file has been *entirely* decoded. If the sound is still being decoded,
+`MA_BUSY` will be returned. Otherwise, some other error code will be returned if the sound failed
+to load. For streaming data sources, `MA_SUCCESS` will be returned when the first page has been
+decoded and the sound is ready to be played. If the first page is still being decoded, `MA_BUSY`
+will be returned. Otherwise, some other error code will be returned if the sound failed to load.
+
+In addition to polling, you can also use a simple synchronization object called a "fence" to wait
+for asynchronously loaded sounds to finish. This is called `ma_fence`. The advantage to using a
+fence is that it can be used to wait for a group of sounds to finish loading rather than waiting
+for sounds on an individual basis. There are two stages to loading a sound:
+
+  * Initialization of the internal decoder; and
+  * Completion of decoding of the file (the file is fully decoded)
+
+You can specify separate fences for each of the different stages. Waiting for the initialization
+of the internal decoder is important for when you need to know the sample format, channels and
+sample rate of the file.
+
+The example below shows how you could use a fence when loading a number of sounds:
+
+    ```c
+    // This fence will be released when all sounds are finished loading entirely.
+    ma_fence fence;
+    ma_fence_init(&fence);
+
+    // This will be passed into the initialization routine for each sound.
+    ma_resource_manager_pipeline_notifications notifications = ma_resource_manager_pipeline_notifications_init();
+    notifications.done.pFence = &fence;
+
+    // Now load a bunch of sounds:
+    for (iSound = 0; iSound < soundCount; iSound += 1) {
+        ma_resource_manager_data_source_init(pResourceManager, pSoundFilePaths[iSound], flags, &notifications, &pSoundSources[iSound]);
+    }
+
+    // ... DO SOMETHING ELSE WHILE SOUNDS ARE LOADING ...
+
+    // Wait for loading of sounds to finish.
+    ma_fence_wait(&fence);
+    ```
+
+In the example above we used a fence for waiting until the entire file has been fully decoded. If
+you only need to wait for the initialization of the internal decoder to complete, you can use the
+`init` member of the `ma_resource_manager_pipeline_notifications` object:
+
+    ```c
+    notifications.init.pFence = &fence;
+    ```
+
+If a fence is not appropriate for your situation, you can instead use a callback that is fired on
+an individual sound basis. This is done in a very similar way to fences:
+
+    ```c
+    typedef struct
+    {
+        ma_async_notification_callbacks cb;
+        void* pMyData;
+    } my_notification;
+
+    void my_notification_callback(ma_async_notification* pNotification)
+    {
+        my_notification* pMyNotification = (my_notification*)pNotification;
+
+        // Do something in response to the sound finishing loading.
+    }
+
+    ...
+
+    my_notification myCallback;
+    myCallback.cb.onSignal = my_notification_callback;
+    myCallback.pMyData     = pMyData;
+
+    ma_resource_manager_pipeline_notifications notifications = ma_resource_manager_pipeline_notifications_init();
+    notifications.done.pNotification = &myCallback;
+
+    ma_resource_manager_data_source_init(pResourceManager, "my_sound.wav", flags, &notifications, &mySound);
+    ```
+
+In the example above we just extend the `ma_async_notification_callbacks` object and pass an
+instantiation into the `ma_resource_manager_pipeline_notifications` in the same way as we did with
+the fence, only we set `pNotification` instead of `pFence`. You can set both of these at the same
+time and they should both work as expected. If using the `pNotification` system, you need to ensure
+your `ma_async_notification_callbacks` object stays valid.
+
+
+
+6.2. Resource Manager Implementation Details
+--------------------------------------------
+Resources are managed in two main ways:
+
+  * By storing the entire sound inside an in-memory buffer (referred to as a data buffer)
+  * By streaming audio data on the fly (referred to as a data stream)
+
+A resource managed data source (`ma_resource_manager_data_source`) encapsulates a data buffer or
+data stream, depending on whether or not the data source was initialized with the
+`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag. If so, it will make use of a
+`ma_resource_manager_data_stream` object. Otherwise it will use a `ma_resource_manager_data_buffer`
+object. Both of these objects are data sources which means they can be used with any
+`ma_data_source_*()` API.
+
+Another major feature of the resource manager is the ability to asynchronously decode audio files.
+This relieves the audio thread of time-consuming decoding which can negatively affect scalability
+due to the audio thread needing to complete it's work extremely quickly to avoid glitching.
+Asynchronous decoding is achieved through a job system. There is a central multi-producer,
+multi-consumer, fixed-capacity job queue. When some asynchronous work needs to be done, a job is
+posted to the queue which is then read by a job thread. The number of job threads can be
+configured for improved scalability, and job threads can all run in parallel without needing to
+worry about the order of execution (how this is achieved is explained below).
+
+When a sound is being loaded asynchronously, playback can begin before the sound has been fully
+decoded. This enables the application to start playback of the sound quickly, while at the same
+time allowing to resource manager to keep loading in the background. Since there may be less
+threads than the number of sounds being loaded at a given time, a simple scheduling system is used
+to keep decoding time balanced and fair. The resource manager solves this by splitting decoding
+into chunks called pages. By default, each page is 1 second long. When a page has been decoded, a
+new job will be posted to start decoding the next page. By dividing up decoding into pages, an
+individual sound shouldn't ever delay every other sound from having their first page decoded. Of
+course, when loading many sounds at the same time, there will always be an amount of time required
+to process jobs in the queue so in heavy load situations there will still be some delay. To
+determine if a data source is ready to have some frames read, use
+`ma_resource_manager_data_source_get_available_frames()`. This will return the number of frames
+available starting from the current position.
+
+
+6.2.1. Job Queue
+----------------
+The resource manager uses a job queue which is multi-producer, multi-consumer, and fixed-capacity.
+This job queue is not currently lock-free, and instead uses a spinlock to achieve thread-safety.
+Only a fixed number of jobs can be allocated and inserted into the queue which is done through a
+lock-free data structure for allocating an index into a fixed sized array, with reference counting
+for mitigation of the ABA problem. The reference count is 32-bit.
+
+For many types of jobs it's important that they execute in a specific order. In these cases, jobs
+are executed serially. For the resource manager, serial execution of jobs is only required on a
+per-object basis (per data buffer or per data stream). Each of these objects stores an execution
+counter. When a job is posted it is associated with an execution counter. When the job is
+processed, it checks if the execution counter of the job equals the execution counter of the
+owning object and if so, processes the job. If the counters are not equal, the job will be posted
+back onto the job queue for later processing. When the job finishes processing the execution order
+of the main object is incremented. This system means the no matter how many job threads are
+executing, decoding of an individual sound will always get processed serially. The advantage to
+having multiple threads comes into play when loading multiple sounds at the same time.
+
+The resource manager's job queue is not 100% lock-free and will use a spinlock to achieve
+thread-safety for a very small section of code. This is only relevant when the resource manager
+uses more than one job thread. If only using a single job thread, which is the default, the
+lock should never actually wait in practice. The amount of time spent locking should be quite
+short, but it's something to be aware of for those who have pedantic lock-free requirements and
+need to use more than one job thread. There are plans to remove this lock in a future version.
+
+In addition, posting a job will release a semaphore, which on Win32 is implemented with
+`ReleaseSemaphore` and on POSIX platforms via a condition variable:
+
+    ```c
+    pthread_mutex_lock(&pSemaphore->lock);
+    {
+        pSemaphore->value += 1;
+        pthread_cond_signal(&pSemaphore->cond);
+    }
+    pthread_mutex_unlock(&pSemaphore->lock);
+    ```
+
+Again, this is relevant for those with strict lock-free requirements in the audio thread. To avoid
+this, you can use non-blocking mode (via the `MA_JOB_QUEUE_FLAG_NON_BLOCKING`
+flag) and implement your own job processing routine (see the "Resource Manager" section above for
+details on how to do this).
+
+
+
+6.2.2. Data Buffers
+-------------------
+When the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag is excluded at initialization time, the
+resource manager will try to load the data into an in-memory data buffer. Before doing so, however,
+it will first check if the specified file is already loaded. If so, it will increment a reference
+counter and just use the already loaded data. This saves both time and memory. When the data buffer
+is uninitialized, the reference counter will be decremented. If the counter hits zero, the file
+will be unloaded. This is a detail to keep in mind because it could result in excessive loading and
+unloading of a sound. For example, the following sequence will result in a file be loaded twice,
+once after the other:
+
+    ```c
+    ma_resource_manager_data_source_init(pResourceManager, "my_file", ..., &myDataBuffer0); // Refcount = 1. Initial load.
+    ma_resource_manager_data_source_uninit(&myDataBuffer0);                                 // Refcount = 0. Unloaded.
+
+    ma_resource_manager_data_source_init(pResourceManager, "my_file", ..., &myDataBuffer1); // Refcount = 1. Reloaded because previous uninit() unloaded it.
+    ma_resource_manager_data_source_uninit(&myDataBuffer1);                                 // Refcount = 0. Unloaded.
+    ```
+
+A binary search tree (BST) is used for storing data buffers as it has good balance between
+efficiency and simplicity. The key of the BST is a 64-bit hash of the file path that was passed
+into `ma_resource_manager_data_source_init()`. The advantage of using a hash is that it saves
+memory over storing the entire path, has faster comparisons, and results in a mostly balanced BST
+due to the random nature of the hash. The disadvantages are that file names are case-sensitive and
+there's a small chance of name collisions. If case-sensitivity is an issue, you should normalize
+your file names to upper- or lower-case before initializing your data sources. If name collisions
+become an issue, you'll need to change the name of one of the colliding names or just not use the
+resource manager.
+
+When a sound file has not already been loaded and the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC`
+flag is excluded, the file will be decoded synchronously by the calling thread. There are two
+options for controlling how the audio is stored in the data buffer - encoded or decoded. When the
+`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE` option is excluded, the raw file data will be stored
+in memory. Otherwise the sound will be decoded before storing it in memory. Synchronous loading is
+a very simple and standard process of simply adding an item to the BST, allocating a block of
+memory and then decoding (if `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE` is specified).
+
+When the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC` flag is specified, loading of the data buffer
+is done asynchronously. In this case, a job is posted to the queue to start loading and then the
+function immediately returns, setting an internal result code to `MA_BUSY`. This result code is
+returned when the program calls `ma_resource_manager_data_source_result()`. When decoding has fully
+completed `MA_SUCCESS` will be returned. This can be used to know if loading has fully completed.
+
+When loading asynchronously, a single job is posted to the queue of the type
+`MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE`. This involves making a copy of the file path and
+associating it with job. When the job is processed by the job thread, it will first load the file
+using the VFS associated with the resource manager. When using a custom VFS, it's important that it
+be completely thread-safe because it will be used from one or more job threads at the same time.
+Individual files should only ever be accessed by one thread at a time, however. After opening the
+file via the VFS, the job will determine whether or not the file is being decoded. If not, it
+simply allocates a block of memory and loads the raw file contents into it and returns. On the
+other hand, when the file is being decoded, it will first allocate a decoder on the heap and
+initialize it. Then it will check if the length of the file is known. If so it will allocate a
+block of memory to store the decoded output and initialize it to silence. If the size is unknown,
+it will allocate room for one page. After memory has been allocated, the first page will be
+decoded. If the sound is shorter than a page, the result code will be set to `MA_SUCCESS` and the
+completion event will be signalled and loading is now complete. If, however, there is more to
+decode, a job with the code `MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE` is posted. This job
+will decode the next page and perform the same process if it reaches the end. If there is more to
+decode, the job will post another `MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE` job which will
+keep on happening until the sound has been fully decoded. For sounds of an unknown length, each
+page will be linked together as a linked list. Internally this is implemented via the
+`ma_paged_audio_buffer` object.
+
+
+6.2.3. Data Streams
+-------------------
+Data streams only ever store two pages worth of data for each instance. They are most useful for
+large sounds like music tracks in games that would consume too much memory if fully decoded in
+memory. After every frame from a page has been read, a job will be posted to load the next page
+which is done from the VFS.
+
+For data streams, the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC` flag will determine whether or
+not initialization of the data source waits until the two pages have been decoded. When unset,
+`ma_resource_manager_data_source_init()` will wait until the two pages have been loaded, otherwise
+it will return immediately.
+
+When frames are read from a data stream using `ma_resource_manager_data_source_read_pcm_frames()`,
+`MA_BUSY` will be returned if there are no frames available. If there are some frames available,
+but less than the number requested, `MA_SUCCESS` will be returned, but the actual number of frames
+read will be less than the number requested. Due to the asynchronous nature of data streams,
+seeking is also asynchronous. If the data stream is in the middle of a seek, `MA_BUSY` will be
+returned when trying to read frames.
+
+When `ma_resource_manager_data_source_read_pcm_frames()` results in a page getting fully consumed
+a job is posted to load the next page. This will be posted from the same thread that called
+`ma_resource_manager_data_source_read_pcm_frames()`.
+
+Data streams are uninitialized by posting a job to the queue, but the function won't return until
+that job has been processed. The reason for this is that the caller owns the data stream object and
+therefore miniaudio needs to ensure everything completes before handing back control to the caller.
+Also, if the data stream is uninitialized while pages are in the middle of decoding, they must
+complete before destroying any underlying object and the job system handles this cleanly.
+
+Note that when a new page needs to be loaded, a job will be posted to the resource manager's job
+thread from the audio thread. You must keep in mind the details mentioned in the "Job Queue"
+section above regarding locking when posting an event if you require a strictly lock-free audio
+thread.
+
+
+
+7. Node Graph
+=============
+miniaudio's routing infrastructure follows a node graph paradigm. The idea is that you create a
+node whose outputs are attached to inputs of another node, thereby creating a graph. There are
+different types of nodes, with each node in the graph processing input data to produce output,
+which is then fed through the chain. Each node in the graph can apply their own custom effects. At
+the start of the graph will usually be one or more data source nodes which have no inputs and
+instead pull their data from a data source. At the end of the graph is an endpoint which represents
+the end of the chain and is where the final output is ultimately extracted from.
+
+Each node has a number of input buses and a number of output buses. An output bus from a node is
+attached to an input bus of another. Multiple nodes can connect their output buses to another
+node's input bus, in which case their outputs will be mixed before processing by the node. Below is
+a diagram that illustrates a hypothetical node graph setup:
+
+    ```
+    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Data flows left to right >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+    +---------------+                              +-----------------+
+    | Data Source 1 =----+    +----------+    +----= Low Pass Filter =----+
+    +---------------+    |    |          =----+    +-----------------+    |    +----------+
+                         +----= Splitter |                                +----= ENDPOINT |
+    +---------------+    |    |          =----+    +-----------------+    |    +----------+
+    | Data Source 2 =----+    +----------+    +----=  Echo / Delay   =----+
+    +---------------+                              +-----------------+
+    ```
+
+In the above graph, it starts with two data sources whose outputs are attached to the input of a
+splitter node. It's at this point that the two data sources are mixed. After mixing, the splitter
+performs it's processing routine and produces two outputs which is simply a duplication of the
+input stream. One output is attached to a low pass filter, whereas the other output is attached to
+a echo/delay. The outputs of the low pass filter and the echo are attached to the endpoint, and
+since they're both connected to the same input bus, they'll be mixed.
+
+Each input bus must be configured to accept the same number of channels, but the number of channels
+used by input buses can be different to the number of channels for output buses in which case
+miniaudio will automatically convert the input data to the output channel count before processing.
+The number of channels of an output bus of one node must match the channel count of the input bus
+it's attached to. The channel counts cannot be changed after the node has been initialized. If you
+attempt to attach an output bus to an input bus with a different channel count, attachment will
+fail.
+
+To use a node graph, you first need to initialize a `ma_node_graph` object. This is essentially a
+container around the entire graph. The `ma_node_graph` object is required for some thread-safety
+issues which will be explained later. A `ma_node_graph` object is initialized using miniaudio's
+standard config/init system:
+
+    ```c
+    ma_node_graph_config nodeGraphConfig = ma_node_graph_config_init(myChannelCount);
+
+    result = ma_node_graph_init(&nodeGraphConfig, NULL, &nodeGraph);    // Second parameter is a pointer to allocation callbacks.
+    if (result != MA_SUCCESS) {
+        // Failed to initialize node graph.
+    }
+    ```
+
+When you initialize the node graph, you're specifying the channel count of the endpoint. The
+endpoint is a special node which has one input bus and one output bus, both of which have the
+same channel count, which is specified in the config. Any nodes that connect directly to the
+endpoint must be configured such that their output buses have the same channel count. When you read
+audio data from the node graph, it'll have the channel count you specified in the config. To read
+data from the graph:
+
+    ```c
+    ma_uint32 framesRead;
+    result = ma_node_graph_read_pcm_frames(&nodeGraph, pFramesOut, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        // Failed to read data from the node graph.
+    }
+    ```
+
+When you read audio data, miniaudio starts at the node graph's endpoint node which then pulls in
+data from its input attachments, which in turn recursively pull in data from their inputs, and so
+on. At the start of the graph there will be some kind of data source node which will have zero
+inputs and will instead read directly from a data source. The base nodes don't literally need to
+read from a `ma_data_source` object, but they will always have some kind of underlying object that
+sources some kind of audio. The `ma_data_source_node` node can be used to read from a
+`ma_data_source`. Data is always in floating-point format and in the number of channels you
+specified when the graph was initialized. The sample rate is defined by the underlying data sources.
+It's up to you to ensure they use a consistent and appropriate sample rate.
+
+The `ma_node` API is designed to allow custom nodes to be implemented with relative ease, but
+miniaudio includes a few stock nodes for common functionality. This is how you would initialize a
+node which reads directly from a data source (`ma_data_source_node`) which is an example of one
+of the stock nodes that comes with miniaudio:
+
+    ```c
+    ma_data_source_node_config config = ma_data_source_node_config_init(pMyDataSource);
+
+    ma_data_source_node dataSourceNode;
+    result = ma_data_source_node_init(&nodeGraph, &config, NULL, &dataSourceNode);
+    if (result != MA_SUCCESS) {
+        // Failed to create data source node.
+    }
+    ```
+
+The data source node will use the output channel count to determine the channel count of the output
+bus. There will be 1 output bus and 0 input buses (data will be drawn directly from the data
+source). The data source must output to floating-point (`ma_format_f32`) or else an error will be
+returned from `ma_data_source_node_init()`.
+
+By default the node will not be attached to the graph. To do so, use `ma_node_attach_output_bus()`:
+
+    ```c
+    result = ma_node_attach_output_bus(&dataSourceNode, 0, ma_node_graph_get_endpoint(&nodeGraph), 0);
+    if (result != MA_SUCCESS) {
+        // Failed to attach node.
+    }
+    ```
+
+The code above connects the data source node directly to the endpoint. Since the data source node
+has only a single output bus, the index will always be 0. Likewise, the endpoint only has a single
+input bus which means the input bus index will also always be 0.
+
+To detach a specific output bus, use `ma_node_detach_output_bus()`. To detach all output buses, use
+`ma_node_detach_all_output_buses()`. If you want to just move the output bus from one attachment to
+another, you do not need to detach first. You can just call `ma_node_attach_output_bus()` and it'll
+deal with it for you.
+
+Less frequently you may want to create a specialized node. This will be a node where you implement
+your own processing callback to apply a custom effect of some kind. This is similar to initializing
+one of the stock node types, only this time you need to specify a pointer to a vtable containing a
+pointer to the processing function and the number of input and output buses. Example:
+
+    ```c
+    static void my_custom_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+    {
+        // Do some processing of ppFramesIn (one stream of audio data per input bus)
+        const float* pFramesIn_0 = ppFramesIn[0]; // Input bus @ index 0.
+        const float* pFramesIn_1 = ppFramesIn[1]; // Input bus @ index 1.
+        float* pFramesOut_0 = ppFramesOut[0];     // Output bus @ index 0.
+
+        // Do some processing. On input, `pFrameCountIn` will be the number of input frames in each
+        // buffer in `ppFramesIn` and `pFrameCountOut` will be the capacity of each of the buffers
+        // in `ppFramesOut`. On output, `pFrameCountIn` should be set to the number of input frames
+        // your node consumed and `pFrameCountOut` should be set the number of output frames that
+        // were produced.
+        //
+        // You should process as many frames as you can. If your effect consumes input frames at the
+        // same rate as output frames (always the case, unless you're doing resampling), you need
+        // only look at `ppFramesOut` and process that exact number of frames. If you're doing
+        // resampling, you'll need to be sure to set both `pFrameCountIn` and `pFrameCountOut`
+        // properly.
+    }
+
+    static ma_node_vtable my_custom_node_vtable =
+    {
+        my_custom_node_process_pcm_frames, // The function that will be called to process your custom node. This is where you'd implement your effect processing.
+        NULL,   // Optional. A callback for calculating the number of input frames that are required to process a specified number of output frames.
+        2,      // 2 input buses.
+        1,      // 1 output bus.
+        0       // Default flags.
+    };
+
+    ...
+
+    // Each bus needs to have a channel count specified. To do this you need to specify the channel
+    // counts in an array and then pass that into the node config.
+    ma_uint32 inputChannels[2];     // Equal in size to the number of input channels specified in the vtable.
+    ma_uint32 outputChannels[1];    // Equal in size to the number of output channels specified in the vtable.
+
+    inputChannels[0]  = channelsIn;
+    inputChannels[1]  = channelsIn;
+    outputChannels[0] = channelsOut;
+
+    ma_node_config nodeConfig = ma_node_config_init();
+    nodeConfig.vtable          = &my_custom_node_vtable;
+    nodeConfig.pInputChannels  = inputChannels;
+    nodeConfig.pOutputChannels = outputChannels;
+
+    ma_node_base node;
+    result = ma_node_init(&nodeGraph, &nodeConfig, NULL, &node);
+    if (result != MA_SUCCESS) {
+        // Failed to initialize node.
+    }
+    ```
+
+When initializing a custom node, as in the code above, you'll normally just place your vtable in
+static space. The number of input and output buses are specified as part of the vtable. If you need
+a variable number of buses on a per-node bases, the vtable should have the relevant bus count set
+to `MA_NODE_BUS_COUNT_UNKNOWN`. In this case, the bus count should be set in the node config:
+
+    ```c
+    static ma_node_vtable my_custom_node_vtable =
+    {
+        my_custom_node_process_pcm_frames, // The function that will be called process your custom node. This is where you'd implement your effect processing.
+        NULL,   // Optional. A callback for calculating the number of input frames that are required to process a specified number of output frames.
+        MA_NODE_BUS_COUNT_UNKNOWN,  // The number of input buses is determined on a per-node basis.
+        1,      // 1 output bus.
+        0       // Default flags.
+    };
+
+    ...
+
+    ma_node_config nodeConfig = ma_node_config_init();
+    nodeConfig.vtable          = &my_custom_node_vtable;
+    nodeConfig.inputBusCount   = myBusCount;        // <-- Since the vtable specifies MA_NODE_BUS_COUNT_UNKNOWN, the input bus count should be set here.
+    nodeConfig.pInputChannels  = inputChannels;     // <-- Make sure there are nodeConfig.inputBusCount elements in this array.
+    nodeConfig.pOutputChannels = outputChannels;    // <-- The vtable specifies 1 output bus, so there must be 1 element in this array.
+    ```
+
+In the above example it's important to never set the `inputBusCount` and `outputBusCount` members
+to anything other than their defaults if the vtable specifies an explicit count. They can only be
+set if the vtable specifies MA_NODE_BUS_COUNT_UNKNOWN in the relevant bus count.
+
+Most often you'll want to create a structure to encapsulate your node with some extra data. You
+need to make sure the `ma_node_base` object is your first member of the structure:
+
+    ```c
+    typedef struct
+    {
+        ma_node_base base; // <-- Make sure this is always the first member.
+        float someCustomData;
+    } my_custom_node;
+    ```
+
+By doing this, your object will be compatible with all `ma_node` APIs and you can attach it to the
+graph just like any other node.
+
+In the custom processing callback (`my_custom_node_process_pcm_frames()` in the example above), the
+number of channels for each bus is what was specified by the config when the node was initialized
+with `ma_node_init()`. In addition, all attachments to each of the input buses will have been
+pre-mixed by miniaudio. The config allows you to specify different channel counts for each
+individual input and output bus. It's up to the effect to handle it appropriate, and if it can't,
+return an error in it's initialization routine.
+
+Custom nodes can be assigned some flags to describe their behaviour. These are set via the vtable
+and include the following:
+
+    +-----------------------------------------+---------------------------------------------------+
+    | Flag Name                               | Description                                       |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_PASSTHROUGH                | Useful for nodes that do not do any kind of audio |
+    |                                         | processing, but are instead used for tracking     |
+    |                                         | time, handling events, etc. Also used by the      |
+    |                                         | internal endpoint node. It reads directly from    |
+    |                                         | the input bus to the output bus. Nodes with this  |
+    |                                         | flag must have exactly 1 input bus and 1 output   |
+    |                                         | bus, and both buses must have the same channel    |
+    |                                         | counts.                                           |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_CONTINUOUS_PROCESSING      | Causes the processing callback to be called even  |
+    |                                         | when no data is available to be read from input   |
+    |                                         | attachments. When a node has at least one input   |
+    |                                         | bus, but there are no inputs attached or the      |
+    |                                         | inputs do not deliver any data, the node's        |
+    |                                         | processing callback will not get fired. This flag |
+    |                                         | will make it so the callback is always fired      |
+    |                                         | regardless of whether or not any input data is    |
+    |                                         | received. This is useful for effects like         |
+    |                                         | echos where there will be a tail of audio data    |
+    |                                         | that still needs to be processed even when the    |
+    |                                         | original data sources have reached their ends. It |
+    |                                         | may also be useful for nodes that must always     |
+    |                                         | have their processing callback fired when there   |
+    |                                         | are no inputs attached.                           |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_ALLOW_NULL_INPUT           | Used in conjunction with                          |
+    |                                         | `MA_NODE_FLAG_CONTINUOUS_PROCESSING`. When this   |
+    |                                         | is set, the `ppFramesIn` parameter of the         |
+    |                                         | processing callback will be set to NULL when      |
+    |                                         | there are no input frames are available. When     |
+    |                                         | this is unset, silence will be posted to the      |
+    |                                         | processing callback.                              |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES | Used to tell miniaudio that input and output      |
+    |                                         | frames are processed at different rates. You      |
+    |                                         | should set this for any nodes that perform        |
+    |                                         | resampling.                                       |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_SILENT_OUTPUT              | Used to tell miniaudio that a node produces only  |
+    |                                         | silent output. This is useful for nodes where you |
+    |                                         | don't want the output to contribute to the final  |
+    |                                         | mix. An example might be if you want split your   |
+    |                                         | stream and have one branch be output to a file.   |
+    |                                         | When using this flag, you should avoid writing to |
+    |                                         | the output buffer of the node's processing        |
+    |                                         | callback because miniaudio will ignore it anyway. |
+    +-----------------------------------------+---------------------------------------------------+
+
+
+If you need to make a copy of an audio stream for effect processing you can use a splitter node
+called `ma_splitter_node`. This takes has 1 input bus and splits the stream into 2 output buses.
+You can use it like this:
+
+    ```c
+    ma_splitter_node_config splitterNodeConfig = ma_splitter_node_config_init(channels);
+
+    ma_splitter_node splitterNode;
+    result = ma_splitter_node_init(&nodeGraph, &splitterNodeConfig, NULL, &splitterNode);
+    if (result != MA_SUCCESS) {
+        // Failed to create node.
+    }
+
+    // Attach your output buses to two different input buses (can be on two different nodes).
+    ma_node_attach_output_bus(&splitterNode, 0, ma_node_graph_get_endpoint(&nodeGraph), 0); // Attach directly to the endpoint.
+    ma_node_attach_output_bus(&splitterNode, 1, &myEffectNode,                          0); // Attach to input bus 0 of some effect node.
+    ```
+
+The volume of an output bus can be configured on a per-bus basis:
+
+    ```c
+    ma_node_set_output_bus_volume(&splitterNode, 0, 0.5f);
+    ma_node_set_output_bus_volume(&splitterNode, 1, 0.5f);
+    ```
+
+In the code above we're using the splitter node from before and changing the volume of each of the
+copied streams.
+
+You can start and stop a node with the following:
+
+    ```c
+    ma_node_set_state(&splitterNode, ma_node_state_started);    // The default state.
+    ma_node_set_state(&splitterNode, ma_node_state_stopped);
+    ```
+
+By default the node is in a started state, but since it won't be connected to anything won't
+actually be invoked by the node graph until it's connected. When you stop a node, data will not be
+read from any of its input connections. You can use this property to stop a group of sounds
+atomically.
+
+You can configure the initial state of a node in it's config:
+
+    ```c
+    nodeConfig.initialState = ma_node_state_stopped;
+    ```
+
+Note that for the stock specialized nodes, all of their configs will have a `nodeConfig` member
+which is the config to use with the base node. This is where the initial state can be configured
+for specialized nodes:
+
+    ```c
+    dataSourceNodeConfig.nodeConfig.initialState = ma_node_state_stopped;
+    ```
+
+When using a specialized node like `ma_data_source_node` or `ma_splitter_node`, be sure to not
+modify the `vtable` member of the `nodeConfig` object.
+
+
+7.1. Timing
+-----------
+The node graph supports starting and stopping nodes at scheduled times. This is especially useful
+for data source nodes where you want to get the node set up, but only start playback at a specific
+time. There are two clocks: local and global.
+
+A local clock is per-node, whereas the global clock is per graph. Scheduling starts and stops can
+only be done based on the global clock because the local clock will not be running while the node
+is stopped. The global clocks advances whenever `ma_node_graph_read_pcm_frames()` is called. On the
+other hand, the local clock only advances when the node's processing callback is fired, and is
+advanced based on the output frame count.
+
+To retrieve the global time, use `ma_node_graph_get_time()`. The global time can be set with
+`ma_node_graph_set_time()` which might be useful if you want to do seeking on a global timeline.
+Getting and setting the local time is similar. Use `ma_node_get_time()` to retrieve the local time,
+and `ma_node_set_time()` to set the local time. The global and local times will be advanced by the
+audio thread, so care should be taken to avoid data races. Ideally you should avoid calling these
+outside of the node processing callbacks which are always run on the audio thread.
+
+There is basic support for scheduling the starting and stopping of nodes. You can only schedule one
+start and one stop at a time. This is mainly intended for putting nodes into a started or stopped
+state in a frame-exact manner. Without this mechanism, starting and stopping of a node is limited
+to the resolution of a call to `ma_node_graph_read_pcm_frames()` which would typically be in blocks
+of several milliseconds. The following APIs can be used for scheduling node states:
+
+    ```c
+    ma_node_set_state_time()
+    ma_node_get_state_time()
+    ```
+
+The time is absolute and must be based on the global clock. An example is below:
+
+    ```c
+    ma_node_set_state_time(&myNode, ma_node_state_started, sampleRate*1);   // Delay starting to 1 second.
+    ma_node_set_state_time(&myNode, ma_node_state_stopped, sampleRate*5);   // Delay stopping to 5 seconds.
+    ```
+
+An example for changing the state using a relative time.
+
+    ```c
+    ma_node_set_state_time(&myNode, ma_node_state_started, sampleRate*1 + ma_node_graph_get_time(&myNodeGraph));
+    ma_node_set_state_time(&myNode, ma_node_state_stopped, sampleRate*5 + ma_node_graph_get_time(&myNodeGraph));
+    ```
+
+Note that due to the nature of multi-threading the times may not be 100% exact. If this is an
+issue, consider scheduling state changes from within a processing callback. An idea might be to
+have some kind of passthrough trigger node that is used specifically for tracking time and handling
+events.
+
+
+
+7.2. Thread Safety and Locking
+------------------------------
+When processing audio, it's ideal not to have any kind of locking in the audio thread. Since it's
+expected that `ma_node_graph_read_pcm_frames()` would be run on the audio thread, it does so
+without the use of any locks. This section discusses the implementation used by miniaudio and goes
+over some of the compromises employed by miniaudio to achieve this goal. Note that the current
+implementation may not be ideal - feedback and critiques are most welcome.
+
+The node graph API is not *entirely* lock-free. Only `ma_node_graph_read_pcm_frames()` is expected
+to be lock-free. Attachment, detachment and uninitialization of nodes use locks to simplify the
+implementation, but are crafted in a way such that such locking is not required when reading audio
+data from the graph. Locking in these areas are achieved by means of spinlocks.
+
+The main complication with keeping `ma_node_graph_read_pcm_frames()` lock-free stems from the fact
+that a node can be uninitialized, and it's memory potentially freed, while in the middle of being
+processed on the audio thread. There are times when the audio thread will be referencing a node,
+which means the uninitialization process of a node needs to make sure it delays returning until the
+audio thread is finished so that control is not handed back to the caller thereby giving them a
+chance to free the node's memory.
+
+When the audio thread is processing a node, it does so by reading from each of the output buses of
+the node. In order for a node to process data for one of its output buses, it needs to read from
+each of its input buses, and so on an so forth. It follows that once all output buses of a node
+are detached, the node as a whole will be disconnected and no further processing will occur unless
+it's output buses are reattached, which won't be happening when the node is being uninitialized.
+By having `ma_node_detach_output_bus()` wait until the audio thread is finished with it, we can
+simplify a few things, at the expense of making `ma_node_detach_output_bus()` a bit slower. By
+doing this, the implementation of `ma_node_uninit()` becomes trivial - just detach all output
+nodes, followed by each of the attachments to each of its input nodes, and then do any final clean
+up.
+
+With the above design, the worst-case scenario is `ma_node_detach_output_bus()` taking as long as
+it takes to process the output bus being detached. This will happen if it's called at just the
+wrong moment where the audio thread has just iterated it and has just started processing. The
+caller of `ma_node_detach_output_bus()` will stall until the audio thread is finished, which
+includes the cost of recursively processing its inputs. This is the biggest compromise made with
+the approach taken by miniaudio for its lock-free processing system. The cost of detaching nodes
+earlier in the pipeline (data sources, for example) will be cheaper than the cost of detaching
+higher level nodes, such as some kind of final post-processing endpoint. If you need to do mass
+detachments, detach starting from the lowest level nodes and work your way towards the final
+endpoint node (but don't try detaching the node graph's endpoint). If the audio thread is not
+running, detachment will be fast and detachment in any order will be the same. The reason nodes
+need to wait for their input attachments to complete is due to the potential for desyncs between
+data sources. If the node was to terminate processing mid way through processing its inputs,
+there's a chance that some of the underlying data sources will have been read, but then others not.
+That will then result in a potential desynchronization when detaching and reattaching higher-level
+nodes. A possible solution to this is to have an option when detaching to terminate processing
+before processing all input attachments which should be fairly simple.
+
+Another compromise, albeit less significant, is locking when attaching and detaching nodes. This
+locking is achieved by means of a spinlock in order to reduce memory overhead. A lock is present
+for each input bus and output bus. When an output bus is connected to an input bus, both the output
+bus and input bus is locked. This locking is specifically for attaching and detaching across
+different threads and does not affect `ma_node_graph_read_pcm_frames()` in any way. The locking and
+unlocking is mostly self-explanatory, but a slightly less intuitive aspect comes into it when
+considering that iterating over attachments must not break as a result of attaching or detaching a
+node while iteration is occurring.
+
+Attaching and detaching are both quite simple. When an output bus of a node is attached to an input
+bus of another node, it's added to a linked list. Basically, an input bus is a linked list, where
+each item in the list is and output bus. We have some intentional (and convenient) restrictions on
+what can done with the linked list in order to simplify the implementation. First of all, whenever
+something needs to iterate over the list, it must do so in a forward direction. Backwards iteration
+is not supported. Also, items can only be added to the start of the list.
+
+The linked list is a doubly-linked list where each item in the list (an output bus) holds a pointer
+to the next item in the list, and another to the previous item. A pointer to the previous item is
+only required for fast detachment of the node - it is never used in iteration. This is an
+important property because it means from the perspective of iteration, attaching and detaching of
+an item can be done with a single atomic assignment. This is exploited by both the attachment and
+detachment process. When attaching the node, the first thing that is done is the setting of the
+local "next" and "previous" pointers of the node. After that, the item is "attached" to the list
+by simply performing an atomic exchange with the head pointer. After that, the node is "attached"
+to the list from the perspective of iteration. Even though the "previous" pointer of the next item
+hasn't yet been set, from the perspective of iteration it's been attached because iteration will
+only be happening in a forward direction which means the "previous" pointer won't actually ever get
+used. The same general process applies to detachment. See `ma_node_attach_output_bus()` and
+`ma_node_detach_output_bus()` for the implementation of this mechanism.
+
+
+
+8. Decoding
+===========
+The `ma_decoder` API is used for reading audio files. Decoders are completely decoupled from
+devices and can be used independently. Built-in support is included for the following formats:
+
+    +---------+
+    | Format  |
+    +---------+
+    | WAV     |
+    | MP3     |
+    | FLAC    |
+    +---------+
+
+You can disable the built-in decoders by specifying one or more of the following options before the
+miniaudio implementation:
+
+    ```c
+    #define MA_NO_WAV
+    #define MA_NO_MP3
+    #define MA_NO_FLAC
+    ```
+
+miniaudio supports the ability to plug in custom decoders. See the section below for details on how
+to use custom decoders.
+
+A decoder can be initialized from a file with `ma_decoder_init_file()`, a block of memory with
+`ma_decoder_init_memory()`, or from data delivered via callbacks with `ma_decoder_init()`. Here is
+an example for loading a decoder from a file:
+
+    ```c
+    ma_decoder decoder;
+    ma_result result = ma_decoder_init_file("MySong.mp3", NULL, &decoder);
+    if (result != MA_SUCCESS) {
+        return false;   // An error occurred.
+    }
+
+    ...
+
+    ma_decoder_uninit(&decoder);
+    ```
+
+When initializing a decoder, you can optionally pass in a pointer to a `ma_decoder_config` object
+(the `NULL` argument in the example above) which allows you to configure the output format, channel
+count, sample rate and channel map:
+
+    ```c
+    ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 2, 48000);
+    ```
+
+When passing in `NULL` for decoder config in `ma_decoder_init*()`, the output format will be the
+same as that defined by the decoding backend.
+
+Data is read from the decoder as PCM frames. This will output the number of PCM frames actually
+read. If this is less than the requested number of PCM frames it means you've reached the end. The
+return value will be `MA_AT_END` if no samples have been read and the end has been reached.
+
+    ```c
+    ma_result result = ma_decoder_read_pcm_frames(pDecoder, pFrames, framesToRead, &framesRead);
+    if (framesRead < framesToRead) {
+        // Reached the end.
+    }
+    ```
+
+You can also seek to a specific frame like so:
+
+    ```c
+    ma_result result = ma_decoder_seek_to_pcm_frame(pDecoder, targetFrame);
+    if (result != MA_SUCCESS) {
+        return false;   // An error occurred.
+    }
+    ```
+
+If you want to loop back to the start, you can simply seek back to the first PCM frame:
+
+    ```c
+    ma_decoder_seek_to_pcm_frame(pDecoder, 0);
+    ```
+
+When loading a decoder, miniaudio uses a trial and error technique to find the appropriate decoding
+backend. This can be unnecessarily inefficient if the type is already known. In this case you can
+use `encodingFormat` variable in the device config to specify a specific encoding format you want
+to decode:
+
+    ```c
+    decoderConfig.encodingFormat = ma_encoding_format_wav;
+    ```
+
+See the `ma_encoding_format` enum for possible encoding formats.
+
+The `ma_decoder_init_file()` API will try using the file extension to determine which decoding
+backend to prefer.
+
+
+8.1. Custom Decoders
+--------------------
+It's possible to implement a custom decoder and plug it into miniaudio. This is extremely useful
+when you want to use the `ma_decoder` API, but need to support an encoding format that's not one of
+the stock formats supported by miniaudio. This can be put to particularly good use when using the
+`ma_engine` and/or `ma_resource_manager` APIs because they use `ma_decoder` internally. If, for
+example, you wanted to support Opus, you can do so with a custom decoder (there if a reference
+Opus decoder in the "extras" folder of the miniaudio repository which uses libopus + libopusfile).
+
+A custom decoder must implement a data source. A vtable called `ma_decoding_backend_vtable` needs
+to be implemented which is then passed into the decoder config:
+
+    ```c
+    ma_decoding_backend_vtable* pCustomBackendVTables[] =
+    {
+        &g_ma_decoding_backend_vtable_libvorbis,
+        &g_ma_decoding_backend_vtable_libopus
+    };
+
+    ...
+
+    decoderConfig = ma_decoder_config_init_default();
+    decoderConfig.pCustomBackendUserData = NULL;
+    decoderConfig.ppCustomBackendVTables = pCustomBackendVTables;
+    decoderConfig.customBackendCount     = sizeof(pCustomBackendVTables) / sizeof(pCustomBackendVTables[0]);
+    ```
+
+The `ma_decoding_backend_vtable` vtable has the following functions:
+
+    ```
+    onInit
+    onInitFile
+    onInitFileW
+    onInitMemory
+    onUninit
+    ```
+
+There are only two functions that must be implemented - `onInit` and `onUninit`. The other
+functions can be implemented for a small optimization for loading from a file path or memory. If
+these are not specified, miniaudio will deal with it for you via a generic implementation.
+
+When you initialize a custom data source (by implementing the `onInit` function in the vtable) you
+will need to output a pointer to a `ma_data_source` which implements your custom decoder. See the
+section about data sources for details on how to implement this. Alternatively, see the
+"custom_decoders" example in the miniaudio repository.
+
+The `onInit` function takes a pointer to some callbacks for the purpose of reading raw audio data
+from some arbitrary source. You'll use these functions to read from the raw data and perform the
+decoding. When you call them, you will pass in the `pReadSeekTellUserData` pointer to the relevant
+parameter.
+
+The `pConfig` parameter in `onInit` can be used to configure the backend if appropriate. It's only
+used as a hint and can be ignored. However, if any of the properties are relevant to your decoder,
+an optimal implementation will handle the relevant properties appropriately.
+
+If memory allocation is required, it should be done so via the specified allocation callbacks if
+possible (the `pAllocationCallbacks` parameter).
+
+If an error occurs when initializing the decoder, you should leave `ppBackend` unset, or set to
+NULL, and make sure everything is cleaned up appropriately and an appropriate result code returned.
+When multiple custom backends are specified, miniaudio will cycle through the vtables in the order
+they're listed in the array that's passed into the decoder config so it's important that your
+initialization routine is clean.
+
+When a decoder is uninitialized, the `onUninit` callback will be fired which will give you an
+opportunity to clean up and internal data.
+
+
+
+9. Encoding
+===========
+The `ma_encoding` API is used for writing audio files. The only supported output format is WAV.
+This can be disabled by specifying the following option before the implementation of miniaudio:
+
+    ```c
+    #define MA_NO_WAV
+    ```
+
+An encoder can be initialized to write to a file with `ma_encoder_init_file()` or from data
+delivered via callbacks with `ma_encoder_init()`. Below is an example for initializing an encoder
+to output to a file.
+
+    ```c
+    ma_encoder_config config = ma_encoder_config_init(ma_encoding_format_wav, FORMAT, CHANNELS, SAMPLE_RATE);
+    ma_encoder encoder;
+    ma_result result = ma_encoder_init_file("my_file.wav", &config, &encoder);
+    if (result != MA_SUCCESS) {
+        // Error
+    }
+
+    ...
+
+    ma_encoder_uninit(&encoder);
+    ```
+
+When initializing an encoder you must specify a config which is initialized with
+`ma_encoder_config_init()`. Here you must specify the file type, the output sample format, output
+channel count and output sample rate. The following file types are supported:
+
+    +------------------------+-------------+
+    | Enum                   | Description |
+    +------------------------+-------------+
+    | ma_encoding_format_wav | WAV         |
+    +------------------------+-------------+
+
+If the format, channel count or sample rate is not supported by the output file type an error will
+be returned. The encoder will not perform data conversion so you will need to convert it before
+outputting any audio data. To output audio data, use `ma_encoder_write_pcm_frames()`, like in the
+example below:
+
+    ```c
+    ma_uint64 framesWritten;
+    result = ma_encoder_write_pcm_frames(&encoder, pPCMFramesToWrite, framesToWrite, &framesWritten);
+    if (result != MA_SUCCESS) {
+        ... handle error ...
+    }
+    ```
+
+The `framesWritten` variable will contain the number of PCM frames that were actually written. This
+is optionally and you can pass in `NULL` if you need this.
+
+Encoders must be uninitialized with `ma_encoder_uninit()`.
+
+
+
+10. Data Conversion
+===================
+A data conversion API is included with miniaudio which supports the majority of data conversion
+requirements. This supports conversion between sample formats, channel counts (with channel
+mapping) and sample rates.
+
+
+10.1. Sample Format Conversion
+------------------------------
+Conversion between sample formats is achieved with the `ma_pcm_*_to_*()`, `ma_pcm_convert()` and
+`ma_convert_pcm_frames_format()` APIs. Use `ma_pcm_*_to_*()` to convert between two specific
+formats. Use `ma_pcm_convert()` to convert based on a `ma_format` variable. Use
+`ma_convert_pcm_frames_format()` to convert PCM frames where you want to specify the frame count
+and channel count as a variable instead of the total sample count.
+
+
+10.1.1. Dithering
+-----------------
+Dithering can be set using the ditherMode parameter.
+
+The different dithering modes include the following, in order of efficiency:
+
+    +-----------+--------------------------+
+    | Type      | Enum Token               |
+    +-----------+--------------------------+
+    | None      | ma_dither_mode_none      |
+    | Rectangle | ma_dither_mode_rectangle |
+    | Triangle  | ma_dither_mode_triangle  |
+    +-----------+--------------------------+
+
+Note that even if the dither mode is set to something other than `ma_dither_mode_none`, it will be
+ignored for conversions where dithering is not needed. Dithering is available for the following
+conversions:
+
+    ```
+    s16 -> u8
+    s24 -> u8
+    s32 -> u8
+    f32 -> u8
+    s24 -> s16
+    s32 -> s16
+    f32 -> s16
+    ```
+
+Note that it is not an error to pass something other than ma_dither_mode_none for conversions where
+dither is not used. It will just be ignored.
+
+
+
+10.2. Channel Conversion
+------------------------
+Channel conversion is used for channel rearrangement and conversion from one channel count to
+another. The `ma_channel_converter` API is used for channel conversion. Below is an example of
+initializing a simple channel converter which converts from mono to stereo.
+
+    ```c
+    ma_channel_converter_config config = ma_channel_converter_config_init(
+        ma_format,                      // Sample format
+        1,                              // Input channels
+        NULL,                           // Input channel map
+        2,                              // Output channels
+        NULL,                           // Output channel map
+        ma_channel_mix_mode_default);   // The mixing algorithm to use when combining channels.
+
+    result = ma_channel_converter_init(&config, NULL, &converter);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+    ```
+
+To perform the conversion simply call `ma_channel_converter_process_pcm_frames()` like so:
+
+    ```c
+    ma_result result = ma_channel_converter_process_pcm_frames(&converter, pFramesOut, pFramesIn, frameCount);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+    ```
+
+It is up to the caller to ensure the output buffer is large enough to accommodate the new PCM
+frames.
+
+Input and output PCM frames are always interleaved. Deinterleaved layouts are not supported.
+
+
+10.2.1. Channel Mapping
+-----------------------
+In addition to converting from one channel count to another, like the example above, the channel
+converter can also be used to rearrange channels. When initializing the channel converter, you can
+optionally pass in channel maps for both the input and output frames. If the channel counts are the
+same, and each channel map contains the same channel positions with the exception that they're in
+a different order, a simple shuffling of the channels will be performed. If, however, there is not
+a 1:1 mapping of channel positions, or the channel counts differ, the input channels will be mixed
+based on a mixing mode which is specified when initializing the `ma_channel_converter_config`
+object.
+
+When converting from mono to multi-channel, the mono channel is simply copied to each output
+channel. When going the other way around, the audio of each output channel is simply averaged and
+copied to the mono channel.
+
+In more complicated cases blending is used. The `ma_channel_mix_mode_simple` mode will drop excess
+channels and silence extra channels. For example, converting from 4 to 2 channels, the 3rd and 4th
+channels will be dropped, whereas converting from 2 to 4 channels will put silence into the 3rd and
+4th channels.
+
+The `ma_channel_mix_mode_rectangle` mode uses spacial locality based on a rectangle to compute a
+simple distribution between input and output. Imagine sitting in the middle of a room, with
+speakers on the walls representing channel positions. The `MA_CHANNEL_FRONT_LEFT` position can be
+thought of as being in the corner of the front and left walls.
+
+Finally, the `ma_channel_mix_mode_custom_weights` mode can be used to use custom user-defined
+weights. Custom weights can be passed in as the last parameter of
+`ma_channel_converter_config_init()`.
+
+Predefined channel maps can be retrieved with `ma_channel_map_init_standard()`. This takes a
+`ma_standard_channel_map` enum as its first parameter, which can be one of the following:
+
+    +-----------------------------------+-----------------------------------------------------------+
+    | Name                              | Description                                               |
+    +-----------------------------------+-----------------------------------------------------------+
+    | ma_standard_channel_map_default   | Default channel map used by miniaudio. See below.         |
+    | ma_standard_channel_map_microsoft | Channel map used by Microsoft's bitfield channel maps.    |
+    | ma_standard_channel_map_alsa      | Default ALSA channel map.                                 |
+    | ma_standard_channel_map_rfc3551   | RFC 3551. Based on AIFF.                                  |
+    | ma_standard_channel_map_flac      | FLAC channel map.                                         |
+    | ma_standard_channel_map_vorbis    | Vorbis channel map.                                       |
+    | ma_standard_channel_map_sound4    | FreeBSD's sound(4).                                       |
+    | ma_standard_channel_map_sndio     | sndio channel map. http://www.sndio.org/tips.html.        |
+    | ma_standard_channel_map_webaudio  | https://webaudio.github.io/web-audio-api/#ChannelOrdering |
+    +-----------------------------------+-----------------------------------------------------------+
+
+Below are the channel maps used by default in miniaudio (`ma_standard_channel_map_default`):
+
+    +---------------+---------------------------------+
+    | Channel Count | Mapping                         |
+    +---------------+---------------------------------+
+    | 1 (Mono)      | 0: MA_CHANNEL_MONO              |
+    +---------------+---------------------------------+
+    | 2 (Stereo)    | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT       |
+    +---------------+---------------------------------+
+    | 3             | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER      |
+    +---------------+---------------------------------+
+    | 4 (Surround)  | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_BACK_CENTER       |
+    +---------------+---------------------------------+
+    | 5             | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_BACK_LEFT    <br> |
+    |               | 4: MA_CHANNEL_BACK_RIGHT        |
+    +---------------+---------------------------------+
+    | 6 (5.1)       | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_LFE          <br> |
+    |               | 4: MA_CHANNEL_SIDE_LEFT    <br> |
+    |               | 5: MA_CHANNEL_SIDE_RIGHT        |
+    +---------------+---------------------------------+
+    | 7             | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_LFE          <br> |
+    |               | 4: MA_CHANNEL_BACK_CENTER  <br> |
+    |               | 4: MA_CHANNEL_SIDE_LEFT    <br> |
+    |               | 5: MA_CHANNEL_SIDE_RIGHT        |
+    +---------------+---------------------------------+
+    | 8 (7.1)       | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_LFE          <br> |
+    |               | 4: MA_CHANNEL_BACK_LEFT    <br> |
+    |               | 5: MA_CHANNEL_BACK_RIGHT   <br> |
+    |               | 6: MA_CHANNEL_SIDE_LEFT    <br> |
+    |               | 7: MA_CHANNEL_SIDE_RIGHT        |
+    +---------------+---------------------------------+
+    | Other         | All channels set to 0. This     |
+    |               | is equivalent to the same       |
+    |               | mapping as the device.          |
+    +---------------+---------------------------------+
+
+
+
+10.3. Resampling
+----------------
+Resampling is achieved with the `ma_resampler` object. To create a resampler object, do something
+like the following:
+
+    ```c
+    ma_resampler_config config = ma_resampler_config_init(
+        ma_format_s16,
+        channels,
+        sampleRateIn,
+        sampleRateOut,
+        ma_resample_algorithm_linear);
+
+    ma_resampler resampler;
+    ma_result result = ma_resampler_init(&config, NULL, &resampler);
+    if (result != MA_SUCCESS) {
+        // An error occurred...
+    }
+    ```
+
+Do the following to uninitialize the resampler:
+
+    ```c
+    ma_resampler_uninit(&resampler);
+    ```
+
+The following example shows how data can be processed
+
+    ```c
+    ma_uint64 frameCountIn  = 1000;
+    ma_uint64 frameCountOut = 2000;
+    ma_result result = ma_resampler_process_pcm_frames(&resampler, pFramesIn, &frameCountIn, pFramesOut, &frameCountOut);
+    if (result != MA_SUCCESS) {
+        // An error occurred...
+    }
+
+    // At this point, frameCountIn contains the number of input frames that were consumed and frameCountOut contains the
+    // number of output frames written.
+    ```
+
+To initialize the resampler you first need to set up a config (`ma_resampler_config`) with
+`ma_resampler_config_init()`. You need to specify the sample format you want to use, the number of
+channels, the input and output sample rate, and the algorithm.
+
+The sample format can be either `ma_format_s16` or `ma_format_f32`. If you need a different format
+you will need to perform pre- and post-conversions yourself where necessary. Note that the format
+is the same for both input and output. The format cannot be changed after initialization.
+
+The resampler supports multiple channels and is always interleaved (both input and output). The
+channel count cannot be changed after initialization.
+
+The sample rates can be anything other than zero, and are always specified in hertz. They should be
+set to something like 44100, etc. The sample rate is the only configuration property that can be
+changed after initialization.
+
+The miniaudio resampler has built-in support for the following algorithms:
+
+    +-----------+------------------------------+
+    | Algorithm | Enum Token                   |
+    +-----------+------------------------------+
+    | Linear    | ma_resample_algorithm_linear |
+    | Custom    | ma_resample_algorithm_custom |
+    +-----------+------------------------------+
+
+The algorithm cannot be changed after initialization.
+
+Processing always happens on a per PCM frame basis and always assumes interleaved input and output.
+De-interleaved processing is not supported. To process frames, use
+`ma_resampler_process_pcm_frames()`. On input, this function takes the number of output frames you
+can fit in the output buffer and the number of input frames contained in the input buffer. On
+output these variables contain the number of output frames that were written to the output buffer
+and the number of input frames that were consumed in the process. You can pass in NULL for the
+input buffer in which case it will be treated as an infinitely large buffer of zeros. The output
+buffer can also be NULL, in which case the processing will be treated as seek.
+
+The sample rate can be changed dynamically on the fly. You can change this with explicit sample
+rates with `ma_resampler_set_rate()` and also with a decimal ratio with
+`ma_resampler_set_rate_ratio()`. The ratio is in/out.
+
+Sometimes it's useful to know exactly how many input frames will be required to output a specific
+number of frames. You can calculate this with `ma_resampler_get_required_input_frame_count()`.
+Likewise, it's sometimes useful to know exactly how many frames would be output given a certain
+number of input frames. You can do this with `ma_resampler_get_expected_output_frame_count()`.
+
+Due to the nature of how resampling works, the resampler introduces some latency. This can be
+retrieved in terms of both the input rate and the output rate with
+`ma_resampler_get_input_latency()` and `ma_resampler_get_output_latency()`.
+
+
+10.3.1. Resampling Algorithms
+-----------------------------
+The choice of resampling algorithm depends on your situation and requirements.
+
+
+10.3.1.1. Linear Resampling
+---------------------------
+The linear resampler is the fastest, but comes at the expense of poorer quality. There is, however,
+some control over the quality of the linear resampler which may make it a suitable option depending
+on your requirements.
+
+The linear resampler performs low-pass filtering before or after downsampling or upsampling,
+depending on the sample rates you're converting between. When decreasing the sample rate, the
+low-pass filter will be applied before downsampling. When increasing the rate it will be performed
+after upsampling. By default a fourth order low-pass filter will be applied. This can be configured
+via the `lpfOrder` configuration variable. Setting this to 0 will disable filtering.
+
+The low-pass filter has a cutoff frequency which defaults to half the sample rate of the lowest of
+the input and output sample rates (Nyquist Frequency).
+
+The API for the linear resampler is the same as the main resampler API, only it's called
+`ma_linear_resampler`.
+
+
+10.3.2. Custom Resamplers
+-------------------------
+You can implement a custom resampler by using the `ma_resample_algorithm_custom` resampling
+algorithm and setting a vtable in the resampler config:
+
+    ```c
+    ma_resampler_config config = ma_resampler_config_init(..., ma_resample_algorithm_custom);
+    config.pBackendVTable = &g_customResamplerVTable;
+    ```
+
+Custom resamplers are useful if the stock algorithms are not appropriate for your use case. You
+need to implement the required functions in `ma_resampling_backend_vtable`. Note that not all
+functions in the vtable need to be implemented, but if it's possible to implement, they should be.
+
+You can use the `ma_linear_resampler` object for an example on how to implement the vtable. The
+`onGetHeapSize` callback is used to calculate the size of any internal heap allocation the custom
+resampler will need to make given the supplied config. When you initialize the resampler via the
+`onInit` callback, you'll be given a pointer to a heap allocation which is where you should store
+the heap allocated data. You should not free this data in `onUninit` because miniaudio will manage
+it for you.
+
+The `onProcess` callback is where the actual resampling takes place. On input, `pFrameCountIn`
+points to a variable containing the number of frames in the `pFramesIn` buffer and
+`pFrameCountOut` points to a variable containing the capacity in frames of the `pFramesOut` buffer.
+On output, `pFrameCountIn` should be set to the number of input frames that were fully consumed,
+whereas `pFrameCountOut` should be set to the number of frames that were written to `pFramesOut`.
+
+The `onSetRate` callback is optional and is used for dynamically changing the sample rate. If
+dynamic rate changes are not supported, you can set this callback to NULL.
+
+The `onGetInputLatency` and `onGetOutputLatency` functions are used for retrieving the latency in
+input and output rates respectively. These can be NULL in which case latency calculations will be
+assumed to be NULL.
+
+The `onGetRequiredInputFrameCount` callback is used to give miniaudio a hint as to how many input
+frames are required to be available to produce the given number of output frames. Likewise, the
+`onGetExpectedOutputFrameCount` callback is used to determine how many output frames will be
+produced given the specified number of input frames. miniaudio will use these as a hint, but they
+are optional and can be set to NULL if you're unable to implement them.
+
+
+
+10.4. General Data Conversion
+-----------------------------
+The `ma_data_converter` API can be used to wrap sample format conversion, channel conversion and
+resampling into one operation. This is what miniaudio uses internally to convert between the format
+requested when the device was initialized and the format of the backend's native device. The API
+for general data conversion is very similar to the resampling API. Create a `ma_data_converter`
+object like this:
+
+    ```c
+    ma_data_converter_config config = ma_data_converter_config_init(
+        inputFormat,
+        outputFormat,
+        inputChannels,
+        outputChannels,
+        inputSampleRate,
+        outputSampleRate
+    );
+
+    ma_data_converter converter;
+    ma_result result = ma_data_converter_init(&config, NULL, &converter);
+    if (result != MA_SUCCESS) {
+        // An error occurred...
+    }
+    ```
+
+In the example above we use `ma_data_converter_config_init()` to initialize the config, however
+there's many more properties that can be configured, such as channel maps and resampling quality.
+Something like the following may be more suitable depending on your requirements:
+
+    ```c
+    ma_data_converter_config config = ma_data_converter_config_init_default();
+    config.formatIn = inputFormat;
+    config.formatOut = outputFormat;
+    config.channelsIn = inputChannels;
+    config.channelsOut = outputChannels;
+    config.sampleRateIn = inputSampleRate;
+    config.sampleRateOut = outputSampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_flac, config.channelMapIn, sizeof(config.channelMapIn)/sizeof(config.channelMapIn[0]), config.channelCountIn);
+    config.resampling.linear.lpfOrder = MA_MAX_FILTER_ORDER;
+    ```
+
+Do the following to uninitialize the data converter:
+
+    ```c
+    ma_data_converter_uninit(&converter, NULL);
+    ```
+
+The following example shows how data can be processed
+
+    ```c
+    ma_uint64 frameCountIn  = 1000;
+    ma_uint64 frameCountOut = 2000;
+    ma_result result = ma_data_converter_process_pcm_frames(&converter, pFramesIn, &frameCountIn, pFramesOut, &frameCountOut);
+    if (result != MA_SUCCESS) {
+        // An error occurred...
+    }
+
+    // At this point, frameCountIn contains the number of input frames that were consumed and frameCountOut contains the number
+    // of output frames written.
+    ```
+
+The data converter supports multiple channels and is always interleaved (both input and output).
+The channel count cannot be changed after initialization.
+
+Sample rates can be anything other than zero, and are always specified in hertz. They should be set
+to something like 44100, etc. The sample rate is the only configuration property that can be
+changed after initialization, but only if the `resampling.allowDynamicSampleRate` member of
+`ma_data_converter_config` is set to `MA_TRUE`. To change the sample rate, use
+`ma_data_converter_set_rate()` or `ma_data_converter_set_rate_ratio()`. The ratio must be in/out.
+The resampling algorithm cannot be changed after initialization.
+
+Processing always happens on a per PCM frame basis and always assumes interleaved input and output.
+De-interleaved processing is not supported. To process frames, use
+`ma_data_converter_process_pcm_frames()`. On input, this function takes the number of output frames
+you can fit in the output buffer and the number of input frames contained in the input buffer. On
+output these variables contain the number of output frames that were written to the output buffer
+and the number of input frames that were consumed in the process. You can pass in NULL for the
+input buffer in which case it will be treated as an infinitely large
+buffer of zeros. The output buffer can also be NULL, in which case the processing will be treated
+as seek.
+
+Sometimes it's useful to know exactly how many input frames will be required to output a specific
+number of frames. You can calculate this with `ma_data_converter_get_required_input_frame_count()`.
+Likewise, it's sometimes useful to know exactly how many frames would be output given a certain
+number of input frames. You can do this with `ma_data_converter_get_expected_output_frame_count()`.
+
+Due to the nature of how resampling works, the data converter introduces some latency if resampling
+is required. This can be retrieved in terms of both the input rate and the output rate with
+`ma_data_converter_get_input_latency()` and `ma_data_converter_get_output_latency()`.
+
+
+
+11. Filtering
+=============
+
+11.1. Biquad Filtering
+----------------------
+Biquad filtering is achieved with the `ma_biquad` API. Example:
+
+    ```c
+    ma_biquad_config config = ma_biquad_config_init(ma_format_f32, channels, b0, b1, b2, a0, a1, a2);
+    ma_result result = ma_biquad_init(&config, NULL, &biquad);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_biquad_process_pcm_frames(&biquad, pFramesOut, pFramesIn, frameCount);
+    ```
+
+Biquad filtering is implemented using transposed direct form 2. The numerator coefficients are b0,
+b1 and b2, and the denominator coefficients are a0, a1 and a2. The a0 coefficient is required and
+coefficients must not be pre-normalized.
+
+Supported formats are `ma_format_s16` and `ma_format_f32`. If you need to use a different format
+you need to convert it yourself beforehand. When using `ma_format_s16` the biquad filter will use
+fixed point arithmetic. When using `ma_format_f32`, floating point arithmetic will be used.
+
+Input and output frames are always interleaved.
+
+Filtering can be applied in-place by passing in the same pointer for both the input and output
+buffers, like so:
+
+    ```c
+    ma_biquad_process_pcm_frames(&biquad, pMyData, pMyData, frameCount);
+    ```
+
+If you need to change the values of the coefficients, but maintain the values in the registers you
+can do so with `ma_biquad_reinit()`. This is useful if you need to change the properties of the
+filter while keeping the values of registers valid to avoid glitching. Do not use
+`ma_biquad_init()` for this as it will do a full initialization which involves clearing the
+registers to 0. Note that changing the format or channel count after initialization is invalid and
+will result in an error.
+
+
+11.2. Low-Pass Filtering
+------------------------
+Low-pass filtering is achieved with the following APIs:
+
+    +---------+------------------------------------------+
+    | API     | Description                              |
+    +---------+------------------------------------------+
+    | ma_lpf1 | First order low-pass filter              |
+    | ma_lpf2 | Second order low-pass filter             |
+    | ma_lpf  | High order low-pass filter (Butterworth) |
+    +---------+------------------------------------------+
+
+Low-pass filter example:
+
+    ```c
+    ma_lpf_config config = ma_lpf_config_init(ma_format_f32, channels, sampleRate, cutoffFrequency, order);
+    ma_result result = ma_lpf_init(&config, &lpf);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_lpf_process_pcm_frames(&lpf, pFramesOut, pFramesIn, frameCount);
+    ```
+
+Supported formats are `ma_format_s16` and` ma_format_f32`. If you need to use a different format
+you need to convert it yourself beforehand. Input and output frames are always interleaved.
+
+Filtering can be applied in-place by passing in the same pointer for both the input and output
+buffers, like so:
+
+    ```c
+    ma_lpf_process_pcm_frames(&lpf, pMyData, pMyData, frameCount);
+    ```
+
+The maximum filter order is limited to `MA_MAX_FILTER_ORDER` which is set to 8. If you need more,
+you can chain first and second order filters together.
+
+    ```c
+    for (iFilter = 0; iFilter < filterCount; iFilter += 1) {
+        ma_lpf2_process_pcm_frames(&lpf2[iFilter], pMyData, pMyData, frameCount);
+    }
+    ```
+
+If you need to change the configuration of the filter, but need to maintain the state of internal
+registers you can do so with `ma_lpf_reinit()`. This may be useful if you need to change the sample
+rate and/or cutoff frequency dynamically while maintaining smooth transitions. Note that changing the
+format or channel count after initialization is invalid and will result in an error.
+
+The `ma_lpf` object supports a configurable order, but if you only need a first order filter you
+may want to consider using `ma_lpf1`. Likewise, if you only need a second order filter you can use
+`ma_lpf2`. The advantage of this is that they're lighter weight and a bit more efficient.
+
+If an even filter order is specified, a series of second order filters will be processed in a
+chain. If an odd filter order is specified, a first order filter will be applied, followed by a
+series of second order filters in a chain.
+
+
+11.3. High-Pass Filtering
+-------------------------
+High-pass filtering is achieved with the following APIs:
+
+    +---------+-------------------------------------------+
+    | API     | Description                               |
+    +---------+-------------------------------------------+
+    | ma_hpf1 | First order high-pass filter              |
+    | ma_hpf2 | Second order high-pass filter             |
+    | ma_hpf  | High order high-pass filter (Butterworth) |
+    +---------+-------------------------------------------+
+
+High-pass filters work exactly the same as low-pass filters, only the APIs are called `ma_hpf1`,
+`ma_hpf2` and `ma_hpf`. See example code for low-pass filters for example usage.
+
+
+11.4. Band-Pass Filtering
+-------------------------
+Band-pass filtering is achieved with the following APIs:
+
+    +---------+-------------------------------+
+    | API     | Description                   |
+    +---------+-------------------------------+
+    | ma_bpf2 | Second order band-pass filter |
+    | ma_bpf  | High order band-pass filter   |
+    +---------+-------------------------------+
+
+Band-pass filters work exactly the same as low-pass filters, only the APIs are called `ma_bpf2` and
+`ma_hpf`. See example code for low-pass filters for example usage. Note that the order for
+band-pass filters must be an even number which means there is no first order band-pass filter,
+unlike low-pass and high-pass filters.
+
+
+11.5. Notch Filtering
+---------------------
+Notch filtering is achieved with the following APIs:
+
+    +-----------+------------------------------------------+
+    | API       | Description                              |
+    +-----------+------------------------------------------+
+    | ma_notch2 | Second order notching filter             |
+    +-----------+------------------------------------------+
+
+
+11.6. Peaking EQ Filtering
+-------------------------
+Peaking filtering is achieved with the following APIs:
+
+    +----------+------------------------------------------+
+    | API      | Description                              |
+    +----------+------------------------------------------+
+    | ma_peak2 | Second order peaking filter              |
+    +----------+------------------------------------------+
+
+
+11.7. Low Shelf Filtering
+-------------------------
+Low shelf filtering is achieved with the following APIs:
+
+    +-------------+------------------------------------------+
+    | API         | Description                              |
+    +-------------+------------------------------------------+
+    | ma_loshelf2 | Second order low shelf filter            |
+    +-------------+------------------------------------------+
+
+Where a high-pass filter is used to eliminate lower frequencies, a low shelf filter can be used to
+just turn them down rather than eliminate them entirely.
+
+
+11.8. High Shelf Filtering
+--------------------------
+High shelf filtering is achieved with the following APIs:
+
+    +-------------+------------------------------------------+
+    | API         | Description                              |
+    +-------------+------------------------------------------+
+    | ma_hishelf2 | Second order high shelf filter           |
+    +-------------+------------------------------------------+
+
+The high shelf filter has the same API as the low shelf filter, only you would use `ma_hishelf`
+instead of `ma_loshelf`. Where a low shelf filter is used to adjust the volume of low frequencies,
+the high shelf filter does the same thing for high frequencies.
+
+
+
+
+12. Waveform and Noise Generation
+=================================
+
+12.1. Waveforms
+---------------
+miniaudio supports generation of sine, square, triangle and sawtooth waveforms. This is achieved
+with the `ma_waveform` API. Example:
+
+    ```c
+    ma_waveform_config config = ma_waveform_config_init(
+        FORMAT,
+        CHANNELS,
+        SAMPLE_RATE,
+        ma_waveform_type_sine,
+        amplitude,
+        frequency);
+
+    ma_waveform waveform;
+    ma_result result = ma_waveform_init(&config, &waveform);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_waveform_read_pcm_frames(&waveform, pOutput, frameCount);
+    ```
+
+The amplitude, frequency, type, and sample rate can be changed dynamically with
+`ma_waveform_set_amplitude()`, `ma_waveform_set_frequency()`, `ma_waveform_set_type()`, and
+`ma_waveform_set_sample_rate()` respectively.
+
+You can invert the waveform by setting the amplitude to a negative value. You can use this to
+control whether or not a sawtooth has a positive or negative ramp, for example.
+
+Below are the supported waveform types:
+
+    +---------------------------+
+    | Enum Name                 |
+    +---------------------------+
+    | ma_waveform_type_sine     |
+    | ma_waveform_type_square   |
+    | ma_waveform_type_triangle |
+    | ma_waveform_type_sawtooth |
+    +---------------------------+
+
+
+
+12.2. Noise
+-----------
+miniaudio supports generation of white, pink and Brownian noise via the `ma_noise` API. Example:
+
+    ```c
+    ma_noise_config config = ma_noise_config_init(
+        FORMAT,
+        CHANNELS,
+        ma_noise_type_white,
+        SEED,
+        amplitude);
+
+    ma_noise noise;
+    ma_result result = ma_noise_init(&config, &noise);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_noise_read_pcm_frames(&noise, pOutput, frameCount);
+    ```
+
+The noise API uses simple LCG random number generation. It supports a custom seed which is useful
+for things like automated testing requiring reproducibility. Setting the seed to zero will default
+to `MA_DEFAULT_LCG_SEED`.
+
+The amplitude and seed can be changed dynamically with `ma_noise_set_amplitude()` and
+`ma_noise_set_seed()` respectively.
+
+By default, the noise API will use different values for different channels. So, for example, the
+left side in a stereo stream will be different to the right side. To instead have each channel use
+the same random value, set the `duplicateChannels` member of the noise config to true, like so:
+
+    ```c
+    config.duplicateChannels = MA_TRUE;
+    ```
+
+Below are the supported noise types.
+
+    +------------------------+
+    | Enum Name              |
+    +------------------------+
+    | ma_noise_type_white    |
+    | ma_noise_type_pink     |
+    | ma_noise_type_brownian |
+    +------------------------+
+
+
+
+13. Audio Buffers
+=================
+miniaudio supports reading from a buffer of raw audio data via the `ma_audio_buffer` API. This can
+read from memory that's managed by the application, but can also handle the memory management for
+you internally. Memory management is flexible and should support most use cases.
+
+Audio buffers are initialized using the standard configuration system used everywhere in miniaudio:
+
+    ```c
+    ma_audio_buffer_config config = ma_audio_buffer_config_init(
+        format,
+        channels,
+        sizeInFrames,
+        pExistingData,
+        &allocationCallbacks);
+
+    ma_audio_buffer buffer;
+    result = ma_audio_buffer_init(&config, &buffer);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_audio_buffer_uninit(&buffer);
+    ```
+
+In the example above, the memory pointed to by `pExistingData` will *not* be copied and is how an
+application can do self-managed memory allocation. If you would rather make a copy of the data, use
+`ma_audio_buffer_init_copy()`. To uninitialize the buffer, use `ma_audio_buffer_uninit()`.
+
+Sometimes it can be convenient to allocate the memory for the `ma_audio_buffer` structure and the
+raw audio data in a contiguous block of memory. That is, the raw audio data will be located
+immediately after the `ma_audio_buffer` structure. To do this, use
+`ma_audio_buffer_alloc_and_init()`:
+
+    ```c
+    ma_audio_buffer_config config = ma_audio_buffer_config_init(
+        format,
+        channels,
+        sizeInFrames,
+        pExistingData,
+        &allocationCallbacks);
+
+    ma_audio_buffer* pBuffer
+    result = ma_audio_buffer_alloc_and_init(&config, &pBuffer);
+    if (result != MA_SUCCESS) {
+        // Error
+    }
+
+    ...
+
+    ma_audio_buffer_uninit_and_free(&buffer);
+    ```
+
+If you initialize the buffer with `ma_audio_buffer_alloc_and_init()` you should uninitialize it
+with `ma_audio_buffer_uninit_and_free()`. In the example above, the memory pointed to by
+`pExistingData` will be copied into the buffer, which is contrary to the behavior of
+`ma_audio_buffer_init()`.
+
+An audio buffer has a playback cursor just like a decoder. As you read frames from the buffer, the
+cursor moves forward. The last parameter (`loop`) can be used to determine if the buffer should
+loop. The return value is the number of frames actually read. If this is less than the number of
+frames requested it means the end has been reached. This should never happen if the `loop`
+parameter is set to true. If you want to manually loop back to the start, you can do so with with
+`ma_audio_buffer_seek_to_pcm_frame(pAudioBuffer, 0)`. Below is an example for reading data from an
+audio buffer.
+
+    ```c
+    ma_uint64 framesRead = ma_audio_buffer_read_pcm_frames(pAudioBuffer, pFramesOut, desiredFrameCount, isLooping);
+    if (framesRead < desiredFrameCount) {
+        // If not looping, this means the end has been reached. This should never happen in looping mode with valid input.
+    }
+    ```
+
+Sometimes you may want to avoid the cost of data movement between the internal buffer and the
+output buffer. Instead you can use memory mapping to retrieve a pointer to a segment of data:
+
+    ```c
+    void* pMappedFrames;
+    ma_uint64 frameCount = frameCountToTryMapping;
+    ma_result result = ma_audio_buffer_map(pAudioBuffer, &pMappedFrames, &frameCount);
+    if (result == MA_SUCCESS) {
+        // Map was successful. The value in frameCount will be how many frames were _actually_ mapped, which may be
+        // less due to the end of the buffer being reached.
+        ma_copy_pcm_frames(pFramesOut, pMappedFrames, frameCount, pAudioBuffer->format, pAudioBuffer->channels);
+
+        // You must unmap the buffer.
+        ma_audio_buffer_unmap(pAudioBuffer, frameCount);
+    }
+    ```
+
+When you use memory mapping, the read cursor is increment by the frame count passed in to
+`ma_audio_buffer_unmap()`. If you decide not to process every frame you can pass in a value smaller
+than the value returned by `ma_audio_buffer_map()`. The disadvantage to using memory mapping is
+that it does not handle looping for you. You can determine if the buffer is at the end for the
+purpose of looping with `ma_audio_buffer_at_end()` or by inspecting the return value of
+`ma_audio_buffer_unmap()` and checking if it equals `MA_AT_END`. You should not treat `MA_AT_END`
+as an error when returned by `ma_audio_buffer_unmap()`.
+
+
+
+14. Ring Buffers
+================
+miniaudio supports lock free (single producer, single consumer) ring buffers which are exposed via
+the `ma_rb` and `ma_pcm_rb` APIs. The `ma_rb` API operates on bytes, whereas the `ma_pcm_rb`
+operates on PCM frames. They are otherwise identical as `ma_pcm_rb` is just a wrapper around
+`ma_rb`.
+
+Unlike most other APIs in miniaudio, ring buffers support both interleaved and deinterleaved
+streams. The caller can also allocate their own backing memory for the ring buffer to use
+internally for added flexibility. Otherwise the ring buffer will manage it's internal memory for
+you.
+
+The examples below use the PCM frame variant of the ring buffer since that's most likely the one
+you will want to use. To initialize a ring buffer, do something like the following:
+
+    ```c
+    ma_pcm_rb rb;
+    ma_result result = ma_pcm_rb_init(FORMAT, CHANNELS, BUFFER_SIZE_IN_FRAMES, NULL, NULL, &rb);
+    if (result != MA_SUCCESS) {
+        // Error
+    }
+    ```
+
+The `ma_pcm_rb_init()` function takes the sample format and channel count as parameters because
+it's the PCM variant of the ring buffer API. For the regular ring buffer that operates on bytes you
+would call `ma_rb_init()` which leaves these out and just takes the size of the buffer in bytes
+instead of frames. The fourth parameter is an optional pre-allocated buffer and the fifth parameter
+is a pointer to a `ma_allocation_callbacks` structure for custom memory allocation routines.
+Passing in `NULL` for this results in `MA_MALLOC()` and `MA_FREE()` being used.
+
+Use `ma_pcm_rb_init_ex()` if you need a deinterleaved buffer. The data for each sub-buffer is
+offset from each other based on the stride. To manage your sub-buffers you can use
+`ma_pcm_rb_get_subbuffer_stride()`, `ma_pcm_rb_get_subbuffer_offset()` and
+`ma_pcm_rb_get_subbuffer_ptr()`.
+
+Use `ma_pcm_rb_acquire_read()` and `ma_pcm_rb_acquire_write()` to retrieve a pointer to a section
+of the ring buffer. You specify the number of frames you need, and on output it will set to what
+was actually acquired. If the read or write pointer is positioned such that the number of frames
+requested will require a loop, it will be clamped to the end of the buffer. Therefore, the number
+of frames you're given may be less than the number you requested.
+
+After calling `ma_pcm_rb_acquire_read()` or `ma_pcm_rb_acquire_write()`, you do your work on the
+buffer and then "commit" it with `ma_pcm_rb_commit_read()` or `ma_pcm_rb_commit_write()`. This is
+where the read/write pointers are updated. When you commit you need to pass in the buffer that was
+returned by the earlier call to `ma_pcm_rb_acquire_read()` or `ma_pcm_rb_acquire_write()` and is
+only used for validation. The number of frames passed to `ma_pcm_rb_commit_read()` and
+`ma_pcm_rb_commit_write()` is what's used to increment the pointers, and can be less that what was
+originally requested.
+
+If you want to correct for drift between the write pointer and the read pointer you can use a
+combination of `ma_pcm_rb_pointer_distance()`, `ma_pcm_rb_seek_read()` and
+`ma_pcm_rb_seek_write()`. Note that you can only move the pointers forward, and you should only
+move the read pointer forward via the consumer thread, and the write pointer forward by the
+producer thread. If there is too much space between the pointers, move the read pointer forward. If
+there is too little space between the pointers, move the write pointer forward.
+
+You can use a ring buffer at the byte level instead of the PCM frame level by using the `ma_rb`
+API. This is exactly the same, only you will use the `ma_rb` functions instead of `ma_pcm_rb` and
+instead of frame counts you will pass around byte counts.
+
+The maximum size of the buffer in bytes is `0x7FFFFFFF-(MA_SIMD_ALIGNMENT-1)` due to the most
+significant bit being used to encode a loop flag and the internally managed buffers always being
+aligned to `MA_SIMD_ALIGNMENT`.
+
+Note that the ring buffer is only thread safe when used by a single consumer thread and single
+producer thread.
+
+
+
+15. Backends
+============
+The following backends are supported by miniaudio. These are listed in order of default priority.
+When no backend is specified when initializing a context or device, miniaudio will attempt to use
+each of these backends in the order listed in the table below.
+
+Note that backends that are not usable by the build target will not be included in the build. For
+example, ALSA, which is specific to Linux, will not be included in the Windows build.
+
+    +-------------+-----------------------+--------------------------------------------------------+
+    | Name        | Enum Name             | Supported Operating Systems                            |
+    +-------------+-----------------------+--------------------------------------------------------+
+    | WASAPI      | ma_backend_wasapi     | Windows Vista+                                         |
+    | DirectSound | ma_backend_dsound     | Windows XP+                                            |
+    | WinMM       | ma_backend_winmm      | Windows 95+                                            |
+    | Core Audio  | ma_backend_coreaudio  | macOS, iOS                                             |
+    | sndio       | ma_backend_sndio      | OpenBSD                                                |
+    | audio(4)    | ma_backend_audio4     | NetBSD, OpenBSD                                        |
+    | OSS         | ma_backend_oss        | FreeBSD                                                |
+    | PulseAudio  | ma_backend_pulseaudio | Cross Platform (disabled on Windows, BSD and Android)  |
+    | ALSA        | ma_backend_alsa       | Linux                                                  |
+    | JACK        | ma_backend_jack       | Cross Platform (disabled on BSD and Android)           |
+    | AAudio      | ma_backend_aaudio     | Android 8+                                             |
+    | OpenSL ES   | ma_backend_opensl     | Android (API level 16+)                                |
+    | Web Audio   | ma_backend_webaudio   | Web (via Emscripten)                                   |
+    | Custom      | ma_backend_custom     | Cross Platform                                         |
+    | Null        | ma_backend_null       | Cross Platform (not used on Web)                       |
+    +-------------+-----------------------+--------------------------------------------------------+
+
+Some backends have some nuance details you may want to be aware of.
+
+15.1. WASAPI
+------------
+- Low-latency shared mode will be disabled when using an application-defined sample rate which is
+  different to the device's native sample rate. To work around this, set `wasapi.noAutoConvertSRC`
+  to true in the device config. This is due to IAudioClient3_InitializeSharedAudioStream() failing
+  when the `AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM` flag is specified. Setting wasapi.noAutoConvertSRC
+  will result in miniaudio's internal resampler being used instead which will in turn enable the
+  use of low-latency shared mode.
+
+15.2. PulseAudio
+----------------
+- If you experience bad glitching/noise on Arch Linux, consider this fix from the Arch wiki:
+  https://wiki.archlinux.org/index.php/PulseAudio/Troubleshooting#Glitches,_skips_or_crackling.
+  Alternatively, consider using a different backend such as ALSA.
+
+15.3. Android
+-------------
+- To capture audio on Android, remember to add the RECORD_AUDIO permission to your manifest:
+  `<uses-permission android:name="android.permission.RECORD_AUDIO" />`
+- With OpenSL|ES, only a single ma_context can be active at any given time. This is due to a
+  limitation with OpenSL|ES.
+- With AAudio, only default devices are enumerated. This is due to AAudio not having an enumeration
+  API (devices are enumerated through Java). You can however perform your own device enumeration
+  through Java and then set the ID in the ma_device_id structure (ma_device_id.aaudio) and pass it
+  to ma_device_init().
+- The backend API will perform resampling where possible. The reason for this as opposed to using
+  miniaudio's built-in resampler is to take advantage of any potential device-specific
+  optimizations the driver may implement.
+
+BSD
+---
+- The sndio backend is currently only enabled on OpenBSD builds.
+- The audio(4) backend is supported on OpenBSD, but you may need to disable sndiod before you can
+  use it.
+
+15.4. UWP
+---------
+- UWP only supports default playback and capture devices.
+- UWP requires the Microphone capability to be enabled in the application's manifest (Package.appxmanifest):
+
+    ```
+    <Package ...>
+        ...
+        <Capabilities>
+            <DeviceCapability Name="microphone" />
+        </Capabilities>
+    </Package>
+    ```
+
+15.5. Web Audio / Emscripten
+----------------------------
+- You cannot use `-std=c*` compiler flags, nor `-ansi`. This only applies to the Emscripten build.
+- The first time a context is initialized it will create a global object called "miniaudio" whose
+  primary purpose is to act as a factory for device objects.
+- Currently the Web Audio backend uses ScriptProcessorNode's, but this may need to change later as
+  they've been deprecated.
+- Google has implemented a policy in their browsers that prevent automatic media output without
+  first receiving some kind of user input. The following web page has additional details:
+  https://developers.google.com/web/updates/2017/09/autoplay-policy-changes. Starting the device
+  may fail if you try to start playback without first handling some kind of user input.
+
+
+
+16. Optimization Tips
+=====================
+See below for some tips on improving performance.
+
+16.1. Low Level API
+-------------------
+- In the data callback, if your data is already clipped prior to copying it into the output buffer,
+  set the `noClip` config option in the device config to true. This will disable miniaudio's built
+  in clipping function.
+- By default, miniaudio will pre-silence the data callback's output buffer. If you know that you
+  will always write valid data to the output buffer you can disable pre-silencing by setting the
+  `noPreSilence` config option in the device config to true.
+
+16.2. High Level API
+--------------------
+- If a sound does not require doppler or pitch shifting, consider disabling pitching by
+  initializing the sound with the `MA_SOUND_FLAG_NO_PITCH` flag.
+- If a sound does not require spatialization, disable it by initializing the sound with the
+  `MA_SOUND_FLAG_NO_SPATIALIZATION` flag. It can be re-enabled again post-initialization with
+  `ma_sound_set_spatialization_enabled()`.
+- If you know all of your sounds will always be the same sample rate, set the engine's sample
+  rate to match that of the sounds. Likewise, if you're using a self-managed resource manager,
+  consider setting the decoded sample rate to match your sounds. By configuring everything to
+  use a consistent sample rate, sample rate conversion can be avoided.
+
+
+
+17. Miscellaneous Notes
+=======================
+- Automatic stream routing is enabled on a per-backend basis. Support is explicitly enabled for
+  WASAPI and Core Audio, however other backends such as PulseAudio may naturally support it, though
+  not all have been tested.
+- When compiling with VC6 and earlier, decoding is restricted to files less than 2GB in size. This
+  is due to 64-bit file APIs not being available.
+*/
+
+#ifndef miniaudio_h
+#define miniaudio_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MA_STRINGIFY(x)     #x
+#define MA_XSTRINGIFY(x)    MA_STRINGIFY(x)
+
+#define MA_VERSION_MAJOR    0
+#define MA_VERSION_MINOR    11
+#define MA_VERSION_REVISION 23
+#define MA_VERSION_STRING   MA_XSTRINGIFY(MA_VERSION_MAJOR) "." MA_XSTRINGIFY(MA_VERSION_MINOR) "." MA_XSTRINGIFY(MA_VERSION_REVISION)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(push)
+    #pragma warning(disable:4201)   /* nonstandard extension used: nameless struct/union */
+    #pragma warning(disable:4214)   /* nonstandard extension used: bit field types other than int */
+    #pragma warning(disable:4324)   /* structure was padded due to alignment specifier */
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic" /* For ISO C99 doesn't support unnamed structs/unions [-Wpedantic] */
+    #if defined(__clang__)
+        #pragma GCC diagnostic ignored "-Wc11-extensions"   /* anonymous unions are a C11 extension */
+    #endif
+#endif
+
+
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(_M_ARM64) || defined(__powerpc64__) || defined(__ppc64__)
+    #define MA_SIZEOF_PTR   8
+#else
+    #define MA_SIZEOF_PTR   4
+#endif
+
+#include <stddef.h> /* For size_t. */
+
+/* Sized types. */
+#if defined(MA_USE_STDINT)
+    #include <stdint.h>
+    typedef int8_t   ma_int8;
+    typedef uint8_t  ma_uint8;
+    typedef int16_t  ma_int16;
+    typedef uint16_t ma_uint16;
+    typedef int32_t  ma_int32;
+    typedef uint32_t ma_uint32;
+    typedef int64_t  ma_int64;
+    typedef uint64_t ma_uint64;
+#else
+    typedef   signed char           ma_int8;
+    typedef unsigned char           ma_uint8;
+    typedef   signed short          ma_int16;
+    typedef unsigned short          ma_uint16;
+    typedef   signed int            ma_int32;
+    typedef unsigned int            ma_uint32;
+    #if defined(_MSC_VER) && !defined(__clang__)
+        typedef   signed __int64    ma_int64;
+        typedef unsigned __int64    ma_uint64;
+    #else
+        #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+            #pragma GCC diagnostic push
+            #pragma GCC diagnostic ignored "-Wlong-long"
+            #if defined(__clang__)
+                #pragma GCC diagnostic ignored "-Wc++11-long-long"
+            #endif
+        #endif
+        typedef   signed long long  ma_int64;
+        typedef unsigned long long  ma_uint64;
+        #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+            #pragma GCC diagnostic pop
+        #endif
+    #endif
+#endif  /* MA_USE_STDINT */
+
+#if MA_SIZEOF_PTR == 8
+    typedef ma_uint64           ma_uintptr;
+#else
+    typedef ma_uint32           ma_uintptr;
+#endif
+
+typedef ma_uint8    ma_bool8;
+typedef ma_uint32   ma_bool32;
+#define MA_TRUE     1
+#define MA_FALSE    0
+
+/* These float types are not used universally by miniaudio. It's to simplify some macro expansion for atomic types. */
+typedef float       ma_float;
+typedef double      ma_double;
+
+typedef void* ma_handle;
+typedef void* ma_ptr;
+
+/*
+ma_proc is annoying because when compiling with GCC we get pedantic warnings about converting
+between `void*` and `void (*)()`. We can't use `void (*)()` with MSVC however, because we'll get
+warning C4191 about "type cast between incompatible function types". To work around this I'm going
+to use a different data type depending on the compiler.
+*/
+#if defined(__GNUC__)
+typedef void (*ma_proc)(void);
+#else
+typedef void* ma_proc;
+#endif
+
+#if defined(_MSC_VER) && !defined(_WCHAR_T_DEFINED)
+typedef ma_uint16 wchar_t;
+#endif
+
+/* Define NULL for some compilers. */
+#ifndef NULL
+#define NULL 0
+#endif
+
+#if defined(SIZE_MAX)
+    #define MA_SIZE_MAX    SIZE_MAX
+#else
+    #define MA_SIZE_MAX    0xFFFFFFFF  /* When SIZE_MAX is not defined by the standard library just default to the maximum 32-bit unsigned integer. */
+#endif
+
+#define MA_UINT64_MAX      (((ma_uint64)0xFFFFFFFF << 32) | (ma_uint64)0xFFFFFFFF)   /* Weird shifting syntax is for VC6 compatibility. */
+
+
+/* Platform/backend detection. */
+#if defined(_WIN32) || defined(__COSMOPOLITAN__)
+    #define MA_WIN32
+    #if defined(MA_FORCE_UWP) || (defined(WINAPI_FAMILY) && ((defined(WINAPI_FAMILY_PC_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PC_APP) || (defined(WINAPI_FAMILY_PHONE_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)))
+        #define MA_WIN32_UWP
+    #elif defined(WINAPI_FAMILY) && (defined(WINAPI_FAMILY_GAMES) && WINAPI_FAMILY == WINAPI_FAMILY_GAMES)
+        #define MA_WIN32_GDK
+    #elif defined(NXDK)
+        #define MA_WIN32_NXDK
+    #else
+        #define MA_WIN32_DESKTOP
+    #endif
+
+    /* The original Xbox. */
+    #if defined(NXDK)   /* <-- Add other Xbox compiler toolchains here, and then add a toolchain-specific define in case we need to discriminate between them later. */
+        #define MA_XBOX
+
+        #if defined(NXDK)
+            #define MA_XBOX_NXDK
+        #endif
+    #endif
+#endif
+#if defined(__MSDOS__) || defined(MSDOS) || defined(_MSDOS) || defined(__DOS__)
+    #define MA_DOS
+
+    /* No threading allowed on DOS. */
+    #ifndef MA_NO_THREADING
+    #define MA_NO_THREADING
+    #endif
+
+    /* No runtime linking allowed on DOS. */
+    #ifndef MA_NO_RUNTIME_LINKING
+    #define MA_NO_RUNTIME_LINKING
+    #endif
+#endif
+#if !defined(MA_WIN32) && !defined(MA_DOS)    /* If it's not Win32, assume POSIX. */
+    #define MA_POSIX
+
+    #if !defined(MA_NO_THREADING)
+        /*
+        Use the MA_NO_PTHREAD_IN_HEADER option at your own risk. This is intentionally undocumented.
+        You can use this to avoid including pthread.h in the header section. The downside is that it
+        results in some fixed sized structures being declared for the various types that are used in
+        miniaudio. The risk here is that these types might be too small for a given platform. This
+        risk is yours to take and no support will be offered if you enable this option.
+        */
+        #ifndef MA_NO_PTHREAD_IN_HEADER
+            #include <pthread.h>    /* Unfortunate #include, but needed for pthread_t, pthread_mutex_t and pthread_cond_t types. */
+            typedef pthread_t       ma_pthread_t;
+            typedef pthread_mutex_t ma_pthread_mutex_t;
+            typedef pthread_cond_t  ma_pthread_cond_t;
+        #else
+            typedef ma_uintptr      ma_pthread_t;
+            typedef union           ma_pthread_mutex_t { char __data[40]; ma_uint64 __alignment; } ma_pthread_mutex_t;
+            typedef union           ma_pthread_cond_t  { char __data[48]; ma_uint64 __alignment; } ma_pthread_cond_t;
+        #endif
+    #endif
+
+    #if defined(__unix__)
+        #define MA_UNIX
+    #endif
+    #if defined(__linux__)
+        #define MA_LINUX
+    #endif
+    #if defined(__APPLE__)
+        #define MA_APPLE
+    #endif
+    #if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+        #define MA_BSD
+    #endif
+    #if defined(__ANDROID__)
+        #define MA_ANDROID
+    #endif
+    #if defined(__EMSCRIPTEN__)
+        #define MA_EMSCRIPTEN
+    #endif
+    #if defined(__ORBIS__)
+        #define MA_ORBIS
+    #endif
+    #if defined(__PROSPERO__)
+        #define MA_PROSPERO
+    #endif
+    #if defined(__3DS__)
+        #define MA_3DS
+    #endif
+    #if defined(__SWITCH__) || defined(__NX__)
+        #define MA_SWITCH
+    #endif
+    #if defined(__BEOS__) || defined(__HAIKU__)
+        #define MA_BEOS
+    #endif
+    #if defined(__HAIKU__)
+        #define MA_HAIKU
+    #endif
+#endif
+
+#if !defined(MA_FALLTHROUGH) && defined(__cplusplus) && __cplusplus >= 201703L
+    #define MA_FALLTHROUGH [[fallthrough]]
+#endif
+#if !defined(MA_FALLTHROUGH) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
+    #define MA_FALLTHROUGH [[fallthrough]]
+#endif
+#if !defined(MA_FALLTHROUGH) && defined(__has_attribute)
+    #if __has_attribute(fallthrough)
+        #define MA_FALLTHROUGH __attribute__((fallthrough))
+    #endif
+#endif
+#if !defined(MA_FALLTHROUGH)
+    #define MA_FALLTHROUGH ((void)0)
+#endif
+
+#ifdef _MSC_VER
+    #define MA_INLINE __forceinline
+
+    /* noinline was introduced in Visual Studio 2005. */
+    #if _MSC_VER >= 1400
+        #define MA_NO_INLINE __declspec(noinline)
+    #else
+        #define MA_NO_INLINE
+    #endif
+#elif defined(__GNUC__)
+    /*
+    I've had a bug report where GCC is emitting warnings about functions possibly not being inlineable. This warning happens when
+    the __attribute__((always_inline)) attribute is defined without an "inline" statement. I think therefore there must be some
+    case where "__inline__" is not always defined, thus the compiler emitting these warnings. When using -std=c89 or -ansi on the
+    command line, we cannot use the "inline" keyword and instead need to use "__inline__". In an attempt to work around this issue
+    I am using "__inline__" only when we're compiling in strict ANSI mode.
+    */
+    #if defined(__STRICT_ANSI__)
+        #define MA_GNUC_INLINE_HINT __inline__
+    #else
+        #define MA_GNUC_INLINE_HINT inline
+    #endif
+
+    #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2)) || defined(__clang__)
+        #define MA_INLINE MA_GNUC_INLINE_HINT __attribute__((always_inline))
+        #define MA_NO_INLINE __attribute__((noinline))
+    #else
+        #define MA_INLINE MA_GNUC_INLINE_HINT
+        #define MA_NO_INLINE
+    #endif
+#elif defined(__WATCOMC__)
+    #define MA_INLINE __inline
+    #define MA_NO_INLINE
+#else
+    #define MA_INLINE
+    #define MA_NO_INLINE
+#endif
+
+/* MA_DLL is not officially supported. You're on your own if you want to use this. */
+#if defined(MA_DLL)
+    #if defined(_WIN32)
+        #define MA_DLL_IMPORT  __declspec(dllimport)
+        #define MA_DLL_EXPORT  __declspec(dllexport)
+        #define MA_DLL_PRIVATE static
+    #else
+        #if defined(__GNUC__) && __GNUC__ >= 4
+            #define MA_DLL_IMPORT  __attribute__((visibility("default")))
+            #define MA_DLL_EXPORT  __attribute__((visibility("default")))
+            #define MA_DLL_PRIVATE __attribute__((visibility("hidden")))
+        #else
+            #define MA_DLL_IMPORT
+            #define MA_DLL_EXPORT
+            #define MA_DLL_PRIVATE static
+        #endif
+    #endif
+#endif
+
+#if !defined(MA_API)
+    #if defined(MA_DLL)
+        #if defined(MINIAUDIO_IMPLEMENTATION) || defined(MA_IMPLEMENTATION)
+            #define MA_API  MA_DLL_EXPORT
+        #else
+            #define MA_API  MA_DLL_IMPORT
+        #endif
+    #else
+        #define MA_API extern
+    #endif
+#endif
+
+#if !defined(MA_STATIC)
+    #if defined(MA_DLL)
+        #define MA_PRIVATE MA_DLL_PRIVATE
+    #else
+        #define MA_PRIVATE static
+    #endif
+#endif
+
+
+/* SIMD alignment in bytes. Currently set to 32 bytes in preparation for future AVX optimizations. */
+#define MA_SIMD_ALIGNMENT  32
+
+/*
+Special wchar_t type to ensure any structures in the public sections that reference it have a
+consistent size across all platforms.
+
+On Windows, wchar_t is 2 bytes, whereas everywhere else it's 4 bytes. Since Windows likes to use
+wchar_t for its IDs, we need a special explicitly sized wchar type that is always 2 bytes on all
+platforms.
+*/
+#if !defined(MA_POSIX) && defined(MA_WIN32)
+typedef wchar_t     ma_wchar_win32;
+#else
+typedef ma_uint16   ma_wchar_win32;
+#endif
+
+
+
+/*
+Logging Levels
+==============
+Log levels are only used to give logging callbacks some context as to the severity of a log message
+so they can do filtering. All log levels will be posted to registered logging callbacks. If you
+don't want to output a certain log level you can discriminate against the log level in the callback.
+
+MA_LOG_LEVEL_DEBUG
+    Used for debugging. Useful for debug and test builds, but should be disabled in release builds.
+
+MA_LOG_LEVEL_INFO
+    Informational logging. Useful for debugging. This will never be called from within the data
+    callback.
+
+MA_LOG_LEVEL_WARNING
+    Warnings. You should enable this in you development builds and action them when encountered. These
+    logs usually indicate a potential problem or misconfiguration, but still allow you to keep
+    running. This will never be called from within the data callback.
+
+MA_LOG_LEVEL_ERROR
+    Error logging. This will be fired when an operation fails and is subsequently aborted. This can
+    be fired from within the data callback, in which case the device will be stopped. You should
+    always have this log level enabled.
+*/
+typedef enum
+{
+    MA_LOG_LEVEL_DEBUG   = 4,
+    MA_LOG_LEVEL_INFO    = 3,
+    MA_LOG_LEVEL_WARNING = 2,
+    MA_LOG_LEVEL_ERROR   = 1
+} ma_log_level;
+
+/*
+Variables needing to be accessed atomically should be declared with this macro for two reasons:
+
+    1) It allows people who read the code to identify a variable as such; and
+    2) It forces alignment on platforms where it's required or optimal.
+
+Note that for x86/64, alignment is not strictly necessary, but does have some performance
+implications. Where supported by the compiler, alignment will be used, but otherwise if the CPU
+architecture does not require it, it will simply leave it unaligned. This is the case with old
+versions of Visual Studio, which I've confirmed with at least VC6.
+*/
+#if !defined(_MSC_VER) && defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
+    #include <stdalign.h>
+    #define MA_ATOMIC(alignment, type)            _Alignas(alignment) type
+#else
+    #if defined(__GNUC__)
+        /* GCC-style compilers. */
+        #define MA_ATOMIC(alignment, type)        type __attribute__((aligned(alignment)))
+    #elif defined(_MSC_VER) && _MSC_VER > 1200  /* 1200 = VC6. Alignment not supported, but not necessary because x86 is the only supported target. */
+        /* MSVC. */
+        #define MA_ATOMIC(alignment, type)        __declspec(align(alignment)) type
+    #else
+        /* Other compilers. */
+        #define MA_ATOMIC(alignment, type)        type
+    #endif
+#endif
+
+typedef struct ma_context ma_context;
+typedef struct ma_device ma_device;
+
+typedef ma_uint8 ma_channel;
+typedef enum
+{
+    MA_CHANNEL_NONE               = 0,
+    MA_CHANNEL_MONO               = 1,
+    MA_CHANNEL_FRONT_LEFT         = 2,
+    MA_CHANNEL_FRONT_RIGHT        = 3,
+    MA_CHANNEL_FRONT_CENTER       = 4,
+    MA_CHANNEL_LFE                = 5,
+    MA_CHANNEL_BACK_LEFT          = 6,
+    MA_CHANNEL_BACK_RIGHT         = 7,
+    MA_CHANNEL_FRONT_LEFT_CENTER  = 8,
+    MA_CHANNEL_FRONT_RIGHT_CENTER = 9,
+    MA_CHANNEL_BACK_CENTER        = 10,
+    MA_CHANNEL_SIDE_LEFT          = 11,
+    MA_CHANNEL_SIDE_RIGHT         = 12,
+    MA_CHANNEL_TOP_CENTER         = 13,
+    MA_CHANNEL_TOP_FRONT_LEFT     = 14,
+    MA_CHANNEL_TOP_FRONT_CENTER   = 15,
+    MA_CHANNEL_TOP_FRONT_RIGHT    = 16,
+    MA_CHANNEL_TOP_BACK_LEFT      = 17,
+    MA_CHANNEL_TOP_BACK_CENTER    = 18,
+    MA_CHANNEL_TOP_BACK_RIGHT     = 19,
+    MA_CHANNEL_AUX_0              = 20,
+    MA_CHANNEL_AUX_1              = 21,
+    MA_CHANNEL_AUX_2              = 22,
+    MA_CHANNEL_AUX_3              = 23,
+    MA_CHANNEL_AUX_4              = 24,
+    MA_CHANNEL_AUX_5              = 25,
+    MA_CHANNEL_AUX_6              = 26,
+    MA_CHANNEL_AUX_7              = 27,
+    MA_CHANNEL_AUX_8              = 28,
+    MA_CHANNEL_AUX_9              = 29,
+    MA_CHANNEL_AUX_10             = 30,
+    MA_CHANNEL_AUX_11             = 31,
+    MA_CHANNEL_AUX_12             = 32,
+    MA_CHANNEL_AUX_13             = 33,
+    MA_CHANNEL_AUX_14             = 34,
+    MA_CHANNEL_AUX_15             = 35,
+    MA_CHANNEL_AUX_16             = 36,
+    MA_CHANNEL_AUX_17             = 37,
+    MA_CHANNEL_AUX_18             = 38,
+    MA_CHANNEL_AUX_19             = 39,
+    MA_CHANNEL_AUX_20             = 40,
+    MA_CHANNEL_AUX_21             = 41,
+    MA_CHANNEL_AUX_22             = 42,
+    MA_CHANNEL_AUX_23             = 43,
+    MA_CHANNEL_AUX_24             = 44,
+    MA_CHANNEL_AUX_25             = 45,
+    MA_CHANNEL_AUX_26             = 46,
+    MA_CHANNEL_AUX_27             = 47,
+    MA_CHANNEL_AUX_28             = 48,
+    MA_CHANNEL_AUX_29             = 49,
+    MA_CHANNEL_AUX_30             = 50,
+    MA_CHANNEL_AUX_31             = 51,
+    MA_CHANNEL_LEFT               = MA_CHANNEL_FRONT_LEFT,
+    MA_CHANNEL_RIGHT              = MA_CHANNEL_FRONT_RIGHT,
+    MA_CHANNEL_POSITION_COUNT     = (MA_CHANNEL_AUX_31 + 1)
+} _ma_channel_position; /* Do not use `_ma_channel_position` directly. Use `ma_channel` instead. */
+
+typedef enum
+{
+    MA_SUCCESS                        =  0,
+    MA_ERROR                          = -1,  /* A generic error. */
+    MA_INVALID_ARGS                   = -2,
+    MA_INVALID_OPERATION              = -3,
+    MA_OUT_OF_MEMORY                  = -4,
+    MA_OUT_OF_RANGE                   = -5,
+    MA_ACCESS_DENIED                  = -6,
+    MA_DOES_NOT_EXIST                 = -7,
+    MA_ALREADY_EXISTS                 = -8,
+    MA_TOO_MANY_OPEN_FILES            = -9,
+    MA_INVALID_FILE                   = -10,
+    MA_TOO_BIG                        = -11,
+    MA_PATH_TOO_LONG                  = -12,
+    MA_NAME_TOO_LONG                  = -13,
+    MA_NOT_DIRECTORY                  = -14,
+    MA_IS_DIRECTORY                   = -15,
+    MA_DIRECTORY_NOT_EMPTY            = -16,
+    MA_AT_END                         = -17,
+    MA_NO_SPACE                       = -18,
+    MA_BUSY                           = -19,
+    MA_IO_ERROR                       = -20,
+    MA_INTERRUPT                      = -21,
+    MA_UNAVAILABLE                    = -22,
+    MA_ALREADY_IN_USE                 = -23,
+    MA_BAD_ADDRESS                    = -24,
+    MA_BAD_SEEK                       = -25,
+    MA_BAD_PIPE                       = -26,
+    MA_DEADLOCK                       = -27,
+    MA_TOO_MANY_LINKS                 = -28,
+    MA_NOT_IMPLEMENTED                = -29,
+    MA_NO_MESSAGE                     = -30,
+    MA_BAD_MESSAGE                    = -31,
+    MA_NO_DATA_AVAILABLE              = -32,
+    MA_INVALID_DATA                   = -33,
+    MA_TIMEOUT                        = -34,
+    MA_NO_NETWORK                     = -35,
+    MA_NOT_UNIQUE                     = -36,
+    MA_NOT_SOCKET                     = -37,
+    MA_NO_ADDRESS                     = -38,
+    MA_BAD_PROTOCOL                   = -39,
+    MA_PROTOCOL_UNAVAILABLE           = -40,
+    MA_PROTOCOL_NOT_SUPPORTED         = -41,
+    MA_PROTOCOL_FAMILY_NOT_SUPPORTED  = -42,
+    MA_ADDRESS_FAMILY_NOT_SUPPORTED   = -43,
+    MA_SOCKET_NOT_SUPPORTED           = -44,
+    MA_CONNECTION_RESET               = -45,
+    MA_ALREADY_CONNECTED              = -46,
+    MA_NOT_CONNECTED                  = -47,
+    MA_CONNECTION_REFUSED             = -48,
+    MA_NO_HOST                        = -49,
+    MA_IN_PROGRESS                    = -50,
+    MA_CANCELLED                      = -51,
+    MA_MEMORY_ALREADY_MAPPED          = -52,
+
+    /* General non-standard errors. */
+    MA_CRC_MISMATCH                   = -100,
+
+    /* General miniaudio-specific errors. */
+    MA_FORMAT_NOT_SUPPORTED           = -200,
+    MA_DEVICE_TYPE_NOT_SUPPORTED      = -201,
+    MA_SHARE_MODE_NOT_SUPPORTED       = -202,
+    MA_NO_BACKEND                     = -203,
+    MA_NO_DEVICE                      = -204,
+    MA_API_NOT_FOUND                  = -205,
+    MA_INVALID_DEVICE_CONFIG          = -206,
+    MA_LOOP                           = -207,
+    MA_BACKEND_NOT_ENABLED            = -208,
+
+    /* State errors. */
+    MA_DEVICE_NOT_INITIALIZED         = -300,
+    MA_DEVICE_ALREADY_INITIALIZED     = -301,
+    MA_DEVICE_NOT_STARTED             = -302,
+    MA_DEVICE_NOT_STOPPED             = -303,
+
+    /* Operation errors. */
+    MA_FAILED_TO_INIT_BACKEND         = -400,
+    MA_FAILED_TO_OPEN_BACKEND_DEVICE  = -401,
+    MA_FAILED_TO_START_BACKEND_DEVICE = -402,
+    MA_FAILED_TO_STOP_BACKEND_DEVICE  = -403
+} ma_result;
+
+
+#define MA_MIN_CHANNELS                 1
+#ifndef MA_MAX_CHANNELS
+#define MA_MAX_CHANNELS                 254
+#endif
+
+#ifndef MA_MAX_FILTER_ORDER
+#define MA_MAX_FILTER_ORDER             8
+#endif
+
+typedef enum
+{
+    ma_stream_format_pcm = 0
+} ma_stream_format;
+
+typedef enum
+{
+    ma_stream_layout_interleaved = 0,
+    ma_stream_layout_deinterleaved
+} ma_stream_layout;
+
+typedef enum
+{
+    ma_dither_mode_none = 0,
+    ma_dither_mode_rectangle,
+    ma_dither_mode_triangle
+} ma_dither_mode;
+
+typedef enum
+{
+    /*
+    I like to keep these explicitly defined because they're used as a key into a lookup table. When items are
+    added to this, make sure there are no gaps and that they're added to the lookup table in ma_get_bytes_per_sample().
+    */
+    ma_format_unknown = 0,     /* Mainly used for indicating an error, but also used as the default for the output format for decoders. */
+    ma_format_u8      = 1,
+    ma_format_s16     = 2,     /* Seems to be the most widely supported format. */
+    ma_format_s24     = 3,     /* Tightly packed. 3 bytes per sample. */
+    ma_format_s32     = 4,
+    ma_format_f32     = 5,
+    ma_format_count
+} ma_format;
+
+typedef enum
+{
+    /* Standard rates need to be in priority order. */
+    ma_standard_sample_rate_48000  = 48000,     /* Most common */
+    ma_standard_sample_rate_44100  = 44100,
+
+    ma_standard_sample_rate_32000  = 32000,     /* Lows */
+    ma_standard_sample_rate_24000  = 24000,
+    ma_standard_sample_rate_22050  = 22050,
+
+    ma_standard_sample_rate_88200  = 88200,     /* Highs */
+    ma_standard_sample_rate_96000  = 96000,
+    ma_standard_sample_rate_176400 = 176400,
+    ma_standard_sample_rate_192000 = 192000,
+
+    ma_standard_sample_rate_16000  = 16000,     /* Extreme lows */
+    ma_standard_sample_rate_11025  = 11025,
+    ma_standard_sample_rate_8000   = 8000,
+
+    ma_standard_sample_rate_352800 = 352800,    /* Extreme highs */
+    ma_standard_sample_rate_384000 = 384000,
+
+    ma_standard_sample_rate_min    = ma_standard_sample_rate_8000,
+    ma_standard_sample_rate_max    = ma_standard_sample_rate_384000,
+    ma_standard_sample_rate_count  = 14         /* Need to maintain the count manually. Make sure this is updated if items are added to enum. */
+} ma_standard_sample_rate;
+
+
+typedef enum
+{
+    ma_channel_mix_mode_rectangular = 0,   /* Simple averaging based on the plane(s) the channel is sitting on. */
+    ma_channel_mix_mode_simple,            /* Drop excess channels; zeroed out extra channels. */
+    ma_channel_mix_mode_custom_weights,    /* Use custom weights specified in ma_channel_converter_config. */
+    ma_channel_mix_mode_default = ma_channel_mix_mode_rectangular
+} ma_channel_mix_mode;
+
+typedef enum
+{
+    ma_standard_channel_map_microsoft,
+    ma_standard_channel_map_alsa,
+    ma_standard_channel_map_rfc3551,   /* Based off AIFF. */
+    ma_standard_channel_map_flac,
+    ma_standard_channel_map_vorbis,
+    ma_standard_channel_map_sound4,    /* FreeBSD's sound(4). */
+    ma_standard_channel_map_sndio,     /* www.sndio.org/tips.html */
+    ma_standard_channel_map_webaudio = ma_standard_channel_map_flac, /* https://webaudio.github.io/web-audio-api/#ChannelOrdering. Only 1, 2, 4 and 6 channels are defined, but can fill in the gaps with logical assumptions. */
+    ma_standard_channel_map_default = ma_standard_channel_map_microsoft
+} ma_standard_channel_map;
+
+typedef enum
+{
+    ma_performance_profile_low_latency = 0,
+    ma_performance_profile_conservative
+} ma_performance_profile;
+
+
+typedef struct
+{
+    void* pUserData;
+    void* (* onMalloc)(size_t sz, void* pUserData);
+    void* (* onRealloc)(void* p, size_t sz, void* pUserData);
+    void  (* onFree)(void* p, void* pUserData);
+} ma_allocation_callbacks;
+
+typedef struct
+{
+    ma_uint32 state;
+} ma_lcg;
+
+
+/*
+Atomics.
+
+These are typesafe structures to prevent errors as a result of forgetting to reference variables atomically. It's too
+easy to introduce subtle bugs where you accidentally do a regular assignment instead of an atomic load/store, etc. By
+using a struct we can enforce the use of atomics at compile time.
+
+These types are declared in the header section because we need to reference them in structs below, but functions for
+using them are only exposed in the implementation section. I do not want these to be part of the public API.
+
+There's a few downsides to this system. The first is that you need to declare a new struct for each type. Below are
+some macros to help with the declarations. They will be named like so:
+
+    ma_atomic_uint32 - atomic ma_uint32
+    ma_atomic_int32  - atomic ma_int32
+    ma_atomic_uint64 - atomic ma_uint64
+    ma_atomic_float  - atomic float
+    ma_atomic_bool32 - atomic ma_bool32
+
+The other downside is that atomic pointers are extremely messy. You need to declare a new struct for each specific
+type of pointer you need to make atomic. For example, an atomic ma_node* will look like this:
+
+    MA_ATOMIC_SAFE_TYPE_IMPL_PTR(node)
+
+Which will declare a type struct that's named like so:
+
+    ma_atomic_ptr_node
+
+Functions to use the atomic types are declared in the implementation section. All atomic functions are prefixed with
+the name of the struct. For example:
+
+    ma_atomic_uint32_set() - Atomic store of ma_uint32
+    ma_atomic_uint32_get() - Atomic load of ma_uint32
+    etc.
+
+For pointer types it's the same, which makes them a bit messy to use due to the length of each function name, but in
+return you get type safety and enforcement of atomic operations.
+*/
+#define MA_ATOMIC_SAFE_TYPE_DECL(c89TypeExtension, typeSize, type) \
+    typedef struct \
+    { \
+        MA_ATOMIC(typeSize, ma_##type) value; \
+    } ma_atomic_##type; \
+
+#define MA_ATOMIC_SAFE_TYPE_DECL_PTR(type) \
+    typedef struct \
+    { \
+        MA_ATOMIC(MA_SIZEOF_PTR, ma_##type*) value; \
+    } ma_atomic_ptr_##type; \
+
+MA_ATOMIC_SAFE_TYPE_DECL(32,  4, uint32)
+MA_ATOMIC_SAFE_TYPE_DECL(i32, 4, int32)
+MA_ATOMIC_SAFE_TYPE_DECL(64,  8, uint64)
+MA_ATOMIC_SAFE_TYPE_DECL(f32, 4, float)
+MA_ATOMIC_SAFE_TYPE_DECL(32,  4, bool32)
+
+
+/* Spinlocks are 32-bit for compatibility reasons. */
+typedef ma_uint32 ma_spinlock;
+
+#ifndef MA_NO_THREADING
+    /* Thread priorities should be ordered such that the default priority of the worker thread is 0. */
+    typedef enum
+    {
+        ma_thread_priority_idle     = -5,
+        ma_thread_priority_lowest   = -4,
+        ma_thread_priority_low      = -3,
+        ma_thread_priority_normal   = -2,
+        ma_thread_priority_high     = -1,
+        ma_thread_priority_highest  =  0,
+        ma_thread_priority_realtime =  1,
+        ma_thread_priority_default  =  0
+    } ma_thread_priority;
+
+    #if defined(MA_POSIX)
+        typedef ma_pthread_t ma_thread;
+    #elif defined(MA_WIN32)
+        typedef ma_handle ma_thread;
+    #endif
+
+    #if defined(MA_POSIX)
+        typedef ma_pthread_mutex_t ma_mutex;
+    #elif defined(MA_WIN32)
+        typedef ma_handle ma_mutex;
+    #endif
+
+    #if defined(MA_POSIX)
+        typedef struct
+        {
+            ma_uint32 value;
+            ma_pthread_mutex_t lock;
+            ma_pthread_cond_t cond;
+        } ma_event;
+    #elif defined(MA_WIN32)
+        typedef ma_handle ma_event;
+    #endif
+
+    #if defined(MA_POSIX)
+        typedef struct
+        {
+            int value;
+            ma_pthread_mutex_t lock;
+            ma_pthread_cond_t cond;
+        } ma_semaphore;
+    #elif defined(MA_WIN32)
+        typedef ma_handle ma_semaphore;
+    #endif
+#else
+    /* MA_NO_THREADING is set which means threading is disabled. Threading is required by some API families. If any of these are enabled we need to throw an error. */
+    #ifndef MA_NO_DEVICE_IO
+        #error "MA_NO_THREADING cannot be used without MA_NO_DEVICE_IO";
+    #endif
+#endif  /* MA_NO_THREADING */
+
+
+/*
+Retrieves the version of miniaudio as separated integers. Each component can be NULL if it's not required.
+*/
+MA_API void ma_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
+
+/*
+Retrieves the version of miniaudio as a string which can be useful for logging purposes.
+*/
+MA_API const char* ma_version_string(void);
+
+
+/**************************************************************************************************************************************************************
+
+Logging
+
+**************************************************************************************************************************************************************/
+#include <stdarg.h> /* For va_list. */
+
+#if defined(__has_attribute)
+    #if __has_attribute(format)
+        #define MA_ATTRIBUTE_FORMAT(fmt, va) __attribute__((format(printf, fmt, va)))
+    #endif
+#endif
+#ifndef MA_ATTRIBUTE_FORMAT
+#define MA_ATTRIBUTE_FORMAT(fmt, va)
+#endif
+
+#ifndef MA_MAX_LOG_CALLBACKS
+#define MA_MAX_LOG_CALLBACKS    4
+#endif
+
+
+/*
+The callback for handling log messages.
+
+
+Parameters
+----------
+pUserData (in)
+    The user data pointer that was passed into ma_log_register_callback().
+
+logLevel (in)
+    The log level. This can be one of the following:
+
+    +----------------------+
+    | Log Level            |
+    +----------------------+
+    | MA_LOG_LEVEL_DEBUG   |
+    | MA_LOG_LEVEL_INFO    |
+    | MA_LOG_LEVEL_WARNING |
+    | MA_LOG_LEVEL_ERROR   |
+    +----------------------+
+
+pMessage (in)
+    The log message.
+*/
+typedef void (* ma_log_callback_proc)(void* pUserData, ma_uint32 level, const char* pMessage);
+
+typedef struct
+{
+    ma_log_callback_proc onLog;
+    void* pUserData;
+} ma_log_callback;
+
+MA_API ma_log_callback ma_log_callback_init(ma_log_callback_proc onLog, void* pUserData);
+
+
+typedef struct
+{
+    ma_log_callback callbacks[MA_MAX_LOG_CALLBACKS];
+    ma_uint32 callbackCount;
+    ma_allocation_callbacks allocationCallbacks;    /* Need to store these persistently because ma_log_postv() might need to allocate a buffer on the heap. */
+#ifndef MA_NO_THREADING
+    ma_mutex lock;  /* For thread safety just to make it easier and safer for the logging implementation. */
+#endif
+} ma_log;
+
+MA_API ma_result ma_log_init(const ma_allocation_callbacks* pAllocationCallbacks, ma_log* pLog);
+MA_API void ma_log_uninit(ma_log* pLog);
+MA_API ma_result ma_log_register_callback(ma_log* pLog, ma_log_callback callback);
+MA_API ma_result ma_log_unregister_callback(ma_log* pLog, ma_log_callback callback);
+MA_API ma_result ma_log_post(ma_log* pLog, ma_uint32 level, const char* pMessage);
+MA_API ma_result ma_log_postv(ma_log* pLog, ma_uint32 level, const char* pFormat, va_list args);
+MA_API ma_result ma_log_postf(ma_log* pLog, ma_uint32 level, const char* pFormat, ...) MA_ATTRIBUTE_FORMAT(3, 4);
+
+
+/**************************************************************************************************************************************************************
+
+Biquad Filtering
+
+**************************************************************************************************************************************************************/
+typedef union
+{
+    float    f32;
+    ma_int32 s32;
+} ma_biquad_coefficient;
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    double b0;
+    double b1;
+    double b2;
+    double a0;
+    double a1;
+    double a2;
+} ma_biquad_config;
+
+MA_API ma_biquad_config ma_biquad_config_init(ma_format format, ma_uint32 channels, double b0, double b1, double b2, double a0, double a1, double a2);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_biquad_coefficient b0;
+    ma_biquad_coefficient b1;
+    ma_biquad_coefficient b2;
+    ma_biquad_coefficient a1;
+    ma_biquad_coefficient a2;
+    ma_biquad_coefficient* pR1;
+    ma_biquad_coefficient* pR2;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_biquad;
+
+MA_API ma_result ma_biquad_get_heap_size(const ma_biquad_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_biquad_init_preallocated(const ma_biquad_config* pConfig, void* pHeap, ma_biquad* pBQ);
+MA_API ma_result ma_biquad_init(const ma_biquad_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_biquad* pBQ);
+MA_API void ma_biquad_uninit(ma_biquad* pBQ, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_biquad_reinit(const ma_biquad_config* pConfig, ma_biquad* pBQ);
+MA_API ma_result ma_biquad_clear_cache(ma_biquad* pBQ);
+MA_API ma_result ma_biquad_process_pcm_frames(ma_biquad* pBQ, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_biquad_get_latency(const ma_biquad* pBQ);
+
+
+/**************************************************************************************************************************************************************
+
+Low-Pass Filtering
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    double q;
+} ma_lpf1_config, ma_lpf2_config;
+
+MA_API ma_lpf1_config ma_lpf1_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency);
+MA_API ma_lpf2_config ma_lpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_biquad_coefficient a;
+    ma_biquad_coefficient* pR1;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_lpf1;
+
+MA_API ma_result ma_lpf1_get_heap_size(const ma_lpf1_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_lpf1_init_preallocated(const ma_lpf1_config* pConfig, void* pHeap, ma_lpf1* pLPF);
+MA_API ma_result ma_lpf1_init(const ma_lpf1_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf1* pLPF);
+MA_API void ma_lpf1_uninit(ma_lpf1* pLPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_lpf1_reinit(const ma_lpf1_config* pConfig, ma_lpf1* pLPF);
+MA_API ma_result ma_lpf1_clear_cache(ma_lpf1* pLPF);
+MA_API ma_result ma_lpf1_process_pcm_frames(ma_lpf1* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_lpf1_get_latency(const ma_lpf1* pLPF);
+
+typedef struct
+{
+    ma_biquad bq;   /* The second order low-pass filter is implemented as a biquad filter. */
+} ma_lpf2;
+
+MA_API ma_result ma_lpf2_get_heap_size(const ma_lpf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_lpf2_init_preallocated(const ma_lpf2_config* pConfig, void* pHeap, ma_lpf2* pHPF);
+MA_API ma_result ma_lpf2_init(const ma_lpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf2* pLPF);
+MA_API void ma_lpf2_uninit(ma_lpf2* pLPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_lpf2_reinit(const ma_lpf2_config* pConfig, ma_lpf2* pLPF);
+MA_API ma_result ma_lpf2_clear_cache(ma_lpf2* pLPF);
+MA_API ma_result ma_lpf2_process_pcm_frames(ma_lpf2* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_lpf2_get_latency(const ma_lpf2* pLPF);
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    ma_uint32 order;    /* If set to 0, will be treated as a passthrough (no filtering will be applied). */
+} ma_lpf_config;
+
+MA_API ma_lpf_config ma_lpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 lpf1Count;
+    ma_uint32 lpf2Count;
+    ma_lpf1* pLPF1;
+    ma_lpf2* pLPF2;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_lpf;
+
+MA_API ma_result ma_lpf_get_heap_size(const ma_lpf_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_lpf_init_preallocated(const ma_lpf_config* pConfig, void* pHeap, ma_lpf* pLPF);
+MA_API ma_result ma_lpf_init(const ma_lpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf* pLPF);
+MA_API void ma_lpf_uninit(ma_lpf* pLPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_lpf_reinit(const ma_lpf_config* pConfig, ma_lpf* pLPF);
+MA_API ma_result ma_lpf_clear_cache(ma_lpf* pLPF);
+MA_API ma_result ma_lpf_process_pcm_frames(ma_lpf* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_lpf_get_latency(const ma_lpf* pLPF);
+
+
+/**************************************************************************************************************************************************************
+
+High-Pass Filtering
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    double q;
+} ma_hpf1_config, ma_hpf2_config;
+
+MA_API ma_hpf1_config ma_hpf1_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency);
+MA_API ma_hpf2_config ma_hpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_biquad_coefficient a;
+    ma_biquad_coefficient* pR1;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_hpf1;
+
+MA_API ma_result ma_hpf1_get_heap_size(const ma_hpf1_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_hpf1_init_preallocated(const ma_hpf1_config* pConfig, void* pHeap, ma_hpf1* pLPF);
+MA_API ma_result ma_hpf1_init(const ma_hpf1_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf1* pHPF);
+MA_API void ma_hpf1_uninit(ma_hpf1* pHPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_hpf1_reinit(const ma_hpf1_config* pConfig, ma_hpf1* pHPF);
+MA_API ma_result ma_hpf1_process_pcm_frames(ma_hpf1* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_hpf1_get_latency(const ma_hpf1* pHPF);
+
+typedef struct
+{
+    ma_biquad bq;   /* The second order high-pass filter is implemented as a biquad filter. */
+} ma_hpf2;
+
+MA_API ma_result ma_hpf2_get_heap_size(const ma_hpf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_hpf2_init_preallocated(const ma_hpf2_config* pConfig, void* pHeap, ma_hpf2* pHPF);
+MA_API ma_result ma_hpf2_init(const ma_hpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf2* pHPF);
+MA_API void ma_hpf2_uninit(ma_hpf2* pHPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_hpf2_reinit(const ma_hpf2_config* pConfig, ma_hpf2* pHPF);
+MA_API ma_result ma_hpf2_process_pcm_frames(ma_hpf2* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_hpf2_get_latency(const ma_hpf2* pHPF);
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    ma_uint32 order;    /* If set to 0, will be treated as a passthrough (no filtering will be applied). */
+} ma_hpf_config;
+
+MA_API ma_hpf_config ma_hpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 hpf1Count;
+    ma_uint32 hpf2Count;
+    ma_hpf1* pHPF1;
+    ma_hpf2* pHPF2;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_hpf;
+
+MA_API ma_result ma_hpf_get_heap_size(const ma_hpf_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_hpf_init_preallocated(const ma_hpf_config* pConfig, void* pHeap, ma_hpf* pLPF);
+MA_API ma_result ma_hpf_init(const ma_hpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf* pHPF);
+MA_API void ma_hpf_uninit(ma_hpf* pHPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_hpf_reinit(const ma_hpf_config* pConfig, ma_hpf* pHPF);
+MA_API ma_result ma_hpf_process_pcm_frames(ma_hpf* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_hpf_get_latency(const ma_hpf* pHPF);
+
+
+/**************************************************************************************************************************************************************
+
+Band-Pass Filtering
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    double q;
+} ma_bpf2_config;
+
+MA_API ma_bpf2_config ma_bpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q);
+
+typedef struct
+{
+    ma_biquad bq;   /* The second order band-pass filter is implemented as a biquad filter. */
+} ma_bpf2;
+
+MA_API ma_result ma_bpf2_get_heap_size(const ma_bpf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_bpf2_init_preallocated(const ma_bpf2_config* pConfig, void* pHeap, ma_bpf2* pBPF);
+MA_API ma_result ma_bpf2_init(const ma_bpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf2* pBPF);
+MA_API void ma_bpf2_uninit(ma_bpf2* pBPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_bpf2_reinit(const ma_bpf2_config* pConfig, ma_bpf2* pBPF);
+MA_API ma_result ma_bpf2_process_pcm_frames(ma_bpf2* pBPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_bpf2_get_latency(const ma_bpf2* pBPF);
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    ma_uint32 order;    /* If set to 0, will be treated as a passthrough (no filtering will be applied). */
+} ma_bpf_config;
+
+MA_API ma_bpf_config ma_bpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 bpf2Count;
+    ma_bpf2* pBPF2;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_bpf;
+
+MA_API ma_result ma_bpf_get_heap_size(const ma_bpf_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_bpf_init_preallocated(const ma_bpf_config* pConfig, void* pHeap, ma_bpf* pBPF);
+MA_API ma_result ma_bpf_init(const ma_bpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf* pBPF);
+MA_API void ma_bpf_uninit(ma_bpf* pBPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_bpf_reinit(const ma_bpf_config* pConfig, ma_bpf* pBPF);
+MA_API ma_result ma_bpf_process_pcm_frames(ma_bpf* pBPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_bpf_get_latency(const ma_bpf* pBPF);
+
+
+/**************************************************************************************************************************************************************
+
+Notching Filter
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double q;
+    double frequency;
+} ma_notch2_config, ma_notch_config;
+
+MA_API ma_notch2_config ma_notch2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double q, double frequency);
+
+typedef struct
+{
+    ma_biquad bq;
+} ma_notch2;
+
+MA_API ma_result ma_notch2_get_heap_size(const ma_notch2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_notch2_init_preallocated(const ma_notch2_config* pConfig, void* pHeap, ma_notch2* pFilter);
+MA_API ma_result ma_notch2_init(const ma_notch2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_notch2* pFilter);
+MA_API void ma_notch2_uninit(ma_notch2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_notch2_reinit(const ma_notch2_config* pConfig, ma_notch2* pFilter);
+MA_API ma_result ma_notch2_process_pcm_frames(ma_notch2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_notch2_get_latency(const ma_notch2* pFilter);
+
+
+/**************************************************************************************************************************************************************
+
+Peaking EQ Filter
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double gainDB;
+    double q;
+    double frequency;
+} ma_peak2_config, ma_peak_config;
+
+MA_API ma_peak2_config ma_peak2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency);
+
+typedef struct
+{
+    ma_biquad bq;
+} ma_peak2;
+
+MA_API ma_result ma_peak2_get_heap_size(const ma_peak2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_peak2_init_preallocated(const ma_peak2_config* pConfig, void* pHeap, ma_peak2* pFilter);
+MA_API ma_result ma_peak2_init(const ma_peak2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_peak2* pFilter);
+MA_API void ma_peak2_uninit(ma_peak2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_peak2_reinit(const ma_peak2_config* pConfig, ma_peak2* pFilter);
+MA_API ma_result ma_peak2_process_pcm_frames(ma_peak2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_peak2_get_latency(const ma_peak2* pFilter);
+
+
+/**************************************************************************************************************************************************************
+
+Low Shelf Filter
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double gainDB;
+    double shelfSlope;
+    double frequency;
+} ma_loshelf2_config, ma_loshelf_config;
+
+MA_API ma_loshelf2_config ma_loshelf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency);
+
+typedef struct
+{
+    ma_biquad bq;
+} ma_loshelf2;
+
+MA_API ma_result ma_loshelf2_get_heap_size(const ma_loshelf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_loshelf2_init_preallocated(const ma_loshelf2_config* pConfig, void* pHeap, ma_loshelf2* pFilter);
+MA_API ma_result ma_loshelf2_init(const ma_loshelf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_loshelf2* pFilter);
+MA_API void ma_loshelf2_uninit(ma_loshelf2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_loshelf2_reinit(const ma_loshelf2_config* pConfig, ma_loshelf2* pFilter);
+MA_API ma_result ma_loshelf2_process_pcm_frames(ma_loshelf2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_loshelf2_get_latency(const ma_loshelf2* pFilter);
+
+
+/**************************************************************************************************************************************************************
+
+High Shelf Filter
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double gainDB;
+    double shelfSlope;
+    double frequency;
+} ma_hishelf2_config, ma_hishelf_config;
+
+MA_API ma_hishelf2_config ma_hishelf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency);
+
+typedef struct
+{
+    ma_biquad bq;
+} ma_hishelf2;
+
+MA_API ma_result ma_hishelf2_get_heap_size(const ma_hishelf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_hishelf2_init_preallocated(const ma_hishelf2_config* pConfig, void* pHeap, ma_hishelf2* pFilter);
+MA_API ma_result ma_hishelf2_init(const ma_hishelf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hishelf2* pFilter);
+MA_API void ma_hishelf2_uninit(ma_hishelf2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_hishelf2_reinit(const ma_hishelf2_config* pConfig, ma_hishelf2* pFilter);
+MA_API ma_result ma_hishelf2_process_pcm_frames(ma_hishelf2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_hishelf2_get_latency(const ma_hishelf2* pFilter);
+
+
+
+/*
+Delay
+*/
+typedef struct
+{
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 delayInFrames;
+    ma_bool32 delayStart;       /* Set to true to delay the start of the output; false otherwise. */
+    float wet;                  /* 0..1. Default = 1. */
+    float dry;                  /* 0..1. Default = 1. */
+    float decay;                /* 0..1. Default = 0 (no feedback). Feedback decay. Use this for echo. */
+} ma_delay_config;
+
+MA_API ma_delay_config ma_delay_config_init(ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 delayInFrames, float decay);
+
+
+typedef struct
+{
+    ma_delay_config config;
+    ma_uint32 cursor;               /* Feedback is written to this cursor. Always equal or in front of the read cursor. */
+    ma_uint32 bufferSizeInFrames;
+    float* pBuffer;
+} ma_delay;
+
+MA_API ma_result ma_delay_init(const ma_delay_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_delay* pDelay);
+MA_API void ma_delay_uninit(ma_delay* pDelay, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_delay_process_pcm_frames(ma_delay* pDelay, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount);
+MA_API void ma_delay_set_wet(ma_delay* pDelay, float value);
+MA_API float ma_delay_get_wet(const ma_delay* pDelay);
+MA_API void ma_delay_set_dry(ma_delay* pDelay, float value);
+MA_API float ma_delay_get_dry(const ma_delay* pDelay);
+MA_API void ma_delay_set_decay(ma_delay* pDelay, float value);
+MA_API float ma_delay_get_decay(const ma_delay* pDelay);
+
+
+/* Gainer for smooth volume changes. */
+typedef struct
+{
+    ma_uint32 channels;
+    ma_uint32 smoothTimeInFrames;
+} ma_gainer_config;
+
+MA_API ma_gainer_config ma_gainer_config_init(ma_uint32 channels, ma_uint32 smoothTimeInFrames);
+
+
+typedef struct
+{
+    ma_gainer_config config;
+    ma_uint32 t;
+    float masterVolume;
+    float* pOldGains;
+    float* pNewGains;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_gainer;
+
+MA_API ma_result ma_gainer_get_heap_size(const ma_gainer_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_gainer_init_preallocated(const ma_gainer_config* pConfig, void* pHeap, ma_gainer* pGainer);
+MA_API ma_result ma_gainer_init(const ma_gainer_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_gainer* pGainer);
+MA_API void ma_gainer_uninit(ma_gainer* pGainer, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_gainer_process_pcm_frames(ma_gainer* pGainer, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_result ma_gainer_set_gain(ma_gainer* pGainer, float newGain);
+MA_API ma_result ma_gainer_set_gains(ma_gainer* pGainer, float* pNewGains);
+MA_API ma_result ma_gainer_set_master_volume(ma_gainer* pGainer, float volume);
+MA_API ma_result ma_gainer_get_master_volume(const ma_gainer* pGainer, float* pVolume);
+
+
+
+/* Stereo panner. */
+typedef enum
+{
+    ma_pan_mode_balance = 0,    /* Does not blend one side with the other. Technically just a balance. Compatible with other popular audio engines and therefore the default. */
+    ma_pan_mode_pan             /* A true pan. The sound from one side will "move" to the other side and blend with it. */
+} ma_pan_mode;
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_pan_mode mode;
+    float pan;
+} ma_panner_config;
+
+MA_API ma_panner_config ma_panner_config_init(ma_format format, ma_uint32 channels);
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_pan_mode mode;
+    float pan;  /* -1..1 where 0 is no pan, -1 is left side, +1 is right side. Defaults to 0. */
+} ma_panner;
+
+MA_API ma_result ma_panner_init(const ma_panner_config* pConfig, ma_panner* pPanner);
+MA_API ma_result ma_panner_process_pcm_frames(ma_panner* pPanner, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API void ma_panner_set_mode(ma_panner* pPanner, ma_pan_mode mode);
+MA_API ma_pan_mode ma_panner_get_mode(const ma_panner* pPanner);
+MA_API void ma_panner_set_pan(ma_panner* pPanner, float pan);
+MA_API float ma_panner_get_pan(const ma_panner* pPanner);
+
+
+
+/* Fader. */
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+} ma_fader_config;
+
+MA_API ma_fader_config ma_fader_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate);
+
+typedef struct
+{
+    ma_fader_config config;
+    float volumeBeg;            /* If volumeBeg and volumeEnd is equal to 1, no fading happens (ma_fader_process_pcm_frames() will run as a passthrough). */
+    float volumeEnd;
+    ma_uint64 lengthInFrames;   /* The total length of the fade. */
+    ma_int64  cursorInFrames;   /* The current time in frames. Incremented by ma_fader_process_pcm_frames(). Signed because it'll be offset by startOffsetInFrames in set_fade_ex(). */
+} ma_fader;
+
+MA_API ma_result ma_fader_init(const ma_fader_config* pConfig, ma_fader* pFader);
+MA_API ma_result ma_fader_process_pcm_frames(ma_fader* pFader, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API void ma_fader_get_data_format(const ma_fader* pFader, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate);
+MA_API void ma_fader_set_fade(ma_fader* pFader, float volumeBeg, float volumeEnd, ma_uint64 lengthInFrames);
+MA_API void ma_fader_set_fade_ex(ma_fader* pFader, float volumeBeg, float volumeEnd, ma_uint64 lengthInFrames, ma_int64 startOffsetInFrames);
+MA_API float ma_fader_get_current_volume(const ma_fader* pFader);
+
+
+
+/* Spatializer. */
+typedef struct
+{
+    float x;
+    float y;
+    float z;
+} ma_vec3f;
+
+typedef struct
+{
+    ma_vec3f v;
+    ma_spinlock lock;
+} ma_atomic_vec3f;
+
+typedef enum
+{
+    ma_attenuation_model_none,          /* No distance attenuation and no spatialization. */
+    ma_attenuation_model_inverse,       /* Equivalent to OpenAL's AL_INVERSE_DISTANCE_CLAMPED. */
+    ma_attenuation_model_linear,        /* Linear attenuation. Equivalent to OpenAL's AL_LINEAR_DISTANCE_CLAMPED. */
+    ma_attenuation_model_exponential    /* Exponential attenuation. Equivalent to OpenAL's AL_EXPONENT_DISTANCE_CLAMPED. */
+} ma_attenuation_model;
+
+typedef enum
+{
+    ma_positioning_absolute,
+    ma_positioning_relative
+} ma_positioning;
+
+typedef enum
+{
+    ma_handedness_right,
+    ma_handedness_left
+} ma_handedness;
+
+
+typedef struct
+{
+    ma_uint32 channelsOut;
+    ma_channel* pChannelMapOut;
+    ma_handedness handedness;   /* Defaults to right. Forward is -1 on the Z axis. In a left handed system, forward is +1 on the Z axis. */
+    float coneInnerAngleInRadians;
+    float coneOuterAngleInRadians;
+    float coneOuterGain;
+    float speedOfSound;
+    ma_vec3f worldUp;
+} ma_spatializer_listener_config;
+
+MA_API ma_spatializer_listener_config ma_spatializer_listener_config_init(ma_uint32 channelsOut);
+
+
+typedef struct
+{
+    ma_spatializer_listener_config config;
+    ma_atomic_vec3f position;  /* The absolute position of the listener. */
+    ma_atomic_vec3f direction; /* The direction the listener is facing. The world up vector is config.worldUp. */
+    ma_atomic_vec3f velocity;
+    ma_bool32 isEnabled;
+
+    /* Memory management. */
+    ma_bool32 _ownsHeap;
+    void* _pHeap;
+} ma_spatializer_listener;
+
+MA_API ma_result ma_spatializer_listener_get_heap_size(const ma_spatializer_listener_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_spatializer_listener_init_preallocated(const ma_spatializer_listener_config* pConfig, void* pHeap, ma_spatializer_listener* pListener);
+MA_API ma_result ma_spatializer_listener_init(const ma_spatializer_listener_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_uninit(ma_spatializer_listener* pListener, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_channel* ma_spatializer_listener_get_channel_map(ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_cone(ma_spatializer_listener* pListener, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_spatializer_listener_get_cone(const ma_spatializer_listener* pListener, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_spatializer_listener_set_position(ma_spatializer_listener* pListener, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_listener_get_position(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_direction(ma_spatializer_listener* pListener, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_listener_get_direction(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_velocity(ma_spatializer_listener* pListener, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_listener_get_velocity(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_speed_of_sound(ma_spatializer_listener* pListener, float speedOfSound);
+MA_API float ma_spatializer_listener_get_speed_of_sound(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_world_up(ma_spatializer_listener* pListener, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_listener_get_world_up(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_enabled(ma_spatializer_listener* pListener, ma_bool32 isEnabled);
+MA_API ma_bool32 ma_spatializer_listener_is_enabled(const ma_spatializer_listener* pListener);
+
+
+typedef struct
+{
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel* pChannelMapIn;
+    ma_attenuation_model attenuationModel;
+    ma_positioning positioning;
+    ma_handedness handedness;           /* Defaults to right. Forward is -1 on the Z axis. In a left handed system, forward is +1 on the Z axis. */
+    float minGain;
+    float maxGain;
+    float minDistance;
+    float maxDistance;
+    float rolloff;
+    float coneInnerAngleInRadians;
+    float coneOuterAngleInRadians;
+    float coneOuterGain;
+    float dopplerFactor;                /* Set to 0 to disable doppler effect. */
+    float directionalAttenuationFactor; /* Set to 0 to disable directional attenuation. */
+    float minSpatializationChannelGain; /* The minimal scaling factor to apply to channel gains when accounting for the direction of the sound relative to the listener. Must be in the range of 0..1. Smaller values means more aggressive directional panning, larger values means more subtle directional panning. */
+    ma_uint32 gainSmoothTimeInFrames;   /* When the gain of a channel changes during spatialization, the transition will be linearly interpolated over this number of frames. */
+} ma_spatializer_config;
+
+MA_API ma_spatializer_config ma_spatializer_config_init(ma_uint32 channelsIn, ma_uint32 channelsOut);
+
+
+typedef struct
+{
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel* pChannelMapIn;
+    ma_attenuation_model attenuationModel;
+    ma_positioning positioning;
+    ma_handedness handedness;           /* Defaults to right. Forward is -1 on the Z axis. In a left handed system, forward is +1 on the Z axis. */
+    float minGain;
+    float maxGain;
+    float minDistance;
+    float maxDistance;
+    float rolloff;
+    float coneInnerAngleInRadians;
+    float coneOuterAngleInRadians;
+    float coneOuterGain;
+    float dopplerFactor;                /* Set to 0 to disable doppler effect. */
+    float directionalAttenuationFactor; /* Set to 0 to disable directional attenuation. */
+    ma_uint32 gainSmoothTimeInFrames;   /* When the gain of a channel changes during spatialization, the transition will be linearly interpolated over this number of frames. */
+    ma_atomic_vec3f position;
+    ma_atomic_vec3f direction;
+    ma_atomic_vec3f velocity;  /* For doppler effect. */
+    float dopplerPitch; /* Will be updated by ma_spatializer_process_pcm_frames() and can be used by higher level functions to apply a pitch shift for doppler effect. */
+    float minSpatializationChannelGain;
+    ma_gainer gainer;   /* For smooth gain transitions. */
+    float* pNewChannelGainsOut; /* An offset of _pHeap. Used by ma_spatializer_process_pcm_frames() to store new channel gains. The number of elements in this array is equal to config.channelsOut. */
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_spatializer;
+
+MA_API ma_result ma_spatializer_get_heap_size(const ma_spatializer_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_spatializer_init_preallocated(const ma_spatializer_config* pConfig, void* pHeap, ma_spatializer* pSpatializer);
+MA_API ma_result ma_spatializer_init(const ma_spatializer_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_uninit(ma_spatializer* pSpatializer, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_spatializer_process_pcm_frames(ma_spatializer* pSpatializer, ma_spatializer_listener* pListener, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_result ma_spatializer_set_master_volume(ma_spatializer* pSpatializer, float volume);
+MA_API ma_result ma_spatializer_get_master_volume(const ma_spatializer* pSpatializer, float* pVolume);
+MA_API ma_uint32 ma_spatializer_get_input_channels(const ma_spatializer* pSpatializer);
+MA_API ma_uint32 ma_spatializer_get_output_channels(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_attenuation_model(ma_spatializer* pSpatializer, ma_attenuation_model attenuationModel);
+MA_API ma_attenuation_model ma_spatializer_get_attenuation_model(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_positioning(ma_spatializer* pSpatializer, ma_positioning positioning);
+MA_API ma_positioning ma_spatializer_get_positioning(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_rolloff(ma_spatializer* pSpatializer, float rolloff);
+MA_API float ma_spatializer_get_rolloff(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_min_gain(ma_spatializer* pSpatializer, float minGain);
+MA_API float ma_spatializer_get_min_gain(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_max_gain(ma_spatializer* pSpatializer, float maxGain);
+MA_API float ma_spatializer_get_max_gain(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_min_distance(ma_spatializer* pSpatializer, float minDistance);
+MA_API float ma_spatializer_get_min_distance(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_max_distance(ma_spatializer* pSpatializer, float maxDistance);
+MA_API float ma_spatializer_get_max_distance(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_cone(ma_spatializer* pSpatializer, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_spatializer_get_cone(const ma_spatializer* pSpatializer, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_spatializer_set_doppler_factor(ma_spatializer* pSpatializer, float dopplerFactor);
+MA_API float ma_spatializer_get_doppler_factor(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_directional_attenuation_factor(ma_spatializer* pSpatializer, float directionalAttenuationFactor);
+MA_API float ma_spatializer_get_directional_attenuation_factor(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_position(ma_spatializer* pSpatializer, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_get_position(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_direction(ma_spatializer* pSpatializer, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_get_direction(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_velocity(ma_spatializer* pSpatializer, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_get_velocity(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_get_relative_position_and_direction(const ma_spatializer* pSpatializer, const ma_spatializer_listener* pListener, ma_vec3f* pRelativePos, ma_vec3f* pRelativeDir);
+
+
+
+/************************************************************************************************************************************************************
+*************************************************************************************************************************************************************
+
+DATA CONVERSION
+===============
+
+This section contains the APIs for data conversion. You will find everything here for channel mapping, sample format conversion, resampling, etc.
+
+*************************************************************************************************************************************************************
+************************************************************************************************************************************************************/
+
+/**************************************************************************************************************************************************************
+
+Resampling
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    ma_uint32 lpfOrder;         /* The low-pass filter order. Setting this to 0 will disable low-pass filtering. */
+    double    lpfNyquistFactor; /* 0..1. Defaults to 1. 1 = Half the sampling frequency (Nyquist Frequency), 0.5 = Quarter the sampling frequency (half Nyquest Frequency), etc. */
+} ma_linear_resampler_config;
+
+MA_API ma_linear_resampler_config ma_linear_resampler_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+
+typedef struct
+{
+    ma_linear_resampler_config config;
+    ma_uint32 inAdvanceInt;
+    ma_uint32 inAdvanceFrac;
+    ma_uint32 inTimeInt;
+    ma_uint32 inTimeFrac;
+    union
+    {
+        float* f32;
+        ma_int16* s16;
+    } x0; /* The previous input frame. */
+    union
+    {
+        float* f32;
+        ma_int16* s16;
+    } x1; /* The next input frame. */
+    ma_lpf lpf;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_linear_resampler;
+
+MA_API ma_result ma_linear_resampler_get_heap_size(const ma_linear_resampler_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_linear_resampler_init_preallocated(const ma_linear_resampler_config* pConfig, void* pHeap, ma_linear_resampler* pResampler);
+MA_API ma_result ma_linear_resampler_init(const ma_linear_resampler_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_linear_resampler* pResampler);
+MA_API void ma_linear_resampler_uninit(ma_linear_resampler* pResampler, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_linear_resampler_process_pcm_frames(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
+MA_API ma_result ma_linear_resampler_set_rate(ma_linear_resampler* pResampler, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+MA_API ma_result ma_linear_resampler_set_rate_ratio(ma_linear_resampler* pResampler, float ratioInOut);
+MA_API ma_uint64 ma_linear_resampler_get_input_latency(const ma_linear_resampler* pResampler);
+MA_API ma_uint64 ma_linear_resampler_get_output_latency(const ma_linear_resampler* pResampler);
+MA_API ma_result ma_linear_resampler_get_required_input_frame_count(const ma_linear_resampler* pResampler, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount);
+MA_API ma_result ma_linear_resampler_get_expected_output_frame_count(const ma_linear_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);
+MA_API ma_result ma_linear_resampler_reset(ma_linear_resampler* pResampler);
+
+
+typedef struct ma_resampler_config ma_resampler_config;
+
+typedef void ma_resampling_backend;
+typedef struct
+{
+    ma_result (* onGetHeapSize                )(void* pUserData, const ma_resampler_config* pConfig, size_t* pHeapSizeInBytes);
+    ma_result (* onInit                       )(void* pUserData, const ma_resampler_config* pConfig, void* pHeap, ma_resampling_backend** ppBackend);
+    void      (* onUninit                     )(void* pUserData, ma_resampling_backend* pBackend, const ma_allocation_callbacks* pAllocationCallbacks);
+    ma_result (* onProcess                    )(void* pUserData, ma_resampling_backend* pBackend, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
+    ma_result (* onSetRate                    )(void* pUserData, ma_resampling_backend* pBackend, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);                 /* Optional. Rate changes will be disabled. */
+    ma_uint64 (* onGetInputLatency            )(void* pUserData, const ma_resampling_backend* pBackend);                                                            /* Optional. Latency will be reported as 0. */
+    ma_uint64 (* onGetOutputLatency           )(void* pUserData, const ma_resampling_backend* pBackend);                                                            /* Optional. Latency will be reported as 0. */
+    ma_result (* onGetRequiredInputFrameCount )(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount);   /* Optional. Latency mitigation will be disabled. */
+    ma_result (* onGetExpectedOutputFrameCount)(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);   /* Optional. Latency mitigation will be disabled. */
+    ma_result (* onReset                      )(void* pUserData, ma_resampling_backend* pBackend);
+} ma_resampling_backend_vtable;
+
+typedef enum
+{
+    ma_resample_algorithm_linear = 0,    /* Fastest, lowest quality. Optional low-pass filtering. Default. */
+    ma_resample_algorithm_custom,
+} ma_resample_algorithm;
+
+struct ma_resampler_config
+{
+    ma_format format;   /* Must be either ma_format_f32 or ma_format_s16. */
+    ma_uint32 channels;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    ma_resample_algorithm algorithm;    /* When set to ma_resample_algorithm_custom, pBackendVTable will be used. */
+    ma_resampling_backend_vtable* pBackendVTable;
+    void* pBackendUserData;
+    struct
+    {
+        ma_uint32 lpfOrder;
+    } linear;
+};
+
+MA_API ma_resampler_config ma_resampler_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut, ma_resample_algorithm algorithm);
+
+typedef struct
+{
+    ma_resampling_backend* pBackend;
+    ma_resampling_backend_vtable* pBackendVTable;
+    void* pBackendUserData;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    union
+    {
+        ma_linear_resampler linear;
+    } state;    /* State for stock resamplers so we can avoid a malloc. For stock resamplers, pBackend will point here. */
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_resampler;
+
+MA_API ma_result ma_resampler_get_heap_size(const ma_resampler_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_resampler_init_preallocated(const ma_resampler_config* pConfig, void* pHeap, ma_resampler* pResampler);
+
+/*
+Initializes a new resampler object from a config.
+*/
+MA_API ma_result ma_resampler_init(const ma_resampler_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_resampler* pResampler);
+
+/*
+Uninitializes a resampler.
+*/
+MA_API void ma_resampler_uninit(ma_resampler* pResampler, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Converts the given input data.
+
+Both the input and output frames must be in the format specified in the config when the resampler was initialized.
+
+On input, [pFrameCountOut] contains the number of output frames to process. On output it contains the number of output frames that
+were actually processed, which may be less than the requested amount which will happen if there's not enough input data. You can use
+ma_resampler_get_expected_output_frame_count() to know how many output frames will be processed for a given number of input frames.
+
+On input, [pFrameCountIn] contains the number of input frames contained in [pFramesIn]. On output it contains the number of whole
+input frames that were actually processed. You can use ma_resampler_get_required_input_frame_count() to know how many input frames
+you should provide for a given number of output frames. [pFramesIn] can be NULL, in which case zeroes will be used instead.
+
+If [pFramesOut] is NULL, a seek is performed. In this case, if [pFrameCountOut] is not NULL it will seek by the specified number of
+output frames. Otherwise, if [pFramesCountOut] is NULL and [pFrameCountIn] is not NULL, it will seek by the specified number of input
+frames. When seeking, [pFramesIn] is allowed to NULL, in which case the internal timing state will be updated, but no input will be
+processed. In this case, any internal filter state will be updated as if zeroes were passed in.
+
+It is an error for [pFramesOut] to be non-NULL and [pFrameCountOut] to be NULL.
+
+It is an error for both [pFrameCountOut] and [pFrameCountIn] to be NULL.
+*/
+MA_API ma_result ma_resampler_process_pcm_frames(ma_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
+
+
+/*
+Sets the input and output sample rate.
+*/
+MA_API ma_result ma_resampler_set_rate(ma_resampler* pResampler, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+
+/*
+Sets the input and output sample rate as a ratio.
+
+The ration is in/out.
+*/
+MA_API ma_result ma_resampler_set_rate_ratio(ma_resampler* pResampler, float ratio);
+
+/*
+Retrieves the latency introduced by the resampler in input frames.
+*/
+MA_API ma_uint64 ma_resampler_get_input_latency(const ma_resampler* pResampler);
+
+/*
+Retrieves the latency introduced by the resampler in output frames.
+*/
+MA_API ma_uint64 ma_resampler_get_output_latency(const ma_resampler* pResampler);
+
+/*
+Calculates the number of whole input frames that would need to be read from the client in order to output the specified
+number of output frames.
+
+The returned value does not include cached input frames. It only returns the number of extra frames that would need to be
+read from the input buffer in order to output the specified number of output frames.
+*/
+MA_API ma_result ma_resampler_get_required_input_frame_count(const ma_resampler* pResampler, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount);
+
+/*
+Calculates the number of whole output frames that would be output after fully reading and consuming the specified number of
+input frames.
+*/
+MA_API ma_result ma_resampler_get_expected_output_frame_count(const ma_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);
+
+/*
+Resets the resampler's timer and clears its internal cache.
+*/
+MA_API ma_result ma_resampler_reset(ma_resampler* pResampler);
+
+
+/**************************************************************************************************************************************************************
+
+Channel Conversion
+
+**************************************************************************************************************************************************************/
+typedef enum
+{
+    ma_channel_conversion_path_unknown,
+    ma_channel_conversion_path_passthrough,
+    ma_channel_conversion_path_mono_out,    /* Converting to mono. */
+    ma_channel_conversion_path_mono_in,     /* Converting from mono. */
+    ma_channel_conversion_path_shuffle,     /* Simple shuffle. Will use this when all channels are present in both input and output channel maps, but just in a different order. */
+    ma_channel_conversion_path_weights      /* Blended based on weights. */
+} ma_channel_conversion_path;
+
+typedef enum
+{
+    ma_mono_expansion_mode_duplicate = 0,   /* The default. */
+    ma_mono_expansion_mode_average,         /* Average the mono channel across all channels. */
+    ma_mono_expansion_mode_stereo_only,     /* Duplicate to the left and right channels only and ignore the others. */
+    ma_mono_expansion_mode_default = ma_mono_expansion_mode_duplicate
+} ma_mono_expansion_mode;
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    const ma_channel* pChannelMapIn;
+    const ma_channel* pChannelMapOut;
+    ma_channel_mix_mode mixingMode;
+    ma_bool32 calculateLFEFromSpatialChannels;  /* When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. */
+    float** ppWeights;  /* [in][out]. Only used when mixingMode is set to ma_channel_mix_mode_custom_weights. */
+} ma_channel_converter_config;
+
+MA_API ma_channel_converter_config ma_channel_converter_config_init(ma_format format, ma_uint32 channelsIn, const ma_channel* pChannelMapIn, ma_uint32 channelsOut, const ma_channel* pChannelMapOut, ma_channel_mix_mode mixingMode);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel_mix_mode mixingMode;
+    ma_channel_conversion_path conversionPath;
+    ma_channel* pChannelMapIn;
+    ma_channel* pChannelMapOut;
+    ma_uint8* pShuffleTable;    /* Indexed by output channel index. */
+    union
+    {
+        float**    f32;
+        ma_int32** s16;
+    } weights;  /* [in][out] */
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_channel_converter;
+
+MA_API ma_result ma_channel_converter_get_heap_size(const ma_channel_converter_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_channel_converter_init_preallocated(const ma_channel_converter_config* pConfig, void* pHeap, ma_channel_converter* pConverter);
+MA_API ma_result ma_channel_converter_init(const ma_channel_converter_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_channel_converter* pConverter);
+MA_API void ma_channel_converter_uninit(ma_channel_converter* pConverter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_channel_converter_process_pcm_frames(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_result ma_channel_converter_get_input_channel_map(const ma_channel_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_channel_converter_get_output_channel_map(const ma_channel_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
+
+
+/**************************************************************************************************************************************************************
+
+Data Conversion
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format formatIn;
+    ma_format formatOut;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    ma_channel* pChannelMapIn;
+    ma_channel* pChannelMapOut;
+    ma_dither_mode ditherMode;
+    ma_channel_mix_mode channelMixMode;
+    ma_bool32 calculateLFEFromSpatialChannels;  /* When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. */
+    float** ppChannelWeights;  /* [in][out]. Only used when mixingMode is set to ma_channel_mix_mode_custom_weights. */
+    ma_bool32 allowDynamicSampleRate;
+    ma_resampler_config resampling;
+} ma_data_converter_config;
+
+MA_API ma_data_converter_config ma_data_converter_config_init_default(void);
+MA_API ma_data_converter_config ma_data_converter_config_init(ma_format formatIn, ma_format formatOut, ma_uint32 channelsIn, ma_uint32 channelsOut, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+
+
+typedef enum
+{
+    ma_data_converter_execution_path_passthrough,       /* No conversion. */
+    ma_data_converter_execution_path_format_only,       /* Only format conversion. */
+    ma_data_converter_execution_path_channels_only,     /* Only channel conversion. */
+    ma_data_converter_execution_path_resample_only,     /* Only resampling. */
+    ma_data_converter_execution_path_resample_first,    /* All conversions, but resample as the first step. */
+    ma_data_converter_execution_path_channels_first     /* All conversions, but channels as the first step. */
+} ma_data_converter_execution_path;
+
+typedef struct
+{
+    ma_format formatIn;
+    ma_format formatOut;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    ma_dither_mode ditherMode;
+    ma_data_converter_execution_path executionPath; /* The execution path the data converter will follow when processing. */
+    ma_channel_converter channelConverter;
+    ma_resampler resampler;
+    ma_bool8 hasPreFormatConversion;
+    ma_bool8 hasPostFormatConversion;
+    ma_bool8 hasChannelConverter;
+    ma_bool8 hasResampler;
+    ma_bool8 isPassthrough;
+
+    /* Memory management. */
+    ma_bool8 _ownsHeap;
+    void* _pHeap;
+} ma_data_converter;
+
+MA_API ma_result ma_data_converter_get_heap_size(const ma_data_converter_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_data_converter_init_preallocated(const ma_data_converter_config* pConfig, void* pHeap, ma_data_converter* pConverter);
+MA_API ma_result ma_data_converter_init(const ma_data_converter_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_converter* pConverter);
+MA_API void ma_data_converter_uninit(ma_data_converter* pConverter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_data_converter_process_pcm_frames(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
+MA_API ma_result ma_data_converter_set_rate(ma_data_converter* pConverter, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+MA_API ma_result ma_data_converter_set_rate_ratio(ma_data_converter* pConverter, float ratioInOut);
+MA_API ma_uint64 ma_data_converter_get_input_latency(const ma_data_converter* pConverter);
+MA_API ma_uint64 ma_data_converter_get_output_latency(const ma_data_converter* pConverter);
+MA_API ma_result ma_data_converter_get_required_input_frame_count(const ma_data_converter* pConverter, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount);
+MA_API ma_result ma_data_converter_get_expected_output_frame_count(const ma_data_converter* pConverter, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);
+MA_API ma_result ma_data_converter_get_input_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_data_converter_get_output_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_data_converter_reset(ma_data_converter* pConverter);
+
+
+/************************************************************************************************************************************************************
+
+Format Conversion
+
+************************************************************************************************************************************************************/
+MA_API void ma_pcm_u8_to_s16(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_u8_to_s24(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_u8_to_s32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_u8_to_f32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s16_to_u8(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s16_to_s24(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s16_to_s32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s16_to_f32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s24_to_u8(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s24_to_s16(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s24_to_s32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s24_to_f32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s32_to_u8(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s32_to_s16(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s32_to_s24(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s32_to_f32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_f32_to_u8(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_f32_to_s16(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_f32_to_s24(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_f32_to_s32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_convert(void* pOut, ma_format formatOut, const void* pIn, ma_format formatIn, ma_uint64 sampleCount, ma_dither_mode ditherMode);
+MA_API void ma_convert_pcm_frames_format(void* pOut, ma_format formatOut, const void* pIn, ma_format formatIn, ma_uint64 frameCount, ma_uint32 channels, ma_dither_mode ditherMode);
+
+/*
+Deinterleaves an interleaved buffer.
+*/
+MA_API void ma_deinterleave_pcm_frames(ma_format format, ma_uint32 channels, ma_uint64 frameCount, const void* pInterleavedPCMFrames, void** ppDeinterleavedPCMFrames);
+
+/*
+Interleaves a group of deinterleaved buffers.
+*/
+MA_API void ma_interleave_pcm_frames(ma_format format, ma_uint32 channels, ma_uint64 frameCount, const void** ppDeinterleavedPCMFrames, void* pInterleavedPCMFrames);
+
+
+/************************************************************************************************************************************************************
+
+Channel Maps
+
+************************************************************************************************************************************************************/
+/*
+This is used in the shuffle table to indicate that the channel index is undefined and should be ignored.
+*/
+#define MA_CHANNEL_INDEX_NULL   255
+
+/*
+Retrieves the channel position of the specified channel in the given channel map.
+
+The pChannelMap parameter can be null, in which case miniaudio's default channel map will be assumed.
+*/
+MA_API ma_channel ma_channel_map_get_channel(const ma_channel* pChannelMap, ma_uint32 channelCount, ma_uint32 channelIndex);
+
+/*
+Initializes a blank channel map.
+
+When a blank channel map is specified anywhere it indicates that the native channel map should be used.
+*/
+MA_API void ma_channel_map_init_blank(ma_channel* pChannelMap, ma_uint32 channels);
+
+/*
+Helper for retrieving a standard channel map.
+
+The output channel map buffer must have a capacity of at least `channelMapCap`.
+*/
+MA_API void ma_channel_map_init_standard(ma_standard_channel_map standardChannelMap, ma_channel* pChannelMap, size_t channelMapCap, ma_uint32 channels);
+
+/*
+Copies a channel map.
+
+Both input and output channel map buffers must have a capacity of at least `channels`.
+*/
+MA_API void ma_channel_map_copy(ma_channel* pOut, const ma_channel* pIn, ma_uint32 channels);
+
+/*
+Copies a channel map if one is specified, otherwise copies the default channel map.
+
+The output buffer must have a capacity of at least `channels`. If not NULL, the input channel map must also have a capacity of at least `channels`.
+*/
+MA_API void ma_channel_map_copy_or_default(ma_channel* pOut, size_t channelMapCapOut, const ma_channel* pIn, ma_uint32 channels);
+
+
+/*
+Determines whether or not a channel map is valid.
+
+A blank channel map is valid (all channels set to MA_CHANNEL_NONE). The way a blank channel map is handled is context specific, but
+is usually treated as a passthrough.
+
+Invalid channel maps:
+  - A channel map with no channels
+  - A channel map with more than one channel and a mono channel
+
+The channel map buffer must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_is_valid(const ma_channel* pChannelMap, ma_uint32 channels);
+
+/*
+Helper for comparing two channel maps for equality.
+
+This assumes the channel count is the same between the two.
+
+Both channels map buffers must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_is_equal(const ma_channel* pChannelMapA, const ma_channel* pChannelMapB, ma_uint32 channels);
+
+/*
+Helper for determining if a channel map is blank (all channels set to MA_CHANNEL_NONE).
+
+The channel map buffer must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_is_blank(const ma_channel* pChannelMap, ma_uint32 channels);
+
+/*
+Helper for determining whether or not a channel is present in the given channel map.
+
+The channel map buffer must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_contains_channel_position(ma_uint32 channels, const ma_channel* pChannelMap, ma_channel channelPosition);
+
+/*
+Find a channel position in the given channel map. Returns MA_TRUE if the channel is found; MA_FALSE otherwise. The
+index of the channel is output to `pChannelIndex`.
+
+The channel map buffer must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_find_channel_position(ma_uint32 channels, const ma_channel* pChannelMap, ma_channel channelPosition, ma_uint32* pChannelIndex);
+
+/*
+Generates a string representing the given channel map.
+
+This is for printing and debugging purposes, not serialization/deserialization.
+
+Returns the length of the string, not including the null terminator.
+*/
+MA_API size_t ma_channel_map_to_string(const ma_channel* pChannelMap, ma_uint32 channels, char* pBufferOut, size_t bufferCap);
+
+/*
+Retrieves a human readable version of a channel position.
+*/
+MA_API const char* ma_channel_position_to_string(ma_channel channel);
+
+
+/************************************************************************************************************************************************************
+
+Conversion Helpers
+
+************************************************************************************************************************************************************/
+
+/*
+High-level helper for doing a full format conversion in one go. Returns the number of output frames. Call this with pOut set to NULL to
+determine the required size of the output buffer. frameCountOut should be set to the capacity of pOut. If pOut is NULL, frameCountOut is
+ignored.
+
+A return value of 0 indicates an error.
+
+This function is useful for one-off bulk conversions, but if you're streaming data you should use the ma_data_converter APIs instead.
+*/
+MA_API ma_uint64 ma_convert_frames(void* pOut, ma_uint64 frameCountOut, ma_format formatOut, ma_uint32 channelsOut, ma_uint32 sampleRateOut, const void* pIn, ma_uint64 frameCountIn, ma_format formatIn, ma_uint32 channelsIn, ma_uint32 sampleRateIn);
+MA_API ma_uint64 ma_convert_frames_ex(void* pOut, ma_uint64 frameCountOut, const void* pIn, ma_uint64 frameCountIn, const ma_data_converter_config* pConfig);
+
+
+/************************************************************************************************************************************************************
+
+Data Source
+
+************************************************************************************************************************************************************/
+typedef void ma_data_source;
+
+#define MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT    0x00000001
+
+typedef struct
+{
+    ma_result (* onRead)(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+    ma_result (* onSeek)(ma_data_source* pDataSource, ma_uint64 frameIndex);
+    ma_result (* onGetDataFormat)(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+    ma_result (* onGetCursor)(ma_data_source* pDataSource, ma_uint64* pCursor);
+    ma_result (* onGetLength)(ma_data_source* pDataSource, ma_uint64* pLength);
+    ma_result (* onSetLooping)(ma_data_source* pDataSource, ma_bool32 isLooping);
+    ma_uint32 flags;
+} ma_data_source_vtable;
+
+typedef ma_data_source* (* ma_data_source_get_next_proc)(ma_data_source* pDataSource);
+
+typedef struct
+{
+    const ma_data_source_vtable* vtable;
+} ma_data_source_config;
+
+MA_API ma_data_source_config ma_data_source_config_init(void);
+
+
+typedef struct
+{
+    const ma_data_source_vtable* vtable;
+    ma_uint64 rangeBegInFrames;
+    ma_uint64 rangeEndInFrames;             /* Set to -1 for unranged (default). */
+    ma_uint64 loopBegInFrames;              /* Relative to rangeBegInFrames. */
+    ma_uint64 loopEndInFrames;              /* Relative to rangeBegInFrames. Set to -1 for the end of the range. */
+    ma_data_source* pCurrent;               /* When non-NULL, the data source being initialized will act as a proxy and will route all operations to pCurrent. Used in conjunction with pNext/onGetNext for seamless chaining. */
+    ma_data_source* pNext;                  /* When set to NULL, onGetNext will be used. */
+    ma_data_source_get_next_proc onGetNext; /* Will be used when pNext is NULL. If both are NULL, no next will be used. */
+    MA_ATOMIC(4, ma_bool32) isLooping;
+} ma_data_source_base;
+
+MA_API ma_result ma_data_source_init(const ma_data_source_config* pConfig, ma_data_source* pDataSource);
+MA_API void ma_data_source_uninit(ma_data_source* pDataSource);
+MA_API ma_result ma_data_source_read_pcm_frames(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);   /* Must support pFramesOut = NULL in which case a forward seek should be performed. */
+MA_API ma_result ma_data_source_seek_pcm_frames(ma_data_source* pDataSource, ma_uint64 frameCount, ma_uint64* pFramesSeeked); /* Can only seek forward. Equivalent to ma_data_source_read_pcm_frames(pDataSource, NULL, frameCount, &framesRead); */
+MA_API ma_result ma_data_source_seek_to_pcm_frame(ma_data_source* pDataSource, ma_uint64 frameIndex);
+MA_API ma_result ma_data_source_seek_seconds(ma_data_source* pDataSource, float secondCount, float* pSecondsSeeked); /* Can only seek forward. Abstraction to ma_data_source_seek_pcm_frames() */
+MA_API ma_result ma_data_source_seek_to_second(ma_data_source* pDataSource, float seekPointInSeconds); /* Abstraction to ma_data_source_seek_to_pcm_frame() */
+MA_API ma_result ma_data_source_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_data_source_get_cursor_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pCursor);
+MA_API ma_result ma_data_source_get_length_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLength);    /* Returns MA_NOT_IMPLEMENTED if the length is unknown or cannot be determined. Decoders can return this. */
+MA_API ma_result ma_data_source_get_cursor_in_seconds(ma_data_source* pDataSource, float* pCursor);
+MA_API ma_result ma_data_source_get_length_in_seconds(ma_data_source* pDataSource, float* pLength);
+MA_API ma_result ma_data_source_set_looping(ma_data_source* pDataSource, ma_bool32 isLooping);
+MA_API ma_bool32 ma_data_source_is_looping(const ma_data_source* pDataSource);
+MA_API ma_result ma_data_source_set_range_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 rangeBegInFrames, ma_uint64 rangeEndInFrames);
+MA_API void ma_data_source_get_range_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pRangeBegInFrames, ma_uint64* pRangeEndInFrames);
+MA_API ma_result ma_data_source_set_loop_point_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 loopBegInFrames, ma_uint64 loopEndInFrames);
+MA_API void ma_data_source_get_loop_point_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pLoopBegInFrames, ma_uint64* pLoopEndInFrames);
+MA_API ma_result ma_data_source_set_current(ma_data_source* pDataSource, ma_data_source* pCurrentDataSource);
+MA_API ma_data_source* ma_data_source_get_current(const ma_data_source* pDataSource);
+MA_API ma_result ma_data_source_set_next(ma_data_source* pDataSource, ma_data_source* pNextDataSource);
+MA_API ma_data_source* ma_data_source_get_next(const ma_data_source* pDataSource);
+MA_API ma_result ma_data_source_set_next_callback(ma_data_source* pDataSource, ma_data_source_get_next_proc onGetNext);
+MA_API ma_data_source_get_next_proc ma_data_source_get_next_callback(const ma_data_source* pDataSource);
+
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint64 cursor;
+    ma_uint64 sizeInFrames;
+    const void* pData;
+} ma_audio_buffer_ref;
+
+MA_API ma_result ma_audio_buffer_ref_init(ma_format format, ma_uint32 channels, const void* pData, ma_uint64 sizeInFrames, ma_audio_buffer_ref* pAudioBufferRef);
+MA_API void ma_audio_buffer_ref_uninit(ma_audio_buffer_ref* pAudioBufferRef);
+MA_API ma_result ma_audio_buffer_ref_set_data(ma_audio_buffer_ref* pAudioBufferRef, const void* pData, ma_uint64 sizeInFrames);
+MA_API ma_uint64 ma_audio_buffer_ref_read_pcm_frames(ma_audio_buffer_ref* pAudioBufferRef, void* pFramesOut, ma_uint64 frameCount, ma_bool32 loop);
+MA_API ma_result ma_audio_buffer_ref_seek_to_pcm_frame(ma_audio_buffer_ref* pAudioBufferRef, ma_uint64 frameIndex);
+MA_API ma_result ma_audio_buffer_ref_map(ma_audio_buffer_ref* pAudioBufferRef, void** ppFramesOut, ma_uint64* pFrameCount);
+MA_API ma_result ma_audio_buffer_ref_unmap(ma_audio_buffer_ref* pAudioBufferRef, ma_uint64 frameCount);    /* Returns MA_AT_END if the end has been reached. This should be considered successful. */
+MA_API ma_bool32 ma_audio_buffer_ref_at_end(const ma_audio_buffer_ref* pAudioBufferRef);
+MA_API ma_result ma_audio_buffer_ref_get_cursor_in_pcm_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pCursor);
+MA_API ma_result ma_audio_buffer_ref_get_length_in_pcm_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pLength);
+MA_API ma_result ma_audio_buffer_ref_get_available_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pAvailableFrames);
+
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint64 sizeInFrames;
+    const void* pData;  /* If set to NULL, will allocate a block of memory for you. */
+    ma_allocation_callbacks allocationCallbacks;
+} ma_audio_buffer_config;
+
+MA_API ma_audio_buffer_config ma_audio_buffer_config_init(ma_format format, ma_uint32 channels, ma_uint64 sizeInFrames, const void* pData, const ma_allocation_callbacks* pAllocationCallbacks);
+
+typedef struct
+{
+    ma_audio_buffer_ref ref;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_bool32 ownsData;             /* Used to control whether or not miniaudio owns the data buffer. If set to true, pData will be freed in ma_audio_buffer_uninit(). */
+    ma_uint8 _pExtraData[1];        /* For allocating a buffer with the memory located directly after the other memory of the structure. */
+} ma_audio_buffer;
+
+MA_API ma_result ma_audio_buffer_init(const ma_audio_buffer_config* pConfig, ma_audio_buffer* pAudioBuffer);
+MA_API ma_result ma_audio_buffer_init_copy(const ma_audio_buffer_config* pConfig, ma_audio_buffer* pAudioBuffer);
+MA_API ma_result ma_audio_buffer_alloc_and_init(const ma_audio_buffer_config* pConfig, ma_audio_buffer** ppAudioBuffer);  /* Always copies the data. Doesn't make sense to use this otherwise. Use ma_audio_buffer_uninit_and_free() to uninit. */
+MA_API void ma_audio_buffer_uninit(ma_audio_buffer* pAudioBuffer);
+MA_API void ma_audio_buffer_uninit_and_free(ma_audio_buffer* pAudioBuffer);
+MA_API ma_uint64 ma_audio_buffer_read_pcm_frames(ma_audio_buffer* pAudioBuffer, void* pFramesOut, ma_uint64 frameCount, ma_bool32 loop);
+MA_API ma_result ma_audio_buffer_seek_to_pcm_frame(ma_audio_buffer* pAudioBuffer, ma_uint64 frameIndex);
+MA_API ma_result ma_audio_buffer_map(ma_audio_buffer* pAudioBuffer, void** ppFramesOut, ma_uint64* pFrameCount);
+MA_API ma_result ma_audio_buffer_unmap(ma_audio_buffer* pAudioBuffer, ma_uint64 frameCount);    /* Returns MA_AT_END if the end has been reached. This should be considered successful. */
+MA_API ma_bool32 ma_audio_buffer_at_end(const ma_audio_buffer* pAudioBuffer);
+MA_API ma_result ma_audio_buffer_get_cursor_in_pcm_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pCursor);
+MA_API ma_result ma_audio_buffer_get_length_in_pcm_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pLength);
+MA_API ma_result ma_audio_buffer_get_available_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pAvailableFrames);
+
+
+/*
+Paged Audio Buffer
+==================
+A paged audio buffer is made up of a linked list of pages. It's expandable, but not shrinkable. It
+can be used for cases where audio data is streamed in asynchronously while allowing data to be read
+at the same time.
+
+This is lock-free, but not 100% thread safe. You can append a page and read from the buffer across
+simultaneously across different threads, however only one thread at a time can append, and only one
+thread at a time can read and seek.
+*/
+typedef struct ma_paged_audio_buffer_page ma_paged_audio_buffer_page;
+struct ma_paged_audio_buffer_page
+{
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_paged_audio_buffer_page*) pNext;
+    ma_uint64 sizeInFrames;
+    ma_uint8 pAudioData[1];
+};
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_paged_audio_buffer_page head;                                /* Dummy head for the lock-free algorithm. Always has a size of 0. */
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_paged_audio_buffer_page*) pTail;    /* Never null. Initially set to &head. */
+} ma_paged_audio_buffer_data;
+
+MA_API ma_result ma_paged_audio_buffer_data_init(ma_format format, ma_uint32 channels, ma_paged_audio_buffer_data* pData);
+MA_API void ma_paged_audio_buffer_data_uninit(ma_paged_audio_buffer_data* pData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_paged_audio_buffer_page* ma_paged_audio_buffer_data_get_head(ma_paged_audio_buffer_data* pData);
+MA_API ma_paged_audio_buffer_page* ma_paged_audio_buffer_data_get_tail(ma_paged_audio_buffer_data* pData);
+MA_API ma_result ma_paged_audio_buffer_data_get_length_in_pcm_frames(ma_paged_audio_buffer_data* pData, ma_uint64* pLength);
+MA_API ma_result ma_paged_audio_buffer_data_allocate_page(ma_paged_audio_buffer_data* pData, ma_uint64 pageSizeInFrames, const void* pInitialData, const ma_allocation_callbacks* pAllocationCallbacks, ma_paged_audio_buffer_page** ppPage);
+MA_API ma_result ma_paged_audio_buffer_data_free_page(ma_paged_audio_buffer_data* pData, ma_paged_audio_buffer_page* pPage, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_paged_audio_buffer_data_append_page(ma_paged_audio_buffer_data* pData, ma_paged_audio_buffer_page* pPage);
+MA_API ma_result ma_paged_audio_buffer_data_allocate_and_append_page(ma_paged_audio_buffer_data* pData, ma_uint32 pageSizeInFrames, const void* pInitialData, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+typedef struct
+{
+    ma_paged_audio_buffer_data* pData;  /* Must not be null. */
+} ma_paged_audio_buffer_config;
+
+MA_API ma_paged_audio_buffer_config ma_paged_audio_buffer_config_init(ma_paged_audio_buffer_data* pData);
+
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_paged_audio_buffer_data* pData;              /* Audio data is read from here. Cannot be null. */
+    ma_paged_audio_buffer_page* pCurrent;
+    ma_uint64 relativeCursor;                       /* Relative to the current page. */
+    ma_uint64 absoluteCursor;
+} ma_paged_audio_buffer;
+
+MA_API ma_result ma_paged_audio_buffer_init(const ma_paged_audio_buffer_config* pConfig, ma_paged_audio_buffer* pPagedAudioBuffer);
+MA_API void ma_paged_audio_buffer_uninit(ma_paged_audio_buffer* pPagedAudioBuffer);
+MA_API ma_result ma_paged_audio_buffer_read_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);   /* Returns MA_AT_END if no more pages available. */
+MA_API ma_result ma_paged_audio_buffer_seek_to_pcm_frame(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64 frameIndex);
+MA_API ma_result ma_paged_audio_buffer_get_cursor_in_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64* pCursor);
+MA_API ma_result ma_paged_audio_buffer_get_length_in_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64* pLength);
+
+
+
+/************************************************************************************************************************************************************
+
+Ring Buffer
+
+************************************************************************************************************************************************************/
+typedef struct
+{
+    void* pBuffer;
+    ma_uint32 subbufferSizeInBytes;
+    ma_uint32 subbufferCount;
+    ma_uint32 subbufferStrideInBytes;
+    MA_ATOMIC(4, ma_uint32) encodedReadOffset;  /* Most significant bit is the loop flag. Lower 31 bits contains the actual offset in bytes. Must be used atomically. */
+    MA_ATOMIC(4, ma_uint32) encodedWriteOffset; /* Most significant bit is the loop flag. Lower 31 bits contains the actual offset in bytes. Must be used atomically. */
+    ma_bool8 ownsBuffer;                        /* Used to know whether or not miniaudio is responsible for free()-ing the buffer. */
+    ma_bool8 clearOnWriteAcquire;               /* When set, clears the acquired write buffer before returning from ma_rb_acquire_write(). */
+    ma_allocation_callbacks allocationCallbacks;
+} ma_rb;
+
+MA_API ma_result ma_rb_init_ex(size_t subbufferSizeInBytes, size_t subbufferCount, size_t subbufferStrideInBytes, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_rb* pRB);
+MA_API ma_result ma_rb_init(size_t bufferSizeInBytes, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_rb* pRB);
+MA_API void ma_rb_uninit(ma_rb* pRB);
+MA_API void ma_rb_reset(ma_rb* pRB);
+MA_API ma_result ma_rb_acquire_read(ma_rb* pRB, size_t* pSizeInBytes, void** ppBufferOut);
+MA_API ma_result ma_rb_commit_read(ma_rb* pRB, size_t sizeInBytes);
+MA_API ma_result ma_rb_acquire_write(ma_rb* pRB, size_t* pSizeInBytes, void** ppBufferOut);
+MA_API ma_result ma_rb_commit_write(ma_rb* pRB, size_t sizeInBytes);
+MA_API ma_result ma_rb_seek_read(ma_rb* pRB, size_t offsetInBytes);
+MA_API ma_result ma_rb_seek_write(ma_rb* pRB, size_t offsetInBytes);
+MA_API ma_int32 ma_rb_pointer_distance(ma_rb* pRB);    /* Returns the distance between the write pointer and the read pointer. Should never be negative for a correct program. Will return the number of bytes that can be read before the read pointer hits the write pointer. */
+MA_API ma_uint32 ma_rb_available_read(ma_rb* pRB);
+MA_API ma_uint32 ma_rb_available_write(ma_rb* pRB);
+MA_API size_t ma_rb_get_subbuffer_size(ma_rb* pRB);
+MA_API size_t ma_rb_get_subbuffer_stride(ma_rb* pRB);
+MA_API size_t ma_rb_get_subbuffer_offset(ma_rb* pRB, size_t subbufferIndex);
+MA_API void* ma_rb_get_subbuffer_ptr(ma_rb* pRB, size_t subbufferIndex, void* pBuffer);
+
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_rb rb;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate; /* Not required for the ring buffer itself, but useful for associating the data with some sample rate, particularly for data sources. */
+} ma_pcm_rb;
+
+MA_API ma_result ma_pcm_rb_init_ex(ma_format format, ma_uint32 channels, ma_uint32 subbufferSizeInFrames, ma_uint32 subbufferCount, ma_uint32 subbufferStrideInFrames, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_pcm_rb* pRB);
+MA_API ma_result ma_pcm_rb_init(ma_format format, ma_uint32 channels, ma_uint32 bufferSizeInFrames, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_pcm_rb* pRB);
+MA_API void ma_pcm_rb_uninit(ma_pcm_rb* pRB);
+MA_API void ma_pcm_rb_reset(ma_pcm_rb* pRB);
+MA_API ma_result ma_pcm_rb_acquire_read(ma_pcm_rb* pRB, ma_uint32* pSizeInFrames, void** ppBufferOut);
+MA_API ma_result ma_pcm_rb_commit_read(ma_pcm_rb* pRB, ma_uint32 sizeInFrames);
+MA_API ma_result ma_pcm_rb_acquire_write(ma_pcm_rb* pRB, ma_uint32* pSizeInFrames, void** ppBufferOut);
+MA_API ma_result ma_pcm_rb_commit_write(ma_pcm_rb* pRB, ma_uint32 sizeInFrames);
+MA_API ma_result ma_pcm_rb_seek_read(ma_pcm_rb* pRB, ma_uint32 offsetInFrames);
+MA_API ma_result ma_pcm_rb_seek_write(ma_pcm_rb* pRB, ma_uint32 offsetInFrames);
+MA_API ma_int32 ma_pcm_rb_pointer_distance(ma_pcm_rb* pRB); /* Return value is in frames. */
+MA_API ma_uint32 ma_pcm_rb_available_read(ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_available_write(ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_size(ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_stride(ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_offset(ma_pcm_rb* pRB, ma_uint32 subbufferIndex);
+MA_API void* ma_pcm_rb_get_subbuffer_ptr(ma_pcm_rb* pRB, ma_uint32 subbufferIndex, void* pBuffer);
+MA_API ma_format ma_pcm_rb_get_format(const ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_channels(const ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_sample_rate(const ma_pcm_rb* pRB);
+MA_API void ma_pcm_rb_set_sample_rate(ma_pcm_rb* pRB, ma_uint32 sampleRate);
+
+
+/*
+The idea of the duplex ring buffer is to act as the intermediary buffer when running two asynchronous devices in a duplex set up. The
+capture device writes to it, and then a playback device reads from it.
+
+At the moment this is just a simple naive implementation, but in the future I want to implement some dynamic resampling to seamlessly
+handle desyncs. Note that the API is work in progress and may change at any time in any version.
+
+The size of the buffer is based on the capture side since that's what'll be written to the buffer. It is based on the capture period size
+in frames. The internal sample rate of the capture device is also needed in order to calculate the size.
+*/
+typedef struct
+{
+    ma_pcm_rb rb;
+} ma_duplex_rb;
+
+MA_API ma_result ma_duplex_rb_init(ma_format captureFormat, ma_uint32 captureChannels, ma_uint32 sampleRate, ma_uint32 captureInternalSampleRate, ma_uint32 captureInternalPeriodSizeInFrames, const ma_allocation_callbacks* pAllocationCallbacks, ma_duplex_rb* pRB);
+MA_API ma_result ma_duplex_rb_uninit(ma_duplex_rb* pRB);
+
+
+/************************************************************************************************************************************************************
+
+Miscellaneous Helpers
+
+************************************************************************************************************************************************************/
+/*
+Retrieves a human readable description of the given result code.
+*/
+MA_API const char* ma_result_description(ma_result result);
+
+/*
+malloc()
+*/
+MA_API void* ma_malloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+calloc()
+*/
+MA_API void* ma_calloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+realloc()
+*/
+MA_API void* ma_realloc(void* p, size_t sz, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+free()
+*/
+MA_API void ma_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Performs an aligned malloc, with the assumption that the alignment is a power of 2.
+*/
+MA_API void* ma_aligned_malloc(size_t sz, size_t alignment, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Free's an aligned malloc'd buffer.
+*/
+MA_API void ma_aligned_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Retrieves a friendly name for a format.
+*/
+MA_API const char* ma_get_format_name(ma_format format);
+
+/*
+Blends two frames in floating point format.
+*/
+MA_API void ma_blend_f32(float* pOut, float* pInA, float* pInB, float factor, ma_uint32 channels);
+
+/*
+Retrieves the size of a sample in bytes for the given format.
+
+This API is efficient and is implemented using a lookup table.
+
+Thread Safety: SAFE
+  This API is pure.
+*/
+MA_API ma_uint32 ma_get_bytes_per_sample(ma_format format);
+static MA_INLINE ma_uint32 ma_get_bytes_per_frame(ma_format format, ma_uint32 channels) { return ma_get_bytes_per_sample(format) * channels; }
+
+/*
+Converts a log level to a string.
+*/
+MA_API const char* ma_log_level_to_string(ma_uint32 logLevel);
+
+
+
+
+/************************************************************************************************************************************************************
+
+Synchronization
+
+************************************************************************************************************************************************************/
+/*
+Locks a spinlock.
+*/
+MA_API ma_result ma_spinlock_lock(volatile ma_spinlock* pSpinlock);
+
+/*
+Locks a spinlock, but does not yield() when looping.
+*/
+MA_API ma_result ma_spinlock_lock_noyield(volatile ma_spinlock* pSpinlock);
+
+/*
+Unlocks a spinlock.
+*/
+MA_API ma_result ma_spinlock_unlock(volatile ma_spinlock* pSpinlock);
+
+
+#ifndef MA_NO_THREADING
+
+/*
+Creates a mutex.
+
+A mutex must be created from a valid context. A mutex is initially unlocked.
+*/
+MA_API ma_result ma_mutex_init(ma_mutex* pMutex);
+
+/*
+Deletes a mutex.
+*/
+MA_API void ma_mutex_uninit(ma_mutex* pMutex);
+
+/*
+Locks a mutex with an infinite timeout.
+*/
+MA_API void ma_mutex_lock(ma_mutex* pMutex);
+
+/*
+Unlocks a mutex.
+*/
+MA_API void ma_mutex_unlock(ma_mutex* pMutex);
+
+
+/*
+Initializes an auto-reset event.
+*/
+MA_API ma_result ma_event_init(ma_event* pEvent);
+
+/*
+Uninitializes an auto-reset event.
+*/
+MA_API void ma_event_uninit(ma_event* pEvent);
+
+/*
+Waits for the specified auto-reset event to become signalled.
+*/
+MA_API ma_result ma_event_wait(ma_event* pEvent);
+
+/*
+Signals the specified auto-reset event.
+*/
+MA_API ma_result ma_event_signal(ma_event* pEvent);
+
+
+MA_API ma_result ma_semaphore_init(int initialValue, ma_semaphore* pSemaphore);
+MA_API void ma_semaphore_uninit(ma_semaphore* pSemaphore);
+MA_API ma_result ma_semaphore_wait(ma_semaphore* pSemaphore);
+MA_API ma_result ma_semaphore_release(ma_semaphore* pSemaphore);
+#endif  /* MA_NO_THREADING */
+
+
+/*
+Fence
+=====
+This locks while the counter is larger than 0. Counter can be incremented and decremented by any
+thread, but care needs to be taken when waiting. It is possible for one thread to acquire the
+fence just as another thread returns from ma_fence_wait().
+
+The idea behind a fence is to allow you to wait for a group of operations to complete. When an
+operation starts, the counter is incremented which locks the fence. When the operation completes,
+the fence will be released which decrements the counter. ma_fence_wait() will block until the
+counter hits zero.
+
+If threading is disabled, ma_fence_wait() will spin on the counter.
+*/
+typedef struct
+{
+#ifndef MA_NO_THREADING
+    ma_event e;
+#endif
+    ma_uint32 counter;
+} ma_fence;
+
+MA_API ma_result ma_fence_init(ma_fence* pFence);
+MA_API void ma_fence_uninit(ma_fence* pFence);
+MA_API ma_result ma_fence_acquire(ma_fence* pFence);    /* Increment counter. */
+MA_API ma_result ma_fence_release(ma_fence* pFence);    /* Decrement counter. */
+MA_API ma_result ma_fence_wait(ma_fence* pFence);       /* Wait for counter to reach 0. */
+
+
+
+/*
+Notification callback for asynchronous operations.
+*/
+typedef void ma_async_notification;
+
+typedef struct
+{
+    void (* onSignal)(ma_async_notification* pNotification);
+} ma_async_notification_callbacks;
+
+MA_API ma_result ma_async_notification_signal(ma_async_notification* pNotification);
+
+
+/*
+Simple polling notification.
+
+This just sets a variable when the notification has been signalled which is then polled with ma_async_notification_poll_is_signalled()
+*/
+typedef struct
+{
+    ma_async_notification_callbacks cb;
+    ma_bool32 signalled;
+} ma_async_notification_poll;
+
+MA_API ma_result ma_async_notification_poll_init(ma_async_notification_poll* pNotificationPoll);
+MA_API ma_bool32 ma_async_notification_poll_is_signalled(const ma_async_notification_poll* pNotificationPoll);
+
+
+/*
+Event Notification
+
+This uses an ma_event. If threading is disabled (MA_NO_THREADING), initialization will fail.
+*/
+typedef struct
+{
+    ma_async_notification_callbacks cb;
+#ifndef MA_NO_THREADING
+    ma_event e;
+#endif
+} ma_async_notification_event;
+
+MA_API ma_result ma_async_notification_event_init(ma_async_notification_event* pNotificationEvent);
+MA_API ma_result ma_async_notification_event_uninit(ma_async_notification_event* pNotificationEvent);
+MA_API ma_result ma_async_notification_event_wait(ma_async_notification_event* pNotificationEvent);
+MA_API ma_result ma_async_notification_event_signal(ma_async_notification_event* pNotificationEvent);
+
+
+
+
+/************************************************************************************************************************************************************
+
+Job Queue
+
+************************************************************************************************************************************************************/
+
+/*
+Slot Allocator
+--------------
+The idea of the slot allocator is for it to be used in conjunction with a fixed sized buffer. You use the slot allocator to allocate an index that can be used
+as the insertion point for an object.
+
+Slots are reference counted to help mitigate the ABA problem in the lock-free queue we use for tracking jobs.
+
+The slot index is stored in the low 32 bits. The reference counter is stored in the high 32 bits:
+
+    +-----------------+-----------------+
+    | 32 Bits         | 32 Bits         |
+    +-----------------+-----------------+
+    | Reference Count | Slot Index      |
+    +-----------------+-----------------+
+*/
+typedef struct
+{
+    ma_uint32 capacity;    /* The number of slots to make available. */
+} ma_slot_allocator_config;
+
+MA_API ma_slot_allocator_config ma_slot_allocator_config_init(ma_uint32 capacity);
+
+
+typedef struct
+{
+    MA_ATOMIC(4, ma_uint32) bitfield;   /* Must be used atomically because the allocation and freeing routines need to make copies of this which must never be optimized away by the compiler. */
+} ma_slot_allocator_group;
+
+typedef struct
+{
+    ma_slot_allocator_group* pGroups;   /* Slots are grouped in chunks of 32. */
+    ma_uint32* pSlots;                  /* 32 bits for reference counting for ABA mitigation. */
+    ma_uint32 count;                    /* Allocation count. */
+    ma_uint32 capacity;
+
+    /* Memory management. */
+    ma_bool32 _ownsHeap;
+    void* _pHeap;
+} ma_slot_allocator;
+
+MA_API ma_result ma_slot_allocator_get_heap_size(const ma_slot_allocator_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_slot_allocator_init_preallocated(const ma_slot_allocator_config* pConfig, void* pHeap, ma_slot_allocator* pAllocator);
+MA_API ma_result ma_slot_allocator_init(const ma_slot_allocator_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_slot_allocator* pAllocator);
+MA_API void ma_slot_allocator_uninit(ma_slot_allocator* pAllocator, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_slot_allocator_alloc(ma_slot_allocator* pAllocator, ma_uint64* pSlot);
+MA_API ma_result ma_slot_allocator_free(ma_slot_allocator* pAllocator, ma_uint64 slot);
+
+
+typedef struct ma_job ma_job;
+
+/*
+Callback for processing a job. Each job type will have their own processing callback which will be
+called by ma_job_process().
+*/
+typedef ma_result (* ma_job_proc)(ma_job* pJob);
+
+/* When a job type is added here an callback needs to be added go "g_jobVTable" in the implementation section. */
+typedef enum
+{
+    /* Miscellaneous. */
+    MA_JOB_TYPE_QUIT = 0,
+    MA_JOB_TYPE_CUSTOM,
+
+    /* Resource Manager. */
+    MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE,
+    MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE,
+    MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE,
+    MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER,
+    MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER,
+    MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM,
+    MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM,
+    MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_STREAM,
+    MA_JOB_TYPE_RESOURCE_MANAGER_SEEK_DATA_STREAM,
+
+    /* Device. */
+    MA_JOB_TYPE_DEVICE_AAUDIO_REROUTE,
+
+    /* Count. Must always be last. */
+    MA_JOB_TYPE_COUNT
+} ma_job_type;
+
+struct ma_job
+{
+    union
+    {
+        struct
+        {
+            ma_uint16 code;         /* Job type. */
+            ma_uint16 slot;         /* Index into a ma_slot_allocator. */
+            ma_uint32 refcount;
+        } breakup;
+        ma_uint64 allocation;
+    } toc;  /* 8 bytes. We encode the job code into the slot allocation data to save space. */
+    MA_ATOMIC(8, ma_uint64) next; /* refcount + slot for the next item. Does not include the job code. */
+    ma_uint32 order;    /* Execution order. Used to create a data dependency and ensure a job is executed in order. Usage is contextual depending on the job type. */
+
+    union
+    {
+        /* Miscellaneous. */
+        struct
+        {
+            ma_job_proc proc;
+            ma_uintptr data0;
+            ma_uintptr data1;
+        } custom;
+
+        /* Resource Manager */
+        union
+        {
+            struct
+            {
+                /*ma_resource_manager**/ void* pResourceManager;
+                /*ma_resource_manager_data_buffer_node**/ void* pDataBufferNode;
+                char* pFilePath;
+                wchar_t* pFilePathW;
+                ma_uint32 flags;                                /* Resource manager data source flags that were used when initializing the data buffer. */
+                ma_async_notification* pInitNotification;       /* Signalled when the data buffer has been initialized and the format/channels/rate can be retrieved. */
+                ma_async_notification* pDoneNotification;       /* Signalled when the data buffer has been fully decoded. Will be passed through to MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE when decoding. */
+                ma_fence* pInitFence;                           /* Released when initialization of the decoder is complete. */
+                ma_fence* pDoneFence;                           /* Released if initialization of the decoder fails. Passed through to PAGE_DATA_BUFFER_NODE untouched if init is successful. */
+            } loadDataBufferNode;
+            struct
+            {
+                /*ma_resource_manager**/ void* pResourceManager;
+                /*ma_resource_manager_data_buffer_node**/ void* pDataBufferNode;
+                ma_async_notification* pDoneNotification;
+                ma_fence* pDoneFence;
+            } freeDataBufferNode;
+            struct
+            {
+                /*ma_resource_manager**/ void* pResourceManager;
+                /*ma_resource_manager_data_buffer_node**/ void* pDataBufferNode;
+                /*ma_decoder**/ void* pDecoder;
+                ma_async_notification* pDoneNotification;       /* Signalled when the data buffer has been fully decoded. */
+                ma_fence* pDoneFence;                           /* Passed through from LOAD_DATA_BUFFER_NODE and released when the data buffer completes decoding or an error occurs. */
+            } pageDataBufferNode;
+
+            struct
+            {
+                /*ma_resource_manager_data_buffer**/ void* pDataBuffer;
+                ma_async_notification* pInitNotification;       /* Signalled when the data buffer has been initialized and the format/channels/rate can be retrieved. */
+                ma_async_notification* pDoneNotification;       /* Signalled when the data buffer has been fully decoded. */
+                ma_fence* pInitFence;                           /* Released when the data buffer has been initialized and the format/channels/rate can be retrieved. */
+                ma_fence* pDoneFence;                           /* Released when the data buffer has been fully decoded. */
+                ma_uint64 rangeBegInPCMFrames;
+                ma_uint64 rangeEndInPCMFrames;
+                ma_uint64 loopPointBegInPCMFrames;
+                ma_uint64 loopPointEndInPCMFrames;
+                ma_uint32 isLooping;
+            } loadDataBuffer;
+            struct
+            {
+                /*ma_resource_manager_data_buffer**/ void* pDataBuffer;
+                ma_async_notification* pDoneNotification;
+                ma_fence* pDoneFence;
+            } freeDataBuffer;
+
+            struct
+            {
+                /*ma_resource_manager_data_stream**/ void* pDataStream;
+                char* pFilePath;                            /* Allocated when the job is posted, freed by the job thread after loading. */
+                wchar_t* pFilePathW;                        /* ^ As above ^. Only used if pFilePath is NULL. */
+                ma_uint64 initialSeekPoint;
+                ma_async_notification* pInitNotification;   /* Signalled after the first two pages have been decoded and frames can be read from the stream. */
+                ma_fence* pInitFence;
+            } loadDataStream;
+            struct
+            {
+                /*ma_resource_manager_data_stream**/ void* pDataStream;
+                ma_async_notification* pDoneNotification;
+                ma_fence* pDoneFence;
+            } freeDataStream;
+            struct
+            {
+                /*ma_resource_manager_data_stream**/ void* pDataStream;
+                ma_uint32 pageIndex;                    /* The index of the page to decode into. */
+            } pageDataStream;
+            struct
+            {
+                /*ma_resource_manager_data_stream**/ void* pDataStream;
+                ma_uint64 frameIndex;
+            } seekDataStream;
+        } resourceManager;
+
+        /* Device. */
+        union
+        {
+            union
+            {
+                struct
+                {
+                    /*ma_device**/ void* pDevice;
+                    /*ma_device_type*/ ma_uint32 deviceType;
+                } reroute;
+            } aaudio;
+        } device;
+    } data;
+};
+
+MA_API ma_job ma_job_init(ma_uint16 code);
+MA_API ma_result ma_job_process(ma_job* pJob);
+
+
+/*
+When set, ma_job_queue_next() will not wait and no semaphore will be signaled in
+ma_job_queue_post(). ma_job_queue_next() will return MA_NO_DATA_AVAILABLE if nothing is available.
+
+This flag should always be used for platforms that do not support multithreading.
+*/
+typedef enum
+{
+    MA_JOB_QUEUE_FLAG_NON_BLOCKING = 0x00000001
+} ma_job_queue_flags;
+
+typedef struct
+{
+    ma_uint32 flags;
+    ma_uint32 capacity; /* The maximum number of jobs that can fit in the queue at a time. */
+} ma_job_queue_config;
+
+MA_API ma_job_queue_config ma_job_queue_config_init(ma_uint32 flags, ma_uint32 capacity);
+
+
+typedef struct
+{
+    ma_uint32 flags;                /* Flags passed in at initialization time. */
+    ma_uint32 capacity;             /* The maximum number of jobs that can fit in the queue at a time. Set by the config. */
+    MA_ATOMIC(8, ma_uint64) head;   /* The first item in the list. Required for removing from the top of the list. */
+    MA_ATOMIC(8, ma_uint64) tail;   /* The last item in the list. Required for appending to the end of the list. */
+#ifndef MA_NO_THREADING
+    ma_semaphore sem;               /* Only used when MA_JOB_QUEUE_FLAG_NON_BLOCKING is unset. */
+#endif
+    ma_slot_allocator allocator;
+    ma_job* pJobs;
+#ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock lock;
+#endif
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_job_queue;
+
+MA_API ma_result ma_job_queue_get_heap_size(const ma_job_queue_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_job_queue_init_preallocated(const ma_job_queue_config* pConfig, void* pHeap, ma_job_queue* pQueue);
+MA_API ma_result ma_job_queue_init(const ma_job_queue_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_job_queue* pQueue);
+MA_API void ma_job_queue_uninit(ma_job_queue* pQueue, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_job_queue_post(ma_job_queue* pQueue, const ma_job* pJob);
+MA_API ma_result ma_job_queue_next(ma_job_queue* pQueue, ma_job* pJob); /* Returns MA_CANCELLED if the next job is a quit job. */
+
+
+
+/************************************************************************************************************************************************************
+*************************************************************************************************************************************************************
+
+DEVICE I/O
+==========
+
+This section contains the APIs for device playback and capture. Here is where you'll find ma_device_init(), etc.
+
+*************************************************************************************************************************************************************
+************************************************************************************************************************************************************/
+#ifndef MA_NO_DEVICE_IO
+/* Some backends are only supported on certain platforms. */
+#if defined(MA_WIN32) && !defined(MA_XBOX)
+    #define MA_SUPPORT_WASAPI
+
+    #if defined(MA_WIN32_DESKTOP)   /* DirectSound and WinMM backends are only supported on desktops. */
+        #define MA_SUPPORT_DSOUND
+        #define MA_SUPPORT_WINMM
+
+        /* Don't enable JACK here if compiling with Cosmopolitan. It'll be enabled in the Linux section below. */
+        #if !defined(__COSMOPOLITAN__)
+            #define MA_SUPPORT_JACK    /* JACK is technically supported on Windows, but I don't know how many people use it in practice... */
+        #endif
+    #endif
+#endif
+#if defined(MA_UNIX) && !defined(MA_ORBIS) && !defined(MA_PROSPERO)
+    #if defined(MA_LINUX)
+        #if !defined(MA_ANDROID) && !defined(__COSMOPOLITAN__)   /* ALSA is not supported on Android. */
+            #define MA_SUPPORT_ALSA
+        #endif
+    #endif
+    #if !defined(MA_BSD) && !defined(MA_ANDROID) && !defined(MA_EMSCRIPTEN)
+        #define MA_SUPPORT_PULSEAUDIO
+        #define MA_SUPPORT_JACK
+    #endif
+    #if defined(__OpenBSD__)        /* <-- Change this to "#if defined(MA_BSD)" to enable sndio on all BSD flavors. */
+        #define MA_SUPPORT_SNDIO    /* sndio is only supported on OpenBSD for now. May be expanded later if there's demand. */
+    #endif
+    #if defined(__NetBSD__) || defined(__OpenBSD__)
+        #define MA_SUPPORT_AUDIO4   /* Only support audio(4) on platforms with known support. */
+    #endif
+    #if defined(__FreeBSD__) || defined(__DragonFly__)
+        #define MA_SUPPORT_OSS      /* Only support OSS on specific platforms with known support. */
+    #endif
+#endif
+#if defined(MA_ANDROID)
+    #define MA_SUPPORT_AAUDIO
+    #define MA_SUPPORT_OPENSL
+#endif
+#if defined(MA_APPLE)
+    #define MA_SUPPORT_COREAUDIO
+#endif
+#if defined(MA_EMSCRIPTEN)
+    #define MA_SUPPORT_WEBAUDIO
+#endif
+
+/* All platforms should support custom backends. */
+#define MA_SUPPORT_CUSTOM
+
+/* Explicitly disable the Null backend for Emscripten because it uses a background thread which is not properly supported right now. */
+#if !defined(MA_EMSCRIPTEN)
+#define MA_SUPPORT_NULL
+#endif
+
+
+#if defined(MA_SUPPORT_WASAPI) && !defined(MA_NO_WASAPI) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_WASAPI))
+    #define MA_HAS_WASAPI
+#endif
+#if defined(MA_SUPPORT_DSOUND) && !defined(MA_NO_DSOUND) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_DSOUND))
+    #define MA_HAS_DSOUND
+#endif
+#if defined(MA_SUPPORT_WINMM) && !defined(MA_NO_WINMM) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_WINMM))
+    #define MA_HAS_WINMM
+#endif
+#if defined(MA_SUPPORT_ALSA) && !defined(MA_NO_ALSA) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_ALSA))
+    #define MA_HAS_ALSA
+#endif
+#if defined(MA_SUPPORT_PULSEAUDIO) && !defined(MA_NO_PULSEAUDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_PULSEAUDIO))
+    #define MA_HAS_PULSEAUDIO
+#endif
+#if defined(MA_SUPPORT_JACK) && !defined(MA_NO_JACK) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_JACK))
+    #define MA_HAS_JACK
+#endif
+#if defined(MA_SUPPORT_COREAUDIO) && !defined(MA_NO_COREAUDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_COREAUDIO))
+    #define MA_HAS_COREAUDIO
+#endif
+#if defined(MA_SUPPORT_SNDIO) && !defined(MA_NO_SNDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_SNDIO))
+    #define MA_HAS_SNDIO
+#endif
+#if defined(MA_SUPPORT_AUDIO4) && !defined(MA_NO_AUDIO4) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_AUDIO4))
+    #define MA_HAS_AUDIO4
+#endif
+#if defined(MA_SUPPORT_OSS) && !defined(MA_NO_OSS) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_OSS))
+    #define MA_HAS_OSS
+#endif
+#if defined(MA_SUPPORT_AAUDIO) && !defined(MA_NO_AAUDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_AAUDIO))
+    #define MA_HAS_AAUDIO
+#endif
+#if defined(MA_SUPPORT_OPENSL) && !defined(MA_NO_OPENSL) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_OPENSL))
+    #define MA_HAS_OPENSL
+#endif
+#if defined(MA_SUPPORT_WEBAUDIO) && !defined(MA_NO_WEBAUDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_WEBAUDIO))
+    #define MA_HAS_WEBAUDIO
+#endif
+#if defined(MA_SUPPORT_CUSTOM) && !defined(MA_NO_CUSTOM) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_CUSTOM))
+    #define MA_HAS_CUSTOM
+#endif
+#if defined(MA_SUPPORT_NULL) && !defined(MA_NO_NULL) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_NULL))
+    #define MA_HAS_NULL
+#endif
+
+typedef enum
+{
+    ma_device_state_uninitialized = 0,
+    ma_device_state_stopped       = 1,  /* The device's default state after initialization. */
+    ma_device_state_started       = 2,  /* The device is started and is requesting and/or delivering audio data. */
+    ma_device_state_starting      = 3,  /* Transitioning from a stopped state to started. */
+    ma_device_state_stopping      = 4   /* Transitioning from a started state to stopped. */
+} ma_device_state;
+
+MA_ATOMIC_SAFE_TYPE_DECL(i32, 4, device_state)
+
+
+#ifdef MA_SUPPORT_WASAPI
+/* We need a IMMNotificationClient object for WASAPI. */
+typedef struct
+{
+    void* lpVtbl;
+    ma_uint32 counter;
+    ma_device* pDevice;
+} ma_IMMNotificationClient;
+#endif
+
+/* Backend enums must be in priority order. */
+typedef enum
+{
+    ma_backend_wasapi,
+    ma_backend_dsound,
+    ma_backend_winmm,
+    ma_backend_coreaudio,
+    ma_backend_sndio,
+    ma_backend_audio4,
+    ma_backend_oss,
+    ma_backend_pulseaudio,
+    ma_backend_alsa,
+    ma_backend_jack,
+    ma_backend_aaudio,
+    ma_backend_opensl,
+    ma_backend_webaudio,
+    ma_backend_custom,  /* <-- Custom backend, with callbacks defined by the context config. */
+    ma_backend_null     /* <-- Must always be the last item. Lowest priority, and used as the terminator for backend enumeration. */
+} ma_backend;
+
+#define MA_BACKEND_COUNT (ma_backend_null+1)
+
+
+/*
+Device job thread. This is used by backends that require asynchronous processing of certain
+operations. It is not used by all backends.
+
+The device job thread is made up of a thread and a job queue. You can post a job to the thread with
+ma_device_job_thread_post(). The thread will do the processing of the job.
+*/
+typedef struct
+{
+    ma_bool32 noThread; /* Set this to true if you want to process jobs yourself. */
+    ma_uint32 jobQueueCapacity;
+    ma_uint32 jobQueueFlags;
+} ma_device_job_thread_config;
+
+MA_API ma_device_job_thread_config ma_device_job_thread_config_init(void);
+
+typedef struct
+{
+    ma_thread thread;
+    ma_job_queue jobQueue;
+    ma_bool32 _hasThread;
+} ma_device_job_thread;
+
+MA_API ma_result ma_device_job_thread_init(const ma_device_job_thread_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_device_job_thread* pJobThread);
+MA_API void ma_device_job_thread_uninit(ma_device_job_thread* pJobThread, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_device_job_thread_post(ma_device_job_thread* pJobThread, const ma_job* pJob);
+MA_API ma_result ma_device_job_thread_next(ma_device_job_thread* pJobThread, ma_job* pJob);
+
+
+
+/* Device notification types. */
+typedef enum
+{
+    ma_device_notification_type_started,
+    ma_device_notification_type_stopped,
+    ma_device_notification_type_rerouted,
+    ma_device_notification_type_interruption_began,
+    ma_device_notification_type_interruption_ended,
+    ma_device_notification_type_unlocked
+} ma_device_notification_type;
+
+typedef struct
+{
+    ma_device* pDevice;
+    ma_device_notification_type type;
+    union
+    {
+        struct
+        {
+            int _unused;
+        } started;
+        struct
+        {
+            int _unused;
+        } stopped;
+        struct
+        {
+            int _unused;
+        } rerouted;
+        struct
+        {
+            int _unused;
+        } interruption;
+    } data;
+} ma_device_notification;
+
+/*
+The notification callback for when the application should be notified of a change to the device.
+
+This callback is used for notifying the application of changes such as when the device has started,
+stopped, rerouted or an interruption has occurred. Note that not all backends will post all
+notification types. For example, some backends will perform automatic stream routing without any
+kind of notification to the host program which means miniaudio will never know about it and will
+never be able to fire the rerouted notification. You should keep this in mind when designing your
+program.
+
+The stopped notification will *not* get fired when a device is rerouted.
+
+
+Parameters
+----------
+pNotification (in)
+    A pointer to a structure containing information about the event. Use the `pDevice` member of
+    this object to retrieve the relevant device. The `type` member can be used to discriminate
+    against each of the notification types.
+
+
+Remarks
+-------
+Do not restart or uninitialize the device from the callback.
+
+Not all notifications will be triggered by all backends, however the started and stopped events
+should be reliable for all backends. Some backends do not have a good way to detect device
+stoppages due to unplugging the device which may result in the stopped callback not getting
+fired. This has been observed with at least one BSD variant.
+
+The rerouted notification is fired *after* the reroute has occurred. The stopped notification will
+*not* get fired when a device is rerouted. The following backends are known to do automatic stream
+rerouting, but do not have a way to be notified of the change:
+
+  * DirectSound
+
+The interruption notifications are used on mobile platforms for detecting when audio is interrupted
+due to things like an incoming phone call. Currently this is only implemented on iOS. None of the
+Android backends will report this notification.
+*/
+typedef void (* ma_device_notification_proc)(const ma_device_notification* pNotification);
+
+
+/*
+The callback for processing audio data from the device.
+
+The data callback is fired by miniaudio whenever the device needs to have more data delivered to a playback device, or when a capture device has some data
+available. This is called as soon as the backend asks for more data which means it may be called with inconsistent frame counts. You cannot assume the
+callback will be fired with a consistent frame count.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the relevant device.
+
+pOutput (out)
+    A pointer to the output buffer that will receive audio data that will later be played back through the speakers. This will be non-null for a playback or
+    full-duplex device and null for a capture and loopback device.
+
+pInput (in)
+    A pointer to the buffer containing input data from a recording device. This will be non-null for a capture, full-duplex or loopback device and null for a
+    playback device.
+
+frameCount (in)
+    The number of PCM frames to process. Note that this will not necessarily be equal to what you requested when you initialized the device. The
+    `periodSizeInFrames` and `periodSizeInMilliseconds` members of the device config are just hints, and are not necessarily exactly what you'll get. You must
+    not assume this will always be the same value each time the callback is fired.
+
+
+Remarks
+-------
+You cannot stop and start the device from inside the callback or else you'll get a deadlock. You must also not uninitialize the device from inside the
+callback. The following APIs cannot be called from inside the callback:
+
+    ma_device_init()
+    ma_device_init_ex()
+    ma_device_uninit()
+    ma_device_start()
+    ma_device_stop()
+
+The proper way to stop the device is to call `ma_device_stop()` from a different thread, normally the main application thread.
+*/
+typedef void (* ma_device_data_proc)(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount);
+
+
+
+
+/*
+DEPRECATED. Use ma_device_notification_proc instead.
+
+The callback for when the device has been stopped.
+
+This will be called when the device is stopped explicitly with `ma_device_stop()` and also called implicitly when the device is stopped through external forces
+such as being unplugged or an internal error occurring.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device that has just stopped.
+
+
+Remarks
+-------
+Do not restart or uninitialize the device from the callback.
+*/
+typedef void (* ma_stop_proc)(ma_device* pDevice);  /* DEPRECATED. Use ma_device_notification_proc instead. */
+
+typedef enum
+{
+    ma_device_type_playback = 1,
+    ma_device_type_capture  = 2,
+    ma_device_type_duplex   = ma_device_type_playback | ma_device_type_capture, /* 3 */
+    ma_device_type_loopback = 4
+} ma_device_type;
+
+typedef enum
+{
+    ma_share_mode_shared = 0,
+    ma_share_mode_exclusive
+} ma_share_mode;
+
+/* iOS/tvOS/watchOS session categories. */
+typedef enum
+{
+    ma_ios_session_category_default = 0,        /* AVAudioSessionCategoryPlayAndRecord. */
+    ma_ios_session_category_none,               /* Leave the session category unchanged. */
+    ma_ios_session_category_ambient,            /* AVAudioSessionCategoryAmbient */
+    ma_ios_session_category_solo_ambient,       /* AVAudioSessionCategorySoloAmbient */
+    ma_ios_session_category_playback,           /* AVAudioSessionCategoryPlayback */
+    ma_ios_session_category_record,             /* AVAudioSessionCategoryRecord */
+    ma_ios_session_category_play_and_record,    /* AVAudioSessionCategoryPlayAndRecord */
+    ma_ios_session_category_multi_route         /* AVAudioSessionCategoryMultiRoute */
+} ma_ios_session_category;
+
+/* iOS/tvOS/watchOS session category options */
+typedef enum
+{
+    ma_ios_session_category_option_mix_with_others                            = 0x01,   /* AVAudioSessionCategoryOptionMixWithOthers */
+    ma_ios_session_category_option_duck_others                                = 0x02,   /* AVAudioSessionCategoryOptionDuckOthers */
+    ma_ios_session_category_option_allow_bluetooth                            = 0x04,   /* AVAudioSessionCategoryOptionAllowBluetooth */
+    ma_ios_session_category_option_default_to_speaker                         = 0x08,   /* AVAudioSessionCategoryOptionDefaultToSpeaker */
+    ma_ios_session_category_option_interrupt_spoken_audio_and_mix_with_others = 0x11,   /* AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers */
+    ma_ios_session_category_option_allow_bluetooth_a2dp                       = 0x20,   /* AVAudioSessionCategoryOptionAllowBluetoothA2DP */
+    ma_ios_session_category_option_allow_air_play                             = 0x40,   /* AVAudioSessionCategoryOptionAllowAirPlay */
+} ma_ios_session_category_option;
+
+/* OpenSL stream types. */
+typedef enum
+{
+    ma_opensl_stream_type_default = 0,              /* Leaves the stream type unset. */
+    ma_opensl_stream_type_voice,                    /* SL_ANDROID_STREAM_VOICE */
+    ma_opensl_stream_type_system,                   /* SL_ANDROID_STREAM_SYSTEM */
+    ma_opensl_stream_type_ring,                     /* SL_ANDROID_STREAM_RING */
+    ma_opensl_stream_type_media,                    /* SL_ANDROID_STREAM_MEDIA */
+    ma_opensl_stream_type_alarm,                    /* SL_ANDROID_STREAM_ALARM */
+    ma_opensl_stream_type_notification              /* SL_ANDROID_STREAM_NOTIFICATION */
+} ma_opensl_stream_type;
+
+/* OpenSL recording presets. */
+typedef enum
+{
+    ma_opensl_recording_preset_default = 0,         /* Leaves the input preset unset. */
+    ma_opensl_recording_preset_generic,             /* SL_ANDROID_RECORDING_PRESET_GENERIC */
+    ma_opensl_recording_preset_camcorder,           /* SL_ANDROID_RECORDING_PRESET_CAMCORDER */
+    ma_opensl_recording_preset_voice_recognition,   /* SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION */
+    ma_opensl_recording_preset_voice_communication, /* SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION */
+    ma_opensl_recording_preset_voice_unprocessed    /* SL_ANDROID_RECORDING_PRESET_UNPROCESSED */
+} ma_opensl_recording_preset;
+
+/* WASAPI audio thread priority characteristics. */
+typedef enum
+{
+    ma_wasapi_usage_default = 0,
+    ma_wasapi_usage_games,
+    ma_wasapi_usage_pro_audio,
+} ma_wasapi_usage;
+
+/* AAudio usage types. */
+typedef enum
+{
+    ma_aaudio_usage_default = 0,                    /* Leaves the usage type unset. */
+    ma_aaudio_usage_media,                          /* AAUDIO_USAGE_MEDIA */
+    ma_aaudio_usage_voice_communication,            /* AAUDIO_USAGE_VOICE_COMMUNICATION */
+    ma_aaudio_usage_voice_communication_signalling, /* AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING */
+    ma_aaudio_usage_alarm,                          /* AAUDIO_USAGE_ALARM */
+    ma_aaudio_usage_notification,                   /* AAUDIO_USAGE_NOTIFICATION */
+    ma_aaudio_usage_notification_ringtone,          /* AAUDIO_USAGE_NOTIFICATION_RINGTONE */
+    ma_aaudio_usage_notification_event,             /* AAUDIO_USAGE_NOTIFICATION_EVENT */
+    ma_aaudio_usage_assistance_accessibility,       /* AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY */
+    ma_aaudio_usage_assistance_navigation_guidance, /* AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE */
+    ma_aaudio_usage_assistance_sonification,        /* AAUDIO_USAGE_ASSISTANCE_SONIFICATION */
+    ma_aaudio_usage_game,                           /* AAUDIO_USAGE_GAME */
+    ma_aaudio_usage_assitant,                       /* AAUDIO_USAGE_ASSISTANT */
+    ma_aaudio_usage_emergency,                      /* AAUDIO_SYSTEM_USAGE_EMERGENCY */
+    ma_aaudio_usage_safety,                         /* AAUDIO_SYSTEM_USAGE_SAFETY */
+    ma_aaudio_usage_vehicle_status,                 /* AAUDIO_SYSTEM_USAGE_VEHICLE_STATUS */
+    ma_aaudio_usage_announcement                    /* AAUDIO_SYSTEM_USAGE_ANNOUNCEMENT */
+} ma_aaudio_usage;
+
+/* AAudio content types. */
+typedef enum
+{
+    ma_aaudio_content_type_default = 0,             /* Leaves the content type unset. */
+    ma_aaudio_content_type_speech,                  /* AAUDIO_CONTENT_TYPE_SPEECH */
+    ma_aaudio_content_type_music,                   /* AAUDIO_CONTENT_TYPE_MUSIC */
+    ma_aaudio_content_type_movie,                   /* AAUDIO_CONTENT_TYPE_MOVIE */
+    ma_aaudio_content_type_sonification             /* AAUDIO_CONTENT_TYPE_SONIFICATION */
+} ma_aaudio_content_type;
+
+/* AAudio input presets. */
+typedef enum
+{
+    ma_aaudio_input_preset_default = 0,             /* Leaves the input preset unset. */
+    ma_aaudio_input_preset_generic,                 /* AAUDIO_INPUT_PRESET_GENERIC */
+    ma_aaudio_input_preset_camcorder,               /* AAUDIO_INPUT_PRESET_CAMCORDER */
+    ma_aaudio_input_preset_voice_recognition,       /* AAUDIO_INPUT_PRESET_VOICE_RECOGNITION */
+    ma_aaudio_input_preset_voice_communication,     /* AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION */
+    ma_aaudio_input_preset_unprocessed,             /* AAUDIO_INPUT_PRESET_UNPROCESSED */
+    ma_aaudio_input_preset_voice_performance        /* AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE */
+} ma_aaudio_input_preset;
+
+typedef enum
+{
+    ma_aaudio_allow_capture_default = 0,            /* Leaves the allowed capture policy unset. */
+    ma_aaudio_allow_capture_by_all,                 /* AAUDIO_ALLOW_CAPTURE_BY_ALL */
+    ma_aaudio_allow_capture_by_system,              /* AAUDIO_ALLOW_CAPTURE_BY_SYSTEM */
+    ma_aaudio_allow_capture_by_none                 /* AAUDIO_ALLOW_CAPTURE_BY_NONE */
+} ma_aaudio_allowed_capture_policy;
+
+typedef union
+{
+    ma_int64 counter;
+    double counterD;
+} ma_timer;
+
+typedef union
+{
+    ma_wchar_win32 wasapi[64];      /* WASAPI uses a wchar_t string for identification. */
+    ma_uint8 dsound[16];            /* DirectSound uses a GUID for identification. */
+    /*UINT_PTR*/ ma_uint32 winmm;   /* When creating a device, WinMM expects a Win32 UINT_PTR for device identification. In practice it's actually just a UINT. */
+    char alsa[256];                 /* ALSA uses a name string for identification. */
+    char pulse[256];                /* PulseAudio uses a name string for identification. */
+    int jack;                       /* JACK always uses default devices. */
+    char coreaudio[256];            /* Core Audio uses a string for identification. */
+    char sndio[256];                /* "snd/0", etc. */
+    char audio4[256];               /* "/dev/audio", etc. */
+    char oss[64];                   /* "dev/dsp0", etc. "dev/dsp" for the default device. */
+    ma_int32 aaudio;                /* AAudio uses a 32-bit integer for identification. */
+    ma_uint32 opensl;               /* OpenSL|ES uses a 32-bit unsigned integer for identification. */
+    char webaudio[32];              /* Web Audio always uses default devices for now, but if this changes it'll be a GUID. */
+    union
+    {
+        int i;
+        char s[256];
+        void* p;
+    } custom;                       /* The custom backend could be anything. Give them a few options. */
+    int nullbackend;                /* The null backend uses an integer for device IDs. */
+} ma_device_id;
+
+MA_API ma_bool32 ma_device_id_equal(const ma_device_id* pA, const ma_device_id* pB);
+
+
+typedef struct ma_context_config    ma_context_config;
+typedef struct ma_device_config     ma_device_config;
+typedef struct ma_backend_callbacks ma_backend_callbacks;
+
+#define MA_DATA_FORMAT_FLAG_EXCLUSIVE_MODE (1U << 1)    /* If set, this is supported in exclusive mode. Otherwise not natively supported by exclusive mode. */
+
+#ifndef MA_MAX_DEVICE_NAME_LENGTH
+#define MA_MAX_DEVICE_NAME_LENGTH   255
+#endif
+
+typedef struct
+{
+    /* Basic info. This is the only information guaranteed to be filled in during device enumeration. */
+    ma_device_id id;
+    char name[MA_MAX_DEVICE_NAME_LENGTH + 1];   /* +1 for null terminator. */
+    ma_bool32 isDefault;
+
+    ma_uint32 nativeDataFormatCount;
+    struct
+    {
+        ma_format format;       /* Sample format. If set to ma_format_unknown, all sample formats are supported. */
+        ma_uint32 channels;     /* If set to 0, all channels are supported. */
+        ma_uint32 sampleRate;   /* If set to 0, all sample rates are supported. */
+        ma_uint32 flags;        /* A combination of MA_DATA_FORMAT_FLAG_* flags. */
+    } nativeDataFormats[/*ma_format_count * ma_standard_sample_rate_count * MA_MAX_CHANNELS*/ 64];  /* Not sure how big to make this. There can be *many* permutations for virtual devices which can support anything. */
+} ma_device_info;
+
+struct ma_device_config
+{
+    ma_device_type deviceType;
+    ma_uint32 sampleRate;
+    ma_uint32 periodSizeInFrames;
+    ma_uint32 periodSizeInMilliseconds;
+    ma_uint32 periods;
+    ma_performance_profile performanceProfile;
+    ma_bool8 noPreSilencedOutputBuffer; /* When set to true, the contents of the output buffer passed into the data callback will be left undefined rather than initialized to silence. */
+    ma_bool8 noClip;                    /* When set to true, the contents of the output buffer passed into the data callback will not be clipped after returning. Only applies when the playback sample format is f32. */
+    ma_bool8 noDisableDenormals;        /* Do not disable denormals when firing the data callback. */
+    ma_bool8 noFixedSizedCallback;      /* Disables strict fixed-sized data callbacks. Setting this to true will result in the period size being treated only as a hint to the backend. This is an optimization for those who don't need fixed sized callbacks. */
+    ma_device_data_proc dataCallback;
+    ma_device_notification_proc notificationCallback;
+    ma_stop_proc stopCallback;
+    void* pUserData;
+    ma_resampler_config resampling;
+    struct
+    {
+        const ma_device_id* pDeviceID;
+        ma_format format;
+        ma_uint32 channels;
+        ma_channel* pChannelMap;
+        ma_channel_mix_mode channelMixMode;
+        ma_bool32 calculateLFEFromSpatialChannels;  /* When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. */
+        ma_share_mode shareMode;
+    } playback;
+    struct
+    {
+        const ma_device_id* pDeviceID;
+        ma_format format;
+        ma_uint32 channels;
+        ma_channel* pChannelMap;
+        ma_channel_mix_mode channelMixMode;
+        ma_bool32 calculateLFEFromSpatialChannels;  /* When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. */
+        ma_share_mode shareMode;
+    } capture;
+
+    struct
+    {
+        ma_wasapi_usage usage;              /* When configured, uses Avrt APIs to set the thread characteristics. */
+        ma_bool8 noAutoConvertSRC;          /* When set to true, disables the use of AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM. */
+        ma_bool8 noDefaultQualitySRC;       /* When set to true, disables the use of AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY. */
+        ma_bool8 noAutoStreamRouting;       /* Disables automatic stream routing. */
+        ma_bool8 noHardwareOffloading;      /* Disables WASAPI's hardware offloading feature. */
+        ma_uint32 loopbackProcessID;        /* The process ID to include or exclude for loopback mode. Set to 0 to capture audio from all processes. Ignored when an explicit device ID is specified. */
+        ma_bool8 loopbackProcessExclude;    /* When set to true, excludes the process specified by loopbackProcessID. By default, the process will be included. */
+    } wasapi;
+    struct
+    {
+        ma_bool32 noMMap;           /* Disables MMap mode. */
+        ma_bool32 noAutoFormat;     /* Opens the ALSA device with SND_PCM_NO_AUTO_FORMAT. */
+        ma_bool32 noAutoChannels;   /* Opens the ALSA device with SND_PCM_NO_AUTO_CHANNELS. */
+        ma_bool32 noAutoResample;   /* Opens the ALSA device with SND_PCM_NO_AUTO_RESAMPLE. */
+    } alsa;
+    struct
+    {
+        const char* pStreamNamePlayback;
+        const char* pStreamNameCapture;
+        int channelMap;
+    } pulse;
+    struct
+    {
+        ma_bool32 allowNominalSampleRateChange; /* Desktop only. When enabled, allows changing of the sample rate at the operating system level. */
+    } coreaudio;
+    struct
+    {
+        ma_opensl_stream_type streamType;
+        ma_opensl_recording_preset recordingPreset;
+        ma_bool32 enableCompatibilityWorkarounds;
+    } opensl;
+    struct
+    {
+        ma_aaudio_usage usage;
+        ma_aaudio_content_type contentType;
+        ma_aaudio_input_preset inputPreset;
+        ma_aaudio_allowed_capture_policy allowedCapturePolicy;
+        ma_bool32 noAutoStartAfterReroute;
+        ma_bool32 enableCompatibilityWorkarounds;
+        ma_bool32 allowSetBufferCapacity;
+    } aaudio;
+};
+
+
+/*
+The callback for handling device enumeration. This is fired from `ma_context_enumerate_devices()`.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context performing the enumeration.
+
+deviceType (in)
+    The type of the device being enumerated. This will always be either `ma_device_type_playback` or `ma_device_type_capture`.
+
+pInfo (in)
+    A pointer to a `ma_device_info` containing the ID and name of the enumerated device. Note that this will not include detailed information about the device,
+    only basic information (ID and name). The reason for this is that it would otherwise require opening the backend device to probe for the information which
+    is too inefficient.
+
+pUserData (in)
+    The user data pointer passed into `ma_context_enumerate_devices()`.
+*/
+typedef ma_bool32 (* ma_enum_devices_callback_proc)(ma_context* pContext, ma_device_type deviceType, const ma_device_info* pInfo, void* pUserData);
+
+
+/*
+Describes some basic details about a playback or capture device.
+*/
+typedef struct
+{
+    const ma_device_id* pDeviceID;
+    ma_share_mode shareMode;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_channel channelMap[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFrames;
+    ma_uint32 periodSizeInMilliseconds;
+    ma_uint32 periodCount;
+} ma_device_descriptor;
+
+/*
+These are the callbacks required to be implemented for a backend. These callbacks are grouped into two parts: context and device. There is one context
+to many devices. A device is created from a context.
+
+The general flow goes like this:
+
+  1) A context is created with `onContextInit()`
+     1a) Available devices can be enumerated with `onContextEnumerateDevices()` if required.
+     1b) Detailed information about a device can be queried with `onContextGetDeviceInfo()` if required.
+  2) A device is created from the context that was created in the first step using `onDeviceInit()`, and optionally a device ID that was
+     selected from device enumeration via `onContextEnumerateDevices()`.
+  3) A device is started or stopped with `onDeviceStart()` / `onDeviceStop()`
+  4) Data is delivered to and from the device by the backend. This is always done based on the native format returned by the prior call
+     to `onDeviceInit()`. Conversion between the device's native format and the format requested by the application will be handled by
+     miniaudio internally.
+
+Initialization of the context is quite simple. You need to do any necessary initialization of internal objects and then output the
+callbacks defined in this structure.
+
+Once the context has been initialized you can initialize a device. Before doing so, however, the application may want to know which
+physical devices are available. This is where `onContextEnumerateDevices()` comes in. This is fairly simple. For each device, fire the
+given callback with, at a minimum, the basic information filled out in `ma_device_info`. When the callback returns `MA_FALSE`, enumeration
+needs to stop and the `onContextEnumerateDevices()` function returns with a success code.
+
+Detailed device information can be retrieved from a device ID using `onContextGetDeviceInfo()`. This takes as input the device type and ID,
+and on output returns detailed information about the device in `ma_device_info`. The `onContextGetDeviceInfo()` callback must handle the
+case when the device ID is NULL, in which case information about the default device needs to be retrieved.
+
+Once the context has been created and the device ID retrieved (if using anything other than the default device), the device can be created.
+This is a little bit more complicated than initialization of the context due to its more complicated configuration. When initializing a
+device, a duplex device may be requested. This means a separate data format needs to be specified for both playback and capture. On input,
+the data format is set to what the application wants. On output it's set to the native format which should match as closely as possible to
+the requested format. The conversion between the format requested by the application and the device's native format will be handled
+internally by miniaudio.
+
+On input, if the sample format is set to `ma_format_unknown`, the backend is free to use whatever sample format it desires, so long as it's
+supported by miniaudio. When the channel count is set to 0, the backend should use the device's native channel count. The same applies for
+sample rate. For the channel map, the default should be used when `ma_channel_map_is_blank()` returns true (all channels set to
+`MA_CHANNEL_NONE`). On input, the `periodSizeInFrames` or `periodSizeInMilliseconds` option should always be set. The backend should
+inspect both of these variables. If `periodSizeInFrames` is set, it should take priority, otherwise it needs to be derived from the period
+size in milliseconds (`periodSizeInMilliseconds`) and the sample rate, keeping in mind that the sample rate may be 0, in which case the
+sample rate will need to be determined before calculating the period size in frames. On output, all members of the `ma_device_descriptor`
+object should be set to a valid value, except for `periodSizeInMilliseconds` which is optional (`periodSizeInFrames` *must* be set).
+
+Starting and stopping of the device is done with `onDeviceStart()` and `onDeviceStop()` and should be self-explanatory. If the backend uses
+asynchronous reading and writing, `onDeviceStart()` and `onDeviceStop()` should always be implemented.
+
+The handling of data delivery between the application and the device is the most complicated part of the process. To make this a bit
+easier, some helper callbacks are available. If the backend uses a blocking read/write style of API, the `onDeviceRead()` and
+`onDeviceWrite()` callbacks can optionally be implemented. These are blocking and work just like reading and writing from a file. If the
+backend uses a callback for data delivery, that callback must call `ma_device_handle_backend_data_callback()` from within its callback.
+This allows miniaudio to then process any necessary data conversion and then pass it to the miniaudio data callback.
+
+If the backend requires absolute flexibility with its data delivery, it can optionally implement the `onDeviceDataLoop()` callback
+which will allow it to implement the logic that will run on the audio thread. This is much more advanced and is completely optional.
+
+The audio thread should run data delivery logic in a loop while `ma_device_get_state() == ma_device_state_started` and no errors have been
+encountered. Do not start or stop the device here. That will be handled from outside the `onDeviceDataLoop()` callback.
+
+The invocation of the `onDeviceDataLoop()` callback will be handled by miniaudio. When you start the device, miniaudio will fire this
+callback. When the device is stopped, the `ma_device_get_state() == ma_device_state_started` condition will fail and the loop will be terminated
+which will then fall through to the part that stops the device. For an example on how to implement the `onDeviceDataLoop()` callback,
+look at `ma_device_audio_thread__default_read_write()`. Implement the `onDeviceDataLoopWakeup()` callback if you need a mechanism to
+wake up the audio thread.
+
+If the backend supports an optimized retrieval of device information from an initialized `ma_device` object, it should implement the
+`onDeviceGetInfo()` callback. This is optional, in which case it will fall back to `onContextGetDeviceInfo()` which is less efficient.
+*/
+struct ma_backend_callbacks
+{
+    ma_result (* onContextInit)(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks);
+    ma_result (* onContextUninit)(ma_context* pContext);
+    ma_result (* onContextEnumerateDevices)(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData);
+    ma_result (* onContextGetDeviceInfo)(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo);
+    ma_result (* onDeviceInit)(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture);
+    ma_result (* onDeviceUninit)(ma_device* pDevice);
+    ma_result (* onDeviceStart)(ma_device* pDevice);
+    ma_result (* onDeviceStop)(ma_device* pDevice);
+    ma_result (* onDeviceRead)(ma_device* pDevice, void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesRead);
+    ma_result (* onDeviceWrite)(ma_device* pDevice, const void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten);
+    ma_result (* onDeviceDataLoop)(ma_device* pDevice);
+    ma_result (* onDeviceDataLoopWakeup)(ma_device* pDevice);
+    ma_result (* onDeviceGetInfo)(ma_device* pDevice, ma_device_type type, ma_device_info* pDeviceInfo);
+};
+
+struct ma_context_config
+{
+    ma_log* pLog;
+    ma_thread_priority threadPriority;
+    size_t threadStackSize;
+    void* pUserData;
+    ma_allocation_callbacks allocationCallbacks;
+    struct
+    {
+        ma_handle hWnd; /* HWND. Optional window handle to pass into SetCooperativeLevel(). Will default to the foreground window, and if that fails, the desktop window. */
+    } dsound;
+    struct
+    {
+        ma_bool32 useVerboseDeviceEnumeration;
+    } alsa;
+    struct
+    {
+        const char* pApplicationName;
+        const char* pServerName;
+        ma_bool32 tryAutoSpawn; /* Enables autospawning of the PulseAudio daemon if necessary. */
+    } pulse;
+    struct
+    {
+        ma_ios_session_category sessionCategory;
+        ma_uint32 sessionCategoryOptions;
+        ma_bool32 noAudioSessionActivate;   /* iOS only. When set to true, does not perform an explicit [[AVAudioSession sharedInstace] setActive:true] on initialization. */
+        ma_bool32 noAudioSessionDeactivate; /* iOS only. When set to true, does not perform an explicit [[AVAudioSession sharedInstace] setActive:false] on uninitialization. */
+    } coreaudio;
+    struct
+    {
+        const char* pClientName;
+        ma_bool32 tryStartServer;
+    } jack;
+    ma_backend_callbacks custom;
+};
+
+/* WASAPI specific structure for some commands which must run on a common thread due to bugs in WASAPI. */
+typedef struct
+{
+    int code;
+    ma_event* pEvent;   /* This will be signalled when the event is complete. */
+    union
+    {
+        struct
+        {
+            int _unused;
+        } quit;
+        struct
+        {
+            ma_device_type deviceType;
+            void* pAudioClient;
+            void** ppAudioClientService;
+            ma_result* pResult; /* The result from creating the audio client service. */
+        } createAudioClient;
+        struct
+        {
+            ma_device* pDevice;
+            ma_device_type deviceType;
+        } releaseAudioClient;
+    } data;
+} ma_context_command__wasapi;
+
+struct ma_context
+{
+    ma_backend_callbacks callbacks;
+    ma_backend backend;                 /* DirectSound, ALSA, etc. */
+    ma_log* pLog;
+    ma_log log; /* Only used if the log is owned by the context. The pLog member will be set to &log in this case. */
+    ma_thread_priority threadPriority;
+    size_t threadStackSize;
+    void* pUserData;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_mutex deviceEnumLock;            /* Used to make ma_context_get_devices() thread safe. */
+    ma_mutex deviceInfoLock;            /* Used to make ma_context_get_device_info() thread safe. */
+    ma_uint32 deviceInfoCapacity;       /* Total capacity of pDeviceInfos. */
+    ma_uint32 playbackDeviceInfoCount;
+    ma_uint32 captureDeviceInfoCount;
+    ma_device_info* pDeviceInfos;       /* Playback devices first, then capture. */
+
+    union
+    {
+#ifdef MA_SUPPORT_WASAPI
+        struct
+        {
+            ma_thread commandThread;
+            ma_mutex commandLock;
+            ma_semaphore commandSem;
+            ma_uint32 commandIndex;
+            ma_uint32 commandCount;
+            ma_context_command__wasapi commands[4];
+            ma_handle hAvrt;
+            ma_proc AvSetMmThreadCharacteristicsA;
+            ma_proc AvRevertMmThreadcharacteristics;
+            ma_handle hMMDevapi;
+            ma_proc ActivateAudioInterfaceAsync;
+        } wasapi;
+#endif
+#ifdef MA_SUPPORT_DSOUND
+        struct
+        {
+            ma_handle hWnd; /* Can be null. */
+            ma_handle hDSoundDLL;
+            ma_proc DirectSoundCreate;
+            ma_proc DirectSoundEnumerateA;
+            ma_proc DirectSoundCaptureCreate;
+            ma_proc DirectSoundCaptureEnumerateA;
+        } dsound;
+#endif
+#ifdef MA_SUPPORT_WINMM
+        struct
+        {
+            ma_handle hWinMM;
+            ma_proc waveOutGetNumDevs;
+            ma_proc waveOutGetDevCapsA;
+            ma_proc waveOutOpen;
+            ma_proc waveOutClose;
+            ma_proc waveOutPrepareHeader;
+            ma_proc waveOutUnprepareHeader;
+            ma_proc waveOutWrite;
+            ma_proc waveOutReset;
+            ma_proc waveInGetNumDevs;
+            ma_proc waveInGetDevCapsA;
+            ma_proc waveInOpen;
+            ma_proc waveInClose;
+            ma_proc waveInPrepareHeader;
+            ma_proc waveInUnprepareHeader;
+            ma_proc waveInAddBuffer;
+            ma_proc waveInStart;
+            ma_proc waveInReset;
+        } winmm;
+#endif
+#ifdef MA_SUPPORT_ALSA
+        struct
+        {
+            ma_handle asoundSO;
+            ma_proc snd_pcm_open;
+            ma_proc snd_pcm_close;
+            ma_proc snd_pcm_hw_params_sizeof;
+            ma_proc snd_pcm_hw_params_any;
+            ma_proc snd_pcm_hw_params_set_format;
+            ma_proc snd_pcm_hw_params_set_format_first;
+            ma_proc snd_pcm_hw_params_get_format_mask;
+            ma_proc snd_pcm_hw_params_set_channels;
+            ma_proc snd_pcm_hw_params_set_channels_near;
+            ma_proc snd_pcm_hw_params_set_channels_minmax;
+            ma_proc snd_pcm_hw_params_set_rate_resample;
+            ma_proc snd_pcm_hw_params_set_rate;
+            ma_proc snd_pcm_hw_params_set_rate_near;
+            ma_proc snd_pcm_hw_params_set_rate_minmax;
+            ma_proc snd_pcm_hw_params_set_buffer_size_near;
+            ma_proc snd_pcm_hw_params_set_periods_near;
+            ma_proc snd_pcm_hw_params_set_access;
+            ma_proc snd_pcm_hw_params_get_format;
+            ma_proc snd_pcm_hw_params_get_channels;
+            ma_proc snd_pcm_hw_params_get_channels_min;
+            ma_proc snd_pcm_hw_params_get_channels_max;
+            ma_proc snd_pcm_hw_params_get_rate;
+            ma_proc snd_pcm_hw_params_get_rate_min;
+            ma_proc snd_pcm_hw_params_get_rate_max;
+            ma_proc snd_pcm_hw_params_get_buffer_size;
+            ma_proc snd_pcm_hw_params_get_periods;
+            ma_proc snd_pcm_hw_params_get_access;
+            ma_proc snd_pcm_hw_params_test_format;
+            ma_proc snd_pcm_hw_params_test_channels;
+            ma_proc snd_pcm_hw_params_test_rate;
+            ma_proc snd_pcm_hw_params;
+            ma_proc snd_pcm_sw_params_sizeof;
+            ma_proc snd_pcm_sw_params_current;
+            ma_proc snd_pcm_sw_params_get_boundary;
+            ma_proc snd_pcm_sw_params_set_avail_min;
+            ma_proc snd_pcm_sw_params_set_start_threshold;
+            ma_proc snd_pcm_sw_params_set_stop_threshold;
+            ma_proc snd_pcm_sw_params;
+            ma_proc snd_pcm_format_mask_sizeof;
+            ma_proc snd_pcm_format_mask_test;
+            ma_proc snd_pcm_get_chmap;
+            ma_proc snd_pcm_state;
+            ma_proc snd_pcm_prepare;
+            ma_proc snd_pcm_start;
+            ma_proc snd_pcm_drop;
+            ma_proc snd_pcm_drain;
+            ma_proc snd_pcm_reset;
+            ma_proc snd_device_name_hint;
+            ma_proc snd_device_name_get_hint;
+            ma_proc snd_card_get_index;
+            ma_proc snd_device_name_free_hint;
+            ma_proc snd_pcm_mmap_begin;
+            ma_proc snd_pcm_mmap_commit;
+            ma_proc snd_pcm_recover;
+            ma_proc snd_pcm_readi;
+            ma_proc snd_pcm_writei;
+            ma_proc snd_pcm_avail;
+            ma_proc snd_pcm_avail_update;
+            ma_proc snd_pcm_wait;
+            ma_proc snd_pcm_nonblock;
+            ma_proc snd_pcm_info;
+            ma_proc snd_pcm_info_sizeof;
+            ma_proc snd_pcm_info_get_name;
+            ma_proc snd_pcm_poll_descriptors;
+            ma_proc snd_pcm_poll_descriptors_count;
+            ma_proc snd_pcm_poll_descriptors_revents;
+            ma_proc snd_config_update_free_global;
+
+            ma_mutex internalDeviceEnumLock;
+            ma_bool32 useVerboseDeviceEnumeration;
+        } alsa;
+#endif
+#ifdef MA_SUPPORT_PULSEAUDIO
+        struct
+        {
+            ma_handle pulseSO;
+            ma_proc pa_mainloop_new;
+            ma_proc pa_mainloop_free;
+            ma_proc pa_mainloop_quit;
+            ma_proc pa_mainloop_get_api;
+            ma_proc pa_mainloop_iterate;
+            ma_proc pa_mainloop_wakeup;
+            ma_proc pa_threaded_mainloop_new;
+            ma_proc pa_threaded_mainloop_free;
+            ma_proc pa_threaded_mainloop_start;
+            ma_proc pa_threaded_mainloop_stop;
+            ma_proc pa_threaded_mainloop_lock;
+            ma_proc pa_threaded_mainloop_unlock;
+            ma_proc pa_threaded_mainloop_wait;
+            ma_proc pa_threaded_mainloop_signal;
+            ma_proc pa_threaded_mainloop_accept;
+            ma_proc pa_threaded_mainloop_get_retval;
+            ma_proc pa_threaded_mainloop_get_api;
+            ma_proc pa_threaded_mainloop_in_thread;
+            ma_proc pa_threaded_mainloop_set_name;
+            ma_proc pa_context_new;
+            ma_proc pa_context_unref;
+            ma_proc pa_context_connect;
+            ma_proc pa_context_disconnect;
+            ma_proc pa_context_set_state_callback;
+            ma_proc pa_context_get_state;
+            ma_proc pa_context_get_sink_info_list;
+            ma_proc pa_context_get_source_info_list;
+            ma_proc pa_context_get_sink_info_by_name;
+            ma_proc pa_context_get_source_info_by_name;
+            ma_proc pa_operation_unref;
+            ma_proc pa_operation_get_state;
+            ma_proc pa_channel_map_init_extend;
+            ma_proc pa_channel_map_valid;
+            ma_proc pa_channel_map_compatible;
+            ma_proc pa_stream_new;
+            ma_proc pa_stream_unref;
+            ma_proc pa_stream_connect_playback;
+            ma_proc pa_stream_connect_record;
+            ma_proc pa_stream_disconnect;
+            ma_proc pa_stream_get_state;
+            ma_proc pa_stream_get_sample_spec;
+            ma_proc pa_stream_get_channel_map;
+            ma_proc pa_stream_get_buffer_attr;
+            ma_proc pa_stream_set_buffer_attr;
+            ma_proc pa_stream_get_device_name;
+            ma_proc pa_stream_set_write_callback;
+            ma_proc pa_stream_set_read_callback;
+            ma_proc pa_stream_set_suspended_callback;
+            ma_proc pa_stream_set_moved_callback;
+            ma_proc pa_stream_is_suspended;
+            ma_proc pa_stream_flush;
+            ma_proc pa_stream_drain;
+            ma_proc pa_stream_is_corked;
+            ma_proc pa_stream_cork;
+            ma_proc pa_stream_trigger;
+            ma_proc pa_stream_begin_write;
+            ma_proc pa_stream_write;
+            ma_proc pa_stream_peek;
+            ma_proc pa_stream_drop;
+            ma_proc pa_stream_writable_size;
+            ma_proc pa_stream_readable_size;
+
+            /*pa_mainloop**/ ma_ptr pMainLoop;
+            /*pa_context**/ ma_ptr pPulseContext;
+            char* pApplicationName; /* Set when the context is initialized. Used by devices for their local pa_context objects. */
+            char* pServerName;      /* Set when the context is initialized. Used by devices for their local pa_context objects. */
+        } pulse;
+#endif
+#ifdef MA_SUPPORT_JACK
+        struct
+        {
+            ma_handle jackSO;
+            ma_proc jack_client_open;
+            ma_proc jack_client_close;
+            ma_proc jack_client_name_size;
+            ma_proc jack_set_process_callback;
+            ma_proc jack_set_buffer_size_callback;
+            ma_proc jack_on_shutdown;
+            ma_proc jack_get_sample_rate;
+            ma_proc jack_get_buffer_size;
+            ma_proc jack_get_ports;
+            ma_proc jack_activate;
+            ma_proc jack_deactivate;
+            ma_proc jack_connect;
+            ma_proc jack_port_register;
+            ma_proc jack_port_name;
+            ma_proc jack_port_get_buffer;
+            ma_proc jack_free;
+
+            char* pClientName;
+            ma_bool32 tryStartServer;
+        } jack;
+#endif
+#ifdef MA_SUPPORT_COREAUDIO
+        struct
+        {
+            ma_handle hCoreFoundation;
+            ma_proc CFStringGetCString;
+            ma_proc CFRelease;
+
+            ma_handle hCoreAudio;
+            ma_proc AudioObjectGetPropertyData;
+            ma_proc AudioObjectGetPropertyDataSize;
+            ma_proc AudioObjectSetPropertyData;
+            ma_proc AudioObjectAddPropertyListener;
+            ma_proc AudioObjectRemovePropertyListener;
+
+            ma_handle hAudioUnit;  /* Could possibly be set to AudioToolbox on later versions of macOS. */
+            ma_proc AudioComponentFindNext;
+            ma_proc AudioComponentInstanceDispose;
+            ma_proc AudioComponentInstanceNew;
+            ma_proc AudioOutputUnitStart;
+            ma_proc AudioOutputUnitStop;
+            ma_proc AudioUnitAddPropertyListener;
+            ma_proc AudioUnitGetPropertyInfo;
+            ma_proc AudioUnitGetProperty;
+            ma_proc AudioUnitSetProperty;
+            ma_proc AudioUnitInitialize;
+            ma_proc AudioUnitRender;
+
+            /*AudioComponent*/ ma_ptr component;
+            ma_bool32 noAudioSessionDeactivate; /* For tracking whether or not the iOS audio session should be explicitly deactivated. Set from the config in ma_context_init__coreaudio(). */
+        } coreaudio;
+#endif
+#ifdef MA_SUPPORT_SNDIO
+        struct
+        {
+            ma_handle sndioSO;
+            ma_proc sio_open;
+            ma_proc sio_close;
+            ma_proc sio_setpar;
+            ma_proc sio_getpar;
+            ma_proc sio_getcap;
+            ma_proc sio_start;
+            ma_proc sio_stop;
+            ma_proc sio_read;
+            ma_proc sio_write;
+            ma_proc sio_onmove;
+            ma_proc sio_nfds;
+            ma_proc sio_pollfd;
+            ma_proc sio_revents;
+            ma_proc sio_eof;
+            ma_proc sio_setvol;
+            ma_proc sio_onvol;
+            ma_proc sio_initpar;
+        } sndio;
+#endif
+#ifdef MA_SUPPORT_AUDIO4
+        struct
+        {
+            int _unused;
+        } audio4;
+#endif
+#ifdef MA_SUPPORT_OSS
+        struct
+        {
+            int versionMajor;
+            int versionMinor;
+        } oss;
+#endif
+#ifdef MA_SUPPORT_AAUDIO
+        struct
+        {
+            ma_handle hAAudio; /* libaaudio.so */
+            ma_proc AAudio_createStreamBuilder;
+            ma_proc AAudioStreamBuilder_delete;
+            ma_proc AAudioStreamBuilder_setDeviceId;
+            ma_proc AAudioStreamBuilder_setDirection;
+            ma_proc AAudioStreamBuilder_setSharingMode;
+            ma_proc AAudioStreamBuilder_setFormat;
+            ma_proc AAudioStreamBuilder_setChannelCount;
+            ma_proc AAudioStreamBuilder_setSampleRate;
+            ma_proc AAudioStreamBuilder_setBufferCapacityInFrames;
+            ma_proc AAudioStreamBuilder_setFramesPerDataCallback;
+            ma_proc AAudioStreamBuilder_setDataCallback;
+            ma_proc AAudioStreamBuilder_setErrorCallback;
+            ma_proc AAudioStreamBuilder_setPerformanceMode;
+            ma_proc AAudioStreamBuilder_setUsage;
+            ma_proc AAudioStreamBuilder_setContentType;
+            ma_proc AAudioStreamBuilder_setInputPreset;
+            ma_proc AAudioStreamBuilder_setAllowedCapturePolicy;
+            ma_proc AAudioStreamBuilder_openStream;
+            ma_proc AAudioStream_close;
+            ma_proc AAudioStream_getState;
+            ma_proc AAudioStream_waitForStateChange;
+            ma_proc AAudioStream_getFormat;
+            ma_proc AAudioStream_getChannelCount;
+            ma_proc AAudioStream_getSampleRate;
+            ma_proc AAudioStream_getBufferCapacityInFrames;
+            ma_proc AAudioStream_getFramesPerDataCallback;
+            ma_proc AAudioStream_getFramesPerBurst;
+            ma_proc AAudioStream_requestStart;
+            ma_proc AAudioStream_requestStop;
+            ma_device_job_thread jobThread; /* For processing operations outside of the error callback, specifically device disconnections and rerouting. */
+        } aaudio;
+#endif
+#ifdef MA_SUPPORT_OPENSL
+        struct
+        {
+            ma_handle libOpenSLES;
+            ma_handle SL_IID_ENGINE;
+            ma_handle SL_IID_AUDIOIODEVICECAPABILITIES;
+            ma_handle SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
+            ma_handle SL_IID_RECORD;
+            ma_handle SL_IID_PLAY;
+            ma_handle SL_IID_OUTPUTMIX;
+            ma_handle SL_IID_ANDROIDCONFIGURATION;
+            ma_proc   slCreateEngine;
+        } opensl;
+#endif
+#ifdef MA_SUPPORT_WEBAUDIO
+        struct
+        {
+            int _unused;
+        } webaudio;
+#endif
+#ifdef MA_SUPPORT_NULL
+        struct
+        {
+            int _unused;
+        } null_backend;
+#endif
+    };
+
+    union
+    {
+#if defined(MA_WIN32)
+        struct
+        {
+            /*HMODULE*/ ma_handle hOle32DLL;
+            ma_proc CoInitialize;
+            ma_proc CoInitializeEx;
+            ma_proc CoUninitialize;
+            ma_proc CoCreateInstance;
+            ma_proc CoTaskMemFree;
+            ma_proc PropVariantClear;
+            ma_proc StringFromGUID2;
+
+            /*HMODULE*/ ma_handle hUser32DLL;
+            ma_proc GetForegroundWindow;
+            ma_proc GetDesktopWindow;
+
+            /*HMODULE*/ ma_handle hAdvapi32DLL;
+            ma_proc RegOpenKeyExA;
+            ma_proc RegCloseKey;
+            ma_proc RegQueryValueExA;
+
+            /*HRESULT*/ long CoInitializeResult;
+        } win32;
+#endif
+#ifdef MA_POSIX
+        struct
+        {
+            int _unused;
+        } posix;
+#endif
+        int _unused;
+    };
+};
+
+struct ma_device
+{
+    ma_context* pContext;
+    ma_device_type type;
+    ma_uint32 sampleRate;
+    ma_atomic_device_state state;               /* The state of the device is variable and can change at any time on any thread. Must be used atomically. */
+    ma_device_data_proc onData;                 /* Set once at initialization time and should not be changed after. */
+    ma_device_notification_proc onNotification; /* Set once at initialization time and should not be changed after. */
+    ma_stop_proc onStop;                        /* DEPRECATED. Use the notification callback instead. Set once at initialization time and should not be changed after. */
+    void* pUserData;                            /* Application defined data. */
+    ma_mutex startStopLock;
+    ma_event wakeupEvent;
+    ma_event startEvent;
+    ma_event stopEvent;
+    ma_thread thread;
+    ma_result workResult;                       /* This is set by the worker thread after it's finished doing a job. */
+    ma_bool8 isOwnerOfContext;                  /* When set to true, uninitializing the device will also uninitialize the context. Set to true when NULL is passed into ma_device_init(). */
+    ma_bool8 noPreSilencedOutputBuffer;
+    ma_bool8 noClip;
+    ma_bool8 noDisableDenormals;
+    ma_bool8 noFixedSizedCallback;
+    ma_atomic_float masterVolumeFactor;         /* Linear 0..1. Can be read and written simultaneously by different threads. Must be used atomically. */
+    ma_duplex_rb duplexRB;                      /* Intermediary buffer for duplex device on asynchronous backends. */
+    struct
+    {
+        ma_resample_algorithm algorithm;
+        ma_resampling_backend_vtable* pBackendVTable;
+        void* pBackendUserData;
+        struct
+        {
+            ma_uint32 lpfOrder;
+        } linear;
+    } resampling;
+    struct
+    {
+        ma_device_id* pID;                  /* Set to NULL if using default ID, otherwise set to the address of "id". */
+        ma_device_id id;                    /* If using an explicit device, will be set to a copy of the ID used for initialization. Otherwise cleared to 0. */
+        char name[MA_MAX_DEVICE_NAME_LENGTH + 1];                     /* Maybe temporary. Likely to be replaced with a query API. */
+        ma_share_mode shareMode;            /* Set to whatever was passed in when the device was initialized. */
+        ma_format format;
+        ma_uint32 channels;
+        ma_channel channelMap[MA_MAX_CHANNELS];
+        ma_format internalFormat;
+        ma_uint32 internalChannels;
+        ma_uint32 internalSampleRate;
+        ma_channel internalChannelMap[MA_MAX_CHANNELS];
+        ma_uint32 internalPeriodSizeInFrames;
+        ma_uint32 internalPeriods;
+        ma_channel_mix_mode channelMixMode;
+        ma_bool32 calculateLFEFromSpatialChannels;
+        ma_data_converter converter;
+        void* pIntermediaryBuffer;          /* For implementing fixed sized buffer callbacks. Will be null if using variable sized callbacks. */
+        ma_uint32 intermediaryBufferCap;
+        ma_uint32 intermediaryBufferLen;    /* How many valid frames are sitting in the intermediary buffer. */
+        void* pInputCache;                  /* In external format. Can be null. */
+        ma_uint64 inputCacheCap;
+        ma_uint64 inputCacheConsumed;
+        ma_uint64 inputCacheRemaining;
+    } playback;
+    struct
+    {
+        ma_device_id* pID;                  /* Set to NULL if using default ID, otherwise set to the address of "id". */
+        ma_device_id id;                    /* If using an explicit device, will be set to a copy of the ID used for initialization. Otherwise cleared to 0. */
+        char name[MA_MAX_DEVICE_NAME_LENGTH + 1];                     /* Maybe temporary. Likely to be replaced with a query API. */
+        ma_share_mode shareMode;            /* Set to whatever was passed in when the device was initialized. */
+        ma_format format;
+        ma_uint32 channels;
+        ma_channel channelMap[MA_MAX_CHANNELS];
+        ma_format internalFormat;
+        ma_uint32 internalChannels;
+        ma_uint32 internalSampleRate;
+        ma_channel internalChannelMap[MA_MAX_CHANNELS];
+        ma_uint32 internalPeriodSizeInFrames;
+        ma_uint32 internalPeriods;
+        ma_channel_mix_mode channelMixMode;
+        ma_bool32 calculateLFEFromSpatialChannels;
+        ma_data_converter converter;
+        void* pIntermediaryBuffer;          /* For implementing fixed sized buffer callbacks. Will be null if using variable sized callbacks. */
+        ma_uint32 intermediaryBufferCap;
+        ma_uint32 intermediaryBufferLen;    /* How many valid frames are sitting in the intermediary buffer. */
+    } capture;
+
+    union
+    {
+#ifdef MA_SUPPORT_WASAPI
+        struct
+        {
+            /*IAudioClient**/ ma_ptr pAudioClientPlayback;
+            /*IAudioClient**/ ma_ptr pAudioClientCapture;
+            /*IAudioRenderClient**/ ma_ptr pRenderClient;
+            /*IAudioCaptureClient**/ ma_ptr pCaptureClient;
+            /*IMMDeviceEnumerator**/ ma_ptr pDeviceEnumerator;      /* Used for IMMNotificationClient notifications. Required for detecting default device changes. */
+            ma_IMMNotificationClient notificationClient;
+            /*HANDLE*/ ma_handle hEventPlayback;                    /* Auto reset. Initialized to signaled. */
+            /*HANDLE*/ ma_handle hEventCapture;                     /* Auto reset. Initialized to unsignaled. */
+            ma_uint32 actualBufferSizeInFramesPlayback;             /* Value from GetBufferSize(). internalPeriodSizeInFrames is not set to the _actual_ buffer size when low-latency shared mode is being used due to the way the IAudioClient3 API works. */
+            ma_uint32 actualBufferSizeInFramesCapture;
+            ma_uint32 originalPeriodSizeInFrames;
+            ma_uint32 originalPeriodSizeInMilliseconds;
+            ma_uint32 originalPeriods;
+            ma_performance_profile originalPerformanceProfile;
+            ma_uint32 periodSizeInFramesPlayback;
+            ma_uint32 periodSizeInFramesCapture;
+            void* pMappedBufferCapture;
+            ma_uint32 mappedBufferCaptureCap;
+            ma_uint32 mappedBufferCaptureLen;
+            void* pMappedBufferPlayback;
+            ma_uint32 mappedBufferPlaybackCap;
+            ma_uint32 mappedBufferPlaybackLen;
+            ma_atomic_bool32 isStartedCapture;                      /* Can be read and written simultaneously across different threads. Must be used atomically, and must be 32-bit. */
+            ma_atomic_bool32 isStartedPlayback;                     /* Can be read and written simultaneously across different threads. Must be used atomically, and must be 32-bit. */
+            ma_uint32 loopbackProcessID;
+            ma_bool8 loopbackProcessExclude;
+            ma_bool8 noAutoConvertSRC;                              /* When set to true, disables the use of AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM. */
+            ma_bool8 noDefaultQualitySRC;                           /* When set to true, disables the use of AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY. */
+            ma_bool8 noHardwareOffloading;
+            ma_bool8 allowCaptureAutoStreamRouting;
+            ma_bool8 allowPlaybackAutoStreamRouting;
+            ma_bool8 isDetachedPlayback;
+            ma_bool8 isDetachedCapture;
+            ma_wasapi_usage usage;
+            void* hAvrtHandle;
+            ma_mutex rerouteLock;
+        } wasapi;
+#endif
+#ifdef MA_SUPPORT_DSOUND
+        struct
+        {
+            /*LPDIRECTSOUND*/ ma_ptr pPlayback;
+            /*LPDIRECTSOUNDBUFFER*/ ma_ptr pPlaybackPrimaryBuffer;
+            /*LPDIRECTSOUNDBUFFER*/ ma_ptr pPlaybackBuffer;
+            /*LPDIRECTSOUNDCAPTURE*/ ma_ptr pCapture;
+            /*LPDIRECTSOUNDCAPTUREBUFFER*/ ma_ptr pCaptureBuffer;
+        } dsound;
+#endif
+#ifdef MA_SUPPORT_WINMM
+        struct
+        {
+            /*HWAVEOUT*/ ma_handle hDevicePlayback;
+            /*HWAVEIN*/ ma_handle hDeviceCapture;
+            /*HANDLE*/ ma_handle hEventPlayback;
+            /*HANDLE*/ ma_handle hEventCapture;
+            ma_uint32 fragmentSizeInFrames;
+            ma_uint32 iNextHeaderPlayback;             /* [0,periods). Used as an index into pWAVEHDRPlayback. */
+            ma_uint32 iNextHeaderCapture;              /* [0,periods). Used as an index into pWAVEHDRCapture. */
+            ma_uint32 headerFramesConsumedPlayback;    /* The number of PCM frames consumed in the buffer in pWAVEHEADER[iNextHeader]. */
+            ma_uint32 headerFramesConsumedCapture;     /* ^^^ */
+            /*WAVEHDR**/ ma_uint8* pWAVEHDRPlayback;   /* One instantiation for each period. */
+            /*WAVEHDR**/ ma_uint8* pWAVEHDRCapture;    /* One instantiation for each period. */
+            ma_uint8* pIntermediaryBufferPlayback;
+            ma_uint8* pIntermediaryBufferCapture;
+            ma_uint8* _pHeapData;                      /* Used internally and is used for the heap allocated data for the intermediary buffer and the WAVEHDR structures. */
+        } winmm;
+#endif
+#ifdef MA_SUPPORT_ALSA
+        struct
+        {
+            /*snd_pcm_t**/ ma_ptr pPCMPlayback;
+            /*snd_pcm_t**/ ma_ptr pPCMCapture;
+            /*struct pollfd**/ void* pPollDescriptorsPlayback;
+            /*struct pollfd**/ void* pPollDescriptorsCapture;
+            int pollDescriptorCountPlayback;
+            int pollDescriptorCountCapture;
+            int wakeupfdPlayback;   /* eventfd for waking up from poll() when the playback device is stopped. */
+            int wakeupfdCapture;    /* eventfd for waking up from poll() when the capture device is stopped. */
+            ma_bool8 isUsingMMapPlayback;
+            ma_bool8 isUsingMMapCapture;
+        } alsa;
+#endif
+#ifdef MA_SUPPORT_PULSEAUDIO
+        struct
+        {
+            /*pa_mainloop**/ ma_ptr pMainLoop;
+            /*pa_context**/ ma_ptr pPulseContext;
+            /*pa_stream**/ ma_ptr pStreamPlayback;
+            /*pa_stream**/ ma_ptr pStreamCapture;
+        } pulse;
+#endif
+#ifdef MA_SUPPORT_JACK
+        struct
+        {
+            /*jack_client_t**/ ma_ptr pClient;
+            /*jack_port_t**/ ma_ptr* ppPortsPlayback;
+            /*jack_port_t**/ ma_ptr* ppPortsCapture;
+            float* pIntermediaryBufferPlayback; /* Typed as a float because JACK is always floating point. */
+            float* pIntermediaryBufferCapture;
+        } jack;
+#endif
+#ifdef MA_SUPPORT_COREAUDIO
+        struct
+        {
+            ma_uint32 deviceObjectIDPlayback;
+            ma_uint32 deviceObjectIDCapture;
+            /*AudioUnit*/ ma_ptr audioUnitPlayback;
+            /*AudioUnit*/ ma_ptr audioUnitCapture;
+            /*AudioBufferList**/ ma_ptr pAudioBufferList;   /* Only used for input devices. */
+            ma_uint32 audioBufferCapInFrames;               /* Only used for input devices. The capacity in frames of each buffer in pAudioBufferList. */
+            ma_event stopEvent;
+            ma_uint32 originalPeriodSizeInFrames;
+            ma_uint32 originalPeriodSizeInMilliseconds;
+            ma_uint32 originalPeriods;
+            ma_performance_profile originalPerformanceProfile;
+            ma_bool32 isDefaultPlaybackDevice;
+            ma_bool32 isDefaultCaptureDevice;
+            ma_bool32 isSwitchingPlaybackDevice;   /* <-- Set to true when the default device has changed and miniaudio is in the process of switching. */
+            ma_bool32 isSwitchingCaptureDevice;    /* <-- Set to true when the default device has changed and miniaudio is in the process of switching. */
+            void* pNotificationHandler;             /* Only used on mobile platforms. Obj-C object for handling route changes. */
+        } coreaudio;
+#endif
+#ifdef MA_SUPPORT_SNDIO
+        struct
+        {
+            ma_ptr handlePlayback;
+            ma_ptr handleCapture;
+            ma_bool32 isStartedPlayback;
+            ma_bool32 isStartedCapture;
+        } sndio;
+#endif
+#ifdef MA_SUPPORT_AUDIO4
+        struct
+        {
+            int fdPlayback;
+            int fdCapture;
+        } audio4;
+#endif
+#ifdef MA_SUPPORT_OSS
+        struct
+        {
+            int fdPlayback;
+            int fdCapture;
+        } oss;
+#endif
+#ifdef MA_SUPPORT_AAUDIO
+        struct
+        {
+            /*AAudioStream**/ ma_ptr pStreamPlayback;
+            /*AAudioStream**/ ma_ptr pStreamCapture;
+            ma_mutex rerouteLock;
+            ma_atomic_bool32 isTearingDown;
+            ma_aaudio_usage usage;
+            ma_aaudio_content_type contentType;
+            ma_aaudio_input_preset inputPreset;
+            ma_aaudio_allowed_capture_policy allowedCapturePolicy;
+            ma_bool32 noAutoStartAfterReroute;
+        } aaudio;
+#endif
+#ifdef MA_SUPPORT_OPENSL
+        struct
+        {
+            /*SLObjectItf*/ ma_ptr pOutputMixObj;
+            /*SLOutputMixItf*/ ma_ptr pOutputMix;
+            /*SLObjectItf*/ ma_ptr pAudioPlayerObj;
+            /*SLPlayItf*/ ma_ptr pAudioPlayer;
+            /*SLObjectItf*/ ma_ptr pAudioRecorderObj;
+            /*SLRecordItf*/ ma_ptr pAudioRecorder;
+            /*SLAndroidSimpleBufferQueueItf*/ ma_ptr pBufferQueuePlayback;
+            /*SLAndroidSimpleBufferQueueItf*/ ma_ptr pBufferQueueCapture;
+            ma_bool32 isDrainingCapture;
+            ma_bool32 isDrainingPlayback;
+            ma_uint32 currentBufferIndexPlayback;
+            ma_uint32 currentBufferIndexCapture;
+            ma_uint8* pBufferPlayback;      /* This is malloc()'d and is used for storing audio data. Typed as ma_uint8 for easy offsetting. */
+            ma_uint8* pBufferCapture;
+        } opensl;
+#endif
+#ifdef MA_SUPPORT_WEBAUDIO
+        struct
+        {
+            /* AudioWorklets path. */
+            /* EMSCRIPTEN_WEBAUDIO_T */ int audioContext;
+            /* EMSCRIPTEN_WEBAUDIO_T */ int audioWorklet;
+            float* pIntermediaryBuffer;
+            void* pStackBuffer;
+            ma_result initResult;   /* Set to MA_BUSY while initialization is in progress. */
+            int deviceIndex;        /* We store the device in a list on the JavaScript side. This is used to map our C object to the JS object. */
+        } webaudio;
+#endif
+#ifdef MA_SUPPORT_NULL
+        struct
+        {
+            ma_thread deviceThread;
+            ma_event operationEvent;
+            ma_event operationCompletionEvent;
+            ma_semaphore operationSemaphore;
+            ma_uint32 operation;
+            ma_result operationResult;
+            ma_timer timer;
+            double priorRunTime;
+            ma_uint32 currentPeriodFramesRemainingPlayback;
+            ma_uint32 currentPeriodFramesRemainingCapture;
+            ma_uint64 lastProcessedFramePlayback;
+            ma_uint64 lastProcessedFrameCapture;
+            ma_atomic_bool32 isStarted; /* Read and written by multiple threads. Must be used atomically, and must be 32-bit for compiler compatibility. */
+        } null_device;
+#endif
+    };
+};
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(pop)
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic pop  /* For ISO C99 doesn't support unnamed structs/unions [-Wpedantic] */
+#endif
+
+/*
+Initializes a `ma_context_config` object.
+
+
+Return Value
+------------
+A `ma_context_config` initialized to defaults.
+
+
+Remarks
+-------
+You must always use this to initialize the default state of the `ma_context_config` object. Not using this will result in your program breaking when miniaudio
+is updated and new members are added to `ma_context_config`. It also sets logical defaults.
+
+You can override members of the returned object by changing it's members directly.
+
+
+See Also
+--------
+ma_context_init()
+*/
+MA_API ma_context_config ma_context_config_init(void);
+
+/*
+Initializes a context.
+
+The context is used for selecting and initializing an appropriate backend and to represent the backend at a more global level than that of an individual
+device. There is one context to many devices, and a device is created from a context. A context is required to enumerate devices.
+
+
+Parameters
+----------
+backends (in, optional)
+    A list of backends to try initializing, in priority order. Can be NULL, in which case it uses default priority order.
+
+backendCount (in, optional)
+    The number of items in `backend`. Ignored if `backend` is NULL.
+
+pConfig (in, optional)
+    The context configuration.
+
+pContext (in)
+    A pointer to the context object being initialized.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. Do not call this function across multiple threads as some backends read and write to global state.
+
+
+Remarks
+-------
+When `backends` is NULL, the default priority order will be used. Below is a list of backends in priority order:
+
+    |-------------|-----------------------|--------------------------------------------------------|
+    | Name        | Enum Name             | Supported Operating Systems                            |
+    |-------------|-----------------------|--------------------------------------------------------|
+    | WASAPI      | ma_backend_wasapi     | Windows Vista+                                         |
+    | DirectSound | ma_backend_dsound     | Windows XP+                                            |
+    | WinMM       | ma_backend_winmm      | Windows XP+ (may work on older versions, but untested) |
+    | Core Audio  | ma_backend_coreaudio  | macOS, iOS                                             |
+    | ALSA        | ma_backend_alsa       | Linux                                                  |
+    | PulseAudio  | ma_backend_pulseaudio | Cross Platform (disabled on Windows, BSD and Android)  |
+    | JACK        | ma_backend_jack       | Cross Platform (disabled on BSD and Android)           |
+    | sndio       | ma_backend_sndio      | OpenBSD                                                |
+    | audio(4)    | ma_backend_audio4     | NetBSD, OpenBSD                                        |
+    | OSS         | ma_backend_oss        | FreeBSD                                                |
+    | AAudio      | ma_backend_aaudio     | Android 8+                                             |
+    | OpenSL|ES   | ma_backend_opensl     | Android (API level 16+)                                |
+    | Web Audio   | ma_backend_webaudio   | Web (via Emscripten)                                   |
+    | Null        | ma_backend_null       | Cross Platform (not used on Web)                       |
+    |-------------|-----------------------|--------------------------------------------------------|
+
+The context can be configured via the `pConfig` argument. The config object is initialized with `ma_context_config_init()`. Individual configuration settings
+can then be set directly on the structure. Below are the members of the `ma_context_config` object.
+
+    pLog
+        A pointer to the `ma_log` to post log messages to. Can be NULL if the application does not
+        require logging. See the `ma_log` API for details on how to use the logging system.
+
+    threadPriority
+        The desired priority to use for the audio thread. Allowable values include the following:
+
+        |--------------------------------------|
+        | Thread Priority                      |
+        |--------------------------------------|
+        | ma_thread_priority_idle              |
+        | ma_thread_priority_lowest            |
+        | ma_thread_priority_low               |
+        | ma_thread_priority_normal            |
+        | ma_thread_priority_high              |
+        | ma_thread_priority_highest (default) |
+        | ma_thread_priority_realtime          |
+        | ma_thread_priority_default           |
+        |--------------------------------------|
+
+    threadStackSize
+        The desired size of the stack for the audio thread. Defaults to the operating system's default.
+
+    pUserData
+        A pointer to application-defined data. This can be accessed from the context object directly such as `context.pUserData`.
+
+    allocationCallbacks
+        Structure containing custom allocation callbacks. Leaving this at defaults will cause it to use MA_MALLOC, MA_REALLOC and MA_FREE. These allocation
+        callbacks will be used for anything tied to the context, including devices.
+
+    alsa.useVerboseDeviceEnumeration
+        ALSA will typically enumerate many different devices which can be intrusive and not user-friendly. To combat this, miniaudio will enumerate only unique
+        card/device pairs by default. The problem with this is that you lose a bit of flexibility and control. Setting alsa.useVerboseDeviceEnumeration makes
+        it so the ALSA backend includes all devices. Defaults to false.
+
+    pulse.pApplicationName
+        PulseAudio only. The application name to use when initializing the PulseAudio context with `pa_context_new()`.
+
+    pulse.pServerName
+        PulseAudio only. The name of the server to connect to with `pa_context_connect()`.
+
+    pulse.tryAutoSpawn
+        PulseAudio only. Whether or not to try automatically starting the PulseAudio daemon. Defaults to false. If you set this to true, keep in mind that
+        miniaudio uses a trial and error method to find the most appropriate backend, and this will result in the PulseAudio daemon starting which may be
+        intrusive for the end user.
+
+    coreaudio.sessionCategory
+        iOS only. The session category to use for the shared AudioSession instance. Below is a list of allowable values and their Core Audio equivalents.
+
+        |-----------------------------------------|-------------------------------------|
+        | miniaudio Token                         | Core Audio Token                    |
+        |-----------------------------------------|-------------------------------------|
+        | ma_ios_session_category_ambient         | AVAudioSessionCategoryAmbient       |
+        | ma_ios_session_category_solo_ambient    | AVAudioSessionCategorySoloAmbient   |
+        | ma_ios_session_category_playback        | AVAudioSessionCategoryPlayback      |
+        | ma_ios_session_category_record          | AVAudioSessionCategoryRecord        |
+        | ma_ios_session_category_play_and_record | AVAudioSessionCategoryPlayAndRecord |
+        | ma_ios_session_category_multi_route     | AVAudioSessionCategoryMultiRoute    |
+        | ma_ios_session_category_none            | AVAudioSessionCategoryAmbient       |
+        | ma_ios_session_category_default         | AVAudioSessionCategoryAmbient       |
+        |-----------------------------------------|-------------------------------------|
+
+    coreaudio.sessionCategoryOptions
+        iOS only. Session category options to use with the shared AudioSession instance. Below is a list of allowable values and their Core Audio equivalents.
+
+        |---------------------------------------------------------------------------|------------------------------------------------------------------|
+        | miniaudio Token                                                           | Core Audio Token                                                 |
+        |---------------------------------------------------------------------------|------------------------------------------------------------------|
+        | ma_ios_session_category_option_mix_with_others                            | AVAudioSessionCategoryOptionMixWithOthers                        |
+        | ma_ios_session_category_option_duck_others                                | AVAudioSessionCategoryOptionDuckOthers                           |
+        | ma_ios_session_category_option_allow_bluetooth                            | AVAudioSessionCategoryOptionAllowBluetooth                       |
+        | ma_ios_session_category_option_default_to_speaker                         | AVAudioSessionCategoryOptionDefaultToSpeaker                     |
+        | ma_ios_session_category_option_interrupt_spoken_audio_and_mix_with_others | AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers |
+        | ma_ios_session_category_option_allow_bluetooth_a2dp                       | AVAudioSessionCategoryOptionAllowBluetoothA2DP                   |
+        | ma_ios_session_category_option_allow_air_play                             | AVAudioSessionCategoryOptionAllowAirPlay                         |
+        |---------------------------------------------------------------------------|------------------------------------------------------------------|
+
+    coreaudio.noAudioSessionActivate
+        iOS only. When set to true, does not perform an explicit [[AVAudioSession sharedInstace] setActive:true] on initialization.
+
+    coreaudio.noAudioSessionDeactivate
+        iOS only. When set to true, does not perform an explicit [[AVAudioSession sharedInstace] setActive:false] on uninitialization.
+
+    jack.pClientName
+        The name of the client to pass to `jack_client_open()`.
+
+    jack.tryStartServer
+        Whether or not to try auto-starting the JACK server. Defaults to false.
+
+
+It is recommended that only a single context is active at any given time because it's a bulky data structure which performs run-time linking for the
+relevant backends every time it's initialized.
+
+The location of the context cannot change throughout it's lifetime. Consider allocating the `ma_context` object with `malloc()` if this is an issue. The
+reason for this is that a pointer to the context is stored in the `ma_device` structure.
+
+
+Example 1 - Default Initialization
+----------------------------------
+The example below shows how to initialize the context using the default configuration.
+
+```c
+ma_context context;
+ma_result result = ma_context_init(NULL, 0, NULL, &context);
+if (result != MA_SUCCESS) {
+    // Error.
+}
+```
+
+
+Example 2 - Custom Configuration
+--------------------------------
+The example below shows how to initialize the context using custom backend priorities and a custom configuration. In this hypothetical example, the program
+wants to prioritize ALSA over PulseAudio on Linux. They also want to avoid using the WinMM backend on Windows because it's latency is too high. They also
+want an error to be returned if no valid backend is available which they achieve by excluding the Null backend.
+
+For the configuration, the program wants to capture any log messages so they can, for example, route it to a log file and user interface.
+
+```c
+ma_backend backends[] = {
+    ma_backend_alsa,
+    ma_backend_pulseaudio,
+    ma_backend_wasapi,
+    ma_backend_dsound
+};
+
+ma_log log;
+ma_log_init(&log);
+ma_log_register_callback(&log, ma_log_callback_init(my_log_callbac, pMyLogUserData));
+
+ma_context_config config = ma_context_config_init();
+config.pLog = &log; // Specify a custom log object in the config so any logs that are posted from ma_context_init() are captured.
+
+ma_context context;
+ma_result result = ma_context_init(backends, sizeof(backends)/sizeof(backends[0]), &config, &context);
+if (result != MA_SUCCESS) {
+    // Error.
+    if (result == MA_NO_BACKEND) {
+        // Couldn't find an appropriate backend.
+    }
+}
+
+// You could also attach a log callback post-initialization:
+ma_log_register_callback(ma_context_get_log(&context), ma_log_callback_init(my_log_callback, pMyLogUserData));
+```
+
+
+See Also
+--------
+ma_context_config_init()
+ma_context_uninit()
+*/
+MA_API ma_result ma_context_init(const ma_backend backends[], ma_uint32 backendCount, const ma_context_config* pConfig, ma_context* pContext);
+
+/*
+Uninitializes a context.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. Do not call this function across multiple threads as some backends read and write to global state.
+
+
+Remarks
+-------
+Results are undefined if you call this while any device created by this context is still active.
+
+
+See Also
+--------
+ma_context_init()
+*/
+MA_API ma_result ma_context_uninit(ma_context* pContext);
+
+/*
+Retrieves the size of the ma_context object.
+
+This is mainly for the purpose of bindings to know how much memory to allocate.
+*/
+MA_API size_t ma_context_sizeof(void);
+
+/*
+Retrieves a pointer to the log object associated with this context.
+
+
+Remarks
+-------
+Pass the returned pointer to `ma_log_post()`, `ma_log_postv()` or `ma_log_postf()` to post a log
+message.
+
+You can attach your own logging callback to the log with `ma_log_register_callback()`
+
+
+Return Value
+------------
+A pointer to the `ma_log` object that the context uses to post log messages. If some error occurs,
+NULL will be returned.
+*/
+MA_API ma_log* ma_context_get_log(ma_context* pContext);
+
+/*
+Enumerates over every device (both playback and capture).
+
+This is a lower-level enumeration function to the easier to use `ma_context_get_devices()`. Use `ma_context_enumerate_devices()` if you would rather not incur
+an internal heap allocation, or it simply suits your code better.
+
+Note that this only retrieves the ID and name/description of the device. The reason for only retrieving basic information is that it would otherwise require
+opening the backend device in order to probe it for more detailed information which can be inefficient. Consider using `ma_context_get_device_info()` for this,
+but don't call it from within the enumeration callback.
+
+Returning false from the callback will stop enumeration. Returning true will continue enumeration.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context performing the enumeration.
+
+callback (in)
+    The callback to fire for each enumerated device.
+
+pUserData (in)
+    A pointer to application-defined data passed to the callback.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Safe. This is guarded using a simple mutex lock.
+
+
+Remarks
+-------
+Do _not_ assume the first enumerated device of a given type is the default device.
+
+Some backends and platforms may only support default playback and capture devices.
+
+In general, you should not do anything complicated from within the callback. In particular, do not try initializing a device from within the callback. Also,
+do not try to call `ma_context_get_device_info()` from within the callback.
+
+Consider using `ma_context_get_devices()` for a simpler and safer API, albeit at the expense of an internal heap allocation.
+
+
+Example 1 - Simple Enumeration
+------------------------------
+ma_bool32 ma_device_enum_callback(ma_context* pContext, ma_device_type deviceType, const ma_device_info* pInfo, void* pUserData)
+{
+    printf("Device Name: %s\n", pInfo->name);
+    return MA_TRUE;
+}
+
+ma_result result = ma_context_enumerate_devices(&context, my_device_enum_callback, pMyUserData);
+if (result != MA_SUCCESS) {
+    // Error.
+}
+
+
+See Also
+--------
+ma_context_get_devices()
+*/
+MA_API ma_result ma_context_enumerate_devices(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData);
+
+/*
+Retrieves basic information about every active playback and/or capture device.
+
+This function will allocate memory internally for the device lists and return a pointer to them through the `ppPlaybackDeviceInfos` and `ppCaptureDeviceInfos`
+parameters. If you do not want to incur the overhead of these allocations consider using `ma_context_enumerate_devices()` which will instead use a callback.
+
+Note that this only retrieves the ID and name/description of the device. The reason for only retrieving basic information is that it would otherwise require
+opening the backend device in order to probe it for more detailed information which can be inefficient. Consider using `ma_context_get_device_info()` for this,
+but don't call it from within the enumeration callback.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context performing the enumeration.
+
+ppPlaybackDeviceInfos (out)
+    A pointer to a pointer that will receive the address of a buffer containing the list of `ma_device_info` structures for playback devices.
+
+pPlaybackDeviceCount (out)
+    A pointer to an unsigned integer that will receive the number of playback devices.
+
+ppCaptureDeviceInfos (out)
+    A pointer to a pointer that will receive the address of a buffer containing the list of `ma_device_info` structures for capture devices.
+
+pCaptureDeviceCount (out)
+    A pointer to an unsigned integer that will receive the number of capture devices.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. Since each call to this function invalidates the pointers from the previous call, you should not be calling this simultaneously across multiple
+threads. Instead, you need to make a copy of the returned data with your own higher level synchronization.
+
+
+Remarks
+-------
+It is _not_ safe to assume the first device in the list is the default device.
+
+You can pass in NULL for the playback or capture lists in which case they'll be ignored.
+
+The returned pointers will become invalid upon the next call this this function, or when the context is uninitialized. Do not free the returned pointers.
+
+
+See Also
+--------
+ma_context_enumerate_devices()
+*/
+MA_API ma_result ma_context_get_devices(ma_context* pContext, ma_device_info** ppPlaybackDeviceInfos, ma_uint32* pPlaybackDeviceCount, ma_device_info** ppCaptureDeviceInfos, ma_uint32* pCaptureDeviceCount);
+
+/*
+Retrieves information about a device of the given type, with the specified ID and share mode.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context performing the query.
+
+deviceType (in)
+    The type of the device being queried. Must be either `ma_device_type_playback` or `ma_device_type_capture`.
+
+pDeviceID (in)
+    The ID of the device being queried.
+
+pDeviceInfo (out)
+    A pointer to the `ma_device_info` structure that will receive the device information.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Safe. This is guarded using a simple mutex lock.
+
+
+Remarks
+-------
+Do _not_ call this from within the `ma_context_enumerate_devices()` callback.
+
+It's possible for a device to have different information and capabilities depending on whether or not it's opened in shared or exclusive mode. For example, in
+shared mode, WASAPI always uses floating point samples for mixing, but in exclusive mode it can be anything. Therefore, this function allows you to specify
+which share mode you want information for. Note that not all backends and devices support shared or exclusive mode, in which case this function will fail if
+the requested share mode is unsupported.
+
+This leaves pDeviceInfo unmodified in the result of an error.
+*/
+MA_API ma_result ma_context_get_device_info(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo);
+
+/*
+Determines if the given context supports loopback mode.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context getting queried.
+
+
+Return Value
+------------
+MA_TRUE if the context supports loopback mode; MA_FALSE otherwise.
+*/
+MA_API ma_bool32 ma_context_is_loopback_supported(ma_context* pContext);
+
+
+
+/*
+Initializes a device config with default settings.
+
+
+Parameters
+----------
+deviceType (in)
+    The type of the device this config is being initialized for. This must set to one of the following:
+
+    |-------------------------|
+    | Device Type             |
+    |-------------------------|
+    | ma_device_type_playback |
+    | ma_device_type_capture  |
+    | ma_device_type_duplex   |
+    | ma_device_type_loopback |
+    |-------------------------|
+
+
+Return Value
+------------
+A new device config object with default settings. You will typically want to adjust the config after this function returns. See remarks.
+
+
+Thread Safety
+-------------
+Safe.
+
+
+Callback Safety
+---------------
+Safe, but don't try initializing a device in a callback.
+
+
+Remarks
+-------
+The returned config will be initialized to defaults. You will normally want to customize a few variables before initializing the device. See Example 1 for a
+typical configuration which sets the sample format, channel count, sample rate, data callback and user data. These are usually things you will want to change
+before initializing the device.
+
+See `ma_device_init()` for details on specific configuration options.
+
+
+Example 1 - Simple Configuration
+--------------------------------
+The example below is what a program will typically want to configure for each device at a minimum. Notice how `ma_device_config_init()` is called first, and
+then the returned object is modified directly. This is important because it ensures that your program continues to work as new configuration options are added
+to the `ma_device_config` structure.
+
+```c
+ma_device_config config = ma_device_config_init(ma_device_type_playback);
+config.playback.format   = ma_format_f32;
+config.playback.channels = 2;
+config.sampleRate        = 48000;
+config.dataCallback      = ma_data_callback;
+config.pUserData         = pMyUserData;
+```
+
+
+See Also
+--------
+ma_device_init()
+ma_device_init_ex()
+*/
+MA_API ma_device_config ma_device_config_init(ma_device_type deviceType);
+
+
+/*
+Initializes a device.
+
+A device represents a physical audio device. The idea is you send or receive audio data from the device to either play it back through a speaker, or capture it
+from a microphone. Whether or not you should send or receive data from the device (or both) depends on the type of device you are initializing which can be
+playback, capture, full-duplex or loopback. (Note that loopback mode is only supported on select backends.) Sending and receiving audio data to and from the
+device is done via a callback which is fired by miniaudio at periodic time intervals.
+
+The frequency at which data is delivered to and from a device depends on the size of its period. The size of the period can be defined in terms of PCM frames
+or milliseconds, whichever is more convenient. Generally speaking, the smaller the period, the lower the latency at the expense of higher CPU usage and
+increased risk of glitching due to the more frequent and granular data deliver intervals. The size of a period will depend on your requirements, but
+miniaudio's defaults should work fine for most scenarios. If you're building a game you should leave this fairly small, whereas if you're building a simple
+media player you can make it larger. Note that the period size you request is actually just a hint - miniaudio will tell the backend what you want, but the
+backend is ultimately responsible for what it gives you. You cannot assume you will get exactly what you ask for.
+
+When delivering data to and from a device you need to make sure it's in the correct format which you can set through the device configuration. You just set the
+format that you want to use and miniaudio will perform all of the necessary conversion for you internally. When delivering data to and from the callback you
+can assume the format is the same as what you requested when you initialized the device. See Remarks for more details on miniaudio's data conversion pipeline.
+
+
+Parameters
+----------
+pContext (in, optional)
+    A pointer to the context that owns the device. This can be null, in which case it creates a default context internally.
+
+pConfig (in)
+    A pointer to the device configuration. Cannot be null. See remarks for details.
+
+pDevice (out)
+    A pointer to the device object being initialized.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. It is not safe to call this function simultaneously for different devices because some backends depend on and mutate global state. The same applies to
+calling this at the same time as `ma_device_uninit()`.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback.
+
+
+Remarks
+-------
+Setting `pContext` to NULL will result in miniaudio creating a default context internally and is equivalent to passing in a context initialized like so:
+
+    ```c
+    ma_context_init(NULL, 0, NULL, &context);
+    ```
+
+Do not set `pContext` to NULL if you are needing to open multiple devices. You can, however, use NULL when initializing the first device, and then use
+device.pContext for the initialization of other devices.
+
+The device can be configured via the `pConfig` argument. The config object is initialized with `ma_device_config_init()`. Individual configuration settings can
+then be set directly on the structure. Below are the members of the `ma_device_config` object.
+
+    deviceType
+        Must be `ma_device_type_playback`, `ma_device_type_capture`, `ma_device_type_duplex` of `ma_device_type_loopback`.
+
+    sampleRate
+        The sample rate, in hertz. The most common sample rates are 48000 and 44100. Setting this to 0 will use the device's native sample rate.
+
+    periodSizeInFrames
+        The desired size of a period in PCM frames. If this is 0, `periodSizeInMilliseconds` will be used instead. If both are 0 the default buffer size will
+        be used depending on the selected performance profile. This value affects latency. See below for details.
+
+    periodSizeInMilliseconds
+        The desired size of a period in milliseconds. If this is 0, `periodSizeInFrames` will be used instead. If both are 0 the default buffer size will be
+        used depending on the selected performance profile. The value affects latency. See below for details.
+
+    periods
+        The number of periods making up the device's entire buffer. The total buffer size is `periodSizeInFrames` or `periodSizeInMilliseconds` multiplied by
+        this value. This is just a hint as backends will be the ones who ultimately decide how your periods will be configured.
+
+    performanceProfile
+        A hint to miniaudio as to the performance requirements of your program. Can be either `ma_performance_profile_low_latency` (default) or
+        `ma_performance_profile_conservative`. This mainly affects the size of default buffers and can usually be left at its default value.
+
+    noPreSilencedOutputBuffer
+        When set to true, the contents of the output buffer passed into the data callback will be left undefined. When set to false (default), the contents of
+        the output buffer will be cleared the zero. You can use this to avoid the overhead of zeroing out the buffer if you can guarantee that your data
+        callback will write to every sample in the output buffer, or if you are doing your own clearing.
+
+    noClip
+        When set to true, the contents of the output buffer are left alone after returning and it will be left up to the backend itself to decide whether or
+        not to clip. When set to false (default), the contents of the output buffer passed into the data callback will be clipped after returning. This only
+        applies when the playback sample format is f32.
+
+    noDisableDenormals
+        By default, miniaudio will disable denormals when the data callback is called. Setting this to true will prevent the disabling of denormals.
+
+    noFixedSizedCallback
+        Allows miniaudio to fire the data callback with any frame count. When this is set to false (the default), the data callback will be fired with a
+        consistent frame count as specified by `periodSizeInFrames` or `periodSizeInMilliseconds`. When set to true, miniaudio will fire the callback with
+        whatever the backend requests, which could be anything.
+
+    dataCallback
+        The callback to fire whenever data is ready to be delivered to or from the device.
+
+    notificationCallback
+        The callback to fire when something has changed with the device, such as whether or not it has been started or stopped.
+
+    pUserData
+        The user data pointer to use with the device. You can access this directly from the device object like `device.pUserData`.
+
+    resampling.algorithm
+        The resampling algorithm to use when miniaudio needs to perform resampling between the rate specified by `sampleRate` and the device's native rate. The
+        default value is `ma_resample_algorithm_linear`, and the quality can be configured with `resampling.linear.lpfOrder`.
+
+    resampling.pBackendVTable
+        A pointer to an optional vtable that can be used for plugging in a custom resampler.
+
+    resampling.pBackendUserData
+        A pointer that will passed to callbacks in pBackendVTable.
+
+    resampling.linear.lpfOrder
+        The linear resampler applies a low-pass filter as part of its processing for anti-aliasing. This setting controls the order of the filter. The higher
+        the value, the better the quality, in general. Setting this to 0 will disable low-pass filtering altogether. The maximum value is
+        `MA_MAX_FILTER_ORDER`. The default value is `min(4, MA_MAX_FILTER_ORDER)`.
+
+    playback.pDeviceID
+        A pointer to a `ma_device_id` structure containing the ID of the playback device to initialize. Setting this NULL (default) will use the system's
+        default playback device. Retrieve the device ID from the `ma_device_info` structure, which can be retrieved using device enumeration.
+
+    playback.format
+        The sample format to use for playback. When set to `ma_format_unknown` the device's native format will be used. This can be retrieved after
+        initialization from the device object directly with `device.playback.format`.
+
+    playback.channels
+        The number of channels to use for playback. When set to 0 the device's native channel count will be used. This can be retrieved after initialization
+        from the device object directly with `device.playback.channels`.
+
+    playback.pChannelMap
+        The channel map to use for playback. When left empty, the device's native channel map will be used. This can be retrieved after initialization from the
+        device object direct with `device.playback.pChannelMap`. When set, the buffer should contain `channels` items.
+
+    playback.shareMode
+        The preferred share mode to use for playback. Can be either `ma_share_mode_shared` (default) or `ma_share_mode_exclusive`. Note that if you specify
+        exclusive mode, but it's not supported by the backend, initialization will fail. You can then fall back to shared mode if desired by changing this to
+        ma_share_mode_shared and reinitializing.
+
+    capture.pDeviceID
+        A pointer to a `ma_device_id` structure containing the ID of the capture device to initialize. Setting this NULL (default) will use the system's
+        default capture device. Retrieve the device ID from the `ma_device_info` structure, which can be retrieved using device enumeration.
+
+    capture.format
+        The sample format to use for capture. When set to `ma_format_unknown` the device's native format will be used. This can be retrieved after
+        initialization from the device object directly with `device.capture.format`.
+
+    capture.channels
+        The number of channels to use for capture. When set to 0 the device's native channel count will be used. This can be retrieved after initialization
+        from the device object directly with `device.capture.channels`.
+
+    capture.pChannelMap
+        The channel map to use for capture. When left empty, the device's native channel map will be used. This can be retrieved after initialization from the
+        device object direct with `device.capture.pChannelMap`. When set, the buffer should contain `channels` items.
+
+    capture.shareMode
+        The preferred share mode to use for capture. Can be either `ma_share_mode_shared` (default) or `ma_share_mode_exclusive`. Note that if you specify
+        exclusive mode, but it's not supported by the backend, initialization will fail. You can then fall back to shared mode if desired by changing this to
+        ma_share_mode_shared and reinitializing.
+
+    wasapi.noAutoConvertSRC
+        WASAPI only. When set to true, disables WASAPI's automatic resampling and forces the use of miniaudio's resampler. Defaults to false.
+
+    wasapi.noDefaultQualitySRC
+        WASAPI only. Only used when `wasapi.noAutoConvertSRC` is set to false. When set to true, disables the use of `AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY`.
+        You should usually leave this set to false, which is the default.
+
+    wasapi.noAutoStreamRouting
+        WASAPI only. When set to true, disables automatic stream routing on the WASAPI backend. Defaults to false.
+
+    wasapi.noHardwareOffloading
+        WASAPI only. When set to true, disables the use of WASAPI's hardware offloading feature. Defaults to false.
+
+    alsa.noMMap
+        ALSA only. When set to true, disables MMap mode. Defaults to false.
+
+    alsa.noAutoFormat
+        ALSA only. When set to true, disables ALSA's automatic format conversion by including the SND_PCM_NO_AUTO_FORMAT flag. Defaults to false.
+
+    alsa.noAutoChannels
+        ALSA only. When set to true, disables ALSA's automatic channel conversion by including the SND_PCM_NO_AUTO_CHANNELS flag. Defaults to false.
+
+    alsa.noAutoResample
+        ALSA only. When set to true, disables ALSA's automatic resampling by including the SND_PCM_NO_AUTO_RESAMPLE flag. Defaults to false.
+
+    pulse.pStreamNamePlayback
+        PulseAudio only. Sets the stream name for playback.
+
+    pulse.pStreamNameCapture
+        PulseAudio only. Sets the stream name for capture.
+
+    pulse.channelMap
+        PulseAudio only. Sets the channel map that is requested from PulseAudio. See MA_PA_CHANNEL_MAP_* constants. Defaults to MA_PA_CHANNEL_MAP_AIFF.
+
+    coreaudio.allowNominalSampleRateChange
+        Core Audio only. Desktop only. When enabled, allows the sample rate of the device to be changed at the operating system level. This
+        is disabled by default in order to prevent intrusive changes to the user's system. This is useful if you want to use a sample rate
+        that is known to be natively supported by the hardware thereby avoiding the cost of resampling. When set to true, miniaudio will
+        find the closest match between the sample rate requested in the device config and the sample rates natively supported by the
+        hardware. When set to false, the sample rate currently set by the operating system will always be used.
+
+    opensl.streamType
+        OpenSL only. Explicitly sets the stream type. If left unset (`ma_opensl_stream_type_default`), the
+        stream type will be left unset. Think of this as the type of audio you're playing.
+
+    opensl.recordingPreset
+        OpenSL only. Explicitly sets the type of recording your program will be doing. When left
+        unset, the recording preset will be left unchanged.
+
+    aaudio.usage
+        AAudio only. Explicitly sets the nature of the audio the program will be consuming. When
+        left unset, the usage will be left unchanged.
+
+    aaudio.contentType
+        AAudio only. Sets the content type. When left unset, the content type will be left unchanged.
+
+    aaudio.inputPreset
+        AAudio only. Explicitly sets the type of recording your program will be doing. When left
+        unset, the input preset will be left unchanged.
+
+    aaudio.noAutoStartAfterReroute
+        AAudio only. Controls whether or not the device should be automatically restarted after a
+        stream reroute. When set to false (default) the device will be restarted automatically;
+        otherwise the device will be stopped.
+
+
+Once initialized, the device's config is immutable. If you need to change the config you will need to initialize a new device.
+
+After initializing the device it will be in a stopped state. To start it, use `ma_device_start()`.
+
+If both `periodSizeInFrames` and `periodSizeInMilliseconds` are set to zero, it will default to `MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY` or
+`MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE`, depending on whether or not `performanceProfile` is set to `ma_performance_profile_low_latency` or
+`ma_performance_profile_conservative`.
+
+If you request exclusive mode and the backend does not support it an error will be returned. For robustness, you may want to first try initializing the device
+in exclusive mode, and then fall back to shared mode if required. Alternatively you can just request shared mode (the default if you leave it unset in the
+config) which is the most reliable option. Some backends do not have a practical way of choosing whether or not the device should be exclusive or not (ALSA,
+for example) in which case it just acts as a hint. Unless you have special requirements you should try avoiding exclusive mode as it's intrusive to the user.
+Starting with Windows 10, miniaudio will use low-latency shared mode where possible which may make exclusive mode unnecessary.
+
+When sending or receiving data to/from a device, miniaudio will internally perform a format conversion to convert between the format specified by the config
+and the format used internally by the backend. If you pass in 0 for the sample format, channel count, sample rate _and_ channel map, data transmission will run
+on an optimized pass-through fast path. You can retrieve the format, channel count and sample rate by inspecting the `playback/capture.format`,
+`playback/capture.channels` and `sampleRate` members of the device object.
+
+When compiling for UWP you must ensure you call this function on the main UI thread because the operating system may need to present the user with a message
+asking for permissions. Please refer to the official documentation for ActivateAudioInterfaceAsync() for more information.
+
+ALSA Specific: When initializing the default device, requesting shared mode will try using the "dmix" device for playback and the "dsnoop" device for capture.
+If these fail it will try falling back to the "hw" device.
+
+
+Example 1 - Simple Initialization
+---------------------------------
+This example shows how to initialize a simple playback device using a standard configuration. If you are just needing to do simple playback from the default
+playback device this is usually all you need.
+
+```c
+ma_device_config config = ma_device_config_init(ma_device_type_playback);
+config.playback.format   = ma_format_f32;
+config.playback.channels = 2;
+config.sampleRate        = 48000;
+config.dataCallback      = ma_data_callback;
+config.pMyUserData       = pMyUserData;
+
+ma_device device;
+ma_result result = ma_device_init(NULL, &config, &device);
+if (result != MA_SUCCESS) {
+    // Error
+}
+```
+
+
+Example 2 - Advanced Initialization
+-----------------------------------
+This example shows how you might do some more advanced initialization. In this hypothetical example we want to control the latency by setting the buffer size
+and period count. We also want to allow the user to be able to choose which device to output from which means we need a context so we can perform device
+enumeration.
+
+```c
+ma_context context;
+ma_result result = ma_context_init(NULL, 0, NULL, &context);
+if (result != MA_SUCCESS) {
+    // Error
+}
+
+ma_device_info* pPlaybackDeviceInfos;
+ma_uint32 playbackDeviceCount;
+result = ma_context_get_devices(&context, &pPlaybackDeviceInfos, &playbackDeviceCount, NULL, NULL);
+if (result != MA_SUCCESS) {
+    // Error
+}
+
+// ... choose a device from pPlaybackDeviceInfos ...
+
+ma_device_config config = ma_device_config_init(ma_device_type_playback);
+config.playback.pDeviceID       = pMyChosenDeviceID;    // <-- Get this from the `id` member of one of the `ma_device_info` objects returned by ma_context_get_devices().
+config.playback.format          = ma_format_f32;
+config.playback.channels        = 2;
+config.sampleRate               = 48000;
+config.dataCallback             = ma_data_callback;
+config.pUserData                = pMyUserData;
+config.periodSizeInMilliseconds = 10;
+config.periods                  = 3;
+
+ma_device device;
+result = ma_device_init(&context, &config, &device);
+if (result != MA_SUCCESS) {
+    // Error
+}
+```
+
+
+See Also
+--------
+ma_device_config_init()
+ma_device_uninit()
+ma_device_start()
+ma_context_init()
+ma_context_get_devices()
+ma_context_enumerate_devices()
+*/
+MA_API ma_result ma_device_init(ma_context* pContext, const ma_device_config* pConfig, ma_device* pDevice);
+
+/*
+Initializes a device without a context, with extra parameters for controlling the configuration of the internal self-managed context.
+
+This is the same as `ma_device_init()`, only instead of a context being passed in, the parameters from `ma_context_init()` are passed in instead. This function
+allows you to configure the internally created context.
+
+
+Parameters
+----------
+backends (in, optional)
+    A list of backends to try initializing, in priority order. Can be NULL, in which case it uses default priority order.
+
+backendCount (in, optional)
+    The number of items in `backend`. Ignored if `backend` is NULL.
+
+pContextConfig (in, optional)
+    The context configuration.
+
+pConfig (in)
+    A pointer to the device configuration. Cannot be null. See remarks for details.
+
+pDevice (out)
+    A pointer to the device object being initialized.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. It is not safe to call this function simultaneously for different devices because some backends depend on and mutate global state. The same applies to
+calling this at the same time as `ma_device_uninit()`.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback.
+
+
+Remarks
+-------
+You only need to use this function if you want to configure the context differently to its defaults. You should never use this function if you want to manage
+your own context.
+
+See the documentation for `ma_context_init()` for information on the different context configuration options.
+
+
+See Also
+--------
+ma_device_init()
+ma_device_uninit()
+ma_device_config_init()
+ma_context_init()
+*/
+MA_API ma_result ma_device_init_ex(const ma_backend backends[], ma_uint32 backendCount, const ma_context_config* pContextConfig, const ma_device_config* pConfig, ma_device* pDevice);
+
+/*
+Uninitializes a device.
+
+This will explicitly stop the device. You do not need to call `ma_device_stop()` beforehand, but it's harmless if you do.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device to stop.
+
+
+Return Value
+------------
+Nothing
+
+
+Thread Safety
+-------------
+Unsafe. As soon as this API is called the device should be considered undefined.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback. Doing this will result in a deadlock.
+
+
+See Also
+--------
+ma_device_init()
+ma_device_stop()
+*/
+MA_API void ma_device_uninit(ma_device* pDevice);
+
+
+/*
+Retrieves a pointer to the context that owns the given device.
+*/
+MA_API ma_context* ma_device_get_context(ma_device* pDevice);
+
+/*
+Helper function for retrieving the log object associated with the context that owns this device.
+*/
+MA_API ma_log* ma_device_get_log(ma_device* pDevice);
+
+
+/*
+Retrieves information about the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose information is being retrieved.
+
+type (in)
+    The device type. This parameter is required for duplex devices. When retrieving device
+    information, you are doing so for an individual playback or capture device.
+
+pDeviceInfo (out)
+    A pointer to the `ma_device_info` that will receive the device information.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. This should be considered unsafe because it may be calling into the backend which may or
+may not be safe.
+
+
+Callback Safety
+---------------
+Unsafe. You should avoid calling this in the data callback because it may call into the backend
+which may or may not be safe.
+*/
+MA_API ma_result ma_device_get_info(ma_device* pDevice, ma_device_type type, ma_device_info* pDeviceInfo);
+
+
+/*
+Retrieves the name of the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose information is being retrieved.
+
+type (in)
+    The device type. This parameter is required for duplex devices. When retrieving device
+    information, you are doing so for an individual playback or capture device.
+
+pName (out)
+    A pointer to the buffer that will receive the name.
+
+nameCap (in)
+    The capacity of the output buffer, including space for the null terminator.
+
+pLengthNotIncludingNullTerminator (out, optional)
+    A pointer to the variable that will receive the length of the name, not including the null
+    terminator.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. This should be considered unsafe because it may be calling into the backend which may or
+may not be safe.
+
+
+Callback Safety
+---------------
+Unsafe. You should avoid calling this in the data callback because it may call into the backend
+which may or may not be safe.
+
+
+Remarks
+-------
+If the name does not fully fit into the output buffer, it'll be truncated. You can pass in NULL to
+`pName` if you want to first get the length of the name for the purpose of memory allocation of the
+output buffer. Allocating a buffer of size `MA_MAX_DEVICE_NAME_LENGTH + 1` should be enough for
+most cases and will avoid the need for the inefficiency of calling this function twice.
+
+This is implemented in terms of `ma_device_get_info()`.
+*/
+MA_API ma_result ma_device_get_name(ma_device* pDevice, ma_device_type type, char* pName, size_t nameCap, size_t* pLengthNotIncludingNullTerminator);
+
+
+/*
+Starts the device. For playback devices this begins playback. For capture devices it begins recording.
+
+Use `ma_device_stop()` to stop the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device to start.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Safe. It's safe to call this from any thread with the exception of the callback thread.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback.
+
+
+Remarks
+-------
+For a playback device, this will retrieve an initial chunk of audio data from the client before returning. The reason for this is to ensure there is valid
+audio data in the buffer, which needs to be done before the device begins playback.
+
+This API waits until the backend device has been started for real by the worker thread. It also waits on a mutex for thread-safety.
+
+Do not call this in any callback.
+
+
+See Also
+--------
+ma_device_stop()
+*/
+MA_API ma_result ma_device_start(ma_device* pDevice);
+
+/*
+Stops the device. For playback devices this stops playback. For capture devices it stops recording.
+
+Use `ma_device_start()` to start the device again.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device to stop.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Safe. It's safe to call this from any thread with the exception of the callback thread.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback. Doing this will result in a deadlock.
+
+
+Remarks
+-------
+This API needs to wait on the worker thread to stop the backend device properly before returning. It also waits on a mutex for thread-safety. In addition, some
+backends need to wait for the device to finish playback/recording of the current fragment which can take some time (usually proportionate to the buffer size
+that was specified at initialization time).
+
+Backends are required to either pause the stream in-place or drain the buffer if pausing is not possible. The reason for this is that stopping the device and
+the resuming it with ma_device_start() (which you might do when your program loses focus) may result in a situation where those samples are never output to the
+speakers or received from the microphone which can in turn result in de-syncs.
+
+Do not call this in any callback.
+
+
+See Also
+--------
+ma_device_start()
+*/
+MA_API ma_result ma_device_stop(ma_device* pDevice);
+
+/*
+Determines whether or not the device is started.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose start state is being retrieved.
+
+
+Return Value
+------------
+True if the device is started, false otherwise.
+
+
+Thread Safety
+-------------
+Safe. If another thread calls `ma_device_start()` or `ma_device_stop()` at this same time as this function is called, there's a very small chance the return
+value will be out of sync.
+
+
+Callback Safety
+---------------
+Safe. This is implemented as a simple accessor.
+
+
+See Also
+--------
+ma_device_start()
+ma_device_stop()
+*/
+MA_API ma_bool32 ma_device_is_started(const ma_device* pDevice);
+
+
+/*
+Retrieves the state of the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose state is being retrieved.
+
+
+Return Value
+------------
+The current state of the device. The return value will be one of the following:
+
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_uninitialized | Will only be returned if the device is in the middle of initialization.      |
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_stopped       | The device is stopped. The initial state of the device after initialization. |
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_started       | The device started and requesting and/or delivering audio data.              |
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_starting      | The device is in the process of starting.                                    |
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_stopping      | The device is in the process of stopping.                                    |
+    +-------------------------------+------------------------------------------------------------------------------+
+
+
+Thread Safety
+-------------
+Safe. This is implemented as a simple accessor. Note that if the device is started or stopped at the same time as this function is called,
+there's a possibility the return value could be out of sync. See remarks.
+
+
+Callback Safety
+---------------
+Safe. This is implemented as a simple accessor.
+
+
+Remarks
+-------
+The general flow of a devices state goes like this:
+
+    ```
+    ma_device_init()  -> ma_device_state_uninitialized -> ma_device_state_stopped
+    ma_device_start() -> ma_device_state_starting      -> ma_device_state_started
+    ma_device_stop()  -> ma_device_state_stopping      -> ma_device_state_stopped
+    ```
+
+When the state of the device is changed with `ma_device_start()` or `ma_device_stop()` at this same time as this function is called, the
+value returned by this function could potentially be out of sync. If this is significant to your program you need to implement your own
+synchronization.
+*/
+MA_API ma_device_state ma_device_get_state(const ma_device* pDevice);
+
+
+/*
+Performs post backend initialization routines for setting up internal data conversion.
+
+This should be called whenever the backend is initialized. The only time this should be called from
+outside of miniaudio is if you're implementing a custom backend, and you would only do it if you
+are reinitializing the backend due to rerouting or reinitializing for some reason.
+
+
+Parameters
+----------
+pDevice [in]
+    A pointer to the device.
+
+deviceType [in]
+    The type of the device that was just reinitialized.
+
+pPlaybackDescriptor [in]
+    The descriptor of the playback device containing the internal data format and buffer sizes.
+
+pPlaybackDescriptor [in]
+    The descriptor of the capture device containing the internal data format and buffer sizes.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. This will be reinitializing internal data converters which may be in use by another thread.
+
+
+Callback Safety
+---------------
+Unsafe. This will be reinitializing internal data converters which may be in use by the callback.
+
+
+Remarks
+-------
+For a duplex device, you can call this for only one side of the system. This is why the deviceType
+is specified as a parameter rather than deriving it from the device.
+
+You do not need to call this manually unless you are doing a custom backend, in which case you need
+only do it if you're manually performing rerouting or reinitialization.
+*/
+MA_API ma_result ma_device_post_init(ma_device* pDevice, ma_device_type deviceType, const ma_device_descriptor* pPlaybackDescriptor, const ma_device_descriptor* pCaptureDescriptor);
+
+
+/*
+Sets the master volume factor for the device.
+
+The volume factor must be between 0 (silence) and 1 (full volume). Use `ma_device_set_master_volume_db()` to use decibel notation, where 0 is full volume and
+values less than 0 decreases the volume.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose volume is being set.
+
+volume (in)
+    The new volume factor. Must be >= 0.
+
+
+Return Value
+------------
+MA_SUCCESS if the volume was set successfully.
+MA_INVALID_ARGS if pDevice is NULL.
+MA_INVALID_ARGS if volume is negative.
+
+
+Thread Safety
+-------------
+Safe. This just sets a local member of the device object.
+
+
+Callback Safety
+---------------
+Safe. If you set the volume in the data callback, that data written to the output buffer will have the new volume applied.
+
+
+Remarks
+-------
+This applies the volume factor across all channels.
+
+This does not change the operating system's volume. It only affects the volume for the given `ma_device` object's audio stream.
+
+
+See Also
+--------
+ma_device_get_master_volume()
+ma_device_set_master_volume_db()
+ma_device_get_master_volume_db()
+*/
+MA_API ma_result ma_device_set_master_volume(ma_device* pDevice, float volume);
+
+/*
+Retrieves the master volume factor for the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose volume factor is being retrieved.
+
+pVolume (in)
+    A pointer to the variable that will receive the volume factor. The returned value will be in the range of [0, 1].
+
+
+Return Value
+------------
+MA_SUCCESS if successful.
+MA_INVALID_ARGS if pDevice is NULL.
+MA_INVALID_ARGS if pVolume is NULL.
+
+
+Thread Safety
+-------------
+Safe. This just a simple member retrieval.
+
+
+Callback Safety
+---------------
+Safe.
+
+
+Remarks
+-------
+If an error occurs, `*pVolume` will be set to 0.
+
+
+See Also
+--------
+ma_device_set_master_volume()
+ma_device_set_master_volume_gain_db()
+ma_device_get_master_volume_gain_db()
+*/
+MA_API ma_result ma_device_get_master_volume(ma_device* pDevice, float* pVolume);
+
+/*
+Sets the master volume for the device as gain in decibels.
+
+A gain of 0 is full volume, whereas a gain of < 0 will decrease the volume.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose gain is being set.
+
+gainDB (in)
+    The new volume as gain in decibels. Must be less than or equal to 0, where 0 is full volume and anything less than 0 decreases the volume.
+
+
+Return Value
+------------
+MA_SUCCESS if the volume was set successfully.
+MA_INVALID_ARGS if pDevice is NULL.
+MA_INVALID_ARGS if the gain is > 0.
+
+
+Thread Safety
+-------------
+Safe. This just sets a local member of the device object.
+
+
+Callback Safety
+---------------
+Safe. If you set the volume in the data callback, that data written to the output buffer will have the new volume applied.
+
+
+Remarks
+-------
+This applies the gain across all channels.
+
+This does not change the operating system's volume. It only affects the volume for the given `ma_device` object's audio stream.
+
+
+See Also
+--------
+ma_device_get_master_volume_gain_db()
+ma_device_set_master_volume()
+ma_device_get_master_volume()
+*/
+MA_API ma_result ma_device_set_master_volume_db(ma_device* pDevice, float gainDB);
+
+/*
+Retrieves the master gain in decibels.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose gain is being retrieved.
+
+pGainDB (in)
+    A pointer to the variable that will receive the gain in decibels. The returned value will be <= 0.
+
+
+Return Value
+------------
+MA_SUCCESS if successful.
+MA_INVALID_ARGS if pDevice is NULL.
+MA_INVALID_ARGS if pGainDB is NULL.
+
+
+Thread Safety
+-------------
+Safe. This just a simple member retrieval.
+
+
+Callback Safety
+---------------
+Safe.
+
+
+Remarks
+-------
+If an error occurs, `*pGainDB` will be set to 0.
+
+
+See Also
+--------
+ma_device_set_master_volume_db()
+ma_device_set_master_volume()
+ma_device_get_master_volume()
+*/
+MA_API ma_result ma_device_get_master_volume_db(ma_device* pDevice, float* pGainDB);
+
+
+/*
+Called from the data callback of asynchronous backends to allow miniaudio to process the data and fire the miniaudio data callback.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to device whose processing the data callback.
+
+pOutput (out)
+    A pointer to the buffer that will receive the output PCM frame data. On a playback device this must not be NULL. On a duplex device
+    this can be NULL, in which case pInput must not be NULL.
+
+pInput (in)
+    A pointer to the buffer containing input PCM frame data. On a capture device this must not be NULL. On a duplex device this can be
+    NULL, in which case `pOutput` must not be NULL.
+
+frameCount (in)
+    The number of frames being processed.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other result code otherwise.
+
+
+Thread Safety
+-------------
+This function should only ever be called from the internal data callback of the backend. It is safe to call this simultaneously between a
+playback and capture device in duplex setups.
+
+
+Callback Safety
+---------------
+Do not call this from the miniaudio data callback. It should only ever be called from the internal data callback of the backend.
+
+
+Remarks
+-------
+If both `pOutput` and `pInput` are NULL, and error will be returned. In duplex scenarios, both `pOutput` and `pInput` can be non-NULL, in
+which case `pInput` will be processed first, followed by `pOutput`.
+
+If you are implementing a custom backend, and that backend uses a callback for data delivery, you'll need to call this from inside that
+callback.
+*/
+MA_API ma_result ma_device_handle_backend_data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount);
+
+
+/*
+Calculates an appropriate buffer size from a descriptor, native sample rate and performance profile.
+
+This function is used by backends for helping determine an appropriately sized buffer to use with
+the device depending on the values of `periodSizeInFrames` and `periodSizeInMilliseconds` in the
+`pDescriptor` object. Since buffer size calculations based on time depends on the sample rate, a
+best guess at the device's native sample rate is also required which is where `nativeSampleRate`
+comes in. In addition, the performance profile is also needed for cases where both the period size
+in frames and milliseconds are both zero.
+
+
+Parameters
+----------
+pDescriptor (in)
+    A pointer to device descriptor whose `periodSizeInFrames` and `periodSizeInMilliseconds` members
+    will be used for the calculation of the buffer size.
+
+nativeSampleRate (in)
+    The device's native sample rate. This is only ever used when the `periodSizeInFrames` member of
+    `pDescriptor` is zero. In this case, `periodSizeInMilliseconds` will be used instead, in which
+    case a sample rate is required to convert to a size in frames.
+
+performanceProfile (in)
+    When both the `periodSizeInFrames` and `periodSizeInMilliseconds` members of `pDescriptor` are
+    zero, miniaudio will fall back to a buffer size based on the performance profile. The profile
+    to use for this calculation is determine by this parameter.
+
+
+Return Value
+------------
+The calculated buffer size in frames.
+
+
+Thread Safety
+-------------
+This is safe so long as nothing modifies `pDescriptor` at the same time. However, this function
+should only ever be called from within the backend's device initialization routine and therefore
+shouldn't have any multithreading concerns.
+
+
+Callback Safety
+---------------
+This is safe to call within the data callback, but there is no reason to ever do this.
+
+
+Remarks
+-------
+If `nativeSampleRate` is zero, this function will fall back to `pDescriptor->sampleRate`. If that
+is also zero, `MA_DEFAULT_SAMPLE_RATE` will be used instead.
+*/
+MA_API ma_uint32 ma_calculate_buffer_size_in_frames_from_descriptor(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile);
+
+
+
+/*
+Retrieves a friendly name for a backend.
+*/
+MA_API const char* ma_get_backend_name(ma_backend backend);
+
+/*
+Retrieves the backend enum from the given name.
+*/
+MA_API ma_result ma_get_backend_from_name(const char* pBackendName, ma_backend* pBackend);
+
+/*
+Determines whether or not the given backend is available by the compilation environment.
+*/
+MA_API ma_bool32 ma_is_backend_enabled(ma_backend backend);
+
+/*
+Retrieves compile-time enabled backends.
+
+
+Parameters
+----------
+pBackends (out, optional)
+    A pointer to the buffer that will receive the enabled backends. Set to NULL to retrieve the backend count. Setting
+    the capacity of the buffer to `MA_BUFFER_COUNT` will guarantee it's large enough for all backends.
+
+backendCap (in)
+    The capacity of the `pBackends` buffer.
+
+pBackendCount (out)
+    A pointer to the variable that will receive the enabled backend count.
+
+
+Return Value
+------------
+MA_SUCCESS if successful.
+MA_INVALID_ARGS if `pBackendCount` is NULL.
+MA_NO_SPACE if the capacity of `pBackends` is not large enough.
+
+If `MA_NO_SPACE` is returned, the `pBackends` buffer will be filled with `*pBackendCount` values.
+
+
+Thread Safety
+-------------
+Safe.
+
+
+Callback Safety
+---------------
+Safe.
+
+
+Remarks
+-------
+If you want to retrieve the number of backends so you can determine the capacity of `pBackends` buffer, you can call
+this function with `pBackends` set to NULL.
+
+This will also enumerate the null backend. If you don't want to include this you need to check for `ma_backend_null`
+when you enumerate over the returned backends and handle it appropriately. Alternatively, you can disable it at
+compile time with `MA_NO_NULL`.
+
+The returned backends are determined based on compile time settings, not the platform it's currently running on. For
+example, PulseAudio will be returned if it was enabled at compile time, even when the user doesn't actually have
+PulseAudio installed.
+
+
+Example 1
+---------
+The example below retrieves the enabled backend count using a fixed sized buffer allocated on the stack. The buffer is
+given a capacity of `MA_BACKEND_COUNT` which will guarantee it'll be large enough to store all available backends.
+Since `MA_BACKEND_COUNT` is always a relatively small value, this should be suitable for most scenarios.
+
+```
+ma_backend enabledBackends[MA_BACKEND_COUNT];
+size_t enabledBackendCount;
+
+result = ma_get_enabled_backends(enabledBackends, MA_BACKEND_COUNT, &enabledBackendCount);
+if (result != MA_SUCCESS) {
+    // Failed to retrieve enabled backends. Should never happen in this example since all inputs are valid.
+}
+```
+
+
+See Also
+--------
+ma_is_backend_enabled()
+*/
+MA_API ma_result ma_get_enabled_backends(ma_backend* pBackends, size_t backendCap, size_t* pBackendCount);
+
+/*
+Determines whether or not loopback mode is support by a backend.
+*/
+MA_API ma_bool32 ma_is_loopback_supported(ma_backend backend);
+
+#endif  /* MA_NO_DEVICE_IO */
+
+
+
+/************************************************************************************************************************************************************
+
+Utilities
+
+************************************************************************************************************************************************************/
+
+/*
+Calculates a buffer size in milliseconds (rounded up) from the specified number of frames and sample rate.
+*/
+MA_API ma_uint32 ma_calculate_buffer_size_in_milliseconds_from_frames(ma_uint32 bufferSizeInFrames, ma_uint32 sampleRate);
+
+/*
+Calculates a buffer size in frames from the specified number of milliseconds and sample rate.
+*/
+MA_API ma_uint32 ma_calculate_buffer_size_in_frames_from_milliseconds(ma_uint32 bufferSizeInMilliseconds, ma_uint32 sampleRate);
+
+/*
+Copies PCM frames from one buffer to another.
+*/
+MA_API void ma_copy_pcm_frames(void* dst, const void* src, ma_uint64 frameCount, ma_format format, ma_uint32 channels);
+
+/*
+Copies silent frames into the given buffer.
+
+Remarks
+-------
+For all formats except `ma_format_u8`, the output buffer will be filled with 0. For `ma_format_u8` it will be filled with 128. The reason for this is that it
+makes more sense for the purpose of mixing to initialize it to the center point.
+*/
+MA_API void ma_silence_pcm_frames(void* p, ma_uint64 frameCount, ma_format format, ma_uint32 channels);
+
+
+/*
+Offsets a pointer by the specified number of PCM frames.
+*/
+MA_API void* ma_offset_pcm_frames_ptr(void* p, ma_uint64 offsetInFrames, ma_format format, ma_uint32 channels);
+MA_API const void* ma_offset_pcm_frames_const_ptr(const void* p, ma_uint64 offsetInFrames, ma_format format, ma_uint32 channels);
+static MA_INLINE float* ma_offset_pcm_frames_ptr_f32(float* p, ma_uint64 offsetInFrames, ma_uint32 channels) { return (float*)ma_offset_pcm_frames_ptr((void*)p, offsetInFrames, ma_format_f32, channels); }
+static MA_INLINE const float* ma_offset_pcm_frames_const_ptr_f32(const float* p, ma_uint64 offsetInFrames, ma_uint32 channels) { return (const float*)ma_offset_pcm_frames_const_ptr((const void*)p, offsetInFrames, ma_format_f32, channels); }
+
+
+/*
+Clips samples.
+*/
+MA_API void ma_clip_samples_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count);
+MA_API void ma_clip_samples_s16(ma_int16* pDst, const ma_int32* pSrc, ma_uint64 count);
+MA_API void ma_clip_samples_s24(ma_uint8* pDst, const ma_int64* pSrc, ma_uint64 count);
+MA_API void ma_clip_samples_s32(ma_int32* pDst, const ma_int64* pSrc, ma_uint64 count);
+MA_API void ma_clip_samples_f32(float* pDst, const float* pSrc, ma_uint64 count);
+MA_API void ma_clip_pcm_frames(void* pDst, const void* pSrc, ma_uint64 frameCount, ma_format format, ma_uint32 channels);
+
+/*
+Helper for applying a volume factor to samples.
+
+Note that the source and destination buffers can be the same, in which case it'll perform the operation in-place.
+*/
+MA_API void ma_copy_and_apply_volume_factor_u8(ma_uint8* pSamplesOut, const ma_uint8* pSamplesIn, ma_uint64 sampleCount, float factor);
+MA_API void ma_copy_and_apply_volume_factor_s16(ma_int16* pSamplesOut, const ma_int16* pSamplesIn, ma_uint64 sampleCount, float factor);
+MA_API void ma_copy_and_apply_volume_factor_s24(void* pSamplesOut, const void* pSamplesIn, ma_uint64 sampleCount, float factor);
+MA_API void ma_copy_and_apply_volume_factor_s32(ma_int32* pSamplesOut, const ma_int32* pSamplesIn, ma_uint64 sampleCount, float factor);
+MA_API void ma_copy_and_apply_volume_factor_f32(float* pSamplesOut, const float* pSamplesIn, ma_uint64 sampleCount, float factor);
+
+MA_API void ma_apply_volume_factor_u8(ma_uint8* pSamples, ma_uint64 sampleCount, float factor);
+MA_API void ma_apply_volume_factor_s16(ma_int16* pSamples, ma_uint64 sampleCount, float factor);
+MA_API void ma_apply_volume_factor_s24(void* pSamples, ma_uint64 sampleCount, float factor);
+MA_API void ma_apply_volume_factor_s32(ma_int32* pSamples, ma_uint64 sampleCount, float factor);
+MA_API void ma_apply_volume_factor_f32(float* pSamples, ma_uint64 sampleCount, float factor);
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_u8(ma_uint8* pFramesOut, const ma_uint8* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s16(ma_int16* pFramesOut, const ma_int16* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s24(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s32(ma_int32* pFramesOut, const ma_int32* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float factor);
+
+MA_API void ma_apply_volume_factor_pcm_frames_u8(ma_uint8* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames_s16(ma_int16* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames_s24(void* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames_s32(ma_int32* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames_f32(float* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames(void* pFrames, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float factor);
+
+MA_API void ma_copy_and_apply_volume_factor_per_channel_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float* pChannelGains);
+
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s16(ma_int16* pDst, const ma_int32* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s24(ma_uint8* pDst, const ma_int64* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s32(ma_int32* pDst, const ma_int64* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_samples_f32(float* pDst, const float* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_pcm_frames(void* pDst, const void* pSrc, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float volume);
+
+
+/*
+Helper for converting a linear factor to gain in decibels.
+*/
+MA_API float ma_volume_linear_to_db(float factor);
+
+/*
+Helper for converting gain in decibels to a linear factor.
+*/
+MA_API float ma_volume_db_to_linear(float gain);
+
+
+/*
+Mixes the specified number of frames in floating point format with a volume factor.
+
+This will run on an optimized path when the volume is equal to 1.
+*/
+MA_API ma_result ma_mix_pcm_frames_f32(float* pDst, const float* pSrc, ma_uint64 frameCount, ma_uint32 channels, float volume);
+
+
+
+
+/************************************************************************************************************************************************************
+
+VFS
+===
+
+The VFS object (virtual file system) is what's used to customize file access. This is useful in cases where stdio FILE* based APIs may not be entirely
+appropriate for a given situation.
+
+************************************************************************************************************************************************************/
+typedef void      ma_vfs;
+typedef ma_handle ma_vfs_file;
+
+typedef enum
+{
+    MA_OPEN_MODE_READ  = 0x00000001,
+    MA_OPEN_MODE_WRITE = 0x00000002
+} ma_open_mode_flags;
+
+typedef enum
+{
+    ma_seek_origin_start,
+    ma_seek_origin_current,
+    ma_seek_origin_end  /* Not used by decoders. */
+} ma_seek_origin;
+
+typedef struct
+{
+    ma_uint64 sizeInBytes;
+} ma_file_info;
+
+typedef struct
+{
+    ma_result (* onOpen) (ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile);
+    ma_result (* onOpenW)(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile);
+    ma_result (* onClose)(ma_vfs* pVFS, ma_vfs_file file);
+    ma_result (* onRead) (ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead);
+    ma_result (* onWrite)(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten);
+    ma_result (* onSeek) (ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin);
+    ma_result (* onTell) (ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor);
+    ma_result (* onInfo) (ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo);
+} ma_vfs_callbacks;
+
+MA_API ma_result ma_vfs_open(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile);
+MA_API ma_result ma_vfs_open_w(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile);
+MA_API ma_result ma_vfs_close(ma_vfs* pVFS, ma_vfs_file file);
+MA_API ma_result ma_vfs_read(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead);
+MA_API ma_result ma_vfs_write(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten);
+MA_API ma_result ma_vfs_seek(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin);
+MA_API ma_result ma_vfs_tell(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor);
+MA_API ma_result ma_vfs_info(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo);
+MA_API ma_result ma_vfs_open_and_read_file(ma_vfs* pVFS, const char* pFilePath, void** ppData, size_t* pSize, const ma_allocation_callbacks* pAllocationCallbacks);
+
+typedef struct
+{
+    ma_vfs_callbacks cb;
+    ma_allocation_callbacks allocationCallbacks;    /* Only used for the wchar_t version of open() on non-Windows platforms. */
+} ma_default_vfs;
+
+MA_API ma_result ma_default_vfs_init(ma_default_vfs* pVFS, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+
+typedef ma_result (* ma_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead);
+typedef ma_result (* ma_seek_proc)(void* pUserData, ma_int64 offset, ma_seek_origin origin);
+typedef ma_result (* ma_tell_proc)(void* pUserData, ma_int64* pCursor);
+
+
+
+#if !defined(MA_NO_DECODING) || !defined(MA_NO_ENCODING)
+typedef enum
+{
+    ma_encoding_format_unknown = 0,
+    ma_encoding_format_wav,
+    ma_encoding_format_flac,
+    ma_encoding_format_mp3,
+    ma_encoding_format_vorbis
+} ma_encoding_format;
+#endif
+
+/************************************************************************************************************************************************************
+
+Decoding
+========
+
+Decoders are independent of the main device API. Decoding APIs can be called freely inside the device's data callback, but they are not thread safe unless
+you do your own synchronization.
+
+************************************************************************************************************************************************************/
+#ifndef MA_NO_DECODING
+typedef struct ma_decoder ma_decoder;
+
+
+typedef struct
+{
+    ma_format preferredFormat;
+    ma_uint32 seekPointCount;   /* Set to > 0 to generate a seektable if the decoding backend supports it. */
+} ma_decoding_backend_config;
+
+MA_API ma_decoding_backend_config ma_decoding_backend_config_init(ma_format preferredFormat, ma_uint32 seekPointCount);
+
+
+typedef struct
+{
+    ma_result (* onInit      )(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend);
+    ma_result (* onInitFile  )(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend);               /* Optional. */
+    ma_result (* onInitFileW )(void* pUserData, const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend);            /* Optional. */
+    ma_result (* onInitMemory)(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend);  /* Optional. */
+    void      (* onUninit    )(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks);
+} ma_decoding_backend_vtable;
+
+
+typedef ma_result (* ma_decoder_read_proc)(ma_decoder* pDecoder, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead);         /* Returns the number of bytes read. */
+typedef ma_result (* ma_decoder_seek_proc)(ma_decoder* pDecoder, ma_int64 byteOffset, ma_seek_origin origin);
+typedef ma_result (* ma_decoder_tell_proc)(ma_decoder* pDecoder, ma_int64* pCursor);
+
+typedef struct
+{
+    ma_format format;      /* Set to 0 or ma_format_unknown to use the stream's internal format. */
+    ma_uint32 channels;    /* Set to 0 to use the stream's internal channels. */
+    ma_uint32 sampleRate;  /* Set to 0 to use the stream's internal sample rate. */
+    ma_channel* pChannelMap;
+    ma_channel_mix_mode channelMixMode;
+    ma_dither_mode ditherMode;
+    ma_resampler_config resampling;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_encoding_format encodingFormat;
+    ma_uint32 seekPointCount;   /* When set to > 0, specifies the number of seek points to use for the generation of a seek table. Not all decoding backends support this. */
+    ma_decoding_backend_vtable** ppCustomBackendVTables;
+    ma_uint32 customBackendCount;
+    void* pCustomBackendUserData;
+} ma_decoder_config;
+
+struct ma_decoder
+{
+    ma_data_source_base ds;
+    ma_data_source* pBackend;                   /* The decoding backend we'll be pulling data from. */
+    const ma_decoding_backend_vtable* pBackendVTable; /* The vtable for the decoding backend. This needs to be stored so we can access the onUninit() callback. */
+    void* pBackendUserData;
+    ma_decoder_read_proc onRead;
+    ma_decoder_seek_proc onSeek;
+    ma_decoder_tell_proc onTell;
+    void* pUserData;
+    ma_uint64 readPointerInPCMFrames;      /* In output sample rate. Used for keeping track of how many frames are available for decoding. */
+    ma_format outputFormat;
+    ma_uint32 outputChannels;
+    ma_uint32 outputSampleRate;
+    ma_data_converter converter;    /* Data conversion is achieved by running frames through this. */
+    void* pInputCache;              /* In input format. Can be null if it's not needed. */
+    ma_uint64 inputCacheCap;        /* The capacity of the input cache. */
+    ma_uint64 inputCacheConsumed;   /* The number of frames that have been consumed in the cache. Used for determining the next valid frame. */
+    ma_uint64 inputCacheRemaining;  /* The number of valid frames remaining in the cache. */
+    ma_allocation_callbacks allocationCallbacks;
+    union
+    {
+        struct
+        {
+            ma_vfs* pVFS;
+            ma_vfs_file file;
+        } vfs;
+        struct
+        {
+            const ma_uint8* pData;
+            size_t dataSize;
+            size_t currentReadPos;
+        } memory;               /* Only used for decoders that were opened against a block of memory. */
+    } data;
+};
+
+MA_API ma_decoder_config ma_decoder_config_init(ma_format outputFormat, ma_uint32 outputChannels, ma_uint32 outputSampleRate);
+MA_API ma_decoder_config ma_decoder_config_init_default(void);
+
+MA_API ma_result ma_decoder_init(ma_decoder_read_proc onRead, ma_decoder_seek_proc onSeek, void* pUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_memory(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_file(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_file_w(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+
+/*
+Uninitializes a decoder.
+*/
+MA_API ma_result ma_decoder_uninit(ma_decoder* pDecoder);
+
+/*
+Reads PCM frames from the given decoder.
+
+This is not thread safe without your own synchronization.
+*/
+MA_API ma_result ma_decoder_read_pcm_frames(ma_decoder* pDecoder, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+
+/*
+Seeks to a PCM frame based on its absolute index.
+
+This is not thread safe without your own synchronization.
+*/
+MA_API ma_result ma_decoder_seek_to_pcm_frame(ma_decoder* pDecoder, ma_uint64 frameIndex);
+
+/*
+Retrieves the decoder's output data format.
+*/
+MA_API ma_result ma_decoder_get_data_format(ma_decoder* pDecoder, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+
+/*
+Retrieves the current position of the read cursor in PCM frames.
+*/
+MA_API ma_result ma_decoder_get_cursor_in_pcm_frames(ma_decoder* pDecoder, ma_uint64* pCursor);
+
+/*
+Retrieves the length of the decoder in PCM frames.
+
+Do not call this on streams of an undefined length, such as internet radio.
+
+If the length is unknown or an error occurs, 0 will be returned.
+
+This will always return 0 for Vorbis decoders. This is due to a limitation with stb_vorbis in push mode which is what miniaudio
+uses internally.
+
+For MP3's, this will decode the entire file. Do not call this in time critical scenarios.
+
+This function is not thread safe without your own synchronization.
+*/
+MA_API ma_result ma_decoder_get_length_in_pcm_frames(ma_decoder* pDecoder, ma_uint64* pLength);
+
+/*
+Retrieves the number of frames that can be read before reaching the end.
+
+This calls `ma_decoder_get_length_in_pcm_frames()` so you need to be aware of the rules for that function, in
+particular ensuring you do not call it on streams of an undefined length, such as internet radio.
+
+If the total length of the decoder cannot be retrieved, such as with Vorbis decoders, `MA_NOT_IMPLEMENTED` will be
+returned.
+*/
+MA_API ma_result ma_decoder_get_available_frames(ma_decoder* pDecoder, ma_uint64* pAvailableFrames);
+
+/*
+Helper for opening and decoding a file into a heap allocated block of memory. Free the returned pointer with ma_free(). On input,
+pConfig should be set to what you want. On output it will be set to what you got.
+*/
+MA_API ma_result ma_decode_from_vfs(ma_vfs* pVFS, const char* pFilePath, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut);
+MA_API ma_result ma_decode_file(const char* pFilePath, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut);
+MA_API ma_result ma_decode_memory(const void* pData, size_t dataSize, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut);
+
+#endif  /* MA_NO_DECODING */
+
+
+/************************************************************************************************************************************************************
+
+Encoding
+========
+
+Encoders do not perform any format conversion for you. If your target format does not support the format, and error will be returned.
+
+************************************************************************************************************************************************************/
+#ifndef MA_NO_ENCODING
+typedef struct ma_encoder ma_encoder;
+
+typedef ma_result (* ma_encoder_write_proc)           (ma_encoder* pEncoder, const void* pBufferIn, size_t bytesToWrite, size_t* pBytesWritten);
+typedef ma_result (* ma_encoder_seek_proc)            (ma_encoder* pEncoder, ma_int64 offset, ma_seek_origin origin);
+typedef ma_result (* ma_encoder_init_proc)            (ma_encoder* pEncoder);
+typedef void      (* ma_encoder_uninit_proc)          (ma_encoder* pEncoder);
+typedef ma_result (* ma_encoder_write_pcm_frames_proc)(ma_encoder* pEncoder, const void* pFramesIn, ma_uint64 frameCount, ma_uint64* pFramesWritten);
+
+typedef struct
+{
+    ma_encoding_format encodingFormat;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_allocation_callbacks allocationCallbacks;
+} ma_encoder_config;
+
+MA_API ma_encoder_config ma_encoder_config_init(ma_encoding_format encodingFormat, ma_format format, ma_uint32 channels, ma_uint32 sampleRate);
+
+struct ma_encoder
+{
+    ma_encoder_config config;
+    ma_encoder_write_proc onWrite;
+    ma_encoder_seek_proc onSeek;
+    ma_encoder_init_proc onInit;
+    ma_encoder_uninit_proc onUninit;
+    ma_encoder_write_pcm_frames_proc onWritePCMFrames;
+    void* pUserData;
+    void* pInternalEncoder;
+    union
+    {
+        struct
+        {
+            ma_vfs* pVFS;
+            ma_vfs_file file;
+        } vfs;
+    } data;
+};
+
+MA_API ma_result ma_encoder_init(ma_encoder_write_proc onWrite, ma_encoder_seek_proc onSeek, void* pUserData, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_init_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_init_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_init_file(const char* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_init_file_w(const wchar_t* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API void ma_encoder_uninit(ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_write_pcm_frames(ma_encoder* pEncoder, const void* pFramesIn, ma_uint64 frameCount, ma_uint64* pFramesWritten);
+
+#endif /* MA_NO_ENCODING */
+
+
+/************************************************************************************************************************************************************
+
+Generation
+
+************************************************************************************************************************************************************/
+#ifndef MA_NO_GENERATION
+typedef enum
+{
+    ma_waveform_type_sine,
+    ma_waveform_type_square,
+    ma_waveform_type_triangle,
+    ma_waveform_type_sawtooth
+} ma_waveform_type;
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_waveform_type type;
+    double amplitude;
+    double frequency;
+} ma_waveform_config;
+
+MA_API ma_waveform_config ma_waveform_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_waveform_type type, double amplitude, double frequency);
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_waveform_config config;
+    double advance;
+    double time;
+} ma_waveform;
+
+MA_API ma_result ma_waveform_init(const ma_waveform_config* pConfig, ma_waveform* pWaveform);
+MA_API void ma_waveform_uninit(ma_waveform* pWaveform);
+MA_API ma_result ma_waveform_read_pcm_frames(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_waveform_seek_to_pcm_frame(ma_waveform* pWaveform, ma_uint64 frameIndex);
+MA_API ma_result ma_waveform_set_amplitude(ma_waveform* pWaveform, double amplitude);
+MA_API ma_result ma_waveform_set_frequency(ma_waveform* pWaveform, double frequency);
+MA_API ma_result ma_waveform_set_type(ma_waveform* pWaveform, ma_waveform_type type);
+MA_API ma_result ma_waveform_set_sample_rate(ma_waveform* pWaveform, ma_uint32 sampleRate);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double dutyCycle;
+    double amplitude;
+    double frequency;
+} ma_pulsewave_config;
+
+MA_API ma_pulsewave_config ma_pulsewave_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double dutyCycle, double amplitude, double frequency);
+
+typedef struct
+{
+    ma_waveform waveform;
+    ma_pulsewave_config config;
+} ma_pulsewave;
+
+MA_API ma_result ma_pulsewave_init(const ma_pulsewave_config* pConfig, ma_pulsewave* pWaveform);
+MA_API void ma_pulsewave_uninit(ma_pulsewave* pWaveform);
+MA_API ma_result ma_pulsewave_read_pcm_frames(ma_pulsewave* pWaveform, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_pulsewave_seek_to_pcm_frame(ma_pulsewave* pWaveform, ma_uint64 frameIndex);
+MA_API ma_result ma_pulsewave_set_amplitude(ma_pulsewave* pWaveform, double amplitude);
+MA_API ma_result ma_pulsewave_set_frequency(ma_pulsewave* pWaveform, double frequency);
+MA_API ma_result ma_pulsewave_set_sample_rate(ma_pulsewave* pWaveform, ma_uint32 sampleRate);
+MA_API ma_result ma_pulsewave_set_duty_cycle(ma_pulsewave* pWaveform, double dutyCycle);
+
+typedef enum
+{
+    ma_noise_type_white,
+    ma_noise_type_pink,
+    ma_noise_type_brownian
+} ma_noise_type;
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_noise_type type;
+    ma_int32 seed;
+    double amplitude;
+    ma_bool32 duplicateChannels;
+} ma_noise_config;
+
+MA_API ma_noise_config ma_noise_config_init(ma_format format, ma_uint32 channels, ma_noise_type type, ma_int32 seed, double amplitude);
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_noise_config config;
+    ma_lcg lcg;
+    union
+    {
+        struct
+        {
+            double** bin;
+            double* accumulation;
+            ma_uint32* counter;
+        } pink;
+        struct
+        {
+            double* accumulation;
+        } brownian;
+    } state;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_noise;
+
+MA_API ma_result ma_noise_get_heap_size(const ma_noise_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_noise_init_preallocated(const ma_noise_config* pConfig, void* pHeap, ma_noise* pNoise);
+MA_API ma_result ma_noise_init(const ma_noise_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_noise* pNoise);
+MA_API void ma_noise_uninit(ma_noise* pNoise, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_noise_read_pcm_frames(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_noise_set_amplitude(ma_noise* pNoise, double amplitude);
+MA_API ma_result ma_noise_set_seed(ma_noise* pNoise, ma_int32 seed);
+MA_API ma_result ma_noise_set_type(ma_noise* pNoise, ma_noise_type type);
+
+#endif  /* MA_NO_GENERATION */
+
+
+
+/************************************************************************************************************************************************************
+
+Resource Manager
+
+************************************************************************************************************************************************************/
+/* The resource manager cannot be enabled if there is no decoder. */
+#if !defined(MA_NO_RESOURCE_MANAGER) && defined(MA_NO_DECODING)
+#define MA_NO_RESOURCE_MANAGER
+#endif
+
+#ifndef MA_NO_RESOURCE_MANAGER
+typedef struct ma_resource_manager                  ma_resource_manager;
+typedef struct ma_resource_manager_data_buffer_node ma_resource_manager_data_buffer_node;
+typedef struct ma_resource_manager_data_buffer      ma_resource_manager_data_buffer;
+typedef struct ma_resource_manager_data_stream      ma_resource_manager_data_stream;
+typedef struct ma_resource_manager_data_source      ma_resource_manager_data_source;
+
+typedef enum
+{
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM         = 0x00000001,   /* When set, does not load the entire data source in memory. Disk I/O will happen on job threads. */
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE         = 0x00000002,   /* Decode data before storing in memory. When set, decoding is done at the resource manager level rather than the mixing thread. Results in faster mixing, but higher memory usage. */
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC          = 0x00000004,   /* When set, the resource manager will load the data source asynchronously. */
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT      = 0x00000008,   /* When set, waits for initialization of the underlying data source before returning from ma_resource_manager_data_source_init(). */
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH = 0x00000010,   /* Gives the resource manager a hint that the length of the data source is unknown and calling `ma_data_source_get_length_in_pcm_frames()` should be avoided. */
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING        = 0x00000020    /* When set, configures the data source to loop by default. */
+} ma_resource_manager_data_source_flags;
+
+
+/*
+Pipeline notifications used by the resource manager. Made up of both an async notification and a fence, both of which are optional.
+*/
+typedef struct
+{
+    ma_async_notification* pNotification;
+    ma_fence* pFence;
+} ma_resource_manager_pipeline_stage_notification;
+
+typedef struct
+{
+    ma_resource_manager_pipeline_stage_notification init;    /* Initialization of the decoder. */
+    ma_resource_manager_pipeline_stage_notification done;    /* Decoding fully completed. */
+} ma_resource_manager_pipeline_notifications;
+
+MA_API ma_resource_manager_pipeline_notifications ma_resource_manager_pipeline_notifications_init(void);
+
+
+
+/* BEGIN BACKWARDS COMPATIBILITY */
+/* TODO: Remove this block in version 0.12. */
+#if 1
+#define ma_resource_manager_job                         ma_job
+#define ma_resource_manager_job_init                    ma_job_init
+#define MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_FLAG_NON_BLOCKING MA_JOB_QUEUE_FLAG_NON_BLOCKING
+#define ma_resource_manager_job_queue_config            ma_job_queue_config
+#define ma_resource_manager_job_queue_config_init       ma_job_queue_config_init
+#define ma_resource_manager_job_queue                   ma_job_queue
+#define ma_resource_manager_job_queue_get_heap_size     ma_job_queue_get_heap_size
+#define ma_resource_manager_job_queue_init_preallocated ma_job_queue_init_preallocated
+#define ma_resource_manager_job_queue_init              ma_job_queue_init
+#define ma_resource_manager_job_queue_uninit            ma_job_queue_uninit
+#define ma_resource_manager_job_queue_post              ma_job_queue_post
+#define ma_resource_manager_job_queue_next              ma_job_queue_next
+#endif
+/* END BACKWARDS COMPATIBILITY */
+
+
+
+
+/* Maximum job thread count will be restricted to this, but this may be removed later and replaced with a heap allocation thereby removing any limitation. */
+#ifndef MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT
+#define MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT    64
+#endif
+
+typedef enum
+{
+    /* Indicates ma_resource_manager_next_job() should not block. Only valid when the job thread count is 0. */
+    MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING = 0x00000001,
+
+    /* Disables any kind of multithreading. Implicitly enables MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING. */
+    MA_RESOURCE_MANAGER_FLAG_NO_THREADING = 0x00000002
+} ma_resource_manager_flags;
+
+typedef struct
+{
+    const char* pFilePath;
+    const wchar_t* pFilePathW;
+    const ma_resource_manager_pipeline_notifications* pNotifications;
+    ma_uint64 initialSeekPointInPCMFrames;
+    ma_uint64 rangeBegInPCMFrames;
+    ma_uint64 rangeEndInPCMFrames;
+    ma_uint64 loopPointBegInPCMFrames;
+    ma_uint64 loopPointEndInPCMFrames;
+    ma_uint32 flags;
+    ma_bool32 isLooping;    /* Deprecated. Use the MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING flag in `flags` instead. */
+} ma_resource_manager_data_source_config;
+
+MA_API ma_resource_manager_data_source_config ma_resource_manager_data_source_config_init(void);
+
+
+typedef enum
+{
+    ma_resource_manager_data_supply_type_unknown = 0,   /* Used for determining whether or the data supply has been initialized. */
+    ma_resource_manager_data_supply_type_encoded,       /* Data supply is an encoded buffer. Connector is ma_decoder. */
+    ma_resource_manager_data_supply_type_decoded,       /* Data supply is a decoded buffer. Connector is ma_audio_buffer. */
+    ma_resource_manager_data_supply_type_decoded_paged  /* Data supply is a linked list of decoded buffers. Connector is ma_paged_audio_buffer. */
+} ma_resource_manager_data_supply_type;
+
+typedef struct
+{
+    MA_ATOMIC(4, ma_resource_manager_data_supply_type) type;    /* Read and written from different threads so needs to be accessed atomically. */
+    union
+    {
+        struct
+        {
+            const void* pData;
+            size_t sizeInBytes;
+        } encoded;
+        struct
+        {
+            const void* pData;
+            ma_uint64 totalFrameCount;
+            ma_uint64 decodedFrameCount;
+            ma_format format;
+            ma_uint32 channels;
+            ma_uint32 sampleRate;
+        } decoded;
+        struct
+        {
+            ma_paged_audio_buffer_data data;
+            ma_uint64 decodedFrameCount;
+            ma_uint32 sampleRate;
+        } decodedPaged;
+    } backend;
+} ma_resource_manager_data_supply;
+
+struct ma_resource_manager_data_buffer_node
+{
+    ma_uint32 hashedName32;                         /* The hashed name. This is the key. */
+    ma_uint32 refCount;
+    MA_ATOMIC(4, ma_result) result;                 /* Result from asynchronous loading. When loading set to MA_BUSY. When fully loaded set to MA_SUCCESS. When deleting set to MA_UNAVAILABLE. */
+    MA_ATOMIC(4, ma_uint32) executionCounter;       /* For allocating execution orders for jobs. */
+    MA_ATOMIC(4, ma_uint32) executionPointer;       /* For managing the order of execution for asynchronous jobs relating to this object. Incremented as jobs complete processing. */
+    ma_bool32 isDataOwnedByResourceManager;         /* Set to true when the underlying data buffer was allocated the resource manager. Set to false if it is owned by the application (via ma_resource_manager_register_*()). */
+    ma_resource_manager_data_supply data;
+    ma_resource_manager_data_buffer_node* pParent;
+    ma_resource_manager_data_buffer_node* pChildLo;
+    ma_resource_manager_data_buffer_node* pChildHi;
+};
+
+struct ma_resource_manager_data_buffer
+{
+    ma_data_source_base ds;                         /* Base data source. A data buffer is a data source. */
+    ma_resource_manager* pResourceManager;          /* A pointer to the resource manager that owns this buffer. */
+    ma_resource_manager_data_buffer_node* pNode;    /* The data node. This is reference counted and is what supplies the data. */
+    ma_uint32 flags;                                /* The flags that were passed used to initialize the buffer. */
+    MA_ATOMIC(4, ma_uint32) executionCounter;       /* For allocating execution orders for jobs. */
+    MA_ATOMIC(4, ma_uint32) executionPointer;       /* For managing the order of execution for asynchronous jobs relating to this object. Incremented as jobs complete processing. */
+    ma_uint64 seekTargetInPCMFrames;                /* Only updated by the public API. Never written nor read from the job thread. */
+    ma_bool32 seekToCursorOnNextRead;               /* On the next read we need to seek to the frame cursor. */
+    MA_ATOMIC(4, ma_result) result;                 /* Keeps track of a result of decoding. Set to MA_BUSY while the buffer is still loading. Set to MA_SUCCESS when loading is finished successfully. Otherwise set to some other code. */
+    MA_ATOMIC(4, ma_bool32) isLooping;              /* Can be read and written by different threads at the same time. Must be used atomically. */
+    ma_atomic_bool32 isConnectorInitialized;        /* Used for asynchronous loading to ensure we don't try to initialize the connector multiple times while waiting for the node to fully load. */
+    union
+    {
+        ma_decoder decoder;                 /* Supply type is ma_resource_manager_data_supply_type_encoded */
+        ma_audio_buffer buffer;             /* Supply type is ma_resource_manager_data_supply_type_decoded */
+        ma_paged_audio_buffer pagedBuffer;  /* Supply type is ma_resource_manager_data_supply_type_decoded_paged */
+    } connector;    /* Connects this object to the node's data supply. */
+};
+
+struct ma_resource_manager_data_stream
+{
+    ma_data_source_base ds;                     /* Base data source. A data stream is a data source. */
+    ma_resource_manager* pResourceManager;      /* A pointer to the resource manager that owns this data stream. */
+    ma_uint32 flags;                            /* The flags that were passed used to initialize the stream. */
+    ma_decoder decoder;                         /* Used for filling pages with data. This is only ever accessed by the job thread. The public API should never touch this. */
+    ma_bool32 isDecoderInitialized;             /* Required for determining whether or not the decoder should be uninitialized in MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM. */
+    ma_uint64 totalLengthInPCMFrames;           /* This is calculated when first loaded by the MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM. */
+    ma_uint32 relativeCursor;                   /* The playback cursor, relative to the current page. Only ever accessed by the public API. Never accessed by the job thread. */
+    MA_ATOMIC(8, ma_uint64) absoluteCursor;     /* The playback cursor, in absolute position starting from the start of the file. */
+    ma_uint32 currentPageIndex;                 /* Toggles between 0 and 1. Index 0 is the first half of pPageData. Index 1 is the second half. Only ever accessed by the public API. Never accessed by the job thread. */
+    MA_ATOMIC(4, ma_uint32) executionCounter;   /* For allocating execution orders for jobs. */
+    MA_ATOMIC(4, ma_uint32) executionPointer;   /* For managing the order of execution for asynchronous jobs relating to this object. Incremented as jobs complete processing. */
+
+    /* Written by the public API, read by the job thread. */
+    MA_ATOMIC(4, ma_bool32) isLooping;          /* Whether or not the stream is looping. It's important to set the looping flag at the data stream level for smooth loop transitions. */
+
+    /* Written by the job thread, read by the public API. */
+    void* pPageData;                            /* Buffer containing the decoded data of each page. Allocated once at initialization time. */
+    MA_ATOMIC(4, ma_uint32) pageFrameCount[2];  /* The number of valid PCM frames in each page. Used to determine the last valid frame. */
+
+    /* Written and read by both the public API and the job thread. These must be atomic. */
+    MA_ATOMIC(4, ma_result) result;             /* Result from asynchronous loading. When loading set to MA_BUSY. When initialized set to MA_SUCCESS. When deleting set to MA_UNAVAILABLE. If an error occurs when loading, set to an error code. */
+    MA_ATOMIC(4, ma_bool32) isDecoderAtEnd;     /* Whether or not the decoder has reached the end. */
+    MA_ATOMIC(4, ma_bool32) isPageValid[2];     /* Booleans to indicate whether or not a page is valid. Set to false by the public API, set to true by the job thread. Set to false as the pages are consumed, true when they are filled. */
+    MA_ATOMIC(4, ma_bool32) seekCounter;        /* When 0, no seeking is being performed. When > 0, a seek is being performed and reading should be delayed with MA_BUSY. */
+};
+
+struct ma_resource_manager_data_source
+{
+    union
+    {
+        ma_resource_manager_data_buffer buffer;
+        ma_resource_manager_data_stream stream;
+    } backend;  /* Must be the first item because we need the first item to be the data source callbacks for the buffer or stream. */
+
+    ma_uint32 flags;                          /* The flags that were passed in to ma_resource_manager_data_source_init(). */
+    MA_ATOMIC(4, ma_uint32) executionCounter;     /* For allocating execution orders for jobs. */
+    MA_ATOMIC(4, ma_uint32) executionPointer;     /* For managing the order of execution for asynchronous jobs relating to this object. Incremented as jobs complete processing. */
+};
+
+typedef struct
+{
+    ma_allocation_callbacks allocationCallbacks;
+    ma_log* pLog;
+    ma_format decodedFormat;        /* The decoded format to use. Set to ma_format_unknown (default) to use the file's native format. */
+    ma_uint32 decodedChannels;      /* The decoded channel count to use. Set to 0 (default) to use the file's native channel count. */
+    ma_uint32 decodedSampleRate;    /* the decoded sample rate to use. Set to 0 (default) to use the file's native sample rate. */
+    ma_uint32 jobThreadCount;       /* Set to 0 if you want to self-manage your job threads. Defaults to 1. */
+    size_t jobThreadStackSize;
+    ma_uint32 jobQueueCapacity;     /* The maximum number of jobs that can fit in the queue at a time. Defaults to MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_CAPACITY. Cannot be zero. */
+    ma_uint32 flags;
+    ma_vfs* pVFS;                   /* Can be NULL in which case defaults will be used. */
+    ma_decoding_backend_vtable** ppCustomDecodingBackendVTables;
+    ma_uint32 customDecodingBackendCount;
+    void* pCustomDecodingBackendUserData;
+} ma_resource_manager_config;
+
+MA_API ma_resource_manager_config ma_resource_manager_config_init(void);
+
+struct ma_resource_manager
+{
+    ma_resource_manager_config config;
+    ma_resource_manager_data_buffer_node* pRootDataBufferNode;      /* The root buffer in the binary tree. */
+#ifndef MA_NO_THREADING
+    ma_mutex dataBufferBSTLock;                                     /* For synchronizing access to the data buffer binary tree. */
+    ma_thread jobThreads[MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT]; /* The threads for executing jobs. */
+#endif
+    ma_job_queue jobQueue;                                          /* Multi-consumer, multi-producer job queue for managing jobs for asynchronous decoding and streaming. */
+    ma_default_vfs defaultVFS;                                      /* Only used if a custom VFS is not specified. */
+    ma_log log;                                                     /* Only used if no log was specified in the config. */
+};
+
+/* Init. */
+MA_API ma_result ma_resource_manager_init(const ma_resource_manager_config* pConfig, ma_resource_manager* pResourceManager);
+MA_API void ma_resource_manager_uninit(ma_resource_manager* pResourceManager);
+MA_API ma_log* ma_resource_manager_get_log(ma_resource_manager* pResourceManager);
+
+/* Registration. */
+MA_API ma_result ma_resource_manager_register_file(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags);
+MA_API ma_result ma_resource_manager_register_file_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags);
+MA_API ma_result ma_resource_manager_register_decoded_data(ma_resource_manager* pResourceManager, const char* pName, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate);  /* Does not copy. Increments the reference count if already exists and returns MA_SUCCESS. */
+MA_API ma_result ma_resource_manager_register_decoded_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate);
+MA_API ma_result ma_resource_manager_register_encoded_data(ma_resource_manager* pResourceManager, const char* pName, const void* pData, size_t sizeInBytes);    /* Does not copy. Increments the reference count if already exists and returns MA_SUCCESS. */
+MA_API ma_result ma_resource_manager_register_encoded_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName, const void* pData, size_t sizeInBytes);
+MA_API ma_result ma_resource_manager_unregister_file(ma_resource_manager* pResourceManager, const char* pFilePath);
+MA_API ma_result ma_resource_manager_unregister_file_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath);
+MA_API ma_result ma_resource_manager_unregister_data(ma_resource_manager* pResourceManager, const char* pName);
+MA_API ma_result ma_resource_manager_unregister_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName);
+
+/* Data Buffers. */
+MA_API ma_result ma_resource_manager_data_buffer_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_init(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_init_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_init_copy(ma_resource_manager* pResourceManager, const ma_resource_manager_data_buffer* pExistingDataBuffer, ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_uninit(ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_read_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_resource_manager_data_buffer_seek_to_pcm_frame(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64 frameIndex);
+MA_API ma_result ma_resource_manager_data_buffer_get_data_format(ma_resource_manager_data_buffer* pDataBuffer, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_resource_manager_data_buffer_get_cursor_in_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pCursor);
+MA_API ma_result ma_resource_manager_data_buffer_get_length_in_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pLength);
+MA_API ma_result ma_resource_manager_data_buffer_result(const ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_set_looping(ma_resource_manager_data_buffer* pDataBuffer, ma_bool32 isLooping);
+MA_API ma_bool32 ma_resource_manager_data_buffer_is_looping(const ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_get_available_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pAvailableFrames);
+
+/* Data Streams. */
+MA_API ma_result ma_resource_manager_data_stream_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_init(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_init_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_uninit(ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_read_pcm_frames(ma_resource_manager_data_stream* pDataStream, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_resource_manager_data_stream_seek_to_pcm_frame(ma_resource_manager_data_stream* pDataStream, ma_uint64 frameIndex);
+MA_API ma_result ma_resource_manager_data_stream_get_data_format(ma_resource_manager_data_stream* pDataStream, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_resource_manager_data_stream_get_cursor_in_pcm_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pCursor);
+MA_API ma_result ma_resource_manager_data_stream_get_length_in_pcm_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pLength);
+MA_API ma_result ma_resource_manager_data_stream_result(const ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_set_looping(ma_resource_manager_data_stream* pDataStream, ma_bool32 isLooping);
+MA_API ma_bool32 ma_resource_manager_data_stream_is_looping(const ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_get_available_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pAvailableFrames);
+
+/* Data Sources. */
+MA_API ma_result ma_resource_manager_data_source_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_init(ma_resource_manager* pResourceManager, const char* pName, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_init_w(ma_resource_manager* pResourceManager, const wchar_t* pName, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_init_copy(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source* pExistingDataSource, ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_uninit(ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_read_pcm_frames(ma_resource_manager_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_resource_manager_data_source_seek_to_pcm_frame(ma_resource_manager_data_source* pDataSource, ma_uint64 frameIndex);
+MA_API ma_result ma_resource_manager_data_source_get_data_format(ma_resource_manager_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_resource_manager_data_source_get_cursor_in_pcm_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pCursor);
+MA_API ma_result ma_resource_manager_data_source_get_length_in_pcm_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pLength);
+MA_API ma_result ma_resource_manager_data_source_result(const ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_set_looping(ma_resource_manager_data_source* pDataSource, ma_bool32 isLooping);
+MA_API ma_bool32 ma_resource_manager_data_source_is_looping(const ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_get_available_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pAvailableFrames);
+
+/* Job management. */
+MA_API ma_result ma_resource_manager_post_job(ma_resource_manager* pResourceManager, const ma_job* pJob);
+MA_API ma_result ma_resource_manager_post_job_quit(ma_resource_manager* pResourceManager);  /* Helper for posting a quit job. */
+MA_API ma_result ma_resource_manager_next_job(ma_resource_manager* pResourceManager, ma_job* pJob);
+MA_API ma_result ma_resource_manager_process_job(ma_resource_manager* pResourceManager, ma_job* pJob);  /* DEPRECATED. Use ma_job_process(). Will be removed in version 0.12. */
+MA_API ma_result ma_resource_manager_process_next_job(ma_resource_manager* pResourceManager);   /* Returns MA_CANCELLED if a MA_JOB_TYPE_QUIT job is found. In non-blocking mode, returns MA_NO_DATA_AVAILABLE if no jobs are available. */
+#endif  /* MA_NO_RESOURCE_MANAGER */
+
+
+
+/************************************************************************************************************************************************************
+
+Node Graph
+
+************************************************************************************************************************************************************/
+#ifndef MA_NO_NODE_GRAPH
+/* Must never exceed 254. */
+#ifndef MA_MAX_NODE_BUS_COUNT
+#define MA_MAX_NODE_BUS_COUNT       254
+#endif
+
+/* Used internally by miniaudio for memory management. Must never exceed MA_MAX_NODE_BUS_COUNT. */
+#ifndef MA_MAX_NODE_LOCAL_BUS_COUNT
+#define MA_MAX_NODE_LOCAL_BUS_COUNT 2
+#endif
+
+/* Use this when the bus count is determined by the node instance rather than the vtable. */
+#define MA_NODE_BUS_COUNT_UNKNOWN   255
+
+
+/* For some internal memory management of ma_node_graph. */
+typedef struct
+{
+    size_t offset;
+    size_t sizeInBytes;
+    unsigned char _data[1];
+} ma_stack;
+
+
+typedef struct ma_node_graph ma_node_graph;
+typedef void ma_node;
+
+
+/* Node flags. */
+typedef enum
+{
+    MA_NODE_FLAG_PASSTHROUGH                = 0x00000001,
+    MA_NODE_FLAG_CONTINUOUS_PROCESSING      = 0x00000002,
+    MA_NODE_FLAG_ALLOW_NULL_INPUT           = 0x00000004,
+    MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES = 0x00000008,
+    MA_NODE_FLAG_SILENT_OUTPUT              = 0x00000010
+} ma_node_flags;
+
+
+/* The playback state of a node. Either started or stopped. */
+typedef enum
+{
+    ma_node_state_started = 0,
+    ma_node_state_stopped = 1
+} ma_node_state;
+
+
+typedef struct
+{
+    /*
+    Extended processing callback. This callback is used for effects that process input and output
+    at different rates (i.e. they perform resampling). This is similar to the simple version, only
+    they take two separate frame counts: one for input, and one for output.
+
+    On input, `pFrameCountOut` is equal to the capacity of the output buffer for each bus, whereas
+    `pFrameCountIn` will be equal to the number of PCM frames in each of the buffers in `ppFramesIn`.
+
+    On output, set `pFrameCountOut` to the number of PCM frames that were actually output and set
+    `pFrameCountIn` to the number of input frames that were consumed.
+    */
+    void (* onProcess)(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut);
+
+    /*
+    A callback for retrieving the number of input frames that are required to output the
+    specified number of output frames. You would only want to implement this when the node performs
+    resampling. This is optional, even for nodes that perform resampling, but it does offer a
+    small reduction in latency as it allows miniaudio to calculate the exact number of input frames
+    to read at a time instead of having to estimate.
+    */
+    ma_result (* onGetRequiredInputFrameCount)(ma_node* pNode, ma_uint32 outputFrameCount, ma_uint32* pInputFrameCount);
+
+    /*
+    The number of input buses. This is how many sub-buffers will be contained in the `ppFramesIn`
+    parameters of the callbacks above.
+    */
+    ma_uint8 inputBusCount;
+
+    /*
+    The number of output buses. This is how many sub-buffers will be contained in the `ppFramesOut`
+    parameters of the callbacks above.
+    */
+    ma_uint8 outputBusCount;
+
+    /*
+    Flags describing characteristics of the node. This is currently just a placeholder for some
+    ideas for later on.
+    */
+    ma_uint32 flags;
+} ma_node_vtable;
+
+typedef struct
+{
+    const ma_node_vtable* vtable;       /* Should never be null. Initialization of the node will fail if so. */
+    ma_node_state initialState;         /* Defaults to ma_node_state_started. */
+    ma_uint32 inputBusCount;            /* Only used if the vtable specifies an input bus count of `MA_NODE_BUS_COUNT_UNKNOWN`, otherwise must be set to `MA_NODE_BUS_COUNT_UNKNOWN` (default). */
+    ma_uint32 outputBusCount;           /* Only used if the vtable specifies an output bus count of `MA_NODE_BUS_COUNT_UNKNOWN`, otherwise  be set to `MA_NODE_BUS_COUNT_UNKNOWN` (default). */
+    const ma_uint32* pInputChannels;    /* The number of elements are determined by the input bus count as determined by the vtable, or `inputBusCount` if the vtable specifies `MA_NODE_BUS_COUNT_UNKNOWN`. */
+    const ma_uint32* pOutputChannels;   /* The number of elements are determined by the output bus count as determined by the vtable, or `outputBusCount` if the vtable specifies `MA_NODE_BUS_COUNT_UNKNOWN`. */
+} ma_node_config;
+
+MA_API ma_node_config ma_node_config_init(void);
+
+
+/*
+A node has multiple output buses. An output bus is attached to an input bus as an item in a linked
+list. Think of the input bus as a linked list, with the output bus being an item in that list.
+*/
+typedef struct ma_node_output_bus ma_node_output_bus;
+struct ma_node_output_bus
+{
+    /* Immutable. */
+    ma_node* pNode;                                         /* The node that owns this output bus. The input node. Will be null for dummy head and tail nodes. */
+    ma_uint8 outputBusIndex;                                /* The index of the output bus on pNode that this output bus represents. */
+    ma_uint8 channels;                                      /* The number of channels in the audio stream for this bus. */
+
+    /* Mutable via multiple threads. Must be used atomically. The weird ordering here is for packing reasons. */
+    ma_uint8 inputNodeInputBusIndex;                        /* The index of the input bus on the input. Required for detaching. Will only be used within the spinlock so does not need to be atomic. */
+    MA_ATOMIC(4, ma_uint32) flags;                          /* Some state flags for tracking the read state of the output buffer. A combination of MA_NODE_OUTPUT_BUS_FLAG_*. */
+    MA_ATOMIC(4, ma_uint32) refCount;                       /* Reference count for some thread-safety when detaching. */
+    MA_ATOMIC(4, ma_bool32) isAttached;                     /* This is used to prevent iteration of nodes that are in the middle of being detached. Used for thread safety. */
+    MA_ATOMIC(4, ma_spinlock) lock;                         /* Unfortunate lock, but significantly simplifies the implementation. Required for thread-safe attaching and detaching. */
+    MA_ATOMIC(4, float) volume;                             /* Linear. */
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_node_output_bus*) pNext;    /* If null, it's the tail node or detached. */
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_node_output_bus*) pPrev;    /* If null, it's the head node or detached. */
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_node*) pInputNode;          /* The node that this output bus is attached to. Required for detaching. */
+};
+
+/*
+A node has multiple input buses. The output buses of a node are connecting to the input busses of
+another. An input bus is essentially just a linked list of output buses.
+*/
+typedef struct ma_node_input_bus ma_node_input_bus;
+struct ma_node_input_bus
+{
+    /* Mutable via multiple threads. */
+    ma_node_output_bus head;                /* Dummy head node for simplifying some lock-free thread-safety stuff. */
+    MA_ATOMIC(4, ma_uint32) nextCounter;    /* This is used to determine whether or not the input bus is finding the next node in the list. Used for thread safety when detaching output buses. */
+    MA_ATOMIC(4, ma_spinlock) lock;         /* Unfortunate lock, but significantly simplifies the implementation. Required for thread-safe attaching and detaching. */
+
+    /* Set once at startup. */
+    ma_uint8 channels;                      /* The number of channels in the audio stream for this bus. */
+};
+
+
+typedef struct ma_node_base ma_node_base;
+struct ma_node_base
+{
+    /* These variables are set once at startup. */
+    ma_node_graph* pNodeGraph;                  /* The graph this node belongs to. */
+    const ma_node_vtable* vtable;
+    ma_uint32 inputBusCount;
+    ma_uint32 outputBusCount;
+    ma_node_input_bus* pInputBuses;
+    ma_node_output_bus* pOutputBuses;
+    float* pCachedData;                         /* Allocated on the heap. Fixed size. Needs to be stored on the heap because reading from output buses is done in separate function calls. */
+    ma_uint16 cachedDataCapInFramesPerBus;      /* The capacity of the input data cache in frames, per bus. */
+
+    /* These variables are read and written only from the audio thread. */
+    ma_uint16 cachedFrameCountOut;
+    ma_uint16 cachedFrameCountIn;
+    ma_uint16 consumedFrameCountIn;
+
+    /* These variables are read and written between different threads. */
+    MA_ATOMIC(4, ma_node_state) state;          /* When set to stopped, nothing will be read, regardless of the times in stateTimes. */
+    MA_ATOMIC(8, ma_uint64) stateTimes[2];      /* Indexed by ma_node_state. Specifies the time based on the global clock that a node should be considered to be in the relevant state. */
+    MA_ATOMIC(8, ma_uint64) localTime;          /* The node's local clock. This is just a running sum of the number of output frames that have been processed. Can be modified by any thread with `ma_node_set_time()`. */
+
+    /* Memory management. */
+    ma_node_input_bus _inputBuses[MA_MAX_NODE_LOCAL_BUS_COUNT];
+    ma_node_output_bus _outputBuses[MA_MAX_NODE_LOCAL_BUS_COUNT];
+    void* _pHeap;   /* A heap allocation for internal use only. pInputBuses and/or pOutputBuses will point to this if the bus count exceeds MA_MAX_NODE_LOCAL_BUS_COUNT. */
+    ma_bool32 _ownsHeap;    /* If set to true, the node owns the heap allocation and _pHeap will be freed in ma_node_uninit(). */
+};
+
+MA_API ma_result ma_node_get_heap_size(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_node_init_preallocated(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, void* pHeap, ma_node* pNode);
+MA_API ma_result ma_node_init(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node* pNode);
+MA_API void ma_node_uninit(ma_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_node_graph* ma_node_get_node_graph(const ma_node* pNode);
+MA_API ma_uint32 ma_node_get_input_bus_count(const ma_node* pNode);
+MA_API ma_uint32 ma_node_get_output_bus_count(const ma_node* pNode);
+MA_API ma_uint32 ma_node_get_input_channels(const ma_node* pNode, ma_uint32 inputBusIndex);
+MA_API ma_uint32 ma_node_get_output_channels(const ma_node* pNode, ma_uint32 outputBusIndex);
+MA_API ma_result ma_node_attach_output_bus(ma_node* pNode, ma_uint32 outputBusIndex, ma_node* pOtherNode, ma_uint32 otherNodeInputBusIndex);
+MA_API ma_result ma_node_detach_output_bus(ma_node* pNode, ma_uint32 outputBusIndex);
+MA_API ma_result ma_node_detach_all_output_buses(ma_node* pNode);
+MA_API ma_result ma_node_set_output_bus_volume(ma_node* pNode, ma_uint32 outputBusIndex, float volume);
+MA_API float ma_node_get_output_bus_volume(const ma_node* pNode, ma_uint32 outputBusIndex);
+MA_API ma_result ma_node_set_state(ma_node* pNode, ma_node_state state);
+MA_API ma_node_state ma_node_get_state(const ma_node* pNode);
+MA_API ma_result ma_node_set_state_time(ma_node* pNode, ma_node_state state, ma_uint64 globalTime);
+MA_API ma_uint64 ma_node_get_state_time(const ma_node* pNode, ma_node_state state);
+MA_API ma_node_state ma_node_get_state_by_time(const ma_node* pNode, ma_uint64 globalTime);
+MA_API ma_node_state ma_node_get_state_by_time_range(const ma_node* pNode, ma_uint64 globalTimeBeg, ma_uint64 globalTimeEnd);
+MA_API ma_uint64 ma_node_get_time(const ma_node* pNode);
+MA_API ma_result ma_node_set_time(ma_node* pNode, ma_uint64 localTime);
+
+
+typedef struct
+{
+    ma_uint32 channels;
+    ma_uint32 processingSizeInFrames;   /* This is the preferred processing size for node processing callbacks unless overridden by a node itself. Can be 0 in which case it will be based on the frame count passed into ma_node_graph_read_pcm_frames(), but will not be well defined. */
+    size_t preMixStackSizeInBytes;      /* Defaults to 512KB per channel. Reducing this will save memory, but the depth of your node graph will be more restricted. */
+} ma_node_graph_config;
+
+MA_API ma_node_graph_config ma_node_graph_config_init(ma_uint32 channels);
+
+
+struct ma_node_graph
+{
+    /* Immutable. */
+    ma_node_base base;                  /* The node graph itself is a node so it can be connected as an input to different node graph. This has zero inputs and calls ma_node_graph_read_pcm_frames() to generate it's output. */
+    ma_node_base endpoint;              /* Special node that all nodes eventually connect to. Data is read from this node in ma_node_graph_read_pcm_frames(). */
+    float* pProcessingCache;            /* This will be allocated when processingSizeInFrames is non-zero. This is needed because ma_node_graph_read_pcm_frames() can be called with a variable number of frames, and we may need to do some buffering in situations where the caller requests a frame count that's not a multiple of processingSizeInFrames. */
+    ma_uint32 processingCacheFramesRemaining;
+    ma_uint32 processingSizeInFrames;
+
+    /* Read and written by multiple threads. */
+    MA_ATOMIC(4, ma_bool32) isReading;
+
+    /* Modified only by the audio thread. */
+    ma_stack* pPreMixStack;
+};
+
+MA_API ma_result ma_node_graph_init(const ma_node_graph_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node_graph* pNodeGraph);
+MA_API void ma_node_graph_uninit(ma_node_graph* pNodeGraph, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_node* ma_node_graph_get_endpoint(ma_node_graph* pNodeGraph);
+MA_API ma_result ma_node_graph_read_pcm_frames(ma_node_graph* pNodeGraph, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_uint32 ma_node_graph_get_channels(const ma_node_graph* pNodeGraph);
+MA_API ma_uint64 ma_node_graph_get_time(const ma_node_graph* pNodeGraph);
+MA_API ma_result ma_node_graph_set_time(ma_node_graph* pNodeGraph, ma_uint64 globalTime);
+
+
+
+/* Data source node. 0 input buses, 1 output bus. Used for reading from a data source. */
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_data_source* pDataSource;
+} ma_data_source_node_config;
+
+MA_API ma_data_source_node_config ma_data_source_node_config_init(ma_data_source* pDataSource);
+
+
+typedef struct
+{
+    ma_node_base base;
+    ma_data_source* pDataSource;
+} ma_data_source_node;
+
+MA_API ma_result ma_data_source_node_init(ma_node_graph* pNodeGraph, const ma_data_source_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source_node* pDataSourceNode);
+MA_API void ma_data_source_node_uninit(ma_data_source_node* pDataSourceNode, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_data_source_node_set_looping(ma_data_source_node* pDataSourceNode, ma_bool32 isLooping);
+MA_API ma_bool32 ma_data_source_node_is_looping(ma_data_source_node* pDataSourceNode);
+
+
+/* Splitter Node. 1 input, many outputs. Used for splitting/copying a stream so it can be as input into two separate output nodes. */
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_uint32 channels;
+    ma_uint32 outputBusCount;
+} ma_splitter_node_config;
+
+MA_API ma_splitter_node_config ma_splitter_node_config_init(ma_uint32 channels);
+
+
+typedef struct
+{
+    ma_node_base base;
+} ma_splitter_node;
+
+MA_API ma_result ma_splitter_node_init(ma_node_graph* pNodeGraph, const ma_splitter_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_splitter_node* pSplitterNode);
+MA_API void ma_splitter_node_uninit(ma_splitter_node* pSplitterNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Biquad Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_biquad_config biquad;
+} ma_biquad_node_config;
+
+MA_API ma_biquad_node_config ma_biquad_node_config_init(ma_uint32 channels, float b0, float b1, float b2, float a0, float a1, float a2);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_biquad biquad;
+} ma_biquad_node;
+
+MA_API ma_result ma_biquad_node_init(ma_node_graph* pNodeGraph, const ma_biquad_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_biquad_node* pNode);
+MA_API ma_result ma_biquad_node_reinit(const ma_biquad_config* pConfig, ma_biquad_node* pNode);
+MA_API void ma_biquad_node_uninit(ma_biquad_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Low Pass Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_lpf_config lpf;
+} ma_lpf_node_config;
+
+MA_API ma_lpf_node_config ma_lpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_lpf lpf;
+} ma_lpf_node;
+
+MA_API ma_result ma_lpf_node_init(ma_node_graph* pNodeGraph, const ma_lpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf_node* pNode);
+MA_API ma_result ma_lpf_node_reinit(const ma_lpf_config* pConfig, ma_lpf_node* pNode);
+MA_API void ma_lpf_node_uninit(ma_lpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+High Pass Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_hpf_config hpf;
+} ma_hpf_node_config;
+
+MA_API ma_hpf_node_config ma_hpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_hpf hpf;
+} ma_hpf_node;
+
+MA_API ma_result ma_hpf_node_init(ma_node_graph* pNodeGraph, const ma_hpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf_node* pNode);
+MA_API ma_result ma_hpf_node_reinit(const ma_hpf_config* pConfig, ma_hpf_node* pNode);
+MA_API void ma_hpf_node_uninit(ma_hpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Band Pass Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_bpf_config bpf;
+} ma_bpf_node_config;
+
+MA_API ma_bpf_node_config ma_bpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_bpf bpf;
+} ma_bpf_node;
+
+MA_API ma_result ma_bpf_node_init(ma_node_graph* pNodeGraph, const ma_bpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf_node* pNode);
+MA_API ma_result ma_bpf_node_reinit(const ma_bpf_config* pConfig, ma_bpf_node* pNode);
+MA_API void ma_bpf_node_uninit(ma_bpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Notching Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_notch_config notch;
+} ma_notch_node_config;
+
+MA_API ma_notch_node_config ma_notch_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double q, double frequency);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_notch2 notch;
+} ma_notch_node;
+
+MA_API ma_result ma_notch_node_init(ma_node_graph* pNodeGraph, const ma_notch_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_notch_node* pNode);
+MA_API ma_result ma_notch_node_reinit(const ma_notch_config* pConfig, ma_notch_node* pNode);
+MA_API void ma_notch_node_uninit(ma_notch_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Peaking Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_peak_config peak;
+} ma_peak_node_config;
+
+MA_API ma_peak_node_config ma_peak_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_peak2 peak;
+} ma_peak_node;
+
+MA_API ma_result ma_peak_node_init(ma_node_graph* pNodeGraph, const ma_peak_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_peak_node* pNode);
+MA_API ma_result ma_peak_node_reinit(const ma_peak_config* pConfig, ma_peak_node* pNode);
+MA_API void ma_peak_node_uninit(ma_peak_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Low Shelf Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_loshelf_config loshelf;
+} ma_loshelf_node_config;
+
+MA_API ma_loshelf_node_config ma_loshelf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_loshelf2 loshelf;
+} ma_loshelf_node;
+
+MA_API ma_result ma_loshelf_node_init(ma_node_graph* pNodeGraph, const ma_loshelf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_loshelf_node* pNode);
+MA_API ma_result ma_loshelf_node_reinit(const ma_loshelf_config* pConfig, ma_loshelf_node* pNode);
+MA_API void ma_loshelf_node_uninit(ma_loshelf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+High Shelf Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_hishelf_config hishelf;
+} ma_hishelf_node_config;
+
+MA_API ma_hishelf_node_config ma_hishelf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_hishelf2 hishelf;
+} ma_hishelf_node;
+
+MA_API ma_result ma_hishelf_node_init(ma_node_graph* pNodeGraph, const ma_hishelf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hishelf_node* pNode);
+MA_API ma_result ma_hishelf_node_reinit(const ma_hishelf_config* pConfig, ma_hishelf_node* pNode);
+MA_API void ma_hishelf_node_uninit(ma_hishelf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_delay_config delay;
+} ma_delay_node_config;
+
+MA_API ma_delay_node_config ma_delay_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 delayInFrames, float decay);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_delay delay;
+} ma_delay_node;
+
+MA_API ma_result ma_delay_node_init(ma_node_graph* pNodeGraph, const ma_delay_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_delay_node* pDelayNode);
+MA_API void ma_delay_node_uninit(ma_delay_node* pDelayNode, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API void ma_delay_node_set_wet(ma_delay_node* pDelayNode, float value);
+MA_API float ma_delay_node_get_wet(const ma_delay_node* pDelayNode);
+MA_API void ma_delay_node_set_dry(ma_delay_node* pDelayNode, float value);
+MA_API float ma_delay_node_get_dry(const ma_delay_node* pDelayNode);
+MA_API void ma_delay_node_set_decay(ma_delay_node* pDelayNode, float value);
+MA_API float ma_delay_node_get_decay(const ma_delay_node* pDelayNode);
+#endif  /* MA_NO_NODE_GRAPH */
+
+
+/* SECTION: miniaudio_engine.h */
+/************************************************************************************************************************************************************
+
+Engine
+
+************************************************************************************************************************************************************/
+#if !defined(MA_NO_ENGINE) && !defined(MA_NO_NODE_GRAPH)
+typedef struct ma_engine ma_engine;
+typedef struct ma_sound  ma_sound;
+
+
+/* Sound flags. */
+typedef enum
+{
+    /* Resource manager flags. */
+    MA_SOUND_FLAG_STREAM                = 0x00000001,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM */
+    MA_SOUND_FLAG_DECODE                = 0x00000002,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE */
+    MA_SOUND_FLAG_ASYNC                 = 0x00000004,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC */
+    MA_SOUND_FLAG_WAIT_INIT             = 0x00000008,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT */
+    MA_SOUND_FLAG_UNKNOWN_LENGTH        = 0x00000010,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH */
+    MA_SOUND_FLAG_LOOPING               = 0x00000020,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING */
+
+    /* ma_sound specific flags. */
+    MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT = 0x00001000,   /* Do not attach to the endpoint by default. Useful for when setting up nodes in a complex graph system. */
+    MA_SOUND_FLAG_NO_PITCH              = 0x00002000,   /* Disable pitch shifting with ma_sound_set_pitch() and ma_sound_group_set_pitch(). This is an optimization. */
+    MA_SOUND_FLAG_NO_SPATIALIZATION     = 0x00004000    /* Disable spatialization. */
+} ma_sound_flags;
+
+#ifndef MA_ENGINE_MAX_LISTENERS
+#define MA_ENGINE_MAX_LISTENERS             4
+#endif
+
+#define MA_LISTENER_INDEX_CLOSEST           ((ma_uint8)-1)
+
+typedef enum
+{
+    ma_engine_node_type_sound,
+    ma_engine_node_type_group
+} ma_engine_node_type;
+
+typedef struct
+{
+    ma_engine* pEngine;
+    ma_engine_node_type type;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRate;               /* Only used when the type is set to ma_engine_node_type_sound. */
+    ma_uint32 volumeSmoothTimeInPCMFrames;  /* The number of frames to smooth over volume changes. Defaults to 0 in which case no smoothing is used. */
+    ma_mono_expansion_mode monoExpansionMode;
+    ma_bool8 isPitchDisabled;           /* Pitching can be explicitly disabled with MA_SOUND_FLAG_NO_PITCH to optimize processing. */
+    ma_bool8 isSpatializationDisabled;  /* Spatialization can be explicitly disabled with MA_SOUND_FLAG_NO_SPATIALIZATION. */
+    ma_uint8 pinnedListenerIndex;       /* The index of the listener this node should always use for spatialization. If set to MA_LISTENER_INDEX_CLOSEST the engine will use the closest listener. */
+} ma_engine_node_config;
+
+MA_API ma_engine_node_config ma_engine_node_config_init(ma_engine* pEngine, ma_engine_node_type type, ma_uint32 flags);
+
+
+/* Base node object for both ma_sound and ma_sound_group. */
+typedef struct
+{
+    ma_node_base baseNode;                              /* Must be the first member for compatibility with the ma_node API. */
+    ma_engine* pEngine;                                 /* A pointer to the engine. Set based on the value from the config. */
+    ma_uint32 sampleRate;                               /* The sample rate of the input data. For sounds backed by a data source, this will be the data source's sample rate. Otherwise it'll be the engine's sample rate. */
+    ma_uint32 volumeSmoothTimeInPCMFrames;
+    ma_mono_expansion_mode monoExpansionMode;
+    ma_fader fader;
+    ma_linear_resampler resampler;                      /* For pitch shift. */
+    ma_spatializer spatializer;
+    ma_panner panner;
+    ma_gainer volumeGainer;                             /* This will only be used if volumeSmoothTimeInPCMFrames is > 0. */
+    ma_atomic_float volume;                             /* Defaults to 1. */
+    MA_ATOMIC(4, float) pitch;
+    float oldPitch;                                     /* For determining whether or not the resampler needs to be updated to reflect the new pitch. The resampler will be updated on the mixing thread. */
+    float oldDopplerPitch;                              /* For determining whether or not the resampler needs to be updated to take a new doppler pitch into account. */
+    MA_ATOMIC(4, ma_bool32) isPitchDisabled;            /* When set to true, pitching will be disabled which will allow the resampler to be bypassed to save some computation. */
+    MA_ATOMIC(4, ma_bool32) isSpatializationDisabled;   /* Set to false by default. When set to false, will not have spatialisation applied. */
+    MA_ATOMIC(4, ma_uint32) pinnedListenerIndex;        /* The index of the listener this node should always use for spatialization. If set to MA_LISTENER_INDEX_CLOSEST the engine will use the closest listener. */
+
+    /* When setting a fade, it's not done immediately in ma_sound_set_fade(). It's deferred to the audio thread which means we need to store the settings here. */
+    struct
+    {
+        ma_atomic_float volumeBeg;
+        ma_atomic_float volumeEnd;
+        ma_atomic_uint64 fadeLengthInFrames;            /* <-- Defaults to (~(ma_uint64)0) which is used to indicate that no fade should be applied. */
+        ma_atomic_uint64 absoluteGlobalTimeInFrames;    /* <-- The time to start the fade. */
+    } fadeSettings;
+
+    /* Memory management. */
+    ma_bool8 _ownsHeap;
+    void* _pHeap;
+} ma_engine_node;
+
+MA_API ma_result ma_engine_node_get_heap_size(const ma_engine_node_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_engine_node_init_preallocated(const ma_engine_node_config* pConfig, void* pHeap, ma_engine_node* pEngineNode);
+MA_API ma_result ma_engine_node_init(const ma_engine_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_engine_node* pEngineNode);
+MA_API void ma_engine_node_uninit(ma_engine_node* pEngineNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+#define MA_SOUND_SOURCE_CHANNEL_COUNT   0xFFFFFFFF
+
+/* Callback for when a sound reaches the end. */
+typedef void (* ma_sound_end_proc)(void* pUserData, ma_sound* pSound);
+
+typedef struct
+{
+    const char* pFilePath;                      /* Set this to load from the resource manager. */
+    const wchar_t* pFilePathW;                  /* Set this to load from the resource manager. */
+    ma_data_source* pDataSource;                /* Set this to load from an existing data source. */
+    ma_node* pInitialAttachment;                /* If set, the sound will be attached to an input of this node. This can be set to a ma_sound. If set to NULL, the sound will be attached directly to the endpoint unless MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT is set in `flags`. */
+    ma_uint32 initialAttachmentInputBusIndex;   /* The index of the input bus of pInitialAttachment to attach the sound to. */
+    ma_uint32 channelsIn;                       /* Ignored if using a data source as input (the data source's channel count will be used always). Otherwise, setting to 0 will cause the engine's channel count to be used. */
+    ma_uint32 channelsOut;                      /* Set this to 0 (default) to use the engine's channel count. Set to MA_SOUND_SOURCE_CHANNEL_COUNT to use the data source's channel count (only used if using a data source as input). */
+    ma_mono_expansion_mode monoExpansionMode;   /* Controls how the mono channel should be expanded to other channels when spatialization is disabled on a sound. */
+    ma_uint32 flags;                            /* A combination of MA_SOUND_FLAG_* flags. */
+    ma_uint32 volumeSmoothTimeInPCMFrames;      /* The number of frames to smooth over volume changes. Defaults to 0 in which case no smoothing is used. */
+    ma_uint64 initialSeekPointInPCMFrames;      /* Initializes the sound such that it's seeked to this location by default. */
+    ma_uint64 rangeBegInPCMFrames;
+    ma_uint64 rangeEndInPCMFrames;
+    ma_uint64 loopPointBegInPCMFrames;
+    ma_uint64 loopPointEndInPCMFrames;
+    ma_sound_end_proc endCallback;              /* Fired when the sound reaches the end. Will be fired from the audio thread. Do not restart, uninitialize or otherwise change the state of the sound from here. Instead fire an event or set a variable to indicate to a different thread to change the start of the sound. Will not be fired in response to a scheduled stop with ma_sound_set_stop_time_*(). */
+    void* pEndCallbackUserData;
+#ifndef MA_NO_RESOURCE_MANAGER
+    ma_resource_manager_pipeline_notifications initNotifications;
+#endif
+    ma_fence* pDoneFence;                       /* Deprecated. Use initNotifications instead. Released when the resource manager has finished decoding the entire sound. Not used with streams. */
+    ma_bool32 isLooping;                        /* Deprecated. Use the MA_SOUND_FLAG_LOOPING flag in `flags` instead. */
+} ma_sound_config;
+
+MA_API ma_sound_config ma_sound_config_init(void);                  /* Deprecated. Will be removed in version 0.12. Use ma_sound_config_2() instead. */
+MA_API ma_sound_config ma_sound_config_init_2(ma_engine* pEngine);  /* Will be renamed to ma_sound_config_init() in version 0.12. */
+
+struct ma_sound
+{
+    ma_engine_node engineNode;          /* Must be the first member for compatibility with the ma_node API. */
+    ma_data_source* pDataSource;
+    MA_ATOMIC(8, ma_uint64) seekTarget; /* The PCM frame index to seek to in the mixing thread. Set to (~(ma_uint64)0) to not perform any seeking. */
+    MA_ATOMIC(4, ma_bool32) atEnd;
+    ma_sound_end_proc endCallback;
+    void* pEndCallbackUserData;
+    ma_bool8 ownsDataSource;
+
+    /*
+    We're declaring a resource manager data source object here to save us a malloc when loading a
+    sound via the resource manager, which I *think* will be the most common scenario.
+    */
+#ifndef MA_NO_RESOURCE_MANAGER
+    ma_resource_manager_data_source* pResourceManagerDataSource;
+#endif
+};
+
+/* Structure specifically for sounds played with ma_engine_play_sound(). Making this a separate structure to reduce overhead. */
+typedef struct ma_sound_inlined ma_sound_inlined;
+struct ma_sound_inlined
+{
+    ma_sound sound;
+    ma_sound_inlined* pNext;
+    ma_sound_inlined* pPrev;
+};
+
+/* A sound group is just a sound. */
+typedef ma_sound_config ma_sound_group_config;
+typedef ma_sound        ma_sound_group;
+
+MA_API ma_sound_group_config ma_sound_group_config_init(void);                  /* Deprecated. Will be removed in version 0.12. Use ma_sound_config_2() instead. */
+MA_API ma_sound_group_config ma_sound_group_config_init_2(ma_engine* pEngine);  /* Will be renamed to ma_sound_config_init() in version 0.12. */
+
+typedef void (* ma_engine_process_proc)(void* pUserData, float* pFramesOut, ma_uint64 frameCount);
+
+typedef struct
+{
+#if !defined(MA_NO_RESOURCE_MANAGER)
+    ma_resource_manager* pResourceManager;          /* Can be null in which case a resource manager will be created for you. */
+#endif
+#if !defined(MA_NO_DEVICE_IO)
+    ma_context* pContext;
+    ma_device* pDevice;                             /* If set, the caller is responsible for calling ma_engine_data_callback() in the device's data callback. */
+    ma_device_id* pPlaybackDeviceID;                /* The ID of the playback device to use with the default listener. */
+    ma_device_data_proc dataCallback;               /* Can be null. Can be used to provide a custom device data callback. */
+    ma_device_notification_proc notificationCallback;
+#endif
+    ma_log* pLog;                                   /* When set to NULL, will use the context's log. */
+    ma_uint32 listenerCount;                        /* Must be between 1 and MA_ENGINE_MAX_LISTENERS. */
+    ma_uint32 channels;                             /* The number of channels to use when mixing and spatializing. When set to 0, will use the native channel count of the device. */
+    ma_uint32 sampleRate;                           /* The sample rate. When set to 0 will use the native sample rate of the device. */
+    ma_uint32 periodSizeInFrames;                   /* If set to something other than 0, updates will always be exactly this size. The underlying device may be a different size, but from the perspective of the mixer that won't matter.*/
+    ma_uint32 periodSizeInMilliseconds;             /* Used if periodSizeInFrames is unset. */
+    ma_uint32 gainSmoothTimeInFrames;               /* The number of frames to interpolate the gain of spatialized sounds across. If set to 0, will use gainSmoothTimeInMilliseconds. */
+    ma_uint32 gainSmoothTimeInMilliseconds;         /* When set to 0, gainSmoothTimeInFrames will be used. If both are set to 0, a default value will be used. */
+    ma_uint32 defaultVolumeSmoothTimeInPCMFrames;   /* Defaults to 0. Controls the default amount of smoothing to apply to volume changes to sounds. High values means more smoothing at the expense of high latency (will take longer to reach the new volume). */
+    ma_uint32 preMixStackSizeInBytes;               /* A stack is used for internal processing in the node graph. This allows you to configure the size of this stack. Smaller values will reduce the maximum depth of your node graph. You should rarely need to modify this. */
+    ma_allocation_callbacks allocationCallbacks;
+    ma_bool32 noAutoStart;                          /* When set to true, requires an explicit call to ma_engine_start(). This is false by default, meaning the engine will be started automatically in ma_engine_init(). */
+    ma_bool32 noDevice;                             /* When set to true, don't create a default device. ma_engine_read_pcm_frames() can be called manually to read data. */
+    ma_mono_expansion_mode monoExpansionMode;       /* Controls how the mono channel should be expanded to other channels when spatialization is disabled on a sound. */
+    ma_vfs* pResourceManagerVFS;                    /* A pointer to a pre-allocated VFS object to use with the resource manager. This is ignored if pResourceManager is not NULL. */
+    ma_engine_process_proc onProcess;               /* Fired at the end of each call to ma_engine_read_pcm_frames(). For engine's that manage their own internal device (the default configuration), this will be fired from the audio thread, and you do not need to call ma_engine_read_pcm_frames() manually in order to trigger this. */
+    void* pProcessUserData;                         /* User data that's passed into onProcess. */
+} ma_engine_config;
+
+MA_API ma_engine_config ma_engine_config_init(void);
+
+
+struct ma_engine
+{
+    ma_node_graph nodeGraph;                        /* An engine is a node graph. It should be able to be plugged into any ma_node_graph API (with a cast) which means this must be the first member of this struct. */
+#if !defined(MA_NO_RESOURCE_MANAGER)
+    ma_resource_manager* pResourceManager;
+#endif
+#if !defined(MA_NO_DEVICE_IO)
+    ma_device* pDevice;                             /* Optionally set via the config, otherwise allocated by the engine in ma_engine_init(). */
+#endif
+    ma_log* pLog;
+    ma_uint32 sampleRate;
+    ma_uint32 listenerCount;
+    ma_spatializer_listener listeners[MA_ENGINE_MAX_LISTENERS];
+    ma_allocation_callbacks allocationCallbacks;
+    ma_bool8 ownsResourceManager;
+    ma_bool8 ownsDevice;
+    ma_spinlock inlinedSoundLock;                   /* For synchronizing access to the inlined sound list. */
+    ma_sound_inlined* pInlinedSoundHead;            /* The first inlined sound. Inlined sounds are tracked in a linked list. */
+    MA_ATOMIC(4, ma_uint32) inlinedSoundCount;      /* The total number of allocated inlined sound objects. Used for debugging. */
+    ma_uint32 gainSmoothTimeInFrames;               /* The number of frames to interpolate the gain of spatialized sounds across. */
+    ma_uint32 defaultVolumeSmoothTimeInPCMFrames;
+    ma_mono_expansion_mode monoExpansionMode;
+    ma_engine_process_proc onProcess;
+    void* pProcessUserData;
+};
+
+MA_API ma_result ma_engine_init(const ma_engine_config* pConfig, ma_engine* pEngine);
+MA_API void ma_engine_uninit(ma_engine* pEngine);
+MA_API ma_result ma_engine_read_pcm_frames(ma_engine* pEngine, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_node_graph* ma_engine_get_node_graph(ma_engine* pEngine);
+#if !defined(MA_NO_RESOURCE_MANAGER)
+MA_API ma_resource_manager* ma_engine_get_resource_manager(ma_engine* pEngine);
+#endif
+MA_API ma_device* ma_engine_get_device(ma_engine* pEngine);
+MA_API ma_log* ma_engine_get_log(ma_engine* pEngine);
+MA_API ma_node* ma_engine_get_endpoint(ma_engine* pEngine);
+MA_API ma_uint64 ma_engine_get_time_in_pcm_frames(const ma_engine* pEngine);
+MA_API ma_uint64 ma_engine_get_time_in_milliseconds(const ma_engine* pEngine);
+MA_API ma_result ma_engine_set_time_in_pcm_frames(ma_engine* pEngine, ma_uint64 globalTime);
+MA_API ma_result ma_engine_set_time_in_milliseconds(ma_engine* pEngine, ma_uint64 globalTime);
+MA_API ma_uint64 ma_engine_get_time(const ma_engine* pEngine);                  /* Deprecated. Use ma_engine_get_time_in_pcm_frames(). Will be removed in version 0.12. */
+MA_API ma_result ma_engine_set_time(ma_engine* pEngine, ma_uint64 globalTime);  /* Deprecated. Use ma_engine_set_time_in_pcm_frames(). Will be removed in version 0.12. */
+MA_API ma_uint32 ma_engine_get_channels(const ma_engine* pEngine);
+MA_API ma_uint32 ma_engine_get_sample_rate(const ma_engine* pEngine);
+
+MA_API ma_result ma_engine_start(ma_engine* pEngine);
+MA_API ma_result ma_engine_stop(ma_engine* pEngine);
+MA_API ma_result ma_engine_set_volume(ma_engine* pEngine, float volume);
+MA_API float ma_engine_get_volume(ma_engine* pEngine);
+MA_API ma_result ma_engine_set_gain_db(ma_engine* pEngine, float gainDB);
+MA_API float ma_engine_get_gain_db(ma_engine* pEngine);
+
+MA_API ma_uint32 ma_engine_get_listener_count(const ma_engine* pEngine);
+MA_API ma_uint32 ma_engine_find_closest_listener(const ma_engine* pEngine, float absolutePosX, float absolutePosY, float absolutePosZ);
+MA_API void ma_engine_listener_set_position(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z);
+MA_API ma_vec3f ma_engine_listener_get_position(const ma_engine* pEngine, ma_uint32 listenerIndex);
+MA_API void ma_engine_listener_set_direction(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z);
+MA_API ma_vec3f ma_engine_listener_get_direction(const ma_engine* pEngine, ma_uint32 listenerIndex);
+MA_API void ma_engine_listener_set_velocity(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z);
+MA_API ma_vec3f ma_engine_listener_get_velocity(const ma_engine* pEngine, ma_uint32 listenerIndex);
+MA_API void ma_engine_listener_set_cone(ma_engine* pEngine, ma_uint32 listenerIndex, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_engine_listener_get_cone(const ma_engine* pEngine, ma_uint32 listenerIndex, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_engine_listener_set_world_up(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z);
+MA_API ma_vec3f ma_engine_listener_get_world_up(const ma_engine* pEngine, ma_uint32 listenerIndex);
+MA_API void ma_engine_listener_set_enabled(ma_engine* pEngine, ma_uint32 listenerIndex, ma_bool32 isEnabled);
+MA_API ma_bool32 ma_engine_listener_is_enabled(const ma_engine* pEngine, ma_uint32 listenerIndex);
+
+#ifndef MA_NO_RESOURCE_MANAGER
+MA_API ma_result ma_engine_play_sound_ex(ma_engine* pEngine, const char* pFilePath, ma_node* pNode, ma_uint32 nodeInputBusIndex);
+MA_API ma_result ma_engine_play_sound(ma_engine* pEngine, const char* pFilePath, ma_sound_group* pGroup);   /* Fire and forget. */
+#endif
+
+#ifndef MA_NO_RESOURCE_MANAGER
+MA_API ma_result ma_sound_init_from_file(ma_engine* pEngine, const char* pFilePath, ma_uint32 flags, ma_sound_group* pGroup, ma_fence* pDoneFence, ma_sound* pSound);
+MA_API ma_result ma_sound_init_from_file_w(ma_engine* pEngine, const wchar_t* pFilePath, ma_uint32 flags, ma_sound_group* pGroup, ma_fence* pDoneFence, ma_sound* pSound);
+MA_API ma_result ma_sound_init_copy(ma_engine* pEngine, const ma_sound* pExistingSound, ma_uint32 flags, ma_sound_group* pGroup, ma_sound* pSound);
+#endif
+MA_API ma_result ma_sound_init_from_data_source(ma_engine* pEngine, ma_data_source* pDataSource, ma_uint32 flags, ma_sound_group* pGroup, ma_sound* pSound);
+MA_API ma_result ma_sound_init_ex(ma_engine* pEngine, const ma_sound_config* pConfig, ma_sound* pSound);
+MA_API void ma_sound_uninit(ma_sound* pSound);
+MA_API ma_engine* ma_sound_get_engine(const ma_sound* pSound);
+MA_API ma_data_source* ma_sound_get_data_source(const ma_sound* pSound);
+MA_API ma_result ma_sound_start(ma_sound* pSound);
+MA_API ma_result ma_sound_stop(ma_sound* pSound);
+MA_API ma_result ma_sound_stop_with_fade_in_pcm_frames(ma_sound* pSound, ma_uint64 fadeLengthInFrames);     /* Will overwrite any scheduled stop and fade. */
+MA_API ma_result ma_sound_stop_with_fade_in_milliseconds(ma_sound* pSound, ma_uint64 fadeLengthInFrames);   /* Will overwrite any scheduled stop and fade. */
+MA_API void ma_sound_set_volume(ma_sound* pSound, float volume);
+MA_API float ma_sound_get_volume(const ma_sound* pSound);
+MA_API void ma_sound_set_pan(ma_sound* pSound, float pan);
+MA_API float ma_sound_get_pan(const ma_sound* pSound);
+MA_API void ma_sound_set_pan_mode(ma_sound* pSound, ma_pan_mode panMode);
+MA_API ma_pan_mode ma_sound_get_pan_mode(const ma_sound* pSound);
+MA_API void ma_sound_set_pitch(ma_sound* pSound, float pitch);
+MA_API float ma_sound_get_pitch(const ma_sound* pSound);
+MA_API void ma_sound_set_spatialization_enabled(ma_sound* pSound, ma_bool32 enabled);
+MA_API ma_bool32 ma_sound_is_spatialization_enabled(const ma_sound* pSound);
+MA_API void ma_sound_set_pinned_listener_index(ma_sound* pSound, ma_uint32 listenerIndex);
+MA_API ma_uint32 ma_sound_get_pinned_listener_index(const ma_sound* pSound);
+MA_API ma_uint32 ma_sound_get_listener_index(const ma_sound* pSound);
+MA_API ma_vec3f ma_sound_get_direction_to_listener(const ma_sound* pSound);
+MA_API void ma_sound_set_position(ma_sound* pSound, float x, float y, float z);
+MA_API ma_vec3f ma_sound_get_position(const ma_sound* pSound);
+MA_API void ma_sound_set_direction(ma_sound* pSound, float x, float y, float z);
+MA_API ma_vec3f ma_sound_get_direction(const ma_sound* pSound);
+MA_API void ma_sound_set_velocity(ma_sound* pSound, float x, float y, float z);
+MA_API ma_vec3f ma_sound_get_velocity(const ma_sound* pSound);
+MA_API void ma_sound_set_attenuation_model(ma_sound* pSound, ma_attenuation_model attenuationModel);
+MA_API ma_attenuation_model ma_sound_get_attenuation_model(const ma_sound* pSound);
+MA_API void ma_sound_set_positioning(ma_sound* pSound, ma_positioning positioning);
+MA_API ma_positioning ma_sound_get_positioning(const ma_sound* pSound);
+MA_API void ma_sound_set_rolloff(ma_sound* pSound, float rolloff);
+MA_API float ma_sound_get_rolloff(const ma_sound* pSound);
+MA_API void ma_sound_set_min_gain(ma_sound* pSound, float minGain);
+MA_API float ma_sound_get_min_gain(const ma_sound* pSound);
+MA_API void ma_sound_set_max_gain(ma_sound* pSound, float maxGain);
+MA_API float ma_sound_get_max_gain(const ma_sound* pSound);
+MA_API void ma_sound_set_min_distance(ma_sound* pSound, float minDistance);
+MA_API float ma_sound_get_min_distance(const ma_sound* pSound);
+MA_API void ma_sound_set_max_distance(ma_sound* pSound, float maxDistance);
+MA_API float ma_sound_get_max_distance(const ma_sound* pSound);
+MA_API void ma_sound_set_cone(ma_sound* pSound, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_sound_get_cone(const ma_sound* pSound, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_sound_set_doppler_factor(ma_sound* pSound, float dopplerFactor);
+MA_API float ma_sound_get_doppler_factor(const ma_sound* pSound);
+MA_API void ma_sound_set_directional_attenuation_factor(ma_sound* pSound, float directionalAttenuationFactor);
+MA_API float ma_sound_get_directional_attenuation_factor(const ma_sound* pSound);
+MA_API void ma_sound_set_fade_in_pcm_frames(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames);
+MA_API void ma_sound_set_fade_in_milliseconds(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds);
+MA_API void ma_sound_set_fade_start_in_pcm_frames(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_set_fade_start_in_milliseconds(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API float ma_sound_get_current_fade_volume(const ma_sound* pSound);
+MA_API void ma_sound_set_start_time_in_pcm_frames(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_set_start_time_in_milliseconds(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API void ma_sound_set_stop_time_in_pcm_frames(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_set_stop_time_in_milliseconds(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API void ma_sound_set_stop_time_with_fade_in_pcm_frames(ma_sound* pSound, ma_uint64 stopAbsoluteGlobalTimeInFrames, ma_uint64 fadeLengthInFrames);
+MA_API void ma_sound_set_stop_time_with_fade_in_milliseconds(ma_sound* pSound, ma_uint64 stopAbsoluteGlobalTimeInMilliseconds, ma_uint64 fadeLengthInMilliseconds);
+MA_API ma_bool32 ma_sound_is_playing(const ma_sound* pSound);
+MA_API ma_uint64 ma_sound_get_time_in_pcm_frames(const ma_sound* pSound);
+MA_API ma_uint64 ma_sound_get_time_in_milliseconds(const ma_sound* pSound);
+MA_API void ma_sound_set_looping(ma_sound* pSound, ma_bool32 isLooping);
+MA_API ma_bool32 ma_sound_is_looping(const ma_sound* pSound);
+MA_API ma_bool32 ma_sound_at_end(const ma_sound* pSound);
+MA_API ma_result ma_sound_seek_to_pcm_frame(ma_sound* pSound, ma_uint64 frameIndex); /* Just a wrapper around ma_data_source_seek_to_pcm_frame(). */
+MA_API ma_result ma_sound_seek_to_second(ma_sound* pSound, float seekPointInSeconds); /* Abstraction to ma_sound_seek_to_pcm_frame() */
+MA_API ma_result ma_sound_get_data_format(const ma_sound* pSound, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_sound_get_cursor_in_pcm_frames(const ma_sound* pSound, ma_uint64* pCursor);
+MA_API ma_result ma_sound_get_length_in_pcm_frames(const ma_sound* pSound, ma_uint64* pLength);
+MA_API ma_result ma_sound_get_cursor_in_seconds(const ma_sound* pSound, float* pCursor);
+MA_API ma_result ma_sound_get_length_in_seconds(const ma_sound* pSound, float* pLength);
+MA_API ma_result ma_sound_set_end_callback(ma_sound* pSound, ma_sound_end_proc callback, void* pUserData);
+
+MA_API ma_result ma_sound_group_init(ma_engine* pEngine, ma_uint32 flags, ma_sound_group* pParentGroup, ma_sound_group* pGroup);
+MA_API ma_result ma_sound_group_init_ex(ma_engine* pEngine, const ma_sound_group_config* pConfig, ma_sound_group* pGroup);
+MA_API void ma_sound_group_uninit(ma_sound_group* pGroup);
+MA_API ma_engine* ma_sound_group_get_engine(const ma_sound_group* pGroup);
+MA_API ma_result ma_sound_group_start(ma_sound_group* pGroup);
+MA_API ma_result ma_sound_group_stop(ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_volume(ma_sound_group* pGroup, float volume);
+MA_API float ma_sound_group_get_volume(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_pan(ma_sound_group* pGroup, float pan);
+MA_API float ma_sound_group_get_pan(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_pan_mode(ma_sound_group* pGroup, ma_pan_mode panMode);
+MA_API ma_pan_mode ma_sound_group_get_pan_mode(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_pitch(ma_sound_group* pGroup, float pitch);
+MA_API float ma_sound_group_get_pitch(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_spatialization_enabled(ma_sound_group* pGroup, ma_bool32 enabled);
+MA_API ma_bool32 ma_sound_group_is_spatialization_enabled(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_pinned_listener_index(ma_sound_group* pGroup, ma_uint32 listenerIndex);
+MA_API ma_uint32 ma_sound_group_get_pinned_listener_index(const ma_sound_group* pGroup);
+MA_API ma_uint32 ma_sound_group_get_listener_index(const ma_sound_group* pGroup);
+MA_API ma_vec3f ma_sound_group_get_direction_to_listener(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_position(ma_sound_group* pGroup, float x, float y, float z);
+MA_API ma_vec3f ma_sound_group_get_position(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_direction(ma_sound_group* pGroup, float x, float y, float z);
+MA_API ma_vec3f ma_sound_group_get_direction(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_velocity(ma_sound_group* pGroup, float x, float y, float z);
+MA_API ma_vec3f ma_sound_group_get_velocity(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_attenuation_model(ma_sound_group* pGroup, ma_attenuation_model attenuationModel);
+MA_API ma_attenuation_model ma_sound_group_get_attenuation_model(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_positioning(ma_sound_group* pGroup, ma_positioning positioning);
+MA_API ma_positioning ma_sound_group_get_positioning(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_rolloff(ma_sound_group* pGroup, float rolloff);
+MA_API float ma_sound_group_get_rolloff(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_min_gain(ma_sound_group* pGroup, float minGain);
+MA_API float ma_sound_group_get_min_gain(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_max_gain(ma_sound_group* pGroup, float maxGain);
+MA_API float ma_sound_group_get_max_gain(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_min_distance(ma_sound_group* pGroup, float minDistance);
+MA_API float ma_sound_group_get_min_distance(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_max_distance(ma_sound_group* pGroup, float maxDistance);
+MA_API float ma_sound_group_get_max_distance(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_cone(ma_sound_group* pGroup, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_sound_group_get_cone(const ma_sound_group* pGroup, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_sound_group_set_doppler_factor(ma_sound_group* pGroup, float dopplerFactor);
+MA_API float ma_sound_group_get_doppler_factor(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_directional_attenuation_factor(ma_sound_group* pGroup, float directionalAttenuationFactor);
+MA_API float ma_sound_group_get_directional_attenuation_factor(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_fade_in_pcm_frames(ma_sound_group* pGroup, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames);
+MA_API void ma_sound_group_set_fade_in_milliseconds(ma_sound_group* pGroup, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds);
+MA_API float ma_sound_group_get_current_fade_volume(ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_start_time_in_pcm_frames(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_group_set_start_time_in_milliseconds(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API void ma_sound_group_set_stop_time_in_pcm_frames(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_group_set_stop_time_in_milliseconds(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API ma_bool32 ma_sound_group_is_playing(const ma_sound_group* pGroup);
+MA_API ma_uint64 ma_sound_group_get_time_in_pcm_frames(const ma_sound_group* pGroup);
+#endif  /* MA_NO_ENGINE */
+/* END SECTION: miniaudio_engine.h */
+
+#ifdef __cplusplus
+}
+#endif
+#endif  /* miniaudio_h */
+
+
+/*
+This is for preventing greying out of the implementation section.
+*/
+#if defined(Q_CREATOR_RUN) || defined(__INTELLISENSE__) || defined(__CDT_PARSER__)
+#define MINIAUDIO_IMPLEMENTATION
+#endif
+
+/************************************************************************************************************************************************************
+*************************************************************************************************************************************************************
+
+IMPLEMENTATION
+
+*************************************************************************************************************************************************************
+************************************************************************************************************************************************************/
+#if defined(MINIAUDIO_IMPLEMENTATION) || defined(MA_IMPLEMENTATION)
+#ifndef miniaudio_c
+#define miniaudio_c
+
+#include <assert.h>
+#include <limits.h>         /* For INT_MAX */
+#include <math.h>           /* sin(), etc. */
+#include <stdlib.h>         /* For malloc(), free(), wcstombs(). */
+#include <string.h>         /* For memset() */
+
+#include <stdarg.h>
+#include <stdio.h>
+#if !defined(_MSC_VER) && !defined(__DMC__)
+    #include <strings.h>    /* For strcasecmp(). */
+    #include <wchar.h>      /* For wcslen(), wcsrtombs() */
+#endif
+#ifdef _MSC_VER
+    #include <float.h>      /* For _controlfp_s constants */
+#endif
+
+#if defined(MA_WIN32)
+    #include <windows.h>
+
+    /*
+    There's a possibility that WIN32_LEAN_AND_MEAN has been defined which will exclude some symbols
+    such as STGM_READ and CLSCTL_ALL. We need to check these and define them ourselves if they're
+    unavailable.
+    */
+    #ifndef STGM_READ
+    #define STGM_READ   0x00000000L
+    #endif
+    #ifndef CLSCTX_ALL
+    #define CLSCTX_ALL  23
+    #endif
+
+    /* IUnknown is used by both the WASAPI and DirectSound backends. It easier to just declare our version here. */
+    typedef struct ma_IUnknown  ma_IUnknown;
+#endif
+
+#if !defined(MA_WIN32)
+    #if !defined(MA_NO_THREADING)
+        #include <sched.h>
+        #include <pthread.h>     /* For pthreads. */
+    #endif
+
+    #include <sys/time.h>   /* select() (used for ma_sleep()). */
+    #include <time.h>       /* For nanosleep() */
+    #include <unistd.h> 
+#endif
+
+/* For fstat(), etc. */
+#if defined(MA_XBOX_NXDK)
+    #include <stat.h>       /* Suggestion for NXDK: Add a sys/stat.h wrapper for compatibility. */
+#else
+    #include <sys/stat.h>
+#endif
+
+#ifdef MA_EMSCRIPTEN
+#include <emscripten/emscripten.h>
+#endif
+
+
+/* Architecture Detection */
+#if !defined(MA_64BIT) && !defined(MA_32BIT)
+#ifdef _WIN32
+#ifdef _WIN64
+#define MA_64BIT
+#else
+#define MA_32BIT
+#endif
+#endif
+#endif
+
+#if !defined(MA_64BIT) && !defined(MA_32BIT)
+#ifdef __GNUC__
+#ifdef __LP64__
+#define MA_64BIT
+#else
+#define MA_32BIT
+#endif
+#endif
+#endif
+
+#if !defined(MA_64BIT) && !defined(MA_32BIT)
+#include <stdint.h>
+#if INTPTR_MAX == INT64_MAX
+#define MA_64BIT
+#else
+#define MA_32BIT
+#endif
+#endif
+
+#if defined(__arm__) || defined(_M_ARM)
+#define MA_ARM32
+#endif
+#if defined(__arm64) || defined(__arm64__) || defined(__aarch64__) || defined(_M_ARM64)
+#define MA_ARM64
+#endif
+
+#if defined(__x86_64__) || defined(_M_X64)
+#define MA_X64
+#elif defined(__i386) || defined(_M_IX86)
+#define MA_X86
+#elif defined(MA_ARM32) || defined(MA_ARM64)
+#define MA_ARM
+#endif
+
+/* Intrinsics Support */
+#if (defined(MA_X64) || defined(MA_X86)) && !defined(__COSMOPOLITAN__)
+    #if defined(_MSC_VER) && !defined(__clang__)
+        /* MSVC. */
+        #if _MSC_VER >= 1400 && !defined(MA_NO_SSE2)   /* 2005 */
+            #define MA_SUPPORT_SSE2
+        #endif
+        /*#if _MSC_VER >= 1600 && !defined(MA_NO_AVX)*/    /* 2010 */
+        /*    #define MA_SUPPORT_AVX*/
+        /*#endif*/
+        #if _MSC_VER >= 1700 && !defined(MA_NO_AVX2)   /* 2012 */
+            #define MA_SUPPORT_AVX2
+        #endif
+    #else
+        /* Assume GNUC-style. */
+        #if defined(__SSE2__) && !defined(MA_NO_SSE2)
+            #define MA_SUPPORT_SSE2
+        #endif
+        /*#if defined(__AVX__) && !defined(MA_NO_AVX)*/
+        /*    #define MA_SUPPORT_AVX*/
+        /*#endif*/
+        #if defined(__AVX2__) && !defined(MA_NO_AVX2)
+            #define MA_SUPPORT_AVX2
+        #endif
+    #endif
+
+    /* If at this point we still haven't determined compiler support for the intrinsics just fall back to __has_include. */
+    #if !defined(__GNUC__) && !defined(__clang__) && defined(__has_include)
+        #if !defined(MA_SUPPORT_SSE2)   && !defined(MA_NO_SSE2)   && __has_include(<emmintrin.h>)
+            #define MA_SUPPORT_SSE2
+        #endif
+        /*#if !defined(MA_SUPPORT_AVX)    && !defined(MA_NO_AVX)    && __has_include(<immintrin.h>)*/
+        /*    #define MA_SUPPORT_AVX*/
+        /*#endif*/
+        #if !defined(MA_SUPPORT_AVX2)   && !defined(MA_NO_AVX2)   && __has_include(<immintrin.h>)
+            #define MA_SUPPORT_AVX2
+        #endif
+    #endif
+
+    #if defined(MA_SUPPORT_AVX2) || defined(MA_SUPPORT_AVX)
+        #include <immintrin.h>
+    #elif defined(MA_SUPPORT_SSE2)
+        #include <emmintrin.h>
+    #endif
+#endif
+
+#if defined(MA_ARM)
+    #if !defined(MA_NO_NEON) && (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+        #define MA_SUPPORT_NEON
+        #include <arm_neon.h>
+    #endif
+#endif
+
+/* Begin globally disabled warnings. */
+#if defined(_MSC_VER)
+    #pragma warning(push)
+    #pragma warning(disable:4752)   /* found Intel(R) Advanced Vector Extensions; consider using /arch:AVX */
+    #pragma warning(disable:4049)   /* compiler limit : terminating line number emission */
+#endif
+
+#if defined(MA_X64) || defined(MA_X86)
+    #if defined(_MSC_VER) && !defined(__clang__)
+        #if _MSC_VER >= 1400
+            #include <intrin.h>
+            static MA_INLINE void ma_cpuid(int info[4], int fid)
+            {
+                __cpuid(info, fid);
+            }
+        #else
+            #define MA_NO_CPUID
+        #endif
+
+        #if _MSC_VER >= 1600 && (defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 160040219)
+            static MA_INLINE unsigned __int64 ma_xgetbv(int reg)
+            {
+                return _xgetbv(reg);
+            }
+        #else
+            #define MA_NO_XGETBV
+        #endif
+    #elif (defined(__GNUC__) || defined(__clang__)) && !defined(MA_ANDROID)
+        static MA_INLINE void ma_cpuid(int info[4], int fid)
+        {
+            /*
+            It looks like the -fPIC option uses the ebx register which GCC complains about. We can work around this by just using a different register, the
+            specific register of which I'm letting the compiler decide on. The "k" prefix is used to specify a 32-bit register. The {...} syntax is for
+            supporting different assembly dialects.
+
+            What's basically happening is that we're saving and restoring the ebx register manually.
+            */
+            #if defined(MA_X86) && defined(__PIC__)
+                __asm__ __volatile__ (
+                    "xchg{l} {%%}ebx, %k1;"
+                    "cpuid;"
+                    "xchg{l} {%%}ebx, %k1;"
+                    : "=a"(info[0]), "=&r"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+                );
+            #else
+                __asm__ __volatile__ (
+                    "cpuid" : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+                );
+            #endif
+        }
+
+        static MA_INLINE ma_uint64 ma_xgetbv(int reg)
+        {
+            unsigned int hi;
+            unsigned int lo;
+
+            __asm__ __volatile__ (
+                "xgetbv" : "=a"(lo), "=d"(hi) : "c"(reg)
+            );
+
+            return ((ma_uint64)hi << 32) | (ma_uint64)lo;
+        }
+    #else
+        #define MA_NO_CPUID
+        #define MA_NO_XGETBV
+    #endif
+#else
+    #define MA_NO_CPUID
+    #define MA_NO_XGETBV
+#endif
+
+static MA_INLINE ma_bool32 ma_has_sse2(void)
+{
+#if defined(MA_SUPPORT_SSE2)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_NO_SSE2)
+        #if defined(MA_X64)
+            return MA_TRUE;    /* 64-bit targets always support SSE2. */
+        #elif (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__)
+            return MA_TRUE;    /* If the compiler is allowed to freely generate SSE2 code we can assume support. */
+        #else
+            #if defined(MA_NO_CPUID)
+                return MA_FALSE;
+            #else
+                int info[4];
+                ma_cpuid(info, 1);
+                return (info[3] & (1 << 26)) != 0;
+            #endif
+        #endif
+    #else
+        return MA_FALSE;       /* SSE2 is only supported on x86 and x64 architectures. */
+    #endif
+#else
+    return MA_FALSE;           /* No compiler support. */
+#endif
+}
+
+#if 0
+static MA_INLINE ma_bool32 ma_has_avx()
+{
+#if defined(MA_SUPPORT_AVX)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_NO_AVX)
+        #if defined(_AVX_) || defined(__AVX__)
+            return MA_TRUE;    /* If the compiler is allowed to freely generate AVX code we can assume support. */
+        #else
+            /* AVX requires both CPU and OS support. */
+            #if defined(MA_NO_CPUID) || defined(MA_NO_XGETBV)
+                return MA_FALSE;
+            #else
+                int info[4];
+                ma_cpuid(info, 1);
+                if (((info[2] & (1 << 27)) != 0) && ((info[2] & (1 << 28)) != 0)) {
+                    ma_uint64 xrc = ma_xgetbv(0);
+                    if ((xrc & 0x06) == 0x06) {
+                        return MA_TRUE;
+                    } else {
+                        return MA_FALSE;
+                    }
+                } else {
+                    return MA_FALSE;
+                }
+            #endif
+        #endif
+    #else
+        return MA_FALSE;       /* AVX is only supported on x86 and x64 architectures. */
+    #endif
+#else
+    return MA_FALSE;           /* No compiler support. */
+#endif
+}
+#endif
+
+static MA_INLINE ma_bool32 ma_has_avx2(void)
+{
+#if defined(MA_SUPPORT_AVX2)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_NO_AVX2)
+        #if defined(_AVX2_) || defined(__AVX2__)
+            return MA_TRUE;    /* If the compiler is allowed to freely generate AVX2 code we can assume support. */
+        #else
+            /* AVX2 requires both CPU and OS support. */
+            #if defined(MA_NO_CPUID) || defined(MA_NO_XGETBV)
+                return MA_FALSE;
+            #else
+                int info1[4];
+                int info7[4];
+                ma_cpuid(info1, 1);
+                ma_cpuid(info7, 7);
+                if (((info1[2] & (1 << 27)) != 0) && ((info7[1] & (1 << 5)) != 0)) {
+                    ma_uint64 xrc = ma_xgetbv(0);
+                    if ((xrc & 0x06) == 0x06) {
+                        return MA_TRUE;
+                    } else {
+                        return MA_FALSE;
+                    }
+                } else {
+                    return MA_FALSE;
+                }
+            #endif
+        #endif
+    #else
+        return MA_FALSE;       /* AVX2 is only supported on x86 and x64 architectures. */
+    #endif
+#else
+    return MA_FALSE;           /* No compiler support. */
+#endif
+}
+
+static MA_INLINE ma_bool32 ma_has_neon(void)
+{
+#if defined(MA_SUPPORT_NEON)
+    #if defined(MA_ARM) && !defined(MA_NO_NEON)
+        #if (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+            return MA_TRUE;    /* If the compiler is allowed to freely generate NEON code we can assume support. */
+        #else
+            /* TODO: Runtime check. */
+            return MA_FALSE;
+        #endif
+    #else
+        return MA_FALSE;       /* NEON is only supported on ARM architectures. */
+    #endif
+#else
+    return MA_FALSE;           /* No compiler support. */
+#endif
+}
+
+#if defined(__has_builtin)
+    #define MA_COMPILER_HAS_BUILTIN(x) __has_builtin(x)
+#else
+    #define MA_COMPILER_HAS_BUILTIN(x) 0
+#endif
+
+#ifndef MA_ASSUME
+    #if MA_COMPILER_HAS_BUILTIN(__builtin_assume)
+        #define MA_ASSUME(x) __builtin_assume(x)
+    #elif MA_COMPILER_HAS_BUILTIN(__builtin_unreachable)
+        #define MA_ASSUME(x) do { if (!(x)) __builtin_unreachable(); } while (0)
+    #elif defined(_MSC_VER)
+        #define MA_ASSUME(x) __assume(x)
+    #else
+        #define MA_ASSUME(x) (void)(x)
+    #endif
+#endif
+
+#ifndef MA_RESTRICT
+    #if defined(__clang__) || defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)))
+        #define MA_RESTRICT __restrict
+    #else
+        #define MA_RESTRICT
+    #endif
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    #define MA_HAS_BYTESWAP16_INTRINSIC
+    #define MA_HAS_BYTESWAP32_INTRINSIC
+    #define MA_HAS_BYTESWAP64_INTRINSIC
+#elif defined(__clang__)
+    #if MA_COMPILER_HAS_BUILTIN(__builtin_bswap16)
+        #define MA_HAS_BYTESWAP16_INTRINSIC
+    #endif
+    #if MA_COMPILER_HAS_BUILTIN(__builtin_bswap32)
+        #define MA_HAS_BYTESWAP32_INTRINSIC
+    #endif
+    #if MA_COMPILER_HAS_BUILTIN(__builtin_bswap64)
+        #define MA_HAS_BYTESWAP64_INTRINSIC
+    #endif
+#elif defined(__GNUC__)
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+        #define MA_HAS_BYTESWAP32_INTRINSIC
+        #define MA_HAS_BYTESWAP64_INTRINSIC
+    #endif
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+        #define MA_HAS_BYTESWAP16_INTRINSIC
+    #endif
+#endif
+
+
+static MA_INLINE ma_bool32 ma_is_little_endian(void)
+{
+#if defined(MA_X86) || defined(MA_X64)
+    return MA_TRUE;
+#else
+    int n = 1;
+    return (*(char*)&n) == 1;
+#endif
+}
+
+static MA_INLINE ma_bool32 ma_is_big_endian(void)
+{
+    return !ma_is_little_endian();
+}
+
+
+static MA_INLINE ma_uint32 ma_swap_endian_uint32(ma_uint32 n)
+{
+#ifdef MA_HAS_BYTESWAP32_INTRINSIC
+    #if defined(_MSC_VER)
+        return _byteswap_ulong(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        #if defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(MA_64BIT)   /* <-- 64-bit inline assembly has not been tested, so disabling for now. */
+            /* Inline assembly optimized implementation for ARM. In my testing, GCC does not generate optimized code with __builtin_bswap32(). */
+            ma_uint32 r;
+            __asm__ __volatile__ (
+            #if defined(MA_64BIT)
+                "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n)   /* <-- This is untested. If someone in the community could test this, that would be appreciated! */
+            #else
+                "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n)
+            #endif
+            );
+            return r;
+        #else
+            return __builtin_bswap32(n);
+        #endif
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF000000) >> 24) |
+           ((n & 0x00FF0000) >>  8) |
+           ((n & 0x0000FF00) <<  8) |
+           ((n & 0x000000FF) << 24);
+#endif
+}
+
+
+#if !defined(MA_EMSCRIPTEN)
+#ifdef MA_WIN32
+static void ma_sleep__win32(ma_uint32 milliseconds)
+{
+    Sleep((DWORD)milliseconds);
+}
+#endif
+#ifdef MA_POSIX
+static void ma_sleep__posix(ma_uint32 milliseconds)
+{
+#ifdef MA_EMSCRIPTEN
+    (void)milliseconds;
+    MA_ASSERT(MA_FALSE);  /* The Emscripten build should never sleep. */
+#else
+    #if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309L) || defined(MA_SWITCH)
+        struct timespec ts;
+        ts.tv_sec  = milliseconds / 1000;
+        ts.tv_nsec = milliseconds % 1000 * 1000000;
+        nanosleep(&ts, NULL);
+    #else
+        struct timeval tv;
+        tv.tv_sec  = milliseconds / 1000;
+        tv.tv_usec = milliseconds % 1000 * 1000;
+        select(0, NULL, NULL, NULL, &tv);
+    #endif
+#endif
+}
+#endif
+
+static MA_INLINE void ma_sleep(ma_uint32 milliseconds)
+{
+#ifdef MA_WIN32
+    ma_sleep__win32(milliseconds);
+#endif
+#ifdef MA_POSIX
+    ma_sleep__posix(milliseconds);
+#endif
+}
+#endif
+
+static MA_INLINE void ma_yield(void)
+{
+#if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
+    /* x86/x64 */
+    #if (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__DMC__)) && !defined(__clang__)
+        #if _MSC_VER >= 1400
+            _mm_pause();
+        #else
+            #if defined(__DMC__)
+                /* Digital Mars does not recognize the PAUSE opcode. Fall back to NOP. */
+                __asm nop;
+            #else
+                __asm pause;
+            #endif
+        #endif
+    #else
+        __asm__ __volatile__ ("rep; nop");
+    #endif
+#elif (defined(__arm__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7) || defined(_M_ARM64) || (defined(_M_ARM) && _M_ARM >= 7) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6T2__)
+    /* ARM */
+    #if defined(_MSC_VER)
+        /* Apparently there is a __yield() intrinsic that's compatible with ARM, but I cannot find documentation for it nor can I find where it's declared. */
+        __yield();
+    #else
+        __asm__ __volatile__ ("yield"); /* ARMv6K/ARMv6T2 and above. */
+    #endif
+#else
+    /* Unknown or unsupported architecture. No-op. */
+#endif
+}
+
+
+#define MA_MM_DENORMALS_ZERO_MASK   0x0040
+#define MA_MM_FLUSH_ZERO_MASK       0x8000
+
+static MA_INLINE unsigned int ma_disable_denormals(void)
+{
+    unsigned int prevState;
+
+    #if defined(_MSC_VER) && !defined(MA_XBOX_NXDK)
+    {
+        /*
+        Older versions of Visual Studio don't support the "safe" versions of _controlfp_s(). I don't
+        know which version of Visual Studio first added support for _controlfp_s(), but I do know
+        that VC6 lacks support. _MSC_VER = 1200 is VC6, but if you get compilation errors on older
+        versions of Visual Studio, let me know and I'll make the necessary adjustment.
+        */
+        #if _MSC_VER <= 1200
+        {
+            prevState = _statusfp();
+            _controlfp(prevState | _DN_FLUSH, _MCW_DN);
+        }
+        #else
+        {
+            unsigned int unused;
+            _controlfp_s(&prevState, 0, 0);
+            _controlfp_s(&unused, prevState | _DN_FLUSH, _MCW_DN);
+        }
+        #endif
+    }
+    #elif defined(MA_X86) || defined(MA_X64)
+    {
+        #if defined(MA_SUPPORT_SSE2) && defined(__SSE2__) && !(defined(__TINYC__) || defined(__WATCOMC__) || defined(__COSMOPOLITAN__)) /* <-- Add compilers that lack support for _mm_getcsr() and _mm_setcsr() to this list. */
+        {
+            prevState = _mm_getcsr();
+            _mm_setcsr(prevState | MA_MM_DENORMALS_ZERO_MASK | MA_MM_FLUSH_ZERO_MASK);
+        }
+        #else
+        {
+            /* x88/64, but no support for _mm_getcsr()/_mm_setcsr(). May need to fall back to inlined assembly here. */
+            prevState = 0;
+        }
+        #endif
+    }
+    #else
+    {
+        /* Unknown or unsupported architecture. No-op. */
+        prevState = 0;
+    }
+    #endif
+
+    return prevState;
+}
+
+static MA_INLINE void ma_restore_denormals(unsigned int prevState)
+{
+    #if defined(_MSC_VER) && !defined(MA_XBOX_NXDK)
+    {
+        /* Older versions of Visual Studio do not support _controlfp_s(). See ma_disable_denormals(). */
+        #if _MSC_VER <= 1200
+        {
+            _controlfp(prevState, _MCW_DN);
+        }
+        #else
+        {
+            unsigned int unused;
+            _controlfp_s(&unused, prevState, _MCW_DN);
+        }
+        #endif
+    }
+    #elif defined(MA_X86) || defined(MA_X64)
+    {
+        #if defined(MA_SUPPORT_SSE2) && defined(__SSE2__) && !(defined(__TINYC__) || defined(__WATCOMC__) || defined(__COSMOPOLITAN__))   /* <-- Add compilers that lack support for _mm_getcsr() and _mm_setcsr() to this list. */
+        {
+            _mm_setcsr(prevState);
+        }
+        #else
+        {
+            /* x88/64, but no support for _mm_getcsr()/_mm_setcsr(). May need to fall back to inlined assembly here. */
+            (void)prevState;
+        }
+        #endif
+    }
+    #else
+    {
+        /* Unknown or unsupported architecture. No-op. */
+        (void)prevState;
+    }
+    #endif
+}
+
+
+#ifdef MA_ANDROID
+#include <sys/system_properties.h>
+
+int ma_android_sdk_version()
+{
+    char sdkVersion[PROP_VALUE_MAX + 1] = {0, };
+    if (__system_property_get("ro.build.version.sdk", sdkVersion)) {
+        return atoi(sdkVersion);
+    }
+
+    return 0;
+}
+#endif
+
+
+#ifndef MA_COINIT_VALUE
+#define MA_COINIT_VALUE    0   /* 0 = COINIT_MULTITHREADED */
+#endif
+
+
+#ifndef MA_FLT_MAX
+    #ifdef FLT_MAX
+        #define MA_FLT_MAX FLT_MAX
+    #else
+        #define MA_FLT_MAX 3.402823466e+38F
+    #endif
+#endif
+
+
+#ifndef MA_PI
+#define MA_PI      3.14159265358979323846264f
+#endif
+#ifndef MA_PI_D
+#define MA_PI_D    3.14159265358979323846264
+#endif
+#ifndef MA_TAU
+#define MA_TAU     6.28318530717958647693f
+#endif
+#ifndef MA_TAU_D
+#define MA_TAU_D   6.28318530717958647693
+#endif
+
+
+/* The default format when ma_format_unknown (0) is requested when initializing a device. */
+#ifndef MA_DEFAULT_FORMAT
+#define MA_DEFAULT_FORMAT                                   ma_format_f32
+#endif
+
+/* The default channel count to use when 0 is used when initializing a device. */
+#ifndef MA_DEFAULT_CHANNELS
+#define MA_DEFAULT_CHANNELS                                 2
+#endif
+
+/* The default sample rate to use when 0 is used when initializing a device. */
+#ifndef MA_DEFAULT_SAMPLE_RATE
+#define MA_DEFAULT_SAMPLE_RATE                              48000
+#endif
+
+/* Default periods when none is specified in ma_device_init(). More periods means more work on the CPU. */
+#ifndef MA_DEFAULT_PERIODS
+#define MA_DEFAULT_PERIODS                                  3
+#endif
+
+/* The default period size in milliseconds for low latency mode. */
+#ifndef MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY
+#define MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY  10
+#endif
+
+/* The default buffer size in milliseconds for conservative mode. */
+#ifndef MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE
+#define MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE 100
+#endif
+
+/* The default LPF filter order for linear resampling. Note that this is clamped to MA_MAX_FILTER_ORDER. */
+#ifndef MA_DEFAULT_RESAMPLER_LPF_ORDER
+    #if MA_MAX_FILTER_ORDER >= 4
+        #define MA_DEFAULT_RESAMPLER_LPF_ORDER  4
+    #else
+        #define MA_DEFAULT_RESAMPLER_LPF_ORDER  MA_MAX_FILTER_ORDER
+    #endif
+#endif
+
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+/* Standard sample rates, in order of priority. */
+static ma_uint32 g_maStandardSampleRatePriorities[] = {
+    (ma_uint32)ma_standard_sample_rate_48000,
+    (ma_uint32)ma_standard_sample_rate_44100,
+
+    (ma_uint32)ma_standard_sample_rate_32000,
+    (ma_uint32)ma_standard_sample_rate_24000,
+    (ma_uint32)ma_standard_sample_rate_22050,
+
+    (ma_uint32)ma_standard_sample_rate_88200,
+    (ma_uint32)ma_standard_sample_rate_96000,
+    (ma_uint32)ma_standard_sample_rate_176400,
+    (ma_uint32)ma_standard_sample_rate_192000,
+
+    (ma_uint32)ma_standard_sample_rate_16000,
+    (ma_uint32)ma_standard_sample_rate_11025,
+    (ma_uint32)ma_standard_sample_rate_8000,
+
+    (ma_uint32)ma_standard_sample_rate_352800,
+    (ma_uint32)ma_standard_sample_rate_384000
+};
+
+static MA_INLINE ma_bool32 ma_is_standard_sample_rate(ma_uint32 sampleRate)
+{
+    ma_uint32 iSampleRate;
+
+    for (iSampleRate = 0; iSampleRate < sizeof(g_maStandardSampleRatePriorities) / sizeof(g_maStandardSampleRatePriorities[0]); iSampleRate += 1) {
+        if (g_maStandardSampleRatePriorities[iSampleRate] == sampleRate) {
+            return MA_TRUE;
+        }
+    }
+
+    /* Getting here means the sample rate is not supported. */
+    return MA_FALSE;
+}
+
+
+static ma_format g_maFormatPriorities[] = {
+    ma_format_s16,         /* Most common */
+    ma_format_f32,
+
+    /*ma_format_s24_32,*/    /* Clean alignment */
+    ma_format_s32,
+
+    ma_format_s24,         /* Unclean alignment */
+
+    ma_format_u8           /* Low quality */
+};
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic pop
+#endif
+
+
+MA_API void ma_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision)
+{
+    if (pMajor) {
+        *pMajor = MA_VERSION_MAJOR;
+    }
+
+    if (pMinor) {
+        *pMinor = MA_VERSION_MINOR;
+    }
+
+    if (pRevision) {
+        *pRevision = MA_VERSION_REVISION;
+    }
+}
+
+MA_API const char* ma_version_string(void)
+{
+    return MA_VERSION_STRING;
+}
+
+
+/******************************************************************************
+
+Standard Library Stuff
+
+******************************************************************************/
+#ifndef MA_ASSERT
+#define MA_ASSERT(condition)            assert(condition)
+#endif
+
+#ifndef MA_MALLOC
+#define MA_MALLOC(sz)                   malloc((sz))
+#endif
+#ifndef MA_REALLOC
+#define MA_REALLOC(p, sz)               realloc((p), (sz))
+#endif
+#ifndef MA_FREE
+#define MA_FREE(p)                      free((p))
+#endif
+
+static MA_INLINE void ma_zero_memory_default(void* p, size_t sz)
+{
+    if (p == NULL) {
+        MA_ASSERT(sz == 0); /* If this is triggered there's an error with the calling code. */
+        return;
+    }
+
+    if (sz > 0) {
+        memset(p, 0, sz);
+    }
+}
+
+
+#ifndef MA_ZERO_MEMORY
+#define MA_ZERO_MEMORY(p, sz)           ma_zero_memory_default((p), (sz))
+#endif
+#ifndef MA_COPY_MEMORY
+#define MA_COPY_MEMORY(dst, src, sz)    memcpy((dst), (src), (sz))
+#endif
+#ifndef MA_MOVE_MEMORY
+#define MA_MOVE_MEMORY(dst, src, sz)    memmove((dst), (src), (sz))
+#endif
+
+#define MA_ZERO_OBJECT(p)               MA_ZERO_MEMORY((p), sizeof(*(p)))
+
+#define ma_countof(x)                   (sizeof(x) / sizeof(x[0]))
+#define ma_max(x, y)                    (((x) > (y)) ? (x) : (y))
+#define ma_min(x, y)                    (((x) < (y)) ? (x) : (y))
+#define ma_abs(x)                       (((x) > 0) ? (x) : -(x))
+#define ma_clamp(x, lo, hi)             (ma_max(lo, ma_min(x, hi)))
+#define ma_offset_ptr(p, offset)        (((ma_uint8*)(p)) + (offset))
+#define ma_align(x, a)                  (((x) + ((a)-1)) & ~((a)-1))
+#define ma_align_64(x)                  ma_align(x, 8)
+
+#define ma_buffer_frame_capacity(buffer, channels, format) (sizeof(buffer) / ma_get_bytes_per_sample(format) / (channels))
+
+static MA_INLINE double ma_sind(double x)
+{
+    /* TODO: Implement custom sin(x). */
+    return sin(x);
+}
+
+static MA_INLINE double ma_expd(double x)
+{
+    /* TODO: Implement custom exp(x). */
+    return exp(x);
+}
+
+static MA_INLINE double ma_logd(double x)
+{
+    /* TODO: Implement custom log(x). */
+    return log(x);
+}
+
+static MA_INLINE double ma_powd(double x, double y)
+{
+    /* TODO: Implement custom pow(x, y). */
+    return pow(x, y);
+}
+
+static MA_INLINE double ma_sqrtd(double x)
+{
+    /* TODO: Implement custom sqrt(x). */
+    return sqrt(x);
+}
+
+
+static MA_INLINE float ma_rsqrtf(float x)
+{
+    #if defined(MA_SUPPORT_SSE2) && !defined(MA_NO_SSE2) && (defined(MA_X64) || (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__))
+    {
+        /*
+        For SSE we can use RSQRTSS.
+
+        This Stack Overflow post suggests that compilers don't necessarily generate optimal code
+        when using intrinsics:
+
+            https://web.archive.org/web/20221211012522/https://stackoverflow.com/questions/32687079/getting-fewest-instructions-for-rsqrtss-wrapper
+
+        I'm going to do something similar here, but a bit simpler.
+        */
+        #if defined(__GNUC__) || defined(__clang__)
+        {
+            float result;
+            __asm__ __volatile__("rsqrtss %1, %0" : "=x"(result) : "x"(x));
+            return result;
+        }
+        #else
+        {
+            return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ps1(x)));
+        }
+        #endif
+    }
+    #else
+    {
+        return 1 / (float)ma_sqrtd(x);
+    }
+    #endif
+}
+
+
+static MA_INLINE float ma_sinf(float x)
+{
+    return (float)ma_sind((float)x);
+}
+
+static MA_INLINE double ma_cosd(double x)
+{
+    return ma_sind((MA_PI_D*0.5) - x);
+}
+
+static MA_INLINE float ma_cosf(float x)
+{
+    return (float)ma_cosd((float)x);
+}
+
+static MA_INLINE double ma_log10d(double x)
+{
+    return ma_logd(x) * 0.43429448190325182765;
+}
+
+static MA_INLINE float ma_powf(float x, float y)
+{
+    return (float)ma_powd((double)x, (double)y);
+}
+
+static MA_INLINE float ma_log10f(float x)
+{
+    return (float)ma_log10d((double)x);
+}
+
+
+static MA_INLINE double ma_degrees_to_radians(double degrees)
+{
+    return degrees * 0.01745329252;
+}
+
+static MA_INLINE double ma_radians_to_degrees(double radians)
+{
+    return radians * 57.295779512896;
+}
+
+static MA_INLINE float ma_degrees_to_radians_f(float degrees)
+{
+    return degrees * 0.01745329252f;
+}
+
+static MA_INLINE float ma_radians_to_degrees_f(float radians)
+{
+    return radians * 57.295779512896f;
+}
+
+
+/*
+Return Values:
+  0:  Success
+  22: EINVAL
+  34: ERANGE
+
+Not using symbolic constants for errors because I want to avoid #including errno.h
+
+These are marked as no-inline because of some bad code generation by Clang. None of these functions
+are used in any performance-critical code within miniaudio.
+*/
+MA_API MA_NO_INLINE int ma_strcpy_s(char* dst, size_t dstSizeInBytes, const char* src)
+{
+    size_t i;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstSizeInBytes == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    for (i = 0; i < dstSizeInBytes && src[i] != '\0'; ++i) {
+        dst[i] = src[i];
+    }
+
+    if (i < dstSizeInBytes) {
+        dst[i] = '\0';
+        return 0;
+    }
+
+    dst[0] = '\0';
+    return 34;
+}
+
+MA_API MA_NO_INLINE int ma_wcscpy_s(wchar_t* dst, size_t dstCap, const wchar_t* src)
+{
+    size_t i;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstCap == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    for (i = 0; i < dstCap && src[i] != '\0'; ++i) {
+        dst[i] = src[i];
+    }
+
+    if (i < dstCap) {
+        dst[i] = '\0';
+        return 0;
+    }
+
+    dst[0] = '\0';
+    return 34;
+}
+
+
+MA_API MA_NO_INLINE int ma_strncpy_s(char* dst, size_t dstSizeInBytes, const char* src, size_t count)
+{
+    size_t maxcount;
+    size_t i;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstSizeInBytes == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    maxcount = count;
+    if (count == ((size_t)-1) || count >= dstSizeInBytes) {        /* -1 = _TRUNCATE */
+        maxcount = dstSizeInBytes - 1;
+    }
+
+    for (i = 0; i < maxcount && src[i] != '\0'; ++i) {
+        dst[i] = src[i];
+    }
+
+    if (src[i] == '\0' || i == count || count == ((size_t)-1)) {
+        dst[i] = '\0';
+        return 0;
+    }
+
+    dst[0] = '\0';
+    return 34;
+}
+
+MA_API MA_NO_INLINE int ma_strcat_s(char* dst, size_t dstSizeInBytes, const char* src)
+{
+    char* dstorig;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstSizeInBytes == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    dstorig = dst;
+
+    while (dstSizeInBytes > 0 && dst[0] != '\0') {
+        dst += 1;
+        dstSizeInBytes -= 1;
+    }
+
+    if (dstSizeInBytes == 0) {
+        return 22;  /* Unterminated. */
+    }
+
+
+    while (dstSizeInBytes > 0 && src[0] != '\0') {
+        *dst++ = *src++;
+        dstSizeInBytes -= 1;
+    }
+
+    if (dstSizeInBytes > 0) {
+        dst[0] = '\0';
+    } else {
+        dstorig[0] = '\0';
+        return 34;
+    }
+
+    return 0;
+}
+
+MA_API MA_NO_INLINE int ma_strncat_s(char* dst, size_t dstSizeInBytes, const char* src, size_t count)
+{
+    char* dstorig;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstSizeInBytes == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        return 22;
+    }
+
+    dstorig = dst;
+
+    while (dstSizeInBytes > 0 && dst[0] != '\0') {
+        dst += 1;
+        dstSizeInBytes -= 1;
+    }
+
+    if (dstSizeInBytes == 0) {
+        return 22;  /* Unterminated. */
+    }
+
+
+    if (count == ((size_t)-1)) {        /* _TRUNCATE */
+        count = dstSizeInBytes - 1;
+    }
+
+    while (dstSizeInBytes > 0 && src[0] != '\0' && count > 0) {
+        *dst++ = *src++;
+        dstSizeInBytes -= 1;
+        count -= 1;
+    }
+
+    if (dstSizeInBytes > 0) {
+        dst[0] = '\0';
+    } else {
+        dstorig[0] = '\0';
+        return 34;
+    }
+
+    return 0;
+}
+
+MA_API MA_NO_INLINE int ma_itoa_s(int value, char* dst, size_t dstSizeInBytes, int radix)
+{
+    int sign;
+    unsigned int valueU;
+    char* dstEnd;
+
+    if (dst == NULL || dstSizeInBytes == 0) {
+        return 22;
+    }
+    if (radix < 2 || radix > 36) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    sign = (value < 0 && radix == 10) ? -1 : 1;     /* The negative sign is only used when the base is 10. */
+
+    if (value < 0) {
+        valueU = -value;
+    } else {
+        valueU = value;
+    }
+
+    dstEnd = dst;
+    do
+    {
+        int remainder = valueU % radix;
+        if (remainder > 9) {
+            *dstEnd = (char)((remainder - 10) + 'a');
+        } else {
+            *dstEnd = (char)(remainder + '0');
+        }
+
+        dstEnd += 1;
+        dstSizeInBytes -= 1;
+        valueU /= radix;
+    } while (dstSizeInBytes > 0 && valueU > 0);
+
+    if (dstSizeInBytes == 0) {
+        dst[0] = '\0';
+        return 22;  /* Ran out of room in the output buffer. */
+    }
+
+    if (sign < 0) {
+        *dstEnd++ = '-';
+        dstSizeInBytes -= 1;
+    }
+
+    if (dstSizeInBytes == 0) {
+        dst[0] = '\0';
+        return 22;  /* Ran out of room in the output buffer. */
+    }
+
+    *dstEnd = '\0';
+
+
+    /* At this point the string will be reversed. */
+    dstEnd -= 1;
+    while (dst < dstEnd) {
+        char temp = *dst;
+        *dst = *dstEnd;
+        *dstEnd = temp;
+
+        dst += 1;
+        dstEnd -= 1;
+    }
+
+    return 0;
+}
+
+MA_API MA_NO_INLINE int ma_strcmp(const char* str1, const char* str2)
+{
+    if (str1 == str2) return  0;
+
+    /* These checks differ from the standard implementation. It's not important, but I prefer it just for sanity. */
+    if (str1 == NULL) return -1;
+    if (str2 == NULL) return  1;
+
+    for (;;) {
+        if (str1[0] == '\0') {
+            break;
+        }
+        if (str1[0] != str2[0]) {
+            break;
+        }
+
+        str1 += 1;
+        str2 += 1;
+    }
+
+    return ((unsigned char*)str1)[0] - ((unsigned char*)str2)[0];
+}
+
+MA_API MA_NO_INLINE int ma_wcscmp(const wchar_t* str1, const wchar_t* str2)
+{
+    if (str1 == str2) return  0;
+
+    /* These checks differ from the standard implementation. It's not important, but I prefer it just for sanity. */
+    if (str1 == NULL) return -1;
+    if (str2 == NULL) return  1;
+
+    for (;;) {
+        if (str1[0] == L'\0') {
+            break;
+        }
+        if (str1[0] != str2[0]) {
+            break;
+        }
+
+        str1 += 1;
+        str2 += 1;
+    }
+
+    return ((unsigned short*)str1)[0] - ((unsigned short*)str2)[0];
+}
+
+MA_API MA_NO_INLINE int ma_strappend(char* dst, size_t dstSize, const char* srcA, const char* srcB)
+{
+    int result;
+
+    result = ma_strncpy_s(dst, dstSize, srcA, (size_t)-1);
+    if (result != 0) {
+        return result;
+    }
+
+    result = ma_strncat_s(dst, dstSize, srcB, (size_t)-1);
+    if (result != 0) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API MA_NO_INLINE size_t ma_wcslen(const wchar_t* str)
+{
+    const wchar_t* end;
+
+    if (str == NULL) {
+        return 0;
+    }
+
+    end = str;
+    while (end[0] != '\0') {
+        end += 1;
+    }
+
+    return end - str;
+}
+
+MA_API MA_NO_INLINE char* ma_copy_string(const char* src, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    size_t sz;
+    char* dst;
+
+    if (src == NULL) {
+        return NULL;
+    }
+
+    sz = strlen(src)+1;
+    dst = (char*)ma_malloc(sz, pAllocationCallbacks);
+    if (dst == NULL) {
+        return NULL;
+    }
+
+    ma_strcpy_s(dst, sz, src);
+
+    return dst;
+}
+
+MA_API MA_NO_INLINE wchar_t* ma_copy_string_w(const wchar_t* src, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    size_t sz = ma_wcslen(src)+1;
+    wchar_t* dst = (wchar_t*)ma_malloc(sz * sizeof(*dst), pAllocationCallbacks);
+    if (dst == NULL) {
+        return NULL;
+    }
+
+    ma_wcscpy_s(dst, sz, src);
+
+    return dst;
+}
+
+
+
+#include <errno.h>
+static ma_result ma_result_from_errno(int e)
+{
+    if (e == 0) {
+        return MA_SUCCESS;
+    }
+#ifdef EPERM
+    else if (e == EPERM) { return MA_INVALID_OPERATION; }
+#endif
+#ifdef ENOENT
+    else if (e == ENOENT) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef ESRCH
+    else if (e == ESRCH) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef EINTR
+    else if (e == EINTR) { return MA_INTERRUPT; }
+#endif
+#ifdef EIO
+    else if (e == EIO) { return MA_IO_ERROR; }
+#endif
+#ifdef ENXIO
+    else if (e == ENXIO) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef E2BIG
+    else if (e == E2BIG) { return MA_INVALID_ARGS; }
+#endif
+#ifdef ENOEXEC
+    else if (e == ENOEXEC) { return MA_INVALID_FILE; }
+#endif
+#ifdef EBADF
+    else if (e == EBADF) { return MA_INVALID_FILE; }
+#endif
+#ifdef ECHILD
+    else if (e == ECHILD) { return MA_ERROR; }
+#endif
+#ifdef EAGAIN
+    else if (e == EAGAIN) { return MA_UNAVAILABLE; }
+#endif
+#ifdef ENOMEM
+    else if (e == ENOMEM) { return MA_OUT_OF_MEMORY; }
+#endif
+#ifdef EACCES
+    else if (e == EACCES) { return MA_ACCESS_DENIED; }
+#endif
+#ifdef EFAULT
+    else if (e == EFAULT) { return MA_BAD_ADDRESS; }
+#endif
+#ifdef ENOTBLK
+    else if (e == ENOTBLK) { return MA_ERROR; }
+#endif
+#ifdef EBUSY
+    else if (e == EBUSY) { return MA_BUSY; }
+#endif
+#ifdef EEXIST
+    else if (e == EEXIST) { return MA_ALREADY_EXISTS; }
+#endif
+#ifdef EXDEV
+    else if (e == EXDEV) { return MA_ERROR; }
+#endif
+#ifdef ENODEV
+    else if (e == ENODEV) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef ENOTDIR
+    else if (e == ENOTDIR) { return MA_NOT_DIRECTORY; }
+#endif
+#ifdef EISDIR
+    else if (e == EISDIR) { return MA_IS_DIRECTORY; }
+#endif
+#ifdef EINVAL
+    else if (e == EINVAL) { return MA_INVALID_ARGS; }
+#endif
+#ifdef ENFILE
+    else if (e == ENFILE) { return MA_TOO_MANY_OPEN_FILES; }
+#endif
+#ifdef EMFILE
+    else if (e == EMFILE) { return MA_TOO_MANY_OPEN_FILES; }
+#endif
+#ifdef ENOTTY
+    else if (e == ENOTTY) { return MA_INVALID_OPERATION; }
+#endif
+#ifdef ETXTBSY
+    else if (e == ETXTBSY) { return MA_BUSY; }
+#endif
+#ifdef EFBIG
+    else if (e == EFBIG) { return MA_TOO_BIG; }
+#endif
+#ifdef ENOSPC
+    else if (e == ENOSPC) { return MA_NO_SPACE; }
+#endif
+#ifdef ESPIPE
+    else if (e == ESPIPE) { return MA_BAD_SEEK; }
+#endif
+#ifdef EROFS
+    else if (e == EROFS) { return MA_ACCESS_DENIED; }
+#endif
+#ifdef EMLINK
+    else if (e == EMLINK) { return MA_TOO_MANY_LINKS; }
+#endif
+#ifdef EPIPE
+    else if (e == EPIPE) { return MA_BAD_PIPE; }
+#endif
+#ifdef EDOM
+    else if (e == EDOM) { return MA_OUT_OF_RANGE; }
+#endif
+#ifdef ERANGE
+    else if (e == ERANGE) { return MA_OUT_OF_RANGE; }
+#endif
+#ifdef EDEADLK
+    else if (e == EDEADLK) { return MA_DEADLOCK; }
+#endif
+#ifdef ENAMETOOLONG
+    else if (e == ENAMETOOLONG) { return MA_PATH_TOO_LONG; }
+#endif
+#ifdef ENOLCK
+    else if (e == ENOLCK) { return MA_ERROR; }
+#endif
+#ifdef ENOSYS
+    else if (e == ENOSYS) { return MA_NOT_IMPLEMENTED; }
+#endif
+#ifdef ENOTEMPTY
+    else if (e == ENOTEMPTY) { return MA_DIRECTORY_NOT_EMPTY; }
+#endif
+#ifdef ELOOP
+    else if (e == ELOOP) { return MA_TOO_MANY_LINKS; }
+#endif
+#ifdef ENOMSG
+    else if (e == ENOMSG) { return MA_NO_MESSAGE; }
+#endif
+#ifdef EIDRM
+    else if (e == EIDRM) { return MA_ERROR; }
+#endif
+#ifdef ECHRNG
+    else if (e == ECHRNG) { return MA_ERROR; }
+#endif
+#ifdef EL2NSYNC
+    else if (e == EL2NSYNC) { return MA_ERROR; }
+#endif
+#ifdef EL3HLT
+    else if (e == EL3HLT) { return MA_ERROR; }
+#endif
+#ifdef EL3RST
+    else if (e == EL3RST) { return MA_ERROR; }
+#endif
+#ifdef ELNRNG
+    else if (e == ELNRNG) { return MA_OUT_OF_RANGE; }
+#endif
+#ifdef EUNATCH
+    else if (e == EUNATCH) { return MA_ERROR; }
+#endif
+#ifdef ENOCSI
+    else if (e == ENOCSI) { return MA_ERROR; }
+#endif
+#ifdef EL2HLT
+    else if (e == EL2HLT) { return MA_ERROR; }
+#endif
+#ifdef EBADE
+    else if (e == EBADE) { return MA_ERROR; }
+#endif
+#ifdef EBADR
+    else if (e == EBADR) { return MA_ERROR; }
+#endif
+#ifdef EXFULL
+    else if (e == EXFULL) { return MA_ERROR; }
+#endif
+#ifdef ENOANO
+    else if (e == ENOANO) { return MA_ERROR; }
+#endif
+#ifdef EBADRQC
+    else if (e == EBADRQC) { return MA_ERROR; }
+#endif
+#ifdef EBADSLT
+    else if (e == EBADSLT) { return MA_ERROR; }
+#endif
+#ifdef EBFONT
+    else if (e == EBFONT) { return MA_INVALID_FILE; }
+#endif
+#ifdef ENOSTR
+    else if (e == ENOSTR) { return MA_ERROR; }
+#endif
+#ifdef ENODATA
+    else if (e == ENODATA) { return MA_NO_DATA_AVAILABLE; }
+#endif
+#ifdef ETIME
+    else if (e == ETIME) { return MA_TIMEOUT; }
+#endif
+#ifdef ENOSR
+    else if (e == ENOSR) { return MA_NO_DATA_AVAILABLE; }
+#endif
+#ifdef ENONET
+    else if (e == ENONET) { return MA_NO_NETWORK; }
+#endif
+#ifdef ENOPKG
+    else if (e == ENOPKG) { return MA_ERROR; }
+#endif
+#ifdef EREMOTE
+    else if (e == EREMOTE) { return MA_ERROR; }
+#endif
+#ifdef ENOLINK
+    else if (e == ENOLINK) { return MA_ERROR; }
+#endif
+#ifdef EADV
+    else if (e == EADV) { return MA_ERROR; }
+#endif
+#ifdef ESRMNT
+    else if (e == ESRMNT) { return MA_ERROR; }
+#endif
+#ifdef ECOMM
+    else if (e == ECOMM) { return MA_ERROR; }
+#endif
+#ifdef EPROTO
+    else if (e == EPROTO) { return MA_ERROR; }
+#endif
+#ifdef EMULTIHOP
+    else if (e == EMULTIHOP) { return MA_ERROR; }
+#endif
+#ifdef EDOTDOT
+    else if (e == EDOTDOT) { return MA_ERROR; }
+#endif
+#ifdef EBADMSG
+    else if (e == EBADMSG) { return MA_BAD_MESSAGE; }
+#endif
+#ifdef EOVERFLOW
+    else if (e == EOVERFLOW) { return MA_TOO_BIG; }
+#endif
+#ifdef ENOTUNIQ
+    else if (e == ENOTUNIQ) { return MA_NOT_UNIQUE; }
+#endif
+#ifdef EBADFD
+    else if (e == EBADFD) { return MA_ERROR; }
+#endif
+#ifdef EREMCHG
+    else if (e == EREMCHG) { return MA_ERROR; }
+#endif
+#ifdef ELIBACC
+    else if (e == ELIBACC) { return MA_ACCESS_DENIED; }
+#endif
+#ifdef ELIBBAD
+    else if (e == ELIBBAD) { return MA_INVALID_FILE; }
+#endif
+#ifdef ELIBSCN
+    else if (e == ELIBSCN) { return MA_INVALID_FILE; }
+#endif
+#ifdef ELIBMAX
+    else if (e == ELIBMAX) { return MA_ERROR; }
+#endif
+#ifdef ELIBEXEC
+    else if (e == ELIBEXEC) { return MA_ERROR; }
+#endif
+#ifdef EILSEQ
+    else if (e == EILSEQ) { return MA_INVALID_DATA; }
+#endif
+#ifdef ERESTART
+    else if (e == ERESTART) { return MA_ERROR; }
+#endif
+#ifdef ESTRPIPE
+    else if (e == ESTRPIPE) { return MA_ERROR; }
+#endif
+#ifdef EUSERS
+    else if (e == EUSERS) { return MA_ERROR; }
+#endif
+#ifdef ENOTSOCK
+    else if (e == ENOTSOCK) { return MA_NOT_SOCKET; }
+#endif
+#ifdef EDESTADDRREQ
+    else if (e == EDESTADDRREQ) { return MA_NO_ADDRESS; }
+#endif
+#ifdef EMSGSIZE
+    else if (e == EMSGSIZE) { return MA_TOO_BIG; }
+#endif
+#ifdef EPROTOTYPE
+    else if (e == EPROTOTYPE) { return MA_BAD_PROTOCOL; }
+#endif
+#ifdef ENOPROTOOPT
+    else if (e == ENOPROTOOPT) { return MA_PROTOCOL_UNAVAILABLE; }
+#endif
+#ifdef EPROTONOSUPPORT
+    else if (e == EPROTONOSUPPORT) { return MA_PROTOCOL_NOT_SUPPORTED; }
+#endif
+#ifdef ESOCKTNOSUPPORT
+    else if (e == ESOCKTNOSUPPORT) { return MA_SOCKET_NOT_SUPPORTED; }
+#endif
+#ifdef EOPNOTSUPP
+    else if (e == EOPNOTSUPP) { return MA_INVALID_OPERATION; }
+#endif
+#ifdef EPFNOSUPPORT
+    else if (e == EPFNOSUPPORT) { return MA_PROTOCOL_FAMILY_NOT_SUPPORTED; }
+#endif
+#ifdef EAFNOSUPPORT
+    else if (e == EAFNOSUPPORT) { return MA_ADDRESS_FAMILY_NOT_SUPPORTED; }
+#endif
+#ifdef EADDRINUSE
+    else if (e == EADDRINUSE) { return MA_ALREADY_IN_USE; }
+#endif
+#ifdef EADDRNOTAVAIL
+    else if (e == EADDRNOTAVAIL) { return MA_ERROR; }
+#endif
+#ifdef ENETDOWN
+    else if (e == ENETDOWN) { return MA_NO_NETWORK; }
+#endif
+#ifdef ENETUNREACH
+    else if (e == ENETUNREACH) { return MA_NO_NETWORK; }
+#endif
+#ifdef ENETRESET
+    else if (e == ENETRESET) { return MA_NO_NETWORK; }
+#endif
+#ifdef ECONNABORTED
+    else if (e == ECONNABORTED) { return MA_NO_NETWORK; }
+#endif
+#ifdef ECONNRESET
+    else if (e == ECONNRESET) { return MA_CONNECTION_RESET; }
+#endif
+#ifdef ENOBUFS
+    else if (e == ENOBUFS) { return MA_NO_SPACE; }
+#endif
+#ifdef EISCONN
+    else if (e == EISCONN) { return MA_ALREADY_CONNECTED; }
+#endif
+#ifdef ENOTCONN
+    else if (e == ENOTCONN) { return MA_NOT_CONNECTED; }
+#endif
+#ifdef ESHUTDOWN
+    else if (e == ESHUTDOWN) { return MA_ERROR; }
+#endif
+#ifdef ETOOMANYREFS
+    else if (e == ETOOMANYREFS) { return MA_ERROR; }
+#endif
+#ifdef ETIMEDOUT
+    else if (e == ETIMEDOUT) { return MA_TIMEOUT; }
+#endif
+#ifdef ECONNREFUSED
+    else if (e == ECONNREFUSED) { return MA_CONNECTION_REFUSED; }
+#endif
+#ifdef EHOSTDOWN
+    else if (e == EHOSTDOWN) { return MA_NO_HOST; }
+#endif
+#ifdef EHOSTUNREACH
+    else if (e == EHOSTUNREACH) { return MA_NO_HOST; }
+#endif
+#ifdef EALREADY
+    else if (e == EALREADY) { return MA_IN_PROGRESS; }
+#endif
+#ifdef EINPROGRESS
+    else if (e == EINPROGRESS) { return MA_IN_PROGRESS; }
+#endif
+#ifdef ESTALE
+    else if (e == ESTALE) { return MA_INVALID_FILE; }
+#endif
+#ifdef EUCLEAN
+    else if (e == EUCLEAN) { return MA_ERROR; }
+#endif
+#ifdef ENOTNAM
+    else if (e == ENOTNAM) { return MA_ERROR; }
+#endif
+#ifdef ENAVAIL
+    else if (e == ENAVAIL) { return MA_ERROR; }
+#endif
+#ifdef EISNAM
+    else if (e == EISNAM) { return MA_ERROR; }
+#endif
+#ifdef EREMOTEIO
+    else if (e == EREMOTEIO) { return MA_IO_ERROR; }
+#endif
+#ifdef EDQUOT
+    else if (e == EDQUOT) { return MA_NO_SPACE; }
+#endif
+#ifdef ENOMEDIUM
+    else if (e == ENOMEDIUM) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef EMEDIUMTYPE
+    else if (e == EMEDIUMTYPE) { return MA_ERROR; }
+#endif
+#ifdef ECANCELED
+    else if (e == ECANCELED) { return MA_CANCELLED; }
+#endif
+#ifdef ENOKEY
+    else if (e == ENOKEY) { return MA_ERROR; }
+#endif
+#ifdef EKEYEXPIRED
+    else if (e == EKEYEXPIRED) { return MA_ERROR; }
+#endif
+#ifdef EKEYREVOKED
+    else if (e == EKEYREVOKED) { return MA_ERROR; }
+#endif
+#ifdef EKEYREJECTED
+    else if (e == EKEYREJECTED) { return MA_ERROR; }
+#endif
+#ifdef EOWNERDEAD
+    else if (e == EOWNERDEAD) { return MA_ERROR; }
+#endif
+#ifdef ENOTRECOVERABLE
+    else if (e == ENOTRECOVERABLE) { return MA_ERROR; }
+#endif
+#ifdef ERFKILL
+    else if (e == ERFKILL) { return MA_ERROR; }
+#endif
+#ifdef EHWPOISON
+    else if (e == EHWPOISON) { return MA_ERROR; }
+#endif
+    else {
+        return MA_ERROR;
+    }
+}
+
+MA_API ma_result ma_fopen(FILE** ppFile, const char* pFilePath, const char* pOpenMode)
+{
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    errno_t err;
+#endif
+
+    if (ppFile != NULL) {
+        *ppFile = NULL;  /* Safety. */
+    }
+
+    if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if (defined(_MSC_VER) && _MSC_VER >= 1400) && !defined(MA_XBOX_NXDK)
+    err = fopen_s(ppFile, pFilePath, pOpenMode);
+    if (err != 0) {
+        return ma_result_from_errno(err);
+    }
+#else
+#if defined(_WIN32) || defined(__APPLE__)
+    *ppFile = fopen(pFilePath, pOpenMode);
+#else
+    #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64 && defined(_LARGEFILE64_SOURCE)
+        *ppFile = fopen64(pFilePath, pOpenMode);
+    #else
+        *ppFile = fopen(pFilePath, pOpenMode);
+    #endif
+#endif
+    if (*ppFile == NULL) {
+        ma_result result = ma_result_from_errno(errno);
+        if (result == MA_SUCCESS) {
+            result = MA_ERROR;   /* Just a safety check to make sure we never ever return success when pFile == NULL. */
+        }
+
+        return result;
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+
+
+/*
+_wfopen() isn't always available in all compilation environments.
+
+    * Windows only.
+    * MSVC seems to support it universally as far back as VC6 from what I can tell (haven't checked further back).
+    * MinGW-64 (both 32- and 64-bit) seems to support it.
+    * MinGW wraps it in !defined(__STRICT_ANSI__).
+    * OpenWatcom wraps it in !defined(_NO_EXT_KEYS).
+
+This can be reviewed as compatibility issues arise. The preference is to use _wfopen_s() and _wfopen() as opposed to the wcsrtombs()
+fallback, so if you notice your compiler not detecting this properly I'm happy to look at adding support.
+*/
+#if defined(_WIN32) && !defined(MA_XBOX_NXDK)
+    #if defined(_MSC_VER) || defined(__MINGW64__) || (!defined(__STRICT_ANSI__) && !defined(_NO_EXT_KEYS))
+        #define MA_HAS_WFOPEN
+    #endif
+#endif
+
+MA_API ma_result ma_wfopen(FILE** ppFile, const wchar_t* pFilePath, const wchar_t* pOpenMode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (ppFile != NULL) {
+        *ppFile = NULL;  /* Safety. */
+    }
+
+    if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if defined(MA_HAS_WFOPEN)
+    {
+        /* Use _wfopen() on Windows. */
+        #if defined(_MSC_VER) && _MSC_VER >= 1400
+        {
+            errno_t err = _wfopen_s(ppFile, pFilePath, pOpenMode);
+            if (err != 0) {
+                return ma_result_from_errno(err);
+            }
+        }
+        #else
+        {
+            *ppFile = _wfopen(pFilePath, pOpenMode);
+            if (*ppFile == NULL) {
+                return ma_result_from_errno(errno);
+            }
+        }
+        #endif
+
+        (void)pAllocationCallbacks;
+    }
+    #elif !defined(MA_XBOX_NXDK) && !defined(MA_DOS)    /* If your compiler does not support wcsrtombs(), add it here. */
+    {
+        /*
+        Use fopen() on anything other than Windows. Requires a conversion. This is annoying because fopen() is locale specific. The only real way I can
+        think of to do this is with wcsrtombs(). Note that wcstombs() is apparently not thread-safe because it uses a static global mbstate_t object for
+        maintaining state. I've checked this with -std=c89 and it works, but if somebody get's a compiler error I'll look into improving compatibility.
+        */
+        mbstate_t mbs;
+        size_t lenMB;
+        const wchar_t* pFilePathTemp = pFilePath;
+        char* pFilePathMB = NULL;
+        char pOpenModeMB[32] = {0};
+
+        /* Get the length first. */
+        MA_ZERO_OBJECT(&mbs);
+        lenMB = wcsrtombs(NULL, &pFilePathTemp, 0, &mbs);
+        if (lenMB == (size_t)-1) {
+            return ma_result_from_errno(errno);
+        }
+
+        pFilePathMB = (char*)ma_malloc(lenMB + 1, pAllocationCallbacks);
+        if (pFilePathMB == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        pFilePathTemp = pFilePath;
+        MA_ZERO_OBJECT(&mbs);
+        wcsrtombs(pFilePathMB, &pFilePathTemp, lenMB + 1, &mbs);
+
+        /* The open mode should always consist of ASCII characters so we should be able to do a trivial conversion. */
+        {
+            size_t i = 0;
+            for (;;) {
+                if (pOpenMode[i] == 0) {
+                    pOpenModeMB[i] = '\0';
+                    break;
+                }
+
+                pOpenModeMB[i] = (char)pOpenMode[i];
+                i += 1;
+            }
+        }
+
+        *ppFile = fopen(pFilePathMB, pOpenModeMB);
+
+        ma_free(pFilePathMB, pAllocationCallbacks);
+    }
+    #else
+    {
+        /* Getting here means there is no way to open the file with a wide character string. */
+        *ppFile = NULL;
+    }
+    #endif
+
+    if (*ppFile == NULL) {
+        return MA_ERROR;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+static MA_INLINE void ma_copy_memory_64(void* dst, const void* src, ma_uint64 sizeInBytes)
+{
+#if MA_SIZE_MAX > 0xFFFFFFFF
+    MA_COPY_MEMORY(dst, src, (size_t)sizeInBytes);
+#else
+    while (sizeInBytes > 0) {
+        ma_uint64 bytesToCopyNow = sizeInBytes;
+        if (bytesToCopyNow > MA_SIZE_MAX) {
+            bytesToCopyNow = MA_SIZE_MAX;
+        }
+
+        MA_COPY_MEMORY(dst, src, (size_t)bytesToCopyNow);  /* Safe cast to size_t. */
+
+        sizeInBytes -= bytesToCopyNow;
+        dst = (      void*)((      ma_uint8*)dst + bytesToCopyNow);
+        src = (const void*)((const ma_uint8*)src + bytesToCopyNow);
+    }
+#endif
+}
+
+static MA_INLINE void ma_zero_memory_64(void* dst, ma_uint64 sizeInBytes)
+{
+#if MA_SIZE_MAX > 0xFFFFFFFF
+    MA_ZERO_MEMORY(dst, (size_t)sizeInBytes);
+#else
+    while (sizeInBytes > 0) {
+        ma_uint64 bytesToZeroNow = sizeInBytes;
+        if (bytesToZeroNow > MA_SIZE_MAX) {
+            bytesToZeroNow = MA_SIZE_MAX;
+        }
+
+        MA_ZERO_MEMORY(dst, (size_t)bytesToZeroNow);  /* Safe cast to size_t. */
+
+        sizeInBytes -= bytesToZeroNow;
+        dst = (void*)((ma_uint8*)dst + bytesToZeroNow);
+    }
+#endif
+}
+
+
+/* Thanks to good old Bit Twiddling Hacks for this one: http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 */
+static MA_INLINE unsigned int ma_next_power_of_2(unsigned int x)
+{
+    x--;
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+    x++;
+
+    return x;
+}
+
+static MA_INLINE unsigned int ma_prev_power_of_2(unsigned int x)
+{
+    return ma_next_power_of_2(x) >> 1;
+}
+
+static MA_INLINE unsigned int ma_round_to_power_of_2(unsigned int x)
+{
+    unsigned int prev = ma_prev_power_of_2(x);
+    unsigned int next = ma_next_power_of_2(x);
+    if ((next - x) > (x - prev)) {
+        return prev;
+    } else {
+        return next;
+    }
+}
+
+static MA_INLINE unsigned int ma_count_set_bits(unsigned int x)
+{
+    unsigned int count = 0;
+    while (x != 0) {
+        if (x & 1) {
+            count += 1;
+        }
+
+        x = x >> 1;
+    }
+
+    return count;
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Allocation Callbacks
+
+**************************************************************************************************************************************************************/
+static void* ma__malloc_default(size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_MALLOC(sz);
+}
+
+static void* ma__realloc_default(void* p, size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_REALLOC(p, sz);
+}
+
+static void ma__free_default(void* p, void* pUserData)
+{
+    (void)pUserData;
+    MA_FREE(p);
+}
+
+static ma_allocation_callbacks ma_allocation_callbacks_init_default(void)
+{
+    ma_allocation_callbacks callbacks;
+    callbacks.pUserData = NULL;
+    callbacks.onMalloc  = ma__malloc_default;
+    callbacks.onRealloc = ma__realloc_default;
+    callbacks.onFree    = ma__free_default;
+
+    return callbacks;
+}
+
+static ma_result ma_allocation_callbacks_init_copy(ma_allocation_callbacks* pDst, const ma_allocation_callbacks* pSrc)
+{
+    if (pDst == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pSrc == NULL) {
+        *pDst = ma_allocation_callbacks_init_default();
+    } else {
+        if (pSrc->pUserData == NULL && pSrc->onFree == NULL && pSrc->onMalloc == NULL && pSrc->onRealloc == NULL) {
+            *pDst = ma_allocation_callbacks_init_default();
+        } else {
+            if (pSrc->onFree == NULL || (pSrc->onMalloc == NULL && pSrc->onRealloc == NULL)) {
+                return MA_INVALID_ARGS;    /* Invalid allocation callbacks. */
+            } else {
+                *pDst = *pSrc;
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+
+/**************************************************************************************************************************************************************
+
+Logging
+
+**************************************************************************************************************************************************************/
+#ifndef ma_va_copy
+    #if !defined(_MSC_VER) || _MSC_VER >= 1800
+        #if (defined(__GNUC__) && __GNUC__ < 3)
+            #define ma_va_copy(dst, src) ((dst) = (src))    /* This is untested. Not sure if this is correct for old GCC. */
+        #else
+            #define ma_va_copy(dst, src) va_copy((dst), (src))
+        #endif
+    #else
+        #define ma_va_copy(dst, src) ((dst) = (src))
+    #endif
+#endif
+
+MA_API const char* ma_log_level_to_string(ma_uint32 logLevel)
+{
+    switch (logLevel)
+    {
+        case MA_LOG_LEVEL_DEBUG:   return "DEBUG";
+        case MA_LOG_LEVEL_INFO:    return "INFO";
+        case MA_LOG_LEVEL_WARNING: return "WARNING";
+        case MA_LOG_LEVEL_ERROR:   return "ERROR";
+        default:                   return "ERROR";
+    }
+}
+
+#if defined(MA_DEBUG_OUTPUT)
+#if defined(MA_ANDROID)
+    #include <android/log.h>
+#endif
+
+/* Customize this to use a specific tag in __android_log_print() for debug output messages. */
+#ifndef MA_ANDROID_LOG_TAG
+#define MA_ANDROID_LOG_TAG  "miniaudio"
+#endif
+
+void ma_log_callback_debug(void* pUserData, ma_uint32 level, const char* pMessage)
+{
+    (void)pUserData;
+
+    /* Special handling for some platforms. */
+    #if defined(MA_ANDROID)
+    {
+        /* Android. */
+        __android_log_print(ANDROID_LOG_DEBUG, MA_ANDROID_LOG_TAG, "%s: %s", ma_log_level_to_string(level), pMessage);
+    }
+    #else
+    {
+        /* Everything else. */
+        printf("%s: %s", ma_log_level_to_string(level), pMessage);
+    }
+    #endif
+}
+#endif
+
+MA_API ma_log_callback ma_log_callback_init(ma_log_callback_proc onLog, void* pUserData)
+{
+    ma_log_callback callback;
+
+    MA_ZERO_OBJECT(&callback);
+    callback.onLog     = onLog;
+    callback.pUserData = pUserData;
+
+    return callback;
+}
+
+
+MA_API ma_result ma_log_init(const ma_allocation_callbacks* pAllocationCallbacks, ma_log* pLog)
+{
+    if (pLog == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLog);
+    ma_allocation_callbacks_init_copy(&pLog->allocationCallbacks, pAllocationCallbacks);
+
+    /* We need a mutex for thread safety. */
+    #ifndef MA_NO_THREADING
+    {
+        ma_result result = ma_mutex_init(&pLog->lock);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+    #endif
+
+    /* If we're using debug output, enable it. */
+    #if defined(MA_DEBUG_OUTPUT)
+    {
+        ma_log_register_callback(pLog, ma_log_callback_init(ma_log_callback_debug, NULL)); /* Doesn't really matter if this fails. */
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_log_uninit(ma_log* pLog)
+{
+    if (pLog == NULL) {
+        return;
+    }
+
+#ifndef MA_NO_THREADING
+    ma_mutex_uninit(&pLog->lock);
+#endif
+}
+
+static void ma_log_lock(ma_log* pLog)
+{
+#ifndef MA_NO_THREADING
+    ma_mutex_lock(&pLog->lock);
+#else
+    (void)pLog;
+#endif
+}
+
+static void ma_log_unlock(ma_log* pLog)
+{
+#ifndef MA_NO_THREADING
+    ma_mutex_unlock(&pLog->lock);
+#else
+    (void)pLog;
+#endif
+}
+
+MA_API ma_result ma_log_register_callback(ma_log* pLog, ma_log_callback callback)
+{
+    ma_result result = MA_SUCCESS;
+
+    if (pLog == NULL || callback.onLog == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_log_lock(pLog);
+    {
+        if (pLog->callbackCount == ma_countof(pLog->callbacks)) {
+            result = MA_OUT_OF_MEMORY;  /* Reached the maximum allowed log callbacks. */
+        } else {
+            pLog->callbacks[pLog->callbackCount] = callback;
+            pLog->callbackCount += 1;
+        }
+    }
+    ma_log_unlock(pLog);
+
+    return result;
+}
+
+MA_API ma_result ma_log_unregister_callback(ma_log* pLog, ma_log_callback callback)
+{
+    if (pLog == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_log_lock(pLog);
+    {
+        ma_uint32 iLog;
+        for (iLog = 0; iLog < pLog->callbackCount; ) {
+            if (pLog->callbacks[iLog].onLog == callback.onLog) {
+                /* Found. Move everything down a slot. */
+                ma_uint32 jLog;
+                for (jLog = iLog; jLog < pLog->callbackCount-1; jLog += 1) {
+                    pLog->callbacks[jLog] = pLog->callbacks[jLog + 1];
+                }
+
+                pLog->callbackCount -= 1;
+            } else {
+                /* Not found. */
+                iLog += 1;
+            }
+        }
+    }
+    ma_log_unlock(pLog);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_log_post(ma_log* pLog, ma_uint32 level, const char* pMessage)
+{
+    if (pLog == NULL || pMessage == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_log_lock(pLog);
+    {
+        ma_uint32 iLog;
+        for (iLog = 0; iLog < pLog->callbackCount; iLog += 1) {
+            if (pLog->callbacks[iLog].onLog) {
+                pLog->callbacks[iLog].onLog(pLog->callbacks[iLog].pUserData, level, pMessage);
+            }
+        }
+    }
+    ma_log_unlock(pLog);
+
+    return MA_SUCCESS;
+}
+
+
+/*
+We need to emulate _vscprintf() for the VC6 build. This can be more efficient, but since it's only VC6, and it's just a
+logging function, I'm happy to keep this simple. In the VC6 build we can implement this in terms of _vsnprintf().
+*/
+#if defined(_MSC_VER) && _MSC_VER < 1900
+static int ma_vscprintf(const ma_allocation_callbacks* pAllocationCallbacks, const char* format, va_list args)
+{
+#if _MSC_VER > 1200
+    return _vscprintf(format, args);
+#else
+    int result;
+    char* pTempBuffer = NULL;
+    size_t tempBufferCap = 1024;
+
+    if (format == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (;;) {
+        char* pNewTempBuffer = (char*)ma_realloc(pTempBuffer, tempBufferCap, pAllocationCallbacks);
+        if (pNewTempBuffer == NULL) {
+            ma_free(pTempBuffer, pAllocationCallbacks);
+            errno = ENOMEM;
+            return -1;  /* Out of memory. */
+        }
+
+        pTempBuffer = pNewTempBuffer;
+
+        result = _vsnprintf(pTempBuffer, tempBufferCap, format, args);
+        ma_free(pTempBuffer, NULL);
+
+        if (result != -1) {
+            break;  /* Got it. */
+        }
+
+        /* Buffer wasn't big enough. Ideally it'd be nice to use an error code to know the reason for sure, but this is reliable enough. */
+        tempBufferCap *= 2;
+    }
+
+    return result;
+#endif
+}
+#endif
+
+MA_API ma_result ma_log_postv(ma_log* pLog, ma_uint32 level, const char* pFormat, va_list args)
+{
+    if (pLog == NULL || pFormat == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || ((!defined(_MSC_VER) || _MSC_VER >= 1900) && !defined(__STRICT_ANSI__) && !defined(_NO_EXT_KEYS)) || (defined(__cplusplus) && __cplusplus >= 201103L)
+    {
+        ma_result result;
+        int length;
+        char  pFormattedMessageStack[1024];
+        char* pFormattedMessageHeap = NULL;
+        va_list args2;
+
+        /* First try formatting into our fixed sized stack allocated buffer. If this is too small we'll fallback to a heap allocation. */
+        ma_va_copy(args2, args);
+        {
+            length = vsnprintf(pFormattedMessageStack, sizeof(pFormattedMessageStack), pFormat, args2);
+        }
+        va_end(args2);
+
+        if (length < 0) {
+            return MA_INVALID_OPERATION;    /* An error occurred when trying to convert the buffer. */
+        }
+
+        if ((size_t)length < sizeof(pFormattedMessageStack)) {
+            /* The string was written to the stack. */
+            result = ma_log_post(pLog, level, pFormattedMessageStack);
+        } else {
+            /* The stack buffer was too small, try the heap. */
+            pFormattedMessageHeap = (char*)ma_malloc(length + 1, &pLog->allocationCallbacks);
+            if (pFormattedMessageHeap == NULL) {
+                return MA_OUT_OF_MEMORY;
+            }
+
+            length = vsnprintf(pFormattedMessageHeap, length + 1, pFormat, args);
+            if (length < 0) {
+                ma_free(pFormattedMessageHeap, &pLog->allocationCallbacks);
+                return MA_INVALID_OPERATION;
+            }
+
+            result = ma_log_post(pLog, level, pFormattedMessageHeap);
+            ma_free(pFormattedMessageHeap, &pLog->allocationCallbacks);
+        }
+
+        return result;
+    }
+    #else
+    {
+        /*
+        Without snprintf() we need to first measure the string and then heap allocate it. I'm only aware of Visual Studio having support for this without snprintf(), so we'll
+        need to restrict this branch to Visual Studio. For other compilers we need to just not support formatted logging because I don't want the security risk of overflowing
+        a fixed sized stack allocated buffer.
+        */
+        #if defined(_MSC_VER) && _MSC_VER >= 1200   /* 1200 = VC6 */
+        {
+            ma_result result;
+            int formattedLen;
+            char* pFormattedMessage = NULL;
+            va_list args2;
+
+            ma_va_copy(args2, args);
+            {
+                formattedLen = ma_vscprintf(&pLog->allocationCallbacks, pFormat, args2);
+            }
+            va_end(args2);
+
+            if (formattedLen <= 0) {
+                return MA_INVALID_OPERATION;
+            }
+
+            pFormattedMessage = (char*)ma_malloc(formattedLen + 1, &pLog->allocationCallbacks);
+            if (pFormattedMessage == NULL) {
+                return MA_OUT_OF_MEMORY;
+            }
+
+            /* We'll get errors on newer versions of Visual Studio if we try to use vsprintf().  */
+            #if _MSC_VER >= 1400    /* 1400 = Visual Studio 2005 */
+            {
+                vsprintf_s(pFormattedMessage, formattedLen + 1, pFormat, args);
+            }
+            #else
+            {
+                vsprintf(pFormattedMessage, pFormat, args);
+            }
+            #endif
+
+            result = ma_log_post(pLog, level, pFormattedMessage);
+            ma_free(pFormattedMessage, &pLog->allocationCallbacks);
+
+            return result;
+        }
+        #else
+        {
+            /* Can't do anything because we don't have a safe way of to emulate vsnprintf() without a manual solution. */
+            (void)level;
+            (void)args;
+
+            return MA_INVALID_OPERATION;
+        }
+        #endif
+    }
+    #endif
+}
+
+MA_API ma_result ma_log_postf(ma_log* pLog, ma_uint32 level, const char* pFormat, ...)
+{
+    ma_result result;
+    va_list args;
+
+    if (pLog == NULL || pFormat == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    va_start(args, pFormat);
+    {
+        result = ma_log_postv(pLog, level, pFormat, args);
+    }
+    va_end(args);
+
+    return result;
+}
+
+
+
+static MA_INLINE ma_uint8 ma_clip_u8(ma_int32 x)
+{
+    return (ma_uint8)(ma_clamp(x, -128, 127) + 128);
+}
+
+static MA_INLINE ma_int16 ma_clip_s16(ma_int32 x)
+{
+    return (ma_int16)ma_clamp(x, -32768, 32767);
+}
+
+static MA_INLINE ma_int64 ma_clip_s24(ma_int64 x)
+{
+    return (ma_int64)ma_clamp(x, -8388608, 8388607);
+}
+
+static MA_INLINE ma_int32 ma_clip_s32(ma_int64 x)
+{
+    /* This dance is to silence warnings with -std=c89. A good compiler should be able to optimize this away. */
+    ma_int64 clipMin;
+    ma_int64 clipMax;
+    clipMin = -((ma_int64)2147483647 + 1);
+    clipMax =   (ma_int64)2147483647;
+
+    return (ma_int32)ma_clamp(x, clipMin, clipMax);
+}
+
+static MA_INLINE float ma_clip_f32(float x)
+{
+    if (x < -1) return -1;
+    if (x > +1) return +1;
+    return x;
+}
+
+
+static MA_INLINE float ma_mix_f32(float x, float y, float a)
+{
+    return x*(1-a) + y*a;
+}
+static MA_INLINE float ma_mix_f32_fast(float x, float y, float a)
+{
+    float r0 = (y - x);
+    float r1 = r0*a;
+    return x + r1;
+    /*return x + (y - x)*a;*/
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE __m128 ma_mix_f32_fast__sse2(__m128 x, __m128 y, __m128 a)
+{
+    return _mm_add_ps(x, _mm_mul_ps(_mm_sub_ps(y, x), a));
+}
+#endif
+#if defined(MA_SUPPORT_AVX2)
+static MA_INLINE __m256 ma_mix_f32_fast__avx2(__m256 x, __m256 y, __m256 a)
+{
+    return _mm256_add_ps(x, _mm256_mul_ps(_mm256_sub_ps(y, x), a));
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE float32x4_t ma_mix_f32_fast__neon(float32x4_t x, float32x4_t y, float32x4_t a)
+{
+    return vaddq_f32(x, vmulq_f32(vsubq_f32(y, x), a));
+}
+#endif
+
+
+static MA_INLINE double ma_mix_f64(double x, double y, double a)
+{
+    return x*(1-a) + y*a;
+}
+static MA_INLINE double ma_mix_f64_fast(double x, double y, double a)
+{
+    return x + (y - x)*a;
+}
+
+static MA_INLINE float ma_scale_to_range_f32(float x, float lo, float hi)
+{
+    return lo + x*(hi-lo);
+}
+
+
+/*
+Greatest common factor using Euclid's algorithm iteratively.
+*/
+static MA_INLINE ma_uint32 ma_gcf_u32(ma_uint32 a, ma_uint32 b)
+{
+    for (;;) {
+        if (b == 0) {
+            break;
+        } else {
+            ma_uint32 t = a;
+            a = b;
+            b = t % a;
+        }
+    }
+
+    return a;
+}
+
+
+static ma_uint32 ma_ffs_32(ma_uint32 x)
+{
+    ma_uint32 i;
+
+    /* Just a naive implementation just to get things working for now. Will optimize this later. */
+    for (i = 0; i < 32; i += 1) {
+        if ((x & (1U << i)) != 0) {
+            return i;
+        }
+    }
+
+    return i;
+}
+
+static MA_INLINE ma_int16 ma_float_to_fixed_16(float x)
+{
+    return (ma_int16)(x * (1 << 8));
+}
+
+
+
+/*
+Random Number Generation
+
+miniaudio uses the LCG random number generation algorithm. This is good enough for audio.
+
+Note that miniaudio's global LCG implementation uses global state which is _not_ thread-local. When this is called across
+multiple threads, results will be unpredictable. However, it won't crash and results will still be random enough for
+miniaudio's purposes.
+*/
+#ifndef MA_DEFAULT_LCG_SEED
+#define MA_DEFAULT_LCG_SEED 4321
+#endif
+
+#define MA_LCG_M   2147483647
+#define MA_LCG_A   48271
+#define MA_LCG_C   0
+
+static ma_lcg g_maLCG = {MA_DEFAULT_LCG_SEED}; /* Non-zero initial seed. Use ma_lcg_seed() to use an explicit seed. */
+
+static MA_INLINE void ma_lcg_seed(ma_lcg* pLCG, ma_int32 seed)
+{
+    MA_ASSERT(pLCG != NULL);
+    pLCG->state = seed;
+}
+
+static MA_INLINE ma_int32 ma_lcg_rand_s32(ma_lcg* pLCG)
+{
+    pLCG->state = (MA_LCG_A * pLCG->state + MA_LCG_C) % MA_LCG_M;
+    return pLCG->state;
+}
+
+static MA_INLINE ma_uint32 ma_lcg_rand_u32(ma_lcg* pLCG)
+{
+    return (ma_uint32)ma_lcg_rand_s32(pLCG);
+}
+
+static MA_INLINE ma_int16 ma_lcg_rand_s16(ma_lcg* pLCG)
+{
+    return (ma_int16)(ma_lcg_rand_s32(pLCG) & 0xFFFF);
+}
+
+static MA_INLINE double ma_lcg_rand_f64(ma_lcg* pLCG)
+{
+    return ma_lcg_rand_s32(pLCG) / (double)0x7FFFFFFF;
+}
+
+static MA_INLINE float ma_lcg_rand_f32(ma_lcg* pLCG)
+{
+    return (float)ma_lcg_rand_f64(pLCG);
+}
+
+static MA_INLINE float ma_lcg_rand_range_f32(ma_lcg* pLCG, float lo, float hi)
+{
+    return ma_scale_to_range_f32(ma_lcg_rand_f32(pLCG), lo, hi);
+}
+
+static MA_INLINE ma_int32 ma_lcg_rand_range_s32(ma_lcg* pLCG, ma_int32 lo, ma_int32 hi)
+{
+    if (lo == hi) {
+        return lo;
+    }
+
+    return lo + ma_lcg_rand_u32(pLCG) / (0xFFFFFFFF / (hi - lo + 1) + 1);
+}
+
+
+#if 0   /* Currently unused. */
+static MA_INLINE void ma_seed(ma_int32 seed)
+{
+    ma_lcg_seed(&g_maLCG, seed);
+}
+
+static MA_INLINE ma_int32 ma_rand_s32(void)
+{
+    return ma_lcg_rand_s32(&g_maLCG);
+}
+
+static MA_INLINE ma_uint32 ma_rand_u32(void)
+{
+    return ma_lcg_rand_u32(&g_maLCG);
+}
+
+static MA_INLINE double ma_rand_f64(void)
+{
+    return ma_lcg_rand_f64(&g_maLCG);
+}
+
+static MA_INLINE float ma_rand_f32(void)
+{
+    return ma_lcg_rand_f32(&g_maLCG);
+}
+#endif
+
+static MA_INLINE float ma_rand_range_f32(float lo, float hi)
+{
+    return ma_lcg_rand_range_f32(&g_maLCG, lo, hi);
+}
+
+static MA_INLINE ma_int32 ma_rand_range_s32(ma_int32 lo, ma_int32 hi)
+{
+    return ma_lcg_rand_range_s32(&g_maLCG, lo, hi);
+}
+
+
+static MA_INLINE float ma_dither_f32_rectangle(float ditherMin, float ditherMax)
+{
+    return ma_rand_range_f32(ditherMin, ditherMax);
+}
+
+static MA_INLINE float ma_dither_f32_triangle(float ditherMin, float ditherMax)
+{
+    float a = ma_rand_range_f32(ditherMin, 0);
+    float b = ma_rand_range_f32(0, ditherMax);
+    return a + b;
+}
+
+static MA_INLINE float ma_dither_f32(ma_dither_mode ditherMode, float ditherMin, float ditherMax)
+{
+    if (ditherMode == ma_dither_mode_rectangle) {
+        return ma_dither_f32_rectangle(ditherMin, ditherMax);
+    }
+    if (ditherMode == ma_dither_mode_triangle) {
+        return ma_dither_f32_triangle(ditherMin, ditherMax);
+    }
+
+    return 0;
+}
+
+static MA_INLINE ma_int32 ma_dither_s32(ma_dither_mode ditherMode, ma_int32 ditherMin, ma_int32 ditherMax)
+{
+    if (ditherMode == ma_dither_mode_rectangle) {
+        ma_int32 a = ma_rand_range_s32(ditherMin, ditherMax);
+        return a;
+    }
+    if (ditherMode == ma_dither_mode_triangle) {
+        ma_int32 a = ma_rand_range_s32(ditherMin, 0);
+        ma_int32 b = ma_rand_range_s32(0, ditherMax);
+        return a + b;
+    }
+
+    return 0;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Atomics
+
+**************************************************************************************************************************************************************/
+/* c89atomic.h begin */
+#ifndef ma_atomic_h
+#define ma_atomic_h
+#if defined(__cplusplus)
+extern "C" {
+#endif
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wlong-long"
+    #if defined(__clang__)
+        #pragma GCC diagnostic ignored "-Wc++11-long-long"
+    #endif
+#endif
+typedef int ma_atomic_memory_order;
+#if !defined(MA_ATOMIC_MODERN_MSVC) && \
+    !defined(MA_ATOMIC_LEGACY_MSVC) && \
+    !defined(MA_ATOMIC_LEGACY_MSVC_ASM) && \
+    !defined(MA_ATOMIC_MODERN_GCC) && \
+    !defined(MA_ATOMIC_LEGACY_GCC) && \
+    !defined(MA_ATOMIC_LEGACY_GCC_ASM)
+    #if defined(_MSC_VER) || defined(__WATCOMC__) || defined(__DMC__) || defined(__BORLANDC__)
+        #if (defined(_MSC_VER) && _MSC_VER > 1600)
+            #define MA_ATOMIC_MODERN_MSVC
+        #else
+            #if defined(MA_X64)
+                #define MA_ATOMIC_LEGACY_MSVC
+            #else
+                #define MA_ATOMIC_LEGACY_MSVC_ASM
+            #endif
+        #endif
+    #elif (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))) || defined(__clang__)
+        #define MA_ATOMIC_MODERN_GCC
+    #else
+        #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1))
+            #define MA_ATOMIC_LEGACY_GCC
+        #else
+            #define MA_ATOMIC_LEGACY_GCC_ASM
+        #endif
+    #endif
+#endif
+#if defined(MA_ATOMIC_MODERN_MSVC) || defined(MA_ATOMIC_LEGACY_MSVC)
+    #include <intrin.h>
+    #define ma_atomic_memory_order_relaxed  1
+    #define ma_atomic_memory_order_consume  2
+    #define ma_atomic_memory_order_acquire  3
+    #define ma_atomic_memory_order_release  4
+    #define ma_atomic_memory_order_acq_rel  5
+    #define ma_atomic_memory_order_seq_cst  6
+    #define MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, intrin, ma_atomicType, msvcType)   \
+        ma_atomicType result; \
+        switch (order) \
+        { \
+            case ma_atomic_memory_order_relaxed: \
+            { \
+                result = (ma_atomicType)intrin##_nf((volatile msvcType*)dst, (msvcType)src); \
+            } break; \
+            case ma_atomic_memory_order_consume: \
+            case ma_atomic_memory_order_acquire: \
+            { \
+                result = (ma_atomicType)intrin##_acq((volatile msvcType*)dst, (msvcType)src); \
+            } break; \
+            case ma_atomic_memory_order_release: \
+            { \
+                result = (ma_atomicType)intrin##_rel((volatile msvcType*)dst, (msvcType)src); \
+            } break; \
+            case ma_atomic_memory_order_acq_rel: \
+            case ma_atomic_memory_order_seq_cst: \
+            default: \
+            { \
+                result = (ma_atomicType)intrin((volatile msvcType*)dst, (msvcType)src); \
+            } break; \
+        } \
+        return result;
+    typedef ma_uint32 ma_atomic_flag;
+    static MA_INLINE ma_atomic_flag ma_atomic_flag_test_and_set_explicit(volatile ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, 1, order, _InterlockedExchange, ma_atomic_flag, long);
+        }
+        #else
+        {
+            (void)order;
+            return (ma_atomic_flag)_InterlockedExchange((volatile long*)dst, (long)1);
+        }
+        #endif
+    }
+    static MA_INLINE void ma_atomic_flag_clear_explicit(volatile ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, 0, order, _InterlockedExchange, ma_atomic_flag, long);
+        }
+        #else
+        {
+            (void)order;
+            _InterlockedExchange((volatile long*)dst, (long)0);
+        }
+        #endif
+    }
+    static MA_INLINE ma_atomic_flag ma_atomic_flag_load_explicit(volatile const ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        (void)order;
+        return (ma_uint32)_InterlockedCompareExchange((volatile long*)dst, 0, 0);
+    }
+#endif
+#if defined(MA_ATOMIC_LEGACY_MSVC_ASM)
+    #define ma_atomic_memory_order_relaxed  1
+    #define ma_atomic_memory_order_consume  2
+    #define ma_atomic_memory_order_acquire  3
+    #define ma_atomic_memory_order_release  4
+    #define ma_atomic_memory_order_acq_rel  5
+    #define ma_atomic_memory_order_seq_cst  6
+    typedef ma_uint32 ma_atomic_flag;
+    static MA_INLINE ma_atomic_flag ma_atomic_flag_test_and_set_explicit(volatile ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        ma_atomic_flag result = 0;
+        (void)order;
+        __asm {
+            mov ecx, dst
+            mov eax, 1
+            xchg [ecx], eax
+            mov result, eax
+        }
+        return result;
+    }
+    static MA_INLINE void ma_atomic_flag_clear_explicit(volatile ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        if (order == ma_atomic_memory_order_relaxed) {
+            __asm {
+                mov esi, dst
+                mov dword ptr [esi], 0
+            }
+        } else {
+            __asm {
+                mov esi, dst
+                mov eax, 0
+                xchg [esi], eax
+            }
+        }
+    }
+    static MA_INLINE ma_atomic_flag ma_atomic_flag_load_explicit(volatile const ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        ma_atomic_flag result = 0;
+        if (order == ma_atomic_memory_order_relaxed) {
+            __asm {
+                mov esi, dst
+                mov eax, [esi]
+                mov result, eax
+            }
+        } else if (order <= ma_atomic_memory_order_release) {
+            __asm {
+                mov esi, dst
+                mov eax, [esi]
+                lock add dword ptr [esp], 0
+                mov result, eax
+            }
+        } else {
+            __asm {
+                lock add dword ptr [esp], 0
+                mov esi, dst
+                mov eax, [esi]
+                mov result, eax
+                lock add dword ptr [esp], 0
+            }
+        }
+        return result;
+    }
+#endif
+#if defined(MA_ATOMIC_MODERN_GCC)
+    #define ma_atomic_memory_order_relaxed                   __ATOMIC_RELAXED
+    #define ma_atomic_memory_order_consume                   __ATOMIC_CONSUME
+    #define ma_atomic_memory_order_acquire                   __ATOMIC_ACQUIRE
+    #define ma_atomic_memory_order_release                   __ATOMIC_RELEASE
+    #define ma_atomic_memory_order_acq_rel                   __ATOMIC_ACQ_REL
+    #define ma_atomic_memory_order_seq_cst                   __ATOMIC_SEQ_CST
+    typedef ma_uint32 ma_atomic_flag;
+    #define ma_atomic_flag_test_and_set_explicit(dst, order) __atomic_exchange_n(dst, 1, order)
+    #define ma_atomic_flag_clear_explicit(dst, order)        __atomic_store_n(dst, 0, order)
+    #define ma_atomic_flag_load_explicit(dst, order)         __atomic_load_n(dst, order)
+#endif
+#if defined(MA_ATOMIC_LEGACY_GCC)
+    #define ma_atomic_memory_order_relaxed  1
+    #define ma_atomic_memory_order_consume  2
+    #define ma_atomic_memory_order_acquire  3
+    #define ma_atomic_memory_order_release  4
+    #define ma_atomic_memory_order_acq_rel  5
+    #define ma_atomic_memory_order_seq_cst  6
+    typedef ma_uint32 ma_atomic_flag;
+    static MA_INLINE ma_atomic_flag ma_atomic_flag_test_and_set_explicit(volatile ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        if (order > ma_atomic_memory_order_acquire) {
+            __sync_synchronize();
+        }
+        return __sync_lock_test_and_set(dst, 1);
+    }
+    static MA_INLINE void ma_atomic_flag_clear_explicit(volatile ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        if (order > ma_atomic_memory_order_release) {
+            __sync_synchronize();
+        }
+        __sync_lock_release(dst);
+    }
+    static MA_INLINE ma_atomic_flag ma_atomic_flag_load_explicit(volatile const ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        (void)order;
+        return __sync_val_compare_and_swap((ma_atomic_flag*)dst, 0, 0);
+    }
+#endif
+#if defined(MA_ATOMIC_LEGACY_GCC_ASM)
+    #define ma_atomic_memory_order_relaxed  1
+    #define ma_atomic_memory_order_consume  2
+    #define ma_atomic_memory_order_acquire  3
+    #define ma_atomic_memory_order_release  4
+    #define ma_atomic_memory_order_acq_rel  5
+    #define ma_atomic_memory_order_seq_cst  6
+    #if defined(MA_X86)
+        #define ma_atomic_thread_fence(order) __asm__ __volatile__("lock; addl $0, (%%esp)" ::: "memory")
+    #elif defined(MA_X64)
+        #define ma_atomic_thread_fence(order) __asm__ __volatile__("lock; addq $0, (%%rsp)" ::: "memory")
+    #else
+        #error Unsupported architecture.
+    #endif
+    #define MA_ATOMIC_XCHG_GCC_X86(instructionSizeSuffix, result, dst, src) \
+        __asm__ __volatile__(                    \
+            "xchg"instructionSizeSuffix" %0, %1" \
+            : "=r"(result),              \
+              "=m"(*dst)                 \
+            : "0"(src),                  \
+              "m"(*dst)                  \
+            : "memory"                           \
+        )
+    #define MA_ATOMIC_LOAD_RELAXED_GCC_X86(instructionSizeSuffix, result, dst) \
+        __asm__ __volatile__(                   \
+            "mov"instructionSizeSuffix" %1, %0" \
+            : "=r"(result)              \
+            : "m"(*dst)                 \
+        )
+    #define MA_ATOMIC_LOAD_RELEASE_GCC_X86(instructionSizeSuffix, result, dst) \
+        ma_atomic_thread_fence(ma_atomic_memory_order_release); \
+        __asm__ __volatile__(                   \
+            "mov"instructionSizeSuffix" %1, %0" \
+            : "=r"(result)              \
+            : "m"(*dst)                 \
+            : "memory"                          \
+        )
+    #define MA_ATOMIC_LOAD_SEQ_CST_GCC_X86(instructionSizeSuffix, result, dst) \
+        ma_atomic_thread_fence(ma_atomic_memory_order_seq_cst); \
+        __asm__ __volatile__(                   \
+            "mov"instructionSizeSuffix" %1, %0" \
+            : "=r"(result)              \
+            : "m"(*dst)                 \
+            : "memory"                          \
+        );                                      \
+        ma_atomic_thread_fence(ma_atomic_memory_order_seq_cst)
+    typedef ma_uint32 ma_atomic_flag;
+    static MA_INLINE ma_atomic_flag ma_atomic_flag_test_and_set_explicit(volatile ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        ma_atomic_flag result;
+        #if defined(MA_X86) || defined(MA_X64)
+        {
+            (void)order;
+            MA_ATOMIC_XCHG_GCC_X86("l", result, dst, 1);
+        }
+        #else
+        {
+            #error Unsupported architecture.
+        }
+        #endif
+        return result;
+    }
+    static MA_INLINE void ma_atomic_flag_clear_explicit(volatile ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        #if defined(MA_X86) || defined(MA_X64)
+        {
+            if (order == ma_atomic_memory_order_relaxed) {
+                __asm__ __volatile__(
+                    "movl $0, %0"
+                    : "=m"(*dst)
+                );
+            } else if (order == ma_atomic_memory_order_release) {
+                __asm__ __volatile__(
+                    "movl $0, %0"
+                    : "=m"(*dst)
+                    :
+                    : "memory"
+                );
+            } else {
+                ma_atomic_flag tmp = 0;
+                __asm__ __volatile__(
+                    "xchgl %0, %1"
+                    : "=r"(tmp),
+                      "=m"(*dst)
+                    : "0"(tmp),
+                      "m"(*dst)
+                    : "memory"
+                );
+            }
+        }
+        #else
+        {
+            #error Unsupported architecture.
+        }
+        #endif
+    }
+    static MA_INLINE ma_atomic_flag ma_atomic_flag_load_explicit(volatile const ma_atomic_flag* dst, ma_atomic_memory_order order)
+    {
+        #if defined(MA_X86) || defined(MA_X64)
+        {
+            ma_atomic_flag result;
+            if (order == ma_atomic_memory_order_relaxed) {
+                MA_ATOMIC_LOAD_RELAXED_GCC_X86("l", result, dst);
+            } else if (order <= ma_atomic_memory_order_release) {
+                MA_ATOMIC_LOAD_RELEASE_GCC_X86("l", result, dst);
+            } else {
+                MA_ATOMIC_LOAD_SEQ_CST_GCC_X86("l", result, dst);
+            }
+            return result;
+        }
+        #else
+        {
+            #error Unsupported architecture.
+        }
+        #endif
+    }
+#endif
+#define ma_atomic_flag_test_and_set(dst) ma_atomic_flag_test_and_set_explicit(dst, ma_atomic_memory_order_acquire)
+#define ma_atomic_flag_clear(dst)        ma_atomic_flag_clear_explicit(dst, ma_atomic_memory_order_release)
+typedef ma_atomic_flag ma_atomic_spinlock;
+static MA_INLINE void ma_atomic_spinlock_lock(volatile ma_atomic_spinlock* pSpinlock)
+{
+    for (;;) {
+        if (ma_atomic_flag_test_and_set_explicit(pSpinlock, ma_atomic_memory_order_acquire) == 0) {
+            break;
+        }
+        while (ma_atomic_flag_load_explicit(pSpinlock, ma_atomic_memory_order_relaxed) == 1) {
+        }
+    }
+}
+static MA_INLINE void ma_atomic_spinlock_unlock(volatile ma_atomic_spinlock* pSpinlock)
+{
+    ma_atomic_flag_clear_explicit(pSpinlock, ma_atomic_memory_order_release);
+}
+ma_atomic_spinlock ma_atomic_global_lock;
+#if defined(MA_ATOMIC_MODERN_MSVC) || defined(MA_ATOMIC_LEGACY_MSVC) || defined(MA_ATOMIC_LEGACY_MSVC_ASM) || defined(MA_ATOMIC_LEGACY_GCC) || defined(MA_ATOMIC_LEGACY_GCC_ASM)
+    #if defined(MA_X64) || (defined(MA_X86) && ((defined(__GNUC__) && defined(__i486__)) || (defined(_M_IX86) && _M_IX86 >= 400)))
+        #if defined(MA_ATOMIC_LEGACY_MSVC) && defined(MA_X64)
+        #else
+            #define MA_ATOMIC_IS_LOCK_FREE_8  1
+            #define MA_ATOMIC_IS_LOCK_FREE_16 1
+        #endif
+        #define MA_ATOMIC_IS_LOCK_FREE_32     1
+        #if defined(MA_X64) || (defined(MA_X86) && ((defined(__GNUC__) && defined(__i586__)) || (defined(_M_IX86) && _M_IX86 >= 500)))
+            #define MA_ATOMIC_IS_LOCK_FREE_64 1
+        #else
+        #endif
+    #else
+    #endif
+    #if defined(MA_ARM32) || defined(MA_ARM64)
+        #define MA_ATOMIC_IS_LOCK_FREE_8  1
+        #define MA_ATOMIC_IS_LOCK_FREE_16 1
+        #define MA_ATOMIC_IS_LOCK_FREE_32 1
+        #if defined(MA_ARM64) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__)
+            #define MA_ATOMIC_IS_LOCK_FREE_64 1
+        #endif
+    #endif
+    #if defined(MA_ATOMIC_PPC32) || defined(MA_ATOMIC_PPC64)
+        #if (defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7))) && !defined(__clang__)
+        #else
+            #define MA_ATOMIC_IS_LOCK_FREE_8  1
+            #define MA_ATOMIC_IS_LOCK_FREE_16 1
+        #endif
+        #define MA_ATOMIC_IS_LOCK_FREE_32     1
+        #if defined(MA_ATOMIC_PPC64)
+            #define MA_ATOMIC_IS_LOCK_FREE_64 1
+        #endif
+    #endif
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_8(volatile void* ptr)
+    {
+        (void)ptr;
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            return 1;
+        #else
+            return 0;
+        #endif
+    }
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_16(volatile void* ptr)
+    {
+        (void)ptr;
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            return 1;
+        #else
+            return 0;
+        #endif
+    }
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_32(volatile void* ptr)
+    {
+        (void)ptr;
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            return 1;
+        #else
+            return 0;
+        #endif
+    }
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_64(volatile void* ptr)
+    {
+        (void)ptr;
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+            return 1;
+        #else
+            return 0;
+        #endif
+    }
+#endif
+#define MA_ATOMIC_COMPARE_AND_SWAP_LOCK(sizeInBits, dst, expected, replacement) \
+    ma_uint##sizeInBits result; \
+    ma_atomic_spinlock_lock(&ma_atomic_global_lock); \
+    { \
+        result = *dst; \
+        if (result == expected) { \
+            *dst = replacement; \
+        } \
+    } \
+    ma_atomic_spinlock_unlock(&ma_atomic_global_lock); \
+    return result
+#define MA_ATOMIC_LOAD_EXPLICIT_LOCK(sizeInBits, ptr, order) \
+    ma_uint##sizeInBits result; \
+    ma_atomic_spinlock_lock(&ma_atomic_global_lock); \
+    { \
+        result = *ptr; \
+        (void)order; \
+    } \
+    ma_atomic_spinlock_unlock(&ma_atomic_global_lock); \
+    return result
+#define MA_ATOMIC_STORE_EXPLICIT_LOCK(sizeInBits, dst, src, order) \
+    ma_atomic_spinlock_lock(&ma_atomic_global_lock); \
+    { \
+        *dst = src; \
+        (void)order; \
+    } \
+    ma_atomic_spinlock_unlock(&ma_atomic_global_lock)
+#define MA_ATOMIC_STORE_EXPLICIT_CAS(sizeInBits, dst, src, order) \
+    ma_uint##sizeInBits oldValue; \
+    do { \
+        oldValue = ma_atomic_load_explicit_##sizeInBits(dst, ma_atomic_memory_order_relaxed); \
+    } while (ma_atomic_compare_and_swap_##sizeInBits(dst, oldValue, src) != oldValue); \
+    (void)order
+#define MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(sizeInBits, dst, src, order) \
+    ma_uint##sizeInBits result; \
+    ma_atomic_spinlock_lock(&ma_atomic_global_lock); \
+    { \
+        result = *dst; \
+        *dst = src; \
+        (void)order; \
+    } \
+    ma_atomic_spinlock_unlock(&ma_atomic_global_lock); \
+    return result
+#define MA_ATOMIC_EXCHANGE_EXPLICIT_CAS(sizeInBits, dst, src, order) \
+    ma_uint##sizeInBits oldValue; \
+    do { \
+        oldValue = ma_atomic_load_explicit_##sizeInBits(dst, ma_atomic_memory_order_relaxed); \
+    } while (ma_atomic_compare_and_swap_##sizeInBits(dst, oldValue, src) != oldValue); \
+    (void)order; \
+    return oldValue
+#define MA_ATOMIC_FETCH_ADD_LOCK(sizeInBits, dst, src, order) \
+    ma_uint##sizeInBits result; \
+    ma_atomic_spinlock_lock(&ma_atomic_global_lock); \
+    { \
+        result = *dst; \
+        *dst += src; \
+        (void)order; \
+    } \
+    ma_atomic_spinlock_unlock(&ma_atomic_global_lock); \
+    return result
+#define MA_ATOMIC_FETCH_ADD_CAS(sizeInBits, dst, src, order) \
+    ma_uint##sizeInBits oldValue; \
+    ma_uint##sizeInBits newValue; \
+    do { \
+        oldValue = ma_atomic_load_explicit_##sizeInBits(dst, ma_atomic_memory_order_relaxed); \
+        newValue = oldValue + src; \
+    } while (ma_atomic_compare_and_swap_##sizeInBits(dst, oldValue, newValue) != oldValue); \
+    (void)order; \
+    return oldValue
+#define MA_ATOMIC_FETCH_AND_CAS(sizeInBits, dst, src, order) \
+    ma_uint##sizeInBits oldValue; \
+    ma_uint##sizeInBits newValue; \
+    do { \
+        oldValue = ma_atomic_load_explicit_##sizeInBits(dst, ma_atomic_memory_order_relaxed); \
+        newValue = (ma_uint##sizeInBits)(oldValue & src); \
+    } while (ma_atomic_compare_and_swap_##sizeInBits(dst, oldValue, newValue) != oldValue); \
+    (void)order; \
+    return oldValue
+#define MA_ATOMIC_FETCH_OR_CAS(sizeInBits, dst, src, order) \
+    ma_uint##sizeInBits oldValue; \
+    ma_uint##sizeInBits newValue; \
+    do { \
+        oldValue = ma_atomic_load_explicit_##sizeInBits(dst, ma_atomic_memory_order_relaxed); \
+        newValue = (ma_uint##sizeInBits)(oldValue | src); \
+    } while (ma_atomic_compare_and_swap_##sizeInBits(dst, oldValue, newValue) != oldValue); \
+    (void)order; \
+    return oldValue
+#define MA_ATOMIC_FETCH_XOR_CAS(sizeInBits, dst, src, order) \
+    ma_uint##sizeInBits oldValue; \
+    ma_uint##sizeInBits newValue; \
+    do { \
+        oldValue = ma_atomic_load_explicit_##sizeInBits(dst, ma_atomic_memory_order_relaxed); \
+        newValue = (ma_uint##sizeInBits)(oldValue ^ src); \
+    } while (ma_atomic_compare_and_swap_##sizeInBits(dst, oldValue, newValue) != oldValue); \
+    (void)order; \
+    return oldValue
+#if defined(MA_ATOMIC_MODERN_MSVC) || defined(MA_ATOMIC_LEGACY_MSVC)
+    #define MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, expected, replacement, order, intrin, ma_atomicType, msvcType)   \
+        ma_atomicType result; \
+        switch (order) \
+        { \
+            case ma_atomic_memory_order_relaxed: \
+            { \
+                result = (ma_atomicType)intrin##_nf((volatile msvcType*)ptr, (msvcType)expected, (msvcType)replacement); \
+            } break; \
+            case ma_atomic_memory_order_consume: \
+            case ma_atomic_memory_order_acquire: \
+            { \
+                result = (ma_atomicType)intrin##_acq((volatile msvcType*)ptr, (msvcType)expected, (msvcType)replacement); \
+            } break; \
+            case ma_atomic_memory_order_release: \
+            { \
+                result = (ma_atomicType)intrin##_rel((volatile msvcType*)ptr, (msvcType)expected, (msvcType)replacement); \
+            } break; \
+            case ma_atomic_memory_order_acq_rel: \
+            case ma_atomic_memory_order_seq_cst: \
+            default: \
+            { \
+                result = (ma_atomicType)intrin((volatile msvcType*)ptr, (msvcType)expected, (msvcType)replacement); \
+            } break; \
+        } \
+        return result;
+    #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+        #define ma_atomic_compare_and_swap_8( dst, expected, replacement) (ma_uint8 )_InterlockedCompareExchange8((volatile char*)dst, (char)replacement, (char)expected)
+    #else
+        static MA_INLINE ma_uint8 __stdcall ma_atomic_compare_and_swap_8(volatile ma_uint8* dst, ma_uint8 expected, ma_uint8 replacement)
+        {
+            MA_ATOMIC_COMPARE_AND_SWAP_LOCK(8, dst, expected, replacement);
+        }
+    #endif
+    #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+        #define ma_atomic_compare_and_swap_16(dst, expected, replacement) (ma_uint16)_InterlockedCompareExchange16((volatile short*)dst, (short)replacement, (short)expected)
+    #else
+        static MA_INLINE ma_uint16 __stdcall ma_atomic_compare_and_swap_16(volatile ma_uint16* dst, ma_uint16 expected, ma_uint16 replacement)
+        {
+            MA_ATOMIC_COMPARE_AND_SWAP_LOCK(16, dst, expected, replacement);
+        }
+    #endif
+    #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        #define ma_atomic_compare_and_swap_32(dst, expected, replacement) (ma_uint32)_InterlockedCompareExchange((volatile long*)dst, (long)replacement, (long)expected)
+    #else
+        static MA_INLINE ma_uint32 __stdcall ma_atomic_compare_and_swap_32(volatile ma_uint32* dst, ma_uint32 expected, ma_uint32 replacement)
+        {
+            MA_ATOMIC_COMPARE_AND_SWAP_LOCK(32, dst, expected, replacement);
+        }
+    #endif
+    #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        #define ma_atomic_compare_and_swap_64(dst, expected, replacement) (ma_uint64)_InterlockedCompareExchange64((volatile ma_int64*)dst, (ma_int64)replacement, (ma_int64)expected)
+    #else
+        static MA_INLINE ma_uint64 __stdcall ma_atomic_compare_and_swap_64(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 replacement)
+        {
+            MA_ATOMIC_COMPARE_AND_SWAP_LOCK(64, dst, expected, replacement);
+        }
+    #endif
+    static MA_INLINE ma_uint8 ma_atomic_load_explicit_8(volatile const ma_uint8* ptr, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, 0, 0, order, _InterlockedCompareExchange8, ma_uint8, char);
+            }
+            #else
+            {
+                (void)order;
+                return ma_atomic_compare_and_swap_8((volatile ma_uint8*)ptr, 0, 0);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_LOAD_EXPLICIT_LOCK(8, ptr, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 ma_atomic_load_explicit_16(volatile const ma_uint16* ptr, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, 0, 0, order, _InterlockedCompareExchange16, ma_uint16, short);
+            }
+            #else
+            {
+                (void)order;
+                return ma_atomic_compare_and_swap_16((volatile ma_uint16*)ptr, 0, 0);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_LOAD_EXPLICIT_LOCK(16, ptr, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 ma_atomic_load_explicit_32(volatile const ma_uint32* ptr, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, 0, 0, order, _InterlockedCompareExchange, ma_uint32, long);
+            }
+            #else
+            {
+                (void)order;
+                return ma_atomic_compare_and_swap_32((volatile ma_uint32*)ptr, 0, 0);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_LOAD_EXPLICIT_LOCK(32, ptr, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 ma_atomic_load_explicit_64(volatile const ma_uint64* ptr, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, 0, 0, order, _InterlockedCompareExchange64, ma_uint64, long long);
+            }
+            #else
+            {
+                (void)order;
+                return ma_atomic_compare_and_swap_64((volatile ma_uint64*)ptr, 0, 0);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_LOAD_EXPLICIT_LOCK(64, ptr, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_exchange_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchange8, ma_uint8, char);
+            }
+            #else
+            {
+                (void)order;
+                return (ma_uint8)_InterlockedExchange8((volatile char*)dst, (char)src);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(8, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_exchange_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchange16, ma_uint16, short);
+            }
+            #else
+            {
+                (void)order;
+                return (ma_uint16)_InterlockedExchange16((volatile short*)dst, (short)src);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(16, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_exchange_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchange, ma_uint32, long);
+            }
+            #else
+            {
+                (void)order;
+                return (ma_uint32)_InterlockedExchange((volatile long*)dst, (long)src);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(32, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_exchange_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+        {
+            #if defined(MA_32BIT)
+            {
+                MA_ATOMIC_EXCHANGE_EXPLICIT_CAS(64, dst, src, order);
+            }
+            #else
+            {
+                #if defined(MA_ARM)
+                {
+                    MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchange64, ma_uint64, long long);
+                }
+                #else
+                {
+                    (void)order;
+                    return (ma_uint64)_InterlockedExchange64((volatile long long*)dst, (long long)src);
+                }
+                #endif
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(64, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_add_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchangeAdd8, ma_uint8, char);
+            }
+            #else
+            {
+                (void)order;
+                return (ma_uint8)_InterlockedExchangeAdd8((volatile char*)dst, (char)src);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(8, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_add_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchangeAdd16, ma_uint16, short);
+            }
+            #else
+            {
+                (void)order;
+                return (ma_uint16)_InterlockedExchangeAdd16((volatile short*)dst, (short)src);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(16, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_add_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        {
+            #if defined(MA_ARM)
+            {
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchangeAdd, ma_uint32, long);
+            }
+            #else
+            {
+                (void)order;
+                return (ma_uint32)_InterlockedExchangeAdd((volatile long*)dst, (long)src);
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(32, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_add_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+        {
+            #if defined(MA_32BIT)
+            {
+                MA_ATOMIC_FETCH_ADD_CAS(64, dst, src, order);
+            }
+            #else
+            {
+                #if defined(MA_ARM)
+                {
+                    MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchangeAdd64, ma_uint64, long long);
+                }
+                #else
+                {
+                    (void)order;
+                    return (ma_uint64)_InterlockedExchangeAdd64((volatile long long*)dst, (long long)src);
+                }
+                #endif
+            }
+            #endif
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(64, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_sub_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        return ma_atomic_fetch_add_explicit_8(dst, (ma_uint8)(-(ma_int8)src), order);
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_sub_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        return ma_atomic_fetch_add_explicit_16(dst, (ma_uint16)(-(ma_int16)src), order);
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_sub_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        return ma_atomic_fetch_add_explicit_32(dst, (ma_uint32)(-(ma_int32)src), order);
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_sub_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        return ma_atomic_fetch_add_explicit_64(dst, (ma_uint64)(-(ma_int64)src), order);
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_and_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedAnd8, ma_uint8, char);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_AND_CAS(8, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_and_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedAnd16, ma_uint16, short);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_AND_CAS(16, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_and_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedAnd, ma_uint32, long);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_AND_CAS(32, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_and_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedAnd64, ma_uint64, long long);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_AND_CAS(64, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_or_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedOr8, ma_uint8, char);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_OR_CAS(8, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_or_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedOr16, ma_uint16, short);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_OR_CAS(16, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_or_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedOr, ma_uint32, long);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_OR_CAS(32, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_or_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedOr64, ma_uint64, long long);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_OR_CAS(64, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_xor_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedXor8, ma_uint8, char);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_XOR_CAS(8, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_xor_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedXor16, ma_uint16, short);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_XOR_CAS(16, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_xor_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedXor, ma_uint32, long);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_XOR_CAS(32, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_xor_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ARM)
+        {
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedXor64, ma_uint64, long long);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_XOR_CAS(64, dst, src, order);
+        }
+        #endif
+    }
+    #define ma_atomic_store_explicit_8( dst, src, order) (void)ma_atomic_exchange_explicit_8 (dst, src, order)
+    #define ma_atomic_store_explicit_16(dst, src, order) (void)ma_atomic_exchange_explicit_16(dst, src, order)
+    #define ma_atomic_store_explicit_32(dst, src, order) (void)ma_atomic_exchange_explicit_32(dst, src, order)
+    #define ma_atomic_store_explicit_64(dst, src, order) (void)ma_atomic_exchange_explicit_64(dst, src, order)
+    #if defined(MA_X64)
+        #define ma_atomic_thread_fence(order)   __faststorefence(), (void)order
+    #elif defined(MA_ARM64)
+        #define ma_atomic_thread_fence(order)   __dmb(_ARM64_BARRIER_ISH), (void)order
+    #else
+        static MA_INLINE void ma_atomic_thread_fence(ma_atomic_memory_order order)
+        {
+            volatile ma_uint32 barrier = 0;
+            ma_atomic_fetch_add_explicit_32(&barrier, 0, order);
+        }
+    #endif
+    #define ma_atomic_signal_fence(order)   _ReadWriteBarrier(), (void)order
+#endif
+#if defined(MA_ATOMIC_LEGACY_MSVC_ASM)
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_compare_and_swap_8(volatile ma_uint8* dst, ma_uint8 expected, ma_uint8 replacement)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+        {
+            ma_uint8 result = 0;
+            __asm {
+                mov ecx, dst
+                mov al,  expected
+                mov dl,  replacement
+                lock cmpxchg [ecx], dl
+                mov result, al
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_COMPARE_AND_SWAP_LOCK(8, dst, expected, replacement);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_compare_and_swap_16(volatile ma_uint16* dst, ma_uint16 expected, ma_uint16 replacement)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+        {
+            ma_uint16 result = 0;
+            __asm {
+                mov ecx, dst
+                mov ax,  expected
+                mov dx,  replacement
+                lock cmpxchg [ecx], dx
+                mov result, ax
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_COMPARE_AND_SWAP_LOCK(16, dst, expected, replacement);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_compare_and_swap_32(volatile ma_uint32* dst, ma_uint32 expected, ma_uint32 replacement)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        {
+            ma_uint32 result = 0;
+            __asm {
+                mov ecx, dst
+                mov eax, expected
+                mov edx, replacement
+                lock cmpxchg [ecx], edx
+                mov result, eax
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_COMPARE_AND_SWAP_LOCK(32, dst, expected, replacement);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_compare_and_swap_64(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 replacement)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+        {
+            ma_uint32 resultEAX = 0;
+            ma_uint32 resultEDX = 0;
+            __asm {
+                mov esi, dst
+                mov eax, dword ptr expected
+                mov edx, dword ptr expected + 4
+                mov ebx, dword ptr replacement
+                mov ecx, dword ptr replacement + 4
+                lock cmpxchg8b qword ptr [esi]
+                mov resultEAX, eax
+                mov resultEDX, edx
+            }
+            return ((ma_uint64)resultEDX << 32) | resultEAX;
+        }
+        #else
+        {
+            MA_ATOMIC_COMPARE_AND_SWAP_LOCK(64, dst, expected, replacement);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint8 ma_atomic_load_explicit_8(volatile const ma_uint8* dst, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+        {
+            ma_uint8 result = 0;
+            if (order == ma_atomic_memory_order_relaxed) {
+                __asm {
+                    mov esi, dst
+                    mov al, [esi]
+                    mov result, al
+                }
+            } else if (order <= ma_atomic_memory_order_release) {
+                __asm {
+                    mov esi, dst
+                    mov al, [esi]
+                    lock add dword ptr [esp], 0
+                    mov result, al
+                }
+            } else {
+                __asm {
+                    lock add dword ptr [esp], 0
+                    mov esi, dst
+                    mov al, [esi]
+                    mov result, al
+                    lock add dword ptr [esp], 0
+                }
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_LOAD_EXPLICIT_LOCK(8, dst, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 ma_atomic_load_explicit_16(volatile const ma_uint16* dst, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+        {
+            ma_uint16 result = 0;
+            if (order == ma_atomic_memory_order_relaxed) {
+                __asm {
+                    mov esi, dst
+                    mov ax, [esi]
+                    mov result, ax
+                }
+            } else if (order <= ma_atomic_memory_order_release) {
+                __asm {
+                    mov esi, dst
+                    mov ax, [esi]
+                    lock add dword ptr [esp], 0
+                    mov result, ax
+                }
+            } else {
+                __asm {
+                    lock add dword ptr [esp], 0
+                    mov esi, dst
+                    mov ax, [esi]
+                    mov result, ax
+                    lock add dword ptr [esp], 0
+                }
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_LOAD_EXPLICIT_LOCK(16, dst, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 ma_atomic_load_explicit_32(volatile const ma_uint32* dst, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        {
+            ma_uint32 result = 0;
+            if (order == ma_atomic_memory_order_relaxed) {
+                __asm {
+                    mov esi, dst
+                    mov eax, [esi]
+                    mov result, eax
+                }
+            } else if (order <= ma_atomic_memory_order_release) {
+                __asm {
+                    mov esi, dst
+                    mov eax, [esi]
+                    lock add dword ptr [esp], 0
+                    mov result, eax
+                }
+            } else {
+                __asm {
+                    lock add dword ptr [esp], 0
+                    mov esi, dst
+                    mov eax, [esi]
+                    mov result, eax
+                    lock add dword ptr [esp], 0
+                }
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_LOAD_EXPLICIT_LOCK(32, dst, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 ma_atomic_load_explicit_64(volatile const ma_uint64* dst, ma_atomic_memory_order order)
+    {
+        (void)order;
+        return ma_atomic_compare_and_swap_64((volatile ma_uint64*)dst, 0, 0);
+    }
+    static MA_INLINE void __stdcall ma_atomic_store_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        if (order == ma_atomic_memory_order_relaxed) {
+            __asm {
+                mov esi, dst
+                mov al, src
+                mov [esi], al
+            }
+        } else {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            {
+                __asm {
+                    mov esi, dst
+                    mov al, src
+                    xchg [esi], al
+                }
+            }
+            #else
+            {
+                MA_ATOMIC_STORE_EXPLICIT_LOCK(8, dst, src, order);
+            }
+            #endif
+        }
+    }
+    static MA_INLINE void __stdcall ma_atomic_store_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        if (order == ma_atomic_memory_order_relaxed) {
+            __asm {
+                mov esi, dst
+                mov ax, src
+                mov [esi], ax
+            }
+        } else {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            {
+                __asm {
+                    mov esi, dst
+                    mov ax, src
+                    xchg [esi], ax
+                }
+            }
+            #else
+            {
+                MA_ATOMIC_STORE_EXPLICIT_LOCK(16, dst, src, order);
+            }
+            #endif
+        }
+    }
+    static MA_INLINE void __stdcall ma_atomic_store_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        if (order == ma_atomic_memory_order_relaxed) {
+            __asm {
+                mov esi, dst
+                mov eax, src
+                mov [esi], eax
+            }
+        } else {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            {
+                __asm {
+                    mov esi, dst
+                    mov eax, src
+                    xchg [esi], eax
+                }
+            }
+            #else
+            {
+                MA_ATOMIC_STORE_EXPLICIT_LOCK(32, dst, src, order);
+            }
+            #endif
+        }
+    }
+    static MA_INLINE void __stdcall ma_atomic_store_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+        {
+            MA_ATOMIC_STORE_EXPLICIT_CAS(64, dst, src, order);
+        }
+        #else
+        {
+            MA_ATOMIC_STORE_EXPLICIT_LOCK(64, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_exchange_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+        {
+            ma_uint8 result = 0;
+            (void)order;
+            __asm {
+                mov ecx, dst
+                mov al,  src
+                lock xchg [ecx], al
+                mov result, al
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(8, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_exchange_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+        {
+            ma_uint16 result = 0;
+            (void)order;
+            __asm {
+                mov ecx, dst
+                mov ax,  src
+                lock xchg [ecx], ax
+                mov result, ax
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(16, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_exchange_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        {
+            ma_uint32 result = 0;
+            (void)order;
+            __asm {
+                mov ecx, dst
+                mov eax, src
+                xchg [ecx], eax
+                mov result, eax
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(32, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_exchange_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+        {
+            MA_ATOMIC_EXCHANGE_EXPLICIT_CAS(64, dst, src, order);
+        }
+        #else
+        {
+            MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(64, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_add_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+        {
+            ma_uint8 result = 0;
+            (void)order;
+            __asm {
+                mov ecx, dst
+                mov al,  src
+                lock xadd [ecx], al
+                mov result, al
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(8, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_add_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+        {
+            ma_uint16 result = 0;
+            (void)order;
+            __asm {
+                mov ecx, dst
+                mov ax,  src
+                lock xadd [ecx], ax
+                mov result, ax
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(16, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_add_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        {
+            ma_uint32 result = 0;
+            (void)order;
+            __asm {
+                mov ecx, dst
+                mov eax, src
+                lock xadd [ecx], eax
+                mov result, eax
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(32, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_add_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+        {
+            MA_ATOMIC_FETCH_ADD_CAS(64, dst, src, order);
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(64, dst, src, order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_sub_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+        {
+            ma_uint8 result = 0;
+            (void)order;
+            __asm {
+                mov ecx, dst
+                mov al,  src
+                neg al
+                lock xadd [ecx], al
+                mov result, al
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(8, dst, (ma_uint8)(-(ma_int8)src), order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_sub_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+        {
+            ma_uint16 result = 0;
+            (void)order;
+            __asm {
+                mov ecx, dst
+                mov ax,  src
+                neg ax
+                lock xadd [ecx], ax
+                mov result, ax
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(16, dst, (ma_uint16)(-(ma_int16)src), order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_sub_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+        {
+            ma_uint32 result = 0;
+            (void)order;
+            __asm {
+                mov ecx, dst
+                mov eax, src
+                neg eax
+                lock xadd [ecx], eax
+                mov result, eax
+            }
+            return result;
+        }
+        #else
+        {
+            MA_ATOMIC_FETCH_ADD_LOCK(32, dst, (ma_uint32)(-(ma_int32)src), order);
+        }
+        #endif
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_sub_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_ADD_CAS(64, dst, (ma_uint64)(-(ma_int64)src), order);
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_and_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_AND_CAS(8, dst, src, order);
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_and_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_AND_CAS(16, dst, src, order);
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_and_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_AND_CAS(32, dst, src, order);
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_and_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_AND_CAS(64, dst, src, order);
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_or_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_OR_CAS(8, dst, src, order);
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_or_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_OR_CAS(16, dst, src, order);
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_or_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_OR_CAS(32, dst, src, order);
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_or_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_OR_CAS(64, dst, src, order);
+    }
+    static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_xor_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_XOR_CAS(8, dst, src, order);
+    }
+    static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_xor_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_XOR_CAS(16, dst, src, order);
+    }
+    static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_xor_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_XOR_CAS(32, dst, src, order);
+    }
+    static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_xor_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+    {
+        MA_ATOMIC_FETCH_XOR_CAS(64, dst, src, order);
+    }
+    static MA_INLINE void __stdcall ma_atomic_thread_fence(ma_atomic_memory_order order)
+    {
+        (void)order;
+        __asm {
+            lock add dword ptr [esp], 0
+        }
+    }
+    #define ma_atomic_signal_fence(order) __asm {}; (void)order
+#endif
+#if defined(MA_ATOMIC_MODERN_GCC)
+    #define MA_ATOMIC_HAS_NATIVE_COMPARE_EXCHANGE
+    #define ma_atomic_thread_fence(order)                           __atomic_thread_fence(order)
+    #define ma_atomic_signal_fence(order)                           __atomic_signal_fence(order)
+    #define ma_atomic_is_lock_free_8(ptr)                           __atomic_is_lock_free(1, ptr)
+    #define ma_atomic_is_lock_free_16(ptr)                          __atomic_is_lock_free(2, ptr)
+    #define ma_atomic_is_lock_free_32(ptr)                          __atomic_is_lock_free(4, ptr)
+    #define ma_atomic_is_lock_free_64(ptr)                          __atomic_is_lock_free(8, ptr)
+    #define ma_atomic_store_explicit_8( dst, src, order)            __atomic_store_n(dst, src, order)
+    #define ma_atomic_store_explicit_16(dst, src, order)            __atomic_store_n(dst, src, order)
+    #define ma_atomic_store_explicit_32(dst, src, order)            __atomic_store_n(dst, src, order)
+    #define ma_atomic_store_explicit_64(dst, src, order)            __atomic_store_n(dst, src, order)
+    #define ma_atomic_load_explicit_8( dst, order)                  __atomic_load_n(dst, order)
+    #define ma_atomic_load_explicit_16(dst, order)                  __atomic_load_n(dst, order)
+    #define ma_atomic_load_explicit_32(dst, order)                  __atomic_load_n(dst, order)
+    #define ma_atomic_load_explicit_64(dst, order)                  __atomic_load_n(dst, order)
+    #define ma_atomic_exchange_explicit_8( dst, src, order)         __atomic_exchange_n(dst, src, order)
+    #define ma_atomic_exchange_explicit_16(dst, src, order)         __atomic_exchange_n(dst, src, order)
+    #define ma_atomic_exchange_explicit_32(dst, src, order)         __atomic_exchange_n(dst, src, order)
+    #define ma_atomic_exchange_explicit_64(dst, src, order)         __atomic_exchange_n(dst, src, order)
+    #define ma_atomic_compare_exchange_strong_explicit_8( dst, expected, replacement, successOrder, failureOrder)   __atomic_compare_exchange_n(dst, expected, replacement, 0, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_strong_explicit_16(dst, expected, replacement, successOrder, failureOrder)   __atomic_compare_exchange_n(dst, expected, replacement, 0, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_strong_explicit_32(dst, expected, replacement, successOrder, failureOrder)   __atomic_compare_exchange_n(dst, expected, replacement, 0, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_strong_explicit_64(dst, expected, replacement, successOrder, failureOrder)   __atomic_compare_exchange_n(dst, expected, replacement, 0, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_8( dst, expected, replacement, successOrder, failureOrder)     __atomic_compare_exchange_n(dst, expected, replacement, 1, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_16(dst, expected, replacement, successOrder, failureOrder)     __atomic_compare_exchange_n(dst, expected, replacement, 1, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_32(dst, expected, replacement, successOrder, failureOrder)     __atomic_compare_exchange_n(dst, expected, replacement, 1, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_64(dst, expected, replacement, successOrder, failureOrder)     __atomic_compare_exchange_n(dst, expected, replacement, 1, successOrder, failureOrder)
+    #define ma_atomic_fetch_add_explicit_8( dst, src, order)        __atomic_fetch_add(dst, src, order)
+    #define ma_atomic_fetch_add_explicit_16(dst, src, order)        __atomic_fetch_add(dst, src, order)
+    #define ma_atomic_fetch_add_explicit_32(dst, src, order)        __atomic_fetch_add(dst, src, order)
+    #define ma_atomic_fetch_add_explicit_64(dst, src, order)        __atomic_fetch_add(dst, src, order)
+    #define ma_atomic_fetch_sub_explicit_8( dst, src, order)        __atomic_fetch_sub(dst, src, order)
+    #define ma_atomic_fetch_sub_explicit_16(dst, src, order)        __atomic_fetch_sub(dst, src, order)
+    #define ma_atomic_fetch_sub_explicit_32(dst, src, order)        __atomic_fetch_sub(dst, src, order)
+    #define ma_atomic_fetch_sub_explicit_64(dst, src, order)        __atomic_fetch_sub(dst, src, order)
+    #define ma_atomic_fetch_or_explicit_8( dst, src, order)         __atomic_fetch_or(dst, src, order)
+    #define ma_atomic_fetch_or_explicit_16(dst, src, order)         __atomic_fetch_or(dst, src, order)
+    #define ma_atomic_fetch_or_explicit_32(dst, src, order)         __atomic_fetch_or(dst, src, order)
+    #define ma_atomic_fetch_or_explicit_64(dst, src, order)         __atomic_fetch_or(dst, src, order)
+    #define ma_atomic_fetch_xor_explicit_8( dst, src, order)        __atomic_fetch_xor(dst, src, order)
+    #define ma_atomic_fetch_xor_explicit_16(dst, src, order)        __atomic_fetch_xor(dst, src, order)
+    #define ma_atomic_fetch_xor_explicit_32(dst, src, order)        __atomic_fetch_xor(dst, src, order)
+    #define ma_atomic_fetch_xor_explicit_64(dst, src, order)        __atomic_fetch_xor(dst, src, order)
+    #define ma_atomic_fetch_and_explicit_8( dst, src, order)        __atomic_fetch_and(dst, src, order)
+    #define ma_atomic_fetch_and_explicit_16(dst, src, order)        __atomic_fetch_and(dst, src, order)
+    #define ma_atomic_fetch_and_explicit_32(dst, src, order)        __atomic_fetch_and(dst, src, order)
+    #define ma_atomic_fetch_and_explicit_64(dst, src, order)        __atomic_fetch_and(dst, src, order)
+    static MA_INLINE ma_uint8 ma_atomic_compare_and_swap_8(volatile ma_uint8* dst, ma_uint8 expected, ma_uint8 replacement)
+    {
+        __atomic_compare_exchange_n(dst, &expected, replacement, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        return expected;
+    }
+    static MA_INLINE ma_uint16 ma_atomic_compare_and_swap_16(volatile ma_uint16* dst, ma_uint16 expected, ma_uint16 replacement)
+    {
+        __atomic_compare_exchange_n(dst, &expected, replacement, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        return expected;
+    }
+    static MA_INLINE ma_uint32 ma_atomic_compare_and_swap_32(volatile ma_uint32* dst, ma_uint32 expected, ma_uint32 replacement)
+    {
+        __atomic_compare_exchange_n(dst, &expected, replacement, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        return expected;
+    }
+    #if defined(__clang__)
+        #pragma clang diagnostic push
+        #if __clang_major__ >= 8
+            #pragma clang diagnostic ignored "-Watomic-alignment"
+        #endif
+    #endif
+    static MA_INLINE ma_uint64 ma_atomic_compare_and_swap_64(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 replacement)
+    {
+        __atomic_compare_exchange_n(dst, &expected, replacement, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        return expected;
+    }
+    #if defined(__clang__)
+        #pragma clang diagnostic pop
+    #endif
+#endif
+#if defined(MA_ATOMIC_LEGACY_GCC) || defined(MA_ATOMIC_LEGACY_GCC_ASM)
+    #define ma_atomic_signal_fence(order)   __asm__ __volatile__("":::"memory")
+    #if defined(MA_ATOMIC_LEGACY_GCC)
+        #define ma_atomic_thread_fence(order) __sync_synchronize(), (void)order
+        static MA_INLINE ma_uint8 ma_atomic_compare_and_swap_8(volatile ma_uint8* dst, ma_uint8 expected, ma_uint8 replacement)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            {
+                return __sync_val_compare_and_swap(dst, expected, replacement);
+            }
+            #else
+            {
+                MA_ATOMIC_COMPARE_AND_SWAP_LOCK(8, dst, expected, replacement);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_compare_and_swap_16(volatile ma_uint16* dst, ma_uint16 expected, ma_uint16 replacement)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            {
+                return __sync_val_compare_and_swap(dst, expected, replacement);
+            }
+            #else
+            {
+                MA_ATOMIC_COMPARE_AND_SWAP_LOCK(16, dst, expected, replacement);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_compare_and_swap_32(volatile ma_uint32* dst, ma_uint32 expected, ma_uint32 replacement)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            {
+                return __sync_val_compare_and_swap(dst, expected, replacement);
+            }
+            #else
+            {
+                MA_ATOMIC_COMPARE_AND_SWAP_LOCK(32, dst, expected, replacement);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_compare_and_swap_64(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 replacement)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+            {
+                return __sync_val_compare_and_swap(dst, expected, replacement);
+            }
+            #else
+            {
+                MA_ATOMIC_COMPARE_AND_SWAP_LOCK(64, dst, expected, replacement);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_load_explicit_8(volatile const ma_uint8* ptr, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            {
+                (void)order;
+                return ma_atomic_compare_and_swap_8((ma_uint8*)ptr, 0, 0);
+            }
+            #else
+            {
+                MA_ATOMIC_LOAD_EXPLICIT_LOCK(8, ptr, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_load_explicit_16(volatile const ma_uint16* ptr, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            {
+                (void)order;
+                return ma_atomic_compare_and_swap_16((ma_uint16*)ptr, 0, 0);
+            }
+            #else
+            {
+                MA_ATOMIC_LOAD_EXPLICIT_LOCK(16, ptr, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_load_explicit_32(volatile const ma_uint32* ptr, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            {
+                (void)order;
+                return ma_atomic_compare_and_swap_32((ma_uint32*)ptr, 0, 0);
+            }
+            #else
+            {
+                MA_ATOMIC_LOAD_EXPLICIT_LOCK(32, ptr, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_load_explicit_64(volatile const ma_uint64* ptr, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+            {
+                (void)order;
+                return ma_atomic_compare_and_swap_64((ma_uint64*)ptr, 0, 0);
+            }
+            #else
+            {
+                MA_ATOMIC_LOAD_EXPLICIT_LOCK(64, ptr, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_exchange_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            {
+                if (order > ma_atomic_memory_order_acquire) {
+                    __sync_synchronize();
+                }
+                return __sync_lock_test_and_set(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(8, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_exchange_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            {
+                if (order > ma_atomic_memory_order_acquire) {
+                    __sync_synchronize();
+                }
+                return __sync_lock_test_and_set(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(16, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_exchange_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            {
+                if (order > ma_atomic_memory_order_acquire) {
+                    __sync_synchronize();
+                }
+                return __sync_lock_test_and_set(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(32, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_exchange_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+            {
+                if (order > ma_atomic_memory_order_acquire) {
+                    __sync_synchronize();
+                }
+                return __sync_lock_test_and_set(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(64, dst, src, order);
+            }
+            #endif
+        }
+        #define ma_atomic_store_explicit_8( dst, src, order) (void)ma_atomic_exchange_explicit_8 (dst, src, order)
+        #define ma_atomic_store_explicit_16(dst, src, order) (void)ma_atomic_exchange_explicit_16(dst, src, order)
+        #define ma_atomic_store_explicit_32(dst, src, order) (void)ma_atomic_exchange_explicit_32(dst, src, order)
+        #define ma_atomic_store_explicit_64(dst, src, order) (void)ma_atomic_exchange_explicit_64(dst, src, order)
+        static MA_INLINE ma_uint8 ma_atomic_fetch_add_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            {
+                (void)order;
+                return __sync_fetch_and_add(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(8, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_add_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            {
+                (void)order;
+                return __sync_fetch_and_add(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(16, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_add_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            {
+                (void)order;
+                return __sync_fetch_and_add(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(32, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_add_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+            {
+                (void)order;
+                return __sync_fetch_and_add(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(64, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_sub_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            {
+                (void)order;
+                return __sync_fetch_and_sub(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(8, dst, (ma_uint8)(-(ma_int8)src), order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_sub_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            {
+                (void)order;
+                return __sync_fetch_and_sub(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(16, dst, (ma_uint16)(-(ma_int16)src), order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_sub_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            {
+                (void)order;
+                return __sync_fetch_and_sub(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(32, dst, (ma_uint32)(-(ma_int32)src), order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_sub_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+            {
+                (void)order;
+                return __sync_fetch_and_sub(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(64, dst, (ma_uint64)(-(ma_int64)src), order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_and_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            {
+                (void)order;
+                return __sync_fetch_and_and(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_AND_CAS(8, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_and_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            {
+                (void)order;
+                return __sync_fetch_and_and(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_AND_CAS(16, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_and_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            {
+                (void)order;
+                return __sync_fetch_and_and(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_AND_CAS(32, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_and_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+            {
+                (void)order;
+                return __sync_fetch_and_and(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_AND_CAS(64, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_or_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            {
+                (void)order;
+                return __sync_fetch_and_or(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_OR_CAS(8, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_or_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            {
+                (void)order;
+                return __sync_fetch_and_or(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_OR_CAS(16, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_or_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            {
+                (void)order;
+                return __sync_fetch_and_or(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_OR_CAS(32, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_or_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+            {
+                (void)order;
+                return __sync_fetch_and_or(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_OR_CAS(64, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_xor_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8)
+            {
+                (void)order;
+                return __sync_fetch_and_xor(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_XOR_CAS(8, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_xor_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16)
+            {
+                (void)order;
+                return __sync_fetch_and_xor(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_XOR_CAS(16, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_xor_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32)
+            {
+                (void)order;
+                return __sync_fetch_and_xor(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_XOR_CAS(32, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_xor_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64)
+            {
+                (void)order;
+                return __sync_fetch_and_xor(dst, src);
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_XOR_CAS(64, dst, src, order);
+            }
+            #endif
+        }
+    #elif defined(MA_ATOMIC_LEGACY_GCC_ASM)
+        #define MA_ATOMIC_CMPXCHG_GCC_X86(instructionSizeSuffix, result, dst, expected, replacement) \
+            __asm__ __volatile__(                             \
+                "lock; cmpxchg"instructionSizeSuffix" %2, %1" \
+                : "=a"(result),                       \
+                  "=m"(*dst)                          \
+                : "r"(replacement),                   \
+                  "0"(expected),                      \
+                  "m"(*dst)                           \
+                : "cc", "memory")
+        #define MA_ATOMIC_XADD_GCC_X86(instructionSizeSuffix, result, dst, src) \
+            __asm__ __volatile__(        \
+                "lock; xadd"instructionSizeSuffix" %0, %1"      \
+                : "=a"(result),  \
+                  "=m"(*dst)     \
+                : "0"(src),      \
+                  "m"(*dst)      \
+                : "cc", "memory")
+        static MA_INLINE ma_uint8 ma_atomic_compare_and_swap_8(volatile ma_uint8* dst, ma_uint8 expected, ma_uint8 replacement)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint8 result;
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    MA_ATOMIC_CMPXCHG_GCC_X86("b", result, dst, expected, replacement);
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_COMPARE_AND_SWAP_LOCK(8, dst, expected, replacement);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_compare_and_swap_16(volatile ma_uint16* dst, ma_uint16 expected, ma_uint16 replacement)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint16 result;
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    MA_ATOMIC_CMPXCHG_GCC_X86("w", result, dst, expected, replacement);
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_COMPARE_AND_SWAP_LOCK(16, dst, expected, replacement);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_compare_and_swap_32(volatile ma_uint32* dst, ma_uint32 expected, ma_uint32 replacement)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint32 result;
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    MA_ATOMIC_CMPXCHG_GCC_X86("l", result, dst, expected, replacement);
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_COMPARE_AND_SWAP_LOCK(32, dst, expected, replacement);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_compare_and_swap_64(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 replacement)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint64 result;
+                #if defined(MA_X86)
+                {
+                    ma_uint32 resultEAX;
+                    ma_uint32 resultEDX;
+                    __asm__ __volatile__(
+                        "pushl %%ebx\n"
+                        "movl  %4, %%ebx\n"
+                        "lock  cmpxchg8b (%%edi)\n"
+                        "popl  %%ebx\n"
+                        : "=a"(resultEAX),
+                          "=d"(resultEDX)
+                        : "a"((ma_uint32)(expected & 0xFFFFFFFF)),
+                          "d"((ma_uint32)(expected >> 32)),
+                          "r"((ma_uint32)(replacement & 0xFFFFFFFF)),
+                          "c"((ma_uint32)(replacement >> 32)),
+                          "D"(dst)
+                        : "memory", "cc");
+                    result = ((ma_uint64)resultEDX << 32) | resultEAX;
+                }
+                #elif defined(MA_X64)
+                {
+                    MA_ATOMIC_CMPXCHG_GCC_X86("q", result, dst, expected, replacement);
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_COMPARE_AND_SWAP_LOCK(64, dst, expected, replacement);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_load_explicit_8(volatile const ma_uint8* dst, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint8 result;
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    if (order == ma_atomic_memory_order_relaxed) {
+                        MA_ATOMIC_LOAD_RELAXED_GCC_X86("b", result, dst);
+                    } else if (order <= ma_atomic_memory_order_release) {
+                        MA_ATOMIC_LOAD_RELEASE_GCC_X86("b", result, dst);
+                    } else {
+                        MA_ATOMIC_LOAD_SEQ_CST_GCC_X86("b", result, dst);
+                    }
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_LOAD_EXPLICIT_LOCK(8, dst, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_load_explicit_16(volatile const ma_uint16* dst, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint16 result;
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    if (order == ma_atomic_memory_order_relaxed) {
+                        MA_ATOMIC_LOAD_RELAXED_GCC_X86("w", result, dst);
+                    } else if (order <= ma_atomic_memory_order_release) {
+                        MA_ATOMIC_LOAD_RELEASE_GCC_X86("w", result, dst);
+                    } else {
+                        MA_ATOMIC_LOAD_SEQ_CST_GCC_X86("w", result, dst);
+                    }
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_LOAD_EXPLICIT_LOCK(16, dst, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_load_explicit_32(volatile const ma_uint32* dst, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint32 result;
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    if (order == ma_atomic_memory_order_relaxed) {
+                        MA_ATOMIC_LOAD_RELAXED_GCC_X86("l", result, dst);
+                    } else if (order <= ma_atomic_memory_order_release) {
+                        MA_ATOMIC_LOAD_RELEASE_GCC_X86("l", result, dst);
+                    } else {
+                        MA_ATOMIC_LOAD_SEQ_CST_GCC_X86("l", result, dst);
+                    }
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_LOAD_EXPLICIT_LOCK(32, dst, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_load_explicit_64(volatile const ma_uint64* dst, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint64 result;
+                #if defined(MA_X64)
+                {
+                    if (order == ma_atomic_memory_order_relaxed) {
+                        MA_ATOMIC_LOAD_RELAXED_GCC_X86("q", result, dst);
+                    } else if (order <= ma_atomic_memory_order_release) {
+                        MA_ATOMIC_LOAD_RELEASE_GCC_X86("q", result, dst);
+                    } else {
+                        MA_ATOMIC_LOAD_SEQ_CST_GCC_X86("q", result, dst);
+                    }
+                }
+                #elif defined(MA_X86)
+                {
+                    (void)order;
+                    return ma_atomic_compare_and_swap_64((volatile ma_uint64*)dst, 0, 0);
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_LOAD_EXPLICIT_LOCK(64, dst, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_exchange_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint8 result;
+                (void)order;
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    MA_ATOMIC_XCHG_GCC_X86("b", result, dst, src);
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(8, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_exchange_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint16 result;
+                (void)order;
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    MA_ATOMIC_XCHG_GCC_X86("w", result, dst, src);
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(16, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_exchange_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint32 result;
+                (void)order;
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    MA_ATOMIC_XCHG_GCC_X86("l", result, dst, src);
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(32, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_exchange_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64) && (defined(MA_X86) || defined(MA_X64))
+            {
+                ma_uint64 result;
+                (void)order;
+                #if defined(MA_X86)
+                {
+                    MA_ATOMIC_EXCHANGE_EXPLICIT_CAS(64, dst, src, order);
+                }
+                #elif defined(MA_X64)
+                {
+                    MA_ATOMIC_XCHG_GCC_X86("q", result, dst, src);
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+                return result;
+            }
+            #else
+            {
+                MA_ATOMIC_EXCHANGE_EXPLICIT_LOCK(64, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE void ma_atomic_store_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8) && (defined(MA_X86) || defined(MA_X64))
+            {
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    if (order == ma_atomic_memory_order_relaxed) {
+                        __asm__ __volatile__ (
+                            "movb %1, %0"
+                            : "=m"(*dst)
+                            : "r"(src)
+                        );
+                    } else {
+                        __asm__ __volatile__ (
+                            "xchgb %1, %0"
+                            : "=m"(*dst)
+                            : "r"(src)
+                            : "memory"
+                        );
+                    }
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+            }
+            #else
+            {
+                MA_ATOMIC_STORE_EXPLICIT_LOCK(8, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE void ma_atomic_store_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16) && (defined(MA_X86) || defined(MA_X64))
+            {
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    if (order == ma_atomic_memory_order_relaxed) {
+                        __asm__ __volatile__ (
+                            "movw %1, %0"
+                            : "=m"(*dst)
+                            : "r"(src)
+                        );
+                    } else {
+                        __asm__ __volatile__ (
+                            "xchgw %1, %0"
+                            : "=m"(*dst)
+                            : "r"(src)
+                            : "memory"
+                        );
+                    }
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+            }
+            #else
+            {
+                MA_ATOMIC_STORE_EXPLICIT_LOCK(16, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE void ma_atomic_store_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32) && (defined(MA_X86) || defined(MA_X64))
+            {
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    if (order == ma_atomic_memory_order_relaxed) {
+                        __asm__ __volatile__ (
+                            "movl %1, %0"
+                            : "=m"(*dst)
+                            : "r"(src)
+                        );
+                    } else {
+                        __asm__ __volatile__ (
+                            "xchgl %1, %0"
+                            : "=m"(*dst)
+                            : "r"(src)
+                            : "memory"
+                        );
+                    }
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+            }
+            #else
+            {
+                MA_ATOMIC_STORE_EXPLICIT_LOCK(32, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE void ma_atomic_store_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64) && (defined(MA_X86) || defined(MA_X64))
+            {
+                #if defined(MA_X64)
+                {
+                    if (order == ma_atomic_memory_order_relaxed) {
+                        __asm__ __volatile__ (
+                            "movq %1, %0"
+                            : "=m"(*dst)
+                            : "r"(src)
+                        );
+                    } else {
+                        __asm__ __volatile__ (
+                            "xchgq %1, %0"
+                            : "=m"(*dst)
+                            : "r"(src)
+                            : "memory"
+                        );
+                    }
+                }
+                #else
+                {
+                    MA_ATOMIC_STORE_EXPLICIT_CAS(64, dst, src, order);
+                }
+                #endif
+            }
+            #else
+            {
+                MA_ATOMIC_STORE_EXPLICIT_LOCK(64, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_add_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_8) && (defined(MA_X86) || defined(MA_X64))
+            {
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    ma_uint8 result;
+                    (void)order;
+                    MA_ATOMIC_XADD_GCC_X86("b", result, dst, src);
+                    return result;
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(8, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_add_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_16) && (defined(MA_X86) || defined(MA_X64))
+            {
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    ma_uint16 result;
+                    (void)order;
+                    MA_ATOMIC_XADD_GCC_X86("w", result, dst, src);
+                    return result;
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(16, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_add_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_32) && (defined(MA_X86) || defined(MA_X64))
+            {
+                #if defined(MA_X86) || defined(MA_X64)
+                {
+                    ma_uint32 result;
+                    (void)order;
+                    MA_ATOMIC_XADD_GCC_X86("l", result, dst, src);
+                    return result;
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(32, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_add_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            #if defined(MA_ATOMIC_IS_LOCK_FREE_64) && (defined(MA_X86) || defined(MA_X64))
+            {
+                #if defined(MA_X86)
+                {
+                    MA_ATOMIC_FETCH_ADD_CAS(64, dst, src, order);
+                }
+                #elif defined(MA_X64)
+                {
+                    ma_uint64 result;
+                    MA_ATOMIC_XADD_GCC_X86("q", result, dst, src);
+                    (void)order;
+                    return result;
+                }
+                #else
+                {
+                    #error Unsupported architecture.
+                }
+                #endif
+            }
+            #else
+            {
+                MA_ATOMIC_FETCH_ADD_LOCK(64, dst, src, order);
+            }
+            #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_sub_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            return ma_atomic_fetch_add_explicit_8(dst, (ma_uint8)(-(ma_int8)src), order);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_sub_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            return ma_atomic_fetch_add_explicit_16(dst, (ma_uint16)(-(ma_int16)src), order);
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_sub_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            return ma_atomic_fetch_add_explicit_32(dst, (ma_uint32)(-(ma_int32)src), order);
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_sub_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            return ma_atomic_fetch_add_explicit_64(dst, (ma_uint64)(-(ma_int64)src), order);
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_and_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_AND_CAS(8, dst, src, order);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_and_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_AND_CAS(16, dst, src, order);
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_and_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_AND_CAS(32, dst, src, order);
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_and_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_AND_CAS(64, dst, src, order);
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_or_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_OR_CAS(8, dst, src, order);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_or_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_OR_CAS(16, dst, src, order);
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_or_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_OR_CAS(32, dst, src, order);
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_or_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_OR_CAS(64, dst, src, order);
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_xor_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_XOR_CAS(8, dst, src, order);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_xor_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_XOR_CAS(16, dst, src, order);
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_xor_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_XOR_CAS(32, dst, src, order);
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_xor_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            MA_ATOMIC_FETCH_XOR_CAS(64, dst, src, order);
+        }
+    #else
+        #error Unsupported compiler.
+    #endif
+#endif
+#if !defined(MA_ATOMIC_HAS_NATIVE_COMPARE_EXCHANGE)
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_8(volatile ma_uint8* dst, ma_uint8* expected, ma_uint8 replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        ma_uint8 result;
+        (void)successOrder;
+        (void)failureOrder;
+        result = ma_atomic_compare_and_swap_8(dst, *expected, replacement);
+        if (result == *expected) {
+            return 1;
+        } else {
+            *expected = result;
+            return 0;
+        }
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_16(volatile ma_uint16* dst, ma_uint16* expected, ma_uint16 replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        ma_uint16 result;
+        (void)successOrder;
+        (void)failureOrder;
+        result = ma_atomic_compare_and_swap_16(dst, *expected, replacement);
+        if (result == *expected) {
+            return 1;
+        } else {
+            *expected = result;
+            return 0;
+        }
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_32(volatile ma_uint32* dst, ma_uint32* expected, ma_uint32 replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        ma_uint32 result;
+        (void)successOrder;
+        (void)failureOrder;
+        result = ma_atomic_compare_and_swap_32(dst, *expected, replacement);
+        if (result == *expected) {
+            return 1;
+        } else {
+            *expected = result;
+            return 0;
+        }
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_64(volatile ma_uint64* dst, volatile ma_uint64* expected, ma_uint64 replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        ma_uint64 result;
+        (void)successOrder;
+        (void)failureOrder;
+        result = ma_atomic_compare_and_swap_64(dst, *expected, replacement);
+        if (result == *expected) {
+            return 1;
+        } else {
+            *expected = result;
+            return 0;
+        }
+    }
+    #define ma_atomic_compare_exchange_weak_explicit_8( dst, expected, replacement, successOrder, failureOrder) ma_atomic_compare_exchange_strong_explicit_8 (dst, expected, replacement, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_16(dst, expected, replacement, successOrder, failureOrder) ma_atomic_compare_exchange_strong_explicit_16(dst, expected, replacement, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_32(dst, expected, replacement, successOrder, failureOrder) ma_atomic_compare_exchange_strong_explicit_32(dst, expected, replacement, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_64(dst, expected, replacement, successOrder, failureOrder) ma_atomic_compare_exchange_strong_explicit_64(dst, expected, replacement, successOrder, failureOrder)
+#endif
+#if defined(MA_64BIT)
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_ptr(volatile void** ptr)
+    {
+        return ma_atomic_is_lock_free_64((volatile ma_uint64*)ptr);
+    }
+    static MA_INLINE void* ma_atomic_load_explicit_ptr(volatile void** ptr, ma_atomic_memory_order order)
+    {
+        return (void*)ma_atomic_load_explicit_64((volatile ma_uint64*)ptr, order);
+    }
+    static MA_INLINE void ma_atomic_store_explicit_ptr(volatile void** dst, void* src, ma_atomic_memory_order order)
+    {
+        ma_atomic_store_explicit_64((volatile ma_uint64*)dst, (ma_uint64)src, order);
+    }
+    static MA_INLINE void* ma_atomic_exchange_explicit_ptr(volatile void** dst, void* src, ma_atomic_memory_order order)
+    {
+        return (void*)ma_atomic_exchange_explicit_64((volatile ma_uint64*)dst, (ma_uint64)src, order);
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_ptr(volatile void** dst, void** expected, void* replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        return ma_atomic_compare_exchange_strong_explicit_64((volatile ma_uint64*)dst, (ma_uint64*)expected, (ma_uint64)replacement, successOrder, failureOrder);
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_weak_explicit_ptr(volatile void** dst, void** expected, void* replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        return ma_atomic_compare_exchange_weak_explicit_64((volatile ma_uint64*)dst, (ma_uint64*)expected, (ma_uint64)replacement, successOrder, failureOrder);
+    }
+    static MA_INLINE void* ma_atomic_compare_and_swap_ptr(volatile void** dst, void* expected, void* replacement)
+    {
+        return (void*)ma_atomic_compare_and_swap_64((volatile ma_uint64*)dst, (ma_uint64)expected, (ma_uint64)replacement);
+    }
+#elif defined(MA_32BIT)
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_ptr(volatile void** ptr)
+    {
+        return ma_atomic_is_lock_free_32((volatile ma_uint32*)ptr);
+    }
+    static MA_INLINE void* ma_atomic_load_explicit_ptr(volatile void** ptr, ma_atomic_memory_order order)
+    {
+        return (void*)ma_atomic_load_explicit_32((volatile ma_uint32*)ptr, order);
+    }
+    static MA_INLINE void ma_atomic_store_explicit_ptr(volatile void** dst, void* src, ma_atomic_memory_order order)
+    {
+        ma_atomic_store_explicit_32((volatile ma_uint32*)dst, (ma_uint32)src, order);
+    }
+    static MA_INLINE void* ma_atomic_exchange_explicit_ptr(volatile void** dst, void* src, ma_atomic_memory_order order)
+    {
+        return (void*)ma_atomic_exchange_explicit_32((volatile ma_uint32*)dst, (ma_uint32)src, order);
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_ptr(volatile void** dst, void** expected, void* replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        return ma_atomic_compare_exchange_strong_explicit_32((volatile ma_uint32*)dst, (ma_uint32*)expected, (ma_uint32)replacement, successOrder, failureOrder);
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_weak_explicit_ptr(volatile void** dst, void** expected, void* replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        return ma_atomic_compare_exchange_weak_explicit_32((volatile ma_uint32*)dst, (ma_uint32*)expected, (ma_uint32)replacement, successOrder, failureOrder);
+    }
+    static MA_INLINE void* ma_atomic_compare_and_swap_ptr(volatile void** dst, void* expected, void* replacement)
+    {
+        return (void*)ma_atomic_compare_and_swap_32((volatile ma_uint32*)dst, (ma_uint32)expected, (ma_uint32)replacement);
+    }
+#else
+    #error Unsupported architecture.
+#endif
+#define ma_atomic_store_ptr(dst, src)                                       ma_atomic_store_explicit_ptr((volatile void**)dst, (void*)src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_ptr(ptr)                                             ma_atomic_load_explicit_ptr((volatile void**)ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_ptr(dst, src)                                    ma_atomic_exchange_explicit_ptr((volatile void**)dst, (void*)src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_ptr(dst, expected, replacement)   ma_atomic_compare_exchange_strong_explicit_ptr((volatile void**)dst, (void**)expected, (void*)replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_ptr(dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_ptr((volatile void**)dst, (void**)expected, (void*)replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_8( dst, src)                                    ma_atomic_store_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_16(dst, src)                                    ma_atomic_store_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_32(dst, src)                                    ma_atomic_store_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_64(dst, src)                                    ma_atomic_store_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_8( ptr)                                          ma_atomic_load_explicit_8( ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_16(ptr)                                          ma_atomic_load_explicit_16(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_32(ptr)                                          ma_atomic_load_explicit_32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_64(ptr)                                          ma_atomic_load_explicit_64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_8( dst, src)                                 ma_atomic_exchange_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_16(dst, src)                                 ma_atomic_exchange_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_32(dst, src)                                 ma_atomic_exchange_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_64(dst, src)                                 ma_atomic_exchange_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_8( dst, expected, replacement)    ma_atomic_compare_exchange_strong_explicit_8( dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_16(dst, expected, replacement)    ma_atomic_compare_exchange_strong_explicit_16(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_32(dst, expected, replacement)    ma_atomic_compare_exchange_strong_explicit_32(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_64(dst, expected, replacement)    ma_atomic_compare_exchange_strong_explicit_64(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_8(  dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_8( dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_16( dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_16(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_32( dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_32(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_64( dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_64(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_8( dst, src)                                ma_atomic_fetch_add_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_16(dst, src)                                ma_atomic_fetch_add_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_32(dst, src)                                ma_atomic_fetch_add_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_64(dst, src)                                ma_atomic_fetch_add_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_8( dst, src)                                ma_atomic_fetch_sub_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_16(dst, src)                                ma_atomic_fetch_sub_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_32(dst, src)                                ma_atomic_fetch_sub_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_64(dst, src)                                ma_atomic_fetch_sub_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_8( dst, src)                                 ma_atomic_fetch_or_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_16(dst, src)                                 ma_atomic_fetch_or_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_32(dst, src)                                 ma_atomic_fetch_or_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_64(dst, src)                                 ma_atomic_fetch_or_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_8( dst, src)                                ma_atomic_fetch_xor_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_16(dst, src)                                ma_atomic_fetch_xor_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_32(dst, src)                                ma_atomic_fetch_xor_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_64(dst, src)                                ma_atomic_fetch_xor_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_8( dst, src)                                ma_atomic_fetch_and_explicit_8 (dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_16(dst, src)                                ma_atomic_fetch_and_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_32(dst, src)                                ma_atomic_fetch_and_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_64(dst, src)                                ma_atomic_fetch_and_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_explicit_i8( dst, src, order)                   ma_atomic_store_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_store_explicit_i16(dst, src, order)                   ma_atomic_store_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_store_explicit_i32(dst, src, order)                   ma_atomic_store_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_store_explicit_i64(dst, src, order)                   ma_atomic_store_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_load_explicit_i8( ptr, order)                         (ma_int8 )ma_atomic_load_explicit_8( (ma_uint8* )ptr, order)
+#define ma_atomic_load_explicit_i16(ptr, order)                         (ma_int16)ma_atomic_load_explicit_16((ma_uint16*)ptr, order)
+#define ma_atomic_load_explicit_i32(ptr, order)                         (ma_int32)ma_atomic_load_explicit_32((ma_uint32*)ptr, order)
+#define ma_atomic_load_explicit_i64(ptr, order)                         (ma_int64)ma_atomic_load_explicit_64((ma_uint64*)ptr, order)
+#define ma_atomic_exchange_explicit_i8( dst, src, order)                (ma_int8 )ma_atomic_exchange_explicit_8 ((ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_exchange_explicit_i16(dst, src, order)                (ma_int16)ma_atomic_exchange_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_exchange_explicit_i32(dst, src, order)                (ma_int32)ma_atomic_exchange_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_exchange_explicit_i64(dst, src, order)                (ma_int64)ma_atomic_exchange_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_compare_exchange_strong_explicit_i8( dst, expected, replacement, successOrder, failureOrder)  ma_atomic_compare_exchange_strong_explicit_8( (ma_uint8* )dst, (ma_uint8* )expected, (ma_uint8 )replacement, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_strong_explicit_i16(dst, expected, replacement, successOrder, failureOrder)  ma_atomic_compare_exchange_strong_explicit_16((ma_uint16*)dst, (ma_uint16*)expected, (ma_uint16)replacement, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_strong_explicit_i32(dst, expected, replacement, successOrder, failureOrder)  ma_atomic_compare_exchange_strong_explicit_32((ma_uint32*)dst, (ma_uint32*)expected, (ma_uint32)replacement, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_strong_explicit_i64(dst, expected, replacement, successOrder, failureOrder)  ma_atomic_compare_exchange_strong_explicit_64((ma_uint64*)dst, (ma_uint64*)expected, (ma_uint64)replacement, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_weak_explicit_i8( dst, expected, replacement, successOrder, failureOrder)    ma_atomic_compare_exchange_weak_explicit_8( (ma_uint8* )dst, (ma_uint8* )expected, (ma_uint8 )replacement, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_weak_explicit_i16(dst, expected, replacement, successOrder, failureOrder)    ma_atomic_compare_exchange_weak_explicit_16((ma_uint16*)dst, (ma_uint16*)expected, (ma_uint16)replacement, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_weak_explicit_i32(dst, expected, replacement, successOrder, failureOrder)    ma_atomic_compare_exchange_weak_explicit_32((ma_uint32*)dst, (ma_uint32*)expected, (ma_uint32)replacement, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_weak_explicit_i64(dst, expected, replacement, successOrder, failureOrder)    ma_atomic_compare_exchange_weak_explicit_64((ma_uint64*)dst, (ma_uint64*)expected, (ma_uint64)replacement, successOrder, failureOrder)
+#define ma_atomic_fetch_add_explicit_i8( dst, src, order)               (ma_int8 )ma_atomic_fetch_add_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_add_explicit_i16(dst, src, order)               (ma_int16)ma_atomic_fetch_add_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_add_explicit_i32(dst, src, order)               (ma_int32)ma_atomic_fetch_add_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_add_explicit_i64(dst, src, order)               (ma_int64)ma_atomic_fetch_add_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_fetch_sub_explicit_i8( dst, src, order)               (ma_int8 )ma_atomic_fetch_sub_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_sub_explicit_i16(dst, src, order)               (ma_int16)ma_atomic_fetch_sub_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_sub_explicit_i32(dst, src, order)               (ma_int32)ma_atomic_fetch_sub_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_sub_explicit_i64(dst, src, order)               (ma_int64)ma_atomic_fetch_sub_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_fetch_or_explicit_i8( dst, src, order)                (ma_int8 )ma_atomic_fetch_or_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_or_explicit_i16(dst, src, order)                (ma_int16)ma_atomic_fetch_or_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_or_explicit_i32(dst, src, order)                (ma_int32)ma_atomic_fetch_or_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_or_explicit_i64(dst, src, order)                (ma_int64)ma_atomic_fetch_or_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_fetch_xor_explicit_i8( dst, src, order)               (ma_int8 )ma_atomic_fetch_xor_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_xor_explicit_i16(dst, src, order)               (ma_int16)ma_atomic_fetch_xor_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_xor_explicit_i32(dst, src, order)               (ma_int32)ma_atomic_fetch_xor_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_xor_explicit_i64(dst, src, order)               (ma_int64)ma_atomic_fetch_xor_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_fetch_and_explicit_i8( dst, src, order)               (ma_int8 )ma_atomic_fetch_and_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_and_explicit_i16(dst, src, order)               (ma_int16)ma_atomic_fetch_and_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_and_explicit_i32(dst, src, order)               (ma_int32)ma_atomic_fetch_and_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_and_explicit_i64(dst, src, order)               (ma_int64)ma_atomic_fetch_and_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_store_i8( dst, src)                                   ma_atomic_store_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_i16(dst, src)                                   ma_atomic_store_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_i32(dst, src)                                   ma_atomic_store_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_i64(dst, src)                                   ma_atomic_store_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_i8( ptr)                                         ma_atomic_load_explicit_i8( ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_i16(ptr)                                         ma_atomic_load_explicit_i16(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_i32(ptr)                                         ma_atomic_load_explicit_i32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_i64(ptr)                                         ma_atomic_load_explicit_i64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_i8( dst, src)                                ma_atomic_exchange_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_i16(dst, src)                                ma_atomic_exchange_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_i32(dst, src)                                ma_atomic_exchange_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_i64(dst, src)                                ma_atomic_exchange_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_i8( dst, expected, replacement)   ma_atomic_compare_exchange_strong_explicit_i8( dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_i16(dst, expected, replacement)   ma_atomic_compare_exchange_strong_explicit_i16(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_i32(dst, expected, replacement)   ma_atomic_compare_exchange_strong_explicit_i32(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_i64(dst, expected, replacement)   ma_atomic_compare_exchange_strong_explicit_i64(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_i8( dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_i8( dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_i16(dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_i16(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_i32(dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_i32(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_i64(dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_i64(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_i8( dst, src)                               ma_atomic_fetch_add_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_i16(dst, src)                               ma_atomic_fetch_add_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_i32(dst, src)                               ma_atomic_fetch_add_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_i64(dst, src)                               ma_atomic_fetch_add_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_i8( dst, src)                               ma_atomic_fetch_sub_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_i16(dst, src)                               ma_atomic_fetch_sub_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_i32(dst, src)                               ma_atomic_fetch_sub_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_i64(dst, src)                               ma_atomic_fetch_sub_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_i8( dst, src)                                ma_atomic_fetch_or_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_i16(dst, src)                                ma_atomic_fetch_or_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_i32(dst, src)                                ma_atomic_fetch_or_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_i64(dst, src)                                ma_atomic_fetch_or_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_i8( dst, src)                               ma_atomic_fetch_xor_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_i16(dst, src)                               ma_atomic_fetch_xor_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_i32(dst, src)                               ma_atomic_fetch_xor_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_i64(dst, src)                               ma_atomic_fetch_xor_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_i8( dst, src)                               ma_atomic_fetch_and_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_i16(dst, src)                               ma_atomic_fetch_and_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_i32(dst, src)                               ma_atomic_fetch_and_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_i64(dst, src)                               ma_atomic_fetch_and_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_and_swap_i8( dst, expected, dedsired)         (ma_int8 )ma_atomic_compare_and_swap_8( (ma_uint8* )dst, (ma_uint8 )expected, (ma_uint8 )dedsired)
+#define ma_atomic_compare_and_swap_i16(dst, expected, dedsired)         (ma_int16)ma_atomic_compare_and_swap_16((ma_uint16*)dst, (ma_uint16)expected, (ma_uint16)dedsired)
+#define ma_atomic_compare_and_swap_i32(dst, expected, dedsired)         (ma_int32)ma_atomic_compare_and_swap_32((ma_uint32*)dst, (ma_uint32)expected, (ma_uint32)dedsired)
+#define ma_atomic_compare_and_swap_i64(dst, expected, dedsired)         (ma_int64)ma_atomic_compare_and_swap_64((ma_uint64*)dst, (ma_uint64)expected, (ma_uint64)dedsired)
+typedef union
+{
+    ma_uint32 i;
+    float f;
+} ma_atomic_if32;
+typedef union
+{
+    ma_uint64 i;
+    double f;
+} ma_atomic_if64;
+#define ma_atomic_clear_explicit_f32(ptr, order)                        ma_atomic_clear_explicit_32((ma_uint32*)ptr, order)
+#define ma_atomic_clear_explicit_f64(ptr, order)                        ma_atomic_clear_explicit_64((ma_uint64*)ptr, order)
+static MA_INLINE void ma_atomic_store_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 x;
+    x.f = src;
+    ma_atomic_store_explicit_32((volatile ma_uint32*)dst, x.i, order);
+}
+static MA_INLINE void ma_atomic_store_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 x;
+    x.f = src;
+    ma_atomic_store_explicit_64((volatile ma_uint64*)dst, x.i, order);
+}
+static MA_INLINE float ma_atomic_load_explicit_f32(volatile const float* ptr, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    r.i = ma_atomic_load_explicit_32((volatile const ma_uint32*)ptr, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_load_explicit_f64(volatile const double* ptr, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    r.i = ma_atomic_load_explicit_64((volatile const ma_uint64*)ptr, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_exchange_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_exchange_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_exchange_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_exchange_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_f32(volatile float* dst, float* expected, float replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+{
+    ma_atomic_if32 d;
+    d.f = replacement;
+    return ma_atomic_compare_exchange_strong_explicit_32((volatile ma_uint32*)dst, (ma_uint32*)expected, d.i, successOrder, failureOrder);
+}
+static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_f64(volatile double* dst, double* expected, double replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+{
+    ma_atomic_if64 d;
+    d.f = replacement;
+    return ma_atomic_compare_exchange_strong_explicit_64((volatile ma_uint64*)dst, (ma_uint64*)expected, d.i, successOrder, failureOrder);
+}
+static MA_INLINE ma_bool32 ma_atomic_compare_exchange_weak_explicit_f32(volatile float* dst, float* expected, float replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+{
+    ma_atomic_if32 d;
+    d.f = replacement;
+    return ma_atomic_compare_exchange_weak_explicit_32((volatile ma_uint32*)dst, (ma_uint32*)expected, d.i, successOrder, failureOrder);
+}
+static MA_INLINE ma_bool32 ma_atomic_compare_exchange_weak_explicit_f64(volatile double* dst, double* expected, double replacement, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+{
+    ma_atomic_if64 d;
+    d.f = replacement;
+    return ma_atomic_compare_exchange_weak_explicit_64((volatile ma_uint64*)dst, (ma_uint64*)expected, d.i, successOrder, failureOrder);
+}
+static MA_INLINE float ma_atomic_fetch_add_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_add_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_add_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_add_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_fetch_sub_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_sub_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_sub_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_sub_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_fetch_or_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_or_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_or_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_or_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_fetch_xor_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_xor_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_xor_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_xor_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_fetch_and_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_and_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_and_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_and_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+#define ma_atomic_clear_f32(ptr)                                        (float )ma_atomic_clear_explicit_f32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_f64(ptr)                                        (double)ma_atomic_clear_explicit_f64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_f32(dst, src)                                   ma_atomic_store_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_f64(dst, src)                                   ma_atomic_store_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_f32(ptr)                                         (float )ma_atomic_load_explicit_f32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_f64(ptr)                                         (double)ma_atomic_load_explicit_f64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_f32(dst, src)                                (float )ma_atomic_exchange_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_f64(dst, src)                                (double)ma_atomic_exchange_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_f32(dst, expected, replacement)   ma_atomic_compare_exchange_strong_explicit_f32(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_f64(dst, expected, replacement)   ma_atomic_compare_exchange_strong_explicit_f64(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_f32(dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_f32(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_f64(dst, expected, replacement)     ma_atomic_compare_exchange_weak_explicit_f64(dst, expected, replacement, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_f32(dst, src)                               ma_atomic_fetch_add_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_f64(dst, src)                               ma_atomic_fetch_add_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_f32(dst, src)                               ma_atomic_fetch_sub_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_f64(dst, src)                               ma_atomic_fetch_sub_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_f32(dst, src)                                ma_atomic_fetch_or_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_f64(dst, src)                                ma_atomic_fetch_or_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_f32(dst, src)                               ma_atomic_fetch_xor_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_f64(dst, src)                               ma_atomic_fetch_xor_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_f32(dst, src)                               ma_atomic_fetch_and_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_f64(dst, src)                               ma_atomic_fetch_and_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+static MA_INLINE float ma_atomic_compare_and_swap_f32(volatile float* dst, float expected, float replacement)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 e, d;
+    e.f = expected;
+    d.f = replacement;
+    r.i = ma_atomic_compare_and_swap_32((volatile ma_uint32*)dst, e.i, d.i);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_compare_and_swap_f64(volatile double* dst, double expected, double replacement)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 e, d;
+    e.f = expected;
+    d.f = replacement;
+    r.i = ma_atomic_compare_and_swap_64((volatile ma_uint64*)dst, e.i, d.i);
+    return r.f;
+}
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic pop
+#endif
+#if defined(__cplusplus)
+}
+#endif
+#endif
+/* c89atomic.h end */
+
+#define MA_ATOMIC_SAFE_TYPE_IMPL(c89TypeExtension, type) \
+    static MA_INLINE ma_##type ma_atomic_##type##_get(ma_atomic_##type* x) \
+    { \
+        return (ma_##type)ma_atomic_load_##c89TypeExtension(&x->value); \
+    } \
+    static MA_INLINE void ma_atomic_##type##_set(ma_atomic_##type* x, ma_##type value) \
+    { \
+        ma_atomic_store_##c89TypeExtension(&x->value, value); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_exchange(ma_atomic_##type* x, ma_##type value) \
+    { \
+        return (ma_##type)ma_atomic_exchange_##c89TypeExtension(&x->value, value); \
+    } \
+    static MA_INLINE ma_bool32 ma_atomic_##type##_compare_exchange(ma_atomic_##type* x, ma_##type* expected, ma_##type desired) \
+    { \
+        return ma_atomic_compare_exchange_weak_##c89TypeExtension(&x->value, expected, desired); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_add(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_add_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_sub(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_sub_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_or(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_or_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_xor(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_xor_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_and(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_and_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_compare_and_swap(ma_atomic_##type* x, ma_##type expected, ma_##type desired) \
+    { \
+        return (ma_##type)ma_atomic_compare_and_swap_##c89TypeExtension(&x->value, expected, desired); \
+    } \
+
+#define MA_ATOMIC_SAFE_TYPE_IMPL_PTR(type) \
+    static MA_INLINE ma_##type* ma_atomic_ptr_##type##_get(ma_atomic_ptr_##type* x) \
+    { \
+        return ma_atomic_load_ptr((void**)&x->value); \
+    } \
+    static MA_INLINE void ma_atomic_ptr_##type##_set(ma_atomic_ptr_##type* x, ma_##type* value) \
+    { \
+        ma_atomic_store_ptr((void**)&x->value, (void*)value); \
+    } \
+    static MA_INLINE ma_##type* ma_atomic_ptr_##type##_exchange(ma_atomic_ptr_##type* x, ma_##type* value) \
+    { \
+        return ma_atomic_exchange_ptr((void**)&x->value, (void*)value); \
+    } \
+    static MA_INLINE ma_bool32 ma_atomic_ptr_##type##_compare_exchange(ma_atomic_ptr_##type* x, ma_##type** expected, ma_##type* desired) \
+    { \
+        return ma_atomic_compare_exchange_weak_ptr((void**)&x->value, (void*)expected, (void*)desired); \
+    } \
+    static MA_INLINE ma_##type* ma_atomic_ptr_##type##_compare_and_swap(ma_atomic_ptr_##type* x, ma_##type* expected, ma_##type* desired) \
+    { \
+        return (ma_##type*)ma_atomic_compare_and_swap_ptr((void**)&x->value, (void*)expected, (void*)desired); \
+    } \
+
+MA_ATOMIC_SAFE_TYPE_IMPL(32,  uint32)
+MA_ATOMIC_SAFE_TYPE_IMPL(i32, int32)
+MA_ATOMIC_SAFE_TYPE_IMPL(64,  uint64)
+MA_ATOMIC_SAFE_TYPE_IMPL(f32, float)
+MA_ATOMIC_SAFE_TYPE_IMPL(32,  bool32)
+
+#if !defined(MA_NO_DEVICE_IO)
+MA_ATOMIC_SAFE_TYPE_IMPL(i32, device_state)
+#endif
+
+
+MA_API ma_uint64 ma_calculate_frame_count_after_resampling(ma_uint32 sampleRateOut, ma_uint32 sampleRateIn, ma_uint64 frameCountIn)
+{
+    /* This is based on the calculation in ma_linear_resampler_get_expected_output_frame_count(). */
+    ma_uint64 outputFrameCount;
+    ma_uint64 preliminaryInputFrameCountFromFrac;
+    ma_uint64 preliminaryInputFrameCount;
+
+    if (sampleRateIn == 0 || sampleRateOut == 0 || frameCountIn == 0) {
+        return 0;
+    }
+
+    if (sampleRateOut == sampleRateIn) {
+        return frameCountIn;
+    }
+
+    outputFrameCount = (frameCountIn * sampleRateOut) / sampleRateIn;
+
+    preliminaryInputFrameCountFromFrac = (outputFrameCount * (sampleRateIn / sampleRateOut)) / sampleRateOut;
+    preliminaryInputFrameCount         = (outputFrameCount * (sampleRateIn % sampleRateOut)) + preliminaryInputFrameCountFromFrac;
+
+    if (preliminaryInputFrameCount <= frameCountIn) {
+        outputFrameCount += 1;
+    }
+
+    return outputFrameCount;
+}
+
+#ifndef MA_DATA_CONVERTER_STACK_BUFFER_SIZE
+#define MA_DATA_CONVERTER_STACK_BUFFER_SIZE     4096
+#endif
+
+
+
+#if defined(MA_WIN32)
+static ma_result ma_result_from_GetLastError(DWORD error)
+{
+    switch (error)
+    {
+        case ERROR_SUCCESS:             return MA_SUCCESS;
+        case ERROR_PATH_NOT_FOUND:      return MA_DOES_NOT_EXIST;
+        case ERROR_TOO_MANY_OPEN_FILES: return MA_TOO_MANY_OPEN_FILES;
+        case ERROR_NOT_ENOUGH_MEMORY:   return MA_OUT_OF_MEMORY;
+        case ERROR_DISK_FULL:           return MA_NO_SPACE;
+        case ERROR_HANDLE_EOF:          return MA_AT_END;
+        case ERROR_NEGATIVE_SEEK:       return MA_BAD_SEEK;
+        case ERROR_INVALID_PARAMETER:   return MA_INVALID_ARGS;
+        case ERROR_ACCESS_DENIED:       return MA_ACCESS_DENIED;
+        case ERROR_SEM_TIMEOUT:         return MA_TIMEOUT;
+        case ERROR_FILE_NOT_FOUND:      return MA_DOES_NOT_EXIST;
+        default: break;
+    }
+
+    return MA_ERROR;
+}
+#endif  /* MA_WIN32 */
+
+
+/*******************************************************************************
+
+Threading
+
+*******************************************************************************/
+static MA_INLINE ma_result ma_spinlock_lock_ex(volatile ma_spinlock* pSpinlock, ma_bool32 yield)
+{
+    if (pSpinlock == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (;;) {
+        if (ma_atomic_exchange_explicit_32(pSpinlock, 1, ma_atomic_memory_order_acquire) == 0) {
+            break;
+        }
+
+        while (ma_atomic_load_explicit_32(pSpinlock, ma_atomic_memory_order_relaxed) == 1) {
+            if (yield) {
+                ma_yield();
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spinlock_lock(volatile ma_spinlock* pSpinlock)
+{
+    return ma_spinlock_lock_ex(pSpinlock, MA_TRUE);
+}
+
+MA_API ma_result ma_spinlock_lock_noyield(volatile ma_spinlock* pSpinlock)
+{
+    return ma_spinlock_lock_ex(pSpinlock, MA_FALSE);
+}
+
+MA_API ma_result ma_spinlock_unlock(volatile ma_spinlock* pSpinlock)
+{
+    if (pSpinlock == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_store_explicit_32(pSpinlock, 0, ma_atomic_memory_order_release);
+    return MA_SUCCESS;
+}
+
+
+#ifndef MA_NO_THREADING
+#if defined(MA_POSIX)
+    #define MA_THREADCALL
+    typedef void* ma_thread_result;
+#elif defined(MA_WIN32)
+    #define MA_THREADCALL WINAPI
+    typedef unsigned long ma_thread_result;
+#endif
+
+typedef ma_thread_result (MA_THREADCALL * ma_thread_entry_proc)(void* pData);
+
+#ifdef MA_POSIX
+static ma_result ma_thread_create__posix(ma_thread* pThread, ma_thread_priority priority, size_t stackSize, ma_thread_entry_proc entryProc, void* pData)
+{
+    int result;
+    pthread_attr_t* pAttr = NULL;
+
+#if !defined(MA_EMSCRIPTEN) && !defined(MA_3DS) && !defined(MA_SWITCH)
+    /* Try setting the thread priority. It's not critical if anything fails here. */
+    pthread_attr_t attr;
+    if (pthread_attr_init(&attr) == 0) {
+        int scheduler = -1;
+
+        /* We successfully initialized our attributes object so we can assign the pointer so it's passed into pthread_create(). */
+        pAttr = &attr;
+
+        /* We need to set the scheduler policy. Only do this if the OS supports pthread_attr_setschedpolicy() */
+        #if !defined(MA_BEOS)
+        {
+            if (priority == ma_thread_priority_idle) {
+            #ifdef SCHED_IDLE
+                if (pthread_attr_setschedpolicy(&attr, SCHED_IDLE) == 0) {
+                    scheduler = SCHED_IDLE;
+                }
+            #endif
+            } else if (priority == ma_thread_priority_realtime) {
+            #ifdef SCHED_FIFO
+                if (pthread_attr_setschedpolicy(&attr, SCHED_FIFO) == 0) {
+                    scheduler = SCHED_FIFO;
+                }
+            #endif
+            #ifdef MA_LINUX
+            } else {
+                scheduler = sched_getscheduler(0);
+            #endif
+            }
+        }
+        #endif
+
+        #if defined(_POSIX_THREAD_ATTR_STACKSIZE) && _POSIX_THREAD_ATTR_STACKSIZE >= 0
+        {
+            if (stackSize > 0) {
+                pthread_attr_setstacksize(&attr, stackSize);
+            }
+        }
+        #else
+        {
+            (void)stackSize;  /* Suppress unused parameter warning. */
+        }
+        #endif
+        
+
+        if (scheduler != -1) {
+            int priorityMin = sched_get_priority_min(scheduler);
+            int priorityMax = sched_get_priority_max(scheduler);
+            int priorityStep = (priorityMax - priorityMin) / 7;  /* 7 = number of priorities supported by miniaudio. */
+
+            struct sched_param sched;
+            if (pthread_attr_getschedparam(&attr, &sched) == 0) {
+                if (priority == ma_thread_priority_idle) {
+                    sched.sched_priority = priorityMin;
+                } else if (priority == ma_thread_priority_realtime) {
+                    #if defined(MA_PTHREAD_REALTIME_THREAD_PRIORITY)
+                    {
+                        sched.sched_priority = MA_PTHREAD_REALTIME_THREAD_PRIORITY;
+                    }
+                    #else
+                    {
+                        sched.sched_priority = priorityMax;
+                    }
+                    #endif
+                } else {
+                    sched.sched_priority += ((int)priority + 5) * priorityStep;  /* +5 because the lowest priority is -5. */
+                }
+
+                if (sched.sched_priority < priorityMin) {
+                    sched.sched_priority = priorityMin;
+                }
+                if (sched.sched_priority > priorityMax) {
+                    sched.sched_priority = priorityMax;
+                }
+
+                /* I'm not treating a failure of setting the priority as a critical error so not aborting on failure here. */
+                if (pthread_attr_setschedparam(&attr, &sched) == 0) {
+                    #if !defined(MA_ANDROID) || (defined(__ANDROID_API__) && __ANDROID_API__ >= 28)
+                    {
+                        pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+                    }
+                    #endif
+                }
+            }
+        }
+    }
+#else
+    /* It's the emscripten build. We'll have a few unused parameters. */
+    (void)priority;
+    (void)stackSize;
+#endif
+
+    result = pthread_create((pthread_t*)pThread, pAttr, entryProc, pData);
+
+    /* The thread attributes object is no longer required. */
+    if (pAttr != NULL) {
+        pthread_attr_destroy(pAttr);
+    }
+
+    if (result != 0) {
+        /*
+        There have been reports that attempting to create a realtime thread can sometimes fail. In this case,
+        fall back to a normal priority thread.
+
+        I'm including a compile-time option here to disable this functionality for those who have a hard
+        requirement on realtime threads and would rather an explicit failure.
+        */
+        #ifndef MA_NO_PTHREAD_REALTIME_PRIORITY_FALLBACK
+        {
+            if(result == EPERM && priority == ma_thread_priority_realtime) {
+                return ma_thread_create__posix(pThread, ma_thread_priority_normal, stackSize, entryProc, pData);
+            }
+        }
+        #endif
+
+        return ma_result_from_errno(result);
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_thread_wait__posix(ma_thread* pThread)
+{
+    pthread_join((pthread_t)*pThread, NULL);
+}
+
+
+static ma_result ma_mutex_init__posix(ma_mutex* pMutex)
+{
+    int result;
+
+    if (pMutex == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pMutex);
+
+    result = pthread_mutex_init((pthread_mutex_t*)pMutex, NULL);
+    if (result != 0) {
+        return ma_result_from_errno(result);
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_mutex_uninit__posix(ma_mutex* pMutex)
+{
+    pthread_mutex_destroy((pthread_mutex_t*)pMutex);
+}
+
+static void ma_mutex_lock__posix(ma_mutex* pMutex)
+{
+    pthread_mutex_lock((pthread_mutex_t*)pMutex);
+}
+
+static void ma_mutex_unlock__posix(ma_mutex* pMutex)
+{
+    pthread_mutex_unlock((pthread_mutex_t*)pMutex);
+}
+
+
+static ma_result ma_event_init__posix(ma_event* pEvent)
+{
+    int result;
+
+    result = pthread_mutex_init((pthread_mutex_t*)&pEvent->lock, NULL);
+    if (result != 0) {
+        return ma_result_from_errno(result);
+    }
+
+    result = pthread_cond_init((pthread_cond_t*)&pEvent->cond, NULL);
+    if (result != 0) {
+        pthread_mutex_destroy((pthread_mutex_t*)&pEvent->lock);
+        return ma_result_from_errno(result);
+    }
+
+    pEvent->value = 0;
+    return MA_SUCCESS;
+}
+
+static void ma_event_uninit__posix(ma_event* pEvent)
+{
+    pthread_cond_destroy((pthread_cond_t*)&pEvent->cond);
+    pthread_mutex_destroy((pthread_mutex_t*)&pEvent->lock);
+}
+
+static ma_result ma_event_wait__posix(ma_event* pEvent)
+{
+    pthread_mutex_lock((pthread_mutex_t*)&pEvent->lock);
+    {
+        while (pEvent->value == 0) {
+            pthread_cond_wait((pthread_cond_t*)&pEvent->cond, (pthread_mutex_t*)&pEvent->lock);
+        }
+        pEvent->value = 0;  /* Auto-reset. */
+    }
+    pthread_mutex_unlock((pthread_mutex_t*)&pEvent->lock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_event_signal__posix(ma_event* pEvent)
+{
+    pthread_mutex_lock((pthread_mutex_t*)&pEvent->lock);
+    {
+        pEvent->value = 1;
+        pthread_cond_signal((pthread_cond_t*)&pEvent->cond);
+    }
+    pthread_mutex_unlock((pthread_mutex_t*)&pEvent->lock);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_semaphore_init__posix(int initialValue, ma_semaphore* pSemaphore)
+{
+    int result;
+
+    if (pSemaphore == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pSemaphore->value = initialValue;
+
+    result = pthread_mutex_init((pthread_mutex_t*)&pSemaphore->lock, NULL);
+    if (result != 0) {
+        return ma_result_from_errno(result);  /* Failed to create mutex. */
+    }
+
+    result = pthread_cond_init((pthread_cond_t*)&pSemaphore->cond, NULL);
+    if (result != 0) {
+        pthread_mutex_destroy((pthread_mutex_t*)&pSemaphore->lock);
+        return ma_result_from_errno(result);  /* Failed to create condition variable. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_semaphore_uninit__posix(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        return;
+    }
+
+    pthread_cond_destroy((pthread_cond_t*)&pSemaphore->cond);
+    pthread_mutex_destroy((pthread_mutex_t*)&pSemaphore->lock);
+}
+
+static ma_result ma_semaphore_wait__posix(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pthread_mutex_lock((pthread_mutex_t*)&pSemaphore->lock);
+    {
+        /* We need to wait on a condition variable before escaping. We can't return from this function until the semaphore has been signaled. */
+        while (pSemaphore->value == 0) {
+            pthread_cond_wait((pthread_cond_t*)&pSemaphore->cond, (pthread_mutex_t*)&pSemaphore->lock);
+        }
+
+        pSemaphore->value -= 1;
+    }
+    pthread_mutex_unlock((pthread_mutex_t*)&pSemaphore->lock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_semaphore_release__posix(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pthread_mutex_lock((pthread_mutex_t*)&pSemaphore->lock);
+    {
+        pSemaphore->value += 1;
+        pthread_cond_signal((pthread_cond_t*)&pSemaphore->cond);
+    }
+    pthread_mutex_unlock((pthread_mutex_t*)&pSemaphore->lock);
+
+    return MA_SUCCESS;
+}
+#elif defined(MA_WIN32)
+static int ma_thread_priority_to_win32(ma_thread_priority priority)
+{
+    switch (priority) {
+        case ma_thread_priority_idle:     return THREAD_PRIORITY_IDLE;
+        case ma_thread_priority_lowest:   return THREAD_PRIORITY_LOWEST;
+        case ma_thread_priority_low:      return THREAD_PRIORITY_BELOW_NORMAL;
+        case ma_thread_priority_normal:   return THREAD_PRIORITY_NORMAL;
+        case ma_thread_priority_high:     return THREAD_PRIORITY_ABOVE_NORMAL;
+        case ma_thread_priority_highest:  return THREAD_PRIORITY_HIGHEST;
+        case ma_thread_priority_realtime: return THREAD_PRIORITY_TIME_CRITICAL;
+        default:                          return THREAD_PRIORITY_NORMAL;
+    }
+}
+
+static ma_result ma_thread_create__win32(ma_thread* pThread, ma_thread_priority priority, size_t stackSize, ma_thread_entry_proc entryProc, void* pData)
+{
+    DWORD threadID; /* Not used. Only used for passing into CreateThread() so it doesn't fail on Windows 98. */
+
+    *pThread = CreateThread(NULL, stackSize, entryProc, pData, 0, &threadID);
+    if (*pThread == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    SetThreadPriority((HANDLE)*pThread, ma_thread_priority_to_win32(priority));
+
+    return MA_SUCCESS;
+}
+
+static void ma_thread_wait__win32(ma_thread* pThread)
+{
+    WaitForSingleObject((HANDLE)*pThread, INFINITE);
+    CloseHandle((HANDLE)*pThread);
+}
+
+
+static ma_result ma_mutex_init__win32(ma_mutex* pMutex)
+{
+    *pMutex = CreateEventA(NULL, FALSE, TRUE, NULL);
+    if (*pMutex == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_mutex_uninit__win32(ma_mutex* pMutex)
+{
+    CloseHandle((HANDLE)*pMutex);
+}
+
+static void ma_mutex_lock__win32(ma_mutex* pMutex)
+{
+    WaitForSingleObject((HANDLE)*pMutex, INFINITE);
+}
+
+static void ma_mutex_unlock__win32(ma_mutex* pMutex)
+{
+    SetEvent((HANDLE)*pMutex);
+}
+
+
+static ma_result ma_event_init__win32(ma_event* pEvent)
+{
+    *pEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+    if (*pEvent == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_event_uninit__win32(ma_event* pEvent)
+{
+    CloseHandle((HANDLE)*pEvent);
+}
+
+static ma_result ma_event_wait__win32(ma_event* pEvent)
+{
+    DWORD result = WaitForSingleObject((HANDLE)*pEvent, INFINITE);
+    if (result == WAIT_OBJECT_0) {
+        return MA_SUCCESS;
+    }
+
+    if (result == WAIT_TIMEOUT) {
+        return MA_TIMEOUT;
+    }
+
+    return ma_result_from_GetLastError(GetLastError());
+}
+
+static ma_result ma_event_signal__win32(ma_event* pEvent)
+{
+    BOOL result = SetEvent((HANDLE)*pEvent);
+    if (result == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_semaphore_init__win32(int initialValue, ma_semaphore* pSemaphore)
+{
+    *pSemaphore = CreateSemaphore(NULL, (LONG)initialValue, LONG_MAX, NULL);
+    if (*pSemaphore == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_semaphore_uninit__win32(ma_semaphore* pSemaphore)
+{
+    CloseHandle((HANDLE)*pSemaphore);
+}
+
+static ma_result ma_semaphore_wait__win32(ma_semaphore* pSemaphore)
+{
+    DWORD result = WaitForSingleObject((HANDLE)*pSemaphore, INFINITE);
+    if (result == WAIT_OBJECT_0) {
+        return MA_SUCCESS;
+    }
+
+    if (result == WAIT_TIMEOUT) {
+        return MA_TIMEOUT;
+    }
+
+    return ma_result_from_GetLastError(GetLastError());
+}
+
+static ma_result ma_semaphore_release__win32(ma_semaphore* pSemaphore)
+{
+    BOOL result = ReleaseSemaphore((HANDLE)*pSemaphore, 1, NULL);
+    if (result == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+#endif
+
+typedef struct
+{
+    ma_thread_entry_proc entryProc;
+    void* pData;
+    ma_allocation_callbacks allocationCallbacks;
+} ma_thread_proxy_data;
+
+static ma_thread_result MA_THREADCALL ma_thread_entry_proxy(void* pData)
+{
+    ma_thread_proxy_data* pProxyData = (ma_thread_proxy_data*)pData;
+    ma_thread_entry_proc entryProc;
+    void* pEntryProcData;
+    ma_thread_result result;
+
+    #if defined(MA_ON_THREAD_ENTRY)
+        MA_ON_THREAD_ENTRY
+    #endif
+
+    entryProc = pProxyData->entryProc;
+    pEntryProcData = pProxyData->pData;
+
+    /* Free the proxy data before getting into the real thread entry proc. */
+    ma_free(pProxyData, &pProxyData->allocationCallbacks);
+
+    result = entryProc(pEntryProcData);
+
+    #if defined(MA_ON_THREAD_EXIT)
+        MA_ON_THREAD_EXIT
+    #endif
+
+    return result;
+}
+
+static ma_result ma_thread_create(ma_thread* pThread, ma_thread_priority priority, size_t stackSize, ma_thread_entry_proc entryProc, void* pData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+    ma_thread_proxy_data* pProxyData;
+
+    if (pThread == NULL || entryProc == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pProxyData = (ma_thread_proxy_data*)ma_malloc(sizeof(*pProxyData), pAllocationCallbacks);   /* Will be freed by the proxy entry proc. */
+    if (pProxyData == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+#if defined(MA_THREAD_DEFAULT_STACK_SIZE)
+    if (stackSize == 0) {
+        stackSize = MA_THREAD_DEFAULT_STACK_SIZE;
+    }
+#endif
+
+    pProxyData->entryProc = entryProc;
+    pProxyData->pData     = pData;
+    ma_allocation_callbacks_init_copy(&pProxyData->allocationCallbacks, pAllocationCallbacks);
+
+#if defined(MA_POSIX)
+    result = ma_thread_create__posix(pThread, priority, stackSize, ma_thread_entry_proxy, pProxyData);
+#elif defined(MA_WIN32)
+    result = ma_thread_create__win32(pThread, priority, stackSize, ma_thread_entry_proxy, pProxyData);
+#endif
+
+    if (result != MA_SUCCESS) {
+        ma_free(pProxyData, pAllocationCallbacks);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_thread_wait(ma_thread* pThread)
+{
+    if (pThread == NULL) {
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_thread_wait__posix(pThread);
+#elif defined(MA_WIN32)
+    ma_thread_wait__win32(pThread);
+#endif
+}
+
+
+MA_API ma_result ma_mutex_init(ma_mutex* pMutex)
+{
+    if (pMutex == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_mutex_init__posix(pMutex);
+#elif defined(MA_WIN32)
+    return ma_mutex_init__win32(pMutex);
+#endif
+}
+
+MA_API void ma_mutex_uninit(ma_mutex* pMutex)
+{
+    if (pMutex == NULL) {
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_mutex_uninit__posix(pMutex);
+#elif defined(MA_WIN32)
+    ma_mutex_uninit__win32(pMutex);
+#endif
+}
+
+MA_API void ma_mutex_lock(ma_mutex* pMutex)
+{
+    if (pMutex == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_mutex_lock__posix(pMutex);
+#elif defined(MA_WIN32)
+    ma_mutex_lock__win32(pMutex);
+#endif
+}
+
+MA_API void ma_mutex_unlock(ma_mutex* pMutex)
+{
+    if (pMutex == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_mutex_unlock__posix(pMutex);
+#elif defined(MA_WIN32)
+    ma_mutex_unlock__win32(pMutex);
+#endif
+}
+
+
+MA_API ma_result ma_event_init(ma_event* pEvent)
+{
+    if (pEvent == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_event_init__posix(pEvent);
+#elif defined(MA_WIN32)
+    return ma_event_init__win32(pEvent);
+#endif
+}
+
+#if 0
+static ma_result ma_event_alloc_and_init(ma_event** ppEvent, ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+    ma_event* pEvent;
+
+    if (ppEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *ppEvent = NULL;
+
+    pEvent = ma_malloc(sizeof(*pEvent), pAllocationCallbacks);
+    if (pEvent == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_event_init(pEvent);
+    if (result != MA_SUCCESS) {
+        ma_free(pEvent, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppEvent = pEvent;
+    return result;
+}
+#endif
+
+MA_API void ma_event_uninit(ma_event* pEvent)
+{
+    if (pEvent == NULL) {
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_event_uninit__posix(pEvent);
+#elif defined(MA_WIN32)
+    ma_event_uninit__win32(pEvent);
+#endif
+}
+
+#if 0
+static void ma_event_uninit_and_free(ma_event* pEvent, ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pEvent == NULL) {
+        return;
+    }
+
+    ma_event_uninit(pEvent);
+    ma_free(pEvent, pAllocationCallbacks);
+}
+#endif
+
+MA_API ma_result ma_event_wait(ma_event* pEvent)
+{
+    if (pEvent == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert to the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_event_wait__posix(pEvent);
+#elif defined(MA_WIN32)
+    return ma_event_wait__win32(pEvent);
+#endif
+}
+
+MA_API ma_result ma_event_signal(ma_event* pEvent)
+{
+    if (pEvent == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert to the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_event_signal__posix(pEvent);
+#elif defined(MA_WIN32)
+    return ma_event_signal__win32(pEvent);
+#endif
+}
+
+
+MA_API ma_result ma_semaphore_init(int initialValue, ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_semaphore_init__posix(initialValue, pSemaphore);
+#elif defined(MA_WIN32)
+    return ma_semaphore_init__win32(initialValue, pSemaphore);
+#endif
+}
+
+MA_API void ma_semaphore_uninit(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_semaphore_uninit__posix(pSemaphore);
+#elif defined(MA_WIN32)
+    ma_semaphore_uninit__win32(pSemaphore);
+#endif
+}
+
+MA_API ma_result ma_semaphore_wait(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_semaphore_wait__posix(pSemaphore);
+#elif defined(MA_WIN32)
+    return ma_semaphore_wait__win32(pSemaphore);
+#endif
+}
+
+MA_API ma_result ma_semaphore_release(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_semaphore_release__posix(pSemaphore);
+#elif defined(MA_WIN32)
+    return ma_semaphore_release__win32(pSemaphore);
+#endif
+}
+#else
+/* MA_NO_THREADING is set which means threading is disabled. Threading is required by some API families. If any of these are enabled we need to throw an error. */
+#ifndef MA_NO_DEVICE_IO
+#error "MA_NO_THREADING cannot be used without MA_NO_DEVICE_IO";
+#endif
+#endif  /* MA_NO_THREADING */
+
+
+
+#define MA_FENCE_COUNTER_MAX    0x7FFFFFFF
+
+MA_API ma_result ma_fence_init(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFence);
+    pFence->counter = 0;
+
+    #ifndef MA_NO_THREADING
+    {
+        ma_result result;
+
+        result = ma_event_init(&pFence->e);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_fence_uninit(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        ma_event_uninit(&pFence->e);
+    }
+    #endif
+
+    MA_ZERO_OBJECT(pFence);
+}
+
+MA_API ma_result ma_fence_acquire(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (;;) {
+        ma_uint32 oldCounter = ma_atomic_load_32(&pFence->counter);
+        ma_uint32 newCounter = oldCounter + 1;
+
+        /* Make sure we're not about to exceed our maximum value. */
+        if (newCounter > MA_FENCE_COUNTER_MAX) {
+            MA_ASSERT(MA_FALSE);
+            return MA_OUT_OF_RANGE;
+        }
+
+        if (ma_atomic_compare_exchange_weak_32(&pFence->counter, &oldCounter, newCounter)) {
+            return MA_SUCCESS;
+        } else {
+            if (oldCounter == MA_FENCE_COUNTER_MAX) {
+                MA_ASSERT(MA_FALSE);
+                return MA_OUT_OF_RANGE; /* The other thread took the last available slot. Abort. */
+            }
+        }
+    }
+
+    /* Should never get here. */
+    /*return MA_SUCCESS;*/
+}
+
+MA_API ma_result ma_fence_release(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (;;) {
+        ma_uint32 oldCounter = ma_atomic_load_32(&pFence->counter);
+        ma_uint32 newCounter = oldCounter - 1;
+
+        if (oldCounter == 0) {
+            MA_ASSERT(MA_FALSE);
+            return MA_INVALID_OPERATION;    /* Acquire/release mismatch. */
+        }
+
+        if (ma_atomic_compare_exchange_weak_32(&pFence->counter, &oldCounter, newCounter)) {
+            #ifndef MA_NO_THREADING
+            {
+                if (newCounter == 0) {
+                    ma_event_signal(&pFence->e);    /* <-- ma_fence_wait() will be waiting on this. */
+                }
+            }
+            #endif
+
+            return MA_SUCCESS;
+        } else {
+            if (oldCounter == 0) {
+                MA_ASSERT(MA_FALSE);
+                return MA_INVALID_OPERATION;    /* Another thread has taken the 0 slot. Acquire/release mismatch. */
+            }
+        }
+    }
+
+    /* Should never get here. */
+    /*return MA_SUCCESS;*/
+}
+
+MA_API ma_result ma_fence_wait(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (;;) {
+        ma_uint32 counter;
+
+        counter = ma_atomic_load_32(&pFence->counter);
+        if (counter == 0) {
+            /*
+            Counter has hit zero. By the time we get here some other thread may have acquired the
+            fence again, but that is where the caller needs to take care with how they se the fence.
+            */
+            return MA_SUCCESS;
+        }
+
+        /* Getting here means the counter is > 0. We'll need to wait for something to happen. */
+        #ifndef MA_NO_THREADING
+        {
+            ma_result result;
+
+            result = ma_event_wait(&pFence->e);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+        #endif
+    }
+
+    /* Should never get here. */
+    /*return MA_INVALID_OPERATION;*/
+}
+
+
+MA_API ma_result ma_async_notification_signal(ma_async_notification* pNotification)
+{
+    ma_async_notification_callbacks* pNotificationCallbacks = (ma_async_notification_callbacks*)pNotification;
+
+    if (pNotification == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pNotificationCallbacks->onSignal == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    pNotificationCallbacks->onSignal(pNotification);
+    return MA_INVALID_ARGS;
+}
+
+
+static void ma_async_notification_poll__on_signal(ma_async_notification* pNotification)
+{
+    ((ma_async_notification_poll*)pNotification)->signalled = MA_TRUE;
+}
+
+MA_API ma_result ma_async_notification_poll_init(ma_async_notification_poll* pNotificationPoll)
+{
+    if (pNotificationPoll == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pNotificationPoll->cb.onSignal = ma_async_notification_poll__on_signal;
+    pNotificationPoll->signalled = MA_FALSE;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_bool32 ma_async_notification_poll_is_signalled(const ma_async_notification_poll* pNotificationPoll)
+{
+    if (pNotificationPoll == NULL) {
+        return MA_FALSE;
+    }
+
+    return pNotificationPoll->signalled;
+}
+
+
+static void ma_async_notification_event__on_signal(ma_async_notification* pNotification)
+{
+    ma_async_notification_event_signal((ma_async_notification_event*)pNotification);
+}
+
+MA_API ma_result ma_async_notification_event_init(ma_async_notification_event* pNotificationEvent)
+{
+    if (pNotificationEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pNotificationEvent->cb.onSignal = ma_async_notification_event__on_signal;
+
+    #ifndef MA_NO_THREADING
+    {
+        ma_result result;
+
+        result = ma_event_init(&pNotificationEvent->e);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        return MA_NOT_IMPLEMENTED;  /* Threading is disabled. */
+    }
+    #endif
+}
+
+MA_API ma_result ma_async_notification_event_uninit(ma_async_notification_event* pNotificationEvent)
+{
+    if (pNotificationEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        ma_event_uninit(&pNotificationEvent->e);
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        return MA_NOT_IMPLEMENTED;  /* Threading is disabled. */
+    }
+    #endif
+}
+
+MA_API ma_result ma_async_notification_event_wait(ma_async_notification_event* pNotificationEvent)
+{
+    if (pNotificationEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        return ma_event_wait(&pNotificationEvent->e);
+    }
+    #else
+    {
+        return MA_NOT_IMPLEMENTED;  /* Threading is disabled. */
+    }
+    #endif
+}
+
+MA_API ma_result ma_async_notification_event_signal(ma_async_notification_event* pNotificationEvent)
+{
+    if (pNotificationEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        return ma_event_signal(&pNotificationEvent->e);
+    }
+    #else
+    {
+        return MA_NOT_IMPLEMENTED;  /* Threading is disabled. */
+    }
+    #endif
+}
+
+
+
+/************************************************************************************************************************************************************
+
+Job Queue
+
+************************************************************************************************************************************************************/
+MA_API ma_slot_allocator_config ma_slot_allocator_config_init(ma_uint32 capacity)
+{
+    ma_slot_allocator_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.capacity = capacity;
+
+    return config;
+}
+
+
+static MA_INLINE ma_uint32 ma_slot_allocator_calculate_group_capacity(ma_uint32 slotCapacity)
+{
+    ma_uint32 cap = slotCapacity / 32;
+    if ((slotCapacity % 32) != 0) {
+        cap += 1;
+    }
+
+    return cap;
+}
+
+static MA_INLINE ma_uint32 ma_slot_allocator_group_capacity(const ma_slot_allocator* pAllocator)
+{
+    return ma_slot_allocator_calculate_group_capacity(pAllocator->capacity);
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t groupsOffset;
+    size_t slotsOffset;
+} ma_slot_allocator_heap_layout;
+
+static ma_result ma_slot_allocator_get_heap_layout(const ma_slot_allocator_config* pConfig, ma_slot_allocator_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->capacity == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Groups. */
+    pHeapLayout->groupsOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(ma_slot_allocator_calculate_group_capacity(pConfig->capacity) * sizeof(ma_slot_allocator_group));
+
+    /* Slots. */
+    pHeapLayout->slotsOffset  = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(pConfig->capacity * sizeof(ma_uint32));
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_slot_allocator_get_heap_size(const ma_slot_allocator_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_slot_allocator_heap_layout layout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_slot_allocator_get_heap_layout(pConfig, &layout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = layout.sizeInBytes;
+
+    return result;
+}
+
+MA_API ma_result ma_slot_allocator_init_preallocated(const ma_slot_allocator_config* pConfig, void* pHeap, ma_slot_allocator* pAllocator)
+{
+    ma_result result;
+    ma_slot_allocator_heap_layout heapLayout;
+
+    if (pAllocator == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pAllocator);
+
+    if (pHeap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_slot_allocator_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pAllocator->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pAllocator->pGroups  = (ma_slot_allocator_group*)ma_offset_ptr(pHeap, heapLayout.groupsOffset);
+    pAllocator->pSlots   = (ma_uint32*)ma_offset_ptr(pHeap, heapLayout.slotsOffset);
+    pAllocator->capacity = pConfig->capacity;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_slot_allocator_init(const ma_slot_allocator_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_slot_allocator* pAllocator)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_slot_allocator_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap allocation. */
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_slot_allocator_init_preallocated(pConfig, pHeap, pAllocator);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pAllocator->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_slot_allocator_uninit(ma_slot_allocator* pAllocator, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocator == NULL) {
+        return;
+    }
+
+    if (pAllocator->_ownsHeap) {
+        ma_free(pAllocator->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_slot_allocator_alloc(ma_slot_allocator* pAllocator, ma_uint64* pSlot)
+{
+    ma_uint32 iAttempt;
+    const ma_uint32 maxAttempts = 2;    /* The number of iterations to perform until returning MA_OUT_OF_MEMORY if no slots can be found. */
+
+    if (pAllocator == NULL || pSlot == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iAttempt = 0; iAttempt < maxAttempts; iAttempt += 1) {
+        /* We need to acquire a suitable bitfield first. This is a bitfield that's got an available slot within it. */
+        ma_uint32 iGroup;
+        for (iGroup = 0; iGroup < ma_slot_allocator_group_capacity(pAllocator); iGroup += 1) {
+            /* CAS */
+            for (;;) {
+                ma_uint32 oldBitfield;
+                ma_uint32 newBitfield;
+                ma_uint32 bitOffset;
+
+                oldBitfield = ma_atomic_load_32(&pAllocator->pGroups[iGroup].bitfield);  /* <-- This copy must happen. The compiler must not optimize this away. */
+
+                /* Fast check to see if anything is available. */
+                if (oldBitfield == 0xFFFFFFFF) {
+                    break;  /* No available bits in this bitfield. */
+                }
+
+                bitOffset = ma_ffs_32(~oldBitfield);
+                MA_ASSERT(bitOffset < 32);
+
+                newBitfield = oldBitfield | (1 << bitOffset);
+
+                if (ma_atomic_compare_and_swap_32(&pAllocator->pGroups[iGroup].bitfield, oldBitfield, newBitfield) == oldBitfield) {
+                    ma_uint32 slotIndex;
+
+                    /* Increment the counter as soon as possible to have other threads report out-of-memory sooner than later. */
+                    ma_atomic_fetch_add_32(&pAllocator->count, 1);
+
+                    /* The slot index is required for constructing the output value. */
+                    slotIndex = (iGroup << 5) + bitOffset;  /* iGroup << 5 = iGroup * 32 */
+                    if (slotIndex >= pAllocator->capacity) {
+                        return MA_OUT_OF_MEMORY;
+                    }
+
+                    /* Increment the reference count before constructing the output value. */
+                    pAllocator->pSlots[slotIndex] += 1;
+
+                    /* Construct the output value. */
+                    *pSlot = (((ma_uint64)pAllocator->pSlots[slotIndex] << 32) | slotIndex);
+
+                    return MA_SUCCESS;
+                }
+            }
+        }
+
+        /* We weren't able to find a slot. If it's because we've reached our capacity we need to return MA_OUT_OF_MEMORY. Otherwise we need to do another iteration and try again. */
+        if (pAllocator->count < pAllocator->capacity) {
+            ma_yield();
+        } else {
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+    /* We couldn't find a slot within the maximum number of attempts. */
+    return MA_OUT_OF_MEMORY;
+}
+
+MA_API ma_result ma_slot_allocator_free(ma_slot_allocator* pAllocator, ma_uint64 slot)
+{
+    ma_uint32 iGroup;
+    ma_uint32 iBit;
+
+    if (pAllocator == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    iGroup = (ma_uint32)((slot & 0xFFFFFFFF) >> 5);   /* slot / 32 */
+    iBit   = (ma_uint32)((slot & 0xFFFFFFFF) & 31);   /* slot % 32 */
+
+    if (iGroup >= ma_slot_allocator_group_capacity(pAllocator)) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ASSERT(iBit < 32);   /* This must be true due to the logic we used to actually calculate it. */
+
+    while (ma_atomic_load_32(&pAllocator->count) > 0) {
+        /* CAS */
+        ma_uint32 oldBitfield;
+        ma_uint32 newBitfield;
+
+        oldBitfield = ma_atomic_load_32(&pAllocator->pGroups[iGroup].bitfield);  /* <-- This copy must happen. The compiler must not optimize this away. */
+        newBitfield = oldBitfield & ~(1 << iBit);
+
+        /* Debugging for checking for double-frees. */
+        #if defined(MA_DEBUG_OUTPUT)
+        {
+            if ((oldBitfield & (1 << iBit)) == 0) {
+                MA_ASSERT(MA_FALSE);    /* Double free detected.*/
+            }
+        }
+        #endif
+
+        if (ma_atomic_compare_and_swap_32(&pAllocator->pGroups[iGroup].bitfield, oldBitfield, newBitfield) == oldBitfield) {
+            ma_atomic_fetch_sub_32(&pAllocator->count, 1);
+            return MA_SUCCESS;
+        }
+    }
+
+    /* Getting here means there are no allocations available for freeing. */
+    return MA_INVALID_OPERATION;
+}
+
+
+#define MA_JOB_ID_NONE      ~((ma_uint64)0)
+#define MA_JOB_SLOT_NONE    (ma_uint16)(~0)
+
+static MA_INLINE ma_uint32 ma_job_extract_refcount(ma_uint64 toc)
+{
+    return (ma_uint32)(toc >> 32);
+}
+
+static MA_INLINE ma_uint16 ma_job_extract_slot(ma_uint64 toc)
+{
+    return (ma_uint16)(toc & 0x0000FFFF);
+}
+
+#if 0   /* Currently unused, but might make use of this later. */
+static MA_INLINE ma_uint16 ma_job_extract_code(ma_uint64 toc)
+{
+    return (ma_uint16)((toc & 0xFFFF0000) >> 16);
+}
+#endif
+
+static MA_INLINE ma_uint64 ma_job_toc_to_allocation(ma_uint64 toc)
+{
+    return ((ma_uint64)ma_job_extract_refcount(toc) << 32) | (ma_uint64)ma_job_extract_slot(toc);
+}
+
+static MA_INLINE ma_uint64 ma_job_set_refcount(ma_uint64 toc, ma_uint32 refcount)
+{
+    /* Clear the reference count first. */
+    toc = toc & ~((ma_uint64)0xFFFFFFFF << 32);
+    toc = toc |  ((ma_uint64)refcount   << 32);
+
+    return toc;
+}
+
+
+MA_API ma_job ma_job_init(ma_uint16 code)
+{
+    ma_job job;
+
+    MA_ZERO_OBJECT(&job);
+    job.toc.breakup.code = code;
+    job.toc.breakup.slot = MA_JOB_SLOT_NONE;    /* Temp value. Will be allocated when posted to a queue. */
+    job.next             = MA_JOB_ID_NONE;
+
+    return job;
+}
+
+
+static ma_result ma_job_process__noop(ma_job* pJob);
+static ma_result ma_job_process__quit(ma_job* pJob);
+static ma_result ma_job_process__custom(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__load_data_buffer_node(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__free_data_buffer_node(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__page_data_buffer_node(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__load_data_buffer(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__free_data_buffer(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__load_data_stream(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__free_data_stream(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__page_data_stream(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__seek_data_stream(ma_job* pJob);
+
+#if !defined(MA_NO_DEVICE_IO)
+static ma_result ma_job_process__device__aaudio_reroute(ma_job* pJob);
+#endif
+
+static ma_job_proc g_jobVTable[MA_JOB_TYPE_COUNT] =
+{
+    /* Miscellaneous. */
+    ma_job_process__quit,                                       /* MA_JOB_TYPE_QUIT */
+    ma_job_process__custom,                                     /* MA_JOB_TYPE_CUSTOM */
+
+    /* Resource Manager. */
+    ma_job_process__resource_manager__load_data_buffer_node,    /* MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE */
+    ma_job_process__resource_manager__free_data_buffer_node,    /* MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE */
+    ma_job_process__resource_manager__page_data_buffer_node,    /* MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE */
+    ma_job_process__resource_manager__load_data_buffer,         /* MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER */
+    ma_job_process__resource_manager__free_data_buffer,         /* MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER */
+    ma_job_process__resource_manager__load_data_stream,         /* MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM */
+    ma_job_process__resource_manager__free_data_stream,         /* MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM */
+    ma_job_process__resource_manager__page_data_stream,         /* MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_STREAM */
+    ma_job_process__resource_manager__seek_data_stream,         /* MA_JOB_TYPE_RESOURCE_MANAGER_SEEK_DATA_STREAM */
+
+    /* Device. */
+#if !defined(MA_NO_DEVICE_IO)
+    ma_job_process__device__aaudio_reroute                      /* MA_JOB_TYPE_DEVICE_AAUDIO_REROUTE */
+#endif
+};
+
+MA_API ma_result ma_job_process(ma_job* pJob)
+{
+    if (pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pJob->toc.breakup.code >= MA_JOB_TYPE_COUNT) {
+        return MA_INVALID_OPERATION;
+    }
+
+    return g_jobVTable[pJob->toc.breakup.code](pJob);
+}
+
+static ma_result ma_job_process__noop(ma_job* pJob)
+{
+    MA_ASSERT(pJob != NULL);
+
+    /* No-op. */
+    (void)pJob;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__quit(ma_job* pJob)
+{
+    return ma_job_process__noop(pJob);
+}
+
+static ma_result ma_job_process__custom(ma_job* pJob)
+{
+    MA_ASSERT(pJob != NULL);
+
+    /* No-op if there's no callback. */
+    if (pJob->data.custom.proc == NULL) {
+        return MA_SUCCESS;
+    }
+
+    return pJob->data.custom.proc(pJob);
+}
+
+
+
+MA_API ma_job_queue_config ma_job_queue_config_init(ma_uint32 flags, ma_uint32 capacity)
+{
+    ma_job_queue_config config;
+
+    config.flags    = flags;
+    config.capacity = capacity;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t allocatorOffset;
+    size_t jobsOffset;
+} ma_job_queue_heap_layout;
+
+static ma_result ma_job_queue_get_heap_layout(const ma_job_queue_config* pConfig, ma_job_queue_heap_layout* pHeapLayout)
+{
+    ma_result result;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->capacity == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Allocator. */
+    {
+        ma_slot_allocator_config allocatorConfig;
+        size_t allocatorHeapSizeInBytes;
+
+        allocatorConfig = ma_slot_allocator_config_init(pConfig->capacity);
+        result = ma_slot_allocator_get_heap_size(&allocatorConfig, &allocatorHeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->allocatorOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes    += allocatorHeapSizeInBytes;
+    }
+
+    /* Jobs. */
+    pHeapLayout->jobsOffset   = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(pConfig->capacity * sizeof(ma_job));
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_job_queue_get_heap_size(const ma_job_queue_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_job_queue_heap_layout layout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_job_queue_get_heap_layout(pConfig, &layout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = layout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_job_queue_init_preallocated(const ma_job_queue_config* pConfig, void* pHeap, ma_job_queue* pQueue)
+{
+    ma_result result;
+    ma_job_queue_heap_layout heapLayout;
+    ma_slot_allocator_config allocatorConfig;
+
+    if (pQueue == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pQueue);
+
+    result = ma_job_queue_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pQueue->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pQueue->flags    = pConfig->flags;
+    pQueue->capacity = pConfig->capacity;
+    pQueue->pJobs    = (ma_job*)ma_offset_ptr(pHeap, heapLayout.jobsOffset);
+
+    allocatorConfig = ma_slot_allocator_config_init(pConfig->capacity);
+    result = ma_slot_allocator_init_preallocated(&allocatorConfig, ma_offset_ptr(pHeap, heapLayout.allocatorOffset), &pQueue->allocator);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* We need a semaphore if we're running in non-blocking mode. If threading is disabled we need to return an error. */
+    if ((pQueue->flags & MA_JOB_QUEUE_FLAG_NON_BLOCKING) == 0) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_semaphore_init(0, &pQueue->sem);
+        }
+        #else
+        {
+            /* Threading is disabled and we've requested non-blocking mode. */
+            return MA_INVALID_OPERATION;
+        }
+        #endif
+    }
+
+    /*
+    Our queue needs to be initialized with a free standing node. This should always be slot 0. Required for the lock free algorithm. The first job in the queue is
+    just a dummy item for giving us the first item in the list which is stored in the "next" member.
+    */
+    ma_slot_allocator_alloc(&pQueue->allocator, &pQueue->head);  /* Will never fail. */
+    pQueue->pJobs[ma_job_extract_slot(pQueue->head)].next = MA_JOB_ID_NONE;
+    pQueue->tail = pQueue->head;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_job_queue_init(const ma_job_queue_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_job_queue* pQueue)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_job_queue_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_job_queue_init_preallocated(pConfig, pHeap, pQueue);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pQueue->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_job_queue_uninit(ma_job_queue* pQueue, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pQueue == NULL) {
+        return;
+    }
+
+    /* All we need to do is uninitialize the semaphore. */
+    if ((pQueue->flags & MA_JOB_QUEUE_FLAG_NON_BLOCKING) == 0) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_semaphore_uninit(&pQueue->sem);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never get here. Should have been checked at initialization time. */
+        }
+        #endif
+    }
+
+    ma_slot_allocator_uninit(&pQueue->allocator, pAllocationCallbacks);
+
+    if (pQueue->_ownsHeap) {
+        ma_free(pQueue->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static ma_bool32 ma_job_queue_cas(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 desired)
+{
+    /* The new counter is taken from the expected value. */
+    return ma_atomic_compare_and_swap_64(dst, expected, ma_job_set_refcount(desired, ma_job_extract_refcount(expected) + 1)) == expected;
+}
+
+MA_API ma_result ma_job_queue_post(ma_job_queue* pQueue, const ma_job* pJob)
+{
+    /*
+    Lock free queue implementation based on the paper by Michael and Scott: Nonblocking Algorithms and Preemption-Safe Locking on Multiprogrammed Shared Memory Multiprocessors
+    */
+    ma_result result;
+    ma_uint64 slot;
+    ma_uint64 tail;
+    ma_uint64 next;
+
+    if (pQueue == NULL || pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* We need a new slot. */
+    result = ma_slot_allocator_alloc(&pQueue->allocator, &slot);
+    if (result != MA_SUCCESS) {
+        return result;  /* Probably ran out of slots. If so, MA_OUT_OF_MEMORY will be returned. */
+    }
+
+    /* At this point we should have a slot to place the job. */
+    MA_ASSERT(ma_job_extract_slot(slot) < pQueue->capacity);
+
+    /* We need to put the job into memory before we do anything. */
+    pQueue->pJobs[ma_job_extract_slot(slot)]                  = *pJob;
+    pQueue->pJobs[ma_job_extract_slot(slot)].toc.allocation   = slot;                    /* This will overwrite the job code. */
+    pQueue->pJobs[ma_job_extract_slot(slot)].toc.breakup.code = pJob->toc.breakup.code;  /* The job code needs to be applied again because the line above overwrote it. */
+    pQueue->pJobs[ma_job_extract_slot(slot)].next             = MA_JOB_ID_NONE;          /* Reset for safety. */
+
+    #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock_lock(&pQueue->lock);
+    #endif
+    {
+        /* The job is stored in memory so now we need to add it to our linked list. We only ever add items to the end of the list. */
+        for (;;) {
+            tail = ma_atomic_load_64(&pQueue->tail);
+            next = ma_atomic_load_64(&pQueue->pJobs[ma_job_extract_slot(tail)].next);
+
+            if (ma_job_toc_to_allocation(tail) == ma_job_toc_to_allocation(ma_atomic_load_64(&pQueue->tail))) {
+                if (ma_job_extract_slot(next) == 0xFFFF) {
+                    if (ma_job_queue_cas(&pQueue->pJobs[ma_job_extract_slot(tail)].next, next, slot)) {
+                        break;
+                    }
+                } else {
+                    ma_job_queue_cas(&pQueue->tail, tail, ma_job_extract_slot(next));
+                }
+            }
+        }
+        ma_job_queue_cas(&pQueue->tail, tail, slot);
+    }
+    #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock_unlock(&pQueue->lock);
+    #endif
+
+
+    /* Signal the semaphore as the last step if we're using synchronous mode. */
+    if ((pQueue->flags & MA_JOB_QUEUE_FLAG_NON_BLOCKING) == 0) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_semaphore_release(&pQueue->sem);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never get here. Should have been checked at initialization time. */
+        }
+        #endif
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_job_queue_next(ma_job_queue* pQueue, ma_job* pJob)
+{
+    ma_uint64 head;
+    ma_uint64 tail;
+    ma_uint64 next;
+
+    if (pQueue == NULL || pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If we're running in synchronous mode we'll need to wait on a semaphore. */
+    if ((pQueue->flags & MA_JOB_QUEUE_FLAG_NON_BLOCKING) == 0) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_semaphore_wait(&pQueue->sem);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never get here. Should have been checked at initialization time. */
+        }
+        #endif
+    }
+
+    #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock_lock(&pQueue->lock);
+    #endif
+    {
+        /*
+        BUG: In lock-free mode, multiple threads can be in this section of code. The "head" variable in the loop below
+        is stored. One thread can fall through to the freeing of this item while another is still using "head" for the
+        retrieval of the "next" variable.
+
+        The slot allocator might need to make use of some reference counting to ensure it's only truly freed when
+        there are no more references to the item. This must be fixed before removing these locks.
+        */
+
+        /* Now we need to remove the root item from the list. */
+        for (;;) {
+            head = ma_atomic_load_64(&pQueue->head);
+            tail = ma_atomic_load_64(&pQueue->tail);
+            next = ma_atomic_load_64(&pQueue->pJobs[ma_job_extract_slot(head)].next);
+
+            if (ma_job_toc_to_allocation(head) == ma_job_toc_to_allocation(ma_atomic_load_64(&pQueue->head))) {
+                if (ma_job_extract_slot(head) == ma_job_extract_slot(tail)) {
+                    if (ma_job_extract_slot(next) == 0xFFFF) {
+                        #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+                        ma_spinlock_unlock(&pQueue->lock);
+                        #endif
+                        return MA_NO_DATA_AVAILABLE;
+                    }
+                    ma_job_queue_cas(&pQueue->tail, tail, ma_job_extract_slot(next));
+                } else {
+                    *pJob = pQueue->pJobs[ma_job_extract_slot(next)];
+                    if (ma_job_queue_cas(&pQueue->head, head, ma_job_extract_slot(next))) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock_unlock(&pQueue->lock);
+    #endif
+
+    ma_slot_allocator_free(&pQueue->allocator, head);
+
+    /*
+    If it's a quit job make sure it's put back on the queue to ensure other threads have an opportunity to detect it and terminate naturally. We
+    could instead just leave it on the queue, but that would involve fiddling with the lock-free code above and I want to keep that as simple as
+    possible.
+    */
+    if (pJob->toc.breakup.code == MA_JOB_TYPE_QUIT) {
+        ma_job_queue_post(pQueue, pJob);
+        return MA_CANCELLED;    /* Return a cancelled status just in case the thread is checking return codes and not properly checking for a quit job. */
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+/*******************************************************************************
+
+Dynamic Linking
+
+*******************************************************************************/
+/* Disable run-time linking on certain backends and platforms. */
+#ifndef MA_NO_RUNTIME_LINKING
+    #if defined(MA_EMSCRIPTEN) || defined(MA_ORBIS) || defined(MA_PROSPERO) || defined(MA_SWITCH) || defined(MA_DOS)
+        #define MA_NO_RUNTIME_LINKING
+    #endif
+#endif
+
+#ifdef MA_POSIX
+    /* No need for dlfcn.h if we're not using runtime linking. */
+    #ifndef MA_NO_RUNTIME_LINKING
+        #include <dlfcn.h>
+    #endif
+#endif
+
+MA_API ma_handle ma_dlopen(ma_log* pLog, const char* filename)
+{
+    #ifndef MA_NO_RUNTIME_LINKING
+    {
+        ma_handle handle;
+
+        ma_log_postf(pLog, MA_LOG_LEVEL_DEBUG, "Loading library: %s\n", filename);
+
+        #ifdef MA_WIN32
+            /* From MSDN: Desktop applications cannot use LoadPackagedLibrary; if a desktop application calls this function it fails with APPMODEL_ERROR_NO_PACKAGE.*/
+            #if !defined(MA_WIN32_UWP) || !(defined(WINAPI_FAMILY) && ((defined(WINAPI_FAMILY_PHONE_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)))
+                handle = (ma_handle)LoadLibraryA(filename);
+            #else
+                /* *sigh* It appears there is no ANSI version of LoadPackagedLibrary()... */
+                WCHAR filenameW[4096];
+                if (MultiByteToWideChar(CP_UTF8, 0, filename, -1, filenameW, sizeof(filenameW)) == 0) {
+                    handle = NULL;
+                } else {
+                    handle = (ma_handle)LoadPackagedLibrary(filenameW, 0);
+                }
+            #endif
+        #else
+            handle = (ma_handle)dlopen(filename, RTLD_NOW);
+        #endif
+
+        /*
+        I'm not considering failure to load a library an error nor a warning because seamlessly falling through to a lower-priority
+        backend is a deliberate design choice. Instead I'm logging it as an informational message.
+        */
+        if (handle == NULL) {
+            ma_log_postf(pLog, MA_LOG_LEVEL_INFO, "Failed to load library: %s\n", filename);
+        }
+
+        return handle;
+    }
+    #else
+    {
+        /* Runtime linking is disabled. */
+        (void)pLog;
+        (void)filename;
+        return NULL;
+    }
+    #endif
+}
+
+MA_API void ma_dlclose(ma_log* pLog, ma_handle handle)
+{
+    #ifndef MA_NO_RUNTIME_LINKING
+    {
+        #ifdef MA_WIN32
+        {
+            FreeLibrary((HMODULE)handle);
+        }
+        #else
+        {
+            /* Hack for Android bug (see https://github.com/android/ndk/issues/360). Calling dlclose() pre-API 28 may segfault. */
+            #if !defined(MA_ANDROID) || (defined(__ANDROID_API__) && __ANDROID_API__ >= 28)
+            {
+                dlclose((void*)handle);
+            }
+            #else
+            {
+                (void)handle;
+            }
+            #endif
+        }
+        #endif
+
+        (void)pLog;
+    }
+    #else
+    {
+        /* Runtime linking is disabled. */
+        (void)pLog;
+        (void)handle;
+    }
+    #endif
+}
+
+MA_API ma_proc ma_dlsym(ma_log* pLog, ma_handle handle, const char* symbol)
+{
+    #ifndef MA_NO_RUNTIME_LINKING
+    {
+        ma_proc proc;
+
+        ma_log_postf(pLog, MA_LOG_LEVEL_DEBUG, "Loading symbol: %s\n", symbol);
+
+        #ifdef _WIN32
+        {
+            proc = (ma_proc)GetProcAddress((HMODULE)handle, symbol);
+        }
+        #else
+        {
+            #if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))) || defined(__clang__)
+                #pragma GCC diagnostic push
+                #pragma GCC diagnostic ignored "-Wpedantic"
+            #endif
+                proc = (ma_proc)dlsym((void*)handle, symbol);
+            #if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))) || defined(__clang__)
+                #pragma GCC diagnostic pop
+            #endif
+        }
+        #endif
+
+        if (proc == NULL) {
+            ma_log_postf(pLog, MA_LOG_LEVEL_WARNING, "Failed to load symbol: %s\n", symbol);
+        }
+
+        (void)pLog; /* It's possible for pContext to be unused. */
+        return proc;
+    }
+    #else
+    {
+        /* Runtime linking is disabled. */
+        (void)pLog;
+        (void)handle;
+        (void)symbol;
+        return NULL;
+    }
+    #endif
+}
+
+
+
+/************************************************************************************************************************************************************
+*************************************************************************************************************************************************************
+
+DEVICE I/O
+==========
+
+*************************************************************************************************************************************************************
+************************************************************************************************************************************************************/
+
+#ifdef MA_APPLE
+    #include <AvailabilityMacros.h>
+#endif
+
+#ifndef MA_NO_DEVICE_IO
+
+#if defined(MA_APPLE) && (MAC_OS_X_VERSION_MIN_REQUIRED < 101200)
+    #include <mach/mach_time.h> /* For mach_absolute_time() */
+#endif
+
+#ifdef MA_POSIX
+    #include <sys/types.h>
+#endif
+
+/* This must be set to at least 26. */
+#ifndef MA_AAUDIO_MIN_ANDROID_SDK_VERSION
+#define MA_AAUDIO_MIN_ANDROID_SDK_VERSION 27
+#endif
+
+
+MA_API void ma_device_info_add_native_data_format(ma_device_info* pDeviceInfo, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 flags)
+{
+    if (pDeviceInfo == NULL) {
+        return;
+    }
+
+    if (pDeviceInfo->nativeDataFormatCount < ma_countof(pDeviceInfo->nativeDataFormats)) {
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = sampleRate;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = flags;
+        pDeviceInfo->nativeDataFormatCount += 1;
+    }
+}
+
+
+typedef struct
+{
+    ma_backend backend;
+    const char* pName;
+} ma_backend_info;
+
+static ma_backend_info gBackendInfo[] = /* Indexed by the backend enum. Must be in the order backends are declared in the ma_backend enum. */
+{
+    {ma_backend_wasapi,     "WASAPI"},
+    {ma_backend_dsound,     "DirectSound"},
+    {ma_backend_winmm,      "WinMM"},
+    {ma_backend_coreaudio,  "Core Audio"},
+    {ma_backend_sndio,      "sndio"},
+    {ma_backend_audio4,     "audio(4)"},
+    {ma_backend_oss,        "OSS"},
+    {ma_backend_pulseaudio, "PulseAudio"},
+    {ma_backend_alsa,       "ALSA"},
+    {ma_backend_jack,       "JACK"},
+    {ma_backend_aaudio,     "AAudio"},
+    {ma_backend_opensl,     "OpenSL|ES"},
+    {ma_backend_webaudio,   "Web Audio"},
+    {ma_backend_custom,     "Custom"},
+    {ma_backend_null,       "Null"}
+};
+
+MA_API const char* ma_get_backend_name(ma_backend backend)
+{
+    if (backend < 0 || backend >= (int)ma_countof(gBackendInfo)) {
+        return "Unknown";
+    }
+
+    return gBackendInfo[backend].pName;
+}
+
+MA_API ma_result ma_get_backend_from_name(const char* pBackendName, ma_backend* pBackend)
+{
+    size_t iBackend;
+
+    if (pBackendName == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iBackend = 0; iBackend < ma_countof(gBackendInfo); iBackend += 1) {
+        if (ma_strcmp(pBackendName, gBackendInfo[iBackend].pName) == 0) {
+            if (pBackend != NULL) {
+                *pBackend = gBackendInfo[iBackend].backend;
+            }
+
+            return MA_SUCCESS;
+        }
+    }
+
+    /* Getting here means the backend name is unknown. */
+    return MA_INVALID_ARGS;
+}
+
+MA_API ma_bool32 ma_is_backend_enabled(ma_backend backend)
+{
+    /*
+    This looks a little bit gross, but we want all backends to be included in the switch to avoid warnings on some compilers
+    about some enums not being handled by the switch statement.
+    */
+    switch (backend)
+    {
+        case ma_backend_wasapi:
+        #if defined(MA_HAS_WASAPI)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_dsound:
+        #if defined(MA_HAS_DSOUND)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_winmm:
+        #if defined(MA_HAS_WINMM)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_coreaudio:
+        #if defined(MA_HAS_COREAUDIO)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_sndio:
+        #if defined(MA_HAS_SNDIO)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_audio4:
+        #if defined(MA_HAS_AUDIO4)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_oss:
+        #if defined(MA_HAS_OSS)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_pulseaudio:
+        #if defined(MA_HAS_PULSEAUDIO)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_alsa:
+        #if defined(MA_HAS_ALSA)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_jack:
+        #if defined(MA_HAS_JACK)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_aaudio:
+        #if defined(MA_HAS_AAUDIO)
+            #if defined(MA_ANDROID)
+            {
+                return ma_android_sdk_version() >= MA_AAUDIO_MIN_ANDROID_SDK_VERSION;
+            }
+            #else
+                return MA_FALSE;
+            #endif
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_opensl:
+        #if defined(MA_HAS_OPENSL)
+            #if defined(MA_ANDROID)
+            {
+                return ma_android_sdk_version() >= 9;
+            }
+            #else
+                return MA_TRUE;
+            #endif
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_webaudio:
+        #if defined(MA_HAS_WEBAUDIO)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_custom:
+        #if defined(MA_HAS_CUSTOM)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_null:
+        #if defined(MA_HAS_NULL)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+
+        default: return MA_FALSE;
+    }
+}
+
+MA_API ma_result ma_get_enabled_backends(ma_backend* pBackends, size_t backendCap, size_t* pBackendCount)
+{
+    size_t backendCount;
+    size_t iBackend;
+    ma_result result = MA_SUCCESS;
+
+    if (pBackendCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    backendCount = 0;
+
+    for (iBackend = 0; iBackend <= ma_backend_null; iBackend += 1) {
+        ma_backend backend = (ma_backend)iBackend;
+
+        if (ma_is_backend_enabled(backend)) {
+            /* The backend is enabled. Try adding it to the list. If there's no room, MA_NO_SPACE needs to be returned. */
+            if (backendCount == backendCap) {
+                result = MA_NO_SPACE;
+                break;
+            } else {
+                pBackends[backendCount] = backend;
+                backendCount += 1;
+            }
+        }
+    }
+
+    if (pBackendCount != NULL) {
+        *pBackendCount = backendCount;
+    }
+
+    return result;
+}
+
+MA_API ma_bool32 ma_is_loopback_supported(ma_backend backend)
+{
+    switch (backend)
+    {
+        case ma_backend_wasapi:     return MA_TRUE;
+        case ma_backend_dsound:     return MA_FALSE;
+        case ma_backend_winmm:      return MA_FALSE;
+        case ma_backend_coreaudio:  return MA_FALSE;
+        case ma_backend_sndio:      return MA_FALSE;
+        case ma_backend_audio4:     return MA_FALSE;
+        case ma_backend_oss:        return MA_FALSE;
+        case ma_backend_pulseaudio: return MA_FALSE;
+        case ma_backend_alsa:       return MA_FALSE;
+        case ma_backend_jack:       return MA_FALSE;
+        case ma_backend_aaudio:     return MA_FALSE;
+        case ma_backend_opensl:     return MA_FALSE;
+        case ma_backend_webaudio:   return MA_FALSE;
+        case ma_backend_custom:     return MA_FALSE;    /* <-- Will depend on the implementation of the backend. */
+        case ma_backend_null:       return MA_FALSE;
+        default:                    return MA_FALSE;
+    }
+}
+
+
+
+#if defined(MA_WIN32) && !defined(MA_XBOX)
+/* WASAPI error codes. */
+#define MA_AUDCLNT_E_NOT_INITIALIZED              ((HRESULT)0x88890001)
+#define MA_AUDCLNT_E_ALREADY_INITIALIZED          ((HRESULT)0x88890002)
+#define MA_AUDCLNT_E_WRONG_ENDPOINT_TYPE          ((HRESULT)0x88890003)
+#define MA_AUDCLNT_E_DEVICE_INVALIDATED           ((HRESULT)0x88890004)
+#define MA_AUDCLNT_E_NOT_STOPPED                  ((HRESULT)0x88890005)
+#define MA_AUDCLNT_E_BUFFER_TOO_LARGE             ((HRESULT)0x88890006)
+#define MA_AUDCLNT_E_OUT_OF_ORDER                 ((HRESULT)0x88890007)
+#define MA_AUDCLNT_E_UNSUPPORTED_FORMAT           ((HRESULT)0x88890008)
+#define MA_AUDCLNT_E_INVALID_SIZE                 ((HRESULT)0x88890009)
+#define MA_AUDCLNT_E_DEVICE_IN_USE                ((HRESULT)0x8889000A)
+#define MA_AUDCLNT_E_BUFFER_OPERATION_PENDING     ((HRESULT)0x8889000B)
+#define MA_AUDCLNT_E_THREAD_NOT_REGISTERED        ((HRESULT)0x8889000C)
+#define MA_AUDCLNT_E_NO_SINGLE_PROCESS            ((HRESULT)0x8889000D)
+#define MA_AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED   ((HRESULT)0x8889000E)
+#define MA_AUDCLNT_E_ENDPOINT_CREATE_FAILED       ((HRESULT)0x8889000F)
+#define MA_AUDCLNT_E_SERVICE_NOT_RUNNING          ((HRESULT)0x88890010)
+#define MA_AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED     ((HRESULT)0x88890011)
+#define MA_AUDCLNT_E_EXCLUSIVE_MODE_ONLY          ((HRESULT)0x88890012)
+#define MA_AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL ((HRESULT)0x88890013)
+#define MA_AUDCLNT_E_EVENTHANDLE_NOT_SET          ((HRESULT)0x88890014)
+#define MA_AUDCLNT_E_INCORRECT_BUFFER_SIZE        ((HRESULT)0x88890015)
+#define MA_AUDCLNT_E_BUFFER_SIZE_ERROR            ((HRESULT)0x88890016)
+#define MA_AUDCLNT_E_CPUUSAGE_EXCEEDED            ((HRESULT)0x88890017)
+#define MA_AUDCLNT_E_BUFFER_ERROR                 ((HRESULT)0x88890018)
+#define MA_AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED      ((HRESULT)0x88890019)
+#define MA_AUDCLNT_E_INVALID_DEVICE_PERIOD        ((HRESULT)0x88890020)
+#define MA_AUDCLNT_E_INVALID_STREAM_FLAG          ((HRESULT)0x88890021)
+#define MA_AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE ((HRESULT)0x88890022)
+#define MA_AUDCLNT_E_OUT_OF_OFFLOAD_RESOURCES     ((HRESULT)0x88890023)
+#define MA_AUDCLNT_E_OFFLOAD_MODE_ONLY            ((HRESULT)0x88890024)
+#define MA_AUDCLNT_E_NONOFFLOAD_MODE_ONLY         ((HRESULT)0x88890025)
+#define MA_AUDCLNT_E_RESOURCES_INVALIDATED        ((HRESULT)0x88890026)
+#define MA_AUDCLNT_E_RAW_MODE_UNSUPPORTED         ((HRESULT)0x88890027)
+#define MA_AUDCLNT_E_ENGINE_PERIODICITY_LOCKED    ((HRESULT)0x88890028)
+#define MA_AUDCLNT_E_ENGINE_FORMAT_LOCKED         ((HRESULT)0x88890029)
+#define MA_AUDCLNT_E_HEADTRACKING_ENABLED         ((HRESULT)0x88890030)
+#define MA_AUDCLNT_E_HEADTRACKING_UNSUPPORTED     ((HRESULT)0x88890040)
+#define MA_AUDCLNT_S_BUFFER_EMPTY                 ((HRESULT)0x08890001)
+#define MA_AUDCLNT_S_THREAD_ALREADY_REGISTERED    ((HRESULT)0x08890002)
+#define MA_AUDCLNT_S_POSITION_STALLED             ((HRESULT)0x08890003)
+
+#define MA_DS_OK                                  ((HRESULT)0)
+#define MA_DS_NO_VIRTUALIZATION                   ((HRESULT)0x0878000A)
+#define MA_DSERR_ALLOCATED                        ((HRESULT)0x8878000A)
+#define MA_DSERR_CONTROLUNAVAIL                   ((HRESULT)0x8878001E)
+#define MA_DSERR_INVALIDPARAM                     ((HRESULT)0x80070057) /*E_INVALIDARG*/
+#define MA_DSERR_INVALIDCALL                      ((HRESULT)0x88780032)
+#define MA_DSERR_GENERIC                          ((HRESULT)0x80004005) /*E_FAIL*/
+#define MA_DSERR_PRIOLEVELNEEDED                  ((HRESULT)0x88780046)
+#define MA_DSERR_OUTOFMEMORY                      ((HRESULT)0x8007000E) /*E_OUTOFMEMORY*/
+#define MA_DSERR_BADFORMAT                        ((HRESULT)0x88780064)
+#define MA_DSERR_UNSUPPORTED                      ((HRESULT)0x80004001) /*E_NOTIMPL*/
+#define MA_DSERR_NODRIVER                         ((HRESULT)0x88780078)
+#define MA_DSERR_ALREADYINITIALIZED               ((HRESULT)0x88780082)
+#define MA_DSERR_NOAGGREGATION                    ((HRESULT)0x80040110) /*CLASS_E_NOAGGREGATION*/
+#define MA_DSERR_BUFFERLOST                       ((HRESULT)0x88780096)
+#define MA_DSERR_OTHERAPPHASPRIO                  ((HRESULT)0x887800A0)
+#define MA_DSERR_UNINITIALIZED                    ((HRESULT)0x887800AA)
+#define MA_DSERR_NOINTERFACE                      ((HRESULT)0x80004002) /*E_NOINTERFACE*/
+#define MA_DSERR_ACCESSDENIED                     ((HRESULT)0x80070005) /*E_ACCESSDENIED*/
+#define MA_DSERR_BUFFERTOOSMALL                   ((HRESULT)0x887800B4)
+#define MA_DSERR_DS8_REQUIRED                     ((HRESULT)0x887800BE)
+#define MA_DSERR_SENDLOOP                         ((HRESULT)0x887800C8)
+#define MA_DSERR_BADSENDBUFFERGUID                ((HRESULT)0x887800D2)
+#define MA_DSERR_OBJECTNOTFOUND                   ((HRESULT)0x88781161)
+#define MA_DSERR_FXUNAVAILABLE                    ((HRESULT)0x887800DC)
+
+static ma_result ma_result_from_HRESULT(HRESULT hr)
+{
+    switch (hr)
+    {
+        case NOERROR:                                   return MA_SUCCESS;
+        /*case S_OK:                                      return MA_SUCCESS;*/
+
+        case E_POINTER:                                 return MA_INVALID_ARGS;
+        case E_UNEXPECTED:                              return MA_ERROR;
+        case E_NOTIMPL:                                 return MA_NOT_IMPLEMENTED;
+        case E_OUTOFMEMORY:                             return MA_OUT_OF_MEMORY;
+        case E_INVALIDARG:                              return MA_INVALID_ARGS;
+        case E_NOINTERFACE:                             return MA_API_NOT_FOUND;
+        case E_HANDLE:                                  return MA_INVALID_ARGS;
+        case E_ABORT:                                   return MA_ERROR;
+        case E_FAIL:                                    return MA_ERROR;
+        case E_ACCESSDENIED:                            return MA_ACCESS_DENIED;
+
+        /* WASAPI */
+        case MA_AUDCLNT_E_NOT_INITIALIZED:              return MA_DEVICE_NOT_INITIALIZED;
+        case MA_AUDCLNT_E_ALREADY_INITIALIZED:          return MA_DEVICE_ALREADY_INITIALIZED;
+        case MA_AUDCLNT_E_WRONG_ENDPOINT_TYPE:          return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_DEVICE_INVALIDATED:           return MA_UNAVAILABLE;
+        case MA_AUDCLNT_E_NOT_STOPPED:                  return MA_DEVICE_NOT_STOPPED;
+        case MA_AUDCLNT_E_BUFFER_TOO_LARGE:             return MA_TOO_BIG;
+        case MA_AUDCLNT_E_OUT_OF_ORDER:                 return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_UNSUPPORTED_FORMAT:           return MA_FORMAT_NOT_SUPPORTED;
+        case MA_AUDCLNT_E_INVALID_SIZE:                 return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_DEVICE_IN_USE:                return MA_BUSY;
+        case MA_AUDCLNT_E_BUFFER_OPERATION_PENDING:     return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_THREAD_NOT_REGISTERED:        return MA_DOES_NOT_EXIST;
+        case MA_AUDCLNT_E_NO_SINGLE_PROCESS:            return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED:   return MA_SHARE_MODE_NOT_SUPPORTED;
+        case MA_AUDCLNT_E_ENDPOINT_CREATE_FAILED:       return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        case MA_AUDCLNT_E_SERVICE_NOT_RUNNING:          return MA_NOT_CONNECTED;
+        case MA_AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED:     return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_EXCLUSIVE_MODE_ONLY:          return MA_SHARE_MODE_NOT_SUPPORTED;
+        case MA_AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL: return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_EVENTHANDLE_NOT_SET:          return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_INCORRECT_BUFFER_SIZE:        return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_BUFFER_SIZE_ERROR:            return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_CPUUSAGE_EXCEEDED:            return MA_ERROR;
+        case MA_AUDCLNT_E_BUFFER_ERROR:                 return MA_ERROR;
+        case MA_AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED:      return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_INVALID_DEVICE_PERIOD:        return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_INVALID_STREAM_FLAG:          return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE: return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_OUT_OF_OFFLOAD_RESOURCES:     return MA_OUT_OF_MEMORY;
+        case MA_AUDCLNT_E_OFFLOAD_MODE_ONLY:            return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_NONOFFLOAD_MODE_ONLY:         return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_RESOURCES_INVALIDATED:        return MA_INVALID_DATA;
+        case MA_AUDCLNT_E_RAW_MODE_UNSUPPORTED:         return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_ENGINE_PERIODICITY_LOCKED:    return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_ENGINE_FORMAT_LOCKED:         return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_HEADTRACKING_ENABLED:         return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_HEADTRACKING_UNSUPPORTED:     return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_S_BUFFER_EMPTY:                 return MA_NO_SPACE;
+        case MA_AUDCLNT_S_THREAD_ALREADY_REGISTERED:    return MA_ALREADY_EXISTS;
+        case MA_AUDCLNT_S_POSITION_STALLED:             return MA_ERROR;
+
+        /* DirectSound */
+        /*case MA_DS_OK:                                  return MA_SUCCESS;*/          /* S_OK */
+        case MA_DS_NO_VIRTUALIZATION:                   return MA_SUCCESS;
+        case MA_DSERR_ALLOCATED:                        return MA_ALREADY_IN_USE;
+        case MA_DSERR_CONTROLUNAVAIL:                   return MA_INVALID_OPERATION;
+        /*case MA_DSERR_INVALIDPARAM:                    return MA_INVALID_ARGS;*/      /* E_INVALIDARG */
+        case MA_DSERR_INVALIDCALL:                      return MA_INVALID_OPERATION;
+        /*case MA_DSERR_GENERIC:                          return MA_ERROR;*/            /* E_FAIL */
+        case MA_DSERR_PRIOLEVELNEEDED:                  return MA_INVALID_OPERATION;
+        /*case MA_DSERR_OUTOFMEMORY:                      return MA_OUT_OF_MEMORY;*/    /* E_OUTOFMEMORY */
+        case MA_DSERR_BADFORMAT:                        return MA_FORMAT_NOT_SUPPORTED;
+        /*case MA_DSERR_UNSUPPORTED:                      return MA_NOT_IMPLEMENTED;*/  /* E_NOTIMPL */
+        case MA_DSERR_NODRIVER:                         return MA_FAILED_TO_INIT_BACKEND;
+        case MA_DSERR_ALREADYINITIALIZED:               return MA_DEVICE_ALREADY_INITIALIZED;
+        case MA_DSERR_NOAGGREGATION:                    return MA_ERROR;
+        case MA_DSERR_BUFFERLOST:                       return MA_UNAVAILABLE;
+        case MA_DSERR_OTHERAPPHASPRIO:                  return MA_ACCESS_DENIED;
+        case MA_DSERR_UNINITIALIZED:                    return MA_DEVICE_NOT_INITIALIZED;
+        /*case MA_DSERR_NOINTERFACE:                      return MA_API_NOT_FOUND;*/    /* E_NOINTERFACE */
+        /*case MA_DSERR_ACCESSDENIED:                     return MA_ACCESS_DENIED;*/    /* E_ACCESSDENIED */
+        case MA_DSERR_BUFFERTOOSMALL:                   return MA_NO_SPACE;
+        case MA_DSERR_DS8_REQUIRED:                     return MA_INVALID_OPERATION;
+        case MA_DSERR_SENDLOOP:                         return MA_DEADLOCK;
+        case MA_DSERR_BADSENDBUFFERGUID:                return MA_INVALID_ARGS;
+        case MA_DSERR_OBJECTNOTFOUND:                   return MA_NO_DEVICE;
+        case MA_DSERR_FXUNAVAILABLE:                    return MA_UNAVAILABLE;
+
+        default:                                        return MA_ERROR;
+    }
+}
+
+/* PROPVARIANT */
+#define MA_VT_LPWSTR    31
+#define MA_VT_BLOB      65
+
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(push)
+    #pragma warning(disable:4201)   /* nonstandard extension used: nameless struct/union */
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic" /* For ISO C99 doesn't support unnamed structs/unions [-Wpedantic] */
+    #if defined(__clang__)
+        #pragma GCC diagnostic ignored "-Wc11-extensions"   /* anonymous unions are a C11 extension */
+    #endif
+#endif
+typedef struct
+{
+    WORD vt;
+    WORD wReserved1;
+    WORD wReserved2;
+    WORD wReserved3;
+    union
+    {
+        struct
+        {
+            ULONG cbSize;
+            BYTE* pBlobData;
+        } blob;
+        WCHAR* pwszVal;
+        char pad[16];   /* Just to ensure the size of the struct matches the official version. */
+    };
+} MA_PROPVARIANT;
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(pop)
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic pop
+#endif
+
+typedef HRESULT (WINAPI * MA_PFN_CoInitialize)(void* pvReserved);
+typedef HRESULT (WINAPI * MA_PFN_CoInitializeEx)(void* pvReserved, DWORD  dwCoInit);
+typedef void    (WINAPI * MA_PFN_CoUninitialize)(void);
+typedef HRESULT (WINAPI * MA_PFN_CoCreateInstance)(const IID* rclsid, void* pUnkOuter, DWORD dwClsContext, const IID* riid, void* ppv);
+typedef void    (WINAPI * MA_PFN_CoTaskMemFree)(void* pv);
+typedef HRESULT (WINAPI * MA_PFN_PropVariantClear)(MA_PROPVARIANT *pvar);
+typedef int     (WINAPI * MA_PFN_StringFromGUID2)(const GUID* const rguid, WCHAR* lpsz, int cchMax);
+
+typedef HWND    (WINAPI * MA_PFN_GetForegroundWindow)(void);
+typedef HWND    (WINAPI * MA_PFN_GetDesktopWindow)(void);
+
+#if defined(MA_WIN32_DESKTOP)
+/* Microsoft documents these APIs as returning LSTATUS, but the Win32 API shipping with some compilers do not define it. It's just a LONG. */
+typedef LONG    (WINAPI * MA_PFN_RegOpenKeyExA)(HKEY hKey, const char* lpSubKey, DWORD ulOptions, DWORD samDesired, HKEY* phkResult);
+typedef LONG    (WINAPI * MA_PFN_RegCloseKey)(HKEY hKey);
+typedef LONG    (WINAPI * MA_PFN_RegQueryValueExA)(HKEY hKey, const char* lpValueName, DWORD* lpReserved, DWORD* lpType, BYTE* lpData, DWORD* lpcbData);
+#endif  /* MA_WIN32_DESKTOP */
+
+static GUID MA_GUID_KSDATAFORMAT_SUBTYPE_PCM        = {0x00000001, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
+static GUID MA_GUID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT = {0x00000003, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
+/*static GUID MA_GUID_KSDATAFORMAT_SUBTYPE_ALAW       = {0x00000006, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};*/
+/*static GUID MA_GUID_KSDATAFORMAT_SUBTYPE_MULAW      = {0x00000007, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};*/
+
+MA_API size_t ma_strlen_WCHAR(const WCHAR* str)
+{
+    size_t len = 0;
+    while (str[len] != '\0') {
+        len += 1;
+    }
+
+    return len;
+}
+
+MA_API int ma_strcmp_WCHAR(const WCHAR *s1, const WCHAR *s2)
+{
+    while (*s1 != '\0' && *s1 == *s2) {
+        s1 += 1;
+        s2 += 1;
+    }
+
+    return *s1 - *s2;
+}
+
+MA_API int ma_strcpy_s_WCHAR(WCHAR* dst, size_t dstCap, const WCHAR* src)
+{
+    size_t i;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstCap == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    for (i = 0; i < dstCap && src[i] != '\0'; ++i) {
+        dst[i] = src[i];
+    }
+
+    if (i < dstCap) {
+        dst[i] = '\0';
+        return 0;
+    }
+
+    dst[0] = '\0';
+    return 34;
+}
+#endif  /* MA_WIN32 */
+
+
+#define MA_DEFAULT_PLAYBACK_DEVICE_NAME    "Default Playback Device"
+#define MA_DEFAULT_CAPTURE_DEVICE_NAME     "Default Capture Device"
+
+
+
+
+/*******************************************************************************
+
+Timing
+
+*******************************************************************************/
+#if defined(MA_WIN32) && !defined(MA_POSIX)
+    static LARGE_INTEGER g_ma_TimerFrequency;   /* <-- Initialized to zero since it's static. */
+    static MA_INLINE void ma_timer_init(ma_timer* pTimer)
+    {
+        LARGE_INTEGER counter;
+
+        if (g_ma_TimerFrequency.QuadPart == 0) {
+            QueryPerformanceFrequency(&g_ma_TimerFrequency);
+        }
+
+        QueryPerformanceCounter(&counter);
+        pTimer->counter = counter.QuadPart;
+    }
+
+    static MA_INLINE double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+    {
+        LARGE_INTEGER counter;
+        if (!QueryPerformanceCounter(&counter)) {
+            return 0;
+        }
+
+        return (double)(counter.QuadPart - pTimer->counter) / g_ma_TimerFrequency.QuadPart;
+    }
+#elif defined(MA_APPLE) && (MAC_OS_X_VERSION_MIN_REQUIRED < 101200)
+    static ma_uint64 g_ma_TimerFrequency = 0;
+    static MA_INLINE void ma_timer_init(ma_timer* pTimer)
+    {
+        mach_timebase_info_data_t baseTime;
+        mach_timebase_info(&baseTime);
+        g_ma_TimerFrequency = (baseTime.denom * 1e9) / baseTime.numer;
+
+        pTimer->counter = mach_absolute_time();
+    }
+
+    static MA_INLINE double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+    {
+        ma_uint64 newTimeCounter = mach_absolute_time();
+        ma_uint64 oldTimeCounter = pTimer->counter;
+
+        return (newTimeCounter - oldTimeCounter) / g_ma_TimerFrequency;
+    }
+#elif defined(MA_EMSCRIPTEN)
+    static MA_INLINE void ma_timer_init(ma_timer* pTimer)
+    {
+        pTimer->counterD = emscripten_get_now();
+    }
+
+    static MA_INLINE double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+    {
+        return (emscripten_get_now() - pTimer->counterD) / 1000;    /* Emscripten is in milliseconds. */
+    }
+#else
+    #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309L
+        #if defined(CLOCK_MONOTONIC)
+            #define MA_CLOCK_ID CLOCK_MONOTONIC
+        #else
+            #define MA_CLOCK_ID CLOCK_REALTIME
+        #endif
+
+        static MA_INLINE void ma_timer_init(ma_timer* pTimer)
+        {
+            struct timespec newTime;
+            clock_gettime(MA_CLOCK_ID, &newTime);
+
+            pTimer->counter = (newTime.tv_sec * 1000000000) + newTime.tv_nsec;
+        }
+
+        static MA_INLINE double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+        {
+            ma_uint64 newTimeCounter;
+            ma_uint64 oldTimeCounter;
+
+            struct timespec newTime;
+            clock_gettime(MA_CLOCK_ID, &newTime);
+
+            newTimeCounter = (newTime.tv_sec * 1000000000) + newTime.tv_nsec;
+            oldTimeCounter = pTimer->counter;
+
+            return (newTimeCounter - oldTimeCounter) / 1000000000.0;
+        }
+    #else
+        static MA_INLINE void ma_timer_init(ma_timer* pTimer)
+        {
+            struct timeval newTime;
+            gettimeofday(&newTime, NULL);
+
+            pTimer->counter = (newTime.tv_sec * 1000000) + newTime.tv_usec;
+        }
+
+        static MA_INLINE double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+        {
+            ma_uint64 newTimeCounter;
+            ma_uint64 oldTimeCounter;
+
+            struct timeval newTime;
+            gettimeofday(&newTime, NULL);
+
+            newTimeCounter = (newTime.tv_sec * 1000000) + newTime.tv_usec;
+            oldTimeCounter = pTimer->counter;
+
+            return (newTimeCounter - oldTimeCounter) / 1000000.0;
+        }
+    #endif
+#endif
+
+
+
+#if 0
+static ma_uint32 ma_get_closest_standard_sample_rate(ma_uint32 sampleRateIn)
+{
+    ma_uint32 closestRate = 0;
+    ma_uint32 closestDiff = 0xFFFFFFFF;
+    size_t iStandardRate;
+
+    for (iStandardRate = 0; iStandardRate < ma_countof(g_maStandardSampleRatePriorities); ++iStandardRate) {
+        ma_uint32 standardRate = g_maStandardSampleRatePriorities[iStandardRate];
+        ma_uint32 diff;
+
+        if (sampleRateIn > standardRate) {
+            diff = sampleRateIn - standardRate;
+        } else {
+            diff = standardRate - sampleRateIn;
+        }
+
+        if (diff == 0) {
+            return standardRate;    /* The input sample rate is a standard rate. */
+        }
+
+        if (closestDiff > diff) {
+            closestDiff = diff;
+            closestRate = standardRate;
+        }
+    }
+
+    return closestRate;
+}
+#endif
+
+
+static MA_INLINE unsigned int ma_device_disable_denormals(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (!pDevice->noDisableDenormals) {
+        return ma_disable_denormals();
+    } else {
+        return 0;
+    }
+}
+
+static MA_INLINE void ma_device_restore_denormals(ma_device* pDevice, unsigned int prevState)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (!pDevice->noDisableDenormals) {
+        ma_restore_denormals(prevState);
+    } else {
+        /* Do nothing. */
+        (void)prevState;
+    }
+}
+
+static ma_device_notification ma_device_notification_init(ma_device* pDevice, ma_device_notification_type type)
+{
+    ma_device_notification notification;
+
+    MA_ZERO_OBJECT(&notification);
+    notification.pDevice = pDevice;
+    notification.type    = type;
+
+    return notification;
+}
+
+static void ma_device__on_notification(ma_device_notification notification)
+{
+    MA_ASSERT(notification.pDevice != NULL);
+
+    if (notification.pDevice->onNotification != NULL) {
+        notification.pDevice->onNotification(&notification);
+    }
+
+    /* TEMP FOR COMPATIBILITY: If it's a stopped notification, fire the onStop callback as well. This is only for backwards compatibility and will be removed. */
+    if (notification.pDevice->onStop != NULL && notification.type == ma_device_notification_type_stopped) {
+        notification.pDevice->onStop(notification.pDevice);
+    }
+}
+
+static void ma_device__on_notification_started(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_started));
+}
+
+static void ma_device__on_notification_stopped(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_stopped));
+}
+
+/* Not all platforms support reroute notifications. */
+#if !defined(MA_EMSCRIPTEN)
+static void ma_device__on_notification_rerouted(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_rerouted));
+}
+#endif
+
+#if defined(MA_EMSCRIPTEN)
+#ifdef __cplusplus
+extern "C" {
+#endif
+void EMSCRIPTEN_KEEPALIVE ma_device__on_notification_unlocked(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_unlocked));
+}
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+
+static void ma_device__on_data_inner(ma_device* pDevice, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pDevice->onData != NULL);
+
+    if (!pDevice->noPreSilencedOutputBuffer && pFramesOut != NULL) {
+        ma_silence_pcm_frames(pFramesOut, frameCount, pDevice->playback.format, pDevice->playback.channels);
+    }
+
+    pDevice->onData(pDevice, pFramesOut, pFramesIn, frameCount);
+}
+
+static void ma_device__on_data(ma_device* pDevice, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* Don't read more data from the client if we're in the process of stopping. */
+    if (ma_device_get_state(pDevice) == ma_device_state_stopping) {
+        return;
+    }
+
+    if (pDevice->noFixedSizedCallback) {
+        /* Fast path. Not using a fixed sized callback. Process directly from the specified buffers. */
+        ma_device__on_data_inner(pDevice, pFramesOut, pFramesIn, frameCount);
+    } else {
+        /* Slow path. Using a fixed sized callback. Need to use the intermediary buffer. */
+        ma_uint32 totalFramesProcessed = 0;
+
+        while (totalFramesProcessed < frameCount) {
+            ma_uint32 totalFramesRemaining = frameCount - totalFramesProcessed;
+            ma_uint32 framesToProcessThisIteration = 0;
+
+            if (pFramesIn != NULL) {
+                /* Capturing. Write to the intermediary buffer. If there's no room, fire the callback to empty it. */
+                if (pDevice->capture.intermediaryBufferLen < pDevice->capture.intermediaryBufferCap) {
+                    /* There's some room left in the intermediary buffer. Write to it without firing the callback. */
+                    framesToProcessThisIteration = totalFramesRemaining;
+                    if (framesToProcessThisIteration > pDevice->capture.intermediaryBufferCap - pDevice->capture.intermediaryBufferLen) {
+                        framesToProcessThisIteration = pDevice->capture.intermediaryBufferCap - pDevice->capture.intermediaryBufferLen;
+                    }
+
+                    ma_copy_pcm_frames(
+                        ma_offset_pcm_frames_ptr(pDevice->capture.pIntermediaryBuffer, pDevice->capture.intermediaryBufferLen, pDevice->capture.format, pDevice->capture.channels),
+                        ma_offset_pcm_frames_const_ptr(pFramesIn, totalFramesProcessed, pDevice->capture.format, pDevice->capture.channels),
+                        framesToProcessThisIteration,
+                        pDevice->capture.format, pDevice->capture.channels);
+
+                    pDevice->capture.intermediaryBufferLen += framesToProcessThisIteration;
+                }
+
+                if (pDevice->capture.intermediaryBufferLen == pDevice->capture.intermediaryBufferCap) {
+                    /* No room left in the intermediary buffer. Fire the data callback. */
+                    if (pDevice->type == ma_device_type_duplex) {
+                        /* We'll do the duplex data callback later after we've processed the playback data. */
+                    } else {
+                        ma_device__on_data_inner(pDevice, NULL, pDevice->capture.pIntermediaryBuffer, pDevice->capture.intermediaryBufferCap);
+
+                        /* The intermediary buffer has just been drained. */
+                        pDevice->capture.intermediaryBufferLen = 0;
+                    }
+                }
+            }
+
+            if (pFramesOut != NULL) {
+                /* Playing back. Read from the intermediary buffer. If there's nothing in it, fire the callback to fill it. */
+                if (pDevice->playback.intermediaryBufferLen > 0) {
+                    /* There's some content in the intermediary buffer. Read from that without firing the callback. */
+                    if (pDevice->type == ma_device_type_duplex) {
+                        /* The frames processed this iteration for a duplex device will always be based on the capture side. Leave it unmodified. */
+                    } else {
+                        framesToProcessThisIteration = totalFramesRemaining;
+                        if (framesToProcessThisIteration > pDevice->playback.intermediaryBufferLen) {
+                            framesToProcessThisIteration = pDevice->playback.intermediaryBufferLen;
+                        }
+                    }
+
+                    ma_copy_pcm_frames(
+                        ma_offset_pcm_frames_ptr(pFramesOut, totalFramesProcessed, pDevice->playback.format, pDevice->playback.channels),
+                        ma_offset_pcm_frames_ptr(pDevice->playback.pIntermediaryBuffer, pDevice->playback.intermediaryBufferCap - pDevice->playback.intermediaryBufferLen, pDevice->playback.format, pDevice->playback.channels),
+                        framesToProcessThisIteration,
+                        pDevice->playback.format, pDevice->playback.channels);
+
+                    pDevice->playback.intermediaryBufferLen -= framesToProcessThisIteration;
+                }
+
+                if (pDevice->playback.intermediaryBufferLen == 0) {
+                    /* There's nothing in the intermediary buffer. Fire the data callback to fill it. */
+                    if (pDevice->type == ma_device_type_duplex) {
+                        /* In duplex mode, the data callback will be fired later. Nothing to do here. */
+                    } else {
+                        ma_device__on_data_inner(pDevice, pDevice->playback.pIntermediaryBuffer, NULL, pDevice->playback.intermediaryBufferCap);
+
+                        /* The intermediary buffer has just been filled. */
+                        pDevice->playback.intermediaryBufferLen = pDevice->playback.intermediaryBufferCap;
+                    }
+                }
+            }
+
+            /* If we're in duplex mode we might need to do a refill of the data. */
+            if (pDevice->type == ma_device_type_duplex) {
+                if (pDevice->capture.intermediaryBufferLen == pDevice->capture.intermediaryBufferCap) {
+                    ma_device__on_data_inner(pDevice, pDevice->playback.pIntermediaryBuffer, pDevice->capture.pIntermediaryBuffer, pDevice->capture.intermediaryBufferCap);
+
+                    pDevice->playback.intermediaryBufferLen = pDevice->playback.intermediaryBufferCap;  /* The playback buffer will have just been filled. */
+                    pDevice->capture.intermediaryBufferLen  = 0;                                        /* The intermediary buffer has just been drained. */
+                }
+            }
+
+            /* Make sure this is only incremented once in the duplex case. */
+            totalFramesProcessed += framesToProcessThisIteration;
+        }
+    }
+}
+
+static void ma_device__handle_data_callback(ma_device* pDevice, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    float masterVolumeFactor;
+
+    ma_device_get_master_volume(pDevice, &masterVolumeFactor);  /* Use ma_device_get_master_volume() to ensure the volume is loaded atomically. */
+
+    if (pDevice->onData) {
+        unsigned int prevDenormalState = ma_device_disable_denormals(pDevice);
+        {
+            /* Volume control of input makes things a bit awkward because the input buffer is read-only. We'll need to use a temp buffer and loop in this case. */
+            if (pFramesIn != NULL && masterVolumeFactor != 1) {
+                ma_uint8 tempFramesIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                ma_uint32 bpfCapture  = ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+                ma_uint32 bpfPlayback = ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+                ma_uint32 totalFramesProcessed = 0;
+                while (totalFramesProcessed < frameCount) {
+                    ma_uint32 framesToProcessThisIteration = frameCount - totalFramesProcessed;
+                    if (framesToProcessThisIteration > sizeof(tempFramesIn)/bpfCapture) {
+                        framesToProcessThisIteration = sizeof(tempFramesIn)/bpfCapture;
+                    }
+
+                    ma_copy_and_apply_volume_factor_pcm_frames(tempFramesIn, ma_offset_ptr(pFramesIn, totalFramesProcessed*bpfCapture), framesToProcessThisIteration, pDevice->capture.format, pDevice->capture.channels, masterVolumeFactor);
+
+                    ma_device__on_data(pDevice, ma_offset_ptr(pFramesOut, totalFramesProcessed*bpfPlayback), tempFramesIn, framesToProcessThisIteration);
+
+                    totalFramesProcessed += framesToProcessThisIteration;
+                }
+            } else {
+                ma_device__on_data(pDevice, pFramesOut, pFramesIn, frameCount);
+            }
+
+            /* Volume control and clipping for playback devices. */
+            if (pFramesOut != NULL) {
+                if (masterVolumeFactor != 1) {
+                    if (pFramesIn == NULL) {    /* <-- In full-duplex situations, the volume will have been applied to the input samples before the data callback. Applying it again post-callback will incorrectly compound it. */
+                        ma_apply_volume_factor_pcm_frames(pFramesOut, frameCount, pDevice->playback.format, pDevice->playback.channels, masterVolumeFactor);
+                    }
+                }
+
+                if (!pDevice->noClip && pDevice->playback.format == ma_format_f32) {
+                    ma_clip_samples_f32((float*)pFramesOut, (const float*)pFramesOut, frameCount * pDevice->playback.channels);   /* Intentionally specifying the same pointer for both input and output for in-place processing. */
+                }
+            }
+        }
+        ma_device_restore_denormals(pDevice, prevDenormalState);
+    } else {
+        /* No data callback. Just silence the output. */
+        if (pFramesOut != NULL) {
+            ma_silence_pcm_frames(pFramesOut, frameCount, pDevice->playback.format, pDevice->playback.channels);
+        }
+    }
+}
+
+
+
+/* A helper function for reading sample data from the client. */
+static void ma_device__read_frames_from_client(ma_device* pDevice, ma_uint32 frameCount, void* pFramesOut)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(frameCount > 0);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pDevice->playback.converter.isPassthrough) {
+        ma_device__handle_data_callback(pDevice, pFramesOut, NULL, frameCount);
+    } else {
+        ma_result result;
+        ma_uint64 totalFramesReadOut;
+        void* pRunningFramesOut;
+
+        totalFramesReadOut = 0;
+        pRunningFramesOut  = pFramesOut;
+
+        /*
+        We run slightly different logic depending on whether or not we're using a heap-allocated
+        buffer for caching input data. This will be the case if the data converter does not have
+        the ability to retrieve the required input frame count for a given output frame count.
+        */
+        if (pDevice->playback.pInputCache != NULL) {
+            while (totalFramesReadOut < frameCount) {
+                ma_uint64 framesToReadThisIterationIn;
+                ma_uint64 framesToReadThisIterationOut;
+
+                /* If there's any data available in the cache, that needs to get processed first. */
+                if (pDevice->playback.inputCacheRemaining > 0) {
+                    framesToReadThisIterationOut = (frameCount - totalFramesReadOut);
+                    framesToReadThisIterationIn  = framesToReadThisIterationOut;
+                    if (framesToReadThisIterationIn > pDevice->playback.inputCacheRemaining) {
+                        framesToReadThisIterationIn = pDevice->playback.inputCacheRemaining;
+                    }
+
+                    result = ma_data_converter_process_pcm_frames(&pDevice->playback.converter, ma_offset_pcm_frames_ptr(pDevice->playback.pInputCache, pDevice->playback.inputCacheConsumed, pDevice->playback.format, pDevice->playback.channels), &framesToReadThisIterationIn, pRunningFramesOut, &framesToReadThisIterationOut);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    pDevice->playback.inputCacheConsumed  += framesToReadThisIterationIn;
+                    pDevice->playback.inputCacheRemaining -= framesToReadThisIterationIn;
+
+                    totalFramesReadOut += framesToReadThisIterationOut;
+                    pRunningFramesOut   = ma_offset_ptr(pRunningFramesOut, framesToReadThisIterationOut * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+
+                    if (framesToReadThisIterationIn == 0 && framesToReadThisIterationOut == 0) {
+                        break;  /* We're done. */
+                    }
+                }
+
+                /* Getting here means there's no data in the cache and we need to fill it up with data from the client. */
+                if (pDevice->playback.inputCacheRemaining == 0) {
+                    ma_device__handle_data_callback(pDevice, pDevice->playback.pInputCache, NULL, (ma_uint32)pDevice->playback.inputCacheCap);
+
+                    pDevice->playback.inputCacheConsumed  = 0;
+                    pDevice->playback.inputCacheRemaining = pDevice->playback.inputCacheCap;
+                }
+            }
+        } else {
+            while (totalFramesReadOut < frameCount) {
+                ma_uint8 pIntermediaryBuffer[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In client format. */
+                ma_uint64 intermediaryBufferCap = sizeof(pIntermediaryBuffer) / ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+                ma_uint64 framesToReadThisIterationIn;
+                ma_uint64 framesReadThisIterationIn;
+                ma_uint64 framesToReadThisIterationOut;
+                ma_uint64 framesReadThisIterationOut;
+                ma_uint64 requiredInputFrameCount;
+
+                framesToReadThisIterationOut = (frameCount - totalFramesReadOut);
+                framesToReadThisIterationIn = framesToReadThisIterationOut;
+                if (framesToReadThisIterationIn > intermediaryBufferCap) {
+                    framesToReadThisIterationIn = intermediaryBufferCap;
+                }
+
+                ma_data_converter_get_required_input_frame_count(&pDevice->playback.converter, framesToReadThisIterationOut, &requiredInputFrameCount);
+                if (framesToReadThisIterationIn > requiredInputFrameCount) {
+                    framesToReadThisIterationIn = requiredInputFrameCount;
+                }
+
+                ma_device__handle_data_callback(pDevice, pIntermediaryBuffer, NULL, (ma_uint32)framesToReadThisIterationIn);
+
+                /*
+                At this point we have our decoded data in input format and now we need to convert to output format. Note that even if we didn't read any
+                input frames, we still want to try processing frames because there may some output frames generated from cached input data.
+                */
+                framesReadThisIterationIn  = framesToReadThisIterationIn;
+                framesReadThisIterationOut = framesToReadThisIterationOut;
+                result = ma_data_converter_process_pcm_frames(&pDevice->playback.converter, pIntermediaryBuffer, &framesReadThisIterationIn, pRunningFramesOut, &framesReadThisIterationOut);
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+
+                totalFramesReadOut += framesReadThisIterationOut;
+                pRunningFramesOut   = ma_offset_ptr(pRunningFramesOut, framesReadThisIterationOut * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+
+                if (framesReadThisIterationIn == 0 && framesReadThisIterationOut == 0) {
+                    break;  /* We're done. */
+                }
+            }
+        }
+    }
+}
+
+/* A helper for sending sample data to the client. */
+static void ma_device__send_frames_to_client(ma_device* pDevice, ma_uint32 frameCountInDeviceFormat, const void* pFramesInDeviceFormat)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(frameCountInDeviceFormat > 0);
+    MA_ASSERT(pFramesInDeviceFormat != NULL);
+
+    if (pDevice->capture.converter.isPassthrough) {
+        ma_device__handle_data_callback(pDevice, NULL, pFramesInDeviceFormat, frameCountInDeviceFormat);
+    } else {
+        ma_result result;
+        ma_uint8 pFramesInClientFormat[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+        ma_uint64 framesInClientFormatCap = sizeof(pFramesInClientFormat) / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+        ma_uint64 totalDeviceFramesProcessed = 0;
+        ma_uint64 totalClientFramesProcessed = 0;
+        const void* pRunningFramesInDeviceFormat = pFramesInDeviceFormat;
+
+        /* We just keep going until we've exhausted all of our input frames and cannot generate any more output frames. */
+        for (;;) {
+            ma_uint64 deviceFramesProcessedThisIteration;
+            ma_uint64 clientFramesProcessedThisIteration;
+
+            deviceFramesProcessedThisIteration = (frameCountInDeviceFormat - totalDeviceFramesProcessed);
+            clientFramesProcessedThisIteration = framesInClientFormatCap;
+
+            result = ma_data_converter_process_pcm_frames(&pDevice->capture.converter, pRunningFramesInDeviceFormat, &deviceFramesProcessedThisIteration, pFramesInClientFormat, &clientFramesProcessedThisIteration);
+            if (result != MA_SUCCESS) {
+                break;
+            }
+
+            if (clientFramesProcessedThisIteration > 0) {
+                ma_device__handle_data_callback(pDevice, NULL, pFramesInClientFormat, (ma_uint32)clientFramesProcessedThisIteration);    /* Safe cast. */
+            }
+
+            pRunningFramesInDeviceFormat = ma_offset_ptr(pRunningFramesInDeviceFormat, deviceFramesProcessedThisIteration * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+            totalDeviceFramesProcessed  += deviceFramesProcessedThisIteration;
+            totalClientFramesProcessed  += clientFramesProcessedThisIteration;
+
+            /* This is just to silence a warning. I might want to use this variable later so leaving in place for now. */
+            (void)totalClientFramesProcessed;
+
+            if (deviceFramesProcessedThisIteration == 0 && clientFramesProcessedThisIteration == 0) {
+                break;  /* We're done. */
+            }
+        }
+    }
+}
+
+static ma_result ma_device__handle_duplex_callback_capture(ma_device* pDevice, ma_uint32 frameCountInDeviceFormat, const void* pFramesInDeviceFormat, ma_pcm_rb* pRB)
+{
+    ma_result result;
+    ma_uint32 totalDeviceFramesProcessed = 0;
+    const void* pRunningFramesInDeviceFormat = pFramesInDeviceFormat;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(frameCountInDeviceFormat > 0);
+    MA_ASSERT(pFramesInDeviceFormat != NULL);
+    MA_ASSERT(pRB != NULL);
+
+    /* Write to the ring buffer. The ring buffer is in the client format which means we need to convert. */
+    for (;;) {
+        ma_uint32 framesToProcessInDeviceFormat = (frameCountInDeviceFormat - totalDeviceFramesProcessed);
+        ma_uint32 framesToProcessInClientFormat = MA_DATA_CONVERTER_STACK_BUFFER_SIZE / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+        ma_uint64 framesProcessedInDeviceFormat;
+        ma_uint64 framesProcessedInClientFormat;
+        void* pFramesInClientFormat;
+
+        result = ma_pcm_rb_acquire_write(pRB, &framesToProcessInClientFormat, &pFramesInClientFormat);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "Failed to acquire capture PCM frames from ring buffer.");
+            break;
+        }
+
+        if (framesToProcessInClientFormat == 0) {
+            if (ma_pcm_rb_pointer_distance(pRB) == (ma_int32)ma_pcm_rb_get_subbuffer_size(pRB)) {
+                break;  /* Overrun. Not enough room in the ring buffer for input frame. Excess frames are dropped. */
+            }
+        }
+
+        /* Convert. */
+        framesProcessedInDeviceFormat = framesToProcessInDeviceFormat;
+        framesProcessedInClientFormat = framesToProcessInClientFormat;
+        result = ma_data_converter_process_pcm_frames(&pDevice->capture.converter, pRunningFramesInDeviceFormat, &framesProcessedInDeviceFormat, pFramesInClientFormat, &framesProcessedInClientFormat);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        result = ma_pcm_rb_commit_write(pRB, (ma_uint32)framesProcessedInClientFormat);  /* Safe cast. */
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "Failed to commit capture PCM frames to ring buffer.");
+            break;
+        }
+
+        pRunningFramesInDeviceFormat = ma_offset_ptr(pRunningFramesInDeviceFormat, framesProcessedInDeviceFormat * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+        totalDeviceFramesProcessed += (ma_uint32)framesProcessedInDeviceFormat; /* Safe cast. */
+
+        /* We're done when we're unable to process any client nor device frames. */
+        if (framesProcessedInClientFormat == 0 && framesProcessedInDeviceFormat == 0) {
+            break;  /* Done. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device__handle_duplex_callback_playback(ma_device* pDevice, ma_uint32 frameCount, void* pFramesInInternalFormat, ma_pcm_rb* pRB)
+{
+    ma_result result;
+    ma_uint8 silentInputFrames[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+    ma_uint32 totalFramesReadOut = 0;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(frameCount > 0);
+    MA_ASSERT(pFramesInInternalFormat != NULL);
+    MA_ASSERT(pRB != NULL);
+    MA_ASSERT(pDevice->playback.pInputCache != NULL);
+
+    /*
+    Sitting in the ring buffer should be captured data from the capture callback in external format. If there's not enough data in there for
+    the whole frameCount frames we just use silence instead for the input data.
+    */
+    MA_ZERO_MEMORY(silentInputFrames, sizeof(silentInputFrames));
+
+    while (totalFramesReadOut < frameCount && ma_device_is_started(pDevice)) {
+        /*
+        We should have a buffer allocated on the heap. Any playback frames still sitting in there
+        need to be sent to the internal device before we process any more data from the client.
+        */
+        if (pDevice->playback.inputCacheRemaining > 0) {
+            ma_uint64 framesConvertedIn  = pDevice->playback.inputCacheRemaining;
+            ma_uint64 framesConvertedOut = (frameCount - totalFramesReadOut);
+            ma_data_converter_process_pcm_frames(&pDevice->playback.converter, ma_offset_pcm_frames_ptr(pDevice->playback.pInputCache, pDevice->playback.inputCacheConsumed, pDevice->playback.format, pDevice->playback.channels), &framesConvertedIn, pFramesInInternalFormat, &framesConvertedOut);
+
+            pDevice->playback.inputCacheConsumed  += framesConvertedIn;
+            pDevice->playback.inputCacheRemaining -= framesConvertedIn;
+
+            totalFramesReadOut        += (ma_uint32)framesConvertedOut; /* Safe cast. */
+            pFramesInInternalFormat    = ma_offset_ptr(pFramesInInternalFormat, framesConvertedOut * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+        }
+
+        /* If there's no more data in the cache we'll need to fill it with some. */
+        if (totalFramesReadOut < frameCount && pDevice->playback.inputCacheRemaining == 0) {
+            ma_uint32 inputFrameCount;
+            void* pInputFrames;
+
+            inputFrameCount = (ma_uint32)pDevice->playback.inputCacheCap;
+            result = ma_pcm_rb_acquire_read(pRB, &inputFrameCount, &pInputFrames);
+            if (result == MA_SUCCESS) {
+                if (inputFrameCount > 0) {
+                    ma_device__handle_data_callback(pDevice, pDevice->playback.pInputCache, pInputFrames, inputFrameCount);
+                } else {
+                    if (ma_pcm_rb_pointer_distance(pRB) == 0) {
+                        break;  /* Underrun. */
+                    }
+                }
+            } else {
+                /* No capture data available. Feed in silence. */
+                inputFrameCount = (ma_uint32)ma_min(pDevice->playback.inputCacheCap, sizeof(silentInputFrames) / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels));
+                ma_device__handle_data_callback(pDevice, pDevice->playback.pInputCache, silentInputFrames, inputFrameCount);
+            }
+
+            pDevice->playback.inputCacheConsumed  = 0;
+            pDevice->playback.inputCacheRemaining = inputFrameCount;
+
+            result = ma_pcm_rb_commit_read(pRB, inputFrameCount);
+            if (result != MA_SUCCESS) {
+                return result;  /* Should never happen. */
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+/* A helper for changing the state of the device. */
+static MA_INLINE void ma_device__set_state(ma_device* pDevice, ma_device_state newState)
+{
+    ma_atomic_device_state_set(&pDevice->state, newState);
+}
+
+
+
+MA_API ma_uint32 ma_get_format_priority_index(ma_format format) /* Lower = better. */
+{
+    ma_uint32 i;
+    for (i = 0; i < ma_countof(g_maFormatPriorities); ++i) {
+        if (g_maFormatPriorities[i] == format) {
+            return i;
+        }
+    }
+
+    /* Getting here means the format could not be found or is equal to ma_format_unknown. */
+    return (ma_uint32)-1;
+}
+
+static ma_result ma_device__post_init_setup(ma_device* pDevice, ma_device_type deviceType);
+
+static ma_bool32 ma_device_descriptor_is_valid(const ma_device_descriptor* pDeviceDescriptor)
+{
+    if (pDeviceDescriptor == NULL) {
+        return MA_FALSE;
+    }
+
+    if (pDeviceDescriptor->format == ma_format_unknown) {
+        return MA_FALSE;
+    }
+
+    if (pDeviceDescriptor->channels == 0 || pDeviceDescriptor->channels > MA_MAX_CHANNELS) {
+        return MA_FALSE;
+    }
+
+    if (pDeviceDescriptor->sampleRate == 0) {
+        return MA_FALSE;
+    }
+
+    return MA_TRUE;
+}
+
+
+static ma_result ma_device_audio_thread__default_read_write(ma_device* pDevice)
+{
+    ma_result result = MA_SUCCESS;
+    ma_bool32 exitLoop = MA_FALSE;
+    ma_uint8  capturedDeviceData[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+    ma_uint8  playbackDeviceData[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+    ma_uint32 capturedDeviceDataCapInFrames = 0;
+    ma_uint32 playbackDeviceDataCapInFrames = 0;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* Just some quick validation on the device type and the available callbacks. */
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        if (pDevice->pContext->callbacks.onDeviceRead == NULL) {
+            return MA_NOT_IMPLEMENTED;
+        }
+
+        capturedDeviceDataCapInFrames = sizeof(capturedDeviceData) / ma_get_bytes_per_frame(pDevice->capture.internalFormat,  pDevice->capture.internalChannels);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->pContext->callbacks.onDeviceWrite == NULL) {
+            return MA_NOT_IMPLEMENTED;
+        }
+
+        playbackDeviceDataCapInFrames = sizeof(playbackDeviceData) / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    }
+
+    /* NOTE: The device was started outside of this function, in the worker thread. */
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started && !exitLoop) {
+        switch (pDevice->type) {
+            case ma_device_type_duplex:
+            {
+                /* The process is: onDeviceRead() -> convert -> callback -> convert -> onDeviceWrite() */
+                ma_uint32 totalCapturedDeviceFramesProcessed = 0;
+                ma_uint32 capturedDevicePeriodSizeInFrames = ma_min(pDevice->capture.internalPeriodSizeInFrames, pDevice->playback.internalPeriodSizeInFrames);
+
+                while (totalCapturedDeviceFramesProcessed < capturedDevicePeriodSizeInFrames) {
+                    ma_uint32 capturedDeviceFramesRemaining;
+                    ma_uint32 capturedDeviceFramesProcessed;
+                    ma_uint32 capturedDeviceFramesToProcess;
+                    ma_uint32 capturedDeviceFramesToTryProcessing = capturedDevicePeriodSizeInFrames - totalCapturedDeviceFramesProcessed;
+                    if (capturedDeviceFramesToTryProcessing > capturedDeviceDataCapInFrames) {
+                        capturedDeviceFramesToTryProcessing = capturedDeviceDataCapInFrames;
+                    }
+
+                    result = pDevice->pContext->callbacks.onDeviceRead(pDevice, capturedDeviceData, capturedDeviceFramesToTryProcessing, &capturedDeviceFramesToProcess);
+                    if (result != MA_SUCCESS) {
+                        exitLoop = MA_TRUE;
+                        break;
+                    }
+
+                    capturedDeviceFramesRemaining = capturedDeviceFramesToProcess;
+                    capturedDeviceFramesProcessed = 0;
+
+                    /* At this point we have our captured data in device format and we now need to convert it to client format. */
+                    for (;;) {
+                        ma_uint8  capturedClientData[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                        ma_uint8  playbackClientData[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                        ma_uint32 capturedClientDataCapInFrames = sizeof(capturedClientData) / ma_get_bytes_per_frame(pDevice->capture.format,  pDevice->capture.channels);
+                        ma_uint32 playbackClientDataCapInFrames = sizeof(playbackClientData) / ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+                        ma_uint64 capturedClientFramesToProcessThisIteration = ma_min(capturedClientDataCapInFrames, playbackClientDataCapInFrames);
+                        ma_uint64 capturedDeviceFramesToProcessThisIteration = capturedDeviceFramesRemaining;
+                        ma_uint8* pRunningCapturedDeviceFrames = ma_offset_ptr(capturedDeviceData, capturedDeviceFramesProcessed * ma_get_bytes_per_frame(pDevice->capture.internalFormat,  pDevice->capture.internalChannels));
+
+                        /* Convert capture data from device format to client format. */
+                        result = ma_data_converter_process_pcm_frames(&pDevice->capture.converter, pRunningCapturedDeviceFrames, &capturedDeviceFramesToProcessThisIteration, capturedClientData, &capturedClientFramesToProcessThisIteration);
+                        if (result != MA_SUCCESS) {
+                            break;
+                        }
+
+                        /*
+                        If we weren't able to generate any output frames it must mean we've exhausted all of our input. The only time this would not be the case is if capturedClientData was too small
+                        which should never be the case when it's of the size MA_DATA_CONVERTER_STACK_BUFFER_SIZE.
+                        */
+                        if (capturedClientFramesToProcessThisIteration == 0) {
+                            break;
+                        }
+
+                        ma_device__handle_data_callback(pDevice, playbackClientData, capturedClientData, (ma_uint32)capturedClientFramesToProcessThisIteration);    /* Safe cast .*/
+
+                        capturedDeviceFramesProcessed += (ma_uint32)capturedDeviceFramesToProcessThisIteration; /* Safe cast. */
+                        capturedDeviceFramesRemaining -= (ma_uint32)capturedDeviceFramesToProcessThisIteration; /* Safe cast. */
+
+                        /* At this point the playbackClientData buffer should be holding data that needs to be written to the device. */
+                        for (;;) {
+                            ma_uint64 convertedClientFrameCount = capturedClientFramesToProcessThisIteration;
+                            ma_uint64 convertedDeviceFrameCount = playbackDeviceDataCapInFrames;
+                            result = ma_data_converter_process_pcm_frames(&pDevice->playback.converter, playbackClientData, &convertedClientFrameCount, playbackDeviceData, &convertedDeviceFrameCount);
+                            if (result != MA_SUCCESS) {
+                                break;
+                            }
+
+                            result = pDevice->pContext->callbacks.onDeviceWrite(pDevice, playbackDeviceData, (ma_uint32)convertedDeviceFrameCount, NULL);   /* Safe cast. */
+                            if (result != MA_SUCCESS) {
+                                exitLoop = MA_TRUE;
+                                break;
+                            }
+
+                            capturedClientFramesToProcessThisIteration -= (ma_uint32)convertedClientFrameCount;  /* Safe cast. */
+                            if (capturedClientFramesToProcessThisIteration == 0) {
+                                break;
+                            }
+                        }
+
+                        /* In case an error happened from ma_device_write__null()... */
+                        if (result != MA_SUCCESS) {
+                            exitLoop = MA_TRUE;
+                            break;
+                        }
+                    }
+
+                    /* Make sure we don't get stuck in the inner loop. */
+                    if (capturedDeviceFramesProcessed == 0) {
+                        break;
+                    }
+
+                    totalCapturedDeviceFramesProcessed += capturedDeviceFramesProcessed;
+                }
+            } break;
+
+            case ma_device_type_capture:
+            case ma_device_type_loopback:
+            {
+                ma_uint32 periodSizeInFrames = pDevice->capture.internalPeriodSizeInFrames;
+                ma_uint32 framesReadThisPeriod = 0;
+                while (framesReadThisPeriod < periodSizeInFrames) {
+                    ma_uint32 framesRemainingInPeriod = periodSizeInFrames - framesReadThisPeriod;
+                    ma_uint32 framesProcessed;
+                    ma_uint32 framesToReadThisIteration = framesRemainingInPeriod;
+                    if (framesToReadThisIteration > capturedDeviceDataCapInFrames) {
+                        framesToReadThisIteration = capturedDeviceDataCapInFrames;
+                    }
+
+                    result = pDevice->pContext->callbacks.onDeviceRead(pDevice, capturedDeviceData, framesToReadThisIteration, &framesProcessed);
+                    if (result != MA_SUCCESS) {
+                        exitLoop = MA_TRUE;
+                        break;
+                    }
+
+                    /* Make sure we don't get stuck in the inner loop. */
+                    if (framesProcessed == 0) {
+                        break;
+                    }
+
+                    ma_device__send_frames_to_client(pDevice, framesProcessed, capturedDeviceData);
+
+                    framesReadThisPeriod += framesProcessed;
+                }
+            } break;
+
+            case ma_device_type_playback:
+            {
+                /* We write in chunks of the period size, but use a stack allocated buffer for the intermediary. */
+                ma_uint32 periodSizeInFrames = pDevice->playback.internalPeriodSizeInFrames;
+                ma_uint32 framesWrittenThisPeriod = 0;
+                while (framesWrittenThisPeriod < periodSizeInFrames) {
+                    ma_uint32 framesRemainingInPeriod = periodSizeInFrames - framesWrittenThisPeriod;
+                    ma_uint32 framesProcessed;
+                    ma_uint32 framesToWriteThisIteration = framesRemainingInPeriod;
+                    if (framesToWriteThisIteration > playbackDeviceDataCapInFrames) {
+                        framesToWriteThisIteration = playbackDeviceDataCapInFrames;
+                    }
+
+                    ma_device__read_frames_from_client(pDevice, framesToWriteThisIteration, playbackDeviceData);
+
+                    result = pDevice->pContext->callbacks.onDeviceWrite(pDevice, playbackDeviceData, framesToWriteThisIteration, &framesProcessed);
+                    if (result != MA_SUCCESS) {
+                        exitLoop = MA_TRUE;
+                        break;
+                    }
+
+                    /* Make sure we don't get stuck in the inner loop. */
+                    if (framesProcessed == 0) {
+                        break;
+                    }
+
+                    framesWrittenThisPeriod += framesProcessed;
+                }
+            } break;
+
+            /* Should never get here. */
+            default: break;
+        }
+    }
+
+    return result;
+}
+
+
+
+/*******************************************************************************
+
+Null Backend
+
+*******************************************************************************/
+#ifdef MA_HAS_NULL
+
+#define MA_DEVICE_OP_NONE__NULL    0
+#define MA_DEVICE_OP_START__NULL   1
+#define MA_DEVICE_OP_SUSPEND__NULL 2
+#define MA_DEVICE_OP_KILL__NULL    3
+
+static ma_thread_result MA_THREADCALL ma_device_thread__null(void* pData)
+{
+    ma_device* pDevice = (ma_device*)pData;
+    MA_ASSERT(pDevice != NULL);
+
+    for (;;) {  /* Keep the thread alive until the device is uninitialized. */
+        ma_uint32 operation;
+
+        /* Wait for an operation to be requested. */
+        ma_event_wait(&pDevice->null_device.operationEvent);
+
+        /* At this point an event should have been triggered. */
+        operation = pDevice->null_device.operation;
+
+        /* Starting the device needs to put the thread into a loop. */
+        if (operation == MA_DEVICE_OP_START__NULL) {
+            /* Reset the timer just in case. */
+            ma_timer_init(&pDevice->null_device.timer);
+
+            /* Getting here means a suspend or kill operation has been requested. */
+            pDevice->null_device.operationResult = MA_SUCCESS;
+            ma_event_signal(&pDevice->null_device.operationCompletionEvent);
+            ma_semaphore_release(&pDevice->null_device.operationSemaphore);
+            continue;
+        }
+
+        /* Suspending the device means we need to stop the timer and just continue the loop. */
+        if (operation == MA_DEVICE_OP_SUSPEND__NULL) {
+            /* We need to add the current run time to the prior run time, then reset the timer. */
+            pDevice->null_device.priorRunTime += ma_timer_get_time_in_seconds(&pDevice->null_device.timer);
+            ma_timer_init(&pDevice->null_device.timer);
+
+            /* We're done. */
+            pDevice->null_device.operationResult = MA_SUCCESS;
+            ma_event_signal(&pDevice->null_device.operationCompletionEvent);
+            ma_semaphore_release(&pDevice->null_device.operationSemaphore);
+            continue;
+        }
+
+        /* Killing the device means we need to get out of this loop so that this thread can terminate. */
+        if (operation == MA_DEVICE_OP_KILL__NULL) {
+            pDevice->null_device.operationResult = MA_SUCCESS;
+            ma_event_signal(&pDevice->null_device.operationCompletionEvent);
+            ma_semaphore_release(&pDevice->null_device.operationSemaphore);
+            break;
+        }
+
+        /* Getting a signal on a "none" operation probably means an error. Return invalid operation. */
+        if (operation == MA_DEVICE_OP_NONE__NULL) {
+            MA_ASSERT(MA_FALSE);  /* <-- Trigger this in debug mode to ensure developers are aware they're doing something wrong (or there's a bug in a miniaudio). */
+            pDevice->null_device.operationResult = MA_INVALID_OPERATION;
+            ma_event_signal(&pDevice->null_device.operationCompletionEvent);
+            ma_semaphore_release(&pDevice->null_device.operationSemaphore);
+            continue;   /* Continue the loop. Don't terminate. */
+        }
+    }
+
+    return (ma_thread_result)0;
+}
+
+static ma_result ma_device_do_operation__null(ma_device* pDevice, ma_uint32 operation)
+{
+    ma_result result;
+
+    /*
+    TODO: Need to review this and consider just using mutual exclusion. I think the original motivation
+    for this was to just post the event to a queue and return immediately, but that has since changed
+    and now this function is synchronous. I think this can be simplified to just use a mutex.
+    */
+
+    /*
+    The first thing to do is wait for an operation slot to become available. We only have a single slot for this, but we could extend this later
+    to support queuing of operations.
+    */
+    result = ma_semaphore_wait(&pDevice->null_device.operationSemaphore);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to wait for the event. */
+    }
+
+    /*
+    When we get here it means the background thread is not referencing the operation code and it can be changed. After changing this we need to
+    signal an event to the worker thread to let it know that it can start work.
+    */
+    pDevice->null_device.operation = operation;
+
+    /* Once the operation code has been set, the worker thread can start work. */
+    if (ma_event_signal(&pDevice->null_device.operationEvent) != MA_SUCCESS) {
+        return MA_ERROR;
+    }
+
+    /* We want everything to be synchronous so we're going to wait for the worker thread to complete it's operation. */
+    if (ma_event_wait(&pDevice->null_device.operationCompletionEvent) != MA_SUCCESS) {
+        return MA_ERROR;
+    }
+
+    return pDevice->null_device.operationResult;
+}
+
+static ma_uint64 ma_device_get_total_run_time_in_frames__null(ma_device* pDevice)
+{
+    ma_uint32 internalSampleRate;
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        internalSampleRate = pDevice->capture.internalSampleRate;
+    } else {
+        internalSampleRate = pDevice->playback.internalSampleRate;
+    }
+
+    return (ma_uint64)((pDevice->null_device.priorRunTime + ma_timer_get_time_in_seconds(&pDevice->null_device.timer)) * internalSampleRate);
+}
+
+static ma_result ma_context_enumerate_devices__null(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult = MA_TRUE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), "NULL Playback Device", (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE; /* Only one playback and capture device for the null backend, so might as well mark as default. */
+        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), "NULL Capture Device", (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE; /* Only one playback and capture device for the null backend, so might as well mark as default. */
+        cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+    }
+
+    (void)cbResult; /* Silence a static analysis warning. */
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__null(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext != NULL);
+
+    if (pDeviceID != NULL && pDeviceID->nullbackend != 0) {
+        return MA_NO_DEVICE;   /* Don't know the device. */
+    }
+
+    /* Name / Description */
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), "NULL Playback Device", (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), "NULL Capture Device", (size_t)-1);
+    }
+
+    pDeviceInfo->isDefault = MA_TRUE;   /* Only one playback and capture device for the null backend, so might as well mark as default. */
+
+    /* Support everything on the null backend. */
+    pDeviceInfo->nativeDataFormats[0].format     = ma_format_unknown;
+    pDeviceInfo->nativeDataFormats[0].channels   = 0;
+    pDeviceInfo->nativeDataFormats[0].sampleRate = 0;
+    pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pDeviceInfo->nativeDataFormatCount = 1;
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_uninit__null(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* Keep it clean and wait for the device thread to finish before returning. */
+    ma_device_do_operation__null(pDevice, MA_DEVICE_OP_KILL__NULL);
+
+    /* Wait for the thread to finish before continuing. */
+    ma_thread_wait(&pDevice->null_device.deviceThread);
+
+    /* At this point the loop in the device thread is as good as terminated so we can uninitialize our events. */
+    ma_semaphore_uninit(&pDevice->null_device.operationSemaphore);
+    ma_event_uninit(&pDevice->null_device.operationCompletionEvent);
+    ma_event_uninit(&pDevice->null_device.operationEvent);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__null(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->null_device);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* The null backend supports everything exactly as we specify it. */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        pDescriptorCapture->format     = (pDescriptorCapture->format     != ma_format_unknown) ? pDescriptorCapture->format     : MA_DEFAULT_FORMAT;
+        pDescriptorCapture->channels   = (pDescriptorCapture->channels   != 0)                 ? pDescriptorCapture->channels   : MA_DEFAULT_CHANNELS;
+        pDescriptorCapture->sampleRate = (pDescriptorCapture->sampleRate != 0)                 ? pDescriptorCapture->sampleRate : MA_DEFAULT_SAMPLE_RATE;
+
+        if (pDescriptorCapture->channelMap[0] == MA_CHANNEL_NONE) {
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorCapture->channels);
+        }
+
+        pDescriptorCapture->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorCapture, pDescriptorCapture->sampleRate, pConfig->performanceProfile);
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        pDescriptorPlayback->format     = (pDescriptorPlayback->format     != ma_format_unknown) ? pDescriptorPlayback->format     : MA_DEFAULT_FORMAT;
+        pDescriptorPlayback->channels   = (pDescriptorPlayback->channels   != 0)                 ? pDescriptorPlayback->channels   : MA_DEFAULT_CHANNELS;
+        pDescriptorPlayback->sampleRate = (pDescriptorPlayback->sampleRate != 0)                 ? pDescriptorPlayback->sampleRate : MA_DEFAULT_SAMPLE_RATE;
+
+        if (pDescriptorPlayback->channelMap[0] == MA_CHANNEL_NONE) {
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pDescriptorPlayback->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorPlayback->channels);
+        }
+
+        pDescriptorPlayback->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorPlayback, pDescriptorPlayback->sampleRate, pConfig->performanceProfile);
+    }
+
+    /*
+    In order to get timing right, we need to create a thread that does nothing but keeps track of the timer. This timer is started when the
+    first period is "written" to it, and then stopped in ma_device_stop__null().
+    */
+    result = ma_event_init(&pDevice->null_device.operationEvent);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_event_init(&pDevice->null_device.operationCompletionEvent);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_semaphore_init(1, &pDevice->null_device.operationSemaphore);    /* <-- It's important that the initial value is set to 1. */
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_thread_create(&pDevice->null_device.deviceThread, pDevice->pContext->threadPriority, 0, ma_device_thread__null, pDevice, &pDevice->pContext->allocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__null(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ma_device_do_operation__null(pDevice, MA_DEVICE_OP_START__NULL);
+
+    ma_atomic_bool32_set(&pDevice->null_device.isStarted, MA_TRUE);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__null(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ma_device_do_operation__null(pDevice, MA_DEVICE_OP_SUSPEND__NULL);
+
+    ma_atomic_bool32_set(&pDevice->null_device.isStarted, MA_FALSE);
+    return MA_SUCCESS;
+}
+
+static ma_bool32 ma_device_is_started__null(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    return ma_atomic_bool32_get(&pDevice->null_device.isStarted);
+}
+
+static ma_result ma_device_write__null(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 totalPCMFramesProcessed;
+    ma_bool32 wasStartedOnEntry;
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    wasStartedOnEntry = ma_device_is_started__null(pDevice);
+
+    /* Keep going until everything has been read. */
+    totalPCMFramesProcessed = 0;
+    while (totalPCMFramesProcessed < frameCount) {
+        ma_uint64 targetFrame;
+
+        /* If there are any frames remaining in the current period, consume those first. */
+        if (pDevice->null_device.currentPeriodFramesRemainingPlayback > 0) {
+            ma_uint32 framesRemaining = (frameCount - totalPCMFramesProcessed);
+            ma_uint32 framesToProcess = pDevice->null_device.currentPeriodFramesRemainingPlayback;
+            if (framesToProcess > framesRemaining) {
+                framesToProcess = framesRemaining;
+            }
+
+            /* We don't actually do anything with pPCMFrames, so just mark it as unused to prevent a warning. */
+            (void)pPCMFrames;
+
+            pDevice->null_device.currentPeriodFramesRemainingPlayback -= framesToProcess;
+            totalPCMFramesProcessed += framesToProcess;
+        }
+
+        /* If we've consumed the current period we'll need to mark it as such an ensure the device is started if it's not already. */
+        if (pDevice->null_device.currentPeriodFramesRemainingPlayback == 0) {
+            pDevice->null_device.currentPeriodFramesRemainingPlayback = 0;
+
+            if (!ma_device_is_started__null(pDevice) && !wasStartedOnEntry) {
+                result = ma_device_start__null(pDevice);
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+            }
+        }
+
+        /* If we've consumed the whole buffer we can return now. */
+        MA_ASSERT(totalPCMFramesProcessed <= frameCount);
+        if (totalPCMFramesProcessed == frameCount) {
+            break;
+        }
+
+        /* Getting here means we've still got more frames to consume, we but need to wait for it to become available. */
+        targetFrame = pDevice->null_device.lastProcessedFramePlayback;
+        for (;;) {
+            ma_uint64 currentFrame;
+
+            /* Stop waiting if the device has been stopped. */
+            if (!ma_device_is_started__null(pDevice)) {
+                break;
+            }
+
+            currentFrame = ma_device_get_total_run_time_in_frames__null(pDevice);
+            if (currentFrame >= targetFrame) {
+                break;
+            }
+
+            /* Getting here means we haven't yet reached the target sample, so continue waiting. */
+            ma_sleep(10);
+        }
+
+        pDevice->null_device.lastProcessedFramePlayback          += pDevice->playback.internalPeriodSizeInFrames;
+        pDevice->null_device.currentPeriodFramesRemainingPlayback = pDevice->playback.internalPeriodSizeInFrames;
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = totalPCMFramesProcessed;
+    }
+
+    return result;
+}
+
+static ma_result ma_device_read__null(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 totalPCMFramesProcessed;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    /* Keep going until everything has been read. */
+    totalPCMFramesProcessed = 0;
+    while (totalPCMFramesProcessed < frameCount) {
+        ma_uint64 targetFrame;
+
+        /* If there are any frames remaining in the current period, consume those first. */
+        if (pDevice->null_device.currentPeriodFramesRemainingCapture > 0) {
+            ma_uint32 bpf = ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+            ma_uint32 framesRemaining = (frameCount - totalPCMFramesProcessed);
+            ma_uint32 framesToProcess = pDevice->null_device.currentPeriodFramesRemainingCapture;
+            if (framesToProcess > framesRemaining) {
+                framesToProcess = framesRemaining;
+            }
+
+            /* We need to ensure the output buffer is zeroed. */
+            MA_ZERO_MEMORY(ma_offset_ptr(pPCMFrames, totalPCMFramesProcessed*bpf), framesToProcess*bpf);
+
+            pDevice->null_device.currentPeriodFramesRemainingCapture -= framesToProcess;
+            totalPCMFramesProcessed += framesToProcess;
+        }
+
+        /* If we've consumed the current period we'll need to mark it as such an ensure the device is started if it's not already. */
+        if (pDevice->null_device.currentPeriodFramesRemainingCapture == 0) {
+            pDevice->null_device.currentPeriodFramesRemainingCapture = 0;
+        }
+
+        /* If we've consumed the whole buffer we can return now. */
+        MA_ASSERT(totalPCMFramesProcessed <= frameCount);
+        if (totalPCMFramesProcessed == frameCount) {
+            break;
+        }
+
+        /* Getting here means we've still got more frames to consume, we but need to wait for it to become available. */
+        targetFrame = pDevice->null_device.lastProcessedFrameCapture + pDevice->capture.internalPeriodSizeInFrames;
+        for (;;) {
+            ma_uint64 currentFrame;
+
+            /* Stop waiting if the device has been stopped. */
+            if (!ma_device_is_started__null(pDevice)) {
+                break;
+            }
+
+            currentFrame = ma_device_get_total_run_time_in_frames__null(pDevice);
+            if (currentFrame >= targetFrame) {
+                break;
+            }
+
+            /* Getting here means we haven't yet reached the target sample, so continue waiting. */
+            ma_sleep(10);
+        }
+
+        pDevice->null_device.lastProcessedFrameCapture          += pDevice->capture.internalPeriodSizeInFrames;
+        pDevice->null_device.currentPeriodFramesRemainingCapture = pDevice->capture.internalPeriodSizeInFrames;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalPCMFramesProcessed;
+    }
+
+    return result;
+}
+
+static ma_result ma_context_uninit__null(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_null);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__null(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+    (void)pContext;
+
+    pCallbacks->onContextInit             = ma_context_init__null;
+    pCallbacks->onContextUninit           = ma_context_uninit__null;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__null;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__null;
+    pCallbacks->onDeviceInit              = ma_device_init__null;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__null;
+    pCallbacks->onDeviceStart             = ma_device_start__null;
+    pCallbacks->onDeviceStop              = ma_device_stop__null;
+    pCallbacks->onDeviceRead              = ma_device_read__null;
+    pCallbacks->onDeviceWrite             = ma_device_write__null;
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Our backend is asynchronous with a blocking read-write API which means we can get miniaudio to deal with the audio thread. */
+
+    /* The null backend always works. */
+    return MA_SUCCESS;
+}
+#endif
+
+
+
+/*******************************************************************************
+
+WIN32 COMMON
+
+*******************************************************************************/
+#if defined(MA_WIN32) && !defined(MA_XBOX)
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    #define ma_CoInitializeEx(pContext, pvReserved, dwCoInit)                          ((pContext->win32.CoInitializeEx) ? ((MA_PFN_CoInitializeEx)pContext->win32.CoInitializeEx)(pvReserved, dwCoInit) : ((MA_PFN_CoInitialize)pContext->win32.CoInitialize)(pvReserved))
+    #define ma_CoUninitialize(pContext)                                                ((MA_PFN_CoUninitialize)pContext->win32.CoUninitialize)()
+    #define ma_CoCreateInstance(pContext, rclsid, pUnkOuter, dwClsContext, riid, ppv)  ((MA_PFN_CoCreateInstance)pContext->win32.CoCreateInstance)(rclsid, pUnkOuter, dwClsContext, riid, ppv)
+    #define ma_CoTaskMemFree(pContext, pv)                                             ((MA_PFN_CoTaskMemFree)pContext->win32.CoTaskMemFree)(pv)
+    #define ma_PropVariantClear(pContext, pvar)                                        ((MA_PFN_PropVariantClear)pContext->win32.PropVariantClear)(pvar)
+#else
+    #define ma_CoInitializeEx(pContext, pvReserved, dwCoInit)                          CoInitializeEx(pvReserved, dwCoInit)
+    #define ma_CoUninitialize(pContext)                                                CoUninitialize()
+    #define ma_CoCreateInstance(pContext, rclsid, pUnkOuter, dwClsContext, riid, ppv)  CoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv)
+    #define ma_CoTaskMemFree(pContext, pv)                                             CoTaskMemFree(pv)
+    #define ma_PropVariantClear(pContext, pvar)                                        PropVariantClear(pvar)
+#endif
+
+#if !defined(MAXULONG_PTR) && !defined(__WATCOMC__) && !defined(MA_XBOX_NXDK)
+typedef size_t DWORD_PTR;
+#endif
+
+#if !defined(WAVE_FORMAT_1M08)
+#define WAVE_FORMAT_1M08    0x00000001
+#define WAVE_FORMAT_1S08    0x00000002
+#define WAVE_FORMAT_1M16    0x00000004
+#define WAVE_FORMAT_1S16    0x00000008
+#define WAVE_FORMAT_2M08    0x00000010
+#define WAVE_FORMAT_2S08    0x00000020
+#define WAVE_FORMAT_2M16    0x00000040
+#define WAVE_FORMAT_2S16    0x00000080
+#define WAVE_FORMAT_4M08    0x00000100
+#define WAVE_FORMAT_4S08    0x00000200
+#define WAVE_FORMAT_4M16    0x00000400
+#define WAVE_FORMAT_4S16    0x00000800
+#endif
+
+#if !defined(WAVE_FORMAT_44M08)
+#define WAVE_FORMAT_44M08   0x00000100
+#define WAVE_FORMAT_44S08   0x00000200
+#define WAVE_FORMAT_44M16   0x00000400
+#define WAVE_FORMAT_44S16   0x00000800
+#define WAVE_FORMAT_48M08   0x00001000
+#define WAVE_FORMAT_48S08   0x00002000
+#define WAVE_FORMAT_48M16   0x00004000
+#define WAVE_FORMAT_48S16   0x00008000
+#define WAVE_FORMAT_96M08   0x00010000
+#define WAVE_FORMAT_96S08   0x00020000
+#define WAVE_FORMAT_96M16   0x00040000
+#define WAVE_FORMAT_96S16   0x00080000
+#endif
+
+#ifndef SPEAKER_FRONT_LEFT
+#define SPEAKER_FRONT_LEFT            0x1
+#define SPEAKER_FRONT_RIGHT           0x2
+#define SPEAKER_FRONT_CENTER          0x4
+#define SPEAKER_LOW_FREQUENCY         0x8
+#define SPEAKER_BACK_LEFT             0x10
+#define SPEAKER_BACK_RIGHT            0x20
+#define SPEAKER_FRONT_LEFT_OF_CENTER  0x40
+#define SPEAKER_FRONT_RIGHT_OF_CENTER 0x80
+#define SPEAKER_BACK_CENTER           0x100
+#define SPEAKER_SIDE_LEFT             0x200
+#define SPEAKER_SIDE_RIGHT            0x400
+#define SPEAKER_TOP_CENTER            0x800
+#define SPEAKER_TOP_FRONT_LEFT        0x1000
+#define SPEAKER_TOP_FRONT_CENTER      0x2000
+#define SPEAKER_TOP_FRONT_RIGHT       0x4000
+#define SPEAKER_TOP_BACK_LEFT         0x8000
+#define SPEAKER_TOP_BACK_CENTER       0x10000
+#define SPEAKER_TOP_BACK_RIGHT        0x20000
+#endif
+
+/*
+Implement our own version of MA_WAVEFORMATEXTENSIBLE so we can avoid a header. Be careful with this
+because MA_WAVEFORMATEX has an extra two bytes over standard WAVEFORMATEX due to padding. The
+standard version uses tight packing, but for compiler compatibility we're not doing that with ours.
+*/
+typedef struct
+{
+    WORD wFormatTag;
+    WORD nChannels;
+    DWORD nSamplesPerSec;
+    DWORD nAvgBytesPerSec;
+    WORD nBlockAlign;
+    WORD wBitsPerSample;
+    WORD cbSize;
+} MA_WAVEFORMATEX;
+
+typedef struct
+{
+    WORD wFormatTag;
+    WORD nChannels;
+    DWORD nSamplesPerSec;
+    DWORD nAvgBytesPerSec;
+    WORD nBlockAlign;
+    WORD wBitsPerSample;
+    WORD cbSize;
+    union
+    {
+        WORD wValidBitsPerSample;
+        WORD wSamplesPerBlock;
+        WORD wReserved;
+    } Samples;
+    DWORD dwChannelMask;
+    GUID SubFormat;
+} MA_WAVEFORMATEXTENSIBLE;
+
+
+
+#ifndef WAVE_FORMAT_EXTENSIBLE
+#define WAVE_FORMAT_EXTENSIBLE  0xFFFE
+#endif
+
+#ifndef WAVE_FORMAT_PCM
+#define WAVE_FORMAT_PCM         1
+#endif
+
+#ifndef WAVE_FORMAT_IEEE_FLOAT
+#define WAVE_FORMAT_IEEE_FLOAT  0x0003
+#endif
+
+/* Converts an individual Win32-style channel identifier (SPEAKER_FRONT_LEFT, etc.) to miniaudio. */
+static ma_uint8 ma_channel_id_to_ma__win32(DWORD id)
+{
+    switch (id)
+    {
+        case SPEAKER_FRONT_LEFT:            return MA_CHANNEL_FRONT_LEFT;
+        case SPEAKER_FRONT_RIGHT:           return MA_CHANNEL_FRONT_RIGHT;
+        case SPEAKER_FRONT_CENTER:          return MA_CHANNEL_FRONT_CENTER;
+        case SPEAKER_LOW_FREQUENCY:         return MA_CHANNEL_LFE;
+        case SPEAKER_BACK_LEFT:             return MA_CHANNEL_BACK_LEFT;
+        case SPEAKER_BACK_RIGHT:            return MA_CHANNEL_BACK_RIGHT;
+        case SPEAKER_FRONT_LEFT_OF_CENTER:  return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case SPEAKER_FRONT_RIGHT_OF_CENTER: return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case SPEAKER_BACK_CENTER:           return MA_CHANNEL_BACK_CENTER;
+        case SPEAKER_SIDE_LEFT:             return MA_CHANNEL_SIDE_LEFT;
+        case SPEAKER_SIDE_RIGHT:            return MA_CHANNEL_SIDE_RIGHT;
+        case SPEAKER_TOP_CENTER:            return MA_CHANNEL_TOP_CENTER;
+        case SPEAKER_TOP_FRONT_LEFT:        return MA_CHANNEL_TOP_FRONT_LEFT;
+        case SPEAKER_TOP_FRONT_CENTER:      return MA_CHANNEL_TOP_FRONT_CENTER;
+        case SPEAKER_TOP_FRONT_RIGHT:       return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case SPEAKER_TOP_BACK_LEFT:         return MA_CHANNEL_TOP_BACK_LEFT;
+        case SPEAKER_TOP_BACK_CENTER:       return MA_CHANNEL_TOP_BACK_CENTER;
+        case SPEAKER_TOP_BACK_RIGHT:        return MA_CHANNEL_TOP_BACK_RIGHT;
+        default: return 0;
+    }
+}
+
+/* Converts an individual miniaudio channel identifier (MA_CHANNEL_FRONT_LEFT, etc.) to Win32-style. */
+static DWORD ma_channel_id_to_win32(DWORD id)
+{
+    switch (id)
+    {
+        case MA_CHANNEL_MONO:               return SPEAKER_FRONT_CENTER;
+        case MA_CHANNEL_FRONT_LEFT:         return SPEAKER_FRONT_LEFT;
+        case MA_CHANNEL_FRONT_RIGHT:        return SPEAKER_FRONT_RIGHT;
+        case MA_CHANNEL_FRONT_CENTER:       return SPEAKER_FRONT_CENTER;
+        case MA_CHANNEL_LFE:                return SPEAKER_LOW_FREQUENCY;
+        case MA_CHANNEL_BACK_LEFT:          return SPEAKER_BACK_LEFT;
+        case MA_CHANNEL_BACK_RIGHT:         return SPEAKER_BACK_RIGHT;
+        case MA_CHANNEL_FRONT_LEFT_CENTER:  return SPEAKER_FRONT_LEFT_OF_CENTER;
+        case MA_CHANNEL_FRONT_RIGHT_CENTER: return SPEAKER_FRONT_RIGHT_OF_CENTER;
+        case MA_CHANNEL_BACK_CENTER:        return SPEAKER_BACK_CENTER;
+        case MA_CHANNEL_SIDE_LEFT:          return SPEAKER_SIDE_LEFT;
+        case MA_CHANNEL_SIDE_RIGHT:         return SPEAKER_SIDE_RIGHT;
+        case MA_CHANNEL_TOP_CENTER:         return SPEAKER_TOP_CENTER;
+        case MA_CHANNEL_TOP_FRONT_LEFT:     return SPEAKER_TOP_FRONT_LEFT;
+        case MA_CHANNEL_TOP_FRONT_CENTER:   return SPEAKER_TOP_FRONT_CENTER;
+        case MA_CHANNEL_TOP_FRONT_RIGHT:    return SPEAKER_TOP_FRONT_RIGHT;
+        case MA_CHANNEL_TOP_BACK_LEFT:      return SPEAKER_TOP_BACK_LEFT;
+        case MA_CHANNEL_TOP_BACK_CENTER:    return SPEAKER_TOP_BACK_CENTER;
+        case MA_CHANNEL_TOP_BACK_RIGHT:     return SPEAKER_TOP_BACK_RIGHT;
+        default: return 0;
+    }
+}
+
+/* Converts a channel mapping to a Win32-style channel mask. */
+static DWORD ma_channel_map_to_channel_mask__win32(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    DWORD dwChannelMask = 0;
+    ma_uint32 iChannel;
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        dwChannelMask |= ma_channel_id_to_win32(pChannelMap[iChannel]);
+    }
+
+    return dwChannelMask;
+}
+
+/* Converts a Win32-style channel mask to a miniaudio channel map. */
+static void ma_channel_mask_to_channel_map__win32(DWORD dwChannelMask, ma_uint32 channels, ma_channel* pChannelMap)
+{
+    /* If the channel mask is set to 0, just assume a default Win32 channel map. */
+    if (dwChannelMask == 0) {
+        ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pChannelMap, channels, channels);
+    } else {
+        if (channels == 1 && (dwChannelMask & SPEAKER_FRONT_CENTER) != 0) {
+            pChannelMap[0] = MA_CHANNEL_MONO;
+        } else {
+            /* Just iterate over each bit. */
+            ma_uint32 iChannel = 0;
+            ma_uint32 iBit;
+
+            for (iBit = 0; iBit < 32 && iChannel < channels; ++iBit) {
+                DWORD bitValue = (dwChannelMask & (1UL << iBit));
+                if (bitValue != 0) {
+                    /* The bit is set. */
+                    pChannelMap[iChannel] = ma_channel_id_to_ma__win32(bitValue);
+                    iChannel += 1;
+                }
+            }
+        }
+    }
+}
+
+#ifdef __cplusplus
+static ma_bool32 ma_is_guid_equal(const void* a, const void* b)
+{
+    return IsEqualGUID(*(const GUID*)a, *(const GUID*)b);
+}
+#else
+#define ma_is_guid_equal(a, b) IsEqualGUID((const GUID*)a, (const GUID*)b)
+#endif
+
+static MA_INLINE ma_bool32 ma_is_guid_null(const void* guid)
+{
+    static GUID nullguid = {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
+    return ma_is_guid_equal(guid, &nullguid);
+}
+
+static ma_format ma_format_from_WAVEFORMATEX(const MA_WAVEFORMATEX* pWF)
+{
+    MA_ASSERT(pWF != NULL);
+
+    if (pWF->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
+        const MA_WAVEFORMATEXTENSIBLE* pWFEX = (const MA_WAVEFORMATEXTENSIBLE*)pWF;
+        if (ma_is_guid_equal(&pWFEX->SubFormat, &MA_GUID_KSDATAFORMAT_SUBTYPE_PCM)) {
+            if (pWFEX->Samples.wValidBitsPerSample == 32) {
+                return ma_format_s32;
+            }
+            if (pWFEX->Samples.wValidBitsPerSample == 24) {
+                if (pWFEX->wBitsPerSample == 32) {
+                    return ma_format_s32;
+                }
+                if (pWFEX->wBitsPerSample == 24) {
+                    return ma_format_s24;
+                }
+            }
+            if (pWFEX->Samples.wValidBitsPerSample == 16) {
+                return ma_format_s16;
+            }
+            if (pWFEX->Samples.wValidBitsPerSample == 8) {
+                return ma_format_u8;
+            }
+        }
+        if (ma_is_guid_equal(&pWFEX->SubFormat, &MA_GUID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) {
+            if (pWFEX->Samples.wValidBitsPerSample == 32) {
+                return ma_format_f32;
+            }
+            /*
+            if (pWFEX->Samples.wValidBitsPerSample == 64) {
+                return ma_format_f64;
+            }
+            */
+        }
+    } else {
+        if (pWF->wFormatTag == WAVE_FORMAT_PCM) {
+            if (pWF->wBitsPerSample == 32) {
+                return ma_format_s32;
+            }
+            if (pWF->wBitsPerSample == 24) {
+                return ma_format_s24;
+            }
+            if (pWF->wBitsPerSample == 16) {
+                return ma_format_s16;
+            }
+            if (pWF->wBitsPerSample == 8) {
+                return ma_format_u8;
+            }
+        }
+        if (pWF->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) {
+            if (pWF->wBitsPerSample == 32) {
+                return ma_format_f32;
+            }
+            if (pWF->wBitsPerSample == 64) {
+                /*return ma_format_f64;*/
+            }
+        }
+    }
+
+    return ma_format_unknown;
+}
+#endif
+
+
+/*******************************************************************************
+
+WASAPI Backend
+
+*******************************************************************************/
+#ifdef MA_HAS_WASAPI
+#if 0
+#if defined(_MSC_VER)
+    #pragma warning(push)
+    #pragma warning(disable:4091)   /* 'typedef ': ignored on left of '' when no variable is declared */
+#endif
+#include <audioclient.h>
+#include <mmdeviceapi.h>
+#if defined(_MSC_VER)
+    #pragma warning(pop)
+#endif
+#endif  /* 0 */
+
+static ma_result ma_device_reroute__wasapi(ma_device* pDevice, ma_device_type deviceType);
+
+/* Some compilers don't define VerifyVersionInfoW. Need to write this ourselves. */
+#define MA_WIN32_WINNT_VISTA    0x0600
+#define MA_VER_MINORVERSION     0x01
+#define MA_VER_MAJORVERSION     0x02
+#define MA_VER_SERVICEPACKMAJOR 0x20
+#define MA_VER_GREATER_EQUAL    0x03
+
+typedef struct  {
+    DWORD dwOSVersionInfoSize;
+    DWORD dwMajorVersion;
+    DWORD dwMinorVersion;
+    DWORD dwBuildNumber;
+    DWORD dwPlatformId;
+    WCHAR szCSDVersion[128];
+    WORD  wServicePackMajor;
+    WORD  wServicePackMinor;
+    WORD  wSuiteMask;
+    BYTE  wProductType;
+    BYTE  wReserved;
+} ma_OSVERSIONINFOEXW;
+
+typedef BOOL      (WINAPI * ma_PFNVerifyVersionInfoW) (ma_OSVERSIONINFOEXW* lpVersionInfo, DWORD dwTypeMask, DWORDLONG dwlConditionMask);
+typedef ULONGLONG (WINAPI * ma_PFNVerSetConditionMask)(ULONGLONG dwlConditionMask, DWORD dwTypeBitMask, BYTE dwConditionMask);
+
+
+#ifndef PROPERTYKEY_DEFINED
+#define PROPERTYKEY_DEFINED
+#ifndef __WATCOMC__
+typedef struct
+{
+    GUID fmtid;
+    DWORD pid;
+} PROPERTYKEY;
+#endif
+#endif
+
+/* Some compilers don't define PropVariantInit(). We just do this ourselves since it's just a memset(). */
+static MA_INLINE void ma_PropVariantInit(MA_PROPVARIANT* pProp)
+{
+    MA_ZERO_OBJECT(pProp);
+}
+
+
+static const PROPERTYKEY MA_PKEY_Device_FriendlyName             = {{0xA45C254E, 0xDF1C, 0x4EFD, {0x80, 0x20, 0x67, 0xD1, 0x46, 0xA8, 0x50, 0xE0}}, 14};
+static const PROPERTYKEY MA_PKEY_AudioEngine_DeviceFormat        = {{0xF19F064D, 0x82C,  0x4E27, {0xBC, 0x73, 0x68, 0x82, 0xA1, 0xBB, 0x8E, 0x4C}},  0};
+
+static const IID MA_IID_IUnknown                                 = {0x00000000, 0x0000, 0x0000, {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}; /* 00000000-0000-0000-C000-000000000046 */
+#if !defined(MA_WIN32_DESKTOP) && !defined(MA_WIN32_GDK)
+static const IID MA_IID_IAgileObject                             = {0x94EA2B94, 0xE9CC, 0x49E0, {0xC0, 0xFF, 0xEE, 0x64, 0xCA, 0x8F, 0x5B, 0x90}}; /* 94EA2B94-E9CC-49E0-C0FF-EE64CA8F5B90 */
+#endif
+
+static const IID MA_IID_IAudioClient                             = {0x1CB9AD4C, 0xDBFA, 0x4C32, {0xB1, 0x78, 0xC2, 0xF5, 0x68, 0xA7, 0x03, 0xB2}}; /* 1CB9AD4C-DBFA-4C32-B178-C2F568A703B2 = __uuidof(IAudioClient) */
+static const IID MA_IID_IAudioClient2                            = {0x726778CD, 0xF60A, 0x4EDA, {0x82, 0xDE, 0xE4, 0x76, 0x10, 0xCD, 0x78, 0xAA}}; /* 726778CD-F60A-4EDA-82DE-E47610CD78AA = __uuidof(IAudioClient2) */
+static const IID MA_IID_IAudioClient3                            = {0x7ED4EE07, 0x8E67, 0x4CD4, {0x8C, 0x1A, 0x2B, 0x7A, 0x59, 0x87, 0xAD, 0x42}}; /* 7ED4EE07-8E67-4CD4-8C1A-2B7A5987AD42 = __uuidof(IAudioClient3) */
+static const IID MA_IID_IAudioRenderClient                       = {0xF294ACFC, 0x3146, 0x4483, {0xA7, 0xBF, 0xAD, 0xDC, 0xA7, 0xC2, 0x60, 0xE2}}; /* F294ACFC-3146-4483-A7BF-ADDCA7C260E2 = __uuidof(IAudioRenderClient) */
+static const IID MA_IID_IAudioCaptureClient                      = {0xC8ADBD64, 0xE71E, 0x48A0, {0xA4, 0xDE, 0x18, 0x5C, 0x39, 0x5C, 0xD3, 0x17}}; /* C8ADBD64-E71E-48A0-A4DE-185C395CD317 = __uuidof(IAudioCaptureClient) */
+static const IID MA_IID_IMMNotificationClient                    = {0x7991EEC9, 0x7E89, 0x4D85, {0x83, 0x90, 0x6C, 0x70, 0x3C, 0xEC, 0x60, 0xC0}}; /* 7991EEC9-7E89-4D85-8390-6C703CEC60C0 = __uuidof(IMMNotificationClient) */
+#if !defined(MA_WIN32_DESKTOP) && !defined(MA_WIN32_GDK)
+static const IID MA_IID_DEVINTERFACE_AUDIO_RENDER                = {0xE6327CAD, 0xDCEC, 0x4949, {0xAE, 0x8A, 0x99, 0x1E, 0x97, 0x6A, 0x79, 0xD2}}; /* E6327CAD-DCEC-4949-AE8A-991E976A79D2 */
+static const IID MA_IID_DEVINTERFACE_AUDIO_CAPTURE               = {0x2EEF81BE, 0x33FA, 0x4800, {0x96, 0x70, 0x1C, 0xD4, 0x74, 0x97, 0x2C, 0x3F}}; /* 2EEF81BE-33FA-4800-9670-1CD474972C3F */
+static const IID MA_IID_IActivateAudioInterfaceCompletionHandler = {0x41D949AB, 0x9862, 0x444A, {0x80, 0xF6, 0xC2, 0x61, 0x33, 0x4D, 0xA5, 0xEB}}; /* 41D949AB-9862-444A-80F6-C261334DA5EB */
+#endif
+
+static const IID MA_CLSID_MMDeviceEnumerator                     = {0xBCDE0395, 0xE52F, 0x467C, {0x8E, 0x3D, 0xC4, 0x57, 0x92, 0x91, 0x69, 0x2E}}; /* BCDE0395-E52F-467C-8E3D-C4579291692E = __uuidof(MMDeviceEnumerator) */
+static const IID MA_IID_IMMDeviceEnumerator                      = {0xA95664D2, 0x9614, 0x4F35, {0xA7, 0x46, 0xDE, 0x8D, 0xB6, 0x36, 0x17, 0xE6}}; /* A95664D2-9614-4F35-A746-DE8DB63617E6 = __uuidof(IMMDeviceEnumerator) */
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+#define MA_MM_DEVICE_STATE_ACTIVE                          1
+#define MA_MM_DEVICE_STATE_DISABLED                        2
+#define MA_MM_DEVICE_STATE_NOTPRESENT                      4
+#define MA_MM_DEVICE_STATE_UNPLUGGED                       8
+
+typedef struct ma_IMMDeviceEnumerator                      ma_IMMDeviceEnumerator;
+typedef struct ma_IMMDeviceCollection                      ma_IMMDeviceCollection;
+typedef struct ma_IMMDevice                                ma_IMMDevice;
+#else
+typedef struct ma_IActivateAudioInterfaceCompletionHandler ma_IActivateAudioInterfaceCompletionHandler;
+typedef struct ma_IActivateAudioInterfaceAsyncOperation    ma_IActivateAudioInterfaceAsyncOperation;
+#endif
+typedef struct ma_IPropertyStore                           ma_IPropertyStore;
+typedef struct ma_IAudioClient                             ma_IAudioClient;
+typedef struct ma_IAudioClient2                            ma_IAudioClient2;
+typedef struct ma_IAudioClient3                            ma_IAudioClient3;
+typedef struct ma_IAudioRenderClient                       ma_IAudioRenderClient;
+typedef struct ma_IAudioCaptureClient                      ma_IAudioCaptureClient;
+
+typedef ma_int64                                           MA_REFERENCE_TIME;
+
+#define MA_AUDCLNT_STREAMFLAGS_CROSSPROCESS                0x00010000
+#define MA_AUDCLNT_STREAMFLAGS_LOOPBACK                    0x00020000
+#define MA_AUDCLNT_STREAMFLAGS_EVENTCALLBACK               0x00040000
+#define MA_AUDCLNT_STREAMFLAGS_NOPERSIST                   0x00080000
+#define MA_AUDCLNT_STREAMFLAGS_RATEADJUST                  0x00100000
+#define MA_AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY         0x08000000
+#define MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM              0x80000000
+#define MA_AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED          0x10000000
+#define MA_AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE               0x20000000
+#define MA_AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED    0x40000000
+
+/* Buffer flags. */
+#define MA_AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY          1
+#define MA_AUDCLNT_BUFFERFLAGS_SILENT                      2
+#define MA_AUDCLNT_BUFFERFLAGS_TIMESTAMP_ERROR             4
+
+typedef enum
+{
+    ma_eRender  = 0,
+    ma_eCapture = 1,
+    ma_eAll     = 2
+} ma_EDataFlow;
+
+typedef enum
+{
+    ma_eConsole        = 0,
+    ma_eMultimedia     = 1,
+    ma_eCommunications = 2
+} ma_ERole;
+
+typedef enum
+{
+    MA_AUDCLNT_SHAREMODE_SHARED,
+    MA_AUDCLNT_SHAREMODE_EXCLUSIVE
+} MA_AUDCLNT_SHAREMODE;
+
+typedef enum
+{
+    MA_AudioCategory_Other = 0  /* <-- miniaudio is only caring about Other. */
+} MA_AUDIO_STREAM_CATEGORY;
+
+typedef enum
+{
+    MA_AUDCLNT_STREAMOPTIONS_NONE,
+    MA_AUDCLNT_STREAMOPTIONS_RAW,
+    MA_AUDCLNT_STREAMOPTIONS_MATCH_FORMAT,
+    MA_AUDCLNT_STREAMOPTIONS_AMBISONICS,
+    MA_AUDCLNT_STREAMOPTIONS_POST_VOLUME_LOOPBACK
+} MA_AUDCLNT_STREAMOPTIONS;
+
+typedef struct
+{
+    ma_uint32 cbSize;
+    BOOL bIsOffload;
+    MA_AUDIO_STREAM_CATEGORY eCategory;
+    MA_AUDCLNT_STREAMOPTIONS Options;
+} ma_AudioClientProperties;
+
+/* IUnknown */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IUnknown* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IUnknown* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IUnknown* pThis);
+} ma_IUnknownVtbl;
+struct ma_IUnknown
+{
+    ma_IUnknownVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IUnknown_QueryInterface(ma_IUnknown* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IUnknown_AddRef(ma_IUnknown* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IUnknown_Release(ma_IUnknown* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    /* IMMNotificationClient */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IMMNotificationClient* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IMMNotificationClient* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IMMNotificationClient* pThis);
+
+        /* IMMNotificationClient */
+        HRESULT (STDMETHODCALLTYPE * OnDeviceStateChanged)  (ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID, DWORD dwNewState);
+        HRESULT (STDMETHODCALLTYPE * OnDeviceAdded)         (ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID);
+        HRESULT (STDMETHODCALLTYPE * OnDeviceRemoved)       (ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID);
+        HRESULT (STDMETHODCALLTYPE * OnDefaultDeviceChanged)(ma_IMMNotificationClient* pThis, ma_EDataFlow dataFlow, ma_ERole role, const WCHAR* pDefaultDeviceID);
+        HRESULT (STDMETHODCALLTYPE * OnPropertyValueChanged)(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID, const PROPERTYKEY key);
+    } ma_IMMNotificationClientVtbl;
+
+    /* IMMDeviceEnumerator */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IMMDeviceEnumerator* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IMMDeviceEnumerator* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IMMDeviceEnumerator* pThis);
+
+        /* IMMDeviceEnumerator */
+        HRESULT (STDMETHODCALLTYPE * EnumAudioEndpoints)                    (ma_IMMDeviceEnumerator* pThis, ma_EDataFlow dataFlow, DWORD dwStateMask, ma_IMMDeviceCollection** ppDevices);
+        HRESULT (STDMETHODCALLTYPE * GetDefaultAudioEndpoint)               (ma_IMMDeviceEnumerator* pThis, ma_EDataFlow dataFlow, ma_ERole role, ma_IMMDevice** ppEndpoint);
+        HRESULT (STDMETHODCALLTYPE * GetDevice)                             (ma_IMMDeviceEnumerator* pThis, const WCHAR* pID, ma_IMMDevice** ppDevice);
+        HRESULT (STDMETHODCALLTYPE * RegisterEndpointNotificationCallback)  (ma_IMMDeviceEnumerator* pThis, ma_IMMNotificationClient* pClient);
+        HRESULT (STDMETHODCALLTYPE * UnregisterEndpointNotificationCallback)(ma_IMMDeviceEnumerator* pThis, ma_IMMNotificationClient* pClient);
+    } ma_IMMDeviceEnumeratorVtbl;
+    struct ma_IMMDeviceEnumerator
+    {
+        ma_IMMDeviceEnumeratorVtbl* lpVtbl;
+    };
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_QueryInterface(ma_IMMDeviceEnumerator* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+    static MA_INLINE ULONG   ma_IMMDeviceEnumerator_AddRef(ma_IMMDeviceEnumerator* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+    static MA_INLINE ULONG   ma_IMMDeviceEnumerator_Release(ma_IMMDeviceEnumerator* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_EnumAudioEndpoints(ma_IMMDeviceEnumerator* pThis, ma_EDataFlow dataFlow, DWORD dwStateMask, ma_IMMDeviceCollection** ppDevices) { return pThis->lpVtbl->EnumAudioEndpoints(pThis, dataFlow, dwStateMask, ppDevices); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_GetDefaultAudioEndpoint(ma_IMMDeviceEnumerator* pThis, ma_EDataFlow dataFlow, ma_ERole role, ma_IMMDevice** ppEndpoint) { return pThis->lpVtbl->GetDefaultAudioEndpoint(pThis, dataFlow, role, ppEndpoint); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_GetDevice(ma_IMMDeviceEnumerator* pThis, const WCHAR* pID, ma_IMMDevice** ppDevice) { return pThis->lpVtbl->GetDevice(pThis, pID, ppDevice); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_RegisterEndpointNotificationCallback(ma_IMMDeviceEnumerator* pThis, ma_IMMNotificationClient* pClient) { return pThis->lpVtbl->RegisterEndpointNotificationCallback(pThis, pClient); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_UnregisterEndpointNotificationCallback(ma_IMMDeviceEnumerator* pThis, ma_IMMNotificationClient* pClient) { return pThis->lpVtbl->UnregisterEndpointNotificationCallback(pThis, pClient); }
+
+
+    /* IMMDeviceCollection */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IMMDeviceCollection* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IMMDeviceCollection* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IMMDeviceCollection* pThis);
+
+        /* IMMDeviceCollection */
+        HRESULT (STDMETHODCALLTYPE * GetCount)(ma_IMMDeviceCollection* pThis, UINT* pDevices);
+        HRESULT (STDMETHODCALLTYPE * Item)    (ma_IMMDeviceCollection* pThis, UINT nDevice, ma_IMMDevice** ppDevice);
+    } ma_IMMDeviceCollectionVtbl;
+    struct ma_IMMDeviceCollection
+    {
+        ma_IMMDeviceCollectionVtbl* lpVtbl;
+    };
+    static MA_INLINE HRESULT ma_IMMDeviceCollection_QueryInterface(ma_IMMDeviceCollection* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+    static MA_INLINE ULONG   ma_IMMDeviceCollection_AddRef(ma_IMMDeviceCollection* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+    static MA_INLINE ULONG   ma_IMMDeviceCollection_Release(ma_IMMDeviceCollection* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+    static MA_INLINE HRESULT ma_IMMDeviceCollection_GetCount(ma_IMMDeviceCollection* pThis, UINT* pDevices)                               { return pThis->lpVtbl->GetCount(pThis, pDevices); }
+    static MA_INLINE HRESULT ma_IMMDeviceCollection_Item(ma_IMMDeviceCollection* pThis, UINT nDevice, ma_IMMDevice** ppDevice)            { return pThis->lpVtbl->Item(pThis, nDevice, ppDevice); }
+
+
+    /* IMMDevice */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IMMDevice* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IMMDevice* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IMMDevice* pThis);
+
+        /* IMMDevice */
+        HRESULT (STDMETHODCALLTYPE * Activate)         (ma_IMMDevice* pThis, const IID* const iid, DWORD dwClsCtx, MA_PROPVARIANT* pActivationParams, void** ppInterface);
+        HRESULT (STDMETHODCALLTYPE * OpenPropertyStore)(ma_IMMDevice* pThis, DWORD stgmAccess, ma_IPropertyStore** ppProperties);
+        HRESULT (STDMETHODCALLTYPE * GetId)            (ma_IMMDevice* pThis, WCHAR** pID);
+        HRESULT (STDMETHODCALLTYPE * GetState)         (ma_IMMDevice* pThis, DWORD *pState);
+    } ma_IMMDeviceVtbl;
+    struct ma_IMMDevice
+    {
+        ma_IMMDeviceVtbl* lpVtbl;
+    };
+    static MA_INLINE HRESULT ma_IMMDevice_QueryInterface(ma_IMMDevice* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+    static MA_INLINE ULONG   ma_IMMDevice_AddRef(ma_IMMDevice* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+    static MA_INLINE ULONG   ma_IMMDevice_Release(ma_IMMDevice* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+    static MA_INLINE HRESULT ma_IMMDevice_Activate(ma_IMMDevice* pThis, const IID* const iid, DWORD dwClsCtx, MA_PROPVARIANT* pActivationParams, void** ppInterface) { return pThis->lpVtbl->Activate(pThis, iid, dwClsCtx, pActivationParams, ppInterface); }
+    static MA_INLINE HRESULT ma_IMMDevice_OpenPropertyStore(ma_IMMDevice* pThis, DWORD stgmAccess, ma_IPropertyStore** ppProperties) { return pThis->lpVtbl->OpenPropertyStore(pThis, stgmAccess, ppProperties); }
+    static MA_INLINE HRESULT ma_IMMDevice_GetId(ma_IMMDevice* pThis, WCHAR** pID)                                     { return pThis->lpVtbl->GetId(pThis, pID); }
+    static MA_INLINE HRESULT ma_IMMDevice_GetState(ma_IMMDevice* pThis, DWORD *pState)                                { return pThis->lpVtbl->GetState(pThis, pState); }
+#else
+    /* IActivateAudioInterfaceAsyncOperation */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IActivateAudioInterfaceAsyncOperation* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IActivateAudioInterfaceAsyncOperation* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IActivateAudioInterfaceAsyncOperation* pThis);
+
+        /* IActivateAudioInterfaceAsyncOperation */
+        HRESULT (STDMETHODCALLTYPE * GetActivateResult)(ma_IActivateAudioInterfaceAsyncOperation* pThis, HRESULT *pActivateResult, ma_IUnknown** ppActivatedInterface);
+    } ma_IActivateAudioInterfaceAsyncOperationVtbl;
+    struct ma_IActivateAudioInterfaceAsyncOperation
+    {
+        ma_IActivateAudioInterfaceAsyncOperationVtbl* lpVtbl;
+    };
+    static MA_INLINE HRESULT ma_IActivateAudioInterfaceAsyncOperation_QueryInterface(ma_IActivateAudioInterfaceAsyncOperation* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+    static MA_INLINE ULONG   ma_IActivateAudioInterfaceAsyncOperation_AddRef(ma_IActivateAudioInterfaceAsyncOperation* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+    static MA_INLINE ULONG   ma_IActivateAudioInterfaceAsyncOperation_Release(ma_IActivateAudioInterfaceAsyncOperation* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+    static MA_INLINE HRESULT ma_IActivateAudioInterfaceAsyncOperation_GetActivateResult(ma_IActivateAudioInterfaceAsyncOperation* pThis, HRESULT *pActivateResult, ma_IUnknown** ppActivatedInterface) { return pThis->lpVtbl->GetActivateResult(pThis, pActivateResult, ppActivatedInterface); }
+#endif
+
+/* IPropertyStore */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IPropertyStore* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IPropertyStore* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IPropertyStore* pThis);
+
+    /* IPropertyStore */
+    HRESULT (STDMETHODCALLTYPE * GetCount)(ma_IPropertyStore* pThis, DWORD* pPropCount);
+    HRESULT (STDMETHODCALLTYPE * GetAt)   (ma_IPropertyStore* pThis, DWORD propIndex, PROPERTYKEY* pPropKey);
+    HRESULT (STDMETHODCALLTYPE * GetValue)(ma_IPropertyStore* pThis, const PROPERTYKEY* const pKey, MA_PROPVARIANT* pPropVar);
+    HRESULT (STDMETHODCALLTYPE * SetValue)(ma_IPropertyStore* pThis, const PROPERTYKEY* const pKey, const MA_PROPVARIANT* const pPropVar);
+    HRESULT (STDMETHODCALLTYPE * Commit)  (ma_IPropertyStore* pThis);
+} ma_IPropertyStoreVtbl;
+struct ma_IPropertyStore
+{
+    ma_IPropertyStoreVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IPropertyStore_QueryInterface(ma_IPropertyStore* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IPropertyStore_AddRef(ma_IPropertyStore* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IPropertyStore_Release(ma_IPropertyStore* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IPropertyStore_GetCount(ma_IPropertyStore* pThis, DWORD* pPropCount)                            { return pThis->lpVtbl->GetCount(pThis, pPropCount); }
+static MA_INLINE HRESULT ma_IPropertyStore_GetAt(ma_IPropertyStore* pThis, DWORD propIndex, PROPERTYKEY* pPropKey)          { return pThis->lpVtbl->GetAt(pThis, propIndex, pPropKey); }
+static MA_INLINE HRESULT ma_IPropertyStore_GetValue(ma_IPropertyStore* pThis, const PROPERTYKEY* const pKey, MA_PROPVARIANT* pPropVar) { return pThis->lpVtbl->GetValue(pThis, pKey, pPropVar); }
+static MA_INLINE HRESULT ma_IPropertyStore_SetValue(ma_IPropertyStore* pThis, const PROPERTYKEY* const pKey, const MA_PROPVARIANT* const pPropVar) { return pThis->lpVtbl->SetValue(pThis, pKey, pPropVar); }
+static MA_INLINE HRESULT ma_IPropertyStore_Commit(ma_IPropertyStore* pThis)                                                 { return pThis->lpVtbl->Commit(pThis); }
+
+
+/* IAudioClient */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioClient* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioClient* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioClient* pThis);
+
+    /* IAudioClient */
+    HRESULT (STDMETHODCALLTYPE * Initialize)       (ma_IAudioClient* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSize)    (ma_IAudioClient* pThis, ma_uint32* pNumBufferFrames);
+    HRESULT (STDMETHODCALLTYPE * GetStreamLatency) (ma_IAudioClient* pThis, MA_REFERENCE_TIME* pLatency);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPadding)(ma_IAudioClient* pThis, ma_uint32* pNumPaddingFrames);
+    HRESULT (STDMETHODCALLTYPE * IsFormatSupported)(ma_IAudioClient* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch);
+    HRESULT (STDMETHODCALLTYPE * GetMixFormat)     (ma_IAudioClient* pThis, MA_WAVEFORMATEX** ppDeviceFormat);
+    HRESULT (STDMETHODCALLTYPE * GetDevicePeriod)  (ma_IAudioClient* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod);
+    HRESULT (STDMETHODCALLTYPE * Start)            (ma_IAudioClient* pThis);
+    HRESULT (STDMETHODCALLTYPE * Stop)             (ma_IAudioClient* pThis);
+    HRESULT (STDMETHODCALLTYPE * Reset)            (ma_IAudioClient* pThis);
+    HRESULT (STDMETHODCALLTYPE * SetEventHandle)   (ma_IAudioClient* pThis, HANDLE eventHandle);
+    HRESULT (STDMETHODCALLTYPE * GetService)       (ma_IAudioClient* pThis, const IID* const riid, void** pp);
+} ma_IAudioClientVtbl;
+struct ma_IAudioClient
+{
+    ma_IAudioClientVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioClient_QueryInterface(ma_IAudioClient* pThis, const IID* const riid, void** ppObject)    { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioClient_AddRef(ma_IAudioClient* pThis)                                                    { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioClient_Release(ma_IAudioClient* pThis)                                                   { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient_Initialize(ma_IAudioClient* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid) { return pThis->lpVtbl->Initialize(pThis, shareMode, streamFlags, bufferDuration, periodicity, pFormat, pAudioSessionGuid); }
+static MA_INLINE HRESULT ma_IAudioClient_GetBufferSize(ma_IAudioClient* pThis, ma_uint32* pNumBufferFrames)                { return pThis->lpVtbl->GetBufferSize(pThis, pNumBufferFrames); }
+static MA_INLINE HRESULT ma_IAudioClient_GetStreamLatency(ma_IAudioClient* pThis, MA_REFERENCE_TIME* pLatency)             { return pThis->lpVtbl->GetStreamLatency(pThis, pLatency); }
+static MA_INLINE HRESULT ma_IAudioClient_GetCurrentPadding(ma_IAudioClient* pThis, ma_uint32* pNumPaddingFrames)           { return pThis->lpVtbl->GetCurrentPadding(pThis, pNumPaddingFrames); }
+static MA_INLINE HRESULT ma_IAudioClient_IsFormatSupported(ma_IAudioClient* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch) { return pThis->lpVtbl->IsFormatSupported(pThis, shareMode, pFormat, ppClosestMatch); }
+static MA_INLINE HRESULT ma_IAudioClient_GetMixFormat(ma_IAudioClient* pThis, MA_WAVEFORMATEX** ppDeviceFormat)            { return pThis->lpVtbl->GetMixFormat(pThis, ppDeviceFormat); }
+static MA_INLINE HRESULT ma_IAudioClient_GetDevicePeriod(ma_IAudioClient* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod) { return pThis->lpVtbl->GetDevicePeriod(pThis, pDefaultDevicePeriod, pMinimumDevicePeriod); }
+static MA_INLINE HRESULT ma_IAudioClient_Start(ma_IAudioClient* pThis)                                                     { return pThis->lpVtbl->Start(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient_Stop(ma_IAudioClient* pThis)                                                      { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient_Reset(ma_IAudioClient* pThis)                                                     { return pThis->lpVtbl->Reset(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient_SetEventHandle(ma_IAudioClient* pThis, HANDLE eventHandle)                        { return pThis->lpVtbl->SetEventHandle(pThis, eventHandle); }
+static MA_INLINE HRESULT ma_IAudioClient_GetService(ma_IAudioClient* pThis, const IID* const riid, void** pp)              { return pThis->lpVtbl->GetService(pThis, riid, pp); }
+
+/* IAudioClient2 */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioClient2* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioClient2* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioClient2* pThis);
+
+    /* IAudioClient */
+    HRESULT (STDMETHODCALLTYPE * Initialize)       (ma_IAudioClient2* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSize)    (ma_IAudioClient2* pThis, ma_uint32* pNumBufferFrames);
+    HRESULT (STDMETHODCALLTYPE * GetStreamLatency) (ma_IAudioClient2* pThis, MA_REFERENCE_TIME* pLatency);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPadding)(ma_IAudioClient2* pThis, ma_uint32* pNumPaddingFrames);
+    HRESULT (STDMETHODCALLTYPE * IsFormatSupported)(ma_IAudioClient2* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch);
+    HRESULT (STDMETHODCALLTYPE * GetMixFormat)     (ma_IAudioClient2* pThis, MA_WAVEFORMATEX** ppDeviceFormat);
+    HRESULT (STDMETHODCALLTYPE * GetDevicePeriod)  (ma_IAudioClient2* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod);
+    HRESULT (STDMETHODCALLTYPE * Start)            (ma_IAudioClient2* pThis);
+    HRESULT (STDMETHODCALLTYPE * Stop)             (ma_IAudioClient2* pThis);
+    HRESULT (STDMETHODCALLTYPE * Reset)            (ma_IAudioClient2* pThis);
+    HRESULT (STDMETHODCALLTYPE * SetEventHandle)   (ma_IAudioClient2* pThis, HANDLE eventHandle);
+    HRESULT (STDMETHODCALLTYPE * GetService)       (ma_IAudioClient2* pThis, const IID* const riid, void** pp);
+
+    /* IAudioClient2 */
+    HRESULT (STDMETHODCALLTYPE * IsOffloadCapable)   (ma_IAudioClient2* pThis, MA_AUDIO_STREAM_CATEGORY category, BOOL* pOffloadCapable);
+    HRESULT (STDMETHODCALLTYPE * SetClientProperties)(ma_IAudioClient2* pThis, const ma_AudioClientProperties* pProperties);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSizeLimits)(ma_IAudioClient2* pThis, const MA_WAVEFORMATEX* pFormat, BOOL eventDriven, MA_REFERENCE_TIME* pMinBufferDuration, MA_REFERENCE_TIME* pMaxBufferDuration);
+} ma_IAudioClient2Vtbl;
+struct ma_IAudioClient2
+{
+    ma_IAudioClient2Vtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioClient2_QueryInterface(ma_IAudioClient2* pThis, const IID* const riid, void** ppObject)    { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioClient2_AddRef(ma_IAudioClient2* pThis)                                                    { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioClient2_Release(ma_IAudioClient2* pThis)                                                   { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient2_Initialize(ma_IAudioClient2* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid) { return pThis->lpVtbl->Initialize(pThis, shareMode, streamFlags, bufferDuration, periodicity, pFormat, pAudioSessionGuid); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetBufferSize(ma_IAudioClient2* pThis, ma_uint32* pNumBufferFrames)                { return pThis->lpVtbl->GetBufferSize(pThis, pNumBufferFrames); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetStreamLatency(ma_IAudioClient2* pThis, MA_REFERENCE_TIME* pLatency)             { return pThis->lpVtbl->GetStreamLatency(pThis, pLatency); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetCurrentPadding(ma_IAudioClient2* pThis, ma_uint32* pNumPaddingFrames)           { return pThis->lpVtbl->GetCurrentPadding(pThis, pNumPaddingFrames); }
+static MA_INLINE HRESULT ma_IAudioClient2_IsFormatSupported(ma_IAudioClient2* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch) { return pThis->lpVtbl->IsFormatSupported(pThis, shareMode, pFormat, ppClosestMatch); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetMixFormat(ma_IAudioClient2* pThis, MA_WAVEFORMATEX** ppDeviceFormat)            { return pThis->lpVtbl->GetMixFormat(pThis, ppDeviceFormat); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetDevicePeriod(ma_IAudioClient2* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod) { return pThis->lpVtbl->GetDevicePeriod(pThis, pDefaultDevicePeriod, pMinimumDevicePeriod); }
+static MA_INLINE HRESULT ma_IAudioClient2_Start(ma_IAudioClient2* pThis)                                                     { return pThis->lpVtbl->Start(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient2_Stop(ma_IAudioClient2* pThis)                                                      { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient2_Reset(ma_IAudioClient2* pThis)                                                     { return pThis->lpVtbl->Reset(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient2_SetEventHandle(ma_IAudioClient2* pThis, HANDLE eventHandle)                        { return pThis->lpVtbl->SetEventHandle(pThis, eventHandle); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetService(ma_IAudioClient2* pThis, const IID* const riid, void** pp)              { return pThis->lpVtbl->GetService(pThis, riid, pp); }
+static MA_INLINE HRESULT ma_IAudioClient2_IsOffloadCapable(ma_IAudioClient2* pThis, MA_AUDIO_STREAM_CATEGORY category, BOOL* pOffloadCapable) { return pThis->lpVtbl->IsOffloadCapable(pThis, category, pOffloadCapable); }
+static MA_INLINE HRESULT ma_IAudioClient2_SetClientProperties(ma_IAudioClient2* pThis, const ma_AudioClientProperties* pProperties)           { return pThis->lpVtbl->SetClientProperties(pThis, pProperties); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetBufferSizeLimits(ma_IAudioClient2* pThis, const MA_WAVEFORMATEX* pFormat, BOOL eventDriven, MA_REFERENCE_TIME* pMinBufferDuration, MA_REFERENCE_TIME* pMaxBufferDuration) { return pThis->lpVtbl->GetBufferSizeLimits(pThis, pFormat, eventDriven, pMinBufferDuration, pMaxBufferDuration); }
+
+
+/* IAudioClient3 */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioClient3* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioClient3* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioClient3* pThis);
+
+    /* IAudioClient */
+    HRESULT (STDMETHODCALLTYPE * Initialize)       (ma_IAudioClient3* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSize)    (ma_IAudioClient3* pThis, ma_uint32* pNumBufferFrames);
+    HRESULT (STDMETHODCALLTYPE * GetStreamLatency) (ma_IAudioClient3* pThis, MA_REFERENCE_TIME* pLatency);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPadding)(ma_IAudioClient3* pThis, ma_uint32* pNumPaddingFrames);
+    HRESULT (STDMETHODCALLTYPE * IsFormatSupported)(ma_IAudioClient3* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch);
+    HRESULT (STDMETHODCALLTYPE * GetMixFormat)     (ma_IAudioClient3* pThis, MA_WAVEFORMATEX** ppDeviceFormat);
+    HRESULT (STDMETHODCALLTYPE * GetDevicePeriod)  (ma_IAudioClient3* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod);
+    HRESULT (STDMETHODCALLTYPE * Start)            (ma_IAudioClient3* pThis);
+    HRESULT (STDMETHODCALLTYPE * Stop)             (ma_IAudioClient3* pThis);
+    HRESULT (STDMETHODCALLTYPE * Reset)            (ma_IAudioClient3* pThis);
+    HRESULT (STDMETHODCALLTYPE * SetEventHandle)   (ma_IAudioClient3* pThis, HANDLE eventHandle);
+    HRESULT (STDMETHODCALLTYPE * GetService)       (ma_IAudioClient3* pThis, const IID* const riid, void** pp);
+
+    /* IAudioClient2 */
+    HRESULT (STDMETHODCALLTYPE * IsOffloadCapable)   (ma_IAudioClient3* pThis, MA_AUDIO_STREAM_CATEGORY category, BOOL* pOffloadCapable);
+    HRESULT (STDMETHODCALLTYPE * SetClientProperties)(ma_IAudioClient3* pThis, const ma_AudioClientProperties* pProperties);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSizeLimits)(ma_IAudioClient3* pThis, const MA_WAVEFORMATEX* pFormat, BOOL eventDriven, MA_REFERENCE_TIME* pMinBufferDuration, MA_REFERENCE_TIME* pMaxBufferDuration);
+
+    /* IAudioClient3 */
+    HRESULT (STDMETHODCALLTYPE * GetSharedModeEnginePeriod)       (ma_IAudioClient3* pThis, const MA_WAVEFORMATEX* pFormat, ma_uint32* pDefaultPeriodInFrames, ma_uint32* pFundamentalPeriodInFrames, ma_uint32* pMinPeriodInFrames, ma_uint32* pMaxPeriodInFrames);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentSharedModeEnginePeriod)(ma_IAudioClient3* pThis, MA_WAVEFORMATEX** ppFormat, ma_uint32* pCurrentPeriodInFrames);
+    HRESULT (STDMETHODCALLTYPE * InitializeSharedAudioStream)     (ma_IAudioClient3* pThis, DWORD streamFlags, ma_uint32 periodInFrames, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid);
+} ma_IAudioClient3Vtbl;
+struct ma_IAudioClient3
+{
+    ma_IAudioClient3Vtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioClient3_QueryInterface(ma_IAudioClient3* pThis, const IID* const riid, void** ppObject)    { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioClient3_AddRef(ma_IAudioClient3* pThis)                                                    { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioClient3_Release(ma_IAudioClient3* pThis)                                                   { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient3_Initialize(ma_IAudioClient3* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid) { return pThis->lpVtbl->Initialize(pThis, shareMode, streamFlags, bufferDuration, periodicity, pFormat, pAudioSessionGuid); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetBufferSize(ma_IAudioClient3* pThis, ma_uint32* pNumBufferFrames)                { return pThis->lpVtbl->GetBufferSize(pThis, pNumBufferFrames); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetStreamLatency(ma_IAudioClient3* pThis, MA_REFERENCE_TIME* pLatency)             { return pThis->lpVtbl->GetStreamLatency(pThis, pLatency); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetCurrentPadding(ma_IAudioClient3* pThis, ma_uint32* pNumPaddingFrames)           { return pThis->lpVtbl->GetCurrentPadding(pThis, pNumPaddingFrames); }
+static MA_INLINE HRESULT ma_IAudioClient3_IsFormatSupported(ma_IAudioClient3* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch) { return pThis->lpVtbl->IsFormatSupported(pThis, shareMode, pFormat, ppClosestMatch); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetMixFormat(ma_IAudioClient3* pThis, MA_WAVEFORMATEX** ppDeviceFormat)               { return pThis->lpVtbl->GetMixFormat(pThis, ppDeviceFormat); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetDevicePeriod(ma_IAudioClient3* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod) { return pThis->lpVtbl->GetDevicePeriod(pThis, pDefaultDevicePeriod, pMinimumDevicePeriod); }
+static MA_INLINE HRESULT ma_IAudioClient3_Start(ma_IAudioClient3* pThis)                                                     { return pThis->lpVtbl->Start(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient3_Stop(ma_IAudioClient3* pThis)                                                      { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient3_Reset(ma_IAudioClient3* pThis)                                                     { return pThis->lpVtbl->Reset(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient3_SetEventHandle(ma_IAudioClient3* pThis, HANDLE eventHandle)                        { return pThis->lpVtbl->SetEventHandle(pThis, eventHandle); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetService(ma_IAudioClient3* pThis, const IID* const riid, void** pp)              { return pThis->lpVtbl->GetService(pThis, riid, pp); }
+static MA_INLINE HRESULT ma_IAudioClient3_IsOffloadCapable(ma_IAudioClient3* pThis, MA_AUDIO_STREAM_CATEGORY category, BOOL* pOffloadCapable) { return pThis->lpVtbl->IsOffloadCapable(pThis, category, pOffloadCapable); }
+static MA_INLINE HRESULT ma_IAudioClient3_SetClientProperties(ma_IAudioClient3* pThis, const ma_AudioClientProperties* pProperties)           { return pThis->lpVtbl->SetClientProperties(pThis, pProperties); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetBufferSizeLimits(ma_IAudioClient3* pThis, const MA_WAVEFORMATEX* pFormat, BOOL eventDriven, MA_REFERENCE_TIME* pMinBufferDuration, MA_REFERENCE_TIME* pMaxBufferDuration) { return pThis->lpVtbl->GetBufferSizeLimits(pThis, pFormat, eventDriven, pMinBufferDuration, pMaxBufferDuration); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetSharedModeEnginePeriod(ma_IAudioClient3* pThis, const MA_WAVEFORMATEX* pFormat, ma_uint32* pDefaultPeriodInFrames, ma_uint32* pFundamentalPeriodInFrames, ma_uint32* pMinPeriodInFrames, ma_uint32* pMaxPeriodInFrames) { return pThis->lpVtbl->GetSharedModeEnginePeriod(pThis, pFormat, pDefaultPeriodInFrames, pFundamentalPeriodInFrames, pMinPeriodInFrames, pMaxPeriodInFrames); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetCurrentSharedModeEnginePeriod(ma_IAudioClient3* pThis, MA_WAVEFORMATEX** ppFormat, ma_uint32* pCurrentPeriodInFrames) { return pThis->lpVtbl->GetCurrentSharedModeEnginePeriod(pThis, ppFormat, pCurrentPeriodInFrames); }
+static MA_INLINE HRESULT ma_IAudioClient3_InitializeSharedAudioStream(ma_IAudioClient3* pThis, DWORD streamFlags, ma_uint32 periodInFrames, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGUID) { return pThis->lpVtbl->InitializeSharedAudioStream(pThis, streamFlags, periodInFrames, pFormat, pAudioSessionGUID); }
+
+
+/* IAudioRenderClient */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioRenderClient* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioRenderClient* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioRenderClient* pThis);
+
+    /* IAudioRenderClient */
+    HRESULT (STDMETHODCALLTYPE * GetBuffer)    (ma_IAudioRenderClient* pThis, ma_uint32 numFramesRequested, BYTE** ppData);
+    HRESULT (STDMETHODCALLTYPE * ReleaseBuffer)(ma_IAudioRenderClient* pThis, ma_uint32 numFramesWritten, DWORD dwFlags);
+} ma_IAudioRenderClientVtbl;
+struct ma_IAudioRenderClient
+{
+    ma_IAudioRenderClientVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioRenderClient_QueryInterface(ma_IAudioRenderClient* pThis, const IID* const riid, void** ppObject)   { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioRenderClient_AddRef(ma_IAudioRenderClient* pThis)                                                   { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioRenderClient_Release(ma_IAudioRenderClient* pThis)                                                  { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioRenderClient_GetBuffer(ma_IAudioRenderClient* pThis, ma_uint32 numFramesRequested, BYTE** ppData)   { return pThis->lpVtbl->GetBuffer(pThis, numFramesRequested, ppData); }
+static MA_INLINE HRESULT ma_IAudioRenderClient_ReleaseBuffer(ma_IAudioRenderClient* pThis, ma_uint32 numFramesWritten, DWORD dwFlags) { return pThis->lpVtbl->ReleaseBuffer(pThis, numFramesWritten, dwFlags); }
+
+
+/* IAudioCaptureClient */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioCaptureClient* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioCaptureClient* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioCaptureClient* pThis);
+
+    /* IAudioRenderClient */
+    HRESULT (STDMETHODCALLTYPE * GetBuffer)        (ma_IAudioCaptureClient* pThis, BYTE** ppData, ma_uint32* pNumFramesToRead, DWORD* pFlags, ma_uint64* pDevicePosition, ma_uint64* pQPCPosition);
+    HRESULT (STDMETHODCALLTYPE * ReleaseBuffer)    (ma_IAudioCaptureClient* pThis, ma_uint32 numFramesRead);
+    HRESULT (STDMETHODCALLTYPE * GetNextPacketSize)(ma_IAudioCaptureClient* pThis, ma_uint32* pNumFramesInNextPacket);
+} ma_IAudioCaptureClientVtbl;
+struct ma_IAudioCaptureClient
+{
+    ma_IAudioCaptureClientVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioCaptureClient_QueryInterface(ma_IAudioCaptureClient* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioCaptureClient_AddRef(ma_IAudioCaptureClient* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioCaptureClient_Release(ma_IAudioCaptureClient* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioCaptureClient_GetBuffer(ma_IAudioCaptureClient* pThis, BYTE** ppData, ma_uint32* pNumFramesToRead, DWORD* pFlags, ma_uint64* pDevicePosition, ma_uint64* pQPCPosition) { return pThis->lpVtbl->GetBuffer(pThis, ppData, pNumFramesToRead, pFlags, pDevicePosition, pQPCPosition); }
+static MA_INLINE HRESULT ma_IAudioCaptureClient_ReleaseBuffer(ma_IAudioCaptureClient* pThis, ma_uint32 numFramesRead)                 { return pThis->lpVtbl->ReleaseBuffer(pThis, numFramesRead); }
+static MA_INLINE HRESULT ma_IAudioCaptureClient_GetNextPacketSize(ma_IAudioCaptureClient* pThis, ma_uint32* pNumFramesInNextPacket)   { return pThis->lpVtbl->GetNextPacketSize(pThis, pNumFramesInNextPacket); }
+
+#if defined(MA_WIN32_UWP)
+/* mmdevapi Functions */
+typedef HRESULT (WINAPI * MA_PFN_ActivateAudioInterfaceAsync)(const wchar_t* deviceInterfacePath, const IID* riid, MA_PROPVARIANT* activationParams, ma_IActivateAudioInterfaceCompletionHandler* completionHandler, ma_IActivateAudioInterfaceAsyncOperation** activationOperation);
+#endif
+
+/* Avrt Functions */
+typedef HANDLE (WINAPI * MA_PFN_AvSetMmThreadCharacteristicsA)(const char* TaskName, DWORD* TaskIndex);
+typedef BOOL   (WINAPI * MA_PFN_AvRevertMmThreadCharacteristics)(HANDLE AvrtHandle);
+
+#if !defined(MA_WIN32_DESKTOP) && !defined(MA_WIN32_GDK)
+typedef struct ma_completion_handler_uwp ma_completion_handler_uwp;
+
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_completion_handler_uwp* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_completion_handler_uwp* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_completion_handler_uwp* pThis);
+
+    /* IActivateAudioInterfaceCompletionHandler */
+    HRESULT (STDMETHODCALLTYPE * ActivateCompleted)(ma_completion_handler_uwp* pThis, ma_IActivateAudioInterfaceAsyncOperation* pActivateOperation);
+} ma_completion_handler_uwp_vtbl;
+struct ma_completion_handler_uwp
+{
+    ma_completion_handler_uwp_vtbl* lpVtbl;
+    MA_ATOMIC(4, ma_uint32) counter;
+    HANDLE hEvent;
+};
+
+static HRESULT STDMETHODCALLTYPE ma_completion_handler_uwp_QueryInterface(ma_completion_handler_uwp* pThis, const IID* const riid, void** ppObject)
+{
+    /*
+    We need to "implement" IAgileObject which is just an indicator that's used internally by WASAPI for some multithreading management. To
+    "implement" this, we just make sure we return pThis when the IAgileObject is requested.
+    */
+    if (!ma_is_guid_equal(riid, &MA_IID_IUnknown) && !ma_is_guid_equal(riid, &MA_IID_IActivateAudioInterfaceCompletionHandler) && !ma_is_guid_equal(riid, &MA_IID_IAgileObject)) {
+        *ppObject = NULL;
+        return E_NOINTERFACE;
+    }
+
+    /* Getting here means the IID is IUnknown or IMMNotificationClient. */
+    *ppObject = (void*)pThis;
+    ((ma_completion_handler_uwp_vtbl*)pThis->lpVtbl)->AddRef(pThis);
+    return S_OK;
+}
+
+static ULONG STDMETHODCALLTYPE ma_completion_handler_uwp_AddRef(ma_completion_handler_uwp* pThis)
+{
+    return (ULONG)ma_atomic_fetch_add_32(&pThis->counter, 1) + 1;
+}
+
+static ULONG STDMETHODCALLTYPE ma_completion_handler_uwp_Release(ma_completion_handler_uwp* pThis)
+{
+    ma_uint32 newRefCount = ma_atomic_fetch_sub_32(&pThis->counter, 1) - 1;
+    if (newRefCount == 0) {
+        return 0;   /* We don't free anything here because we never allocate the object on the heap. */
+    }
+
+    return (ULONG)newRefCount;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_completion_handler_uwp_ActivateCompleted(ma_completion_handler_uwp* pThis, ma_IActivateAudioInterfaceAsyncOperation* pActivateOperation)
+{
+    (void)pActivateOperation;
+    SetEvent(pThis->hEvent);
+    return S_OK;
+}
+
+
+static ma_completion_handler_uwp_vtbl g_maCompletionHandlerVtblInstance = {
+    ma_completion_handler_uwp_QueryInterface,
+    ma_completion_handler_uwp_AddRef,
+    ma_completion_handler_uwp_Release,
+    ma_completion_handler_uwp_ActivateCompleted
+};
+
+static ma_result ma_completion_handler_uwp_init(ma_completion_handler_uwp* pHandler)
+{
+    MA_ASSERT(pHandler != NULL);
+    MA_ZERO_OBJECT(pHandler);
+
+    pHandler->lpVtbl = &g_maCompletionHandlerVtblInstance;
+    pHandler->counter = 1;
+    pHandler->hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+    if (pHandler->hEvent == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_completion_handler_uwp_uninit(ma_completion_handler_uwp* pHandler)
+{
+    if (pHandler->hEvent != NULL) {
+        CloseHandle(pHandler->hEvent);
+    }
+}
+
+static void ma_completion_handler_uwp_wait(ma_completion_handler_uwp* pHandler)
+{
+    WaitForSingleObject((HANDLE)pHandler->hEvent, INFINITE);
+}
+#endif  /* !MA_WIN32_DESKTOP */
+
+/* We need a virtual table for our notification client object that's used for detecting changes to the default device. */
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_QueryInterface(ma_IMMNotificationClient* pThis, const IID* const riid, void** ppObject)
+{
+    /*
+    We care about two interfaces - IUnknown and IMMNotificationClient. If the requested IID is something else
+    we just return E_NOINTERFACE. Otherwise we need to increment the reference counter and return S_OK.
+    */
+    if (!ma_is_guid_equal(riid, &MA_IID_IUnknown) && !ma_is_guid_equal(riid, &MA_IID_IMMNotificationClient)) {
+        *ppObject = NULL;
+        return E_NOINTERFACE;
+    }
+
+    /* Getting here means the IID is IUnknown or IMMNotificationClient. */
+    *ppObject = (void*)pThis;
+    ((ma_IMMNotificationClientVtbl*)pThis->lpVtbl)->AddRef(pThis);
+    return S_OK;
+}
+
+static ULONG STDMETHODCALLTYPE ma_IMMNotificationClient_AddRef(ma_IMMNotificationClient* pThis)
+{
+    return (ULONG)ma_atomic_fetch_add_32(&pThis->counter, 1) + 1;
+}
+
+static ULONG STDMETHODCALLTYPE ma_IMMNotificationClient_Release(ma_IMMNotificationClient* pThis)
+{
+    ma_uint32 newRefCount = ma_atomic_fetch_sub_32(&pThis->counter, 1) - 1;
+    if (newRefCount == 0) {
+        return 0;   /* We don't free anything here because we never allocate the object on the heap. */
+    }
+
+    return (ULONG)newRefCount;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnDeviceStateChanged(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID, DWORD dwNewState)
+{
+    ma_bool32 isThisDevice = MA_FALSE;
+    ma_bool32 isCapture    = MA_FALSE;
+    ma_bool32 isPlayback   = MA_FALSE;
+
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnDeviceStateChanged(pDeviceID=%S, dwNewState=%u)\n", (pDeviceID != NULL) ? pDeviceID : L"(NULL)", (unsigned int)dwNewState);*/
+#endif
+
+    /*
+    There have been reports of a hang when a playback device is disconnected. The idea with this code is to explicitly stop the device if we detect
+    that the device is disabled or has been unplugged.
+    */
+    if (pThis->pDevice->wasapi.allowCaptureAutoStreamRouting && (pThis->pDevice->type == ma_device_type_capture || pThis->pDevice->type == ma_device_type_duplex || pThis->pDevice->type == ma_device_type_loopback)) {
+        isCapture = MA_TRUE;
+        if (ma_strcmp_WCHAR(pThis->pDevice->capture.id.wasapi, pDeviceID) == 0) {
+            isThisDevice = MA_TRUE;
+        }
+    }
+
+    if (pThis->pDevice->wasapi.allowPlaybackAutoStreamRouting && (pThis->pDevice->type == ma_device_type_playback || pThis->pDevice->type == ma_device_type_duplex)) {
+        isPlayback = MA_TRUE;
+        if (ma_strcmp_WCHAR(pThis->pDevice->playback.id.wasapi, pDeviceID) == 0) {
+            isThisDevice = MA_TRUE;
+        }
+    }
+
+
+    /*
+    If the device ID matches our device we need to mark our device as detached and stop it. When a
+    device is added in OnDeviceAdded(), we'll restart it. We only mark it as detached if the device
+    was started at the time of being removed.
+    */
+    if (isThisDevice) {
+        if ((dwNewState & MA_MM_DEVICE_STATE_ACTIVE) == 0) {
+            /*
+            Unplugged or otherwise unavailable. Mark as detached if we were in a playing state. We'll
+            use this to determine whether or not we need to automatically start the device when it's
+            plugged back in again.
+            */
+            if (ma_device_get_state(pThis->pDevice) == ma_device_state_started) {
+                if (isPlayback) {
+                    pThis->pDevice->wasapi.isDetachedPlayback = MA_TRUE;
+                }
+                if (isCapture) {
+                    pThis->pDevice->wasapi.isDetachedCapture = MA_TRUE;
+                }
+
+                ma_device_stop(pThis->pDevice);
+            }
+        }
+
+        if ((dwNewState & MA_MM_DEVICE_STATE_ACTIVE) != 0) {
+            /* The device was activated. If we were detached, we need to start it again. */
+            ma_bool8 tryRestartingDevice = MA_FALSE;
+
+            if (isPlayback) {
+                if (pThis->pDevice->wasapi.isDetachedPlayback) {
+                    pThis->pDevice->wasapi.isDetachedPlayback = MA_FALSE;
+                    ma_device_reroute__wasapi(pThis->pDevice, ma_device_type_playback);
+                    tryRestartingDevice = MA_TRUE;
+                }
+            }
+
+            if (isCapture) {
+                if (pThis->pDevice->wasapi.isDetachedCapture) {
+                    pThis->pDevice->wasapi.isDetachedCapture = MA_FALSE;
+                    ma_device_reroute__wasapi(pThis->pDevice, (pThis->pDevice->type == ma_device_type_loopback) ? ma_device_type_loopback : ma_device_type_capture);
+                    tryRestartingDevice = MA_TRUE;
+                }
+            }
+
+            if (tryRestartingDevice) {
+                if (pThis->pDevice->wasapi.isDetachedPlayback == MA_FALSE && pThis->pDevice->wasapi.isDetachedCapture == MA_FALSE) {
+                    ma_device_start(pThis->pDevice);
+                }
+            }
+        }
+    }
+
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnDeviceAdded(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID)
+{
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnDeviceAdded(pDeviceID=%S)\n", (pDeviceID != NULL) ? pDeviceID : L"(NULL)");*/
+#endif
+
+    /* We don't need to worry about this event for our purposes. */
+    (void)pThis;
+    (void)pDeviceID;
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnDeviceRemoved(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID)
+{
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnDeviceRemoved(pDeviceID=%S)\n", (pDeviceID != NULL) ? pDeviceID : L"(NULL)");*/
+#endif
+
+    /* We don't need to worry about this event for our purposes. */
+    (void)pThis;
+    (void)pDeviceID;
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnDefaultDeviceChanged(ma_IMMNotificationClient* pThis, ma_EDataFlow dataFlow, ma_ERole role, const WCHAR* pDefaultDeviceID)
+{
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnDefaultDeviceChanged(dataFlow=%d, role=%d, pDefaultDeviceID=%S)\n", dataFlow, role, (pDefaultDeviceID != NULL) ? pDefaultDeviceID : L"(NULL)");*/
+#endif
+
+    (void)role;
+
+    /* We only care about devices with the same data flow as the current device. */
+    if ((pThis->pDevice->type == ma_device_type_playback && dataFlow != ma_eRender)  ||
+        (pThis->pDevice->type == ma_device_type_capture  && dataFlow != ma_eCapture) ||
+        (pThis->pDevice->type == ma_device_type_loopback && dataFlow != ma_eRender)) {
+        ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Stream rerouting abandoned because dataFlow does match device type.\n");
+        return S_OK;
+    }
+
+    /* We need to consider dataFlow as ma_eCapture if device is ma_device_type_loopback */
+    if (pThis->pDevice->type == ma_device_type_loopback) {
+        dataFlow = ma_eCapture;
+    }
+
+    /* Don't do automatic stream routing if we're not allowed. */
+    if ((dataFlow == ma_eRender  && pThis->pDevice->wasapi.allowPlaybackAutoStreamRouting == MA_FALSE) ||
+        (dataFlow == ma_eCapture && pThis->pDevice->wasapi.allowCaptureAutoStreamRouting  == MA_FALSE)) {
+        ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Stream rerouting abandoned because automatic stream routing has been disabled by the device config.\n");
+        return S_OK;
+    }
+
+    /*
+    Not currently supporting automatic stream routing in exclusive mode. This is not working correctly on my machine due to
+    AUDCLNT_E_DEVICE_IN_USE errors when reinitializing the device. If this is a bug in miniaudio, we can try re-enabling this once
+    it's fixed.
+    */
+    if ((dataFlow == ma_eRender  && pThis->pDevice->playback.shareMode == ma_share_mode_exclusive) ||
+        (dataFlow == ma_eCapture && pThis->pDevice->capture.shareMode  == ma_share_mode_exclusive)) {
+        ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Stream rerouting abandoned because the device shared mode is exclusive.\n");
+        return S_OK;
+    }
+
+
+
+    /*
+    Second attempt at device rerouting. We're going to retrieve the device's state at the time of
+    the route change. We're then going to stop the device, reinitialize the device, and then start
+    it again if the state before stopping was ma_device_state_started.
+    */
+    {
+        ma_uint32 previousState = ma_device_get_state(pThis->pDevice);
+        ma_bool8 restartDevice = MA_FALSE;
+
+        if (previousState == ma_device_state_uninitialized || previousState == ma_device_state_starting) {
+            ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Stream rerouting abandoned because the device is in the process of starting.\n");
+            return S_OK;
+        }
+
+        if (previousState == ma_device_state_started) {
+            ma_device_stop(pThis->pDevice);
+            restartDevice = MA_TRUE;
+        }
+
+        if (pDefaultDeviceID != NULL) { /* <-- The input device ID will be null if there's no other device available. */
+            ma_mutex_lock(&pThis->pDevice->wasapi.rerouteLock);
+            {
+                if (dataFlow == ma_eRender) {
+                    ma_device_reroute__wasapi(pThis->pDevice, ma_device_type_playback);
+
+                    if (pThis->pDevice->wasapi.isDetachedPlayback) {
+                        pThis->pDevice->wasapi.isDetachedPlayback = MA_FALSE;
+
+                        if (pThis->pDevice->type == ma_device_type_duplex && pThis->pDevice->wasapi.isDetachedCapture) {
+                            restartDevice = MA_FALSE;   /* It's a duplex device and the capture side is detached. We cannot be restarting the device just yet. */
+                        }
+                        else {
+                            restartDevice = MA_TRUE;    /* It's not a duplex device, or the capture side is also attached so we can go ahead and restart the device. */
+                        }
+                    }
+                }
+                else {
+                    ma_device_reroute__wasapi(pThis->pDevice, (pThis->pDevice->type == ma_device_type_loopback) ? ma_device_type_loopback : ma_device_type_capture);
+
+                    if (pThis->pDevice->wasapi.isDetachedCapture) {
+                        pThis->pDevice->wasapi.isDetachedCapture = MA_FALSE;
+
+                        if (pThis->pDevice->type == ma_device_type_duplex && pThis->pDevice->wasapi.isDetachedPlayback) {
+                            restartDevice = MA_FALSE;   /* It's a duplex device and the playback side is detached. We cannot be restarting the device just yet. */
+                        }
+                        else {
+                            restartDevice = MA_TRUE;    /* It's not a duplex device, or the playback side is also attached so we can go ahead and restart the device. */
+                        }
+                    }
+                }
+            }
+            ma_mutex_unlock(&pThis->pDevice->wasapi.rerouteLock);
+
+            if (restartDevice) {
+                ma_device_start(pThis->pDevice);
+            }
+        }
+    }
+
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnPropertyValueChanged(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID, const PROPERTYKEY key)
+{
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnPropertyValueChanged(pDeviceID=%S)\n", (pDeviceID != NULL) ? pDeviceID : L"(NULL)");*/
+#endif
+
+    (void)pThis;
+    (void)pDeviceID;
+    (void)key;
+    return S_OK;
+}
+
+static ma_IMMNotificationClientVtbl g_maNotificationCientVtbl = {
+    ma_IMMNotificationClient_QueryInterface,
+    ma_IMMNotificationClient_AddRef,
+    ma_IMMNotificationClient_Release,
+    ma_IMMNotificationClient_OnDeviceStateChanged,
+    ma_IMMNotificationClient_OnDeviceAdded,
+    ma_IMMNotificationClient_OnDeviceRemoved,
+    ma_IMMNotificationClient_OnDefaultDeviceChanged,
+    ma_IMMNotificationClient_OnPropertyValueChanged
+};
+#endif  /* MA_WIN32_DESKTOP */
+
+static const char* ma_to_usage_string__wasapi(ma_wasapi_usage usage)
+{
+    switch (usage)
+    {
+        case ma_wasapi_usage_default:   return NULL;
+        case ma_wasapi_usage_games:     return "Games";
+        case ma_wasapi_usage_pro_audio: return "Pro Audio";
+        default: break;
+    }
+
+    return NULL;
+}
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+typedef ma_IMMDevice ma_WASAPIDeviceInterface;
+#else
+typedef ma_IUnknown ma_WASAPIDeviceInterface;
+#endif
+
+
+#define MA_CONTEXT_COMMAND_QUIT__WASAPI                 1
+#define MA_CONTEXT_COMMAND_CREATE_IAUDIOCLIENT__WASAPI  2
+#define MA_CONTEXT_COMMAND_RELEASE_IAUDIOCLIENT__WASAPI 3
+
+static ma_context_command__wasapi ma_context_init_command__wasapi(int code)
+{
+    ma_context_command__wasapi cmd;
+
+    MA_ZERO_OBJECT(&cmd);
+    cmd.code = code;
+
+    return cmd;
+}
+
+static ma_result ma_context_post_command__wasapi(ma_context* pContext, const ma_context_command__wasapi* pCmd)
+{
+    /* For now we are doing everything synchronously, but I might relax this later if the need arises. */
+    ma_result result;
+    ma_bool32 isUsingLocalEvent = MA_FALSE;
+    ma_event localEvent;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCmd     != NULL);
+
+    if (pCmd->pEvent == NULL) {
+        isUsingLocalEvent = MA_TRUE;
+
+        result = ma_event_init(&localEvent);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to create the event for this command. */
+        }
+    }
+
+    /* Here is where we add the command to the list. If there's not enough room we'll spin until there is. */
+    ma_mutex_lock(&pContext->wasapi.commandLock);
+    {
+        ma_uint32 index;
+
+        /* Spin until we've got some space available. */
+        while (pContext->wasapi.commandCount == ma_countof(pContext->wasapi.commands)) {
+            ma_yield();
+        }
+
+        /* Space is now available. Can safely add to the list. */
+        index = (pContext->wasapi.commandIndex + pContext->wasapi.commandCount) % ma_countof(pContext->wasapi.commands);
+        pContext->wasapi.commands[index]        = *pCmd;
+        pContext->wasapi.commands[index].pEvent = &localEvent;
+        pContext->wasapi.commandCount += 1;
+
+        /* Now that the command has been added, release the semaphore so ma_context_next_command__wasapi() can return. */
+        ma_semaphore_release(&pContext->wasapi.commandSem);
+    }
+    ma_mutex_unlock(&pContext->wasapi.commandLock);
+
+    if (isUsingLocalEvent) {
+        ma_event_wait(&localEvent);
+        ma_event_uninit(&localEvent);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_next_command__wasapi(ma_context* pContext, ma_context_command__wasapi* pCmd)
+{
+    ma_result result = MA_SUCCESS;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCmd     != NULL);
+
+    result = ma_semaphore_wait(&pContext->wasapi.commandSem);
+    if (result == MA_SUCCESS) {
+        ma_mutex_lock(&pContext->wasapi.commandLock);
+        {
+            *pCmd = pContext->wasapi.commands[pContext->wasapi.commandIndex];
+            pContext->wasapi.commandIndex  = (pContext->wasapi.commandIndex + 1) % ma_countof(pContext->wasapi.commands);
+            pContext->wasapi.commandCount -= 1;
+        }
+        ma_mutex_unlock(&pContext->wasapi.commandLock);
+    }
+
+    return result;
+}
+
+static ma_thread_result MA_THREADCALL ma_context_command_thread__wasapi(void* pUserData)
+{
+    ma_result result;
+    ma_context* pContext = (ma_context*)pUserData;
+    MA_ASSERT(pContext != NULL);
+
+    for (;;) {
+        ma_context_command__wasapi cmd;
+        result = ma_context_next_command__wasapi(pContext, &cmd);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        switch (cmd.code)
+        {
+            case MA_CONTEXT_COMMAND_QUIT__WASAPI:
+            {
+                /* Do nothing. Handled after the switch. */
+            } break;
+
+            case MA_CONTEXT_COMMAND_CREATE_IAUDIOCLIENT__WASAPI:
+            {
+                if (cmd.data.createAudioClient.deviceType == ma_device_type_playback) {
+                    *cmd.data.createAudioClient.pResult = ma_result_from_HRESULT(ma_IAudioClient_GetService((ma_IAudioClient*)cmd.data.createAudioClient.pAudioClient, &MA_IID_IAudioRenderClient, cmd.data.createAudioClient.ppAudioClientService));
+                } else {
+                    *cmd.data.createAudioClient.pResult = ma_result_from_HRESULT(ma_IAudioClient_GetService((ma_IAudioClient*)cmd.data.createAudioClient.pAudioClient, &MA_IID_IAudioCaptureClient, cmd.data.createAudioClient.ppAudioClientService));
+                }
+            } break;
+
+            case MA_CONTEXT_COMMAND_RELEASE_IAUDIOCLIENT__WASAPI:
+            {
+                if (cmd.data.releaseAudioClient.deviceType == ma_device_type_playback) {
+                    if (cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientPlayback != NULL) {
+                        ma_IAudioClient_Release((ma_IAudioClient*)cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientPlayback);
+                        cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientPlayback = NULL;
+                    }
+                }
+
+                if (cmd.data.releaseAudioClient.deviceType == ma_device_type_capture) {
+                    if (cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientCapture != NULL) {
+                        ma_IAudioClient_Release((ma_IAudioClient*)cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientCapture);
+                        cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientCapture = NULL;
+                    }
+                }
+            } break;
+
+            default:
+            {
+                /* Unknown command. Ignore it, but trigger an assert in debug mode so we're aware of it. */
+                MA_ASSERT(MA_FALSE);
+            } break;
+        }
+
+        if (cmd.pEvent != NULL) {
+            ma_event_signal(cmd.pEvent);
+        }
+
+        if (cmd.code == MA_CONTEXT_COMMAND_QUIT__WASAPI) {
+            break;  /* Received a quit message. Get out of here. */
+        }
+    }
+
+    return (ma_thread_result)0;
+}
+
+static ma_result ma_device_create_IAudioClient_service__wasapi(ma_context* pContext, ma_device_type deviceType, ma_IAudioClient* pAudioClient, void** ppAudioClientService)
+{
+    ma_result result;
+    ma_result cmdResult;
+    ma_context_command__wasapi cmd = ma_context_init_command__wasapi(MA_CONTEXT_COMMAND_CREATE_IAUDIOCLIENT__WASAPI);
+    cmd.data.createAudioClient.deviceType           = deviceType;
+    cmd.data.createAudioClient.pAudioClient         = (void*)pAudioClient;
+    cmd.data.createAudioClient.ppAudioClientService = ppAudioClientService;
+    cmd.data.createAudioClient.pResult              = &cmdResult;   /* Declared locally, but won't be dereferenced after this function returns since execution of the command will wait here. */
+
+    result = ma_context_post_command__wasapi(pContext, &cmd);  /* This will not return until the command has actually been run. */
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return *cmd.data.createAudioClient.pResult;
+}
+
+#if 0   /* Not used at the moment, but leaving here for future use. */
+static ma_result ma_device_release_IAudioClient_service__wasapi(ma_device* pDevice, ma_device_type deviceType)
+{
+    ma_result result;
+    ma_context_command__wasapi cmd = ma_context_init_command__wasapi(MA_CONTEXT_COMMAND_RELEASE_IAUDIOCLIENT__WASAPI);
+    cmd.data.releaseAudioClient.pDevice    = pDevice;
+    cmd.data.releaseAudioClient.deviceType = deviceType;
+
+    result = ma_context_post_command__wasapi(pDevice->pContext, &cmd);  /* This will not return until the command has actually been run. */
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+static void ma_add_native_data_format_to_device_info_from_WAVEFORMATEX(const MA_WAVEFORMATEX* pWF, ma_share_mode shareMode, ma_device_info* pInfo)
+{
+    MA_ASSERT(pWF != NULL);
+    MA_ASSERT(pInfo != NULL);
+
+    if (pInfo->nativeDataFormatCount >= ma_countof(pInfo->nativeDataFormats)) {
+        return; /* Too many data formats. Need to ignore this one. Don't think this should ever happen with WASAPI. */
+    }
+
+    pInfo->nativeDataFormats[pInfo->nativeDataFormatCount].format     = ma_format_from_WAVEFORMATEX(pWF);
+    pInfo->nativeDataFormats[pInfo->nativeDataFormatCount].channels   = pWF->nChannels;
+    pInfo->nativeDataFormats[pInfo->nativeDataFormatCount].sampleRate = pWF->nSamplesPerSec;
+    pInfo->nativeDataFormats[pInfo->nativeDataFormatCount].flags      = (shareMode == ma_share_mode_exclusive) ? MA_DATA_FORMAT_FLAG_EXCLUSIVE_MODE : 0;
+    pInfo->nativeDataFormatCount += 1;
+}
+
+static ma_result ma_context_get_device_info_from_IAudioClient__wasapi(ma_context* pContext, /*ma_IMMDevice**/void* pMMDevice, ma_IAudioClient* pAudioClient, ma_device_info* pInfo)
+{
+    HRESULT hr;
+    MA_WAVEFORMATEX* pWF = NULL;
+
+    MA_ASSERT(pAudioClient != NULL);
+    MA_ASSERT(pInfo != NULL);
+
+    /* Shared Mode. We use GetMixFormat() here. */
+    hr = ma_IAudioClient_GetMixFormat((ma_IAudioClient*)pAudioClient, (MA_WAVEFORMATEX**)&pWF);
+    if (SUCCEEDED(hr)) {
+        ma_add_native_data_format_to_device_info_from_WAVEFORMATEX(pWF, ma_share_mode_shared, pInfo);
+    } else {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to retrieve mix format for device info retrieval.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    /*
+    Exclusive Mode. We repeatedly call IsFormatSupported() here. This is not currently supported on
+    UWP. Failure to retrieve the exclusive mode format is not considered an error, so from here on
+    out, MA_SUCCESS is guaranteed to be returned.
+    */
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    {
+        ma_IPropertyStore *pProperties;
+
+        /*
+        The first thing to do is get the format from PKEY_AudioEngine_DeviceFormat. This should give us a channel count we assume is
+        correct which will simplify our searching.
+        */
+        hr = ma_IMMDevice_OpenPropertyStore((ma_IMMDevice*)pMMDevice, STGM_READ, &pProperties);
+        if (SUCCEEDED(hr)) {
+            MA_PROPVARIANT var;
+            ma_PropVariantInit(&var);
+
+            hr = ma_IPropertyStore_GetValue(pProperties, &MA_PKEY_AudioEngine_DeviceFormat, &var);
+            if (SUCCEEDED(hr)) {
+                pWF = (MA_WAVEFORMATEX*)var.blob.pBlobData;
+
+                /*
+                In my testing, the format returned by PKEY_AudioEngine_DeviceFormat is suitable for exclusive mode so we check this format
+                first. If this fails, fall back to a search.
+                */
+                hr = ma_IAudioClient_IsFormatSupported((ma_IAudioClient*)pAudioClient, MA_AUDCLNT_SHAREMODE_EXCLUSIVE, pWF, NULL);
+                if (SUCCEEDED(hr)) {
+                    /* The format returned by PKEY_AudioEngine_DeviceFormat is supported. */
+                    ma_add_native_data_format_to_device_info_from_WAVEFORMATEX(pWF, ma_share_mode_exclusive, pInfo);
+                } else {
+                    /*
+                    The format returned by PKEY_AudioEngine_DeviceFormat is not supported, so fall back to a search. We assume the channel
+                    count returned by MA_PKEY_AudioEngine_DeviceFormat is valid and correct. For simplicity we're only returning one format.
+                    */
+                    ma_uint32 channels = pWF->nChannels;
+                    ma_channel defaultChannelMap[MA_MAX_CHANNELS];
+                    MA_WAVEFORMATEXTENSIBLE wf;
+                    ma_bool32 found;
+                    ma_uint32 iFormat;
+
+                    /* Make sure we don't overflow the channel map. */
+                    if (channels > MA_MAX_CHANNELS) {
+                        channels = MA_MAX_CHANNELS;
+                    }
+
+                    ma_channel_map_init_standard(ma_standard_channel_map_microsoft, defaultChannelMap, ma_countof(defaultChannelMap), channels);
+
+                    MA_ZERO_OBJECT(&wf);
+                    wf.cbSize     = sizeof(wf);
+                    wf.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
+                    wf.nChannels  = (WORD)channels;
+                    wf.dwChannelMask     = ma_channel_map_to_channel_mask__win32(defaultChannelMap, channels);
+
+                    found = MA_FALSE;
+                    for (iFormat = 0; iFormat < ma_countof(g_maFormatPriorities); ++iFormat) {
+                        ma_format format = g_maFormatPriorities[iFormat];
+                        ma_uint32 iSampleRate;
+
+                        wf.wBitsPerSample       = (WORD)(ma_get_bytes_per_sample(format)*8);
+                        wf.nBlockAlign          = (WORD)(wf.nChannels * wf.wBitsPerSample / 8);
+                        wf.nAvgBytesPerSec      = wf.nBlockAlign * wf.nSamplesPerSec;
+                        wf.Samples.wValidBitsPerSample = /*(format == ma_format_s24_32) ? 24 :*/ wf.wBitsPerSample;
+                        if (format == ma_format_f32) {
+                            wf.SubFormat = MA_GUID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
+                        } else {
+                            wf.SubFormat = MA_GUID_KSDATAFORMAT_SUBTYPE_PCM;
+                        }
+
+                        for (iSampleRate = 0; iSampleRate < ma_countof(g_maStandardSampleRatePriorities); ++iSampleRate) {
+                            wf.nSamplesPerSec = g_maStandardSampleRatePriorities[iSampleRate];
+
+                            hr = ma_IAudioClient_IsFormatSupported((ma_IAudioClient*)pAudioClient, MA_AUDCLNT_SHAREMODE_EXCLUSIVE, (MA_WAVEFORMATEX*)&wf, NULL);
+                            if (SUCCEEDED(hr)) {
+                                ma_add_native_data_format_to_device_info_from_WAVEFORMATEX((MA_WAVEFORMATEX*)&wf, ma_share_mode_exclusive, pInfo);
+                                found = MA_TRUE;
+                                break;
+                            }
+                        }
+
+                        if (found) {
+                            break;
+                        }
+                    }
+
+                    ma_PropVariantClear(pContext, &var);
+
+                    if (!found) {
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "[WASAPI] Failed to find suitable device format for device info retrieval.");
+                    }
+                }
+            } else {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "[WASAPI] Failed to retrieve device format for device info retrieval.");
+            }
+
+            ma_IPropertyStore_Release(pProperties);
+        } else {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "[WASAPI] Failed to open property store for device info retrieval.");
+        }
+    }
+    #else
+    {
+        (void)pMMDevice;    /* Unused. */
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+static ma_EDataFlow ma_device_type_to_EDataFlow(ma_device_type deviceType)
+{
+    if (deviceType == ma_device_type_playback) {
+        return ma_eRender;
+    } else if (deviceType == ma_device_type_capture) {
+        return ma_eCapture;
+    } else {
+        MA_ASSERT(MA_FALSE);
+        return ma_eRender; /* Should never hit this. */
+    }
+}
+
+static ma_result ma_context_create_IMMDeviceEnumerator__wasapi(ma_context* pContext, ma_IMMDeviceEnumerator** ppDeviceEnumerator)
+{
+    HRESULT hr;
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+
+    MA_ASSERT(pContext           != NULL);
+    MA_ASSERT(ppDeviceEnumerator != NULL);
+
+    *ppDeviceEnumerator = NULL; /* Safety. */
+
+    hr = ma_CoCreateInstance(pContext, &MA_CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, &MA_IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create device enumerator.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    *ppDeviceEnumerator = pDeviceEnumerator;
+
+    return MA_SUCCESS;
+}
+
+static WCHAR* ma_context_get_default_device_id_from_IMMDeviceEnumerator__wasapi(ma_context* pContext, ma_IMMDeviceEnumerator* pDeviceEnumerator, ma_device_type deviceType)
+{
+    HRESULT hr;
+    ma_IMMDevice* pMMDefaultDevice = NULL;
+    WCHAR* pDefaultDeviceID = NULL;
+    ma_EDataFlow dataFlow;
+    ma_ERole role;
+
+    MA_ASSERT(pContext          != NULL);
+    MA_ASSERT(pDeviceEnumerator != NULL);
+
+    (void)pContext;
+
+    /* Grab the EDataFlow type from the device type. */
+    dataFlow = ma_device_type_to_EDataFlow(deviceType);
+
+    /* The role is always eConsole, but we may make this configurable later. */
+    role = ma_eConsole;
+
+    hr = ma_IMMDeviceEnumerator_GetDefaultAudioEndpoint(pDeviceEnumerator, dataFlow, role, &pMMDefaultDevice);
+    if (FAILED(hr)) {
+        return NULL;
+    }
+
+    hr = ma_IMMDevice_GetId(pMMDefaultDevice, &pDefaultDeviceID);
+
+    ma_IMMDevice_Release(pMMDefaultDevice);
+    pMMDefaultDevice = NULL;
+
+    if (FAILED(hr)) {
+        return NULL;
+    }
+
+    return pDefaultDeviceID;
+}
+
+static WCHAR* ma_context_get_default_device_id__wasapi(ma_context* pContext, ma_device_type deviceType)    /* Free the returned pointer with ma_CoTaskMemFree() */
+{
+    ma_result result;
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+    WCHAR* pDefaultDeviceID = NULL;
+
+    MA_ASSERT(pContext != NULL);
+
+    result = ma_context_create_IMMDeviceEnumerator__wasapi(pContext, &pDeviceEnumerator);
+    if (result != MA_SUCCESS) {
+        return NULL;
+    }
+
+    pDefaultDeviceID = ma_context_get_default_device_id_from_IMMDeviceEnumerator__wasapi(pContext, pDeviceEnumerator, deviceType);
+
+    ma_IMMDeviceEnumerator_Release(pDeviceEnumerator);
+    return pDefaultDeviceID;
+}
+
+static ma_result ma_context_get_MMDevice__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_IMMDevice** ppMMDevice)
+{
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+    HRESULT hr;
+    HRESULT CoInitializeResult;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppMMDevice != NULL);
+
+    /*
+    This weird COM init/uninit here is a hack to work around a crash when changing devices. What is happening is
+    WASAPI fires a callback from another thread when the device is changed. It's from that thread where this
+    function is getting called. What I'm suspecting is that the other thread is not initializing COM which in turn
+    results in CoCreateInstance() failing.
+
+    The community has reported that this seems to fix the crash. There are future plans to move all WASAPI operation
+    over to a single thread to make everything safer, but in the meantime while we wait for that to come online I'm
+    happy enough to use this hack instead.
+
+    CoUninitialize should only be called if we successfully initialized. S_OK and S_FALSE both mean that we need to
+    call CoUninitialize since the internal ref count was increased. RPC_E_CHANGED_MODE means that CoInitializeEx was
+    called with a different COINIT value, and we don't call CoUninitialize in that case. Other errors are possible,
+    so we check for S_OK and S_FALSE specifically.
+    */
+    CoInitializeResult = ma_CoInitializeEx(pContext, NULL, MA_COINIT_VALUE);
+    {
+        hr = ma_CoCreateInstance(pContext, &MA_CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, &MA_IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator);
+    }    
+    if (CoInitializeResult == S_OK || CoInitializeResult == S_FALSE) { ma_CoUninitialize(pContext); }
+
+    if (FAILED(hr)) {   /* <-- This is checking the call above to ma_CoCreateInstance(). */
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create IMMDeviceEnumerator.\n");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    if (pDeviceID == NULL) {
+        hr = ma_IMMDeviceEnumerator_GetDefaultAudioEndpoint(pDeviceEnumerator, (deviceType == ma_device_type_capture) ? ma_eCapture : ma_eRender, ma_eConsole, ppMMDevice);
+    } else {
+        hr = ma_IMMDeviceEnumerator_GetDevice(pDeviceEnumerator, pDeviceID->wasapi, ppMMDevice);
+    }
+
+    ma_IMMDeviceEnumerator_Release(pDeviceEnumerator);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to retrieve IMMDevice.\n");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_id_from_MMDevice__wasapi(ma_context* pContext, ma_IMMDevice* pMMDevice, ma_device_id* pDeviceID)
+{
+    WCHAR* pDeviceIDString;
+    HRESULT hr;
+
+    MA_ASSERT(pDeviceID != NULL);
+
+    hr = ma_IMMDevice_GetId(pMMDevice, &pDeviceIDString);
+    if (SUCCEEDED(hr)) {
+        size_t idlen = ma_strlen_WCHAR(pDeviceIDString);
+        if (idlen+1 > ma_countof(pDeviceID->wasapi)) {
+            ma_CoTaskMemFree(pContext, pDeviceIDString);
+            MA_ASSERT(MA_FALSE);  /* NOTE: If this is triggered, please report it. It means the format of the ID must have changed and is too long to fit in our fixed sized buffer. */
+            return MA_ERROR;
+        }
+
+        MA_COPY_MEMORY(pDeviceID->wasapi, pDeviceIDString, idlen * sizeof(wchar_t));
+        pDeviceID->wasapi[idlen] = '\0';
+
+        ma_CoTaskMemFree(pContext, pDeviceIDString);
+
+        return MA_SUCCESS;
+    }
+
+    return MA_ERROR;
+}
+
+static ma_result ma_context_get_device_info_from_MMDevice__wasapi(ma_context* pContext, ma_IMMDevice* pMMDevice, WCHAR* pDefaultDeviceID, ma_bool32 onlySimpleInfo, ma_device_info* pInfo)
+{
+    ma_result result;
+    HRESULT hr;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pMMDevice != NULL);
+    MA_ASSERT(pInfo != NULL);
+
+    /* ID. */
+    result = ma_context_get_device_id_from_MMDevice__wasapi(pContext, pMMDevice, &pInfo->id);
+    if (result == MA_SUCCESS) {
+        if (pDefaultDeviceID != NULL) {
+            if (ma_strcmp_WCHAR(pInfo->id.wasapi, pDefaultDeviceID) == 0) {
+                pInfo->isDefault = MA_TRUE;
+            }
+        }
+    }
+
+    /* Description / Friendly Name */
+    {
+        ma_IPropertyStore *pProperties;
+        hr = ma_IMMDevice_OpenPropertyStore(pMMDevice, STGM_READ, &pProperties);
+        if (SUCCEEDED(hr)) {
+            MA_PROPVARIANT var;
+
+            ma_PropVariantInit(&var);
+            hr = ma_IPropertyStore_GetValue(pProperties, &MA_PKEY_Device_FriendlyName, &var);
+            if (SUCCEEDED(hr)) {
+                WideCharToMultiByte(CP_UTF8, 0, var.pwszVal, -1, pInfo->name, sizeof(pInfo->name), 0, FALSE);
+                ma_PropVariantClear(pContext, &var);
+            }
+
+            ma_IPropertyStore_Release(pProperties);
+        }
+    }
+
+    /* Format */
+    if (!onlySimpleInfo) {
+        ma_IAudioClient* pAudioClient;
+        hr = ma_IMMDevice_Activate(pMMDevice, &MA_IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&pAudioClient);
+        if (SUCCEEDED(hr)) {
+            result = ma_context_get_device_info_from_IAudioClient__wasapi(pContext, pMMDevice, pAudioClient, pInfo);
+
+            ma_IAudioClient_Release(pAudioClient);
+            return result;
+        } else {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to activate audio client for device info retrieval.");
+            return ma_result_from_HRESULT(hr);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_enumerate_devices_by_type__wasapi(ma_context* pContext, ma_IMMDeviceEnumerator* pDeviceEnumerator, ma_device_type deviceType, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_result result = MA_SUCCESS;
+    UINT deviceCount;
+    HRESULT hr;
+    ma_uint32 iDevice;
+    WCHAR* pDefaultDeviceID = NULL;
+    ma_IMMDeviceCollection* pDeviceCollection = NULL;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Grab the default device. We use this to know whether or not flag the returned device info as being the default. */
+    pDefaultDeviceID = ma_context_get_default_device_id_from_IMMDeviceEnumerator__wasapi(pContext, pDeviceEnumerator, deviceType);
+
+    /* We need to enumerate the devices which returns a device collection. */
+    hr = ma_IMMDeviceEnumerator_EnumAudioEndpoints(pDeviceEnumerator, ma_device_type_to_EDataFlow(deviceType), MA_MM_DEVICE_STATE_ACTIVE, &pDeviceCollection);
+    if (SUCCEEDED(hr)) {
+        hr = ma_IMMDeviceCollection_GetCount(pDeviceCollection, &deviceCount);
+        if (FAILED(hr)) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to get device count.\n");
+            result = ma_result_from_HRESULT(hr);
+            goto done;
+        }
+
+        for (iDevice = 0; iDevice < deviceCount; ++iDevice) {
+            ma_device_info deviceInfo;
+            ma_IMMDevice* pMMDevice;
+
+            MA_ZERO_OBJECT(&deviceInfo);
+
+            hr = ma_IMMDeviceCollection_Item(pDeviceCollection, iDevice, &pMMDevice);
+            if (SUCCEEDED(hr)) {
+                result = ma_context_get_device_info_from_MMDevice__wasapi(pContext, pMMDevice, pDefaultDeviceID, MA_TRUE, &deviceInfo);   /* MA_TRUE = onlySimpleInfo. */
+
+                ma_IMMDevice_Release(pMMDevice);
+                if (result == MA_SUCCESS) {
+                    ma_bool32 cbResult = callback(pContext, deviceType, &deviceInfo, pUserData);
+                    if (cbResult == MA_FALSE) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+done:
+    if (pDefaultDeviceID != NULL) {
+        ma_CoTaskMemFree(pContext, pDefaultDeviceID);
+        pDefaultDeviceID = NULL;
+    }
+
+    if (pDeviceCollection != NULL) {
+        ma_IMMDeviceCollection_Release(pDeviceCollection);
+        pDeviceCollection = NULL;
+    }
+
+    return result;
+}
+
+static ma_result ma_context_get_IAudioClient_Desktop__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, MA_PROPVARIANT* pActivationParams, ma_IAudioClient** ppAudioClient, ma_IMMDevice** ppMMDevice)
+{
+    ma_result result;
+    HRESULT hr;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppAudioClient != NULL);
+    MA_ASSERT(ppMMDevice != NULL);
+
+    result = ma_context_get_MMDevice__wasapi(pContext, deviceType, pDeviceID, ppMMDevice);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    hr = ma_IMMDevice_Activate(*ppMMDevice, &MA_IID_IAudioClient, CLSCTX_ALL, pActivationParams, (void**)ppAudioClient);
+    if (FAILED(hr)) {
+        return ma_result_from_HRESULT(hr);
+    }
+
+    return MA_SUCCESS;
+}
+#else
+static ma_result ma_context_get_IAudioClient_UWP__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, MA_PROPVARIANT* pActivationParams, ma_IAudioClient** ppAudioClient, ma_IUnknown** ppActivatedInterface)
+{
+    ma_IActivateAudioInterfaceAsyncOperation *pAsyncOp = NULL;
+    ma_completion_handler_uwp completionHandler;
+    IID iid;
+    WCHAR* iidStr;
+    HRESULT hr;
+    ma_result result;
+    HRESULT activateResult;
+    ma_IUnknown* pActivatedInterface;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppAudioClient != NULL);
+
+    if (pDeviceID != NULL) {
+        iidStr = (WCHAR*)pDeviceID->wasapi;
+    } else {
+        if (deviceType == ma_device_type_capture) {
+            iid = MA_IID_DEVINTERFACE_AUDIO_CAPTURE;
+        } else {
+            iid = MA_IID_DEVINTERFACE_AUDIO_RENDER;
+        }
+
+    #if defined(__cplusplus)
+        hr = StringFromIID(iid, &iidStr);
+    #else
+        hr = StringFromIID(&iid, &iidStr);
+    #endif
+        if (FAILED(hr)) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to convert device IID to string for ActivateAudioInterfaceAsync(). Out of memory.\n");
+            return ma_result_from_HRESULT(hr);
+        }
+    }
+
+    result = ma_completion_handler_uwp_init(&completionHandler);
+    if (result != MA_SUCCESS) {
+        ma_CoTaskMemFree(pContext, iidStr);
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create event for waiting for ActivateAudioInterfaceAsync().\n");
+        return result;
+    }
+
+    hr = ((MA_PFN_ActivateAudioInterfaceAsync)pContext->wasapi.ActivateAudioInterfaceAsync)(iidStr, &MA_IID_IAudioClient, pActivationParams, (ma_IActivateAudioInterfaceCompletionHandler*)&completionHandler, (ma_IActivateAudioInterfaceAsyncOperation**)&pAsyncOp);
+    if (FAILED(hr)) {
+        ma_completion_handler_uwp_uninit(&completionHandler);
+        ma_CoTaskMemFree(pContext, iidStr);
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] ActivateAudioInterfaceAsync() failed.\n");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    if (pDeviceID == NULL) {
+        ma_CoTaskMemFree(pContext, iidStr);
+    }
+
+    /* Wait for the async operation for finish. */
+    ma_completion_handler_uwp_wait(&completionHandler);
+    ma_completion_handler_uwp_uninit(&completionHandler);
+
+    hr = ma_IActivateAudioInterfaceAsyncOperation_GetActivateResult(pAsyncOp, &activateResult, &pActivatedInterface);
+    ma_IActivateAudioInterfaceAsyncOperation_Release(pAsyncOp);
+
+    if (FAILED(hr) || FAILED(activateResult)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to activate device.\n");
+        return FAILED(hr) ? ma_result_from_HRESULT(hr) : ma_result_from_HRESULT(activateResult);
+    }
+
+    /* Here is where we grab the IAudioClient interface. */
+    hr = ma_IUnknown_QueryInterface(pActivatedInterface, &MA_IID_IAudioClient, (void**)ppAudioClient);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to query IAudioClient interface.\n");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    if (ppActivatedInterface) {
+        *ppActivatedInterface = pActivatedInterface;
+    } else {
+        ma_IUnknown_Release(pActivatedInterface);
+    }
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+/* https://docs.microsoft.com/en-us/windows/win32/api/audioclientactivationparams/ne-audioclientactivationparams-audioclient_activation_type */
+typedef enum
+{
+    MA_AUDIOCLIENT_ACTIVATION_TYPE_DEFAULT,
+    MA_AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK
+} MA_AUDIOCLIENT_ACTIVATION_TYPE;
+
+/* https://docs.microsoft.com/en-us/windows/win32/api/audioclientactivationparams/ne-audioclientactivationparams-process_loopback_mode */
+typedef enum
+{
+    MA_PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE,
+    MA_PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE
+} MA_PROCESS_LOOPBACK_MODE;
+
+/* https://docs.microsoft.com/en-us/windows/win32/api/audioclientactivationparams/ns-audioclientactivationparams-audioclient_process_loopback_params */
+typedef struct
+{
+    DWORD TargetProcessId;
+    MA_PROCESS_LOOPBACK_MODE ProcessLoopbackMode;
+} MA_AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS;
+
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(push)
+    #pragma warning(disable:4201)   /* nonstandard extension used: nameless struct/union */
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic" /* For ISO C99 doesn't support unnamed structs/unions [-Wpedantic] */
+    #if defined(__clang__)
+        #pragma GCC diagnostic ignored "-Wc11-extensions"   /* anonymous unions are a C11 extension */
+    #endif
+#endif
+/* https://docs.microsoft.com/en-us/windows/win32/api/audioclientactivationparams/ns-audioclientactivationparams-audioclient_activation_params */
+typedef struct
+{
+    MA_AUDIOCLIENT_ACTIVATION_TYPE ActivationType;
+    union
+    {
+        MA_AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS ProcessLoopbackParams;
+    };
+} MA_AUDIOCLIENT_ACTIVATION_PARAMS;
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(pop)
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic pop
+#endif
+
+#define MA_VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK L"VAD\\Process_Loopback"
+
+static ma_result ma_context_get_IAudioClient__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_uint32 loopbackProcessID, ma_bool32 loopbackProcessExclude, ma_IAudioClient** ppAudioClient, ma_WASAPIDeviceInterface** ppDeviceInterface)
+{
+    ma_result result;
+    ma_bool32 usingProcessLoopback = MA_FALSE;
+    MA_AUDIOCLIENT_ACTIVATION_PARAMS audioclientActivationParams;
+    MA_PROPVARIANT activationParams;
+    MA_PROPVARIANT* pActivationParams = NULL;
+    ma_device_id virtualDeviceID;
+
+    /* Activation parameters specific to loopback mode. Note that process-specific loopback will only work when a default device ID is specified. */
+    if (deviceType == ma_device_type_loopback && loopbackProcessID != 0 && pDeviceID == NULL) {
+        usingProcessLoopback = MA_TRUE;
+    }
+
+    if (usingProcessLoopback) {
+        MA_ZERO_OBJECT(&audioclientActivationParams);
+        audioclientActivationParams.ActivationType                            = MA_AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK;
+        audioclientActivationParams.ProcessLoopbackParams.ProcessLoopbackMode = (loopbackProcessExclude) ? MA_PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE : MA_PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE;
+        audioclientActivationParams.ProcessLoopbackParams.TargetProcessId     = (DWORD)loopbackProcessID;
+
+        ma_PropVariantInit(&activationParams);
+        activationParams.vt             = MA_VT_BLOB;
+        activationParams.blob.cbSize    = sizeof(audioclientActivationParams);
+        activationParams.blob.pBlobData = (BYTE*)&audioclientActivationParams;
+        pActivationParams = &activationParams;
+
+        /* When requesting a specific device ID we need to use a special device ID. */
+        MA_COPY_MEMORY(virtualDeviceID.wasapi, MA_VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK, (ma_wcslen(MA_VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK) + 1) * sizeof(wchar_t)); /* +1 for the null terminator. */
+        pDeviceID = &virtualDeviceID;
+    } else {
+        pActivationParams = NULL;   /* No activation parameters required. */
+    }
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    result = ma_context_get_IAudioClient_Desktop__wasapi(pContext, deviceType, pDeviceID, pActivationParams, ppAudioClient, ppDeviceInterface);
+#else
+    result = ma_context_get_IAudioClient_UWP__wasapi(pContext, deviceType, pDeviceID, pActivationParams, ppAudioClient, ppDeviceInterface);
+#endif
+
+    /*
+    If loopback mode was requested with a process ID and initialization failed, it could be because it's
+    trying to run on an older version of Windows where it's not supported. We need to let the caller
+    know about this with a log message.
+    */
+    if (result != MA_SUCCESS) {
+        if (usingProcessLoopback) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Loopback mode requested to %s process ID %u, but initialization failed. Support for this feature begins with Windows 10 Build 20348. Confirm your version of Windows or consider not using process-specific loopback.\n", (loopbackProcessExclude) ? "exclude" : "include", loopbackProcessID);
+        }
+    }
+
+    return result;
+}
+
+
+static ma_result ma_context_enumerate_devices__wasapi(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    /* Different enumeration for desktop and UWP. */
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    /* Desktop */
+    HRESULT hr;
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+
+    hr = ma_CoCreateInstance(pContext, &MA_CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, &MA_IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create device enumerator.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    ma_context_enumerate_devices_by_type__wasapi(pContext, pDeviceEnumerator, ma_device_type_playback, callback, pUserData);
+    ma_context_enumerate_devices_by_type__wasapi(pContext, pDeviceEnumerator, ma_device_type_capture,  callback, pUserData);
+
+    ma_IMMDeviceEnumerator_Release(pDeviceEnumerator);
+#else
+    /*
+    UWP
+
+    The MMDevice API is only supported on desktop applications. For now, while I'm still figuring out how to properly enumerate
+    over devices without using MMDevice, I'm restricting devices to defaults.
+
+    Hint: DeviceInformation::FindAllAsync() with DeviceClass.AudioCapture/AudioRender. https://blogs.windows.com/buildingapps/2014/05/15/real-time-audio-in-windows-store-and-windows-phone-apps/
+    */
+    if (callback) {
+        ma_bool32 cbResult = MA_TRUE;
+
+        /* Playback. */
+        if (cbResult) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+            deviceInfo.isDefault = MA_TRUE;
+            cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+        }
+
+        /* Capture. */
+        if (cbResult) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+            deviceInfo.isDefault = MA_TRUE;
+            cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+        }
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    ma_result result;
+    ma_IMMDevice* pMMDevice = NULL;
+    WCHAR* pDefaultDeviceID = NULL;
+
+    result = ma_context_get_MMDevice__wasapi(pContext, deviceType, pDeviceID, &pMMDevice);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* We need the default device ID so we can set the isDefault flag in the device info. */
+    pDefaultDeviceID = ma_context_get_default_device_id__wasapi(pContext, deviceType);
+
+    result = ma_context_get_device_info_from_MMDevice__wasapi(pContext, pMMDevice, pDefaultDeviceID, MA_FALSE, pDeviceInfo);   /* MA_FALSE = !onlySimpleInfo. */
+
+    if (pDefaultDeviceID != NULL) {
+        ma_CoTaskMemFree(pContext, pDefaultDeviceID);
+        pDefaultDeviceID = NULL;
+    }
+
+    ma_IMMDevice_Release(pMMDevice);
+
+    return result;
+#else
+    ma_IAudioClient* pAudioClient;
+    ma_result result;
+
+    /* UWP currently only uses default devices. */
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+    result = ma_context_get_IAudioClient_UWP__wasapi(pContext, deviceType, pDeviceID, NULL, &pAudioClient, NULL);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_context_get_device_info_from_IAudioClient__wasapi(pContext, NULL, pAudioClient, pDeviceInfo);
+
+    pDeviceInfo->isDefault = MA_TRUE;  /* UWP only supports default devices. */
+
+    ma_IAudioClient_Release(pAudioClient);
+    return result;
+#endif
+}
+
+static ma_result ma_device_uninit__wasapi(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    {
+        if (pDevice->wasapi.pDeviceEnumerator) {
+            ((ma_IMMDeviceEnumerator*)pDevice->wasapi.pDeviceEnumerator)->lpVtbl->UnregisterEndpointNotificationCallback((ma_IMMDeviceEnumerator*)pDevice->wasapi.pDeviceEnumerator, &pDevice->wasapi.notificationClient);
+            ma_IMMDeviceEnumerator_Release((ma_IMMDeviceEnumerator*)pDevice->wasapi.pDeviceEnumerator);
+        }
+
+        ma_mutex_uninit(&pDevice->wasapi.rerouteLock);
+    }
+    #endif
+
+    if (pDevice->wasapi.pRenderClient) {
+        if (pDevice->wasapi.pMappedBufferPlayback != NULL) {
+            ma_IAudioRenderClient_ReleaseBuffer((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient, pDevice->wasapi.mappedBufferPlaybackCap, 0);
+            pDevice->wasapi.pMappedBufferPlayback   = NULL;
+            pDevice->wasapi.mappedBufferPlaybackCap = 0;
+            pDevice->wasapi.mappedBufferPlaybackLen = 0;
+        }
+
+        ma_IAudioRenderClient_Release((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient);
+    }
+    if (pDevice->wasapi.pCaptureClient) {
+        if (pDevice->wasapi.pMappedBufferCapture != NULL) {
+            ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+            pDevice->wasapi.pMappedBufferCapture   = NULL;
+            pDevice->wasapi.mappedBufferCaptureCap = 0;
+            pDevice->wasapi.mappedBufferCaptureLen = 0;
+        }
+
+        ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+    }
+
+    if (pDevice->wasapi.pAudioClientPlayback) {
+        ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback);
+    }
+    if (pDevice->wasapi.pAudioClientCapture) {
+        ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+    }
+
+    if (pDevice->wasapi.hEventPlayback) {
+        CloseHandle((HANDLE)pDevice->wasapi.hEventPlayback);
+    }
+    if (pDevice->wasapi.hEventCapture) {
+        CloseHandle((HANDLE)pDevice->wasapi.hEventCapture);
+    }
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    /* Input. */
+    ma_format formatIn;
+    ma_uint32 channelsIn;
+    ma_uint32 sampleRateIn;
+    ma_channel channelMapIn[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFramesIn;
+    ma_uint32 periodSizeInMillisecondsIn;
+    ma_uint32 periodsIn;
+    ma_share_mode shareMode;
+    ma_performance_profile performanceProfile;
+    ma_bool32 noAutoConvertSRC;
+    ma_bool32 noDefaultQualitySRC;
+    ma_bool32 noHardwareOffloading;
+    ma_uint32 loopbackProcessID;
+    ma_bool32 loopbackProcessExclude;
+
+    /* Output. */
+    ma_IAudioClient* pAudioClient;
+    ma_IAudioRenderClient* pRenderClient;
+    ma_IAudioCaptureClient* pCaptureClient;
+    ma_format formatOut;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRateOut;
+    ma_channel channelMapOut[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFramesOut;
+    ma_uint32 periodsOut;
+    ma_bool32 usingAudioClient3;
+    char deviceName[256];
+    ma_device_id id;
+} ma_device_init_internal_data__wasapi;
+
+static ma_result ma_device_init_internal__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_init_internal_data__wasapi* pData)
+{
+    HRESULT hr;
+    ma_result result = MA_SUCCESS;
+    const char* errorMsg = "";
+    MA_AUDCLNT_SHAREMODE shareMode = MA_AUDCLNT_SHAREMODE_SHARED;
+    DWORD streamFlags = 0;
+    MA_REFERENCE_TIME periodDurationInMicroseconds;
+    ma_bool32 wasInitializedUsingIAudioClient3 = MA_FALSE;
+    MA_WAVEFORMATEXTENSIBLE wf;
+    ma_WASAPIDeviceInterface* pDeviceInterface = NULL;
+    ma_IAudioClient2* pAudioClient2;
+    ma_uint32 nativeSampleRate;
+    ma_bool32 usingProcessLoopback = MA_FALSE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pData != NULL);
+
+    /* This function is only used to initialize one device type: either playback, capture or loopback. Never full-duplex. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    usingProcessLoopback = deviceType == ma_device_type_loopback && pData->loopbackProcessID != 0 && pDeviceID == NULL;
+
+    pData->pAudioClient = NULL;
+    pData->pRenderClient = NULL;
+    pData->pCaptureClient = NULL;
+
+    streamFlags = MA_AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
+    if (!pData->noAutoConvertSRC && pData->sampleRateIn != 0 && pData->shareMode != ma_share_mode_exclusive) {    /* <-- Exclusive streams must use the native sample rate. */
+        streamFlags |= MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM;
+    }
+    if (!pData->noDefaultQualitySRC && pData->sampleRateIn != 0 && (streamFlags & MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM) != 0) {
+        streamFlags |= MA_AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY;
+    }
+    if (deviceType == ma_device_type_loopback) {
+        streamFlags |= MA_AUDCLNT_STREAMFLAGS_LOOPBACK;
+    }
+
+    result = ma_context_get_IAudioClient__wasapi(pContext, deviceType, pDeviceID, pData->loopbackProcessID, pData->loopbackProcessExclude, &pData->pAudioClient, &pDeviceInterface);
+    if (result != MA_SUCCESS) {
+        goto done;
+    }
+
+    MA_ZERO_OBJECT(&wf);
+
+    /* Try enabling hardware offloading. */
+    if (!pData->noHardwareOffloading) {
+        hr = ma_IAudioClient_QueryInterface(pData->pAudioClient, &MA_IID_IAudioClient2, (void**)&pAudioClient2);
+        if (SUCCEEDED(hr)) {
+            BOOL isHardwareOffloadingSupported = 0;
+            hr = ma_IAudioClient2_IsOffloadCapable(pAudioClient2, MA_AudioCategory_Other, &isHardwareOffloadingSupported);
+            if (SUCCEEDED(hr) && isHardwareOffloadingSupported) {
+                ma_AudioClientProperties clientProperties;
+                MA_ZERO_OBJECT(&clientProperties);
+                clientProperties.cbSize = sizeof(clientProperties);
+                clientProperties.bIsOffload = 1;
+                clientProperties.eCategory = MA_AudioCategory_Other;
+                ma_IAudioClient2_SetClientProperties(pAudioClient2, &clientProperties);
+            }
+
+            pAudioClient2->lpVtbl->Release(pAudioClient2);
+        }
+    }
+
+    /* Here is where we try to determine the best format to use with the device. If the client if wanting exclusive mode, first try finding the best format for that. If this fails, fall back to shared mode. */
+    result = MA_FORMAT_NOT_SUPPORTED;
+    if (pData->shareMode == ma_share_mode_exclusive) {
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+        /* In exclusive mode on desktop we always use the backend's native format. */
+        ma_IPropertyStore* pStore = NULL;
+        hr = ma_IMMDevice_OpenPropertyStore(pDeviceInterface, STGM_READ, &pStore);
+        if (SUCCEEDED(hr)) {
+            MA_PROPVARIANT prop;
+            ma_PropVariantInit(&prop);
+            hr = ma_IPropertyStore_GetValue(pStore, &MA_PKEY_AudioEngine_DeviceFormat, &prop);
+            if (SUCCEEDED(hr)) {
+                MA_WAVEFORMATEX* pActualFormat = (MA_WAVEFORMATEX*)prop.blob.pBlobData;
+                hr = ma_IAudioClient_IsFormatSupported((ma_IAudioClient*)pData->pAudioClient, MA_AUDCLNT_SHAREMODE_EXCLUSIVE, pActualFormat, NULL);
+                if (SUCCEEDED(hr)) {
+                    MA_COPY_MEMORY(&wf, pActualFormat, sizeof(MA_WAVEFORMATEXTENSIBLE));
+                }
+
+                ma_PropVariantClear(pContext, &prop);
+            }
+
+            ma_IPropertyStore_Release(pStore);
+        }
+    #else
+        /*
+        I do not know how to query the device's native format on UWP so for now I'm just disabling support for
+        exclusive mode. The alternative is to enumerate over different formats and check IsFormatSupported()
+        until you find one that works.
+
+        TODO: Add support for exclusive mode to UWP.
+        */
+        hr = S_FALSE;
+    #endif
+
+        if (hr == S_OK) {
+            shareMode = MA_AUDCLNT_SHAREMODE_EXCLUSIVE;
+            result = MA_SUCCESS;
+        } else {
+            result = MA_SHARE_MODE_NOT_SUPPORTED;
+        }
+    } else {
+        /* In shared mode we are always using the format reported by the operating system. */
+        MA_WAVEFORMATEXTENSIBLE* pNativeFormat = NULL;
+        hr = ma_IAudioClient_GetMixFormat((ma_IAudioClient*)pData->pAudioClient, (MA_WAVEFORMATEX**)&pNativeFormat);
+        if (hr != S_OK) {
+            /* When using process-specific loopback, GetMixFormat() seems to always fail. */
+            if (usingProcessLoopback) {
+                wf.wFormatTag      = WAVE_FORMAT_IEEE_FLOAT;
+                wf.nChannels       = 2;
+                wf.nSamplesPerSec  = 44100;
+                wf.wBitsPerSample  = 32;
+                wf.nBlockAlign     = wf.nChannels * wf.wBitsPerSample / 8;
+                wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;
+                wf.cbSize          = sizeof(MA_WAVEFORMATEX);
+
+                result = MA_SUCCESS;
+            } else {
+                result = MA_FORMAT_NOT_SUPPORTED;
+            }
+        } else {
+            /*
+            I've seen cases where cbSize will be set to sizeof(WAVEFORMATEX) even though the structure itself
+            is given the format tag of WAVE_FORMAT_EXTENSIBLE. If the format tag is WAVE_FORMAT_EXTENSIBLE
+            want to make sure we copy the whole WAVEFORMATEXTENSIBLE structure. Otherwise we'll have to be
+            safe and only copy the WAVEFORMATEX part.
+            */
+            if (pNativeFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
+                MA_COPY_MEMORY(&wf, pNativeFormat, sizeof(MA_WAVEFORMATEXTENSIBLE));
+            } else {
+                /* I've seen a case where cbSize was set to 0. Assume sizeof(WAVEFORMATEX) in this case. */
+                size_t cbSize = pNativeFormat->cbSize;
+                if (cbSize == 0) {
+                    cbSize = sizeof(MA_WAVEFORMATEX);
+                }
+
+                /* Make sure we don't copy more than the capacity of `wf`. */
+                if (cbSize > sizeof(wf)) {
+                    cbSize = sizeof(wf);
+                }
+
+                MA_COPY_MEMORY(&wf, pNativeFormat, cbSize);
+            }
+
+            result = MA_SUCCESS;
+        }
+
+        ma_CoTaskMemFree(pContext, pNativeFormat);
+
+        shareMode = MA_AUDCLNT_SHAREMODE_SHARED;
+    }
+
+    /* Return an error if we still haven't found a format. */
+    if (result != MA_SUCCESS) {
+        errorMsg = "[WASAPI] Failed to find best device mix format.";
+        goto done;
+    }
+
+    /*
+    Override the native sample rate with the one requested by the caller, but only if we're not using the default sample rate. We'll use
+    WASAPI to perform the sample rate conversion.
+    */
+    nativeSampleRate = wf.nSamplesPerSec;
+    if (streamFlags & MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM) {
+        wf.nSamplesPerSec = (pData->sampleRateIn != 0) ? pData->sampleRateIn : MA_DEFAULT_SAMPLE_RATE;
+        wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;
+    }
+
+    pData->formatOut = ma_format_from_WAVEFORMATEX((MA_WAVEFORMATEX*)&wf);
+    if (pData->formatOut == ma_format_unknown) {
+        /*
+        The format isn't supported. This is almost certainly because the exclusive mode format isn't supported by miniaudio. We need to return MA_SHARE_MODE_NOT_SUPPORTED
+        in this case so that the caller can detect it and fall back to shared mode if desired. We should never get here if shared mode was requested, but just for
+        completeness we'll check for it and return MA_FORMAT_NOT_SUPPORTED.
+        */
+        if (shareMode == MA_AUDCLNT_SHAREMODE_EXCLUSIVE) {
+            result = MA_SHARE_MODE_NOT_SUPPORTED;
+        } else {
+            result = MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        errorMsg = "[WASAPI] Native format not supported.";
+        goto done;
+    }
+
+    pData->channelsOut = wf.nChannels;
+    pData->sampleRateOut = wf.nSamplesPerSec;
+
+    /*
+    Get the internal channel map based on the channel mask. There is a possibility that GetMixFormat() returns
+    a WAVEFORMATEX instead of a WAVEFORMATEXTENSIBLE, in which case the channel mask will be undefined. In this
+    case we'll just use the default channel map.
+    */
+    if (wf.wFormatTag == WAVE_FORMAT_EXTENSIBLE || wf.cbSize >= sizeof(MA_WAVEFORMATEXTENSIBLE)) {
+        ma_channel_mask_to_channel_map__win32(wf.dwChannelMask, pData->channelsOut, pData->channelMapOut);
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pData->channelMapOut, ma_countof(pData->channelMapOut), pData->channelsOut);
+    }
+
+    /* Period size. */
+    pData->periodsOut = (pData->periodsIn != 0) ? pData->periodsIn : MA_DEFAULT_PERIODS;
+    pData->periodSizeInFramesOut = pData->periodSizeInFramesIn;
+    if (pData->periodSizeInFramesOut == 0) {
+        if (pData->periodSizeInMillisecondsIn == 0) {
+            if (pData->performanceProfile == ma_performance_profile_low_latency) {
+                pData->periodSizeInFramesOut = ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY, wf.nSamplesPerSec);
+            } else {
+                pData->periodSizeInFramesOut = ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE, wf.nSamplesPerSec);
+            }
+        } else {
+            pData->periodSizeInFramesOut = ma_calculate_buffer_size_in_frames_from_milliseconds(pData->periodSizeInMillisecondsIn, wf.nSamplesPerSec);
+        }
+    }
+
+    periodDurationInMicroseconds = ((ma_uint64)pData->periodSizeInFramesOut * 1000 * 1000) / wf.nSamplesPerSec;
+
+
+    /* Slightly different initialization for shared and exclusive modes. We try exclusive mode first, and if it fails, fall back to shared mode. */
+    if (shareMode == MA_AUDCLNT_SHAREMODE_EXCLUSIVE) {
+        MA_REFERENCE_TIME bufferDuration = periodDurationInMicroseconds * pData->periodsOut * 10;
+
+        /*
+        If the periodicity is too small, Initialize() will fail with AUDCLNT_E_INVALID_DEVICE_PERIOD. In this case we should just keep increasing
+        it and trying it again.
+        */
+        hr = E_FAIL;
+        for (;;) {
+            hr = ma_IAudioClient_Initialize((ma_IAudioClient*)pData->pAudioClient, shareMode, streamFlags, bufferDuration, bufferDuration, (MA_WAVEFORMATEX*)&wf, NULL);
+            if (hr == MA_AUDCLNT_E_INVALID_DEVICE_PERIOD) {
+                if (bufferDuration > 500*10000) {
+                    break;
+                } else {
+                    if (bufferDuration == 0) {  /* <-- Just a sanity check to prevent an infinite loop. Should never happen, but it makes me feel better. */
+                        break;
+                    }
+
+                    bufferDuration = bufferDuration * 2;
+                    continue;
+                }
+            } else {
+                break;
+            }
+        }
+
+        if (hr == MA_AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED) {
+            ma_uint32 bufferSizeInFrames;
+            hr = ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pData->pAudioClient, &bufferSizeInFrames);
+            if (SUCCEEDED(hr)) {
+                bufferDuration = (MA_REFERENCE_TIME)((10000.0 * 1000 / wf.nSamplesPerSec * bufferSizeInFrames) + 0.5);
+
+                /* Unfortunately we need to release and re-acquire the audio client according to MSDN. Seems silly - why not just call IAudioClient_Initialize() again?! */
+                ma_IAudioClient_Release((ma_IAudioClient*)pData->pAudioClient);
+
+            #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+                hr = ma_IMMDevice_Activate(pDeviceInterface, &MA_IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&pData->pAudioClient);
+            #else
+                hr = ma_IUnknown_QueryInterface(pDeviceInterface, &MA_IID_IAudioClient, (void**)&pData->pAudioClient);
+            #endif
+
+                if (SUCCEEDED(hr)) {
+                    hr = ma_IAudioClient_Initialize((ma_IAudioClient*)pData->pAudioClient, shareMode, streamFlags, bufferDuration, bufferDuration, (MA_WAVEFORMATEX*)&wf, NULL);
+                }
+            }
+        }
+
+        if (FAILED(hr)) {
+            /* Failed to initialize in exclusive mode. Don't fall back to shared mode - instead tell the client about it. They can reinitialize in shared mode if they want. */
+            if (hr == E_ACCESSDENIED) {
+                errorMsg = "[WASAPI] Failed to initialize device in exclusive mode. Access denied.", result = MA_ACCESS_DENIED;
+            } else if (hr == MA_AUDCLNT_E_DEVICE_IN_USE) {
+                errorMsg = "[WASAPI] Failed to initialize device in exclusive mode. Device in use.", result = MA_BUSY;
+            } else {
+                errorMsg = "[WASAPI] Failed to initialize device in exclusive mode."; result = ma_result_from_HRESULT(hr);
+            }
+            goto done;
+        }
+    }
+
+    if (shareMode == MA_AUDCLNT_SHAREMODE_SHARED) {
+        /*
+        Low latency shared mode via IAudioClient3.
+
+        NOTE
+        ====
+        Contrary to the documentation on MSDN (https://docs.microsoft.com/en-us/windows/win32/api/audioclient/nf-audioclient-iaudioclient3-initializesharedaudiostream), the
+        use of AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM and AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY with IAudioClient3_InitializeSharedAudioStream() absolutely does not work. Using
+        any of these flags will result in HRESULT code 0x88890021. The other problem is that calling IAudioClient3_GetSharedModeEnginePeriod() with a sample rate different to
+        that returned by IAudioClient_GetMixFormat() also results in an error. I'm therefore disabling low-latency shared mode with AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM.
+        */
+        #ifndef MA_WASAPI_NO_LOW_LATENCY_SHARED_MODE
+        {
+            if ((streamFlags & MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM) == 0 || nativeSampleRate == wf.nSamplesPerSec) {
+                ma_IAudioClient3* pAudioClient3 = NULL;
+                hr = ma_IAudioClient_QueryInterface(pData->pAudioClient, &MA_IID_IAudioClient3, (void**)&pAudioClient3);
+                if (SUCCEEDED(hr)) {
+                    ma_uint32 defaultPeriodInFrames;
+                    ma_uint32 fundamentalPeriodInFrames;
+                    ma_uint32 minPeriodInFrames;
+                    ma_uint32 maxPeriodInFrames;
+                    hr = ma_IAudioClient3_GetSharedModeEnginePeriod(pAudioClient3, (MA_WAVEFORMATEX*)&wf, &defaultPeriodInFrames, &fundamentalPeriodInFrames, &minPeriodInFrames, &maxPeriodInFrames);
+                    if (SUCCEEDED(hr)) {
+                        ma_uint32 desiredPeriodInFrames = pData->periodSizeInFramesOut;
+                        ma_uint32 actualPeriodInFrames  = desiredPeriodInFrames;
+
+                        /* Make sure the period size is a multiple of fundamentalPeriodInFrames. */
+                        actualPeriodInFrames = actualPeriodInFrames / fundamentalPeriodInFrames;
+                        actualPeriodInFrames = actualPeriodInFrames * fundamentalPeriodInFrames;
+
+                        /* The period needs to be clamped between minPeriodInFrames and maxPeriodInFrames. */
+                        actualPeriodInFrames = ma_clamp(actualPeriodInFrames, minPeriodInFrames, maxPeriodInFrames);
+
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] Trying IAudioClient3_InitializeSharedAudioStream(actualPeriodInFrames=%d)\n", actualPeriodInFrames);
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    defaultPeriodInFrames=%d\n", defaultPeriodInFrames);
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    fundamentalPeriodInFrames=%d\n", fundamentalPeriodInFrames);
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    minPeriodInFrames=%d\n", minPeriodInFrames);
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    maxPeriodInFrames=%d\n", maxPeriodInFrames);
+
+                        /* If the client requested a largish buffer than we don't actually want to use low latency shared mode because it forces small buffers. */
+                        if (actualPeriodInFrames >= desiredPeriodInFrames) {
+                            /*
+                            MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | MA_AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY must not be in the stream flags. If either of these are specified,
+                            IAudioClient3_InitializeSharedAudioStream() will fail.
+                            */
+                            hr = ma_IAudioClient3_InitializeSharedAudioStream(pAudioClient3, streamFlags & ~(MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | MA_AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY), actualPeriodInFrames, (MA_WAVEFORMATEX*)&wf, NULL);
+                            if (SUCCEEDED(hr)) {
+                                wasInitializedUsingIAudioClient3 = MA_TRUE;
+                                pData->periodSizeInFramesOut = actualPeriodInFrames;
+
+                                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] Using IAudioClient3\n");
+                                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    periodSizeInFramesOut=%d\n", pData->periodSizeInFramesOut);
+                            } else {
+                                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] IAudioClient3_InitializeSharedAudioStream failed. Falling back to IAudioClient.\n");
+                            }
+                        } else {
+                            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] Not using IAudioClient3 because the desired period size is larger than the maximum supported by IAudioClient3.\n");
+                        }
+                    } else {
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] IAudioClient3_GetSharedModeEnginePeriod failed. Falling back to IAudioClient.\n");
+                    }
+
+                    ma_IAudioClient3_Release(pAudioClient3);
+                    pAudioClient3 = NULL;
+                }
+            }
+        }
+        #else
+        {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] Not using IAudioClient3 because MA_WASAPI_NO_LOW_LATENCY_SHARED_MODE is enabled.\n");
+        }
+        #endif
+
+        /* If we don't have an IAudioClient3 then we need to use the normal initialization routine. */
+        if (!wasInitializedUsingIAudioClient3) {
+            MA_REFERENCE_TIME bufferDuration = periodDurationInMicroseconds * pData->periodsOut * 10;   /* <-- Multiply by 10 for microseconds to 100-nanoseconds. */
+            hr = ma_IAudioClient_Initialize((ma_IAudioClient*)pData->pAudioClient, shareMode, streamFlags, bufferDuration, 0, (const MA_WAVEFORMATEX*)&wf, NULL);
+            if (FAILED(hr)) {
+                if (hr == E_ACCESSDENIED) {
+                    errorMsg = "[WASAPI] Failed to initialize device. Access denied.", result = MA_ACCESS_DENIED;
+                } else if (hr == MA_AUDCLNT_E_DEVICE_IN_USE) {
+                    errorMsg = "[WASAPI] Failed to initialize device. Device in use.", result = MA_BUSY;
+                } else {
+                    errorMsg = "[WASAPI] Failed to initialize device.", result = ma_result_from_HRESULT(hr);
+                }
+
+                goto done;
+            }
+        }
+    }
+
+    if (!wasInitializedUsingIAudioClient3) {
+        ma_uint32 bufferSizeInFrames = 0;
+        hr = ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pData->pAudioClient, &bufferSizeInFrames);
+        if (FAILED(hr)) {
+            errorMsg = "[WASAPI] Failed to get audio client's actual buffer size.", result = ma_result_from_HRESULT(hr);
+            goto done;
+        }
+
+        /*
+        When using process loopback mode, retrieval of the buffer size seems to result in totally
+        incorrect values. In this case we'll just assume it's the same size as what we requested
+        when we initialized the client.
+        */
+        if (usingProcessLoopback) {
+            bufferSizeInFrames = (ma_uint32)((periodDurationInMicroseconds * pData->periodsOut) * pData->sampleRateOut / 1000000);
+        }
+
+        pData->periodSizeInFramesOut = bufferSizeInFrames / pData->periodsOut;
+    }
+
+    pData->usingAudioClient3 = wasInitializedUsingIAudioClient3;
+
+
+    if (deviceType == ma_device_type_playback) {
+        result = ma_device_create_IAudioClient_service__wasapi(pContext, deviceType, (ma_IAudioClient*)pData->pAudioClient, (void**)&pData->pRenderClient);
+    } else {
+        result = ma_device_create_IAudioClient_service__wasapi(pContext, deviceType, (ma_IAudioClient*)pData->pAudioClient, (void**)&pData->pCaptureClient);
+    }
+
+    /*if (FAILED(hr)) {*/
+    if (result != MA_SUCCESS) {
+        errorMsg = "[WASAPI] Failed to get audio client service.";
+        goto done;
+    }
+
+
+    /* Grab the name of the device. */
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    {
+        ma_IPropertyStore *pProperties;
+        hr = ma_IMMDevice_OpenPropertyStore(pDeviceInterface, STGM_READ, &pProperties);
+        if (SUCCEEDED(hr)) {
+            MA_PROPVARIANT varName;
+            ma_PropVariantInit(&varName);
+            hr = ma_IPropertyStore_GetValue(pProperties, &MA_PKEY_Device_FriendlyName, &varName);
+            if (SUCCEEDED(hr)) {
+                WideCharToMultiByte(CP_UTF8, 0, varName.pwszVal, -1, pData->deviceName, sizeof(pData->deviceName), 0, FALSE);
+                ma_PropVariantClear(pContext, &varName);
+            }
+
+            ma_IPropertyStore_Release(pProperties);
+        }
+    }
+    #endif
+
+    /*
+    For the WASAPI backend we need to know the actual IDs of the device in order to do automatic
+    stream routing so that IDs can be compared and we can determine which device has been detached
+    and whether or not it matches with our ma_device.
+    */
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    {
+        /* Desktop */
+        ma_context_get_device_id_from_MMDevice__wasapi(pContext, pDeviceInterface, &pData->id);
+    }
+    #else
+    {
+        /* UWP */
+        /* TODO: Implement me. Need to figure out how to get the ID of the default device. */
+    }
+    #endif
+
+done:
+    /* Clean up. */
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    if (pDeviceInterface != NULL) {
+        ma_IMMDevice_Release(pDeviceInterface);
+    }
+#else
+    if (pDeviceInterface != NULL) {
+        ma_IUnknown_Release(pDeviceInterface);
+    }
+#endif
+
+    if (result != MA_SUCCESS) {
+        if (pData->pRenderClient) {
+            ma_IAudioRenderClient_Release((ma_IAudioRenderClient*)pData->pRenderClient);
+            pData->pRenderClient = NULL;
+        }
+        if (pData->pCaptureClient) {
+            ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pData->pCaptureClient);
+            pData->pCaptureClient = NULL;
+        }
+        if (pData->pAudioClient) {
+            ma_IAudioClient_Release((ma_IAudioClient*)pData->pAudioClient);
+            pData->pAudioClient = NULL;
+        }
+
+        if (errorMsg != NULL && errorMsg[0] != '\0') {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "%s\n", errorMsg);
+        }
+
+        return result;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+static ma_result ma_device_reinit__wasapi(ma_device* pDevice, ma_device_type deviceType)
+{
+    ma_device_init_internal_data__wasapi data;
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* We only re-initialize the playback or capture device. Never a full-duplex device. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+
+    /*
+    Before reinitializing the device we need to free the previous audio clients.
+
+    There's a known memory leak here. We will be calling this from the routing change callback that
+    is fired by WASAPI. If we attempt to release the IAudioClient we will deadlock. In my opinion
+    this is a bug. I'm not sure what I need to do to handle this cleanly, but I think we'll probably
+    need some system where we post an event, but delay the execution of it until the callback has
+    returned. I'm not sure how to do this reliably, however. I have set up some infrastructure for
+    a command thread which might be useful for this.
+    */
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_loopback) {
+        if (pDevice->wasapi.pCaptureClient) {
+            ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+            pDevice->wasapi.pCaptureClient = NULL;
+        }
+
+        if (pDevice->wasapi.pAudioClientCapture) {
+            /*ma_device_release_IAudioClient_service__wasapi(pDevice, ma_device_type_capture);*/
+            pDevice->wasapi.pAudioClientCapture = NULL;
+        }
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        if (pDevice->wasapi.pRenderClient) {
+            ma_IAudioRenderClient_Release((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient);
+            pDevice->wasapi.pRenderClient = NULL;
+        }
+
+        if (pDevice->wasapi.pAudioClientPlayback) {
+            /*ma_device_release_IAudioClient_service__wasapi(pDevice, ma_device_type_playback);*/
+            pDevice->wasapi.pAudioClientPlayback = NULL;
+        }
+    }
+
+
+    if (deviceType == ma_device_type_playback) {
+        data.formatIn               = pDevice->playback.format;
+        data.channelsIn             = pDevice->playback.channels;
+        MA_COPY_MEMORY(data.channelMapIn, pDevice->playback.channelMap, sizeof(pDevice->playback.channelMap));
+        data.shareMode              = pDevice->playback.shareMode;
+    } else {
+        data.formatIn               = pDevice->capture.format;
+        data.channelsIn             = pDevice->capture.channels;
+        MA_COPY_MEMORY(data.channelMapIn, pDevice->capture.channelMap, sizeof(pDevice->capture.channelMap));
+        data.shareMode              = pDevice->capture.shareMode;
+    }
+
+    data.sampleRateIn               = pDevice->sampleRate;
+    data.periodSizeInFramesIn       = pDevice->wasapi.originalPeriodSizeInFrames;
+    data.periodSizeInMillisecondsIn = pDevice->wasapi.originalPeriodSizeInMilliseconds;
+    data.periodsIn                  = pDevice->wasapi.originalPeriods;
+    data.performanceProfile         = pDevice->wasapi.originalPerformanceProfile;
+    data.noAutoConvertSRC           = pDevice->wasapi.noAutoConvertSRC;
+    data.noDefaultQualitySRC        = pDevice->wasapi.noDefaultQualitySRC;
+    data.noHardwareOffloading       = pDevice->wasapi.noHardwareOffloading;
+    data.loopbackProcessID          = pDevice->wasapi.loopbackProcessID;
+    data.loopbackProcessExclude     = pDevice->wasapi.loopbackProcessExclude;
+    result = ma_device_init_internal__wasapi(pDevice->pContext, deviceType, NULL, &data);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* At this point we have some new objects ready to go. We need to uninitialize the previous ones and then set the new ones. */
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_loopback) {
+        pDevice->wasapi.pAudioClientCapture         = data.pAudioClient;
+        pDevice->wasapi.pCaptureClient              = data.pCaptureClient;
+
+        pDevice->capture.internalFormat             = data.formatOut;
+        pDevice->capture.internalChannels           = data.channelsOut;
+        pDevice->capture.internalSampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDevice->capture.internalChannelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDevice->capture.internalPeriodSizeInFrames = data.periodSizeInFramesOut;
+        pDevice->capture.internalPeriods            = data.periodsOut;
+        ma_strcpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), data.deviceName);
+
+        ma_IAudioClient_SetEventHandle((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture, (HANDLE)pDevice->wasapi.hEventCapture);
+
+        pDevice->wasapi.periodSizeInFramesCapture = data.periodSizeInFramesOut;
+        ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture, &pDevice->wasapi.actualBufferSizeInFramesCapture);
+
+        /* We must always have a valid ID. */
+        ma_strcpy_s_WCHAR(pDevice->capture.id.wasapi, sizeof(pDevice->capture.id.wasapi), data.id.wasapi);
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        pDevice->wasapi.pAudioClientPlayback         = data.pAudioClient;
+        pDevice->wasapi.pRenderClient                = data.pRenderClient;
+
+        pDevice->playback.internalFormat             = data.formatOut;
+        pDevice->playback.internalChannels           = data.channelsOut;
+        pDevice->playback.internalSampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDevice->playback.internalChannelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDevice->playback.internalPeriodSizeInFrames = data.periodSizeInFramesOut;
+        pDevice->playback.internalPeriods            = data.periodsOut;
+        ma_strcpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), data.deviceName);
+
+        ma_IAudioClient_SetEventHandle((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, (HANDLE)pDevice->wasapi.hEventPlayback);
+
+        pDevice->wasapi.periodSizeInFramesPlayback = data.periodSizeInFramesOut;
+        ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, &pDevice->wasapi.actualBufferSizeInFramesPlayback);
+
+        /* We must always have a valid ID because rerouting will look at it. */
+        ma_strcpy_s_WCHAR(pDevice->playback.id.wasapi, sizeof(pDevice->playback.id.wasapi), data.id.wasapi);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__wasapi(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result = MA_SUCCESS;
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    HRESULT hr;
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+#endif
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->wasapi);
+    pDevice->wasapi.usage                  = pConfig->wasapi.usage;
+    pDevice->wasapi.noAutoConvertSRC       = pConfig->wasapi.noAutoConvertSRC;
+    pDevice->wasapi.noDefaultQualitySRC    = pConfig->wasapi.noDefaultQualitySRC;
+    pDevice->wasapi.noHardwareOffloading   = pConfig->wasapi.noHardwareOffloading;
+    pDevice->wasapi.loopbackProcessID      = pConfig->wasapi.loopbackProcessID;
+    pDevice->wasapi.loopbackProcessExclude = pConfig->wasapi.loopbackProcessExclude;
+
+    /* Exclusive mode is not allowed with loopback. */
+    if (pConfig->deviceType == ma_device_type_loopback && pConfig->playback.shareMode == ma_share_mode_exclusive) {
+        return MA_INVALID_DEVICE_CONFIG;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+        ma_device_init_internal_data__wasapi data;
+        data.formatIn                   = pDescriptorCapture->format;
+        data.channelsIn                 = pDescriptorCapture->channels;
+        data.sampleRateIn               = pDescriptorCapture->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDescriptorCapture->channelMap, sizeof(pDescriptorCapture->channelMap));
+        data.periodSizeInFramesIn       = pDescriptorCapture->periodSizeInFrames;
+        data.periodSizeInMillisecondsIn = pDescriptorCapture->periodSizeInMilliseconds;
+        data.periodsIn                  = pDescriptorCapture->periodCount;
+        data.shareMode                  = pDescriptorCapture->shareMode;
+        data.performanceProfile         = pConfig->performanceProfile;
+        data.noAutoConvertSRC           = pConfig->wasapi.noAutoConvertSRC;
+        data.noDefaultQualitySRC        = pConfig->wasapi.noDefaultQualitySRC;
+        data.noHardwareOffloading       = pConfig->wasapi.noHardwareOffloading;
+        data.loopbackProcessID          = pConfig->wasapi.loopbackProcessID;
+        data.loopbackProcessExclude     = pConfig->wasapi.loopbackProcessExclude;
+
+        result = ma_device_init_internal__wasapi(pDevice->pContext, (pConfig->deviceType == ma_device_type_loopback) ? ma_device_type_loopback : ma_device_type_capture, pDescriptorCapture->pDeviceID, &data);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pDevice->wasapi.pAudioClientCapture              = data.pAudioClient;
+        pDevice->wasapi.pCaptureClient                   = data.pCaptureClient;
+        pDevice->wasapi.originalPeriodSizeInMilliseconds = pDescriptorCapture->periodSizeInMilliseconds;
+        pDevice->wasapi.originalPeriodSizeInFrames       = pDescriptorCapture->periodSizeInFrames;
+        pDevice->wasapi.originalPeriods                  = pDescriptorCapture->periodCount;
+        pDevice->wasapi.originalPerformanceProfile       = pConfig->performanceProfile;
+
+        /*
+        The event for capture needs to be manual reset for the same reason as playback. We keep the initial state set to unsignaled,
+        however, because we want to block until we actually have something for the first call to ma_device_read().
+        */
+        pDevice->wasapi.hEventCapture = (ma_handle)CreateEventA(NULL, FALSE, FALSE, NULL);  /* Auto reset, unsignaled by default. */
+        if (pDevice->wasapi.hEventCapture == NULL) {
+            result = ma_result_from_GetLastError(GetLastError());
+
+            if (pDevice->wasapi.pCaptureClient != NULL) {
+                ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+                pDevice->wasapi.pCaptureClient = NULL;
+            }
+            if (pDevice->wasapi.pAudioClientCapture != NULL) {
+                ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+                pDevice->wasapi.pAudioClientCapture = NULL;
+            }
+
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create event for capture.");
+            return result;
+        }
+        ma_IAudioClient_SetEventHandle((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture, (HANDLE)pDevice->wasapi.hEventCapture);
+
+        pDevice->wasapi.periodSizeInFramesCapture = data.periodSizeInFramesOut;
+        ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture, &pDevice->wasapi.actualBufferSizeInFramesCapture);
+
+        /* We must always have a valid ID. */
+        ma_strcpy_s_WCHAR(pDevice->capture.id.wasapi, sizeof(pDevice->capture.id.wasapi), data.id.wasapi);
+
+        /* The descriptor needs to be updated with actual values. */
+        pDescriptorCapture->format             = data.formatOut;
+        pDescriptorCapture->channels           = data.channelsOut;
+        pDescriptorCapture->sampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDescriptorCapture->channelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDescriptorCapture->periodSizeInFrames = data.periodSizeInFramesOut;
+        pDescriptorCapture->periodCount        = data.periodsOut;
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_device_init_internal_data__wasapi data;
+        data.formatIn                   = pDescriptorPlayback->format;
+        data.channelsIn                 = pDescriptorPlayback->channels;
+        data.sampleRateIn               = pDescriptorPlayback->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDescriptorPlayback->channelMap, sizeof(pDescriptorPlayback->channelMap));
+        data.periodSizeInFramesIn       = pDescriptorPlayback->periodSizeInFrames;
+        data.periodSizeInMillisecondsIn = pDescriptorPlayback->periodSizeInMilliseconds;
+        data.periodsIn                  = pDescriptorPlayback->periodCount;
+        data.shareMode                  = pDescriptorPlayback->shareMode;
+        data.performanceProfile         = pConfig->performanceProfile;
+        data.noAutoConvertSRC           = pConfig->wasapi.noAutoConvertSRC;
+        data.noDefaultQualitySRC        = pConfig->wasapi.noDefaultQualitySRC;
+        data.noHardwareOffloading       = pConfig->wasapi.noHardwareOffloading;
+        data.loopbackProcessID          = pConfig->wasapi.loopbackProcessID;
+        data.loopbackProcessExclude     = pConfig->wasapi.loopbackProcessExclude;
+
+        result = ma_device_init_internal__wasapi(pDevice->pContext, ma_device_type_playback, pDescriptorPlayback->pDeviceID, &data);
+        if (result != MA_SUCCESS) {
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                if (pDevice->wasapi.pCaptureClient != NULL) {
+                    ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+                    pDevice->wasapi.pCaptureClient = NULL;
+                }
+                if (pDevice->wasapi.pAudioClientCapture != NULL) {
+                    ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+                    pDevice->wasapi.pAudioClientCapture = NULL;
+                }
+
+                CloseHandle((HANDLE)pDevice->wasapi.hEventCapture);
+                pDevice->wasapi.hEventCapture = NULL;
+            }
+            return result;
+        }
+
+        pDevice->wasapi.pAudioClientPlayback             = data.pAudioClient;
+        pDevice->wasapi.pRenderClient                    = data.pRenderClient;
+        pDevice->wasapi.originalPeriodSizeInMilliseconds = pDescriptorPlayback->periodSizeInMilliseconds;
+        pDevice->wasapi.originalPeriodSizeInFrames       = pDescriptorPlayback->periodSizeInFrames;
+        pDevice->wasapi.originalPeriods                  = pDescriptorPlayback->periodCount;
+        pDevice->wasapi.originalPerformanceProfile       = pConfig->performanceProfile;
+
+        /*
+        The event for playback is needs to be manual reset because we want to explicitly control the fact that it becomes signalled
+        only after the whole available space has been filled, never before.
+
+        The playback event also needs to be initially set to a signaled state so that the first call to ma_device_write() is able
+        to get passed WaitForMultipleObjects().
+        */
+        pDevice->wasapi.hEventPlayback = (ma_handle)CreateEventA(NULL, FALSE, TRUE, NULL);  /* Auto reset, signaled by default. */
+        if (pDevice->wasapi.hEventPlayback == NULL) {
+            result = ma_result_from_GetLastError(GetLastError());
+
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                if (pDevice->wasapi.pCaptureClient != NULL) {
+                    ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+                    pDevice->wasapi.pCaptureClient = NULL;
+                }
+                if (pDevice->wasapi.pAudioClientCapture != NULL) {
+                    ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+                    pDevice->wasapi.pAudioClientCapture = NULL;
+                }
+
+                CloseHandle((HANDLE)pDevice->wasapi.hEventCapture);
+                pDevice->wasapi.hEventCapture = NULL;
+            }
+
+            if (pDevice->wasapi.pRenderClient != NULL) {
+                ma_IAudioRenderClient_Release((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient);
+                pDevice->wasapi.pRenderClient = NULL;
+            }
+            if (pDevice->wasapi.pAudioClientPlayback != NULL) {
+                ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback);
+                pDevice->wasapi.pAudioClientPlayback = NULL;
+            }
+
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create event for playback.");
+            return result;
+        }
+        ma_IAudioClient_SetEventHandle((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, (HANDLE)pDevice->wasapi.hEventPlayback);
+
+        pDevice->wasapi.periodSizeInFramesPlayback = data.periodSizeInFramesOut;
+        ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, &pDevice->wasapi.actualBufferSizeInFramesPlayback);
+
+        /* We must always have a valid ID because rerouting will look at it. */
+        ma_strcpy_s_WCHAR(pDevice->playback.id.wasapi, sizeof(pDevice->playback.id.wasapi), data.id.wasapi);
+
+        /* The descriptor needs to be updated with actual values. */
+        pDescriptorPlayback->format             = data.formatOut;
+        pDescriptorPlayback->channels           = data.channelsOut;
+        pDescriptorPlayback->sampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDescriptorPlayback->channelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDescriptorPlayback->periodSizeInFrames = data.periodSizeInFramesOut;
+        pDescriptorPlayback->periodCount        = data.periodsOut;
+    }
+
+    /*
+    We need to register a notification client to detect when the device has been disabled, unplugged or re-routed (when the default device changes). When
+    we are connecting to the default device we want to do automatic stream routing when the device is disabled or unplugged. Otherwise we want to just
+    stop the device outright and let the application handle it.
+    */
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    if (pConfig->wasapi.noAutoStreamRouting == MA_FALSE) {
+        if ((pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) && pConfig->capture.pDeviceID == NULL) {
+            pDevice->wasapi.allowCaptureAutoStreamRouting = MA_TRUE;
+        }
+        if ((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pConfig->playback.pDeviceID == NULL) {
+            pDevice->wasapi.allowPlaybackAutoStreamRouting = MA_TRUE;
+        }
+    }
+
+    ma_mutex_init(&pDevice->wasapi.rerouteLock);
+
+    hr = ma_CoCreateInstance(pDevice->pContext, &MA_CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, &MA_IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator);
+    if (FAILED(hr)) {
+        ma_device_uninit__wasapi(pDevice);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create device enumerator.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    pDevice->wasapi.notificationClient.lpVtbl  = (void*)&g_maNotificationCientVtbl;
+    pDevice->wasapi.notificationClient.counter = 1;
+    pDevice->wasapi.notificationClient.pDevice = pDevice;
+
+    hr = pDeviceEnumerator->lpVtbl->RegisterEndpointNotificationCallback(pDeviceEnumerator, &pDevice->wasapi.notificationClient);
+    if (SUCCEEDED(hr)) {
+        pDevice->wasapi.pDeviceEnumerator = (ma_ptr)pDeviceEnumerator;
+    } else {
+        /* Not the end of the world if we fail to register the notification callback. We just won't support automatic stream routing. */
+        ma_IMMDeviceEnumerator_Release(pDeviceEnumerator);
+    }
+#endif
+
+    ma_atomic_bool32_set(&pDevice->wasapi.isStartedCapture,  MA_FALSE);
+    ma_atomic_bool32_set(&pDevice->wasapi.isStartedPlayback, MA_FALSE);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device__get_available_frames__wasapi(ma_device* pDevice, ma_IAudioClient* pAudioClient, ma_uint32* pFrameCount)
+{
+    ma_uint32 paddingFramesCount;
+    HRESULT hr;
+    ma_share_mode shareMode;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pFrameCount != NULL);
+
+    *pFrameCount = 0;
+
+    if ((ma_ptr)pAudioClient != pDevice->wasapi.pAudioClientPlayback && (ma_ptr)pAudioClient != pDevice->wasapi.pAudioClientCapture) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    I've had a report that GetCurrentPadding() is returning a frame count of 0 which is preventing
+    higher level function calls from doing anything because it thinks nothing is available. I have
+    taken a look at the documentation and it looks like this is unnecessary in exclusive mode.
+
+    From Microsoft's documentation:
+
+        For an exclusive-mode rendering or capture stream that was initialized with the
+        AUDCLNT_STREAMFLAGS_EVENTCALLBACK flag, the client typically has no use for the padding
+        value reported by GetCurrentPadding. Instead, the client accesses an entire buffer during
+        each processing pass.
+
+    Considering this, I'm going to skip GetCurrentPadding() for exclusive mode and just report the
+    entire buffer. This depends on the caller making sure they wait on the event handler.
+    */
+    shareMode = ((ma_ptr)pAudioClient == pDevice->wasapi.pAudioClientPlayback) ? pDevice->playback.shareMode : pDevice->capture.shareMode;
+    if (shareMode == ma_share_mode_shared) {
+        /* Shared mode. */
+        hr = ma_IAudioClient_GetCurrentPadding(pAudioClient, &paddingFramesCount);
+        if (FAILED(hr)) {
+            return ma_result_from_HRESULT(hr);
+        }
+
+        if ((ma_ptr)pAudioClient == pDevice->wasapi.pAudioClientPlayback) {
+            *pFrameCount = pDevice->wasapi.actualBufferSizeInFramesPlayback - paddingFramesCount;
+        } else {
+            *pFrameCount = paddingFramesCount;
+        }
+    } else {
+        /* Exclusive mode. */
+        if ((ma_ptr)pAudioClient == pDevice->wasapi.pAudioClientPlayback) {
+            *pFrameCount = pDevice->wasapi.actualBufferSizeInFramesPlayback;
+        } else {
+            *pFrameCount = pDevice->wasapi.actualBufferSizeInFramesCapture;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_reroute__wasapi(ma_device* pDevice, ma_device_type deviceType)
+{
+    ma_result result;
+
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "=== CHANGING DEVICE ===\n");
+
+    result = ma_device_reinit__wasapi(pDevice, deviceType);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[WASAPI] Reinitializing device after route change failed.\n");
+        return result;
+    }
+
+    ma_device__post_init_setup(pDevice, deviceType);
+    ma_device__on_notification_rerouted(pDevice);
+
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "=== DEVICE CHANGED ===\n");
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__wasapi_nolock(ma_device* pDevice)
+{
+    HRESULT hr;
+
+    if (pDevice->pContext->wasapi.hAvrt) {
+        const char* pTaskName = ma_to_usage_string__wasapi(pDevice->wasapi.usage);
+        if (pTaskName) {
+            DWORD idx = 0;
+            pDevice->wasapi.hAvrtHandle = (ma_handle)((MA_PFN_AvSetMmThreadCharacteristicsA)pDevice->pContext->wasapi.AvSetMmThreadCharacteristicsA)(pTaskName, &idx);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        hr = ma_IAudioClient_Start((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+        if (FAILED(hr)) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to start internal capture device. HRESULT = %d.", (int)hr);
+            return ma_result_from_HRESULT(hr);
+        }
+
+        ma_atomic_bool32_set(&pDevice->wasapi.isStartedCapture, MA_TRUE);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        hr = ma_IAudioClient_Start((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback);
+        if (FAILED(hr)) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to start internal playback device. HRESULT = %d.", (int)hr);
+            return ma_result_from_HRESULT(hr);
+        }
+
+        ma_atomic_bool32_set(&pDevice->wasapi.isStartedPlayback, MA_TRUE);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__wasapi(ma_device* pDevice)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* Wait for any rerouting to finish before attempting to start the device. */
+    ma_mutex_lock(&pDevice->wasapi.rerouteLock);
+    {
+        result = ma_device_start__wasapi_nolock(pDevice);
+    }
+    ma_mutex_unlock(&pDevice->wasapi.rerouteLock);
+
+    return result;
+}
+
+static ma_result ma_device_stop__wasapi_nolock(ma_device* pDevice)
+{
+    ma_result result;
+    HRESULT hr;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->wasapi.hAvrtHandle) {
+        ((MA_PFN_AvRevertMmThreadCharacteristics)pDevice->pContext->wasapi.AvRevertMmThreadcharacteristics)((HANDLE)pDevice->wasapi.hAvrtHandle);
+        pDevice->wasapi.hAvrtHandle = NULL;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        /* If we have a mapped buffer we need to release it. */
+        if (pDevice->wasapi.pMappedBufferCapture != NULL) {
+            ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+            pDevice->wasapi.pMappedBufferCapture = NULL;
+            pDevice->wasapi.mappedBufferCaptureCap = 0;
+            pDevice->wasapi.mappedBufferCaptureLen = 0;
+        }
+
+        hr = ma_IAudioClient_Stop((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to stop internal capture device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* The audio client needs to be reset otherwise restarting will fail. */
+        hr = ma_IAudioClient_Reset((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to reset internal capture device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        ma_atomic_bool32_set(&pDevice->wasapi.isStartedCapture, MA_FALSE);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->wasapi.pMappedBufferPlayback != NULL) {
+            ma_silence_pcm_frames(
+                ma_offset_pcm_frames_ptr(pDevice->wasapi.pMappedBufferPlayback, pDevice->wasapi.mappedBufferPlaybackLen, pDevice->playback.internalFormat, pDevice->playback.internalChannels),
+                pDevice->wasapi.mappedBufferPlaybackCap - pDevice->wasapi.mappedBufferPlaybackLen,
+                pDevice->playback.internalFormat, pDevice->playback.internalChannels
+            );
+            ma_IAudioRenderClient_ReleaseBuffer((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient, pDevice->wasapi.mappedBufferPlaybackCap, 0);
+            pDevice->wasapi.pMappedBufferPlayback = NULL;
+            pDevice->wasapi.mappedBufferPlaybackCap = 0;
+            pDevice->wasapi.mappedBufferPlaybackLen = 0;
+        }
+
+        /*
+        The buffer needs to be drained before stopping the device. Not doing this will result in the last few frames not getting output to
+        the speakers. This is a problem for very short sounds because it'll result in a significant portion of it not getting played.
+        */
+        if (ma_atomic_bool32_get(&pDevice->wasapi.isStartedPlayback)) {
+            /* We need to make sure we put a timeout here or else we'll risk getting stuck in a deadlock in some cases. */
+            DWORD waitTime = (pDevice->wasapi.actualBufferSizeInFramesPlayback * 1000) / pDevice->playback.internalSampleRate;
+
+            if (pDevice->playback.shareMode == ma_share_mode_exclusive) {
+                WaitForSingleObject((HANDLE)pDevice->wasapi.hEventPlayback, waitTime);
+            } else {
+                ma_uint32 prevFramesAvailablePlayback = (ma_uint32)-1;
+                ma_uint32 framesAvailablePlayback;
+                for (;;) {
+                    result = ma_device__get_available_frames__wasapi(pDevice, (ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, &framesAvailablePlayback);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    if (framesAvailablePlayback >= pDevice->wasapi.actualBufferSizeInFramesPlayback) {
+                        break;
+                    }
+
+                    /*
+                    Just a safety check to avoid an infinite loop. If this iteration results in a situation where the number of available frames
+                    has not changed, get out of the loop. I don't think this should ever happen, but I think it's nice to have just in case.
+                    */
+                    if (framesAvailablePlayback == prevFramesAvailablePlayback) {
+                        break;
+                    }
+                    prevFramesAvailablePlayback = framesAvailablePlayback;
+
+                    ResetEvent((HANDLE)pDevice->wasapi.hEventPlayback); /* Manual reset. */
+                    WaitForSingleObject((HANDLE)pDevice->wasapi.hEventPlayback, waitTime);
+                }
+            }
+        }
+
+        hr = ma_IAudioClient_Stop((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to stop internal playback device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* The audio client needs to be reset otherwise restarting will fail. */
+        {
+            ma_int32 retries = 5;
+
+            while ((hr = ma_IAudioClient_Reset((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback)) == MA_AUDCLNT_E_BUFFER_OPERATION_PENDING && retries > 0) {
+                ma_sleep(10);
+                retries -= 1;
+            }
+        }
+
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to reset internal playback device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        ma_atomic_bool32_set(&pDevice->wasapi.isStartedPlayback, MA_FALSE);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__wasapi(ma_device* pDevice)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* Wait for any rerouting to finish before attempting to stop the device. */
+    ma_mutex_lock(&pDevice->wasapi.rerouteLock);
+    {
+        result = ma_device_stop__wasapi_nolock(pDevice);
+    }
+    ma_mutex_unlock(&pDevice->wasapi.rerouteLock);
+
+    return result;
+}
+
+
+#ifndef MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS
+#define MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS 5000
+#endif
+
+static ma_result ma_device_read__wasapi(ma_device* pDevice, void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 totalFramesProcessed = 0;
+
+    /*
+    When reading, we need to get a buffer and process all of it before releasing it. Because the
+    frame count (frameCount) can be different to the size of the buffer, we'll need to cache the
+    pointer to the buffer.
+    */
+
+    /* Keep running until we've processed the requested number of frames. */
+    while (ma_device_get_state(pDevice) == ma_device_state_started && totalFramesProcessed < frameCount) {
+        ma_uint32 framesRemaining = frameCount - totalFramesProcessed;
+
+        /* If we have a mapped data buffer, consume that first. */
+        if (pDevice->wasapi.pMappedBufferCapture != NULL) {
+            /* We have a cached data pointer so consume that before grabbing another one from WASAPI. */
+            ma_uint32 framesToProcessNow = framesRemaining;
+            if (framesToProcessNow > pDevice->wasapi.mappedBufferCaptureLen) {
+                framesToProcessNow = pDevice->wasapi.mappedBufferCaptureLen;
+            }
+
+            /* Now just copy the data over to the output buffer. */
+            ma_copy_pcm_frames(
+                ma_offset_pcm_frames_ptr(pFrames, totalFramesProcessed, pDevice->capture.internalFormat, pDevice->capture.internalChannels),
+                ma_offset_pcm_frames_const_ptr(pDevice->wasapi.pMappedBufferCapture, pDevice->wasapi.mappedBufferCaptureCap - pDevice->wasapi.mappedBufferCaptureLen, pDevice->capture.internalFormat, pDevice->capture.internalChannels),
+                framesToProcessNow,
+                pDevice->capture.internalFormat, pDevice->capture.internalChannels
+            );
+
+            totalFramesProcessed                   += framesToProcessNow;
+            pDevice->wasapi.mappedBufferCaptureLen -= framesToProcessNow;
+
+            /* If the data buffer has been fully consumed we need to release it. */
+            if (pDevice->wasapi.mappedBufferCaptureLen == 0) {
+                ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+                pDevice->wasapi.pMappedBufferCapture   = NULL;
+                pDevice->wasapi.mappedBufferCaptureCap = 0;
+            }
+        } else {
+            /* We don't have any cached data pointer, so grab another one. */
+            HRESULT hr;
+            DWORD flags = 0;
+
+            /* First just ask WASAPI for a data buffer. If it's not available, we'll wait for more. */
+            hr = ma_IAudioCaptureClient_GetBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, (BYTE**)&pDevice->wasapi.pMappedBufferCapture, &pDevice->wasapi.mappedBufferCaptureCap, &flags, NULL, NULL);
+            if (hr == S_OK) {
+                /* We got a data buffer. Continue to the next loop iteration which will then read from the mapped pointer. */
+                pDevice->wasapi.mappedBufferCaptureLen = pDevice->wasapi.mappedBufferCaptureCap;
+
+                /*
+                There have been reports that indicate that at times the AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY is reported for every
+                call to IAudioCaptureClient_GetBuffer() above which results in spamming of the debug messages below. To partially
+                work around this, I'm only outputting these messages when MA_DEBUG_OUTPUT is explicitly defined. The better solution
+                would be to figure out why the flag is always getting reported.
+                */
+                #if defined(MA_DEBUG_OUTPUT)
+                {
+                    if (flags != 0) {
+                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Capture Flags: %ld\n", flags);
+
+                        if ((flags & MA_AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY) != 0) {
+                            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity (possible overrun). Attempting recovery. mappedBufferCaptureCap=%d\n", pDevice->wasapi.mappedBufferCaptureCap);
+                        }
+                    }
+                }
+                #endif
+
+                /* Overrun detection. */
+                if ((flags & MA_AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY) != 0) {
+                    /* Glitched. Probably due to an overrun. */
+
+                    /*
+                    If we got an overrun it probably means we're straddling the end of the buffer. In normal capture
+                    mode this is the fault of the client application because they're responsible for ensuring data is
+                    processed fast enough. In duplex mode, however, the processing of audio is tied to the playback
+                    device, so this can possibly be the result of a timing de-sync.
+
+                    In capture mode we're not going to do any kind of recovery because the real fix is for the client
+                    application to process faster. In duplex mode, we'll treat this as a desync and reset the buffers
+                    to prevent a never-ending sequence of glitches due to straddling the end of the buffer.
+                    */
+                    if (pDevice->type == ma_device_type_duplex) {
+                        /*
+                        Experiment:
+
+                        If we empty out the *entire* buffer we may end up putting ourselves into an underrun position
+                        which isn't really any better than the overrun we're probably in right now. Instead we'll just
+                        empty out about half.
+                        */
+                        ma_uint32 i;
+                        ma_uint32 periodCount = (pDevice->wasapi.actualBufferSizeInFramesCapture / pDevice->wasapi.periodSizeInFramesCapture);
+                        ma_uint32 iterationCount = periodCount / 2;
+                        if ((periodCount % 2) > 0) {
+                            iterationCount += 1;
+                        }
+
+                        for (i = 0; i < iterationCount; i += 1) {
+                            hr = ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+                            if (FAILED(hr)) {
+                                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity recovery: IAudioCaptureClient_ReleaseBuffer() failed with %ld.\n", hr);
+                                break;
+                            }
+
+                            flags = 0;
+                            hr = ma_IAudioCaptureClient_GetBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, (BYTE**)&pDevice->wasapi.pMappedBufferCapture, &pDevice->wasapi.mappedBufferCaptureCap, &flags, NULL, NULL);
+                            if (hr == MA_AUDCLNT_S_BUFFER_EMPTY || FAILED(hr)) {
+                                /*
+                                The buffer has been completely emptied or an error occurred. In this case we'll need
+                                to reset the state of the mapped buffer which will trigger the next iteration to get
+                                a fresh buffer from WASAPI.
+                                */
+                                pDevice->wasapi.pMappedBufferCapture   = NULL;
+                                pDevice->wasapi.mappedBufferCaptureCap = 0;
+                                pDevice->wasapi.mappedBufferCaptureLen = 0;
+
+                                if (hr == MA_AUDCLNT_S_BUFFER_EMPTY) {
+                                    if ((flags & MA_AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY) != 0) {
+                                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity recovery: Buffer emptied, and data discontinuity still reported.\n");
+                                    } else {
+                                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity recovery: Buffer emptied.\n");
+                                    }
+                                }
+
+                                if (FAILED(hr)) {
+                                    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity recovery: IAudioCaptureClient_GetBuffer() failed with %ld.\n", hr);
+                                }
+
+                                break;
+                            }
+                        }
+
+                        /* If at this point we have a valid buffer mapped, make sure the buffer length is set appropriately. */
+                        if (pDevice->wasapi.pMappedBufferCapture != NULL) {
+                            pDevice->wasapi.mappedBufferCaptureLen = pDevice->wasapi.mappedBufferCaptureCap;
+                        }
+                    }
+                }
+
+                continue;
+            } else {
+                if (hr == MA_AUDCLNT_S_BUFFER_EMPTY || hr == MA_AUDCLNT_E_BUFFER_ERROR) {
+                    /*
+                    No data is available. We need to wait for more. There's two situations to consider
+                    here. The first is normal capture mode. If this times out it probably means the
+                    microphone isn't delivering data for whatever reason. In this case we'll just
+                    abort the read and return whatever we were able to get. The other situations is
+                    loopback mode, in which case a timeout probably just means the nothing is playing
+                    through the speakers.
+                    */
+
+                    /* Experiment: Use a shorter timeout for loopback mode. */
+                    DWORD timeoutInMilliseconds = MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS;
+                    if (pDevice->type == ma_device_type_loopback) {
+                        timeoutInMilliseconds = 10;
+                    }
+
+                    if (WaitForSingleObject((HANDLE)pDevice->wasapi.hEventCapture, timeoutInMilliseconds) != WAIT_OBJECT_0) {
+                        if (pDevice->type == ma_device_type_loopback) {
+                            continue;   /* Keep waiting in loopback mode. */
+                        } else {
+                            result = MA_ERROR;
+                            break;      /* Wait failed. */
+                        }
+                    }
+
+                    /* At this point we should be able to loop back to the start of the loop and try retrieving a data buffer again. */
+                } else {
+                    /* An error occurred and we need to abort. */
+                    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to retrieve internal buffer from capture device in preparation for reading from the device. HRESULT = %d. Stopping device.\n", (int)hr);
+                    result = ma_result_from_HRESULT(hr);
+                    break;
+                }
+            }
+        }
+    }
+
+    /*
+    If we were unable to process the entire requested frame count, but we still have a mapped buffer,
+    there's a good chance either an error occurred or the device was stopped mid-read. In this case
+    we'll need to make sure the buffer is released.
+    */
+    if (totalFramesProcessed < frameCount && pDevice->wasapi.pMappedBufferCapture != NULL) {
+        ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+        pDevice->wasapi.pMappedBufferCapture   = NULL;
+        pDevice->wasapi.mappedBufferCaptureCap = 0;
+        pDevice->wasapi.mappedBufferCaptureLen = 0;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesProcessed;
+    }
+
+    return result;
+}
+
+static ma_result ma_device_write__wasapi(ma_device* pDevice, const void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 totalFramesProcessed = 0;
+
+    /* Keep writing to the device until it's stopped or we've consumed all of our input. */
+    while (ma_device_get_state(pDevice) == ma_device_state_started && totalFramesProcessed < frameCount) {
+        ma_uint32 framesRemaining = frameCount - totalFramesProcessed;
+
+        /*
+        We're going to do this in a similar way to capture. We'll first check if the cached data pointer
+        is valid, and if so, read from that. Otherwise We will call IAudioRenderClient_GetBuffer() with
+        a requested buffer size equal to our actual period size. If it returns AUDCLNT_E_BUFFER_TOO_LARGE
+        it means we need to wait for some data to become available.
+        */
+        if (pDevice->wasapi.pMappedBufferPlayback != NULL) {
+            /* We still have some space available in the mapped data buffer. Write to it. */
+            ma_uint32 framesToProcessNow = framesRemaining;
+            if (framesToProcessNow > (pDevice->wasapi.mappedBufferPlaybackCap - pDevice->wasapi.mappedBufferPlaybackLen)) {
+                framesToProcessNow = (pDevice->wasapi.mappedBufferPlaybackCap - pDevice->wasapi.mappedBufferPlaybackLen);
+            }
+
+            /* Now just copy the data over to the output buffer. */
+            ma_copy_pcm_frames(
+                ma_offset_pcm_frames_ptr(pDevice->wasapi.pMappedBufferPlayback, pDevice->wasapi.mappedBufferPlaybackLen, pDevice->playback.internalFormat, pDevice->playback.internalChannels),
+                ma_offset_pcm_frames_const_ptr(pFrames, totalFramesProcessed, pDevice->playback.internalFormat, pDevice->playback.internalChannels),
+                framesToProcessNow,
+                pDevice->playback.internalFormat, pDevice->playback.internalChannels
+            );
+
+            totalFramesProcessed                    += framesToProcessNow;
+            pDevice->wasapi.mappedBufferPlaybackLen += framesToProcessNow;
+
+            /* If the data buffer has been fully consumed we need to release it. */
+            if (pDevice->wasapi.mappedBufferPlaybackLen == pDevice->wasapi.mappedBufferPlaybackCap) {
+                ma_IAudioRenderClient_ReleaseBuffer((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient, pDevice->wasapi.mappedBufferPlaybackCap, 0);
+                pDevice->wasapi.pMappedBufferPlayback   = NULL;
+                pDevice->wasapi.mappedBufferPlaybackCap = 0;
+                pDevice->wasapi.mappedBufferPlaybackLen = 0;
+
+                /*
+                In exclusive mode we need to wait here. Exclusive mode is weird because GetBuffer() never
+                seems to return AUDCLNT_E_BUFFER_TOO_LARGE, which is what we normally use to determine
+                whether or not we need to wait for more data.
+                */
+                if (pDevice->playback.shareMode == ma_share_mode_exclusive) {
+                    if (WaitForSingleObject((HANDLE)pDevice->wasapi.hEventPlayback, MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS) != WAIT_OBJECT_0) {
+                        result = MA_ERROR;
+                        break;   /* Wait failed. Probably timed out. */
+                    }
+                }
+            }
+        } else {
+            /* We don't have a mapped data buffer so we'll need to get one. */
+            HRESULT hr;
+            ma_uint32 bufferSizeInFrames;
+
+            /* Special rules for exclusive mode. */
+            if (pDevice->playback.shareMode == ma_share_mode_exclusive) {
+                bufferSizeInFrames = pDevice->wasapi.actualBufferSizeInFramesPlayback;
+            } else {
+                bufferSizeInFrames = pDevice->wasapi.periodSizeInFramesPlayback;
+            }
+
+            hr = ma_IAudioRenderClient_GetBuffer((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient, bufferSizeInFrames, (BYTE**)&pDevice->wasapi.pMappedBufferPlayback);
+            if (hr == S_OK) {
+                /* We have data available. */
+                pDevice->wasapi.mappedBufferPlaybackCap = bufferSizeInFrames;
+                pDevice->wasapi.mappedBufferPlaybackLen = 0;
+            } else {
+                if (hr == MA_AUDCLNT_E_BUFFER_TOO_LARGE || hr == MA_AUDCLNT_E_BUFFER_ERROR) {
+                    /* Not enough data available. We need to wait for more. */
+                    if (WaitForSingleObject((HANDLE)pDevice->wasapi.hEventPlayback, MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS) != WAIT_OBJECT_0) {
+                        result = MA_ERROR;
+                        break;   /* Wait failed. Probably timed out. */
+                    }
+                } else {
+                    /* Some error occurred. We'll need to abort. */
+                    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to retrieve internal buffer from playback device in preparation for writing to the device. HRESULT = %d. Stopping device.\n", (int)hr);
+                    result = ma_result_from_HRESULT(hr);
+                    break;
+                }
+            }
+        }
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = totalFramesProcessed;
+    }
+
+    return result;
+}
+
+static ma_result ma_device_data_loop_wakeup__wasapi(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        SetEvent((HANDLE)pDevice->wasapi.hEventCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        SetEvent((HANDLE)pDevice->wasapi.hEventPlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__wasapi(ma_context* pContext)
+{
+    ma_context_command__wasapi cmd = ma_context_init_command__wasapi(MA_CONTEXT_COMMAND_QUIT__WASAPI);
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_wasapi);
+
+    ma_context_post_command__wasapi(pContext, &cmd);
+    ma_thread_wait(&pContext->wasapi.commandThread);
+
+    if (pContext->wasapi.hAvrt) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->wasapi.hAvrt);
+        pContext->wasapi.hAvrt = NULL;
+    }
+
+    #if defined(MA_WIN32_UWP)
+    {
+        if (pContext->wasapi.hMMDevapi) {
+            ma_dlclose(ma_context_get_log(pContext), pContext->wasapi.hMMDevapi);
+            pContext->wasapi.hMMDevapi = NULL;
+        }
+    }
+    #endif
+
+    /* Only after the thread has been terminated can we uninitialize the sync objects for the command thread. */
+    ma_semaphore_uninit(&pContext->wasapi.commandSem);
+    ma_mutex_uninit(&pContext->wasapi.commandLock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__wasapi(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    ma_result result = MA_SUCCESS;
+
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+#ifdef MA_WIN32_DESKTOP
+    /*
+    WASAPI is only supported in Vista SP1 and newer. The reason for SP1 and not the base version of Vista is that event-driven
+    exclusive mode does not work until SP1.
+
+    Unfortunately older compilers don't define these functions so we need to dynamically load them in order to avoid a link error.
+    */
+    {
+        ma_OSVERSIONINFOEXW osvi;
+        ma_handle kernel32DLL;
+        ma_PFNVerifyVersionInfoW _VerifyVersionInfoW;
+        ma_PFNVerSetConditionMask _VerSetConditionMask;
+
+        kernel32DLL = ma_dlopen(ma_context_get_log(pContext), "kernel32.dll");
+        if (kernel32DLL == NULL) {
+            return MA_NO_BACKEND;
+        }
+
+        _VerifyVersionInfoW  = (ma_PFNVerifyVersionInfoW )ma_dlsym(ma_context_get_log(pContext), kernel32DLL, "VerifyVersionInfoW");
+        _VerSetConditionMask = (ma_PFNVerSetConditionMask)ma_dlsym(ma_context_get_log(pContext), kernel32DLL, "VerSetConditionMask");
+        if (_VerifyVersionInfoW == NULL || _VerSetConditionMask == NULL) {
+            ma_dlclose(ma_context_get_log(pContext), kernel32DLL);
+            return MA_NO_BACKEND;
+        }
+
+        MA_ZERO_OBJECT(&osvi);
+        osvi.dwOSVersionInfoSize = sizeof(osvi);
+        osvi.dwMajorVersion = ((MA_WIN32_WINNT_VISTA >> 8) & 0xFF);
+        osvi.dwMinorVersion = ((MA_WIN32_WINNT_VISTA >> 0) & 0xFF);
+        osvi.wServicePackMajor = 1;
+        if (_VerifyVersionInfoW(&osvi, MA_VER_MAJORVERSION | MA_VER_MINORVERSION | MA_VER_SERVICEPACKMAJOR, _VerSetConditionMask(_VerSetConditionMask(_VerSetConditionMask(0, MA_VER_MAJORVERSION, MA_VER_GREATER_EQUAL), MA_VER_MINORVERSION, MA_VER_GREATER_EQUAL), MA_VER_SERVICEPACKMAJOR, MA_VER_GREATER_EQUAL))) {
+            result = MA_SUCCESS;
+        } else {
+            result = MA_NO_BACKEND;
+        }
+
+        ma_dlclose(ma_context_get_log(pContext), kernel32DLL);
+    }
+#endif
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    MA_ZERO_OBJECT(&pContext->wasapi);
+
+
+    #if defined(MA_WIN32_UWP)
+    {
+        /* Link to mmdevapi so we can get access to ActivateAudioInterfaceAsync(). */
+        pContext->wasapi.hMMDevapi = ma_dlopen(ma_context_get_log(pContext), "mmdevapi.dll");
+        if (pContext->wasapi.hMMDevapi) {
+            pContext->wasapi.ActivateAudioInterfaceAsync = ma_dlsym(ma_context_get_log(pContext), pContext->wasapi.hMMDevapi, "ActivateAudioInterfaceAsync");
+            if (pContext->wasapi.ActivateAudioInterfaceAsync == NULL) {
+                ma_dlclose(ma_context_get_log(pContext), pContext->wasapi.hMMDevapi);
+                return MA_NO_BACKEND;   /* ActivateAudioInterfaceAsync() could not be loaded. */
+            }
+        } else {
+            return MA_NO_BACKEND;   /* Failed to load mmdevapi.dll which is required for ActivateAudioInterfaceAsync() */
+        }
+    }
+    #endif
+
+    /* Optionally use the Avrt API to specify the audio thread's latency sensitivity requirements */
+    pContext->wasapi.hAvrt = ma_dlopen(ma_context_get_log(pContext), "avrt.dll");
+    if (pContext->wasapi.hAvrt) {
+        pContext->wasapi.AvSetMmThreadCharacteristicsA   = ma_dlsym(ma_context_get_log(pContext), pContext->wasapi.hAvrt, "AvSetMmThreadCharacteristicsA");
+        pContext->wasapi.AvRevertMmThreadcharacteristics = ma_dlsym(ma_context_get_log(pContext), pContext->wasapi.hAvrt, "AvRevertMmThreadCharacteristics");
+
+        /* If either function could not be found, disable use of avrt entirely. */
+        if (!pContext->wasapi.AvSetMmThreadCharacteristicsA || !pContext->wasapi.AvRevertMmThreadcharacteristics) {
+            pContext->wasapi.AvSetMmThreadCharacteristicsA   = NULL;
+            pContext->wasapi.AvRevertMmThreadcharacteristics = NULL;
+            ma_dlclose(ma_context_get_log(pContext), pContext->wasapi.hAvrt);
+            pContext->wasapi.hAvrt = NULL;
+        }
+    }
+
+
+    /*
+    Annoyingly, WASAPI does not allow you to release an IAudioClient object from a different thread
+    than the one that retrieved it with GetService(). This can result in a deadlock in two
+    situations:
+
+        1) When calling ma_device_uninit() from a different thread to ma_device_init(); and
+        2) When uninitializing and reinitializing the internal IAudioClient object in response to
+           automatic stream routing.
+
+    We could define ma_device_uninit() such that it must be called on the same thread as
+    ma_device_init(). We could also just not release the IAudioClient when performing automatic
+    stream routing to avoid the deadlock. Neither of these are acceptable solutions in my view so
+    we're going to have to work around this with a worker thread. This is not ideal, but I can't
+    think of a better way to do this.
+
+    More information about this can be found here:
+
+        https://docs.microsoft.com/en-us/windows/win32/api/audioclient/nn-audioclient-iaudiorenderclient
+
+    Note this section:
+
+        When releasing an IAudioRenderClient interface instance, the client must call the interface's
+        Release method from the same thread as the call to IAudioClient::GetService that created the
+        object.
+    */
+    {
+        result = ma_mutex_init(&pContext->wasapi.commandLock);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_semaphore_init(0, &pContext->wasapi.commandSem);
+        if (result != MA_SUCCESS) {
+            ma_mutex_uninit(&pContext->wasapi.commandLock);
+            return result;
+        }
+
+        result = ma_thread_create(&pContext->wasapi.commandThread, ma_thread_priority_normal, 0, ma_context_command_thread__wasapi, pContext, &pContext->allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            ma_semaphore_uninit(&pContext->wasapi.commandSem);
+            ma_mutex_uninit(&pContext->wasapi.commandLock);
+            return result;
+        }
+    }
+
+
+    pCallbacks->onContextInit             = ma_context_init__wasapi;
+    pCallbacks->onContextUninit           = ma_context_uninit__wasapi;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__wasapi;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__wasapi;
+    pCallbacks->onDeviceInit              = ma_device_init__wasapi;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__wasapi;
+    pCallbacks->onDeviceStart             = ma_device_start__wasapi;
+    pCallbacks->onDeviceStop              = ma_device_stop__wasapi;
+    pCallbacks->onDeviceRead              = ma_device_read__wasapi;
+    pCallbacks->onDeviceWrite             = ma_device_write__wasapi;
+    pCallbacks->onDeviceDataLoop          = NULL;
+    pCallbacks->onDeviceDataLoopWakeup    = ma_device_data_loop_wakeup__wasapi;
+
+    return MA_SUCCESS;
+}
+#endif
+
+/******************************************************************************
+
+DirectSound Backend
+
+******************************************************************************/
+#ifdef MA_HAS_DSOUND
+/*#include <dsound.h>*/
+
+/*static const GUID MA_GUID_IID_DirectSoundNotify = {0xb0210783, 0x89cd, 0x11d0, {0xaf, 0x08, 0x00, 0xa0, 0xc9, 0x25, 0xcd, 0x16}};*/
+
+/* miniaudio only uses priority or exclusive modes. */
+#define MA_DSSCL_NORMAL                 1
+#define MA_DSSCL_PRIORITY               2
+#define MA_DSSCL_EXCLUSIVE              3
+#define MA_DSSCL_WRITEPRIMARY           4
+
+#define MA_DSCAPS_PRIMARYMONO           0x00000001
+#define MA_DSCAPS_PRIMARYSTEREO         0x00000002
+#define MA_DSCAPS_PRIMARY8BIT           0x00000004
+#define MA_DSCAPS_PRIMARY16BIT          0x00000008
+#define MA_DSCAPS_CONTINUOUSRATE        0x00000010
+#define MA_DSCAPS_EMULDRIVER            0x00000020
+#define MA_DSCAPS_CERTIFIED             0x00000040
+#define MA_DSCAPS_SECONDARYMONO         0x00000100
+#define MA_DSCAPS_SECONDARYSTEREO       0x00000200
+#define MA_DSCAPS_SECONDARY8BIT         0x00000400
+#define MA_DSCAPS_SECONDARY16BIT        0x00000800
+
+#define MA_DSBCAPS_PRIMARYBUFFER        0x00000001
+#define MA_DSBCAPS_STATIC               0x00000002
+#define MA_DSBCAPS_LOCHARDWARE          0x00000004
+#define MA_DSBCAPS_LOCSOFTWARE          0x00000008
+#define MA_DSBCAPS_CTRL3D               0x00000010
+#define MA_DSBCAPS_CTRLFREQUENCY        0x00000020
+#define MA_DSBCAPS_CTRLPAN              0x00000040
+#define MA_DSBCAPS_CTRLVOLUME           0x00000080
+#define MA_DSBCAPS_CTRLPOSITIONNOTIFY   0x00000100
+#define MA_DSBCAPS_CTRLFX               0x00000200
+#define MA_DSBCAPS_STICKYFOCUS          0x00004000
+#define MA_DSBCAPS_GLOBALFOCUS          0x00008000
+#define MA_DSBCAPS_GETCURRENTPOSITION2  0x00010000
+#define MA_DSBCAPS_MUTE3DATMAXDISTANCE  0x00020000
+#define MA_DSBCAPS_LOCDEFER             0x00040000
+#define MA_DSBCAPS_TRUEPLAYPOSITION     0x00080000
+
+#define MA_DSBPLAY_LOOPING              0x00000001
+#define MA_DSBPLAY_LOCHARDWARE          0x00000002
+#define MA_DSBPLAY_LOCSOFTWARE          0x00000004
+#define MA_DSBPLAY_TERMINATEBY_TIME     0x00000008
+#define MA_DSBPLAY_TERMINATEBY_DISTANCE 0x00000010
+#define MA_DSBPLAY_TERMINATEBY_PRIORITY 0x00000020
+
+#define MA_DSBSTATUS_PLAYING            0x00000001
+#define MA_DSBSTATUS_BUFFERLOST         0x00000002
+#define MA_DSBSTATUS_LOOPING            0x00000004
+#define MA_DSBSTATUS_LOCHARDWARE        0x00000008
+#define MA_DSBSTATUS_LOCSOFTWARE        0x00000010
+#define MA_DSBSTATUS_TERMINATED         0x00000020
+
+#define MA_DSCBSTART_LOOPING            0x00000001
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwBufferBytes;
+    DWORD dwReserved;
+    MA_WAVEFORMATEX* lpwfxFormat;
+    GUID guid3DAlgorithm;
+} MA_DSBUFFERDESC;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwBufferBytes;
+    DWORD dwReserved;
+    MA_WAVEFORMATEX* lpwfxFormat;
+    DWORD dwFXCount;
+    void* lpDSCFXDesc;  /* <-- miniaudio doesn't use this, so set to void*. */
+} MA_DSCBUFFERDESC;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwMinSecondarySampleRate;
+    DWORD dwMaxSecondarySampleRate;
+    DWORD dwPrimaryBuffers;
+    DWORD dwMaxHwMixingAllBuffers;
+    DWORD dwMaxHwMixingStaticBuffers;
+    DWORD dwMaxHwMixingStreamingBuffers;
+    DWORD dwFreeHwMixingAllBuffers;
+    DWORD dwFreeHwMixingStaticBuffers;
+    DWORD dwFreeHwMixingStreamingBuffers;
+    DWORD dwMaxHw3DAllBuffers;
+    DWORD dwMaxHw3DStaticBuffers;
+    DWORD dwMaxHw3DStreamingBuffers;
+    DWORD dwFreeHw3DAllBuffers;
+    DWORD dwFreeHw3DStaticBuffers;
+    DWORD dwFreeHw3DStreamingBuffers;
+    DWORD dwTotalHwMemBytes;
+    DWORD dwFreeHwMemBytes;
+    DWORD dwMaxContigFreeHwMemBytes;
+    DWORD dwUnlockTransferRateHwBuffers;
+    DWORD dwPlayCpuOverheadSwBuffers;
+    DWORD dwReserved1;
+    DWORD dwReserved2;
+} MA_DSCAPS;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwBufferBytes;
+    DWORD dwUnlockTransferRate;
+    DWORD dwPlayCpuOverhead;
+} MA_DSBCAPS;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwFormats;
+    DWORD dwChannels;
+} MA_DSCCAPS;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwBufferBytes;
+    DWORD dwReserved;
+} MA_DSCBCAPS;
+
+typedef struct
+{
+    DWORD  dwOffset;
+    HANDLE hEventNotify;
+} MA_DSBPOSITIONNOTIFY;
+
+typedef struct ma_IDirectSound              ma_IDirectSound;
+typedef struct ma_IDirectSoundBuffer        ma_IDirectSoundBuffer;
+typedef struct ma_IDirectSoundCapture       ma_IDirectSoundCapture;
+typedef struct ma_IDirectSoundCaptureBuffer ma_IDirectSoundCaptureBuffer;
+typedef struct ma_IDirectSoundNotify        ma_IDirectSoundNotify;
+
+
+/*
+COM objects. The way these work is that you have a vtable (a list of function pointers, kind of
+like how C++ works internally), and then you have a structure with a single member, which is a
+pointer to the vtable. The vtable is where the methods of the object are defined. Methods need
+to be in a specific order, and parent classes need to have their methods declared first.
+*/
+
+/* IDirectSound */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSound* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSound* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSound* pThis);
+
+    /* IDirectSound */
+    HRESULT (STDMETHODCALLTYPE * CreateSoundBuffer)   (ma_IDirectSound* pThis, const MA_DSBUFFERDESC* pDSBufferDesc, ma_IDirectSoundBuffer** ppDSBuffer, void* pUnkOuter);
+    HRESULT (STDMETHODCALLTYPE * GetCaps)             (ma_IDirectSound* pThis, MA_DSCAPS* pDSCaps);
+    HRESULT (STDMETHODCALLTYPE * DuplicateSoundBuffer)(ma_IDirectSound* pThis, ma_IDirectSoundBuffer* pDSBufferOriginal, ma_IDirectSoundBuffer** ppDSBufferDuplicate);
+    HRESULT (STDMETHODCALLTYPE * SetCooperativeLevel) (ma_IDirectSound* pThis, HWND hwnd, DWORD dwLevel);
+    HRESULT (STDMETHODCALLTYPE * Compact)             (ma_IDirectSound* pThis);
+    HRESULT (STDMETHODCALLTYPE * GetSpeakerConfig)    (ma_IDirectSound* pThis, DWORD* pSpeakerConfig);
+    HRESULT (STDMETHODCALLTYPE * SetSpeakerConfig)    (ma_IDirectSound* pThis, DWORD dwSpeakerConfig);
+    HRESULT (STDMETHODCALLTYPE * Initialize)          (ma_IDirectSound* pThis, const GUID* pGuidDevice);
+} ma_IDirectSoundVtbl;
+struct ma_IDirectSound
+{
+    ma_IDirectSoundVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSound_QueryInterface(ma_IDirectSound* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSound_AddRef(ma_IDirectSound* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSound_Release(ma_IDirectSound* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSound_CreateSoundBuffer(ma_IDirectSound* pThis, const MA_DSBUFFERDESC* pDSBufferDesc, ma_IDirectSoundBuffer** ppDSBuffer, void* pUnkOuter) { return pThis->lpVtbl->CreateSoundBuffer(pThis, pDSBufferDesc, ppDSBuffer, pUnkOuter); }
+static MA_INLINE HRESULT ma_IDirectSound_GetCaps(ma_IDirectSound* pThis, MA_DSCAPS* pDSCaps)                            { return pThis->lpVtbl->GetCaps(pThis, pDSCaps); }
+static MA_INLINE HRESULT ma_IDirectSound_DuplicateSoundBuffer(ma_IDirectSound* pThis, ma_IDirectSoundBuffer* pDSBufferOriginal, ma_IDirectSoundBuffer** ppDSBufferDuplicate) { return pThis->lpVtbl->DuplicateSoundBuffer(pThis, pDSBufferOriginal, ppDSBufferDuplicate); }
+static MA_INLINE HRESULT ma_IDirectSound_SetCooperativeLevel(ma_IDirectSound* pThis, HWND hwnd, DWORD dwLevel)          { return pThis->lpVtbl->SetCooperativeLevel(pThis, hwnd, dwLevel); }
+static MA_INLINE HRESULT ma_IDirectSound_Compact(ma_IDirectSound* pThis)                                                { return pThis->lpVtbl->Compact(pThis); }
+static MA_INLINE HRESULT ma_IDirectSound_GetSpeakerConfig(ma_IDirectSound* pThis, DWORD* pSpeakerConfig)                { return pThis->lpVtbl->GetSpeakerConfig(pThis, pSpeakerConfig); }
+static MA_INLINE HRESULT ma_IDirectSound_SetSpeakerConfig(ma_IDirectSound* pThis, DWORD dwSpeakerConfig)                { return pThis->lpVtbl->SetSpeakerConfig(pThis, dwSpeakerConfig); }
+static MA_INLINE HRESULT ma_IDirectSound_Initialize(ma_IDirectSound* pThis, const GUID* pGuidDevice)                    { return pThis->lpVtbl->Initialize(pThis, pGuidDevice); }
+
+
+/* IDirectSoundBuffer */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSoundBuffer* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSoundBuffer* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSoundBuffer* pThis);
+
+    /* IDirectSoundBuffer */
+    HRESULT (STDMETHODCALLTYPE * GetCaps)           (ma_IDirectSoundBuffer* pThis, MA_DSBCAPS* pDSBufferCaps);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPosition)(ma_IDirectSoundBuffer* pThis, DWORD* pCurrentPlayCursor, DWORD* pCurrentWriteCursor);
+    HRESULT (STDMETHODCALLTYPE * GetFormat)         (ma_IDirectSoundBuffer* pThis, MA_WAVEFORMATEX* pFormat, DWORD dwSizeAllocated, DWORD* pSizeWritten);
+    HRESULT (STDMETHODCALLTYPE * GetVolume)         (ma_IDirectSoundBuffer* pThis, LONG* pVolume);
+    HRESULT (STDMETHODCALLTYPE * GetPan)            (ma_IDirectSoundBuffer* pThis, LONG* pPan);
+    HRESULT (STDMETHODCALLTYPE * GetFrequency)      (ma_IDirectSoundBuffer* pThis, DWORD* pFrequency);
+    HRESULT (STDMETHODCALLTYPE * GetStatus)         (ma_IDirectSoundBuffer* pThis, DWORD* pStatus);
+    HRESULT (STDMETHODCALLTYPE * Initialize)        (ma_IDirectSoundBuffer* pThis, ma_IDirectSound* pDirectSound, const MA_DSBUFFERDESC* pDSBufferDesc);
+    HRESULT (STDMETHODCALLTYPE * Lock)              (ma_IDirectSoundBuffer* pThis, DWORD dwOffset, DWORD dwBytes, void** ppAudioPtr1, DWORD* pAudioBytes1, void** ppAudioPtr2, DWORD* pAudioBytes2, DWORD dwFlags);
+    HRESULT (STDMETHODCALLTYPE * Play)              (ma_IDirectSoundBuffer* pThis, DWORD dwReserved1, DWORD dwPriority, DWORD dwFlags);
+    HRESULT (STDMETHODCALLTYPE * SetCurrentPosition)(ma_IDirectSoundBuffer* pThis, DWORD dwNewPosition);
+    HRESULT (STDMETHODCALLTYPE * SetFormat)         (ma_IDirectSoundBuffer* pThis, const MA_WAVEFORMATEX* pFormat);
+    HRESULT (STDMETHODCALLTYPE * SetVolume)         (ma_IDirectSoundBuffer* pThis, LONG volume);
+    HRESULT (STDMETHODCALLTYPE * SetPan)            (ma_IDirectSoundBuffer* pThis, LONG pan);
+    HRESULT (STDMETHODCALLTYPE * SetFrequency)      (ma_IDirectSoundBuffer* pThis, DWORD dwFrequency);
+    HRESULT (STDMETHODCALLTYPE * Stop)              (ma_IDirectSoundBuffer* pThis);
+    HRESULT (STDMETHODCALLTYPE * Unlock)            (ma_IDirectSoundBuffer* pThis, void* pAudioPtr1, DWORD dwAudioBytes1, void* pAudioPtr2, DWORD dwAudioBytes2);
+    HRESULT (STDMETHODCALLTYPE * Restore)           (ma_IDirectSoundBuffer* pThis);
+} ma_IDirectSoundBufferVtbl;
+struct ma_IDirectSoundBuffer
+{
+    ma_IDirectSoundBufferVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_QueryInterface(ma_IDirectSoundBuffer* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSoundBuffer_AddRef(ma_IDirectSoundBuffer* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSoundBuffer_Release(ma_IDirectSoundBuffer* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetCaps(ma_IDirectSoundBuffer* pThis, MA_DSBCAPS* pDSBufferCaps)                     { return pThis->lpVtbl->GetCaps(pThis, pDSBufferCaps); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetCurrentPosition(ma_IDirectSoundBuffer* pThis, DWORD* pCurrentPlayCursor, DWORD* pCurrentWriteCursor) { return pThis->lpVtbl->GetCurrentPosition(pThis, pCurrentPlayCursor, pCurrentWriteCursor); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetFormat(ma_IDirectSoundBuffer* pThis, MA_WAVEFORMATEX* pFormat, DWORD dwSizeAllocated, DWORD* pSizeWritten) { return pThis->lpVtbl->GetFormat(pThis, pFormat, dwSizeAllocated, pSizeWritten); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetVolume(ma_IDirectSoundBuffer* pThis, LONG* pVolume)                               { return pThis->lpVtbl->GetVolume(pThis, pVolume); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetPan(ma_IDirectSoundBuffer* pThis, LONG* pPan)                                     { return pThis->lpVtbl->GetPan(pThis, pPan); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetFrequency(ma_IDirectSoundBuffer* pThis, DWORD* pFrequency)                        { return pThis->lpVtbl->GetFrequency(pThis, pFrequency); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetStatus(ma_IDirectSoundBuffer* pThis, DWORD* pStatus)                              { return pThis->lpVtbl->GetStatus(pThis, pStatus); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Initialize(ma_IDirectSoundBuffer* pThis, ma_IDirectSound* pDirectSound, const MA_DSBUFFERDESC* pDSBufferDesc) { return pThis->lpVtbl->Initialize(pThis, pDirectSound, pDSBufferDesc); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Lock(ma_IDirectSoundBuffer* pThis, DWORD dwOffset, DWORD dwBytes, void** ppAudioPtr1, DWORD* pAudioBytes1, void** ppAudioPtr2, DWORD* pAudioBytes2, DWORD dwFlags) { return pThis->lpVtbl->Lock(pThis, dwOffset, dwBytes, ppAudioPtr1, pAudioBytes1, ppAudioPtr2, pAudioBytes2, dwFlags); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Play(ma_IDirectSoundBuffer* pThis, DWORD dwReserved1, DWORD dwPriority, DWORD dwFlags) { return pThis->lpVtbl->Play(pThis, dwReserved1, dwPriority, dwFlags); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetCurrentPosition(ma_IDirectSoundBuffer* pThis, DWORD dwNewPosition)                { return pThis->lpVtbl->SetCurrentPosition(pThis, dwNewPosition); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetFormat(ma_IDirectSoundBuffer* pThis, const MA_WAVEFORMATEX* pFormat)              { return pThis->lpVtbl->SetFormat(pThis, pFormat); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetVolume(ma_IDirectSoundBuffer* pThis, LONG volume)                                 { return pThis->lpVtbl->SetVolume(pThis, volume); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetPan(ma_IDirectSoundBuffer* pThis, LONG pan)                                       { return pThis->lpVtbl->SetPan(pThis, pan); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetFrequency(ma_IDirectSoundBuffer* pThis, DWORD dwFrequency)                        { return pThis->lpVtbl->SetFrequency(pThis, dwFrequency); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Stop(ma_IDirectSoundBuffer* pThis)                                                   { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Unlock(ma_IDirectSoundBuffer* pThis, void* pAudioPtr1, DWORD dwAudioBytes1, void* pAudioPtr2, DWORD dwAudioBytes2) { return pThis->lpVtbl->Unlock(pThis, pAudioPtr1, dwAudioBytes1, pAudioPtr2, dwAudioBytes2); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Restore(ma_IDirectSoundBuffer* pThis)                                                { return pThis->lpVtbl->Restore(pThis); }
+
+
+/* IDirectSoundCapture */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSoundCapture* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSoundCapture* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSoundCapture* pThis);
+
+    /* IDirectSoundCapture */
+    HRESULT (STDMETHODCALLTYPE * CreateCaptureBuffer)(ma_IDirectSoundCapture* pThis, const MA_DSCBUFFERDESC* pDSCBufferDesc, ma_IDirectSoundCaptureBuffer** ppDSCBuffer, void* pUnkOuter);
+    HRESULT (STDMETHODCALLTYPE * GetCaps)            (ma_IDirectSoundCapture* pThis, MA_DSCCAPS* pDSCCaps);
+    HRESULT (STDMETHODCALLTYPE * Initialize)         (ma_IDirectSoundCapture* pThis, const GUID* pGuidDevice);
+} ma_IDirectSoundCaptureVtbl;
+struct ma_IDirectSoundCapture
+{
+    ma_IDirectSoundCaptureVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSoundCapture_QueryInterface     (ma_IDirectSoundCapture* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSoundCapture_AddRef             (ma_IDirectSoundCapture* pThis)                                    { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSoundCapture_Release            (ma_IDirectSoundCapture* pThis)                                    { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundCapture_CreateCaptureBuffer(ma_IDirectSoundCapture* pThis, const MA_DSCBUFFERDESC* pDSCBufferDesc, ma_IDirectSoundCaptureBuffer** ppDSCBuffer, void* pUnkOuter) { return pThis->lpVtbl->CreateCaptureBuffer(pThis, pDSCBufferDesc, ppDSCBuffer, pUnkOuter); }
+static MA_INLINE HRESULT ma_IDirectSoundCapture_GetCaps            (ma_IDirectSoundCapture* pThis, MA_DSCCAPS* pDSCCaps)              { return pThis->lpVtbl->GetCaps(pThis, pDSCCaps); }
+static MA_INLINE HRESULT ma_IDirectSoundCapture_Initialize         (ma_IDirectSoundCapture* pThis, const GUID* pGuidDevice)           { return pThis->lpVtbl->Initialize(pThis, pGuidDevice); }
+
+
+/* IDirectSoundCaptureBuffer */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSoundCaptureBuffer* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSoundCaptureBuffer* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSoundCaptureBuffer* pThis);
+
+    /* IDirectSoundCaptureBuffer */
+    HRESULT (STDMETHODCALLTYPE * GetCaps)           (ma_IDirectSoundCaptureBuffer* pThis, MA_DSCBCAPS* pDSCBCaps);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPosition)(ma_IDirectSoundCaptureBuffer* pThis, DWORD* pCapturePosition, DWORD* pReadPosition);
+    HRESULT (STDMETHODCALLTYPE * GetFormat)         (ma_IDirectSoundCaptureBuffer* pThis, MA_WAVEFORMATEX* pFormat, DWORD dwSizeAllocated, DWORD* pSizeWritten);
+    HRESULT (STDMETHODCALLTYPE * GetStatus)         (ma_IDirectSoundCaptureBuffer* pThis, DWORD* pStatus);
+    HRESULT (STDMETHODCALLTYPE * Initialize)        (ma_IDirectSoundCaptureBuffer* pThis, ma_IDirectSoundCapture* pDirectSoundCapture, const MA_DSCBUFFERDESC* pDSCBufferDesc);
+    HRESULT (STDMETHODCALLTYPE * Lock)              (ma_IDirectSoundCaptureBuffer* pThis, DWORD dwOffset, DWORD dwBytes, void** ppAudioPtr1, DWORD* pAudioBytes1, void** ppAudioPtr2, DWORD* pAudioBytes2, DWORD dwFlags);
+    HRESULT (STDMETHODCALLTYPE * Start)             (ma_IDirectSoundCaptureBuffer* pThis, DWORD dwFlags);
+    HRESULT (STDMETHODCALLTYPE * Stop)              (ma_IDirectSoundCaptureBuffer* pThis);
+    HRESULT (STDMETHODCALLTYPE * Unlock)            (ma_IDirectSoundCaptureBuffer* pThis, void* pAudioPtr1, DWORD dwAudioBytes1, void* pAudioPtr2, DWORD dwAudioBytes2);
+} ma_IDirectSoundCaptureBufferVtbl;
+struct ma_IDirectSoundCaptureBuffer
+{
+    ma_IDirectSoundCaptureBufferVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_QueryInterface(ma_IDirectSoundCaptureBuffer* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSoundCaptureBuffer_AddRef(ma_IDirectSoundCaptureBuffer* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSoundCaptureBuffer_Release(ma_IDirectSoundCaptureBuffer* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_GetCaps(ma_IDirectSoundCaptureBuffer* pThis, MA_DSCBCAPS* pDSCBCaps)                        { return pThis->lpVtbl->GetCaps(pThis, pDSCBCaps); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_GetCurrentPosition(ma_IDirectSoundCaptureBuffer* pThis, DWORD* pCapturePosition, DWORD* pReadPosition) { return pThis->lpVtbl->GetCurrentPosition(pThis, pCapturePosition, pReadPosition); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_GetFormat(ma_IDirectSoundCaptureBuffer* pThis, MA_WAVEFORMATEX* pFormat, DWORD dwSizeAllocated, DWORD* pSizeWritten) { return pThis->lpVtbl->GetFormat(pThis, pFormat, dwSizeAllocated, pSizeWritten); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_GetStatus(ma_IDirectSoundCaptureBuffer* pThis, DWORD* pStatus)                              { return pThis->lpVtbl->GetStatus(pThis, pStatus); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Initialize(ma_IDirectSoundCaptureBuffer* pThis, ma_IDirectSoundCapture* pDirectSoundCapture, const MA_DSCBUFFERDESC* pDSCBufferDesc) { return pThis->lpVtbl->Initialize(pThis, pDirectSoundCapture, pDSCBufferDesc); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Lock(ma_IDirectSoundCaptureBuffer* pThis, DWORD dwOffset, DWORD dwBytes, void** ppAudioPtr1, DWORD* pAudioBytes1, void** ppAudioPtr2, DWORD* pAudioBytes2, DWORD dwFlags) { return pThis->lpVtbl->Lock(pThis, dwOffset, dwBytes, ppAudioPtr1, pAudioBytes1, ppAudioPtr2, pAudioBytes2, dwFlags); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Start(ma_IDirectSoundCaptureBuffer* pThis, DWORD dwFlags)                                   { return pThis->lpVtbl->Start(pThis, dwFlags); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Stop(ma_IDirectSoundCaptureBuffer* pThis)                                                   { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Unlock(ma_IDirectSoundCaptureBuffer* pThis, void* pAudioPtr1, DWORD dwAudioBytes1, void* pAudioPtr2, DWORD dwAudioBytes2) { return pThis->lpVtbl->Unlock(pThis, pAudioPtr1, dwAudioBytes1, pAudioPtr2, dwAudioBytes2); }
+
+
+/* IDirectSoundNotify */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSoundNotify* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSoundNotify* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSoundNotify* pThis);
+
+    /* IDirectSoundNotify */
+    HRESULT (STDMETHODCALLTYPE * SetNotificationPositions)(ma_IDirectSoundNotify* pThis, DWORD dwPositionNotifies, const MA_DSBPOSITIONNOTIFY* pPositionNotifies);
+} ma_IDirectSoundNotifyVtbl;
+struct ma_IDirectSoundNotify
+{
+    ma_IDirectSoundNotifyVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSoundNotify_QueryInterface(ma_IDirectSoundNotify* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSoundNotify_AddRef(ma_IDirectSoundNotify* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSoundNotify_Release(ma_IDirectSoundNotify* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundNotify_SetNotificationPositions(ma_IDirectSoundNotify* pThis, DWORD dwPositionNotifies, const MA_DSBPOSITIONNOTIFY* pPositionNotifies) { return pThis->lpVtbl->SetNotificationPositions(pThis, dwPositionNotifies, pPositionNotifies); }
+
+
+typedef BOOL    (CALLBACK * ma_DSEnumCallbackAProc)             (GUID* pDeviceGUID, const char* pDeviceDescription, const char* pModule, void* pContext);
+typedef HRESULT (WINAPI   * ma_DirectSoundCreateProc)           (const GUID* pcGuidDevice, ma_IDirectSound** ppDS8, ma_IUnknown* pUnkOuter);
+typedef HRESULT (WINAPI   * ma_DirectSoundEnumerateAProc)       (ma_DSEnumCallbackAProc pDSEnumCallback, void* pContext);
+typedef HRESULT (WINAPI   * ma_DirectSoundCaptureCreateProc)    (const GUID* pcGuidDevice, ma_IDirectSoundCapture** ppDSC8, ma_IUnknown* pUnkOuter);
+typedef HRESULT (WINAPI   * ma_DirectSoundCaptureEnumerateAProc)(ma_DSEnumCallbackAProc pDSEnumCallback, void* pContext);
+
+static ma_uint32 ma_get_best_sample_rate_within_range(ma_uint32 sampleRateMin, ma_uint32 sampleRateMax)
+{
+    /* Normalize the range in case we were given something stupid. */
+    if (sampleRateMin < (ma_uint32)ma_standard_sample_rate_min) {
+        sampleRateMin = (ma_uint32)ma_standard_sample_rate_min;
+    }
+    if (sampleRateMax > (ma_uint32)ma_standard_sample_rate_max) {
+        sampleRateMax = (ma_uint32)ma_standard_sample_rate_max;
+    }
+    if (sampleRateMin > sampleRateMax) {
+        sampleRateMin = sampleRateMax;
+    }
+
+    if (sampleRateMin == sampleRateMax) {
+        return sampleRateMax;
+    } else {
+        size_t iStandardRate;
+        for (iStandardRate = 0; iStandardRate < ma_countof(g_maStandardSampleRatePriorities); ++iStandardRate) {
+            ma_uint32 standardRate = g_maStandardSampleRatePriorities[iStandardRate];
+            if (standardRate >= sampleRateMin && standardRate <= sampleRateMax) {
+                return standardRate;
+            }
+        }
+    }
+
+    /* Should never get here. */
+    MA_ASSERT(MA_FALSE);
+    return 0;
+}
+
+/*
+Retrieves the channel count and channel map for the given speaker configuration. If the speaker configuration is unknown,
+the channel count and channel map will be left unmodified.
+*/
+static void ma_get_channels_from_speaker_config__dsound(DWORD speakerConfig, WORD* pChannelsOut, DWORD* pChannelMapOut)
+{
+    WORD  channels;
+    DWORD channelMap;
+
+    channels = 0;
+    if (pChannelsOut != NULL) {
+        channels = *pChannelsOut;
+    }
+
+    channelMap = 0;
+    if (pChannelMapOut != NULL) {
+        channelMap = *pChannelMapOut;
+    }
+
+    /*
+    The speaker configuration is a combination of speaker config and speaker geometry. The lower 8 bits is what we care about. The upper
+    16 bits is for the geometry.
+    */
+    switch ((BYTE)(speakerConfig)) {
+        case 1 /*DSSPEAKER_HEADPHONE*/:                          channels = 2; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; break;
+        case 2 /*DSSPEAKER_MONO*/:                               channels = 1; channelMap = SPEAKER_FRONT_CENTER; break;
+        case 3 /*DSSPEAKER_QUAD*/:                               channels = 4; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; break;
+        case 4 /*DSSPEAKER_STEREO*/:                             channels = 2; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; break;
+        case 5 /*DSSPEAKER_SURROUND*/:                           channels = 4; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_BACK_CENTER; break;
+        case 6 /*DSSPEAKER_5POINT1_BACK*/ /*DSSPEAKER_5POINT1*/: channels = 6; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; break;
+        case 7 /*DSSPEAKER_7POINT1_WIDE*/ /*DSSPEAKER_7POINT1*/: channels = 8; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_FRONT_LEFT_OF_CENTER | SPEAKER_FRONT_RIGHT_OF_CENTER; break;
+        case 8 /*DSSPEAKER_7POINT1_SURROUND*/:                   channels = 8; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT; break;
+        case 9 /*DSSPEAKER_5POINT1_SURROUND*/:                   channels = 6; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT; break;
+        default: break;
+    }
+
+    if (pChannelsOut != NULL) {
+        *pChannelsOut = channels;
+    }
+
+    if (pChannelMapOut != NULL) {
+        *pChannelMapOut = channelMap;
+    }
+}
+
+
+static ma_result ma_context_create_IDirectSound__dsound(ma_context* pContext, ma_share_mode shareMode, const ma_device_id* pDeviceID, ma_IDirectSound** ppDirectSound)
+{
+    ma_IDirectSound* pDirectSound;
+    HWND hWnd;
+    HRESULT hr;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppDirectSound != NULL);
+
+    *ppDirectSound = NULL;
+    pDirectSound = NULL;
+
+    if (FAILED(((ma_DirectSoundCreateProc)pContext->dsound.DirectSoundCreate)((pDeviceID == NULL) ? NULL : (const GUID*)pDeviceID->dsound, &pDirectSound, NULL))) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] DirectSoundCreate() failed for playback device.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    /* The cooperative level must be set before doing anything else. */
+    hWnd = (HWND)pContext->dsound.hWnd;
+    if (hWnd == 0) {
+        hWnd = ((MA_PFN_GetForegroundWindow)pContext->win32.GetForegroundWindow)();
+        if (hWnd == 0) {
+            hWnd = ((MA_PFN_GetDesktopWindow)pContext->win32.GetDesktopWindow)();
+        }
+    }
+
+    hr = ma_IDirectSound_SetCooperativeLevel(pDirectSound, hWnd, (shareMode == ma_share_mode_exclusive) ? MA_DSSCL_EXCLUSIVE : MA_DSSCL_PRIORITY);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_SetCooperateiveLevel() failed for playback device.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    *ppDirectSound = pDirectSound;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_create_IDirectSoundCapture__dsound(ma_context* pContext, ma_share_mode shareMode, const ma_device_id* pDeviceID, ma_IDirectSoundCapture** ppDirectSoundCapture)
+{
+    ma_IDirectSoundCapture* pDirectSoundCapture;
+    HRESULT hr;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppDirectSoundCapture != NULL);
+
+    /* DirectSound does not support exclusive mode for capture. */
+    if (shareMode == ma_share_mode_exclusive) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    *ppDirectSoundCapture = NULL;
+    pDirectSoundCapture = NULL;
+
+    hr = ((ma_DirectSoundCaptureCreateProc)pContext->dsound.DirectSoundCaptureCreate)((pDeviceID == NULL) ? NULL : (const GUID*)pDeviceID->dsound, &pDirectSoundCapture, NULL);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] DirectSoundCaptureCreate() failed for capture device.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    *ppDirectSoundCapture = pDirectSoundCapture;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_format_info_for_IDirectSoundCapture__dsound(ma_context* pContext, ma_IDirectSoundCapture* pDirectSoundCapture, WORD* pChannels, WORD* pBitsPerSample, DWORD* pSampleRate)
+{
+    HRESULT hr;
+    MA_DSCCAPS caps;
+    WORD bitsPerSample;
+    DWORD sampleRate;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDirectSoundCapture != NULL);
+
+    if (pChannels) {
+        *pChannels = 0;
+    }
+    if (pBitsPerSample) {
+        *pBitsPerSample = 0;
+    }
+    if (pSampleRate) {
+        *pSampleRate = 0;
+    }
+
+    MA_ZERO_OBJECT(&caps);
+    caps.dwSize = sizeof(caps);
+    hr = ma_IDirectSoundCapture_GetCaps(pDirectSoundCapture, &caps);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundCapture_GetCaps() failed for capture device.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    if (pChannels) {
+        *pChannels = (WORD)caps.dwChannels;
+    }
+
+    /* The device can support multiple formats. We just go through the different formats in order of priority and pick the first one. This the same type of system as the WinMM backend. */
+    bitsPerSample = 16;
+    sampleRate = 48000;
+
+    if (caps.dwChannels == 1) {
+        if ((caps.dwFormats & WAVE_FORMAT_48M16) != 0) {
+            sampleRate = 48000;
+        } else if ((caps.dwFormats & WAVE_FORMAT_44M16) != 0) {
+            sampleRate = 44100;
+        } else if ((caps.dwFormats & WAVE_FORMAT_2M16) != 0) {
+            sampleRate = 22050;
+        } else if ((caps.dwFormats & WAVE_FORMAT_1M16) != 0) {
+            sampleRate = 11025;
+        } else if ((caps.dwFormats & WAVE_FORMAT_96M16) != 0) {
+            sampleRate = 96000;
+        } else {
+            bitsPerSample = 8;
+            if ((caps.dwFormats & WAVE_FORMAT_48M08) != 0) {
+                sampleRate = 48000;
+            } else if ((caps.dwFormats & WAVE_FORMAT_44M08) != 0) {
+                sampleRate = 44100;
+            } else if ((caps.dwFormats & WAVE_FORMAT_2M08) != 0) {
+                sampleRate = 22050;
+            } else if ((caps.dwFormats & WAVE_FORMAT_1M08) != 0) {
+                sampleRate = 11025;
+            } else if ((caps.dwFormats & WAVE_FORMAT_96M08) != 0) {
+                sampleRate = 96000;
+            } else {
+                bitsPerSample = 16;  /* Didn't find it. Just fall back to 16-bit. */
+            }
+        }
+    } else if (caps.dwChannels == 2) {
+        if ((caps.dwFormats & WAVE_FORMAT_48S16) != 0) {
+            sampleRate = 48000;
+        } else if ((caps.dwFormats & WAVE_FORMAT_44S16) != 0) {
+            sampleRate = 44100;
+        } else if ((caps.dwFormats & WAVE_FORMAT_2S16) != 0) {
+            sampleRate = 22050;
+        } else if ((caps.dwFormats & WAVE_FORMAT_1S16) != 0) {
+            sampleRate = 11025;
+        } else if ((caps.dwFormats & WAVE_FORMAT_96S16) != 0) {
+            sampleRate = 96000;
+        } else {
+            bitsPerSample = 8;
+            if ((caps.dwFormats & WAVE_FORMAT_48S08) != 0) {
+                sampleRate = 48000;
+            } else if ((caps.dwFormats & WAVE_FORMAT_44S08) != 0) {
+                sampleRate = 44100;
+            } else if ((caps.dwFormats & WAVE_FORMAT_2S08) != 0) {
+                sampleRate = 22050;
+            } else if ((caps.dwFormats & WAVE_FORMAT_1S08) != 0) {
+                sampleRate = 11025;
+            } else if ((caps.dwFormats & WAVE_FORMAT_96S08) != 0) {
+                sampleRate = 96000;
+            } else {
+                bitsPerSample = 16;  /* Didn't find it. Just fall back to 16-bit. */
+            }
+        }
+    }
+
+    if (pBitsPerSample) {
+        *pBitsPerSample = bitsPerSample;
+    }
+    if (pSampleRate) {
+        *pSampleRate = sampleRate;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    ma_context* pContext;
+    ma_device_type deviceType;
+    ma_enum_devices_callback_proc callback;
+    void* pUserData;
+    ma_bool32 terminated;
+} ma_context_enumerate_devices_callback_data__dsound;
+
+static BOOL CALLBACK ma_context_enumerate_devices_callback__dsound(GUID* lpGuid, const char* lpcstrDescription, const char* lpcstrModule, void* lpContext)
+{
+    ma_context_enumerate_devices_callback_data__dsound* pData = (ma_context_enumerate_devices_callback_data__dsound*)lpContext;
+    ma_device_info deviceInfo;
+
+    (void)lpcstrModule;
+
+    MA_ZERO_OBJECT(&deviceInfo);
+
+    /* ID. */
+    if (lpGuid != NULL) {
+        MA_COPY_MEMORY(deviceInfo.id.dsound, lpGuid, 16);
+    } else {
+        MA_ZERO_MEMORY(deviceInfo.id.dsound, 16);
+        deviceInfo.isDefault = MA_TRUE;
+    }
+
+    /* Name / Description */
+    ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), lpcstrDescription, (size_t)-1);
+
+
+    /* Call the callback function, but make sure we stop enumerating if the callee requested so. */
+    MA_ASSERT(pData != NULL);
+    pData->terminated = (pData->callback(pData->pContext, pData->deviceType, &deviceInfo, pData->pUserData) == MA_FALSE);
+    if (pData->terminated) {
+        return FALSE;   /* Stop enumeration. */
+    } else {
+        return TRUE;    /* Continue enumeration. */
+    }
+}
+
+static ma_result ma_context_enumerate_devices__dsound(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_context_enumerate_devices_callback_data__dsound data;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    data.pContext = pContext;
+    data.callback = callback;
+    data.pUserData = pUserData;
+    data.terminated = MA_FALSE;
+
+    /* Playback. */
+    if (!data.terminated) {
+        data.deviceType = ma_device_type_playback;
+        ((ma_DirectSoundEnumerateAProc)pContext->dsound.DirectSoundEnumerateA)(ma_context_enumerate_devices_callback__dsound, &data);
+    }
+
+    /* Capture. */
+    if (!data.terminated) {
+        data.deviceType = ma_device_type_capture;
+        ((ma_DirectSoundCaptureEnumerateAProc)pContext->dsound.DirectSoundCaptureEnumerateA)(ma_context_enumerate_devices_callback__dsound, &data);
+    }
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    const ma_device_id* pDeviceID;
+    ma_device_info* pDeviceInfo;
+    ma_bool32 found;
+} ma_context_get_device_info_callback_data__dsound;
+
+static BOOL CALLBACK ma_context_get_device_info_callback__dsound(GUID* lpGuid, const char* lpcstrDescription, const char* lpcstrModule, void* lpContext)
+{
+    ma_context_get_device_info_callback_data__dsound* pData = (ma_context_get_device_info_callback_data__dsound*)lpContext;
+    MA_ASSERT(pData != NULL);
+
+    if ((pData->pDeviceID == NULL || ma_is_guid_null(pData->pDeviceID->dsound)) && (lpGuid == NULL || ma_is_guid_null(lpGuid))) {
+        /* Default device. */
+        ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), lpcstrDescription, (size_t)-1);
+        pData->pDeviceInfo->isDefault = MA_TRUE;
+        pData->found = MA_TRUE;
+        return FALSE;   /* Stop enumeration. */
+    } else {
+        /* Not the default device. */
+        if (lpGuid != NULL && pData->pDeviceID != NULL) {
+            if (memcmp(pData->pDeviceID->dsound, lpGuid, sizeof(pData->pDeviceID->dsound)) == 0) {
+                ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), lpcstrDescription, (size_t)-1);
+                pData->found = MA_TRUE;
+                return FALSE;   /* Stop enumeration. */
+            }
+        }
+    }
+
+    (void)lpcstrModule;
+    return TRUE;
+}
+
+static ma_result ma_context_get_device_info__dsound(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_result result;
+    HRESULT hr;
+
+    if (pDeviceID != NULL) {
+        ma_context_get_device_info_callback_data__dsound data;
+
+        /* ID. */
+        MA_COPY_MEMORY(pDeviceInfo->id.dsound, pDeviceID->dsound, 16);
+
+        /* Name / Description. This is retrieved by enumerating over each device until we find that one that matches the input ID. */
+        data.pDeviceID = pDeviceID;
+        data.pDeviceInfo = pDeviceInfo;
+        data.found = MA_FALSE;
+        if (deviceType == ma_device_type_playback) {
+            ((ma_DirectSoundEnumerateAProc)pContext->dsound.DirectSoundEnumerateA)(ma_context_get_device_info_callback__dsound, &data);
+        } else {
+            ((ma_DirectSoundCaptureEnumerateAProc)pContext->dsound.DirectSoundCaptureEnumerateA)(ma_context_get_device_info_callback__dsound, &data);
+        }
+
+        if (!data.found) {
+            return MA_NO_DEVICE;
+        }
+    } else {
+        /* I don't think there's a way to get the name of the default device with DirectSound. In this case we just need to use defaults. */
+
+        /* ID */
+        MA_ZERO_MEMORY(pDeviceInfo->id.dsound, 16);
+
+        /* Name / Description */
+        if (deviceType == ma_device_type_playback) {
+            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        } else {
+            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+        }
+
+        pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    /* Retrieving detailed information is slightly different depending on the device type. */
+    if (deviceType == ma_device_type_playback) {
+        /* Playback. */
+        ma_IDirectSound* pDirectSound;
+        MA_DSCAPS caps;
+        WORD channels;
+
+        result = ma_context_create_IDirectSound__dsound(pContext, ma_share_mode_shared, pDeviceID, &pDirectSound);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        MA_ZERO_OBJECT(&caps);
+        caps.dwSize = sizeof(caps);
+        hr = ma_IDirectSound_GetCaps(pDirectSound, &caps);
+        if (FAILED(hr)) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_GetCaps() failed for playback device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+
+        /* Channels. Only a single channel count is reported for DirectSound. */
+        if ((caps.dwFlags & MA_DSCAPS_PRIMARYSTEREO) != 0) {
+            /* It supports at least stereo, but could support more. */
+            DWORD speakerConfig;
+
+            channels = 2;
+
+            /* Look at the speaker configuration to get a better idea on the channel count. */
+            hr = ma_IDirectSound_GetSpeakerConfig(pDirectSound, &speakerConfig);
+            if (SUCCEEDED(hr)) {
+                ma_get_channels_from_speaker_config__dsound(speakerConfig, &channels, NULL);
+            }
+        } else {
+            /* It does not support stereo, which means we are stuck with mono. */
+            channels = 1;
+        }
+
+
+        /*
+        In DirectSound, our native formats are centered around sample rates. All formats are supported, and we're only reporting a single channel
+        count. However, DirectSound can report a range of supported sample rates. We're only going to include standard rates known by miniaudio
+        in order to keep the size of this within reason.
+        */
+        if ((caps.dwFlags & MA_DSCAPS_CONTINUOUSRATE) != 0) {
+            /* Multiple sample rates are supported. We'll report in order of our preferred sample rates. */
+            size_t iStandardSampleRate;
+            for (iStandardSampleRate = 0; iStandardSampleRate < ma_countof(g_maStandardSampleRatePriorities); iStandardSampleRate += 1) {
+                ma_uint32 sampleRate = g_maStandardSampleRatePriorities[iStandardSampleRate];
+                if (sampleRate >= caps.dwMinSecondarySampleRate && sampleRate <= caps.dwMaxSecondarySampleRate) {
+                    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = ma_format_unknown;
+                    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+                    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = sampleRate;
+                    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = 0;
+                    pDeviceInfo->nativeDataFormatCount += 1;
+                }
+            }
+        } else {
+            /* Only a single sample rate is supported. */
+            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = ma_format_unknown;
+            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = caps.dwMaxSecondarySampleRate;
+            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = 0;
+            pDeviceInfo->nativeDataFormatCount += 1;
+        }
+
+        ma_IDirectSound_Release(pDirectSound);
+    } else {
+        /*
+        Capture. This is a little different to playback due to the say the supported formats are reported. Technically capture
+        devices can support a number of different formats, but for simplicity and consistency with ma_device_init() I'm just
+        reporting the best format.
+        */
+        ma_IDirectSoundCapture* pDirectSoundCapture;
+        WORD channels;
+        WORD bitsPerSample;
+        DWORD sampleRate;
+
+        result = ma_context_create_IDirectSoundCapture__dsound(pContext, ma_share_mode_shared, pDeviceID, &pDirectSoundCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_context_get_format_info_for_IDirectSoundCapture__dsound(pContext, pDirectSoundCapture, &channels, &bitsPerSample, &sampleRate);
+        if (result != MA_SUCCESS) {
+            ma_IDirectSoundCapture_Release(pDirectSoundCapture);
+            return result;
+        }
+
+        ma_IDirectSoundCapture_Release(pDirectSoundCapture);
+
+        /* The format is always an integer format and is based on the bits per sample. */
+        if (bitsPerSample == 8) {
+            pDeviceInfo->nativeDataFormats[0].format = ma_format_u8;
+        } else if (bitsPerSample == 16) {
+            pDeviceInfo->nativeDataFormats[0].format = ma_format_s16;
+        } else if (bitsPerSample == 24) {
+            pDeviceInfo->nativeDataFormats[0].format = ma_format_s24;
+        } else if (bitsPerSample == 32) {
+            pDeviceInfo->nativeDataFormats[0].format = ma_format_s32;
+        } else {
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        pDeviceInfo->nativeDataFormats[0].channels   = channels;
+        pDeviceInfo->nativeDataFormats[0].sampleRate = sampleRate;
+        pDeviceInfo->nativeDataFormats[0].flags      = 0;
+        pDeviceInfo->nativeDataFormatCount = 1;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+static ma_result ma_device_uninit__dsound(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->dsound.pCaptureBuffer != NULL) {
+        ma_IDirectSoundCaptureBuffer_Release((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+    }
+    if (pDevice->dsound.pCapture != NULL) {
+        ma_IDirectSoundCapture_Release((ma_IDirectSoundCapture*)pDevice->dsound.pCapture);
+    }
+
+    if (pDevice->dsound.pPlaybackBuffer != NULL) {
+        ma_IDirectSoundBuffer_Release((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer);
+    }
+    if (pDevice->dsound.pPlaybackPrimaryBuffer != NULL) {
+        ma_IDirectSoundBuffer_Release((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackPrimaryBuffer);
+    }
+    if (pDevice->dsound.pPlayback != NULL) {
+        ma_IDirectSound_Release((ma_IDirectSound*)pDevice->dsound.pPlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_config_to_WAVEFORMATEXTENSIBLE(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, const ma_channel* pChannelMap, MA_WAVEFORMATEXTENSIBLE* pWF)
+{
+    GUID subformat;
+
+    if (format == ma_format_unknown) {
+        format = MA_DEFAULT_FORMAT;
+    }
+
+    if (channels == 0) {
+        channels = MA_DEFAULT_CHANNELS;
+    }
+
+    if (sampleRate == 0) {
+        sampleRate = MA_DEFAULT_SAMPLE_RATE;
+    }
+
+    switch (format)
+    {
+        case ma_format_u8:
+        case ma_format_s16:
+        case ma_format_s24:
+        /*case ma_format_s24_32:*/
+        case ma_format_s32:
+        {
+            subformat = MA_GUID_KSDATAFORMAT_SUBTYPE_PCM;
+        } break;
+
+        case ma_format_f32:
+        {
+            subformat = MA_GUID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
+        } break;
+
+        default:
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    MA_ZERO_OBJECT(pWF);
+    pWF->cbSize                      = sizeof(*pWF);
+    pWF->wFormatTag                  = WAVE_FORMAT_EXTENSIBLE;
+    pWF->nChannels                   = (WORD)channels;
+    pWF->nSamplesPerSec              = (DWORD)sampleRate;
+    pWF->wBitsPerSample              = (WORD)(ma_get_bytes_per_sample(format)*8);
+    pWF->nBlockAlign                 = (WORD)(pWF->nChannels * pWF->wBitsPerSample / 8);
+    pWF->nAvgBytesPerSec             = pWF->nBlockAlign * pWF->nSamplesPerSec;
+    pWF->Samples.wValidBitsPerSample = pWF->wBitsPerSample;
+    pWF->dwChannelMask               = ma_channel_map_to_channel_mask__win32(pChannelMap, channels);
+    pWF->SubFormat                   = subformat;
+
+    return MA_SUCCESS;
+}
+
+static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__dsound(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    /*
+    DirectSound has a minimum period size of 20ms. In practice, this doesn't seem to be enough for
+    reliable glitch-free processing so going to use 30ms instead.
+    */
+    ma_uint32 minPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(30, nativeSampleRate);
+    ma_uint32 periodSizeInFrames;
+
+    periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, nativeSampleRate, performanceProfile);
+    if (periodSizeInFrames < minPeriodSizeInFrames) {
+        periodSizeInFrames = minPeriodSizeInFrames;
+    }
+
+    return periodSizeInFrames;
+}
+
+static ma_result ma_device_init__dsound(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+    HRESULT hr;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->dsound);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /*
+    Unfortunately DirectSound uses different APIs and data structures for playback and capture devices. We need to initialize
+    the capture device first because we'll want to match its buffer size and period count on the playback side if we're using
+    full-duplex mode.
+    */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        MA_WAVEFORMATEXTENSIBLE wf;
+        MA_DSCBUFFERDESC descDS;
+        ma_uint32 periodSizeInFrames;
+        ma_uint32 periodCount;
+        char rawdata[1024]; /* <-- Ugly hack to avoid a malloc() due to a crappy DirectSound API. */
+        MA_WAVEFORMATEXTENSIBLE* pActualFormat;
+
+        result = ma_config_to_WAVEFORMATEXTENSIBLE(pDescriptorCapture->format, pDescriptorCapture->channels, pDescriptorCapture->sampleRate, pDescriptorCapture->channelMap, &wf);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_context_create_IDirectSoundCapture__dsound(pDevice->pContext, pDescriptorCapture->shareMode, pDescriptorCapture->pDeviceID, (ma_IDirectSoundCapture**)&pDevice->dsound.pCapture);
+        if (result != MA_SUCCESS) {
+            ma_device_uninit__dsound(pDevice);
+            return result;
+        }
+
+        result = ma_context_get_format_info_for_IDirectSoundCapture__dsound(pDevice->pContext, (ma_IDirectSoundCapture*)pDevice->dsound.pCapture, &wf.nChannels, &wf.wBitsPerSample, &wf.nSamplesPerSec);
+        if (result != MA_SUCCESS) {
+            ma_device_uninit__dsound(pDevice);
+            return result;
+        }
+
+        wf.nBlockAlign                 = (WORD)(wf.nChannels * wf.wBitsPerSample / 8);
+        wf.nAvgBytesPerSec             = wf.nBlockAlign * wf.nSamplesPerSec;
+        wf.Samples.wValidBitsPerSample = wf.wBitsPerSample;
+        wf.SubFormat                   = MA_GUID_KSDATAFORMAT_SUBTYPE_PCM;
+
+        /* The size of the buffer must be a clean multiple of the period count. */
+        periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__dsound(pDescriptorCapture, wf.nSamplesPerSec, pConfig->performanceProfile);
+        periodCount = (pDescriptorCapture->periodCount > 0) ? pDescriptorCapture->periodCount : MA_DEFAULT_PERIODS;
+
+        MA_ZERO_OBJECT(&descDS);
+        descDS.dwSize        = sizeof(descDS);
+        descDS.dwFlags       = 0;
+        descDS.dwBufferBytes = periodSizeInFrames * periodCount * wf.nBlockAlign;
+        descDS.lpwfxFormat   = (MA_WAVEFORMATEX*)&wf;
+        hr = ma_IDirectSoundCapture_CreateCaptureBuffer((ma_IDirectSoundCapture*)pDevice->dsound.pCapture, &descDS, (ma_IDirectSoundCaptureBuffer**)&pDevice->dsound.pCaptureBuffer, NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundCapture_CreateCaptureBuffer() failed for capture device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* Get the _actual_ properties of the buffer. */
+        pActualFormat = (MA_WAVEFORMATEXTENSIBLE*)rawdata;
+        hr = ma_IDirectSoundCaptureBuffer_GetFormat((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, (MA_WAVEFORMATEX*)pActualFormat, sizeof(rawdata), NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to retrieve the actual format of the capture device's buffer.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* We can now start setting the output data formats. */
+        pDescriptorCapture->format     = ma_format_from_WAVEFORMATEX((MA_WAVEFORMATEX*)pActualFormat);
+        pDescriptorCapture->channels   = pActualFormat->nChannels;
+        pDescriptorCapture->sampleRate = pActualFormat->nSamplesPerSec;
+
+        /* Get the native channel map based on the channel mask. */
+        if (pActualFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
+            ma_channel_mask_to_channel_map__win32(pActualFormat->dwChannelMask, pDescriptorCapture->channels, pDescriptorCapture->channelMap);
+        } else {
+            ma_channel_mask_to_channel_map__win32(wf.dwChannelMask, pDescriptorCapture->channels, pDescriptorCapture->channelMap);
+        }
+
+        /*
+        After getting the actual format the size of the buffer in frames may have actually changed. However, we want this to be as close to what the
+        user has asked for as possible, so let's go ahead and release the old capture buffer and create a new one in this case.
+        */
+        if (periodSizeInFrames != (descDS.dwBufferBytes / ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels) / periodCount)) {
+            descDS.dwBufferBytes = periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels) * periodCount;
+            ma_IDirectSoundCaptureBuffer_Release((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+
+            hr = ma_IDirectSoundCapture_CreateCaptureBuffer((ma_IDirectSoundCapture*)pDevice->dsound.pCapture, &descDS, (ma_IDirectSoundCaptureBuffer**)&pDevice->dsound.pCaptureBuffer, NULL);
+            if (FAILED(hr)) {
+                ma_device_uninit__dsound(pDevice);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Second attempt at IDirectSoundCapture_CreateCaptureBuffer() failed for capture device.");
+                return ma_result_from_HRESULT(hr);
+            }
+        }
+
+        /* DirectSound should give us a buffer exactly the size we asked for. */
+        pDescriptorCapture->periodSizeInFrames = periodSizeInFrames;
+        pDescriptorCapture->periodCount        = periodCount;
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        MA_WAVEFORMATEXTENSIBLE wf;
+        MA_DSBUFFERDESC descDSPrimary;
+        MA_DSCAPS caps;
+        char rawdata[1024]; /* <-- Ugly hack to avoid a malloc() due to a crappy DirectSound API. */
+        MA_WAVEFORMATEXTENSIBLE* pActualFormat;
+        ma_uint32 periodSizeInFrames;
+        ma_uint32 periodCount;
+        MA_DSBUFFERDESC descDS;
+        WORD nativeChannelCount;
+        DWORD nativeChannelMask = 0;
+
+        result = ma_config_to_WAVEFORMATEXTENSIBLE(pDescriptorPlayback->format, pDescriptorPlayback->channels, pDescriptorPlayback->sampleRate, pDescriptorPlayback->channelMap, &wf);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_context_create_IDirectSound__dsound(pDevice->pContext, pDescriptorPlayback->shareMode, pDescriptorPlayback->pDeviceID, (ma_IDirectSound**)&pDevice->dsound.pPlayback);
+        if (result != MA_SUCCESS) {
+            ma_device_uninit__dsound(pDevice);
+            return result;
+        }
+
+        MA_ZERO_OBJECT(&descDSPrimary);
+        descDSPrimary.dwSize  = sizeof(MA_DSBUFFERDESC);
+        descDSPrimary.dwFlags = MA_DSBCAPS_PRIMARYBUFFER | MA_DSBCAPS_CTRLVOLUME;
+        hr = ma_IDirectSound_CreateSoundBuffer((ma_IDirectSound*)pDevice->dsound.pPlayback, &descDSPrimary, (ma_IDirectSoundBuffer**)&pDevice->dsound.pPlaybackPrimaryBuffer, NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_CreateSoundBuffer() failed for playback device's primary buffer.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+
+        /* We may want to make some adjustments to the format if we are using defaults. */
+        MA_ZERO_OBJECT(&caps);
+        caps.dwSize = sizeof(caps);
+        hr = ma_IDirectSound_GetCaps((ma_IDirectSound*)pDevice->dsound.pPlayback, &caps);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_GetCaps() failed for playback device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        if ((caps.dwFlags & MA_DSCAPS_PRIMARYSTEREO) != 0) {
+            DWORD speakerConfig;
+
+            /* It supports at least stereo, but could support more. */
+            nativeChannelCount = 2;
+
+            /* Look at the speaker configuration to get a better idea on the channel count. */
+            if (SUCCEEDED(ma_IDirectSound_GetSpeakerConfig((ma_IDirectSound*)pDevice->dsound.pPlayback, &speakerConfig))) {
+                ma_get_channels_from_speaker_config__dsound(speakerConfig, &nativeChannelCount, &nativeChannelMask);
+            }
+        } else {
+            /* It does not support stereo, which means we are stuck with mono. */
+            nativeChannelCount = 1;
+            nativeChannelMask  = 0x00000001;
+        }
+
+        if (pDescriptorPlayback->channels == 0) {
+            wf.nChannels = nativeChannelCount;
+            wf.dwChannelMask    = nativeChannelMask;
+        }
+
+        if (pDescriptorPlayback->sampleRate == 0) {
+            /* We base the sample rate on the values returned by GetCaps(). */
+            if ((caps.dwFlags & MA_DSCAPS_CONTINUOUSRATE) != 0) {
+                wf.nSamplesPerSec = ma_get_best_sample_rate_within_range(caps.dwMinSecondarySampleRate, caps.dwMaxSecondarySampleRate);
+            } else {
+                wf.nSamplesPerSec = caps.dwMaxSecondarySampleRate;
+            }
+        }
+
+        wf.nBlockAlign     = (WORD)(wf.nChannels * wf.wBitsPerSample / 8);
+        wf.nAvgBytesPerSec = wf.nBlockAlign * wf.nSamplesPerSec;
+
+        /*
+        From MSDN:
+
+        The method succeeds even if the hardware does not support the requested format; DirectSound sets the buffer to the closest
+        supported format. To determine whether this has happened, an application can call the GetFormat method for the primary buffer
+        and compare the result with the format that was requested with the SetFormat method.
+        */
+        hr = ma_IDirectSoundBuffer_SetFormat((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackPrimaryBuffer, (MA_WAVEFORMATEX*)&wf);
+        if (FAILED(hr)) {
+            /*
+            If setting of the format failed we'll try again with some fallback settings. On Windows 98 I have
+            observed that IEEE_FLOAT does not work. We'll therefore enforce PCM. I also had issues where a
+            sample rate of 48000 did not work correctly. Not sure if it was a driver issue or not, but will
+            use 44100 for the sample rate.
+            */
+            wf.cbSize          = 18;    /* NOTE: Don't use sizeof(MA_WAVEFORMATEX) here because it's got an extra 2 bytes due to padding. */
+            wf.wFormatTag      = WAVE_FORMAT_PCM;
+            wf.wBitsPerSample  = 16;
+            wf.nChannels       = nativeChannelCount;
+            wf.nSamplesPerSec  = 44100;
+            wf.nBlockAlign     = wf.nChannels * (wf.wBitsPerSample / 8);
+            wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;
+
+            hr = ma_IDirectSoundBuffer_SetFormat((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackPrimaryBuffer, (MA_WAVEFORMATEX*)&wf);
+            if (FAILED(hr)) {
+                ma_device_uninit__dsound(pDevice);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to set format of playback device's primary buffer.");
+                return ma_result_from_HRESULT(hr);
+            }
+        }
+
+        /* Get the _actual_ properties of the buffer. */
+        pActualFormat = (MA_WAVEFORMATEXTENSIBLE*)rawdata;
+        hr = ma_IDirectSoundBuffer_GetFormat((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackPrimaryBuffer, (MA_WAVEFORMATEX*)pActualFormat, sizeof(rawdata), NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to retrieve the actual format of the playback device's primary buffer.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* We now have enough information to start setting some output properties. */
+        pDescriptorPlayback->format     = ma_format_from_WAVEFORMATEX((MA_WAVEFORMATEX*)pActualFormat);
+        pDescriptorPlayback->channels   = pActualFormat->nChannels;
+        pDescriptorPlayback->sampleRate = pActualFormat->nSamplesPerSec;
+
+        /* Get the internal channel map based on the channel mask. */
+        if (pActualFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
+            ma_channel_mask_to_channel_map__win32(pActualFormat->dwChannelMask, pDescriptorPlayback->channels, pDescriptorPlayback->channelMap);
+        } else {
+            ma_channel_mask_to_channel_map__win32(wf.dwChannelMask, pDescriptorPlayback->channels, pDescriptorPlayback->channelMap);
+        }
+
+        /* The size of the buffer must be a clean multiple of the period count. */
+        periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__dsound(pDescriptorPlayback, pDescriptorPlayback->sampleRate, pConfig->performanceProfile);
+        periodCount = (pDescriptorPlayback->periodCount > 0) ? pDescriptorPlayback->periodCount : MA_DEFAULT_PERIODS;
+
+        /*
+        Meaning of dwFlags (from MSDN):
+
+        DSBCAPS_CTRLPOSITIONNOTIFY
+          The buffer has position notification capability.
+
+        DSBCAPS_GLOBALFOCUS
+          With this flag set, an application using DirectSound can continue to play its buffers if the user switches focus to
+          another application, even if the new application uses DirectSound.
+
+        DSBCAPS_GETCURRENTPOSITION2
+          In the first version of DirectSound, the play cursor was significantly ahead of the actual playing sound on emulated
+          sound cards; it was directly behind the write cursor. Now, if the DSBCAPS_GETCURRENTPOSITION2 flag is specified, the
+          application can get a more accurate play cursor.
+        */
+        MA_ZERO_OBJECT(&descDS);
+        descDS.dwSize = sizeof(descDS);
+        descDS.dwFlags = MA_DSBCAPS_CTRLPOSITIONNOTIFY | MA_DSBCAPS_GLOBALFOCUS | MA_DSBCAPS_GETCURRENTPOSITION2;
+        descDS.dwBufferBytes = periodSizeInFrames * periodCount * ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels);
+        descDS.lpwfxFormat = (MA_WAVEFORMATEX*)pActualFormat;
+        hr = ma_IDirectSound_CreateSoundBuffer((ma_IDirectSound*)pDevice->dsound.pPlayback, &descDS, (ma_IDirectSoundBuffer**)&pDevice->dsound.pPlaybackBuffer, NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_CreateSoundBuffer() failed for playback device's secondary buffer.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* DirectSound should give us a buffer exactly the size we asked for. */
+        pDescriptorPlayback->periodSizeInFrames = periodSizeInFrames;
+        pDescriptorPlayback->periodCount        = periodCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_data_loop__dsound(ma_device* pDevice)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 bpfDeviceCapture  = ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    ma_uint32 bpfDevicePlayback = ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    HRESULT hr;
+    DWORD lockOffsetInBytesCapture;
+    DWORD lockSizeInBytesCapture;
+    DWORD mappedSizeInBytesCapture;
+    DWORD mappedDeviceFramesProcessedCapture;
+    void* pMappedDeviceBufferCapture;
+    DWORD lockOffsetInBytesPlayback;
+    DWORD lockSizeInBytesPlayback;
+    DWORD mappedSizeInBytesPlayback;
+    void* pMappedDeviceBufferPlayback;
+    DWORD prevReadCursorInBytesCapture = 0;
+    DWORD prevPlayCursorInBytesPlayback = 0;
+    ma_bool32 physicalPlayCursorLoopFlagPlayback = 0;
+    DWORD virtualWriteCursorInBytesPlayback = 0;
+    ma_bool32 virtualWriteCursorLoopFlagPlayback = 0;
+    ma_bool32 isPlaybackDeviceStarted = MA_FALSE;
+    ma_uint32 framesWrittenToPlaybackDevice = 0;   /* For knowing whether or not the playback device needs to be started. */
+    ma_uint32 waitTimeInMilliseconds = 1;
+    DWORD playbackBufferStatus = 0;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* The first thing to do is start the capture device. The playback device is only started after the first period is written. */
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        hr = ma_IDirectSoundCaptureBuffer_Start((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, MA_DSCBSTART_LOOPING);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundCaptureBuffer_Start() failed.");
+            return ma_result_from_HRESULT(hr);
+        }
+    }
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started) {
+        switch (pDevice->type)
+        {
+            case ma_device_type_duplex:
+            {
+                DWORD physicalCaptureCursorInBytes;
+                DWORD physicalReadCursorInBytes;
+                hr = ma_IDirectSoundCaptureBuffer_GetCurrentPosition((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, &physicalCaptureCursorInBytes, &physicalReadCursorInBytes);
+                if (FAILED(hr)) {
+                    return ma_result_from_HRESULT(hr);
+                }
+
+                /* If nothing is available we just sleep for a bit and return from this iteration. */
+                if (physicalReadCursorInBytes == prevReadCursorInBytesCapture) {
+                    ma_sleep(waitTimeInMilliseconds);
+                    continue; /* Nothing is available in the capture buffer. */
+                }
+
+                /*
+                The current position has moved. We need to map all of the captured samples and write them to the playback device, making sure
+                we don't return until every frame has been copied over.
+                */
+                if (prevReadCursorInBytesCapture < physicalReadCursorInBytes) {
+                    /* The capture position has not looped. This is the simple case. */
+                    lockOffsetInBytesCapture = prevReadCursorInBytesCapture;
+                    lockSizeInBytesCapture   = (physicalReadCursorInBytes - prevReadCursorInBytesCapture);
+                } else {
+                    /*
+                    The capture position has looped. This is the more complex case. Map to the end of the buffer. If this does not return anything,
+                    do it again from the start.
+                    */
+                    if (prevReadCursorInBytesCapture < pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture) {
+                        /* Lock up to the end of the buffer. */
+                        lockOffsetInBytesCapture = prevReadCursorInBytesCapture;
+                        lockSizeInBytesCapture   = (pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture) - prevReadCursorInBytesCapture;
+                    } else {
+                        /* Lock starting from the start of the buffer. */
+                        lockOffsetInBytesCapture = 0;
+                        lockSizeInBytesCapture   = physicalReadCursorInBytes;
+                    }
+                }
+
+                if (lockSizeInBytesCapture == 0) {
+                    ma_sleep(waitTimeInMilliseconds);
+                    continue; /* Nothing is available in the capture buffer. */
+                }
+
+                hr = ma_IDirectSoundCaptureBuffer_Lock((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, lockOffsetInBytesCapture, lockSizeInBytesCapture, &pMappedDeviceBufferCapture, &mappedSizeInBytesCapture, NULL, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to map buffer from capture device in preparation for writing to the device.");
+                    return ma_result_from_HRESULT(hr);
+                }
+
+
+                /* At this point we have some input data that we need to output. We do not return until every mapped frame of the input data is written to the playback device. */
+                mappedDeviceFramesProcessedCapture = 0;
+
+                for (;;) {  /* Keep writing to the playback device. */
+                    ma_uint8  inputFramesInClientFormat[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                    ma_uint32 inputFramesInClientFormatCap = sizeof(inputFramesInClientFormat) / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+                    ma_uint8  outputFramesInClientFormat[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                    ma_uint32 outputFramesInClientFormatCap = sizeof(outputFramesInClientFormat) / ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+                    ma_uint32 outputFramesInClientFormatCount;
+                    ma_uint32 outputFramesInClientFormatConsumed = 0;
+                    ma_uint64 clientCapturedFramesToProcess = ma_min(inputFramesInClientFormatCap, outputFramesInClientFormatCap);
+                    ma_uint64 deviceCapturedFramesToProcess = (mappedSizeInBytesCapture / bpfDeviceCapture) - mappedDeviceFramesProcessedCapture;
+                    void* pRunningMappedDeviceBufferCapture = ma_offset_ptr(pMappedDeviceBufferCapture, mappedDeviceFramesProcessedCapture * bpfDeviceCapture);
+
+                    result = ma_data_converter_process_pcm_frames(&pDevice->capture.converter, pRunningMappedDeviceBufferCapture, &deviceCapturedFramesToProcess, inputFramesInClientFormat, &clientCapturedFramesToProcess);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    outputFramesInClientFormatCount     = (ma_uint32)clientCapturedFramesToProcess;
+                    mappedDeviceFramesProcessedCapture += (ma_uint32)deviceCapturedFramesToProcess;
+
+                    ma_device__handle_data_callback(pDevice, outputFramesInClientFormat, inputFramesInClientFormat, (ma_uint32)clientCapturedFramesToProcess);
+
+                    /* At this point we have input and output data in client format. All we need to do now is convert it to the output device format. This may take a few passes. */
+                    for (;;) {
+                        ma_uint32 framesWrittenThisIteration;
+                        DWORD physicalPlayCursorInBytes;
+                        DWORD physicalWriteCursorInBytes;
+                        DWORD availableBytesPlayback;
+                        DWORD silentPaddingInBytes = 0; /* <-- Must be initialized to 0. */
+
+                        /* We need the physical play and write cursors. */
+                        if (FAILED(ma_IDirectSoundBuffer_GetCurrentPosition((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, &physicalPlayCursorInBytes, &physicalWriteCursorInBytes))) {
+                            break;
+                        }
+
+                        if (physicalPlayCursorInBytes < prevPlayCursorInBytesPlayback) {
+                            physicalPlayCursorLoopFlagPlayback = !physicalPlayCursorLoopFlagPlayback;
+                        }
+                        prevPlayCursorInBytesPlayback  = physicalPlayCursorInBytes;
+
+                        /* If there's any bytes available for writing we can do that now. The space between the virtual cursor position and play cursor. */
+                        if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                            /* Same loop iteration. The available bytes wraps all the way around from the virtual write cursor to the physical play cursor. */
+                            if (physicalPlayCursorInBytes <= virtualWriteCursorInBytesPlayback) {
+                                availableBytesPlayback  = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                                availableBytesPlayback += physicalPlayCursorInBytes;    /* Wrap around. */
+                            } else {
+                                /* This is an error. */
+                                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback): Play cursor has moved in front of the write cursor (same loop iteration). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCursorInBytesPlayback);
+                                availableBytesPlayback = 0;
+                            }
+                        } else {
+                            /* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
+                            if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
+                                availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                            } else {
+                                /* This is an error. */
+                                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback): Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCursorInBytesPlayback);
+                                availableBytesPlayback = 0;
+                            }
+                        }
+
+                        /* If there's no room available for writing we need to wait for more. */
+                        if (availableBytesPlayback == 0) {
+                            /* If we haven't started the device yet, this will never get beyond 0. In this case we need to get the device started. */
+                            if (!isPlaybackDeviceStarted) {
+                                hr = ma_IDirectSoundBuffer_Play((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0, 0, MA_DSBPLAY_LOOPING);
+                                if (FAILED(hr)) {
+                                    ma_IDirectSoundCaptureBuffer_Stop((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+                                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Play() failed.");
+                                    return ma_result_from_HRESULT(hr);
+                                }
+                                isPlaybackDeviceStarted = MA_TRUE;
+                            } else {
+                                ma_sleep(waitTimeInMilliseconds);
+                                continue;
+                            }
+                        }
+
+
+                        /* Getting here means there room available somewhere. We limit this to either the end of the buffer or the physical play cursor, whichever is closest. */
+                        lockOffsetInBytesPlayback = virtualWriteCursorInBytesPlayback;
+                        if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                            /* Same loop iteration. Go up to the end of the buffer. */
+                            lockSizeInBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                        } else {
+                            /* Different loop iterations. Go up to the physical play cursor. */
+                            lockSizeInBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                        }
+
+                        hr = ma_IDirectSoundBuffer_Lock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, lockOffsetInBytesPlayback, lockSizeInBytesPlayback, &pMappedDeviceBufferPlayback, &mappedSizeInBytesPlayback, NULL, NULL, 0);
+                        if (FAILED(hr)) {
+                            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to map buffer from playback device in preparation for writing to the device.");
+                            result = ma_result_from_HRESULT(hr);
+                            break;
+                        }
+
+                        /*
+                        Experiment: If the playback buffer is being starved, pad it with some silence to get it back in sync. This will cause a glitch, but it may prevent
+                        endless glitching due to it constantly running out of data.
+                        */
+                        if (isPlaybackDeviceStarted) {
+                            DWORD bytesQueuedForPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - availableBytesPlayback;
+                            if (bytesQueuedForPlayback < (pDevice->playback.internalPeriodSizeInFrames*bpfDevicePlayback)) {
+                                silentPaddingInBytes   = (pDevice->playback.internalPeriodSizeInFrames*2*bpfDevicePlayback) - bytesQueuedForPlayback;
+                                if (silentPaddingInBytes > lockSizeInBytesPlayback) {
+                                    silentPaddingInBytes = lockSizeInBytesPlayback;
+                                }
+
+                                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback) Playback buffer starved. availableBytesPlayback=%ld, silentPaddingInBytes=%ld\n", availableBytesPlayback, silentPaddingInBytes);
+                            }
+                        }
+
+                        /* At this point we have a buffer for output. */
+                        if (silentPaddingInBytes > 0) {
+                            MA_ZERO_MEMORY(pMappedDeviceBufferPlayback, silentPaddingInBytes);
+                            framesWrittenThisIteration = silentPaddingInBytes/bpfDevicePlayback;
+                        } else {
+                            ma_uint64 convertedFrameCountIn  = (outputFramesInClientFormatCount - outputFramesInClientFormatConsumed);
+                            ma_uint64 convertedFrameCountOut = mappedSizeInBytesPlayback/bpfDevicePlayback;
+                            void* pConvertedFramesIn  = ma_offset_ptr(outputFramesInClientFormat, outputFramesInClientFormatConsumed * bpfDevicePlayback);
+                            void* pConvertedFramesOut = pMappedDeviceBufferPlayback;
+
+                            result = ma_data_converter_process_pcm_frames(&pDevice->playback.converter, pConvertedFramesIn, &convertedFrameCountIn, pConvertedFramesOut, &convertedFrameCountOut);
+                            if (result != MA_SUCCESS) {
+                                break;
+                            }
+
+                            outputFramesInClientFormatConsumed += (ma_uint32)convertedFrameCountOut;
+                            framesWrittenThisIteration          = (ma_uint32)convertedFrameCountOut;
+                        }
+
+
+                        hr = ma_IDirectSoundBuffer_Unlock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, pMappedDeviceBufferPlayback, framesWrittenThisIteration*bpfDevicePlayback, NULL, 0);
+                        if (FAILED(hr)) {
+                            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to unlock internal buffer from playback device after writing to the device.");
+                            result = ma_result_from_HRESULT(hr);
+                            break;
+                        }
+
+                        virtualWriteCursorInBytesPlayback += framesWrittenThisIteration*bpfDevicePlayback;
+                        if ((virtualWriteCursorInBytesPlayback/bpfDevicePlayback) == pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods) {
+                            virtualWriteCursorInBytesPlayback  = 0;
+                            virtualWriteCursorLoopFlagPlayback = !virtualWriteCursorLoopFlagPlayback;
+                        }
+
+                        /*
+                        We may need to start the device. We want two full periods to be written before starting the playback device. Having an extra period adds
+                        a bit of a buffer to prevent the playback buffer from getting starved.
+                        */
+                        framesWrittenToPlaybackDevice += framesWrittenThisIteration;
+                        if (!isPlaybackDeviceStarted && framesWrittenToPlaybackDevice >= (pDevice->playback.internalPeriodSizeInFrames*2)) {
+                            hr = ma_IDirectSoundBuffer_Play((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0, 0, MA_DSBPLAY_LOOPING);
+                            if (FAILED(hr)) {
+                                ma_IDirectSoundCaptureBuffer_Stop((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+                                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Play() failed.");
+                                return ma_result_from_HRESULT(hr);
+                            }
+                            isPlaybackDeviceStarted = MA_TRUE;
+                        }
+
+                        if (framesWrittenThisIteration < mappedSizeInBytesPlayback/bpfDevicePlayback) {
+                            break;  /* We're finished with the output data.*/
+                        }
+                    }
+
+                    if (clientCapturedFramesToProcess == 0) {
+                        break;  /* We just consumed every input sample. */
+                    }
+                }
+
+
+                /* At this point we're done with the mapped portion of the capture buffer. */
+                hr = ma_IDirectSoundCaptureBuffer_Unlock((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, pMappedDeviceBufferCapture, mappedSizeInBytesCapture, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to unlock internal buffer from capture device after reading from the device.");
+                    return ma_result_from_HRESULT(hr);
+                }
+                prevReadCursorInBytesCapture = (lockOffsetInBytesCapture + mappedSizeInBytesCapture);
+            } break;
+
+
+
+            case ma_device_type_capture:
+            {
+                DWORD physicalCaptureCursorInBytes;
+                DWORD physicalReadCursorInBytes;
+                hr = ma_IDirectSoundCaptureBuffer_GetCurrentPosition((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, &physicalCaptureCursorInBytes, &physicalReadCursorInBytes);
+                if (FAILED(hr)) {
+                    return MA_ERROR;
+                }
+
+                /* If the previous capture position is the same as the current position we need to wait a bit longer. */
+                if (prevReadCursorInBytesCapture == physicalReadCursorInBytes) {
+                    ma_sleep(waitTimeInMilliseconds);
+                    continue;
+                }
+
+                /* Getting here means we have capture data available. */
+                if (prevReadCursorInBytesCapture < physicalReadCursorInBytes) {
+                    /* The capture position has not looped. This is the simple case. */
+                    lockOffsetInBytesCapture = prevReadCursorInBytesCapture;
+                    lockSizeInBytesCapture   = (physicalReadCursorInBytes - prevReadCursorInBytesCapture);
+                } else {
+                    /*
+                    The capture position has looped. This is the more complex case. Map to the end of the buffer. If this does not return anything,
+                    do it again from the start.
+                    */
+                    if (prevReadCursorInBytesCapture < pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture) {
+                        /* Lock up to the end of the buffer. */
+                        lockOffsetInBytesCapture = prevReadCursorInBytesCapture;
+                        lockSizeInBytesCapture   = (pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture) - prevReadCursorInBytesCapture;
+                    } else {
+                        /* Lock starting from the start of the buffer. */
+                        lockOffsetInBytesCapture = 0;
+                        lockSizeInBytesCapture   = physicalReadCursorInBytes;
+                    }
+                }
+
+                if (lockSizeInBytesCapture < pDevice->capture.internalPeriodSizeInFrames) {
+                    ma_sleep(waitTimeInMilliseconds);
+                    continue; /* Nothing is available in the capture buffer. */
+                }
+
+                hr = ma_IDirectSoundCaptureBuffer_Lock((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, lockOffsetInBytesCapture, lockSizeInBytesCapture, &pMappedDeviceBufferCapture, &mappedSizeInBytesCapture, NULL, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to map buffer from capture device in preparation for writing to the device.");
+                    result = ma_result_from_HRESULT(hr);
+                }
+
+                if (lockSizeInBytesCapture != mappedSizeInBytesCapture) {
+                    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[DirectSound] (Capture) lockSizeInBytesCapture=%ld != mappedSizeInBytesCapture=%ld\n", lockSizeInBytesCapture, mappedSizeInBytesCapture);
+                }
+
+                ma_device__send_frames_to_client(pDevice, mappedSizeInBytesCapture/bpfDeviceCapture, pMappedDeviceBufferCapture);
+
+                hr = ma_IDirectSoundCaptureBuffer_Unlock((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, pMappedDeviceBufferCapture, mappedSizeInBytesCapture, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to unlock internal buffer from capture device after reading from the device.");
+                    return ma_result_from_HRESULT(hr);
+                }
+                prevReadCursorInBytesCapture = lockOffsetInBytesCapture + mappedSizeInBytesCapture;
+
+                if (prevReadCursorInBytesCapture == (pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture)) {
+                    prevReadCursorInBytesCapture = 0;
+                }
+            } break;
+
+
+
+            case ma_device_type_playback:
+            {
+                DWORD availableBytesPlayback;
+                DWORD physicalPlayCursorInBytes;
+                DWORD physicalWriteCursorInBytes;
+                hr = ma_IDirectSoundBuffer_GetCurrentPosition((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, &physicalPlayCursorInBytes, &physicalWriteCursorInBytes);
+                if (FAILED(hr)) {
+                    break;
+                }
+
+                hr = ma_IDirectSoundBuffer_GetStatus((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, &playbackBufferStatus);
+                if (SUCCEEDED(hr) && (playbackBufferStatus & MA_DSBSTATUS_PLAYING) == 0 && isPlaybackDeviceStarted) {
+                    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[DirectSound] Attempting to resume audio due to state: %d.", (int)playbackBufferStatus);
+                    hr = ma_IDirectSoundBuffer_Play((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0, 0, MA_DSBPLAY_LOOPING);
+                    if (FAILED(hr)) {
+                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Play() failed after attempting to resume from state %d.", (int)playbackBufferStatus);
+                        return ma_result_from_HRESULT(hr);
+                    }
+
+                    isPlaybackDeviceStarted = MA_TRUE;
+                    ma_sleep(waitTimeInMilliseconds);
+                    continue;
+                }
+
+                if (physicalPlayCursorInBytes < prevPlayCursorInBytesPlayback) {
+                    physicalPlayCursorLoopFlagPlayback = !physicalPlayCursorLoopFlagPlayback;
+                }
+                prevPlayCursorInBytesPlayback  = physicalPlayCursorInBytes;
+
+                /* If there's any bytes available for writing we can do that now. The space between the virtual cursor position and play cursor. */
+                if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                    /* Same loop iteration. The available bytes wraps all the way around from the virtual write cursor to the physical play cursor. */
+                    if (physicalPlayCursorInBytes <= virtualWriteCursorInBytesPlayback) {
+                        availableBytesPlayback  = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                        availableBytesPlayback += physicalPlayCursorInBytes;    /* Wrap around. */
+                    } else {
+                        /* This is an error. */
+                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Playback): Play cursor has moved in front of the write cursor (same loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCursorInBytesPlayback);
+                        availableBytesPlayback = 0;
+                    }
+                } else {
+                    /* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
+                    if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
+                        availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                    } else {
+                        /* This is an error. */
+                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Playback): Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCursorInBytesPlayback);
+                        availableBytesPlayback = 0;
+                    }
+                }
+
+                /* If there's no room available for writing we need to wait for more. */
+                if (availableBytesPlayback < pDevice->playback.internalPeriodSizeInFrames) {
+                    /* If we haven't started the device yet, this will never get beyond 0. In this case we need to get the device started. */
+                    if (availableBytesPlayback == 0 && !isPlaybackDeviceStarted) {
+                        hr = ma_IDirectSoundBuffer_Play((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0, 0, MA_DSBPLAY_LOOPING);
+                        if (FAILED(hr)) {
+                            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Play() failed.");
+                            return ma_result_from_HRESULT(hr);
+                        }
+                        isPlaybackDeviceStarted = MA_TRUE;
+                    } else {
+                        ma_sleep(waitTimeInMilliseconds);
+                        continue;
+                    }
+                }
+
+                /* Getting here means there room available somewhere. We limit this to either the end of the buffer or the physical play cursor, whichever is closest. */
+                lockOffsetInBytesPlayback = virtualWriteCursorInBytesPlayback;
+                if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                    /* Same loop iteration. Go up to the end of the buffer. */
+                    lockSizeInBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                } else {
+                    /* Different loop iterations. Go up to the physical play cursor. */
+                    lockSizeInBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                }
+
+                hr = ma_IDirectSoundBuffer_Lock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, lockOffsetInBytesPlayback, lockSizeInBytesPlayback, &pMappedDeviceBufferPlayback, &mappedSizeInBytesPlayback, NULL, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to map buffer from playback device in preparation for writing to the device.");
+                    result = ma_result_from_HRESULT(hr);
+                    break;
+                }
+
+                /* At this point we have a buffer for output. */
+                ma_device__read_frames_from_client(pDevice, (mappedSizeInBytesPlayback/bpfDevicePlayback), pMappedDeviceBufferPlayback);
+
+                hr = ma_IDirectSoundBuffer_Unlock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, pMappedDeviceBufferPlayback, mappedSizeInBytesPlayback, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to unlock internal buffer from playback device after writing to the device.");
+                    result = ma_result_from_HRESULT(hr);
+                    break;
+                }
+
+                virtualWriteCursorInBytesPlayback += mappedSizeInBytesPlayback;
+                if (virtualWriteCursorInBytesPlayback == pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) {
+                    virtualWriteCursorInBytesPlayback  = 0;
+                    virtualWriteCursorLoopFlagPlayback = !virtualWriteCursorLoopFlagPlayback;
+                }
+
+                /*
+                We may need to start the device. We want two full periods to be written before starting the playback device. Having an extra period adds
+                a bit of a buffer to prevent the playback buffer from getting starved.
+                */
+                framesWrittenToPlaybackDevice += mappedSizeInBytesPlayback/bpfDevicePlayback;
+                if (!isPlaybackDeviceStarted && framesWrittenToPlaybackDevice >= pDevice->playback.internalPeriodSizeInFrames) {
+                    hr = ma_IDirectSoundBuffer_Play((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0, 0, MA_DSBPLAY_LOOPING);
+                    if (FAILED(hr)) {
+                        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Play() failed.");
+                        return ma_result_from_HRESULT(hr);
+                    }
+                    isPlaybackDeviceStarted = MA_TRUE;
+                }
+            } break;
+
+
+            default: return MA_INVALID_ARGS;   /* Invalid device type. */
+        }
+
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    /* Getting here means the device is being stopped. */
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        hr = ma_IDirectSoundCaptureBuffer_Stop((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundCaptureBuffer_Stop() failed.");
+            return ma_result_from_HRESULT(hr);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /* The playback device should be drained before stopping. All we do is wait until the available bytes is equal to the size of the buffer. */
+        if (isPlaybackDeviceStarted) {
+            for (;;) {
+                DWORD availableBytesPlayback = 0;
+                DWORD physicalPlayCursorInBytes;
+                DWORD physicalWriteCursorInBytes;
+                hr = ma_IDirectSoundBuffer_GetCurrentPosition((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, &physicalPlayCursorInBytes, &physicalWriteCursorInBytes);
+                if (FAILED(hr)) {
+                    break;
+                }
+
+                if (physicalPlayCursorInBytes < prevPlayCursorInBytesPlayback) {
+                    physicalPlayCursorLoopFlagPlayback = !physicalPlayCursorLoopFlagPlayback;
+                }
+                prevPlayCursorInBytesPlayback  = physicalPlayCursorInBytes;
+
+                if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                    /* Same loop iteration. The available bytes wraps all the way around from the virtual write cursor to the physical play cursor. */
+                    if (physicalPlayCursorInBytes <= virtualWriteCursorInBytesPlayback) {
+                        availableBytesPlayback  = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                        availableBytesPlayback += physicalPlayCursorInBytes;    /* Wrap around. */
+                    } else {
+                        break;
+                    }
+                } else {
+                    /* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
+                    if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
+                        availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                    } else {
+                        break;
+                    }
+                }
+
+                if (availableBytesPlayback >= (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback)) {
+                    break;
+                }
+
+                ma_sleep(waitTimeInMilliseconds);
+            }
+        }
+
+        hr = ma_IDirectSoundBuffer_Stop((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Stop() failed.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        ma_IDirectSoundBuffer_SetCurrentPosition((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__dsound(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_dsound);
+
+    ma_dlclose(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__dsound(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+    pContext->dsound.hDSoundDLL = ma_dlopen(ma_context_get_log(pContext), "dsound.dll");
+    if (pContext->dsound.hDSoundDLL == NULL) {
+        return MA_API_NOT_FOUND;
+    }
+
+    pContext->dsound.DirectSoundCreate            = ma_dlsym(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL, "DirectSoundCreate");
+    pContext->dsound.DirectSoundEnumerateA        = ma_dlsym(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL, "DirectSoundEnumerateA");
+    pContext->dsound.DirectSoundCaptureCreate     = ma_dlsym(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL, "DirectSoundCaptureCreate");
+    pContext->dsound.DirectSoundCaptureEnumerateA = ma_dlsym(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL, "DirectSoundCaptureEnumerateA");
+
+    /*
+    We need to support all functions or nothing. DirectSound with Windows 95 seems to not work too
+    well in my testing. For example, it's missing DirectSoundCaptureEnumerateA(). This is a convenient
+    place to just disable the DirectSound backend for Windows 95.
+    */
+    if (pContext->dsound.DirectSoundCreate            == NULL ||
+        pContext->dsound.DirectSoundEnumerateA        == NULL ||
+        pContext->dsound.DirectSoundCaptureCreate     == NULL ||
+        pContext->dsound.DirectSoundCaptureEnumerateA == NULL) {
+        return MA_API_NOT_FOUND;
+    }
+
+    pContext->dsound.hWnd = pConfig->dsound.hWnd;
+
+    pCallbacks->onContextInit             = ma_context_init__dsound;
+    pCallbacks->onContextUninit           = ma_context_uninit__dsound;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__dsound;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__dsound;
+    pCallbacks->onDeviceInit              = ma_device_init__dsound;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__dsound;
+    pCallbacks->onDeviceStart             = NULL;   /* Not used. Started in onDeviceDataLoop. */
+    pCallbacks->onDeviceStop              = NULL;   /* Not used. Stopped in onDeviceDataLoop. */
+    pCallbacks->onDeviceRead              = NULL;   /* Not used. Data is read directly in onDeviceDataLoop. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not used. Data is written directly in onDeviceDataLoop. */
+    pCallbacks->onDeviceDataLoop          = ma_device_data_loop__dsound;
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+
+/******************************************************************************
+
+WinMM Backend
+
+******************************************************************************/
+#ifdef MA_HAS_WINMM
+
+/*
+Some build configurations will exclude the WinMM API. An example is when WIN32_LEAN_AND_MEAN
+is defined. We need to define the types and functions we need manually.
+*/
+#define MA_MMSYSERR_NOERROR     0
+#define MA_MMSYSERR_ERROR       1
+#define MA_MMSYSERR_BADDEVICEID 2
+#define MA_MMSYSERR_INVALHANDLE 5
+#define MA_MMSYSERR_NOMEM       7
+#define MA_MMSYSERR_INVALFLAG   10
+#define MA_MMSYSERR_INVALPARAM  11
+#define MA_MMSYSERR_HANDLEBUSY  12
+
+#define MA_CALLBACK_EVENT       0x00050000
+#define MA_WAVE_ALLOWSYNC       0x0002
+
+#define MA_WHDR_DONE            0x00000001
+#define MA_WHDR_PREPARED        0x00000002
+#define MA_WHDR_BEGINLOOP       0x00000004
+#define MA_WHDR_ENDLOOP         0x00000008
+#define MA_WHDR_INQUEUE         0x00000010
+
+#define MA_MAXPNAMELEN          32
+
+typedef void* MA_HWAVEIN;
+typedef void* MA_HWAVEOUT;
+typedef UINT MA_MMRESULT;
+typedef UINT MA_MMVERSION;
+
+typedef struct
+{
+    WORD wMid;
+    WORD wPid;
+    MA_MMVERSION vDriverVersion;
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    WORD wReserved1;
+} MA_WAVEINCAPSA;
+
+typedef struct
+{
+    WORD wMid;
+    WORD wPid;
+    MA_MMVERSION vDriverVersion;
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    WORD wReserved1;
+    DWORD dwSupport;
+} MA_WAVEOUTCAPSA;
+
+typedef struct tagWAVEHDR
+{
+    char* lpData;
+    DWORD dwBufferLength;
+    DWORD dwBytesRecorded;
+    DWORD_PTR dwUser;
+    DWORD dwFlags;
+    DWORD dwLoops;
+    struct tagWAVEHDR* lpNext;
+    DWORD_PTR reserved;
+} MA_WAVEHDR;
+
+typedef struct
+{
+    WORD wMid;
+    WORD wPid;
+    MA_MMVERSION vDriverVersion;
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    WORD wReserved1;
+    DWORD dwSupport;
+    GUID ManufacturerGuid;
+    GUID ProductGuid;
+    GUID NameGuid;
+} MA_WAVEOUTCAPS2A;
+
+typedef struct
+{
+    WORD wMid;
+    WORD wPid;
+    MA_MMVERSION vDriverVersion;
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    WORD wReserved1;
+    GUID ManufacturerGuid;
+    GUID ProductGuid;
+    GUID NameGuid;
+} MA_WAVEINCAPS2A;
+
+typedef UINT        (WINAPI * MA_PFN_waveOutGetNumDevs)(void);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutGetDevCapsA)(ma_uintptr uDeviceID, MA_WAVEOUTCAPSA* pwoc, UINT cbwoc);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutOpen)(MA_HWAVEOUT* phwo, UINT uDeviceID, const MA_WAVEFORMATEX* pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutClose)(MA_HWAVEOUT hwo);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutPrepareHeader)(MA_HWAVEOUT hwo, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutUnprepareHeader)(MA_HWAVEOUT hwo, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutWrite)(MA_HWAVEOUT hwo, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutReset)(MA_HWAVEOUT hwo);
+typedef UINT        (WINAPI * MA_PFN_waveInGetNumDevs)(void);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInGetDevCapsA)(ma_uintptr uDeviceID, MA_WAVEINCAPSA* pwic, UINT cbwic);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInOpen)(MA_HWAVEIN* phwi, UINT uDeviceID, const MA_WAVEFORMATEX* pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInClose)(MA_HWAVEIN hwi);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInPrepareHeader)(MA_HWAVEIN hwi, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInUnprepareHeader)(MA_HWAVEIN hwi, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInAddBuffer)(MA_HWAVEIN hwi, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInStart)(MA_HWAVEIN hwi);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInReset)(MA_HWAVEIN hwi);
+
+static ma_result ma_result_from_MMRESULT(MA_MMRESULT resultMM)
+{
+    switch (resultMM)
+    {
+        case MA_MMSYSERR_NOERROR:       return MA_SUCCESS;
+        case MA_MMSYSERR_BADDEVICEID:   return MA_INVALID_ARGS;
+        case MA_MMSYSERR_INVALHANDLE:   return MA_INVALID_ARGS;
+        case MA_MMSYSERR_NOMEM:         return MA_OUT_OF_MEMORY;
+        case MA_MMSYSERR_INVALFLAG:     return MA_INVALID_ARGS;
+        case MA_MMSYSERR_INVALPARAM:    return MA_INVALID_ARGS;
+        case MA_MMSYSERR_HANDLEBUSY:    return MA_BUSY;
+        case MA_MMSYSERR_ERROR:         return MA_ERROR;
+        default:                        return MA_ERROR;
+    }
+}
+
+static char* ma_find_last_character(char* str, char ch)
+{
+    char* last;
+
+    if (str == NULL) {
+        return NULL;
+    }
+
+    last = NULL;
+    while (*str != '\0') {
+        if (*str == ch) {
+            last = str;
+        }
+
+        str += 1;
+    }
+
+    return last;
+}
+
+static ma_uint32 ma_get_period_size_in_bytes(ma_uint32 periodSizeInFrames, ma_format format, ma_uint32 channels)
+{
+    return periodSizeInFrames * ma_get_bytes_per_frame(format, channels);
+}
+
+
+/*
+Our own "WAVECAPS" structure that contains generic information shared between WAVEOUTCAPS2 and WAVEINCAPS2 so
+we can do things generically and typesafely. Names are being kept the same for consistency.
+*/
+typedef struct
+{
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    GUID NameGuid;
+} MA_WAVECAPSA;
+
+static ma_result ma_get_best_info_from_formats_flags__winmm(DWORD dwFormats, WORD channels, WORD* pBitsPerSample, DWORD* pSampleRate)
+{
+    WORD bitsPerSample = 0;
+    DWORD sampleRate = 0;
+
+    if (pBitsPerSample) {
+        *pBitsPerSample = 0;
+    }
+    if (pSampleRate) {
+        *pSampleRate = 0;
+    }
+
+    if (channels == 1) {
+        bitsPerSample = 16;
+        if ((dwFormats & WAVE_FORMAT_48M16) != 0) {
+            sampleRate = 48000;
+        } else if ((dwFormats & WAVE_FORMAT_44M16) != 0) {
+            sampleRate = 44100;
+        } else if ((dwFormats & WAVE_FORMAT_2M16) != 0) {
+            sampleRate = 22050;
+        } else if ((dwFormats & WAVE_FORMAT_1M16) != 0) {
+            sampleRate = 11025;
+        } else if ((dwFormats & WAVE_FORMAT_96M16) != 0) {
+            sampleRate = 96000;
+        } else {
+            bitsPerSample = 8;
+            if ((dwFormats & WAVE_FORMAT_48M08) != 0) {
+                sampleRate = 48000;
+            } else if ((dwFormats & WAVE_FORMAT_44M08) != 0) {
+                sampleRate = 44100;
+            } else if ((dwFormats & WAVE_FORMAT_2M08) != 0) {
+                sampleRate = 22050;
+            } else if ((dwFormats & WAVE_FORMAT_1M08) != 0) {
+                sampleRate = 11025;
+            } else if ((dwFormats & WAVE_FORMAT_96M08) != 0) {
+                sampleRate = 96000;
+            } else {
+                return MA_FORMAT_NOT_SUPPORTED;
+            }
+        }
+    } else {
+        bitsPerSample = 16;
+        if ((dwFormats & WAVE_FORMAT_48S16) != 0) {
+            sampleRate = 48000;
+        } else if ((dwFormats & WAVE_FORMAT_44S16) != 0) {
+            sampleRate = 44100;
+        } else if ((dwFormats & WAVE_FORMAT_2S16) != 0) {
+            sampleRate = 22050;
+        } else if ((dwFormats & WAVE_FORMAT_1S16) != 0) {
+            sampleRate = 11025;
+        } else if ((dwFormats & WAVE_FORMAT_96S16) != 0) {
+            sampleRate = 96000;
+        } else {
+            bitsPerSample = 8;
+            if ((dwFormats & WAVE_FORMAT_48S08) != 0) {
+                sampleRate = 48000;
+            } else if ((dwFormats & WAVE_FORMAT_44S08) != 0) {
+                sampleRate = 44100;
+            } else if ((dwFormats & WAVE_FORMAT_2S08) != 0) {
+                sampleRate = 22050;
+            } else if ((dwFormats & WAVE_FORMAT_1S08) != 0) {
+                sampleRate = 11025;
+            } else if ((dwFormats & WAVE_FORMAT_96S08) != 0) {
+                sampleRate = 96000;
+            } else {
+                return MA_FORMAT_NOT_SUPPORTED;
+            }
+        }
+    }
+
+    if (pBitsPerSample) {
+        *pBitsPerSample = bitsPerSample;
+    }
+    if (pSampleRate) {
+        *pSampleRate = sampleRate;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_formats_flags_to_WAVEFORMATEX__winmm(DWORD dwFormats, WORD channels, MA_WAVEFORMATEX* pWF)
+{
+    ma_result result;
+
+    MA_ASSERT(pWF != NULL);
+
+    MA_ZERO_OBJECT(pWF);
+    pWF->cbSize     = sizeof(*pWF);
+    pWF->wFormatTag = WAVE_FORMAT_PCM;
+    pWF->nChannels  = (WORD)channels;
+    if (pWF->nChannels > 2) {
+        pWF->nChannels = 2;
+    }
+
+    result = ma_get_best_info_from_formats_flags__winmm(dwFormats, channels, &pWF->wBitsPerSample, &pWF->nSamplesPerSec);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pWF->nBlockAlign     = (WORD)(pWF->nChannels * pWF->wBitsPerSample / 8);
+    pWF->nAvgBytesPerSec = pWF->nBlockAlign * pWF->nSamplesPerSec;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info_from_WAVECAPS(ma_context* pContext, MA_WAVECAPSA* pCaps, ma_device_info* pDeviceInfo)
+{
+    WORD bitsPerSample;
+    DWORD sampleRate;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCaps != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    /*
+    Name / Description
+
+    Unfortunately the name specified in WAVE(OUT/IN)CAPS2 is limited to 31 characters. This results in an unprofessional looking
+    situation where the names of the devices are truncated. To help work around this, we need to look at the name GUID and try
+    looking in the registry for the full name. If we can't find it there, we need to just fall back to the default name.
+    */
+
+    /* Set the default to begin with. */
+    ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), pCaps->szPname, (size_t)-1);
+
+    /*
+    Now try the registry. There's a few things to consider here:
+    - The name GUID can be null, in which we case we just need to stick to the original 31 characters.
+    - If the name GUID is not present in the registry we'll also need to stick to the original 31 characters.
+    - I like consistency, so I want the returned device names to be consistent with those returned by WASAPI and DirectSound. The
+      problem, however is that WASAPI and DirectSound use "<component> (<name>)" format (such as "Speakers (High Definition Audio)"),
+      but WinMM does not specify the component name. From my admittedly limited testing, I've notice the component name seems to
+      usually fit within the 31 characters of the fixed sized buffer, so what I'm going to do is parse that string for the component
+      name, and then concatenate the name from the registry.
+    */
+    if (!ma_is_guid_null(&pCaps->NameGuid)) {
+        WCHAR guidStrW[256];
+        if (((MA_PFN_StringFromGUID2)pContext->win32.StringFromGUID2)(&pCaps->NameGuid, guidStrW, ma_countof(guidStrW)) > 0) {
+            char guidStr[256];
+            char keyStr[1024];
+            HKEY hKey;
+
+            WideCharToMultiByte(CP_UTF8, 0, guidStrW, -1, guidStr, sizeof(guidStr), 0, FALSE);
+
+            ma_strcpy_s(keyStr, sizeof(keyStr), "SYSTEM\\CurrentControlSet\\Control\\MediaCategories\\");
+            ma_strcat_s(keyStr, sizeof(keyStr), guidStr);
+
+            if (((MA_PFN_RegOpenKeyExA)pContext->win32.RegOpenKeyExA)(HKEY_LOCAL_MACHINE, keyStr, 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
+                BYTE nameFromReg[512];
+                DWORD nameFromRegSize = sizeof(nameFromReg);
+                LONG resultWin32 = ((MA_PFN_RegQueryValueExA)pContext->win32.RegQueryValueExA)(hKey, "Name", 0, NULL, (BYTE*)nameFromReg, (DWORD*)&nameFromRegSize);
+                ((MA_PFN_RegCloseKey)pContext->win32.RegCloseKey)(hKey);
+
+                if (resultWin32 == ERROR_SUCCESS) {
+                    /* We have the value from the registry, so now we need to construct the name string. */
+                    char name[1024];
+                    if (ma_strcpy_s(name, sizeof(name), pDeviceInfo->name) == 0) {
+                        char* nameBeg = ma_find_last_character(name, '(');
+                        if (nameBeg != NULL) {
+                            size_t leadingLen = (nameBeg - name);
+                            ma_strncpy_s(nameBeg + 1, sizeof(name) - leadingLen, (const char*)nameFromReg, (size_t)-1);
+
+                            /* The closing ")", if it can fit. */
+                            if (leadingLen + nameFromRegSize < sizeof(name)-1) {
+                                ma_strcat_s(name, sizeof(name), ")");
+                            }
+
+                            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), name, (size_t)-1);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    result = ma_get_best_info_from_formats_flags__winmm(pCaps->dwFormats, pCaps->wChannels, &bitsPerSample, &sampleRate);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (bitsPerSample == 8) {
+        pDeviceInfo->nativeDataFormats[0].format = ma_format_u8;
+    } else if (bitsPerSample == 16) {
+        pDeviceInfo->nativeDataFormats[0].format = ma_format_s16;
+    } else if (bitsPerSample == 24) {
+        pDeviceInfo->nativeDataFormats[0].format = ma_format_s24;
+    } else if (bitsPerSample == 32) {
+        pDeviceInfo->nativeDataFormats[0].format = ma_format_s32;
+    } else {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+    pDeviceInfo->nativeDataFormats[0].channels   = pCaps->wChannels;
+    pDeviceInfo->nativeDataFormats[0].sampleRate = sampleRate;
+    pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pDeviceInfo->nativeDataFormatCount = 1;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info_from_WAVEOUTCAPS2(ma_context* pContext, MA_WAVEOUTCAPS2A* pCaps, ma_device_info* pDeviceInfo)
+{
+    MA_WAVECAPSA caps;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCaps != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    MA_COPY_MEMORY(caps.szPname, pCaps->szPname, sizeof(caps.szPname));
+    caps.dwFormats = pCaps->dwFormats;
+    caps.wChannels = pCaps->wChannels;
+    caps.NameGuid  = pCaps->NameGuid;
+    return ma_context_get_device_info_from_WAVECAPS(pContext, &caps, pDeviceInfo);
+}
+
+static ma_result ma_context_get_device_info_from_WAVEINCAPS2(ma_context* pContext, MA_WAVEINCAPS2A* pCaps, ma_device_info* pDeviceInfo)
+{
+    MA_WAVECAPSA caps;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCaps != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    MA_COPY_MEMORY(caps.szPname, pCaps->szPname, sizeof(caps.szPname));
+    caps.dwFormats = pCaps->dwFormats;
+    caps.wChannels = pCaps->wChannels;
+    caps.NameGuid  = pCaps->NameGuid;
+    return ma_context_get_device_info_from_WAVECAPS(pContext, &caps, pDeviceInfo);
+}
+
+
+static ma_result ma_context_enumerate_devices__winmm(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    UINT playbackDeviceCount;
+    UINT captureDeviceCount;
+    UINT iPlaybackDevice;
+    UINT iCaptureDevice;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Playback. */
+    playbackDeviceCount = ((MA_PFN_waveOutGetNumDevs)pContext->winmm.waveOutGetNumDevs)();
+    for (iPlaybackDevice = 0; iPlaybackDevice < playbackDeviceCount; ++iPlaybackDevice) {
+        MA_MMRESULT result;
+        MA_WAVEOUTCAPS2A caps;
+
+        MA_ZERO_OBJECT(&caps);
+
+        result = ((MA_PFN_waveOutGetDevCapsA)pContext->winmm.waveOutGetDevCapsA)(iPlaybackDevice, (MA_WAVEOUTCAPSA*)&caps, sizeof(caps));
+        if (result == MA_MMSYSERR_NOERROR) {
+            ma_device_info deviceInfo;
+
+            MA_ZERO_OBJECT(&deviceInfo);
+            deviceInfo.id.winmm = iPlaybackDevice;
+
+            /* The first enumerated device is the default device. */
+            if (iPlaybackDevice == 0) {
+                deviceInfo.isDefault = MA_TRUE;
+            }
+
+            if (ma_context_get_device_info_from_WAVEOUTCAPS2(pContext, &caps, &deviceInfo) == MA_SUCCESS) {
+                ma_bool32 cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                if (cbResult == MA_FALSE) {
+                    return MA_SUCCESS; /* Enumeration was stopped. */
+                }
+            }
+        }
+    }
+
+    /* Capture. */
+    captureDeviceCount = ((MA_PFN_waveInGetNumDevs)pContext->winmm.waveInGetNumDevs)();
+    for (iCaptureDevice = 0; iCaptureDevice < captureDeviceCount; ++iCaptureDevice) {
+        MA_MMRESULT result;
+        MA_WAVEINCAPS2A caps;
+
+        MA_ZERO_OBJECT(&caps);
+
+        result = ((MA_PFN_waveInGetDevCapsA)pContext->winmm.waveInGetDevCapsA)(iCaptureDevice, (MA_WAVEINCAPSA*)&caps, sizeof(caps));
+        if (result == MA_MMSYSERR_NOERROR) {
+            ma_device_info deviceInfo;
+
+            MA_ZERO_OBJECT(&deviceInfo);
+            deviceInfo.id.winmm = iCaptureDevice;
+
+            /* The first enumerated device is the default device. */
+            if (iCaptureDevice == 0) {
+                deviceInfo.isDefault = MA_TRUE;
+            }
+
+            if (ma_context_get_device_info_from_WAVEINCAPS2(pContext, &caps, &deviceInfo) == MA_SUCCESS) {
+                ma_bool32 cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                if (cbResult == MA_FALSE) {
+                    return MA_SUCCESS; /* Enumeration was stopped. */
+                }
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__winmm(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    UINT winMMDeviceID;
+
+    MA_ASSERT(pContext != NULL);
+
+    winMMDeviceID = 0;
+    if (pDeviceID != NULL) {
+        winMMDeviceID = (UINT)pDeviceID->winmm;
+    }
+
+    pDeviceInfo->id.winmm = winMMDeviceID;
+
+    /* The first ID is the default device. */
+    if (winMMDeviceID == 0) {
+        pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        MA_MMRESULT result;
+        MA_WAVEOUTCAPS2A caps;
+
+        MA_ZERO_OBJECT(&caps);
+
+        result = ((MA_PFN_waveOutGetDevCapsA)pContext->winmm.waveOutGetDevCapsA)(winMMDeviceID, (MA_WAVEOUTCAPSA*)&caps, sizeof(caps));
+        if (result == MA_MMSYSERR_NOERROR) {
+            return ma_context_get_device_info_from_WAVEOUTCAPS2(pContext, &caps, pDeviceInfo);
+        }
+    } else {
+        MA_MMRESULT result;
+        MA_WAVEINCAPS2A caps;
+
+        MA_ZERO_OBJECT(&caps);
+
+        result = ((MA_PFN_waveInGetDevCapsA)pContext->winmm.waveInGetDevCapsA)(winMMDeviceID, (MA_WAVEINCAPSA*)&caps, sizeof(caps));
+        if (result == MA_MMSYSERR_NOERROR) {
+            return ma_context_get_device_info_from_WAVEINCAPS2(pContext, &caps, pDeviceInfo);
+        }
+    }
+
+    return MA_NO_DEVICE;
+}
+
+
+static ma_result ma_device_uninit__winmm(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((MA_PFN_waveInClose)pDevice->pContext->winmm.waveInClose)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture);
+        CloseHandle((HANDLE)pDevice->winmm.hEventCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ((MA_PFN_waveOutReset)pDevice->pContext->winmm.waveOutReset)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback);
+        ((MA_PFN_waveOutClose)pDevice->pContext->winmm.waveOutClose)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback);
+        CloseHandle((HANDLE)pDevice->winmm.hEventPlayback);
+    }
+
+    ma_free(pDevice->winmm._pHeapData, &pDevice->pContext->allocationCallbacks);
+
+    MA_ZERO_OBJECT(&pDevice->winmm);   /* Safety. */
+
+    return MA_SUCCESS;
+}
+
+static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__winmm(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    /* WinMM has a minimum period size of 40ms. */
+    ma_uint32 minPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(40, nativeSampleRate);
+    ma_uint32 periodSizeInFrames;
+
+    periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, nativeSampleRate, performanceProfile);
+    if (periodSizeInFrames < minPeriodSizeInFrames) {
+        periodSizeInFrames = minPeriodSizeInFrames;
+    }
+
+    return periodSizeInFrames;
+}
+
+static ma_result ma_device_init__winmm(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    const char* errorMsg = "";
+    ma_result errorCode = MA_ERROR;
+    ma_result result = MA_SUCCESS;
+    ma_uint32 heapSize;
+    UINT winMMDeviceIDPlayback = 0;
+    UINT winMMDeviceIDCapture  = 0;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->winmm);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* No exclusive mode with WinMM. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    if (pDescriptorPlayback->pDeviceID != NULL) {
+        winMMDeviceIDPlayback = (UINT)pDescriptorPlayback->pDeviceID->winmm;
+    }
+    if (pDescriptorCapture->pDeviceID != NULL) {
+        winMMDeviceIDCapture = (UINT)pDescriptorCapture->pDeviceID->winmm;
+    }
+
+    /* The capture device needs to be initialized first. */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        MA_WAVEINCAPSA caps;
+        MA_WAVEFORMATEX wf;
+        MA_MMRESULT resultMM;
+
+        /* We use an event to know when a new fragment needs to be enqueued. */
+        pDevice->winmm.hEventCapture = (ma_handle)CreateEventA(NULL, TRUE, TRUE, NULL);
+        if (pDevice->winmm.hEventCapture == NULL) {
+            errorMsg = "[WinMM] Failed to create event for fragment enqueuing for the capture device.", errorCode = ma_result_from_GetLastError(GetLastError());
+            goto on_error;
+        }
+
+        /* The format should be based on the device's actual format. */
+        if (((MA_PFN_waveInGetDevCapsA)pDevice->pContext->winmm.waveInGetDevCapsA)(winMMDeviceIDCapture, &caps, sizeof(caps)) != MA_MMSYSERR_NOERROR) {
+            errorMsg = "[WinMM] Failed to retrieve internal device caps.", errorCode = MA_FORMAT_NOT_SUPPORTED;
+            goto on_error;
+        }
+
+        result = ma_formats_flags_to_WAVEFORMATEX__winmm(caps.dwFormats, caps.wChannels, &wf);
+        if (result != MA_SUCCESS) {
+            errorMsg = "[WinMM] Could not find appropriate format for internal device.", errorCode = result;
+            goto on_error;
+        }
+
+        resultMM = ((MA_PFN_waveInOpen)pDevice->pContext->winmm.waveInOpen)((MA_HWAVEIN*)&pDevice->winmm.hDeviceCapture, winMMDeviceIDCapture, &wf, (DWORD_PTR)pDevice->winmm.hEventCapture, (DWORD_PTR)pDevice, MA_CALLBACK_EVENT | MA_WAVE_ALLOWSYNC);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            errorMsg = "[WinMM] Failed to open capture device.", errorCode = MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+            goto on_error;
+        }
+
+        pDescriptorCapture->format             = ma_format_from_WAVEFORMATEX(&wf);
+        pDescriptorCapture->channels           = wf.nChannels;
+        pDescriptorCapture->sampleRate         = wf.nSamplesPerSec;
+        ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorCapture->channels);
+        pDescriptorCapture->periodCount        = pDescriptorCapture->periodCount;
+        pDescriptorCapture->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__winmm(pDescriptorCapture, pDescriptorCapture->sampleRate, pConfig->performanceProfile);
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        MA_WAVEOUTCAPSA caps;
+        MA_WAVEFORMATEX wf;
+        MA_MMRESULT resultMM;
+
+        /* We use an event to know when a new fragment needs to be enqueued. */
+        pDevice->winmm.hEventPlayback = (ma_handle)CreateEventA(NULL, TRUE, TRUE, NULL);
+        if (pDevice->winmm.hEventPlayback == NULL) {
+            errorMsg = "[WinMM] Failed to create event for fragment enqueuing for the playback device.", errorCode = ma_result_from_GetLastError(GetLastError());
+            goto on_error;
+        }
+
+        /* The format should be based on the device's actual format. */
+        if (((MA_PFN_waveOutGetDevCapsA)pDevice->pContext->winmm.waveOutGetDevCapsA)(winMMDeviceIDPlayback, &caps, sizeof(caps)) != MA_MMSYSERR_NOERROR) {
+            errorMsg = "[WinMM] Failed to retrieve internal device caps.", errorCode = MA_FORMAT_NOT_SUPPORTED;
+            goto on_error;
+        }
+
+        result = ma_formats_flags_to_WAVEFORMATEX__winmm(caps.dwFormats, caps.wChannels, &wf);
+        if (result != MA_SUCCESS) {
+            errorMsg = "[WinMM] Could not find appropriate format for internal device.", errorCode = result;
+            goto on_error;
+        }
+
+        resultMM = ((MA_PFN_waveOutOpen)pDevice->pContext->winmm.waveOutOpen)((MA_HWAVEOUT*)&pDevice->winmm.hDevicePlayback, winMMDeviceIDPlayback, &wf, (DWORD_PTR)pDevice->winmm.hEventPlayback, (DWORD_PTR)pDevice, MA_CALLBACK_EVENT | MA_WAVE_ALLOWSYNC);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            errorMsg = "[WinMM] Failed to open playback device.", errorCode = MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+            goto on_error;
+        }
+
+        pDescriptorPlayback->format             = ma_format_from_WAVEFORMATEX(&wf);
+        pDescriptorPlayback->channels           = wf.nChannels;
+        pDescriptorPlayback->sampleRate         = wf.nSamplesPerSec;
+        ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pDescriptorPlayback->channelMap, ma_countof(pDescriptorPlayback->channelMap), pDescriptorPlayback->channels);
+        pDescriptorPlayback->periodCount        = pDescriptorPlayback->periodCount;
+        pDescriptorPlayback->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__winmm(pDescriptorPlayback, pDescriptorPlayback->sampleRate, pConfig->performanceProfile);
+    }
+
+    /*
+    The heap allocated data is allocated like so:
+
+    [Capture WAVEHDRs][Playback WAVEHDRs][Capture Intermediary Buffer][Playback Intermediary Buffer]
+    */
+    heapSize = 0;
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        heapSize += sizeof(MA_WAVEHDR)*pDescriptorCapture->periodCount + (pDescriptorCapture->periodSizeInFrames * pDescriptorCapture->periodCount * ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels));
+    }
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        heapSize += sizeof(MA_WAVEHDR)*pDescriptorPlayback->periodCount + (pDescriptorPlayback->periodSizeInFrames * pDescriptorPlayback->periodCount * ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels));
+    }
+
+    pDevice->winmm._pHeapData = (ma_uint8*)ma_calloc(heapSize, &pDevice->pContext->allocationCallbacks);
+    if (pDevice->winmm._pHeapData == NULL) {
+        errorMsg = "[WinMM] Failed to allocate memory for the intermediary buffer.", errorCode = MA_OUT_OF_MEMORY;
+        goto on_error;
+    }
+
+    MA_ZERO_MEMORY(pDevice->winmm._pHeapData, heapSize);
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_uint32 iPeriod;
+
+        if (pConfig->deviceType == ma_device_type_capture) {
+            pDevice->winmm.pWAVEHDRCapture            = pDevice->winmm._pHeapData;
+            pDevice->winmm.pIntermediaryBufferCapture = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*(pDescriptorCapture->periodCount));
+        } else {
+            pDevice->winmm.pWAVEHDRCapture            = pDevice->winmm._pHeapData;
+            pDevice->winmm.pIntermediaryBufferCapture = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*(pDescriptorCapture->periodCount + pDescriptorPlayback->periodCount));
+        }
+
+        /* Prepare headers. */
+        for (iPeriod = 0; iPeriod < pDescriptorCapture->periodCount; ++iPeriod) {
+            ma_uint32 periodSizeInBytes = ma_get_period_size_in_bytes(pDescriptorCapture->periodSizeInFrames, pDescriptorCapture->format, pDescriptorCapture->channels);
+
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].lpData         = (char*)(pDevice->winmm.pIntermediaryBufferCapture + (periodSizeInBytes*iPeriod));
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].dwBufferLength = periodSizeInBytes;
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].dwFlags        = 0L;
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].dwLoops        = 0L;
+            ((MA_PFN_waveInPrepareHeader)pDevice->pContext->winmm.waveInPrepareHeader)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod], sizeof(MA_WAVEHDR));
+
+            /*
+            The user data of the MA_WAVEHDR structure is a single flag the controls whether or not it is ready for writing. Consider it to be named "isLocked". A value of 0 means
+            it's unlocked and available for writing. A value of 1 means it's locked.
+            */
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].dwUser = 0;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_uint32 iPeriod;
+
+        if (pConfig->deviceType == ma_device_type_playback) {
+            pDevice->winmm.pWAVEHDRPlayback            = pDevice->winmm._pHeapData;
+            pDevice->winmm.pIntermediaryBufferPlayback = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*pDescriptorPlayback->periodCount);
+        } else {
+            pDevice->winmm.pWAVEHDRPlayback            = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*(pDescriptorCapture->periodCount));
+            pDevice->winmm.pIntermediaryBufferPlayback = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*(pDescriptorCapture->periodCount + pDescriptorPlayback->periodCount)) + (pDescriptorCapture->periodSizeInFrames*pDescriptorCapture->periodCount*ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels));
+        }
+
+        /* Prepare headers. */
+        for (iPeriod = 0; iPeriod < pDescriptorPlayback->periodCount; ++iPeriod) {
+            ma_uint32 periodSizeInBytes = ma_get_period_size_in_bytes(pDescriptorPlayback->periodSizeInFrames, pDescriptorPlayback->format, pDescriptorPlayback->channels);
+
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].lpData         = (char*)(pDevice->winmm.pIntermediaryBufferPlayback + (periodSizeInBytes*iPeriod));
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].dwBufferLength = periodSizeInBytes;
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].dwFlags        = 0L;
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].dwLoops        = 0L;
+            ((MA_PFN_waveOutPrepareHeader)pDevice->pContext->winmm.waveOutPrepareHeader)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod], sizeof(MA_WAVEHDR));
+
+            /*
+            The user data of the MA_WAVEHDR structure is a single flag the controls whether or not it is ready for writing. Consider it to be named "isLocked". A value of 0 means
+            it's unlocked and available for writing. A value of 1 means it's locked.
+            */
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].dwUser = 0;
+        }
+    }
+
+    return MA_SUCCESS;
+
+on_error:
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->winmm.pWAVEHDRCapture != NULL) {
+            ma_uint32 iPeriod;
+            for (iPeriod = 0; iPeriod < pDescriptorCapture->periodCount; ++iPeriod) {
+                ((MA_PFN_waveInUnprepareHeader)pDevice->pContext->winmm.waveInUnprepareHeader)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod], sizeof(MA_WAVEHDR));
+            }
+        }
+
+        ((MA_PFN_waveInClose)pDevice->pContext->winmm.waveInClose)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->winmm.pWAVEHDRCapture != NULL) {
+            ma_uint32 iPeriod;
+            for (iPeriod = 0; iPeriod < pDescriptorPlayback->periodCount; ++iPeriod) {
+                ((MA_PFN_waveOutUnprepareHeader)pDevice->pContext->winmm.waveOutUnprepareHeader)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod], sizeof(MA_WAVEHDR));
+            }
+        }
+
+        ((MA_PFN_waveOutClose)pDevice->pContext->winmm.waveOutClose)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback);
+    }
+
+    ma_free(pDevice->winmm._pHeapData, &pDevice->pContext->allocationCallbacks);
+
+    if (errorMsg != NULL && errorMsg[0] != '\0') {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "%s", errorMsg);
+    }
+
+    return errorCode;
+}
+
+static ma_result ma_device_start__winmm(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        MA_MMRESULT resultMM;
+        MA_WAVEHDR* pWAVEHDR;
+        ma_uint32 iPeriod;
+
+        pWAVEHDR = (MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture;
+
+        /* Make sure the event is reset to a non-signaled state to ensure we don't prematurely return from WaitForSingleObject(). */
+        ResetEvent((HANDLE)pDevice->winmm.hEventCapture);
+
+        /* To start the device we attach all of the buffers and then start it. As the buffers are filled with data we will get notifications. */
+        for (iPeriod = 0; iPeriod < pDevice->capture.internalPeriods; ++iPeriod) {
+            resultMM = ((MA_PFN_waveInAddBuffer)pDevice->pContext->winmm.waveInAddBuffer)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod], sizeof(MA_WAVEHDR));
+            if (resultMM != MA_MMSYSERR_NOERROR) {
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WinMM] Failed to attach input buffers to capture device in preparation for capture.");
+                return ma_result_from_MMRESULT(resultMM);
+            }
+
+            /* Make sure all of the buffers start out locked. We don't want to access them until the backend tells us we can. */
+            pWAVEHDR[iPeriod].dwUser = 1;   /* 1 = locked. */
+        }
+
+        /* Capture devices need to be explicitly started, unlike playback devices. */
+        resultMM = ((MA_PFN_waveInStart)pDevice->pContext->winmm.waveInStart)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WinMM] Failed to start backend device.");
+            return ma_result_from_MMRESULT(resultMM);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /* Don't need to do anything for playback. It'll be started automatically in ma_device_start__winmm(). */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__winmm(ma_device* pDevice)
+{
+    MA_MMRESULT resultMM;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->winmm.hDeviceCapture == NULL) {
+            return MA_INVALID_ARGS;
+        }
+
+        resultMM = ((MA_PFN_waveInReset)pDevice->pContext->winmm.waveInReset)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[WinMM] WARNING: Failed to reset capture device.");
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_uint32 iPeriod;
+        MA_WAVEHDR* pWAVEHDR;
+
+        if (pDevice->winmm.hDevicePlayback == NULL) {
+            return MA_INVALID_ARGS;
+        }
+
+        /* We need to drain the device. To do this we just loop over each header and if it's locked just wait for the event. */
+        pWAVEHDR = (MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback;
+        for (iPeriod = 0; iPeriod < pDevice->playback.internalPeriods; iPeriod += 1) {
+            if (pWAVEHDR[iPeriod].dwUser == 1) { /* 1 = locked. */
+                if (WaitForSingleObject((HANDLE)pDevice->winmm.hEventPlayback, INFINITE) != WAIT_OBJECT_0) {
+                    break;  /* An error occurred so just abandon ship and stop the device without draining. */
+                }
+
+                pWAVEHDR[iPeriod].dwUser = 0;
+            }
+        }
+
+        resultMM = ((MA_PFN_waveOutReset)pDevice->pContext->winmm.waveOutReset)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[WinMM] WARNING: Failed to reset playback device.");
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__winmm(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    ma_result result = MA_SUCCESS;
+    MA_MMRESULT resultMM;
+    ma_uint32 totalFramesWritten;
+    MA_WAVEHDR* pWAVEHDR;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pPCMFrames != NULL);
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    pWAVEHDR = (MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback;
+
+    /* Keep processing as much data as possible. */
+    totalFramesWritten = 0;
+    while (totalFramesWritten < frameCount) {
+        /* If the current header has some space available we need to write part of it. */
+        if (pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwUser == 0) { /* 0 = unlocked. */
+            /*
+            This header has room in it. We copy as much of it as we can. If we end up fully consuming the buffer we need to
+            write it out and move on to the next iteration.
+            */
+            ma_uint32 bpf = ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+            ma_uint32 framesRemainingInHeader = (pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwBufferLength/bpf) - pDevice->winmm.headerFramesConsumedPlayback;
+
+            ma_uint32 framesToCopy = ma_min(framesRemainingInHeader, (frameCount - totalFramesWritten));
+            const void* pSrc = ma_offset_ptr(pPCMFrames, totalFramesWritten*bpf);
+            void* pDst = ma_offset_ptr(pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].lpData, pDevice->winmm.headerFramesConsumedPlayback*bpf);
+            MA_COPY_MEMORY(pDst, pSrc, framesToCopy*bpf);
+
+            pDevice->winmm.headerFramesConsumedPlayback += framesToCopy;
+            totalFramesWritten += framesToCopy;
+
+            /* If we've consumed the buffer entirely we need to write it out to the device. */
+            if (pDevice->winmm.headerFramesConsumedPlayback == (pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwBufferLength/bpf)) {
+                pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwUser = 1;            /* 1 = locked. */
+                pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwFlags &= ~MA_WHDR_DONE; /* <-- Need to make sure the WHDR_DONE flag is unset. */
+
+                /* Make sure the event is reset to a non-signaled state to ensure we don't prematurely return from WaitForSingleObject(). */
+                ResetEvent((HANDLE)pDevice->winmm.hEventPlayback);
+
+                /* The device will be started here. */
+                resultMM = ((MA_PFN_waveOutWrite)pDevice->pContext->winmm.waveOutWrite)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback, &pWAVEHDR[pDevice->winmm.iNextHeaderPlayback], sizeof(MA_WAVEHDR));
+                if (resultMM != MA_MMSYSERR_NOERROR) {
+                    result = ma_result_from_MMRESULT(resultMM);
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WinMM] waveOutWrite() failed.");
+                    break;
+                }
+
+                /* Make sure we move to the next header. */
+                pDevice->winmm.iNextHeaderPlayback = (pDevice->winmm.iNextHeaderPlayback + 1) % pDevice->playback.internalPeriods;
+                pDevice->winmm.headerFramesConsumedPlayback = 0;
+            }
+
+            /* If at this point we have consumed the entire input buffer we can return. */
+            MA_ASSERT(totalFramesWritten <= frameCount);
+            if (totalFramesWritten == frameCount) {
+                break;
+            }
+
+            /* Getting here means there's more to process. */
+            continue;
+        }
+
+        /* Getting here means there isn't enough room in the buffer and we need to wait for one to become available. */
+        if (WaitForSingleObject((HANDLE)pDevice->winmm.hEventPlayback, INFINITE) != WAIT_OBJECT_0) {
+            result = MA_ERROR;
+            break;
+        }
+
+        /* Something happened. If the next buffer has been marked as done we need to reset a bit of state. */
+        if ((pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwFlags & MA_WHDR_DONE) != 0) {
+            pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwUser = 0;    /* 0 = unlocked (make it available for writing). */
+            pDevice->winmm.headerFramesConsumedPlayback = 0;
+        }
+
+        /* If the device has been stopped we need to break. */
+        if (ma_device_get_state(pDevice) != ma_device_state_started) {
+            break;
+        }
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = totalFramesWritten;
+    }
+
+    return result;
+}
+
+static ma_result ma_device_read__winmm(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    MA_MMRESULT resultMM;
+    ma_uint32 totalFramesRead;
+    MA_WAVEHDR* pWAVEHDR;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pPCMFrames != NULL);
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    pWAVEHDR = (MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture;
+
+    /* Keep processing as much data as possible. */
+    totalFramesRead = 0;
+    while (totalFramesRead < frameCount) {
+        /* If the current header has some space available we need to write part of it. */
+        if (pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwUser == 0) { /* 0 = unlocked. */
+            /* The buffer is available for reading. If we fully consume it we need to add it back to the buffer. */
+            ma_uint32 bpf = ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+            ma_uint32 framesRemainingInHeader = (pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwBufferLength/bpf) - pDevice->winmm.headerFramesConsumedCapture;
+
+            ma_uint32 framesToCopy = ma_min(framesRemainingInHeader, (frameCount - totalFramesRead));
+            const void* pSrc = ma_offset_ptr(pWAVEHDR[pDevice->winmm.iNextHeaderCapture].lpData, pDevice->winmm.headerFramesConsumedCapture*bpf);
+            void* pDst = ma_offset_ptr(pPCMFrames, totalFramesRead*bpf);
+            MA_COPY_MEMORY(pDst, pSrc, framesToCopy*bpf);
+
+            pDevice->winmm.headerFramesConsumedCapture += framesToCopy;
+            totalFramesRead += framesToCopy;
+
+            /* If we've consumed the buffer entirely we need to add it back to the device. */
+            if (pDevice->winmm.headerFramesConsumedCapture == (pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwBufferLength/bpf)) {
+                pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwUser = 1;            /* 1 = locked. */
+                pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwFlags &= ~MA_WHDR_DONE; /* <-- Need to make sure the WHDR_DONE flag is unset. */
+
+                /* Make sure the event is reset to a non-signaled state to ensure we don't prematurely return from WaitForSingleObject(). */
+                ResetEvent((HANDLE)pDevice->winmm.hEventCapture);
+
+                /* The device will be started here. */
+                resultMM = ((MA_PFN_waveInAddBuffer)pDevice->pContext->winmm.waveInAddBuffer)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[pDevice->winmm.iNextHeaderCapture], sizeof(MA_WAVEHDR));
+                if (resultMM != MA_MMSYSERR_NOERROR) {
+                    result = ma_result_from_MMRESULT(resultMM);
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WinMM] waveInAddBuffer() failed.");
+                    break;
+                }
+
+                /* Make sure we move to the next header. */
+                pDevice->winmm.iNextHeaderCapture = (pDevice->winmm.iNextHeaderCapture + 1) % pDevice->capture.internalPeriods;
+                pDevice->winmm.headerFramesConsumedCapture = 0;
+            }
+
+            /* If at this point we have filled the entire input buffer we can return. */
+            MA_ASSERT(totalFramesRead <= frameCount);
+            if (totalFramesRead == frameCount) {
+                break;
+            }
+
+            /* Getting here means there's more to process. */
+            continue;
+        }
+
+        /* Getting here means there isn't enough any data left to send to the client which means we need to wait for more. */
+        if (WaitForSingleObject((HANDLE)pDevice->winmm.hEventCapture, INFINITE) != WAIT_OBJECT_0) {
+            result = MA_ERROR;
+            break;
+        }
+
+        /* Something happened. If the next buffer has been marked as done we need to reset a bit of state. */
+        if ((pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwFlags & MA_WHDR_DONE) != 0) {
+            pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwUser = 0;    /* 0 = unlocked (make it available for reading). */
+            pDevice->winmm.headerFramesConsumedCapture = 0;
+        }
+
+        /* If the device has been stopped we need to break. */
+        if (ma_device_get_state(pDevice) != ma_device_state_started) {
+            break;
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesRead;
+    }
+
+    return result;
+}
+
+static ma_result ma_context_uninit__winmm(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_winmm);
+
+    ma_dlclose(ma_context_get_log(pContext), pContext->winmm.hWinMM);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__winmm(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+    pContext->winmm.hWinMM = ma_dlopen(ma_context_get_log(pContext), "winmm.dll");
+    if (pContext->winmm.hWinMM == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    pContext->winmm.waveOutGetNumDevs      = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutGetNumDevs");
+    pContext->winmm.waveOutGetDevCapsA     = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutGetDevCapsA");
+    pContext->winmm.waveOutOpen            = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutOpen");
+    pContext->winmm.waveOutClose           = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutClose");
+    pContext->winmm.waveOutPrepareHeader   = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutPrepareHeader");
+    pContext->winmm.waveOutUnprepareHeader = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutUnprepareHeader");
+    pContext->winmm.waveOutWrite           = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutWrite");
+    pContext->winmm.waveOutReset           = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutReset");
+    pContext->winmm.waveInGetNumDevs       = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInGetNumDevs");
+    pContext->winmm.waveInGetDevCapsA      = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInGetDevCapsA");
+    pContext->winmm.waveInOpen             = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInOpen");
+    pContext->winmm.waveInClose            = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInClose");
+    pContext->winmm.waveInPrepareHeader    = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInPrepareHeader");
+    pContext->winmm.waveInUnprepareHeader  = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInUnprepareHeader");
+    pContext->winmm.waveInAddBuffer        = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInAddBuffer");
+    pContext->winmm.waveInStart            = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInStart");
+    pContext->winmm.waveInReset            = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInReset");
+
+    pCallbacks->onContextInit             = ma_context_init__winmm;
+    pCallbacks->onContextUninit           = ma_context_uninit__winmm;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__winmm;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__winmm;
+    pCallbacks->onDeviceInit              = ma_device_init__winmm;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__winmm;
+    pCallbacks->onDeviceStart             = ma_device_start__winmm;
+    pCallbacks->onDeviceStop              = ma_device_stop__winmm;
+    pCallbacks->onDeviceRead              = ma_device_read__winmm;
+    pCallbacks->onDeviceWrite             = ma_device_write__winmm;
+    pCallbacks->onDeviceDataLoop          = NULL;   /* This is a blocking read-write API, so this can be NULL since miniaudio will manage the audio thread for us. */
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+
+
+/******************************************************************************
+
+ALSA Backend
+
+******************************************************************************/
+#ifdef MA_HAS_ALSA
+
+#include <poll.h>           /* poll(), struct pollfd */
+#include <sys/eventfd.h>    /* eventfd() */
+
+#ifdef MA_NO_RUNTIME_LINKING
+
+/* asoundlib.h marks some functions with "inline" which isn't always supported. Need to emulate it. */
+#if !defined(__cplusplus)
+    #if defined(__STRICT_ANSI__)
+        #if !defined(inline)
+            #define inline __inline__ __attribute__((always_inline))
+            #define MA_INLINE_DEFINED
+        #endif
+    #endif
+#endif
+#include <alsa/asoundlib.h>
+#if defined(MA_INLINE_DEFINED)
+    #undef inline
+    #undef MA_INLINE_DEFINED
+#endif
+
+typedef snd_pcm_uframes_t                       ma_snd_pcm_uframes_t;
+typedef snd_pcm_sframes_t                       ma_snd_pcm_sframes_t;
+typedef snd_pcm_stream_t                        ma_snd_pcm_stream_t;
+typedef snd_pcm_format_t                        ma_snd_pcm_format_t;
+typedef snd_pcm_access_t                        ma_snd_pcm_access_t;
+typedef snd_pcm_t                               ma_snd_pcm_t;
+typedef snd_pcm_hw_params_t                     ma_snd_pcm_hw_params_t;
+typedef snd_pcm_sw_params_t                     ma_snd_pcm_sw_params_t;
+typedef snd_pcm_format_mask_t                   ma_snd_pcm_format_mask_t;
+typedef snd_pcm_info_t                          ma_snd_pcm_info_t;
+typedef snd_pcm_channel_area_t                  ma_snd_pcm_channel_area_t;
+typedef snd_pcm_chmap_t                         ma_snd_pcm_chmap_t;
+typedef snd_pcm_state_t                         ma_snd_pcm_state_t;
+
+/* snd_pcm_state_t */
+#define MA_SND_PCM_STATE_XRUN                   SND_PCM_STATE_XRUN
+
+/* snd_pcm_stream_t */
+#define MA_SND_PCM_STREAM_PLAYBACK              SND_PCM_STREAM_PLAYBACK
+#define MA_SND_PCM_STREAM_CAPTURE               SND_PCM_STREAM_CAPTURE
+
+/* snd_pcm_format_t */
+#define MA_SND_PCM_FORMAT_UNKNOWN               SND_PCM_FORMAT_UNKNOWN
+#define MA_SND_PCM_FORMAT_U8                    SND_PCM_FORMAT_U8
+#define MA_SND_PCM_FORMAT_S16_LE                SND_PCM_FORMAT_S16_LE
+#define MA_SND_PCM_FORMAT_S16_BE                SND_PCM_FORMAT_S16_BE
+#define MA_SND_PCM_FORMAT_S24_LE                SND_PCM_FORMAT_S24_LE
+#define MA_SND_PCM_FORMAT_S24_BE                SND_PCM_FORMAT_S24_BE
+#define MA_SND_PCM_FORMAT_S32_LE                SND_PCM_FORMAT_S32_LE
+#define MA_SND_PCM_FORMAT_S32_BE                SND_PCM_FORMAT_S32_BE
+#define MA_SND_PCM_FORMAT_FLOAT_LE              SND_PCM_FORMAT_FLOAT_LE
+#define MA_SND_PCM_FORMAT_FLOAT_BE              SND_PCM_FORMAT_FLOAT_BE
+#define MA_SND_PCM_FORMAT_FLOAT64_LE            SND_PCM_FORMAT_FLOAT64_LE
+#define MA_SND_PCM_FORMAT_FLOAT64_BE            SND_PCM_FORMAT_FLOAT64_BE
+#define MA_SND_PCM_FORMAT_MU_LAW                SND_PCM_FORMAT_MU_LAW
+#define MA_SND_PCM_FORMAT_A_LAW                 SND_PCM_FORMAT_A_LAW
+#define MA_SND_PCM_FORMAT_S24_3LE               SND_PCM_FORMAT_S24_3LE
+#define MA_SND_PCM_FORMAT_S24_3BE               SND_PCM_FORMAT_S24_3BE
+
+/* ma_snd_pcm_access_t */
+#define MA_SND_PCM_ACCESS_MMAP_INTERLEAVED      SND_PCM_ACCESS_MMAP_INTERLEAVED
+#define MA_SND_PCM_ACCESS_MMAP_NONINTERLEAVED   SND_PCM_ACCESS_MMAP_NONINTERLEAVED
+#define MA_SND_PCM_ACCESS_MMAP_COMPLEX          SND_PCM_ACCESS_MMAP_COMPLEX
+#define MA_SND_PCM_ACCESS_RW_INTERLEAVED        SND_PCM_ACCESS_RW_INTERLEAVED
+#define MA_SND_PCM_ACCESS_RW_NONINTERLEAVED     SND_PCM_ACCESS_RW_NONINTERLEAVED
+
+/* Channel positions. */
+#define MA_SND_CHMAP_UNKNOWN                    SND_CHMAP_UNKNOWN
+#define MA_SND_CHMAP_NA                         SND_CHMAP_NA
+#define MA_SND_CHMAP_MONO                       SND_CHMAP_MONO
+#define MA_SND_CHMAP_FL                         SND_CHMAP_FL
+#define MA_SND_CHMAP_FR                         SND_CHMAP_FR
+#define MA_SND_CHMAP_RL                         SND_CHMAP_RL
+#define MA_SND_CHMAP_RR                         SND_CHMAP_RR
+#define MA_SND_CHMAP_FC                         SND_CHMAP_FC
+#define MA_SND_CHMAP_LFE                        SND_CHMAP_LFE
+#define MA_SND_CHMAP_SL                         SND_CHMAP_SL
+#define MA_SND_CHMAP_SR                         SND_CHMAP_SR
+#define MA_SND_CHMAP_RC                         SND_CHMAP_RC
+#define MA_SND_CHMAP_FLC                        SND_CHMAP_FLC
+#define MA_SND_CHMAP_FRC                        SND_CHMAP_FRC
+#define MA_SND_CHMAP_RLC                        SND_CHMAP_RLC
+#define MA_SND_CHMAP_RRC                        SND_CHMAP_RRC
+#define MA_SND_CHMAP_FLW                        SND_CHMAP_FLW
+#define MA_SND_CHMAP_FRW                        SND_CHMAP_FRW
+#define MA_SND_CHMAP_FLH                        SND_CHMAP_FLH
+#define MA_SND_CHMAP_FCH                        SND_CHMAP_FCH
+#define MA_SND_CHMAP_FRH                        SND_CHMAP_FRH
+#define MA_SND_CHMAP_TC                         SND_CHMAP_TC
+#define MA_SND_CHMAP_TFL                        SND_CHMAP_TFL
+#define MA_SND_CHMAP_TFR                        SND_CHMAP_TFR
+#define MA_SND_CHMAP_TFC                        SND_CHMAP_TFC
+#define MA_SND_CHMAP_TRL                        SND_CHMAP_TRL
+#define MA_SND_CHMAP_TRR                        SND_CHMAP_TRR
+#define MA_SND_CHMAP_TRC                        SND_CHMAP_TRC
+#define MA_SND_CHMAP_TFLC                       SND_CHMAP_TFLC
+#define MA_SND_CHMAP_TFRC                       SND_CHMAP_TFRC
+#define MA_SND_CHMAP_TSL                        SND_CHMAP_TSL
+#define MA_SND_CHMAP_TSR                        SND_CHMAP_TSR
+#define MA_SND_CHMAP_LLFE                       SND_CHMAP_LLFE
+#define MA_SND_CHMAP_RLFE                       SND_CHMAP_RLFE
+#define MA_SND_CHMAP_BC                         SND_CHMAP_BC
+#define MA_SND_CHMAP_BLC                        SND_CHMAP_BLC
+#define MA_SND_CHMAP_BRC                        SND_CHMAP_BRC
+
+/* Open mode flags. */
+#define MA_SND_PCM_NO_AUTO_RESAMPLE             SND_PCM_NO_AUTO_RESAMPLE
+#define MA_SND_PCM_NO_AUTO_CHANNELS             SND_PCM_NO_AUTO_CHANNELS
+#define MA_SND_PCM_NO_AUTO_FORMAT               SND_PCM_NO_AUTO_FORMAT
+#else
+#include <errno.h>  /* For EPIPE, etc. */
+typedef unsigned long                           ma_snd_pcm_uframes_t;
+typedef long                                    ma_snd_pcm_sframes_t;
+typedef int                                     ma_snd_pcm_stream_t;
+typedef int                                     ma_snd_pcm_format_t;
+typedef int                                     ma_snd_pcm_access_t;
+typedef int                                     ma_snd_pcm_state_t;
+typedef struct ma_snd_pcm_t                     ma_snd_pcm_t;
+typedef struct ma_snd_pcm_hw_params_t           ma_snd_pcm_hw_params_t;
+typedef struct ma_snd_pcm_sw_params_t           ma_snd_pcm_sw_params_t;
+typedef struct ma_snd_pcm_format_mask_t         ma_snd_pcm_format_mask_t;
+typedef struct ma_snd_pcm_info_t                ma_snd_pcm_info_t;
+typedef struct
+{
+    void* addr;
+    unsigned int first;
+    unsigned int step;
+} ma_snd_pcm_channel_area_t;
+typedef struct
+{
+    unsigned int channels;
+    unsigned int pos[1];
+} ma_snd_pcm_chmap_t;
+
+/* snd_pcm_state_t */
+#define MA_SND_PCM_STATE_OPEN                  0
+#define MA_SND_PCM_STATE_SETUP                 1
+#define MA_SND_PCM_STATE_PREPARED              2
+#define MA_SND_PCM_STATE_RUNNING               3
+#define MA_SND_PCM_STATE_XRUN                  4
+#define MA_SND_PCM_STATE_DRAINING              5
+#define MA_SND_PCM_STATE_PAUSED                6
+#define MA_SND_PCM_STATE_SUSPENDED             7
+#define MA_SND_PCM_STATE_DISCONNECTED          8
+
+/* snd_pcm_stream_t */
+#define MA_SND_PCM_STREAM_PLAYBACK             0
+#define MA_SND_PCM_STREAM_CAPTURE              1
+
+/* snd_pcm_format_t */
+#define MA_SND_PCM_FORMAT_UNKNOWN              -1
+#define MA_SND_PCM_FORMAT_U8                   1
+#define MA_SND_PCM_FORMAT_S16_LE               2
+#define MA_SND_PCM_FORMAT_S16_BE               3
+#define MA_SND_PCM_FORMAT_S24_LE               6
+#define MA_SND_PCM_FORMAT_S24_BE               7
+#define MA_SND_PCM_FORMAT_S32_LE               10
+#define MA_SND_PCM_FORMAT_S32_BE               11
+#define MA_SND_PCM_FORMAT_FLOAT_LE             14
+#define MA_SND_PCM_FORMAT_FLOAT_BE             15
+#define MA_SND_PCM_FORMAT_FLOAT64_LE           16
+#define MA_SND_PCM_FORMAT_FLOAT64_BE           17
+#define MA_SND_PCM_FORMAT_MU_LAW               20
+#define MA_SND_PCM_FORMAT_A_LAW                21
+#define MA_SND_PCM_FORMAT_S24_3LE              32
+#define MA_SND_PCM_FORMAT_S24_3BE              33
+
+/* snd_pcm_access_t */
+#define MA_SND_PCM_ACCESS_MMAP_INTERLEAVED     0
+#define MA_SND_PCM_ACCESS_MMAP_NONINTERLEAVED  1
+#define MA_SND_PCM_ACCESS_MMAP_COMPLEX         2
+#define MA_SND_PCM_ACCESS_RW_INTERLEAVED       3
+#define MA_SND_PCM_ACCESS_RW_NONINTERLEAVED    4
+
+/* Channel positions. */
+#define MA_SND_CHMAP_UNKNOWN                   0
+#define MA_SND_CHMAP_NA                        1
+#define MA_SND_CHMAP_MONO                      2
+#define MA_SND_CHMAP_FL                        3
+#define MA_SND_CHMAP_FR                        4
+#define MA_SND_CHMAP_RL                        5
+#define MA_SND_CHMAP_RR                        6
+#define MA_SND_CHMAP_FC                        7
+#define MA_SND_CHMAP_LFE                       8
+#define MA_SND_CHMAP_SL                        9
+#define MA_SND_CHMAP_SR                        10
+#define MA_SND_CHMAP_RC                        11
+#define MA_SND_CHMAP_FLC                       12
+#define MA_SND_CHMAP_FRC                       13
+#define MA_SND_CHMAP_RLC                       14
+#define MA_SND_CHMAP_RRC                       15
+#define MA_SND_CHMAP_FLW                       16
+#define MA_SND_CHMAP_FRW                       17
+#define MA_SND_CHMAP_FLH                       18
+#define MA_SND_CHMAP_FCH                       19
+#define MA_SND_CHMAP_FRH                       20
+#define MA_SND_CHMAP_TC                        21
+#define MA_SND_CHMAP_TFL                       22
+#define MA_SND_CHMAP_TFR                       23
+#define MA_SND_CHMAP_TFC                       24
+#define MA_SND_CHMAP_TRL                       25
+#define MA_SND_CHMAP_TRR                       26
+#define MA_SND_CHMAP_TRC                       27
+#define MA_SND_CHMAP_TFLC                      28
+#define MA_SND_CHMAP_TFRC                      29
+#define MA_SND_CHMAP_TSL                       30
+#define MA_SND_CHMAP_TSR                       31
+#define MA_SND_CHMAP_LLFE                      32
+#define MA_SND_CHMAP_RLFE                      33
+#define MA_SND_CHMAP_BC                        34
+#define MA_SND_CHMAP_BLC                       35
+#define MA_SND_CHMAP_BRC                       36
+
+/* Open mode flags. */
+#define MA_SND_PCM_NO_AUTO_RESAMPLE            0x00010000
+#define MA_SND_PCM_NO_AUTO_CHANNELS            0x00020000
+#define MA_SND_PCM_NO_AUTO_FORMAT              0x00040000
+#endif
+
+typedef int                  (* ma_snd_pcm_open_proc)                          (ma_snd_pcm_t **pcm, const char *name, ma_snd_pcm_stream_t stream, int mode);
+typedef int                  (* ma_snd_pcm_close_proc)                         (ma_snd_pcm_t *pcm);
+typedef size_t               (* ma_snd_pcm_hw_params_sizeof_proc)              (void);
+typedef int                  (* ma_snd_pcm_hw_params_any_proc)                 (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params);
+typedef int                  (* ma_snd_pcm_hw_params_set_format_proc)          (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_t val);
+typedef int                  (* ma_snd_pcm_hw_params_set_format_first_proc)    (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_t *format);
+typedef void                 (* ma_snd_pcm_hw_params_get_format_mask_proc)     (ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_mask_t *mask);
+typedef int                  (* ma_snd_pcm_hw_params_set_channels_proc)        (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val);
+typedef int                  (* ma_snd_pcm_hw_params_set_channels_near_proc)   (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int *val);
+typedef int                  (* ma_snd_pcm_hw_params_set_channels_minmax_proc) (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int *minimum, unsigned int *maximum);
+typedef int                  (* ma_snd_pcm_hw_params_set_rate_resample_proc)   (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val);
+typedef int                  (* ma_snd_pcm_hw_params_set_rate_proc)            (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val, int dir);
+typedef int                  (* ma_snd_pcm_hw_params_set_rate_near_proc)       (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_set_rate_minmax_proc)     (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int *min, int *mindir, unsigned int *max, int *maxdir);
+typedef int                  (* ma_snd_pcm_hw_params_set_buffer_size_near_proc)(ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_uframes_t *val);
+typedef int                  (* ma_snd_pcm_hw_params_set_periods_near_proc)    (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_set_access_proc)          (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_access_t _access);
+typedef int                  (* ma_snd_pcm_hw_params_get_format_proc)          (const ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_t *format);
+typedef int                  (* ma_snd_pcm_hw_params_get_channels_proc)        (const ma_snd_pcm_hw_params_t *params, unsigned int *val);
+typedef int                  (* ma_snd_pcm_hw_params_get_channels_min_proc)    (const ma_snd_pcm_hw_params_t *params, unsigned int *val);
+typedef int                  (* ma_snd_pcm_hw_params_get_channels_max_proc)    (const ma_snd_pcm_hw_params_t *params, unsigned int *val);
+typedef int                  (* ma_snd_pcm_hw_params_get_rate_proc)            (const ma_snd_pcm_hw_params_t *params, unsigned int *rate, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_get_rate_min_proc)        (const ma_snd_pcm_hw_params_t *params, unsigned int *rate, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_get_rate_max_proc)        (const ma_snd_pcm_hw_params_t *params, unsigned int *rate, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_get_buffer_size_proc)     (const ma_snd_pcm_hw_params_t *params, ma_snd_pcm_uframes_t *val);
+typedef int                  (* ma_snd_pcm_hw_params_get_periods_proc)         (const ma_snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_get_access_proc)          (const ma_snd_pcm_hw_params_t *params, ma_snd_pcm_access_t *_access);
+typedef int                  (* ma_snd_pcm_hw_params_test_format_proc)         (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_t val);
+typedef int                  (* ma_snd_pcm_hw_params_test_channels_proc)       (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val);
+typedef int                  (* ma_snd_pcm_hw_params_test_rate_proc)           (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val, int dir);
+typedef int                  (* ma_snd_pcm_hw_params_proc)                     (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params);
+typedef size_t               (* ma_snd_pcm_sw_params_sizeof_proc)              (void);
+typedef int                  (* ma_snd_pcm_sw_params_current_proc)             (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params);
+typedef int                  (* ma_snd_pcm_sw_params_get_boundary_proc)        (const ma_snd_pcm_sw_params_t *params, ma_snd_pcm_uframes_t* val);
+typedef int                  (* ma_snd_pcm_sw_params_set_avail_min_proc)       (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params, ma_snd_pcm_uframes_t val);
+typedef int                  (* ma_snd_pcm_sw_params_set_start_threshold_proc) (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params, ma_snd_pcm_uframes_t val);
+typedef int                  (* ma_snd_pcm_sw_params_set_stop_threshold_proc)  (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params, ma_snd_pcm_uframes_t val);
+typedef int                  (* ma_snd_pcm_sw_params_proc)                     (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params);
+typedef size_t               (* ma_snd_pcm_format_mask_sizeof_proc)            (void);
+typedef int                  (* ma_snd_pcm_format_mask_test_proc)              (const ma_snd_pcm_format_mask_t *mask, ma_snd_pcm_format_t val);
+typedef ma_snd_pcm_chmap_t * (* ma_snd_pcm_get_chmap_proc)                     (ma_snd_pcm_t *pcm);
+typedef ma_snd_pcm_state_t   (* ma_snd_pcm_state_proc)                         (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_prepare_proc)                       (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_start_proc)                         (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_drop_proc)                          (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_drain_proc)                         (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_reset_proc)                         (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_device_name_hint_proc)                  (int card, const char *iface, void ***hints);
+typedef char *               (* ma_snd_device_name_get_hint_proc)              (const void *hint, const char *id);
+typedef int                  (* ma_snd_card_get_index_proc)                    (const char *name);
+typedef int                  (* ma_snd_device_name_free_hint_proc)             (void **hints);
+typedef int                  (* ma_snd_pcm_mmap_begin_proc)                    (ma_snd_pcm_t *pcm, const ma_snd_pcm_channel_area_t **areas, ma_snd_pcm_uframes_t *offset, ma_snd_pcm_uframes_t *frames);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_mmap_commit_proc)                   (ma_snd_pcm_t *pcm, ma_snd_pcm_uframes_t offset, ma_snd_pcm_uframes_t frames);
+typedef int                  (* ma_snd_pcm_recover_proc)                       (ma_snd_pcm_t *pcm, int err, int silent);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_readi_proc)                         (ma_snd_pcm_t *pcm, void *buffer, ma_snd_pcm_uframes_t size);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_writei_proc)                        (ma_snd_pcm_t *pcm, const void *buffer, ma_snd_pcm_uframes_t size);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_avail_proc)                         (ma_snd_pcm_t *pcm);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_avail_update_proc)                  (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_wait_proc)                          (ma_snd_pcm_t *pcm, int timeout);
+typedef int                  (* ma_snd_pcm_nonblock_proc)                      (ma_snd_pcm_t *pcm, int nonblock);
+typedef int                  (* ma_snd_pcm_info_proc)                          (ma_snd_pcm_t *pcm, ma_snd_pcm_info_t* info);
+typedef size_t               (* ma_snd_pcm_info_sizeof_proc)                   (void);
+typedef const char*          (* ma_snd_pcm_info_get_name_proc)                 (const ma_snd_pcm_info_t* info);
+typedef int                  (* ma_snd_pcm_poll_descriptors_proc)              (ma_snd_pcm_t *pcm, struct pollfd *pfds, unsigned int space);
+typedef int                  (* ma_snd_pcm_poll_descriptors_count_proc)        (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_poll_descriptors_revents_proc)      (ma_snd_pcm_t *pcm, struct pollfd *pfds, unsigned int nfds, unsigned short *revents);
+typedef int                  (* ma_snd_config_update_free_global_proc)         (void);
+
+/* This array specifies each of the common devices that can be used for both playback and capture. */
+static const char* g_maCommonDeviceNamesALSA[] = {
+    "default",
+    "null",
+    "pulse",
+    "jack"
+};
+
+/* This array allows us to blacklist specific playback devices. */
+static const char* g_maBlacklistedPlaybackDeviceNamesALSA[] = {
+    ""
+};
+
+/* This array allows us to blacklist specific capture devices. */
+static const char* g_maBlacklistedCaptureDeviceNamesALSA[] = {
+    ""
+};
+
+
+static ma_snd_pcm_format_t ma_convert_ma_format_to_alsa_format(ma_format format)
+{
+    ma_snd_pcm_format_t ALSAFormats[] = {
+        MA_SND_PCM_FORMAT_UNKNOWN,     /* ma_format_unknown */
+        MA_SND_PCM_FORMAT_U8,          /* ma_format_u8 */
+        MA_SND_PCM_FORMAT_S16_LE,      /* ma_format_s16 */
+        MA_SND_PCM_FORMAT_S24_3LE,     /* ma_format_s24 */
+        MA_SND_PCM_FORMAT_S32_LE,      /* ma_format_s32 */
+        MA_SND_PCM_FORMAT_FLOAT_LE     /* ma_format_f32 */
+    };
+
+    if (ma_is_big_endian()) {
+        ALSAFormats[0] = MA_SND_PCM_FORMAT_UNKNOWN;
+        ALSAFormats[1] = MA_SND_PCM_FORMAT_U8;
+        ALSAFormats[2] = MA_SND_PCM_FORMAT_S16_BE;
+        ALSAFormats[3] = MA_SND_PCM_FORMAT_S24_3BE;
+        ALSAFormats[4] = MA_SND_PCM_FORMAT_S32_BE;
+        ALSAFormats[5] = MA_SND_PCM_FORMAT_FLOAT_BE;
+    }
+
+    return ALSAFormats[format];
+}
+
+static ma_format ma_format_from_alsa(ma_snd_pcm_format_t formatALSA)
+{
+    if (ma_is_little_endian()) {
+        switch (formatALSA) {
+            case MA_SND_PCM_FORMAT_S16_LE:   return ma_format_s16;
+            case MA_SND_PCM_FORMAT_S24_3LE:  return ma_format_s24;
+            case MA_SND_PCM_FORMAT_S32_LE:   return ma_format_s32;
+            case MA_SND_PCM_FORMAT_FLOAT_LE: return ma_format_f32;
+            default: break;
+        }
+    } else {
+        switch (formatALSA) {
+            case MA_SND_PCM_FORMAT_S16_BE:   return ma_format_s16;
+            case MA_SND_PCM_FORMAT_S24_3BE:  return ma_format_s24;
+            case MA_SND_PCM_FORMAT_S32_BE:   return ma_format_s32;
+            case MA_SND_PCM_FORMAT_FLOAT_BE: return ma_format_f32;
+            default: break;
+        }
+    }
+
+    /* Endian agnostic. */
+    switch (formatALSA) {
+        case MA_SND_PCM_FORMAT_U8: return ma_format_u8;
+        default: return ma_format_unknown;
+    }
+}
+
+static ma_channel ma_convert_alsa_channel_position_to_ma_channel(unsigned int alsaChannelPos)
+{
+    switch (alsaChannelPos)
+    {
+        case MA_SND_CHMAP_MONO: return MA_CHANNEL_MONO;
+        case MA_SND_CHMAP_FL:   return MA_CHANNEL_FRONT_LEFT;
+        case MA_SND_CHMAP_FR:   return MA_CHANNEL_FRONT_RIGHT;
+        case MA_SND_CHMAP_RL:   return MA_CHANNEL_BACK_LEFT;
+        case MA_SND_CHMAP_RR:   return MA_CHANNEL_BACK_RIGHT;
+        case MA_SND_CHMAP_FC:   return MA_CHANNEL_FRONT_CENTER;
+        case MA_SND_CHMAP_LFE:  return MA_CHANNEL_LFE;
+        case MA_SND_CHMAP_SL:   return MA_CHANNEL_SIDE_LEFT;
+        case MA_SND_CHMAP_SR:   return MA_CHANNEL_SIDE_RIGHT;
+        case MA_SND_CHMAP_RC:   return MA_CHANNEL_BACK_CENTER;
+        case MA_SND_CHMAP_FLC:  return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case MA_SND_CHMAP_FRC:  return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case MA_SND_CHMAP_RLC:  return 0;
+        case MA_SND_CHMAP_RRC:  return 0;
+        case MA_SND_CHMAP_FLW:  return 0;
+        case MA_SND_CHMAP_FRW:  return 0;
+        case MA_SND_CHMAP_FLH:  return 0;
+        case MA_SND_CHMAP_FCH:  return 0;
+        case MA_SND_CHMAP_FRH:  return 0;
+        case MA_SND_CHMAP_TC:   return MA_CHANNEL_TOP_CENTER;
+        case MA_SND_CHMAP_TFL:  return MA_CHANNEL_TOP_FRONT_LEFT;
+        case MA_SND_CHMAP_TFR:  return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case MA_SND_CHMAP_TFC:  return MA_CHANNEL_TOP_FRONT_CENTER;
+        case MA_SND_CHMAP_TRL:  return MA_CHANNEL_TOP_BACK_LEFT;
+        case MA_SND_CHMAP_TRR:  return MA_CHANNEL_TOP_BACK_RIGHT;
+        case MA_SND_CHMAP_TRC:  return MA_CHANNEL_TOP_BACK_CENTER;
+        default: break;
+    }
+
+    return 0;
+}
+
+static ma_bool32 ma_is_common_device_name__alsa(const char* name)
+{
+    size_t iName;
+    for (iName = 0; iName < ma_countof(g_maCommonDeviceNamesALSA); ++iName) {
+        if (ma_strcmp(name, g_maCommonDeviceNamesALSA[iName]) == 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+
+static ma_bool32 ma_is_playback_device_blacklisted__alsa(const char* name)
+{
+    size_t iName;
+    for (iName = 0; iName < ma_countof(g_maBlacklistedPlaybackDeviceNamesALSA); ++iName) {
+        if (ma_strcmp(name, g_maBlacklistedPlaybackDeviceNamesALSA[iName]) == 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+static ma_bool32 ma_is_capture_device_blacklisted__alsa(const char* name)
+{
+    size_t iName;
+    for (iName = 0; iName < ma_countof(g_maBlacklistedCaptureDeviceNamesALSA); ++iName) {
+        if (ma_strcmp(name, g_maBlacklistedCaptureDeviceNamesALSA[iName]) == 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+static ma_bool32 ma_is_device_blacklisted__alsa(ma_device_type deviceType, const char* name)
+{
+    if (deviceType == ma_device_type_playback) {
+        return ma_is_playback_device_blacklisted__alsa(name);
+    } else {
+        return ma_is_capture_device_blacklisted__alsa(name);
+    }
+}
+
+
+static const char* ma_find_char(const char* str, char c, int* index)
+{
+    int i = 0;
+    for (;;) {
+        if (str[i] == '\0') {
+            if (index) *index = -1;
+            return NULL;
+        }
+
+        if (str[i] == c) {
+            if (index) *index = i;
+            return str + i;
+        }
+
+        i += 1;
+    }
+
+    /* Should never get here, but treat it as though the character was not found to make me feel better inside. */
+    if (index) *index = -1;
+    return NULL;
+}
+
+static ma_bool32 ma_is_device_name_in_hw_format__alsa(const char* hwid)
+{
+    /* This function is just checking whether or not hwid is in "hw:%d,%d" format. */
+
+    int commaPos;
+    const char* dev;
+    int i;
+
+    if (hwid == NULL) {
+        return MA_FALSE;
+    }
+
+    if (hwid[0] != 'h' || hwid[1] != 'w' || hwid[2] != ':') {
+        return MA_FALSE;
+    }
+
+    hwid += 3;
+
+    dev = ma_find_char(hwid, ',', &commaPos);
+    if (dev == NULL) {
+        return MA_FALSE;
+    } else {
+        dev += 1;   /* Skip past the ",". */
+    }
+
+    /* Check if the part between the ":" and the "," contains only numbers. If not, return false. */
+    for (i = 0; i < commaPos; ++i) {
+        if (hwid[i] < '0' || hwid[i] > '9') {
+            return MA_FALSE;
+        }
+    }
+
+    /* Check if everything after the "," is numeric. If not, return false. */
+    i = 0;
+    while (dev[i] != '\0') {
+        if (dev[i] < '0' || dev[i] > '9') {
+            return MA_FALSE;
+        }
+        i += 1;
+    }
+
+    return MA_TRUE;
+}
+
+static int ma_convert_device_name_to_hw_format__alsa(ma_context* pContext, char* dst, size_t dstSize, const char* src)  /* Returns 0 on success, non-0 on error. */
+{
+    /* src should look something like this: "hw:CARD=I82801AAICH,DEV=0" */
+
+    int colonPos;
+    int commaPos;
+    char card[256];
+    const char* dev;
+    int cardIndex;
+
+    if (dst == NULL) {
+        return -1;
+    }
+    if (dstSize < 7) {
+        return -1;     /* Absolute minimum size of the output buffer is 7 bytes. */
+    }
+
+    *dst = '\0';    /* Safety. */
+    if (src == NULL) {
+        return -1;
+    }
+
+    /* If the input name is already in "hw:%d,%d" format, just return that verbatim. */
+    if (ma_is_device_name_in_hw_format__alsa(src)) {
+        return ma_strcpy_s(dst, dstSize, src);
+    }
+
+    src = ma_find_char(src, ':', &colonPos);
+    if (src == NULL) {
+        return -1;  /* Couldn't find a colon */
+    }
+
+    dev = ma_find_char(src, ',', &commaPos);
+    if (dev == NULL) {
+        dev = "0";
+        ma_strncpy_s(card, sizeof(card), src+6, (size_t)-1);   /* +6 = ":CARD=" */
+    } else {
+        dev = dev + 5;  /* +5 = ",DEV=" */
+        ma_strncpy_s(card, sizeof(card), src+6, commaPos-6);   /* +6 = ":CARD=" */
+    }
+
+    cardIndex = ((ma_snd_card_get_index_proc)pContext->alsa.snd_card_get_index)(card);
+    if (cardIndex < 0) {
+        return -2;  /* Failed to retrieve the card index. */
+    }
+
+
+    /* Construction. */
+    dst[0] = 'h'; dst[1] = 'w'; dst[2] = ':';
+    if (ma_itoa_s(cardIndex, dst+3, dstSize-3, 10) != 0) {
+        return -3;
+    }
+    if (ma_strcat_s(dst, dstSize, ",") != 0) {
+        return -3;
+    }
+    if (ma_strcat_s(dst, dstSize, dev) != 0) {
+        return -3;
+    }
+
+    return 0;
+}
+
+static ma_bool32 ma_does_id_exist_in_list__alsa(ma_device_id* pUniqueIDs, ma_uint32 count, const char* pHWID)
+{
+    ma_uint32 i;
+
+    MA_ASSERT(pHWID != NULL);
+
+    for (i = 0; i < count; ++i) {
+        if (ma_strcmp(pUniqueIDs[i].alsa, pHWID) == 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+
+static ma_result ma_context_open_pcm__alsa(ma_context* pContext, ma_share_mode shareMode, ma_device_type deviceType, const ma_device_id* pDeviceID, int openMode, ma_snd_pcm_t** ppPCM)
+{
+    ma_snd_pcm_t* pPCM;
+    ma_snd_pcm_stream_t stream;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppPCM != NULL);
+
+    *ppPCM = NULL;
+    pPCM = NULL;
+
+    stream = (deviceType == ma_device_type_playback) ? MA_SND_PCM_STREAM_PLAYBACK : MA_SND_PCM_STREAM_CAPTURE;
+
+    if (pDeviceID == NULL) {
+        ma_bool32 isDeviceOpen;
+        size_t i;
+
+        /*
+        We're opening the default device. I don't know if trying anything other than "default" is necessary, but it makes
+        me feel better to try as hard as we can get to get _something_ working.
+        */
+        const char* defaultDeviceNames[] = {
+            "default",
+            NULL,
+            NULL,
+            NULL,
+            NULL,
+            NULL,
+            NULL
+        };
+
+        if (shareMode == ma_share_mode_exclusive) {
+            defaultDeviceNames[1] = "hw";
+            defaultDeviceNames[2] = "hw:0";
+            defaultDeviceNames[3] = "hw:0,0";
+        } else {
+            if (deviceType == ma_device_type_playback) {
+                defaultDeviceNames[1] = "dmix";
+                defaultDeviceNames[2] = "dmix:0";
+                defaultDeviceNames[3] = "dmix:0,0";
+            } else {
+                defaultDeviceNames[1] = "dsnoop";
+                defaultDeviceNames[2] = "dsnoop:0";
+                defaultDeviceNames[3] = "dsnoop:0,0";
+            }
+            defaultDeviceNames[4] = "hw";
+            defaultDeviceNames[5] = "hw:0";
+            defaultDeviceNames[6] = "hw:0,0";
+        }
+
+        isDeviceOpen = MA_FALSE;
+        for (i = 0; i < ma_countof(defaultDeviceNames); ++i) {
+            if (defaultDeviceNames[i] != NULL && defaultDeviceNames[i][0] != '\0') {
+                if (((ma_snd_pcm_open_proc)pContext->alsa.snd_pcm_open)(&pPCM, defaultDeviceNames[i], stream, openMode) == 0) {
+                    isDeviceOpen = MA_TRUE;
+                    break;
+                }
+            }
+        }
+
+        if (!isDeviceOpen) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[ALSA] snd_pcm_open() failed when trying to open an appropriate default device.");
+            return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        }
+    } else {
+        /*
+        We're trying to open a specific device. There's a few things to consider here:
+
+        miniaudio recognizes a special format of device id that excludes the "hw", "dmix", etc. prefix. It looks like this: ":0,0", ":0,1", etc. When
+        an ID of this format is specified, it indicates to miniaudio that it can try different combinations of plugins ("hw", "dmix", etc.) until it
+        finds an appropriate one that works. This comes in very handy when trying to open a device in shared mode ("dmix"), vs exclusive mode ("hw").
+        */
+
+        /* May end up needing to make small adjustments to the ID, so make a copy. */
+        ma_device_id deviceID = *pDeviceID;
+        int resultALSA = -ENODEV;
+
+        if (deviceID.alsa[0] != ':') {
+            /* The ID is not in ":0,0" format. Use the ID exactly as-is. */
+            resultALSA = ((ma_snd_pcm_open_proc)pContext->alsa.snd_pcm_open)(&pPCM, deviceID.alsa, stream, openMode);
+        } else {
+            char hwid[256];
+
+            /* The ID is in ":0,0" format. Try different plugins depending on the shared mode. */
+            if (deviceID.alsa[1] == '\0') {
+                deviceID.alsa[0] = '\0';  /* An ID of ":" should be converted to "". */
+            }
+
+            if (shareMode == ma_share_mode_shared) {
+                if (deviceType == ma_device_type_playback) {
+                    ma_strcpy_s(hwid, sizeof(hwid), "dmix");
+                } else {
+                    ma_strcpy_s(hwid, sizeof(hwid), "dsnoop");
+                }
+
+                if (ma_strcat_s(hwid, sizeof(hwid), deviceID.alsa) == 0) {
+                    resultALSA = ((ma_snd_pcm_open_proc)pContext->alsa.snd_pcm_open)(&pPCM, hwid, stream, openMode);
+                }
+            }
+
+            /* If at this point we still don't have an open device it means we're either preferencing exclusive mode or opening with "dmix"/"dsnoop" failed. */
+            if (resultALSA != 0) {
+                ma_strcpy_s(hwid, sizeof(hwid), "hw");
+                if (ma_strcat_s(hwid, sizeof(hwid), deviceID.alsa) == 0) {
+                    resultALSA = ((ma_snd_pcm_open_proc)pContext->alsa.snd_pcm_open)(&pPCM, hwid, stream, openMode);
+                }
+            }
+        }
+
+        if (resultALSA < 0) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[ALSA] snd_pcm_open() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+    }
+
+    *ppPCM = pPCM;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_enumerate_devices__alsa(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    int resultALSA;
+    ma_bool32 cbResult = MA_TRUE;
+    char** ppDeviceHints;
+    ma_device_id* pUniqueIDs = NULL;
+    ma_uint32 uniqueIDCount = 0;
+    char** ppNextDeviceHint;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    ma_mutex_lock(&pContext->alsa.internalDeviceEnumLock);
+
+    resultALSA = ((ma_snd_device_name_hint_proc)pContext->alsa.snd_device_name_hint)(-1, "pcm", (void***)&ppDeviceHints);
+    if (resultALSA < 0) {
+        ma_mutex_unlock(&pContext->alsa.internalDeviceEnumLock);
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    ppNextDeviceHint = ppDeviceHints;
+    while (*ppNextDeviceHint != NULL) {
+        char* NAME = ((ma_snd_device_name_get_hint_proc)pContext->alsa.snd_device_name_get_hint)(*ppNextDeviceHint, "NAME");
+        char* DESC = ((ma_snd_device_name_get_hint_proc)pContext->alsa.snd_device_name_get_hint)(*ppNextDeviceHint, "DESC");
+        char* IOID = ((ma_snd_device_name_get_hint_proc)pContext->alsa.snd_device_name_get_hint)(*ppNextDeviceHint, "IOID");
+        ma_device_type deviceType = ma_device_type_playback;
+        ma_bool32 stopEnumeration = MA_FALSE;
+        char hwid[sizeof(pUniqueIDs->alsa)];
+        ma_device_info deviceInfo;
+
+        if ((IOID == NULL || ma_strcmp(IOID, "Output") == 0)) {
+            deviceType = ma_device_type_playback;
+        }
+        if ((IOID != NULL && ma_strcmp(IOID, "Input" ) == 0)) {
+            deviceType = ma_device_type_capture;
+        }
+
+        if (NAME != NULL) {
+            if (pContext->alsa.useVerboseDeviceEnumeration) {
+                /* Verbose mode. Use the name exactly as-is. */
+                ma_strncpy_s(hwid, sizeof(hwid), NAME, (size_t)-1);
+            } else {
+                /* Simplified mode. Use ":%d,%d" format. */
+                if (ma_convert_device_name_to_hw_format__alsa(pContext, hwid, sizeof(hwid), NAME) == 0) {
+                    /*
+                    At this point, hwid looks like "hw:0,0". In simplified enumeration mode, we actually want to strip off the
+                    plugin name so it looks like ":0,0". The reason for this is that this special format is detected at device
+                    initialization time and is used as an indicator to try to use the most appropriate plugin depending on the
+                    device type and sharing mode.
+                    */
+                    char* dst = hwid;
+                    char* src = hwid+2;
+                    while ((*dst++ = *src++));
+                } else {
+                    /* Conversion to "hw:%d,%d" failed. Just use the name as-is. */
+                    ma_strncpy_s(hwid, sizeof(hwid), NAME, (size_t)-1);
+                }
+
+                if (ma_does_id_exist_in_list__alsa(pUniqueIDs, uniqueIDCount, hwid)) {
+                    goto next_device;   /* The device has already been enumerated. Move on to the next one. */
+                } else {
+                    /* The device has not yet been enumerated. Make sure it's added to our list so that it's not enumerated again. */
+                    size_t newCapacity = sizeof(*pUniqueIDs) * (uniqueIDCount + 1);
+                    ma_device_id* pNewUniqueIDs = (ma_device_id*)ma_realloc(pUniqueIDs, newCapacity, &pContext->allocationCallbacks);
+                    if (pNewUniqueIDs == NULL) {
+                        goto next_device;   /* Failed to allocate memory. */
+                    }
+
+                    pUniqueIDs = pNewUniqueIDs;
+                    MA_COPY_MEMORY(pUniqueIDs[uniqueIDCount].alsa, hwid, sizeof(hwid));
+                    uniqueIDCount += 1;
+                }
+            }
+        } else {
+            MA_ZERO_MEMORY(hwid, sizeof(hwid));
+        }
+
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.id.alsa, sizeof(deviceInfo.id.alsa), hwid, (size_t)-1);
+
+        /*
+        There's no good way to determine whether or not a device is the default on Linux. We're just going to do something simple and
+        just use the name of "default" as the indicator.
+        */
+        if (ma_strcmp(deviceInfo.id.alsa, "default") == 0) {
+            deviceInfo.isDefault = MA_TRUE;
+        }
+
+
+        /*
+        DESC is the friendly name. We treat this slightly differently depending on whether or not we are using verbose
+        device enumeration. In verbose mode we want to take the entire description so that the end-user can distinguish
+        between the subdevices of each card/dev pair. In simplified mode, however, we only want the first part of the
+        description.
+
+        The value in DESC seems to be split into two lines, with the first line being the name of the device and the
+        second line being a description of the device. I don't like having the description be across two lines because
+        it makes formatting ugly and annoying. I'm therefore deciding to put it all on a single line with the second line
+        being put into parentheses. In simplified mode I'm just stripping the second line entirely.
+        */
+        if (DESC != NULL) {
+            int lfPos;
+            const char* line2 = ma_find_char(DESC, '\n', &lfPos);
+            if (line2 != NULL) {
+                line2 += 1; /* Skip past the new-line character. */
+
+                if (pContext->alsa.useVerboseDeviceEnumeration) {
+                    /* Verbose mode. Put the second line in brackets. */
+                    ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), DESC, lfPos);
+                    ma_strcat_s (deviceInfo.name, sizeof(deviceInfo.name), " (");
+                    ma_strcat_s (deviceInfo.name, sizeof(deviceInfo.name), line2);
+                    ma_strcat_s (deviceInfo.name, sizeof(deviceInfo.name), ")");
+                } else {
+                    /* Simplified mode. Strip the second line entirely. */
+                    ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), DESC, lfPos);
+                }
+            } else {
+                /* There's no second line. Just copy the whole description. */
+                ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), DESC, (size_t)-1);
+            }
+        }
+
+        if (!ma_is_device_blacklisted__alsa(deviceType, NAME)) {
+            cbResult = callback(pContext, deviceType, &deviceInfo, pUserData);
+        }
+
+        /*
+        Some devices are both playback and capture, but they are only enumerated by ALSA once. We need to fire the callback
+        again for the other device type in this case. We do this for known devices and where the IOID hint is NULL, which
+        means both Input and Output.
+        */
+        if (cbResult) {
+            if (ma_is_common_device_name__alsa(NAME) || IOID == NULL) {
+                if (deviceType == ma_device_type_playback) {
+                    if (!ma_is_capture_device_blacklisted__alsa(NAME)) {
+                        cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                    }
+                } else {
+                    if (!ma_is_playback_device_blacklisted__alsa(NAME)) {
+                        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                    }
+                }
+            }
+        }
+
+        if (cbResult == MA_FALSE) {
+            stopEnumeration = MA_TRUE;
+        }
+
+    next_device:
+        free(NAME);
+        free(DESC);
+        free(IOID);
+        ppNextDeviceHint += 1;
+
+        /* We need to stop enumeration if the callback returned false. */
+        if (stopEnumeration) {
+            break;
+        }
+    }
+
+    ma_free(pUniqueIDs, &pContext->allocationCallbacks);
+    ((ma_snd_device_name_free_hint_proc)pContext->alsa.snd_device_name_free_hint)((void**)ppDeviceHints);
+
+    ma_mutex_unlock(&pContext->alsa.internalDeviceEnumLock);
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    ma_device_type deviceType;
+    const ma_device_id* pDeviceID;
+    ma_share_mode shareMode;
+    ma_device_info* pDeviceInfo;
+    ma_bool32 foundDevice;
+} ma_context_get_device_info_enum_callback_data__alsa;
+
+static ma_bool32 ma_context_get_device_info_enum_callback__alsa(ma_context* pContext, ma_device_type deviceType, const ma_device_info* pDeviceInfo, void* pUserData)
+{
+    ma_context_get_device_info_enum_callback_data__alsa* pData = (ma_context_get_device_info_enum_callback_data__alsa*)pUserData;
+    MA_ASSERT(pData != NULL);
+
+    (void)pContext;
+
+    if (pData->pDeviceID == NULL && ma_strcmp(pDeviceInfo->id.alsa, "default") == 0) {
+        ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), pDeviceInfo->name, (size_t)-1);
+        pData->foundDevice = MA_TRUE;
+    } else {
+        if (pData->deviceType == deviceType && (pData->pDeviceID != NULL && ma_strcmp(pData->pDeviceID->alsa, pDeviceInfo->id.alsa) == 0)) {
+            ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), pDeviceInfo->name, (size_t)-1);
+            pData->foundDevice = MA_TRUE;
+        }
+    }
+
+    /* Keep enumerating until we have found the device. */
+    return !pData->foundDevice;
+}
+
+static void ma_context_test_rate_and_add_native_data_format__alsa(ma_context* pContext, ma_snd_pcm_t* pPCM, ma_snd_pcm_hw_params_t* pHWParams, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 flags, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pPCM        != NULL);
+    MA_ASSERT(pHWParams   != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    if (pDeviceInfo->nativeDataFormatCount < ma_countof(pDeviceInfo->nativeDataFormats) && ((ma_snd_pcm_hw_params_test_rate_proc)pContext->alsa.snd_pcm_hw_params_test_rate)(pPCM, pHWParams, sampleRate, 0) == 0) {
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = sampleRate;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = flags;
+        pDeviceInfo->nativeDataFormatCount += 1;
+    }
+}
+
+static void ma_context_iterate_rates_and_add_native_data_format__alsa(ma_context* pContext, ma_snd_pcm_t* pPCM, ma_snd_pcm_hw_params_t* pHWParams, ma_format format, ma_uint32 channels, ma_uint32 flags, ma_device_info* pDeviceInfo)
+{
+    ma_uint32 iSampleRate;
+    unsigned int minSampleRate;
+    unsigned int maxSampleRate;
+    int sampleRateDir;  /* Not used. Just passed into snd_pcm_hw_params_get_rate_min/max(). */
+
+    /* There could be a range. */
+    ((ma_snd_pcm_hw_params_get_rate_min_proc)pContext->alsa.snd_pcm_hw_params_get_rate_min)(pHWParams, &minSampleRate, &sampleRateDir);
+    ((ma_snd_pcm_hw_params_get_rate_max_proc)pContext->alsa.snd_pcm_hw_params_get_rate_max)(pHWParams, &maxSampleRate, &sampleRateDir);
+
+    /* Make sure our sample rates are clamped to sane values. Stupid devices like "pulse" will reports rates like "1" which is ridiculous. */
+    minSampleRate = ma_clamp(minSampleRate, (unsigned int)ma_standard_sample_rate_min, (unsigned int)ma_standard_sample_rate_max);
+    maxSampleRate = ma_clamp(maxSampleRate, (unsigned int)ma_standard_sample_rate_min, (unsigned int)ma_standard_sample_rate_max);
+
+    for (iSampleRate = 0; iSampleRate < ma_countof(g_maStandardSampleRatePriorities); iSampleRate += 1) {
+        ma_uint32 standardSampleRate = g_maStandardSampleRatePriorities[iSampleRate];
+
+        if (standardSampleRate >= minSampleRate && standardSampleRate <= maxSampleRate) {
+            ma_context_test_rate_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, channels, standardSampleRate, flags, pDeviceInfo);
+        }
+    }
+
+    /* Now make sure our min and max rates are included just in case they aren't in the range of our standard rates. */
+    if (!ma_is_standard_sample_rate(minSampleRate)) {
+        ma_context_test_rate_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, channels, minSampleRate, flags, pDeviceInfo);
+    }
+
+    if (!ma_is_standard_sample_rate(maxSampleRate) && maxSampleRate != minSampleRate) {
+        ma_context_test_rate_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, channels, maxSampleRate, flags, pDeviceInfo);
+    }
+}
+
+static ma_result ma_context_get_device_info__alsa(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_context_get_device_info_enum_callback_data__alsa data;
+    ma_result result;
+    int resultALSA;
+    ma_snd_pcm_t* pPCM;
+    ma_snd_pcm_hw_params_t* pHWParams;
+    ma_uint32 iFormat;
+    ma_uint32 iChannel;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* We just enumerate to find basic information about the device. */
+    data.deviceType  = deviceType;
+    data.pDeviceID   = pDeviceID;
+    data.pDeviceInfo = pDeviceInfo;
+    data.foundDevice = MA_FALSE;
+    result = ma_context_enumerate_devices__alsa(pContext, ma_context_get_device_info_enum_callback__alsa, &data);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (!data.foundDevice) {
+        return MA_NO_DEVICE;
+    }
+
+    if (ma_strcmp(pDeviceInfo->id.alsa, "default") == 0) {
+        pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    /* For detailed info we need to open the device. */
+    result = ma_context_open_pcm__alsa(pContext, ma_share_mode_shared, deviceType, pDeviceID, 0, &pPCM);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* We need to initialize a HW parameters object in order to know what formats are supported. */
+    pHWParams = (ma_snd_pcm_hw_params_t*)ma_calloc(((ma_snd_pcm_hw_params_sizeof_proc)pContext->alsa.snd_pcm_hw_params_sizeof)(), &pContext->allocationCallbacks);
+    if (pHWParams == NULL) {
+        ((ma_snd_pcm_close_proc)pContext->alsa.snd_pcm_close)(pPCM);
+        return MA_OUT_OF_MEMORY;
+    }
+
+    resultALSA = ((ma_snd_pcm_hw_params_any_proc)pContext->alsa.snd_pcm_hw_params_any)(pPCM, pHWParams);
+    if (resultALSA < 0) {
+        ma_free(pHWParams, &pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to initialize hardware parameters. snd_pcm_hw_params_any() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    /*
+    Some ALSA devices can support many permutations of formats, channels and rates. We only support
+    a fixed number of permutations which means we need to employ some strategies to ensure the best
+    combinations are returned. An example is the "pulse" device which can do its own data conversion
+    in software and as a result can support any combination of format, channels and rate.
+
+    We want to ensure that the first data formats are the best. We have a list of favored sample
+    formats and sample rates, so these will be the basis of our iteration.
+    */
+
+    /* Formats. We just iterate over our standard formats and test them, making sure we reset the configuration space each iteration. */
+    for (iFormat = 0; iFormat < ma_countof(g_maFormatPriorities); iFormat += 1) {
+        ma_format format = g_maFormatPriorities[iFormat];
+
+        /*
+        For each format we need to make sure we reset the configuration space so we don't return
+        channel counts and rates that aren't compatible with a format.
+        */
+        ((ma_snd_pcm_hw_params_any_proc)pContext->alsa.snd_pcm_hw_params_any)(pPCM, pHWParams);
+
+        /* Test the format first. If this fails it means the format is not supported and we can skip it. */
+        if (((ma_snd_pcm_hw_params_test_format_proc)pContext->alsa.snd_pcm_hw_params_test_format)(pPCM, pHWParams, ma_convert_ma_format_to_alsa_format(format)) == 0) {
+            /* The format is supported. */
+            unsigned int minChannels;
+            unsigned int maxChannels;
+
+            /*
+            The configuration space needs to be restricted to this format so we can get an accurate
+            picture of which sample rates and channel counts are support with this format.
+            */
+            ((ma_snd_pcm_hw_params_set_format_proc)pContext->alsa.snd_pcm_hw_params_set_format)(pPCM, pHWParams, ma_convert_ma_format_to_alsa_format(format));
+
+            /* Now we need to check for supported channels. */
+            ((ma_snd_pcm_hw_params_get_channels_min_proc)pContext->alsa.snd_pcm_hw_params_get_channels_min)(pHWParams, &minChannels);
+            ((ma_snd_pcm_hw_params_get_channels_max_proc)pContext->alsa.snd_pcm_hw_params_get_channels_max)(pHWParams, &maxChannels);
+
+            if (minChannels > MA_MAX_CHANNELS) {
+                continue;   /* Too many channels. */
+            }
+            if (maxChannels < MA_MIN_CHANNELS) {
+                continue;   /* Not enough channels. */
+            }
+
+            /*
+            Make sure the channel count is clamped. This is mainly intended for the max channels
+            because some devices can report an unbound maximum.
+            */
+            minChannels = ma_clamp(minChannels, MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+            maxChannels = ma_clamp(maxChannels, MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+
+            if (minChannels == MA_MIN_CHANNELS && maxChannels == MA_MAX_CHANNELS) {
+                /* The device supports all channels. Don't iterate over every single one. Instead just set the channels to 0 which means all channels are supported. */
+                ma_context_iterate_rates_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, 0, 0, pDeviceInfo);    /* Intentionally setting the channel count to 0 as that means all channels are supported. */
+            } else {
+                /* The device only supports a specific set of channels. We need to iterate over all of them. */
+                for (iChannel = minChannels; iChannel <= maxChannels; iChannel += 1) {
+                    /* Test the channel before applying it to the configuration space. */
+                    unsigned int channels = iChannel;
+
+                    /* Make sure our channel range is reset before testing again or else we'll always fail the test. */
+                    ((ma_snd_pcm_hw_params_any_proc)pContext->alsa.snd_pcm_hw_params_any)(pPCM, pHWParams);
+                    ((ma_snd_pcm_hw_params_set_format_proc)pContext->alsa.snd_pcm_hw_params_set_format)(pPCM, pHWParams, ma_convert_ma_format_to_alsa_format(format));
+
+                    if (((ma_snd_pcm_hw_params_test_channels_proc)pContext->alsa.snd_pcm_hw_params_test_channels)(pPCM, pHWParams, channels) == 0) {
+                        /* The channel count is supported. */
+
+                        /* The configuration space now needs to be restricted to the channel count before extracting the sample rate. */
+                        ((ma_snd_pcm_hw_params_set_channels_proc)pContext->alsa.snd_pcm_hw_params_set_channels)(pPCM, pHWParams, channels);
+
+                        /* Only after the configuration space has been restricted to the specific channel count should we iterate over our sample rates. */
+                        ma_context_iterate_rates_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, channels, 0, pDeviceInfo);
+                    } else {
+                        /* The channel count is not supported. Skip. */
+                    }
+                }
+            }
+        } else {
+            /* The format is not supported. Skip. */
+        }
+    }
+
+    ma_free(pHWParams, &pContext->allocationCallbacks);
+
+    ((ma_snd_pcm_close_proc)pContext->alsa.snd_pcm_close)(pPCM);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_uninit__alsa(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if ((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture);
+        close(pDevice->alsa.wakeupfdCapture);
+        ma_free(pDevice->alsa.pPollDescriptorsCapture, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if ((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback);
+        close(pDevice->alsa.wakeupfdPlayback);
+        ma_free(pDevice->alsa.pPollDescriptorsPlayback, &pDevice->pContext->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init_by_type__alsa(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptor, ma_device_type deviceType)
+{
+    ma_result result;
+    int resultALSA;
+    ma_snd_pcm_t* pPCM;
+    ma_bool32 isUsingMMap;
+    ma_snd_pcm_format_t formatALSA;
+    ma_format internalFormat;
+    ma_uint32 internalChannels;
+    ma_uint32 internalSampleRate;
+    ma_channel internalChannelMap[MA_MAX_CHANNELS];
+    ma_uint32 internalPeriodSizeInFrames;
+    ma_uint32 internalPeriods;
+    int openMode;
+    ma_snd_pcm_hw_params_t* pHWParams;
+    ma_snd_pcm_sw_params_t* pSWParams;
+    ma_snd_pcm_uframes_t bufferBoundary;
+    int pollDescriptorCount;
+    struct pollfd* pPollDescriptors;
+    int wakeupfd;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex); /* This function should only be called for playback _or_ capture, never duplex. */
+    MA_ASSERT(pDevice != NULL);
+
+    formatALSA = ma_convert_ma_format_to_alsa_format(pDescriptor->format);
+
+    openMode = 0;
+    if (pConfig->alsa.noAutoResample) {
+        openMode |= MA_SND_PCM_NO_AUTO_RESAMPLE;
+    }
+    if (pConfig->alsa.noAutoChannels) {
+        openMode |= MA_SND_PCM_NO_AUTO_CHANNELS;
+    }
+    if (pConfig->alsa.noAutoFormat) {
+        openMode |= MA_SND_PCM_NO_AUTO_FORMAT;
+    }
+
+    result = ma_context_open_pcm__alsa(pDevice->pContext, pDescriptor->shareMode, deviceType, pDescriptor->pDeviceID, openMode, &pPCM);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+
+    /* Hardware parameters. */
+    pHWParams = (ma_snd_pcm_hw_params_t*)ma_calloc(((ma_snd_pcm_hw_params_sizeof_proc)pDevice->pContext->alsa.snd_pcm_hw_params_sizeof)(), &pDevice->pContext->allocationCallbacks);
+    if (pHWParams == NULL) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to allocate memory for hardware parameters.");
+        return MA_OUT_OF_MEMORY;
+    }
+
+    resultALSA = ((ma_snd_pcm_hw_params_any_proc)pDevice->pContext->alsa.snd_pcm_hw_params_any)(pPCM, pHWParams);
+    if (resultALSA < 0) {
+        ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to initialize hardware parameters. snd_pcm_hw_params_any() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    /* MMAP Mode. Try using interleaved MMAP access. If this fails, fall back to standard readi/writei. */
+    isUsingMMap = MA_FALSE;
+#if 0   /* NOTE: MMAP mode temporarily disabled. */
+    if (deviceType != ma_device_type_capture) {    /* <-- Disabling MMAP mode for capture devices because I apparently do not have a device that supports it which means I can't test it... Contributions welcome. */
+        if (!pConfig->alsa.noMMap) {
+            if (((ma_snd_pcm_hw_params_set_access_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_access)(pPCM, pHWParams, MA_SND_PCM_ACCESS_MMAP_INTERLEAVED) == 0) {
+                pDevice->alsa.isUsingMMap = MA_TRUE;
+            }
+        }
+    }
+#endif
+
+    if (!isUsingMMap) {
+        resultALSA = ((ma_snd_pcm_hw_params_set_access_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_access)(pPCM, pHWParams, MA_SND_PCM_ACCESS_RW_INTERLEAVED);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set access mode to neither SND_PCM_ACCESS_MMAP_INTERLEAVED nor SND_PCM_ACCESS_RW_INTERLEAVED. snd_pcm_hw_params_set_access() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+    }
+
+    /*
+    Most important properties first. The documentation for OSS (yes, I know this is ALSA!) recommends format, channels, then sample rate. I can't
+    find any documentation for ALSA specifically, so I'm going to copy the recommendation for OSS.
+    */
+
+    /* Format. */
+    {
+        /*
+        At this point we should have a list of supported formats, so now we need to find the best one. We first check if the requested format is
+        supported, and if so, use that one. If it's not supported, we just run though a list of formats and try to find the best one.
+        */
+        if (formatALSA == MA_SND_PCM_FORMAT_UNKNOWN || ((ma_snd_pcm_hw_params_test_format_proc)pDevice->pContext->alsa.snd_pcm_hw_params_test_format)(pPCM, pHWParams, formatALSA) != 0) {
+            /* We're either requesting the native format or the specified format is not supported. */
+            size_t iFormat;
+
+            formatALSA = MA_SND_PCM_FORMAT_UNKNOWN;
+            for (iFormat = 0; iFormat < ma_countof(g_maFormatPriorities); ++iFormat) {
+                if (((ma_snd_pcm_hw_params_test_format_proc)pDevice->pContext->alsa.snd_pcm_hw_params_test_format)(pPCM, pHWParams, ma_convert_ma_format_to_alsa_format(g_maFormatPriorities[iFormat])) == 0) {
+                    formatALSA = ma_convert_ma_format_to_alsa_format(g_maFormatPriorities[iFormat]);
+                    break;
+                }
+            }
+
+            if (formatALSA == MA_SND_PCM_FORMAT_UNKNOWN) {
+                ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+                ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Format not supported. The device does not support any miniaudio formats.");
+                return MA_FORMAT_NOT_SUPPORTED;
+            }
+        }
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_format_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_format)(pPCM, pHWParams, formatALSA);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Format not supported. snd_pcm_hw_params_set_format() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalFormat = ma_format_from_alsa(formatALSA);
+        if (internalFormat == ma_format_unknown) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] The chosen format is not supported by miniaudio.");
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+    }
+
+    /* Channels. */
+    {
+        unsigned int channels = pDescriptor->channels;
+        if (channels == 0) {
+            channels = MA_DEFAULT_CHANNELS;
+        }
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_channels_near_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_channels_near)(pPCM, pHWParams, &channels);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set channel count. snd_pcm_hw_params_set_channels_near() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalChannels = (ma_uint32)channels;
+    }
+
+    /* Sample Rate */
+    {
+        unsigned int sampleRate;
+
+        /*
+        It appears there's either a bug in ALSA, a bug in some drivers, or I'm doing something silly; but having resampling enabled causes
+        problems with some device configurations when used in conjunction with MMAP access mode. To fix this problem we need to disable
+        resampling.
+
+        To reproduce this problem, open the "plug:dmix" device, and set the sample rate to 44100. Internally, it looks like dmix uses a
+        sample rate of 48000. The hardware parameters will get set correctly with no errors, but it looks like the 44100 -> 48000 resampling
+        doesn't work properly - but only with MMAP access mode. You will notice skipping/crackling in the audio, and it'll run at a slightly
+        faster rate.
+
+        miniaudio has built-in support for sample rate conversion (albeit low quality at the moment), so disabling resampling should be fine
+        for us. The only problem is that it won't be taking advantage of any kind of hardware-accelerated resampling and it won't be very
+        good quality until I get a chance to improve the quality of miniaudio's software sample rate conversion.
+
+        I don't currently know if the dmix plugin is the only one with this error. Indeed, this is the only one I've been able to reproduce
+        this error with. In the future, we may want to restrict the disabling of resampling to only known bad plugins.
+        */
+        ((ma_snd_pcm_hw_params_set_rate_resample_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_rate_resample)(pPCM, pHWParams, 0);
+
+        sampleRate = pDescriptor->sampleRate;
+        if (sampleRate == 0) {
+            sampleRate = MA_DEFAULT_SAMPLE_RATE;
+        }
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_rate_near_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_rate_near)(pPCM, pHWParams, &sampleRate, 0);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Sample rate not supported. snd_pcm_hw_params_set_rate_near() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalSampleRate = (ma_uint32)sampleRate;
+    }
+
+    /* Periods. */
+    {
+        ma_uint32 periods = pDescriptor->periodCount;
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_periods_near_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_periods_near)(pPCM, pHWParams, &periods, NULL);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set period count. snd_pcm_hw_params_set_periods_near() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalPeriods = periods;
+    }
+
+    /* Buffer Size */
+    {
+        ma_snd_pcm_uframes_t actualBufferSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, internalSampleRate, pConfig->performanceProfile) * internalPeriods;
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_buffer_size_near_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_buffer_size_near)(pPCM, pHWParams, &actualBufferSizeInFrames);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set buffer size for device. snd_pcm_hw_params_set_buffer_size() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalPeriodSizeInFrames = actualBufferSizeInFrames / internalPeriods;
+    }
+
+    /* Apply hardware parameters. */
+    resultALSA = ((ma_snd_pcm_hw_params_proc)pDevice->pContext->alsa.snd_pcm_hw_params)(pPCM, pHWParams);
+    if (resultALSA < 0) {
+        ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set hardware parameters. snd_pcm_hw_params() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+    pHWParams = NULL;
+
+
+    /* Software parameters. */
+    pSWParams = (ma_snd_pcm_sw_params_t*)ma_calloc(((ma_snd_pcm_sw_params_sizeof_proc)pDevice->pContext->alsa.snd_pcm_sw_params_sizeof)(), &pDevice->pContext->allocationCallbacks);
+    if (pSWParams == NULL) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to allocate memory for software parameters.");
+        return MA_OUT_OF_MEMORY;
+    }
+
+    resultALSA = ((ma_snd_pcm_sw_params_current_proc)pDevice->pContext->alsa.snd_pcm_sw_params_current)(pPCM, pSWParams);
+    if (resultALSA < 0) {
+        ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to initialize software parameters. snd_pcm_sw_params_current() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    resultALSA = ((ma_snd_pcm_sw_params_set_avail_min_proc)pDevice->pContext->alsa.snd_pcm_sw_params_set_avail_min)(pPCM, pSWParams, ma_prev_power_of_2(internalPeriodSizeInFrames));
+    if (resultALSA < 0) {
+        ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] snd_pcm_sw_params_set_avail_min() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    resultALSA = ((ma_snd_pcm_sw_params_get_boundary_proc)pDevice->pContext->alsa.snd_pcm_sw_params_get_boundary)(pSWParams, &bufferBoundary);
+    if (resultALSA < 0) {
+        bufferBoundary = internalPeriodSizeInFrames * internalPeriods;
+    }
+
+    if (deviceType == ma_device_type_playback && !isUsingMMap) {   /* Only playback devices in writei/readi mode need a start threshold. */
+        /*
+        Subtle detail here with the start threshold. When in playback-only mode (no full-duplex) we can set the start threshold to
+        the size of a period. But for full-duplex we need to set it such that it is at least two periods.
+        */
+        resultALSA = ((ma_snd_pcm_sw_params_set_start_threshold_proc)pDevice->pContext->alsa.snd_pcm_sw_params_set_start_threshold)(pPCM, pSWParams, internalPeriodSizeInFrames*2);
+        if (resultALSA < 0) {
+            ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set start threshold for playback device. snd_pcm_sw_params_set_start_threshold() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        resultALSA = ((ma_snd_pcm_sw_params_set_stop_threshold_proc)pDevice->pContext->alsa.snd_pcm_sw_params_set_stop_threshold)(pPCM, pSWParams, bufferBoundary);
+        if (resultALSA < 0) { /* Set to boundary to loop instead of stop in the event of an xrun. */
+            ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set stop threshold for playback device. snd_pcm_sw_params_set_stop_threshold() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+    }
+
+    resultALSA = ((ma_snd_pcm_sw_params_proc)pDevice->pContext->alsa.snd_pcm_sw_params)(pPCM, pSWParams);
+    if (resultALSA < 0) {
+        ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set software parameters. snd_pcm_sw_params() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+    pSWParams = NULL;
+
+
+    /* Grab the internal channel map. For now we're not going to bother trying to change the channel map and instead just do it ourselves. */
+    {
+        ma_snd_pcm_chmap_t* pChmap = NULL;
+        if (pDevice->pContext->alsa.snd_pcm_get_chmap != NULL) {
+            pChmap = ((ma_snd_pcm_get_chmap_proc)pDevice->pContext->alsa.snd_pcm_get_chmap)(pPCM);
+        }
+
+        if (pChmap != NULL) {
+            ma_uint32 iChannel;
+
+            /* There are cases where the returned channel map can have a different channel count than was returned by snd_pcm_hw_params_set_channels_near(). */
+            if (pChmap->channels >= internalChannels) {
+                /* Drop excess channels. */
+                for (iChannel = 0; iChannel < internalChannels; ++iChannel) {
+                    internalChannelMap[iChannel] = ma_convert_alsa_channel_position_to_ma_channel(pChmap->pos[iChannel]);
+                }
+            } else {
+                ma_uint32 i;
+
+                /*
+                Excess channels use defaults. Do an initial fill with defaults, overwrite the first pChmap->channels, validate to ensure there are no duplicate
+                channels. If validation fails, fall back to defaults.
+                */
+                ma_bool32 isValid = MA_TRUE;
+
+                /* Fill with defaults. */
+                ma_channel_map_init_standard(ma_standard_channel_map_alsa, internalChannelMap, ma_countof(internalChannelMap), internalChannels);
+
+                /* Overwrite first pChmap->channels channels. */
+                for (iChannel = 0; iChannel < pChmap->channels; ++iChannel) {
+                    internalChannelMap[iChannel] = ma_convert_alsa_channel_position_to_ma_channel(pChmap->pos[iChannel]);
+                }
+
+                /* Validate. */
+                for (i = 0; i < internalChannels && isValid; ++i) {
+                    ma_uint32 j;
+                    for (j = i+1; j < internalChannels; ++j) {
+                        if (internalChannelMap[i] == internalChannelMap[j]) {
+                            isValid = MA_FALSE;
+                            break;
+                        }
+                    }
+                }
+
+                /* If our channel map is invalid, fall back to defaults. */
+                if (!isValid) {
+                    ma_channel_map_init_standard(ma_standard_channel_map_alsa, internalChannelMap, ma_countof(internalChannelMap), internalChannels);
+                }
+            }
+
+            free(pChmap);
+            pChmap = NULL;
+        } else {
+            /* Could not retrieve the channel map. Fall back to a hard-coded assumption. */
+            ma_channel_map_init_standard(ma_standard_channel_map_alsa, internalChannelMap, ma_countof(internalChannelMap), internalChannels);
+        }
+    }
+
+
+    /*
+    We need to retrieve the poll descriptors so we can use poll() to wait for data to become
+    available for reading or writing. There's no well defined maximum for this so we're just going
+    to allocate this on the heap.
+    */
+    pollDescriptorCount = ((ma_snd_pcm_poll_descriptors_count_proc)pDevice->pContext->alsa.snd_pcm_poll_descriptors_count)(pPCM);
+    if (pollDescriptorCount <= 0) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to retrieve poll descriptors count.");
+        return MA_ERROR;
+    }
+
+    pPollDescriptors = (struct pollfd*)ma_malloc(sizeof(*pPollDescriptors) * (pollDescriptorCount + 1), &pDevice->pContext->allocationCallbacks);   /* +1 because we want room for the wakeup descriptor. */
+    if (pPollDescriptors == NULL) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to allocate memory for poll descriptors.");
+        return MA_OUT_OF_MEMORY;
+    }
+
+    /*
+    We need an eventfd to wakeup from poll() and avoid a deadlock in situations where the driver
+    never returns from writei() and readi(). This has been observed with the "pulse" device.
+    */
+    wakeupfd = eventfd(0, 0);
+    if (wakeupfd < 0) {
+        ma_free(pPollDescriptors, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to create eventfd for poll wakeup.");
+        return ma_result_from_errno(errno);
+    }
+
+    /* We'll place the wakeup fd at the start of the buffer. */
+    pPollDescriptors[0].fd      = wakeupfd;
+    pPollDescriptors[0].events  = POLLIN;    /* We only care about waiting to read from the wakeup file descriptor. */
+    pPollDescriptors[0].revents = 0;
+
+    /* We can now extract the PCM poll descriptors which we place after the wakeup descriptor. */
+    pollDescriptorCount = ((ma_snd_pcm_poll_descriptors_proc)pDevice->pContext->alsa.snd_pcm_poll_descriptors)(pPCM, pPollDescriptors + 1, pollDescriptorCount);    /* +1 because we want to place these descriptors after the wakeup descriptor. */
+    if (pollDescriptorCount <= 0) {
+        close(wakeupfd);
+        ma_free(pPollDescriptors, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to retrieve poll descriptors.");
+        return MA_ERROR;
+    }
+
+    if (deviceType == ma_device_type_capture) {
+        pDevice->alsa.pollDescriptorCountCapture = pollDescriptorCount;
+        pDevice->alsa.pPollDescriptorsCapture = pPollDescriptors;
+        pDevice->alsa.wakeupfdCapture = wakeupfd;
+    } else {
+        pDevice->alsa.pollDescriptorCountPlayback = pollDescriptorCount;
+        pDevice->alsa.pPollDescriptorsPlayback = pPollDescriptors;
+        pDevice->alsa.wakeupfdPlayback = wakeupfd;
+    }
+
+
+    /* We're done. Prepare the device. */
+    resultALSA = ((ma_snd_pcm_prepare_proc)pDevice->pContext->alsa.snd_pcm_prepare)(pPCM);
+    if (resultALSA < 0) {
+        close(wakeupfd);
+        ma_free(pPollDescriptors, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to prepare device.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+
+    if (deviceType == ma_device_type_capture) {
+        pDevice->alsa.pPCMCapture         = (ma_ptr)pPCM;
+        pDevice->alsa.isUsingMMapCapture  = isUsingMMap;
+    } else {
+        pDevice->alsa.pPCMPlayback        = (ma_ptr)pPCM;
+        pDevice->alsa.isUsingMMapPlayback = isUsingMMap;
+    }
+
+    pDescriptor->format             = internalFormat;
+    pDescriptor->channels           = internalChannels;
+    pDescriptor->sampleRate         = internalSampleRate;
+    ma_channel_map_copy(pDescriptor->channelMap, internalChannelMap, ma_min(internalChannels, MA_MAX_CHANNELS));
+    pDescriptor->periodSizeInFrames = internalPeriodSizeInFrames;
+    pDescriptor->periodCount        = internalPeriods;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__alsa(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->alsa);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_by_type__alsa(pDevice, pConfig, pDescriptorCapture, ma_device_type_capture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_by_type__alsa(pDevice, pConfig, pDescriptorPlayback, ma_device_type_playback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__alsa(ma_device* pDevice)
+{
+    int resultALSA;
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        resultALSA = ((ma_snd_pcm_start_proc)pDevice->pContext->alsa.snd_pcm_start)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture);
+        if (resultALSA < 0) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to start capture device.");
+            return ma_result_from_errno(-resultALSA);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /*        
+        When data is written to the device we wait for the device to get ready to receive data with poll(). In my testing
+        I have observed that poll() can sometimes block forever unless the device is started explicitly with snd_pcm_start()
+        or some data is written with snd_pcm_writei().
+
+        To resolve this I've decided to do an explicit start with snd_pcm_start(). The problem with this is that the device
+        is started without any data in the internal buffer which will result in an immediate underrun. If instead we were
+        to call into snd_pcm_writei() in an attempt to prevent the underrun, we would run the risk of a weird deadlock
+        issue as documented inside ma_device_write__alsa().
+        */
+        resultALSA = ((ma_snd_pcm_start_proc)pDevice->pContext->alsa.snd_pcm_start)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback);
+        if (resultALSA < 0) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to start playback device.");
+            return ma_result_from_errno(-resultALSA);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__alsa(ma_device* pDevice)
+{
+    /*
+    The stop callback will get called on the worker thread after read/write__alsa() has returned. At this point there is
+    a small chance that our wakeupfd has not been cleared. We'll clear that out now if applicable.
+    */
+    int resultPoll;
+    int resultRead;
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Dropping capture device...\n");
+        ((ma_snd_pcm_drop_proc)pDevice->pContext->alsa.snd_pcm_drop)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture);
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Dropping capture device successful.\n");
+
+        /* We need to prepare the device again, otherwise we won't be able to restart the device. */
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing capture device...\n");
+        if (((ma_snd_pcm_prepare_proc)pDevice->pContext->alsa.snd_pcm_prepare)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture) < 0) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing capture device failed.\n");
+        } else {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing capture device successful.\n");
+        }
+
+        /* Clear the wakeupfd. */
+        resultPoll = poll((struct pollfd*)pDevice->alsa.pPollDescriptorsCapture, 1, 0);
+        if (resultPoll > 0) {
+            ma_uint64 t;
+            resultRead = read(((struct pollfd*)pDevice->alsa.pPollDescriptorsCapture)[0].fd, &t, sizeof(t));
+            if (resultRead != sizeof(t)) {
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Failed to read from capture wakeupfd. read() = %d\n", resultRead);
+            }
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Dropping playback device...\n");
+        ((ma_snd_pcm_drop_proc)pDevice->pContext->alsa.snd_pcm_drop)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback);
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Dropping playback device successful.\n");
+
+        /* We need to prepare the device again, otherwise we won't be able to restart the device. */
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing playback device...\n");
+        if (((ma_snd_pcm_prepare_proc)pDevice->pContext->alsa.snd_pcm_prepare)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback) < 0) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing playback device failed.\n");
+        } else {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing playback device successful.\n");
+        }
+
+        /* Clear the wakeupfd. */
+        resultPoll = poll((struct pollfd*)pDevice->alsa.pPollDescriptorsPlayback, 1, 0);
+        if (resultPoll > 0) {
+            ma_uint64 t;
+            resultRead = read(((struct pollfd*)pDevice->alsa.pPollDescriptorsPlayback)[0].fd, &t, sizeof(t));
+            if (resultRead != sizeof(t)) {
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Failed to read from playback wakeupfd. read() = %d\n", resultRead);
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_wait__alsa(ma_device* pDevice, ma_snd_pcm_t* pPCM, struct pollfd* pPollDescriptors, int pollDescriptorCount, short requiredEvent)
+{
+    for (;;) {
+        unsigned short revents;
+        int resultALSA;
+        int resultPoll = poll(pPollDescriptors, pollDescriptorCount, -1);
+        if (resultPoll < 0) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[ALSA] poll() failed.\n");
+
+            /*
+            There have been reports that poll() is returning an error randomly and that instead of
+            returning an error, simply trying again will work. I'm experimenting with adopting this
+            advice.
+            */
+            continue;
+            /*return ma_result_from_errno(errno);*/
+        }
+
+        /*
+        Before checking the ALSA poll descriptor flag we need to check if the wakeup descriptor
+        has had it's POLLIN flag set. If so, we need to actually read the data and then exit the
+        function. The wakeup descriptor will be the first item in the descriptors buffer.
+        */
+        if ((pPollDescriptors[0].revents & POLLIN) != 0) {
+            ma_uint64 t;
+            int resultRead = read(pPollDescriptors[0].fd, &t, sizeof(t));    /* <-- Important that we read here so that the next write() does not block. */
+            if (resultRead < 0) {
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] read() failed.\n");
+                return ma_result_from_errno(errno);
+            }
+
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] POLLIN set for wakeupfd\n");
+            return MA_DEVICE_NOT_STARTED;
+        }
+
+        /*
+        Getting here means that some data should be able to be read. We need to use ALSA to
+        translate the revents flags for us.
+        */
+        resultALSA = ((ma_snd_pcm_poll_descriptors_revents_proc)pDevice->pContext->alsa.snd_pcm_poll_descriptors_revents)(pPCM, pPollDescriptors + 1, pollDescriptorCount - 1, &revents);   /* +1, -1 to ignore the wakeup descriptor. */
+        if (resultALSA < 0) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] snd_pcm_poll_descriptors_revents() failed.\n");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        if ((revents & POLLERR) != 0) {
+            ma_snd_pcm_state_t state = ((ma_snd_pcm_state_proc)pDevice->pContext->alsa.snd_pcm_state)(pPCM);
+            if (state == MA_SND_PCM_STATE_XRUN) {
+                /* The PCM is in a xrun state. This will be recovered from at a higher level. We can disregard this. */
+            } else {
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[ALSA] POLLERR detected. status = %d\n", ((ma_snd_pcm_state_proc)pDevice->pContext->alsa.snd_pcm_state)(pPCM));
+            }
+        }
+
+        if ((revents & requiredEvent) == requiredEvent) {
+            break;  /* We're done. Data available for reading or writing. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_wait_read__alsa(ma_device* pDevice)
+{
+    return ma_device_wait__alsa(pDevice, (ma_snd_pcm_t*)pDevice->alsa.pPCMCapture, (struct pollfd*)pDevice->alsa.pPollDescriptorsCapture, pDevice->alsa.pollDescriptorCountCapture + 1, POLLIN); /* +1 to account for the wakeup descriptor. */
+}
+
+static ma_result ma_device_wait_write__alsa(ma_device* pDevice)
+{
+    return ma_device_wait__alsa(pDevice, (ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback, (struct pollfd*)pDevice->alsa.pPollDescriptorsPlayback, pDevice->alsa.pollDescriptorCountPlayback + 1, POLLOUT); /* +1 to account for the wakeup descriptor. */
+}
+
+static ma_result ma_device_read__alsa(ma_device* pDevice, void* pFramesOut, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    ma_snd_pcm_sframes_t resultALSA = 0;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started) {
+        ma_result result;
+
+        /* The first thing to do is wait for data to become available for reading. This will return an error code if the device has been stopped. */
+        result = ma_device_wait_read__alsa(pDevice);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        /* Getting here means we should have data available. */
+        resultALSA = ((ma_snd_pcm_readi_proc)pDevice->pContext->alsa.snd_pcm_readi)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture, pFramesOut, frameCount);
+        if (resultALSA >= 0) {
+            break;  /* Success. */
+        } else {
+            if (resultALSA == -EAGAIN) {
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EGAIN (read)\n");*/
+                continue;   /* Try again. */
+            } else if (resultALSA == -EPIPE) {
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EPIPE (read)\n");
+
+                /* Overrun. Recover and try again. If this fails we need to return an error. */
+                resultALSA = ((ma_snd_pcm_recover_proc)pDevice->pContext->alsa.snd_pcm_recover)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture, resultALSA, MA_TRUE);
+                if (resultALSA < 0) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to recover device after overrun.");
+                    return ma_result_from_errno((int)-resultALSA);
+                }
+
+                resultALSA = ((ma_snd_pcm_start_proc)pDevice->pContext->alsa.snd_pcm_start)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture);
+                if (resultALSA < 0) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to start device after underrun.");
+                    return ma_result_from_errno((int)-resultALSA);
+                }
+
+                continue;   /* Try reading again. */
+            }
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = resultALSA;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__alsa(ma_device* pDevice, const void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    ma_snd_pcm_sframes_t resultALSA = 0;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pFrames != NULL);
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started) {
+        ma_result result;
+
+        /* The first thing to do is wait for space to become available for writing. This will return an error code if the device has been stopped. */
+        result = ma_device_wait_write__alsa(pDevice);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        resultALSA = ((ma_snd_pcm_writei_proc)pDevice->pContext->alsa.snd_pcm_writei)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback, pFrames, frameCount);
+        if (resultALSA >= 0) {
+            break;  /* Success. */
+        } else {
+            if (resultALSA == -EAGAIN) {
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EGAIN (write)\n");*/
+                continue;   /* Try again. */
+            } else if (resultALSA == -EPIPE) {
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EPIPE (write)\n");
+
+                /* Underrun. Recover and try again. If this fails we need to return an error. */
+                resultALSA = ((ma_snd_pcm_recover_proc)pDevice->pContext->alsa.snd_pcm_recover)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback, resultALSA, MA_TRUE);    /* MA_TRUE=silent (don't print anything on error). */
+                if (resultALSA < 0) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to recover device after underrun.");
+                    return ma_result_from_errno((int)-resultALSA);
+                }
+
+                /*
+                In my testing I have had a situation where writei() does not automatically restart the device even though I've set it
+                up as such in the software parameters. What will happen is writei() will block indefinitely even though the number of
+                frames is well beyond the auto-start threshold. To work around this I've needed to add an explicit start here. Not sure
+                if this is me just being stupid and not recovering the device properly, but this definitely feels like something isn't
+                quite right here.
+                */
+                resultALSA = ((ma_snd_pcm_start_proc)pDevice->pContext->alsa.snd_pcm_start)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback);
+                if (resultALSA < 0) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to start device after underrun.");
+                    return ma_result_from_errno((int)-resultALSA);
+                }
+
+                continue;   /* Try writing again. */
+            }
+        }
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = resultALSA;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_data_loop_wakeup__alsa(ma_device* pDevice)
+{
+    ma_uint64 t = 1;
+    int resultWrite = 0;
+
+    MA_ASSERT(pDevice != NULL);
+
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Waking up...\n");
+
+    /* Write to an eventfd to trigger a wakeup from poll() and abort any reading or writing. */
+    if (pDevice->alsa.pPollDescriptorsCapture != NULL) {
+        resultWrite = write(pDevice->alsa.wakeupfdCapture, &t, sizeof(t));
+    }
+    if (pDevice->alsa.pPollDescriptorsPlayback != NULL) {
+        resultWrite = write(pDevice->alsa.wakeupfdPlayback, &t, sizeof(t));
+    }
+
+    if (resultWrite < 0) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] write() failed.\n");
+        return ma_result_from_errno(errno);
+    }
+
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Waking up completed successfully.\n");
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__alsa(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_alsa);
+
+    /* Clean up memory for memory leak checkers. */
+    ((ma_snd_config_update_free_global_proc)pContext->alsa.snd_config_update_free_global)();
+
+#ifndef MA_NO_RUNTIME_LINKING
+    ma_dlclose(ma_context_get_log(pContext), pContext->alsa.asoundSO);
+#endif
+
+    ma_mutex_uninit(&pContext->alsa.internalDeviceEnumLock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__alsa(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    ma_result result;
+#ifndef MA_NO_RUNTIME_LINKING
+    const char* libasoundNames[] = {
+        "libasound.so.2",
+        "libasound.so"
+    };
+    size_t i;
+
+    for (i = 0; i < ma_countof(libasoundNames); ++i) {
+        pContext->alsa.asoundSO = ma_dlopen(ma_context_get_log(pContext), libasoundNames[i]);
+        if (pContext->alsa.asoundSO != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->alsa.asoundSO == NULL) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[ALSA] Failed to open shared object.\n");
+        return MA_NO_BACKEND;
+    }
+
+    pContext->alsa.snd_pcm_open                           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_open");
+    pContext->alsa.snd_pcm_close                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_close");
+    pContext->alsa.snd_pcm_hw_params_sizeof               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_sizeof");
+    pContext->alsa.snd_pcm_hw_params_any                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_any");
+    pContext->alsa.snd_pcm_hw_params_set_format           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_format");
+    pContext->alsa.snd_pcm_hw_params_set_format_first     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_format_first");
+    pContext->alsa.snd_pcm_hw_params_get_format_mask      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_format_mask");
+    pContext->alsa.snd_pcm_hw_params_set_channels         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_channels");
+    pContext->alsa.snd_pcm_hw_params_set_channels_near    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_channels_near");
+    pContext->alsa.snd_pcm_hw_params_set_channels_minmax  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_channels_minmax");
+    pContext->alsa.snd_pcm_hw_params_set_rate_resample    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_rate_resample");
+    pContext->alsa.snd_pcm_hw_params_set_rate             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_rate");
+    pContext->alsa.snd_pcm_hw_params_set_rate_near        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_rate_near");
+    pContext->alsa.snd_pcm_hw_params_set_buffer_size_near = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_buffer_size_near");
+    pContext->alsa.snd_pcm_hw_params_set_periods_near     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_periods_near");
+    pContext->alsa.snd_pcm_hw_params_set_access           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_access");
+    pContext->alsa.snd_pcm_hw_params_get_format           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_format");
+    pContext->alsa.snd_pcm_hw_params_get_channels         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_channels");
+    pContext->alsa.snd_pcm_hw_params_get_channels_min     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_channels_min");
+    pContext->alsa.snd_pcm_hw_params_get_channels_max     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_channels_max");
+    pContext->alsa.snd_pcm_hw_params_get_rate             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_rate");
+    pContext->alsa.snd_pcm_hw_params_get_rate_min         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_rate_min");
+    pContext->alsa.snd_pcm_hw_params_get_rate_max         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_rate_max");
+    pContext->alsa.snd_pcm_hw_params_get_buffer_size      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_buffer_size");
+    pContext->alsa.snd_pcm_hw_params_get_periods          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_periods");
+    pContext->alsa.snd_pcm_hw_params_get_access           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_access");
+    pContext->alsa.snd_pcm_hw_params_test_format          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_test_format");
+    pContext->alsa.snd_pcm_hw_params_test_channels        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_test_channels");
+    pContext->alsa.snd_pcm_hw_params_test_rate            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_test_rate");
+    pContext->alsa.snd_pcm_hw_params                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params");
+    pContext->alsa.snd_pcm_sw_params_sizeof               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_sizeof");
+    pContext->alsa.snd_pcm_sw_params_current              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_current");
+    pContext->alsa.snd_pcm_sw_params_get_boundary         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_get_boundary");
+    pContext->alsa.snd_pcm_sw_params_set_avail_min        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_set_avail_min");
+    pContext->alsa.snd_pcm_sw_params_set_start_threshold  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_set_start_threshold");
+    pContext->alsa.snd_pcm_sw_params_set_stop_threshold   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_set_stop_threshold");
+    pContext->alsa.snd_pcm_sw_params                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params");
+    pContext->alsa.snd_pcm_format_mask_sizeof             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_format_mask_sizeof");
+    pContext->alsa.snd_pcm_format_mask_test               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_format_mask_test");
+    pContext->alsa.snd_pcm_get_chmap                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_get_chmap");
+    pContext->alsa.snd_pcm_state                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_state");
+    pContext->alsa.snd_pcm_prepare                        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_prepare");
+    pContext->alsa.snd_pcm_start                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_start");
+    pContext->alsa.snd_pcm_drop                           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_drop");
+    pContext->alsa.snd_pcm_drain                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_drain");
+    pContext->alsa.snd_pcm_reset                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_reset");
+    pContext->alsa.snd_device_name_hint                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_device_name_hint");
+    pContext->alsa.snd_device_name_get_hint               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_device_name_get_hint");
+    pContext->alsa.snd_card_get_index                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_card_get_index");
+    pContext->alsa.snd_device_name_free_hint              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_device_name_free_hint");
+    pContext->alsa.snd_pcm_mmap_begin                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_mmap_begin");
+    pContext->alsa.snd_pcm_mmap_commit                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_mmap_commit");
+    pContext->alsa.snd_pcm_recover                        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_recover");
+    pContext->alsa.snd_pcm_readi                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_readi");
+    pContext->alsa.snd_pcm_writei                         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_writei");
+    pContext->alsa.snd_pcm_avail                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_avail");
+    pContext->alsa.snd_pcm_avail_update                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_avail_update");
+    pContext->alsa.snd_pcm_wait                           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_wait");
+    pContext->alsa.snd_pcm_nonblock                       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_nonblock");
+    pContext->alsa.snd_pcm_info                           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_info");
+    pContext->alsa.snd_pcm_info_sizeof                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_info_sizeof");
+    pContext->alsa.snd_pcm_info_get_name                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_info_get_name");
+    pContext->alsa.snd_pcm_poll_descriptors               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_poll_descriptors");
+    pContext->alsa.snd_pcm_poll_descriptors_count         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_poll_descriptors_count");
+    pContext->alsa.snd_pcm_poll_descriptors_revents       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_poll_descriptors_revents");
+    pContext->alsa.snd_config_update_free_global          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_config_update_free_global");
+#else
+    /* The system below is just for type safety. */
+    ma_snd_pcm_open_proc                           _snd_pcm_open                           = snd_pcm_open;
+    ma_snd_pcm_close_proc                          _snd_pcm_close                          = snd_pcm_close;
+    ma_snd_pcm_hw_params_sizeof_proc               _snd_pcm_hw_params_sizeof               = snd_pcm_hw_params_sizeof;
+    ma_snd_pcm_hw_params_any_proc                  _snd_pcm_hw_params_any                  = snd_pcm_hw_params_any;
+    ma_snd_pcm_hw_params_set_format_proc           _snd_pcm_hw_params_set_format           = snd_pcm_hw_params_set_format;
+    ma_snd_pcm_hw_params_set_format_first_proc     _snd_pcm_hw_params_set_format_first     = snd_pcm_hw_params_set_format_first;
+    ma_snd_pcm_hw_params_get_format_mask_proc      _snd_pcm_hw_params_get_format_mask      = snd_pcm_hw_params_get_format_mask;
+    ma_snd_pcm_hw_params_set_channels_proc         _snd_pcm_hw_params_set_channels         = snd_pcm_hw_params_set_channels;
+    ma_snd_pcm_hw_params_set_channels_near_proc    _snd_pcm_hw_params_set_channels_near    = snd_pcm_hw_params_set_channels_near;
+    ma_snd_pcm_hw_params_set_channels_minmax_proc  _snd_pcm_hw_params_set_channels_minmax  = snd_pcm_hw_params_set_channels_minmax;
+    ma_snd_pcm_hw_params_set_rate_resample_proc    _snd_pcm_hw_params_set_rate_resample    = snd_pcm_hw_params_set_rate_resample;
+    ma_snd_pcm_hw_params_set_rate_proc             _snd_pcm_hw_params_set_rate             = snd_pcm_hw_params_set_rate;
+    ma_snd_pcm_hw_params_set_rate_near_proc        _snd_pcm_hw_params_set_rate_near        = snd_pcm_hw_params_set_rate_near;
+    ma_snd_pcm_hw_params_set_rate_minmax_proc      _snd_pcm_hw_params_set_rate_minmax      = snd_pcm_hw_params_set_rate_minmax;
+    ma_snd_pcm_hw_params_set_buffer_size_near_proc _snd_pcm_hw_params_set_buffer_size_near = snd_pcm_hw_params_set_buffer_size_near;
+    ma_snd_pcm_hw_params_set_periods_near_proc     _snd_pcm_hw_params_set_periods_near     = snd_pcm_hw_params_set_periods_near;
+    ma_snd_pcm_hw_params_set_access_proc           _snd_pcm_hw_params_set_access           = snd_pcm_hw_params_set_access;
+    ma_snd_pcm_hw_params_get_format_proc           _snd_pcm_hw_params_get_format           = snd_pcm_hw_params_get_format;
+    ma_snd_pcm_hw_params_get_channels_proc         _snd_pcm_hw_params_get_channels         = snd_pcm_hw_params_get_channels;
+    ma_snd_pcm_hw_params_get_channels_min_proc     _snd_pcm_hw_params_get_channels_min     = snd_pcm_hw_params_get_channels_min;
+    ma_snd_pcm_hw_params_get_channels_max_proc     _snd_pcm_hw_params_get_channels_max     = snd_pcm_hw_params_get_channels_max;
+    ma_snd_pcm_hw_params_get_rate_proc             _snd_pcm_hw_params_get_rate             = snd_pcm_hw_params_get_rate;
+    ma_snd_pcm_hw_params_get_rate_min_proc         _snd_pcm_hw_params_get_rate_min         = snd_pcm_hw_params_get_rate_min;
+    ma_snd_pcm_hw_params_get_rate_max_proc         _snd_pcm_hw_params_get_rate_max         = snd_pcm_hw_params_get_rate_max;
+    ma_snd_pcm_hw_params_get_buffer_size_proc      _snd_pcm_hw_params_get_buffer_size      = snd_pcm_hw_params_get_buffer_size;
+    ma_snd_pcm_hw_params_get_periods_proc          _snd_pcm_hw_params_get_periods          = snd_pcm_hw_params_get_periods;
+    ma_snd_pcm_hw_params_get_access_proc           _snd_pcm_hw_params_get_access           = snd_pcm_hw_params_get_access;
+    ma_snd_pcm_hw_params_test_format_proc          _snd_pcm_hw_params_test_format          = snd_pcm_hw_params_test_format;
+    ma_snd_pcm_hw_params_test_channels_proc        _snd_pcm_hw_params_test_channels        = snd_pcm_hw_params_test_channels;
+    ma_snd_pcm_hw_params_test_rate_proc            _snd_pcm_hw_params_test_rate            = snd_pcm_hw_params_test_rate;
+    ma_snd_pcm_hw_params_proc                      _snd_pcm_hw_params                      = snd_pcm_hw_params;
+    ma_snd_pcm_sw_params_sizeof_proc               _snd_pcm_sw_params_sizeof               = snd_pcm_sw_params_sizeof;
+    ma_snd_pcm_sw_params_current_proc              _snd_pcm_sw_params_current              = snd_pcm_sw_params_current;
+    ma_snd_pcm_sw_params_get_boundary_proc         _snd_pcm_sw_params_get_boundary         = snd_pcm_sw_params_get_boundary;
+    ma_snd_pcm_sw_params_set_avail_min_proc        _snd_pcm_sw_params_set_avail_min        = snd_pcm_sw_params_set_avail_min;
+    ma_snd_pcm_sw_params_set_start_threshold_proc  _snd_pcm_sw_params_set_start_threshold  = snd_pcm_sw_params_set_start_threshold;
+    ma_snd_pcm_sw_params_set_stop_threshold_proc   _snd_pcm_sw_params_set_stop_threshold   = snd_pcm_sw_params_set_stop_threshold;
+    ma_snd_pcm_sw_params_proc                      _snd_pcm_sw_params                      = snd_pcm_sw_params;
+    ma_snd_pcm_format_mask_sizeof_proc             _snd_pcm_format_mask_sizeof             = snd_pcm_format_mask_sizeof;
+    ma_snd_pcm_format_mask_test_proc               _snd_pcm_format_mask_test               = snd_pcm_format_mask_test;
+    ma_snd_pcm_get_chmap_proc                      _snd_pcm_get_chmap                      = snd_pcm_get_chmap;
+    ma_snd_pcm_state_proc                          _snd_pcm_state                          = snd_pcm_state;
+    ma_snd_pcm_prepare_proc                        _snd_pcm_prepare                        = snd_pcm_prepare;
+    ma_snd_pcm_start_proc                          _snd_pcm_start                          = snd_pcm_start;
+    ma_snd_pcm_drop_proc                           _snd_pcm_drop                           = snd_pcm_drop;
+    ma_snd_pcm_drain_proc                          _snd_pcm_drain                          = snd_pcm_drain;
+    ma_snd_pcm_reset_proc                          _snd_pcm_reset                          = snd_pcm_reset;
+    ma_snd_device_name_hint_proc                   _snd_device_name_hint                   = snd_device_name_hint;
+    ma_snd_device_name_get_hint_proc               _snd_device_name_get_hint               = snd_device_name_get_hint;
+    ma_snd_card_get_index_proc                     _snd_card_get_index                     = snd_card_get_index;
+    ma_snd_device_name_free_hint_proc              _snd_device_name_free_hint              = snd_device_name_free_hint;
+    ma_snd_pcm_mmap_begin_proc                     _snd_pcm_mmap_begin                     = snd_pcm_mmap_begin;
+    ma_snd_pcm_mmap_commit_proc                    _snd_pcm_mmap_commit                    = snd_pcm_mmap_commit;
+    ma_snd_pcm_recover_proc                        _snd_pcm_recover                        = snd_pcm_recover;
+    ma_snd_pcm_readi_proc                          _snd_pcm_readi                          = snd_pcm_readi;
+    ma_snd_pcm_writei_proc                         _snd_pcm_writei                         = snd_pcm_writei;
+    ma_snd_pcm_avail_proc                          _snd_pcm_avail                          = snd_pcm_avail;
+    ma_snd_pcm_avail_update_proc                   _snd_pcm_avail_update                   = snd_pcm_avail_update;
+    ma_snd_pcm_wait_proc                           _snd_pcm_wait                           = snd_pcm_wait;
+    ma_snd_pcm_nonblock_proc                       _snd_pcm_nonblock                       = snd_pcm_nonblock;
+    ma_snd_pcm_info_proc                           _snd_pcm_info                           = snd_pcm_info;
+    ma_snd_pcm_info_sizeof_proc                    _snd_pcm_info_sizeof                    = snd_pcm_info_sizeof;
+    ma_snd_pcm_info_get_name_proc                  _snd_pcm_info_get_name                  = snd_pcm_info_get_name;
+    ma_snd_pcm_poll_descriptors_proc               _snd_pcm_poll_descriptors               = snd_pcm_poll_descriptors;
+    ma_snd_pcm_poll_descriptors_count_proc         _snd_pcm_poll_descriptors_count         = snd_pcm_poll_descriptors_count;
+    ma_snd_pcm_poll_descriptors_revents_proc       _snd_pcm_poll_descriptors_revents       = snd_pcm_poll_descriptors_revents;
+    ma_snd_config_update_free_global_proc          _snd_config_update_free_global          = snd_config_update_free_global;
+
+    pContext->alsa.snd_pcm_open                           = (ma_proc)_snd_pcm_open;
+    pContext->alsa.snd_pcm_close                          = (ma_proc)_snd_pcm_close;
+    pContext->alsa.snd_pcm_hw_params_sizeof               = (ma_proc)_snd_pcm_hw_params_sizeof;
+    pContext->alsa.snd_pcm_hw_params_any                  = (ma_proc)_snd_pcm_hw_params_any;
+    pContext->alsa.snd_pcm_hw_params_set_format           = (ma_proc)_snd_pcm_hw_params_set_format;
+    pContext->alsa.snd_pcm_hw_params_set_format_first     = (ma_proc)_snd_pcm_hw_params_set_format_first;
+    pContext->alsa.snd_pcm_hw_params_get_format_mask      = (ma_proc)_snd_pcm_hw_params_get_format_mask;
+    pContext->alsa.snd_pcm_hw_params_set_channels         = (ma_proc)_snd_pcm_hw_params_set_channels;
+    pContext->alsa.snd_pcm_hw_params_set_channels_near    = (ma_proc)_snd_pcm_hw_params_set_channels_near;
+    pContext->alsa.snd_pcm_hw_params_set_channels_minmax  = (ma_proc)_snd_pcm_hw_params_set_channels_minmax;
+    pContext->alsa.snd_pcm_hw_params_set_rate_resample    = (ma_proc)_snd_pcm_hw_params_set_rate_resample;
+    pContext->alsa.snd_pcm_hw_params_set_rate             = (ma_proc)_snd_pcm_hw_params_set_rate;
+    pContext->alsa.snd_pcm_hw_params_set_rate_near        = (ma_proc)_snd_pcm_hw_params_set_rate_near;
+    pContext->alsa.snd_pcm_hw_params_set_rate_minmax      = (ma_proc)_snd_pcm_hw_params_set_rate_minmax;
+    pContext->alsa.snd_pcm_hw_params_set_buffer_size_near = (ma_proc)_snd_pcm_hw_params_set_buffer_size_near;
+    pContext->alsa.snd_pcm_hw_params_set_periods_near     = (ma_proc)_snd_pcm_hw_params_set_periods_near;
+    pContext->alsa.snd_pcm_hw_params_set_access           = (ma_proc)_snd_pcm_hw_params_set_access;
+    pContext->alsa.snd_pcm_hw_params_get_format           = (ma_proc)_snd_pcm_hw_params_get_format;
+    pContext->alsa.snd_pcm_hw_params_get_channels         = (ma_proc)_snd_pcm_hw_params_get_channels;
+    pContext->alsa.snd_pcm_hw_params_get_channels_min     = (ma_proc)_snd_pcm_hw_params_get_channels_min;
+    pContext->alsa.snd_pcm_hw_params_get_channels_max     = (ma_proc)_snd_pcm_hw_params_get_channels_max;
+    pContext->alsa.snd_pcm_hw_params_get_rate             = (ma_proc)_snd_pcm_hw_params_get_rate;
+    pContext->alsa.snd_pcm_hw_params_get_rate_min         = (ma_proc)_snd_pcm_hw_params_get_rate_min;
+    pContext->alsa.snd_pcm_hw_params_get_rate_max         = (ma_proc)_snd_pcm_hw_params_get_rate_max;
+    pContext->alsa.snd_pcm_hw_params_get_buffer_size      = (ma_proc)_snd_pcm_hw_params_get_buffer_size;
+    pContext->alsa.snd_pcm_hw_params_get_periods          = (ma_proc)_snd_pcm_hw_params_get_periods;
+    pContext->alsa.snd_pcm_hw_params_get_access           = (ma_proc)_snd_pcm_hw_params_get_access;
+    pContext->alsa.snd_pcm_hw_params_test_format          = (ma_proc)_snd_pcm_hw_params_test_format;
+    pContext->alsa.snd_pcm_hw_params_test_channels        = (ma_proc)_snd_pcm_hw_params_test_channels;
+    pContext->alsa.snd_pcm_hw_params_test_rate            = (ma_proc)_snd_pcm_hw_params_test_rate;
+    pContext->alsa.snd_pcm_hw_params                      = (ma_proc)_snd_pcm_hw_params;
+    pContext->alsa.snd_pcm_sw_params_sizeof               = (ma_proc)_snd_pcm_sw_params_sizeof;
+    pContext->alsa.snd_pcm_sw_params_current              = (ma_proc)_snd_pcm_sw_params_current;
+    pContext->alsa.snd_pcm_sw_params_get_boundary         = (ma_proc)_snd_pcm_sw_params_get_boundary;
+    pContext->alsa.snd_pcm_sw_params_set_avail_min        = (ma_proc)_snd_pcm_sw_params_set_avail_min;
+    pContext->alsa.snd_pcm_sw_params_set_start_threshold  = (ma_proc)_snd_pcm_sw_params_set_start_threshold;
+    pContext->alsa.snd_pcm_sw_params_set_stop_threshold   = (ma_proc)_snd_pcm_sw_params_set_stop_threshold;
+    pContext->alsa.snd_pcm_sw_params                      = (ma_proc)_snd_pcm_sw_params;
+    pContext->alsa.snd_pcm_format_mask_sizeof             = (ma_proc)_snd_pcm_format_mask_sizeof;
+    pContext->alsa.snd_pcm_format_mask_test               = (ma_proc)_snd_pcm_format_mask_test;
+    pContext->alsa.snd_pcm_get_chmap                      = (ma_proc)_snd_pcm_get_chmap;
+    pContext->alsa.snd_pcm_state                          = (ma_proc)_snd_pcm_state;
+    pContext->alsa.snd_pcm_prepare                        = (ma_proc)_snd_pcm_prepare;
+    pContext->alsa.snd_pcm_start                          = (ma_proc)_snd_pcm_start;
+    pContext->alsa.snd_pcm_drop                           = (ma_proc)_snd_pcm_drop;
+    pContext->alsa.snd_pcm_drain                          = (ma_proc)_snd_pcm_drain;
+    pContext->alsa.snd_pcm_reset                          = (ma_proc)_snd_pcm_reset;
+    pContext->alsa.snd_device_name_hint                   = (ma_proc)_snd_device_name_hint;
+    pContext->alsa.snd_device_name_get_hint               = (ma_proc)_snd_device_name_get_hint;
+    pContext->alsa.snd_card_get_index                     = (ma_proc)_snd_card_get_index;
+    pContext->alsa.snd_device_name_free_hint              = (ma_proc)_snd_device_name_free_hint;
+    pContext->alsa.snd_pcm_mmap_begin                     = (ma_proc)_snd_pcm_mmap_begin;
+    pContext->alsa.snd_pcm_mmap_commit                    = (ma_proc)_snd_pcm_mmap_commit;
+    pContext->alsa.snd_pcm_recover                        = (ma_proc)_snd_pcm_recover;
+    pContext->alsa.snd_pcm_readi                          = (ma_proc)_snd_pcm_readi;
+    pContext->alsa.snd_pcm_writei                         = (ma_proc)_snd_pcm_writei;
+    pContext->alsa.snd_pcm_avail                          = (ma_proc)_snd_pcm_avail;
+    pContext->alsa.snd_pcm_avail_update                   = (ma_proc)_snd_pcm_avail_update;
+    pContext->alsa.snd_pcm_wait                           = (ma_proc)_snd_pcm_wait;
+    pContext->alsa.snd_pcm_nonblock                       = (ma_proc)_snd_pcm_nonblock;
+    pContext->alsa.snd_pcm_info                           = (ma_proc)_snd_pcm_info;
+    pContext->alsa.snd_pcm_info_sizeof                    = (ma_proc)_snd_pcm_info_sizeof;
+    pContext->alsa.snd_pcm_info_get_name                  = (ma_proc)_snd_pcm_info_get_name;
+    pContext->alsa.snd_pcm_poll_descriptors               = (ma_proc)_snd_pcm_poll_descriptors;
+    pContext->alsa.snd_pcm_poll_descriptors_count         = (ma_proc)_snd_pcm_poll_descriptors_count;
+    pContext->alsa.snd_pcm_poll_descriptors_revents       = (ma_proc)_snd_pcm_poll_descriptors_revents;
+    pContext->alsa.snd_config_update_free_global          = (ma_proc)_snd_config_update_free_global;
+#endif
+
+    pContext->alsa.useVerboseDeviceEnumeration = pConfig->alsa.useVerboseDeviceEnumeration;
+
+    result = ma_mutex_init(&pContext->alsa.internalDeviceEnumLock);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[ALSA] WARNING: Failed to initialize mutex for internal device enumeration.");
+        return result;
+    }
+
+    pCallbacks->onContextInit             = ma_context_init__alsa;
+    pCallbacks->onContextUninit           = ma_context_uninit__alsa;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__alsa;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__alsa;
+    pCallbacks->onDeviceInit              = ma_device_init__alsa;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__alsa;
+    pCallbacks->onDeviceStart             = ma_device_start__alsa;
+    pCallbacks->onDeviceStop              = ma_device_stop__alsa;
+    pCallbacks->onDeviceRead              = ma_device_read__alsa;
+    pCallbacks->onDeviceWrite             = ma_device_write__alsa;
+    pCallbacks->onDeviceDataLoop          = NULL;
+    pCallbacks->onDeviceDataLoopWakeup    = ma_device_data_loop_wakeup__alsa;
+
+    return MA_SUCCESS;
+}
+#endif  /* MA_HAS_ALSA */
+
+
+
+/******************************************************************************
+
+PulseAudio Backend
+
+******************************************************************************/
+#ifdef MA_HAS_PULSEAUDIO
+/*
+The PulseAudio API, along with Apple's Core Audio, is the worst of the mainstream audio APIs. This is a brief description of what's going on
+in the PulseAudio backend. I apologize if this gets a bit ranty for your liking - you might want to skip this discussion.
+
+PulseAudio has something they call the "Simple API", which unfortunately isn't suitable for miniaudio. I've not seen anywhere where it
+allows you to enumerate over devices, nor does it seem to support the ability to stop and start streams. Looking at the documentation, it
+appears as though the stream is constantly running and you prevent sound from being emitted or captured by simply not calling the read or
+write functions. This is not a professional solution as it would be much better to *actually* stop the underlying stream. Perhaps the
+simple API has some smarts to do this automatically, but I'm not sure. Another limitation with the simple API is that it seems inefficient
+when you want to have multiple streams to a single context. For these reasons, miniaudio is not using the simple API.
+
+Since we're not using the simple API, we're left with the asynchronous API as our only other option. And boy, is this where it starts to
+get fun, and I don't mean that in a good way...
+
+The problems start with the very name of the API - "asynchronous". Yes, this is an asynchronous oriented API which means your commands
+don't immediately take effect. You instead need to issue your commands, and then wait for them to complete. The waiting mechanism is
+enabled through the use of a "main loop". In the asynchronous API you cannot get away from the main loop, and the main loop is where almost
+all of PulseAudio's problems stem from.
+
+When you first initialize PulseAudio you need an object referred to as "main loop". You can implement this yourself by defining your own
+vtable, but it's much easier to just use one of the built-in main loop implementations. There's two generic implementations called
+pa_mainloop and pa_threaded_mainloop, and another implementation specific to GLib called pa_glib_mainloop. We're using pa_threaded_mainloop
+because it simplifies management of the worker thread. The idea of the main loop object is pretty self explanatory - you're supposed to use
+it to implement a worker thread which runs in a loop. The main loop is where operations are actually executed.
+
+To initialize the main loop, you just use `pa_threaded_mainloop_new()`. This is the first function you'll call. You can then get a pointer
+to the vtable with `pa_threaded_mainloop_get_api()` (the main loop vtable is called `pa_mainloop_api`). Again, you can bypass the threaded
+main loop object entirely and just implement `pa_mainloop_api` directly, but there's no need for it unless you're doing something extremely
+specialized such as if you want to integrate it into your application's existing main loop infrastructure.
+
+(EDIT 2021-01-26: miniaudio is no longer using `pa_threaded_mainloop` due to this issue: https://github.com/mackron/miniaudio/issues/262.
+It is now using `pa_mainloop` which turns out to be a simpler solution anyway. The rest of this rant still applies, however.)
+
+Once you have your main loop vtable (the `pa_mainloop_api` object) you can create the PulseAudio context. This is very similar to
+miniaudio's context and they map to each other quite well. You have one context to many streams, which is basically the same as miniaudio's
+one `ma_context` to many `ma_device`s. Here's where it starts to get annoying, however. When you first create the PulseAudio context, which
+is done with `pa_context_new()`, it's not actually connected to anything. When you connect, you call `pa_context_connect()`. However, if
+you remember, PulseAudio is an asynchronous API. That means you cannot just assume the context is connected after `pa_context_context()`
+has returned. You instead need to wait for it to connect. To do this, you need to either wait for a callback to get fired, which you can
+set with `pa_context_set_state_callback()`, or you can continuously poll the context's state. Either way, you need to run this in a loop.
+All objects from here out are created from the context, and, I believe, you can't be creating these objects until the context is connected.
+This waiting loop is therefore unavoidable. In order for the waiting to ever complete, however, the main loop needs to be running. Before
+attempting to connect the context, the main loop needs to be started with `pa_threaded_mainloop_start()`.
+
+The reason for this asynchronous design is to support cases where you're connecting to a remote server, say through a local network or an
+internet connection. However, the *VAST* majority of cases don't involve this at all - they just connect to a local "server" running on the
+host machine. The fact that this would be the default rather than making `pa_context_connect()` synchronous tends to boggle the mind.
+
+Once the context has been created and connected you can start creating a stream. A PulseAudio stream is analogous to miniaudio's device.
+The initialization of a stream is fairly standard - you configure some attributes (analogous to miniaudio's device config) and then call
+`pa_stream_new()` to actually create it. Here is where we start to get into "operations". When configuring the stream, you can get
+information about the source (such as sample format, sample rate, etc.), however it's not synchronous. Instead, a `pa_operation` object
+is returned from `pa_context_get_source_info_by_name()` (capture) or `pa_context_get_sink_info_by_name()` (playback). Then, you need to
+run a loop (again!) to wait for the operation to complete which you can determine via a callback or polling, just like we did with the
+context. Then, as an added bonus, you need to decrement the reference counter of the `pa_operation` object to ensure memory is cleaned up.
+All of that just to retrieve basic information about a device!
+
+Once the basic information about the device has been retrieved, miniaudio can now create the stream with `ma_stream_new()`. Like the
+context, this needs to be connected. But we need to be careful here, because we're now about to introduce one of the most horrific design
+choices in PulseAudio.
+
+PulseAudio allows you to specify a callback that is fired when data can be written to or read from a stream. The language is important here
+because PulseAudio takes it literally, specifically the "can be". You would think these callbacks would be appropriate as the place for
+writing and reading data to and from the stream, and that would be right, except when it's not. When you initialize the stream, you can
+set a flag that tells PulseAudio to not start the stream automatically. This is required because miniaudio does not auto-start devices
+straight after initialization - you need to call `ma_device_start()` manually. The problem is that even when this flag is specified,
+PulseAudio will immediately fire its write or read callback. This is *technically* correct (based on the wording in the documentation)
+because indeed, data *can* be written at this point. The problem is that it's not *practical*. It makes sense that the write/read callback
+would be where a program will want to write or read data to or from the stream, but when it's called before the application has even
+requested that the stream be started, it's just not practical because the program probably isn't ready for any kind of data delivery at
+that point (it may still need to load files or whatnot). Instead, this callback should only be fired when the application requests the
+stream be started which is how it works with literally *every* other callback-based audio API. Since miniaudio forbids firing of the data
+callback until the device has been started (as it should be with *all* callback based APIs), logic needs to be added to ensure miniaudio
+doesn't just blindly fire the application-defined data callback from within the PulseAudio callback before the stream has actually been
+started. The device state is used for this - if the state is anything other than `ma_device_state_starting` or `ma_device_state_started`, the main data
+callback is not fired.
+
+This, unfortunately, is not the end of the problems with the PulseAudio write callback. Any normal callback based audio API will
+continuously fire the callback at regular intervals based on the size of the internal buffer. This will only ever be fired when the device
+is running, and will be fired regardless of whether or not the user actually wrote anything to the device/stream. This not the case in
+PulseAudio. In PulseAudio, the data callback will *only* be called if you wrote something to it previously. That means, if you don't call
+`pa_stream_write()`, the callback will not get fired. On the surface you wouldn't think this would matter because you should be always
+writing data, and if you don't have anything to write, just write silence. That's fine until you want to drain the stream. You see, if
+you're continuously writing data to the stream, the stream will never get drained! That means in order to drain the stream, you need to
+*not* write data to it! But remember, when you don't write data to the stream, the callback won't get fired again! Why is draining
+important? Because that's how we've defined stopping to work in miniaudio. In miniaudio, stopping the device requires it to be drained
+before returning from ma_device_stop(). So we've stopped the device, which requires us to drain, but draining requires us to *not* write
+data to the stream (or else it won't ever complete draining), but not writing to the stream means the callback won't get fired again!
+
+This becomes a problem when stopping and then restarting the device. When the device is stopped, it's drained, which requires us to *not*
+write anything to the stream. But then, since we didn't write anything to it, the write callback will *never* get called again if we just
+resume the stream naively. This means that starting the stream requires us to write data to the stream from outside the callback. This
+disconnect is something PulseAudio has got seriously wrong - there should only ever be a single source of data delivery, that being the
+callback. (I have tried using `pa_stream_flush()` to trigger the write callback to fire, but this just doesn't work for some reason.)
+
+Once you've created the stream, you need to connect it which involves the whole waiting procedure. This is the same process as the context,
+only this time you'll poll for the state with `pa_stream_get_status()`. The starting and stopping of a streaming is referred to as
+"corking" in PulseAudio. The analogy is corking a barrel. To start the stream, you uncork it, to stop it you cork it. Personally I think
+it's silly - why would you not just call it "starting" and "stopping" like any other normal audio API? Anyway, the act of corking is, you
+guessed it, asynchronous. This means you'll need our waiting loop as usual. Again, why this asynchronous design is the default is
+absolutely beyond me. Would it really be that hard to just make it run synchronously?
+
+Teardown is pretty simple (what?!). It's just a matter of calling the relevant `_unref()` function on each object in reverse order that
+they were initialized in.
+
+That's about it from the PulseAudio side. A bit ranty, I know, but they really need to fix that main loop and callback system. They're
+embarrassingly unpractical. The main loop thing is an easy fix - have synchronous versions of all APIs. If an application wants these to
+run asynchronously, they can execute them in a separate thread themselves. The desire to run these asynchronously is such a niche
+requirement - it makes no sense to make it the default. The stream write callback needs to be change, or an alternative provided, that is
+constantly fired, regardless of whether or not `pa_stream_write()` has been called, and it needs to take a pointer to a buffer as a
+parameter which the program just writes to directly rather than having to call `pa_stream_writable_size()` and `pa_stream_write()`. These
+changes alone will change PulseAudio from one of the worst audio APIs to one of the best.
+*/
+
+
+/*
+It is assumed pulseaudio.h is available when linking at compile time. When linking at compile time, we use the declarations in the header
+to check for type safety. We cannot do this when linking at run time because the header might not be available.
+*/
+#ifdef MA_NO_RUNTIME_LINKING
+
+/* pulseaudio.h marks some functions with "inline" which isn't always supported. Need to emulate it. */
+#if !defined(__cplusplus)
+    #if defined(__STRICT_ANSI__)
+        #if !defined(inline)
+            #define inline __inline__ __attribute__((always_inline))
+            #define MA_INLINE_DEFINED
+        #endif
+    #endif
+#endif
+#include <pulse/pulseaudio.h>
+#if defined(MA_INLINE_DEFINED)
+    #undef inline
+    #undef MA_INLINE_DEFINED
+#endif
+
+#define MA_PA_OK                                       PA_OK
+#define MA_PA_ERR_ACCESS                               PA_ERR_ACCESS
+#define MA_PA_ERR_INVALID                              PA_ERR_INVALID
+#define MA_PA_ERR_NOENTITY                             PA_ERR_NOENTITY
+#define MA_PA_ERR_NOTSUPPORTED                         PA_ERR_NOTSUPPORTED
+
+#define MA_PA_CHANNELS_MAX                             PA_CHANNELS_MAX
+#define MA_PA_RATE_MAX                                 PA_RATE_MAX
+
+typedef pa_context_flags_t ma_pa_context_flags_t;
+#define MA_PA_CONTEXT_NOFLAGS                          PA_CONTEXT_NOFLAGS
+#define MA_PA_CONTEXT_NOAUTOSPAWN                      PA_CONTEXT_NOAUTOSPAWN
+#define MA_PA_CONTEXT_NOFAIL                           PA_CONTEXT_NOFAIL
+
+typedef pa_stream_flags_t ma_pa_stream_flags_t;
+#define MA_PA_STREAM_NOFLAGS                           PA_STREAM_NOFLAGS
+#define MA_PA_STREAM_START_CORKED                      PA_STREAM_START_CORKED
+#define MA_PA_STREAM_INTERPOLATE_TIMING                PA_STREAM_INTERPOLATE_TIMING
+#define MA_PA_STREAM_NOT_MONOTONIC                     PA_STREAM_NOT_MONOTONIC
+#define MA_PA_STREAM_AUTO_TIMING_UPDATE                PA_STREAM_AUTO_TIMING_UPDATE
+#define MA_PA_STREAM_NO_REMAP_CHANNELS                 PA_STREAM_NO_REMAP_CHANNELS
+#define MA_PA_STREAM_NO_REMIX_CHANNELS                 PA_STREAM_NO_REMIX_CHANNELS
+#define MA_PA_STREAM_FIX_FORMAT                        PA_STREAM_FIX_FORMAT
+#define MA_PA_STREAM_FIX_RATE                          PA_STREAM_FIX_RATE
+#define MA_PA_STREAM_FIX_CHANNELS                      PA_STREAM_FIX_CHANNELS
+#define MA_PA_STREAM_DONT_MOVE                         PA_STREAM_DONT_MOVE
+#define MA_PA_STREAM_VARIABLE_RATE                     PA_STREAM_VARIABLE_RATE
+#define MA_PA_STREAM_PEAK_DETECT                       PA_STREAM_PEAK_DETECT
+#define MA_PA_STREAM_START_MUTED                       PA_STREAM_START_MUTED
+#define MA_PA_STREAM_ADJUST_LATENCY                    PA_STREAM_ADJUST_LATENCY
+#define MA_PA_STREAM_EARLY_REQUESTS                    PA_STREAM_EARLY_REQUESTS
+#define MA_PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND         PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND
+#define MA_PA_STREAM_START_UNMUTED                     PA_STREAM_START_UNMUTED
+#define MA_PA_STREAM_FAIL_ON_SUSPEND                   PA_STREAM_FAIL_ON_SUSPEND
+#define MA_PA_STREAM_RELATIVE_VOLUME                   PA_STREAM_RELATIVE_VOLUME
+#define MA_PA_STREAM_PASSTHROUGH                       PA_STREAM_PASSTHROUGH
+
+typedef pa_sink_flags_t ma_pa_sink_flags_t;
+#define MA_PA_SINK_NOFLAGS                             PA_SINK_NOFLAGS
+#define MA_PA_SINK_HW_VOLUME_CTRL                      PA_SINK_HW_VOLUME_CTRL
+#define MA_PA_SINK_LATENCY                             PA_SINK_LATENCY
+#define MA_PA_SINK_HARDWARE                            PA_SINK_HARDWARE
+#define MA_PA_SINK_NETWORK                             PA_SINK_NETWORK
+#define MA_PA_SINK_HW_MUTE_CTRL                        PA_SINK_HW_MUTE_CTRL
+#define MA_PA_SINK_DECIBEL_VOLUME                      PA_SINK_DECIBEL_VOLUME
+#define MA_PA_SINK_FLAT_VOLUME                         PA_SINK_FLAT_VOLUME
+#define MA_PA_SINK_DYNAMIC_LATENCY                     PA_SINK_DYNAMIC_LATENCY
+#define MA_PA_SINK_SET_FORMATS                         PA_SINK_SET_FORMATS
+
+typedef pa_source_flags_t ma_pa_source_flags_t;
+#define MA_PA_SOURCE_NOFLAGS                           PA_SOURCE_NOFLAGS
+#define MA_PA_SOURCE_HW_VOLUME_CTRL                    PA_SOURCE_HW_VOLUME_CTRL
+#define MA_PA_SOURCE_LATENCY                           PA_SOURCE_LATENCY
+#define MA_PA_SOURCE_HARDWARE                          PA_SOURCE_HARDWARE
+#define MA_PA_SOURCE_NETWORK                           PA_SOURCE_NETWORK
+#define MA_PA_SOURCE_HW_MUTE_CTRL                      PA_SOURCE_HW_MUTE_CTRL
+#define MA_PA_SOURCE_DECIBEL_VOLUME                    PA_SOURCE_DECIBEL_VOLUME
+#define MA_PA_SOURCE_DYNAMIC_LATENCY                   PA_SOURCE_DYNAMIC_LATENCY
+#define MA_PA_SOURCE_FLAT_VOLUME                       PA_SOURCE_FLAT_VOLUME
+
+typedef pa_context_state_t ma_pa_context_state_t;
+#define MA_PA_CONTEXT_UNCONNECTED                      PA_CONTEXT_UNCONNECTED
+#define MA_PA_CONTEXT_CONNECTING                       PA_CONTEXT_CONNECTING
+#define MA_PA_CONTEXT_AUTHORIZING                      PA_CONTEXT_AUTHORIZING
+#define MA_PA_CONTEXT_SETTING_NAME                     PA_CONTEXT_SETTING_NAME
+#define MA_PA_CONTEXT_READY                            PA_CONTEXT_READY
+#define MA_PA_CONTEXT_FAILED                           PA_CONTEXT_FAILED
+#define MA_PA_CONTEXT_TERMINATED                       PA_CONTEXT_TERMINATED
+
+typedef pa_stream_state_t ma_pa_stream_state_t;
+#define MA_PA_STREAM_UNCONNECTED                       PA_STREAM_UNCONNECTED
+#define MA_PA_STREAM_CREATING                          PA_STREAM_CREATING
+#define MA_PA_STREAM_READY                             PA_STREAM_READY
+#define MA_PA_STREAM_FAILED                            PA_STREAM_FAILED
+#define MA_PA_STREAM_TERMINATED                        PA_STREAM_TERMINATED
+
+typedef pa_operation_state_t ma_pa_operation_state_t;
+#define MA_PA_OPERATION_RUNNING                        PA_OPERATION_RUNNING
+#define MA_PA_OPERATION_DONE                           PA_OPERATION_DONE
+#define MA_PA_OPERATION_CANCELLED                      PA_OPERATION_CANCELLED
+
+typedef pa_sink_state_t ma_pa_sink_state_t;
+#define MA_PA_SINK_INVALID_STATE                       PA_SINK_INVALID_STATE
+#define MA_PA_SINK_RUNNING                             PA_SINK_RUNNING
+#define MA_PA_SINK_IDLE                                PA_SINK_IDLE
+#define MA_PA_SINK_SUSPENDED                           PA_SINK_SUSPENDED
+
+typedef pa_source_state_t ma_pa_source_state_t;
+#define MA_PA_SOURCE_INVALID_STATE                     PA_SOURCE_INVALID_STATE
+#define MA_PA_SOURCE_RUNNING                           PA_SOURCE_RUNNING
+#define MA_PA_SOURCE_IDLE                              PA_SOURCE_IDLE
+#define MA_PA_SOURCE_SUSPENDED                         PA_SOURCE_SUSPENDED
+
+typedef pa_seek_mode_t ma_pa_seek_mode_t;
+#define MA_PA_SEEK_RELATIVE                            PA_SEEK_RELATIVE
+#define MA_PA_SEEK_ABSOLUTE                            PA_SEEK_ABSOLUTE
+#define MA_PA_SEEK_RELATIVE_ON_READ                    PA_SEEK_RELATIVE_ON_READ
+#define MA_PA_SEEK_RELATIVE_END                        PA_SEEK_RELATIVE_END
+
+typedef pa_channel_position_t ma_pa_channel_position_t;
+#define MA_PA_CHANNEL_POSITION_INVALID                 PA_CHANNEL_POSITION_INVALID
+#define MA_PA_CHANNEL_POSITION_MONO                    PA_CHANNEL_POSITION_MONO
+#define MA_PA_CHANNEL_POSITION_FRONT_LEFT              PA_CHANNEL_POSITION_FRONT_LEFT
+#define MA_PA_CHANNEL_POSITION_FRONT_RIGHT             PA_CHANNEL_POSITION_FRONT_RIGHT
+#define MA_PA_CHANNEL_POSITION_FRONT_CENTER            PA_CHANNEL_POSITION_FRONT_CENTER
+#define MA_PA_CHANNEL_POSITION_REAR_CENTER             PA_CHANNEL_POSITION_REAR_CENTER
+#define MA_PA_CHANNEL_POSITION_REAR_LEFT               PA_CHANNEL_POSITION_REAR_LEFT
+#define MA_PA_CHANNEL_POSITION_REAR_RIGHT              PA_CHANNEL_POSITION_REAR_RIGHT
+#define MA_PA_CHANNEL_POSITION_LFE                     PA_CHANNEL_POSITION_LFE
+#define MA_PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER    PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
+#define MA_PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER   PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
+#define MA_PA_CHANNEL_POSITION_SIDE_LEFT               PA_CHANNEL_POSITION_SIDE_LEFT
+#define MA_PA_CHANNEL_POSITION_SIDE_RIGHT              PA_CHANNEL_POSITION_SIDE_RIGHT
+#define MA_PA_CHANNEL_POSITION_AUX0                    PA_CHANNEL_POSITION_AUX0
+#define MA_PA_CHANNEL_POSITION_AUX1                    PA_CHANNEL_POSITION_AUX1
+#define MA_PA_CHANNEL_POSITION_AUX2                    PA_CHANNEL_POSITION_AUX2
+#define MA_PA_CHANNEL_POSITION_AUX3                    PA_CHANNEL_POSITION_AUX3
+#define MA_PA_CHANNEL_POSITION_AUX4                    PA_CHANNEL_POSITION_AUX4
+#define MA_PA_CHANNEL_POSITION_AUX5                    PA_CHANNEL_POSITION_AUX5
+#define MA_PA_CHANNEL_POSITION_AUX6                    PA_CHANNEL_POSITION_AUX6
+#define MA_PA_CHANNEL_POSITION_AUX7                    PA_CHANNEL_POSITION_AUX7
+#define MA_PA_CHANNEL_POSITION_AUX8                    PA_CHANNEL_POSITION_AUX8
+#define MA_PA_CHANNEL_POSITION_AUX9                    PA_CHANNEL_POSITION_AUX9
+#define MA_PA_CHANNEL_POSITION_AUX10                   PA_CHANNEL_POSITION_AUX10
+#define MA_PA_CHANNEL_POSITION_AUX11                   PA_CHANNEL_POSITION_AUX11
+#define MA_PA_CHANNEL_POSITION_AUX12                   PA_CHANNEL_POSITION_AUX12
+#define MA_PA_CHANNEL_POSITION_AUX13                   PA_CHANNEL_POSITION_AUX13
+#define MA_PA_CHANNEL_POSITION_AUX14                   PA_CHANNEL_POSITION_AUX14
+#define MA_PA_CHANNEL_POSITION_AUX15                   PA_CHANNEL_POSITION_AUX15
+#define MA_PA_CHANNEL_POSITION_AUX16                   PA_CHANNEL_POSITION_AUX16
+#define MA_PA_CHANNEL_POSITION_AUX17                   PA_CHANNEL_POSITION_AUX17
+#define MA_PA_CHANNEL_POSITION_AUX18                   PA_CHANNEL_POSITION_AUX18
+#define MA_PA_CHANNEL_POSITION_AUX19                   PA_CHANNEL_POSITION_AUX19
+#define MA_PA_CHANNEL_POSITION_AUX20                   PA_CHANNEL_POSITION_AUX20
+#define MA_PA_CHANNEL_POSITION_AUX21                   PA_CHANNEL_POSITION_AUX21
+#define MA_PA_CHANNEL_POSITION_AUX22                   PA_CHANNEL_POSITION_AUX22
+#define MA_PA_CHANNEL_POSITION_AUX23                   PA_CHANNEL_POSITION_AUX23
+#define MA_PA_CHANNEL_POSITION_AUX24                   PA_CHANNEL_POSITION_AUX24
+#define MA_PA_CHANNEL_POSITION_AUX25                   PA_CHANNEL_POSITION_AUX25
+#define MA_PA_CHANNEL_POSITION_AUX26                   PA_CHANNEL_POSITION_AUX26
+#define MA_PA_CHANNEL_POSITION_AUX27                   PA_CHANNEL_POSITION_AUX27
+#define MA_PA_CHANNEL_POSITION_AUX28                   PA_CHANNEL_POSITION_AUX28
+#define MA_PA_CHANNEL_POSITION_AUX29                   PA_CHANNEL_POSITION_AUX29
+#define MA_PA_CHANNEL_POSITION_AUX30                   PA_CHANNEL_POSITION_AUX30
+#define MA_PA_CHANNEL_POSITION_AUX31                   PA_CHANNEL_POSITION_AUX31
+#define MA_PA_CHANNEL_POSITION_TOP_CENTER              PA_CHANNEL_POSITION_TOP_CENTER
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_LEFT          PA_CHANNEL_POSITION_TOP_FRONT_LEFT
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_RIGHT         PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_CENTER        PA_CHANNEL_POSITION_TOP_FRONT_CENTER
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_LEFT           PA_CHANNEL_POSITION_TOP_REAR_LEFT
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_RIGHT          PA_CHANNEL_POSITION_TOP_REAR_RIGHT
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_CENTER         PA_CHANNEL_POSITION_TOP_REAR_CENTER
+#define MA_PA_CHANNEL_POSITION_LEFT                    PA_CHANNEL_POSITION_LEFT
+#define MA_PA_CHANNEL_POSITION_RIGHT                   PA_CHANNEL_POSITION_RIGHT
+#define MA_PA_CHANNEL_POSITION_CENTER                  PA_CHANNEL_POSITION_CENTER
+#define MA_PA_CHANNEL_POSITION_SUBWOOFER               PA_CHANNEL_POSITION_SUBWOOFER
+
+typedef pa_channel_map_def_t ma_pa_channel_map_def_t;
+#define MA_PA_CHANNEL_MAP_AIFF                         PA_CHANNEL_MAP_AIFF
+#define MA_PA_CHANNEL_MAP_ALSA                         PA_CHANNEL_MAP_ALSA
+#define MA_PA_CHANNEL_MAP_AUX                          PA_CHANNEL_MAP_AUX
+#define MA_PA_CHANNEL_MAP_WAVEEX                       PA_CHANNEL_MAP_WAVEEX
+#define MA_PA_CHANNEL_MAP_OSS                          PA_CHANNEL_MAP_OSS
+#define MA_PA_CHANNEL_MAP_DEFAULT                      PA_CHANNEL_MAP_DEFAULT
+
+typedef pa_sample_format_t ma_pa_sample_format_t;
+#define MA_PA_SAMPLE_INVALID                           PA_SAMPLE_INVALID
+#define MA_PA_SAMPLE_U8                                PA_SAMPLE_U8
+#define MA_PA_SAMPLE_ALAW                              PA_SAMPLE_ALAW
+#define MA_PA_SAMPLE_ULAW                              PA_SAMPLE_ULAW
+#define MA_PA_SAMPLE_S16LE                             PA_SAMPLE_S16LE
+#define MA_PA_SAMPLE_S16BE                             PA_SAMPLE_S16BE
+#define MA_PA_SAMPLE_FLOAT32LE                         PA_SAMPLE_FLOAT32LE
+#define MA_PA_SAMPLE_FLOAT32BE                         PA_SAMPLE_FLOAT32BE
+#define MA_PA_SAMPLE_S32LE                             PA_SAMPLE_S32LE
+#define MA_PA_SAMPLE_S32BE                             PA_SAMPLE_S32BE
+#define MA_PA_SAMPLE_S24LE                             PA_SAMPLE_S24LE
+#define MA_PA_SAMPLE_S24BE                             PA_SAMPLE_S24BE
+#define MA_PA_SAMPLE_S24_32LE                          PA_SAMPLE_S24_32LE
+#define MA_PA_SAMPLE_S24_32BE                          PA_SAMPLE_S24_32BE
+
+typedef pa_mainloop             ma_pa_mainloop;
+typedef pa_threaded_mainloop    ma_pa_threaded_mainloop;
+typedef pa_mainloop_api         ma_pa_mainloop_api;
+typedef pa_context              ma_pa_context;
+typedef pa_operation            ma_pa_operation;
+typedef pa_stream               ma_pa_stream;
+typedef pa_spawn_api            ma_pa_spawn_api;
+typedef pa_buffer_attr          ma_pa_buffer_attr;
+typedef pa_channel_map          ma_pa_channel_map;
+typedef pa_cvolume              ma_pa_cvolume;
+typedef pa_sample_spec          ma_pa_sample_spec;
+typedef pa_sink_info            ma_pa_sink_info;
+typedef pa_source_info          ma_pa_source_info;
+
+typedef pa_context_notify_cb_t  ma_pa_context_notify_cb_t;
+typedef pa_sink_info_cb_t       ma_pa_sink_info_cb_t;
+typedef pa_source_info_cb_t     ma_pa_source_info_cb_t;
+typedef pa_stream_success_cb_t  ma_pa_stream_success_cb_t;
+typedef pa_stream_request_cb_t  ma_pa_stream_request_cb_t;
+typedef pa_stream_notify_cb_t   ma_pa_stream_notify_cb_t;
+typedef pa_free_cb_t            ma_pa_free_cb_t;
+#else
+#define MA_PA_OK                                       0
+#define MA_PA_ERR_ACCESS                               1
+#define MA_PA_ERR_INVALID                              2
+#define MA_PA_ERR_NOENTITY                             5
+#define MA_PA_ERR_NOTSUPPORTED                         19
+
+#define MA_PA_CHANNELS_MAX                             32
+#define MA_PA_RATE_MAX                                 384000
+
+typedef int ma_pa_context_flags_t;
+#define MA_PA_CONTEXT_NOFLAGS                          0x00000000
+#define MA_PA_CONTEXT_NOAUTOSPAWN                      0x00000001
+#define MA_PA_CONTEXT_NOFAIL                           0x00000002
+
+typedef int ma_pa_stream_flags_t;
+#define MA_PA_STREAM_NOFLAGS                           0x00000000
+#define MA_PA_STREAM_START_CORKED                      0x00000001
+#define MA_PA_STREAM_INTERPOLATE_TIMING                0x00000002
+#define MA_PA_STREAM_NOT_MONOTONIC                     0x00000004
+#define MA_PA_STREAM_AUTO_TIMING_UPDATE                0x00000008
+#define MA_PA_STREAM_NO_REMAP_CHANNELS                 0x00000010
+#define MA_PA_STREAM_NO_REMIX_CHANNELS                 0x00000020
+#define MA_PA_STREAM_FIX_FORMAT                        0x00000040
+#define MA_PA_STREAM_FIX_RATE                          0x00000080
+#define MA_PA_STREAM_FIX_CHANNELS                      0x00000100
+#define MA_PA_STREAM_DONT_MOVE                         0x00000200
+#define MA_PA_STREAM_VARIABLE_RATE                     0x00000400
+#define MA_PA_STREAM_PEAK_DETECT                       0x00000800
+#define MA_PA_STREAM_START_MUTED                       0x00001000
+#define MA_PA_STREAM_ADJUST_LATENCY                    0x00002000
+#define MA_PA_STREAM_EARLY_REQUESTS                    0x00004000
+#define MA_PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND         0x00008000
+#define MA_PA_STREAM_START_UNMUTED                     0x00010000
+#define MA_PA_STREAM_FAIL_ON_SUSPEND                   0x00020000
+#define MA_PA_STREAM_RELATIVE_VOLUME                   0x00040000
+#define MA_PA_STREAM_PASSTHROUGH                       0x00080000
+
+typedef int ma_pa_sink_flags_t;
+#define MA_PA_SINK_NOFLAGS                             0x00000000
+#define MA_PA_SINK_HW_VOLUME_CTRL                      0x00000001
+#define MA_PA_SINK_LATENCY                             0x00000002
+#define MA_PA_SINK_HARDWARE                            0x00000004
+#define MA_PA_SINK_NETWORK                             0x00000008
+#define MA_PA_SINK_HW_MUTE_CTRL                        0x00000010
+#define MA_PA_SINK_DECIBEL_VOLUME                      0x00000020
+#define MA_PA_SINK_FLAT_VOLUME                         0x00000040
+#define MA_PA_SINK_DYNAMIC_LATENCY                     0x00000080
+#define MA_PA_SINK_SET_FORMATS                         0x00000100
+
+typedef int ma_pa_source_flags_t;
+#define MA_PA_SOURCE_NOFLAGS                           0x00000000
+#define MA_PA_SOURCE_HW_VOLUME_CTRL                    0x00000001
+#define MA_PA_SOURCE_LATENCY                           0x00000002
+#define MA_PA_SOURCE_HARDWARE                          0x00000004
+#define MA_PA_SOURCE_NETWORK                           0x00000008
+#define MA_PA_SOURCE_HW_MUTE_CTRL                      0x00000010
+#define MA_PA_SOURCE_DECIBEL_VOLUME                    0x00000020
+#define MA_PA_SOURCE_DYNAMIC_LATENCY                   0x00000040
+#define MA_PA_SOURCE_FLAT_VOLUME                       0x00000080
+
+typedef int ma_pa_context_state_t;
+#define MA_PA_CONTEXT_UNCONNECTED                      0
+#define MA_PA_CONTEXT_CONNECTING                       1
+#define MA_PA_CONTEXT_AUTHORIZING                      2
+#define MA_PA_CONTEXT_SETTING_NAME                     3
+#define MA_PA_CONTEXT_READY                            4
+#define MA_PA_CONTEXT_FAILED                           5
+#define MA_PA_CONTEXT_TERMINATED                       6
+
+typedef int ma_pa_stream_state_t;
+#define MA_PA_STREAM_UNCONNECTED                       0
+#define MA_PA_STREAM_CREATING                          1
+#define MA_PA_STREAM_READY                             2
+#define MA_PA_STREAM_FAILED                            3
+#define MA_PA_STREAM_TERMINATED                        4
+
+typedef int ma_pa_operation_state_t;
+#define MA_PA_OPERATION_RUNNING                        0
+#define MA_PA_OPERATION_DONE                           1
+#define MA_PA_OPERATION_CANCELLED                      2
+
+typedef int ma_pa_sink_state_t;
+#define MA_PA_SINK_INVALID_STATE                       -1
+#define MA_PA_SINK_RUNNING                             0
+#define MA_PA_SINK_IDLE                                1
+#define MA_PA_SINK_SUSPENDED                           2
+
+typedef int ma_pa_source_state_t;
+#define MA_PA_SOURCE_INVALID_STATE                     -1
+#define MA_PA_SOURCE_RUNNING                           0
+#define MA_PA_SOURCE_IDLE                              1
+#define MA_PA_SOURCE_SUSPENDED                         2
+
+typedef int ma_pa_seek_mode_t;
+#define MA_PA_SEEK_RELATIVE                            0
+#define MA_PA_SEEK_ABSOLUTE                            1
+#define MA_PA_SEEK_RELATIVE_ON_READ                    2
+#define MA_PA_SEEK_RELATIVE_END                        3
+
+typedef int ma_pa_channel_position_t;
+#define MA_PA_CHANNEL_POSITION_INVALID                 -1
+#define MA_PA_CHANNEL_POSITION_MONO                    0
+#define MA_PA_CHANNEL_POSITION_FRONT_LEFT              1
+#define MA_PA_CHANNEL_POSITION_FRONT_RIGHT             2
+#define MA_PA_CHANNEL_POSITION_FRONT_CENTER            3
+#define MA_PA_CHANNEL_POSITION_REAR_CENTER             4
+#define MA_PA_CHANNEL_POSITION_REAR_LEFT               5
+#define MA_PA_CHANNEL_POSITION_REAR_RIGHT              6
+#define MA_PA_CHANNEL_POSITION_LFE                     7
+#define MA_PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER    8
+#define MA_PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER   9
+#define MA_PA_CHANNEL_POSITION_SIDE_LEFT               10
+#define MA_PA_CHANNEL_POSITION_SIDE_RIGHT              11
+#define MA_PA_CHANNEL_POSITION_AUX0                    12
+#define MA_PA_CHANNEL_POSITION_AUX1                    13
+#define MA_PA_CHANNEL_POSITION_AUX2                    14
+#define MA_PA_CHANNEL_POSITION_AUX3                    15
+#define MA_PA_CHANNEL_POSITION_AUX4                    16
+#define MA_PA_CHANNEL_POSITION_AUX5                    17
+#define MA_PA_CHANNEL_POSITION_AUX6                    18
+#define MA_PA_CHANNEL_POSITION_AUX7                    19
+#define MA_PA_CHANNEL_POSITION_AUX8                    20
+#define MA_PA_CHANNEL_POSITION_AUX9                    21
+#define MA_PA_CHANNEL_POSITION_AUX10                   22
+#define MA_PA_CHANNEL_POSITION_AUX11                   23
+#define MA_PA_CHANNEL_POSITION_AUX12                   24
+#define MA_PA_CHANNEL_POSITION_AUX13                   25
+#define MA_PA_CHANNEL_POSITION_AUX14                   26
+#define MA_PA_CHANNEL_POSITION_AUX15                   27
+#define MA_PA_CHANNEL_POSITION_AUX16                   28
+#define MA_PA_CHANNEL_POSITION_AUX17                   29
+#define MA_PA_CHANNEL_POSITION_AUX18                   30
+#define MA_PA_CHANNEL_POSITION_AUX19                   31
+#define MA_PA_CHANNEL_POSITION_AUX20                   32
+#define MA_PA_CHANNEL_POSITION_AUX21                   33
+#define MA_PA_CHANNEL_POSITION_AUX22                   34
+#define MA_PA_CHANNEL_POSITION_AUX23                   35
+#define MA_PA_CHANNEL_POSITION_AUX24                   36
+#define MA_PA_CHANNEL_POSITION_AUX25                   37
+#define MA_PA_CHANNEL_POSITION_AUX26                   38
+#define MA_PA_CHANNEL_POSITION_AUX27                   39
+#define MA_PA_CHANNEL_POSITION_AUX28                   40
+#define MA_PA_CHANNEL_POSITION_AUX29                   41
+#define MA_PA_CHANNEL_POSITION_AUX30                   42
+#define MA_PA_CHANNEL_POSITION_AUX31                   43
+#define MA_PA_CHANNEL_POSITION_TOP_CENTER              44
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_LEFT          45
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_RIGHT         46
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_CENTER        47
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_LEFT           48
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_RIGHT          49
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_CENTER         50
+#define MA_PA_CHANNEL_POSITION_LEFT                    MA_PA_CHANNEL_POSITION_FRONT_LEFT
+#define MA_PA_CHANNEL_POSITION_RIGHT                   MA_PA_CHANNEL_POSITION_FRONT_RIGHT
+#define MA_PA_CHANNEL_POSITION_CENTER                  MA_PA_CHANNEL_POSITION_FRONT_CENTER
+#define MA_PA_CHANNEL_POSITION_SUBWOOFER               MA_PA_CHANNEL_POSITION_LFE
+
+typedef int ma_pa_channel_map_def_t;
+#define MA_PA_CHANNEL_MAP_AIFF                         0
+#define MA_PA_CHANNEL_MAP_ALSA                         1
+#define MA_PA_CHANNEL_MAP_AUX                          2
+#define MA_PA_CHANNEL_MAP_WAVEEX                       3
+#define MA_PA_CHANNEL_MAP_OSS                          4
+#define MA_PA_CHANNEL_MAP_DEFAULT                      MA_PA_CHANNEL_MAP_AIFF
+
+typedef int ma_pa_sample_format_t;
+#define MA_PA_SAMPLE_INVALID                           -1
+#define MA_PA_SAMPLE_U8                                0
+#define MA_PA_SAMPLE_ALAW                              1
+#define MA_PA_SAMPLE_ULAW                              2
+#define MA_PA_SAMPLE_S16LE                             3
+#define MA_PA_SAMPLE_S16BE                             4
+#define MA_PA_SAMPLE_FLOAT32LE                         5
+#define MA_PA_SAMPLE_FLOAT32BE                         6
+#define MA_PA_SAMPLE_S32LE                             7
+#define MA_PA_SAMPLE_S32BE                             8
+#define MA_PA_SAMPLE_S24LE                             9
+#define MA_PA_SAMPLE_S24BE                             10
+#define MA_PA_SAMPLE_S24_32LE                          11
+#define MA_PA_SAMPLE_S24_32BE                          12
+
+typedef struct ma_pa_mainloop           ma_pa_mainloop;
+typedef struct ma_pa_threaded_mainloop  ma_pa_threaded_mainloop;
+typedef struct ma_pa_mainloop_api       ma_pa_mainloop_api;
+typedef struct ma_pa_context            ma_pa_context;
+typedef struct ma_pa_operation          ma_pa_operation;
+typedef struct ma_pa_stream             ma_pa_stream;
+typedef struct ma_pa_spawn_api          ma_pa_spawn_api;
+
+typedef struct
+{
+    ma_uint32 maxlength;
+    ma_uint32 tlength;
+    ma_uint32 prebuf;
+    ma_uint32 minreq;
+    ma_uint32 fragsize;
+} ma_pa_buffer_attr;
+
+typedef struct
+{
+    ma_uint8 channels;
+    ma_pa_channel_position_t map[MA_PA_CHANNELS_MAX];
+} ma_pa_channel_map;
+
+typedef struct
+{
+    ma_uint8 channels;
+    ma_uint32 values[MA_PA_CHANNELS_MAX];
+} ma_pa_cvolume;
+
+typedef struct
+{
+    ma_pa_sample_format_t format;
+    ma_uint32 rate;
+    ma_uint8 channels;
+} ma_pa_sample_spec;
+
+typedef struct
+{
+    const char* name;
+    ma_uint32 index;
+    const char* description;
+    ma_pa_sample_spec sample_spec;
+    ma_pa_channel_map channel_map;
+    ma_uint32 owner_module;
+    ma_pa_cvolume volume;
+    int mute;
+    ma_uint32 monitor_source;
+    const char* monitor_source_name;
+    ma_uint64 latency;
+    const char* driver;
+    ma_pa_sink_flags_t flags;
+    void* proplist;
+    ma_uint64 configured_latency;
+    ma_uint32 base_volume;
+    ma_pa_sink_state_t state;
+    ma_uint32 n_volume_steps;
+    ma_uint32 card;
+    ma_uint32 n_ports;
+    void** ports;
+    void* active_port;
+    ma_uint8 n_formats;
+    void** formats;
+} ma_pa_sink_info;
+
+typedef struct
+{
+    const char *name;
+    ma_uint32 index;
+    const char *description;
+    ma_pa_sample_spec sample_spec;
+    ma_pa_channel_map channel_map;
+    ma_uint32 owner_module;
+    ma_pa_cvolume volume;
+    int mute;
+    ma_uint32 monitor_of_sink;
+    const char *monitor_of_sink_name;
+    ma_uint64 latency;
+    const char *driver;
+    ma_pa_source_flags_t flags;
+    void* proplist;
+    ma_uint64 configured_latency;
+    ma_uint32 base_volume;
+    ma_pa_source_state_t state;
+    ma_uint32 n_volume_steps;
+    ma_uint32 card;
+    ma_uint32 n_ports;
+    void** ports;
+    void* active_port;
+    ma_uint8 n_formats;
+    void** formats;
+} ma_pa_source_info;
+
+typedef void (* ma_pa_context_notify_cb_t)(ma_pa_context* c, void* userdata);
+typedef void (* ma_pa_sink_info_cb_t)     (ma_pa_context* c, const ma_pa_sink_info* i, int eol, void* userdata);
+typedef void (* ma_pa_source_info_cb_t)   (ma_pa_context* c, const ma_pa_source_info* i, int eol, void* userdata);
+typedef void (* ma_pa_stream_success_cb_t)(ma_pa_stream* s, int success, void* userdata);
+typedef void (* ma_pa_stream_request_cb_t)(ma_pa_stream* s, size_t nbytes, void* userdata);
+typedef void (* ma_pa_stream_notify_cb_t) (ma_pa_stream* s, void* userdata);
+typedef void (* ma_pa_free_cb_t)          (void* p);
+#endif
+
+
+typedef ma_pa_mainloop*          (* ma_pa_mainloop_new_proc)                   (void);
+typedef void                     (* ma_pa_mainloop_free_proc)                  (ma_pa_mainloop* m);
+typedef void                     (* ma_pa_mainloop_quit_proc)                  (ma_pa_mainloop* m, int retval);
+typedef ma_pa_mainloop_api*      (* ma_pa_mainloop_get_api_proc)               (ma_pa_mainloop* m);
+typedef int                      (* ma_pa_mainloop_iterate_proc)               (ma_pa_mainloop* m, int block, int* retval);
+typedef void                     (* ma_pa_mainloop_wakeup_proc)                (ma_pa_mainloop* m);
+typedef ma_pa_threaded_mainloop* (* ma_pa_threaded_mainloop_new_proc)          (void);
+typedef void                     (* ma_pa_threaded_mainloop_free_proc)         (ma_pa_threaded_mainloop* m);
+typedef int                      (* ma_pa_threaded_mainloop_start_proc)        (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_stop_proc)         (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_lock_proc)         (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_unlock_proc)       (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_wait_proc)         (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_signal_proc)       (ma_pa_threaded_mainloop* m, int wait_for_accept);
+typedef void                     (* ma_pa_threaded_mainloop_accept_proc)       (ma_pa_threaded_mainloop* m);
+typedef int                      (* ma_pa_threaded_mainloop_get_retval_proc)   (const ma_pa_threaded_mainloop* m);
+typedef ma_pa_mainloop_api*      (* ma_pa_threaded_mainloop_get_api_proc)      (ma_pa_threaded_mainloop* m);
+typedef int                      (* ma_pa_threaded_mainloop_in_thread_proc)    (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_set_name_proc)     (ma_pa_threaded_mainloop* m, const char* name);
+typedef ma_pa_context*           (* ma_pa_context_new_proc)                    (ma_pa_mainloop_api* mainloop, const char* name);
+typedef void                     (* ma_pa_context_unref_proc)                  (ma_pa_context* c);
+typedef int                      (* ma_pa_context_connect_proc)                (ma_pa_context* c, const char* server, ma_pa_context_flags_t flags, const ma_pa_spawn_api* api);
+typedef void                     (* ma_pa_context_disconnect_proc)             (ma_pa_context* c);
+typedef void                     (* ma_pa_context_set_state_callback_proc)     (ma_pa_context* c, ma_pa_context_notify_cb_t cb, void* userdata);
+typedef ma_pa_context_state_t    (* ma_pa_context_get_state_proc)              (const ma_pa_context* c);
+typedef ma_pa_operation*         (* ma_pa_context_get_sink_info_list_proc)     (ma_pa_context* c, ma_pa_sink_info_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_context_get_source_info_list_proc)   (ma_pa_context* c, ma_pa_source_info_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_context_get_sink_info_by_name_proc)  (ma_pa_context* c, const char* name, ma_pa_sink_info_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_context_get_source_info_by_name_proc)(ma_pa_context* c, const char* name, ma_pa_source_info_cb_t cb, void* userdata);
+typedef void                     (* ma_pa_operation_unref_proc)                (ma_pa_operation* o);
+typedef ma_pa_operation_state_t  (* ma_pa_operation_get_state_proc)            (const ma_pa_operation* o);
+typedef ma_pa_channel_map*       (* ma_pa_channel_map_init_extend_proc)        (ma_pa_channel_map* m, unsigned channels, ma_pa_channel_map_def_t def);
+typedef int                      (* ma_pa_channel_map_valid_proc)              (const ma_pa_channel_map* m);
+typedef int                      (* ma_pa_channel_map_compatible_proc)         (const ma_pa_channel_map* m, const ma_pa_sample_spec* ss);
+typedef ma_pa_stream*            (* ma_pa_stream_new_proc)                     (ma_pa_context* c, const char* name, const ma_pa_sample_spec* ss, const ma_pa_channel_map* map);
+typedef void                     (* ma_pa_stream_unref_proc)                   (ma_pa_stream* s);
+typedef int                      (* ma_pa_stream_connect_playback_proc)        (ma_pa_stream* s, const char* dev, const ma_pa_buffer_attr* attr, ma_pa_stream_flags_t flags, const ma_pa_cvolume* volume, ma_pa_stream* sync_stream);
+typedef int                      (* ma_pa_stream_connect_record_proc)          (ma_pa_stream* s, const char* dev, const ma_pa_buffer_attr* attr, ma_pa_stream_flags_t flags);
+typedef int                      (* ma_pa_stream_disconnect_proc)              (ma_pa_stream* s);
+typedef ma_pa_stream_state_t     (* ma_pa_stream_get_state_proc)               (const ma_pa_stream* s);
+typedef const ma_pa_sample_spec* (* ma_pa_stream_get_sample_spec_proc)         (ma_pa_stream* s);
+typedef const ma_pa_channel_map* (* ma_pa_stream_get_channel_map_proc)         (ma_pa_stream* s);
+typedef const ma_pa_buffer_attr* (* ma_pa_stream_get_buffer_attr_proc)         (ma_pa_stream* s);
+typedef ma_pa_operation*         (* ma_pa_stream_set_buffer_attr_proc)         (ma_pa_stream* s, const ma_pa_buffer_attr* attr, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef const char*              (* ma_pa_stream_get_device_name_proc)         (const ma_pa_stream* s);
+typedef void                     (* ma_pa_stream_set_write_callback_proc)      (ma_pa_stream* s, ma_pa_stream_request_cb_t cb, void* userdata);
+typedef void                     (* ma_pa_stream_set_read_callback_proc)       (ma_pa_stream* s, ma_pa_stream_request_cb_t cb, void* userdata);
+typedef void                     (* ma_pa_stream_set_suspended_callback_proc)  (ma_pa_stream* s, ma_pa_stream_notify_cb_t cb, void* userdata);
+typedef void                     (* ma_pa_stream_set_moved_callback_proc)      (ma_pa_stream* s, ma_pa_stream_notify_cb_t cb, void* userdata);
+typedef int                      (* ma_pa_stream_is_suspended_proc)            (const ma_pa_stream* s);
+typedef ma_pa_operation*         (* ma_pa_stream_flush_proc)                   (ma_pa_stream* s, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_stream_drain_proc)                   (ma_pa_stream* s, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef int                      (* ma_pa_stream_is_corked_proc)               (const ma_pa_stream* s);
+typedef ma_pa_operation*         (* ma_pa_stream_cork_proc)                    (ma_pa_stream* s, int b, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_stream_trigger_proc)                 (ma_pa_stream* s, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef int                      (* ma_pa_stream_begin_write_proc)             (ma_pa_stream* s, void** data, size_t* nbytes);
+typedef int                      (* ma_pa_stream_write_proc)                   (ma_pa_stream* s, const void* data, size_t nbytes, ma_pa_free_cb_t free_cb, int64_t offset, ma_pa_seek_mode_t seek);
+typedef int                      (* ma_pa_stream_peek_proc)                    (ma_pa_stream* s, const void** data, size_t* nbytes);
+typedef int                      (* ma_pa_stream_drop_proc)                    (ma_pa_stream* s);
+typedef size_t                   (* ma_pa_stream_writable_size_proc)           (const ma_pa_stream* s);
+typedef size_t                   (* ma_pa_stream_readable_size_proc)           (const ma_pa_stream* s);
+
+typedef struct
+{
+    ma_uint32 count;
+    ma_uint32 capacity;
+    ma_device_info* pInfo;
+} ma_pulse_device_enum_data;
+
+static ma_result ma_result_from_pulse(int result)
+{
+    if (result < 0) {
+        return MA_ERROR;
+    }
+
+    switch (result) {
+        case MA_PA_OK:           return MA_SUCCESS;
+        case MA_PA_ERR_ACCESS:   return MA_ACCESS_DENIED;
+        case MA_PA_ERR_INVALID:  return MA_INVALID_ARGS;
+        case MA_PA_ERR_NOENTITY: return MA_NO_DEVICE;
+        default:                 return MA_ERROR;
+    }
+}
+
+#if 0
+static ma_pa_sample_format_t ma_format_to_pulse(ma_format format)
+{
+    if (ma_is_little_endian()) {
+        switch (format) {
+            case ma_format_s16: return MA_PA_SAMPLE_S16LE;
+            case ma_format_s24: return MA_PA_SAMPLE_S24LE;
+            case ma_format_s32: return MA_PA_SAMPLE_S32LE;
+            case ma_format_f32: return MA_PA_SAMPLE_FLOAT32LE;
+            default: break;
+        }
+    } else {
+        switch (format) {
+            case ma_format_s16: return MA_PA_SAMPLE_S16BE;
+            case ma_format_s24: return MA_PA_SAMPLE_S24BE;
+            case ma_format_s32: return MA_PA_SAMPLE_S32BE;
+            case ma_format_f32: return MA_PA_SAMPLE_FLOAT32BE;
+            default: break;
+        }
+    }
+
+    /* Endian agnostic. */
+    switch (format) {
+        case ma_format_u8: return MA_PA_SAMPLE_U8;
+        default: return MA_PA_SAMPLE_INVALID;
+    }
+}
+#endif
+
+static ma_format ma_format_from_pulse(ma_pa_sample_format_t format)
+{
+    if (ma_is_little_endian()) {
+        switch (format) {
+            case MA_PA_SAMPLE_S16LE:     return ma_format_s16;
+            case MA_PA_SAMPLE_S24LE:     return ma_format_s24;
+            case MA_PA_SAMPLE_S32LE:     return ma_format_s32;
+            case MA_PA_SAMPLE_FLOAT32LE: return ma_format_f32;
+            default: break;
+        }
+    } else {
+        switch (format) {
+            case MA_PA_SAMPLE_S16BE:     return ma_format_s16;
+            case MA_PA_SAMPLE_S24BE:     return ma_format_s24;
+            case MA_PA_SAMPLE_S32BE:     return ma_format_s32;
+            case MA_PA_SAMPLE_FLOAT32BE: return ma_format_f32;
+            default: break;
+        }
+    }
+
+    /* Endian agnostic. */
+    switch (format) {
+        case MA_PA_SAMPLE_U8: return ma_format_u8;
+        default: return ma_format_unknown;
+    }
+}
+
+static ma_channel ma_channel_position_from_pulse(ma_pa_channel_position_t position)
+{
+    switch (position)
+    {
+        case MA_PA_CHANNEL_POSITION_INVALID:               return MA_CHANNEL_NONE;
+        case MA_PA_CHANNEL_POSITION_MONO:                  return MA_CHANNEL_MONO;
+        case MA_PA_CHANNEL_POSITION_FRONT_LEFT:            return MA_CHANNEL_FRONT_LEFT;
+        case MA_PA_CHANNEL_POSITION_FRONT_RIGHT:           return MA_CHANNEL_FRONT_RIGHT;
+        case MA_PA_CHANNEL_POSITION_FRONT_CENTER:          return MA_CHANNEL_FRONT_CENTER;
+        case MA_PA_CHANNEL_POSITION_REAR_CENTER:           return MA_CHANNEL_BACK_CENTER;
+        case MA_PA_CHANNEL_POSITION_REAR_LEFT:             return MA_CHANNEL_BACK_LEFT;
+        case MA_PA_CHANNEL_POSITION_REAR_RIGHT:            return MA_CHANNEL_BACK_RIGHT;
+        case MA_PA_CHANNEL_POSITION_LFE:                   return MA_CHANNEL_LFE;
+        case MA_PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER:  return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case MA_PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER: return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case MA_PA_CHANNEL_POSITION_SIDE_LEFT:             return MA_CHANNEL_SIDE_LEFT;
+        case MA_PA_CHANNEL_POSITION_SIDE_RIGHT:            return MA_CHANNEL_SIDE_RIGHT;
+        case MA_PA_CHANNEL_POSITION_AUX0:                  return MA_CHANNEL_AUX_0;
+        case MA_PA_CHANNEL_POSITION_AUX1:                  return MA_CHANNEL_AUX_1;
+        case MA_PA_CHANNEL_POSITION_AUX2:                  return MA_CHANNEL_AUX_2;
+        case MA_PA_CHANNEL_POSITION_AUX3:                  return MA_CHANNEL_AUX_3;
+        case MA_PA_CHANNEL_POSITION_AUX4:                  return MA_CHANNEL_AUX_4;
+        case MA_PA_CHANNEL_POSITION_AUX5:                  return MA_CHANNEL_AUX_5;
+        case MA_PA_CHANNEL_POSITION_AUX6:                  return MA_CHANNEL_AUX_6;
+        case MA_PA_CHANNEL_POSITION_AUX7:                  return MA_CHANNEL_AUX_7;
+        case MA_PA_CHANNEL_POSITION_AUX8:                  return MA_CHANNEL_AUX_8;
+        case MA_PA_CHANNEL_POSITION_AUX9:                  return MA_CHANNEL_AUX_9;
+        case MA_PA_CHANNEL_POSITION_AUX10:                 return MA_CHANNEL_AUX_10;
+        case MA_PA_CHANNEL_POSITION_AUX11:                 return MA_CHANNEL_AUX_11;
+        case MA_PA_CHANNEL_POSITION_AUX12:                 return MA_CHANNEL_AUX_12;
+        case MA_PA_CHANNEL_POSITION_AUX13:                 return MA_CHANNEL_AUX_13;
+        case MA_PA_CHANNEL_POSITION_AUX14:                 return MA_CHANNEL_AUX_14;
+        case MA_PA_CHANNEL_POSITION_AUX15:                 return MA_CHANNEL_AUX_15;
+        case MA_PA_CHANNEL_POSITION_AUX16:                 return MA_CHANNEL_AUX_16;
+        case MA_PA_CHANNEL_POSITION_AUX17:                 return MA_CHANNEL_AUX_17;
+        case MA_PA_CHANNEL_POSITION_AUX18:                 return MA_CHANNEL_AUX_18;
+        case MA_PA_CHANNEL_POSITION_AUX19:                 return MA_CHANNEL_AUX_19;
+        case MA_PA_CHANNEL_POSITION_AUX20:                 return MA_CHANNEL_AUX_20;
+        case MA_PA_CHANNEL_POSITION_AUX21:                 return MA_CHANNEL_AUX_21;
+        case MA_PA_CHANNEL_POSITION_AUX22:                 return MA_CHANNEL_AUX_22;
+        case MA_PA_CHANNEL_POSITION_AUX23:                 return MA_CHANNEL_AUX_23;
+        case MA_PA_CHANNEL_POSITION_AUX24:                 return MA_CHANNEL_AUX_24;
+        case MA_PA_CHANNEL_POSITION_AUX25:                 return MA_CHANNEL_AUX_25;
+        case MA_PA_CHANNEL_POSITION_AUX26:                 return MA_CHANNEL_AUX_26;
+        case MA_PA_CHANNEL_POSITION_AUX27:                 return MA_CHANNEL_AUX_27;
+        case MA_PA_CHANNEL_POSITION_AUX28:                 return MA_CHANNEL_AUX_28;
+        case MA_PA_CHANNEL_POSITION_AUX29:                 return MA_CHANNEL_AUX_29;
+        case MA_PA_CHANNEL_POSITION_AUX30:                 return MA_CHANNEL_AUX_30;
+        case MA_PA_CHANNEL_POSITION_AUX31:                 return MA_CHANNEL_AUX_31;
+        case MA_PA_CHANNEL_POSITION_TOP_CENTER:            return MA_CHANNEL_TOP_CENTER;
+        case MA_PA_CHANNEL_POSITION_TOP_FRONT_LEFT:        return MA_CHANNEL_TOP_FRONT_LEFT;
+        case MA_PA_CHANNEL_POSITION_TOP_FRONT_RIGHT:       return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case MA_PA_CHANNEL_POSITION_TOP_FRONT_CENTER:      return MA_CHANNEL_TOP_FRONT_CENTER;
+        case MA_PA_CHANNEL_POSITION_TOP_REAR_LEFT:         return MA_CHANNEL_TOP_BACK_LEFT;
+        case MA_PA_CHANNEL_POSITION_TOP_REAR_RIGHT:        return MA_CHANNEL_TOP_BACK_RIGHT;
+        case MA_PA_CHANNEL_POSITION_TOP_REAR_CENTER:       return MA_CHANNEL_TOP_BACK_CENTER;
+        default: return MA_CHANNEL_NONE;
+    }
+}
+
+#if 0
+static ma_pa_channel_position_t ma_channel_position_to_pulse(ma_channel position)
+{
+    switch (position)
+    {
+        case MA_CHANNEL_NONE:               return MA_PA_CHANNEL_POSITION_INVALID;
+        case MA_CHANNEL_FRONT_LEFT:         return MA_PA_CHANNEL_POSITION_FRONT_LEFT;
+        case MA_CHANNEL_FRONT_RIGHT:        return MA_PA_CHANNEL_POSITION_FRONT_RIGHT;
+        case MA_CHANNEL_FRONT_CENTER:       return MA_PA_CHANNEL_POSITION_FRONT_CENTER;
+        case MA_CHANNEL_LFE:                return MA_PA_CHANNEL_POSITION_LFE;
+        case MA_CHANNEL_BACK_LEFT:          return MA_PA_CHANNEL_POSITION_REAR_LEFT;
+        case MA_CHANNEL_BACK_RIGHT:         return MA_PA_CHANNEL_POSITION_REAR_RIGHT;
+        case MA_CHANNEL_FRONT_LEFT_CENTER:  return MA_PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER;
+        case MA_CHANNEL_FRONT_RIGHT_CENTER: return MA_PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER;
+        case MA_CHANNEL_BACK_CENTER:        return MA_PA_CHANNEL_POSITION_REAR_CENTER;
+        case MA_CHANNEL_SIDE_LEFT:          return MA_PA_CHANNEL_POSITION_SIDE_LEFT;
+        case MA_CHANNEL_SIDE_RIGHT:         return MA_PA_CHANNEL_POSITION_SIDE_RIGHT;
+        case MA_CHANNEL_TOP_CENTER:         return MA_PA_CHANNEL_POSITION_TOP_CENTER;
+        case MA_CHANNEL_TOP_FRONT_LEFT:     return MA_PA_CHANNEL_POSITION_TOP_FRONT_LEFT;
+        case MA_CHANNEL_TOP_FRONT_CENTER:   return MA_PA_CHANNEL_POSITION_TOP_FRONT_CENTER;
+        case MA_CHANNEL_TOP_FRONT_RIGHT:    return MA_PA_CHANNEL_POSITION_TOP_FRONT_RIGHT;
+        case MA_CHANNEL_TOP_BACK_LEFT:      return MA_PA_CHANNEL_POSITION_TOP_REAR_LEFT;
+        case MA_CHANNEL_TOP_BACK_CENTER:    return MA_PA_CHANNEL_POSITION_TOP_REAR_CENTER;
+        case MA_CHANNEL_TOP_BACK_RIGHT:     return MA_PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
+        case MA_CHANNEL_19:                 return MA_PA_CHANNEL_POSITION_AUX18;
+        case MA_CHANNEL_20:                 return MA_PA_CHANNEL_POSITION_AUX19;
+        case MA_CHANNEL_21:                 return MA_PA_CHANNEL_POSITION_AUX20;
+        case MA_CHANNEL_22:                 return MA_PA_CHANNEL_POSITION_AUX21;
+        case MA_CHANNEL_23:                 return MA_PA_CHANNEL_POSITION_AUX22;
+        case MA_CHANNEL_24:                 return MA_PA_CHANNEL_POSITION_AUX23;
+        case MA_CHANNEL_25:                 return MA_PA_CHANNEL_POSITION_AUX24;
+        case MA_CHANNEL_26:                 return MA_PA_CHANNEL_POSITION_AUX25;
+        case MA_CHANNEL_27:                 return MA_PA_CHANNEL_POSITION_AUX26;
+        case MA_CHANNEL_28:                 return MA_PA_CHANNEL_POSITION_AUX27;
+        case MA_CHANNEL_29:                 return MA_PA_CHANNEL_POSITION_AUX28;
+        case MA_CHANNEL_30:                 return MA_PA_CHANNEL_POSITION_AUX29;
+        case MA_CHANNEL_31:                 return MA_PA_CHANNEL_POSITION_AUX30;
+        case MA_CHANNEL_32:                 return MA_PA_CHANNEL_POSITION_AUX31;
+        default: return (ma_pa_channel_position_t)position;
+    }
+}
+#endif
+
+static ma_result ma_wait_for_operation__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_pa_operation* pOP)
+{
+    int resultPA;
+    ma_pa_operation_state_t state;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pOP != NULL);
+
+    for (;;) {
+        state = ((ma_pa_operation_get_state_proc)pContext->pulse.pa_operation_get_state)(pOP);
+        if (state != MA_PA_OPERATION_RUNNING) {
+            break;  /* Done. */
+        }
+
+        resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 1, NULL);
+        if (resultPA < 0) {
+            return ma_result_from_pulse(resultPA);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_wait_for_operation_and_unref__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_pa_operation* pOP)
+{
+    ma_result result;
+
+    if (pOP == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_wait_for_operation__pulse(pContext, pMainLoop, pOP);
+    ((ma_pa_operation_unref_proc)pContext->pulse.pa_operation_unref)(pOP);
+
+    return result;
+}
+
+static ma_result ma_wait_for_pa_context_to_connect__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_ptr pPulseContext)
+{
+    int resultPA;
+    ma_pa_context_state_t state;
+
+    for (;;) {
+        state = ((ma_pa_context_get_state_proc)pContext->pulse.pa_context_get_state)((ma_pa_context*)pPulseContext);
+        if (state == MA_PA_CONTEXT_READY) {
+            break;  /* Done. */
+        }
+
+        if (state == MA_PA_CONTEXT_FAILED || state == MA_PA_CONTEXT_TERMINATED) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] An error occurred while connecting the PulseAudio context.");
+            return MA_ERROR;
+        }
+
+        resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 1, NULL);
+        if (resultPA < 0) {
+            return ma_result_from_pulse(resultPA);
+        }
+    }
+
+    /* Should never get here. */
+    return MA_SUCCESS;
+}
+
+static ma_result ma_wait_for_pa_stream_to_connect__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_ptr pStream)
+{
+    int resultPA;
+    ma_pa_stream_state_t state;
+
+    for (;;) {
+        state = ((ma_pa_stream_get_state_proc)pContext->pulse.pa_stream_get_state)((ma_pa_stream*)pStream);
+        if (state == MA_PA_STREAM_READY) {
+            break;  /* Done. */
+        }
+
+        if (state == MA_PA_STREAM_FAILED || state == MA_PA_STREAM_TERMINATED) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] An error occurred while connecting the PulseAudio stream.");
+            return MA_ERROR;
+        }
+
+        resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 1, NULL);
+        if (resultPA < 0) {
+            return ma_result_from_pulse(resultPA);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_init_pa_mainloop_and_pa_context__pulse(ma_context* pContext, const char* pApplicationName, const char* pServerName, ma_bool32 tryAutoSpawn, ma_ptr* ppMainLoop, ma_ptr* ppPulseContext)
+{
+    ma_result result;
+    ma_ptr pMainLoop;
+    ma_ptr pPulseContext;
+
+    MA_ASSERT(ppMainLoop     != NULL);
+    MA_ASSERT(ppPulseContext != NULL);
+
+    /* The PulseAudio context maps well to miniaudio's notion of a context. The pa_context object will be initialized as part of the ma_context. */
+    pMainLoop = ((ma_pa_mainloop_new_proc)pContext->pulse.pa_mainloop_new)();
+    if (pMainLoop == NULL) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to create mainloop.");
+        return MA_FAILED_TO_INIT_BACKEND;
+    }
+
+    pPulseContext = ((ma_pa_context_new_proc)pContext->pulse.pa_context_new)(((ma_pa_mainloop_get_api_proc)pContext->pulse.pa_mainloop_get_api)((ma_pa_mainloop*)pMainLoop), pApplicationName);
+    if (pPulseContext == NULL) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to create PulseAudio context.");
+        ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)(pMainLoop));
+        return MA_FAILED_TO_INIT_BACKEND;
+    }
+
+    /* Now we need to connect to the context. Everything is asynchronous so we need to wait for it to connect before returning. */
+    result = ma_result_from_pulse(((ma_pa_context_connect_proc)pContext->pulse.pa_context_connect)((ma_pa_context*)pPulseContext, pServerName, (tryAutoSpawn) ? MA_PA_CONTEXT_NOFLAGS : MA_PA_CONTEXT_NOAUTOSPAWN, NULL));
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to connect PulseAudio context.");
+        ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)(pMainLoop));
+        return result;
+    }
+
+    /* Since ma_context_init() runs synchronously we need to wait for the PulseAudio context to connect before we return. */
+    result = ma_wait_for_pa_context_to_connect__pulse(pContext, pMainLoop, pPulseContext);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] Waiting for connection failed.");
+        ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)(pMainLoop));
+        return result;
+    }
+
+    *ppMainLoop     = pMainLoop;
+    *ppPulseContext = pPulseContext;
+
+    return MA_SUCCESS;
+}
+
+
+static void ma_device_sink_info_callback(ma_pa_context* pPulseContext, const ma_pa_sink_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_pa_sink_info* pInfoOut;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    /*
+    There has been a report that indicates that pInfo can be null which results
+    in a null pointer dereference below. We'll check for this for safety.
+    */
+    if (pInfo == NULL) {
+        return;
+    }
+
+    pInfoOut = (ma_pa_sink_info*)pUserData;
+    MA_ASSERT(pInfoOut != NULL);
+
+    *pInfoOut = *pInfo;
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static void ma_device_source_info_callback(ma_pa_context* pPulseContext, const ma_pa_source_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_pa_source_info* pInfoOut;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    /*
+    There has been a report that indicates that pInfo can be null which results
+    in a null pointer dereference below. We'll check for this for safety.
+    */
+    if (pInfo == NULL) {
+        return;
+    }
+
+    pInfoOut = (ma_pa_source_info*)pUserData;
+    MA_ASSERT(pInfoOut != NULL);
+
+    *pInfoOut = *pInfo;
+
+    (void)pPulseContext; /* Unused. */
+}
+
+#if 0
+static void ma_device_sink_name_callback(ma_pa_context* pPulseContext, const ma_pa_sink_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_device* pDevice;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), pInfo->description, (size_t)-1);
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static void ma_device_source_name_callback(ma_pa_context* pPulseContext, const ma_pa_source_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_device* pDevice;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), pInfo->description, (size_t)-1);
+
+    (void)pPulseContext; /* Unused. */
+}
+#endif
+
+static ma_result ma_context_get_sink_info__pulse(ma_context* pContext, const char* pDeviceName, ma_pa_sink_info* pSinkInfo)
+{
+    ma_pa_operation* pOP;
+
+    pOP = ((ma_pa_context_get_sink_info_by_name_proc)pContext->pulse.pa_context_get_sink_info_by_name)((ma_pa_context*)pContext->pulse.pPulseContext, pDeviceName, ma_device_sink_info_callback, pSinkInfo);
+    if (pOP == NULL) {
+        return MA_ERROR;
+    }
+
+    return ma_wait_for_operation_and_unref__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+}
+
+static ma_result ma_context_get_source_info__pulse(ma_context* pContext, const char* pDeviceName, ma_pa_source_info* pSourceInfo)
+{
+    ma_pa_operation* pOP;
+
+    pOP = ((ma_pa_context_get_source_info_by_name_proc)pContext->pulse.pa_context_get_source_info_by_name)((ma_pa_context*)pContext->pulse.pPulseContext, pDeviceName, ma_device_source_info_callback, pSourceInfo);
+    if (pOP == NULL) {
+        return MA_ERROR;
+    }
+
+    return ma_wait_for_operation_and_unref__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+}
+
+static ma_result ma_context_get_default_device_index__pulse(ma_context* pContext, ma_device_type deviceType, ma_uint32* pIndex)
+{
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pIndex   != NULL);
+
+    if (pIndex != NULL) {
+        *pIndex = (ma_uint32)-1;
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        ma_pa_sink_info sinkInfo;
+        result = ma_context_get_sink_info__pulse(pContext, NULL, &sinkInfo);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        if (pIndex != NULL) {
+            *pIndex = sinkInfo.index;
+        }
+    }
+
+    if (deviceType == ma_device_type_capture) {
+        ma_pa_source_info sourceInfo;
+        result = ma_context_get_source_info__pulse(pContext, NULL, &sourceInfo);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        if (pIndex != NULL) {
+            *pIndex = sourceInfo.index;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    ma_context* pContext;
+    ma_enum_devices_callback_proc callback;
+    void* pUserData;
+    ma_bool32 isTerminated;
+    ma_uint32 defaultDeviceIndexPlayback;
+    ma_uint32 defaultDeviceIndexCapture;
+} ma_context_enumerate_devices_callback_data__pulse;
+
+static void ma_context_enumerate_devices_sink_callback__pulse(ma_pa_context* pPulseContext, const ma_pa_sink_info* pSinkInfo, int endOfList, void* pUserData)
+{
+    ma_context_enumerate_devices_callback_data__pulse* pData = (ma_context_enumerate_devices_callback_data__pulse*)pUserData;
+    ma_device_info deviceInfo;
+
+    MA_ASSERT(pData != NULL);
+
+    if (endOfList || pData->isTerminated) {
+        return;
+    }
+
+    MA_ZERO_OBJECT(&deviceInfo);
+
+    /* The name from PulseAudio is the ID for miniaudio. */
+    if (pSinkInfo->name != NULL) {
+        ma_strncpy_s(deviceInfo.id.pulse, sizeof(deviceInfo.id.pulse), pSinkInfo->name, (size_t)-1);
+    }
+
+    /* The description from PulseAudio is the name for miniaudio. */
+    if (pSinkInfo->description != NULL) {
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), pSinkInfo->description, (size_t)-1);
+    }
+
+    if (pSinkInfo->index == pData->defaultDeviceIndexPlayback) {
+        deviceInfo.isDefault = MA_TRUE;
+    }
+
+    pData->isTerminated = !pData->callback(pData->pContext, ma_device_type_playback, &deviceInfo, pData->pUserData);
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static void ma_context_enumerate_devices_source_callback__pulse(ma_pa_context* pPulseContext, const ma_pa_source_info* pSourceInfo, int endOfList, void* pUserData)
+{
+    ma_context_enumerate_devices_callback_data__pulse* pData = (ma_context_enumerate_devices_callback_data__pulse*)pUserData;
+    ma_device_info deviceInfo;
+
+    MA_ASSERT(pData != NULL);
+
+    if (endOfList || pData->isTerminated) {
+        return;
+    }
+
+    MA_ZERO_OBJECT(&deviceInfo);
+
+    /* The name from PulseAudio is the ID for miniaudio. */
+    if (pSourceInfo->name != NULL) {
+        ma_strncpy_s(deviceInfo.id.pulse, sizeof(deviceInfo.id.pulse), pSourceInfo->name, (size_t)-1);
+    }
+
+    /* The description from PulseAudio is the name for miniaudio. */
+    if (pSourceInfo->description != NULL) {
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), pSourceInfo->description, (size_t)-1);
+    }
+
+    if (pSourceInfo->index == pData->defaultDeviceIndexCapture) {
+        deviceInfo.isDefault = MA_TRUE;
+    }
+
+    pData->isTerminated = !pData->callback(pData->pContext, ma_device_type_capture, &deviceInfo, pData->pUserData);
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static ma_result ma_context_enumerate_devices__pulse(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_result result = MA_SUCCESS;
+    ma_context_enumerate_devices_callback_data__pulse callbackData;
+    ma_pa_operation* pOP = NULL;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    callbackData.pContext = pContext;
+    callbackData.callback = callback;
+    callbackData.pUserData = pUserData;
+    callbackData.isTerminated = MA_FALSE;
+    callbackData.defaultDeviceIndexPlayback = (ma_uint32)-1;
+    callbackData.defaultDeviceIndexCapture  = (ma_uint32)-1;
+
+    /* We need to get the index of the default devices. */
+    ma_context_get_default_device_index__pulse(pContext, ma_device_type_playback, &callbackData.defaultDeviceIndexPlayback);
+    ma_context_get_default_device_index__pulse(pContext, ma_device_type_capture,  &callbackData.defaultDeviceIndexCapture);
+
+    /* Playback. */
+    if (!callbackData.isTerminated) {
+        pOP = ((ma_pa_context_get_sink_info_list_proc)pContext->pulse.pa_context_get_sink_info_list)((ma_pa_context*)(pContext->pulse.pPulseContext), ma_context_enumerate_devices_sink_callback__pulse, &callbackData);
+        if (pOP == NULL) {
+            result = MA_ERROR;
+            goto done;
+        }
+
+        result = ma_wait_for_operation__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+        ((ma_pa_operation_unref_proc)pContext->pulse.pa_operation_unref)(pOP);
+
+        if (result != MA_SUCCESS) {
+            goto done;
+        }
+    }
+
+
+    /* Capture. */
+    if (!callbackData.isTerminated) {
+        pOP = ((ma_pa_context_get_source_info_list_proc)pContext->pulse.pa_context_get_source_info_list)((ma_pa_context*)(pContext->pulse.pPulseContext), ma_context_enumerate_devices_source_callback__pulse, &callbackData);
+        if (pOP == NULL) {
+            result = MA_ERROR;
+            goto done;
+        }
+
+        result = ma_wait_for_operation__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+        ((ma_pa_operation_unref_proc)pContext->pulse.pa_operation_unref)(pOP);
+
+        if (result != MA_SUCCESS) {
+            goto done;
+        }
+    }
+
+done:
+    return result;
+}
+
+
+typedef struct
+{
+    ma_device_info* pDeviceInfo;
+    ma_uint32 defaultDeviceIndex;
+    ma_bool32 foundDevice;
+} ma_context_get_device_info_callback_data__pulse;
+
+static void ma_context_get_device_info_sink_callback__pulse(ma_pa_context* pPulseContext, const ma_pa_sink_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_context_get_device_info_callback_data__pulse* pData = (ma_context_get_device_info_callback_data__pulse*)pUserData;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    MA_ASSERT(pData != NULL);
+    pData->foundDevice = MA_TRUE;
+
+    if (pInfo->name != NULL) {
+        ma_strncpy_s(pData->pDeviceInfo->id.pulse, sizeof(pData->pDeviceInfo->id.pulse), pInfo->name, (size_t)-1);
+    }
+
+    if (pInfo->description != NULL) {
+        ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), pInfo->description, (size_t)-1);
+    }
+
+    /*
+    We're just reporting a single data format here. I think technically PulseAudio might support
+    all formats, but I don't trust that PulseAudio will do *anything* right, so I'm just going to
+    report the "native" device format.
+    */
+    pData->pDeviceInfo->nativeDataFormats[0].format     = ma_format_from_pulse(pInfo->sample_spec.format);
+    pData->pDeviceInfo->nativeDataFormats[0].channels   = pInfo->sample_spec.channels;
+    pData->pDeviceInfo->nativeDataFormats[0].sampleRate = pInfo->sample_spec.rate;
+    pData->pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pData->pDeviceInfo->nativeDataFormatCount = 1;
+
+    if (pData->defaultDeviceIndex == pInfo->index) {
+        pData->pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static void ma_context_get_device_info_source_callback__pulse(ma_pa_context* pPulseContext, const ma_pa_source_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_context_get_device_info_callback_data__pulse* pData = (ma_context_get_device_info_callback_data__pulse*)pUserData;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    MA_ASSERT(pData != NULL);
+    pData->foundDevice = MA_TRUE;
+
+    if (pInfo->name != NULL) {
+        ma_strncpy_s(pData->pDeviceInfo->id.pulse, sizeof(pData->pDeviceInfo->id.pulse), pInfo->name, (size_t)-1);
+    }
+
+    if (pInfo->description != NULL) {
+        ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), pInfo->description, (size_t)-1);
+    }
+
+    /*
+    We're just reporting a single data format here. I think technically PulseAudio might support
+    all formats, but I don't trust that PulseAudio will do *anything* right, so I'm just going to
+    report the "native" device format.
+    */
+    pData->pDeviceInfo->nativeDataFormats[0].format     = ma_format_from_pulse(pInfo->sample_spec.format);
+    pData->pDeviceInfo->nativeDataFormats[0].channels   = pInfo->sample_spec.channels;
+    pData->pDeviceInfo->nativeDataFormats[0].sampleRate = pInfo->sample_spec.rate;
+    pData->pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pData->pDeviceInfo->nativeDataFormatCount = 1;
+
+    if (pData->defaultDeviceIndex == pInfo->index) {
+        pData->pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static ma_result ma_context_get_device_info__pulse(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_result result = MA_SUCCESS;
+    ma_context_get_device_info_callback_data__pulse callbackData;
+    ma_pa_operation* pOP = NULL;
+    const char* pDeviceName = NULL;
+
+    MA_ASSERT(pContext != NULL);
+
+    callbackData.pDeviceInfo = pDeviceInfo;
+    callbackData.foundDevice = MA_FALSE;
+
+    if (pDeviceID != NULL) {
+        pDeviceName = pDeviceID->pulse;
+    } else {
+        pDeviceName = NULL;
+    }
+
+    result = ma_context_get_default_device_index__pulse(pContext, deviceType, &callbackData.defaultDeviceIndex);
+
+    if (deviceType == ma_device_type_playback) {
+        pOP = ((ma_pa_context_get_sink_info_by_name_proc)pContext->pulse.pa_context_get_sink_info_by_name)((ma_pa_context*)(pContext->pulse.pPulseContext), pDeviceName, ma_context_get_device_info_sink_callback__pulse, &callbackData);
+    } else {
+        pOP = ((ma_pa_context_get_source_info_by_name_proc)pContext->pulse.pa_context_get_source_info_by_name)((ma_pa_context*)(pContext->pulse.pPulseContext), pDeviceName, ma_context_get_device_info_source_callback__pulse, &callbackData);
+    }
+
+    if (pOP != NULL) {
+        ma_wait_for_operation_and_unref__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+    } else {
+        result = MA_ERROR;
+        goto done;
+    }
+
+    if (!callbackData.foundDevice) {
+        result = MA_NO_DEVICE;
+        goto done;
+    }
+
+done:
+    return result;
+}
+
+static ma_result ma_device_uninit__pulse(ma_device* pDevice)
+{
+    ma_context* pContext;
+
+    MA_ASSERT(pDevice != NULL);
+
+    pContext = pDevice->pContext;
+    MA_ASSERT(pContext != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((ma_pa_stream_disconnect_proc)pContext->pulse.pa_stream_disconnect)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+        ((ma_pa_stream_unref_proc)pContext->pulse.pa_stream_unref)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ((ma_pa_stream_disconnect_proc)pContext->pulse.pa_stream_disconnect)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+        ((ma_pa_stream_unref_proc)pContext->pulse.pa_stream_unref)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+    }
+
+    if (pDevice->type == ma_device_type_duplex) {
+        ma_duplex_rb_uninit(&pDevice->duplexRB);
+    }
+
+    ((ma_pa_context_disconnect_proc)pContext->pulse.pa_context_disconnect)((ma_pa_context*)pDevice->pulse.pPulseContext);
+    ((ma_pa_context_unref_proc)pContext->pulse.pa_context_unref)((ma_pa_context*)pDevice->pulse.pPulseContext);
+    ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)pDevice->pulse.pMainLoop);
+
+    return MA_SUCCESS;
+}
+
+static ma_pa_buffer_attr ma_device__pa_buffer_attr_new(ma_uint32 periodSizeInFrames, ma_uint32 periods, const ma_pa_sample_spec* ss)
+{
+    ma_pa_buffer_attr attr;
+    attr.maxlength = periodSizeInFrames * periods * ma_get_bytes_per_frame(ma_format_from_pulse(ss->format), ss->channels);
+    attr.tlength   = attr.maxlength / periods;
+    attr.prebuf    = (ma_uint32)-1;
+    attr.minreq    = (ma_uint32)-1;
+    attr.fragsize  = attr.maxlength / periods;
+
+    return attr;
+}
+
+static ma_pa_stream* ma_device__pa_stream_new__pulse(ma_device* pDevice, const char* pStreamName, const ma_pa_sample_spec* ss, const ma_pa_channel_map* cmap)
+{
+    static ma_atomic_uint32 g_StreamCounter = { 0 };
+    char actualStreamName[256];
+
+    if (pStreamName != NULL) {
+        ma_strncpy_s(actualStreamName, sizeof(actualStreamName), pStreamName, (size_t)-1);
+    } else {
+        const char* pBaseName = "miniaudio:";
+        size_t baseNameLen = strlen(pBaseName);
+        ma_strcpy_s(actualStreamName, sizeof(actualStreamName), pBaseName);
+        ma_itoa_s((int)ma_atomic_uint32_get(&g_StreamCounter), actualStreamName + baseNameLen, sizeof(actualStreamName)-baseNameLen, 10);
+    }
+    ma_atomic_uint32_fetch_add(&g_StreamCounter, 1);
+
+    return ((ma_pa_stream_new_proc)pDevice->pContext->pulse.pa_stream_new)((ma_pa_context*)pDevice->pulse.pPulseContext, actualStreamName, ss, cmap);
+}
+
+
+static void ma_device_on_read__pulse(ma_pa_stream* pStream, size_t byteCount, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    ma_uint32 bpf;
+    ma_uint32 deviceState;
+    ma_uint64 frameCount;
+    ma_uint64 framesProcessed;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    Don't do anything if the device isn't initialized yet. Yes, this can happen because PulseAudio
+    can fire this callback before the stream has even started. Ridiculous.
+    */
+    deviceState = ma_device_get_state(pDevice);
+    if (deviceState != ma_device_state_starting && deviceState != ma_device_state_started) {
+        return;
+    }
+
+    bpf = ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    MA_ASSERT(bpf > 0);
+
+    frameCount = byteCount / bpf;
+    framesProcessed = 0;
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started && framesProcessed < frameCount) {
+        const void* pMappedPCMFrames;
+        size_t bytesMapped;
+        ma_uint64 framesMapped;
+
+        int pulseResult = ((ma_pa_stream_peek_proc)pDevice->pContext->pulse.pa_stream_peek)(pStream, &pMappedPCMFrames, &bytesMapped);
+        if (pulseResult < 0) {
+            break; /* Failed to map. Abort. */
+        }
+
+        framesMapped = bytesMapped / bpf;
+        if (framesMapped > 0) {
+            if (pMappedPCMFrames != NULL) {
+                ma_device_handle_backend_data_callback(pDevice, NULL, pMappedPCMFrames, framesMapped);
+            } else {
+                /* It's a hole. */
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[PulseAudio] ma_device_on_read__pulse: Hole.\n");
+            }
+
+            pulseResult = ((ma_pa_stream_drop_proc)pDevice->pContext->pulse.pa_stream_drop)(pStream);
+            if (pulseResult < 0) {
+                break;  /* Failed to drop the buffer. */
+            }
+
+            framesProcessed += framesMapped;
+
+        } else {
+            /* Nothing was mapped. Just abort. */
+            break;
+        }
+    }
+}
+
+static ma_result ma_device_write_to_stream__pulse(ma_device* pDevice, ma_pa_stream* pStream, ma_uint64* pFramesProcessed)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 framesProcessed = 0;
+    size_t bytesMapped;
+    ma_uint32 bpf;
+    ma_uint32 deviceState;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pStream != NULL);
+
+    bpf = ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    MA_ASSERT(bpf > 0);
+
+    deviceState = ma_device_get_state(pDevice);
+
+    bytesMapped = ((ma_pa_stream_writable_size_proc)pDevice->pContext->pulse.pa_stream_writable_size)(pStream);
+    if (bytesMapped != (size_t)-1) {
+        if (bytesMapped > 0) {
+            ma_uint64 framesMapped;
+            void* pMappedPCMFrames;
+            int pulseResult = ((ma_pa_stream_begin_write_proc)pDevice->pContext->pulse.pa_stream_begin_write)(pStream, &pMappedPCMFrames, &bytesMapped);
+            if (pulseResult < 0) {
+                result = ma_result_from_pulse(pulseResult);
+                goto done;
+            }
+
+            framesMapped = bytesMapped / bpf;
+
+            if (deviceState == ma_device_state_started || deviceState == ma_device_state_starting) {  /* Check for starting state just in case this is being used to do the initial fill. */
+                ma_device_handle_backend_data_callback(pDevice, pMappedPCMFrames, NULL, framesMapped);
+            } else {
+                /* Device is not started. Write silence. */
+                ma_silence_pcm_frames(pMappedPCMFrames, framesMapped, pDevice->playback.format, pDevice->playback.channels);
+            }
+
+            pulseResult = ((ma_pa_stream_write_proc)pDevice->pContext->pulse.pa_stream_write)(pStream, pMappedPCMFrames, bytesMapped, NULL, 0, MA_PA_SEEK_RELATIVE);
+            if (pulseResult < 0) {
+                result = ma_result_from_pulse(pulseResult);
+                goto done;  /* Failed to write data to stream. */
+            }
+
+            framesProcessed += framesMapped;
+        } else {
+            result = MA_SUCCESS;  /* No data available for writing. */
+            goto done;
+        }
+    } else {
+        result = MA_ERROR;  /* Failed to retrieve the writable size. Abort. */
+        goto done;
+    }
+
+done:
+    if (pFramesProcessed != NULL) {
+        *pFramesProcessed = framesProcessed;
+    }
+
+    return result;
+}
+
+static void ma_device_on_write__pulse(ma_pa_stream* pStream, size_t byteCount, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    ma_uint32 bpf;
+    ma_uint64 frameCount;
+    ma_uint64 framesProcessed;
+    ma_uint32 deviceState;
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    Don't do anything if the device isn't initialized yet. Yes, this can happen because PulseAudio
+    can fire this callback before the stream has even started. Ridiculous.
+    */
+    deviceState = ma_device_get_state(pDevice);
+    if (deviceState != ma_device_state_starting && deviceState != ma_device_state_started) {
+        return;
+    }
+
+    bpf = ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    MA_ASSERT(bpf > 0);
+
+    frameCount = byteCount / bpf;
+    framesProcessed = 0;
+
+    while (framesProcessed < frameCount) {
+        ma_uint64 framesProcessedThisIteration;
+
+        /* Don't keep trying to process frames if the device isn't started. */
+        deviceState = ma_device_get_state(pDevice);
+        if (deviceState != ma_device_state_starting && deviceState != ma_device_state_started) {
+            break;
+        }
+
+        result = ma_device_write_to_stream__pulse(pDevice, pStream, &framesProcessedThisIteration);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        framesProcessed += framesProcessedThisIteration;
+    }
+}
+
+static void ma_device_on_suspended__pulse(ma_pa_stream* pStream, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    int suspended;
+
+    (void)pStream;
+
+    suspended = ((ma_pa_stream_is_suspended_proc)pDevice->pContext->pulse.pa_stream_is_suspended)(pStream);
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[Pulse] Device suspended state changed. pa_stream_is_suspended() returned %d.\n", suspended);
+
+    if (suspended < 0) {
+        return;
+    }
+
+    if (suspended == 1) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[Pulse] Device suspended state changed. Suspended.\n");
+        ma_device__on_notification_stopped(pDevice);
+    } else {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[Pulse] Device suspended state changed. Resumed.\n");
+        ma_device__on_notification_started(pDevice);
+    }
+}
+
+static void ma_device_on_rerouted__pulse(ma_pa_stream* pStream, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+
+    (void)pStream;
+    (void)pUserData;
+
+    ma_device__on_notification_rerouted(pDevice);
+}
+
+static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__pulse(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    /*
+    There have been reports from users where buffers of < ~20ms result glitches when running through
+    PipeWire. To work around this we're going to have to use a different default buffer size.
+    */
+    const ma_uint32 defaultPeriodSizeInMilliseconds_LowLatency   = 25;
+    const ma_uint32 defaultPeriodSizeInMilliseconds_Conservative = MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE;
+
+    MA_ASSERT(nativeSampleRate != 0);
+
+    if (pDescriptor->periodSizeInFrames == 0) {
+        if (pDescriptor->periodSizeInMilliseconds == 0) {
+            if (performanceProfile == ma_performance_profile_low_latency) {
+                return ma_calculate_buffer_size_in_frames_from_milliseconds(defaultPeriodSizeInMilliseconds_LowLatency, nativeSampleRate);
+            } else {
+                return ma_calculate_buffer_size_in_frames_from_milliseconds(defaultPeriodSizeInMilliseconds_Conservative, nativeSampleRate);
+            }
+        } else {
+            return ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptor->periodSizeInMilliseconds, nativeSampleRate);
+        }
+    } else {
+        return pDescriptor->periodSizeInFrames;
+    }
+}
+
+static ma_result ma_device_init__pulse(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    /*
+    Notes for PulseAudio:
+
+      - When both the period size in frames and milliseconds are 0, we default to miniaudio's
+        default buffer sizes rather than leaving it up to PulseAudio because I don't trust
+        PulseAudio to give us any kind of reasonable latency by default.
+
+      - Do not ever, *ever* forget to use MA_PA_STREAM_ADJUST_LATENCY. If you don't specify this
+        flag, capture mode will just not work properly until you open another PulseAudio app.
+    */
+
+    ma_result result = MA_SUCCESS;
+    int error = 0;
+    const char* devPlayback = NULL;
+    const char* devCapture  = NULL;
+    ma_format format = ma_format_unknown;
+    ma_uint32 channels = 0;
+    ma_uint32 sampleRate = 0;
+    ma_pa_sink_info sinkInfo;
+    ma_pa_source_info sourceInfo;
+    ma_pa_sample_spec ss;
+    ma_pa_channel_map cmap;
+    ma_pa_buffer_attr attr;
+    const ma_pa_sample_spec* pActualSS   = NULL;
+    const ma_pa_buffer_attr* pActualAttr = NULL;
+    const ma_pa_channel_map* pActualChannelMap = NULL;
+    ma_uint32 iChannel;
+    int streamFlags;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ZERO_OBJECT(&pDevice->pulse);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* No exclusive mode with the PulseAudio backend. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pConfig->playback.shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pConfig->capture.shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        if (pDescriptorPlayback->pDeviceID != NULL) {
+            devPlayback = pDescriptorPlayback->pDeviceID->pulse;
+        }
+
+        format     = pDescriptorPlayback->format;
+        channels   = pDescriptorPlayback->channels;
+        sampleRate = pDescriptorPlayback->sampleRate;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) {
+        if (pDescriptorCapture->pDeviceID != NULL) {
+            devCapture = pDescriptorCapture->pDeviceID->pulse;
+        }
+
+        format     = pDescriptorCapture->format;
+        channels   = pDescriptorCapture->channels;
+        sampleRate = pDescriptorCapture->sampleRate;
+    }
+
+
+
+    result = ma_init_pa_mainloop_and_pa_context__pulse(pDevice->pContext, pDevice->pContext->pulse.pApplicationName, pDevice->pContext->pulse.pServerName, MA_FALSE, &pDevice->pulse.pMainLoop, &pDevice->pulse.pPulseContext);
+    if (result != MA_SUCCESS) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to initialize PA mainloop and context for device.\n");
+        return result;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        result = ma_context_get_source_info__pulse(pDevice->pContext, devCapture, &sourceInfo);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to retrieve source info for capture device.");
+            goto on_error0;
+        }
+
+        ss   = sourceInfo.sample_spec;
+        cmap = sourceInfo.channel_map;
+
+        /* Use the requested channel count if we have one. */
+        if (pDescriptorCapture->channels != 0) {
+            ss.channels = pDescriptorCapture->channels;
+        }
+
+        /* PulseAudio has a maximum channel count of 32. We'll get a crash if this is exceeded. */
+        if (ss.channels > 32) {
+            ss.channels = 32;
+        }
+
+        /* Use a default channel map. */
+        ((ma_pa_channel_map_init_extend_proc)pDevice->pContext->pulse.pa_channel_map_init_extend)(&cmap, ss.channels, (ma_pa_channel_map_def_t)pConfig->pulse.channelMap);
+
+        /* Use the requested sample rate if one was specified. */
+        if (pDescriptorCapture->sampleRate != 0) {
+            ss.rate = pDescriptorCapture->sampleRate;
+        }
+        streamFlags = MA_PA_STREAM_START_CORKED | MA_PA_STREAM_ADJUST_LATENCY;
+
+        if (ma_format_from_pulse(ss.format) == ma_format_unknown) {
+            if (ma_is_little_endian()) {
+                ss.format = MA_PA_SAMPLE_FLOAT32LE;
+            } else {
+                ss.format = MA_PA_SAMPLE_FLOAT32BE;
+            }
+            streamFlags |= MA_PA_STREAM_FIX_FORMAT;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.format not supported by miniaudio. Defaulting to PA_SAMPLE_FLOAT32.\n");
+        }
+        if (ss.rate == 0) {
+            ss.rate = MA_DEFAULT_SAMPLE_RATE;
+            streamFlags |= MA_PA_STREAM_FIX_RATE;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.rate = 0. Defaulting to %d.\n", ss.rate);
+        }
+        if (ss.channels == 0) {
+            ss.channels = MA_DEFAULT_CHANNELS;
+            streamFlags |= MA_PA_STREAM_FIX_CHANNELS;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.channels = 0. Defaulting to %d.\n", ss.channels);
+        }
+
+        /* We now have enough information to calculate our actual period size in frames. */
+        pDescriptorCapture->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__pulse(pDescriptorCapture, ss.rate, pConfig->performanceProfile);
+
+        attr = ma_device__pa_buffer_attr_new(pDescriptorCapture->periodSizeInFrames, pDescriptorCapture->periodCount, &ss);
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Capture attr: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d, fragsize=%d; periodSizeInFrames=%d\n", attr.maxlength, attr.tlength, attr.prebuf, attr.minreq, attr.fragsize, pDescriptorCapture->periodSizeInFrames);
+
+        pDevice->pulse.pStreamCapture = ma_device__pa_stream_new__pulse(pDevice, pConfig->pulse.pStreamNameCapture, &ss, &cmap);
+        if (pDevice->pulse.pStreamCapture == NULL) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to create PulseAudio capture stream.\n");
+            result = MA_ERROR;
+            goto on_error0;
+        }
+
+
+        /* The callback needs to be set before connecting the stream. */
+        ((ma_pa_stream_set_read_callback_proc)pDevice->pContext->pulse.pa_stream_set_read_callback)((ma_pa_stream*)pDevice->pulse.pStreamCapture, ma_device_on_read__pulse, pDevice);
+
+        /* State callback for checking when the device has been corked. */
+        ((ma_pa_stream_set_suspended_callback_proc)pDevice->pContext->pulse.pa_stream_set_suspended_callback)((ma_pa_stream*)pDevice->pulse.pStreamCapture, ma_device_on_suspended__pulse, pDevice);
+
+        /* Rerouting notification. */
+        ((ma_pa_stream_set_moved_callback_proc)pDevice->pContext->pulse.pa_stream_set_moved_callback)((ma_pa_stream*)pDevice->pulse.pStreamCapture, ma_device_on_rerouted__pulse, pDevice);
+
+
+        /* Connect after we've got all of our internal state set up. */
+        if (devCapture != NULL) {
+            streamFlags |= MA_PA_STREAM_DONT_MOVE;
+        }
+
+        error = ((ma_pa_stream_connect_record_proc)pDevice->pContext->pulse.pa_stream_connect_record)((ma_pa_stream*)pDevice->pulse.pStreamCapture, devCapture, &attr, (ma_pa_stream_flags_t)streamFlags);
+        if (error != MA_PA_OK) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to connect PulseAudio capture stream.");
+            result = ma_result_from_pulse(error);
+            goto on_error1;
+        }
+
+        result = ma_wait_for_pa_stream_to_connect__pulse(pDevice->pContext, pDevice->pulse.pMainLoop, (ma_pa_stream*)pDevice->pulse.pStreamCapture);
+        if (result != MA_SUCCESS) {
+            goto on_error2;
+        }
+
+
+        /* Internal format. */
+        pActualSS = ((ma_pa_stream_get_sample_spec_proc)pDevice->pContext->pulse.pa_stream_get_sample_spec)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+        if (pActualSS != NULL) {
+            ss = *pActualSS;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Capture sample spec: format=%s, channels=%d, rate=%d\n", ma_get_format_name(ma_format_from_pulse(ss.format)), ss.channels, ss.rate);
+        } else {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Failed to retrieve capture sample spec.\n");
+        }
+
+        pDescriptorCapture->format     = ma_format_from_pulse(ss.format);
+        pDescriptorCapture->channels   = ss.channels;
+        pDescriptorCapture->sampleRate = ss.rate;
+
+        if (pDescriptorCapture->format == ma_format_unknown || pDescriptorCapture->channels == 0 || pDescriptorCapture->sampleRate == 0) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Capture sample spec is invalid. Device unusable by miniaudio. format=%s, channels=%d, sampleRate=%d.\n", ma_get_format_name(pDescriptorCapture->format), pDescriptorCapture->channels, pDescriptorCapture->sampleRate);
+            result = MA_ERROR;
+            goto on_error4;
+        }
+
+
+        /* Internal channel map. */
+        pActualChannelMap = ((ma_pa_stream_get_channel_map_proc)pDevice->pContext->pulse.pa_stream_get_channel_map)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+        if (pActualChannelMap == NULL) {
+            pActualChannelMap = &cmap;  /* Fallback just in case. */
+        }
+
+        /*
+        Bug in PipeWire. There have been reports that PipeWire is returning AUX channels when reporting
+        the channel map. To somewhat workaround this, I'm hacking in a hard coded channel map for mono
+        and stereo. In this case it should be safe to assume mono = MONO and stereo = LEFT/RIGHT. For
+        all other channel counts we need to just put up with whatever PipeWire reports and hope it gets
+        fixed sooner than later. I might remove this hack later.
+        */
+        if (pDescriptorCapture->channels > 2) {
+            for (iChannel = 0; iChannel < pDescriptorCapture->channels; iChannel += 1) {
+                pDescriptorCapture->channelMap[iChannel] = ma_channel_position_from_pulse(pActualChannelMap->map[iChannel]);
+            }
+        } else {
+            /* Hack for mono and stereo. */
+            if (pDescriptorCapture->channels == 1) {
+                pDescriptorCapture->channelMap[0] = MA_CHANNEL_MONO;
+            } else if (pDescriptorCapture->channels == 2) {
+                pDescriptorCapture->channelMap[0] = MA_CHANNEL_FRONT_LEFT;
+                pDescriptorCapture->channelMap[1] = MA_CHANNEL_FRONT_RIGHT;
+            } else {
+                MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+            }
+        }
+
+
+        /* Buffer. */
+        pActualAttr = ((ma_pa_stream_get_buffer_attr_proc)pDevice->pContext->pulse.pa_stream_get_buffer_attr)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+        if (pActualAttr != NULL) {
+            attr = *pActualAttr;
+        }
+
+        if (attr.fragsize > 0) {
+            pDescriptorCapture->periodCount = ma_max(attr.maxlength / attr.fragsize, 1);
+        } else {
+            pDescriptorCapture->periodCount = 1;
+        }
+
+        pDescriptorCapture->periodSizeInFrames = attr.maxlength / ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels) / pDescriptorCapture->periodCount;
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Capture actual attr: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d, fragsize=%d; periodSizeInFrames=%d\n", attr.maxlength, attr.tlength, attr.prebuf, attr.minreq, attr.fragsize, pDescriptorCapture->periodSizeInFrames);
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        result = ma_context_get_sink_info__pulse(pDevice->pContext, devPlayback, &sinkInfo);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to retrieve sink info for playback device.\n");
+            goto on_error2;
+        }
+
+        ss   = sinkInfo.sample_spec;
+        cmap = sinkInfo.channel_map;
+
+        /* Use the requested channel count if we have one. */
+        if (pDescriptorPlayback->channels != 0) {
+            ss.channels = pDescriptorPlayback->channels;
+        }
+
+        /* PulseAudio has a maximum channel count of 32. We'll get a crash if this is exceeded. */
+        if (ss.channels > 32) {
+            ss.channels = 32;
+        }
+
+        /* Use a default channel map. */
+        ((ma_pa_channel_map_init_extend_proc)pDevice->pContext->pulse.pa_channel_map_init_extend)(&cmap, ss.channels, (ma_pa_channel_map_def_t)pConfig->pulse.channelMap);
+
+
+        /* Use the requested sample rate if one was specified. */
+        if (pDescriptorPlayback->sampleRate != 0) {
+            ss.rate = pDescriptorPlayback->sampleRate;
+        }
+
+        streamFlags = MA_PA_STREAM_START_CORKED | MA_PA_STREAM_ADJUST_LATENCY;
+        if (ma_format_from_pulse(ss.format) == ma_format_unknown) {
+            if (ma_is_little_endian()) {
+                ss.format = MA_PA_SAMPLE_FLOAT32LE;
+            } else {
+                ss.format = MA_PA_SAMPLE_FLOAT32BE;
+            }
+            streamFlags |= MA_PA_STREAM_FIX_FORMAT;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.format not supported by miniaudio. Defaulting to PA_SAMPLE_FLOAT32.\n");
+        }
+        if (ss.rate == 0) {
+            ss.rate = MA_DEFAULT_SAMPLE_RATE;
+            streamFlags |= MA_PA_STREAM_FIX_RATE;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.rate = 0. Defaulting to %d.\n", ss.rate);
+        }
+        if (ss.channels == 0) {
+            ss.channels = MA_DEFAULT_CHANNELS;
+            streamFlags |= MA_PA_STREAM_FIX_CHANNELS;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.channels = 0. Defaulting to %d.\n", ss.channels);
+        }
+
+        /* We now have enough information to calculate the actual buffer size in frames. */
+        pDescriptorPlayback->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__pulse(pDescriptorPlayback, ss.rate, pConfig->performanceProfile);
+
+        attr = ma_device__pa_buffer_attr_new(pDescriptorPlayback->periodSizeInFrames, pDescriptorPlayback->periodCount, &ss);
+
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Playback attr: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d, fragsize=%d; periodSizeInFrames=%d\n", attr.maxlength, attr.tlength, attr.prebuf, attr.minreq, attr.fragsize, pDescriptorPlayback->periodSizeInFrames);
+
+        pDevice->pulse.pStreamPlayback = ma_device__pa_stream_new__pulse(pDevice, pConfig->pulse.pStreamNamePlayback, &ss, &cmap);
+        if (pDevice->pulse.pStreamPlayback == NULL) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to create PulseAudio playback stream.\n");
+            result = MA_ERROR;
+            goto on_error2;
+        }
+
+
+        /*
+        Note that this callback will be fired as soon as the stream is connected, even though it's started as corked. The callback needs to handle a
+        device state of ma_device_state_uninitialized.
+        */
+        ((ma_pa_stream_set_write_callback_proc)pDevice->pContext->pulse.pa_stream_set_write_callback)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, ma_device_on_write__pulse, pDevice);
+
+        /* State callback for checking when the device has been corked. */
+        ((ma_pa_stream_set_suspended_callback_proc)pDevice->pContext->pulse.pa_stream_set_suspended_callback)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, ma_device_on_suspended__pulse, pDevice);
+
+        /* Rerouting notification. */
+        ((ma_pa_stream_set_moved_callback_proc)pDevice->pContext->pulse.pa_stream_set_moved_callback)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, ma_device_on_rerouted__pulse, pDevice);
+
+
+        /* Connect after we've got all of our internal state set up. */
+        if (devPlayback != NULL) {
+            streamFlags |= MA_PA_STREAM_DONT_MOVE;
+        }
+
+        error = ((ma_pa_stream_connect_playback_proc)pDevice->pContext->pulse.pa_stream_connect_playback)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, devPlayback, &attr, (ma_pa_stream_flags_t)streamFlags, NULL, NULL);
+        if (error != MA_PA_OK) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to connect PulseAudio playback stream.");
+            result = ma_result_from_pulse(error);
+            goto on_error3;
+        }
+
+        result = ma_wait_for_pa_stream_to_connect__pulse(pDevice->pContext, pDevice->pulse.pMainLoop, (ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+        if (result != MA_SUCCESS) {
+            goto on_error3;
+        }
+
+
+        /* Internal format. */
+        pActualSS = ((ma_pa_stream_get_sample_spec_proc)pDevice->pContext->pulse.pa_stream_get_sample_spec)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+        if (pActualSS != NULL) {
+            ss = *pActualSS;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Playback sample spec: format=%s, channels=%d, rate=%d\n", ma_get_format_name(ma_format_from_pulse(ss.format)), ss.channels, ss.rate);
+        } else {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Failed to retrieve playback sample spec.\n");
+        }
+
+        pDescriptorPlayback->format     = ma_format_from_pulse(ss.format);
+        pDescriptorPlayback->channels   = ss.channels;
+        pDescriptorPlayback->sampleRate = ss.rate;
+
+        if (pDescriptorPlayback->format == ma_format_unknown || pDescriptorPlayback->channels == 0 || pDescriptorPlayback->sampleRate == 0) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Playback sample spec is invalid. Device unusable by miniaudio. format=%s, channels=%d, sampleRate=%d.\n", ma_get_format_name(pDescriptorPlayback->format), pDescriptorPlayback->channels, pDescriptorPlayback->sampleRate);
+            result = MA_ERROR;
+            goto on_error4;
+        }
+
+
+        /* Internal channel map. */
+        pActualChannelMap = ((ma_pa_stream_get_channel_map_proc)pDevice->pContext->pulse.pa_stream_get_channel_map)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+        if (pActualChannelMap == NULL) {
+            pActualChannelMap = &cmap;  /* Fallback just in case. */
+        }
+
+        /*
+        Bug in PipeWire. There have been reports that PipeWire is returning AUX channels when reporting
+        the channel map. To somewhat workaround this, I'm hacking in a hard coded channel map for mono
+        and stereo. In this case it should be safe to assume mono = MONO and stereo = LEFT/RIGHT. For
+        all other channel counts we need to just put up with whatever PipeWire reports and hope it gets
+        fixed sooner than later. I might remove this hack later.
+        */
+        if (pDescriptorPlayback->channels > 2) {
+            for (iChannel = 0; iChannel < pDescriptorPlayback->channels; iChannel += 1) {
+                pDescriptorPlayback->channelMap[iChannel] = ma_channel_position_from_pulse(pActualChannelMap->map[iChannel]);
+            }
+        } else {
+            /* Hack for mono and stereo. */
+            if (pDescriptorPlayback->channels == 1) {
+                pDescriptorPlayback->channelMap[0] = MA_CHANNEL_MONO;
+            } else if (pDescriptorPlayback->channels == 2) {
+                pDescriptorPlayback->channelMap[0] = MA_CHANNEL_FRONT_LEFT;
+                pDescriptorPlayback->channelMap[1] = MA_CHANNEL_FRONT_RIGHT;
+            } else {
+                MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+            }
+        }
+
+
+        /* Buffer. */
+        pActualAttr = ((ma_pa_stream_get_buffer_attr_proc)pDevice->pContext->pulse.pa_stream_get_buffer_attr)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+        if (pActualAttr != NULL) {
+            attr = *pActualAttr;
+        }
+
+        if (attr.tlength > 0) {
+            pDescriptorPlayback->periodCount = ma_max(attr.maxlength / attr.tlength, 1);
+        } else {
+            pDescriptorPlayback->periodCount = 1;
+        }
+
+        pDescriptorPlayback->periodSizeInFrames = attr.maxlength / ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels) / pDescriptorPlayback->periodCount;
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Playback actual attr: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d, fragsize=%d; internalPeriodSizeInFrames=%d\n", attr.maxlength, attr.tlength, attr.prebuf, attr.minreq, attr.fragsize, pDescriptorPlayback->periodSizeInFrames);
+    }
+
+
+    /*
+    We need a ring buffer for handling duplex mode. We can use the main duplex ring buffer in the main
+    part of the ma_device struct. We cannot, however, depend on ma_device_init() initializing this for
+    us later on because that will only do it if it's a fully asynchronous backend - i.e. the
+    onDeviceDataLoop callback is NULL, which is not the case for PulseAudio.
+    */
+    if (pConfig->deviceType == ma_device_type_duplex) {
+        ma_format rbFormat     = (format != ma_format_unknown) ? format     : pDescriptorCapture->format;
+        ma_uint32 rbChannels   = (channels   > 0)              ? channels   : pDescriptorCapture->channels;
+        ma_uint32 rbSampleRate = (sampleRate > 0)              ? sampleRate : pDescriptorCapture->sampleRate;
+
+        result = ma_duplex_rb_init(rbFormat, rbChannels, rbSampleRate, pDescriptorCapture->sampleRate, pDescriptorCapture->periodSizeInFrames, &pDevice->pContext->allocationCallbacks, &pDevice->duplexRB);
+        if (result != MA_SUCCESS) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to initialize ring buffer. %s.\n", ma_result_description(result));
+            goto on_error4;
+        }
+    }
+
+    return MA_SUCCESS;
+
+
+on_error4:
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ((ma_pa_stream_disconnect_proc)pDevice->pContext->pulse.pa_stream_disconnect)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+    }
+on_error3:
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ((ma_pa_stream_unref_proc)pDevice->pContext->pulse.pa_stream_unref)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+    }
+on_error2:
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ((ma_pa_stream_disconnect_proc)pDevice->pContext->pulse.pa_stream_disconnect)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+    }
+on_error1:
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ((ma_pa_stream_unref_proc)pDevice->pContext->pulse.pa_stream_unref)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+    }
+on_error0:
+    return result;
+}
+
+
+static void ma_pulse_operation_complete_callback(ma_pa_stream* pStream, int success, void* pUserData)
+{
+    ma_bool32* pIsSuccessful = (ma_bool32*)pUserData;
+    MA_ASSERT(pIsSuccessful != NULL);
+
+    *pIsSuccessful = (ma_bool32)success;
+
+    (void)pStream; /* Unused. */
+}
+
+static ma_result ma_device__cork_stream__pulse(ma_device* pDevice, ma_device_type deviceType, int cork)
+{
+    ma_context* pContext = pDevice->pContext;
+    ma_bool32 wasSuccessful;
+    ma_pa_stream* pStream;
+    ma_pa_operation* pOP;
+    ma_result result;
+
+    /* This should not be called with a duplex device type. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    wasSuccessful = MA_FALSE;
+
+    pStream = (ma_pa_stream*)((deviceType == ma_device_type_capture) ? pDevice->pulse.pStreamCapture : pDevice->pulse.pStreamPlayback);
+    MA_ASSERT(pStream != NULL);
+
+    pOP = ((ma_pa_stream_cork_proc)pContext->pulse.pa_stream_cork)(pStream, cork, ma_pulse_operation_complete_callback, &wasSuccessful);
+    if (pOP == NULL) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to cork PulseAudio stream.");
+        return MA_ERROR;
+    }
+
+    result = ma_wait_for_operation_and_unref__pulse(pDevice->pContext, pDevice->pulse.pMainLoop, pOP);
+    if (result != MA_SUCCESS) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] An error occurred while waiting for the PulseAudio stream to cork.");
+        return result;
+    }
+
+    if (!wasSuccessful) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to %s PulseAudio stream.", (cork) ? "stop" : "start");
+        return MA_ERROR;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__pulse(ma_device* pDevice)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        result = ma_device__cork_stream__pulse(pDevice, ma_device_type_capture, 0);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /*
+        We need to fill some data before uncorking. Not doing this will result in the write callback
+        never getting fired. We're not going to abort if writing fails because I still want the device
+        to get uncorked.
+        */
+        ma_device_write_to_stream__pulse(pDevice, (ma_pa_stream*)(pDevice->pulse.pStreamPlayback), NULL);   /* No need to check the result here. Always want to fall through an uncork.*/
+
+        result = ma_device__cork_stream__pulse(pDevice, ma_device_type_playback, 0);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__pulse(ma_device* pDevice)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        result = ma_device__cork_stream__pulse(pDevice, ma_device_type_capture, 1);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /*
+        Ideally we would drain the device here, but there's been cases where PulseAudio seems to be
+        broken on some systems to the point where no audio processing seems to happen. When this
+        happens, draining never completes and we get stuck here. For now I'm disabling draining of
+        the device so we don't just freeze the application.
+        */
+    #if 0
+        ma_pa_operation* pOP = ((ma_pa_stream_drain_proc)pDevice->pContext->pulse.pa_stream_drain)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, ma_pulse_operation_complete_callback, &wasSuccessful);
+        ma_wait_for_operation_and_unref__pulse(pDevice->pContext, pDevice->pulse.pMainLoop, pOP);
+    #endif
+
+        result = ma_device__cork_stream__pulse(pDevice, ma_device_type_playback, 1);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_data_loop__pulse(ma_device* pDevice)
+{
+    int resultPA;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* NOTE: Don't start the device here. It'll be done at a higher level. */
+
+    /*
+    All data is handled through callbacks. All we need to do is iterate over the main loop and let
+    the callbacks deal with it.
+    */
+    while (ma_device_get_state(pDevice) == ma_device_state_started) {
+        resultPA = ((ma_pa_mainloop_iterate_proc)pDevice->pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pDevice->pulse.pMainLoop, 1, NULL);
+        if (resultPA < 0) {
+            break;
+        }
+    }
+
+    /* NOTE: Don't stop the device here. It'll be done at a higher level. */
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_data_loop_wakeup__pulse(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ((ma_pa_mainloop_wakeup_proc)pDevice->pContext->pulse.pa_mainloop_wakeup)((ma_pa_mainloop*)pDevice->pulse.pMainLoop);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__pulse(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_pulseaudio);
+
+    ((ma_pa_context_disconnect_proc)pContext->pulse.pa_context_disconnect)((ma_pa_context*)pContext->pulse.pPulseContext);
+    ((ma_pa_context_unref_proc)pContext->pulse.pa_context_unref)((ma_pa_context*)pContext->pulse.pPulseContext);
+    ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)pContext->pulse.pMainLoop);
+
+    ma_free(pContext->pulse.pServerName, &pContext->allocationCallbacks);
+    ma_free(pContext->pulse.pApplicationName, &pContext->allocationCallbacks);
+
+#ifndef MA_NO_RUNTIME_LINKING
+    ma_dlclose(ma_context_get_log(pContext), pContext->pulse.pulseSO);
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    ma_result result;
+#ifndef MA_NO_RUNTIME_LINKING
+    const char* libpulseNames[] = {
+        "libpulse.so",
+        "libpulse.so.0"
+    };
+    size_t i;
+
+    for (i = 0; i < ma_countof(libpulseNames); ++i) {
+        pContext->pulse.pulseSO = ma_dlopen(ma_context_get_log(pContext), libpulseNames[i]);
+        if (pContext->pulse.pulseSO != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->pulse.pulseSO == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    pContext->pulse.pa_mainloop_new                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_new");
+    pContext->pulse.pa_mainloop_free                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_free");
+    pContext->pulse.pa_mainloop_quit                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_quit");
+    pContext->pulse.pa_mainloop_get_api                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_get_api");
+    pContext->pulse.pa_mainloop_iterate                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_iterate");
+    pContext->pulse.pa_mainloop_wakeup                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_wakeup");
+    pContext->pulse.pa_threaded_mainloop_new           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_new");
+    pContext->pulse.pa_threaded_mainloop_free          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_free");
+    pContext->pulse.pa_threaded_mainloop_start         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_start");
+    pContext->pulse.pa_threaded_mainloop_stop          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_stop");
+    pContext->pulse.pa_threaded_mainloop_lock          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_lock");
+    pContext->pulse.pa_threaded_mainloop_unlock        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_unlock");
+    pContext->pulse.pa_threaded_mainloop_wait          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_wait");
+    pContext->pulse.pa_threaded_mainloop_signal        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_signal");
+    pContext->pulse.pa_threaded_mainloop_accept        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_accept");
+    pContext->pulse.pa_threaded_mainloop_get_retval    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_get_retval");
+    pContext->pulse.pa_threaded_mainloop_get_api       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_get_api");
+    pContext->pulse.pa_threaded_mainloop_in_thread     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_in_thread");
+    pContext->pulse.pa_threaded_mainloop_set_name      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_set_name");
+    pContext->pulse.pa_context_new                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_new");
+    pContext->pulse.pa_context_unref                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_unref");
+    pContext->pulse.pa_context_connect                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_connect");
+    pContext->pulse.pa_context_disconnect              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_disconnect");
+    pContext->pulse.pa_context_set_state_callback      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_set_state_callback");
+    pContext->pulse.pa_context_get_state               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_state");
+    pContext->pulse.pa_context_get_sink_info_list      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_sink_info_list");
+    pContext->pulse.pa_context_get_source_info_list    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_source_info_list");
+    pContext->pulse.pa_context_get_sink_info_by_name   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_sink_info_by_name");
+    pContext->pulse.pa_context_get_source_info_by_name = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_source_info_by_name");
+    pContext->pulse.pa_operation_unref                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_operation_unref");
+    pContext->pulse.pa_operation_get_state             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_operation_get_state");
+    pContext->pulse.pa_channel_map_init_extend         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_channel_map_init_extend");
+    pContext->pulse.pa_channel_map_valid               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_channel_map_valid");
+    pContext->pulse.pa_channel_map_compatible          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_channel_map_compatible");
+    pContext->pulse.pa_stream_new                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_new");
+    pContext->pulse.pa_stream_unref                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_unref");
+    pContext->pulse.pa_stream_connect_playback         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_connect_playback");
+    pContext->pulse.pa_stream_connect_record           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_connect_record");
+    pContext->pulse.pa_stream_disconnect               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_disconnect");
+    pContext->pulse.pa_stream_get_state                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_state");
+    pContext->pulse.pa_stream_get_sample_spec          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_sample_spec");
+    pContext->pulse.pa_stream_get_channel_map          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_channel_map");
+    pContext->pulse.pa_stream_get_buffer_attr          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_buffer_attr");
+    pContext->pulse.pa_stream_set_buffer_attr          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_buffer_attr");
+    pContext->pulse.pa_stream_get_device_name          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_device_name");
+    pContext->pulse.pa_stream_set_write_callback       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_write_callback");
+    pContext->pulse.pa_stream_set_read_callback        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_read_callback");
+    pContext->pulse.pa_stream_set_suspended_callback   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_suspended_callback");
+    pContext->pulse.pa_stream_set_moved_callback       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_moved_callback");
+    pContext->pulse.pa_stream_is_suspended             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_is_suspended");
+    pContext->pulse.pa_stream_flush                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_flush");
+    pContext->pulse.pa_stream_drain                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_drain");
+    pContext->pulse.pa_stream_is_corked                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_is_corked");
+    pContext->pulse.pa_stream_cork                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_cork");
+    pContext->pulse.pa_stream_trigger                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_trigger");
+    pContext->pulse.pa_stream_begin_write              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_begin_write");
+    pContext->pulse.pa_stream_write                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_write");
+    pContext->pulse.pa_stream_peek                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_peek");
+    pContext->pulse.pa_stream_drop                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_drop");
+    pContext->pulse.pa_stream_writable_size            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_writable_size");
+    pContext->pulse.pa_stream_readable_size            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_readable_size");
+#else
+    /* This strange assignment system is just for type safety. */
+    ma_pa_mainloop_new_proc                    _pa_mainloop_new                   = pa_mainloop_new;
+    ma_pa_mainloop_free_proc                   _pa_mainloop_free                  = pa_mainloop_free;
+    ma_pa_mainloop_quit_proc                   _pa_mainloop_quit                  = pa_mainloop_quit;
+    ma_pa_mainloop_get_api_proc                _pa_mainloop_get_api               = pa_mainloop_get_api;
+    ma_pa_mainloop_iterate_proc                _pa_mainloop_iterate               = pa_mainloop_iterate;
+    ma_pa_mainloop_wakeup_proc                 _pa_mainloop_wakeup                = pa_mainloop_wakeup;
+    ma_pa_threaded_mainloop_new_proc           _pa_threaded_mainloop_new          = pa_threaded_mainloop_new;
+    ma_pa_threaded_mainloop_free_proc          _pa_threaded_mainloop_free         = pa_threaded_mainloop_free;
+    ma_pa_threaded_mainloop_start_proc         _pa_threaded_mainloop_start        = pa_threaded_mainloop_start;
+    ma_pa_threaded_mainloop_stop_proc          _pa_threaded_mainloop_stop         = pa_threaded_mainloop_stop;
+    ma_pa_threaded_mainloop_lock_proc          _pa_threaded_mainloop_lock         = pa_threaded_mainloop_lock;
+    ma_pa_threaded_mainloop_unlock_proc        _pa_threaded_mainloop_unlock       = pa_threaded_mainloop_unlock;
+    ma_pa_threaded_mainloop_wait_proc          _pa_threaded_mainloop_wait         = pa_threaded_mainloop_wait;
+    ma_pa_threaded_mainloop_signal_proc        _pa_threaded_mainloop_signal       = pa_threaded_mainloop_signal;
+    ma_pa_threaded_mainloop_accept_proc        _pa_threaded_mainloop_accept       = pa_threaded_mainloop_accept;
+    ma_pa_threaded_mainloop_get_retval_proc    _pa_threaded_mainloop_get_retval   = pa_threaded_mainloop_get_retval;
+    ma_pa_threaded_mainloop_get_api_proc       _pa_threaded_mainloop_get_api      = pa_threaded_mainloop_get_api;
+    ma_pa_threaded_mainloop_in_thread_proc     _pa_threaded_mainloop_in_thread    = pa_threaded_mainloop_in_thread;
+    ma_pa_threaded_mainloop_set_name_proc      _pa_threaded_mainloop_set_name     = pa_threaded_mainloop_set_name;
+    ma_pa_context_new_proc                     _pa_context_new                    = pa_context_new;
+    ma_pa_context_unref_proc                   _pa_context_unref                  = pa_context_unref;
+    ma_pa_context_connect_proc                 _pa_context_connect                = pa_context_connect;
+    ma_pa_context_disconnect_proc              _pa_context_disconnect             = pa_context_disconnect;
+    ma_pa_context_set_state_callback_proc      _pa_context_set_state_callback     = pa_context_set_state_callback;
+    ma_pa_context_get_state_proc               _pa_context_get_state              = pa_context_get_state;
+    ma_pa_context_get_sink_info_list_proc      _pa_context_get_sink_info_list     = pa_context_get_sink_info_list;
+    ma_pa_context_get_source_info_list_proc    _pa_context_get_source_info_list   = pa_context_get_source_info_list;
+    ma_pa_context_get_sink_info_by_name_proc   _pa_context_get_sink_info_by_name  = pa_context_get_sink_info_by_name;
+    ma_pa_context_get_source_info_by_name_proc _pa_context_get_source_info_by_name= pa_context_get_source_info_by_name;
+    ma_pa_operation_unref_proc                 _pa_operation_unref                = pa_operation_unref;
+    ma_pa_operation_get_state_proc             _pa_operation_get_state            = pa_operation_get_state;
+    ma_pa_channel_map_init_extend_proc         _pa_channel_map_init_extend        = pa_channel_map_init_extend;
+    ma_pa_channel_map_valid_proc               _pa_channel_map_valid              = pa_channel_map_valid;
+    ma_pa_channel_map_compatible_proc          _pa_channel_map_compatible         = pa_channel_map_compatible;
+    ma_pa_stream_new_proc                      _pa_stream_new                     = pa_stream_new;
+    ma_pa_stream_unref_proc                    _pa_stream_unref                   = pa_stream_unref;
+    ma_pa_stream_connect_playback_proc         _pa_stream_connect_playback        = pa_stream_connect_playback;
+    ma_pa_stream_connect_record_proc           _pa_stream_connect_record          = pa_stream_connect_record;
+    ma_pa_stream_disconnect_proc               _pa_stream_disconnect              = pa_stream_disconnect;
+    ma_pa_stream_get_state_proc                _pa_stream_get_state               = pa_stream_get_state;
+    ma_pa_stream_get_sample_spec_proc          _pa_stream_get_sample_spec         = pa_stream_get_sample_spec;
+    ma_pa_stream_get_channel_map_proc          _pa_stream_get_channel_map         = pa_stream_get_channel_map;
+    ma_pa_stream_get_buffer_attr_proc          _pa_stream_get_buffer_attr         = pa_stream_get_buffer_attr;
+    ma_pa_stream_set_buffer_attr_proc          _pa_stream_set_buffer_attr         = pa_stream_set_buffer_attr;
+    ma_pa_stream_get_device_name_proc          _pa_stream_get_device_name         = pa_stream_get_device_name;
+    ma_pa_stream_set_write_callback_proc       _pa_stream_set_write_callback      = pa_stream_set_write_callback;
+    ma_pa_stream_set_read_callback_proc        _pa_stream_set_read_callback       = pa_stream_set_read_callback;
+    ma_pa_stream_set_suspended_callback_proc   _pa_stream_set_suspended_callback  = pa_stream_set_suspended_callback;
+    ma_pa_stream_set_moved_callback_proc       _pa_stream_set_moved_callback      = pa_stream_set_moved_callback;
+    ma_pa_stream_is_suspended_proc             _pa_stream_is_suspended            = pa_stream_is_suspended;
+    ma_pa_stream_flush_proc                    _pa_stream_flush                   = pa_stream_flush;
+    ma_pa_stream_drain_proc                    _pa_stream_drain                   = pa_stream_drain;
+    ma_pa_stream_is_corked_proc                _pa_stream_is_corked               = pa_stream_is_corked;
+    ma_pa_stream_cork_proc                     _pa_stream_cork                    = pa_stream_cork;
+    ma_pa_stream_trigger_proc                  _pa_stream_trigger                 = pa_stream_trigger;
+    ma_pa_stream_begin_write_proc              _pa_stream_begin_write             = pa_stream_begin_write;
+    ma_pa_stream_write_proc                    _pa_stream_write                   = pa_stream_write;
+    ma_pa_stream_peek_proc                     _pa_stream_peek                    = pa_stream_peek;
+    ma_pa_stream_drop_proc                     _pa_stream_drop                    = pa_stream_drop;
+    ma_pa_stream_writable_size_proc            _pa_stream_writable_size           = pa_stream_writable_size;
+    ma_pa_stream_readable_size_proc            _pa_stream_readable_size           = pa_stream_readable_size;
+
+    pContext->pulse.pa_mainloop_new                    = (ma_proc)_pa_mainloop_new;
+    pContext->pulse.pa_mainloop_free                   = (ma_proc)_pa_mainloop_free;
+    pContext->pulse.pa_mainloop_quit                   = (ma_proc)_pa_mainloop_quit;
+    pContext->pulse.pa_mainloop_get_api                = (ma_proc)_pa_mainloop_get_api;
+    pContext->pulse.pa_mainloop_iterate                = (ma_proc)_pa_mainloop_iterate;
+    pContext->pulse.pa_mainloop_wakeup                 = (ma_proc)_pa_mainloop_wakeup;
+    pContext->pulse.pa_threaded_mainloop_new           = (ma_proc)_pa_threaded_mainloop_new;
+    pContext->pulse.pa_threaded_mainloop_free          = (ma_proc)_pa_threaded_mainloop_free;
+    pContext->pulse.pa_threaded_mainloop_start         = (ma_proc)_pa_threaded_mainloop_start;
+    pContext->pulse.pa_threaded_mainloop_stop          = (ma_proc)_pa_threaded_mainloop_stop;
+    pContext->pulse.pa_threaded_mainloop_lock          = (ma_proc)_pa_threaded_mainloop_lock;
+    pContext->pulse.pa_threaded_mainloop_unlock        = (ma_proc)_pa_threaded_mainloop_unlock;
+    pContext->pulse.pa_threaded_mainloop_wait          = (ma_proc)_pa_threaded_mainloop_wait;
+    pContext->pulse.pa_threaded_mainloop_signal        = (ma_proc)_pa_threaded_mainloop_signal;
+    pContext->pulse.pa_threaded_mainloop_accept        = (ma_proc)_pa_threaded_mainloop_accept;
+    pContext->pulse.pa_threaded_mainloop_get_retval    = (ma_proc)_pa_threaded_mainloop_get_retval;
+    pContext->pulse.pa_threaded_mainloop_get_api       = (ma_proc)_pa_threaded_mainloop_get_api;
+    pContext->pulse.pa_threaded_mainloop_in_thread     = (ma_proc)_pa_threaded_mainloop_in_thread;
+    pContext->pulse.pa_threaded_mainloop_set_name      = (ma_proc)_pa_threaded_mainloop_set_name;
+    pContext->pulse.pa_context_new                     = (ma_proc)_pa_context_new;
+    pContext->pulse.pa_context_unref                   = (ma_proc)_pa_context_unref;
+    pContext->pulse.pa_context_connect                 = (ma_proc)_pa_context_connect;
+    pContext->pulse.pa_context_disconnect              = (ma_proc)_pa_context_disconnect;
+    pContext->pulse.pa_context_set_state_callback      = (ma_proc)_pa_context_set_state_callback;
+    pContext->pulse.pa_context_get_state               = (ma_proc)_pa_context_get_state;
+    pContext->pulse.pa_context_get_sink_info_list      = (ma_proc)_pa_context_get_sink_info_list;
+    pContext->pulse.pa_context_get_source_info_list    = (ma_proc)_pa_context_get_source_info_list;
+    pContext->pulse.pa_context_get_sink_info_by_name   = (ma_proc)_pa_context_get_sink_info_by_name;
+    pContext->pulse.pa_context_get_source_info_by_name = (ma_proc)_pa_context_get_source_info_by_name;
+    pContext->pulse.pa_operation_unref                 = (ma_proc)_pa_operation_unref;
+    pContext->pulse.pa_operation_get_state             = (ma_proc)_pa_operation_get_state;
+    pContext->pulse.pa_channel_map_init_extend         = (ma_proc)_pa_channel_map_init_extend;
+    pContext->pulse.pa_channel_map_valid               = (ma_proc)_pa_channel_map_valid;
+    pContext->pulse.pa_channel_map_compatible          = (ma_proc)_pa_channel_map_compatible;
+    pContext->pulse.pa_stream_new                      = (ma_proc)_pa_stream_new;
+    pContext->pulse.pa_stream_unref                    = (ma_proc)_pa_stream_unref;
+    pContext->pulse.pa_stream_connect_playback         = (ma_proc)_pa_stream_connect_playback;
+    pContext->pulse.pa_stream_connect_record           = (ma_proc)_pa_stream_connect_record;
+    pContext->pulse.pa_stream_disconnect               = (ma_proc)_pa_stream_disconnect;
+    pContext->pulse.pa_stream_get_state                = (ma_proc)_pa_stream_get_state;
+    pContext->pulse.pa_stream_get_sample_spec          = (ma_proc)_pa_stream_get_sample_spec;
+    pContext->pulse.pa_stream_get_channel_map          = (ma_proc)_pa_stream_get_channel_map;
+    pContext->pulse.pa_stream_get_buffer_attr          = (ma_proc)_pa_stream_get_buffer_attr;
+    pContext->pulse.pa_stream_set_buffer_attr          = (ma_proc)_pa_stream_set_buffer_attr;
+    pContext->pulse.pa_stream_get_device_name          = (ma_proc)_pa_stream_get_device_name;
+    pContext->pulse.pa_stream_set_write_callback       = (ma_proc)_pa_stream_set_write_callback;
+    pContext->pulse.pa_stream_set_read_callback        = (ma_proc)_pa_stream_set_read_callback;
+    pContext->pulse.pa_stream_set_suspended_callback   = (ma_proc)_pa_stream_set_suspended_callback;
+    pContext->pulse.pa_stream_set_moved_callback       = (ma_proc)_pa_stream_set_moved_callback;
+    pContext->pulse.pa_stream_is_suspended             = (ma_proc)_pa_stream_is_suspended;
+    pContext->pulse.pa_stream_flush                    = (ma_proc)_pa_stream_flush;
+    pContext->pulse.pa_stream_drain                    = (ma_proc)_pa_stream_drain;
+    pContext->pulse.pa_stream_is_corked                = (ma_proc)_pa_stream_is_corked;
+    pContext->pulse.pa_stream_cork                     = (ma_proc)_pa_stream_cork;
+    pContext->pulse.pa_stream_trigger                  = (ma_proc)_pa_stream_trigger;
+    pContext->pulse.pa_stream_begin_write              = (ma_proc)_pa_stream_begin_write;
+    pContext->pulse.pa_stream_write                    = (ma_proc)_pa_stream_write;
+    pContext->pulse.pa_stream_peek                     = (ma_proc)_pa_stream_peek;
+    pContext->pulse.pa_stream_drop                     = (ma_proc)_pa_stream_drop;
+    pContext->pulse.pa_stream_writable_size            = (ma_proc)_pa_stream_writable_size;
+    pContext->pulse.pa_stream_readable_size            = (ma_proc)_pa_stream_readable_size;
+#endif
+
+    /* We need to make a copy of the application and server names so we can pass them to the pa_context of each device. */
+    pContext->pulse.pApplicationName = ma_copy_string(pConfig->pulse.pApplicationName, &pContext->allocationCallbacks);
+    if (pContext->pulse.pApplicationName == NULL && pConfig->pulse.pApplicationName != NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    pContext->pulse.pServerName = ma_copy_string(pConfig->pulse.pServerName, &pContext->allocationCallbacks);
+    if (pContext->pulse.pServerName == NULL && pConfig->pulse.pServerName != NULL) {
+        ma_free(pContext->pulse.pApplicationName, &pContext->allocationCallbacks);
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_init_pa_mainloop_and_pa_context__pulse(pContext, pConfig->pulse.pApplicationName, pConfig->pulse.pServerName, pConfig->pulse.tryAutoSpawn, &pContext->pulse.pMainLoop, &pContext->pulse.pPulseContext);
+    if (result != MA_SUCCESS) {
+        ma_free(pContext->pulse.pServerName, &pContext->allocationCallbacks);
+        ma_free(pContext->pulse.pApplicationName, &pContext->allocationCallbacks);
+    #ifndef MA_NO_RUNTIME_LINKING
+        ma_dlclose(ma_context_get_log(pContext), pContext->pulse.pulseSO);
+    #endif
+        return result;
+    }
+
+    /* With pa_mainloop we run a synchronous backend, but we implement our own main loop. */
+    pCallbacks->onContextInit             = ma_context_init__pulse;
+    pCallbacks->onContextUninit           = ma_context_uninit__pulse;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__pulse;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__pulse;
+    pCallbacks->onDeviceInit              = ma_device_init__pulse;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__pulse;
+    pCallbacks->onDeviceStart             = ma_device_start__pulse;
+    pCallbacks->onDeviceStop              = ma_device_stop__pulse;
+    pCallbacks->onDeviceRead              = NULL;   /* Not used because we're implementing onDeviceDataLoop. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not used because we're implementing onDeviceDataLoop. */
+    pCallbacks->onDeviceDataLoop          = ma_device_data_loop__pulse;
+    pCallbacks->onDeviceDataLoopWakeup    = ma_device_data_loop_wakeup__pulse;
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+/******************************************************************************
+
+JACK Backend
+
+******************************************************************************/
+#ifdef MA_HAS_JACK
+
+/* It is assumed jack.h is available when compile-time linking is being used. */
+#ifdef MA_NO_RUNTIME_LINKING
+#include <jack/jack.h>
+
+typedef jack_nframes_t              ma_jack_nframes_t;
+typedef jack_options_t              ma_jack_options_t;
+typedef jack_status_t               ma_jack_status_t;
+typedef jack_client_t               ma_jack_client_t;
+typedef jack_port_t                 ma_jack_port_t;
+typedef JackProcessCallback         ma_JackProcessCallback;
+typedef JackBufferSizeCallback      ma_JackBufferSizeCallback;
+typedef JackShutdownCallback        ma_JackShutdownCallback;
+#define MA_JACK_DEFAULT_AUDIO_TYPE  JACK_DEFAULT_AUDIO_TYPE
+#define ma_JackNullOption           JackNullOption
+#define ma_JackNoStartServer        JackNoStartServer
+#define ma_JackPortIsInput          JackPortIsInput
+#define ma_JackPortIsOutput         JackPortIsOutput
+#define ma_JackPortIsPhysical       JackPortIsPhysical
+#else
+typedef ma_uint32               ma_jack_nframes_t;
+typedef int                     ma_jack_options_t;
+typedef int                     ma_jack_status_t;
+typedef struct ma_jack_client_t ma_jack_client_t;
+typedef struct ma_jack_port_t   ma_jack_port_t;
+typedef int  (* ma_JackProcessCallback)   (ma_jack_nframes_t nframes, void* arg);
+typedef int  (* ma_JackBufferSizeCallback)(ma_jack_nframes_t nframes, void* arg);
+typedef void (* ma_JackShutdownCallback)  (void* arg);
+#define MA_JACK_DEFAULT_AUDIO_TYPE "32 bit float mono audio"
+#define ma_JackNullOption          0
+#define ma_JackNoStartServer       1
+#define ma_JackPortIsInput         1
+#define ma_JackPortIsOutput        2
+#define ma_JackPortIsPhysical      4
+#endif
+
+typedef ma_jack_client_t* (* ma_jack_client_open_proc)             (const char* client_name, ma_jack_options_t options, ma_jack_status_t* status, ...);
+typedef int               (* ma_jack_client_close_proc)            (ma_jack_client_t* client);
+typedef int               (* ma_jack_client_name_size_proc)        (void);
+typedef int               (* ma_jack_set_process_callback_proc)    (ma_jack_client_t* client, ma_JackProcessCallback process_callback, void* arg);
+typedef int               (* ma_jack_set_buffer_size_callback_proc)(ma_jack_client_t* client, ma_JackBufferSizeCallback bufsize_callback, void* arg);
+typedef void              (* ma_jack_on_shutdown_proc)             (ma_jack_client_t* client, ma_JackShutdownCallback function, void* arg);
+typedef ma_jack_nframes_t (* ma_jack_get_sample_rate_proc)         (ma_jack_client_t* client);
+typedef ma_jack_nframes_t (* ma_jack_get_buffer_size_proc)         (ma_jack_client_t* client);
+typedef const char**      (* ma_jack_get_ports_proc)               (ma_jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags);
+typedef int               (* ma_jack_activate_proc)                (ma_jack_client_t* client);
+typedef int               (* ma_jack_deactivate_proc)              (ma_jack_client_t* client);
+typedef int               (* ma_jack_connect_proc)                 (ma_jack_client_t* client, const char* source_port, const char* destination_port);
+typedef ma_jack_port_t*   (* ma_jack_port_register_proc)           (ma_jack_client_t* client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
+typedef const char*       (* ma_jack_port_name_proc)               (const ma_jack_port_t* port);
+typedef void*             (* ma_jack_port_get_buffer_proc)         (ma_jack_port_t* port, ma_jack_nframes_t nframes);
+typedef void              (* ma_jack_free_proc)                    (void* ptr);
+
+static ma_result ma_context_open_client__jack(ma_context* pContext, ma_jack_client_t** ppClient)
+{
+    size_t maxClientNameSize;
+    char clientName[256];
+    ma_jack_status_t status;
+    ma_jack_client_t* pClient;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppClient != NULL);
+
+    if (ppClient) {
+        *ppClient = NULL;
+    }
+
+    maxClientNameSize = ((ma_jack_client_name_size_proc)pContext->jack.jack_client_name_size)(); /* Includes null terminator. */
+    ma_strncpy_s(clientName, ma_min(sizeof(clientName), maxClientNameSize), (pContext->jack.pClientName != NULL) ? pContext->jack.pClientName : "miniaudio", (size_t)-1);
+
+    pClient = ((ma_jack_client_open_proc)pContext->jack.jack_client_open)(clientName, (pContext->jack.tryStartServer) ? ma_JackNullOption : ma_JackNoStartServer, &status, NULL);
+    if (pClient == NULL) {
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    if (ppClient) {
+        *ppClient = pClient;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_enumerate_devices__jack(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult = MA_TRUE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE;    /* JACK only uses default devices. */
+        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE;    /* JACK only uses default devices. */
+        cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+    }
+
+    (void)cbResult; /* For silencing a static analysis warning. */
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__jack(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_jack_client_t* pClient;
+    ma_result result;
+    const char** ppPorts;
+
+    MA_ASSERT(pContext != NULL);
+
+    if (pDeviceID != NULL && pDeviceID->jack != 0) {
+        return MA_NO_DEVICE;   /* Don't know the device. */
+    }
+
+    /* Name / Description */
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+    /* Jack only uses default devices. */
+    pDeviceInfo->isDefault = MA_TRUE;
+
+    /* Jack only supports f32 and has a specific channel count and sample rate. */
+    pDeviceInfo->nativeDataFormats[0].format = ma_format_f32;
+
+    /* The channel count and sample rate can only be determined by opening the device. */
+    result = ma_context_open_client__jack(pContext, &pClient);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[JACK] Failed to open client.");
+        return result;
+    }
+
+    pDeviceInfo->nativeDataFormats[0].sampleRate = ((ma_jack_get_sample_rate_proc)pContext->jack.jack_get_sample_rate)((ma_jack_client_t*)pClient);
+    pDeviceInfo->nativeDataFormats[0].channels   = 0;
+
+    ppPorts = ((ma_jack_get_ports_proc)pContext->jack.jack_get_ports)((ma_jack_client_t*)pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ((deviceType == ma_device_type_playback) ? ma_JackPortIsInput : ma_JackPortIsOutput));
+    if (ppPorts == NULL) {
+        ((ma_jack_client_close_proc)pContext->jack.jack_client_close)((ma_jack_client_t*)pClient);
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[JACK] Failed to query physical ports.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    while (ppPorts[pDeviceInfo->nativeDataFormats[0].channels] != NULL) {
+        pDeviceInfo->nativeDataFormats[0].channels += 1;
+    }
+
+    pDeviceInfo->nativeDataFormats[0].flags = 0;
+    pDeviceInfo->nativeDataFormatCount = 1;
+
+    ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppPorts);
+    ((ma_jack_client_close_proc)pContext->jack.jack_client_close)((ma_jack_client_t*)pClient);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_uninit__jack(ma_device* pDevice)
+{
+    ma_context* pContext;
+
+    MA_ASSERT(pDevice != NULL);
+
+    pContext = pDevice->pContext;
+    MA_ASSERT(pContext != NULL);
+
+    if (pDevice->jack.pClient != NULL) {
+        ((ma_jack_client_close_proc)pContext->jack.jack_client_close)((ma_jack_client_t*)pDevice->jack.pClient);
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_free(pDevice->jack.pIntermediaryBufferCapture, &pDevice->pContext->allocationCallbacks);
+        ma_free(pDevice->jack.ppPortsCapture, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_free(pDevice->jack.pIntermediaryBufferPlayback, &pDevice->pContext->allocationCallbacks);
+        ma_free(pDevice->jack.ppPortsPlayback, &pDevice->pContext->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_device__jack_shutdown_callback(void* pUserData)
+{
+    /* JACK died. Stop the device. */
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    ma_device_stop(pDevice);
+}
+
+static int ma_device__jack_buffer_size_callback(ma_jack_nframes_t frameCount, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        size_t newBufferSize = frameCount * (pDevice->capture.internalChannels * ma_get_bytes_per_sample(pDevice->capture.internalFormat));
+        float* pNewBuffer = (float*)ma_calloc(newBufferSize, &pDevice->pContext->allocationCallbacks);
+        if (pNewBuffer == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        ma_free(pDevice->jack.pIntermediaryBufferCapture, &pDevice->pContext->allocationCallbacks);
+
+        pDevice->jack.pIntermediaryBufferCapture = pNewBuffer;
+        pDevice->playback.internalPeriodSizeInFrames = frameCount;
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        size_t newBufferSize = frameCount * (pDevice->playback.internalChannels * ma_get_bytes_per_sample(pDevice->playback.internalFormat));
+        float* pNewBuffer = (float*)ma_calloc(newBufferSize, &pDevice->pContext->allocationCallbacks);
+        if (pNewBuffer == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        ma_free(pDevice->jack.pIntermediaryBufferPlayback, &pDevice->pContext->allocationCallbacks);
+
+        pDevice->jack.pIntermediaryBufferPlayback = pNewBuffer;
+        pDevice->playback.internalPeriodSizeInFrames = frameCount;
+    }
+
+    return 0;
+}
+
+static int ma_device__jack_process_callback(ma_jack_nframes_t frameCount, void* pUserData)
+{
+    ma_device* pDevice;
+    ma_context* pContext;
+    ma_uint32 iChannel;
+
+    pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    pContext = pDevice->pContext;
+    MA_ASSERT(pContext != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        /* Channels need to be interleaved. */
+        for (iChannel = 0; iChannel < pDevice->capture.internalChannels; ++iChannel) {
+            const float* pSrc = (const float*)((ma_jack_port_get_buffer_proc)pContext->jack.jack_port_get_buffer)((ma_jack_port_t*)pDevice->jack.ppPortsCapture[iChannel], frameCount);
+            if (pSrc != NULL) {
+                float* pDst = pDevice->jack.pIntermediaryBufferCapture + iChannel;
+                ma_jack_nframes_t iFrame;
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    *pDst = *pSrc;
+
+                    pDst += pDevice->capture.internalChannels;
+                    pSrc += 1;
+                }
+            }
+        }
+
+        ma_device_handle_backend_data_callback(pDevice, NULL, pDevice->jack.pIntermediaryBufferCapture, frameCount);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_device_handle_backend_data_callback(pDevice, pDevice->jack.pIntermediaryBufferPlayback, NULL, frameCount);
+
+        /* Channels need to be deinterleaved. */
+        for (iChannel = 0; iChannel < pDevice->playback.internalChannels; ++iChannel) {
+            float* pDst = (float*)((ma_jack_port_get_buffer_proc)pContext->jack.jack_port_get_buffer)((ma_jack_port_t*)pDevice->jack.ppPortsPlayback[iChannel], frameCount);
+            if (pDst != NULL) {
+                const float* pSrc = pDevice->jack.pIntermediaryBufferPlayback + iChannel;
+                ma_jack_nframes_t iFrame;
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    *pDst = *pSrc;
+
+                    pDst += 1;
+                    pSrc += pDevice->playback.internalChannels;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static ma_result ma_device_init__jack(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+    ma_uint32 periodSizeInFrames;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDevice != NULL);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Loopback mode not supported.");
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* Only supporting default devices with JACK. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->pDeviceID != NULL && pDescriptorPlayback->pDeviceID->jack != 0) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->pDeviceID  != NULL && pDescriptorCapture->pDeviceID->jack  != 0)) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Only default devices are supported.");
+        return MA_NO_DEVICE;
+    }
+
+    /* No exclusive mode with the JACK backend. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Exclusive mode not supported.");
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    /* Open the client. */
+    result = ma_context_open_client__jack(pDevice->pContext, (ma_jack_client_t**)&pDevice->jack.pClient);
+    if (result != MA_SUCCESS) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to open client.");
+        return result;
+    }
+
+    /* Callbacks. */
+    if (((ma_jack_set_process_callback_proc)pDevice->pContext->jack.jack_set_process_callback)((ma_jack_client_t*)pDevice->jack.pClient, ma_device__jack_process_callback, pDevice) != 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to set process callback.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+    if (((ma_jack_set_buffer_size_callback_proc)pDevice->pContext->jack.jack_set_buffer_size_callback)((ma_jack_client_t*)pDevice->jack.pClient, ma_device__jack_buffer_size_callback, pDevice) != 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to set buffer size callback.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    ((ma_jack_on_shutdown_proc)pDevice->pContext->jack.jack_on_shutdown)((ma_jack_client_t*)pDevice->jack.pClient, ma_device__jack_shutdown_callback, pDevice);
+
+
+    /* The buffer size in frames can change. */
+    periodSizeInFrames = ((ma_jack_get_buffer_size_proc)pDevice->pContext->jack.jack_get_buffer_size)((ma_jack_client_t*)pDevice->jack.pClient);
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_uint32 iPort;
+        const char** ppPorts;
+
+        pDescriptorCapture->format     = ma_format_f32;
+        pDescriptorCapture->channels   = 0;
+        pDescriptorCapture->sampleRate = ((ma_jack_get_sample_rate_proc)pDevice->pContext->jack.jack_get_sample_rate)((ma_jack_client_t*)pDevice->jack.pClient);
+        ma_channel_map_init_standard(ma_standard_channel_map_alsa, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorCapture->channels);
+
+        ppPorts = ((ma_jack_get_ports_proc)pDevice->pContext->jack.jack_get_ports)((ma_jack_client_t*)pDevice->jack.pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ma_JackPortIsOutput);
+        if (ppPorts == NULL) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to query physical ports.");
+            return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        }
+
+        /* Need to count the number of ports first so we can allocate some memory. */
+        while (ppPorts[pDescriptorCapture->channels] != NULL) {
+            pDescriptorCapture->channels += 1;
+        }
+
+        pDevice->jack.ppPortsCapture = (ma_ptr*)ma_malloc(sizeof(*pDevice->jack.ppPortsCapture) * pDescriptorCapture->channels, &pDevice->pContext->allocationCallbacks);
+        if (pDevice->jack.ppPortsCapture == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        for (iPort = 0; iPort < pDescriptorCapture->channels; iPort += 1) {
+            char name[64];
+            ma_strcpy_s(name, sizeof(name), "capture");
+            ma_itoa_s((int)iPort, name+7, sizeof(name)-7, 10); /* 7 = length of "capture" */
+
+            pDevice->jack.ppPortsCapture[iPort] = ((ma_jack_port_register_proc)pDevice->pContext->jack.jack_port_register)((ma_jack_client_t*)pDevice->jack.pClient, name, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsInput, 0);
+            if (pDevice->jack.ppPortsCapture[iPort] == NULL) {
+                ((ma_jack_free_proc)pDevice->pContext->jack.jack_free)((void*)ppPorts);
+                ma_device_uninit__jack(pDevice);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to register ports.");
+                return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+            }
+        }
+
+        ((ma_jack_free_proc)pDevice->pContext->jack.jack_free)((void*)ppPorts);
+
+        pDescriptorCapture->periodSizeInFrames = periodSizeInFrames;
+        pDescriptorCapture->periodCount        = 1; /* There's no notion of a period in JACK. Just set to 1. */
+
+        pDevice->jack.pIntermediaryBufferCapture = (float*)ma_calloc(pDescriptorCapture->periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels), &pDevice->pContext->allocationCallbacks);
+        if (pDevice->jack.pIntermediaryBufferCapture == NULL) {
+            ma_device_uninit__jack(pDevice);
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_uint32 iPort;
+        const char** ppPorts;
+
+        pDescriptorPlayback->format     = ma_format_f32;
+        pDescriptorPlayback->channels   = 0;
+        pDescriptorPlayback->sampleRate = ((ma_jack_get_sample_rate_proc)pDevice->pContext->jack.jack_get_sample_rate)((ma_jack_client_t*)pDevice->jack.pClient);
+        ma_channel_map_init_standard(ma_standard_channel_map_alsa, pDescriptorPlayback->channelMap, ma_countof(pDescriptorPlayback->channelMap), pDescriptorPlayback->channels);
+
+        ppPorts = ((ma_jack_get_ports_proc)pDevice->pContext->jack.jack_get_ports)((ma_jack_client_t*)pDevice->jack.pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ma_JackPortIsInput);
+        if (ppPorts == NULL) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to query physical ports.");
+            return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        }
+
+        /* Need to count the number of ports first so we can allocate some memory. */
+        while (ppPorts[pDescriptorPlayback->channels] != NULL) {
+            pDescriptorPlayback->channels += 1;
+        }
+
+        pDevice->jack.ppPortsPlayback = (ma_ptr*)ma_malloc(sizeof(*pDevice->jack.ppPortsPlayback) * pDescriptorPlayback->channels, &pDevice->pContext->allocationCallbacks);
+        if (pDevice->jack.ppPortsPlayback == NULL) {
+            ma_free(pDevice->jack.ppPortsCapture, &pDevice->pContext->allocationCallbacks);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        for (iPort = 0; iPort < pDescriptorPlayback->channels; iPort += 1) {
+            char name[64];
+            ma_strcpy_s(name, sizeof(name), "playback");
+            ma_itoa_s((int)iPort, name+8, sizeof(name)-8, 10); /* 8 = length of "playback" */
+
+            pDevice->jack.ppPortsPlayback[iPort] = ((ma_jack_port_register_proc)pDevice->pContext->jack.jack_port_register)((ma_jack_client_t*)pDevice->jack.pClient, name, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsOutput, 0);
+            if (pDevice->jack.ppPortsPlayback[iPort] == NULL) {
+                ((ma_jack_free_proc)pDevice->pContext->jack.jack_free)((void*)ppPorts);
+                ma_device_uninit__jack(pDevice);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to register ports.");
+                return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+            }
+        }
+
+        ((ma_jack_free_proc)pDevice->pContext->jack.jack_free)((void*)ppPorts);
+
+        pDescriptorPlayback->periodSizeInFrames = periodSizeInFrames;
+        pDescriptorPlayback->periodCount        = 1;   /* There's no notion of a period in JACK. Just set to 1. */
+
+        pDevice->jack.pIntermediaryBufferPlayback = (float*)ma_calloc(pDescriptorPlayback->periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels), &pDevice->pContext->allocationCallbacks);
+        if (pDevice->jack.pIntermediaryBufferPlayback == NULL) {
+            ma_device_uninit__jack(pDevice);
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_start__jack(ma_device* pDevice)
+{
+    ma_context* pContext = pDevice->pContext;
+    int resultJACK;
+    size_t i;
+
+    resultJACK = ((ma_jack_activate_proc)pContext->jack.jack_activate)((ma_jack_client_t*)pDevice->jack.pClient);
+    if (resultJACK != 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to activate the JACK client.");
+        return MA_FAILED_TO_START_BACKEND_DEVICE;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        const char** ppServerPorts = ((ma_jack_get_ports_proc)pContext->jack.jack_get_ports)((ma_jack_client_t*)pDevice->jack.pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ma_JackPortIsOutput);
+        if (ppServerPorts == NULL) {
+            ((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to retrieve physical ports.");
+            return MA_ERROR;
+        }
+
+        for (i = 0; ppServerPorts[i] != NULL; ++i) {
+            const char* pServerPort = ppServerPorts[i];
+            const char* pClientPort = ((ma_jack_port_name_proc)pContext->jack.jack_port_name)((ma_jack_port_t*)pDevice->jack.ppPortsCapture[i]);
+
+            resultJACK = ((ma_jack_connect_proc)pContext->jack.jack_connect)((ma_jack_client_t*)pDevice->jack.pClient, pServerPort, pClientPort);
+            if (resultJACK != 0) {
+                ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppServerPorts);
+                ((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to connect ports.");
+                return MA_ERROR;
+            }
+        }
+
+        ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppServerPorts);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        const char** ppServerPorts = ((ma_jack_get_ports_proc)pContext->jack.jack_get_ports)((ma_jack_client_t*)pDevice->jack.pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ma_JackPortIsInput);
+        if (ppServerPorts == NULL) {
+            ((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to retrieve physical ports.");
+            return MA_ERROR;
+        }
+
+        for (i = 0; ppServerPorts[i] != NULL; ++i) {
+            const char* pServerPort = ppServerPorts[i];
+            const char* pClientPort = ((ma_jack_port_name_proc)pContext->jack.jack_port_name)((ma_jack_port_t*)pDevice->jack.ppPortsPlayback[i]);
+
+            resultJACK = ((ma_jack_connect_proc)pContext->jack.jack_connect)((ma_jack_client_t*)pDevice->jack.pClient, pClientPort, pServerPort);
+            if (resultJACK != 0) {
+                ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppServerPorts);
+                ((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to connect ports.");
+                return MA_ERROR;
+            }
+        }
+
+        ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppServerPorts);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__jack(ma_device* pDevice)
+{
+    ma_context* pContext = pDevice->pContext;
+
+    if (((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient) != 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] An error occurred when deactivating the JACK client.");
+        return MA_ERROR;
+    }
+
+    ma_device__on_notification_stopped(pDevice);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__jack(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_jack);
+
+    ma_free(pContext->jack.pClientName, &pContext->allocationCallbacks);
+    pContext->jack.pClientName = NULL;
+
+#ifndef MA_NO_RUNTIME_LINKING
+    ma_dlclose(ma_context_get_log(pContext), pContext->jack.jackSO);
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__jack(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+#ifndef MA_NO_RUNTIME_LINKING
+    const char* libjackNames[] = {
+#if defined(MA_WIN32)
+        "libjack.dll",
+        "libjack64.dll"
+#endif
+#if defined(MA_UNIX)
+        "libjack.so",
+        "libjack.so.0"
+#endif
+    };
+    size_t i;
+
+    for (i = 0; i < ma_countof(libjackNames); ++i) {
+        pContext->jack.jackSO = ma_dlopen(ma_context_get_log(pContext), libjackNames[i]);
+        if (pContext->jack.jackSO != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->jack.jackSO == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    pContext->jack.jack_client_open              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_client_open");
+    pContext->jack.jack_client_close             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_client_close");
+    pContext->jack.jack_client_name_size         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_client_name_size");
+    pContext->jack.jack_set_process_callback     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_set_process_callback");
+    pContext->jack.jack_set_buffer_size_callback = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_set_buffer_size_callback");
+    pContext->jack.jack_on_shutdown              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_on_shutdown");
+    pContext->jack.jack_get_sample_rate          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_get_sample_rate");
+    pContext->jack.jack_get_buffer_size          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_get_buffer_size");
+    pContext->jack.jack_get_ports                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_get_ports");
+    pContext->jack.jack_activate                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_activate");
+    pContext->jack.jack_deactivate               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_deactivate");
+    pContext->jack.jack_connect                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_connect");
+    pContext->jack.jack_port_register            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_port_register");
+    pContext->jack.jack_port_name                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_port_name");
+    pContext->jack.jack_port_get_buffer          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_port_get_buffer");
+    pContext->jack.jack_free                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_free");
+#else
+    /*
+    This strange assignment system is here just to ensure type safety of miniaudio's function pointer
+    types. If anything differs slightly the compiler should throw a warning.
+    */
+    ma_jack_client_open_proc              _jack_client_open              = jack_client_open;
+    ma_jack_client_close_proc             _jack_client_close             = jack_client_close;
+    ma_jack_client_name_size_proc         _jack_client_name_size         = jack_client_name_size;
+    ma_jack_set_process_callback_proc     _jack_set_process_callback     = jack_set_process_callback;
+    ma_jack_set_buffer_size_callback_proc _jack_set_buffer_size_callback = jack_set_buffer_size_callback;
+    ma_jack_on_shutdown_proc              _jack_on_shutdown              = jack_on_shutdown;
+    ma_jack_get_sample_rate_proc          _jack_get_sample_rate          = jack_get_sample_rate;
+    ma_jack_get_buffer_size_proc          _jack_get_buffer_size          = jack_get_buffer_size;
+    ma_jack_get_ports_proc                _jack_get_ports                = jack_get_ports;
+    ma_jack_activate_proc                 _jack_activate                 = jack_activate;
+    ma_jack_deactivate_proc               _jack_deactivate               = jack_deactivate;
+    ma_jack_connect_proc                  _jack_connect                  = jack_connect;
+    ma_jack_port_register_proc            _jack_port_register            = jack_port_register;
+    ma_jack_port_name_proc                _jack_port_name                = jack_port_name;
+    ma_jack_port_get_buffer_proc          _jack_port_get_buffer          = jack_port_get_buffer;
+    ma_jack_free_proc                     _jack_free                     = jack_free;
+
+    pContext->jack.jack_client_open              = (ma_proc)_jack_client_open;
+    pContext->jack.jack_client_close             = (ma_proc)_jack_client_close;
+    pContext->jack.jack_client_name_size         = (ma_proc)_jack_client_name_size;
+    pContext->jack.jack_set_process_callback     = (ma_proc)_jack_set_process_callback;
+    pContext->jack.jack_set_buffer_size_callback = (ma_proc)_jack_set_buffer_size_callback;
+    pContext->jack.jack_on_shutdown              = (ma_proc)_jack_on_shutdown;
+    pContext->jack.jack_get_sample_rate          = (ma_proc)_jack_get_sample_rate;
+    pContext->jack.jack_get_buffer_size          = (ma_proc)_jack_get_buffer_size;
+    pContext->jack.jack_get_ports                = (ma_proc)_jack_get_ports;
+    pContext->jack.jack_activate                 = (ma_proc)_jack_activate;
+    pContext->jack.jack_deactivate               = (ma_proc)_jack_deactivate;
+    pContext->jack.jack_connect                  = (ma_proc)_jack_connect;
+    pContext->jack.jack_port_register            = (ma_proc)_jack_port_register;
+    pContext->jack.jack_port_name                = (ma_proc)_jack_port_name;
+    pContext->jack.jack_port_get_buffer          = (ma_proc)_jack_port_get_buffer;
+    pContext->jack.jack_free                     = (ma_proc)_jack_free;
+#endif
+
+    if (pConfig->jack.pClientName != NULL) {
+        pContext->jack.pClientName = ma_copy_string(pConfig->jack.pClientName, &pContext->allocationCallbacks);
+    }
+    pContext->jack.tryStartServer = pConfig->jack.tryStartServer;
+
+    /*
+    Getting here means the JACK library is installed, but it doesn't necessarily mean it's usable. We need to quickly test this by connecting
+    a temporary client.
+    */
+    {
+        ma_jack_client_t* pDummyClient;
+        ma_result result = ma_context_open_client__jack(pContext, &pDummyClient);
+        if (result != MA_SUCCESS) {
+            ma_free(pContext->jack.pClientName, &pContext->allocationCallbacks);
+        #ifndef MA_NO_RUNTIME_LINKING
+            ma_dlclose(ma_context_get_log(pContext), pContext->jack.jackSO);
+        #endif
+            return MA_NO_BACKEND;
+        }
+
+        ((ma_jack_client_close_proc)pContext->jack.jack_client_close)((ma_jack_client_t*)pDummyClient);
+    }
+
+
+    pCallbacks->onContextInit             = ma_context_init__jack;
+    pCallbacks->onContextUninit           = ma_context_uninit__jack;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__jack;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__jack;
+    pCallbacks->onDeviceInit              = ma_device_init__jack;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__jack;
+    pCallbacks->onDeviceStart             = ma_device_start__jack;
+    pCallbacks->onDeviceStop              = ma_device_stop__jack;
+    pCallbacks->onDeviceRead              = NULL;   /* Not used because JACK is asynchronous. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not used because JACK is asynchronous. */
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Not used because JACK is asynchronous. */
+
+    return MA_SUCCESS;
+}
+#endif  /* MA_HAS_JACK */
+
+
+
+/******************************************************************************
+
+Core Audio Backend
+
+References
+==========
+- Technical Note TN2091: Device input using the HAL Output Audio Unit
+    https://developer.apple.com/library/archive/technotes/tn2091/_index.html
+
+******************************************************************************/
+#ifdef MA_HAS_COREAUDIO
+#include <TargetConditionals.h>
+
+#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1
+    #define MA_APPLE_MOBILE
+    #if defined(TARGET_OS_TV) && TARGET_OS_TV == 1
+        #define MA_APPLE_TV
+    #endif
+    #if defined(TARGET_OS_WATCH) && TARGET_OS_WATCH == 1
+        #define MA_APPLE_WATCH
+    #endif
+    #if __has_feature(objc_arc)
+        #define MA_BRIDGE_TRANSFER  __bridge_transfer
+        #define MA_BRIDGE_RETAINED  __bridge_retained
+    #else
+        #define MA_BRIDGE_TRANSFER
+        #define MA_BRIDGE_RETAINED
+    #endif
+#else
+    #define MA_APPLE_DESKTOP
+#endif
+
+#if defined(MA_APPLE_DESKTOP)
+#include <CoreAudio/CoreAudio.h>
+#else
+#include <AVFoundation/AVFoundation.h>
+#endif
+
+#include <AudioToolbox/AudioToolbox.h>
+
+/* CoreFoundation */
+typedef Boolean (* ma_CFStringGetCString_proc)(CFStringRef theString, char* buffer, CFIndex bufferSize, CFStringEncoding encoding);
+typedef void (* ma_CFRelease_proc)(CFTypeRef cf);
+
+/* CoreAudio */
+#if defined(MA_APPLE_DESKTOP)
+typedef OSStatus (* ma_AudioObjectGetPropertyData_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* ioDataSize, void* outData);
+typedef OSStatus (* ma_AudioObjectGetPropertyDataSize_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize);
+typedef OSStatus (* ma_AudioObjectSetPropertyData_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData);
+typedef OSStatus (* ma_AudioObjectAddPropertyListener_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, AudioObjectPropertyListenerProc inListener, void* inClientData);
+typedef OSStatus (* ma_AudioObjectRemovePropertyListener_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, AudioObjectPropertyListenerProc inListener, void* inClientData);
+#endif
+
+/* AudioToolbox */
+typedef AudioComponent (* ma_AudioComponentFindNext_proc)(AudioComponent inComponent, const AudioComponentDescription* inDesc);
+typedef OSStatus (* ma_AudioComponentInstanceDispose_proc)(AudioComponentInstance inInstance);
+typedef OSStatus (* ma_AudioComponentInstanceNew_proc)(AudioComponent inComponent, AudioComponentInstance* outInstance);
+typedef OSStatus (* ma_AudioOutputUnitStart_proc)(AudioUnit inUnit);
+typedef OSStatus (* ma_AudioOutputUnitStop_proc)(AudioUnit inUnit);
+typedef OSStatus (* ma_AudioUnitAddPropertyListener_proc)(AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitPropertyListenerProc inProc, void* inProcUserData);
+typedef OSStatus (* ma_AudioUnitGetPropertyInfo_proc)(AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitScope inScope, AudioUnitElement inElement, UInt32* outDataSize, Boolean* outWriteable);
+typedef OSStatus (* ma_AudioUnitGetProperty_proc)(AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitScope inScope, AudioUnitElement inElement, void* outData, UInt32* ioDataSize);
+typedef OSStatus (* ma_AudioUnitSetProperty_proc)(AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitScope inScope, AudioUnitElement inElement, const void* inData, UInt32 inDataSize);
+typedef OSStatus (* ma_AudioUnitInitialize_proc)(AudioUnit inUnit);
+typedef OSStatus (* ma_AudioUnitRender_proc)(AudioUnit inUnit, AudioUnitRenderActionFlags* ioActionFlags, const AudioTimeStamp* inTimeStamp, UInt32 inOutputBusNumber, UInt32 inNumberFrames, AudioBufferList* ioData);
+
+
+#define MA_COREAUDIO_OUTPUT_BUS    0
+#define MA_COREAUDIO_INPUT_BUS     1
+
+#if defined(MA_APPLE_DESKTOP)
+static ma_result ma_device_reinit_internal__coreaudio(ma_device* pDevice, ma_device_type deviceType, ma_bool32 disposePreviousAudioUnit);
+#endif
+
+/*
+Core Audio
+
+So far, Core Audio has been the worst backend to work with due to being both unintuitive and having almost no documentation
+apart from comments in the headers (which admittedly are quite good). For my own purposes, and for anybody out there whose
+needing to figure out how this darn thing works, I'm going to outline a few things here.
+
+Since miniaudio is a fairly low-level API, one of the things it needs is control over specific devices, and it needs to be
+able to identify whether or not it can be used as playback and/or capture. The AudioObject API is the only one I've seen
+that supports this level of detail. There was some public domain sample code I stumbled across that used the AudioComponent
+and AudioUnit APIs, but I couldn't see anything that gave low-level control over device selection and capabilities (the
+distinction between playback and capture in particular). Therefore, miniaudio is using the AudioObject API.
+
+Most (all?) functions in the AudioObject API take a AudioObjectID as its input. This is the device identifier. When
+retrieving global information, such as the device list, you use kAudioObjectSystemObject. When retrieving device-specific
+data, you pass in the ID for that device. In order to retrieve device-specific IDs you need to enumerate over each of the
+devices. This is done using the AudioObjectGetPropertyDataSize() and AudioObjectGetPropertyData() APIs which seem to be
+the central APIs for retrieving information about the system and specific devices.
+
+To use the AudioObjectGetPropertyData() API you need to use the notion of a property address. A property address is a
+structure with three variables and is used to identify which property you are getting or setting. The first is the "selector"
+which is basically the specific property that you're wanting to retrieve or set. The second is the "scope", which is
+typically set to kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyScopeInput for input-specific properties and
+kAudioObjectPropertyScopeOutput for output-specific properties. The last is the "element" which is always set to
+kAudioObjectPropertyElementMain in miniaudio's case. I don't know of any cases where this would be set to anything different.
+
+Back to the earlier issue of device retrieval, you first use the AudioObjectGetPropertyDataSize() API to retrieve the size
+of the raw data which is just a list of AudioDeviceID's. You use the kAudioObjectSystemObject AudioObjectID, and a property
+address with the kAudioHardwarePropertyDevices selector and the kAudioObjectPropertyScopeGlobal scope. Once you have the
+size, allocate a block of memory of that size and then call AudioObjectGetPropertyData(). The data is just a list of
+AudioDeviceID's so just do "dataSize/sizeof(AudioDeviceID)" to know the device count.
+*/
+
+#if defined(MA_APPLE_MOBILE)
+static void ma_device__on_notification_interruption_began(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_interruption_began));
+}
+
+static void ma_device__on_notification_interruption_ended(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_interruption_ended));
+}
+#endif
+
+static ma_result ma_result_from_OSStatus(OSStatus status)
+{
+    switch (status)
+    {
+        case noErr:                                   return MA_SUCCESS;
+    #if defined(MA_APPLE_DESKTOP)
+        case kAudioHardwareNotRunningError:           return MA_DEVICE_NOT_STARTED;
+        case kAudioHardwareUnspecifiedError:          return MA_ERROR;
+        case kAudioHardwareUnknownPropertyError:      return MA_INVALID_ARGS;
+        case kAudioHardwareBadPropertySizeError:      return MA_INVALID_OPERATION;
+        case kAudioHardwareIllegalOperationError:     return MA_INVALID_OPERATION;
+        case kAudioHardwareBadObjectError:            return MA_INVALID_ARGS;
+        case kAudioHardwareBadDeviceError:            return MA_INVALID_ARGS;
+        case kAudioHardwareBadStreamError:            return MA_INVALID_ARGS;
+        case kAudioHardwareUnsupportedOperationError: return MA_INVALID_OPERATION;
+        case kAudioDeviceUnsupportedFormatError:      return MA_FORMAT_NOT_SUPPORTED;
+        case kAudioDevicePermissionsError:            return MA_ACCESS_DENIED;
+    #endif
+        default:                                      return MA_ERROR;
+    }
+}
+
+#if 0
+static ma_channel ma_channel_from_AudioChannelBitmap(AudioChannelBitmap bit)
+{
+    switch (bit)
+    {
+        case kAudioChannelBit_Left:                 return MA_CHANNEL_LEFT;
+        case kAudioChannelBit_Right:                return MA_CHANNEL_RIGHT;
+        case kAudioChannelBit_Center:               return MA_CHANNEL_FRONT_CENTER;
+        case kAudioChannelBit_LFEScreen:            return MA_CHANNEL_LFE;
+        case kAudioChannelBit_LeftSurround:         return MA_CHANNEL_BACK_LEFT;
+        case kAudioChannelBit_RightSurround:        return MA_CHANNEL_BACK_RIGHT;
+        case kAudioChannelBit_LeftCenter:           return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case kAudioChannelBit_RightCenter:          return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case kAudioChannelBit_CenterSurround:       return MA_CHANNEL_BACK_CENTER;
+        case kAudioChannelBit_LeftSurroundDirect:   return MA_CHANNEL_SIDE_LEFT;
+        case kAudioChannelBit_RightSurroundDirect:  return MA_CHANNEL_SIDE_RIGHT;
+        case kAudioChannelBit_TopCenterSurround:    return MA_CHANNEL_TOP_CENTER;
+        case kAudioChannelBit_VerticalHeightLeft:   return MA_CHANNEL_TOP_FRONT_LEFT;
+        case kAudioChannelBit_VerticalHeightCenter: return MA_CHANNEL_TOP_FRONT_CENTER;
+        case kAudioChannelBit_VerticalHeightRight:  return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case kAudioChannelBit_TopBackLeft:          return MA_CHANNEL_TOP_BACK_LEFT;
+        case kAudioChannelBit_TopBackCenter:        return MA_CHANNEL_TOP_BACK_CENTER;
+        case kAudioChannelBit_TopBackRight:         return MA_CHANNEL_TOP_BACK_RIGHT;
+        default:                                    return MA_CHANNEL_NONE;
+    }
+}
+#endif
+
+static ma_result ma_format_from_AudioStreamBasicDescription(const AudioStreamBasicDescription* pDescription, ma_format* pFormatOut)
+{
+    MA_ASSERT(pDescription != NULL);
+    MA_ASSERT(pFormatOut != NULL);
+
+    *pFormatOut = ma_format_unknown;   /* Safety. */
+
+    /* There's a few things miniaudio doesn't support. */
+    if (pDescription->mFormatID != kAudioFormatLinearPCM) {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    /* We don't support any non-packed formats that are aligned high. */
+    if ((pDescription->mFormatFlags & kLinearPCMFormatFlagIsAlignedHigh) != 0) {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    /* Only supporting native-endian. */
+    if ((ma_is_little_endian() && (pDescription->mFormatFlags & kAudioFormatFlagIsBigEndian) != 0) || (ma_is_big_endian() && (pDescription->mFormatFlags & kAudioFormatFlagIsBigEndian) == 0)) {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    /* We are not currently supporting non-interleaved formats (this will be added in a future version of miniaudio). */
+    /*if ((pDescription->mFormatFlags & kAudioFormatFlagIsNonInterleaved) != 0) {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }*/
+
+    if ((pDescription->mFormatFlags & kLinearPCMFormatFlagIsFloat) != 0) {
+        if (pDescription->mBitsPerChannel == 32) {
+            *pFormatOut = ma_format_f32;
+            return MA_SUCCESS;
+        }
+    } else {
+        if ((pDescription->mFormatFlags & kLinearPCMFormatFlagIsSignedInteger) != 0) {
+            if (pDescription->mBitsPerChannel == 16) {
+                *pFormatOut = ma_format_s16;
+                return MA_SUCCESS;
+            } else if (pDescription->mBitsPerChannel == 24) {
+                if (pDescription->mBytesPerFrame == (pDescription->mBitsPerChannel/8 * pDescription->mChannelsPerFrame)) {
+                    *pFormatOut = ma_format_s24;
+                    return MA_SUCCESS;
+                } else {
+                    if (pDescription->mBytesPerFrame/pDescription->mChannelsPerFrame == sizeof(ma_int32)) {
+                        /* TODO: Implement ma_format_s24_32. */
+                        /**pFormatOut = ma_format_s24_32;*/
+                        /*return MA_SUCCESS;*/
+                        return MA_FORMAT_NOT_SUPPORTED;
+                    }
+                }
+            } else if (pDescription->mBitsPerChannel == 32) {
+                *pFormatOut = ma_format_s32;
+                return MA_SUCCESS;
+            }
+        } else {
+            if (pDescription->mBitsPerChannel == 8) {
+                *pFormatOut = ma_format_u8;
+                return MA_SUCCESS;
+            }
+        }
+    }
+
+    /* Getting here means the format is not supported. */
+    return MA_FORMAT_NOT_SUPPORTED;
+}
+
+#if defined(MA_APPLE_DESKTOP)
+static ma_channel ma_channel_from_AudioChannelLabel(AudioChannelLabel label)
+{
+    switch (label)
+    {
+        case kAudioChannelLabel_Unknown:              return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Unused:               return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_UseCoordinates:       return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Left:                 return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_Right:                return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_Center:               return MA_CHANNEL_FRONT_CENTER;
+        case kAudioChannelLabel_LFEScreen:            return MA_CHANNEL_LFE;
+        case kAudioChannelLabel_LeftSurround:         return MA_CHANNEL_BACK_LEFT;
+        case kAudioChannelLabel_RightSurround:        return MA_CHANNEL_BACK_RIGHT;
+        case kAudioChannelLabel_LeftCenter:           return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case kAudioChannelLabel_RightCenter:          return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case kAudioChannelLabel_CenterSurround:       return MA_CHANNEL_BACK_CENTER;
+        case kAudioChannelLabel_LeftSurroundDirect:   return MA_CHANNEL_SIDE_LEFT;
+        case kAudioChannelLabel_RightSurroundDirect:  return MA_CHANNEL_SIDE_RIGHT;
+        case kAudioChannelLabel_TopCenterSurround:    return MA_CHANNEL_TOP_CENTER;
+        case kAudioChannelLabel_VerticalHeightLeft:   return MA_CHANNEL_TOP_FRONT_LEFT;
+        case kAudioChannelLabel_VerticalHeightCenter: return MA_CHANNEL_TOP_FRONT_CENTER;
+        case kAudioChannelLabel_VerticalHeightRight:  return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case kAudioChannelLabel_TopBackLeft:          return MA_CHANNEL_TOP_BACK_LEFT;
+        case kAudioChannelLabel_TopBackCenter:        return MA_CHANNEL_TOP_BACK_CENTER;
+        case kAudioChannelLabel_TopBackRight:         return MA_CHANNEL_TOP_BACK_RIGHT;
+        case kAudioChannelLabel_RearSurroundLeft:     return MA_CHANNEL_BACK_LEFT;
+        case kAudioChannelLabel_RearSurroundRight:    return MA_CHANNEL_BACK_RIGHT;
+        case kAudioChannelLabel_LeftWide:             return MA_CHANNEL_SIDE_LEFT;
+        case kAudioChannelLabel_RightWide:            return MA_CHANNEL_SIDE_RIGHT;
+        case kAudioChannelLabel_LFE2:                 return MA_CHANNEL_LFE;
+        case kAudioChannelLabel_LeftTotal:            return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_RightTotal:           return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_HearingImpaired:      return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Narration:            return MA_CHANNEL_MONO;
+        case kAudioChannelLabel_Mono:                 return MA_CHANNEL_MONO;
+        case kAudioChannelLabel_DialogCentricMix:     return MA_CHANNEL_MONO;
+        case kAudioChannelLabel_CenterSurroundDirect: return MA_CHANNEL_BACK_CENTER;
+        case kAudioChannelLabel_Haptic:               return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Ambisonic_W:          return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Ambisonic_X:          return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Ambisonic_Y:          return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Ambisonic_Z:          return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_MS_Mid:               return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_MS_Side:              return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_XY_X:                 return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_XY_Y:                 return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_HeadphonesLeft:       return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_HeadphonesRight:      return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_ClickTrack:           return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_ForeignLanguage:      return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Discrete:             return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Discrete_0:           return MA_CHANNEL_AUX_0;
+        case kAudioChannelLabel_Discrete_1:           return MA_CHANNEL_AUX_1;
+        case kAudioChannelLabel_Discrete_2:           return MA_CHANNEL_AUX_2;
+        case kAudioChannelLabel_Discrete_3:           return MA_CHANNEL_AUX_3;
+        case kAudioChannelLabel_Discrete_4:           return MA_CHANNEL_AUX_4;
+        case kAudioChannelLabel_Discrete_5:           return MA_CHANNEL_AUX_5;
+        case kAudioChannelLabel_Discrete_6:           return MA_CHANNEL_AUX_6;
+        case kAudioChannelLabel_Discrete_7:           return MA_CHANNEL_AUX_7;
+        case kAudioChannelLabel_Discrete_8:           return MA_CHANNEL_AUX_8;
+        case kAudioChannelLabel_Discrete_9:           return MA_CHANNEL_AUX_9;
+        case kAudioChannelLabel_Discrete_10:          return MA_CHANNEL_AUX_10;
+        case kAudioChannelLabel_Discrete_11:          return MA_CHANNEL_AUX_11;
+        case kAudioChannelLabel_Discrete_12:          return MA_CHANNEL_AUX_12;
+        case kAudioChannelLabel_Discrete_13:          return MA_CHANNEL_AUX_13;
+        case kAudioChannelLabel_Discrete_14:          return MA_CHANNEL_AUX_14;
+        case kAudioChannelLabel_Discrete_15:          return MA_CHANNEL_AUX_15;
+        case kAudioChannelLabel_Discrete_65535:       return MA_CHANNEL_NONE;
+
+    #if 0   /* Introduced in a later version of macOS. */
+        case kAudioChannelLabel_HOA_ACN:              return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_HOA_ACN_0:            return MA_CHANNEL_AUX_0;
+        case kAudioChannelLabel_HOA_ACN_1:            return MA_CHANNEL_AUX_1;
+        case kAudioChannelLabel_HOA_ACN_2:            return MA_CHANNEL_AUX_2;
+        case kAudioChannelLabel_HOA_ACN_3:            return MA_CHANNEL_AUX_3;
+        case kAudioChannelLabel_HOA_ACN_4:            return MA_CHANNEL_AUX_4;
+        case kAudioChannelLabel_HOA_ACN_5:            return MA_CHANNEL_AUX_5;
+        case kAudioChannelLabel_HOA_ACN_6:            return MA_CHANNEL_AUX_6;
+        case kAudioChannelLabel_HOA_ACN_7:            return MA_CHANNEL_AUX_7;
+        case kAudioChannelLabel_HOA_ACN_8:            return MA_CHANNEL_AUX_8;
+        case kAudioChannelLabel_HOA_ACN_9:            return MA_CHANNEL_AUX_9;
+        case kAudioChannelLabel_HOA_ACN_10:           return MA_CHANNEL_AUX_10;
+        case kAudioChannelLabel_HOA_ACN_11:           return MA_CHANNEL_AUX_11;
+        case kAudioChannelLabel_HOA_ACN_12:           return MA_CHANNEL_AUX_12;
+        case kAudioChannelLabel_HOA_ACN_13:           return MA_CHANNEL_AUX_13;
+        case kAudioChannelLabel_HOA_ACN_14:           return MA_CHANNEL_AUX_14;
+        case kAudioChannelLabel_HOA_ACN_15:           return MA_CHANNEL_AUX_15;
+        case kAudioChannelLabel_HOA_ACN_65024:        return MA_CHANNEL_NONE;
+    #endif
+
+        default:                                      return MA_CHANNEL_NONE;
+    }
+}
+
+static ma_result ma_get_channel_map_from_AudioChannelLayout(AudioChannelLayout* pChannelLayout, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    MA_ASSERT(pChannelLayout != NULL);
+
+    if (pChannelLayout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelDescriptions) {
+        UInt32 iChannel;
+        for (iChannel = 0; iChannel < pChannelLayout->mNumberChannelDescriptions && iChannel < channelMapCap; ++iChannel) {
+            pChannelMap[iChannel] = ma_channel_from_AudioChannelLabel(pChannelLayout->mChannelDescriptions[iChannel].mChannelLabel);
+        }
+    } else
+#if 0
+    if (pChannelLayout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelBitmap) {
+        /* This is the same kind of system that's used by Windows audio APIs. */
+        UInt32 iChannel = 0;
+        UInt32 iBit;
+        AudioChannelBitmap bitmap = pChannelLayout->mChannelBitmap;
+        for (iBit = 0; iBit < 32 && iChannel < channelMapCap; ++iBit) {
+            AudioChannelBitmap bit = bitmap & (1 << iBit);
+            if (bit != 0) {
+                pChannelMap[iChannel++] = ma_channel_from_AudioChannelBit(bit);
+            }
+        }
+    } else
+#endif
+    {
+        /*
+        Need to use the tag to determine the channel map. For now I'm just assuming a default channel map, but later on this should
+        be updated to determine the mapping based on the tag.
+        */
+        UInt32 channelCount;
+
+        /* Our channel map retrieval APIs below take 32-bit integers, so we'll want to clamp the channel map capacity. */
+        if (channelMapCap > 0xFFFFFFFF) {
+            channelMapCap = 0xFFFFFFFF;
+        }
+
+        channelCount = ma_min(AudioChannelLayoutTag_GetNumberOfChannels(pChannelLayout->mChannelLayoutTag), (UInt32)channelMapCap);
+
+        switch (pChannelLayout->mChannelLayoutTag)
+        {
+            case kAudioChannelLayoutTag_Mono:
+            case kAudioChannelLayoutTag_Stereo:
+            case kAudioChannelLayoutTag_StereoHeadphones:
+            case kAudioChannelLayoutTag_MatrixStereo:
+            case kAudioChannelLayoutTag_MidSide:
+            case kAudioChannelLayoutTag_XY:
+            case kAudioChannelLayoutTag_Binaural:
+            case kAudioChannelLayoutTag_Ambisonic_B_Format:
+            {
+                ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, channelCount);
+            } break;
+
+            case kAudioChannelLayoutTag_Octagonal:
+            {
+                pChannelMap[7] = MA_CHANNEL_SIDE_RIGHT;
+                pChannelMap[6] = MA_CHANNEL_SIDE_LEFT;
+            } MA_FALLTHROUGH; /* Intentional fallthrough. */
+            case kAudioChannelLayoutTag_Hexagonal:
+            {
+                pChannelMap[5] = MA_CHANNEL_BACK_CENTER;
+            } MA_FALLTHROUGH; /* Intentional fallthrough. */
+            case kAudioChannelLayoutTag_Pentagonal:
+            {
+                pChannelMap[4] = MA_CHANNEL_FRONT_CENTER;
+            } MA_FALLTHROUGH; /* Intentional fallthrough. */
+            case kAudioChannelLayoutTag_Quadraphonic:
+            {
+                pChannelMap[3] = MA_CHANNEL_BACK_RIGHT;
+                pChannelMap[2] = MA_CHANNEL_BACK_LEFT;
+                pChannelMap[1] = MA_CHANNEL_RIGHT;
+                pChannelMap[0] = MA_CHANNEL_LEFT;
+            } break;
+
+            /* TODO: Add support for more tags here. */
+
+            default:
+            {
+                ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, channelCount);
+            } break;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+#if (defined(MAC_OS_VERSION_12_0) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_VERSION_12_0) || \
+    (defined(__IPHONE_15_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_15_0)
+#define AUDIO_OBJECT_PROPERTY_ELEMENT kAudioObjectPropertyElementMain
+#else
+/* kAudioObjectPropertyElementMaster is deprecated. */
+#define AUDIO_OBJECT_PROPERTY_ELEMENT kAudioObjectPropertyElementMaster
+#endif
+
+/* kAudioDevicePropertyScope* were renamed to kAudioObjectPropertyScope* in 10.8. */
+#if !defined(MAC_OS_X_VERSION_10_8) || (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_8)
+#define kAudioObjectPropertyScopeInput kAudioDevicePropertyScopeInput
+#define kAudioObjectPropertyScopeOutput kAudioDevicePropertyScopeOutput
+#endif
+
+static ma_result ma_get_device_object_ids__coreaudio(ma_context* pContext, UInt32* pDeviceCount, AudioObjectID** ppDeviceObjectIDs) /* NOTE: Free the returned buffer with ma_free(). */
+{
+    AudioObjectPropertyAddress propAddressDevices;
+    UInt32 deviceObjectsDataSize;
+    OSStatus status;
+    AudioObjectID* pDeviceObjectIDs;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDeviceCount != NULL);
+    MA_ASSERT(ppDeviceObjectIDs != NULL);
+
+    /* Safety. */
+    *pDeviceCount = 0;
+    *ppDeviceObjectIDs = NULL;
+
+    propAddressDevices.mSelector = kAudioHardwarePropertyDevices;
+    propAddressDevices.mScope    = kAudioObjectPropertyScopeGlobal;
+    propAddressDevices.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(kAudioObjectSystemObject, &propAddressDevices, 0, NULL, &deviceObjectsDataSize);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pDeviceObjectIDs = (AudioObjectID*)ma_malloc(deviceObjectsDataSize, &pContext->allocationCallbacks);
+    if (pDeviceObjectIDs == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(kAudioObjectSystemObject, &propAddressDevices, 0, NULL, &deviceObjectsDataSize, pDeviceObjectIDs);
+    if (status != noErr) {
+        ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    *pDeviceCount = deviceObjectsDataSize / sizeof(AudioObjectID);
+    *ppDeviceObjectIDs = pDeviceObjectIDs;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioObject_uid_as_CFStringRef(ma_context* pContext, AudioObjectID objectID, CFStringRef* pUID)
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+
+    propAddress.mSelector = kAudioDevicePropertyDeviceUID;
+    propAddress.mScope    = kAudioObjectPropertyScopeGlobal;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    dataSize = sizeof(*pUID);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(objectID, &propAddress, 0, NULL, &dataSize, pUID);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioObject_uid(ma_context* pContext, AudioObjectID objectID, size_t bufferSize, char* bufferOut)
+{
+    CFStringRef uid;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    result = ma_get_AudioObject_uid_as_CFStringRef(pContext, objectID, &uid);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (!((ma_CFStringGetCString_proc)pContext->coreaudio.CFStringGetCString)(uid, bufferOut, bufferSize, kCFStringEncodingUTF8)) {
+        return MA_ERROR;
+    }
+
+    ((ma_CFRelease_proc)pContext->coreaudio.CFRelease)(uid);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioObject_name(ma_context* pContext, AudioObjectID objectID, size_t bufferSize, char* bufferOut)
+{
+    AudioObjectPropertyAddress propAddress;
+    CFStringRef deviceName = NULL;
+    UInt32 dataSize;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+
+    propAddress.mSelector = kAudioDevicePropertyDeviceNameCFString;
+    propAddress.mScope    = kAudioObjectPropertyScopeGlobal;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    dataSize = sizeof(deviceName);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(objectID, &propAddress, 0, NULL, &dataSize, &deviceName);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    if (!((ma_CFStringGetCString_proc)pContext->coreaudio.CFStringGetCString)(deviceName, bufferOut, bufferSize, kCFStringEncodingUTF8)) {
+        return MA_ERROR;
+    }
+
+    ((ma_CFRelease_proc)pContext->coreaudio.CFRelease)(deviceName);
+    return MA_SUCCESS;
+}
+
+static ma_bool32 ma_does_AudioObject_support_scope(ma_context* pContext, AudioObjectID deviceObjectID, AudioObjectPropertyScope scope)
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+    AudioBufferList* pBufferList;
+    ma_bool32 isSupported;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* To know whether or not a device is an input device we need ot look at the stream configuration. If it has an output channel it's a playback device. */
+    propAddress.mSelector = kAudioDevicePropertyStreamConfiguration;
+    propAddress.mScope    = scope;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(deviceObjectID, &propAddress, 0, NULL, &dataSize);
+    if (status != noErr) {
+        return MA_FALSE;
+    }
+
+    pBufferList = (AudioBufferList*)ma_malloc(dataSize, &pContext->allocationCallbacks);
+    if (pBufferList == NULL) {
+        return MA_FALSE;   /* Out of memory. */
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, pBufferList);
+    if (status != noErr) {
+        ma_free(pBufferList, &pContext->allocationCallbacks);
+        return MA_FALSE;
+    }
+
+    isSupported = MA_FALSE;
+    if (pBufferList->mNumberBuffers > 0) {
+        isSupported = MA_TRUE;
+    }
+
+    ma_free(pBufferList, &pContext->allocationCallbacks);
+    return isSupported;
+}
+
+static ma_bool32 ma_does_AudioObject_support_playback(ma_context* pContext, AudioObjectID deviceObjectID)
+{
+    return ma_does_AudioObject_support_scope(pContext, deviceObjectID, kAudioObjectPropertyScopeOutput);
+}
+
+static ma_bool32 ma_does_AudioObject_support_capture(ma_context* pContext, AudioObjectID deviceObjectID)
+{
+    return ma_does_AudioObject_support_scope(pContext, deviceObjectID, kAudioObjectPropertyScopeInput);
+}
+
+
+static ma_result ma_get_AudioObject_stream_descriptions(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, UInt32* pDescriptionCount, AudioStreamRangedDescription** ppDescriptions) /* NOTE: Free the returned pointer with ma_free(). */
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+    AudioStreamRangedDescription* pDescriptions;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDescriptionCount != NULL);
+    MA_ASSERT(ppDescriptions != NULL);
+
+    /*
+    TODO: Experiment with kAudioStreamPropertyAvailablePhysicalFormats instead of (or in addition to) kAudioStreamPropertyAvailableVirtualFormats. My
+          MacBook Pro uses s24/32 format, however, which miniaudio does not currently support.
+    */
+    propAddress.mSelector = kAudioStreamPropertyAvailableVirtualFormats; /*kAudioStreamPropertyAvailablePhysicalFormats;*/
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(deviceObjectID, &propAddress, 0, NULL, &dataSize);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pDescriptions = (AudioStreamRangedDescription*)ma_malloc(dataSize, &pContext->allocationCallbacks);
+    if (pDescriptions == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, pDescriptions);
+    if (status != noErr) {
+        ma_free(pDescriptions, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    *pDescriptionCount = dataSize / sizeof(*pDescriptions);
+    *ppDescriptions = pDescriptions;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_get_AudioObject_channel_layout(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, AudioChannelLayout** ppChannelLayout)   /* NOTE: Free the returned pointer with ma_free(). */
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+    AudioChannelLayout* pChannelLayout;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppChannelLayout != NULL);
+
+    *ppChannelLayout = NULL;    /* Safety. */
+
+    propAddress.mSelector = kAudioDevicePropertyPreferredChannelLayout;
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(deviceObjectID, &propAddress, 0, NULL, &dataSize);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pChannelLayout = (AudioChannelLayout*)ma_malloc(dataSize, &pContext->allocationCallbacks);
+    if (pChannelLayout == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, pChannelLayout);
+    if (status != noErr) {
+        ma_free(pChannelLayout, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    *ppChannelLayout = pChannelLayout;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioObject_channel_count(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_uint32* pChannelCount)
+{
+    AudioChannelLayout* pChannelLayout;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pChannelCount != NULL);
+
+    *pChannelCount = 0; /* Safety. */
+
+    result = ma_get_AudioObject_channel_layout(pContext, deviceObjectID, deviceType, &pChannelLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pChannelLayout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelDescriptions) {
+        *pChannelCount = pChannelLayout->mNumberChannelDescriptions;
+    } else if (pChannelLayout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelBitmap) {
+        *pChannelCount = ma_count_set_bits(pChannelLayout->mChannelBitmap);
+    } else {
+        *pChannelCount = AudioChannelLayoutTag_GetNumberOfChannels(pChannelLayout->mChannelLayoutTag);
+    }
+
+    ma_free(pChannelLayout, &pContext->allocationCallbacks);
+    return MA_SUCCESS;
+}
+
+#if 0
+static ma_result ma_get_AudioObject_channel_map(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    AudioChannelLayout* pChannelLayout;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    result = ma_get_AudioObject_channel_layout(pContext, deviceObjectID, deviceType, &pChannelLayout);
+    if (result != MA_SUCCESS) {
+        return result;  /* Rather than always failing here, would it be more robust to simply assume a default? */
+    }
+
+    result = ma_get_channel_map_from_AudioChannelLayout(pChannelLayout, pChannelMap, channelMapCap);
+    if (result != MA_SUCCESS) {
+        ma_free(pChannelLayout, &pContext->allocationCallbacks);
+        return result;
+    }
+
+    ma_free(pChannelLayout, &pContext->allocationCallbacks);
+    return result;
+}
+#endif
+
+static ma_result ma_get_AudioObject_sample_rates(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, UInt32* pSampleRateRangesCount, AudioValueRange** ppSampleRateRanges)   /* NOTE: Free the returned pointer with ma_free(). */
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+    AudioValueRange* pSampleRateRanges;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pSampleRateRangesCount != NULL);
+    MA_ASSERT(ppSampleRateRanges != NULL);
+
+    /* Safety. */
+    *pSampleRateRangesCount = 0;
+    *ppSampleRateRanges = NULL;
+
+    propAddress.mSelector = kAudioDevicePropertyAvailableNominalSampleRates;
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(deviceObjectID, &propAddress, 0, NULL, &dataSize);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pSampleRateRanges = (AudioValueRange*)ma_malloc(dataSize, &pContext->allocationCallbacks);
+    if (pSampleRateRanges == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, pSampleRateRanges);
+    if (status != noErr) {
+        ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    *pSampleRateRangesCount = dataSize / sizeof(*pSampleRateRanges);
+    *ppSampleRateRanges = pSampleRateRanges;
+    return MA_SUCCESS;
+}
+
+#if 0
+static ma_result ma_get_AudioObject_get_closest_sample_rate(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_uint32 sampleRateIn, ma_uint32* pSampleRateOut)
+{
+    UInt32 sampleRateRangeCount;
+    AudioValueRange* pSampleRateRanges;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pSampleRateOut != NULL);
+
+    *pSampleRateOut = 0;    /* Safety. */
+
+    result = ma_get_AudioObject_sample_rates(pContext, deviceObjectID, deviceType, &sampleRateRangeCount, &pSampleRateRanges);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (sampleRateRangeCount == 0) {
+        ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+        return MA_ERROR;   /* Should never hit this case should we? */
+    }
+
+    if (sampleRateIn == 0) {
+        /* Search in order of miniaudio's preferred priority. */
+        UInt32 iMALSampleRate;
+        for (iMALSampleRate = 0; iMALSampleRate < ma_countof(g_maStandardSampleRatePriorities); ++iMALSampleRate) {
+            ma_uint32 malSampleRate = g_maStandardSampleRatePriorities[iMALSampleRate];
+            UInt32 iCASampleRate;
+            for (iCASampleRate = 0; iCASampleRate < sampleRateRangeCount; ++iCASampleRate) {
+                AudioValueRange caSampleRate = pSampleRateRanges[iCASampleRate];
+                if (caSampleRate.mMinimum <= malSampleRate && caSampleRate.mMaximum >= malSampleRate) {
+                    *pSampleRateOut = malSampleRate;
+                    ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+                    return MA_SUCCESS;
+                }
+            }
+        }
+
+        /*
+        If we get here it means none of miniaudio's standard sample rates matched any of the supported sample rates from the device. In this
+        case we just fall back to the first one reported by Core Audio.
+        */
+        MA_ASSERT(sampleRateRangeCount > 0);
+
+        *pSampleRateOut = pSampleRateRanges[0].mMinimum;
+        ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+        return MA_SUCCESS;
+    } else {
+        /* Find the closest match to this sample rate. */
+        UInt32 currentAbsoluteDifference = INT32_MAX;
+        UInt32 iCurrentClosestRange = (UInt32)-1;
+        UInt32 iRange;
+        for (iRange = 0; iRange < sampleRateRangeCount; ++iRange) {
+            if (pSampleRateRanges[iRange].mMinimum <= sampleRateIn && pSampleRateRanges[iRange].mMaximum >= sampleRateIn) {
+                *pSampleRateOut = sampleRateIn;
+                ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+                return MA_SUCCESS;
+            } else {
+                UInt32 absoluteDifference;
+                if (pSampleRateRanges[iRange].mMinimum > sampleRateIn) {
+                    absoluteDifference = pSampleRateRanges[iRange].mMinimum - sampleRateIn;
+                } else {
+                    absoluteDifference = sampleRateIn - pSampleRateRanges[iRange].mMaximum;
+                }
+
+                if (currentAbsoluteDifference > absoluteDifference) {
+                    currentAbsoluteDifference = absoluteDifference;
+                    iCurrentClosestRange = iRange;
+                }
+            }
+        }
+
+        MA_ASSERT(iCurrentClosestRange != (UInt32)-1);
+
+        *pSampleRateOut = pSampleRateRanges[iCurrentClosestRange].mMinimum;
+        ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+        return MA_SUCCESS;
+    }
+
+    /* Should never get here, but it would mean we weren't able to find any suitable sample rates. */
+    /*ma_free(pSampleRateRanges, &pContext->allocationCallbacks);*/
+    /*return MA_ERROR;*/
+}
+#endif
+
+static ma_result ma_get_AudioObject_closest_buffer_size_in_frames(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_uint32 bufferSizeInFramesIn, ma_uint32* pBufferSizeInFramesOut)
+{
+    AudioObjectPropertyAddress propAddress;
+    AudioValueRange bufferSizeRange;
+    UInt32 dataSize;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pBufferSizeInFramesOut != NULL);
+
+    *pBufferSizeInFramesOut = 0;    /* Safety. */
+
+    propAddress.mSelector = kAudioDevicePropertyBufferFrameSizeRange;
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    dataSize = sizeof(bufferSizeRange);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, &bufferSizeRange);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    /* This is just a clamp. */
+    if (bufferSizeInFramesIn < bufferSizeRange.mMinimum) {
+        *pBufferSizeInFramesOut = (ma_uint32)bufferSizeRange.mMinimum;
+    } else if (bufferSizeInFramesIn > bufferSizeRange.mMaximum) {
+        *pBufferSizeInFramesOut = (ma_uint32)bufferSizeRange.mMaximum;
+    } else {
+        *pBufferSizeInFramesOut = bufferSizeInFramesIn;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_set_AudioObject_buffer_size_in_frames(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_uint32* pPeriodSizeInOut)
+{
+    ma_result result;
+    ma_uint32 chosenBufferSizeInFrames;
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+
+    result = ma_get_AudioObject_closest_buffer_size_in_frames(pContext, deviceObjectID, deviceType, *pPeriodSizeInOut, &chosenBufferSizeInFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Try setting the size of the buffer... If this fails we just use whatever is currently set. */
+    propAddress.mSelector = kAudioDevicePropertyBufferFrameSize;
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    ((ma_AudioObjectSetPropertyData_proc)pContext->coreaudio.AudioObjectSetPropertyData)(deviceObjectID, &propAddress, 0, NULL, sizeof(chosenBufferSizeInFrames), &chosenBufferSizeInFrames);
+
+    /* Get the actual size of the buffer. */
+    dataSize = sizeof(*pPeriodSizeInOut);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, &chosenBufferSizeInFrames);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    *pPeriodSizeInOut = chosenBufferSizeInFrames;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_find_default_AudioObjectID(ma_context* pContext, ma_device_type deviceType, AudioObjectID* pDeviceObjectID)
+{
+    AudioObjectPropertyAddress propAddressDefaultDevice;
+    UInt32 defaultDeviceObjectIDSize = sizeof(AudioObjectID);
+    AudioObjectID defaultDeviceObjectID;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDeviceObjectID != NULL);
+
+    /* Safety. */
+    *pDeviceObjectID = 0;
+
+    propAddressDefaultDevice.mScope = kAudioObjectPropertyScopeGlobal;
+    propAddressDefaultDevice.mElement = AUDIO_OBJECT_PROPERTY_ELEMENT;
+    if (deviceType == ma_device_type_playback) {
+        propAddressDefaultDevice.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
+    } else {
+        propAddressDefaultDevice.mSelector = kAudioHardwarePropertyDefaultInputDevice;
+    }
+
+    defaultDeviceObjectIDSize = sizeof(AudioObjectID);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(kAudioObjectSystemObject, &propAddressDefaultDevice, 0, NULL, &defaultDeviceObjectIDSize, &defaultDeviceObjectID);
+    if (status == noErr) {
+        *pDeviceObjectID = defaultDeviceObjectID;
+        return MA_SUCCESS;
+    }
+
+    /* If we get here it means we couldn't find the device. */
+    return MA_NO_DEVICE;
+}
+
+static ma_result ma_find_AudioObjectID(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, AudioObjectID* pDeviceObjectID)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDeviceObjectID != NULL);
+
+    /* Safety. */
+    *pDeviceObjectID = 0;
+
+    if (pDeviceID == NULL) {
+        /* Default device. */
+        return ma_find_default_AudioObjectID(pContext, deviceType, pDeviceObjectID);
+    } else {
+        /* Explicit device. */
+        UInt32 deviceCount;
+        AudioObjectID* pDeviceObjectIDs;
+        ma_result result;
+        UInt32 iDevice;
+
+        result = ma_get_device_object_ids__coreaudio(pContext, &deviceCount, &pDeviceObjectIDs);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        for (iDevice = 0; iDevice < deviceCount; ++iDevice) {
+            AudioObjectID deviceObjectID = pDeviceObjectIDs[iDevice];
+
+            char uid[256];
+            if (ma_get_AudioObject_uid(pContext, deviceObjectID, sizeof(uid), uid) != MA_SUCCESS) {
+                continue;
+            }
+
+            if (deviceType == ma_device_type_playback) {
+                if (ma_does_AudioObject_support_playback(pContext, deviceObjectID)) {
+                    if (strcmp(uid, pDeviceID->coreaudio) == 0) {
+                        *pDeviceObjectID = deviceObjectID;
+                        ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+                        return MA_SUCCESS;
+                    }
+                }
+            } else {
+                if (ma_does_AudioObject_support_capture(pContext, deviceObjectID)) {
+                    if (strcmp(uid, pDeviceID->coreaudio) == 0) {
+                        *pDeviceObjectID = deviceObjectID;
+                        ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+                        return MA_SUCCESS;
+                    }
+                }
+            }
+        }
+
+        ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+    }
+
+    /* If we get here it means we couldn't find the device. */
+    return MA_NO_DEVICE;
+}
+
+
+static ma_result ma_find_best_format__coreaudio(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, const AudioStreamBasicDescription* pOrigFormat, AudioStreamBasicDescription* pFormat)
+{
+    UInt32 deviceFormatDescriptionCount;
+    AudioStreamRangedDescription* pDeviceFormatDescriptions;
+    ma_result result;
+    ma_uint32 desiredSampleRate;
+    ma_uint32 desiredChannelCount;
+    ma_format desiredFormat;
+    AudioStreamBasicDescription bestDeviceFormatSoFar;
+    ma_bool32 hasSupportedFormat;
+    UInt32 iFormat;
+
+    result = ma_get_AudioObject_stream_descriptions(pContext, deviceObjectID, deviceType, &deviceFormatDescriptionCount, &pDeviceFormatDescriptions);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    desiredSampleRate = sampleRate;
+    if (desiredSampleRate == 0) {
+        desiredSampleRate = (ma_uint32)pOrigFormat->mSampleRate;
+    }
+
+    desiredChannelCount = channels;
+    if (desiredChannelCount == 0) {
+        desiredChannelCount = pOrigFormat->mChannelsPerFrame;
+    }
+
+    desiredFormat = format;
+    if (desiredFormat == ma_format_unknown) {
+        result = ma_format_from_AudioStreamBasicDescription(pOrigFormat, &desiredFormat);
+        if (result != MA_SUCCESS || desiredFormat == ma_format_unknown) {
+            desiredFormat = g_maFormatPriorities[0];
+        }
+    }
+
+    /*
+    If we get here it means we don't have an exact match to what the client is asking for. We'll need to find the closest one. The next
+    loop will check for formats that have the same sample rate to what we're asking for. If there is, we prefer that one in all cases.
+    */
+    MA_ZERO_OBJECT(&bestDeviceFormatSoFar);
+
+    hasSupportedFormat = MA_FALSE;
+    for (iFormat = 0; iFormat < deviceFormatDescriptionCount; ++iFormat) {
+        ma_format formatFromDescription;
+        ma_result formatResult = ma_format_from_AudioStreamBasicDescription(&pDeviceFormatDescriptions[iFormat].mFormat, &formatFromDescription);
+        if (formatResult == MA_SUCCESS && formatFromDescription != ma_format_unknown) {
+            hasSupportedFormat = MA_TRUE;
+            bestDeviceFormatSoFar = pDeviceFormatDescriptions[iFormat].mFormat;
+            break;
+        }
+    }
+
+    if (!hasSupportedFormat) {
+        ma_free(pDeviceFormatDescriptions, &pContext->allocationCallbacks);
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+
+    for (iFormat = 0; iFormat < deviceFormatDescriptionCount; ++iFormat) {
+        AudioStreamBasicDescription thisDeviceFormat = pDeviceFormatDescriptions[iFormat].mFormat;
+        ma_format thisSampleFormat;
+        ma_result formatResult;
+        ma_format bestSampleFormatSoFar;
+
+        /* If the format is not supported by miniaudio we need to skip this one entirely. */
+        formatResult = ma_format_from_AudioStreamBasicDescription(&pDeviceFormatDescriptions[iFormat].mFormat, &thisSampleFormat);
+        if (formatResult != MA_SUCCESS || thisSampleFormat == ma_format_unknown) {
+            continue;   /* The format is not supported by miniaudio. Skip. */
+        }
+
+        ma_format_from_AudioStreamBasicDescription(&bestDeviceFormatSoFar, &bestSampleFormatSoFar);
+
+        /* Getting here means the format is supported by miniaudio which makes this format a candidate. */
+        if (thisDeviceFormat.mSampleRate != desiredSampleRate) {
+            /*
+            The sample rate does not match, but this format could still be usable, although it's a very low priority. If the best format
+            so far has an equal sample rate we can just ignore this one.
+            */
+            if (bestDeviceFormatSoFar.mSampleRate == desiredSampleRate) {
+                continue;   /* The best sample rate so far has the same sample rate as what we requested which means it's still the best so far. Skip this format. */
+            } else {
+                /* In this case, neither the best format so far nor this one have the same sample rate. Check the channel count next. */
+                if (thisDeviceFormat.mChannelsPerFrame != desiredChannelCount) {
+                    /* This format has a different sample rate _and_ a different channel count. */
+                    if (bestDeviceFormatSoFar.mChannelsPerFrame == desiredChannelCount) {
+                        continue;   /* No change to the best format. */
+                    } else {
+                        /*
+                        Both this format and the best so far have different sample rates and different channel counts. Whichever has the
+                        best format is the new best.
+                        */
+                        if (ma_get_format_priority_index(thisSampleFormat) < ma_get_format_priority_index(bestSampleFormatSoFar)) {
+                            bestDeviceFormatSoFar = thisDeviceFormat;
+                            continue;
+                        } else {
+                            continue;   /* No change to the best format. */
+                        }
+                    }
+                } else {
+                    /* This format has a different sample rate but the desired channel count. */
+                    if (bestDeviceFormatSoFar.mChannelsPerFrame == desiredChannelCount) {
+                        /* Both this format and the best so far have the desired channel count. Whichever has the best format is the new best. */
+                        if (ma_get_format_priority_index(thisSampleFormat) < ma_get_format_priority_index(bestSampleFormatSoFar)) {
+                            bestDeviceFormatSoFar = thisDeviceFormat;
+                            continue;
+                        } else {
+                            continue;   /* No change to the best format for now. */
+                        }
+                    } else {
+                        /* This format has the desired channel count, but the best so far does not. We have a new best. */
+                        bestDeviceFormatSoFar = thisDeviceFormat;
+                        continue;
+                    }
+                }
+            }
+        } else {
+            /*
+            The sample rates match which makes this format a very high priority contender. If the best format so far has a different
+            sample rate it needs to be replaced with this one.
+            */
+            if (bestDeviceFormatSoFar.mSampleRate != desiredSampleRate) {
+                bestDeviceFormatSoFar = thisDeviceFormat;
+                continue;
+            } else {
+                /* In this case both this format and the best format so far have the same sample rate. Check the channel count next. */
+                if (thisDeviceFormat.mChannelsPerFrame == desiredChannelCount) {
+                    /*
+                    In this case this format has the same channel count as what the client is requesting. If the best format so far has
+                    a different count, this one becomes the new best.
+                    */
+                    if (bestDeviceFormatSoFar.mChannelsPerFrame != desiredChannelCount) {
+                        bestDeviceFormatSoFar = thisDeviceFormat;
+                        continue;
+                    } else {
+                        /* In this case both this format and the best so far have the ideal sample rate and channel count. Check the format. */
+                        if (thisSampleFormat == desiredFormat) {
+                            bestDeviceFormatSoFar = thisDeviceFormat;
+                            break;  /* Found the exact match. */
+                        } else {
+                            /* The formats are different. The new best format is the one with the highest priority format according to miniaudio. */
+                            if (ma_get_format_priority_index(thisSampleFormat) < ma_get_format_priority_index(bestSampleFormatSoFar)) {
+                                bestDeviceFormatSoFar = thisDeviceFormat;
+                                continue;
+                            } else {
+                                continue;   /* No change to the best format for now. */
+                            }
+                        }
+                    }
+                } else {
+                    /*
+                    In this case the channel count is different to what the client has requested. If the best so far has the same channel
+                    count as the requested count then it remains the best.
+                    */
+                    if (bestDeviceFormatSoFar.mChannelsPerFrame == desiredChannelCount) {
+                        continue;
+                    } else {
+                        /*
+                        This is the case where both have the same sample rate (good) but different channel counts. Right now both have about
+                        the same priority, but we need to compare the format now.
+                        */
+                        if (thisSampleFormat == bestSampleFormatSoFar) {
+                            if (ma_get_format_priority_index(thisSampleFormat) < ma_get_format_priority_index(bestSampleFormatSoFar)) {
+                                bestDeviceFormatSoFar = thisDeviceFormat;
+                                continue;
+                            } else {
+                                continue;   /* No change to the best format for now. */
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    *pFormat = bestDeviceFormatSoFar;
+
+    ma_free(pDeviceFormatDescriptions, &pContext->allocationCallbacks);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioUnit_channel_map(ma_context* pContext, AudioUnit audioUnit, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    AudioUnitScope deviceScope;
+    AudioUnitElement deviceBus;
+    UInt32 channelLayoutSize;
+    OSStatus status;
+    AudioChannelLayout* pChannelLayout;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    if (deviceType == ma_device_type_playback) {
+        deviceScope = kAudioUnitScope_Input;
+        deviceBus = MA_COREAUDIO_OUTPUT_BUS;
+    } else {
+        deviceScope = kAudioUnitScope_Output;
+        deviceBus = MA_COREAUDIO_INPUT_BUS;
+    }
+
+    status = ((ma_AudioUnitGetPropertyInfo_proc)pContext->coreaudio.AudioUnitGetPropertyInfo)(audioUnit, kAudioUnitProperty_AudioChannelLayout, deviceScope, deviceBus, &channelLayoutSize, NULL);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pChannelLayout = (AudioChannelLayout*)ma_malloc(channelLayoutSize, &pContext->allocationCallbacks);
+    if (pChannelLayout == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioUnitGetProperty_proc)pContext->coreaudio.AudioUnitGetProperty)(audioUnit, kAudioUnitProperty_AudioChannelLayout, deviceScope, deviceBus, pChannelLayout, &channelLayoutSize);
+    if (status != noErr) {
+        ma_free(pChannelLayout, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    result = ma_get_channel_map_from_AudioChannelLayout(pChannelLayout, pChannelMap, channelMapCap);
+    if (result != MA_SUCCESS) {
+        ma_free(pChannelLayout, &pContext->allocationCallbacks);
+        return result;
+    }
+
+    ma_free(pChannelLayout, &pContext->allocationCallbacks);
+    return MA_SUCCESS;
+}
+#endif /* MA_APPLE_DESKTOP */
+
+
+#if !defined(MA_APPLE_DESKTOP)
+static void ma_AVAudioSessionPortDescription_to_device_info(AVAudioSessionPortDescription* pPortDesc, ma_device_info* pInfo)
+{
+    MA_ZERO_OBJECT(pInfo);
+    ma_strncpy_s(pInfo->name,         sizeof(pInfo->name),         [pPortDesc.portName UTF8String], (size_t)-1);
+    ma_strncpy_s(pInfo->id.coreaudio, sizeof(pInfo->id.coreaudio), [pPortDesc.UID      UTF8String], (size_t)-1);
+}
+#endif
+
+static ma_result ma_context_enumerate_devices__coreaudio(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+#if defined(MA_APPLE_DESKTOP)
+    UInt32 deviceCount;
+    AudioObjectID* pDeviceObjectIDs;
+    AudioObjectID defaultDeviceObjectIDPlayback;
+    AudioObjectID defaultDeviceObjectIDCapture;
+    ma_result result;
+    UInt32 iDevice;
+
+    ma_find_default_AudioObjectID(pContext, ma_device_type_playback, &defaultDeviceObjectIDPlayback);   /* OK if this fails. */
+    ma_find_default_AudioObjectID(pContext, ma_device_type_capture,  &defaultDeviceObjectIDCapture);    /* OK if this fails. */
+
+    result = ma_get_device_object_ids__coreaudio(pContext, &deviceCount, &pDeviceObjectIDs);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    for (iDevice = 0; iDevice < deviceCount; ++iDevice) {
+        AudioObjectID deviceObjectID = pDeviceObjectIDs[iDevice];
+        ma_device_info info;
+
+        MA_ZERO_OBJECT(&info);
+        if (ma_get_AudioObject_uid(pContext, deviceObjectID, sizeof(info.id.coreaudio), info.id.coreaudio) != MA_SUCCESS) {
+            continue;
+        }
+        if (ma_get_AudioObject_name(pContext, deviceObjectID, sizeof(info.name), info.name) != MA_SUCCESS) {
+            continue;
+        }
+
+        if (ma_does_AudioObject_support_playback(pContext, deviceObjectID)) {
+            if (deviceObjectID == defaultDeviceObjectIDPlayback) {
+                info.isDefault = MA_TRUE;
+            }
+
+            if (!callback(pContext, ma_device_type_playback, &info, pUserData)) {
+                break;
+            }
+        }
+        if (ma_does_AudioObject_support_capture(pContext, deviceObjectID)) {
+            if (deviceObjectID == defaultDeviceObjectIDCapture) {
+                info.isDefault = MA_TRUE;
+            }
+
+            if (!callback(pContext, ma_device_type_capture, &info, pUserData)) {
+                break;
+            }
+        }
+    }
+
+    ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+#else
+    ma_device_info info;
+    NSArray *pInputs  = [[[AVAudioSession sharedInstance] currentRoute] inputs];
+    NSArray *pOutputs = [[[AVAudioSession sharedInstance] currentRoute] outputs];
+
+    for (AVAudioSessionPortDescription* pPortDesc in pOutputs) {
+        ma_AVAudioSessionPortDescription_to_device_info(pPortDesc, &info);
+        if (!callback(pContext, ma_device_type_playback, &info, pUserData)) {
+            return MA_SUCCESS;
+        }
+    }
+
+    for (AVAudioSessionPortDescription* pPortDesc in pInputs) {
+        ma_AVAudioSessionPortDescription_to_device_info(pPortDesc, &info);
+        if (!callback(pContext, ma_device_type_capture, &info, pUserData)) {
+            return MA_SUCCESS;
+        }
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__coreaudio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+#if defined(MA_APPLE_DESKTOP)
+    /* Desktop */
+    {
+        AudioObjectID deviceObjectID;
+        AudioObjectID defaultDeviceObjectID;
+        UInt32 streamDescriptionCount;
+        AudioStreamRangedDescription* pStreamDescriptions;
+        UInt32 iStreamDescription;
+        UInt32 sampleRateRangeCount;
+        AudioValueRange* pSampleRateRanges;
+
+        ma_find_default_AudioObjectID(pContext, deviceType, &defaultDeviceObjectID);     /* OK if this fails. */
+
+        result = ma_find_AudioObjectID(pContext, deviceType, pDeviceID, &deviceObjectID);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_get_AudioObject_uid(pContext, deviceObjectID, sizeof(pDeviceInfo->id.coreaudio), pDeviceInfo->id.coreaudio);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_get_AudioObject_name(pContext, deviceObjectID, sizeof(pDeviceInfo->name), pDeviceInfo->name);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        if (deviceObjectID == defaultDeviceObjectID) {
+            pDeviceInfo->isDefault = MA_TRUE;
+        }
+
+        /*
+        There could be a large number of permutations here. Fortunately there is only a single channel count
+        being reported which reduces this quite a bit. For sample rates we're only reporting those that are
+        one of miniaudio's recognized "standard" rates. If there are still more formats than can fit into
+        our fixed sized array we'll just need to truncate them. This is unlikely and will probably only happen
+        if some driver performs software data conversion and therefore reports every possible format and
+        sample rate.
+        */
+        pDeviceInfo->nativeDataFormatCount = 0;
+
+        /* Formats. */
+        {
+            ma_format uniqueFormats[ma_format_count];
+            ma_uint32 uniqueFormatCount = 0;
+            ma_uint32 channels;
+
+            /* Channels. */
+            result = ma_get_AudioObject_channel_count(pContext, deviceObjectID, deviceType, &channels);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+
+            /* Formats. */
+            result = ma_get_AudioObject_stream_descriptions(pContext, deviceObjectID, deviceType, &streamDescriptionCount, &pStreamDescriptions);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+
+            for (iStreamDescription = 0; iStreamDescription < streamDescriptionCount; ++iStreamDescription) {
+                ma_format format;
+                ma_bool32 hasFormatBeenHandled = MA_FALSE;
+                ma_uint32 iOutputFormat;
+                ma_uint32 iSampleRate;
+
+                result = ma_format_from_AudioStreamBasicDescription(&pStreamDescriptions[iStreamDescription].mFormat, &format);
+                if (result != MA_SUCCESS) {
+                    continue;
+                }
+
+                MA_ASSERT(format != ma_format_unknown);
+
+                /* Make sure the format isn't already in the output list. */
+                for (iOutputFormat = 0; iOutputFormat < uniqueFormatCount; ++iOutputFormat) {
+                    if (uniqueFormats[iOutputFormat] == format) {
+                        hasFormatBeenHandled = MA_TRUE;
+                        break;
+                    }
+                }
+
+                /* If we've already handled this format just skip it. */
+                if (hasFormatBeenHandled) {
+                    continue;
+                }
+
+                uniqueFormats[uniqueFormatCount] = format;
+                uniqueFormatCount += 1;
+
+                /* Sample Rates */
+                result = ma_get_AudioObject_sample_rates(pContext, deviceObjectID, deviceType, &sampleRateRangeCount, &pSampleRateRanges);
+                if (result != MA_SUCCESS) {
+                    return result;
+                }
+
+                /*
+                Annoyingly Core Audio reports a sample rate range. We just get all the standard rates that are
+                between this range.
+                */
+                for (iSampleRate = 0; iSampleRate < sampleRateRangeCount; ++iSampleRate) {
+                    ma_uint32 iStandardSampleRate;
+                    for (iStandardSampleRate = 0; iStandardSampleRate < ma_countof(g_maStandardSampleRatePriorities); iStandardSampleRate += 1) {
+                        ma_uint32 standardSampleRate = g_maStandardSampleRatePriorities[iStandardSampleRate];
+                        if (standardSampleRate >= pSampleRateRanges[iSampleRate].mMinimum && standardSampleRate <= pSampleRateRanges[iSampleRate].mMaximum) {
+                            /* We have a new data format. Add it to the list. */
+                            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+                            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+                            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = standardSampleRate;
+                            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = 0;
+                            pDeviceInfo->nativeDataFormatCount += 1;
+
+                            if (pDeviceInfo->nativeDataFormatCount >= ma_countof(pDeviceInfo->nativeDataFormats)) {
+                                break;  /* No more room for any more formats. */
+                            }
+                        }
+                    }
+                }
+
+                ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+
+                if (pDeviceInfo->nativeDataFormatCount >= ma_countof(pDeviceInfo->nativeDataFormats)) {
+                    break;  /* No more room for any more formats. */
+                }
+            }
+
+            ma_free(pStreamDescriptions, &pContext->allocationCallbacks);
+        }
+    }
+#else
+    /* Mobile */
+    {
+        AudioComponentDescription desc;
+        AudioComponent component;
+        AudioUnit audioUnit;
+        OSStatus status;
+        AudioUnitScope formatScope;
+        AudioUnitElement formatElement;
+        AudioStreamBasicDescription bestFormat;
+        UInt32 propSize;
+
+        /* We want to ensure we use a consistent device name to device enumeration. */
+        if (pDeviceID != NULL && pDeviceID->coreaudio[0] != '\0') {
+            ma_bool32 found = MA_FALSE;
+            if (deviceType == ma_device_type_playback) {
+                NSArray *pOutputs = [[[AVAudioSession sharedInstance] currentRoute] outputs];
+                for (AVAudioSessionPortDescription* pPortDesc in pOutputs) {
+                    if (strcmp(pDeviceID->coreaudio, [pPortDesc.UID UTF8String]) == 0) {
+                        ma_AVAudioSessionPortDescription_to_device_info(pPortDesc, pDeviceInfo);
+                        found = MA_TRUE;
+                        break;
+                    }
+                }
+            } else {
+                NSArray *pInputs = [[[AVAudioSession sharedInstance] currentRoute] inputs];
+                for (AVAudioSessionPortDescription* pPortDesc in pInputs) {
+                    if (strcmp(pDeviceID->coreaudio, [pPortDesc.UID UTF8String]) == 0) {
+                        ma_AVAudioSessionPortDescription_to_device_info(pPortDesc, pDeviceInfo);
+                        found = MA_TRUE;
+                        break;
+                    }
+                }
+            }
+
+            if (!found) {
+                return MA_DOES_NOT_EXIST;
+            }
+        } else {
+            if (deviceType == ma_device_type_playback) {
+                ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+            } else {
+                ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+            }
+        }
+
+
+        /*
+        Retrieving device information is more annoying on mobile than desktop. For simplicity I'm locking this down to whatever format is
+        reported on a temporary I/O unit. The problem, however, is that this doesn't return a value for the sample rate which we need to
+        retrieve from the AVAudioSession shared instance.
+        */
+        desc.componentType = kAudioUnitType_Output;
+        desc.componentSubType = kAudioUnitSubType_RemoteIO;
+        desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+        desc.componentFlags = 0;
+        desc.componentFlagsMask = 0;
+
+        component = ((ma_AudioComponentFindNext_proc)pContext->coreaudio.AudioComponentFindNext)(NULL, &desc);
+        if (component == NULL) {
+            return MA_FAILED_TO_INIT_BACKEND;
+        }
+
+        status = ((ma_AudioComponentInstanceNew_proc)pContext->coreaudio.AudioComponentInstanceNew)(component, &audioUnit);
+        if (status != noErr) {
+            return ma_result_from_OSStatus(status);
+        }
+
+        formatScope   = (deviceType == ma_device_type_playback) ? kAudioUnitScope_Input : kAudioUnitScope_Output;
+        formatElement = (deviceType == ma_device_type_playback) ? MA_COREAUDIO_OUTPUT_BUS : MA_COREAUDIO_INPUT_BUS;
+
+        propSize = sizeof(bestFormat);
+        status = ((ma_AudioUnitGetProperty_proc)pContext->coreaudio.AudioUnitGetProperty)(audioUnit, kAudioUnitProperty_StreamFormat, formatScope, formatElement, &bestFormat, &propSize);
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(audioUnit);
+        audioUnit = NULL;
+
+        /* Only a single format is being reported for iOS. */
+        pDeviceInfo->nativeDataFormatCount = 1;
+
+        result = ma_format_from_AudioStreamBasicDescription(&bestFormat, &pDeviceInfo->nativeDataFormats[0].format);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pDeviceInfo->nativeDataFormats[0].channels = bestFormat.mChannelsPerFrame;
+
+        /*
+        It looks like Apple are wanting to push the whole AVAudioSession thing. Thus, we need to use that to determine device settings. To do
+        this we just get the shared instance and inspect.
+        */
+        @autoreleasepool {
+            AVAudioSession* pAudioSession = [AVAudioSession sharedInstance];
+            MA_ASSERT(pAudioSession != NULL);
+
+            pDeviceInfo->nativeDataFormats[0].sampleRate = (ma_uint32)pAudioSession.sampleRate;
+        }
+    }
+#endif
+
+    (void)pDeviceInfo; /* Unused. */
+    return MA_SUCCESS;
+}
+
+static AudioBufferList* ma_allocate_AudioBufferList__coreaudio(ma_uint32 sizeInFrames, ma_format format, ma_uint32 channels, ma_stream_layout layout, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    AudioBufferList* pBufferList;
+    UInt32 audioBufferSizeInBytes;
+    size_t allocationSize;
+
+    MA_ASSERT(sizeInFrames > 0);
+    MA_ASSERT(format != ma_format_unknown);
+    MA_ASSERT(channels > 0);
+
+    allocationSize = sizeof(AudioBufferList) - sizeof(AudioBuffer);  /* Subtract sizeof(AudioBuffer) because that part is dynamically sized. */
+    if (layout == ma_stream_layout_interleaved) {
+        /* Interleaved case. This is the simple case because we just have one buffer. */
+        allocationSize += sizeof(AudioBuffer) * 1;
+    } else {
+        /* Non-interleaved case. This is the more complex case because there's more than one buffer. */
+        allocationSize += sizeof(AudioBuffer) * channels;
+    }
+
+    allocationSize += sizeInFrames * ma_get_bytes_per_frame(format, channels);
+
+    pBufferList = (AudioBufferList*)ma_malloc(allocationSize, pAllocationCallbacks);
+    if (pBufferList == NULL) {
+        return NULL;
+    }
+
+    audioBufferSizeInBytes = (UInt32)(sizeInFrames * ma_get_bytes_per_sample(format));
+
+    if (layout == ma_stream_layout_interleaved) {
+        pBufferList->mNumberBuffers = 1;
+        pBufferList->mBuffers[0].mNumberChannels = channels;
+        pBufferList->mBuffers[0].mDataByteSize   = audioBufferSizeInBytes * channels;
+        pBufferList->mBuffers[0].mData           = (ma_uint8*)pBufferList + sizeof(AudioBufferList);
+    } else {
+        ma_uint32 iBuffer;
+        pBufferList->mNumberBuffers = channels;
+        for (iBuffer = 0; iBuffer < pBufferList->mNumberBuffers; ++iBuffer) {
+            pBufferList->mBuffers[iBuffer].mNumberChannels = 1;
+            pBufferList->mBuffers[iBuffer].mDataByteSize   = audioBufferSizeInBytes;
+            pBufferList->mBuffers[iBuffer].mData           = (ma_uint8*)pBufferList + ((sizeof(AudioBufferList) - sizeof(AudioBuffer)) + (sizeof(AudioBuffer) * channels)) + (audioBufferSizeInBytes * iBuffer);
+        }
+    }
+
+    return pBufferList;
+}
+
+static ma_result ma_device_realloc_AudioBufferList__coreaudio(ma_device* pDevice, ma_uint32 sizeInFrames, ma_format format, ma_uint32 channels, ma_stream_layout layout)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(format != ma_format_unknown);
+    MA_ASSERT(channels > 0);
+
+    /* Only resize the buffer if necessary. */
+    if (pDevice->coreaudio.audioBufferCapInFrames < sizeInFrames) {
+        AudioBufferList* pNewAudioBufferList;
+
+        pNewAudioBufferList = ma_allocate_AudioBufferList__coreaudio(sizeInFrames, format, channels, layout, &pDevice->pContext->allocationCallbacks);
+        if (pNewAudioBufferList == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        /* At this point we'll have a new AudioBufferList and we can free the old one. */
+        ma_free(pDevice->coreaudio.pAudioBufferList, &pDevice->pContext->allocationCallbacks);
+        pDevice->coreaudio.pAudioBufferList = pNewAudioBufferList;
+        pDevice->coreaudio.audioBufferCapInFrames = sizeInFrames;
+    }
+
+    /* Getting here means the capacity of the audio is fine. */
+    return MA_SUCCESS;
+}
+
+
+static OSStatus ma_on_output__coreaudio(void* pUserData, AudioUnitRenderActionFlags* pActionFlags, const AudioTimeStamp* pTimeStamp, UInt32 busNumber, UInt32 frameCount, AudioBufferList* pBufferList)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    ma_stream_layout layout;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "INFO: Output Callback: busNumber=%d, frameCount=%d, mNumberBuffers=%d\n", (int)busNumber, (int)frameCount, (int)pBufferList->mNumberBuffers);*/
+
+    /* We need to check whether or not we are outputting interleaved or non-interleaved samples. The way we do this is slightly different for each type. */
+    layout = ma_stream_layout_interleaved;
+    if (pBufferList->mBuffers[0].mNumberChannels != pDevice->playback.internalChannels) {
+        layout = ma_stream_layout_deinterleaved;
+    }
+
+    if (layout == ma_stream_layout_interleaved) {
+        /* For now we can assume everything is interleaved. */
+        UInt32 iBuffer;
+        for (iBuffer = 0; iBuffer < pBufferList->mNumberBuffers; ++iBuffer) {
+            if (pBufferList->mBuffers[iBuffer].mNumberChannels == pDevice->playback.internalChannels) {
+                ma_uint32 frameCountForThisBuffer = pBufferList->mBuffers[iBuffer].mDataByteSize / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+                if (frameCountForThisBuffer > 0) {
+                    ma_device_handle_backend_data_callback(pDevice, pBufferList->mBuffers[iBuffer].mData, NULL, frameCountForThisBuffer);
+                }
+
+                /*a_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "  frameCount=%d, mNumberChannels=%d, mDataByteSize=%d\n", (int)frameCount, (int)pBufferList->mBuffers[iBuffer].mNumberChannels, (int)pBufferList->mBuffers[iBuffer].mDataByteSize);*/
+            } else {
+                /*
+                This case is where the number of channels in the output buffer do not match our internal channels. It could mean that it's
+                not interleaved, in which case we can't handle right now since miniaudio does not yet support non-interleaved streams. We just
+                output silence here.
+                */
+                MA_ZERO_MEMORY(pBufferList->mBuffers[iBuffer].mData, pBufferList->mBuffers[iBuffer].mDataByteSize);
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "  WARNING: Outputting silence. frameCount=%d, mNumberChannels=%d, mDataByteSize=%d\n", (int)frameCount, (int)pBufferList->mBuffers[iBuffer].mNumberChannels, (int)pBufferList->mBuffers[iBuffer].mDataByteSize);*/
+            }
+        }
+    } else {
+        /* This is the deinterleaved case. We need to update each buffer in groups of internalChannels. This assumes each buffer is the same size. */
+        MA_ASSERT(pDevice->playback.internalChannels <= MA_MAX_CHANNELS);   /* This should have been validated at initialization time. */
+
+        /*
+        For safety we'll check that the internal channels is a multiple of the buffer count. If it's not it means something
+        very strange has happened and we're not going to support it.
+        */
+        if ((pBufferList->mNumberBuffers % pDevice->playback.internalChannels) == 0) {
+            ma_uint8 tempBuffer[4096];
+            UInt32 iBuffer;
+
+            for (iBuffer = 0; iBuffer < pBufferList->mNumberBuffers; iBuffer += pDevice->playback.internalChannels) {
+                ma_uint32 frameCountPerBuffer = pBufferList->mBuffers[iBuffer].mDataByteSize / ma_get_bytes_per_sample(pDevice->playback.internalFormat);
+                ma_uint32 framesRemaining = frameCountPerBuffer;
+
+                while (framesRemaining > 0) {
+                    void* ppDeinterleavedBuffers[MA_MAX_CHANNELS];
+                    ma_uint32 iChannel;
+                    ma_uint32 framesToRead = sizeof(tempBuffer) / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+                    if (framesToRead > framesRemaining) {
+                        framesToRead = framesRemaining;
+                    }
+
+                    ma_device_handle_backend_data_callback(pDevice, tempBuffer, NULL, framesToRead);
+
+                    for (iChannel = 0; iChannel < pDevice->playback.internalChannels; ++iChannel) {
+                        ppDeinterleavedBuffers[iChannel] = (void*)ma_offset_ptr(pBufferList->mBuffers[iBuffer+iChannel].mData, (frameCountPerBuffer - framesRemaining) * ma_get_bytes_per_sample(pDevice->playback.internalFormat));
+                    }
+
+                    ma_deinterleave_pcm_frames(pDevice->playback.internalFormat, pDevice->playback.internalChannels, framesToRead, tempBuffer, ppDeinterleavedBuffers);
+
+                    framesRemaining -= framesToRead;
+                }
+            }
+        }
+    }
+
+    (void)pActionFlags;
+    (void)pTimeStamp;
+    (void)busNumber;
+    (void)frameCount;
+
+    return noErr;
+}
+
+static OSStatus ma_on_input__coreaudio(void* pUserData, AudioUnitRenderActionFlags* pActionFlags, const AudioTimeStamp* pTimeStamp, UInt32 busNumber, UInt32 frameCount, AudioBufferList* pUnusedBufferList)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    AudioBufferList* pRenderedBufferList;
+    ma_result result;
+    ma_stream_layout layout;
+    ma_uint32 iBuffer;
+    OSStatus status;
+
+    MA_ASSERT(pDevice != NULL);
+
+    pRenderedBufferList = (AudioBufferList*)pDevice->coreaudio.pAudioBufferList;
+    MA_ASSERT(pRenderedBufferList);
+
+    /* We need to check whether or not we are outputting interleaved or non-interleaved samples. The way we do this is slightly different for each type. */
+    layout = ma_stream_layout_interleaved;
+    if (pRenderedBufferList->mBuffers[0].mNumberChannels != pDevice->capture.internalChannels) {
+        layout = ma_stream_layout_deinterleaved;
+    }
+
+    /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "INFO: Input Callback: busNumber=%d, frameCount=%d, mNumberBuffers=%d\n", (int)busNumber, (int)frameCount, (int)pRenderedBufferList->mNumberBuffers);*/
+
+    /*
+    There has been a situation reported where frame count passed into this function is greater than the capacity of
+    our capture buffer. There doesn't seem to be a reliable way to determine what the maximum frame count will be,
+    so we need to instead resort to dynamically reallocating our buffer to ensure it's large enough to capture the
+    number of frames requested by this callback.
+    */
+    result = ma_device_realloc_AudioBufferList__coreaudio(pDevice, frameCount, pDevice->capture.internalFormat, pDevice->capture.internalChannels, layout);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "Failed to allocate AudioBufferList for capture.\n");
+        return noErr;
+    }
+
+    pRenderedBufferList = (AudioBufferList*)pDevice->coreaudio.pAudioBufferList;
+    MA_ASSERT(pRenderedBufferList);
+
+    /*
+    When you call AudioUnitRender(), Core Audio tries to be helpful by setting the mDataByteSize to the number of bytes
+    that were actually rendered. The problem with this is that the next call can fail with -50 due to the size no longer
+    being set to the capacity of the buffer, but instead the size in bytes of the previous render. This will cause a
+    problem when a future call to this callback specifies a larger number of frames.
+
+    To work around this we need to explicitly set the size of each buffer to their respective size in bytes.
+    */
+    for (iBuffer = 0; iBuffer < pRenderedBufferList->mNumberBuffers; ++iBuffer) {
+        pRenderedBufferList->mBuffers[iBuffer].mDataByteSize = pDevice->coreaudio.audioBufferCapInFrames * ma_get_bytes_per_sample(pDevice->capture.internalFormat) * pRenderedBufferList->mBuffers[iBuffer].mNumberChannels;
+        /*printf("DEBUG: nDataByteSize = %d\n", (int)pRenderedBufferList->mBuffers[iBuffer].mDataByteSize);*/
+    }
+
+    status = ((ma_AudioUnitRender_proc)pDevice->pContext->coreaudio.AudioUnitRender)((AudioUnit)pDevice->coreaudio.audioUnitCapture, pActionFlags, pTimeStamp, busNumber, frameCount, pRenderedBufferList);
+    if (status != noErr) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "ERROR: AudioUnitRender() failed with %d.\n", (int)status);
+        return status;
+    }
+
+    if (layout == ma_stream_layout_interleaved) {
+        for (iBuffer = 0; iBuffer < pRenderedBufferList->mNumberBuffers; ++iBuffer) {
+            if (pRenderedBufferList->mBuffers[iBuffer].mNumberChannels == pDevice->capture.internalChannels) {
+                ma_device_handle_backend_data_callback(pDevice, NULL, pRenderedBufferList->mBuffers[iBuffer].mData, frameCount);
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "  mDataByteSize=%d.\n", (int)pRenderedBufferList->mBuffers[iBuffer].mDataByteSize);*/
+            } else {
+                /*
+                This case is where the number of channels in the output buffer do not match our internal channels. It could mean that it's
+                not interleaved, in which case we can't handle right now since miniaudio does not yet support non-interleaved streams.
+                */
+                ma_uint8 silentBuffer[4096];
+                ma_uint32 framesRemaining;
+
+                MA_ZERO_MEMORY(silentBuffer, sizeof(silentBuffer));
+
+                framesRemaining = frameCount;
+                while (framesRemaining > 0) {
+                    ma_uint32 framesToSend = sizeof(silentBuffer) / ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+                    if (framesToSend > framesRemaining) {
+                        framesToSend = framesRemaining;
+                    }
+
+                    ma_device_handle_backend_data_callback(pDevice, NULL, silentBuffer, framesToSend);
+
+                    framesRemaining -= framesToSend;
+                }
+
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "  WARNING: Outputting silence. frameCount=%d, mNumberChannels=%d, mDataByteSize=%d\n", (int)frameCount, (int)pRenderedBufferList->mBuffers[iBuffer].mNumberChannels, (int)pRenderedBufferList->mBuffers[iBuffer].mDataByteSize);*/
+            }
+        }
+    } else {
+        /* This is the deinterleaved case. We need to interleave the audio data before sending it to the client. This assumes each buffer is the same size. */
+        MA_ASSERT(pDevice->capture.internalChannels <= MA_MAX_CHANNELS);    /* This should have been validated at initialization time. */
+
+        /*
+        For safety we'll check that the internal channels is a multiple of the buffer count. If it's not it means something
+        very strange has happened and we're not going to support it.
+        */
+        if ((pRenderedBufferList->mNumberBuffers % pDevice->capture.internalChannels) == 0) {
+            ma_uint8 tempBuffer[4096];
+            for (iBuffer = 0; iBuffer < pRenderedBufferList->mNumberBuffers; iBuffer += pDevice->capture.internalChannels) {
+                ma_uint32 framesRemaining = frameCount;
+                while (framesRemaining > 0) {
+                    void* ppDeinterleavedBuffers[MA_MAX_CHANNELS];
+                    ma_uint32 iChannel;
+                    ma_uint32 framesToSend = sizeof(tempBuffer) / ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+                    if (framesToSend > framesRemaining) {
+                        framesToSend = framesRemaining;
+                    }
+
+                    for (iChannel = 0; iChannel < pDevice->capture.internalChannels; ++iChannel) {
+                        ppDeinterleavedBuffers[iChannel] = (void*)ma_offset_ptr(pRenderedBufferList->mBuffers[iBuffer+iChannel].mData, (frameCount - framesRemaining) * ma_get_bytes_per_sample(pDevice->capture.internalFormat));
+                    }
+
+                    ma_interleave_pcm_frames(pDevice->capture.internalFormat, pDevice->capture.internalChannels, framesToSend, (const void**)ppDeinterleavedBuffers, tempBuffer);
+                    ma_device_handle_backend_data_callback(pDevice, NULL, tempBuffer, framesToSend);
+
+                    framesRemaining -= framesToSend;
+                }
+            }
+        }
+    }
+
+    (void)pActionFlags;
+    (void)pTimeStamp;
+    (void)busNumber;
+    (void)frameCount;
+    (void)pUnusedBufferList;
+
+    return noErr;
+}
+
+static void on_start_stop__coreaudio(void* pUserData, AudioUnit audioUnit, AudioUnitPropertyID propertyID, AudioUnitScope scope, AudioUnitElement element)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    /* Don't do anything if it looks like we're just reinitializing due to a device switch. */
+    if (((audioUnit == pDevice->coreaudio.audioUnitPlayback) && pDevice->coreaudio.isSwitchingPlaybackDevice) ||
+        ((audioUnit == pDevice->coreaudio.audioUnitCapture)  && pDevice->coreaudio.isSwitchingCaptureDevice)) {
+        return;
+    }
+
+    /*
+    There's been a report of a deadlock here when triggered by ma_device_uninit(). It looks like
+    AudioUnitGetProprty (called below) and AudioComponentInstanceDispose (called in ma_device_uninit)
+    can try waiting on the same lock. I'm going to try working around this by not calling any Core
+    Audio APIs in the callback when the device has been stopped or uninitialized.
+    */
+    if (ma_device_get_state(pDevice) == ma_device_state_uninitialized || ma_device_get_state(pDevice) == ma_device_state_stopping || ma_device_get_state(pDevice) == ma_device_state_stopped) {
+        ma_device__on_notification_stopped(pDevice);
+    } else {
+        UInt32 isRunning;
+        UInt32 isRunningSize = sizeof(isRunning);
+        OSStatus status = ((ma_AudioUnitGetProperty_proc)pDevice->pContext->coreaudio.AudioUnitGetProperty)(audioUnit, kAudioOutputUnitProperty_IsRunning, scope, element, &isRunning, &isRunningSize);
+        if (status != noErr) {
+            goto done; /* Don't really know what to do in this case... just ignore it, I suppose... */
+        }
+
+        if (!isRunning) {
+            /*
+            The stop event is a bit annoying in Core Audio because it will be called when we automatically switch the default device. Some scenarios to consider:
+
+            1) When the device is unplugged, this will be called _before_ the default device change notification.
+            2) When the device is changed via the default device change notification, this will be called _after_ the switch.
+
+            For case #1, we just check if there's a new default device available. If so, we just ignore the stop event. For case #2 we check a flag.
+            */
+            if (((audioUnit == pDevice->coreaudio.audioUnitPlayback) && pDevice->coreaudio.isDefaultPlaybackDevice) ||
+                ((audioUnit == pDevice->coreaudio.audioUnitCapture)  && pDevice->coreaudio.isDefaultCaptureDevice)) {
+                /*
+                It looks like the device is switching through an external event, such as the user unplugging the device or changing the default device
+                via the operating system's sound settings. If we're re-initializing the device, we just terminate because we want the stopping of the
+                device to be seamless to the client (we don't want them receiving the stopped event and thinking that the device has stopped when it
+                hasn't!).
+                */
+                if (((audioUnit == pDevice->coreaudio.audioUnitPlayback) && pDevice->coreaudio.isSwitchingPlaybackDevice) ||
+                    ((audioUnit == pDevice->coreaudio.audioUnitCapture)  && pDevice->coreaudio.isSwitchingCaptureDevice)) {
+                    goto done;
+                }
+
+                /*
+                Getting here means the device is not reinitializing which means it may have been unplugged. From what I can see, it looks like Core Audio
+                will try switching to the new default device seamlessly. We need to somehow find a way to determine whether or not Core Audio will most
+                likely be successful in switching to the new device.
+
+                TODO: Try to predict if Core Audio will switch devices. If not, the stopped callback needs to be posted.
+                */
+                goto done;
+            }
+
+            /* Getting here means we need to stop the device. */
+            ma_device__on_notification_stopped(pDevice);
+        }
+    }
+
+    (void)propertyID; /* Unused. */
+
+done:
+    /* Always signal the stop event. It's possible for the "else" case to get hit which can happen during an interruption. */
+    ma_event_signal(&pDevice->coreaudio.stopEvent);
+}
+
+#if defined(MA_APPLE_DESKTOP)
+static ma_spinlock g_DeviceTrackingInitLock_CoreAudio = 0;  /* A spinlock for mutal exclusion of the init/uninit of the global tracking data. Initialization to 0 is what we need. */
+static ma_uint32   g_DeviceTrackingInitCounter_CoreAudio = 0;
+static ma_mutex    g_DeviceTrackingMutex_CoreAudio;
+static ma_device** g_ppTrackedDevices_CoreAudio = NULL;
+static ma_uint32   g_TrackedDeviceCap_CoreAudio = 0;
+static ma_uint32   g_TrackedDeviceCount_CoreAudio = 0;
+
+static OSStatus ma_default_device_changed__coreaudio(AudioObjectID objectID, UInt32 addressCount, const AudioObjectPropertyAddress* pAddresses, void* pUserData)
+{
+    ma_device_type deviceType;
+
+    /* Not sure if I really need to check this, but it makes me feel better. */
+    if (addressCount == 0) {
+        return noErr;
+    }
+
+    if (pAddresses[0].mSelector == kAudioHardwarePropertyDefaultOutputDevice) {
+        deviceType = ma_device_type_playback;
+    } else if (pAddresses[0].mSelector == kAudioHardwarePropertyDefaultInputDevice) {
+        deviceType = ma_device_type_capture;
+    } else {
+        return noErr;   /* Should never hit this. */
+    }
+
+    ma_mutex_lock(&g_DeviceTrackingMutex_CoreAudio);
+    {
+        ma_uint32 iDevice;
+        for (iDevice = 0; iDevice < g_TrackedDeviceCount_CoreAudio; iDevice += 1) {
+            ma_result reinitResult;
+            ma_device* pDevice;
+
+            pDevice = g_ppTrackedDevices_CoreAudio[iDevice];
+            if (pDevice->type == deviceType || pDevice->type == ma_device_type_duplex) {
+                if (deviceType == ma_device_type_playback) {
+                    pDevice->coreaudio.isSwitchingPlaybackDevice = MA_TRUE;
+                    reinitResult = ma_device_reinit_internal__coreaudio(pDevice, deviceType, MA_TRUE);
+                    pDevice->coreaudio.isSwitchingPlaybackDevice = MA_FALSE;
+                } else {
+                    pDevice->coreaudio.isSwitchingCaptureDevice = MA_TRUE;
+                    reinitResult = ma_device_reinit_internal__coreaudio(pDevice, deviceType, MA_TRUE);
+                    pDevice->coreaudio.isSwitchingCaptureDevice = MA_FALSE;
+                }
+
+                if (reinitResult == MA_SUCCESS) {
+                    ma_device__post_init_setup(pDevice, deviceType);
+
+                    /* Restart the device if required. If this fails we need to stop the device entirely. */
+                    if (ma_device_get_state(pDevice) == ma_device_state_started) {
+                        OSStatus status;
+                        if (deviceType == ma_device_type_playback) {
+                            status = ((ma_AudioOutputUnitStart_proc)pDevice->pContext->coreaudio.AudioOutputUnitStart)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+                            if (status != noErr) {
+                                if (pDevice->type == ma_device_type_duplex) {
+                                    ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+                                }
+                                ma_device__set_state(pDevice, ma_device_state_stopped);
+                            }
+                        } else if (deviceType == ma_device_type_capture) {
+                            status = ((ma_AudioOutputUnitStart_proc)pDevice->pContext->coreaudio.AudioOutputUnitStart)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+                            if (status != noErr) {
+                                if (pDevice->type == ma_device_type_duplex) {
+                                    ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+                                }
+                                ma_device__set_state(pDevice, ma_device_state_stopped);
+                            }
+                        }
+                    }
+
+                    ma_device__on_notification_rerouted(pDevice);
+                }
+            }
+        }
+    }
+    ma_mutex_unlock(&g_DeviceTrackingMutex_CoreAudio);
+
+    /* Unused parameters. */
+    (void)objectID;
+    (void)pUserData;
+
+    return noErr;
+}
+
+static ma_result ma_context__init_device_tracking__coreaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+
+    ma_spinlock_lock(&g_DeviceTrackingInitLock_CoreAudio);
+    {
+        /* Don't do anything if we've already initialized device tracking. */
+        if (g_DeviceTrackingInitCounter_CoreAudio == 0) {
+            AudioObjectPropertyAddress propAddress;
+            propAddress.mScope    = kAudioObjectPropertyScopeGlobal;
+            propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+            ma_mutex_init(&g_DeviceTrackingMutex_CoreAudio);
+
+            propAddress.mSelector = kAudioHardwarePropertyDefaultInputDevice;
+            ((ma_AudioObjectAddPropertyListener_proc)pContext->coreaudio.AudioObjectAddPropertyListener)(kAudioObjectSystemObject, &propAddress, &ma_default_device_changed__coreaudio, NULL);
+
+            propAddress.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
+            ((ma_AudioObjectAddPropertyListener_proc)pContext->coreaudio.AudioObjectAddPropertyListener)(kAudioObjectSystemObject, &propAddress, &ma_default_device_changed__coreaudio, NULL);
+
+        }
+        g_DeviceTrackingInitCounter_CoreAudio += 1;
+    }
+    ma_spinlock_unlock(&g_DeviceTrackingInitLock_CoreAudio);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context__uninit_device_tracking__coreaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+
+    ma_spinlock_lock(&g_DeviceTrackingInitLock_CoreAudio);
+    {
+        if (g_DeviceTrackingInitCounter_CoreAudio > 0)
+            g_DeviceTrackingInitCounter_CoreAudio -= 1;
+
+        if (g_DeviceTrackingInitCounter_CoreAudio == 0) {
+            AudioObjectPropertyAddress propAddress;
+            propAddress.mScope    = kAudioObjectPropertyScopeGlobal;
+            propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+            propAddress.mSelector = kAudioHardwarePropertyDefaultInputDevice;
+            ((ma_AudioObjectRemovePropertyListener_proc)pContext->coreaudio.AudioObjectRemovePropertyListener)(kAudioObjectSystemObject, &propAddress, &ma_default_device_changed__coreaudio, NULL);
+
+            propAddress.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
+            ((ma_AudioObjectRemovePropertyListener_proc)pContext->coreaudio.AudioObjectRemovePropertyListener)(kAudioObjectSystemObject, &propAddress, &ma_default_device_changed__coreaudio, NULL);
+
+            /* At this point there should be no tracked devices. If not there's an error somewhere. */
+            if (g_ppTrackedDevices_CoreAudio != NULL) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "You have uninitialized all contexts while an associated device is still active.");
+                ma_spinlock_unlock(&g_DeviceTrackingInitLock_CoreAudio);
+                return MA_INVALID_OPERATION;
+            }
+
+            ma_mutex_uninit(&g_DeviceTrackingMutex_CoreAudio);
+        }
+    }
+    ma_spinlock_unlock(&g_DeviceTrackingInitLock_CoreAudio);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device__track__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ma_mutex_lock(&g_DeviceTrackingMutex_CoreAudio);
+    {
+        /* Allocate memory if required. */
+        if (g_TrackedDeviceCap_CoreAudio <= g_TrackedDeviceCount_CoreAudio) {
+            ma_uint32 newCap;
+            ma_device** ppNewDevices;
+
+            newCap = g_TrackedDeviceCap_CoreAudio * 2;
+            if (newCap == 0) {
+                newCap = 1;
+            }
+
+            ppNewDevices = (ma_device**)ma_realloc(g_ppTrackedDevices_CoreAudio, sizeof(*g_ppTrackedDevices_CoreAudio)*newCap, &pDevice->pContext->allocationCallbacks);
+            if (ppNewDevices == NULL) {
+                ma_mutex_unlock(&g_DeviceTrackingMutex_CoreAudio);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            g_ppTrackedDevices_CoreAudio = ppNewDevices;
+            g_TrackedDeviceCap_CoreAudio = newCap;
+        }
+
+        g_ppTrackedDevices_CoreAudio[g_TrackedDeviceCount_CoreAudio] = pDevice;
+        g_TrackedDeviceCount_CoreAudio += 1;
+    }
+    ma_mutex_unlock(&g_DeviceTrackingMutex_CoreAudio);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device__untrack__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ma_mutex_lock(&g_DeviceTrackingMutex_CoreAudio);
+    {
+        ma_uint32 iDevice;
+        for (iDevice = 0; iDevice < g_TrackedDeviceCount_CoreAudio; iDevice += 1) {
+            if (g_ppTrackedDevices_CoreAudio[iDevice] == pDevice) {
+                /* We've found the device. We now need to remove it from the list. */
+                ma_uint32 jDevice;
+                for (jDevice = iDevice; jDevice < g_TrackedDeviceCount_CoreAudio-1; jDevice += 1) {
+                    g_ppTrackedDevices_CoreAudio[jDevice] = g_ppTrackedDevices_CoreAudio[jDevice+1];
+                }
+
+                g_TrackedDeviceCount_CoreAudio -= 1;
+
+                /* If there's nothing else in the list we need to free memory. */
+                if (g_TrackedDeviceCount_CoreAudio == 0) {
+                    ma_free(g_ppTrackedDevices_CoreAudio, &pDevice->pContext->allocationCallbacks);
+                    g_ppTrackedDevices_CoreAudio = NULL;
+                    g_TrackedDeviceCap_CoreAudio = 0;
+                }
+
+                break;
+            }
+        }
+    }
+    ma_mutex_unlock(&g_DeviceTrackingMutex_CoreAudio);
+
+    return MA_SUCCESS;
+}
+#endif
+
+#if defined(MA_APPLE_MOBILE)
+@interface ma_ios_notification_handler:NSObject {
+    ma_device* m_pDevice;
+}
+@end
+
+@implementation ma_ios_notification_handler
+-(id)init:(ma_device*)pDevice
+{
+    self = [super init];
+    m_pDevice = pDevice;
+
+    /* For route changes. */
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handle_route_change:) name:AVAudioSessionRouteChangeNotification object:[AVAudioSession sharedInstance]];
+
+    /* For interruptions. */
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handle_interruption:) name:AVAudioSessionInterruptionNotification object:[AVAudioSession sharedInstance]];
+
+    return self;
+}
+
+-(void)dealloc
+{
+    [self remove_handler];
+
+    #if defined(__has_feature)
+        #if !__has_feature(objc_arc)
+            [super dealloc];
+        #endif
+    #endif
+}
+
+-(void)remove_handler
+{
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:AVAudioSessionRouteChangeNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:AVAudioSessionInterruptionNotification object:nil];
+}
+
+-(void)handle_interruption:(NSNotification*)pNotification
+{
+    NSInteger type = [[[pNotification userInfo] objectForKey:AVAudioSessionInterruptionTypeKey] integerValue];
+    switch (type)
+    {
+        case AVAudioSessionInterruptionTypeBegan:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Interruption: AVAudioSessionInterruptionTypeBegan\n");
+
+            /*
+            Core Audio will have stopped the internal device automatically, but we need explicitly
+            stop it at a higher level to ensure miniaudio-specific state is updated for consistency.
+            */
+            ma_device_stop(m_pDevice);
+
+            /*
+            Fire the notification after the device has been stopped to ensure it's in the correct
+            state when the notification handler is invoked.
+            */
+            ma_device__on_notification_interruption_began(m_pDevice);
+        } break;
+
+        case AVAudioSessionInterruptionTypeEnded:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Interruption: AVAudioSessionInterruptionTypeEnded\n");
+            ma_device__on_notification_interruption_ended(m_pDevice);
+        } break;
+    }
+}
+
+-(void)handle_route_change:(NSNotification*)pNotification
+{
+    AVAudioSession* pSession = [AVAudioSession sharedInstance];
+
+    NSInteger reason = [[[pNotification userInfo] objectForKey:AVAudioSessionRouteChangeReasonKey] integerValue];
+    switch (reason)
+    {
+        case AVAudioSessionRouteChangeReasonOldDeviceUnavailable:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonOldDeviceUnavailable\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonNewDeviceAvailable:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonNewDeviceAvailable\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonNoSuitableRouteForCategory:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonNoSuitableRouteForCategory\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonWakeFromSleep:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonWakeFromSleep\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonOverride:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonOverride\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonCategoryChange:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonCategoryChange\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonUnknown:
+        default:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonUnknown\n");
+        } break;
+    }
+
+    ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_DEBUG, "[Core Audio] Changing Route. inputNumberChannels=%d; outputNumberOfChannels=%d\n", (int)pSession.inputNumberOfChannels, (int)pSession.outputNumberOfChannels);
+
+    /* Let the application know about the route change. */
+    ma_device__on_notification_rerouted(m_pDevice);
+}
+@end
+#endif
+
+static ma_result ma_device_uninit__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_uninitialized);
+
+#if defined(MA_APPLE_DESKTOP)
+    /*
+    Make sure we're no longer tracking the device. It doesn't matter if we call this for a non-default device because it'll
+    just gracefully ignore it.
+    */
+    ma_device__untrack__coreaudio(pDevice);
+#endif
+#if defined(MA_APPLE_MOBILE)
+    if (pDevice->coreaudio.pNotificationHandler != NULL) {
+        ma_ios_notification_handler* pNotificationHandler = (MA_BRIDGE_TRANSFER ma_ios_notification_handler*)pDevice->coreaudio.pNotificationHandler;
+        [pNotificationHandler remove_handler];
+    }
+#endif
+
+    if (pDevice->coreaudio.audioUnitCapture != NULL) {
+        ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+    }
+    if (pDevice->coreaudio.audioUnitPlayback != NULL) {
+        ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+    }
+
+    if (pDevice->coreaudio.pAudioBufferList) {
+        ma_free(pDevice->coreaudio.pAudioBufferList, &pDevice->pContext->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+typedef struct
+{
+    ma_bool32 allowNominalSampleRateChange;
+
+    /* Input. */
+    ma_format formatIn;
+    ma_uint32 channelsIn;
+    ma_uint32 sampleRateIn;
+    ma_channel channelMapIn[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFramesIn;
+    ma_uint32 periodSizeInMillisecondsIn;
+    ma_uint32 periodsIn;
+    ma_share_mode shareMode;
+    ma_performance_profile performanceProfile;
+    ma_bool32 registerStopEvent;
+
+    /* Output. */
+#if defined(MA_APPLE_DESKTOP)
+    AudioObjectID deviceObjectID;
+#endif
+    AudioComponent component;
+    AudioUnit audioUnit;
+    AudioBufferList* pAudioBufferList;  /* Only used for input devices. */
+    ma_format formatOut;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRateOut;
+    ma_channel channelMapOut[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFramesOut;
+    ma_uint32 periodsOut;
+    char deviceName[256];
+} ma_device_init_internal_data__coreaudio;
+
+static ma_result ma_device_init_internal__coreaudio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_init_internal_data__coreaudio* pData, void* pDevice_DoNotReference)   /* <-- pDevice is typed as void* intentionally so as to avoid accidentally referencing it. */
+{
+    ma_result result = MA_SUCCESS;
+    OSStatus status;
+    UInt32 enableIOFlag;
+    AudioStreamBasicDescription bestFormat;
+    ma_uint32 actualPeriodSizeInFrames;
+    AURenderCallbackStruct callbackInfo;
+#if defined(MA_APPLE_DESKTOP)
+    AudioObjectID deviceObjectID;
+#endif
+
+    /* This API should only be used for a single device type: playback or capture. No full-duplex mode. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(deviceType == ma_device_type_playback || deviceType == ma_device_type_capture);
+
+#if defined(MA_APPLE_DESKTOP)
+    pData->deviceObjectID = 0;
+#endif
+    pData->component = NULL;
+    pData->audioUnit = NULL;
+    pData->pAudioBufferList = NULL;
+
+#if defined(MA_APPLE_DESKTOP)
+    result = ma_find_AudioObjectID(pContext, deviceType, pDeviceID, &deviceObjectID);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pData->deviceObjectID = deviceObjectID;
+#endif
+
+    /* Core audio doesn't really use the notion of a period so we can leave this unmodified, but not too over the top. */
+    pData->periodsOut = pData->periodsIn;
+    if (pData->periodsOut == 0) {
+        pData->periodsOut = MA_DEFAULT_PERIODS;
+    }
+    if (pData->periodsOut > 16) {
+        pData->periodsOut = 16;
+    }
+
+
+    /* Audio unit. */
+    status = ((ma_AudioComponentInstanceNew_proc)pContext->coreaudio.AudioComponentInstanceNew)((AudioComponent)pContext->coreaudio.component, (AudioUnit*)&pData->audioUnit);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+
+    /* The input/output buses need to be explicitly enabled and disabled. We set the flag based on the output unit first, then we just swap it for input. */
+    enableIOFlag = 1;
+    if (deviceType == ma_device_type_capture) {
+        enableIOFlag = 0;
+    }
+
+    status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, MA_COREAUDIO_OUTPUT_BUS, &enableIOFlag, sizeof(enableIOFlag));
+    if (status != noErr) {
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(status);
+    }
+
+    enableIOFlag = (enableIOFlag == 0) ? 1 : 0;
+    status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, MA_COREAUDIO_INPUT_BUS, &enableIOFlag, sizeof(enableIOFlag));
+    if (status != noErr) {
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(status);
+    }
+
+
+    /* Set the device to use with this audio unit. This is only used on desktop since we are using defaults on mobile. */
+#if defined(MA_APPLE_DESKTOP)
+    status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &deviceObjectID, sizeof(deviceObjectID));
+    if (status != noErr) {
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(result);
+    }
+#else
+    /*
+    For some reason it looks like Apple is only allowing selection of the input device. There does not appear to be any way to change
+    the default output route. I have no idea why this is like this, but for now we'll only be able to configure capture devices.
+    */
+    if (pDeviceID != NULL) {
+        if (deviceType == ma_device_type_capture) {
+            ma_bool32 found = MA_FALSE;
+            NSArray *pInputs = [[[AVAudioSession sharedInstance] currentRoute] inputs];
+            for (AVAudioSessionPortDescription* pPortDesc in pInputs) {
+                if (strcmp(pDeviceID->coreaudio, [pPortDesc.UID UTF8String]) == 0) {
+                    [[AVAudioSession sharedInstance] setPreferredInput:pPortDesc error:nil];
+                    found = MA_TRUE;
+                    break;
+                }
+            }
+
+            if (found == MA_FALSE) {
+                return MA_DOES_NOT_EXIST;
+            }
+        }
+    }
+#endif
+
+    /*
+    Format. This is the hardest part of initialization because there's a few variables to take into account.
+      1) The format must be supported by the device.
+      2) The format must be supported miniaudio.
+      3) There's a priority that miniaudio prefers.
+
+    Ideally we would like to use a format that's as close to the hardware as possible so we can get as close to a passthrough as possible. The
+    most important property is the sample rate. miniaudio can do format conversion for any sample rate and channel count, but cannot do the same
+    for the sample data format. If the sample data format is not supported by miniaudio it must be ignored completely.
+
+    On mobile platforms this is a bit different. We just force the use of whatever the audio unit's current format is set to.
+    */
+    {
+        AudioStreamBasicDescription origFormat;
+        UInt32 origFormatSize = sizeof(origFormat);
+        AudioUnitScope   formatScope   = (deviceType == ma_device_type_playback) ? kAudioUnitScope_Input : kAudioUnitScope_Output;
+        AudioUnitElement formatElement = (deviceType == ma_device_type_playback) ? MA_COREAUDIO_OUTPUT_BUS : MA_COREAUDIO_INPUT_BUS;
+
+        if (deviceType == ma_device_type_playback) {
+            status = ((ma_AudioUnitGetProperty_proc)pContext->coreaudio.AudioUnitGetProperty)(pData->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, MA_COREAUDIO_OUTPUT_BUS, &origFormat, &origFormatSize);
+        } else {
+            status = ((ma_AudioUnitGetProperty_proc)pContext->coreaudio.AudioUnitGetProperty)(pData->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, MA_COREAUDIO_INPUT_BUS, &origFormat, &origFormatSize);
+        }
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+
+    #if defined(MA_APPLE_DESKTOP)
+        result = ma_find_best_format__coreaudio(pContext, deviceObjectID, deviceType, pData->formatIn, pData->channelsIn, pData->sampleRateIn, &origFormat, &bestFormat);
+        if (result != MA_SUCCESS) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return result;
+        }
+
+        /*
+        Technical Note TN2091: Device input using the HAL Output Audio Unit
+            https://developer.apple.com/library/archive/technotes/tn2091/_index.html
+
+        This documentation says the following:
+
+            The internal AudioConverter can handle any *simple* conversion. Typically, this means that a client can specify ANY
+            variant of the PCM formats. Consequently, the device's sample rate should match the desired sample rate. If sample rate
+            conversion is needed, it can be accomplished by buffering the input and converting the data on a separate thread with
+            another AudioConverter.
+
+        The important part here is the mention that it can handle *simple* conversions, which does *not* include sample rate. We
+        therefore want to ensure the sample rate stays consistent. This document is specifically for input, but I'm going to play it
+        safe and apply the same rule to output as well.
+
+        I have tried going against the documentation by setting the sample rate anyway, but this just results in AudioUnitRender()
+        returning a result code of -10863. I have also tried changing the format directly on the input scope on the input bus, but
+        this just results in `ca_require: IsStreamFormatWritable(inScope, inElement) NotWritable` when trying to set the format.
+
+        Something that does seem to work, however, has been setting the nominal sample rate on the device object. The problem with
+        this, however, is that it actually changes the sample rate at the operating system level and not just the application. This
+        could be intrusive to the user, however, so I don't think it's wise to make this the default. Instead I'm making this a
+        configuration option. When the `coreaudio.allowNominalSampleRateChange` config option is set to true, changing the sample
+        rate will be allowed. Otherwise it'll be fixed to the current sample rate. To check the system-defined sample rate, run
+        the Audio MIDI Setup program that comes installed on macOS and observe how the sample rate changes as the sample rate is
+        changed by miniaudio.
+        */
+        if (pData->allowNominalSampleRateChange) {
+            AudioValueRange sampleRateRange;
+            AudioObjectPropertyAddress propAddress;
+
+            sampleRateRange.mMinimum = bestFormat.mSampleRate;
+            sampleRateRange.mMaximum = bestFormat.mSampleRate;
+
+            propAddress.mSelector = kAudioDevicePropertyNominalSampleRate;
+            propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+            propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+            status = ((ma_AudioObjectSetPropertyData_proc)pContext->coreaudio.AudioObjectSetPropertyData)(deviceObjectID, &propAddress, 0, NULL, sizeof(sampleRateRange), &sampleRateRange);
+            if (status != noErr) {
+                bestFormat.mSampleRate = origFormat.mSampleRate;
+            }
+        } else {
+            bestFormat.mSampleRate = origFormat.mSampleRate;
+        }
+
+        status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioUnitProperty_StreamFormat, formatScope, formatElement, &bestFormat, sizeof(bestFormat));
+        if (status != noErr) {
+            /* We failed to set the format, so fall back to the current format of the audio unit. */
+            bestFormat = origFormat;
+        }
+    #else
+        bestFormat = origFormat;
+
+        /*
+        Sample rate is a little different here because for some reason kAudioUnitProperty_StreamFormat returns 0... Oh well. We need to instead try
+        setting the sample rate to what the user has requested and then just see the results of it. Need to use some Objective-C here for this since
+        it depends on Apple's AVAudioSession API. To do this we just get the shared AVAudioSession instance and then set it. Note that from what I
+        can tell, it looks like the sample rate is shared between playback and capture for everything.
+        */
+        @autoreleasepool {
+            AVAudioSession* pAudioSession = [AVAudioSession sharedInstance];
+            MA_ASSERT(pAudioSession != NULL);
+
+            [pAudioSession setPreferredSampleRate:(double)pData->sampleRateIn error:nil];
+            bestFormat.mSampleRate = pAudioSession.sampleRate;
+
+            /*
+            I've had a report that the channel count returned by AudioUnitGetProperty above is inconsistent with
+            AVAudioSession outputNumberOfChannels. I'm going to try using the AVAudioSession values instead.
+
+            UPDATE 20/02/2025:
+            When testing on the simulator with an iPhone 15 and iOS 17 I get an error when initializing the audio
+            unit if set the input channels to pAudioSession.inputNumberOfChannels. What is happening is the channel
+            count returned from AudioUnitGetProperty() above is set to 2, but pAudioSession is reporting a channel
+            count of 1. When this happens, the call to AudioUnitSetProprty() below just down below will succeed, but
+            AudioUnitInitialize() further down will fail. The only solution I have come up with is to not set the
+            channel count to pAudioSession.inputNumberOfChannels.
+            */
+            if (deviceType == ma_device_type_playback) {
+                bestFormat.mChannelsPerFrame = (UInt32)pAudioSession.outputNumberOfChannels;
+            }
+
+            #if 0
+            if (deviceType == ma_device_type_capture) {
+                /*printf("DEBUG: bestFormat.mChannelsPerFrame = %d; pAudioSession.inputNumberOfChannels = %d\n", (int)bestFormat.mChannelsPerFrame, (int)pAudioSession.inputNumberOfChannels);*/
+                bestFormat.mChannelsPerFrame = (UInt32)pAudioSession.inputNumberOfChannels;
+            }
+            #endif
+        }
+
+        
+        status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioUnitProperty_StreamFormat, formatScope, formatElement, &bestFormat, sizeof(bestFormat));
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+    #endif
+
+        result = ma_format_from_AudioStreamBasicDescription(&bestFormat, &pData->formatOut);
+        if (result != MA_SUCCESS) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return result;
+        }
+
+        if (pData->formatOut == ma_format_unknown) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        pData->channelsOut   = bestFormat.mChannelsPerFrame;
+        pData->sampleRateOut = (ma_uint32)bestFormat.mSampleRate;
+    }
+
+    /* Clamp the channel count for safety. */
+    if (pData->channelsOut > MA_MAX_CHANNELS) {
+        pData->channelsOut = MA_MAX_CHANNELS;
+    }
+
+    /*
+    Internal channel map. This is weird in my testing. If I use the AudioObject to get the
+    channel map, the channel descriptions are set to "Unknown" for some reason. To work around
+    this it looks like retrieving it from the AudioUnit will work. However, and this is where
+    it gets weird, it doesn't seem to work with capture devices, nor at all on iOS... Therefore
+    I'm going to fall back to a default assumption in these cases.
+    */
+#if defined(MA_APPLE_DESKTOP)
+    result = ma_get_AudioUnit_channel_map(pContext, pData->audioUnit, deviceType, pData->channelMapOut, pData->channelsOut);
+    if (result != MA_SUCCESS) {
+    #if 0
+        /* Try falling back to the channel map from the AudioObject. */
+        result = ma_get_AudioObject_channel_map(pContext, deviceObjectID, deviceType, pData->channelMapOut, pData->channelsOut);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    #else
+        /* Fall back to default assumptions. */
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pData->channelMapOut, ma_countof(pData->channelMapOut), pData->channelsOut);
+    #endif
+    }
+#else
+    /* TODO: Figure out how to get the channel map using AVAudioSession. */
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pData->channelMapOut, ma_countof(pData->channelMapOut), pData->channelsOut);
+#endif
+
+
+    /* Buffer size. Not allowing this to be configurable on iOS. */
+    if (pData->periodSizeInFramesIn == 0) {
+        if (pData->periodSizeInMillisecondsIn == 0) {
+            if (pData->performanceProfile == ma_performance_profile_low_latency) {
+                actualPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY, pData->sampleRateOut);
+            } else {
+                actualPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE, pData->sampleRateOut);
+            }
+        } else {
+            actualPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(pData->periodSizeInMillisecondsIn, pData->sampleRateOut);
+        }
+    } else {
+        actualPeriodSizeInFrames = pData->periodSizeInFramesIn;
+    }
+
+#if defined(MA_APPLE_DESKTOP)
+    result = ma_set_AudioObject_buffer_size_in_frames(pContext, deviceObjectID, deviceType, &actualPeriodSizeInFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+#else
+    /*
+    On iOS, the size of the IO buffer needs to be specified in seconds and is a floating point
+    number. I don't trust any potential truncation errors due to converting from float to integer
+    so I'm going to explicitly set the actual period size to the next power of 2.
+    */
+    @autoreleasepool {
+        AVAudioSession* pAudioSession = [AVAudioSession sharedInstance];
+        MA_ASSERT(pAudioSession != NULL);
+
+        [pAudioSession setPreferredIOBufferDuration:((float)actualPeriodSizeInFrames / pAudioSession.sampleRate) error:nil];
+        actualPeriodSizeInFrames = ma_next_power_of_2((ma_uint32)(pAudioSession.IOBufferDuration * pAudioSession.sampleRate));
+    }
+#endif
+
+
+    /*
+    During testing I discovered that the buffer size can be too big. You'll get an error like this:
+
+      kAudioUnitErr_TooManyFramesToProcess : inFramesToProcess=4096, mMaxFramesPerSlice=512
+
+    Note how inFramesToProcess is smaller than mMaxFramesPerSlice. To fix, we need to set kAudioUnitProperty_MaximumFramesPerSlice to that
+    of the size of our buffer, or do it the other way around and set our buffer size to the kAudioUnitProperty_MaximumFramesPerSlice.
+    */
+    status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, &actualPeriodSizeInFrames, sizeof(actualPeriodSizeInFrames));
+    if (status != noErr) {
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(status);
+    }
+
+    pData->periodSizeInFramesOut = (ma_uint32)actualPeriodSizeInFrames;
+
+    /* We need a buffer list if this is an input device. We render into this in the input callback. */
+    if (deviceType == ma_device_type_capture) {
+        ma_bool32 isInterleaved = (bestFormat.mFormatFlags & kAudioFormatFlagIsNonInterleaved) == 0;
+        AudioBufferList* pBufferList;
+
+        pBufferList = ma_allocate_AudioBufferList__coreaudio(pData->periodSizeInFramesOut, pData->formatOut, pData->channelsOut, (isInterleaved) ? ma_stream_layout_interleaved : ma_stream_layout_deinterleaved, &pContext->allocationCallbacks);
+        if (pBufferList == NULL) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        pData->pAudioBufferList = pBufferList;
+    }
+
+    /* Callbacks. */
+    callbackInfo.inputProcRefCon = pDevice_DoNotReference;
+    if (deviceType == ma_device_type_playback) {
+        callbackInfo.inputProc = ma_on_output__coreaudio;
+        status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Global, 0, &callbackInfo, sizeof(callbackInfo));
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+    } else {
+        callbackInfo.inputProc = ma_on_input__coreaudio;
+        status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &callbackInfo, sizeof(callbackInfo));
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    /* We need to listen for stop events. */
+    if (pData->registerStopEvent) {
+        status = ((ma_AudioUnitAddPropertyListener_proc)pContext->coreaudio.AudioUnitAddPropertyListener)(pData->audioUnit, kAudioOutputUnitProperty_IsRunning, on_start_stop__coreaudio, pDevice_DoNotReference);
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    /* Initialize the audio unit. */
+    status = ((ma_AudioUnitInitialize_proc)pContext->coreaudio.AudioUnitInitialize)(pData->audioUnit);
+    if (status != noErr) {
+        ma_free(pData->pAudioBufferList, &pContext->allocationCallbacks);
+        pData->pAudioBufferList = NULL;
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(status);
+    }
+
+    /* Grab the name. */
+#if defined(MA_APPLE_DESKTOP)
+    ma_get_AudioObject_name(pContext, deviceObjectID, sizeof(pData->deviceName), pData->deviceName);
+#else
+    if (deviceType == ma_device_type_playback) {
+        ma_strcpy_s(pData->deviceName, sizeof(pData->deviceName), MA_DEFAULT_PLAYBACK_DEVICE_NAME);
+    } else {
+        ma_strcpy_s(pData->deviceName, sizeof(pData->deviceName), MA_DEFAULT_CAPTURE_DEVICE_NAME);
+    }
+#endif
+
+    return result;
+}
+
+#if defined(MA_APPLE_DESKTOP)
+static ma_result ma_device_reinit_internal__coreaudio(ma_device* pDevice, ma_device_type deviceType, ma_bool32 disposePreviousAudioUnit)
+{
+    ma_device_init_internal_data__coreaudio data;
+    ma_result result;
+
+    /* This should only be called for playback or capture, not duplex. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    data.allowNominalSampleRateChange = MA_FALSE;   /* Don't change the nominal sample rate when switching devices. */
+
+    if (deviceType == ma_device_type_capture) {
+        data.formatIn               = pDevice->capture.format;
+        data.channelsIn             = pDevice->capture.channels;
+        data.sampleRateIn           = pDevice->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDevice->capture.channelMap, sizeof(pDevice->capture.channelMap));
+        data.shareMode              = pDevice->capture.shareMode;
+        data.performanceProfile     = pDevice->coreaudio.originalPerformanceProfile;
+        data.registerStopEvent      = MA_TRUE;
+
+        if (disposePreviousAudioUnit) {
+            ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+            ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+        }
+        if (pDevice->coreaudio.pAudioBufferList) {
+            ma_free(pDevice->coreaudio.pAudioBufferList, &pDevice->pContext->allocationCallbacks);
+        }
+    } else if (deviceType == ma_device_type_playback) {
+        data.formatIn               = pDevice->playback.format;
+        data.channelsIn             = pDevice->playback.channels;
+        data.sampleRateIn           = pDevice->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDevice->playback.channelMap, sizeof(pDevice->playback.channelMap));
+        data.shareMode              = pDevice->playback.shareMode;
+        data.performanceProfile     = pDevice->coreaudio.originalPerformanceProfile;
+        data.registerStopEvent      = (pDevice->type != ma_device_type_duplex);
+
+        if (disposePreviousAudioUnit) {
+            ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+            ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+        }
+    }
+    data.periodSizeInFramesIn       = pDevice->coreaudio.originalPeriodSizeInFrames;
+    data.periodSizeInMillisecondsIn = pDevice->coreaudio.originalPeriodSizeInMilliseconds;
+    data.periodsIn                  = pDevice->coreaudio.originalPeriods;
+
+    /* Need at least 3 periods for duplex. */
+    if (data.periodsIn < 3 && pDevice->type == ma_device_type_duplex) {
+        data.periodsIn = 3;
+    }
+
+    result = ma_device_init_internal__coreaudio(pDevice->pContext, deviceType, NULL, &data, (void*)pDevice);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (deviceType == ma_device_type_capture) {
+    #if defined(MA_APPLE_DESKTOP)
+        pDevice->coreaudio.deviceObjectIDCapture     = (ma_uint32)data.deviceObjectID;
+        ma_get_AudioObject_uid(pDevice->pContext, pDevice->coreaudio.deviceObjectIDCapture, sizeof(pDevice->capture.id.coreaudio), pDevice->capture.id.coreaudio);
+    #endif
+        pDevice->coreaudio.audioUnitCapture          = (ma_ptr)data.audioUnit;
+        pDevice->coreaudio.pAudioBufferList          = (ma_ptr)data.pAudioBufferList;
+        pDevice->coreaudio.audioBufferCapInFrames    = data.periodSizeInFramesOut;
+
+        pDevice->capture.internalFormat              = data.formatOut;
+        pDevice->capture.internalChannels            = data.channelsOut;
+        pDevice->capture.internalSampleRate          = data.sampleRateOut;
+        MA_COPY_MEMORY(pDevice->capture.internalChannelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDevice->capture.internalPeriodSizeInFrames  = data.periodSizeInFramesOut;
+        pDevice->capture.internalPeriods             = data.periodsOut;
+    } else if (deviceType == ma_device_type_playback) {
+    #if defined(MA_APPLE_DESKTOP)
+        pDevice->coreaudio.deviceObjectIDPlayback    = (ma_uint32)data.deviceObjectID;
+        ma_get_AudioObject_uid(pDevice->pContext, pDevice->coreaudio.deviceObjectIDPlayback, sizeof(pDevice->playback.id.coreaudio), pDevice->playback.id.coreaudio);
+    #endif
+        pDevice->coreaudio.audioUnitPlayback         = (ma_ptr)data.audioUnit;
+
+        pDevice->playback.internalFormat             = data.formatOut;
+        pDevice->playback.internalChannels           = data.channelsOut;
+        pDevice->playback.internalSampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDevice->playback.internalChannelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDevice->playback.internalPeriodSizeInFrames = data.periodSizeInFramesOut;
+        pDevice->playback.internalPeriods            = data.periodsOut;
+    }
+
+    return MA_SUCCESS;
+}
+#endif /* MA_APPLE_DESKTOP */
+
+static ma_result ma_device_init__coreaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pConfig != NULL);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* No exclusive mode with the Core Audio backend for now. */
+    if (((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    /* Capture needs to be initialized first. */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_device_init_internal_data__coreaudio data;
+        data.allowNominalSampleRateChange = pConfig->coreaudio.allowNominalSampleRateChange;
+        data.formatIn                     = pDescriptorCapture->format;
+        data.channelsIn                   = pDescriptorCapture->channels;
+        data.sampleRateIn                 = pDescriptorCapture->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDescriptorCapture->channelMap, sizeof(pDescriptorCapture->channelMap));
+        data.periodSizeInFramesIn         = pDescriptorCapture->periodSizeInFrames;
+        data.periodSizeInMillisecondsIn   = pDescriptorCapture->periodSizeInMilliseconds;
+        data.periodsIn                    = pDescriptorCapture->periodCount;
+        data.shareMode                    = pDescriptorCapture->shareMode;
+        data.performanceProfile           = pConfig->performanceProfile;
+        data.registerStopEvent            = MA_TRUE;
+
+        /* Need at least 3 periods for duplex. */
+        if (data.periodsIn < 3 && pConfig->deviceType == ma_device_type_duplex) {
+            data.periodsIn = 3;
+        }
+
+        result = ma_device_init_internal__coreaudio(pDevice->pContext, ma_device_type_capture, pDescriptorCapture->pDeviceID, &data, (void*)pDevice);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pDevice->coreaudio.isDefaultCaptureDevice           = (pConfig->capture.pDeviceID == NULL);
+    #if defined(MA_APPLE_DESKTOP)
+        pDevice->coreaudio.deviceObjectIDCapture            = (ma_uint32)data.deviceObjectID;
+    #endif
+        pDevice->coreaudio.audioUnitCapture                 = (ma_ptr)data.audioUnit;
+        pDevice->coreaudio.pAudioBufferList                 = (ma_ptr)data.pAudioBufferList;
+        pDevice->coreaudio.audioBufferCapInFrames           = data.periodSizeInFramesOut;
+        pDevice->coreaudio.originalPeriodSizeInFrames       = pDescriptorCapture->periodSizeInFrames;
+        pDevice->coreaudio.originalPeriodSizeInMilliseconds = pDescriptorCapture->periodSizeInMilliseconds;
+        pDevice->coreaudio.originalPeriods                  = pDescriptorCapture->periodCount;
+        pDevice->coreaudio.originalPerformanceProfile       = pConfig->performanceProfile;
+
+        pDescriptorCapture->format                          = data.formatOut;
+        pDescriptorCapture->channels                        = data.channelsOut;
+        pDescriptorCapture->sampleRate                      = data.sampleRateOut;
+        MA_COPY_MEMORY(pDescriptorCapture->channelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDescriptorCapture->periodSizeInFrames              = data.periodSizeInFramesOut;
+        pDescriptorCapture->periodCount                     = data.periodsOut;
+
+    #if defined(MA_APPLE_DESKTOP)
+        ma_get_AudioObject_uid(pDevice->pContext, pDevice->coreaudio.deviceObjectIDCapture, sizeof(pDevice->capture.id.coreaudio), pDevice->capture.id.coreaudio);
+
+        /*
+        If we are using the default device we'll need to listen for changes to the system's default device so we can seamlessly
+        switch the device in the background.
+        */
+        if (pConfig->capture.pDeviceID == NULL) {
+            ma_device__track__coreaudio(pDevice);
+        }
+    #endif
+    }
+
+    /* Playback. */
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_device_init_internal_data__coreaudio data;
+        data.allowNominalSampleRateChange   = pConfig->coreaudio.allowNominalSampleRateChange;
+        data.formatIn                       = pDescriptorPlayback->format;
+        data.channelsIn                     = pDescriptorPlayback->channels;
+        data.sampleRateIn                   = pDescriptorPlayback->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDescriptorPlayback->channelMap, sizeof(pDescriptorPlayback->channelMap));
+        data.shareMode                      = pDescriptorPlayback->shareMode;
+        data.performanceProfile             = pConfig->performanceProfile;
+
+        /* In full-duplex mode we want the playback buffer to be the same size as the capture buffer. */
+        if (pConfig->deviceType == ma_device_type_duplex) {
+            data.periodSizeInFramesIn       = pDescriptorCapture->periodSizeInFrames;
+            data.periodsIn                  = pDescriptorCapture->periodCount;
+            data.registerStopEvent          = MA_FALSE;
+        } else {
+            data.periodSizeInFramesIn       = pDescriptorPlayback->periodSizeInFrames;
+            data.periodSizeInMillisecondsIn = pDescriptorPlayback->periodSizeInMilliseconds;
+            data.periodsIn                  = pDescriptorPlayback->periodCount;
+            data.registerStopEvent          = MA_TRUE;
+        }
+
+        result = ma_device_init_internal__coreaudio(pDevice->pContext, ma_device_type_playback, pDescriptorPlayback->pDeviceID, &data, (void*)pDevice);
+        if (result != MA_SUCCESS) {
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+                if (pDevice->coreaudio.pAudioBufferList) {
+                    ma_free(pDevice->coreaudio.pAudioBufferList, &pDevice->pContext->allocationCallbacks);
+                }
+            }
+            return result;
+        }
+
+        pDevice->coreaudio.isDefaultPlaybackDevice          = (pConfig->playback.pDeviceID == NULL);
+    #if defined(MA_APPLE_DESKTOP)
+        pDevice->coreaudio.deviceObjectIDPlayback           = (ma_uint32)data.deviceObjectID;
+    #endif
+        pDevice->coreaudio.audioUnitPlayback                = (ma_ptr)data.audioUnit;
+        pDevice->coreaudio.originalPeriodSizeInFrames       = pDescriptorPlayback->periodSizeInFrames;
+        pDevice->coreaudio.originalPeriodSizeInMilliseconds = pDescriptorPlayback->periodSizeInMilliseconds;
+        pDevice->coreaudio.originalPeriods                  = pDescriptorPlayback->periodCount;
+        pDevice->coreaudio.originalPerformanceProfile       = pConfig->performanceProfile;
+
+        pDescriptorPlayback->format                         = data.formatOut;
+        pDescriptorPlayback->channels                       = data.channelsOut;
+        pDescriptorPlayback->sampleRate                     = data.sampleRateOut;
+        MA_COPY_MEMORY(pDescriptorPlayback->channelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDescriptorPlayback->periodSizeInFrames             = data.periodSizeInFramesOut;
+        pDescriptorPlayback->periodCount                    = data.periodsOut;
+
+    #if defined(MA_APPLE_DESKTOP)
+        ma_get_AudioObject_uid(pDevice->pContext, pDevice->coreaudio.deviceObjectIDPlayback, sizeof(pDevice->playback.id.coreaudio), pDevice->playback.id.coreaudio);
+
+        /*
+        If we are using the default device we'll need to listen for changes to the system's default device so we can seamlessly
+        switch the device in the background.
+        */
+        if (pDescriptorPlayback->pDeviceID == NULL && (pConfig->deviceType != ma_device_type_duplex || pDescriptorCapture->pDeviceID != NULL)) {
+            ma_device__track__coreaudio(pDevice);
+        }
+    #endif
+    }
+
+
+
+    /*
+    When stopping the device, a callback is called on another thread. We need to wait for this callback
+    before returning from ma_device_stop(). This event is used for this.
+    */
+    ma_event_init(&pDevice->coreaudio.stopEvent);
+
+    /*
+    We need to detect when a route has changed so we can update the data conversion pipeline accordingly. This is done
+    differently on non-Desktop Apple platforms.
+    */
+#if defined(MA_APPLE_MOBILE)
+    pDevice->coreaudio.pNotificationHandler = (MA_BRIDGE_RETAINED void*)[[ma_ios_notification_handler alloc] init:pDevice];
+#endif
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_start__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        OSStatus status = ((ma_AudioOutputUnitStart_proc)pDevice->pContext->coreaudio.AudioOutputUnitStart)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+        if (status != noErr) {
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        OSStatus status = ((ma_AudioOutputUnitStart_proc)pDevice->pContext->coreaudio.AudioOutputUnitStart)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+        if (status != noErr) {
+            if (pDevice->type == ma_device_type_duplex) {
+                ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+            }
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* It's not clear from the documentation whether or not AudioOutputUnitStop() actually drains the device or not. */
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        OSStatus status = ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+        if (status != noErr) {
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        OSStatus status = ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+        if (status != noErr) {
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    /* We need to wait for the callback to finish before returning. */
+    ma_event_wait(&pDevice->coreaudio.stopEvent);
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__coreaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_coreaudio);
+
+#if defined(MA_APPLE_MOBILE)
+    if (!pContext->coreaudio.noAudioSessionDeactivate) {
+        if (![[AVAudioSession sharedInstance] setActive:false error:nil]) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "Failed to deactivate audio session.");
+            return MA_FAILED_TO_INIT_BACKEND;
+        }
+    }
+#endif
+
+#if !defined(MA_NO_RUNTIME_LINKING) && !defined(MA_APPLE_MOBILE)
+    ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit);
+    ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+    ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+#endif
+
+#if !defined(MA_APPLE_MOBILE)
+    ma_context__uninit_device_tracking__coreaudio(pContext);
+#endif
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+#if defined(MA_APPLE_MOBILE) && defined(__IPHONE_12_0)
+static AVAudioSessionCategory ma_to_AVAudioSessionCategory(ma_ios_session_category category)
+{
+    /* The "default" and "none" categories are treated different and should not be used as an input into this function. */
+    MA_ASSERT(category != ma_ios_session_category_default);
+    MA_ASSERT(category != ma_ios_session_category_none);
+
+    switch (category) {
+        case ma_ios_session_category_ambient:         return AVAudioSessionCategoryAmbient;
+        case ma_ios_session_category_solo_ambient:    return AVAudioSessionCategorySoloAmbient;
+        case ma_ios_session_category_playback:        return AVAudioSessionCategoryPlayback;
+        case ma_ios_session_category_record:          return AVAudioSessionCategoryRecord;
+        case ma_ios_session_category_play_and_record: return AVAudioSessionCategoryPlayAndRecord;
+        case ma_ios_session_category_multi_route:     return AVAudioSessionCategoryMultiRoute;
+        case ma_ios_session_category_none:            return AVAudioSessionCategoryAmbient;
+        case ma_ios_session_category_default:         return AVAudioSessionCategoryAmbient;
+        default:                                      return AVAudioSessionCategoryAmbient;
+    }
+}
+#endif
+
+static ma_result ma_context_init__coreaudio(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+#if !defined(MA_APPLE_MOBILE)
+    ma_result result;
+#endif
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pContext != NULL);
+
+#if defined(MA_APPLE_MOBILE)
+    @autoreleasepool {
+        AVAudioSession* pAudioSession = [AVAudioSession sharedInstance];
+        AVAudioSessionCategoryOptions options = pConfig->coreaudio.sessionCategoryOptions;
+
+        MA_ASSERT(pAudioSession != NULL);
+
+        if (pConfig->coreaudio.sessionCategory == ma_ios_session_category_default) {
+            /*
+            I'm going to use trial and error to determine our default session category. First we'll try PlayAndRecord. If that fails
+            we'll try Playback and if that fails we'll try record. If all of these fail we'll just not set the category.
+            */
+        #if !defined(MA_APPLE_TV) && !defined(MA_APPLE_WATCH)
+            options |= AVAudioSessionCategoryOptionDefaultToSpeaker;
+        #endif
+
+            if ([pAudioSession setCategory: AVAudioSessionCategoryPlayAndRecord withOptions:options error:nil]) {
+                /* Using PlayAndRecord */
+            } else if ([pAudioSession setCategory: AVAudioSessionCategoryPlayback withOptions:options error:nil]) {
+                /* Using Playback */
+            } else if ([pAudioSession setCategory: AVAudioSessionCategoryRecord withOptions:options error:nil]) {
+                /* Using Record */
+            } else {
+                /* Leave as default? */
+            }
+        } else {
+            if (pConfig->coreaudio.sessionCategory != ma_ios_session_category_none) {
+            #if defined(__IPHONE_12_0)
+                if (![pAudioSession setCategory: ma_to_AVAudioSessionCategory(pConfig->coreaudio.sessionCategory) withOptions:options error:nil]) {
+                    return MA_INVALID_OPERATION;    /* Failed to set session category. */
+                }
+            #else
+                /* Ignore the session category on version 11 and older, but post a warning. */
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "Session category only supported in iOS 12 and newer.");
+            #endif
+            }
+        }
+
+        if (!pConfig->coreaudio.noAudioSessionActivate) {
+            if (![pAudioSession setActive:true error:nil]) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "Failed to activate audio session.");
+                return MA_FAILED_TO_INIT_BACKEND;
+            }
+        }
+    }
+#endif
+
+#if !defined(MA_NO_RUNTIME_LINKING) && !defined(MA_APPLE_MOBILE)
+    pContext->coreaudio.hCoreFoundation = ma_dlopen(ma_context_get_log(pContext), "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation");
+    if (pContext->coreaudio.hCoreFoundation == NULL) {
+        return MA_API_NOT_FOUND;
+    }
+
+    pContext->coreaudio.CFStringGetCString = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation, "CFStringGetCString");
+    pContext->coreaudio.CFRelease          = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation, "CFRelease");
+
+
+    pContext->coreaudio.hCoreAudio = ma_dlopen(ma_context_get_log(pContext), "/System/Library/Frameworks/CoreAudio.framework/CoreAudio");
+    if (pContext->coreaudio.hCoreAudio == NULL) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+        return MA_API_NOT_FOUND;
+    }
+
+    pContext->coreaudio.AudioObjectGetPropertyData        = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectGetPropertyData");
+    pContext->coreaudio.AudioObjectGetPropertyDataSize    = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectGetPropertyDataSize");
+    pContext->coreaudio.AudioObjectSetPropertyData        = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectSetPropertyData");
+    pContext->coreaudio.AudioObjectAddPropertyListener    = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectAddPropertyListener");
+    pContext->coreaudio.AudioObjectRemovePropertyListener = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectRemovePropertyListener");
+
+    /*
+    It looks like Apple has moved some APIs from AudioUnit into AudioToolbox on more recent versions of macOS. They are still
+    defined in AudioUnit, but just in case they decide to remove them from there entirely I'm going to implement a fallback.
+    The way it'll work is that it'll first try AudioUnit, and if the required symbols are not present there we'll fall back to
+    AudioToolbox.
+    */
+    pContext->coreaudio.hAudioUnit = ma_dlopen(ma_context_get_log(pContext), "/System/Library/Frameworks/AudioUnit.framework/AudioUnit");
+    if (pContext->coreaudio.hAudioUnit == NULL) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+        return MA_API_NOT_FOUND;
+    }
+
+    if (ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioComponentFindNext") == NULL) {
+        /* Couldn't find the required symbols in AudioUnit, so fall back to AudioToolbox. */
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit);
+        pContext->coreaudio.hAudioUnit = ma_dlopen(ma_context_get_log(pContext), "/System/Library/Frameworks/AudioToolbox.framework/AudioToolbox");
+        if (pContext->coreaudio.hAudioUnit == NULL) {
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+            return MA_API_NOT_FOUND;
+        }
+    }
+
+    pContext->coreaudio.AudioComponentFindNext            = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioComponentFindNext");
+    pContext->coreaudio.AudioComponentInstanceDispose     = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioComponentInstanceDispose");
+    pContext->coreaudio.AudioComponentInstanceNew         = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioComponentInstanceNew");
+    pContext->coreaudio.AudioOutputUnitStart              = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioOutputUnitStart");
+    pContext->coreaudio.AudioOutputUnitStop               = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioOutputUnitStop");
+    pContext->coreaudio.AudioUnitAddPropertyListener      = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitAddPropertyListener");
+    pContext->coreaudio.AudioUnitGetPropertyInfo          = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitGetPropertyInfo");
+    pContext->coreaudio.AudioUnitGetProperty              = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitGetProperty");
+    pContext->coreaudio.AudioUnitSetProperty              = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitSetProperty");
+    pContext->coreaudio.AudioUnitInitialize               = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitInitialize");
+    pContext->coreaudio.AudioUnitRender                   = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitRender");
+#else
+    pContext->coreaudio.CFStringGetCString                = (ma_proc)CFStringGetCString;
+    pContext->coreaudio.CFRelease                         = (ma_proc)CFRelease;
+
+    #if defined(MA_APPLE_DESKTOP)
+    pContext->coreaudio.AudioObjectGetPropertyData        = (ma_proc)AudioObjectGetPropertyData;
+    pContext->coreaudio.AudioObjectGetPropertyDataSize    = (ma_proc)AudioObjectGetPropertyDataSize;
+    pContext->coreaudio.AudioObjectSetPropertyData        = (ma_proc)AudioObjectSetPropertyData;
+    pContext->coreaudio.AudioObjectAddPropertyListener    = (ma_proc)AudioObjectAddPropertyListener;
+    pContext->coreaudio.AudioObjectRemovePropertyListener = (ma_proc)AudioObjectRemovePropertyListener;
+    #endif
+
+    pContext->coreaudio.AudioComponentFindNext            = (ma_proc)AudioComponentFindNext;
+    pContext->coreaudio.AudioComponentInstanceDispose     = (ma_proc)AudioComponentInstanceDispose;
+    pContext->coreaudio.AudioComponentInstanceNew         = (ma_proc)AudioComponentInstanceNew;
+    pContext->coreaudio.AudioOutputUnitStart              = (ma_proc)AudioOutputUnitStart;
+    pContext->coreaudio.AudioOutputUnitStop               = (ma_proc)AudioOutputUnitStop;
+    pContext->coreaudio.AudioUnitAddPropertyListener      = (ma_proc)AudioUnitAddPropertyListener;
+    pContext->coreaudio.AudioUnitGetPropertyInfo          = (ma_proc)AudioUnitGetPropertyInfo;
+    pContext->coreaudio.AudioUnitGetProperty              = (ma_proc)AudioUnitGetProperty;
+    pContext->coreaudio.AudioUnitSetProperty              = (ma_proc)AudioUnitSetProperty;
+    pContext->coreaudio.AudioUnitInitialize               = (ma_proc)AudioUnitInitialize;
+    pContext->coreaudio.AudioUnitRender                   = (ma_proc)AudioUnitRender;
+#endif
+
+    /* Audio component. */
+    {
+        AudioComponentDescription desc;
+        desc.componentType         = kAudioUnitType_Output;
+    #if defined(MA_APPLE_DESKTOP)
+        desc.componentSubType      = kAudioUnitSubType_HALOutput;
+    #else
+        desc.componentSubType      = kAudioUnitSubType_RemoteIO;
+    #endif
+        desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+        desc.componentFlags        = 0;
+        desc.componentFlagsMask    = 0;
+
+        pContext->coreaudio.component = ((ma_AudioComponentFindNext_proc)pContext->coreaudio.AudioComponentFindNext)(NULL, &desc);
+        if (pContext->coreaudio.component == NULL) {
+        #if !defined(MA_NO_RUNTIME_LINKING) && !defined(MA_APPLE_MOBILE)
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit);
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+        #endif
+            return MA_FAILED_TO_INIT_BACKEND;
+        }
+    }
+
+#if !defined(MA_APPLE_MOBILE)
+    result = ma_context__init_device_tracking__coreaudio(pContext);
+    if (result != MA_SUCCESS) {
+    #if !defined(MA_NO_RUNTIME_LINKING) && !defined(MA_APPLE_MOBILE)
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit);
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+    #endif
+        return result;
+    }
+#endif
+
+    pContext->coreaudio.noAudioSessionDeactivate = pConfig->coreaudio.noAudioSessionDeactivate;
+
+    pCallbacks->onContextInit             = ma_context_init__coreaudio;
+    pCallbacks->onContextUninit           = ma_context_uninit__coreaudio;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__coreaudio;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__coreaudio;
+    pCallbacks->onDeviceInit              = ma_device_init__coreaudio;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__coreaudio;
+    pCallbacks->onDeviceStart             = ma_device_start__coreaudio;
+    pCallbacks->onDeviceStop              = ma_device_stop__coreaudio;
+    pCallbacks->onDeviceRead              = NULL;
+    pCallbacks->onDeviceWrite             = NULL;
+    pCallbacks->onDeviceDataLoop          = NULL;
+
+    return MA_SUCCESS;
+}
+#endif  /* MA_HAS_COREAUDIO */
+
+
+
+/******************************************************************************
+
+sndio Backend
+
+******************************************************************************/
+#ifdef MA_HAS_SNDIO
+#include <fcntl.h>
+
+/*
+Only supporting OpenBSD. This did not work very well at all on FreeBSD when I tried it. Not sure if this is due
+to miniaudio's implementation or if it's some kind of system configuration issue, but basically the default device
+just doesn't emit any sound, or at times you'll hear tiny pieces. I will consider enabling this when there's
+demand for it or if I can get it tested and debugged more thoroughly.
+*/
+#if 0
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <sys/audioio.h>
+#endif
+#if defined(__FreeBSD__) || defined(__DragonFly__)
+#include <sys/soundcard.h>
+#endif
+#endif
+
+#define MA_SIO_DEVANY   "default"
+#define MA_SIO_PLAY     1
+#define MA_SIO_REC      2
+#define MA_SIO_NENC     8
+#define MA_SIO_NCHAN    8
+#define MA_SIO_NRATE    16
+#define MA_SIO_NCONF    4
+
+struct ma_sio_hdl; /* <-- Opaque */
+
+struct ma_sio_par
+{
+    unsigned int bits;
+    unsigned int bps;
+    unsigned int sig;
+    unsigned int le;
+    unsigned int msb;
+    unsigned int rchan;
+    unsigned int pchan;
+    unsigned int rate;
+    unsigned int bufsz;
+    unsigned int xrun;
+    unsigned int round;
+    unsigned int appbufsz;
+    int __pad[3];
+    unsigned int __magic;
+};
+
+struct ma_sio_enc
+{
+    unsigned int bits;
+    unsigned int bps;
+    unsigned int sig;
+    unsigned int le;
+    unsigned int msb;
+};
+
+struct ma_sio_conf
+{
+    unsigned int enc;
+    unsigned int rchan;
+    unsigned int pchan;
+    unsigned int rate;
+};
+
+struct ma_sio_cap
+{
+    struct ma_sio_enc enc[MA_SIO_NENC];
+    unsigned int rchan[MA_SIO_NCHAN];
+    unsigned int pchan[MA_SIO_NCHAN];
+    unsigned int rate[MA_SIO_NRATE];
+    int __pad[7];
+    unsigned int nconf;
+    struct ma_sio_conf confs[MA_SIO_NCONF];
+};
+
+typedef struct ma_sio_hdl* (* ma_sio_open_proc)   (const char*, unsigned int, int);
+typedef void               (* ma_sio_close_proc)  (struct ma_sio_hdl*);
+typedef int                (* ma_sio_setpar_proc) (struct ma_sio_hdl*, struct ma_sio_par*);
+typedef int                (* ma_sio_getpar_proc) (struct ma_sio_hdl*, struct ma_sio_par*);
+typedef int                (* ma_sio_getcap_proc) (struct ma_sio_hdl*, struct ma_sio_cap*);
+typedef size_t             (* ma_sio_write_proc)  (struct ma_sio_hdl*, const void*, size_t);
+typedef size_t             (* ma_sio_read_proc)   (struct ma_sio_hdl*, void*, size_t);
+typedef int                (* ma_sio_start_proc)  (struct ma_sio_hdl*);
+typedef int                (* ma_sio_stop_proc)   (struct ma_sio_hdl*);
+typedef int                (* ma_sio_initpar_proc)(struct ma_sio_par*);
+
+static ma_uint32 ma_get_standard_sample_rate_priority_index__sndio(ma_uint32 sampleRate)   /* Lower = higher priority */
+{
+    ma_uint32 i;
+    for (i = 0; i < ma_countof(g_maStandardSampleRatePriorities); ++i) {
+        if (g_maStandardSampleRatePriorities[i] == sampleRate) {
+            return i;
+        }
+    }
+
+    return (ma_uint32)-1;
+}
+
+static ma_format ma_format_from_sio_enc__sndio(unsigned int bits, unsigned int bps, unsigned int sig, unsigned int le, unsigned int msb)
+{
+    /* We only support native-endian right now. */
+    if ((ma_is_little_endian() && le == 0) || (ma_is_big_endian() && le == 1)) {
+        return ma_format_unknown;
+    }
+
+    if (bits ==  8 && bps == 1 && sig == 0) {
+        return ma_format_u8;
+    }
+    if (bits == 16 && bps == 2 && sig == 1) {
+        return ma_format_s16;
+    }
+    if (bits == 24 && bps == 3 && sig == 1) {
+        return ma_format_s24;
+    }
+    if (bits == 24 && bps == 4 && sig == 1 && msb == 0) {
+        /*return ma_format_s24_32;*/
+    }
+    if (bits == 32 && bps == 4 && sig == 1) {
+        return ma_format_s32;
+    }
+
+    return ma_format_unknown;
+}
+
+static ma_format ma_find_best_format_from_sio_cap__sndio(struct ma_sio_cap* caps)
+{
+    ma_format bestFormat;
+    unsigned int iConfig;
+
+    MA_ASSERT(caps != NULL);
+
+    bestFormat = ma_format_unknown;
+    for (iConfig = 0; iConfig < caps->nconf; iConfig += 1) {
+        unsigned int iEncoding;
+        for (iEncoding = 0; iEncoding < MA_SIO_NENC; iEncoding += 1) {
+            unsigned int bits;
+            unsigned int bps;
+            unsigned int sig;
+            unsigned int le;
+            unsigned int msb;
+            ma_format format;
+
+            if ((caps->confs[iConfig].enc & (1UL << iEncoding)) == 0) {
+                continue;
+            }
+
+            bits = caps->enc[iEncoding].bits;
+            bps  = caps->enc[iEncoding].bps;
+            sig  = caps->enc[iEncoding].sig;
+            le   = caps->enc[iEncoding].le;
+            msb  = caps->enc[iEncoding].msb;
+            format = ma_format_from_sio_enc__sndio(bits, bps, sig, le, msb);
+            if (format == ma_format_unknown) {
+                continue;   /* Format not supported. */
+            }
+
+            if (bestFormat == ma_format_unknown) {
+                bestFormat = format;
+            } else {
+                if (ma_get_format_priority_index(bestFormat) > ma_get_format_priority_index(format)) {    /* <-- Lower = better. */
+                    bestFormat = format;
+                }
+            }
+        }
+    }
+
+    return bestFormat;
+}
+
+static ma_uint32 ma_find_best_channels_from_sio_cap__sndio(struct ma_sio_cap* caps, ma_device_type deviceType, ma_format requiredFormat)
+{
+    ma_uint32 maxChannels;
+    unsigned int iConfig;
+
+    MA_ASSERT(caps != NULL);
+    MA_ASSERT(requiredFormat != ma_format_unknown);
+
+    /* Just pick whatever configuration has the most channels. */
+    maxChannels = 0;
+    for (iConfig = 0; iConfig < caps->nconf; iConfig += 1) {
+        /* The encoding should be of requiredFormat. */
+        unsigned int iEncoding;
+        for (iEncoding = 0; iEncoding < MA_SIO_NENC; iEncoding += 1) {
+            unsigned int iChannel;
+            unsigned int bits;
+            unsigned int bps;
+            unsigned int sig;
+            unsigned int le;
+            unsigned int msb;
+            ma_format format;
+
+            if ((caps->confs[iConfig].enc & (1UL << iEncoding)) == 0) {
+                continue;
+            }
+
+            bits = caps->enc[iEncoding].bits;
+            bps  = caps->enc[iEncoding].bps;
+            sig  = caps->enc[iEncoding].sig;
+            le   = caps->enc[iEncoding].le;
+            msb  = caps->enc[iEncoding].msb;
+            format = ma_format_from_sio_enc__sndio(bits, bps, sig, le, msb);
+            if (format != requiredFormat) {
+                continue;
+            }
+
+            /* Getting here means the format is supported. Iterate over each channel count and grab the biggest one. */
+            for (iChannel = 0; iChannel < MA_SIO_NCHAN; iChannel += 1) {
+                unsigned int chan = 0;
+                unsigned int channels;
+
+                if (deviceType == ma_device_type_playback) {
+                    chan = caps->confs[iConfig].pchan;
+                } else {
+                    chan = caps->confs[iConfig].rchan;
+                }
+
+                if ((chan & (1UL << iChannel)) == 0) {
+                    continue;
+                }
+
+                if (deviceType == ma_device_type_playback) {
+                    channels = caps->pchan[iChannel];
+                } else {
+                    channels = caps->rchan[iChannel];
+                }
+
+                if (maxChannels < channels) {
+                    maxChannels = channels;
+                }
+            }
+        }
+    }
+
+    return maxChannels;
+}
+
+static ma_uint32 ma_find_best_sample_rate_from_sio_cap__sndio(struct ma_sio_cap* caps, ma_device_type deviceType, ma_format requiredFormat, ma_uint32 requiredChannels)
+{
+    ma_uint32 firstSampleRate;
+    ma_uint32 bestSampleRate;
+    unsigned int iConfig;
+
+    MA_ASSERT(caps != NULL);
+    MA_ASSERT(requiredFormat != ma_format_unknown);
+    MA_ASSERT(requiredChannels > 0);
+    MA_ASSERT(requiredChannels <= MA_MAX_CHANNELS);
+
+    firstSampleRate = 0; /* <-- If the device does not support a standard rate we'll fall back to the first one that's found. */
+    bestSampleRate  = 0;
+
+    for (iConfig = 0; iConfig < caps->nconf; iConfig += 1) {
+        /* The encoding should be of requiredFormat. */
+        unsigned int iEncoding;
+        for (iEncoding = 0; iEncoding < MA_SIO_NENC; iEncoding += 1) {
+            unsigned int iChannel;
+            unsigned int bits;
+            unsigned int bps;
+            unsigned int sig;
+            unsigned int le;
+            unsigned int msb;
+            ma_format format;
+
+            if ((caps->confs[iConfig].enc & (1UL << iEncoding)) == 0) {
+                continue;
+            }
+
+            bits = caps->enc[iEncoding].bits;
+            bps  = caps->enc[iEncoding].bps;
+            sig  = caps->enc[iEncoding].sig;
+            le   = caps->enc[iEncoding].le;
+            msb  = caps->enc[iEncoding].msb;
+            format = ma_format_from_sio_enc__sndio(bits, bps, sig, le, msb);
+            if (format != requiredFormat) {
+                continue;
+            }
+
+            /* Getting here means the format is supported. Iterate over each channel count and grab the biggest one. */
+            for (iChannel = 0; iChannel < MA_SIO_NCHAN; iChannel += 1) {
+                unsigned int chan = 0;
+                unsigned int channels;
+                unsigned int iRate;
+
+                if (deviceType == ma_device_type_playback) {
+                    chan = caps->confs[iConfig].pchan;
+                } else {
+                    chan = caps->confs[iConfig].rchan;
+                }
+
+                if ((chan & (1UL << iChannel)) == 0) {
+                    continue;
+                }
+
+                if (deviceType == ma_device_type_playback) {
+                    channels = caps->pchan[iChannel];
+                } else {
+                    channels = caps->rchan[iChannel];
+                }
+
+                if (channels != requiredChannels) {
+                    continue;
+                }
+
+                /* Getting here means we have found a compatible encoding/channel pair. */
+                for (iRate = 0; iRate < MA_SIO_NRATE; iRate += 1) {
+                    ma_uint32 rate = (ma_uint32)caps->rate[iRate];
+                    ma_uint32 ratePriority;
+
+                    if (firstSampleRate == 0) {
+                        firstSampleRate = rate;
+                    }
+
+                    /* Disregard this rate if it's not a standard one. */
+                    ratePriority = ma_get_standard_sample_rate_priority_index__sndio(rate);
+                    if (ratePriority == (ma_uint32)-1) {
+                        continue;
+                    }
+
+                    if (ma_get_standard_sample_rate_priority_index__sndio(bestSampleRate) > ratePriority) {   /* Lower = better. */
+                        bestSampleRate = rate;
+                    }
+                }
+            }
+        }
+    }
+
+    /* If a standard sample rate was not found just fall back to the first one that was iterated. */
+    if (bestSampleRate == 0) {
+        bestSampleRate = firstSampleRate;
+    }
+
+    return bestSampleRate;
+}
+
+
+static ma_result ma_context_enumerate_devices__sndio(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 isTerminating = MA_FALSE;
+    struct ma_sio_hdl* handle;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* sndio doesn't seem to have a good device enumeration API, so I'm therefore only enumerating over default devices for now. */
+
+    /* Playback. */
+    if (!isTerminating) {
+        handle = ((ma_sio_open_proc)pContext->sndio.sio_open)(MA_SIO_DEVANY, MA_SIO_PLAY, 0);
+        if (handle != NULL) {
+            /* Supports playback. */
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strcpy_s(deviceInfo.id.sndio, sizeof(deviceInfo.id.sndio), MA_SIO_DEVANY);
+            ma_strcpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME);
+
+            isTerminating = !callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+
+            ((ma_sio_close_proc)pContext->sndio.sio_close)(handle);
+        }
+    }
+
+    /* Capture. */
+    if (!isTerminating) {
+        handle = ((ma_sio_open_proc)pContext->sndio.sio_open)(MA_SIO_DEVANY, MA_SIO_REC, 0);
+        if (handle != NULL) {
+            /* Supports capture. */
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strcpy_s(deviceInfo.id.sndio, sizeof(deviceInfo.id.sndio), "default");
+            ma_strcpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME);
+
+            isTerminating = !callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+
+            ((ma_sio_close_proc)pContext->sndio.sio_close)(handle);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    char devid[256];
+    struct ma_sio_hdl* handle;
+    struct ma_sio_cap caps;
+    unsigned int iConfig;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* We need to open the device before we can get information about it. */
+    if (pDeviceID == NULL) {
+        ma_strcpy_s(devid, sizeof(devid), MA_SIO_DEVANY);
+        ma_strcpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), (deviceType == ma_device_type_playback) ? MA_DEFAULT_PLAYBACK_DEVICE_NAME : MA_DEFAULT_CAPTURE_DEVICE_NAME);
+    } else {
+        ma_strcpy_s(devid, sizeof(devid), pDeviceID->sndio);
+        ma_strcpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), devid);
+    }
+
+    handle = ((ma_sio_open_proc)pContext->sndio.sio_open)(devid, (deviceType == ma_device_type_playback) ? MA_SIO_PLAY : MA_SIO_REC, 0);
+    if (handle == NULL) {
+        return MA_NO_DEVICE;
+    }
+
+    if (((ma_sio_getcap_proc)pContext->sndio.sio_getcap)(handle, &caps) == 0) {
+        return MA_ERROR;
+    }
+
+    pDeviceInfo->nativeDataFormatCount = 0;
+
+    for (iConfig = 0; iConfig < caps.nconf; iConfig += 1) {
+        /*
+        The main thing we care about is that the encoding is supported by miniaudio. If it is, we want to give
+        preference to some formats over others.
+        */
+        unsigned int iEncoding;
+        unsigned int iChannel;
+        unsigned int iRate;
+
+        for (iEncoding = 0; iEncoding < MA_SIO_NENC; iEncoding += 1) {
+            unsigned int bits;
+            unsigned int bps;
+            unsigned int sig;
+            unsigned int le;
+            unsigned int msb;
+            ma_format format;
+
+            if ((caps.confs[iConfig].enc & (1UL << iEncoding)) == 0) {
+                continue;
+            }
+
+            bits = caps.enc[iEncoding].bits;
+            bps  = caps.enc[iEncoding].bps;
+            sig  = caps.enc[iEncoding].sig;
+            le   = caps.enc[iEncoding].le;
+            msb  = caps.enc[iEncoding].msb;
+            format = ma_format_from_sio_enc__sndio(bits, bps, sig, le, msb);
+            if (format == ma_format_unknown) {
+                continue;   /* Format not supported. */
+            }
+
+
+            /* Channels. */
+            for (iChannel = 0; iChannel < MA_SIO_NCHAN; iChannel += 1) {
+                unsigned int chan = 0;
+                unsigned int channels;
+
+                if (deviceType == ma_device_type_playback) {
+                    chan = caps.confs[iConfig].pchan;
+                } else {
+                    chan = caps.confs[iConfig].rchan;
+                }
+
+                if ((chan & (1UL << iChannel)) == 0) {
+                    continue;
+                }
+
+                if (deviceType == ma_device_type_playback) {
+                    channels = caps.pchan[iChannel];
+                } else {
+                    channels = caps.rchan[iChannel];
+                }
+
+
+                /* Sample Rates. */
+                for (iRate = 0; iRate < MA_SIO_NRATE; iRate += 1) {
+                    if ((caps.confs[iConfig].rate & (1UL << iRate)) != 0) {
+                        ma_device_info_add_native_data_format(pDeviceInfo, format, channels, caps.rate[iRate], 0);
+                    }
+                }
+            }
+        }
+    }
+
+    ((ma_sio_close_proc)pContext->sndio.sio_close)(handle);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_uninit__sndio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)pDevice->sndio.handleCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init_handle__sndio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptor, ma_device_type deviceType)
+{
+    const char* pDeviceName;
+    ma_ptr handle;
+    int openFlags = 0;
+    struct ma_sio_cap caps;
+    struct ma_sio_par par;
+    const ma_device_id* pDeviceID;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_format internalFormat;
+    ma_uint32 internalChannels;
+    ma_uint32 internalSampleRate;
+    ma_uint32 internalPeriodSizeInFrames;
+    ma_uint32 internalPeriods;
+
+    MA_ASSERT(pConfig    != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex);
+    MA_ASSERT(pDevice    != NULL);
+
+    if (deviceType == ma_device_type_capture) {
+        openFlags = MA_SIO_REC;
+    } else {
+        openFlags = MA_SIO_PLAY;
+    }
+
+    pDeviceID  = pDescriptor->pDeviceID;
+    format     = pDescriptor->format;
+    channels   = pDescriptor->channels;
+    sampleRate = pDescriptor->sampleRate;
+
+    pDeviceName = MA_SIO_DEVANY;
+    if (pDeviceID != NULL) {
+        pDeviceName = pDeviceID->sndio;
+    }
+
+    handle = (ma_ptr)((ma_sio_open_proc)pDevice->pContext->sndio.sio_open)(pDeviceName, openFlags, 0);
+    if (handle == NULL) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to open device.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    /* We need to retrieve the device caps to determine the most appropriate format to use. */
+    if (((ma_sio_getcap_proc)pDevice->pContext->sndio.sio_getcap)((struct ma_sio_hdl*)handle, &caps) == 0) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)handle);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to retrieve device caps.");
+        return MA_ERROR;
+    }
+
+    /*
+    Note: sndio reports a huge range of available channels. This is inconvenient for us because there's no real
+    way, as far as I can tell, to get the _actual_ channel count of the device. I'm therefore restricting this
+    to the requested channels, regardless of whether or not the default channel count is requested.
+
+    For hardware devices, I'm suspecting only a single channel count will be reported and we can safely use the
+    value returned by ma_find_best_channels_from_sio_cap__sndio().
+    */
+    if (deviceType == ma_device_type_capture) {
+        if (format == ma_format_unknown) {
+            format = ma_find_best_format_from_sio_cap__sndio(&caps);
+        }
+
+        if (channels == 0) {
+            if (strlen(pDeviceName) > strlen("rsnd/") && strncmp(pDeviceName, "rsnd/", strlen("rsnd/")) == 0) {
+                channels = ma_find_best_channels_from_sio_cap__sndio(&caps, deviceType, format);
+            } else {
+                channels = MA_DEFAULT_CHANNELS;
+            }
+        }
+    } else {
+        if (format == ma_format_unknown) {
+            format = ma_find_best_format_from_sio_cap__sndio(&caps);
+        }
+
+        if (channels == 0) {
+            if (strlen(pDeviceName) > strlen("rsnd/") && strncmp(pDeviceName, "rsnd/", strlen("rsnd/")) == 0) {
+                channels = ma_find_best_channels_from_sio_cap__sndio(&caps, deviceType, format);
+            } else {
+                channels = MA_DEFAULT_CHANNELS;
+            }
+        }
+    }
+
+    if (sampleRate == 0) {
+        sampleRate = ma_find_best_sample_rate_from_sio_cap__sndio(&caps, pConfig->deviceType, format, channels);
+    }
+
+
+    ((ma_sio_initpar_proc)pDevice->pContext->sndio.sio_initpar)(&par);
+    par.msb = 0;
+    par.le  = ma_is_little_endian();
+
+    switch (format) {
+        case ma_format_u8:
+        {
+            par.bits = 8;
+            par.bps  = 1;
+            par.sig  = 0;
+        } break;
+
+        case ma_format_s24:
+        {
+            par.bits = 24;
+            par.bps  = 3;
+            par.sig  = 1;
+        } break;
+
+        case ma_format_s32:
+        {
+            par.bits = 32;
+            par.bps  = 4;
+            par.sig  = 1;
+        } break;
+
+        case ma_format_s16:
+        case ma_format_f32:
+        case ma_format_unknown:
+        default:
+        {
+            par.bits = 16;
+            par.bps  = 2;
+            par.sig  = 1;
+        } break;
+    }
+
+    if (deviceType == ma_device_type_capture) {
+        par.rchan = channels;
+    } else {
+        par.pchan = channels;
+    }
+
+    par.rate = sampleRate;
+
+    internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, par.rate, pConfig->performanceProfile);
+
+    par.round    = internalPeriodSizeInFrames;
+    par.appbufsz = par.round * pDescriptor->periodCount;
+
+    if (((ma_sio_setpar_proc)pDevice->pContext->sndio.sio_setpar)((struct ma_sio_hdl*)handle, &par) == 0) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)handle);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to set buffer size.");
+        return MA_ERROR;
+    }
+
+    if (((ma_sio_getpar_proc)pDevice->pContext->sndio.sio_getpar)((struct ma_sio_hdl*)handle, &par) == 0) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)handle);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to retrieve buffer size.");
+        return MA_ERROR;
+    }
+
+    internalFormat             = ma_format_from_sio_enc__sndio(par.bits, par.bps, par.sig, par.le, par.msb);
+    internalChannels           = (deviceType == ma_device_type_capture) ? par.rchan : par.pchan;
+    internalSampleRate         = par.rate;
+    internalPeriods            = par.appbufsz / par.round;
+    internalPeriodSizeInFrames = par.round;
+
+    if (deviceType == ma_device_type_capture) {
+        pDevice->sndio.handleCapture  = handle;
+    } else {
+        pDevice->sndio.handlePlayback = handle;
+    }
+
+    pDescriptor->format             = internalFormat;
+    pDescriptor->channels           = internalChannels;
+    pDescriptor->sampleRate         = internalSampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_sndio, pDescriptor->channelMap, ma_countof(pDescriptor->channelMap), internalChannels);
+    pDescriptor->periodSizeInFrames = internalPeriodSizeInFrames;
+    pDescriptor->periodCount        = internalPeriods;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__sndio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->sndio);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_handle__sndio(pDevice, pConfig, pDescriptorCapture, ma_device_type_capture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_handle__sndio(pDevice, pConfig, pDescriptorPlayback, ma_device_type_playback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__sndio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_start_proc)pDevice->pContext->sndio.sio_start)((struct ma_sio_hdl*)pDevice->sndio.handleCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_start_proc)pDevice->pContext->sndio.sio_start)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback);   /* <-- Doesn't actually playback until data is written. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__sndio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    From the documentation:
+
+        The sio_stop() function puts the audio subsystem in the same state as before sio_start() is called. It stops recording, drains the play buffer and then
+        stops playback. If samples to play are queued but playback hasn't started yet then playback is forced immediately; playback will actually stop once the
+        buffer is drained. In no case are samples in the play buffer discarded.
+
+    Therefore, sio_stop() performs all of the necessary draining for us.
+    */
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_stop_proc)pDevice->pContext->sndio.sio_stop)((struct ma_sio_hdl*)pDevice->sndio.handleCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_stop_proc)pDevice->pContext->sndio.sio_stop)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__sndio(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    int result;
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    result = ((ma_sio_write_proc)pDevice->pContext->sndio.sio_write)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+    if (result == 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to send data from the client to the device.");
+        return MA_IO_ERROR;
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_read__sndio(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    int result;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    result = ((ma_sio_read_proc)pDevice->pContext->sndio.sio_read)((struct ma_sio_hdl*)pDevice->sndio.handleCapture, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+    if (result == 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to read data from the device to be sent to the device.");
+        return MA_IO_ERROR;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__sndio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_sndio);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__sndio(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+#ifndef MA_NO_RUNTIME_LINKING
+    const char* libsndioNames[] = {
+        "libsndio.so"
+    };
+    size_t i;
+
+    for (i = 0; i < ma_countof(libsndioNames); ++i) {
+        pContext->sndio.sndioSO = ma_dlopen(ma_context_get_log(pContext), libsndioNames[i]);
+        if (pContext->sndio.sndioSO != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->sndio.sndioSO == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    pContext->sndio.sio_open    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_open");
+    pContext->sndio.sio_close   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_close");
+    pContext->sndio.sio_setpar  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_setpar");
+    pContext->sndio.sio_getpar  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_getpar");
+    pContext->sndio.sio_getcap  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_getcap");
+    pContext->sndio.sio_write   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_write");
+    pContext->sndio.sio_read    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_read");
+    pContext->sndio.sio_start   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_start");
+    pContext->sndio.sio_stop    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_stop");
+    pContext->sndio.sio_initpar = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_initpar");
+#else
+    pContext->sndio.sio_open    = sio_open;
+    pContext->sndio.sio_close   = sio_close;
+    pContext->sndio.sio_setpar  = sio_setpar;
+    pContext->sndio.sio_getpar  = sio_getpar;
+    pContext->sndio.sio_getcap  = sio_getcap;
+    pContext->sndio.sio_write   = sio_write;
+    pContext->sndio.sio_read    = sio_read;
+    pContext->sndio.sio_start   = sio_start;
+    pContext->sndio.sio_stop    = sio_stop;
+    pContext->sndio.sio_initpar = sio_initpar;
+#endif
+
+    pCallbacks->onContextInit             = ma_context_init__sndio;
+    pCallbacks->onContextUninit           = ma_context_uninit__sndio;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__sndio;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__sndio;
+    pCallbacks->onDeviceInit              = ma_device_init__sndio;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__sndio;
+    pCallbacks->onDeviceStart             = ma_device_start__sndio;
+    pCallbacks->onDeviceStop              = ma_device_stop__sndio;
+    pCallbacks->onDeviceRead              = ma_device_read__sndio;
+    pCallbacks->onDeviceWrite             = ma_device_write__sndio;
+    pCallbacks->onDeviceDataLoop          = NULL;
+
+    (void)pConfig;
+    return MA_SUCCESS;
+}
+#endif  /* MA_HAS_SNDIO */
+
+
+
+/******************************************************************************
+
+audio(4) Backend
+
+******************************************************************************/
+#ifdef MA_HAS_AUDIO4
+#include <fcntl.h>
+#include <poll.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/audioio.h>
+
+#ifdef __NetBSD__
+#include <sys/param.h>
+#endif
+
+#if defined(__OpenBSD__)
+    #include <sys/param.h>
+    #if defined(OpenBSD) && OpenBSD >= 201709
+        #define MA_AUDIO4_USE_NEW_API
+    #endif
+#endif
+
+static void ma_construct_device_id__audio4(char* id, size_t idSize, const char* base, int deviceIndex)
+{
+    size_t baseLen;
+
+    MA_ASSERT(id != NULL);
+    MA_ASSERT(idSize > 0);
+    MA_ASSERT(deviceIndex >= 0);
+
+    baseLen = strlen(base);
+    MA_ASSERT(idSize > baseLen);
+
+    ma_strcpy_s(id, idSize, base);
+    ma_itoa_s(deviceIndex, id+baseLen, idSize-baseLen, 10);
+}
+
+static ma_result ma_extract_device_index_from_id__audio4(const char* id, const char* base, int* pIndexOut)
+{
+    size_t idLen;
+    size_t baseLen;
+    const char* deviceIndexStr;
+
+    MA_ASSERT(id != NULL);
+    MA_ASSERT(base != NULL);
+    MA_ASSERT(pIndexOut != NULL);
+
+    idLen = strlen(id);
+    baseLen = strlen(base);
+    if (idLen <= baseLen) {
+        return MA_ERROR;   /* Doesn't look like the id starts with the base. */
+    }
+
+    if (strncmp(id, base, baseLen) != 0) {
+        return MA_ERROR;   /* ID does not begin with base. */
+    }
+
+    deviceIndexStr = id + baseLen;
+    if (deviceIndexStr[0] == '\0') {
+        return MA_ERROR;   /* No index specified in the ID. */
+    }
+
+    if (pIndexOut) {
+        *pIndexOut = atoi(deviceIndexStr);
+    }
+
+    return MA_SUCCESS;
+}
+
+
+#if !defined(MA_AUDIO4_USE_NEW_API)    /* Old API */
+static ma_format ma_format_from_encoding__audio4(unsigned int encoding, unsigned int precision)
+{
+    if (precision == 8 && (encoding == AUDIO_ENCODING_ULINEAR || encoding == AUDIO_ENCODING_ULINEAR || encoding == AUDIO_ENCODING_ULINEAR_LE || encoding == AUDIO_ENCODING_ULINEAR_BE)) {
+        return ma_format_u8;
+    } else {
+        if (ma_is_little_endian() && encoding == AUDIO_ENCODING_SLINEAR_LE) {
+            if (precision == 16) {
+                return ma_format_s16;
+            } else if (precision == 24) {
+                return ma_format_s24;
+            } else if (precision == 32) {
+                return ma_format_s32;
+            }
+        } else if (ma_is_big_endian() && encoding == AUDIO_ENCODING_SLINEAR_BE) {
+            if (precision == 16) {
+                return ma_format_s16;
+            } else if (precision == 24) {
+                return ma_format_s24;
+            } else if (precision == 32) {
+                return ma_format_s32;
+            }
+        }
+    }
+
+    return ma_format_unknown;  /* Encoding not supported. */
+}
+
+static void ma_encoding_from_format__audio4(ma_format format, unsigned int* pEncoding, unsigned int* pPrecision)
+{
+    MA_ASSERT(pEncoding  != NULL);
+    MA_ASSERT(pPrecision != NULL);
+
+    switch (format)
+    {
+        case ma_format_u8:
+        {
+            *pEncoding = AUDIO_ENCODING_ULINEAR;
+            *pPrecision = 8;
+        } break;
+
+        case ma_format_s24:
+        {
+            *pEncoding = (ma_is_little_endian()) ? AUDIO_ENCODING_SLINEAR_LE : AUDIO_ENCODING_SLINEAR_BE;
+            *pPrecision = 24;
+        } break;
+
+        case ma_format_s32:
+        {
+            *pEncoding = (ma_is_little_endian()) ? AUDIO_ENCODING_SLINEAR_LE : AUDIO_ENCODING_SLINEAR_BE;
+            *pPrecision = 32;
+        } break;
+
+        case ma_format_s16:
+        case ma_format_f32:
+        case ma_format_unknown:
+        default:
+        {
+            *pEncoding = (ma_is_little_endian()) ? AUDIO_ENCODING_SLINEAR_LE : AUDIO_ENCODING_SLINEAR_BE;
+            *pPrecision = 16;
+        } break;
+    }
+}
+
+static ma_format ma_format_from_prinfo__audio4(struct audio_prinfo* prinfo)
+{
+    return ma_format_from_encoding__audio4(prinfo->encoding, prinfo->precision);
+}
+
+static ma_format ma_best_format_from_fd__audio4(int fd, ma_format preferredFormat)
+{
+    audio_encoding_t encoding;
+    ma_uint32 iFormat;
+    int counter = 0;
+
+    /* First check to see if the preferred format is supported. */
+    if (preferredFormat != ma_format_unknown) {
+        counter = 0;
+        for (;;) {
+            MA_ZERO_OBJECT(&encoding);
+            encoding.index = counter;
+            if (ioctl(fd, AUDIO_GETENC, &encoding) < 0) {
+                break;
+            }
+
+            if (preferredFormat == ma_format_from_encoding__audio4(encoding.encoding, encoding.precision)) {
+                return preferredFormat;  /* Found the preferred format. */
+            }
+
+            /* Getting here means this encoding does not match our preferred format so we need to more on to the next encoding. */
+            counter += 1;
+        }
+    }
+
+    /* Getting here means our preferred format is not supported, so fall back to our standard priorities. */
+    for (iFormat = 0; iFormat < ma_countof(g_maFormatPriorities); iFormat += 1) {
+        ma_format format = g_maFormatPriorities[iFormat];
+
+        counter = 0;
+        for (;;) {
+            MA_ZERO_OBJECT(&encoding);
+            encoding.index = counter;
+            if (ioctl(fd, AUDIO_GETENC, &encoding) < 0) {
+                break;
+            }
+
+            if (format == ma_format_from_encoding__audio4(encoding.encoding, encoding.precision)) {
+                return format;  /* Found a workable format. */
+            }
+
+            /* Getting here means this encoding does not match our preferred format so we need to more on to the next encoding. */
+            counter += 1;
+        }
+    }
+
+    /* Getting here means not appropriate format was found. */
+    return ma_format_unknown;
+}
+#else
+static ma_format ma_format_from_swpar__audio4(struct audio_swpar* par)
+{
+    if (par->bits == 8 && par->bps == 1 && par->sig == 0) {
+        return ma_format_u8;
+    }
+    if (par->bits == 16 && par->bps == 2 && par->sig == 1 && par->le == ma_is_little_endian()) {
+        return ma_format_s16;
+    }
+    if (par->bits == 24 && par->bps == 3 && par->sig == 1 && par->le == ma_is_little_endian()) {
+        return ma_format_s24;
+    }
+    if (par->bits == 32 && par->bps == 4 && par->sig == 1 && par->le == ma_is_little_endian()) {
+        return ma_format_f32;
+    }
+
+    /* Format not supported. */
+    return ma_format_unknown;
+}
+#endif
+
+static ma_result ma_context_get_device_info_from_fd__audio4(ma_context* pContext, ma_device_type deviceType, int fd, ma_device_info* pDeviceInfo)
+{
+    audio_device_t fdDevice;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(fd >= 0);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    (void)pContext;
+    (void)deviceType;
+
+    if (ioctl(fd, AUDIO_GETDEV, &fdDevice) < 0) {
+        return MA_ERROR;   /* Failed to retrieve device info. */
+    }
+
+    /* Name. */
+    ma_strcpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), fdDevice.name);
+
+    #if !defined(MA_AUDIO4_USE_NEW_API)
+    {
+        audio_info_t fdInfo;
+        int counter = 0;
+        ma_uint32 channels;
+        ma_uint32 sampleRate;
+
+#if defined(__NetBSD__) && (__NetBSD_Version__ >= 900000000)
+        if (ioctl(fd, AUDIO_GETFORMAT, &fdInfo) < 0) {
+            return MA_ERROR;
+        }
+#else
+        if (ioctl(fd, AUDIO_GETINFO, &fdInfo) < 0) {
+            return MA_ERROR;
+        }
+#endif
+
+        if (deviceType == ma_device_type_playback) {
+            channels   = fdInfo.play.channels;
+            sampleRate = fdInfo.play.sample_rate;
+        } else {
+            channels   = fdInfo.record.channels;
+            sampleRate = fdInfo.record.sample_rate;
+        }
+
+        /* Supported formats. We get this by looking at the encodings. */
+        pDeviceInfo->nativeDataFormatCount = 0;
+        for (;;) {
+            audio_encoding_t encoding;
+            ma_format format;
+
+            MA_ZERO_OBJECT(&encoding);
+            encoding.index = counter;
+            if (ioctl(fd, AUDIO_GETENC, &encoding) < 0) {
+                break;
+            }
+
+            format = ma_format_from_encoding__audio4(encoding.encoding, encoding.precision);
+            if (format != ma_format_unknown) {
+                ma_device_info_add_native_data_format(pDeviceInfo, format, channels, sampleRate, 0);
+            }
+
+            counter += 1;
+        }
+    }
+    #else
+    {
+        struct audio_swpar fdPar;
+        ma_format format;
+        ma_uint32 channels;
+        ma_uint32 sampleRate;
+
+        if (ioctl(fd, AUDIO_GETPAR, &fdPar) < 0) {
+            return MA_ERROR;
+        }
+
+        format = ma_format_from_swpar__audio4(&fdPar);
+        if (format == ma_format_unknown) {
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        if (deviceType == ma_device_type_playback) {
+            channels = fdPar.pchan;
+        } else {
+            channels = fdPar.rchan;
+        }
+
+        sampleRate = fdPar.rate;
+
+        pDeviceInfo->nativeDataFormatCount = 0;
+        ma_device_info_add_native_data_format(pDeviceInfo, format, channels, sampleRate, 0);
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_enumerate_devices__audio4(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    const int maxDevices = 64;
+    char devpath[256];
+    int iDevice;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /*
+    Every device will be named "/dev/audioN", with a "/dev/audioctlN" equivalent. We use the "/dev/audioctlN"
+    version here since we can open it even when another process has control of the "/dev/audioN" device.
+    */
+    for (iDevice = 0; iDevice < maxDevices; ++iDevice) {
+        struct stat st;
+        int fd;
+        ma_bool32 isTerminating = MA_FALSE;
+
+        ma_strcpy_s(devpath, sizeof(devpath), "/dev/audioctl");
+        ma_itoa_s(iDevice, devpath+strlen(devpath), sizeof(devpath)-strlen(devpath), 10);
+
+        if (stat(devpath, &st) < 0) {
+            break;
+        }
+
+        /* The device exists, but we need to check if it's usable as playback and/or capture. */
+
+        /* Playback. */
+        if (!isTerminating) {
+            fd = open(devpath, O_RDONLY, 0);
+            if (fd >= 0) {
+                /* Supports playback. */
+                ma_device_info deviceInfo;
+                MA_ZERO_OBJECT(&deviceInfo);
+                ma_construct_device_id__audio4(deviceInfo.id.audio4, sizeof(deviceInfo.id.audio4), "/dev/audio", iDevice);
+                if (ma_context_get_device_info_from_fd__audio4(pContext, ma_device_type_playback, fd, &deviceInfo) == MA_SUCCESS) {
+                    isTerminating = !callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                }
+
+                close(fd);
+            }
+        }
+
+        /* Capture. */
+        if (!isTerminating) {
+            fd = open(devpath, O_WRONLY, 0);
+            if (fd >= 0) {
+                /* Supports capture. */
+                ma_device_info deviceInfo;
+                MA_ZERO_OBJECT(&deviceInfo);
+                ma_construct_device_id__audio4(deviceInfo.id.audio4, sizeof(deviceInfo.id.audio4), "/dev/audio", iDevice);
+                if (ma_context_get_device_info_from_fd__audio4(pContext, ma_device_type_capture, fd, &deviceInfo) == MA_SUCCESS) {
+                    isTerminating = !callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                }
+
+                close(fd);
+            }
+        }
+
+        if (isTerminating) {
+            break;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__audio4(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    int fd = -1;
+    int deviceIndex = -1;
+    char ctlid[256];
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    /*
+    We need to open the "/dev/audioctlN" device to get the info. To do this we need to extract the number
+    from the device ID which will be in "/dev/audioN" format.
+    */
+    if (pDeviceID == NULL) {
+        /* Default device. */
+        ma_strcpy_s(ctlid, sizeof(ctlid), "/dev/audioctl");
+    } else {
+        /* Specific device. We need to convert from "/dev/audioN" to "/dev/audioctlN". */
+        result = ma_extract_device_index_from_id__audio4(pDeviceID->audio4, "/dev/audio", &deviceIndex);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        ma_construct_device_id__audio4(ctlid, sizeof(ctlid), "/dev/audioctl", deviceIndex);
+    }
+
+    fd = open(ctlid, (deviceType == ma_device_type_playback) ? O_WRONLY : O_RDONLY, 0);
+    if (fd == -1) {
+        return MA_NO_DEVICE;
+    }
+
+    if (deviceIndex == -1) {
+        ma_strcpy_s(pDeviceInfo->id.audio4, sizeof(pDeviceInfo->id.audio4), "/dev/audio");
+    } else {
+        ma_construct_device_id__audio4(pDeviceInfo->id.audio4, sizeof(pDeviceInfo->id.audio4), "/dev/audio", deviceIndex);
+    }
+
+    result = ma_context_get_device_info_from_fd__audio4(pContext, deviceType, fd, pDeviceInfo);
+
+    close(fd);
+    return result;
+}
+
+static ma_result ma_device_uninit__audio4(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        close(pDevice->audio4.fdCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        close(pDevice->audio4.fdPlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init_fd__audio4(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptor, ma_device_type deviceType)
+{
+    const char* pDefaultDeviceNames[] = {
+        "/dev/audio",
+        "/dev/audio0"
+    };
+    const char* pDefaultDeviceCtlNames[] = {
+        "/dev/audioctl",
+        "/dev/audioctl0"
+    };
+    int fd;
+    int fdFlags = 0;
+    size_t iDefaultDevice = (size_t)-1;
+    ma_format internalFormat;
+    ma_uint32 internalChannels;
+    ma_uint32 internalSampleRate;
+    ma_uint32 internalPeriodSizeInFrames;
+    ma_uint32 internalPeriods;
+
+    MA_ASSERT(pConfig    != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex);
+    MA_ASSERT(pDevice    != NULL);
+
+    /* The first thing to do is open the file. */
+    if (deviceType == ma_device_type_capture) {
+        fdFlags = O_RDONLY;
+    } else {
+        fdFlags = O_WRONLY;
+    }
+    /*fdFlags |= O_NONBLOCK;*/
+
+    /* Find the index of the default device as a start. We'll use this index later. Set it to (size_t)-1 otherwise. */
+    if (pDescriptor->pDeviceID == NULL) {
+        /* Default device. */
+        for (iDefaultDevice = 0; iDefaultDevice < ma_countof(pDefaultDeviceNames); ++iDefaultDevice) {
+            fd = open(pDefaultDeviceNames[iDefaultDevice], fdFlags, 0);
+            if (fd != -1) {
+                break;
+            }
+        }
+    } else {
+        /* Specific device. */
+        fd = open(pDescriptor->pDeviceID->audio4, fdFlags, 0);
+
+        for (iDefaultDevice = 0; iDefaultDevice < ma_countof(pDefaultDeviceNames); iDefaultDevice += 1) {
+            if (ma_strcmp(pDefaultDeviceNames[iDefaultDevice], pDescriptor->pDeviceID->audio4) == 0) {
+                break;
+            }
+        }
+
+        if (iDefaultDevice == ma_countof(pDefaultDeviceNames)) {
+            iDefaultDevice = (size_t)-1;
+        }
+    }
+
+    if (fd == -1) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to open device.");
+        return ma_result_from_errno(errno);
+    }
+
+    #if !defined(MA_AUDIO4_USE_NEW_API)    /* Old API */
+    {
+        audio_info_t fdInfo;
+        int fdInfoResult = -1;
+
+        /*
+        The documentation is a little bit unclear to me as to how it handles formats. It says the
+        following:
+
+            Regardless of formats supported by underlying driver, the audio driver accepts the
+            following formats.
+
+        By then the next sentence says this:
+
+            `encoding` and `precision` are one of the values obtained by AUDIO_GETENC.
+
+        It sounds like a direct contradiction to me. I'm going to play this safe any only use the
+        best sample format returned by AUDIO_GETENC. If the requested format is supported we'll
+        use that, but otherwise we'll just use our standard format priorities to pick an
+        appropriate one.
+        */
+        AUDIO_INITINFO(&fdInfo);
+
+        /*
+        Get the default format from the audioctl file if we're asking for a default device. If we
+        retrieve it from /dev/audio it'll default to mono 8000Hz.
+        */
+        if (iDefaultDevice != (size_t)-1) {
+            /* We're using a default device. Get the info from the /dev/audioctl file instead of /dev/audio. */
+            int fdctl = open(pDefaultDeviceCtlNames[iDefaultDevice], fdFlags, 0);
+            if (fdctl != -1) {
+#if defined(__NetBSD__) && (__NetBSD_Version__ >= 900000000)
+                fdInfoResult = ioctl(fdctl, AUDIO_GETFORMAT, &fdInfo);
+#else
+                fdInfoResult = ioctl(fdctl, AUDIO_GETINFO, &fdInfo);
+#endif
+                close(fdctl);
+            }
+        }
+
+        if (fdInfoResult == -1) {
+            /* We still don't have the default device info so just retrieve it from the main audio device. */
+            if (ioctl(fd, AUDIO_GETINFO, &fdInfo) < 0) {
+                close(fd);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] AUDIO_GETINFO failed.");
+                return ma_result_from_errno(errno);
+            }
+        }
+
+        /* We get the driver to do as much of the data conversion as possible. */
+        if (deviceType == ma_device_type_capture) {
+            fdInfo.mode = AUMODE_RECORD;
+            ma_encoding_from_format__audio4(ma_best_format_from_fd__audio4(fd, pDescriptor->format), &fdInfo.record.encoding, &fdInfo.record.precision);
+
+            if (pDescriptor->channels != 0) {
+                fdInfo.record.channels = ma_clamp(pDescriptor->channels, 1, 12);    /* From the documentation: `channels` ranges from 1 to 12. */
+            }
+
+            if (pDescriptor->sampleRate != 0) {
+                fdInfo.record.sample_rate = ma_clamp(pDescriptor->sampleRate, 1000, 192000);    /* From the documentation: `frequency` ranges from 1000Hz to 192000Hz. (They mean `sample_rate` instead of `frequency`.) */
+            }
+        } else {
+            fdInfo.mode = AUMODE_PLAY;
+            ma_encoding_from_format__audio4(ma_best_format_from_fd__audio4(fd, pDescriptor->format), &fdInfo.play.encoding, &fdInfo.play.precision);
+
+            if (pDescriptor->channels != 0) {
+                fdInfo.play.channels = ma_clamp(pDescriptor->channels, 1, 12);    /* From the documentation: `channels` ranges from 1 to 12. */
+            }
+
+            if (pDescriptor->sampleRate != 0) {
+                fdInfo.play.sample_rate = ma_clamp(pDescriptor->sampleRate, 1000, 192000);    /* From the documentation: `frequency` ranges from 1000Hz to 192000Hz. (They mean `sample_rate` instead of `frequency`.) */
+            }
+        }
+
+        if (ioctl(fd, AUDIO_SETINFO, &fdInfo) < 0) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to set device format. AUDIO_SETINFO failed.");
+            return ma_result_from_errno(errno);
+        }
+
+        if (ioctl(fd, AUDIO_GETINFO, &fdInfo) < 0) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] AUDIO_GETINFO failed.");
+            return ma_result_from_errno(errno);
+        }
+
+        if (deviceType == ma_device_type_capture) {
+            internalFormat     = ma_format_from_prinfo__audio4(&fdInfo.record);
+            internalChannels   = fdInfo.record.channels;
+            internalSampleRate = fdInfo.record.sample_rate;
+        } else {
+            internalFormat     = ma_format_from_prinfo__audio4(&fdInfo.play);
+            internalChannels   = fdInfo.play.channels;
+            internalSampleRate = fdInfo.play.sample_rate;
+        }
+
+        if (internalFormat == ma_format_unknown) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] The device's internal device format is not supported by miniaudio. The device is unusable.");
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        /* Buffer. */
+        {
+            ma_uint32 internalPeriodSizeInBytes;
+
+            internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, internalSampleRate, pConfig->performanceProfile);
+
+            internalPeriodSizeInBytes = internalPeriodSizeInFrames * ma_get_bytes_per_frame(internalFormat, internalChannels);
+            if (internalPeriodSizeInBytes < 16) {
+                internalPeriodSizeInBytes = 16;
+            }
+
+            internalPeriods = pDescriptor->periodCount;
+            if (internalPeriods < 2) {
+                internalPeriods = 2;
+            }
+
+            /* What miniaudio calls a period, audio4 calls a block. */
+            AUDIO_INITINFO(&fdInfo);
+            fdInfo.hiwat     = internalPeriods;
+            fdInfo.lowat     = internalPeriods-1;
+            fdInfo.blocksize = internalPeriodSizeInBytes;
+            if (ioctl(fd, AUDIO_SETINFO, &fdInfo) < 0) {
+                close(fd);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to set internal buffer size. AUDIO_SETINFO failed.");
+                return ma_result_from_errno(errno);
+            }
+
+            internalPeriods            = fdInfo.hiwat;
+            internalPeriodSizeInFrames = fdInfo.blocksize / ma_get_bytes_per_frame(internalFormat, internalChannels);
+        }
+    }
+    #else
+    {
+        struct audio_swpar fdPar;
+
+        /* We need to retrieve the format of the device so we can know the channel count and sample rate. Then we can calculate the buffer size. */
+        if (ioctl(fd, AUDIO_GETPAR, &fdPar) < 0) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to retrieve initial device parameters.");
+            return ma_result_from_errno(errno);
+        }
+
+        internalFormat     = ma_format_from_swpar__audio4(&fdPar);
+        internalChannels   = (deviceType == ma_device_type_capture) ? fdPar.rchan : fdPar.pchan;
+        internalSampleRate = fdPar.rate;
+
+        if (internalFormat == ma_format_unknown) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] The device's internal device format is not supported by miniaudio. The device is unusable.");
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        /* Buffer. */
+        {
+            ma_uint32 internalPeriodSizeInBytes;
+
+            internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, internalSampleRate, pConfig->performanceProfile);
+
+            /* What miniaudio calls a period, audio4 calls a block. */
+            internalPeriodSizeInBytes = internalPeriodSizeInFrames * ma_get_bytes_per_frame(internalFormat, internalChannels);
+            if (internalPeriodSizeInBytes < 16) {
+                internalPeriodSizeInBytes = 16;
+            }
+
+            fdPar.nblks = pDescriptor->periodCount;
+            fdPar.round = internalPeriodSizeInBytes;
+
+            if (ioctl(fd, AUDIO_SETPAR, &fdPar) < 0) {
+                close(fd);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to set device parameters.");
+                return ma_result_from_errno(errno);
+            }
+
+            if (ioctl(fd, AUDIO_GETPAR, &fdPar) < 0) {
+                close(fd);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to retrieve actual device parameters.");
+                return ma_result_from_errno(errno);
+            }
+        }
+
+        internalFormat             = ma_format_from_swpar__audio4(&fdPar);
+        internalChannels           = (deviceType == ma_device_type_capture) ? fdPar.rchan : fdPar.pchan;
+        internalSampleRate         = fdPar.rate;
+        internalPeriods            = fdPar.nblks;
+        internalPeriodSizeInFrames = fdPar.round / ma_get_bytes_per_frame(internalFormat, internalChannels);
+    }
+    #endif
+
+    if (internalFormat == ma_format_unknown) {
+        close(fd);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] The device's internal device format is not supported by miniaudio. The device is unusable.");
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    if (deviceType == ma_device_type_capture) {
+        pDevice->audio4.fdCapture  = fd;
+    } else {
+        pDevice->audio4.fdPlayback = fd;
+    }
+
+    pDescriptor->format             = internalFormat;
+    pDescriptor->channels           = internalChannels;
+    pDescriptor->sampleRate         = internalSampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_sound4, pDescriptor->channelMap, ma_countof(pDescriptor->channelMap), internalChannels);
+    pDescriptor->periodSizeInFrames = internalPeriodSizeInFrames;
+    pDescriptor->periodCount        = internalPeriods;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__audio4(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->audio4);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    pDevice->audio4.fdCapture  = -1;
+    pDevice->audio4.fdPlayback = -1;
+
+    /*
+    The version of the operating system dictates whether or not the device is exclusive or shared. NetBSD
+    introduced in-kernel mixing which means it's shared. All other BSD flavours are exclusive as far as
+    I'm aware.
+    */
+#if defined(__NetBSD_Version__) && __NetBSD_Version__ >= 800000000
+    /* NetBSD 8.0+ */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+#else
+    /* All other flavors. */
+#endif
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_fd__audio4(pDevice, pConfig, pDescriptorCapture, ma_device_type_capture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_fd__audio4(pDevice, pConfig, pDescriptorPlayback, ma_device_type_playback);
+        if (result != MA_SUCCESS) {
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                close(pDevice->audio4.fdCapture);
+            }
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__audio4(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->audio4.fdCapture == -1) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->audio4.fdPlayback == -1) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop_fd__audio4(ma_device* pDevice, int fd)
+{
+    if (fd == -1) {
+        return MA_INVALID_ARGS;
+    }
+
+#if !defined(MA_AUDIO4_USE_NEW_API)
+    if (ioctl(fd, AUDIO_FLUSH, 0) < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to stop device. AUDIO_FLUSH failed.");
+        return ma_result_from_errno(errno);
+    }
+#else
+    if (ioctl(fd, AUDIO_STOP, 0) < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to stop device. AUDIO_STOP failed.");
+        return ma_result_from_errno(errno);
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__audio4(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_result result;
+
+        result = ma_device_stop_fd__audio4(pDevice, pDevice->audio4.fdCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_result result;
+
+        /* Drain the device first. If this fails we'll just need to flush without draining. Unfortunately draining isn't available on newer version of OpenBSD. */
+    #if !defined(MA_AUDIO4_USE_NEW_API)
+        ioctl(pDevice->audio4.fdPlayback, AUDIO_DRAIN, 0);
+    #endif
+
+        /* Here is where the device is stopped immediately. */
+        result = ma_device_stop_fd__audio4(pDevice, pDevice->audio4.fdPlayback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__audio4(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    int result;
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    result = write(pDevice->audio4.fdPlayback, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+    if (result < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to write data to the device.");
+        return ma_result_from_errno(errno);
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = (ma_uint32)result / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_read__audio4(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    int result;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    result = read(pDevice->audio4.fdCapture, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+    if (result < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to read data from the device.");
+        return ma_result_from_errno(errno);
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = (ma_uint32)result / ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__audio4(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_audio4);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__audio4(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+    pCallbacks->onContextInit             = ma_context_init__audio4;
+    pCallbacks->onContextUninit           = ma_context_uninit__audio4;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__audio4;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__audio4;
+    pCallbacks->onDeviceInit              = ma_device_init__audio4;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__audio4;
+    pCallbacks->onDeviceStart             = ma_device_start__audio4;
+    pCallbacks->onDeviceStop              = ma_device_stop__audio4;
+    pCallbacks->onDeviceRead              = ma_device_read__audio4;
+    pCallbacks->onDeviceWrite             = ma_device_write__audio4;
+    pCallbacks->onDeviceDataLoop          = NULL;
+
+    return MA_SUCCESS;
+}
+#endif  /* MA_HAS_AUDIO4 */
+
+
+/******************************************************************************
+
+OSS Backend
+
+******************************************************************************/
+#ifdef MA_HAS_OSS
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/soundcard.h>
+
+#ifndef SNDCTL_DSP_HALT
+#define SNDCTL_DSP_HALT SNDCTL_DSP_RESET
+#endif
+
+#define MA_OSS_DEFAULT_DEVICE_NAME  "/dev/dsp"
+
+static int ma_open_temp_device__oss(void)
+{
+    /* The OSS sample code uses "/dev/mixer" as the device for getting system properties so I'm going to do the same. */
+    int fd = open("/dev/mixer", O_RDONLY, 0);
+    if (fd >= 0) {
+        return fd;
+    }
+
+    return -1;
+}
+
+static ma_result ma_context_open_device__oss(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_share_mode shareMode, int* pfd)
+{
+    const char* deviceName;
+    int flags;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pfd != NULL);
+    (void)pContext;
+
+    *pfd = -1;
+
+    /* This function should only be called for playback or capture, not duplex. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    deviceName = MA_OSS_DEFAULT_DEVICE_NAME;
+    if (pDeviceID != NULL) {
+        deviceName = pDeviceID->oss;
+    }
+
+    flags = (deviceType == ma_device_type_playback) ? O_WRONLY : O_RDONLY;
+    if (shareMode == ma_share_mode_exclusive) {
+        flags |= O_EXCL;
+    }
+
+    *pfd = open(deviceName, flags, 0);
+    if (*pfd == -1) {
+        return ma_result_from_errno(errno);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_enumerate_devices__oss(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    int fd;
+    oss_sysinfo si;
+    int result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    fd = ma_open_temp_device__oss();
+    if (fd == -1) {
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open a temporary device for retrieving system information used for device enumeration.");
+        return MA_NO_BACKEND;
+    }
+
+    result = ioctl(fd, SNDCTL_SYSINFO, &si);
+    if (result != -1) {
+        int iAudioDevice;
+        for (iAudioDevice = 0; iAudioDevice < si.numaudios; ++iAudioDevice) {
+            oss_audioinfo ai;
+            ai.dev = iAudioDevice;
+            result = ioctl(fd, SNDCTL_AUDIOINFO, &ai);
+            if (result != -1) {
+                if (ai.devnode[0] != '\0') {    /* <-- Can be blank, according to documentation. */
+                    ma_device_info deviceInfo;
+                    ma_bool32 isTerminating = MA_FALSE;
+
+                    MA_ZERO_OBJECT(&deviceInfo);
+
+                    /* ID */
+                    ma_strncpy_s(deviceInfo.id.oss, sizeof(deviceInfo.id.oss), ai.devnode, (size_t)-1);
+
+                    /*
+                    The human readable device name should be in the "ai.handle" variable, but it can
+                    sometimes be empty in which case we just fall back to "ai.name" which is less user
+                    friendly, but usually has a value.
+                    */
+                    if (ai.handle[0] != '\0') {
+                        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), ai.handle, (size_t)-1);
+                    } else {
+                        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), ai.name, (size_t)-1);
+                    }
+
+                    /* The device can be both playback and capture. */
+                    if (!isTerminating && (ai.caps & PCM_CAP_OUTPUT) != 0) {
+                        isTerminating = !callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                    }
+                    if (!isTerminating && (ai.caps & PCM_CAP_INPUT) != 0) {
+                        isTerminating = !callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                    }
+
+                    if (isTerminating) {
+                        break;
+                    }
+                }
+            }
+        }
+    } else {
+        close(fd);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to retrieve system information for device enumeration.");
+        return MA_NO_BACKEND;
+    }
+
+    close(fd);
+    return MA_SUCCESS;
+}
+
+static void ma_context_add_native_data_format__oss(ma_context* pContext, oss_audioinfo* pAudioInfo, ma_format format, ma_device_info* pDeviceInfo)
+{
+    unsigned int minChannels;
+    unsigned int maxChannels;
+    unsigned int iRate;
+
+    MA_ASSERT(pContext    != NULL);
+    MA_ASSERT(pAudioInfo  != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    /* If we support all channels we just report 0. */
+    minChannels = ma_clamp(pAudioInfo->min_channels, MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+    maxChannels = ma_clamp(pAudioInfo->max_channels, MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+
+    /*
+    OSS has this annoying thing where sample rates can be reported in two ways. We prefer explicitness,
+    which OSS has in the form of nrates/rates, however there are times where nrates can be 0, in which
+    case we'll need to use min_rate and max_rate and report only standard rates.
+    */
+    if (pAudioInfo->nrates > 0) {
+        for (iRate = 0; iRate < pAudioInfo->nrates; iRate += 1) {
+            unsigned int rate = pAudioInfo->rates[iRate];
+
+            if (minChannels == MA_MIN_CHANNELS && maxChannels == MA_MAX_CHANNELS) {
+                ma_device_info_add_native_data_format(pDeviceInfo, format, 0, rate, 0);   /* Set the channel count to 0 to indicate that all channel counts are supported. */
+            } else {
+                unsigned int iChannel;
+                for (iChannel = minChannels; iChannel <= maxChannels; iChannel += 1) {
+                     ma_device_info_add_native_data_format(pDeviceInfo, format, iChannel, rate, 0);
+                }
+            }
+        }
+    } else {
+        for (iRate = 0; iRate < ma_countof(g_maStandardSampleRatePriorities); iRate += 1) {
+            ma_uint32 standardRate = g_maStandardSampleRatePriorities[iRate];
+
+            if (standardRate >= (ma_uint32)pAudioInfo->min_rate && standardRate <= (ma_uint32)pAudioInfo->max_rate) {
+                if (minChannels == MA_MIN_CHANNELS && maxChannels == MA_MAX_CHANNELS) {
+                    ma_device_info_add_native_data_format(pDeviceInfo, format, 0, standardRate, 0);   /* Set the channel count to 0 to indicate that all channel counts are supported. */
+                } else {
+                    unsigned int iChannel;
+                    for (iChannel = minChannels; iChannel <= maxChannels; iChannel += 1) {
+                         ma_device_info_add_native_data_format(pDeviceInfo, format, iChannel, standardRate, 0);
+                    }
+                }
+            }
+        }
+    }
+}
+
+static ma_result ma_context_get_device_info__oss(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_bool32 foundDevice;
+    int fdTemp;
+    oss_sysinfo si;
+    int result;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* Handle the default device a little differently. */
+    if (pDeviceID == NULL) {
+        if (deviceType == ma_device_type_playback) {
+            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        } else {
+            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+        }
+
+        return MA_SUCCESS;
+    }
+
+
+    /* If we get here it means we are _not_ using the default device. */
+    foundDevice = MA_FALSE;
+
+    fdTemp = ma_open_temp_device__oss();
+    if (fdTemp == -1) {
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open a temporary device for retrieving system information used for device enumeration.");
+        return MA_NO_BACKEND;
+    }
+
+    result = ioctl(fdTemp, SNDCTL_SYSINFO, &si);
+    if (result != -1) {
+        int iAudioDevice;
+        for (iAudioDevice = 0; iAudioDevice < si.numaudios; ++iAudioDevice) {
+            oss_audioinfo ai;
+            ai.dev = iAudioDevice;
+            result = ioctl(fdTemp, SNDCTL_AUDIOINFO, &ai);
+            if (result != -1) {
+                if (ma_strcmp(ai.devnode, pDeviceID->oss) == 0) {
+                    /* It has the same name, so now just confirm the type. */
+                    if ((deviceType == ma_device_type_playback && ((ai.caps & PCM_CAP_OUTPUT) != 0)) ||
+                        (deviceType == ma_device_type_capture  && ((ai.caps & PCM_CAP_INPUT)  != 0))) {
+                        unsigned int formatMask;
+
+                        /* ID */
+                        ma_strncpy_s(pDeviceInfo->id.oss, sizeof(pDeviceInfo->id.oss), ai.devnode, (size_t)-1);
+
+                        /*
+                        The human readable device name should be in the "ai.handle" variable, but it can
+                        sometimes be empty in which case we just fall back to "ai.name" which is less user
+                        friendly, but usually has a value.
+                        */
+                        if (ai.handle[0] != '\0') {
+                            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), ai.handle, (size_t)-1);
+                        } else {
+                            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), ai.name, (size_t)-1);
+                        }
+
+
+                        pDeviceInfo->nativeDataFormatCount = 0;
+
+                        if (deviceType == ma_device_type_playback) {
+                            formatMask = ai.oformats;
+                        } else {
+                            formatMask = ai.iformats;
+                        }
+
+                        if (((formatMask & AFMT_S16_LE) != 0 && ma_is_little_endian()) || (AFMT_S16_BE && ma_is_big_endian())) {
+                            ma_context_add_native_data_format__oss(pContext, &ai, ma_format_s16, pDeviceInfo);
+                        }
+                        if (((formatMask & AFMT_S32_LE) != 0 && ma_is_little_endian()) || (AFMT_S32_BE && ma_is_big_endian())) {
+                            ma_context_add_native_data_format__oss(pContext, &ai, ma_format_s32, pDeviceInfo);
+                        }
+                        if ((formatMask & AFMT_U8) != 0) {
+                            ma_context_add_native_data_format__oss(pContext, &ai, ma_format_u8, pDeviceInfo);
+                        }
+
+                        foundDevice = MA_TRUE;
+                        break;
+                    }
+                }
+            }
+        }
+    } else {
+        close(fdTemp);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to retrieve system information for device enumeration.");
+        return MA_NO_BACKEND;
+    }
+
+
+    close(fdTemp);
+
+    if (!foundDevice) {
+        return MA_NO_DEVICE;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_uninit__oss(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        close(pDevice->oss.fdCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        close(pDevice->oss.fdPlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static int ma_format_to_oss(ma_format format)
+{
+    int ossFormat = AFMT_U8;
+    switch (format) {
+        case ma_format_s16: ossFormat = (ma_is_little_endian()) ? AFMT_S16_LE : AFMT_S16_BE; break;
+        case ma_format_s24: ossFormat = (ma_is_little_endian()) ? AFMT_S32_LE : AFMT_S32_BE; break;
+        case ma_format_s32: ossFormat = (ma_is_little_endian()) ? AFMT_S32_LE : AFMT_S32_BE; break;
+        case ma_format_f32: ossFormat = (ma_is_little_endian()) ? AFMT_S16_LE : AFMT_S16_BE; break;
+        case ma_format_u8:
+        default: ossFormat = AFMT_U8; break;
+    }
+
+    return ossFormat;
+}
+
+static ma_format ma_format_from_oss(int ossFormat)
+{
+    if (ossFormat == AFMT_U8) {
+        return ma_format_u8;
+    } else {
+        if (ma_is_little_endian()) {
+            switch (ossFormat) {
+                case AFMT_S16_LE: return ma_format_s16;
+                case AFMT_S32_LE: return ma_format_s32;
+                default: return ma_format_unknown;
+            }
+        } else {
+            switch (ossFormat) {
+                case AFMT_S16_BE: return ma_format_s16;
+                case AFMT_S32_BE: return ma_format_s32;
+                default: return ma_format_unknown;
+            }
+        }
+    }
+
+    return ma_format_unknown;
+}
+
+static ma_result ma_device_init_fd__oss(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptor, ma_device_type deviceType)
+{
+    ma_result result;
+    int ossResult;
+    int fd;
+    const ma_device_id* pDeviceID = NULL;
+    ma_share_mode shareMode;
+    int ossFormat;
+    int ossChannels;
+    int ossSampleRate;
+    int ossFragment;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex);
+
+    pDeviceID     = pDescriptor->pDeviceID;
+    shareMode     = pDescriptor->shareMode;
+    ossFormat     = ma_format_to_oss((pDescriptor->format != ma_format_unknown) ? pDescriptor->format : ma_format_s16); /* Use s16 by default because OSS doesn't like floating point. */
+    ossChannels   = (int)(pDescriptor->channels   > 0) ? pDescriptor->channels   : MA_DEFAULT_CHANNELS;
+    ossSampleRate = (int)(pDescriptor->sampleRate > 0) ? pDescriptor->sampleRate : MA_DEFAULT_SAMPLE_RATE;
+
+    result = ma_context_open_device__oss(pDevice->pContext, deviceType, pDeviceID, shareMode, &fd);
+    if (result != MA_SUCCESS) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open device.");
+        return result;
+    }
+
+    /*
+    The OSS documentation is very clear about the order we should be initializing the device's properties:
+      1) Format
+      2) Channels
+      3) Sample rate.
+    */
+
+    /* Format. */
+    ossResult = ioctl(fd, SNDCTL_DSP_SETFMT, &ossFormat);
+    if (ossResult == -1) {
+        close(fd);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to set format.");
+        return ma_result_from_errno(errno);
+    }
+
+    /* Channels. */
+    ossResult = ioctl(fd, SNDCTL_DSP_CHANNELS, &ossChannels);
+    if (ossResult == -1) {
+        close(fd);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to set channel count.");
+        return ma_result_from_errno(errno);
+    }
+
+    /* Sample Rate. */
+    ossResult = ioctl(fd, SNDCTL_DSP_SPEED, &ossSampleRate);
+    if (ossResult == -1) {
+        close(fd);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to set sample rate.");
+        return ma_result_from_errno(errno);
+    }
+
+    /*
+    Buffer.
+
+    The documentation says that the fragment settings should be set as soon as possible, but I'm not sure if
+    it should be done before or after format/channels/rate.
+
+    OSS wants the fragment size in bytes and a power of 2. When setting, we specify the power, not the actual
+    value.
+    */
+    {
+        ma_uint32 periodSizeInFrames;
+        ma_uint32 periodSizeInBytes;
+        ma_uint32 ossFragmentSizePower;
+
+        periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, (ma_uint32)ossSampleRate, pConfig->performanceProfile);
+
+        periodSizeInBytes = ma_round_to_power_of_2(periodSizeInFrames * ma_get_bytes_per_frame(ma_format_from_oss(ossFormat), ossChannels));
+        if (periodSizeInBytes < 16) {
+            periodSizeInBytes = 16;
+        }
+
+        ossFragmentSizePower = 4;
+        periodSizeInBytes >>= 4;
+        while (periodSizeInBytes >>= 1) {
+            ossFragmentSizePower += 1;
+        }
+
+        ossFragment = (int)((pConfig->periods << 16) | ossFragmentSizePower);
+        ossResult = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &ossFragment);
+        if (ossResult == -1) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to set fragment size and period count.");
+            return ma_result_from_errno(errno);
+        }
+    }
+
+    /* Internal settings. */
+    if (deviceType == ma_device_type_capture) {
+        pDevice->oss.fdCapture  = fd;
+    } else {
+        pDevice->oss.fdPlayback = fd;
+    }
+
+    pDescriptor->format             = ma_format_from_oss(ossFormat);
+    pDescriptor->channels           = ossChannels;
+    pDescriptor->sampleRate         = ossSampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_sound4, pDescriptor->channelMap, ma_countof(pDescriptor->channelMap), pDescriptor->channels);
+    pDescriptor->periodCount        = (ma_uint32)(ossFragment >> 16);
+    pDescriptor->periodSizeInFrames = (ma_uint32)(1 << (ossFragment & 0xFFFF)) / ma_get_bytes_per_frame(pDescriptor->format, pDescriptor->channels);
+
+    if (pDescriptor->format == ma_format_unknown) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] The device's internal format is not supported by miniaudio.");
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__oss(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    MA_ASSERT(pDevice  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->oss);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_fd__oss(pDevice, pConfig, pDescriptorCapture, ma_device_type_capture);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open device.");
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_fd__oss(pDevice, pConfig, pDescriptorPlayback, ma_device_type_playback);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open device.");
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+/*
+Note on Starting and Stopping
+=============================
+In the past I was using SNDCTL_DSP_HALT to stop the device, however this results in issues when
+trying to resume the device again. If we use SNDCTL_DSP_HALT, the next write() or read() will
+fail. Instead what we need to do is just not write or read to and from the device when the
+device is not running.
+
+As a result, both the start and stop functions for OSS are just empty stubs. The starting and
+stopping logic is handled by ma_device_write__oss() and ma_device_read__oss(). These will check
+the device state, and if the device is stopped they will simply not do any kind of processing.
+
+The downside to this technique is that I've noticed a fairly lengthy delay in stopping the
+device, up to a second. This is on a virtual machine, and as such might just be due to the
+virtual drivers, but I'm not fully sure. I am not sure how to work around this problem so for
+the moment that's just how it's going to have to be.
+
+When starting the device, OSS will automatically start it when write() or read() is called.
+*/
+static ma_result ma_device_start__oss(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* The device is automatically started with reading and writing. */
+    (void)pDevice;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__oss(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* See note above on why this is empty. */
+    (void)pDevice;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__oss(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    int resultOSS;
+    ma_uint32 deviceState;
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    /* Don't do any processing if the device is stopped. */
+    deviceState = ma_device_get_state(pDevice);
+    if (deviceState != ma_device_state_started && deviceState != ma_device_state_starting) {
+        return MA_SUCCESS;
+    }
+
+    resultOSS = write(pDevice->oss.fdPlayback, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+    if (resultOSS < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to send data from the client to the device.");
+        return ma_result_from_errno(errno);
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = (ma_uint32)resultOSS / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_read__oss(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    int resultOSS;
+    ma_uint32 deviceState;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    /* Don't do any processing if the device is stopped. */
+    deviceState = ma_device_get_state(pDevice);
+    if (deviceState != ma_device_state_started && deviceState != ma_device_state_starting) {
+        return MA_SUCCESS;
+    }
+
+    resultOSS = read(pDevice->oss.fdCapture, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+    if (resultOSS < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to read data from the device to be sent to the client.");
+        return ma_result_from_errno(errno);
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = (ma_uint32)resultOSS / ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__oss(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_oss);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__oss(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    int fd;
+    int ossVersion;
+    int result;
+
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+    /* Try opening a temporary device first so we can get version information. This is closed at the end. */
+    fd = ma_open_temp_device__oss();
+    if (fd == -1) {
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open temporary device for retrieving system properties.");   /* Looks liks OSS isn't installed, or there are no available devices. */
+        return MA_NO_BACKEND;
+    }
+
+    /* Grab the OSS version. */
+    ossVersion = 0;
+    result = ioctl(fd, OSS_GETVERSION, &ossVersion);
+    if (result == -1) {
+        close(fd);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to retrieve OSS version.");
+        return MA_NO_BACKEND;
+    }
+
+    /* The file handle to temp device is no longer needed. Close ASAP. */
+    close(fd);
+
+    pContext->oss.versionMajor = ((ossVersion & 0xFF0000) >> 16);
+    pContext->oss.versionMinor = ((ossVersion & 0x00FF00) >> 8);
+
+    pCallbacks->onContextInit             = ma_context_init__oss;
+    pCallbacks->onContextUninit           = ma_context_uninit__oss;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__oss;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__oss;
+    pCallbacks->onDeviceInit              = ma_device_init__oss;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__oss;
+    pCallbacks->onDeviceStart             = ma_device_start__oss;
+    pCallbacks->onDeviceStop              = ma_device_stop__oss;
+    pCallbacks->onDeviceRead              = ma_device_read__oss;
+    pCallbacks->onDeviceWrite             = ma_device_write__oss;
+    pCallbacks->onDeviceDataLoop          = NULL;
+
+    return MA_SUCCESS;
+}
+#endif  /* MA_HAS_OSS */
+
+
+
+
+
+/******************************************************************************
+
+AAudio Backend
+
+******************************************************************************/
+#ifdef MA_HAS_AAUDIO
+
+#ifdef MA_NO_RUNTIME_LINKING
+    #include <AAudio/AAudio.h>
+#endif
+
+typedef int32_t                                         ma_aaudio_result_t;
+typedef int32_t                                         ma_aaudio_direction_t;
+typedef int32_t                                         ma_aaudio_sharing_mode_t;
+typedef int32_t                                         ma_aaudio_format_t;
+typedef int32_t                                         ma_aaudio_stream_state_t;
+typedef int32_t                                         ma_aaudio_performance_mode_t;
+typedef int32_t                                         ma_aaudio_usage_t;
+typedef int32_t                                         ma_aaudio_content_type_t;
+typedef int32_t                                         ma_aaudio_input_preset_t;
+typedef int32_t                                         ma_aaudio_allowed_capture_policy_t;
+typedef int32_t                                         ma_aaudio_data_callback_result_t;
+typedef struct ma_AAudioStreamBuilder_t*                ma_AAudioStreamBuilder;
+typedef struct ma_AAudioStream_t*                       ma_AAudioStream;
+
+#define MA_AAUDIO_UNSPECIFIED                           0
+
+/* Result codes. miniaudio only cares about the success code. */
+#define MA_AAUDIO_OK                                    0
+
+/* Directions. */
+#define MA_AAUDIO_DIRECTION_OUTPUT                      0
+#define MA_AAUDIO_DIRECTION_INPUT                       1
+
+/* Sharing modes. */
+#define MA_AAUDIO_SHARING_MODE_EXCLUSIVE                0
+#define MA_AAUDIO_SHARING_MODE_SHARED                   1
+
+/* Formats. */
+#define MA_AAUDIO_FORMAT_PCM_I16                        1
+#define MA_AAUDIO_FORMAT_PCM_FLOAT                      2
+
+/* Stream states. */
+#define MA_AAUDIO_STREAM_STATE_UNINITIALIZED            0
+#define MA_AAUDIO_STREAM_STATE_UNKNOWN                  1
+#define MA_AAUDIO_STREAM_STATE_OPEN                     2
+#define MA_AAUDIO_STREAM_STATE_STARTING                 3
+#define MA_AAUDIO_STREAM_STATE_STARTED                  4
+#define MA_AAUDIO_STREAM_STATE_PAUSING                  5
+#define MA_AAUDIO_STREAM_STATE_PAUSED                   6
+#define MA_AAUDIO_STREAM_STATE_FLUSHING                 7
+#define MA_AAUDIO_STREAM_STATE_FLUSHED                  8
+#define MA_AAUDIO_STREAM_STATE_STOPPING                 9
+#define MA_AAUDIO_STREAM_STATE_STOPPED                  10
+#define MA_AAUDIO_STREAM_STATE_CLOSING                  11
+#define MA_AAUDIO_STREAM_STATE_CLOSED                   12
+#define MA_AAUDIO_STREAM_STATE_DISCONNECTED             13
+
+/* Performance modes. */
+#define MA_AAUDIO_PERFORMANCE_MODE_NONE                 10
+#define MA_AAUDIO_PERFORMANCE_MODE_POWER_SAVING         11
+#define MA_AAUDIO_PERFORMANCE_MODE_LOW_LATENCY          12
+
+/* Usage types. */
+#define MA_AAUDIO_USAGE_MEDIA                           1
+#define MA_AAUDIO_USAGE_VOICE_COMMUNICATION             2
+#define MA_AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING  3
+#define MA_AAUDIO_USAGE_ALARM                           4
+#define MA_AAUDIO_USAGE_NOTIFICATION                    5
+#define MA_AAUDIO_USAGE_NOTIFICATION_RINGTONE           6
+#define MA_AAUDIO_USAGE_NOTIFICATION_EVENT              10
+#define MA_AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY        11
+#define MA_AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE  12
+#define MA_AAUDIO_USAGE_ASSISTANCE_SONIFICATION         13
+#define MA_AAUDIO_USAGE_GAME                            14
+#define MA_AAUDIO_USAGE_ASSISTANT                       16
+#define MA_AAUDIO_SYSTEM_USAGE_EMERGENCY                1000
+#define MA_AAUDIO_SYSTEM_USAGE_SAFETY                   1001
+#define MA_AAUDIO_SYSTEM_USAGE_VEHICLE_STATUS           1002
+#define MA_AAUDIO_SYSTEM_USAGE_ANNOUNCEMENT             1003
+
+/* Content types. */
+#define MA_AAUDIO_CONTENT_TYPE_SPEECH                   1
+#define MA_AAUDIO_CONTENT_TYPE_MUSIC                    2
+#define MA_AAUDIO_CONTENT_TYPE_MOVIE                    3
+#define MA_AAUDIO_CONTENT_TYPE_SONIFICATION             4
+
+/* Input presets. */
+#define MA_AAUDIO_INPUT_PRESET_GENERIC                  1
+#define MA_AAUDIO_INPUT_PRESET_CAMCORDER                5
+#define MA_AAUDIO_INPUT_PRESET_VOICE_RECOGNITION        6
+#define MA_AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION      7
+#define MA_AAUDIO_INPUT_PRESET_UNPROCESSED              9
+#define MA_AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE        10
+
+/* Allowed Capture Policies */
+#define MA_AAUDIO_ALLOW_CAPTURE_BY_ALL                  1
+#define MA_AAUDIO_ALLOW_CAPTURE_BY_SYSTEM               2
+#define MA_AAUDIO_ALLOW_CAPTURE_BY_NONE                 3
+
+/* Callback results. */
+#define MA_AAUDIO_CALLBACK_RESULT_CONTINUE              0
+#define MA_AAUDIO_CALLBACK_RESULT_STOP                  1
+
+
+typedef ma_aaudio_data_callback_result_t (* ma_AAudioStream_dataCallback) (ma_AAudioStream* pStream, void* pUserData, void* pAudioData, int32_t numFrames);
+typedef void                             (* ma_AAudioStream_errorCallback)(ma_AAudioStream *pStream, void *pUserData, ma_aaudio_result_t error);
+
+typedef ma_aaudio_result_t       (* MA_PFN_AAudio_createStreamBuilder)                   (ma_AAudioStreamBuilder** ppBuilder);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStreamBuilder_delete)                   (ma_AAudioStreamBuilder* pBuilder);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setDeviceId)              (ma_AAudioStreamBuilder* pBuilder, int32_t deviceId);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setDirection)             (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_direction_t direction);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setSharingMode)           (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_sharing_mode_t sharingMode);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setFormat)                (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_format_t format);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setChannelCount)          (ma_AAudioStreamBuilder* pBuilder, int32_t channelCount);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setSampleRate)            (ma_AAudioStreamBuilder* pBuilder, int32_t sampleRate);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setBufferCapacityInFrames)(ma_AAudioStreamBuilder* pBuilder, int32_t numFrames);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setFramesPerDataCallback) (ma_AAudioStreamBuilder* pBuilder, int32_t numFrames);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setDataCallback)          (ma_AAudioStreamBuilder* pBuilder, ma_AAudioStream_dataCallback callback, void* pUserData);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setErrorCallback)         (ma_AAudioStreamBuilder* pBuilder, ma_AAudioStream_errorCallback callback, void* pUserData);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setPerformanceMode)       (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_performance_mode_t mode);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setUsage)                 (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_usage_t contentType);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setContentType)           (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_content_type_t contentType);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setInputPreset)           (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_input_preset_t inputPreset);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setAllowedCapturePolicy)  (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_allowed_capture_policy_t policy);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStreamBuilder_openStream)               (ma_AAudioStreamBuilder* pBuilder, ma_AAudioStream** ppStream);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStream_close)                           (ma_AAudioStream* pStream);
+typedef ma_aaudio_stream_state_t (* MA_PFN_AAudioStream_getState)                        (ma_AAudioStream* pStream);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStream_waitForStateChange)              (ma_AAudioStream* pStream, ma_aaudio_stream_state_t inputState, ma_aaudio_stream_state_t* pNextState, int64_t timeoutInNanoseconds);
+typedef ma_aaudio_format_t       (* MA_PFN_AAudioStream_getFormat)                       (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getChannelCount)                 (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getSampleRate)                   (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getBufferCapacityInFrames)       (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getFramesPerDataCallback)        (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getFramesPerBurst)               (ma_AAudioStream* pStream);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStream_requestStart)                    (ma_AAudioStream* pStream);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStream_requestStop)                     (ma_AAudioStream* pStream);
+
+static ma_result ma_result_from_aaudio(ma_aaudio_result_t resultAA)
+{
+    switch (resultAA)
+    {
+        case MA_AAUDIO_OK: return MA_SUCCESS;
+        default: break;
+    }
+
+    return MA_ERROR;
+}
+
+static ma_aaudio_usage_t ma_to_usage__aaudio(ma_aaudio_usage usage)
+{
+    switch (usage) {
+        case ma_aaudio_usage_media:                          return MA_AAUDIO_USAGE_MEDIA;
+        case ma_aaudio_usage_voice_communication:            return MA_AAUDIO_USAGE_VOICE_COMMUNICATION;
+        case ma_aaudio_usage_voice_communication_signalling: return MA_AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
+        case ma_aaudio_usage_alarm:                          return MA_AAUDIO_USAGE_ALARM;
+        case ma_aaudio_usage_notification:                   return MA_AAUDIO_USAGE_NOTIFICATION;
+        case ma_aaudio_usage_notification_ringtone:          return MA_AAUDIO_USAGE_NOTIFICATION_RINGTONE;
+        case ma_aaudio_usage_notification_event:             return MA_AAUDIO_USAGE_NOTIFICATION_EVENT;
+        case ma_aaudio_usage_assistance_accessibility:       return MA_AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
+        case ma_aaudio_usage_assistance_navigation_guidance: return MA_AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
+        case ma_aaudio_usage_assistance_sonification:        return MA_AAUDIO_USAGE_ASSISTANCE_SONIFICATION;
+        case ma_aaudio_usage_game:                           return MA_AAUDIO_USAGE_GAME;
+        case ma_aaudio_usage_assitant:                       return MA_AAUDIO_USAGE_ASSISTANT;
+        case ma_aaudio_usage_emergency:                      return MA_AAUDIO_SYSTEM_USAGE_EMERGENCY;
+        case ma_aaudio_usage_safety:                         return MA_AAUDIO_SYSTEM_USAGE_SAFETY;
+        case ma_aaudio_usage_vehicle_status:                 return MA_AAUDIO_SYSTEM_USAGE_VEHICLE_STATUS;
+        case ma_aaudio_usage_announcement:                   return MA_AAUDIO_SYSTEM_USAGE_ANNOUNCEMENT;
+        default: break;
+    }
+
+    return MA_AAUDIO_USAGE_MEDIA;
+}
+
+static ma_aaudio_content_type_t ma_to_content_type__aaudio(ma_aaudio_content_type contentType)
+{
+    switch (contentType) {
+        case ma_aaudio_content_type_speech:       return MA_AAUDIO_CONTENT_TYPE_SPEECH;
+        case ma_aaudio_content_type_music:        return MA_AAUDIO_CONTENT_TYPE_MUSIC;
+        case ma_aaudio_content_type_movie:        return MA_AAUDIO_CONTENT_TYPE_MOVIE;
+        case ma_aaudio_content_type_sonification: return MA_AAUDIO_CONTENT_TYPE_SONIFICATION;
+        default: break;
+    }
+
+    return MA_AAUDIO_CONTENT_TYPE_SPEECH;
+}
+
+static ma_aaudio_input_preset_t ma_to_input_preset__aaudio(ma_aaudio_input_preset inputPreset)
+{
+    switch (inputPreset) {
+        case ma_aaudio_input_preset_generic:             return MA_AAUDIO_INPUT_PRESET_GENERIC;
+        case ma_aaudio_input_preset_camcorder:           return MA_AAUDIO_INPUT_PRESET_CAMCORDER;
+        case ma_aaudio_input_preset_voice_recognition:   return MA_AAUDIO_INPUT_PRESET_VOICE_RECOGNITION;
+        case ma_aaudio_input_preset_voice_communication: return MA_AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION;
+        case ma_aaudio_input_preset_unprocessed:         return MA_AAUDIO_INPUT_PRESET_UNPROCESSED;
+        case ma_aaudio_input_preset_voice_performance:   return MA_AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE;
+        default: break;
+    }
+
+    return MA_AAUDIO_INPUT_PRESET_GENERIC;
+}
+
+static ma_aaudio_allowed_capture_policy_t ma_to_allowed_capture_policy__aaudio(ma_aaudio_allowed_capture_policy allowedCapturePolicy)
+{
+    switch (allowedCapturePolicy) {
+        case ma_aaudio_allow_capture_by_all:    return MA_AAUDIO_ALLOW_CAPTURE_BY_ALL;
+        case ma_aaudio_allow_capture_by_system: return MA_AAUDIO_ALLOW_CAPTURE_BY_SYSTEM;
+        case ma_aaudio_allow_capture_by_none:   return MA_AAUDIO_ALLOW_CAPTURE_BY_NONE;
+        default: break;
+    }
+
+    return MA_AAUDIO_ALLOW_CAPTURE_BY_ALL;
+}
+
+static void ma_stream_error_callback__aaudio(ma_AAudioStream* pStream, void* pUserData, ma_aaudio_result_t error)
+{
+    ma_result result;
+    ma_job job;
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    (void)error;
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[AAudio] ERROR CALLBACK: error=%d, AAudioStream_getState()=%d\n", error, ((MA_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)(pStream));
+    
+    /*
+    When we get an error, we'll assume that the stream is in an erroneous state and needs to be restarted. From the documentation,
+    we cannot do this from the error callback. Therefore we are going to use an event thread for the AAudio backend to do this
+    cleanly and safely.
+    */
+    if (ma_atomic_bool32_get(&pDevice->aaudio.isTearingDown)) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[AAudio] Device Disconnected. Tearing down device.\n");
+    }
+    else {
+        job = ma_job_init(MA_JOB_TYPE_DEVICE_AAUDIO_REROUTE);
+        job.data.device.aaudio.reroute.pDevice = pDevice;
+    
+        if (pStream == pDevice->aaudio.pStreamCapture) {
+            job.data.device.aaudio.reroute.deviceType = ma_device_type_capture;
+        } else {
+            job.data.device.aaudio.reroute.deviceType = ma_device_type_playback;
+        }
+    
+        result = ma_device_job_thread_post(&pDevice->pContext->aaudio.jobThread, &job);
+        if (result != MA_SUCCESS) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[AAudio] Device Disconnected. Failed to post job for rerouting.\n");
+            return;
+        }
+    }
+}
+
+static ma_aaudio_data_callback_result_t ma_stream_data_callback_capture__aaudio(ma_AAudioStream* pStream, void* pUserData, void* pAudioData, int32_t frameCount)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    if (frameCount > 0) {
+        ma_device_handle_backend_data_callback(pDevice, NULL, pAudioData, (ma_uint32)frameCount);
+    }
+
+    (void)pStream;
+    return MA_AAUDIO_CALLBACK_RESULT_CONTINUE;
+}
+
+static ma_aaudio_data_callback_result_t ma_stream_data_callback_playback__aaudio(ma_AAudioStream* pStream, void* pUserData, void* pAudioData, int32_t frameCount)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    I've had a report that AAudio can sometimes post a frame count of 0. We need to check for that here
+    so we don't get any errors at a deeper level. I'm doing the same with the capture side for safety,
+    though I've not yet had any reports about that one.
+    */
+    if (frameCount > 0) {
+        ma_device_handle_backend_data_callback(pDevice, pAudioData, NULL, (ma_uint32)frameCount);
+    }
+
+    (void)pStream;
+    return MA_AAUDIO_CALLBACK_RESULT_CONTINUE;
+}
+
+static ma_result ma_create_and_configure_AAudioStreamBuilder__aaudio(ma_context* pContext, const ma_device_id* pDeviceID, ma_device_type deviceType, ma_share_mode shareMode, const ma_device_descriptor* pDescriptor, const ma_device_config* pConfig, ma_device* pDevice, ma_AAudioStreamBuilder** ppBuilder)
+{
+    ma_AAudioStreamBuilder* pBuilder;
+    ma_aaudio_result_t resultAA;
+
+    /* Safety. */
+    *ppBuilder = NULL;
+
+    resultAA = ((MA_PFN_AAudio_createStreamBuilder)pContext->aaudio.AAudio_createStreamBuilder)(&pBuilder);
+    if (resultAA != MA_AAUDIO_OK) {
+        return ma_result_from_aaudio(resultAA);
+    }
+
+    if (pDeviceID != NULL) {
+        ((MA_PFN_AAudioStreamBuilder_setDeviceId)pContext->aaudio.AAudioStreamBuilder_setDeviceId)(pBuilder, pDeviceID->aaudio);
+    }
+
+    ((MA_PFN_AAudioStreamBuilder_setDirection)pContext->aaudio.AAudioStreamBuilder_setDirection)(pBuilder, (deviceType == ma_device_type_playback) ? MA_AAUDIO_DIRECTION_OUTPUT : MA_AAUDIO_DIRECTION_INPUT);
+    ((MA_PFN_AAudioStreamBuilder_setSharingMode)pContext->aaudio.AAudioStreamBuilder_setSharingMode)(pBuilder, (shareMode == ma_share_mode_shared) ? MA_AAUDIO_SHARING_MODE_SHARED : MA_AAUDIO_SHARING_MODE_EXCLUSIVE);
+
+
+    /* If we have a device descriptor make sure we configure the stream builder to take our requested parameters. */
+    if (pDescriptor != NULL) {
+        MA_ASSERT(pConfig != NULL); /* We must have a device config if we also have a descriptor. The config is required for AAudio specific configuration options. */
+
+        if (pDescriptor->sampleRate != 0) {
+            ((MA_PFN_AAudioStreamBuilder_setSampleRate)pContext->aaudio.AAudioStreamBuilder_setSampleRate)(pBuilder, pDescriptor->sampleRate);
+        }
+
+        if (pDescriptor->channels != 0) {
+            ((MA_PFN_AAudioStreamBuilder_setChannelCount)pContext->aaudio.AAudioStreamBuilder_setChannelCount)(pBuilder, pDescriptor->channels);
+        }
+
+        if (pDescriptor->format != ma_format_unknown) {
+            ((MA_PFN_AAudioStreamBuilder_setFormat)pContext->aaudio.AAudioStreamBuilder_setFormat)(pBuilder, (pDescriptor->format == ma_format_s16) ? MA_AAUDIO_FORMAT_PCM_I16 : MA_AAUDIO_FORMAT_PCM_FLOAT);
+        }
+
+
+        /*
+        There have been reports where setting the frames per data callback results in an error.
+        In particular, re-routing may inadvertently switch from low-latency mode, resulting in a less stable
+        stream from the legacy path (AudioStreamLegacy). To address this, we simply don't set the value. It
+        can still be set if it's explicitly requested via the aaudio.allowSetBufferCapacity variable in the
+        device config.
+        */
+        if ((!pConfig->aaudio.enableCompatibilityWorkarounds || ma_android_sdk_version() > 30) && pConfig->aaudio.allowSetBufferCapacity) {
+            /*
+            AAudio is annoying when it comes to its buffer calculation stuff because it doesn't let you
+            retrieve the actual sample rate until after you've opened the stream. But you need to configure
+            the buffer capacity before you open the stream... :/
+
+            To solve, we're just going to assume MA_DEFAULT_SAMPLE_RATE (48000) and move on.
+            */
+            ma_uint32 bufferCapacityInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, pDescriptor->sampleRate, pConfig->performanceProfile) * pDescriptor->periodCount;
+
+            ((MA_PFN_AAudioStreamBuilder_setBufferCapacityInFrames)pContext->aaudio.AAudioStreamBuilder_setBufferCapacityInFrames)(pBuilder, bufferCapacityInFrames);
+            ((MA_PFN_AAudioStreamBuilder_setFramesPerDataCallback)pContext->aaudio.AAudioStreamBuilder_setFramesPerDataCallback)(pBuilder, bufferCapacityInFrames / pDescriptor->periodCount);
+        }
+
+        if (deviceType == ma_device_type_capture) {
+            if (pConfig->aaudio.inputPreset != ma_aaudio_input_preset_default && pContext->aaudio.AAudioStreamBuilder_setInputPreset != NULL) {
+                ((MA_PFN_AAudioStreamBuilder_setInputPreset)pContext->aaudio.AAudioStreamBuilder_setInputPreset)(pBuilder, ma_to_input_preset__aaudio(pConfig->aaudio.inputPreset));
+            }
+
+            ((MA_PFN_AAudioStreamBuilder_setDataCallback)pContext->aaudio.AAudioStreamBuilder_setDataCallback)(pBuilder, ma_stream_data_callback_capture__aaudio, (void*)pDevice);
+        } else {
+            if (pConfig->aaudio.usage != ma_aaudio_usage_default && pContext->aaudio.AAudioStreamBuilder_setUsage != NULL) {
+                ((MA_PFN_AAudioStreamBuilder_setUsage)pContext->aaudio.AAudioStreamBuilder_setUsage)(pBuilder, ma_to_usage__aaudio(pConfig->aaudio.usage));
+            }
+
+            if (pConfig->aaudio.contentType != ma_aaudio_content_type_default && pContext->aaudio.AAudioStreamBuilder_setContentType != NULL) {
+                ((MA_PFN_AAudioStreamBuilder_setContentType)pContext->aaudio.AAudioStreamBuilder_setContentType)(pBuilder, ma_to_content_type__aaudio(pConfig->aaudio.contentType));
+            }
+
+            if (pConfig->aaudio.allowedCapturePolicy != ma_aaudio_allow_capture_default && pContext->aaudio.AAudioStreamBuilder_setAllowedCapturePolicy != NULL) {
+                ((MA_PFN_AAudioStreamBuilder_setAllowedCapturePolicy)pContext->aaudio.AAudioStreamBuilder_setAllowedCapturePolicy)(pBuilder, ma_to_allowed_capture_policy__aaudio(pConfig->aaudio.allowedCapturePolicy));
+            }
+
+            ((MA_PFN_AAudioStreamBuilder_setDataCallback)pContext->aaudio.AAudioStreamBuilder_setDataCallback)(pBuilder, ma_stream_data_callback_playback__aaudio, (void*)pDevice);
+        }
+
+        /*
+        If we set AAUDIO_PERFORMANCE_MODE_LOW_LATENCY, we allow for MMAP (non-legacy path).
+        Since there's a mapping between miniaudio's performance profiles and AAudio's performance modes, let's use it.
+        Beware though, with a conservative performance profile, AAudio will indeed take the legacy path.
+        */
+        ((MA_PFN_AAudioStreamBuilder_setPerformanceMode)pContext->aaudio.AAudioStreamBuilder_setPerformanceMode)(pBuilder, (pConfig->performanceProfile == ma_performance_profile_low_latency) ? MA_AAUDIO_PERFORMANCE_MODE_LOW_LATENCY : MA_AAUDIO_PERFORMANCE_MODE_NONE);
+
+        /* We need to set an error callback to detect device changes. */
+        if (pDevice != NULL) {  /* <-- pDevice should never be null if pDescriptor is not null, which is always the case if we hit this branch. Check anyway for safety. */
+            ((MA_PFN_AAudioStreamBuilder_setErrorCallback)pContext->aaudio.AAudioStreamBuilder_setErrorCallback)(pBuilder, ma_stream_error_callback__aaudio, (void*)pDevice);
+        }
+    }
+
+    *ppBuilder = pBuilder;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_open_stream_and_close_builder__aaudio(ma_context* pContext, ma_AAudioStreamBuilder* pBuilder, ma_AAudioStream** ppStream)
+{
+    ma_result result;
+
+    result = ma_result_from_aaudio(((MA_PFN_AAudioStreamBuilder_openStream)pContext->aaudio.AAudioStreamBuilder_openStream)(pBuilder, ppStream));
+    ((MA_PFN_AAudioStreamBuilder_delete)pContext->aaudio.AAudioStreamBuilder_delete)(pBuilder);
+
+    return result;
+}
+
+static ma_result ma_open_stream_basic__aaudio(ma_context* pContext, const ma_device_id* pDeviceID, ma_device_type deviceType, ma_share_mode shareMode, ma_AAudioStream** ppStream)
+{
+    ma_result result;
+    ma_AAudioStreamBuilder* pBuilder;
+
+    *ppStream = NULL;
+
+    result = ma_create_and_configure_AAudioStreamBuilder__aaudio(pContext, pDeviceID, deviceType, shareMode, NULL, NULL, NULL, &pBuilder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Let's give AAudio a hint to avoid the legacy path (AudioStreamLegacy). */
+    ((MA_PFN_AAudioStreamBuilder_setPerformanceMode)pContext->aaudio.AAudioStreamBuilder_setPerformanceMode)(pBuilder, MA_AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
+
+    return ma_open_stream_and_close_builder__aaudio(pContext, pBuilder, ppStream);
+}
+
+static ma_result ma_open_stream__aaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_type deviceType, const ma_device_descriptor* pDescriptor, ma_AAudioStream** ppStream)
+{
+    ma_result result;
+    ma_AAudioStreamBuilder* pBuilder;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pDescriptor != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex);   /* This function should not be called for a full-duplex device type. */
+
+    *ppStream = NULL;
+
+    result = ma_create_and_configure_AAudioStreamBuilder__aaudio(pDevice->pContext, pDescriptor->pDeviceID, deviceType, pDescriptor->shareMode, pDescriptor, pConfig, pDevice, &pBuilder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_open_stream_and_close_builder__aaudio(pDevice->pContext, pBuilder, ppStream);
+}
+
+static ma_result ma_close_stream__aaudio(ma_context* pContext, ma_AAudioStream* pStream)
+{
+    if (pStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_result_from_aaudio(((MA_PFN_AAudioStream_close)pContext->aaudio.AAudioStream_close)(pStream));
+}
+
+static ma_bool32 ma_has_default_device__aaudio(ma_context* pContext, ma_device_type deviceType)
+{
+    /* The only way to know this is to try creating a stream. */
+    ma_AAudioStream* pStream;
+    ma_result result = ma_open_stream_basic__aaudio(pContext, NULL, deviceType, ma_share_mode_shared, &pStream);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+
+    ma_close_stream__aaudio(pContext, pStream);
+    return MA_TRUE;
+}
+
+static ma_result ma_wait_for_simple_state_transition__aaudio(ma_context* pContext, ma_AAudioStream* pStream, ma_aaudio_stream_state_t oldState, ma_aaudio_stream_state_t newState)
+{
+    ma_aaudio_stream_state_t actualNewState;
+    ma_aaudio_result_t resultAA = ((MA_PFN_AAudioStream_waitForStateChange)pContext->aaudio.AAudioStream_waitForStateChange)(pStream, oldState, &actualNewState, 5000000000); /* 5 second timeout. */
+    if (resultAA != MA_AAUDIO_OK) {
+        return ma_result_from_aaudio(resultAA);
+    }
+
+    if (newState != actualNewState) {
+        return MA_ERROR;   /* Failed to transition into the expected state. */
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_enumerate_devices__aaudio(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult = MA_TRUE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Unfortunately AAudio does not have an enumeration API. Therefore I'm only going to report default devices, but only if it can instantiate a stream. */
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        deviceInfo.id.aaudio = MA_AAUDIO_UNSPECIFIED;
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+
+        if (ma_has_default_device__aaudio(pContext, ma_device_type_playback)) {
+            cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+        }
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        deviceInfo.id.aaudio = MA_AAUDIO_UNSPECIFIED;
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+
+        if (ma_has_default_device__aaudio(pContext, ma_device_type_capture)) {
+            cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_context_add_native_data_format_from_AAudioStream_ex__aaudio(ma_context* pContext, ma_AAudioStream* pStream, ma_format format, ma_uint32 flags, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext    != NULL);
+    MA_ASSERT(pStream     != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = ((MA_PFN_AAudioStream_getChannelCount)pContext->aaudio.AAudioStream_getChannelCount)(pStream);
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = ((MA_PFN_AAudioStream_getSampleRate)pContext->aaudio.AAudioStream_getSampleRate)(pStream);
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = flags;
+    pDeviceInfo->nativeDataFormatCount += 1;
+}
+
+static void ma_context_add_native_data_format_from_AAudioStream__aaudio(ma_context* pContext, ma_AAudioStream* pStream, ma_uint32 flags, ma_device_info* pDeviceInfo)
+{
+    /* AAudio supports s16 and f32. */
+    ma_context_add_native_data_format_from_AAudioStream_ex__aaudio(pContext, pStream, ma_format_f32, flags, pDeviceInfo);
+    ma_context_add_native_data_format_from_AAudioStream_ex__aaudio(pContext, pStream, ma_format_s16, flags, pDeviceInfo);
+}
+
+static ma_result ma_context_get_device_info__aaudio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_AAudioStream* pStream;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* ID */
+    if (pDeviceID != NULL) {
+        pDeviceInfo->id.aaudio = pDeviceID->aaudio;
+    } else {
+        pDeviceInfo->id.aaudio = MA_AAUDIO_UNSPECIFIED;
+    }
+
+    /* Name */
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+
+    pDeviceInfo->nativeDataFormatCount = 0;
+
+    /* We'll need to open the device to get accurate sample rate and channel count information. */
+    result = ma_open_stream_basic__aaudio(pContext, pDeviceID, deviceType, ma_share_mode_shared, &pStream);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    ma_context_add_native_data_format_from_AAudioStream__aaudio(pContext, pStream, 0, pDeviceInfo);
+
+    ma_close_stream__aaudio(pContext, pStream);
+    pStream = NULL;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_close_streams__aaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* When rerouting, streams may have been closed and never re-opened. Hence the extra checks below. */
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_close_stream__aaudio(pDevice->pContext, (ma_AAudioStream*)pDevice->aaudio.pStreamCapture);
+        pDevice->aaudio.pStreamCapture = NULL;
+    }
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_close_stream__aaudio(pDevice->pContext, (ma_AAudioStream*)pDevice->aaudio.pStreamPlayback);
+        pDevice->aaudio.pStreamPlayback = NULL;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_uninit__aaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    Note: Closing the streams may cause a timeout error, which would then trigger rerouting in our error callback.
+    We must not schedule a reroute when device is getting destroyed.
+    */
+    ma_atomic_bool32_set(&pDevice->aaudio.isTearingDown, MA_TRUE);
+
+    /* Wait for any rerouting to finish before attempting to close the streams. */
+    ma_mutex_lock(&pDevice->aaudio.rerouteLock);
+    {
+        ma_close_streams__aaudio(pDevice);
+    }
+    ma_mutex_unlock(&pDevice->aaudio.rerouteLock);
+
+    /* Destroy rerouting lock. */
+    ma_mutex_uninit(&pDevice->aaudio.rerouteLock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init_by_type__aaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_type deviceType, ma_device_descriptor* pDescriptor, ma_AAudioStream** ppStream)
+{
+    ma_result result;
+    int32_t bufferCapacityInFrames;
+    int32_t framesPerDataCallback;
+    ma_AAudioStream* pStream;
+
+    MA_ASSERT(pDevice     != NULL);
+    MA_ASSERT(pConfig     != NULL);
+    MA_ASSERT(pDescriptor != NULL);
+
+    *ppStream = NULL;   /* Safety. */
+
+    /* First step is to open the stream. From there we'll be able to extract the internal configuration. */
+    result = ma_open_stream__aaudio(pDevice, pConfig, deviceType, pDescriptor, &pStream);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to open the AAudio stream. */
+    }
+
+    /* Now extract the internal configuration. */
+    pDescriptor->format     = (((MA_PFN_AAudioStream_getFormat)pDevice->pContext->aaudio.AAudioStream_getFormat)(pStream) == MA_AAUDIO_FORMAT_PCM_I16) ? ma_format_s16 : ma_format_f32;
+    pDescriptor->channels   = ((MA_PFN_AAudioStream_getChannelCount)pDevice->pContext->aaudio.AAudioStream_getChannelCount)(pStream);
+    pDescriptor->sampleRate = ((MA_PFN_AAudioStream_getSampleRate)pDevice->pContext->aaudio.AAudioStream_getSampleRate)(pStream);
+
+    /* For the channel map we need to be sure we don't overflow any buffers. */
+    if (pDescriptor->channels <= MA_MAX_CHANNELS) {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pDescriptor->channelMap, ma_countof(pDescriptor->channelMap), pDescriptor->channels); /* <-- Cannot find info on channel order, so assuming a default. */
+    } else {
+        ma_channel_map_init_blank(pDescriptor->channelMap, MA_MAX_CHANNELS); /* Too many channels. Use a blank channel map. */
+    }
+
+    bufferCapacityInFrames = ((MA_PFN_AAudioStream_getBufferCapacityInFrames)pDevice->pContext->aaudio.AAudioStream_getBufferCapacityInFrames)(pStream);
+    framesPerDataCallback = ((MA_PFN_AAudioStream_getFramesPerDataCallback)pDevice->pContext->aaudio.AAudioStream_getFramesPerDataCallback)(pStream);
+
+    if (framesPerDataCallback > 0) {
+        pDescriptor->periodSizeInFrames = framesPerDataCallback;
+        pDescriptor->periodCount        = bufferCapacityInFrames / framesPerDataCallback;
+    } else {
+        pDescriptor->periodSizeInFrames = bufferCapacityInFrames;
+        pDescriptor->periodCount        = 1;
+    }
+
+    *ppStream = pStream;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init_streams__aaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    pDevice->aaudio.usage                   = pConfig->aaudio.usage;
+    pDevice->aaudio.contentType             = pConfig->aaudio.contentType;
+    pDevice->aaudio.inputPreset             = pConfig->aaudio.inputPreset;
+    pDevice->aaudio.allowedCapturePolicy    = pConfig->aaudio.allowedCapturePolicy;
+    pDevice->aaudio.noAutoStartAfterReroute = pConfig->aaudio.noAutoStartAfterReroute;
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        result = ma_device_init_by_type__aaudio(pDevice, pConfig, ma_device_type_capture, pDescriptorCapture, (ma_AAudioStream**)&pDevice->aaudio.pStreamCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        result = ma_device_init_by_type__aaudio(pDevice, pConfig, ma_device_type_playback, pDescriptorPlayback, (ma_AAudioStream**)&pDevice->aaudio.pStreamPlayback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__aaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    result = ma_device_init_streams__aaudio(pDevice, pConfig, pDescriptorPlayback, pDescriptorCapture);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_mutex_init(&pDevice->aaudio.rerouteLock);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start_stream__aaudio(ma_device* pDevice, ma_AAudioStream* pStream)
+{
+    ma_aaudio_result_t resultAA;
+    ma_aaudio_stream_state_t currentState;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    resultAA = ((MA_PFN_AAudioStream_requestStart)pDevice->pContext->aaudio.AAudioStream_requestStart)(pStream);
+    if (resultAA != MA_AAUDIO_OK) {
+        return ma_result_from_aaudio(resultAA);
+    }
+
+    /* Do we actually need to wait for the device to transition into its started state? */
+
+    /* The device should be in either a starting or started state. If it's not set to started we need to wait for it to transition. It should go from starting to started. */
+    currentState = ((MA_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)(pStream);
+    if (currentState != MA_AAUDIO_STREAM_STATE_STARTED) {
+        ma_result result;
+
+        if (currentState != MA_AAUDIO_STREAM_STATE_STARTING) {
+            return MA_ERROR;   /* Expecting the stream to be a starting or started state. */
+        }
+
+        result = ma_wait_for_simple_state_transition__aaudio(pDevice->pContext, pStream, currentState, MA_AAUDIO_STREAM_STATE_STARTED);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop_stream__aaudio(ma_device* pDevice, ma_AAudioStream* pStream)
+{
+    ma_aaudio_result_t resultAA;
+    ma_aaudio_stream_state_t currentState;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    From the AAudio documentation:
+
+        The stream will stop after all of the data currently buffered has been played.
+
+    This maps with miniaudio's requirement that device's be drained which means we don't need to implement any draining logic.
+    */
+    currentState = ((MA_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)(pStream);
+    if (currentState == MA_AAUDIO_STREAM_STATE_DISCONNECTED) {
+        return MA_SUCCESS;  /* The device is disconnected. Don't try stopping it. */
+    }
+
+    resultAA = ((MA_PFN_AAudioStream_requestStop)pDevice->pContext->aaudio.AAudioStream_requestStop)(pStream);
+    if (resultAA != MA_AAUDIO_OK) {
+        return ma_result_from_aaudio(resultAA);
+    }
+
+    /* The device should be in either a stopping or stopped state. If it's not set to started we need to wait for it to transition. It should go from stopping to stopped. */
+    currentState = ((MA_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)(pStream);
+    if (currentState != MA_AAUDIO_STREAM_STATE_STOPPED) {
+        ma_result result;
+
+        if (currentState != MA_AAUDIO_STREAM_STATE_STOPPING) {
+            return MA_ERROR;   /* Expecting the stream to be a stopping or stopped state. */
+        }
+
+        result = ma_wait_for_simple_state_transition__aaudio(pDevice->pContext, pStream, currentState, MA_AAUDIO_STREAM_STATE_STOPPED);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__aaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_result result = ma_device_start_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_result result = ma_device_start_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamPlayback);
+        if (result != MA_SUCCESS) {
+            if (pDevice->type == ma_device_type_duplex) {
+                ma_device_stop_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamCapture);
+            }
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__aaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_result result = ma_device_stop_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_result result = ma_device_stop_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamPlayback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    ma_device__on_notification_stopped(pDevice);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_reinit__aaudio(ma_device* pDevice, ma_device_type deviceType)
+{
+    const ma_int32 maxAttempts = 4; /* Reasonable retry limit. */
+
+    ma_result result;
+    ma_int32 iAttempt;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* We got disconnected! Retry a few times, until we find a connected device! */
+    iAttempt = 0;
+    while (iAttempt++ < maxAttempts) {        
+        /* Device tearing down? No need to reroute! */
+        if (ma_atomic_bool32_get(&pDevice->aaudio.isTearingDown)) {
+            result = MA_SUCCESS; /* Caller should continue as normal. */
+            break;
+        }
+
+        /* The first thing to do is close the streams. */
+        ma_close_streams__aaudio(pDevice);
+
+        /* Now we need to reinitialize each streams. The hardest part with this is just filling output the config and descriptors. */
+        ma_device_config deviceConfig;
+        ma_device_descriptor descriptorPlayback;
+        ma_device_descriptor descriptorCapture;
+
+        deviceConfig = ma_device_config_init(deviceType);
+        deviceConfig.playback.pDeviceID             = NULL; /* Only doing rerouting with default devices. */
+        deviceConfig.playback.shareMode             = pDevice->playback.shareMode;
+        deviceConfig.playback.format                = pDevice->playback.format;
+        deviceConfig.playback.channels              = pDevice->playback.channels;
+        deviceConfig.capture.pDeviceID              = NULL; /* Only doing rerouting with default devices. */
+        deviceConfig.capture.shareMode              = pDevice->capture.shareMode;
+        deviceConfig.capture.format                 = pDevice->capture.format;
+        deviceConfig.capture.channels               = pDevice->capture.channels;
+        deviceConfig.sampleRate                     = pDevice->sampleRate;
+        deviceConfig.aaudio.usage                   = pDevice->aaudio.usage;
+        deviceConfig.aaudio.contentType             = pDevice->aaudio.contentType;
+        deviceConfig.aaudio.inputPreset             = pDevice->aaudio.inputPreset;
+        deviceConfig.aaudio.allowedCapturePolicy    = pDevice->aaudio.allowedCapturePolicy;
+        deviceConfig.aaudio.noAutoStartAfterReroute = pDevice->aaudio.noAutoStartAfterReroute;
+        deviceConfig.periods                        = 1;
+
+        /* Try to get an accurate period size. */
+        if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+            deviceConfig.periodSizeInFrames = pDevice->playback.internalPeriodSizeInFrames;
+        } else {
+            deviceConfig.periodSizeInFrames = pDevice->capture.internalPeriodSizeInFrames;
+        }
+
+        if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+            descriptorCapture.pDeviceID           = deviceConfig.capture.pDeviceID;
+            descriptorCapture.shareMode           = deviceConfig.capture.shareMode;
+            descriptorCapture.format              = deviceConfig.capture.format;
+            descriptorCapture.channels            = deviceConfig.capture.channels;
+            descriptorCapture.sampleRate          = deviceConfig.sampleRate;
+            descriptorCapture.periodSizeInFrames  = deviceConfig.periodSizeInFrames;
+            descriptorCapture.periodCount         = deviceConfig.periods;
+        }
+
+        if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+            descriptorPlayback.pDeviceID          = deviceConfig.playback.pDeviceID;
+            descriptorPlayback.shareMode          = deviceConfig.playback.shareMode;
+            descriptorPlayback.format             = deviceConfig.playback.format;
+            descriptorPlayback.channels           = deviceConfig.playback.channels;
+            descriptorPlayback.sampleRate         = deviceConfig.sampleRate;
+            descriptorPlayback.periodSizeInFrames = deviceConfig.periodSizeInFrames;
+            descriptorPlayback.periodCount        = deviceConfig.periods;
+        }
+
+        result = ma_device_init_streams__aaudio(pDevice, &deviceConfig, &descriptorPlayback, &descriptorCapture);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[AAudio] Failed to create stream after route change.");
+            /* Reroute failed! */
+            break;
+        }
+
+        result = ma_device_post_init(pDevice, deviceType, &descriptorPlayback, &descriptorCapture);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[AAudio] Failed to initialize device after route change.");
+            ma_close_streams__aaudio(pDevice);
+            /* Reroute failed! */
+            break;
+        }
+
+        /* We'll only ever do this in response to a reroute. */
+        ma_device__on_notification_rerouted(pDevice);
+
+        /* If the device is started, start the streams. Maybe make this configurable? */
+        if (ma_device_get_state(pDevice) == ma_device_state_started) {
+            if (pDevice->aaudio.noAutoStartAfterReroute == MA_FALSE) {
+                result = ma_device_start__aaudio(pDevice);
+                if (result != MA_SUCCESS) {
+                    if (iAttempt < maxAttempts) {
+                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[AAudio] Failed to start stream after route change, retrying(%d)", iAttempt);
+                    } else {
+                        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[AAudio] Failed to start stream after route change, giving up.");
+                    }
+                }
+            } else {
+                ma_device_stop(pDevice); /* Do a full device stop so we set internal state correctly. */
+            }
+        }
+
+        if (result == MA_SUCCESS) {
+            /* Reroute successful! */
+            break;
+        }
+    }
+    
+    return result;
+}
+
+static ma_result ma_device_get_info__aaudio(ma_device* pDevice, ma_device_type type, ma_device_info* pDeviceInfo)
+{
+    ma_AAudioStream* pStream = NULL;
+
+    MA_ASSERT(pDevice     != NULL);
+    MA_ASSERT(type        != ma_device_type_duplex);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    if (type == ma_device_type_capture) {
+        pStream = (ma_AAudioStream*)pDevice->aaudio.pStreamCapture;
+        pDeviceInfo->id.aaudio = pDevice->capture.id.aaudio;
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);     /* Only supporting default devices. */
+    }
+    if (type == ma_device_type_playback) {
+        pStream = (ma_AAudioStream*)pDevice->aaudio.pStreamPlayback;
+        pDeviceInfo->id.aaudio = pDevice->playback.id.aaudio;
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);    /* Only supporting default devices. */
+    }
+
+    /* Safety. Should never happen. */
+    if (pStream == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    pDeviceInfo->nativeDataFormatCount = 0;
+    ma_context_add_native_data_format_from_AAudioStream__aaudio(pDevice->pContext, pStream, 0, pDeviceInfo);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__aaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_aaudio);
+
+    ma_device_job_thread_uninit(&pContext->aaudio.jobThread, &pContext->allocationCallbacks);
+
+    ma_dlclose(ma_context_get_log(pContext), pContext->aaudio.hAAudio);
+    pContext->aaudio.hAAudio = NULL;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__aaudio(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+#if !defined(MA_NO_RUNTIME_LINKING)
+    size_t i;
+    const char* libNames[] = {
+        "libaaudio.so"
+    };
+
+    for (i = 0; i < ma_countof(libNames); ++i) {
+        pContext->aaudio.hAAudio = ma_dlopen(ma_context_get_log(pContext), libNames[i]);
+        if (pContext->aaudio.hAAudio != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->aaudio.hAAudio == NULL) {
+        return MA_FAILED_TO_INIT_BACKEND;
+    }
+
+    pContext->aaudio.AAudio_createStreamBuilder                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudio_createStreamBuilder");
+    pContext->aaudio.AAudioStreamBuilder_delete                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_delete");
+    pContext->aaudio.AAudioStreamBuilder_setDeviceId               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setDeviceId");
+    pContext->aaudio.AAudioStreamBuilder_setDirection              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setDirection");
+    pContext->aaudio.AAudioStreamBuilder_setSharingMode            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setSharingMode");
+    pContext->aaudio.AAudioStreamBuilder_setFormat                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setFormat");
+    pContext->aaudio.AAudioStreamBuilder_setChannelCount           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setChannelCount");
+    pContext->aaudio.AAudioStreamBuilder_setSampleRate             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setSampleRate");
+    pContext->aaudio.AAudioStreamBuilder_setBufferCapacityInFrames = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setBufferCapacityInFrames");
+    pContext->aaudio.AAudioStreamBuilder_setFramesPerDataCallback  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setFramesPerDataCallback");
+    pContext->aaudio.AAudioStreamBuilder_setDataCallback           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setDataCallback");
+    pContext->aaudio.AAudioStreamBuilder_setErrorCallback          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setErrorCallback");
+    pContext->aaudio.AAudioStreamBuilder_setPerformanceMode        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setPerformanceMode");
+    pContext->aaudio.AAudioStreamBuilder_setUsage                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setUsage");
+    pContext->aaudio.AAudioStreamBuilder_setContentType            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setContentType");
+    pContext->aaudio.AAudioStreamBuilder_setInputPreset            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setInputPreset");
+    pContext->aaudio.AAudioStreamBuilder_setAllowedCapturePolicy   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setAllowedCapturePolicy");
+    pContext->aaudio.AAudioStreamBuilder_openStream                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_openStream");
+    pContext->aaudio.AAudioStream_close                            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_close");
+    pContext->aaudio.AAudioStream_getState                         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getState");
+    pContext->aaudio.AAudioStream_waitForStateChange               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_waitForStateChange");
+    pContext->aaudio.AAudioStream_getFormat                        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getFormat");
+    pContext->aaudio.AAudioStream_getChannelCount                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getChannelCount");
+    pContext->aaudio.AAudioStream_getSampleRate                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getSampleRate");
+    pContext->aaudio.AAudioStream_getBufferCapacityInFrames        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getBufferCapacityInFrames");
+    pContext->aaudio.AAudioStream_getFramesPerDataCallback         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getFramesPerDataCallback");
+    pContext->aaudio.AAudioStream_getFramesPerBurst                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getFramesPerBurst");
+    pContext->aaudio.AAudioStream_requestStart                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_requestStart");
+    pContext->aaudio.AAudioStream_requestStop                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_requestStop");
+#else
+    pContext->aaudio.AAudio_createStreamBuilder                    = (ma_proc)AAudio_createStreamBuilder;
+    pContext->aaudio.AAudioStreamBuilder_delete                    = (ma_proc)AAudioStreamBuilder_delete;
+    pContext->aaudio.AAudioStreamBuilder_setDeviceId               = (ma_proc)AAudioStreamBuilder_setDeviceId;
+    pContext->aaudio.AAudioStreamBuilder_setDirection              = (ma_proc)AAudioStreamBuilder_setDirection;
+    pContext->aaudio.AAudioStreamBuilder_setSharingMode            = (ma_proc)AAudioStreamBuilder_setSharingMode;
+    pContext->aaudio.AAudioStreamBuilder_setFormat                 = (ma_proc)AAudioStreamBuilder_setFormat;
+    pContext->aaudio.AAudioStreamBuilder_setChannelCount           = (ma_proc)AAudioStreamBuilder_setChannelCount;
+    pContext->aaudio.AAudioStreamBuilder_setSampleRate             = (ma_proc)AAudioStreamBuilder_setSampleRate;
+    pContext->aaudio.AAudioStreamBuilder_setBufferCapacityInFrames = (ma_proc)AAudioStreamBuilder_setBufferCapacityInFrames;
+    pContext->aaudio.AAudioStreamBuilder_setFramesPerDataCallback  = (ma_proc)AAudioStreamBuilder_setFramesPerDataCallback;
+    pContext->aaudio.AAudioStreamBuilder_setDataCallback           = (ma_proc)AAudioStreamBuilder_setDataCallback;
+    pContext->aaudio.AAudioStreamBuilder_setErrorCallback          = (ma_proc)AAudioStreamBuilder_setErrorCallback;
+    pContext->aaudio.AAudioStreamBuilder_setPerformanceMode        = (ma_proc)AAudioStreamBuilder_setPerformanceMode;
+    pContext->aaudio.AAudioStreamBuilder_setUsage                  = (ma_proc)AAudioStreamBuilder_setUsage;
+    pContext->aaudio.AAudioStreamBuilder_setContentType            = (ma_proc)AAudioStreamBuilder_setContentType;
+    pContext->aaudio.AAudioStreamBuilder_setInputPreset            = (ma_proc)AAudioStreamBuilder_setInputPreset;
+    #if defined(__ANDROID_API__) && __ANDROID_API__ >= 29
+    pContext->aaudio.AAudioStreamBuilder_setAllowedCapturePolicy   = (ma_proc)AAudioStreamBuilder_setAllowedCapturePolicy;
+    #endif
+    pContext->aaudio.AAudioStreamBuilder_openStream                = (ma_proc)AAudioStreamBuilder_openStream;
+    pContext->aaudio.AAudioStream_close                            = (ma_proc)AAudioStream_close;
+    pContext->aaudio.AAudioStream_getState                         = (ma_proc)AAudioStream_getState;
+    pContext->aaudio.AAudioStream_waitForStateChange               = (ma_proc)AAudioStream_waitForStateChange;
+    pContext->aaudio.AAudioStream_getFormat                        = (ma_proc)AAudioStream_getFormat;
+    pContext->aaudio.AAudioStream_getChannelCount                  = (ma_proc)AAudioStream_getChannelCount;
+    pContext->aaudio.AAudioStream_getSampleRate                    = (ma_proc)AAudioStream_getSampleRate;
+    pContext->aaudio.AAudioStream_getBufferCapacityInFrames        = (ma_proc)AAudioStream_getBufferCapacityInFrames;
+    pContext->aaudio.AAudioStream_getFramesPerDataCallback         = (ma_proc)AAudioStream_getFramesPerDataCallback;
+    pContext->aaudio.AAudioStream_getFramesPerBurst                = (ma_proc)AAudioStream_getFramesPerBurst;
+    pContext->aaudio.AAudioStream_requestStart                     = (ma_proc)AAudioStream_requestStart;
+    pContext->aaudio.AAudioStream_requestStop                      = (ma_proc)AAudioStream_requestStop;
+#endif
+
+    pCallbacks->onContextInit             = ma_context_init__aaudio;
+    pCallbacks->onContextUninit           = ma_context_uninit__aaudio;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__aaudio;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__aaudio;
+    pCallbacks->onDeviceInit              = ma_device_init__aaudio;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__aaudio;
+    pCallbacks->onDeviceStart             = ma_device_start__aaudio;
+    pCallbacks->onDeviceStop              = ma_device_stop__aaudio;
+    pCallbacks->onDeviceRead              = NULL;   /* Not used because AAudio is asynchronous. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not used because AAudio is asynchronous. */
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Not used because AAudio is asynchronous. */
+    pCallbacks->onDeviceGetInfo           = ma_device_get_info__aaudio;
+
+
+    /* We need a job thread so we can deal with rerouting. */
+    {
+        ma_result result;
+        ma_device_job_thread_config jobThreadConfig;
+
+        jobThreadConfig = ma_device_job_thread_config_init();
+
+        result = ma_device_job_thread_init(&jobThreadConfig, &pContext->allocationCallbacks, &pContext->aaudio.jobThread);
+        if (result != MA_SUCCESS) {
+            ma_dlclose(ma_context_get_log(pContext), pContext->aaudio.hAAudio);
+            pContext->aaudio.hAAudio = NULL;
+            return result;
+        }
+    }
+
+
+    (void)pConfig;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__device__aaudio_reroute(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_device* pDevice;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDevice = (ma_device*)pJob->data.device.aaudio.reroute.pDevice;
+    MA_ASSERT(pDevice != NULL);
+
+    ma_mutex_lock(&pDevice->aaudio.rerouteLock);
+    {
+        /* Here is where we need to reroute the device. To do this we need to uninitialize the stream and reinitialize it. */
+        result = ma_device_reinit__aaudio(pDevice, (ma_device_type)pJob->data.device.aaudio.reroute.deviceType);
+        if (result != MA_SUCCESS) {
+            /*
+            Getting here means we failed to reroute the device. The best thing I can think of here is to
+            just stop the device.
+            */
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[AAudio] Stopping device due to reroute failure.");
+            ma_device_stop(pDevice);
+        }
+    }
+    ma_mutex_unlock(&pDevice->aaudio.rerouteLock);
+
+    return result;
+}
+#else
+/* Getting here means there is no AAudio backend so we need a no-op job implementation. */
+static ma_result ma_job_process__device__aaudio_reroute(ma_job* pJob)
+{
+    return ma_job_process__noop(pJob);
+}
+#endif  /* AAudio */
+
+
+/******************************************************************************
+
+OpenSL|ES Backend
+
+******************************************************************************/
+#ifdef MA_HAS_OPENSL
+#include <SLES/OpenSLES.h>
+#ifdef MA_ANDROID
+#include <SLES/OpenSLES_Android.h>
+#endif
+
+typedef SLresult (SLAPIENTRY * ma_slCreateEngine_proc)(SLObjectItf* pEngine, SLuint32 numOptions, SLEngineOption* pEngineOptions, SLuint32 numInterfaces, SLInterfaceID* pInterfaceIds, SLboolean* pInterfaceRequired);
+
+/* OpenSL|ES has one-per-application objects :( */
+static SLObjectItf g_maEngineObjectSL    = NULL;
+static SLEngineItf g_maEngineSL          = NULL;
+static ma_uint32   g_maOpenSLInitCounter = 0;
+static ma_spinlock g_maOpenSLSpinlock    = 0;   /* For init/uninit. */
+
+#define MA_OPENSL_OBJ(p)         (*((SLObjectItf)(p)))
+#define MA_OPENSL_OUTPUTMIX(p)   (*((SLOutputMixItf)(p)))
+#define MA_OPENSL_PLAY(p)        (*((SLPlayItf)(p)))
+#define MA_OPENSL_RECORD(p)      (*((SLRecordItf)(p)))
+
+#ifdef MA_ANDROID
+#define MA_OPENSL_BUFFERQUEUE(p) (*((SLAndroidSimpleBufferQueueItf)(p)))
+#else
+#define MA_OPENSL_BUFFERQUEUE(p) (*((SLBufferQueueItf)(p)))
+#endif
+
+static ma_result ma_result_from_OpenSL(SLuint32 result)
+{
+    switch (result)
+    {
+        case SL_RESULT_SUCCESS:                 return MA_SUCCESS;
+        case SL_RESULT_PRECONDITIONS_VIOLATED:  return MA_ERROR;
+        case SL_RESULT_PARAMETER_INVALID:       return MA_INVALID_ARGS;
+        case SL_RESULT_MEMORY_FAILURE:          return MA_OUT_OF_MEMORY;
+        case SL_RESULT_RESOURCE_ERROR:          return MA_INVALID_DATA;
+        case SL_RESULT_RESOURCE_LOST:           return MA_ERROR;
+        case SL_RESULT_IO_ERROR:                return MA_IO_ERROR;
+        case SL_RESULT_BUFFER_INSUFFICIENT:     return MA_NO_SPACE;
+        case SL_RESULT_CONTENT_CORRUPTED:       return MA_INVALID_DATA;
+        case SL_RESULT_CONTENT_UNSUPPORTED:     return MA_FORMAT_NOT_SUPPORTED;
+        case SL_RESULT_CONTENT_NOT_FOUND:       return MA_ERROR;
+        case SL_RESULT_PERMISSION_DENIED:       return MA_ACCESS_DENIED;
+        case SL_RESULT_FEATURE_UNSUPPORTED:     return MA_NOT_IMPLEMENTED;
+        case SL_RESULT_INTERNAL_ERROR:          return MA_ERROR;
+        case SL_RESULT_UNKNOWN_ERROR:           return MA_ERROR;
+        case SL_RESULT_OPERATION_ABORTED:       return MA_ERROR;
+        case SL_RESULT_CONTROL_LOST:            return MA_ERROR;
+        default:                                return MA_ERROR;
+    }
+}
+
+/* Converts an individual OpenSL-style channel identifier (SL_SPEAKER_FRONT_LEFT, etc.) to miniaudio. */
+static ma_uint8 ma_channel_id_to_ma__opensl(SLuint32 id)
+{
+    switch (id)
+    {
+        case SL_SPEAKER_FRONT_LEFT:            return MA_CHANNEL_FRONT_LEFT;
+        case SL_SPEAKER_FRONT_RIGHT:           return MA_CHANNEL_FRONT_RIGHT;
+        case SL_SPEAKER_FRONT_CENTER:          return MA_CHANNEL_FRONT_CENTER;
+        case SL_SPEAKER_LOW_FREQUENCY:         return MA_CHANNEL_LFE;
+        case SL_SPEAKER_BACK_LEFT:             return MA_CHANNEL_BACK_LEFT;
+        case SL_SPEAKER_BACK_RIGHT:            return MA_CHANNEL_BACK_RIGHT;
+        case SL_SPEAKER_FRONT_LEFT_OF_CENTER:  return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case SL_SPEAKER_FRONT_RIGHT_OF_CENTER: return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case SL_SPEAKER_BACK_CENTER:           return MA_CHANNEL_BACK_CENTER;
+        case SL_SPEAKER_SIDE_LEFT:             return MA_CHANNEL_SIDE_LEFT;
+        case SL_SPEAKER_SIDE_RIGHT:            return MA_CHANNEL_SIDE_RIGHT;
+        case SL_SPEAKER_TOP_CENTER:            return MA_CHANNEL_TOP_CENTER;
+        case SL_SPEAKER_TOP_FRONT_LEFT:        return MA_CHANNEL_TOP_FRONT_LEFT;
+        case SL_SPEAKER_TOP_FRONT_CENTER:      return MA_CHANNEL_TOP_FRONT_CENTER;
+        case SL_SPEAKER_TOP_FRONT_RIGHT:       return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case SL_SPEAKER_TOP_BACK_LEFT:         return MA_CHANNEL_TOP_BACK_LEFT;
+        case SL_SPEAKER_TOP_BACK_CENTER:       return MA_CHANNEL_TOP_BACK_CENTER;
+        case SL_SPEAKER_TOP_BACK_RIGHT:        return MA_CHANNEL_TOP_BACK_RIGHT;
+        default: return 0;
+    }
+}
+
+/* Converts an individual miniaudio channel identifier (MA_CHANNEL_FRONT_LEFT, etc.) to OpenSL-style. */
+static SLuint32 ma_channel_id_to_opensl(ma_uint8 id)
+{
+    switch (id)
+    {
+        case MA_CHANNEL_MONO:               return SL_SPEAKER_FRONT_CENTER;
+        case MA_CHANNEL_FRONT_LEFT:         return SL_SPEAKER_FRONT_LEFT;
+        case MA_CHANNEL_FRONT_RIGHT:        return SL_SPEAKER_FRONT_RIGHT;
+        case MA_CHANNEL_FRONT_CENTER:       return SL_SPEAKER_FRONT_CENTER;
+        case MA_CHANNEL_LFE:                return SL_SPEAKER_LOW_FREQUENCY;
+        case MA_CHANNEL_BACK_LEFT:          return SL_SPEAKER_BACK_LEFT;
+        case MA_CHANNEL_BACK_RIGHT:         return SL_SPEAKER_BACK_RIGHT;
+        case MA_CHANNEL_FRONT_LEFT_CENTER:  return SL_SPEAKER_FRONT_LEFT_OF_CENTER;
+        case MA_CHANNEL_FRONT_RIGHT_CENTER: return SL_SPEAKER_FRONT_RIGHT_OF_CENTER;
+        case MA_CHANNEL_BACK_CENTER:        return SL_SPEAKER_BACK_CENTER;
+        case MA_CHANNEL_SIDE_LEFT:          return SL_SPEAKER_SIDE_LEFT;
+        case MA_CHANNEL_SIDE_RIGHT:         return SL_SPEAKER_SIDE_RIGHT;
+        case MA_CHANNEL_TOP_CENTER:         return SL_SPEAKER_TOP_CENTER;
+        case MA_CHANNEL_TOP_FRONT_LEFT:     return SL_SPEAKER_TOP_FRONT_LEFT;
+        case MA_CHANNEL_TOP_FRONT_CENTER:   return SL_SPEAKER_TOP_FRONT_CENTER;
+        case MA_CHANNEL_TOP_FRONT_RIGHT:    return SL_SPEAKER_TOP_FRONT_RIGHT;
+        case MA_CHANNEL_TOP_BACK_LEFT:      return SL_SPEAKER_TOP_BACK_LEFT;
+        case MA_CHANNEL_TOP_BACK_CENTER:    return SL_SPEAKER_TOP_BACK_CENTER;
+        case MA_CHANNEL_TOP_BACK_RIGHT:     return SL_SPEAKER_TOP_BACK_RIGHT;
+        default: return 0;
+    }
+}
+
+/* Converts a channel mapping to an OpenSL-style channel mask. */
+static SLuint32 ma_channel_map_to_channel_mask__opensl(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    SLuint32 channelMask = 0;
+    ma_uint32 iChannel;
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        channelMask |= ma_channel_id_to_opensl(pChannelMap[iChannel]);
+    }
+
+    return channelMask;
+}
+
+/* Converts an OpenSL-style channel mask to a miniaudio channel map. */
+static void ma_channel_mask_to_channel_map__opensl(SLuint32 channelMask, ma_uint32 channels, ma_channel* pChannelMap)
+{
+    if (channels == 1 && channelMask == 0) {
+        pChannelMap[0] = MA_CHANNEL_MONO;
+    } else if (channels == 2 && channelMask == 0) {
+        pChannelMap[0] = MA_CHANNEL_FRONT_LEFT;
+        pChannelMap[1] = MA_CHANNEL_FRONT_RIGHT;
+    } else {
+        if (channels == 1 && (channelMask & SL_SPEAKER_FRONT_CENTER) != 0) {
+            pChannelMap[0] = MA_CHANNEL_MONO;
+        } else {
+            /* Just iterate over each bit. */
+            ma_uint32 iChannel = 0;
+            ma_uint32 iBit;
+            for (iBit = 0; iBit < 32 && iChannel < channels; ++iBit) {
+                SLuint32 bitValue = (channelMask & (1UL << iBit));
+                if (bitValue != 0) {
+                    /* The bit is set. */
+                    pChannelMap[iChannel] = ma_channel_id_to_ma__opensl(bitValue);
+                    iChannel += 1;
+                }
+            }
+        }
+    }
+}
+
+static SLuint32 ma_round_to_standard_sample_rate__opensl(SLuint32 samplesPerSec)
+{
+    if (samplesPerSec <= SL_SAMPLINGRATE_8) {
+        return SL_SAMPLINGRATE_8;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_11_025) {
+        return SL_SAMPLINGRATE_11_025;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_12) {
+        return SL_SAMPLINGRATE_12;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_16) {
+        return SL_SAMPLINGRATE_16;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_22_05) {
+        return SL_SAMPLINGRATE_22_05;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_24) {
+        return SL_SAMPLINGRATE_24;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_32) {
+        return SL_SAMPLINGRATE_32;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_44_1) {
+        return SL_SAMPLINGRATE_44_1;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_48) {
+        return SL_SAMPLINGRATE_48;
+    }
+
+    /* Android doesn't support more than 48000. */
+#ifndef MA_ANDROID
+    if (samplesPerSec <= SL_SAMPLINGRATE_64) {
+        return SL_SAMPLINGRATE_64;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_88_2) {
+        return SL_SAMPLINGRATE_88_2;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_96) {
+        return SL_SAMPLINGRATE_96;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_192) {
+        return SL_SAMPLINGRATE_192;
+    }
+#endif
+
+    return SL_SAMPLINGRATE_16;
+}
+
+
+static SLint32 ma_to_stream_type__opensl(ma_opensl_stream_type streamType)
+{
+    switch (streamType) {
+        case ma_opensl_stream_type_voice:        return SL_ANDROID_STREAM_VOICE;
+        case ma_opensl_stream_type_system:       return SL_ANDROID_STREAM_SYSTEM;
+        case ma_opensl_stream_type_ring:         return SL_ANDROID_STREAM_RING;
+        case ma_opensl_stream_type_media:        return SL_ANDROID_STREAM_MEDIA;
+        case ma_opensl_stream_type_alarm:        return SL_ANDROID_STREAM_ALARM;
+        case ma_opensl_stream_type_notification: return SL_ANDROID_STREAM_NOTIFICATION;
+        default: break;
+    }
+
+    return SL_ANDROID_STREAM_VOICE;
+}
+
+static SLint32 ma_to_recording_preset__opensl(ma_opensl_recording_preset recordingPreset)
+{
+    switch (recordingPreset) {
+        case ma_opensl_recording_preset_generic:             return SL_ANDROID_RECORDING_PRESET_GENERIC;
+        case ma_opensl_recording_preset_camcorder:           return SL_ANDROID_RECORDING_PRESET_CAMCORDER;
+        case ma_opensl_recording_preset_voice_recognition:   return SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION;
+        case ma_opensl_recording_preset_voice_communication: return SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION;
+        case ma_opensl_recording_preset_voice_unprocessed:   return SL_ANDROID_RECORDING_PRESET_UNPROCESSED;
+        default: break;
+    }
+
+    return SL_ANDROID_RECORDING_PRESET_NONE;
+}
+
+
+static ma_result ma_context_enumerate_devices__opensl(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it and then attempted to enumerate devices. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    TODO: Test Me.
+
+    This is currently untested, so for now we are just returning default devices.
+    */
+#if 0 && !defined(MA_ANDROID)
+    ma_bool32 isTerminated = MA_FALSE;
+
+    SLuint32 pDeviceIDs[128];
+    SLint32 deviceCount = sizeof(pDeviceIDs) / sizeof(pDeviceIDs[0]);
+
+    SLAudioIODeviceCapabilitiesItf deviceCaps;
+    SLresult resultSL = (*g_maEngineObjectSL)->GetInterface(g_maEngineObjectSL, (SLInterfaceID)pContext->opensl.SL_IID_AUDIOIODEVICECAPABILITIES, &deviceCaps);
+    if (resultSL != SL_RESULT_SUCCESS) {
+        /* The interface may not be supported so just report a default device. */
+        goto return_default_device;
+    }
+
+    /* Playback */
+    if (!isTerminated) {
+        resultSL = (*deviceCaps)->GetAvailableAudioOutputs(deviceCaps, &deviceCount, pDeviceIDs);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        for (SLint32 iDevice = 0; iDevice < deviceCount; ++iDevice) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            deviceInfo.id.opensl = pDeviceIDs[iDevice];
+
+            SLAudioOutputDescriptor desc;
+            resultSL = (*deviceCaps)->QueryAudioOutputCapabilities(deviceCaps, deviceInfo.id.opensl, &desc);
+            if (resultSL == SL_RESULT_SUCCESS) {
+                ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), (const char*)desc.pDeviceName, (size_t)-1);
+
+                ma_bool32 cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                if (cbResult == MA_FALSE) {
+                    isTerminated = MA_TRUE;
+                    break;
+                }
+            }
+        }
+    }
+
+    /* Capture */
+    if (!isTerminated) {
+        resultSL = (*deviceCaps)->GetAvailableAudioInputs(deviceCaps, &deviceCount, pDeviceIDs);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        for (SLint32 iDevice = 0; iDevice < deviceCount; ++iDevice) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            deviceInfo.id.opensl = pDeviceIDs[iDevice];
+
+            SLAudioInputDescriptor desc;
+            resultSL = (*deviceCaps)->QueryAudioInputCapabilities(deviceCaps, deviceInfo.id.opensl, &desc);
+            if (resultSL == SL_RESULT_SUCCESS) {
+                ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), (const char*)desc.deviceName, (size_t)-1);
+
+                ma_bool32 cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                if (cbResult == MA_FALSE) {
+                    isTerminated = MA_TRUE;
+                    break;
+                }
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+#else
+    goto return_default_device;
+#endif
+
+return_default_device:;
+    cbResult = MA_TRUE;
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        deviceInfo.id.opensl = SL_DEFAULTDEVICEID_AUDIOOUTPUT;
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        deviceInfo.id.opensl = SL_DEFAULTDEVICEID_AUDIOINPUT;
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+        cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_context_add_data_format_ex__opensl(ma_context* pContext, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext    != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = sampleRate;
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = 0;
+    pDeviceInfo->nativeDataFormatCount += 1;
+}
+
+static void ma_context_add_data_format__opensl(ma_context* pContext, ma_format format, ma_device_info* pDeviceInfo)
+{
+    ma_uint32 minChannels   = 1;
+    ma_uint32 maxChannels   = 2;
+    ma_uint32 minSampleRate = (ma_uint32)ma_standard_sample_rate_8000;
+    ma_uint32 maxSampleRate = (ma_uint32)ma_standard_sample_rate_48000;
+    ma_uint32 iChannel;
+    ma_uint32 iSampleRate;
+
+    MA_ASSERT(pContext    != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    /*
+    Each sample format can support mono and stereo, and we'll support a small subset of standard
+    rates (up to 48000). A better solution would be to somehow find a native sample rate.
+    */
+    for (iChannel = minChannels; iChannel < maxChannels; iChannel += 1) {
+        for (iSampleRate = 0; iSampleRate < ma_countof(g_maStandardSampleRatePriorities); iSampleRate += 1) {
+            ma_uint32 standardSampleRate = g_maStandardSampleRatePriorities[iSampleRate];
+            if (standardSampleRate >= minSampleRate && standardSampleRate <= maxSampleRate) {
+                ma_context_add_data_format_ex__opensl(pContext, format, iChannel, standardSampleRate, pDeviceInfo);
+            }
+        }
+    }
+}
+
+static ma_result ma_context_get_device_info__opensl(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it and then attempted to get device info. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    TODO: Test Me.
+
+    This is currently untested, so for now we are just returning default devices.
+    */
+#if 0 && !defined(MA_ANDROID)
+    SLAudioIODeviceCapabilitiesItf deviceCaps;
+    SLresult resultSL = (*g_maEngineObjectSL)->GetInterface(g_maEngineObjectSL, (SLInterfaceID)pContext->opensl.SL_IID_AUDIOIODEVICECAPABILITIES, &deviceCaps);
+    if (resultSL != SL_RESULT_SUCCESS) {
+        /* The interface may not be supported so just report a default device. */
+        goto return_default_device;
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        SLAudioOutputDescriptor desc;
+        resultSL = (*deviceCaps)->QueryAudioOutputCapabilities(deviceCaps, pDeviceID->opensl, &desc);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), (const char*)desc.pDeviceName, (size_t)-1);
+    } else {
+        SLAudioInputDescriptor desc;
+        resultSL = (*deviceCaps)->QueryAudioInputCapabilities(deviceCaps, pDeviceID->opensl, &desc);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), (const char*)desc.deviceName, (size_t)-1);
+    }
+
+    goto return_detailed_info;
+#else
+    goto return_default_device;
+#endif
+
+return_default_device:
+    if (pDeviceID != NULL) {
+        if ((deviceType == ma_device_type_playback && pDeviceID->opensl != SL_DEFAULTDEVICEID_AUDIOOUTPUT) ||
+            (deviceType == ma_device_type_capture  && pDeviceID->opensl != SL_DEFAULTDEVICEID_AUDIOINPUT)) {
+            return MA_NO_DEVICE;   /* Don't know the device. */
+        }
+    }
+
+    /* ID and Name / Description */
+    if (deviceType == ma_device_type_playback) {
+        pDeviceInfo->id.opensl = SL_DEFAULTDEVICEID_AUDIOOUTPUT;
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        pDeviceInfo->id.opensl = SL_DEFAULTDEVICEID_AUDIOINPUT;
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+    pDeviceInfo->isDefault = MA_TRUE;
+
+    goto return_detailed_info;
+
+
+return_detailed_info:
+
+    /*
+    For now we're just outputting a set of values that are supported by the API but not necessarily supported
+    by the device natively. Later on we should work on this so that it more closely reflects the device's
+    actual native format.
+    */
+    pDeviceInfo->nativeDataFormatCount = 0;
+#if defined(MA_ANDROID) && __ANDROID_API__ >= 21
+    ma_context_add_data_format__opensl(pContext, ma_format_f32, pDeviceInfo);
+#endif
+    ma_context_add_data_format__opensl(pContext, ma_format_s16, pDeviceInfo);
+    ma_context_add_data_format__opensl(pContext, ma_format_u8,  pDeviceInfo);
+
+    return MA_SUCCESS;
+}
+
+
+#ifdef MA_ANDROID
+/*void ma_buffer_queue_callback_capture__opensl_android(SLAndroidSimpleBufferQueueItf pBufferQueue, SLuint32 eventFlags, const void* pBuffer, SLuint32 bufferSize, SLuint32 dataUsed, void* pContext)*/
+static void ma_buffer_queue_callback_capture__opensl_android(SLAndroidSimpleBufferQueueItf pBufferQueue, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    size_t periodSizeInBytes;
+    ma_uint8* pBuffer;
+    SLresult resultSL;
+
+    MA_ASSERT(pDevice != NULL);
+
+    (void)pBufferQueue;
+
+    /*
+    For now, don't do anything unless the buffer was fully processed. From what I can tell, it looks like
+    OpenSL|ES 1.1 improves on buffer queues to the point that we could much more intelligently handle this,
+    but unfortunately it looks like Android is only supporting OpenSL|ES 1.0.1 for now :(
+    */
+
+    /* Don't do anything if the device is not started. */
+    if (ma_device_get_state(pDevice) != ma_device_state_started) {
+        return;
+    }
+
+    /* Don't do anything if the device is being drained. */
+    if (pDevice->opensl.isDrainingCapture) {
+        return;
+    }
+
+    periodSizeInBytes = pDevice->capture.internalPeriodSizeInFrames * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    pBuffer = pDevice->opensl.pBufferCapture + (pDevice->opensl.currentBufferIndexCapture * periodSizeInBytes);
+
+    ma_device_handle_backend_data_callback(pDevice, NULL, pBuffer, pDevice->capture.internalPeriodSizeInFrames);
+
+    resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueueCapture)->Enqueue((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture, pBuffer, periodSizeInBytes);
+    if (resultSL != SL_RESULT_SUCCESS) {
+        return;
+    }
+
+    pDevice->opensl.currentBufferIndexCapture = (pDevice->opensl.currentBufferIndexCapture + 1) % pDevice->capture.internalPeriods;
+}
+
+static void ma_buffer_queue_callback_playback__opensl_android(SLAndroidSimpleBufferQueueItf pBufferQueue, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    size_t periodSizeInBytes;
+    ma_uint8* pBuffer;
+    SLresult resultSL;
+
+    MA_ASSERT(pDevice != NULL);
+
+    (void)pBufferQueue;
+
+    /* Don't do anything if the device is not started. */
+    if (ma_device_get_state(pDevice) != ma_device_state_started) {
+        return;
+    }
+
+    /* Don't do anything if the device is being drained. */
+    if (pDevice->opensl.isDrainingPlayback) {
+        return;
+    }
+
+    periodSizeInBytes = pDevice->playback.internalPeriodSizeInFrames * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    pBuffer = pDevice->opensl.pBufferPlayback + (pDevice->opensl.currentBufferIndexPlayback * periodSizeInBytes);
+
+    ma_device_handle_backend_data_callback(pDevice, pBuffer, NULL, pDevice->playback.internalPeriodSizeInFrames);
+
+    resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueuePlayback)->Enqueue((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback, pBuffer, periodSizeInBytes);
+    if (resultSL != SL_RESULT_SUCCESS) {
+        return;
+    }
+
+    pDevice->opensl.currentBufferIndexPlayback = (pDevice->opensl.currentBufferIndexPlayback + 1) % pDevice->playback.internalPeriods;
+}
+#endif
+
+static ma_result ma_device_uninit__opensl(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it before uninitializing the device. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->opensl.pAudioRecorderObj) {
+            MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->Destroy((SLObjectItf)pDevice->opensl.pAudioRecorderObj);
+        }
+
+        ma_free(pDevice->opensl.pBufferCapture, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->opensl.pAudioPlayerObj) {
+            MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->Destroy((SLObjectItf)pDevice->opensl.pAudioPlayerObj);
+        }
+        if (pDevice->opensl.pOutputMixObj) {
+            MA_OPENSL_OBJ(pDevice->opensl.pOutputMixObj)->Destroy((SLObjectItf)pDevice->opensl.pOutputMixObj);
+        }
+
+        ma_free(pDevice->opensl.pBufferPlayback, &pDevice->pContext->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+#if defined(MA_ANDROID) && __ANDROID_API__ >= 21
+typedef SLAndroidDataFormat_PCM_EX  ma_SLDataFormat_PCM;
+#else
+typedef SLDataFormat_PCM            ma_SLDataFormat_PCM;
+#endif
+
+static ma_result ma_SLDataFormat_PCM_init__opensl(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, const ma_channel* channelMap, ma_SLDataFormat_PCM* pDataFormat)
+{
+    /* We need to convert our format/channels/rate so that they aren't set to default. */
+    if (format == ma_format_unknown) {
+        format = MA_DEFAULT_FORMAT;
+    }
+    if (channels == 0) {
+        channels = MA_DEFAULT_CHANNELS;
+    }
+    if (sampleRate == 0) {
+        sampleRate = MA_DEFAULT_SAMPLE_RATE;
+    }
+
+#if defined(MA_ANDROID) && __ANDROID_API__ >= 21
+    if (format == ma_format_f32) {
+        pDataFormat->formatType     = SL_ANDROID_DATAFORMAT_PCM_EX;
+        pDataFormat->representation = SL_ANDROID_PCM_REPRESENTATION_FLOAT;
+    } else {
+        pDataFormat->formatType = SL_DATAFORMAT_PCM;
+    }
+#else
+    pDataFormat->formatType = SL_DATAFORMAT_PCM;
+#endif
+
+    pDataFormat->numChannels   = channels;
+    ((SLDataFormat_PCM*)pDataFormat)->samplesPerSec = ma_round_to_standard_sample_rate__opensl(sampleRate * 1000);  /* In millihertz. Annoyingly, the sample rate variable is named differently between SLAndroidDataFormat_PCM_EX and SLDataFormat_PCM */
+    pDataFormat->bitsPerSample = ma_get_bytes_per_sample(format) * 8;
+    pDataFormat->channelMask   = ma_channel_map_to_channel_mask__opensl(channelMap, channels);
+    pDataFormat->endianness    = (ma_is_little_endian()) ? SL_BYTEORDER_LITTLEENDIAN : SL_BYTEORDER_BIGENDIAN;
+
+    /*
+    Android has a few restrictions on the format as documented here: https://developer.android.com/ndk/guides/audio/opensl-for-android.html
+     - Only mono and stereo is supported.
+     - Only u8 and s16 formats are supported.
+     - Maximum sample rate of 48000.
+    */
+#ifdef MA_ANDROID
+    if (pDataFormat->numChannels > 2) {
+        pDataFormat->numChannels = 2;
+    }
+#if __ANDROID_API__ >= 21
+    if (pDataFormat->formatType == SL_ANDROID_DATAFORMAT_PCM_EX) {
+        /* It's floating point. */
+        MA_ASSERT(pDataFormat->representation == SL_ANDROID_PCM_REPRESENTATION_FLOAT);
+        if (pDataFormat->bitsPerSample > 32) {
+            pDataFormat->bitsPerSample = 32;
+        }
+    } else {
+        if (pDataFormat->bitsPerSample > 16) {
+            pDataFormat->bitsPerSample = 16;
+        }
+    }
+#else
+    if (pDataFormat->bitsPerSample > 16) {
+        pDataFormat->bitsPerSample = 16;
+    }
+#endif
+    if (((SLDataFormat_PCM*)pDataFormat)->samplesPerSec > SL_SAMPLINGRATE_48) {
+        ((SLDataFormat_PCM*)pDataFormat)->samplesPerSec = SL_SAMPLINGRATE_48;
+    }
+#endif
+
+    pDataFormat->containerSize = pDataFormat->bitsPerSample;  /* Always tightly packed for now. */
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_deconstruct_SLDataFormat_PCM__opensl(ma_SLDataFormat_PCM* pDataFormat, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_bool32 isFloatingPoint = MA_FALSE;
+#if defined(MA_ANDROID) && __ANDROID_API__ >= 21
+    if (pDataFormat->formatType == SL_ANDROID_DATAFORMAT_PCM_EX) {
+        MA_ASSERT(pDataFormat->representation == SL_ANDROID_PCM_REPRESENTATION_FLOAT);
+        isFloatingPoint = MA_TRUE;
+    }
+#endif
+    if (isFloatingPoint) {
+        if (pDataFormat->bitsPerSample == 32) {
+            *pFormat = ma_format_f32;
+        }
+    } else {
+        if (pDataFormat->bitsPerSample == 8) {
+            *pFormat = ma_format_u8;
+        } else if (pDataFormat->bitsPerSample == 16) {
+            *pFormat = ma_format_s16;
+        } else if (pDataFormat->bitsPerSample == 24) {
+            *pFormat = ma_format_s24;
+        } else if (pDataFormat->bitsPerSample == 32) {
+            *pFormat = ma_format_s32;
+        }
+    }
+
+    *pChannels   = pDataFormat->numChannels;
+    *pSampleRate = ((SLDataFormat_PCM*)pDataFormat)->samplesPerSec / 1000;
+    ma_channel_mask_to_channel_map__opensl(pDataFormat->channelMask, ma_min(pDataFormat->numChannels, channelMapCap), pChannelMap);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__opensl(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+#ifdef MA_ANDROID
+    SLDataLocator_AndroidSimpleBufferQueue queue;
+    SLresult resultSL;
+    size_t bufferSizeInBytes;
+    SLInterfaceID itfIDs[2];
+    const SLboolean itfIDsRequired[] = {
+        SL_BOOLEAN_TRUE,    /* SL_IID_ANDROIDSIMPLEBUFFERQUEUE */
+        SL_BOOLEAN_FALSE    /* SL_IID_ANDROIDCONFIGURATION */
+    };
+#endif
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it and then attempted to initialize a new device. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /*
+    For now, only supporting Android implementations of OpenSL|ES since that's the only one I've
+    been able to test with and I currently depend on Android-specific extensions (simple buffer
+    queues).
+    */
+#ifdef MA_ANDROID
+    itfIDs[0] = (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
+    itfIDs[1] = (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDCONFIGURATION;
+
+    /* No exclusive mode with OpenSL|ES. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    /* Now we can start initializing the device properly. */
+    MA_ASSERT(pDevice != NULL);
+    MA_ZERO_OBJECT(&pDevice->opensl);
+
+    queue.locatorType = SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE;
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_SLDataFormat_PCM pcm;
+        SLDataLocator_IODevice locatorDevice;
+        SLDataSource source;
+        SLDataSink sink;
+        SLAndroidConfigurationItf pRecorderConfig;
+
+        ma_SLDataFormat_PCM_init__opensl(pDescriptorCapture->format, pDescriptorCapture->channels, pDescriptorCapture->sampleRate, pDescriptorCapture->channelMap, &pcm);
+
+        locatorDevice.locatorType = SL_DATALOCATOR_IODEVICE;
+        locatorDevice.deviceType  = SL_IODEVICE_AUDIOINPUT;
+        locatorDevice.deviceID    = SL_DEFAULTDEVICEID_AUDIOINPUT;  /* Must always use the default device with Android. */
+        locatorDevice.device      = NULL;
+
+        source.pLocator = &locatorDevice;
+        source.pFormat  = NULL;
+
+        queue.numBuffers = pDescriptorCapture->periodCount;
+
+        sink.pLocator = &queue;
+        sink.pFormat  = (SLDataFormat_PCM*)&pcm;
+
+        resultSL = (*g_maEngineSL)->CreateAudioRecorder(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pAudioRecorderObj, &source, &sink, ma_countof(itfIDs), itfIDs, itfIDsRequired);
+        if (resultSL == SL_RESULT_CONTENT_UNSUPPORTED || resultSL == SL_RESULT_PARAMETER_INVALID) {
+            /* Unsupported format. Fall back to something safer and try again. If this fails, just abort. */
+            pcm.formatType    = SL_DATAFORMAT_PCM;
+            pcm.numChannels   = 1;
+            ((SLDataFormat_PCM*)&pcm)->samplesPerSec = SL_SAMPLINGRATE_16;  /* The name of the sample rate variable is different between SLAndroidDataFormat_PCM_EX and SLDataFormat_PCM. */
+            pcm.bitsPerSample = 16;
+            pcm.containerSize = pcm.bitsPerSample;  /* Always tightly packed for now. */
+            pcm.channelMask   = 0;
+            resultSL = (*g_maEngineSL)->CreateAudioRecorder(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pAudioRecorderObj, &source, &sink, ma_countof(itfIDs), itfIDs, itfIDsRequired);
+        }
+
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to create audio recorder.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+
+        /* Set the recording preset before realizing the player. */
+        if (pConfig->opensl.recordingPreset != ma_opensl_recording_preset_default) {
+            resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioRecorderObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDCONFIGURATION, &pRecorderConfig);
+            if (resultSL == SL_RESULT_SUCCESS) {
+                SLint32 recordingPreset = ma_to_recording_preset__opensl(pConfig->opensl.recordingPreset);
+                resultSL = (*pRecorderConfig)->SetConfiguration(pRecorderConfig, SL_ANDROID_KEY_RECORDING_PRESET, &recordingPreset, sizeof(SLint32));
+                if (resultSL != SL_RESULT_SUCCESS) {
+                    /* Failed to set the configuration. Just keep going. */
+                }
+            }
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->Realize((SLObjectItf)pDevice->opensl.pAudioRecorderObj, SL_BOOLEAN_FALSE);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to realize audio recorder.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioRecorderObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_RECORD, &pDevice->opensl.pAudioRecorder);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_RECORD interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioRecorderObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &pDevice->opensl.pBufferQueueCapture);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_ANDROIDSIMPLEBUFFERQUEUE interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueueCapture)->RegisterCallback((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture, ma_buffer_queue_callback_capture__opensl_android, pDevice);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to register buffer queue callback.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        /* The internal format is determined by the "pcm" object. */
+        ma_deconstruct_SLDataFormat_PCM__opensl(&pcm, &pDescriptorCapture->format, &pDescriptorCapture->channels, &pDescriptorCapture->sampleRate, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap));
+
+        /* Buffer. */
+        pDescriptorCapture->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorCapture, pDescriptorCapture->sampleRate, pConfig->performanceProfile);
+        pDevice->opensl.currentBufferIndexCapture = 0;
+
+        bufferSizeInBytes = pDescriptorCapture->periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels) * pDescriptorCapture->periodCount;
+        pDevice->opensl.pBufferCapture = (ma_uint8*)ma_calloc(bufferSizeInBytes, &pDevice->pContext->allocationCallbacks);
+        if (pDevice->opensl.pBufferCapture == NULL) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to allocate memory for data buffer.");
+            return MA_OUT_OF_MEMORY;
+        }
+        MA_ZERO_MEMORY(pDevice->opensl.pBufferCapture, bufferSizeInBytes);
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_SLDataFormat_PCM pcm;
+        SLDataSource source;
+        SLDataLocator_OutputMix outmixLocator;
+        SLDataSink sink;
+        SLAndroidConfigurationItf pPlayerConfig;
+
+        ma_SLDataFormat_PCM_init__opensl(pDescriptorPlayback->format, pDescriptorPlayback->channels, pDescriptorPlayback->sampleRate, pDescriptorPlayback->channelMap, &pcm);
+
+        resultSL = (*g_maEngineSL)->CreateOutputMix(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pOutputMixObj, 0, NULL, NULL);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to create output mix.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pOutputMixObj)->Realize((SLObjectItf)pDevice->opensl.pOutputMixObj, SL_BOOLEAN_FALSE);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to realize output mix object.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pOutputMixObj)->GetInterface((SLObjectItf)pDevice->opensl.pOutputMixObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_OUTPUTMIX, &pDevice->opensl.pOutputMix);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_OUTPUTMIX interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        /* Set the output device. */
+        if (pDescriptorPlayback->pDeviceID != NULL) {
+            SLuint32 deviceID_OpenSL = pDescriptorPlayback->pDeviceID->opensl;
+            MA_OPENSL_OUTPUTMIX(pDevice->opensl.pOutputMix)->ReRoute((SLOutputMixItf)pDevice->opensl.pOutputMix, 1, &deviceID_OpenSL);
+        }
+
+        queue.numBuffers = pDescriptorPlayback->periodCount;
+
+        source.pLocator = &queue;
+        source.pFormat  = (SLDataFormat_PCM*)&pcm;
+
+        outmixLocator.locatorType = SL_DATALOCATOR_OUTPUTMIX;
+        outmixLocator.outputMix   = (SLObjectItf)pDevice->opensl.pOutputMixObj;
+
+        sink.pLocator = &outmixLocator;
+        sink.pFormat  = NULL;
+
+        resultSL = (*g_maEngineSL)->CreateAudioPlayer(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pAudioPlayerObj, &source, &sink, ma_countof(itfIDs), itfIDs, itfIDsRequired);
+        if (resultSL == SL_RESULT_CONTENT_UNSUPPORTED || resultSL == SL_RESULT_PARAMETER_INVALID) {
+            /* Unsupported format. Fall back to something safer and try again. If this fails, just abort. */
+            pcm.formatType = SL_DATAFORMAT_PCM;
+            pcm.numChannels = 2;
+            ((SLDataFormat_PCM*)&pcm)->samplesPerSec = SL_SAMPLINGRATE_16;
+            pcm.bitsPerSample = 16;
+            pcm.containerSize = pcm.bitsPerSample;  /* Always tightly packed for now. */
+            pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
+            resultSL = (*g_maEngineSL)->CreateAudioPlayer(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pAudioPlayerObj, &source, &sink, ma_countof(itfIDs), itfIDs, itfIDsRequired);
+        }
+
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to create audio player.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+
+        /* Set the stream type before realizing the player. */
+        if (pConfig->opensl.streamType != ma_opensl_stream_type_default) {
+            resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioPlayerObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDCONFIGURATION, &pPlayerConfig);
+            if (resultSL == SL_RESULT_SUCCESS) {
+                SLint32 streamType = ma_to_stream_type__opensl(pConfig->opensl.streamType);
+                resultSL = (*pPlayerConfig)->SetConfiguration(pPlayerConfig, SL_ANDROID_KEY_STREAM_TYPE, &streamType, sizeof(SLint32));
+                if (resultSL != SL_RESULT_SUCCESS) {
+                    /* Failed to set the configuration. Just keep going. */
+                }
+            }
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->Realize((SLObjectItf)pDevice->opensl.pAudioPlayerObj, SL_BOOLEAN_FALSE);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to realize audio player.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioPlayerObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_PLAY, &pDevice->opensl.pAudioPlayer);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_PLAY interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioPlayerObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &pDevice->opensl.pBufferQueuePlayback);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_ANDROIDSIMPLEBUFFERQUEUE interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueuePlayback)->RegisterCallback((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback, ma_buffer_queue_callback_playback__opensl_android, pDevice);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to register buffer queue callback.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        /* The internal format is determined by the "pcm" object. */
+        ma_deconstruct_SLDataFormat_PCM__opensl(&pcm, &pDescriptorPlayback->format, &pDescriptorPlayback->channels, &pDescriptorPlayback->sampleRate, pDescriptorPlayback->channelMap, ma_countof(pDescriptorPlayback->channelMap));
+
+        /* Buffer. */
+        pDescriptorPlayback->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorPlayback, pDescriptorPlayback->sampleRate, pConfig->performanceProfile);
+        pDevice->opensl.currentBufferIndexPlayback   = 0;
+
+        bufferSizeInBytes = pDescriptorPlayback->periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels) * pDescriptorPlayback->periodCount;
+        pDevice->opensl.pBufferPlayback = (ma_uint8*)ma_calloc(bufferSizeInBytes, &pDevice->pContext->allocationCallbacks);
+        if (pDevice->opensl.pBufferPlayback == NULL) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to allocate memory for data buffer.");
+            return MA_OUT_OF_MEMORY;
+        }
+        MA_ZERO_MEMORY(pDevice->opensl.pBufferPlayback, bufferSizeInBytes);
+    }
+
+    return MA_SUCCESS;
+#else
+    return MA_NO_BACKEND;   /* Non-Android implementations are not supported. */
+#endif
+}
+
+static ma_result ma_device_start__opensl(ma_device* pDevice)
+{
+    SLresult resultSL;
+    size_t periodSizeInBytes;
+    ma_uint32 iPeriod;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it and then attempted to start the device. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        resultSL = MA_OPENSL_RECORD(pDevice->opensl.pAudioRecorder)->SetRecordState((SLRecordItf)pDevice->opensl.pAudioRecorder, SL_RECORDSTATE_RECORDING);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to start internal capture device.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        periodSizeInBytes = pDevice->capture.internalPeriodSizeInFrames * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+        for (iPeriod = 0; iPeriod < pDevice->capture.internalPeriods; ++iPeriod) {
+            resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueueCapture)->Enqueue((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture, pDevice->opensl.pBufferCapture + (periodSizeInBytes * iPeriod), periodSizeInBytes);
+            if (resultSL != SL_RESULT_SUCCESS) {
+                MA_OPENSL_RECORD(pDevice->opensl.pAudioRecorder)->SetRecordState((SLRecordItf)pDevice->opensl.pAudioRecorder, SL_RECORDSTATE_STOPPED);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to enqueue buffer for capture device.");
+                return ma_result_from_OpenSL(resultSL);
+            }
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        resultSL = MA_OPENSL_PLAY(pDevice->opensl.pAudioPlayer)->SetPlayState((SLPlayItf)pDevice->opensl.pAudioPlayer, SL_PLAYSTATE_PLAYING);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to start internal playback device.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        /* In playback mode (no duplex) we need to load some initial buffers. In duplex mode we need to enqueue silent buffers. */
+        if (pDevice->type == ma_device_type_duplex) {
+            MA_ZERO_MEMORY(pDevice->opensl.pBufferPlayback, pDevice->playback.internalPeriodSizeInFrames * pDevice->playback.internalPeriods * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+        } else {
+            ma_device__read_frames_from_client(pDevice, pDevice->playback.internalPeriodSizeInFrames * pDevice->playback.internalPeriods, pDevice->opensl.pBufferPlayback);
+        }
+
+        periodSizeInBytes = pDevice->playback.internalPeriodSizeInFrames * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+        for (iPeriod = 0; iPeriod < pDevice->playback.internalPeriods; ++iPeriod) {
+            resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueuePlayback)->Enqueue((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback, pDevice->opensl.pBufferPlayback + (periodSizeInBytes * iPeriod), periodSizeInBytes);
+            if (resultSL != SL_RESULT_SUCCESS) {
+                MA_OPENSL_PLAY(pDevice->opensl.pAudioPlayer)->SetPlayState((SLPlayItf)pDevice->opensl.pAudioPlayer, SL_PLAYSTATE_STOPPED);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to enqueue buffer for playback device.");
+                return ma_result_from_OpenSL(resultSL);
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_drain__opensl(ma_device* pDevice, ma_device_type deviceType)
+{
+    SLAndroidSimpleBufferQueueItf pBufferQueue;
+
+    MA_ASSERT(deviceType == ma_device_type_capture || deviceType == ma_device_type_playback);
+
+    if (pDevice->type == ma_device_type_capture) {
+        pBufferQueue = (SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture;
+        pDevice->opensl.isDrainingCapture  = MA_TRUE;
+    } else {
+        pBufferQueue = (SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback;
+        pDevice->opensl.isDrainingPlayback = MA_TRUE;
+    }
+
+    for (;;) {
+        SLAndroidSimpleBufferQueueState state;
+
+        MA_OPENSL_BUFFERQUEUE(pBufferQueue)->GetState(pBufferQueue, &state);
+        if (state.count == 0) {
+            break;
+        }
+
+        ma_sleep(10);
+    }
+
+    if (pDevice->type == ma_device_type_capture) {
+        pDevice->opensl.isDrainingCapture  = MA_FALSE;
+    } else {
+        pDevice->opensl.isDrainingPlayback = MA_FALSE;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__opensl(ma_device* pDevice)
+{
+    SLresult resultSL;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it before stopping/uninitializing the device. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_device_drain__opensl(pDevice, ma_device_type_capture);
+
+        resultSL = MA_OPENSL_RECORD(pDevice->opensl.pAudioRecorder)->SetRecordState((SLRecordItf)pDevice->opensl.pAudioRecorder, SL_RECORDSTATE_STOPPED);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to stop internal capture device.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueueCapture)->Clear((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_device_drain__opensl(pDevice, ma_device_type_playback);
+
+        resultSL = MA_OPENSL_PLAY(pDevice->opensl.pAudioPlayer)->SetPlayState((SLPlayItf)pDevice->opensl.pAudioPlayer, SL_PLAYSTATE_STOPPED);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to stop internal playback device.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueuePlayback)->Clear((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback);
+    }
+
+    /* Make sure the client is aware that the device has stopped. There may be an OpenSL|ES callback for this, but I haven't found it. */
+    ma_device__on_notification_stopped(pDevice);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__opensl(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_opensl);
+    (void)pContext;
+
+    /* Uninit global data. */
+    ma_spinlock_lock(&g_maOpenSLSpinlock);
+    {
+        MA_ASSERT(g_maOpenSLInitCounter > 0);   /* If you've triggered this, it means you have ma_context_init/uninit mismatch. Each successful call to ma_context_init() must be matched up with a call to ma_context_uninit(). */
+
+        g_maOpenSLInitCounter -= 1;
+        if (g_maOpenSLInitCounter == 0) {
+            (*g_maEngineObjectSL)->Destroy(g_maEngineObjectSL);
+        }
+    }
+    ma_spinlock_unlock(&g_maOpenSLSpinlock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_dlsym_SLInterfaceID__opensl(ma_context* pContext, const char* pName, ma_handle* pHandle)
+{
+    /* We need to return an error if the symbol cannot be found. This is important because there have been reports that some symbols do not exist. */
+    ma_handle* p = (ma_handle*)ma_dlsym(ma_context_get_log(pContext), pContext->opensl.libOpenSLES, pName);
+    if (p == NULL) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_INFO, "[OpenSL] Cannot find symbol %s", pName);
+        return MA_NO_BACKEND;
+    }
+
+    *pHandle = *p;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init_engine_nolock__opensl(ma_context* pContext)
+{
+    g_maOpenSLInitCounter += 1;
+    if (g_maOpenSLInitCounter == 1) {
+        SLresult resultSL;
+
+        resultSL = ((ma_slCreateEngine_proc)pContext->opensl.slCreateEngine)(&g_maEngineObjectSL, 0, NULL, 0, NULL, NULL);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            g_maOpenSLInitCounter -= 1;
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        (*g_maEngineObjectSL)->Realize(g_maEngineObjectSL, SL_BOOLEAN_FALSE);
+
+        resultSL = (*g_maEngineObjectSL)->GetInterface(g_maEngineObjectSL, (SLInterfaceID)pContext->opensl.SL_IID_ENGINE, &g_maEngineSL);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            (*g_maEngineObjectSL)->Destroy(g_maEngineObjectSL);
+            g_maOpenSLInitCounter -= 1;
+            return ma_result_from_OpenSL(resultSL);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__opensl(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    ma_result result;
+
+#if !defined(MA_NO_RUNTIME_LINKING)
+    size_t i;
+    const char* libOpenSLESNames[] = {
+        "libOpenSLES.so"
+    };
+#endif
+
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+#if !defined(MA_NO_RUNTIME_LINKING)
+    /*
+    Dynamically link against libOpenSLES.so. I have now had multiple reports that SL_IID_ANDROIDSIMPLEBUFFERQUEUE cannot be found. One
+    report was happening at compile time and another at runtime. To try working around this, I'm going to link to libOpenSLES at runtime
+    and extract the symbols rather than reference them directly. This should, hopefully, fix these issues as the compiler won't see any
+    references to the symbols and will hopefully skip the checks.
+    */
+    for (i = 0; i < ma_countof(libOpenSLESNames); i += 1) {
+        pContext->opensl.libOpenSLES = ma_dlopen(ma_context_get_log(pContext), libOpenSLESNames[i]);
+        if (pContext->opensl.libOpenSLES != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->opensl.libOpenSLES == NULL) {
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_INFO, "[OpenSL] Could not find libOpenSLES.so");
+        return MA_NO_BACKEND;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_ENGINE", &pContext->opensl.SL_IID_ENGINE);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_AUDIOIODEVICECAPABILITIES", &pContext->opensl.SL_IID_AUDIOIODEVICECAPABILITIES);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_ANDROIDSIMPLEBUFFERQUEUE", &pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_RECORD", &pContext->opensl.SL_IID_RECORD);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_PLAY", &pContext->opensl.SL_IID_PLAY);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_OUTPUTMIX", &pContext->opensl.SL_IID_OUTPUTMIX);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_ANDROIDCONFIGURATION", &pContext->opensl.SL_IID_ANDROIDCONFIGURATION);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    pContext->opensl.slCreateEngine = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->opensl.libOpenSLES, "slCreateEngine");
+    if (pContext->opensl.slCreateEngine == NULL) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_INFO, "[OpenSL] Cannot find symbol slCreateEngine.");
+        return MA_NO_BACKEND;
+    }
+#else
+    pContext->opensl.SL_IID_ENGINE                    = (ma_handle)SL_IID_ENGINE;
+    pContext->opensl.SL_IID_AUDIOIODEVICECAPABILITIES = (ma_handle)SL_IID_AUDIOIODEVICECAPABILITIES;
+    pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE  = (ma_handle)SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
+    pContext->opensl.SL_IID_RECORD                    = (ma_handle)SL_IID_RECORD;
+    pContext->opensl.SL_IID_PLAY                      = (ma_handle)SL_IID_PLAY;
+    pContext->opensl.SL_IID_OUTPUTMIX                 = (ma_handle)SL_IID_OUTPUTMIX;
+    pContext->opensl.SL_IID_ANDROIDCONFIGURATION      = (ma_handle)SL_IID_ANDROIDCONFIGURATION;
+    pContext->opensl.slCreateEngine                   = (ma_proc)slCreateEngine;
+#endif
+
+
+    /* Initialize global data first if applicable. */
+    ma_spinlock_lock(&g_maOpenSLSpinlock);
+    {
+        result = ma_context_init_engine_nolock__opensl(pContext);
+    }
+    ma_spinlock_unlock(&g_maOpenSLSpinlock);
+
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_INFO, "[OpenSL] Failed to initialize OpenSL engine.");
+        return result;
+    }
+
+    pCallbacks->onContextInit             = ma_context_init__opensl;
+    pCallbacks->onContextUninit           = ma_context_uninit__opensl;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__opensl;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__opensl;
+    pCallbacks->onDeviceInit              = ma_device_init__opensl;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__opensl;
+    pCallbacks->onDeviceStart             = ma_device_start__opensl;
+    pCallbacks->onDeviceStop              = ma_device_stop__opensl;
+    pCallbacks->onDeviceRead              = NULL;   /* Not needed because OpenSL|ES is asynchronous. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not needed because OpenSL|ES is asynchronous. */
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Not needed because OpenSL|ES is asynchronous. */
+
+    return MA_SUCCESS;
+}
+#endif  /* OpenSL|ES */
+
+
+/******************************************************************************
+
+Web Audio Backend
+
+******************************************************************************/
+#ifdef MA_HAS_WEBAUDIO
+#include <emscripten/emscripten.h>
+
+#if (__EMSCRIPTEN_major__ > 3) || (__EMSCRIPTEN_major__ == 3 && (__EMSCRIPTEN_minor__ > 1 || (__EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ >= 32)))
+    #include <emscripten/webaudio.h>
+    #define MA_SUPPORT_AUDIO_WORKLETS
+
+    #if (__EMSCRIPTEN_major__ > 3) || (__EMSCRIPTEN_major__ == 3 && (__EMSCRIPTEN_minor__ > 1 || (__EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ >= 70)))
+        #define MA_SUPPORT_AUDIO_WORKLETS_VARIABLE_BUFFER_SIZE
+    #endif
+#endif
+
+/*
+TODO: Version 0.12: Swap this logic around so that AudioWorklets are used by default. Add MA_NO_AUDIO_WORKLETS.
+*/
+#if defined(MA_ENABLE_AUDIO_WORKLETS) && defined(MA_SUPPORT_AUDIO_WORKLETS)
+    #define MA_USE_AUDIO_WORKLETS
+#endif
+
+/* The thread stack size must be a multiple of 16. */
+#ifndef MA_AUDIO_WORKLETS_THREAD_STACK_SIZE
+#define MA_AUDIO_WORKLETS_THREAD_STACK_SIZE     131072
+#endif
+
+#if defined(MA_USE_AUDIO_WORKLETS)
+#define MA_WEBAUDIO_LATENCY_HINT_BALANCED       "balanced"
+#define MA_WEBAUDIO_LATENCY_HINT_INTERACTIVE    "interactive"
+#define MA_WEBAUDIO_LATENCY_HINT_PLAYBACK       "playback"
+#endif
+
+static ma_bool32 ma_is_capture_supported__webaudio()
+{
+    return EM_ASM_INT({
+        return (navigator.mediaDevices !== undefined && navigator.mediaDevices.getUserMedia !== undefined);
+    }, 0) != 0; /* Must pass in a dummy argument for C99 compatibility. */
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void* EMSCRIPTEN_KEEPALIVE ma_malloc_emscripten(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_malloc(sz, pAllocationCallbacks);
+}
+
+void EMSCRIPTEN_KEEPALIVE ma_free_emscripten(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_free(p, pAllocationCallbacks);
+}
+
+void EMSCRIPTEN_KEEPALIVE ma_device_process_pcm_frames_capture__webaudio(ma_device* pDevice, int frameCount, float* pFrames)
+{
+    ma_device_handle_backend_data_callback(pDevice, NULL, pFrames, (ma_uint32)frameCount);
+}
+
+void EMSCRIPTEN_KEEPALIVE ma_device_process_pcm_frames_playback__webaudio(ma_device* pDevice, int frameCount, float* pFrames)
+{
+    ma_device_handle_backend_data_callback(pDevice, pFrames, NULL, (ma_uint32)frameCount);
+}
+#ifdef __cplusplus
+}
+#endif
+
+static ma_result ma_context_enumerate_devices__webaudio(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult = MA_TRUE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Only supporting default devices for now. */
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE;    /* Only supporting default devices. */
+        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        if (ma_is_capture_supported__webaudio()) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+            deviceInfo.isDefault = MA_TRUE;    /* Only supporting default devices. */
+            cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__webaudio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext != NULL);
+
+    if (deviceType == ma_device_type_capture && !ma_is_capture_supported__webaudio()) {
+        return MA_NO_DEVICE;
+    }
+
+    MA_ZERO_MEMORY(pDeviceInfo->id.webaudio, sizeof(pDeviceInfo->id.webaudio));
+
+    /* Only supporting default devices for now. */
+    (void)pDeviceID;
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+    /* Only supporting default devices. */
+    pDeviceInfo->isDefault = MA_TRUE;
+
+    /* Web Audio can support any number of channels and sample rates. It only supports f32 formats, however. */
+    pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pDeviceInfo->nativeDataFormats[0].format     = ma_format_unknown;
+    pDeviceInfo->nativeDataFormats[0].channels   = 0; /* All channels are supported. */
+    pDeviceInfo->nativeDataFormats[0].sampleRate = EM_ASM_INT({
+        try {
+            var temp = new (window.AudioContext || window.webkitAudioContext)();
+            var sampleRate = temp.sampleRate;
+            temp.close();
+            return sampleRate;
+        } catch(e) {
+            return 0;
+        }
+    }, 0);  /* Must pass in a dummy argument for C99 compatibility. */
+
+    if (pDeviceInfo->nativeDataFormats[0].sampleRate == 0) {
+        return MA_NO_DEVICE;
+    }
+
+    pDeviceInfo->nativeDataFormatCount = 1;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_uninit__webaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    #if defined(MA_USE_AUDIO_WORKLETS)
+    {
+        EM_ASM({
+            var device = window.miniaudio.get_device_by_index($0);
+
+            if (device.streamNode !== undefined) {
+                device.streamNode.disconnect();
+                device.streamNode = undefined;
+            }
+
+            device.pDevice = undefined;
+        }, pDevice->webaudio.deviceIndex);
+
+        emscripten_destroy_web_audio_node(pDevice->webaudio.audioWorklet);
+        emscripten_destroy_audio_context(pDevice->webaudio.audioContext);
+        ma_free(pDevice->webaudio.pStackBuffer, &pDevice->pContext->allocationCallbacks);
+    }
+    #else
+    {
+        EM_ASM({
+            var device = window.miniaudio.get_device_by_index($0);
+
+            /* Make sure all nodes are disconnected and marked for collection. */
+            if (device.scriptNode !== undefined) {
+                device.scriptNode.onaudioprocess = function(e) {};  /* We want to reset the callback to ensure it doesn't get called after AudioContext.close() has returned. Shouldn't happen since we're disconnecting, but just to be safe... */
+                device.scriptNode.disconnect();
+                device.scriptNode = undefined;
+            }
+
+            if (device.streamNode !== undefined) {
+                device.streamNode.disconnect();
+                device.streamNode = undefined;
+            }
+
+            /*
+            Stop the device. I think there is a chance the callback could get fired after calling this, hence why we want
+            to clear the callback before closing.
+            */
+            device.webaudio.close();
+            device.webaudio = undefined;
+            device.pDevice = undefined;
+        }, pDevice->webaudio.deviceIndex);
+    }
+    #endif
+
+    /* Clean up the device on the JS side. */
+    EM_ASM({
+        window.miniaudio.untrack_device_by_index($0);
+    }, pDevice->webaudio.deviceIndex);
+
+    ma_free(pDevice->webaudio.pIntermediaryBuffer, &pDevice->pContext->allocationCallbacks);
+
+    return MA_SUCCESS;
+}
+
+#if !defined(MA_USE_AUDIO_WORKLETS)
+static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__webaudio(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    /*
+    There have been reports of the default buffer size being too small on some browsers. If we're using
+    the default buffer size, we'll make sure the period size is bigger than our standard defaults.
+    */
+    ma_uint32 periodSizeInFrames;
+
+    if (nativeSampleRate == 0) {
+        nativeSampleRate = MA_DEFAULT_SAMPLE_RATE;
+    }
+
+    if (pDescriptor->periodSizeInFrames == 0) {
+        if (pDescriptor->periodSizeInMilliseconds == 0) {
+            if (performanceProfile == ma_performance_profile_low_latency) {
+                periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(33, nativeSampleRate);  /* 1 frame @ 30 FPS */
+            } else {
+                periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(333, nativeSampleRate);
+            }
+        } else {
+            periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptor->periodSizeInMilliseconds, nativeSampleRate);
+        }
+    } else {
+        periodSizeInFrames = pDescriptor->periodSizeInFrames;
+    }
+
+    /* The size of the buffer must be a power of 2 and between 256 and 16384. */
+    if (periodSizeInFrames < 256) {
+        periodSizeInFrames = 256;
+    } else if (periodSizeInFrames > 16384) {
+        periodSizeInFrames = 16384;
+    } else {
+        periodSizeInFrames = ma_next_power_of_2(periodSizeInFrames);
+    }
+
+    return periodSizeInFrames;
+}
+#endif
+
+
+#if defined(MA_USE_AUDIO_WORKLETS)
+typedef struct
+{
+    ma_device* pDevice;
+    const ma_device_config* pConfig;
+    ma_device_descriptor* pDescriptorPlayback;
+    ma_device_descriptor* pDescriptorCapture;
+} ma_audio_worklet_thread_initialized_data;
+
+static EM_BOOL ma_audio_worklet_process_callback__webaudio(int inputCount, const AudioSampleFrame* pInputs, int outputCount, AudioSampleFrame* pOutputs, int paramCount, const AudioParamFrame* pParams, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    ma_uint32 frameCount;
+
+    (void)paramCount;
+    (void)pParams;
+
+    /*
+    The Emscripten documentation says that it'll always be 128 frames being passed in. Hard coding it like that feels
+    like a very bad idea to me. Even if it's hard coded in the backend, the API and documentation should always refer
+    to variables instead of a hard coded number. In any case, will follow along for the time being.
+
+    Unfortunately the audio data is not interleaved so we'll need to convert it before we give the data to miniaudio
+    for further processing.
+    */
+    if (pDevice->type == ma_device_type_playback) {
+        frameCount = pDevice->playback.internalPeriodSizeInFrames;
+    } else {
+        frameCount = pDevice->capture.internalPeriodSizeInFrames;
+    }
+
+    if (ma_device_get_state(pDevice) != ma_device_state_started) {
+        /* Fill the output buffer with zero to avoid a noise sound */
+        for (int i = 0; i < outputCount; i += 1) {
+            MA_ZERO_MEMORY(pOutputs[i].data, pOutputs[i].numberOfChannels * frameCount * sizeof(float));
+        }
+
+        return EM_TRUE;
+    }
+
+    if (inputCount > 0) {
+        /* Input data needs to be interleaved before we hand it to the client. */
+        for (ma_uint32 iChannel = 0; iChannel < pDevice->capture.internalChannels; iChannel += 1) {
+            for (ma_uint32 iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pDevice->webaudio.pIntermediaryBuffer[iFrame*pDevice->capture.internalChannels + iChannel] = pInputs[0].data[frameCount*iChannel + iFrame];
+            }
+        }
+
+        ma_device_process_pcm_frames_capture__webaudio(pDevice, frameCount, pDevice->webaudio.pIntermediaryBuffer);
+    }
+
+    if (outputCount > 0) {
+        /* If it's a capture-only device, we'll need to output silence. */
+        if (pDevice->type == ma_device_type_capture) {
+            MA_ZERO_MEMORY(pOutputs[0].data, frameCount * pDevice->playback.internalChannels * sizeof(float));
+        } else {
+            ma_device_process_pcm_frames_playback__webaudio(pDevice, frameCount, pDevice->webaudio.pIntermediaryBuffer);
+
+            /* We've read the data from the client. Now we need to deinterleave the buffer and output to the output buffer. */
+            for (ma_uint32 iChannel = 0; iChannel < pDevice->playback.internalChannels; iChannel += 1) {
+                for (ma_uint32 iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                    pOutputs[0].data[frameCount*iChannel + iFrame] = pDevice->webaudio.pIntermediaryBuffer[iFrame*pDevice->playback.internalChannels + iChannel];
+                }
+            }
+        }
+    }
+
+    return EM_TRUE;
+}
+
+
+static void ma_audio_worklet_processor_created__webaudio(EMSCRIPTEN_WEBAUDIO_T audioContext, EM_BOOL success, void* pUserData)
+{
+    ma_audio_worklet_thread_initialized_data* pParameters = (ma_audio_worklet_thread_initialized_data*)pUserData;
+    EmscriptenAudioWorkletNodeCreateOptions audioWorkletOptions;
+    int channels = 0;
+    size_t intermediaryBufferSizeInFrames;
+    int sampleRate;
+
+    if (success == EM_FALSE) {
+        pParameters->pDevice->webaudio.initResult = MA_ERROR;
+        ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+        return;
+    }
+
+    /* The next step is to initialize the audio worklet node. */
+    MA_ZERO_OBJECT(&audioWorkletOptions);
+
+    /*
+    The way channel counts work with Web Audio is confusing. As far as I can tell, there's no way to know the channel
+    count from MediaStreamAudioSourceNode (what we use for capture)? The only way to have control is to configure an
+    output channel count on the capture side. This is slightly confusing for capture mode because intuitively you
+    wouldn't actually connect an output to an input-only node, but this is what we'll have to do in order to have
+    proper control over the channel count. In the capture case, we'll have to output silence to its output node.
+    */
+    if (pParameters->pConfig->deviceType == ma_device_type_capture) {
+        channels = (int)((pParameters->pDescriptorCapture->channels > 0) ? pParameters->pDescriptorCapture->channels : MA_DEFAULT_CHANNELS);
+        audioWorkletOptions.numberOfInputs = 1;
+    } else {
+        channels = (int)((pParameters->pDescriptorPlayback->channels > 0) ? pParameters->pDescriptorPlayback->channels : MA_DEFAULT_CHANNELS);
+
+        if (pParameters->pConfig->deviceType == ma_device_type_duplex) {
+            audioWorkletOptions.numberOfInputs = 1;
+        } else {
+            audioWorkletOptions.numberOfInputs = 0;
+        }
+    }
+
+    audioWorkletOptions.numberOfOutputs = 1;
+    audioWorkletOptions.outputChannelCounts = &channels;
+
+
+    /*
+    Now that we know the channel count to use we can allocate the intermediary buffer. The
+    intermediary buffer is used for interleaving and deinterleaving.
+    */
+    #if defined(MA_SUPPORT_AUDIO_WORKLETS_VARIABLE_BUFFER_SIZE)
+    {
+        intermediaryBufferSizeInFrames = (size_t)emscripten_audio_context_quantum_size(audioContext);
+    }
+    #else
+    {
+        intermediaryBufferSizeInFrames = 128;
+    }
+    #endif
+
+    pParameters->pDevice->webaudio.pIntermediaryBuffer = (float*)ma_malloc(intermediaryBufferSizeInFrames * (ma_uint32)channels * sizeof(float), &pParameters->pDevice->pContext->allocationCallbacks);
+    if (pParameters->pDevice->webaudio.pIntermediaryBuffer == NULL) {
+        pParameters->pDevice->webaudio.initResult = MA_OUT_OF_MEMORY;
+        ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+        return;
+    }
+
+    pParameters->pDevice->webaudio.audioWorklet = emscripten_create_wasm_audio_worklet_node(audioContext, "miniaudio", &audioWorkletOptions, &ma_audio_worklet_process_callback__webaudio, pParameters->pDevice);
+
+    /* With the audio worklet initialized we can now attach it to the graph. */
+    if (pParameters->pConfig->deviceType == ma_device_type_capture || pParameters->pConfig->deviceType == ma_device_type_duplex) {
+        ma_result attachmentResult = (ma_result)EM_ASM_INT({
+            var getUserMediaResult = 0;
+            var audioWorklet = emscriptenGetAudioObject($0);
+            var audioContext = emscriptenGetAudioObject($1);
+
+            navigator.mediaDevices.getUserMedia({audio:true, video:false})
+                .then(function(stream) {
+                    audioContext.streamNode = audioContext.createMediaStreamSource(stream);
+                    audioContext.streamNode.connect(audioWorklet);
+                    audioWorklet.connect(audioContext.destination);
+                    getUserMediaResult = 0;   /* 0 = MA_SUCCESS */
+                })
+                .catch(function(error) {
+                    console.log("navigator.mediaDevices.getUserMedia Failed: " + error);
+                    getUserMediaResult = -1;  /* -1 = MA_ERROR */
+                });
+
+            return getUserMediaResult;
+        }, pParameters->pDevice->webaudio.audioWorklet, audioContext);
+
+        if (attachmentResult != MA_SUCCESS) {
+            ma_log_postf(ma_device_get_log(pParameters->pDevice), MA_LOG_LEVEL_ERROR, "Web Audio: Failed to connect capture node.");
+            emscripten_destroy_web_audio_node(pParameters->pDevice->webaudio.audioWorklet);
+            pParameters->pDevice->webaudio.initResult = attachmentResult;
+            ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+            return;
+        }
+    }
+
+    /* If it's playback only we can now attach the worklet node to the graph. This has already been done for the duplex case. */
+    if (pParameters->pConfig->deviceType == ma_device_type_playback) {
+        ma_result attachmentResult = (ma_result)EM_ASM_INT({
+            var audioWorklet = emscriptenGetAudioObject($0);
+            var audioContext = emscriptenGetAudioObject($1);
+            audioWorklet.connect(audioContext.destination);
+            return 0;   /* 0 = MA_SUCCESS */
+        }, pParameters->pDevice->webaudio.audioWorklet, audioContext);
+
+        if (attachmentResult != MA_SUCCESS) {
+            ma_log_postf(ma_device_get_log(pParameters->pDevice), MA_LOG_LEVEL_ERROR, "Web Audio: Failed to connect playback node.");
+            pParameters->pDevice->webaudio.initResult = attachmentResult;
+            ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+            return;
+        }
+    }
+
+    /* We need to update the descriptors so that they reflect the internal data format. Both capture and playback should be the same. */
+    sampleRate = EM_ASM_INT({ return emscriptenGetAudioObject($0).sampleRate; }, audioContext);
+
+    if (pParameters->pDescriptorCapture != NULL) {
+        pParameters->pDescriptorCapture->format              = ma_format_f32;
+        pParameters->pDescriptorCapture->channels            = (ma_uint32)channels;
+        pParameters->pDescriptorCapture->sampleRate          = (ma_uint32)sampleRate;
+        ma_channel_map_init_standard(ma_standard_channel_map_webaudio, pParameters->pDescriptorCapture->channelMap, ma_countof(pParameters->pDescriptorCapture->channelMap), pParameters->pDescriptorCapture->channels);
+        pParameters->pDescriptorCapture->periodSizeInFrames  = intermediaryBufferSizeInFrames;
+        pParameters->pDescriptorCapture->periodCount         = 1;
+    }
+
+    if (pParameters->pDescriptorPlayback != NULL) {
+        pParameters->pDescriptorPlayback->format             = ma_format_f32;
+        pParameters->pDescriptorPlayback->channels           = (ma_uint32)channels;
+        pParameters->pDescriptorPlayback->sampleRate         = (ma_uint32)sampleRate;
+        ma_channel_map_init_standard(ma_standard_channel_map_webaudio, pParameters->pDescriptorPlayback->channelMap, ma_countof(pParameters->pDescriptorPlayback->channelMap), pParameters->pDescriptorPlayback->channels);
+        pParameters->pDescriptorPlayback->periodSizeInFrames = intermediaryBufferSizeInFrames;
+        pParameters->pDescriptorPlayback->periodCount        = 1;
+    }
+
+    /* At this point we're done and we can return. */
+    ma_log_postf(ma_device_get_log(pParameters->pDevice), MA_LOG_LEVEL_DEBUG, "AudioWorklets: Created worklet node: %d\n", pParameters->pDevice->webaudio.audioWorklet);
+    pParameters->pDevice->webaudio.initResult = MA_SUCCESS;
+    ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+}
+
+static void ma_audio_worklet_thread_initialized__webaudio(EMSCRIPTEN_WEBAUDIO_T audioContext, EM_BOOL success, void* pUserData)
+{
+    ma_audio_worklet_thread_initialized_data* pParameters = (ma_audio_worklet_thread_initialized_data*)pUserData;
+    WebAudioWorkletProcessorCreateOptions workletProcessorOptions;
+
+    MA_ASSERT(pParameters != NULL);
+
+    if (success == EM_FALSE) {
+        pParameters->pDevice->webaudio.initResult = MA_ERROR;
+        return;
+    }
+
+    MA_ZERO_OBJECT(&workletProcessorOptions);
+    workletProcessorOptions.name = "miniaudio"; /* I'm not entirely sure what to call this. Does this need to be globally unique, or does it need only be unique for a given AudioContext? */
+
+    emscripten_create_wasm_audio_worklet_processor_async(audioContext, &workletProcessorOptions, ma_audio_worklet_processor_created__webaudio, pParameters);
+}
+#endif
+
+static ma_result ma_device_init__webaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* No exclusive mode with Web Audio. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    /*
+    With AudioWorklets we'll have just a single AudioContext. I'm not sure why I'm not doing this for ScriptProcessorNode so
+    it might be worthwhile to look into that as well.
+    */
+    #if defined(MA_USE_AUDIO_WORKLETS)
+    {
+        EmscriptenWebAudioCreateAttributes audioContextAttributes;
+        ma_audio_worklet_thread_initialized_data* pInitParameters;
+        void* pStackBuffer;
+
+        if (pConfig->performanceProfile == ma_performance_profile_conservative) {
+            audioContextAttributes.latencyHint = MA_WEBAUDIO_LATENCY_HINT_PLAYBACK;
+        } else {
+            audioContextAttributes.latencyHint = MA_WEBAUDIO_LATENCY_HINT_INTERACTIVE;
+        }
+
+        /*
+        In my testing, Firefox does not seem to capture audio data properly if the sample rate is set
+        to anything other than 48K. This does not seem to be the case for other browsers. For this reason,
+        if the device type is anything other than playback, we'll leave the sample rate as-is and let the
+        browser pick the appropriate rate for us.
+        */
+        if (pConfig->deviceType == ma_device_type_playback) {
+            audioContextAttributes.sampleRate = pDescriptorPlayback->sampleRate;
+        } else {
+            audioContextAttributes.sampleRate = 0;
+        }
+
+        /* It's not clear if this can return an error. None of the tests in the Emscripten repository check for this, so neither am I for now. */
+        pDevice->webaudio.audioContext = emscripten_create_audio_context(&audioContextAttributes);
+
+        /*
+        With the context created we can now create the worklet. We can only have a single worklet per audio
+        context which means we'll need to craft this appropriately to handle duplex devices correctly.
+        */
+
+        /*
+        We now need to create a worker thread. This is a bit weird because we need to allocate our
+        own buffer for the thread's stack. The stack needs to be aligned to 16 bytes. I'm going to
+        allocate this on the heap to keep it simple.
+        */
+        pStackBuffer = ma_aligned_malloc(MA_AUDIO_WORKLETS_THREAD_STACK_SIZE, 16, &pDevice->pContext->allocationCallbacks);
+        if (pStackBuffer == NULL) {
+            emscripten_destroy_audio_context(pDevice->webaudio.audioContext);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        /* Our thread initialization parameters need to be allocated on the heap so they don't go out of scope. */
+        pInitParameters = (ma_audio_worklet_thread_initialized_data*)ma_malloc(sizeof(*pInitParameters), &pDevice->pContext->allocationCallbacks);
+        if (pInitParameters == NULL) {
+            ma_free(pStackBuffer, &pDevice->pContext->allocationCallbacks);
+            emscripten_destroy_audio_context(pDevice->webaudio.audioContext);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        pInitParameters->pDevice = pDevice;
+        pInitParameters->pConfig = pConfig;
+        pInitParameters->pDescriptorPlayback = pDescriptorPlayback;
+        pInitParameters->pDescriptorCapture  = pDescriptorCapture;
+
+        /*
+        We need to flag the device as not yet initialized so we can wait on it later. Unfortunately all of
+        the Emscripten WebAudio stuff is asynchronous.
+        */
+        pDevice->webaudio.initResult = MA_BUSY;
+        {
+            emscripten_start_wasm_audio_worklet_thread_async(pDevice->webaudio.audioContext, pStackBuffer, MA_AUDIO_WORKLETS_THREAD_STACK_SIZE, ma_audio_worklet_thread_initialized__webaudio, pInitParameters);
+        }
+        while (pDevice->webaudio.initResult == MA_BUSY) { emscripten_sleep(1); }    /* We must wait for initialization to complete. We're just spinning here. The emscripten_sleep() call is why we need to build with `-sASYNCIFY`. */
+
+        /* Initialization is now complete. Descriptors were updated when the worklet was initialized. */
+        if (pDevice->webaudio.initResult != MA_SUCCESS) {
+            ma_free(pStackBuffer, &pDevice->pContext->allocationCallbacks);
+            emscripten_destroy_audio_context(pDevice->webaudio.audioContext);
+            return pDevice->webaudio.initResult;
+        }
+
+        /* We need to add an entry to the miniaudio.devices list on the JS side so we can do some JS/C interop. */
+        pDevice->webaudio.deviceIndex = EM_ASM_INT({
+            return window.miniaudio.track_device({
+                webaudio: emscriptenGetAudioObject($0),
+                state:    1, /* 1 = ma_device_state_stopped */
+                pDevice: $1
+            });
+        }, pDevice->webaudio.audioContext, pDevice);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* ScriptProcessorNode. This path requires us to do almost everything in JS, but we'll do as much as we can in C. */
+        ma_uint32 deviceIndex;
+        ma_uint32 channels;
+        ma_uint32 sampleRate;
+        ma_uint32 periodSizeInFrames;
+
+        /* The channel count will depend on the device type. If it's a capture, use its, otherwise use the playback side. */
+        if (pConfig->deviceType == ma_device_type_capture) {
+            channels = (pDescriptorCapture->channels  > 0) ? pDescriptorCapture->channels  : MA_DEFAULT_CHANNELS;
+        } else {
+            channels = (pDescriptorPlayback->channels > 0) ? pDescriptorPlayback->channels : MA_DEFAULT_CHANNELS;
+        }
+
+        /*
+        When testing in Firefox, I've seen it where capture mode fails if the sample rate is changed to anything other than it's
+        native rate. For this reason we're leaving the sample rate untouched for capture devices.
+        */
+        if (pConfig->deviceType == ma_device_type_playback) {
+            sampleRate = pDescriptorPlayback->sampleRate;
+        } else {
+            sampleRate = 0; /* Let the browser decide when capturing. */
+        }
+
+        /* The period size needs to be a power of 2. */
+        if (pConfig->deviceType == ma_device_type_capture) {
+            periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__webaudio(pDescriptorCapture, sampleRate, pConfig->performanceProfile);
+        } else {
+            periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__webaudio(pDescriptorPlayback, sampleRate, pConfig->performanceProfile);
+        }
+
+        /* We need an intermediary buffer for doing interleaving and deinterleaving. */
+        pDevice->webaudio.pIntermediaryBuffer = (float*)ma_malloc(periodSizeInFrames * channels * sizeof(float), &pDevice->pContext->allocationCallbacks);
+        if (pDevice->webaudio.pIntermediaryBuffer == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        deviceIndex = EM_ASM_INT({
+            var deviceType = $0;
+            var channels   = $1;
+            var sampleRate = $2;
+            var bufferSize = $3;
+            var pIntermediaryBuffer = $4;
+            var pDevice    = $5;
+
+            if (typeof(window.miniaudio) === 'undefined') {
+                return -1;  /* Context not initialized. */
+            }
+
+            var device = {};
+
+            /* First thing we need is an AudioContext. */
+            var audioContextOptions = {};
+            if (deviceType == window.miniaudio.device_type.playback && sampleRate != 0) {
+                audioContextOptions.sampleRate = sampleRate;
+            }
+
+            device.webaudio = new (window.AudioContext || window.webkitAudioContext)(audioContextOptions);
+            device.webaudio.suspend();  /* The AudioContext must be created in a suspended state. */
+            device.state = window.miniaudio.device_state.stopped;
+
+            /*
+            We need to create a ScriptProcessorNode. The channel situation is the same as the AudioWorklet path in that we
+            need to specify an output and configure the channel count there.
+            */
+            var channelCountIn  = 0;
+            var channelCountOut = channels;
+            if (deviceType != window.miniaudio.device_type.playback) {
+                channelCountIn  = channels;
+            }
+
+            device.scriptNode = device.webaudio.createScriptProcessor(bufferSize, channelCountIn, channelCountOut);
+
+            /* The node processing callback. */
+            device.scriptNode.onaudioprocess = function(e) {
+                if (device.intermediaryBufferView == null || device.intermediaryBufferView.length == 0) {
+                    device.intermediaryBufferView = new Float32Array(HEAPF32.buffer, pIntermediaryBuffer, bufferSize * channels);
+                }
+
+                /* Do the capture side first. */
+                if (deviceType == window.miniaudio.device_type.capture || deviceType == window.miniaudio.device_type.duplex) {
+                    /* The data must be interleaved before being processed miniaudio. */
+                    for (var iChannel = 0; iChannel < channels; iChannel += 1) {
+                        var inputBuffer = e.inputBuffer.getChannelData(iChannel);
+                        var intermediaryBuffer = device.intermediaryBufferView;
+
+                        for (var iFrame = 0; iFrame < bufferSize; iFrame += 1) {
+                            intermediaryBuffer[iFrame*channels + iChannel] = inputBuffer[iFrame];
+                        }
+                    }
+
+                    _ma_device_process_pcm_frames_capture__webaudio(pDevice, bufferSize, pIntermediaryBuffer);
+                }
+
+                if (deviceType == window.miniaudio.device_type.playback || deviceType == window.miniaudio.device_type.duplex) {
+                    _ma_device_process_pcm_frames_playback__webaudio(pDevice, bufferSize, pIntermediaryBuffer);
+
+                    for (var iChannel = 0; iChannel < e.outputBuffer.numberOfChannels; ++iChannel) {
+                        var outputBuffer = e.outputBuffer.getChannelData(iChannel);
+                        var intermediaryBuffer = device.intermediaryBufferView;
+
+                        for (var iFrame = 0; iFrame < bufferSize; iFrame += 1) {
+                            outputBuffer[iFrame] = intermediaryBuffer[iFrame*channels + iChannel];
+                        }
+                    }
+                } else {
+                    /* It's a capture-only device. Make sure the output is silenced. */
+                    for (var iChannel = 0; iChannel < e.outputBuffer.numberOfChannels; ++iChannel) {
+                        e.outputBuffer.getChannelData(iChannel).fill(0.0);
+                    }
+                }
+            };
+
+            /* Now we need to connect our node to the graph. */
+            if (deviceType == window.miniaudio.device_type.capture || deviceType == window.miniaudio.device_type.duplex) {
+                navigator.mediaDevices.getUserMedia({audio:true, video:false})
+                    .then(function(stream) {
+                        device.streamNode = device.webaudio.createMediaStreamSource(stream);
+                        device.streamNode.connect(device.scriptNode);
+                        device.scriptNode.connect(device.webaudio.destination);
+                    })
+                    .catch(function(error) {
+                        console.log("Failed to get user media: " + error);
+                    });
+            }
+
+            if (deviceType == window.miniaudio.device_type.playback) {
+                device.scriptNode.connect(device.webaudio.destination);
+            }
+
+            device.pDevice = pDevice;
+
+            return window.miniaudio.track_device(device);
+        }, pConfig->deviceType, channels, sampleRate, periodSizeInFrames, pDevice->webaudio.pIntermediaryBuffer, pDevice);
+
+        if (deviceIndex < 0) {
+            return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        }
+
+        pDevice->webaudio.deviceIndex = deviceIndex;
+
+        /* Grab the sample rate from the audio context directly. */
+        sampleRate = (ma_uint32)EM_ASM_INT({ return window.miniaudio.get_device_by_index($0).webaudio.sampleRate; }, deviceIndex);
+
+        if (pDescriptorCapture != NULL) {
+            pDescriptorCapture->format              = ma_format_f32;
+            pDescriptorCapture->channels            = channels;
+            pDescriptorCapture->sampleRate          = sampleRate;
+            ma_channel_map_init_standard(ma_standard_channel_map_webaudio, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorCapture->channels);
+            pDescriptorCapture->periodSizeInFrames  = periodSizeInFrames;
+            pDescriptorCapture->periodCount         = 1;
+        }
+
+        if (pDescriptorPlayback != NULL) {
+            pDescriptorPlayback->format             = ma_format_f32;
+            pDescriptorPlayback->channels           = channels;
+            pDescriptorPlayback->sampleRate         = sampleRate;
+            ma_channel_map_init_standard(ma_standard_channel_map_webaudio, pDescriptorPlayback->channelMap, ma_countof(pDescriptorPlayback->channelMap), pDescriptorPlayback->channels);
+            pDescriptorPlayback->periodSizeInFrames = periodSizeInFrames;
+            pDescriptorPlayback->periodCount        = 1;
+        }
+
+        return MA_SUCCESS;
+    }
+    #endif
+}
+
+static ma_result ma_device_start__webaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    EM_ASM({
+        var device = window.miniaudio.get_device_by_index($0);
+        device.webaudio.resume();
+        device.state = window.miniaudio.device_state.started;
+    }, pDevice->webaudio.deviceIndex);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__webaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    From the WebAudio API documentation for AudioContext.suspend():
+
+        Suspends the progression of AudioContext's currentTime, allows any current context processing blocks that are already processed to be played to the
+        destination, and then allows the system to release its claim on audio hardware.
+
+    I read this to mean that "any current context processing blocks" are processed by suspend() - i.e. They they are drained. We therefore shouldn't need to
+    do any kind of explicit draining.
+    */
+    EM_ASM({
+        var device = window.miniaudio.get_device_by_index($0);
+        device.webaudio.suspend();
+        device.state = window.miniaudio.device_state.stopped;
+    }, pDevice->webaudio.deviceIndex);
+
+    ma_device__on_notification_stopped(pDevice);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__webaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_webaudio);
+
+    (void)pContext; /* Unused. */
+
+    /* Remove the global miniaudio object from window if there are no more references to it. */
+    EM_ASM({
+        if (typeof(window.miniaudio) !== 'undefined') {
+            miniaudio.unlock_event_types.map(function(event_type) {
+                document.removeEventListener(event_type, miniaudio.unlock, true);
+            });
+
+            window.miniaudio.referenceCount -= 1;
+            if (window.miniaudio.referenceCount === 0) {
+                delete window.miniaudio;
+            }
+        }
+    });
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__webaudio(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    int resultFromJS;
+
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig; /* Unused. */
+
+    /* Here is where our global JavaScript object is initialized. */
+    resultFromJS = EM_ASM_INT({
+        if (typeof window === 'undefined' || (window.AudioContext || window.webkitAudioContext) === undefined) {
+            return 0;   /* Web Audio not supported. */
+        }
+
+        if (typeof(window.miniaudio) === 'undefined') {
+            window.miniaudio = {
+                referenceCount: 0
+            };
+
+            /* Device types. */
+            window.miniaudio.device_type = {};
+            window.miniaudio.device_type.playback = $0;
+            window.miniaudio.device_type.capture  = $1;
+            window.miniaudio.device_type.duplex   = $2;
+
+            /* Device states. */
+            window.miniaudio.device_state = {};
+            window.miniaudio.device_state.stopped = $3;
+            window.miniaudio.device_state.started = $4;
+
+            /* Device cache for mapping devices to indexes for JavaScript/C interop. */
+            let miniaudio = window.miniaudio;
+            miniaudio.devices = [];
+
+            miniaudio.track_device = function(device) {
+                /* Try inserting into a free slot first. */
+                for (var iDevice = 0; iDevice < miniaudio.devices.length; ++iDevice) {
+                    if (miniaudio.devices[iDevice] == null) {
+                        miniaudio.devices[iDevice] = device;
+                        return iDevice;
+                    }
+                }
+
+                /* Getting here means there is no empty slots in the array so we just push to the end. */
+                miniaudio.devices.push(device);
+                return miniaudio.devices.length - 1;
+            };
+
+            miniaudio.untrack_device_by_index = function(deviceIndex) {
+                /* We just set the device's slot to null. The slot will get reused in the next call to ma_track_device. */
+                miniaudio.devices[deviceIndex] = null;
+
+                /* Trim the array if possible. */
+                while (miniaudio.devices.length > 0) {
+                    if (miniaudio.devices[miniaudio.devices.length-1] == null) {
+                        miniaudio.devices.pop();
+                    } else {
+                        break;
+                    }
+                }
+            };
+
+            miniaudio.untrack_device = function(device) {
+                for (var iDevice = 0; iDevice < miniaudio.devices.length; ++iDevice) {
+                    if (miniaudio.devices[iDevice] == device) {
+                        return miniaudio.untrack_device_by_index(iDevice);
+                    }
+                }
+            };
+
+            miniaudio.get_device_by_index = function(deviceIndex) {
+                return miniaudio.devices[deviceIndex];
+            };
+
+            miniaudio.unlock_event_types = (function(){
+                return ['touchend', 'click'];
+            })();
+
+            miniaudio.unlock = function() {
+                for(var i = 0; i < miniaudio.devices.length; ++i) {
+                    var device = miniaudio.devices[i];
+                    if (device != null &&
+                        device.webaudio != null &&
+                        device.state === miniaudio.device_state.started) {
+
+                        device.webaudio.resume().then(() => {
+                            _ma_device__on_notification_unlocked(device.pDevice);
+                        },
+                        (error) => {console.error("Failed to resume audiocontext", error);
+                        });
+                    }
+                }
+                miniaudio.unlock_event_types.map(function(event_type) {
+                    document.removeEventListener(event_type, miniaudio.unlock, true);
+                });
+            };
+
+            miniaudio.unlock_event_types.map(function(event_type) {
+                document.addEventListener(event_type, miniaudio.unlock, true);
+            });
+        }
+
+        window.miniaudio.referenceCount += 1;
+
+        return 1;
+    }, ma_device_type_playback, ma_device_type_capture, ma_device_type_duplex, ma_device_state_stopped, ma_device_state_started);
+
+    if (resultFromJS != 1) {
+        return MA_FAILED_TO_INIT_BACKEND;
+    }
+
+    pCallbacks->onContextInit             = ma_context_init__webaudio;
+    pCallbacks->onContextUninit           = ma_context_uninit__webaudio;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__webaudio;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__webaudio;
+    pCallbacks->onDeviceInit              = ma_device_init__webaudio;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__webaudio;
+    pCallbacks->onDeviceStart             = ma_device_start__webaudio;
+    pCallbacks->onDeviceStop              = ma_device_stop__webaudio;
+    pCallbacks->onDeviceRead              = NULL;   /* Not needed because WebAudio is asynchronous. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not needed because WebAudio is asynchronous. */
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Not needed because WebAudio is asynchronous. */
+
+    return MA_SUCCESS;
+}
+#endif  /* MA_HAS_WEBAUDIO */
+
+
+
+static ma_bool32 ma__is_channel_map_valid(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    /* A blank channel map should be allowed, in which case it should use an appropriate default which will depend on context. */
+    if (pChannelMap != NULL && pChannelMap[0] != MA_CHANNEL_NONE) {
+        ma_uint32 iChannel;
+
+        if (channels == 0 || channels > MA_MAX_CHANNELS) {
+            return MA_FALSE;   /* Channel count out of range. */
+        }
+
+        /* A channel cannot be present in the channel map more than once. */
+        for (iChannel = 0; iChannel < channels; ++iChannel) {
+            ma_uint32 jChannel;
+            for (jChannel = iChannel + 1; jChannel < channels; ++jChannel) {
+                if (pChannelMap[iChannel] == pChannelMap[jChannel]) {
+                    return MA_FALSE;
+                }
+            }
+        }
+    }
+
+    return MA_TRUE;
+}
+
+
+static ma_bool32 ma_context_is_backend_asynchronous(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+
+    if (pContext->callbacks.onDeviceRead == NULL && pContext->callbacks.onDeviceWrite == NULL) {
+        if (pContext->callbacks.onDeviceDataLoop == NULL) {
+            return MA_TRUE;
+        } else {
+            return MA_FALSE;
+        }
+    } else {
+        return MA_FALSE;
+    }
+}
+
+
+static ma_result ma_device__post_init_setup(ma_device* pDevice, ma_device_type deviceType)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+        if (pDevice->capture.format == ma_format_unknown) {
+            pDevice->capture.format = pDevice->capture.internalFormat;
+        }
+        if (pDevice->capture.channels == 0) {
+            pDevice->capture.channels = pDevice->capture.internalChannels;
+        }
+        if (pDevice->capture.channelMap[0] == MA_CHANNEL_NONE) {
+            MA_ASSERT(pDevice->capture.channels <= MA_MAX_CHANNELS);
+            if (pDevice->capture.internalChannels == pDevice->capture.channels) {
+                ma_channel_map_copy(pDevice->capture.channelMap, pDevice->capture.internalChannelMap, pDevice->capture.channels);
+            } else {
+                if (pDevice->capture.channelMixMode == ma_channel_mix_mode_simple) {
+                    ma_channel_map_init_blank(pDevice->capture.channelMap, pDevice->capture.channels);
+                } else {
+                    ma_channel_map_init_standard(ma_standard_channel_map_default, pDevice->capture.channelMap, ma_countof(pDevice->capture.channelMap), pDevice->capture.channels);
+                }
+            }
+        }
+    }
+
+    if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+        if (pDevice->playback.format == ma_format_unknown) {
+            pDevice->playback.format = pDevice->playback.internalFormat;
+        }
+        if (pDevice->playback.channels == 0) {
+            pDevice->playback.channels = pDevice->playback.internalChannels;
+        }
+        if (pDevice->playback.channelMap[0] == MA_CHANNEL_NONE) {
+            MA_ASSERT(pDevice->playback.channels <= MA_MAX_CHANNELS);
+            if (pDevice->playback.internalChannels == pDevice->playback.channels) {
+                ma_channel_map_copy(pDevice->playback.channelMap, pDevice->playback.internalChannelMap, pDevice->playback.channels);
+            } else {
+                if (pDevice->playback.channelMixMode == ma_channel_mix_mode_simple) {
+                    ma_channel_map_init_blank(pDevice->playback.channelMap, pDevice->playback.channels);
+                } else {
+                    ma_channel_map_init_standard(ma_standard_channel_map_default, pDevice->playback.channelMap, ma_countof(pDevice->playback.channelMap), pDevice->playback.channels);
+                }
+            }
+        }
+    }
+
+    if (pDevice->sampleRate == 0) {
+        if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+            pDevice->sampleRate = pDevice->capture.internalSampleRate;
+        } else {
+            pDevice->sampleRate = pDevice->playback.internalSampleRate;
+        }
+    }
+
+    /* Data converters. */
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+        /* Converting from internal device format to client format. */
+        ma_data_converter_config converterConfig = ma_data_converter_config_init_default();
+        converterConfig.formatIn                        = pDevice->capture.internalFormat;
+        converterConfig.channelsIn                      = pDevice->capture.internalChannels;
+        converterConfig.sampleRateIn                    = pDevice->capture.internalSampleRate;
+        converterConfig.pChannelMapIn                   = pDevice->capture.internalChannelMap;
+        converterConfig.formatOut                       = pDevice->capture.format;
+        converterConfig.channelsOut                     = pDevice->capture.channels;
+        converterConfig.sampleRateOut                   = pDevice->sampleRate;
+        converterConfig.pChannelMapOut                  = pDevice->capture.channelMap;
+        converterConfig.channelMixMode                  = pDevice->capture.channelMixMode;
+        converterConfig.calculateLFEFromSpatialChannels = pDevice->capture.calculateLFEFromSpatialChannels;
+        converterConfig.allowDynamicSampleRate          = MA_FALSE;
+        converterConfig.resampling.algorithm            = pDevice->resampling.algorithm;
+        converterConfig.resampling.linear.lpfOrder      = pDevice->resampling.linear.lpfOrder;
+        converterConfig.resampling.pBackendVTable       = pDevice->resampling.pBackendVTable;
+        converterConfig.resampling.pBackendUserData     = pDevice->resampling.pBackendUserData;
+
+        /* Make sure the old converter is uninitialized first. */
+        if (ma_device_get_state(pDevice) != ma_device_state_uninitialized) {
+            ma_data_converter_uninit(&pDevice->capture.converter, &pDevice->pContext->allocationCallbacks);
+        }
+
+        result = ma_data_converter_init(&converterConfig, &pDevice->pContext->allocationCallbacks, &pDevice->capture.converter);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+        /* Converting from client format to device format. */
+        ma_data_converter_config converterConfig = ma_data_converter_config_init_default();
+        converterConfig.formatIn                        = pDevice->playback.format;
+        converterConfig.channelsIn                      = pDevice->playback.channels;
+        converterConfig.sampleRateIn                    = pDevice->sampleRate;
+        converterConfig.pChannelMapIn                   = pDevice->playback.channelMap;
+        converterConfig.formatOut                       = pDevice->playback.internalFormat;
+        converterConfig.channelsOut                     = pDevice->playback.internalChannels;
+        converterConfig.sampleRateOut                   = pDevice->playback.internalSampleRate;
+        converterConfig.pChannelMapOut                  = pDevice->playback.internalChannelMap;
+        converterConfig.channelMixMode                  = pDevice->playback.channelMixMode;
+        converterConfig.calculateLFEFromSpatialChannels = pDevice->playback.calculateLFEFromSpatialChannels;
+        converterConfig.allowDynamicSampleRate          = MA_FALSE;
+        converterConfig.resampling.algorithm            = pDevice->resampling.algorithm;
+        converterConfig.resampling.linear.lpfOrder      = pDevice->resampling.linear.lpfOrder;
+        converterConfig.resampling.pBackendVTable       = pDevice->resampling.pBackendVTable;
+        converterConfig.resampling.pBackendUserData     = pDevice->resampling.pBackendUserData;
+
+        /* Make sure the old converter is uninitialized first. */
+        if (ma_device_get_state(pDevice) != ma_device_state_uninitialized) {
+            ma_data_converter_uninit(&pDevice->playback.converter, &pDevice->pContext->allocationCallbacks);
+        }
+
+        result = ma_data_converter_init(&converterConfig, &pDevice->pContext->allocationCallbacks, &pDevice->playback.converter);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+
+    /*
+    If the device is doing playback (ma_device_type_playback or ma_device_type_duplex), there's
+    a couple of situations where we'll need a heap allocated cache.
+
+    The first is a duplex device for backends that use a callback for data delivery. The reason
+    this is needed is that the input stage needs to have a buffer to place the input data while it
+    waits for the playback stage, after which the miniaudio data callback will get fired. This is
+    not needed for backends that use a blocking API because miniaudio manages temporary buffers on
+    the stack to achieve this.
+
+    The other situation is when the data converter does not have the ability to query the number
+    of input frames that are required in order to process a given number of output frames. When
+    performing data conversion, it's useful if miniaudio know exactly how many frames it needs
+    from the client in order to generate a given number of output frames. This way, only exactly
+    the number of frames are needed to be read from the client which means no cache is necessary.
+    On the other hand, if miniaudio doesn't know how many frames to read, it is forced to read
+    in fixed sized chunks and then cache any residual unused input frames, those of which will be
+    processed at a later stage.
+    */
+    if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+        ma_uint64 unused;
+
+        pDevice->playback.inputCacheConsumed  = 0;
+        pDevice->playback.inputCacheRemaining = 0;
+
+        if (pDevice->type == ma_device_type_duplex ||                                                                       /* Duplex. backend may decide to use ma_device_handle_backend_data_callback() which will require this cache. */
+            ma_data_converter_get_required_input_frame_count(&pDevice->playback.converter, 1, &unused) != MA_SUCCESS)       /* Data conversion required input frame calculation not supported. */
+        {
+            /* We need a heap allocated cache. We want to size this based on the period size. */
+            void* pNewInputCache;
+            ma_uint64 newInputCacheCap;
+            ma_uint64 newInputCacheSizeInBytes;
+
+            newInputCacheCap = ma_calculate_frame_count_after_resampling(pDevice->playback.internalSampleRate, pDevice->sampleRate, pDevice->playback.internalPeriodSizeInFrames);
+
+            newInputCacheSizeInBytes = newInputCacheCap * ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+            if (newInputCacheSizeInBytes > MA_SIZE_MAX) {
+                ma_free(pDevice->playback.pInputCache, &pDevice->pContext->allocationCallbacks);
+                pDevice->playback.pInputCache   = NULL;
+                pDevice->playback.inputCacheCap = 0;
+                return MA_OUT_OF_MEMORY;    /* Allocation too big. Should never hit this, but makes the cast below safer for 32-bit builds. */
+            }
+
+            pNewInputCache = ma_realloc(pDevice->playback.pInputCache, (size_t)newInputCacheSizeInBytes, &pDevice->pContext->allocationCallbacks);
+            if (pNewInputCache == NULL) {
+                ma_free(pDevice->playback.pInputCache, &pDevice->pContext->allocationCallbacks);
+                pDevice->playback.pInputCache   = NULL;
+                pDevice->playback.inputCacheCap = 0;
+                return MA_OUT_OF_MEMORY;
+            }
+
+            pDevice->playback.pInputCache   = pNewInputCache;
+            pDevice->playback.inputCacheCap = newInputCacheCap;
+        } else {
+            /* Heap allocation not required. Make sure we clear out the old cache just in case this function was called in response to a route change. */
+            ma_free(pDevice->playback.pInputCache, &pDevice->pContext->allocationCallbacks);
+            pDevice->playback.pInputCache   = NULL;
+            pDevice->playback.inputCacheCap = 0;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_post_init(ma_device* pDevice, ma_device_type deviceType, const ma_device_descriptor* pDescriptorPlayback, const ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Capture. */
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+        if (ma_device_descriptor_is_valid(pDescriptorCapture) == MA_FALSE) {
+            return MA_INVALID_ARGS;
+        }
+
+        pDevice->capture.internalFormat             = pDescriptorCapture->format;
+        pDevice->capture.internalChannels           = pDescriptorCapture->channels;
+        pDevice->capture.internalSampleRate         = pDescriptorCapture->sampleRate;
+        MA_COPY_MEMORY(pDevice->capture.internalChannelMap, pDescriptorCapture->channelMap, sizeof(pDescriptorCapture->channelMap));
+        pDevice->capture.internalPeriodSizeInFrames = pDescriptorCapture->periodSizeInFrames;
+        pDevice->capture.internalPeriods            = pDescriptorCapture->periodCount;
+
+        if (pDevice->capture.internalPeriodSizeInFrames == 0) {
+            pDevice->capture.internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptorCapture->periodSizeInMilliseconds, pDescriptorCapture->sampleRate);
+        }
+    }
+
+    /* Playback. */
+    if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+        if (ma_device_descriptor_is_valid(pDescriptorPlayback) == MA_FALSE) {
+            return MA_INVALID_ARGS;
+        }
+
+        pDevice->playback.internalFormat             = pDescriptorPlayback->format;
+        pDevice->playback.internalChannels           = pDescriptorPlayback->channels;
+        pDevice->playback.internalSampleRate         = pDescriptorPlayback->sampleRate;
+        MA_COPY_MEMORY(pDevice->playback.internalChannelMap, pDescriptorPlayback->channelMap, sizeof(pDescriptorPlayback->channelMap));
+        pDevice->playback.internalPeriodSizeInFrames = pDescriptorPlayback->periodSizeInFrames;
+        pDevice->playback.internalPeriods            = pDescriptorPlayback->periodCount;
+
+        if (pDevice->playback.internalPeriodSizeInFrames == 0) {
+            pDevice->playback.internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptorPlayback->periodSizeInMilliseconds, pDescriptorPlayback->sampleRate);
+        }
+    }
+
+    /*
+    The name of the device can be retrieved from device info. This may be temporary and replaced with a `ma_device_get_info(pDevice, deviceType)` instead.
+    For loopback devices, we need to retrieve the name of the playback device.
+    */
+    {
+        ma_device_info deviceInfo;
+
+        if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+            result = ma_device_get_info(pDevice, ma_device_type_capture, &deviceInfo);
+            if (result == MA_SUCCESS) {
+                ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), deviceInfo.name, (size_t)-1);
+            } else {
+                /* We failed to retrieve the device info. Fall back to a default name. */
+                if (pDescriptorCapture->pDeviceID == NULL) {
+                    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+                } else {
+                    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), "Capture Device", (size_t)-1);
+                }
+            }
+        }
+
+        if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+            result = ma_device_get_info(pDevice, ma_device_type_playback, &deviceInfo);
+            if (result == MA_SUCCESS) {
+                ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), deviceInfo.name, (size_t)-1);
+            } else {
+                /* We failed to retrieve the device info. Fall back to a default name. */
+                if (pDescriptorPlayback->pDeviceID == NULL) {
+                    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+                } else {
+                    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), "Playback Device", (size_t)-1);
+                }
+            }
+        }
+    }
+
+    /* Update data conversion. */
+    return ma_device__post_init_setup(pDevice, deviceType); /* TODO: Should probably rename ma_device__post_init_setup() to something better. */
+}
+
+
+static ma_thread_result MA_THREADCALL ma_worker_thread(void* pData)
+{
+    ma_device* pDevice = (ma_device*)pData;
+#if defined(MA_WIN32) && !defined(MA_XBOX)
+    HRESULT CoInitializeResult;
+#endif
+
+    MA_ASSERT(pDevice != NULL);
+
+#if defined(MA_WIN32) && !defined(MA_XBOX)
+    CoInitializeResult = ma_CoInitializeEx(pDevice->pContext, NULL, MA_COINIT_VALUE);
+#endif
+
+    /*
+    When the device is being initialized its initial state is set to ma_device_state_uninitialized. Before returning from
+    ma_device_init(), the state needs to be set to something valid. In miniaudio the device's default state immediately
+    after initialization is stopped, so therefore we need to mark the device as such. miniaudio will wait on the worker
+    thread to signal an event to know when the worker thread is ready for action.
+    */
+    ma_device__set_state(pDevice, ma_device_state_stopped);
+    ma_event_signal(&pDevice->stopEvent);
+
+    for (;;) {  /* <-- This loop just keeps the thread alive. The main audio loop is inside. */
+        ma_result startResult;
+        ma_result stopResult;   /* <-- This will store the result from onDeviceStop(). If it returns an error, we don't fire the stopped notification callback. */
+
+        /* We wait on an event to know when something has requested that the device be started and the main loop entered. */
+        ma_event_wait(&pDevice->wakeupEvent);
+
+        /* Default result code. */
+        pDevice->workResult = MA_SUCCESS;
+
+        /* If the reason for the wake up is that we are terminating, just break from the loop. */
+        if (ma_device_get_state(pDevice) == ma_device_state_uninitialized) {
+            break;
+        }
+
+        /*
+        Getting to this point means the device is wanting to get started. The function that has requested that the device
+        be started will be waiting on an event (pDevice->startEvent) which means we need to make sure we signal the event
+        in both the success and error case. It's important that the state of the device is set _before_ signaling the event.
+        */
+        MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_starting);
+
+        /* If the device has a start callback, start it now. */
+        if (pDevice->pContext->callbacks.onDeviceStart != NULL) {
+            startResult = pDevice->pContext->callbacks.onDeviceStart(pDevice);
+        } else {
+            startResult = MA_SUCCESS;
+        }
+
+        /*
+        If starting was not successful we'll need to loop back to the start and wait for something
+        to happen (pDevice->wakeupEvent).
+        */
+        if (startResult != MA_SUCCESS) {
+            pDevice->workResult = startResult;
+            ma_event_signal(&pDevice->startEvent);  /* <-- Always signal the start event so ma_device_start() can return as it'll be waiting on it. */
+            continue;
+        }
+
+        /* Make sure the state is set appropriately. */
+        ma_device__set_state(pDevice, ma_device_state_started); /* <-- Set this before signaling the event so that the state is always guaranteed to be good after ma_device_start() has returned. */
+        ma_event_signal(&pDevice->startEvent);
+
+        ma_device__on_notification_started(pDevice);
+
+        if (pDevice->pContext->callbacks.onDeviceDataLoop != NULL) {
+            pDevice->pContext->callbacks.onDeviceDataLoop(pDevice);
+        } else {
+            /* The backend is not using a custom main loop implementation, so now fall back to the blocking read-write implementation. */
+            ma_device_audio_thread__default_read_write(pDevice);
+        }
+
+        /* Getting here means we have broken from the main loop which happens the application has requested that device be stopped. */
+        if (pDevice->pContext->callbacks.onDeviceStop != NULL) {
+            stopResult = pDevice->pContext->callbacks.onDeviceStop(pDevice);
+        } else {
+            stopResult = MA_SUCCESS;    /* No stop callback with the backend. Just assume successful. */
+        }
+
+        /*
+        After the device has stopped, make sure an event is posted. Don't post a stopped event if
+        stopping failed. This can happen on some backends when the underlying stream has been
+        stopped due to the device being physically unplugged or disabled via an OS setting.
+        */
+        if (stopResult == MA_SUCCESS) {
+            ma_device__on_notification_stopped(pDevice);
+        }
+
+        /* If we stopped because the device has been uninitialized, abort now. */
+        if (ma_device_get_state(pDevice) == ma_device_state_uninitialized) {
+            break;
+        }
+
+        /* A function somewhere is waiting for the device to have stopped for real so we need to signal an event to allow it to continue. */
+        ma_device__set_state(pDevice, ma_device_state_stopped);
+        ma_event_signal(&pDevice->stopEvent);
+    }
+
+#if defined(MA_WIN32) && !defined(MA_XBOX)
+    if (CoInitializeResult == S_OK || CoInitializeResult == S_FALSE) {
+        ma_CoUninitialize(pDevice->pContext);
+    }
+#endif
+
+    return (ma_thread_result)0;
+}
+
+
+/* Helper for determining whether or not the given device is initialized. */
+static ma_bool32 ma_device__is_initialized(ma_device* pDevice)
+{
+    if (pDevice == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_device_get_state(pDevice) != ma_device_state_uninitialized;
+}
+
+
+#ifdef MA_WIN32
+static ma_result ma_context_uninit_backend_apis__win32(ma_context* pContext)
+{
+    /* For some reason UWP complains when CoUninitialize() is called. I'm just not going to call it on UWP. */
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    {
+        /* TODO: Remove this once the new single threaded backend system is in place in 0.12. */
+        #if !defined(MA_XBOX)
+        {
+            if (pContext->win32.CoInitializeResult == S_OK || pContext->win32.CoInitializeResult == S_FALSE) {
+                ma_CoUninitialize(pContext);    /* TODO: Remove this once the new single threaded backend system is in place in 0.12. */
+            }
+        }
+        #endif
+
+        #if defined(MA_WIN32_DESKTOP)
+            ma_dlclose(ma_context_get_log(pContext), pContext->win32.hUser32DLL);
+            ma_dlclose(ma_context_get_log(pContext), pContext->win32.hAdvapi32DLL);
+        #endif
+
+        ma_dlclose(ma_context_get_log(pContext), pContext->win32.hOle32DLL);
+    }
+    #else
+    {
+        (void)pContext;
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init_backend_apis__win32(ma_context* pContext)
+{
+    /*
+    TODO: Reassess all of this stuff and move everything to the relevant backends. For example, I think
+    GetForegroundWindow() and GetDesktopWindow() are only used by the DirectSound backend.
+    */
+    #if (defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)) && !defined(MA_XBOX)
+    {
+        #if defined(MA_WIN32_DESKTOP)
+        {
+            /* User32.dll */
+            pContext->win32.hUser32DLL = ma_dlopen(ma_context_get_log(pContext), "user32.dll");
+            if (pContext->win32.hUser32DLL == NULL) {
+                return MA_FAILED_TO_INIT_BACKEND;
+            }
+
+            pContext->win32.GetForegroundWindow = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hUser32DLL, "GetForegroundWindow");
+            pContext->win32.GetDesktopWindow    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hUser32DLL, "GetDesktopWindow");
+
+
+            /* Advapi32.dll */
+            pContext->win32.hAdvapi32DLL = ma_dlopen(ma_context_get_log(pContext), "advapi32.dll");
+            if (pContext->win32.hAdvapi32DLL == NULL) {
+                return MA_FAILED_TO_INIT_BACKEND;
+            }
+
+            pContext->win32.RegOpenKeyExA    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hAdvapi32DLL, "RegOpenKeyExA");
+            pContext->win32.RegCloseKey      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hAdvapi32DLL, "RegCloseKey");
+            pContext->win32.RegQueryValueExA = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hAdvapi32DLL, "RegQueryValueExA");
+        }
+        #endif
+
+        /* Ole32.dll */
+        pContext->win32.hOle32DLL = ma_dlopen(ma_context_get_log(pContext), "ole32.dll");
+        if (pContext->win32.hOle32DLL == NULL) {
+            return MA_FAILED_TO_INIT_BACKEND;
+        }
+
+        pContext->win32.CoInitialize     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoInitialize");
+        pContext->win32.CoInitializeEx   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoInitializeEx");
+        pContext->win32.CoUninitialize   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoUninitialize");
+        pContext->win32.CoCreateInstance = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoCreateInstance");
+        pContext->win32.CoTaskMemFree    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoTaskMemFree");
+        pContext->win32.PropVariantClear = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "PropVariantClear");
+        pContext->win32.StringFromGUID2  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "StringFromGUID2");
+    }
+    #else
+    {
+        (void)pContext; /* Unused. */
+    }
+    #endif
+
+    /* TODO: Remove this once the new single threaded backend system is in place in 0.12. */
+    #if !defined(MA_XBOX)
+    {
+        pContext->win32.CoInitializeResult = ma_CoInitializeEx(pContext, NULL, MA_COINIT_VALUE);
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+#else
+static ma_result ma_context_uninit_backend_apis__nix(ma_context* pContext)
+{
+    (void)pContext;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init_backend_apis__nix(ma_context* pContext)
+{
+    (void)pContext;
+
+    return MA_SUCCESS;
+}
+#endif
+
+static ma_result ma_context_init_backend_apis(ma_context* pContext)
+{
+    ma_result result;
+#ifdef MA_WIN32
+    result = ma_context_init_backend_apis__win32(pContext);
+#else
+    result = ma_context_init_backend_apis__nix(pContext);
+#endif
+
+    return result;
+}
+
+static ma_result ma_context_uninit_backend_apis(ma_context* pContext)
+{
+    ma_result result;
+#ifdef MA_WIN32
+    result = ma_context_uninit_backend_apis__win32(pContext);
+#else
+    result = ma_context_uninit_backend_apis__nix(pContext);
+#endif
+
+    return result;
+}
+
+
+/* The default capacity doesn't need to be too big. */
+#ifndef MA_DEFAULT_DEVICE_JOB_QUEUE_CAPACITY
+#define MA_DEFAULT_DEVICE_JOB_QUEUE_CAPACITY    32
+#endif
+
+MA_API ma_device_job_thread_config ma_device_job_thread_config_init(void)
+{
+    ma_device_job_thread_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.noThread         = MA_FALSE;
+    config.jobQueueCapacity = MA_DEFAULT_DEVICE_JOB_QUEUE_CAPACITY;
+    config.jobQueueFlags    = 0;
+
+    return config;
+}
+
+
+static ma_thread_result MA_THREADCALL ma_device_job_thread_entry(void* pUserData)
+{
+    ma_device_job_thread* pJobThread = (ma_device_job_thread*)pUserData;
+    MA_ASSERT(pJobThread != NULL);
+
+    for (;;) {
+        ma_result result;
+        ma_job job;
+
+        result = ma_device_job_thread_next(pJobThread, &job);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        if (job.toc.breakup.code == MA_JOB_TYPE_QUIT) {
+            break;
+        }
+
+        ma_job_process(&job);
+    }
+
+    return (ma_thread_result)0;
+}
+
+MA_API ma_result ma_device_job_thread_init(const ma_device_job_thread_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_device_job_thread* pJobThread)
+{
+    ma_result result;
+    ma_job_queue_config jobQueueConfig;
+
+    if (pJobThread == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pJobThread);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+
+    /* Initialize the job queue before the thread to ensure it's in a valid state. */
+    jobQueueConfig = ma_job_queue_config_init(pConfig->jobQueueFlags, pConfig->jobQueueCapacity);
+
+    result = ma_job_queue_init(&jobQueueConfig, pAllocationCallbacks, &pJobThread->jobQueue);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize job queue. */
+    }
+
+
+    /* The thread needs to be initialized after the job queue to ensure the thread doesn't try to access it prematurely. */
+    if (pConfig->noThread == MA_FALSE) {
+        result = ma_thread_create(&pJobThread->thread, ma_thread_priority_normal, 0, ma_device_job_thread_entry, pJobThread, pAllocationCallbacks);
+        if (result != MA_SUCCESS) {
+            ma_job_queue_uninit(&pJobThread->jobQueue, pAllocationCallbacks);
+            return result;  /* Failed to create the job thread. */
+        }
+
+        pJobThread->_hasThread = MA_TRUE;
+    } else {
+        pJobThread->_hasThread = MA_FALSE;
+    }
+
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_device_job_thread_uninit(ma_device_job_thread* pJobThread, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pJobThread == NULL) {
+        return;
+    }
+
+    /* The first thing to do is post a quit message to the job queue. If we're using a thread we'll need to wait for it. */
+    {
+        ma_job job = ma_job_init(MA_JOB_TYPE_QUIT);
+        ma_device_job_thread_post(pJobThread, &job);
+    }
+
+    /* Wait for the thread to terminate naturally. */
+    if (pJobThread->_hasThread) {
+        ma_thread_wait(&pJobThread->thread);
+    }
+
+    /* At this point the thread should be terminated so we can safely uninitialize the job queue. */
+    ma_job_queue_uninit(&pJobThread->jobQueue, pAllocationCallbacks);
+}
+
+MA_API ma_result ma_device_job_thread_post(ma_device_job_thread* pJobThread, const ma_job* pJob)
+{
+    if (pJobThread == NULL || pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_queue_post(&pJobThread->jobQueue, pJob);
+}
+
+MA_API ma_result ma_device_job_thread_next(ma_device_job_thread* pJobThread, ma_job* pJob)
+{
+    if (pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pJob);
+
+    if (pJobThread == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_queue_next(&pJobThread->jobQueue, pJob);
+}
+
+
+MA_API ma_bool32 ma_device_id_equal(const ma_device_id* pA, const ma_device_id* pB)
+{
+    size_t i;
+
+    if (pA == NULL || pB == NULL) {
+        return MA_FALSE;
+    }
+
+    for (i = 0; i < sizeof(ma_device_id); i += 1) {
+        if (((const char*)pA)[i] != ((const char*)pB)[i]) {
+            return MA_FALSE;
+        }
+    }
+
+    return MA_TRUE;
+}
+
+
+
+MA_API ma_context_config ma_context_config_init(void)
+{
+    ma_context_config config;
+    MA_ZERO_OBJECT(&config);
+
+    return config;
+}
+
+MA_API ma_result ma_context_init(const ma_backend backends[], ma_uint32 backendCount, const ma_context_config* pConfig, ma_context* pContext)
+{
+    ma_result result;
+    ma_context_config defaultConfig;
+    ma_backend defaultBackends[ma_backend_null+1];
+    ma_uint32 iBackend;
+    ma_backend* pBackendsToIterate;
+    ma_uint32 backendsToIterateCount;
+
+    if (pContext == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pContext);
+
+    /* Always make sure the config is set first to ensure properties are available as soon as possible. */
+    if (pConfig == NULL) {
+        defaultConfig = ma_context_config_init();
+        pConfig = &defaultConfig;
+    }
+
+    /* Allocation callbacks need to come first because they'll be passed around to other areas. */
+    result = ma_allocation_callbacks_init_copy(&pContext->allocationCallbacks, &pConfig->allocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Get a lot set up first so we can start logging ASAP. */
+    if (pConfig->pLog != NULL) {
+        pContext->pLog = pConfig->pLog;
+    } else {
+        result = ma_log_init(&pContext->allocationCallbacks, &pContext->log);
+        if (result == MA_SUCCESS) {
+            pContext->pLog = &pContext->log;
+        } else {
+            pContext->pLog = NULL;  /* Logging is not available. */
+        }
+    }
+
+    pContext->threadPriority  = pConfig->threadPriority;
+    pContext->threadStackSize = pConfig->threadStackSize;
+    pContext->pUserData       = pConfig->pUserData;
+
+    /* Backend APIs need to be initialized first. This is where external libraries will be loaded and linked. */
+    result = ma_context_init_backend_apis(pContext);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    for (iBackend = 0; iBackend <= ma_backend_null; ++iBackend) {
+        defaultBackends[iBackend] = (ma_backend)iBackend;
+    }
+
+    pBackendsToIterate = (ma_backend*)backends;
+    backendsToIterateCount = backendCount;
+    if (pBackendsToIterate == NULL) {
+        pBackendsToIterate = (ma_backend*)defaultBackends;
+        backendsToIterateCount = ma_countof(defaultBackends);
+    }
+
+    MA_ASSERT(pBackendsToIterate != NULL);
+
+    for (iBackend = 0; iBackend < backendsToIterateCount; iBackend += 1) {
+        ma_backend backend = pBackendsToIterate[iBackend];
+
+        /* Make sure all callbacks are reset so we don't accidentally drag in any from previously failed initialization attempts. */
+        MA_ZERO_OBJECT(&pContext->callbacks);
+
+        /* These backends are using the new callback system. */
+        switch (backend) {
+        #ifdef MA_HAS_WASAPI
+            case ma_backend_wasapi:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__wasapi;
+            } break;
+        #endif
+        #ifdef MA_HAS_DSOUND
+            case ma_backend_dsound:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__dsound;
+            } break;
+        #endif
+        #ifdef MA_HAS_WINMM
+            case ma_backend_winmm:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__winmm;
+            } break;
+        #endif
+        #ifdef MA_HAS_COREAUDIO
+            case ma_backend_coreaudio:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__coreaudio;
+            } break;
+        #endif
+        #ifdef MA_HAS_SNDIO
+            case ma_backend_sndio:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__sndio;
+            } break;
+        #endif
+        #ifdef MA_HAS_AUDIO4
+            case ma_backend_audio4:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__audio4;
+            } break;
+        #endif
+        #ifdef MA_HAS_OSS
+            case ma_backend_oss:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__oss;
+            } break;
+        #endif
+        #ifdef MA_HAS_PULSEAUDIO
+            case ma_backend_pulseaudio:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__pulse;
+            } break;
+        #endif
+        #ifdef MA_HAS_ALSA
+            case ma_backend_alsa:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__alsa;
+            } break;
+        #endif
+        #ifdef MA_HAS_JACK
+            case ma_backend_jack:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__jack;
+            } break;
+        #endif
+        #ifdef MA_HAS_AAUDIO
+            case ma_backend_aaudio:
+            {
+                if (ma_is_backend_enabled(backend)) {
+                    pContext->callbacks.onContextInit = ma_context_init__aaudio;
+                }
+            } break;
+        #endif
+        #ifdef MA_HAS_OPENSL
+            case ma_backend_opensl:
+            {
+                if (ma_is_backend_enabled(backend)) {
+                    pContext->callbacks.onContextInit = ma_context_init__opensl;
+                }
+            } break;
+        #endif
+        #ifdef MA_HAS_WEBAUDIO
+            case ma_backend_webaudio:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__webaudio;
+            } break;
+        #endif
+        #ifdef MA_HAS_CUSTOM
+            case ma_backend_custom:
+            {
+                /* Slightly different logic for custom backends. Custom backends can optionally set all of their callbacks in the config. */
+                pContext->callbacks = pConfig->custom;
+            } break;
+        #endif
+        #ifdef MA_HAS_NULL
+            case ma_backend_null:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__null;
+            } break;
+        #endif
+
+            default: break;
+        }
+
+        if (pContext->callbacks.onContextInit != NULL) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "Attempting to initialize %s backend...\n", ma_get_backend_name(backend));
+            result = pContext->callbacks.onContextInit(pContext, pConfig, &pContext->callbacks);
+        } else {
+            /* Getting here means the onContextInit callback is not set which means the backend is not enabled. Special case for the custom backend. */
+            if (backend != ma_backend_custom) {
+                result = MA_BACKEND_NOT_ENABLED;
+            } else {
+            #if !defined(MA_HAS_CUSTOM)
+                result = MA_BACKEND_NOT_ENABLED;
+            #else
+                result = MA_NO_BACKEND;
+            #endif
+            }
+        }
+
+        /* If this iteration was successful, return. */
+        if (result == MA_SUCCESS) {
+            result = ma_mutex_init(&pContext->deviceEnumLock);
+            if (result != MA_SUCCESS) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "Failed to initialize mutex for device enumeration. ma_context_get_devices() is not thread safe.\n");
+            }
+
+            result = ma_mutex_init(&pContext->deviceInfoLock);
+            if (result != MA_SUCCESS) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "Failed to initialize mutex for device info retrieval. ma_context_get_device_info() is not thread safe.\n");
+            }
+
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "System Architecture:\n");
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "  Endian: %s\n", ma_is_little_endian() ? "LE"  : "BE");
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "  SSE2:   %s\n", ma_has_sse2()         ? "YES" : "NO");
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "  AVX2:   %s\n", ma_has_avx2()         ? "YES" : "NO");
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "  NEON:   %s\n", ma_has_neon()         ? "YES" : "NO");
+
+            pContext->backend = backend;
+            return result;
+        } else {
+            if (result == MA_BACKEND_NOT_ENABLED) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "%s backend is disabled.\n", ma_get_backend_name(backend));
+            } else {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "Failed to initialize %s backend.\n", ma_get_backend_name(backend));
+            }
+        }
+    }
+
+    /* If we get here it means an error occurred. */
+    MA_ZERO_OBJECT(pContext);  /* Safety. */
+    return MA_NO_BACKEND;
+}
+
+MA_API ma_result ma_context_uninit(ma_context* pContext)
+{
+    if (pContext == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pContext->callbacks.onContextUninit != NULL) {
+        pContext->callbacks.onContextUninit(pContext);
+    }
+
+    ma_mutex_uninit(&pContext->deviceEnumLock);
+    ma_mutex_uninit(&pContext->deviceInfoLock);
+    ma_free(pContext->pDeviceInfos, &pContext->allocationCallbacks);
+    ma_context_uninit_backend_apis(pContext);
+
+    if (pContext->pLog == &pContext->log) {
+        ma_log_uninit(&pContext->log);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API size_t ma_context_sizeof(void)
+{
+    return sizeof(ma_context);
+}
+
+
+MA_API ma_log* ma_context_get_log(ma_context* pContext)
+{
+    if (pContext == NULL) {
+        return NULL;
+    }
+
+    return pContext->pLog;
+}
+
+
+MA_API ma_result ma_context_enumerate_devices(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_result result;
+
+    if (pContext == NULL || callback == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pContext->callbacks.onContextEnumerateDevices == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    ma_mutex_lock(&pContext->deviceEnumLock);
+    {
+        result = pContext->callbacks.onContextEnumerateDevices(pContext, callback, pUserData);
+    }
+    ma_mutex_unlock(&pContext->deviceEnumLock);
+
+    return result;
+}
+
+
+static ma_bool32 ma_context_get_devices__enum_callback(ma_context* pContext, ma_device_type deviceType, const ma_device_info* pInfo, void* pUserData)
+{
+    /*
+    We need to insert the device info into our main internal buffer. Where it goes depends on the device type. If it's a capture device
+    it's just appended to the end. If it's a playback device it's inserted just before the first capture device.
+    */
+
+    /*
+    First make sure we have room. Since the number of devices we add to the list is usually relatively small I've decided to use a
+    simple fixed size increment for buffer expansion.
+    */
+    const ma_uint32 bufferExpansionCount = 2;
+    const ma_uint32 totalDeviceInfoCount = pContext->playbackDeviceInfoCount + pContext->captureDeviceInfoCount;
+
+    if (totalDeviceInfoCount >= pContext->deviceInfoCapacity) {
+        ma_uint32 newCapacity = pContext->deviceInfoCapacity + bufferExpansionCount;
+        ma_device_info* pNewInfos = (ma_device_info*)ma_realloc(pContext->pDeviceInfos, sizeof(*pContext->pDeviceInfos)*newCapacity, &pContext->allocationCallbacks);
+        if (pNewInfos == NULL) {
+            return MA_FALSE;   /* Out of memory. */
+        }
+
+        pContext->pDeviceInfos = pNewInfos;
+        pContext->deviceInfoCapacity = newCapacity;
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        /* Playback. Insert just before the first capture device. */
+
+        /* The first thing to do is move all of the capture devices down a slot. */
+        ma_uint32 iFirstCaptureDevice = pContext->playbackDeviceInfoCount;
+        size_t iCaptureDevice;
+        for (iCaptureDevice = totalDeviceInfoCount; iCaptureDevice > iFirstCaptureDevice; --iCaptureDevice) {
+            pContext->pDeviceInfos[iCaptureDevice] = pContext->pDeviceInfos[iCaptureDevice-1];
+        }
+
+        /* Now just insert where the first capture device was before moving it down a slot. */
+        pContext->pDeviceInfos[iFirstCaptureDevice] = *pInfo;
+        pContext->playbackDeviceInfoCount += 1;
+    } else {
+        /* Capture. Insert at the end. */
+        pContext->pDeviceInfos[totalDeviceInfoCount] = *pInfo;
+        pContext->captureDeviceInfoCount += 1;
+    }
+
+    (void)pUserData;
+    return MA_TRUE;
+}
+
+MA_API ma_result ma_context_get_devices(ma_context* pContext, ma_device_info** ppPlaybackDeviceInfos, ma_uint32* pPlaybackDeviceCount, ma_device_info** ppCaptureDeviceInfos, ma_uint32* pCaptureDeviceCount)
+{
+    ma_result result;
+
+    /* Safety. */
+    if (ppPlaybackDeviceInfos != NULL) *ppPlaybackDeviceInfos = NULL;
+    if (pPlaybackDeviceCount  != NULL) *pPlaybackDeviceCount  = 0;
+    if (ppCaptureDeviceInfos  != NULL) *ppCaptureDeviceInfos  = NULL;
+    if (pCaptureDeviceCount   != NULL) *pCaptureDeviceCount   = 0;
+
+    if (pContext == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pContext->callbacks.onContextEnumerateDevices == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Note that we don't use ma_context_enumerate_devices() here because we want to do locking at a higher level. */
+    ma_mutex_lock(&pContext->deviceEnumLock);
+    {
+        /* Reset everything first. */
+        pContext->playbackDeviceInfoCount = 0;
+        pContext->captureDeviceInfoCount = 0;
+
+        /* Now enumerate over available devices. */
+        result = pContext->callbacks.onContextEnumerateDevices(pContext, ma_context_get_devices__enum_callback, NULL);
+        if (result == MA_SUCCESS) {
+            /* Playback devices. */
+            if (ppPlaybackDeviceInfos != NULL) {
+                *ppPlaybackDeviceInfos = pContext->pDeviceInfos;
+            }
+            if (pPlaybackDeviceCount != NULL) {
+                *pPlaybackDeviceCount = pContext->playbackDeviceInfoCount;
+            }
+
+            /* Capture devices. */
+            if (ppCaptureDeviceInfos != NULL) {
+                *ppCaptureDeviceInfos = pContext->pDeviceInfos;
+                /* Capture devices come after playback devices. */
+                if (pContext->playbackDeviceInfoCount > 0) {
+                    /* Conditional, because NULL+0 is undefined behavior. */
+                    *ppCaptureDeviceInfos += pContext->playbackDeviceInfoCount;
+                }
+            }
+            if (pCaptureDeviceCount != NULL) {
+                *pCaptureDeviceCount = pContext->captureDeviceInfoCount;
+            }
+        }
+    }
+    ma_mutex_unlock(&pContext->deviceEnumLock);
+
+    return result;
+}
+
+MA_API ma_result ma_context_get_device_info(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_result result;
+    ma_device_info deviceInfo;
+
+    /* NOTE: Do not clear pDeviceInfo on entry. The reason is the pDeviceID may actually point to pDeviceInfo->id which will break things. */
+    if (pContext == NULL || pDeviceInfo == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(&deviceInfo);
+
+    /* Help the backend out by copying over the device ID if we have one. */
+    if (pDeviceID != NULL) {
+        MA_COPY_MEMORY(&deviceInfo.id, pDeviceID, sizeof(*pDeviceID));
+    }
+
+    if (pContext->callbacks.onContextGetDeviceInfo == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    ma_mutex_lock(&pContext->deviceInfoLock);
+    {
+        result = pContext->callbacks.onContextGetDeviceInfo(pContext, deviceType, pDeviceID, &deviceInfo);
+    }
+    ma_mutex_unlock(&pContext->deviceInfoLock);
+
+    *pDeviceInfo = deviceInfo;
+    return result;
+}
+
+MA_API ma_bool32 ma_context_is_loopback_supported(ma_context* pContext)
+{
+    if (pContext == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_is_loopback_supported(pContext->backend);
+}
+
+
+MA_API ma_device_config ma_device_config_init(ma_device_type deviceType)
+{
+    ma_device_config config;
+    MA_ZERO_OBJECT(&config);
+    config.deviceType = deviceType;
+    config.resampling = ma_resampler_config_init(ma_format_unknown, 0, 0, 0, ma_resample_algorithm_linear); /* Format/channels/rate don't matter here. */
+
+    return config;
+}
+
+MA_API ma_result ma_device_init(ma_context* pContext, const ma_device_config* pConfig, ma_device* pDevice)
+{
+    ma_result result;
+    ma_device_descriptor descriptorPlayback;
+    ma_device_descriptor descriptorCapture;
+
+    /* The context can be null, in which case we self-manage it. */
+    if (pContext == NULL) {
+        return ma_device_init_ex(NULL, 0, NULL, pConfig, pDevice);
+    }
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDevice);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Check that we have our callbacks defined. */
+    if (pContext->callbacks.onDeviceInit == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Basic config validation. */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        if (pConfig->capture.channels > MA_MAX_CHANNELS) {
+            return MA_INVALID_ARGS;
+        }
+
+        if (!ma__is_channel_map_valid(pConfig->capture.pChannelMap, pConfig->capture.channels)) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+        if (pConfig->playback.channels > MA_MAX_CHANNELS) {
+            return MA_INVALID_ARGS;
+        }
+
+        if (!ma__is_channel_map_valid(pConfig->playback.pChannelMap, pConfig->playback.channels)) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    pDevice->pContext = pContext;
+
+    /* Set the user data and log callback ASAP to ensure it is available for the entire initialization process. */
+    pDevice->pUserData      = pConfig->pUserData;
+    pDevice->onData         = pConfig->dataCallback;
+    pDevice->onNotification = pConfig->notificationCallback;
+    pDevice->onStop         = pConfig->stopCallback;
+
+    if (pConfig->playback.pDeviceID != NULL) {
+        MA_COPY_MEMORY(&pDevice->playback.id, pConfig->playback.pDeviceID, sizeof(pDevice->playback.id));
+        pDevice->playback.pID = &pDevice->playback.id;
+    } else {
+        pDevice->playback.pID = NULL;
+    }
+
+    if (pConfig->capture.pDeviceID != NULL) {
+        MA_COPY_MEMORY(&pDevice->capture.id, pConfig->capture.pDeviceID, sizeof(pDevice->capture.id));
+        pDevice->capture.pID = &pDevice->capture.id;
+    } else {
+        pDevice->capture.pID = NULL;
+    }
+
+    pDevice->noPreSilencedOutputBuffer   = pConfig->noPreSilencedOutputBuffer;
+    pDevice->noClip                      = pConfig->noClip;
+    pDevice->noDisableDenormals          = pConfig->noDisableDenormals;
+    pDevice->noFixedSizedCallback        = pConfig->noFixedSizedCallback;
+    ma_atomic_float_set(&pDevice->masterVolumeFactor, 1);
+
+    pDevice->type                        = pConfig->deviceType;
+    pDevice->sampleRate                  = pConfig->sampleRate;
+    pDevice->resampling.algorithm        = pConfig->resampling.algorithm;
+    pDevice->resampling.linear.lpfOrder  = pConfig->resampling.linear.lpfOrder;
+    pDevice->resampling.pBackendVTable   = pConfig->resampling.pBackendVTable;
+    pDevice->resampling.pBackendUserData = pConfig->resampling.pBackendUserData;
+
+    pDevice->capture.shareMode           = pConfig->capture.shareMode;
+    pDevice->capture.format              = pConfig->capture.format;
+    pDevice->capture.channels            = pConfig->capture.channels;
+    ma_channel_map_copy_or_default(pDevice->capture.channelMap, ma_countof(pDevice->capture.channelMap), pConfig->capture.pChannelMap, pConfig->capture.channels);
+    pDevice->capture.channelMixMode      = pConfig->capture.channelMixMode;
+    pDevice->capture.calculateLFEFromSpatialChannels = pConfig->capture.calculateLFEFromSpatialChannels;
+
+    pDevice->playback.shareMode          = pConfig->playback.shareMode;
+    pDevice->playback.format             = pConfig->playback.format;
+    pDevice->playback.channels           = pConfig->playback.channels;
+    ma_channel_map_copy_or_default(pDevice->playback.channelMap, ma_countof(pDevice->playback.channelMap), pConfig->playback.pChannelMap, pConfig->playback.channels);
+    pDevice->playback.channelMixMode     = pConfig->playback.channelMixMode;
+    pDevice->playback.calculateLFEFromSpatialChannels = pConfig->playback.calculateLFEFromSpatialChannels;
+
+    result = ma_mutex_init(&pDevice->startStopLock);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /*
+    When the device is started, the worker thread is the one that does the actual startup of the backend device. We
+    use a semaphore to wait for the background thread to finish the work. The same applies for stopping the device.
+
+    Each of these semaphores is released internally by the worker thread when the work is completed. The start
+    semaphore is also used to wake up the worker thread.
+    */
+    result = ma_event_init(&pDevice->wakeupEvent);
+    if (result != MA_SUCCESS) {
+        ma_mutex_uninit(&pDevice->startStopLock);
+        return result;
+    }
+
+    result = ma_event_init(&pDevice->startEvent);
+    if (result != MA_SUCCESS) {
+        ma_event_uninit(&pDevice->wakeupEvent);
+        ma_mutex_uninit(&pDevice->startStopLock);
+        return result;
+    }
+
+    result = ma_event_init(&pDevice->stopEvent);
+    if (result != MA_SUCCESS) {
+        ma_event_uninit(&pDevice->startEvent);
+        ma_event_uninit(&pDevice->wakeupEvent);
+        ma_mutex_uninit(&pDevice->startStopLock);
+        return result;
+    }
+
+
+    MA_ZERO_OBJECT(&descriptorPlayback);
+    descriptorPlayback.pDeviceID                = pConfig->playback.pDeviceID;
+    descriptorPlayback.shareMode                = pConfig->playback.shareMode;
+    descriptorPlayback.format                   = pConfig->playback.format;
+    descriptorPlayback.channels                 = pConfig->playback.channels;
+    descriptorPlayback.sampleRate               = pConfig->sampleRate;
+    ma_channel_map_copy_or_default(descriptorPlayback.channelMap, ma_countof(descriptorPlayback.channelMap), pConfig->playback.pChannelMap, pConfig->playback.channels);
+    descriptorPlayback.periodSizeInFrames       = pConfig->periodSizeInFrames;
+    descriptorPlayback.periodSizeInMilliseconds = pConfig->periodSizeInMilliseconds;
+    descriptorPlayback.periodCount              = pConfig->periods;
+
+    if (descriptorPlayback.periodCount == 0) {
+        descriptorPlayback.periodCount = MA_DEFAULT_PERIODS;
+    }
+
+
+    MA_ZERO_OBJECT(&descriptorCapture);
+    descriptorCapture.pDeviceID                 = pConfig->capture.pDeviceID;
+    descriptorCapture.shareMode                 = pConfig->capture.shareMode;
+    descriptorCapture.format                    = pConfig->capture.format;
+    descriptorCapture.channels                  = pConfig->capture.channels;
+    descriptorCapture.sampleRate                = pConfig->sampleRate;
+    ma_channel_map_copy_or_default(descriptorCapture.channelMap, ma_countof(descriptorCapture.channelMap), pConfig->capture.pChannelMap, pConfig->capture.channels);
+    descriptorCapture.periodSizeInFrames        = pConfig->periodSizeInFrames;
+    descriptorCapture.periodSizeInMilliseconds  = pConfig->periodSizeInMilliseconds;
+    descriptorCapture.periodCount               = pConfig->periods;
+
+    if (descriptorCapture.periodCount == 0) {
+        descriptorCapture.periodCount = MA_DEFAULT_PERIODS;
+    }
+
+
+    result = pContext->callbacks.onDeviceInit(pDevice, pConfig, &descriptorPlayback, &descriptorCapture);
+    if (result != MA_SUCCESS) {
+        ma_event_uninit(&pDevice->startEvent);
+        ma_event_uninit(&pDevice->wakeupEvent);
+        ma_mutex_uninit(&pDevice->startStopLock);
+        return result;
+    }
+
+#if 0
+    /*
+    On output the descriptors will contain the *actual* data format of the device. We need this to know how to convert the data between
+    the requested format and the internal format.
+    */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+        if (!ma_device_descriptor_is_valid(&descriptorCapture)) {
+            ma_device_uninit(pDevice);
+            return MA_INVALID_ARGS;
+        }
+
+        pDevice->capture.internalFormat             = descriptorCapture.format;
+        pDevice->capture.internalChannels           = descriptorCapture.channels;
+        pDevice->capture.internalSampleRate         = descriptorCapture.sampleRate;
+        ma_channel_map_copy(pDevice->capture.internalChannelMap, descriptorCapture.channelMap, descriptorCapture.channels);
+        pDevice->capture.internalPeriodSizeInFrames = descriptorCapture.periodSizeInFrames;
+        pDevice->capture.internalPeriods            = descriptorCapture.periodCount;
+
+        if (pDevice->capture.internalPeriodSizeInFrames == 0) {
+            pDevice->capture.internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(descriptorCapture.periodSizeInMilliseconds, descriptorCapture.sampleRate);
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        if (!ma_device_descriptor_is_valid(&descriptorPlayback)) {
+            ma_device_uninit(pDevice);
+            return MA_INVALID_ARGS;
+        }
+
+        pDevice->playback.internalFormat             = descriptorPlayback.format;
+        pDevice->playback.internalChannels           = descriptorPlayback.channels;
+        pDevice->playback.internalSampleRate         = descriptorPlayback.sampleRate;
+        ma_channel_map_copy(pDevice->playback.internalChannelMap, descriptorPlayback.channelMap, descriptorPlayback.channels);
+        pDevice->playback.internalPeriodSizeInFrames = descriptorPlayback.periodSizeInFrames;
+        pDevice->playback.internalPeriods            = descriptorPlayback.periodCount;
+
+        if (pDevice->playback.internalPeriodSizeInFrames == 0) {
+            pDevice->playback.internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(descriptorPlayback.periodSizeInMilliseconds, descriptorPlayback.sampleRate);
+        }
+    }
+
+
+    /*
+    The name of the device can be retrieved from device info. This may be temporary and replaced with a `ma_device_get_info(pDevice, deviceType)` instead.
+    For loopback devices, we need to retrieve the name of the playback device.
+    */
+    {
+        ma_device_info deviceInfo;
+
+        if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+            result = ma_device_get_info(pDevice, (pConfig->deviceType == ma_device_type_loopback) ? ma_device_type_playback : ma_device_type_capture, &deviceInfo);
+            if (result == MA_SUCCESS) {
+                ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), deviceInfo.name, (size_t)-1);
+            } else {
+                /* We failed to retrieve the device info. Fall back to a default name. */
+                if (descriptorCapture.pDeviceID == NULL) {
+                    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+                } else {
+                    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), "Capture Device", (size_t)-1);
+                }
+            }
+        }
+
+        if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+            result = ma_device_get_info(pDevice, ma_device_type_playback, &deviceInfo);
+            if (result == MA_SUCCESS) {
+                ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), deviceInfo.name, (size_t)-1);
+            } else {
+                /* We failed to retrieve the device info. Fall back to a default name. */
+                if (descriptorPlayback.pDeviceID == NULL) {
+                    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+                } else {
+                    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), "Playback Device", (size_t)-1);
+                }
+            }
+        }
+    }
+
+
+    ma_device__post_init_setup(pDevice, pConfig->deviceType);
+#endif
+
+    result = ma_device_post_init(pDevice, pConfig->deviceType, &descriptorPlayback, &descriptorCapture);
+    if (result != MA_SUCCESS) {
+        ma_device_uninit(pDevice);
+        return result;
+    }
+
+
+    /*
+    If we're using fixed sized callbacks we'll need to make use of an intermediary buffer. Needs to
+    be done after post_init_setup() because we'll need access to the sample rate.
+    */
+    if (pConfig->noFixedSizedCallback == MA_FALSE) {
+        /* We're using a fixed sized data callback so we'll need an intermediary buffer. */
+        ma_uint32 intermediaryBufferCap = pConfig->periodSizeInFrames;
+        if (intermediaryBufferCap == 0) {
+            intermediaryBufferCap = ma_calculate_buffer_size_in_frames_from_milliseconds(pConfig->periodSizeInMilliseconds, pDevice->sampleRate);
+        }
+
+        if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+            ma_uint32 intermediaryBufferSizeInBytes;
+
+            pDevice->capture.intermediaryBufferLen = 0;
+            pDevice->capture.intermediaryBufferCap = intermediaryBufferCap;
+            if (pDevice->capture.intermediaryBufferCap == 0) {
+                pDevice->capture.intermediaryBufferCap = pDevice->capture.internalPeriodSizeInFrames;
+            }
+
+            intermediaryBufferSizeInBytes = pDevice->capture.intermediaryBufferCap * ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+
+            pDevice->capture.pIntermediaryBuffer = ma_malloc((size_t)intermediaryBufferSizeInBytes, &pContext->allocationCallbacks);
+            if (pDevice->capture.pIntermediaryBuffer == NULL) {
+                ma_device_uninit(pDevice);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            /* Silence the buffer for safety. */
+            ma_silence_pcm_frames(pDevice->capture.pIntermediaryBuffer, pDevice->capture.intermediaryBufferCap, pDevice->capture.format, pDevice->capture.channels);
+            pDevice->capture.intermediaryBufferLen = pDevice->capture.intermediaryBufferCap;
+        }
+
+        if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+            ma_uint64 intermediaryBufferSizeInBytes;
+
+            pDevice->playback.intermediaryBufferLen = 0;
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                pDevice->playback.intermediaryBufferCap = pDevice->capture.intermediaryBufferCap;   /* In duplex mode, make sure the intermediary buffer is always the same size as the capture side. */
+            } else {
+                pDevice->playback.intermediaryBufferCap = intermediaryBufferCap;
+                if (pDevice->playback.intermediaryBufferCap == 0) {
+                    pDevice->playback.intermediaryBufferCap = pDevice->playback.internalPeriodSizeInFrames;
+                }
+            }
+
+            intermediaryBufferSizeInBytes = pDevice->playback.intermediaryBufferCap * ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+
+            pDevice->playback.pIntermediaryBuffer = ma_malloc((size_t)intermediaryBufferSizeInBytes, &pContext->allocationCallbacks);
+            if (pDevice->playback.pIntermediaryBuffer == NULL) {
+                ma_device_uninit(pDevice);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            /* Silence the buffer for safety. */
+            ma_silence_pcm_frames(pDevice->playback.pIntermediaryBuffer, pDevice->playback.intermediaryBufferCap, pDevice->playback.format, pDevice->playback.channels);
+            pDevice->playback.intermediaryBufferLen = 0;
+        }
+    } else {
+        /* Not using a fixed sized data callback so no need for an intermediary buffer. */
+    }
+
+
+    /* Some backends don't require the worker thread. */
+    if (!ma_context_is_backend_asynchronous(pContext)) {
+        /* The worker thread. */
+        result = ma_thread_create(&pDevice->thread, pContext->threadPriority, pContext->threadStackSize, ma_worker_thread, pDevice, &pContext->allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            ma_device_uninit(pDevice);
+            return result;
+        }
+
+        /* Wait for the worker thread to put the device into its stopped state for real. */
+        ma_event_wait(&pDevice->stopEvent);
+        MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_stopped);
+    } else {
+        /*
+        If the backend is asynchronous and the device is duplex, we'll need an intermediary ring buffer. Note that this needs to be done
+        after ma_device__post_init_setup().
+        */
+        if (ma_context_is_backend_asynchronous(pContext)) {
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                result = ma_duplex_rb_init(pDevice->capture.format, pDevice->capture.channels, pDevice->sampleRate, pDevice->capture.internalSampleRate, pDevice->capture.internalPeriodSizeInFrames, &pDevice->pContext->allocationCallbacks, &pDevice->duplexRB);
+                if (result != MA_SUCCESS) {
+                    ma_device_uninit(pDevice);
+                    return result;
+                }
+            }
+        }
+
+        ma_device__set_state(pDevice, ma_device_state_stopped);
+    }
+
+    /* Log device information. */
+    {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[%s]\n", ma_get_backend_name(pDevice->pContext->backend));
+        if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+            char name[MA_MAX_DEVICE_NAME_LENGTH + 1];
+            ma_device_get_name(pDevice, ma_device_type_capture, name, sizeof(name), NULL);
+
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "  %s (%s)\n", name, "Capture");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Format:      %s -> %s\n", ma_get_format_name(pDevice->capture.internalFormat), ma_get_format_name(pDevice->capture.format));
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Channels:    %d -> %d\n", pDevice->capture.internalChannels, pDevice->capture.channels);
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Sample Rate: %d -> %d\n", pDevice->capture.internalSampleRate, pDevice->sampleRate);
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Buffer Size: %d*%d (%d)\n", pDevice->capture.internalPeriodSizeInFrames, pDevice->capture.internalPeriods, (pDevice->capture.internalPeriodSizeInFrames * pDevice->capture.internalPeriods));
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Conversion:\n");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Pre Format Conversion:  %s\n", pDevice->capture.converter.hasPreFormatConversion  ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Post Format Conversion: %s\n", pDevice->capture.converter.hasPostFormatConversion ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Routing:        %s\n", pDevice->capture.converter.hasChannelConverter     ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Resampling:             %s\n", pDevice->capture.converter.hasResampler            ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Passthrough:            %s\n", pDevice->capture.converter.isPassthrough           ? "YES" : "NO");
+            {
+                char channelMapStr[1024];
+                ma_channel_map_to_string(pDevice->capture.internalChannelMap, pDevice->capture.internalChannels, channelMapStr, sizeof(channelMapStr));
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Map In:         {%s}\n", channelMapStr);
+
+                ma_channel_map_to_string(pDevice->capture.channelMap, pDevice->capture.channels, channelMapStr, sizeof(channelMapStr));
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Map Out:        {%s}\n", channelMapStr);
+            }
+        }
+        if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+            char name[MA_MAX_DEVICE_NAME_LENGTH + 1];
+            ma_device_get_name(pDevice, ma_device_type_playback, name, sizeof(name), NULL);
+
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "  %s (%s)\n", name, "Playback");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Format:      %s -> %s\n", ma_get_format_name(pDevice->playback.format), ma_get_format_name(pDevice->playback.internalFormat));
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Channels:    %d -> %d\n", pDevice->playback.channels, pDevice->playback.internalChannels);
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Sample Rate: %d -> %d\n", pDevice->sampleRate, pDevice->playback.internalSampleRate);
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Buffer Size: %d*%d (%d)\n", pDevice->playback.internalPeriodSizeInFrames, pDevice->playback.internalPeriods, (pDevice->playback.internalPeriodSizeInFrames * pDevice->playback.internalPeriods));
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Conversion:\n");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Pre Format Conversion:  %s\n", pDevice->playback.converter.hasPreFormatConversion  ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Post Format Conversion: %s\n", pDevice->playback.converter.hasPostFormatConversion ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Routing:        %s\n", pDevice->playback.converter.hasChannelConverter     ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Resampling:             %s\n", pDevice->playback.converter.hasResampler            ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Passthrough:            %s\n", pDevice->playback.converter.isPassthrough           ? "YES" : "NO");
+            {
+                char channelMapStr[1024];
+                ma_channel_map_to_string(pDevice->playback.channelMap, pDevice->playback.channels, channelMapStr, sizeof(channelMapStr));
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Map In:         {%s}\n", channelMapStr);
+
+                ma_channel_map_to_string(pDevice->playback.internalChannelMap, pDevice->playback.internalChannels, channelMapStr, sizeof(channelMapStr));
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Map Out:        {%s}\n", channelMapStr);
+            }
+        }
+    }
+
+    MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_stopped);
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_init_ex(const ma_backend backends[], ma_uint32 backendCount, const ma_context_config* pContextConfig, const ma_device_config* pConfig, ma_device* pDevice)
+{
+    ma_result result;
+    ma_context* pContext;
+    ma_backend defaultBackends[ma_backend_null+1];
+    ma_uint32 iBackend;
+    ma_backend* pBackendsToIterate;
+    ma_uint32 backendsToIterateCount;
+    ma_allocation_callbacks allocationCallbacks;
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pContextConfig != NULL) {
+        result = ma_allocation_callbacks_init_copy(&allocationCallbacks, &pContextConfig->allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    } else {
+        allocationCallbacks = ma_allocation_callbacks_init_default();
+    }
+
+    pContext = (ma_context*)ma_malloc(sizeof(*pContext), &allocationCallbacks);
+    if (pContext == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    for (iBackend = 0; iBackend <= ma_backend_null; ++iBackend) {
+        defaultBackends[iBackend] = (ma_backend)iBackend;
+    }
+
+    pBackendsToIterate = (ma_backend*)backends;
+    backendsToIterateCount = backendCount;
+    if (pBackendsToIterate == NULL) {
+        pBackendsToIterate = (ma_backend*)defaultBackends;
+        backendsToIterateCount = ma_countof(defaultBackends);
+    }
+
+    result = MA_NO_BACKEND;
+
+    for (iBackend = 0; iBackend < backendsToIterateCount; ++iBackend) {
+        /*
+        This is a hack for iOS. If the context config is null, there's a good chance the
+        `ma_device_init(NULL, &deviceConfig, pDevice);` pattern is being used. In this
+        case, set the session category based on the device type.
+        */
+    #if defined(MA_APPLE_MOBILE)
+        ma_context_config contextConfig;
+
+        if (pContextConfig == NULL) {
+            contextConfig = ma_context_config_init();
+            switch (pConfig->deviceType) {
+                case ma_device_type_duplex: {
+                    contextConfig.coreaudio.sessionCategory = ma_ios_session_category_play_and_record;
+                } break;
+                case ma_device_type_capture: {
+                    contextConfig.coreaudio.sessionCategory = ma_ios_session_category_record;
+                } break;
+                case ma_device_type_playback:
+                default: {
+                    contextConfig.coreaudio.sessionCategory = ma_ios_session_category_playback;
+                } break;
+            }
+
+            pContextConfig = &contextConfig;
+        }
+    #endif
+
+        result = ma_context_init(&pBackendsToIterate[iBackend], 1, pContextConfig, pContext);
+        if (result == MA_SUCCESS) {
+            result = ma_device_init(pContext, pConfig, pDevice);
+            if (result == MA_SUCCESS) {
+                break;  /* Success. */
+            } else {
+                ma_context_uninit(pContext);   /* Failure. */
+            }
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        ma_free(pContext, &allocationCallbacks);
+        return result;
+    }
+
+    pDevice->isOwnerOfContext = MA_TRUE;
+    return result;
+}
+
+MA_API void ma_device_uninit(ma_device* pDevice)
+{
+    if (!ma_device__is_initialized(pDevice)) {
+        return;
+    }
+
+    /*
+    It's possible for the miniaudio side of the device and the backend to not be in sync due to
+    system-level situations such as the computer being put into sleep mode and the backend not
+    notifying miniaudio of the fact the device has stopped. It's possible for this to result in a
+    deadlock due to miniaudio thinking the device is in a running state, when in fact it's not
+    running at all. For this reason I am no longer explicitly stopping the device. I don't think
+    this should affect anyone in practice since uninitializing the backend will naturally stop the
+    device anyway.
+    */
+    #if 0
+    {
+        /* Make sure the device is stopped first. The backends will probably handle this naturally, but I like to do it explicitly for my own sanity. */
+        if (ma_device_is_started(pDevice)) {
+            ma_device_stop(pDevice);
+        }
+    }
+    #endif
+
+    /* Putting the device into an uninitialized state will make the worker thread return. */
+    ma_device__set_state(pDevice, ma_device_state_uninitialized);
+
+    /* Wake up the worker thread and wait for it to properly terminate. */
+    if (!ma_context_is_backend_asynchronous(pDevice->pContext)) {
+        ma_event_signal(&pDevice->wakeupEvent);
+        ma_thread_wait(&pDevice->thread);
+    }
+
+    if (pDevice->pContext->callbacks.onDeviceUninit != NULL) {
+        pDevice->pContext->callbacks.onDeviceUninit(pDevice);
+    }
+
+
+    ma_event_uninit(&pDevice->stopEvent);
+    ma_event_uninit(&pDevice->startEvent);
+    ma_event_uninit(&pDevice->wakeupEvent);
+    ma_mutex_uninit(&pDevice->startStopLock);
+
+    if (ma_context_is_backend_asynchronous(pDevice->pContext)) {
+        if (pDevice->type == ma_device_type_duplex) {
+            ma_duplex_rb_uninit(&pDevice->duplexRB);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        ma_data_converter_uninit(&pDevice->capture.converter, &pDevice->pContext->allocationCallbacks);
+    }
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_data_converter_uninit(&pDevice->playback.converter, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->playback.pInputCache != NULL) {
+        ma_free(pDevice->playback.pInputCache, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->capture.pIntermediaryBuffer != NULL) {
+        ma_free(pDevice->capture.pIntermediaryBuffer, &pDevice->pContext->allocationCallbacks);
+    }
+    if (pDevice->playback.pIntermediaryBuffer != NULL) {
+        ma_free(pDevice->playback.pIntermediaryBuffer, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->isOwnerOfContext) {
+        ma_allocation_callbacks allocationCallbacks = pDevice->pContext->allocationCallbacks;
+
+        ma_context_uninit(pDevice->pContext);
+        ma_free(pDevice->pContext, &allocationCallbacks);
+    }
+
+    MA_ZERO_OBJECT(pDevice);
+}
+
+MA_API ma_context* ma_device_get_context(ma_device* pDevice)
+{
+    if (pDevice == NULL) {
+        return NULL;
+    }
+
+    return pDevice->pContext;
+}
+
+MA_API ma_log* ma_device_get_log(ma_device* pDevice)
+{
+    return ma_context_get_log(ma_device_get_context(pDevice));
+}
+
+MA_API ma_result ma_device_get_info(ma_device* pDevice, ma_device_type type, ma_device_info* pDeviceInfo)
+{
+    if (pDeviceInfo == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDeviceInfo);
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If the onDeviceGetInfo() callback is set, use that. Otherwise we'll fall back to ma_context_get_device_info(). */
+    if (pDevice->pContext->callbacks.onDeviceGetInfo != NULL) {
+        return pDevice->pContext->callbacks.onDeviceGetInfo(pDevice, type, pDeviceInfo);
+    }
+
+    /* Getting here means onDeviceGetInfo is not implemented so we need to fall back to an alternative. */
+    if (type == ma_device_type_playback) {
+        return ma_context_get_device_info(pDevice->pContext, type, pDevice->playback.pID, pDeviceInfo);
+    } else {
+        /*
+        Here we're getting the capture side, which is the branch we'll be entering for a loopback
+        device, since loopback is capturing. However, if the device is using the default device ID,
+        it won't get the correct information because it'll think we're asking for the default
+        capture device, where in fact for loopback we want the default *playback* device. We'll do
+        a bit of a hack here to make sure we get the correct info.
+        */
+        if (pDevice->type == ma_device_type_loopback && pDevice->capture.pID == NULL) {
+            type = ma_device_type_playback;
+        }
+
+        return ma_context_get_device_info(pDevice->pContext, type, pDevice->capture.pID, pDeviceInfo);
+    }
+}
+
+MA_API ma_result ma_device_get_name(ma_device* pDevice, ma_device_type type, char* pName, size_t nameCap, size_t* pLengthNotIncludingNullTerminator)
+{
+    ma_result result;
+    ma_device_info deviceInfo;
+
+    if (pLengthNotIncludingNullTerminator != NULL) {
+        *pLengthNotIncludingNullTerminator = 0;
+    }
+
+    if (pName != NULL && nameCap > 0) {
+        pName[0] = '\0';
+    }
+
+    result = ma_device_get_info(pDevice, type, &deviceInfo);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pName != NULL) {
+        ma_strncpy_s(pName, nameCap, deviceInfo.name, (size_t)-1);
+
+        /*
+        For safety, make sure the length is based on the truncated output string rather than the
+        source. Otherwise the caller might assume the output buffer contains more content than it
+        actually does.
+        */
+        if (pLengthNotIncludingNullTerminator != NULL) {
+            *pLengthNotIncludingNullTerminator = strlen(pName);
+        }
+    } else {
+        /* Name not specified. Just report the length of the source string. */
+        if (pLengthNotIncludingNullTerminator != NULL) {
+            *pLengthNotIncludingNullTerminator = strlen(deviceInfo.name);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_start(ma_device* pDevice)
+{
+    ma_result result;
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_device_get_state(pDevice) == ma_device_state_uninitialized) {
+        return MA_INVALID_OPERATION;    /* Not initialized. */
+    }
+
+    if (ma_device_get_state(pDevice) == ma_device_state_started) {
+        return MA_SUCCESS;  /* Already started. */
+    }
+
+    ma_mutex_lock(&pDevice->startStopLock);
+    {
+        /*
+        We need to check again if the device is in a started state because it's possible for one thread to have started the device
+        while another was waiting on the mutex.
+        */
+        if (ma_device_get_state(pDevice) == ma_device_state_started) {
+            ma_mutex_unlock(&pDevice->startStopLock);
+            return MA_SUCCESS;  /* Already started. */
+        }
+
+        /* Starting and stopping are wrapped in a mutex which means we can assert that the device is in a stopped or paused state. */
+        MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_stopped);
+
+        ma_device__set_state(pDevice, ma_device_state_starting);
+
+        /* Asynchronous backends need to be handled differently. */
+        if (ma_context_is_backend_asynchronous(pDevice->pContext)) {
+            if (pDevice->pContext->callbacks.onDeviceStart != NULL) {
+                result = pDevice->pContext->callbacks.onDeviceStart(pDevice);
+            } else {
+                result = MA_INVALID_OPERATION;
+            }
+
+            if (result == MA_SUCCESS) {
+                ma_device__set_state(pDevice, ma_device_state_started);
+                ma_device__on_notification_started(pDevice);
+            }
+        } else {
+            /*
+            Synchronous backends are started by signaling an event that's being waited on in the worker thread. We first wake up the
+            thread and then wait for the start event.
+            */
+            ma_event_signal(&pDevice->wakeupEvent);
+
+            /*
+            Wait for the worker thread to finish starting the device. Note that the worker thread will be the one who puts the device
+            into the started state. Don't call ma_device__set_state() here.
+            */
+            ma_event_wait(&pDevice->startEvent);
+            result = pDevice->workResult;
+        }
+
+        /* We changed the state from stopped to started, so if we failed, make sure we put the state back to stopped. */
+        if (result != MA_SUCCESS) {
+            ma_device__set_state(pDevice, ma_device_state_stopped);
+        }
+    }
+    ma_mutex_unlock(&pDevice->startStopLock);
+
+    return result;
+}
+
+MA_API ma_result ma_device_stop(ma_device* pDevice)
+{
+    ma_result result;
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_device_get_state(pDevice) == ma_device_state_uninitialized) {
+        return MA_INVALID_OPERATION;    /* Not initialized. */
+    }
+
+    if (ma_device_get_state(pDevice) == ma_device_state_stopped) {
+        return MA_SUCCESS;  /* Already stopped. */
+    }
+
+    ma_mutex_lock(&pDevice->startStopLock);
+    {
+        /*
+        We need to check again if the device is in a stopped state because it's possible for one thread to have stopped the device
+        while another was waiting on the mutex.
+        */
+        if (ma_device_get_state(pDevice) == ma_device_state_stopped) {
+            ma_mutex_unlock(&pDevice->startStopLock);
+            return MA_SUCCESS;  /* Already stopped. */
+        }
+
+        /* Starting and stopping are wrapped in a mutex which means we can assert that the device is in a started or paused state. */
+        MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_started);
+
+        ma_device__set_state(pDevice, ma_device_state_stopping);
+
+        /* Asynchronous backends need to be handled differently. */
+        if (ma_context_is_backend_asynchronous(pDevice->pContext)) {
+            /* Asynchronous backends must have a stop operation. */
+            if (pDevice->pContext->callbacks.onDeviceStop != NULL) {
+                result = pDevice->pContext->callbacks.onDeviceStop(pDevice);
+            } else {
+                result = MA_INVALID_OPERATION;
+            }
+
+            ma_device__set_state(pDevice, ma_device_state_stopped);
+        } else {
+            /*
+            Synchronous backends. The stop callback is always called from the worker thread. Do not call the stop callback here. If
+            the backend is implementing its own audio thread loop we'll need to wake it up if required. Note that we need to make
+            sure the state of the device is *not* playing right now, which it shouldn't be since we set it above. This is super
+            important though, so I'm asserting it here as well for extra safety in case we accidentally change something later.
+            */
+            MA_ASSERT(ma_device_get_state(pDevice) != ma_device_state_started);
+
+            if (pDevice->pContext->callbacks.onDeviceDataLoopWakeup != NULL) {
+                pDevice->pContext->callbacks.onDeviceDataLoopWakeup(pDevice);
+            }
+
+            /*
+            We need to wait for the worker thread to become available for work before returning. Note that the worker thread will be
+            the one who puts the device into the stopped state. Don't call ma_device__set_state() here.
+            */
+            ma_event_wait(&pDevice->stopEvent);
+            result = MA_SUCCESS;
+        }
+
+        /*
+        This is a safety measure to ensure the internal buffer has been cleared so any leftover
+        does not get played the next time the device starts. Ideally this should be drained by
+        the backend first.
+        */
+        pDevice->playback.intermediaryBufferLen = 0;
+        pDevice->playback.inputCacheConsumed    = 0;
+        pDevice->playback.inputCacheRemaining   = 0;
+    }
+    ma_mutex_unlock(&pDevice->startStopLock);
+
+    return result;
+}
+
+MA_API ma_bool32 ma_device_is_started(const ma_device* pDevice)
+{
+    return ma_device_get_state(pDevice) == ma_device_state_started;
+}
+
+MA_API ma_device_state ma_device_get_state(const ma_device* pDevice)
+{
+    if (pDevice == NULL) {
+        return ma_device_state_uninitialized;
+    }
+
+    return ma_atomic_device_state_get((ma_atomic_device_state*)&pDevice->state);   /* Naughty cast to get rid of a const warning. */
+}
+
+MA_API ma_result ma_device_set_master_volume(ma_device* pDevice, float volume)
+{
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (volume < 0.0f) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_float_set(&pDevice->masterVolumeFactor, volume);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_get_master_volume(ma_device* pDevice, float* pVolume)
+{
+    if (pVolume == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDevice == NULL) {
+        *pVolume = 0;
+        return MA_INVALID_ARGS;
+    }
+
+    *pVolume = ma_atomic_float_get(&pDevice->masterVolumeFactor);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_set_master_volume_db(ma_device* pDevice, float gainDB)
+{
+    if (gainDB > 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_device_set_master_volume(pDevice, ma_volume_db_to_linear(gainDB));
+}
+
+MA_API ma_result ma_device_get_master_volume_db(ma_device* pDevice, float* pGainDB)
+{
+    float factor;
+    ma_result result;
+
+    if (pGainDB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_device_get_master_volume(pDevice, &factor);
+    if (result != MA_SUCCESS) {
+        *pGainDB = 0;
+        return result;
+    }
+
+    *pGainDB = ma_volume_linear_to_db(factor);
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_device_handle_backend_data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
+{
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pOutput == NULL && pInput == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    There is an assert deeper in the code that checks that frameCount > 0. Since this is a public facing
+    API we'll need to check for that here. I've had reports that AAudio can sometimes post a frame count
+    of 0.
+    */
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDevice->type == ma_device_type_duplex) {
+        if (pInput != NULL) {
+            ma_device__handle_duplex_callback_capture(pDevice, frameCount, pInput, &pDevice->duplexRB.rb);
+        }
+
+        if (pOutput != NULL) {
+            ma_device__handle_duplex_callback_playback(pDevice, frameCount, pOutput, &pDevice->duplexRB.rb);
+        }
+    } else {
+        if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_loopback) {
+            if (pInput == NULL) {
+                return MA_INVALID_ARGS;
+            }
+
+            ma_device__send_frames_to_client(pDevice, frameCount, pInput);
+        }
+
+        if (pDevice->type == ma_device_type_playback) {
+            if (pOutput == NULL) {
+                return MA_INVALID_ARGS;
+            }
+
+            ma_device__read_frames_from_client(pDevice, frameCount, pOutput);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_calculate_buffer_size_in_frames_from_descriptor(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    if (pDescriptor == NULL) {
+        return 0;
+    }
+
+    /*
+    We must have a non-0 native sample rate, but some backends don't allow retrieval of this at the
+    time when the size of the buffer needs to be determined. In this case we need to just take a best
+    guess and move on. We'll try using the sample rate in pDescriptor first. If that's not set we'll
+    just fall back to MA_DEFAULT_SAMPLE_RATE.
+    */
+    if (nativeSampleRate == 0) {
+        nativeSampleRate = pDescriptor->sampleRate;
+    }
+    if (nativeSampleRate == 0) {
+        nativeSampleRate = MA_DEFAULT_SAMPLE_RATE;
+    }
+
+    MA_ASSERT(nativeSampleRate != 0);
+
+    if (pDescriptor->periodSizeInFrames == 0) {
+        if (pDescriptor->periodSizeInMilliseconds == 0) {
+            if (performanceProfile == ma_performance_profile_low_latency) {
+                return ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY, nativeSampleRate);
+            } else {
+                return ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE, nativeSampleRate);
+            }
+        } else {
+            return ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptor->periodSizeInMilliseconds, nativeSampleRate);
+        }
+    } else {
+        return pDescriptor->periodSizeInFrames;
+    }
+}
+#endif  /* MA_NO_DEVICE_IO */
+
+
+MA_API ma_uint32 ma_calculate_buffer_size_in_milliseconds_from_frames(ma_uint32 bufferSizeInFrames, ma_uint32 sampleRate)
+{
+    /* Prevent a division by zero. */
+    if (sampleRate == 0) {
+        return 0;
+    }
+
+    return (bufferSizeInFrames*1000 + (sampleRate - 1)) / sampleRate;
+}
+
+MA_API ma_uint32 ma_calculate_buffer_size_in_frames_from_milliseconds(ma_uint32 bufferSizeInMilliseconds, ma_uint32 sampleRate)
+{
+    /* Prevent a division by zero. */
+    if (sampleRate == 0) {
+        return 0;
+    }
+
+    return bufferSizeInMilliseconds*sampleRate / 1000;
+}
+
+MA_API void ma_copy_pcm_frames(void* dst, const void* src, ma_uint64 frameCount, ma_format format, ma_uint32 channels)
+{
+    if (dst == src) {
+        return; /* No-op. */
+    }
+
+    ma_copy_memory_64(dst, src, frameCount * ma_get_bytes_per_frame(format, channels));
+}
+
+MA_API void ma_silence_pcm_frames(void* p, ma_uint64 frameCount, ma_format format, ma_uint32 channels)
+{
+    if (format == ma_format_u8) {
+        ma_uint64 sampleCount = frameCount * channels;
+        ma_uint64 iSample;
+        for (iSample = 0; iSample < sampleCount; iSample += 1) {
+            ((ma_uint8*)p)[iSample] = 128;
+        }
+    } else {
+        ma_zero_memory_64(p, frameCount * ma_get_bytes_per_frame(format, channels));
+    }
+}
+
+MA_API void* ma_offset_pcm_frames_ptr(void* p, ma_uint64 offsetInFrames, ma_format format, ma_uint32 channels)
+{
+    return ma_offset_ptr(p, offsetInFrames * ma_get_bytes_per_frame(format, channels));
+}
+
+MA_API const void* ma_offset_pcm_frames_const_ptr(const void* p, ma_uint64 offsetInFrames, ma_format format, ma_uint32 channels)
+{
+    return ma_offset_ptr(p, offsetInFrames * ma_get_bytes_per_frame(format, channels));
+}
+
+
+MA_API void ma_clip_samples_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_u8(pSrc[iSample]);
+    }
+}
+
+MA_API void ma_clip_samples_s16(ma_int16* pDst, const ma_int32* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_s16(pSrc[iSample]);
+    }
+}
+
+MA_API void ma_clip_samples_s24(ma_uint8* pDst, const ma_int64* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        ma_int64 s = ma_clip_s24(pSrc[iSample]);
+        pDst[iSample*3 + 0] = (ma_uint8)((s & 0x000000FF) >>  0);
+        pDst[iSample*3 + 1] = (ma_uint8)((s & 0x0000FF00) >>  8);
+        pDst[iSample*3 + 2] = (ma_uint8)((s & 0x00FF0000) >> 16);
+    }
+}
+
+MA_API void ma_clip_samples_s32(ma_int32* pDst, const ma_int64* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_s32(pSrc[iSample]);
+    }
+}
+
+MA_API void ma_clip_samples_f32(float* pDst, const float* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_f32(pSrc[iSample]);
+    }
+}
+
+MA_API void ma_clip_pcm_frames(void* pDst, const void* pSrc, ma_uint64 frameCount, ma_format format, ma_uint32 channels)
+{
+    ma_uint64 sampleCount;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    sampleCount = frameCount * channels;
+
+    switch (format) {
+        case ma_format_u8:  ma_clip_samples_u8( (ma_uint8*)pDst, (const ma_int16*)pSrc, sampleCount); break;
+        case ma_format_s16: ma_clip_samples_s16((ma_int16*)pDst, (const ma_int32*)pSrc, sampleCount); break;
+        case ma_format_s24: ma_clip_samples_s24((ma_uint8*)pDst, (const ma_int64*)pSrc, sampleCount); break;
+        case ma_format_s32: ma_clip_samples_s32((ma_int32*)pDst, (const ma_int64*)pSrc, sampleCount); break;
+        case ma_format_f32: ma_clip_samples_f32((   float*)pDst, (const    float*)pSrc, sampleCount); break;
+
+        /* Do nothing if we don't know the format. We're including these here to silence a compiler warning about enums not being handled by the switch. */
+        case ma_format_unknown:
+        case ma_format_count:
+            break;
+    }
+}
+
+
+MA_API void ma_copy_and_apply_volume_factor_u8(ma_uint8* pSamplesOut, const ma_uint8* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamplesOut[iSample] = (ma_uint8)(pSamplesIn[iSample] * factor);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_factor_s16(ma_int16* pSamplesOut, const ma_int16* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamplesOut[iSample] = (ma_int16)(pSamplesIn[iSample] * factor);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_factor_s24(void* pSamplesOut, const void* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+    ma_uint8* pSamplesOut8;
+    ma_uint8* pSamplesIn8;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    pSamplesOut8 = (ma_uint8*)pSamplesOut;
+    pSamplesIn8  = (ma_uint8*)pSamplesIn;
+
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        ma_int32 sampleS32;
+
+        sampleS32 = (ma_int32)(((ma_uint32)(pSamplesIn8[iSample*3+0]) << 8) | ((ma_uint32)(pSamplesIn8[iSample*3+1]) << 16) | ((ma_uint32)(pSamplesIn8[iSample*3+2])) << 24);
+        sampleS32 = (ma_int32)(sampleS32 * factor);
+
+        pSamplesOut8[iSample*3+0] = (ma_uint8)(((ma_uint32)sampleS32 & 0x0000FF00) >>  8);
+        pSamplesOut8[iSample*3+1] = (ma_uint8)(((ma_uint32)sampleS32 & 0x00FF0000) >> 16);
+        pSamplesOut8[iSample*3+2] = (ma_uint8)(((ma_uint32)sampleS32 & 0xFF000000) >> 24);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_factor_s32(ma_int32* pSamplesOut, const ma_int32* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamplesOut[iSample] = (ma_int32)(pSamplesIn[iSample] * factor);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_factor_f32(float* pSamplesOut, const float* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    if (factor == 1) {
+        if (pSamplesOut == pSamplesIn) {
+            /* In place. No-op. */
+        } else {
+            /* Just a copy. */
+            for (iSample = 0; iSample < sampleCount; iSample += 1) {
+                pSamplesOut[iSample] = pSamplesIn[iSample];
+            }
+        }
+    } else {
+        for (iSample = 0; iSample < sampleCount; iSample += 1) {
+            pSamplesOut[iSample] = pSamplesIn[iSample] * factor;
+        }
+    }
+}
+
+MA_API void ma_apply_volume_factor_u8(ma_uint8* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_u8(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_apply_volume_factor_s16(ma_int16* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_s16(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_apply_volume_factor_s24(void* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_s24(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_apply_volume_factor_s32(ma_int32* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_s32(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_apply_volume_factor_f32(float* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_f32(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_u8(ma_uint8* pFramesOut, const ma_uint8* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_u8(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s16(ma_int16* pFramesOut, const ma_int16* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_s16(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s24(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_s24(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s32(ma_int32* pFramesOut, const ma_int32* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_s32(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_f32(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float factor)
+{
+    switch (format)
+    {
+    case ma_format_u8:  ma_copy_and_apply_volume_factor_pcm_frames_u8 ((ma_uint8*)pFramesOut, (const ma_uint8*)pFramesIn, frameCount, channels, factor); return;
+    case ma_format_s16: ma_copy_and_apply_volume_factor_pcm_frames_s16((ma_int16*)pFramesOut, (const ma_int16*)pFramesIn, frameCount, channels, factor); return;
+    case ma_format_s24: ma_copy_and_apply_volume_factor_pcm_frames_s24(           pFramesOut,                  pFramesIn, frameCount, channels, factor); return;
+    case ma_format_s32: ma_copy_and_apply_volume_factor_pcm_frames_s32((ma_int32*)pFramesOut, (const ma_int32*)pFramesIn, frameCount, channels, factor); return;
+    case ma_format_f32: ma_copy_and_apply_volume_factor_pcm_frames_f32(   (float*)pFramesOut,    (const float*)pFramesIn, frameCount, channels, factor); return;
+    default: return;    /* Do nothing. */
+    }
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_u8(ma_uint8* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_u8(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_s16(ma_int16* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_s16(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_s24(void* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_s24(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_s32(ma_int32* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_s32(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_f32(float* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_f32(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames(void* pFramesOut, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames(pFramesOut, pFramesOut, frameCount, format, channels, factor);
+}
+
+
+MA_API void ma_copy_and_apply_volume_factor_per_channel_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float* pChannelGains)
+{
+    ma_uint64 iFrame;
+
+    if (channels == 2) {
+        /* TODO: Do an optimized implementation for stereo and mono. Can do a SIMD optimized implementation as well. */
+    }
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            pFramesOut[iFrame * channels + iChannel] = pFramesIn[iFrame * channels + iChannel] * pChannelGains[iChannel];
+        }
+    }
+}
+
+
+
+static MA_INLINE ma_int16 ma_apply_volume_unclipped_u8(ma_int16 x, ma_int16 volume)
+{
+    return (ma_int16)(((ma_int32)x * (ma_int32)volume) >> 8);
+}
+
+static MA_INLINE ma_int32 ma_apply_volume_unclipped_s16(ma_int32 x, ma_int16 volume)
+{
+    return (ma_int32)((x * volume) >> 8);
+}
+
+static MA_INLINE ma_int64 ma_apply_volume_unclipped_s24(ma_int64 x, ma_int16 volume)
+{
+    return (ma_int64)((x * volume) >> 8);
+}
+
+static MA_INLINE ma_int64 ma_apply_volume_unclipped_s32(ma_int64 x, ma_int16 volume)
+{
+    return (ma_int64)((x * volume) >> 8);
+}
+
+static MA_INLINE float ma_apply_volume_unclipped_f32(float x, float volume)
+{
+    return x * volume;
+}
+
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+    ma_int16  volumeFixed;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    volumeFixed = ma_float_to_fixed_16(volume);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_u8(ma_apply_volume_unclipped_u8(pSrc[iSample], volumeFixed));
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s16(ma_int16* pDst, const ma_int32* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+    ma_int16  volumeFixed;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    volumeFixed = ma_float_to_fixed_16(volume);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_s16(ma_apply_volume_unclipped_s16(pSrc[iSample], volumeFixed));
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s24(ma_uint8* pDst, const ma_int64* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+    ma_int16  volumeFixed;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    volumeFixed = ma_float_to_fixed_16(volume);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        ma_int64 s = ma_clip_s24(ma_apply_volume_unclipped_s24(pSrc[iSample], volumeFixed));
+        pDst[iSample*3 + 0] = (ma_uint8)((s & 0x000000FF) >>  0);
+        pDst[iSample*3 + 1] = (ma_uint8)((s & 0x0000FF00) >>  8);
+        pDst[iSample*3 + 2] = (ma_uint8)((s & 0x00FF0000) >> 16);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s32(ma_int32* pDst, const ma_int64* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+    ma_int16  volumeFixed;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    volumeFixed = ma_float_to_fixed_16(volume);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_s32(ma_apply_volume_unclipped_s32(pSrc[iSample], volumeFixed));
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_f32(float* pDst, const float* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    /* For the f32 case we need to make sure this supports in-place processing where the input and output buffers are the same. */
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_f32(ma_apply_volume_unclipped_f32(pSrc[iSample], volume));
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_pcm_frames(void* pDst, const void* pSrc, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float volume)
+{
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    if (volume == 1) {
+        ma_clip_pcm_frames(pDst, pSrc, frameCount, format, channels);   /* Optimized case for volume = 1. */
+    } else if (volume == 0) {
+        ma_silence_pcm_frames(pDst, frameCount, format, channels);      /* Optimized case for volume = 0. */
+    } else {
+        ma_uint64 sampleCount = frameCount * channels;
+
+        switch (format) {
+            case ma_format_u8:  ma_copy_and_apply_volume_and_clip_samples_u8( (ma_uint8*)pDst, (const ma_int16*)pSrc, sampleCount, volume); break;
+            case ma_format_s16: ma_copy_and_apply_volume_and_clip_samples_s16((ma_int16*)pDst, (const ma_int32*)pSrc, sampleCount, volume); break;
+            case ma_format_s24: ma_copy_and_apply_volume_and_clip_samples_s24((ma_uint8*)pDst, (const ma_int64*)pSrc, sampleCount, volume); break;
+            case ma_format_s32: ma_copy_and_apply_volume_and_clip_samples_s32((ma_int32*)pDst, (const ma_int64*)pSrc, sampleCount, volume); break;
+            case ma_format_f32: ma_copy_and_apply_volume_and_clip_samples_f32((   float*)pDst, (const    float*)pSrc, sampleCount, volume); break;
+
+            /* Do nothing if we don't know the format. We're including these here to silence a compiler warning about enums not being handled by the switch. */
+            case ma_format_unknown:
+            case ma_format_count:
+                break;
+        }
+    }
+}
+
+
+
+MA_API float ma_volume_linear_to_db(float factor)
+{
+    return 20*ma_log10f(factor);
+}
+
+MA_API float ma_volume_db_to_linear(float gain)
+{
+    return ma_powf(10, gain/20.0f);
+}
+
+
+MA_API ma_result ma_mix_pcm_frames_f32(float* pDst, const float* pSrc, ma_uint64 frameCount, ma_uint32 channels, float volume)
+{
+    ma_uint64 iSample;
+    ma_uint64 sampleCount;
+
+    if (pDst == NULL || pSrc == NULL || channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (volume == 0) {
+        return MA_SUCCESS;  /* No changes if the volume is 0. */
+    }
+
+    sampleCount = frameCount * channels;
+
+    if (volume == 1) {
+        for (iSample = 0; iSample < sampleCount; iSample += 1) {
+            pDst[iSample] += pSrc[iSample];
+        }
+    } else {
+        for (iSample = 0; iSample < sampleCount; iSample += 1) {
+            pDst[iSample] += ma_apply_volume_unclipped_f32(pSrc[iSample], volume);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Format Conversion
+
+**************************************************************************************************************************************************************/
+
+static MA_INLINE ma_int16 ma_pcm_sample_f32_to_s16(float x)
+{
+    return (ma_int16)(x * 32767.0f);
+}
+
+static MA_INLINE ma_int16 ma_pcm_sample_u8_to_s16_no_scale(ma_uint8 x)
+{
+    return (ma_int16)((ma_int16)x - 128);
+}
+
+static MA_INLINE ma_int64 ma_pcm_sample_s24_to_s32_no_scale(const ma_uint8* x)
+{
+    return (ma_int64)(((ma_uint64)x[0] << 40) | ((ma_uint64)x[1] << 48) | ((ma_uint64)x[2] << 56)) >> 40;  /* Make sure the sign bits are maintained. */
+}
+
+static MA_INLINE void ma_pcm_sample_s32_to_s24_no_scale(ma_int64 x, ma_uint8* s24)
+{
+    s24[0] = (ma_uint8)((x & 0x000000FF) >>  0);
+    s24[1] = (ma_uint8)((x & 0x0000FF00) >>  8);
+    s24[2] = (ma_uint8)((x & 0x00FF0000) >> 16);
+}
+
+
+/* u8 */
+MA_API void ma_pcm_u8_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+    ma_copy_memory_64(dst, src, count * sizeof(ma_uint8));
+}
+
+
+static MA_INLINE void ma_pcm_u8_to_s16__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_int16 x = src_u8[i];
+        x = (ma_int16)(x - 128);
+        x = (ma_int16)(x << 8);
+        dst_s16[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_u8_to_s16__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s16__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_u8_to_s16__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_u8_to_s16__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_u8_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_u8_to_s16__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_u8_to_s16__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_u8_to_s16__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_u8_to_s16__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_u8_to_s24__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_s24 = (ma_uint8*)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_int16 x = src_u8[i];
+        x = (ma_int16)(x - 128);
+
+        dst_s24[i*3+0] = 0;
+        dst_s24[i*3+1] = 0;
+        dst_s24[i*3+2] = (ma_uint8)((ma_int8)x);
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_u8_to_s24__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s24__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_u8_to_s24__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_u8_to_s24__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_u8_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_u8_to_s24__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_u8_to_s24__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_u8_to_s24__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_u8_to_s24__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_u8_to_s32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_int32 x = src_u8[i];
+        x = x - 128;
+        x = x << 24;
+        dst_s32[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_u8_to_s32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_u8_to_s32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_u8_to_s32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_u8_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_u8_to_s32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_u8_to_s32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_u8_to_s32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_u8_to_s32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_u8_to_f32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    float* dst_f32 = (float*)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        float x = (float)src_u8[i];
+        x = x * 0.00784313725490196078f;    /* 0..255 to 0..2 */
+        x = x - 1;                          /* 0..2 to -1..1 */
+
+        dst_f32[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_u8_to_f32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_f32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_u8_to_f32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_u8_to_f32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_u8_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_u8_to_f32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_u8_to_f32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_u8_to_f32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_u8_to_f32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+static MA_INLINE void ma_pcm_interleave_u8__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_uint8** src_u8 = (const ma_uint8**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_u8[iFrame*channels + iChannel] = src_u8[iChannel][iFrame];
+        }
+    }
+}
+#else
+static MA_INLINE void ma_pcm_interleave_u8__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_uint8** src_u8 = (const ma_uint8**)src;
+
+    if (channels == 1) {
+        ma_copy_memory_64(dst, src[0], frameCount * sizeof(ma_uint8));
+    } else if (channels == 2) {
+        ma_uint64 iFrame;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            dst_u8[iFrame*2 + 0] = src_u8[0][iFrame];
+            dst_u8[iFrame*2 + 1] = src_u8[1][iFrame];
+        }
+    } else {
+        ma_uint64 iFrame;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_uint32 iChannel;
+            for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                dst_u8[iFrame*channels + iChannel] = src_u8[iChannel][iFrame];
+            }
+        }
+    }
+}
+#endif
+
+MA_API void ma_pcm_interleave_u8(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_u8__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_u8__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_deinterleave_u8__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8** dst_u8 = (ma_uint8**)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_u8[iChannel][iFrame] = src_u8[iFrame*channels + iChannel];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_deinterleave_u8__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_u8__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_u8(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_u8__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_u8__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+/* s16 */
+static MA_INLINE void ma_pcm_s16_to_u8__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int16 x = src_s16[i];
+            x = (ma_int16)(x >> 8);
+            x = (ma_int16)(x + 128);
+            dst_u8[i] = (ma_uint8)x;
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int16 x = src_s16[i];
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x80, 0x7F);
+            if ((x + dither) <= 0x7FFF) {
+                x = (ma_int16)(x + dither);
+            } else {
+                x = 0x7FFF;
+            }
+
+            x = (ma_int16)(x >> 8);
+            x = (ma_int16)(x + 128);
+            dst_u8[i] = (ma_uint8)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s16_to_u8__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_u8__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s16_to_u8__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s16_to_u8__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s16_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s16_to_u8__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s16_to_u8__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s16_to_u8__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s16_to_u8__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+MA_API void ma_pcm_s16_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+    ma_copy_memory_64(dst, src, count * sizeof(ma_int16));
+}
+
+
+static MA_INLINE void ma_pcm_s16_to_s24__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_s24 = (ma_uint8*)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        dst_s24[i*3+0] = 0;
+        dst_s24[i*3+1] = (ma_uint8)(src_s16[i] & 0xFF);
+        dst_s24[i*3+2] = (ma_uint8)(src_s16[i] >> 8);
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s16_to_s24__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s24__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s16_to_s24__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s16_to_s24__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s16_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s16_to_s24__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s16_to_s24__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s16_to_s24__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s16_to_s24__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s16_to_s32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        dst_s32[i] = (ma_int32)src_s16[i] << 16;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s16_to_s32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s16_to_s32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s16_to_s32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s16_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s16_to_s32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s16_to_s32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s16_to_s32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s16_to_s32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s16_to_f32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    float* dst_f32 = (float*)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        float x = (float)src_s16[i];
+
+#if 0
+        /* The accurate way. */
+        x = x + 32768.0f;                   /* -32768..32767 to 0..65535 */
+        x = x * 0.00003051804379339284f;    /* 0..65535 to 0..2 */
+        x = x - 1;                          /* 0..2 to -1..1 */
+#else
+        /* The fast way. */
+        x = x * 0.000030517578125f;         /* -32768..32767 to -1..0.999969482421875 */
+#endif
+
+        dst_f32[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s16_to_f32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_f32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s16_to_f32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s16_to_f32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s16_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s16_to_f32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s16_to_f32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s16_to_f32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s16_to_f32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_interleave_s16__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const ma_int16** src_s16 = (const ma_int16**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_s16[iFrame*channels + iChannel] = src_s16[iChannel][iFrame];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_interleave_s16__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_interleave_s16__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_interleave_s16(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_s16__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_s16__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_deinterleave_s16__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_int16** dst_s16 = (ma_int16**)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_s16[iChannel][iFrame] = src_s16[iFrame*channels + iChannel];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_deinterleave_s16__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_s16__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_s16(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_s16__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_s16__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+/* s24 */
+static MA_INLINE void ma_pcm_s24_to_u8__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_uint8* src_s24 = (const ma_uint8*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            dst_u8[i] = (ma_uint8)((ma_int8)src_s24[i*3 + 2] + 128);
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = (ma_int32)(((ma_uint32)(src_s24[i*3+0]) << 8) | ((ma_uint32)(src_s24[i*3+1]) << 16) | ((ma_uint32)(src_s24[i*3+2])) << 24);
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x800000, 0x7FFFFF);
+            if ((ma_int64)x + dither <= 0x7FFFFFFF) {
+                x = x + dither;
+            } else {
+                x = 0x7FFFFFFF;
+            }
+
+            x = x >> 24;
+            x = x + 128;
+            dst_u8[i] = (ma_uint8)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s24_to_u8__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_u8__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s24_to_u8__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s24_to_u8__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s24_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s24_to_u8__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s24_to_u8__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s24_to_u8__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s24_to_u8__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s24_to_s16__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const ma_uint8* src_s24 = (const ma_uint8*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_uint16 dst_lo =            ((ma_uint16)src_s24[i*3 + 1]);
+            ma_uint16 dst_hi = (ma_uint16)((ma_uint16)src_s24[i*3 + 2] << 8);
+            dst_s16[i] = (ma_int16)(dst_lo | dst_hi);
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = (ma_int32)(((ma_uint32)(src_s24[i*3+0]) << 8) | ((ma_uint32)(src_s24[i*3+1]) << 16) | ((ma_uint32)(src_s24[i*3+2])) << 24);
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x8000, 0x7FFF);
+            if ((ma_int64)x + dither <= 0x7FFFFFFF) {
+                x = x + dither;
+            } else {
+                x = 0x7FFFFFFF;
+            }
+
+            x = x >> 16;
+            dst_s16[i] = (ma_int16)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s24_to_s16__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s16__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s24_to_s16__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s24_to_s16__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s24_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s24_to_s16__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s24_to_s16__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s24_to_s16__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s24_to_s16__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+MA_API void ma_pcm_s24_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+
+    ma_copy_memory_64(dst, src, count * 3);
+}
+
+
+static MA_INLINE void ma_pcm_s24_to_s32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const ma_uint8* src_s24 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        dst_s32[i] = (ma_int32)(((ma_uint32)(src_s24[i*3+0]) << 8) | ((ma_uint32)(src_s24[i*3+1]) << 16) | ((ma_uint32)(src_s24[i*3+2])) << 24);
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s24_to_s32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s24_to_s32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s24_to_s32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s24_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s24_to_s32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s24_to_s32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s24_to_s32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s24_to_s32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s24_to_f32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    float* dst_f32 = (float*)dst;
+    const ma_uint8* src_s24 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        float x = (float)(((ma_int32)(((ma_uint32)(src_s24[i*3+0]) << 8) | ((ma_uint32)(src_s24[i*3+1]) << 16) | ((ma_uint32)(src_s24[i*3+2])) << 24)) >> 8);
+
+#if 0
+        /* The accurate way. */
+        x = x + 8388608.0f;                 /* -8388608..8388607 to 0..16777215 */
+        x = x * 0.00000011920929665621f;    /* 0..16777215 to 0..2 */
+        x = x - 1;                          /* 0..2 to -1..1 */
+#else
+        /* The fast way. */
+        x = x * 0.00000011920928955078125f; /* -8388608..8388607 to -1..0.999969482421875 */
+#endif
+
+        dst_f32[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s24_to_f32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_f32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s24_to_f32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s24_to_f32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s24_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s24_to_f32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s24_to_f32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s24_to_f32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s24_to_f32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_interleave_s24__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8* dst8 = (ma_uint8*)dst;
+    const ma_uint8** src8 = (const ma_uint8**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst8[iFrame*3*channels + iChannel*3 + 0] = src8[iChannel][iFrame*3 + 0];
+            dst8[iFrame*3*channels + iChannel*3 + 1] = src8[iChannel][iFrame*3 + 1];
+            dst8[iFrame*3*channels + iChannel*3 + 2] = src8[iChannel][iFrame*3 + 2];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_interleave_s24__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_interleave_s24__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_interleave_s24(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_s24__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_s24__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_deinterleave_s24__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8** dst8 = (ma_uint8**)dst;
+    const ma_uint8* src8 = (const ma_uint8*)src;
+
+    ma_uint32 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst8[iChannel][iFrame*3 + 0] = src8[iFrame*3*channels + iChannel*3 + 0];
+            dst8[iChannel][iFrame*3 + 1] = src8[iFrame*3*channels + iChannel*3 + 1];
+            dst8[iChannel][iFrame*3 + 2] = src8[iFrame*3*channels + iChannel*3 + 2];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_deinterleave_s24__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_s24__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_s24(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_s24__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_s24__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+
+/* s32 */
+static MA_INLINE void ma_pcm_s32_to_u8__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = src_s32[i];
+            x = x >> 24;
+            x = x + 128;
+            dst_u8[i] = (ma_uint8)x;
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = src_s32[i];
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x800000, 0x7FFFFF);
+            if ((ma_int64)x + dither <= 0x7FFFFFFF) {
+                x = x + dither;
+            } else {
+                x = 0x7FFFFFFF;
+            }
+
+            x = x >> 24;
+            x = x + 128;
+            dst_u8[i] = (ma_uint8)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s32_to_u8__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_u8__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s32_to_u8__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s32_to_u8__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s32_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s32_to_u8__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s32_to_u8__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s32_to_u8__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s32_to_u8__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s32_to_s16__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = src_s32[i];
+            x = x >> 16;
+            dst_s16[i] = (ma_int16)x;
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = src_s32[i];
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x8000, 0x7FFF);
+            if ((ma_int64)x + dither <= 0x7FFFFFFF) {
+                x = x + dither;
+            } else {
+                x = 0x7FFFFFFF;
+            }
+
+            x = x >> 16;
+            dst_s16[i] = (ma_int16)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s32_to_s16__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s16__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s32_to_s16__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s32_to_s16__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s32_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s32_to_s16__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s32_to_s16__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s32_to_s16__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s32_to_s16__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s32_to_s24__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_s24 = (ma_uint8*)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_uint32 x = (ma_uint32)src_s32[i];
+        dst_s24[i*3+0] = (ma_uint8)((x & 0x0000FF00) >>  8);
+        dst_s24[i*3+1] = (ma_uint8)((x & 0x00FF0000) >> 16);
+        dst_s24[i*3+2] = (ma_uint8)((x & 0xFF000000) >> 24);
+    }
+
+    (void)ditherMode;   /* No dithering for s32 -> s24. */
+}
+
+static MA_INLINE void ma_pcm_s32_to_s24__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s24__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s32_to_s24__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s32_to_s24__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s32_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s32_to_s24__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s32_to_s24__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s32_to_s24__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s32_to_s24__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+MA_API void ma_pcm_s32_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+
+    ma_copy_memory_64(dst, src, count * sizeof(ma_int32));
+}
+
+
+static MA_INLINE void ma_pcm_s32_to_f32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    float* dst_f32 = (float*)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        double x = src_s32[i];
+
+#if 0
+        x = x + 2147483648.0;
+        x = x * 0.0000000004656612873077392578125;
+        x = x - 1;
+#else
+        x = x / 2147483648.0;
+#endif
+
+        dst_f32[i] = (float)x;
+    }
+
+    (void)ditherMode;   /* No dithering for s32 -> f32. */
+}
+
+static MA_INLINE void ma_pcm_s32_to_f32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_f32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s32_to_f32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s32_to_f32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s32_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s32_to_f32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s32_to_f32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s32_to_f32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s32_to_f32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_interleave_s32__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const ma_int32** src_s32 = (const ma_int32**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_s32[iFrame*channels + iChannel] = src_s32[iChannel][iFrame];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_interleave_s32__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_interleave_s32__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_interleave_s32(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_s32__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_s32__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_deinterleave_s32__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_int32** dst_s32 = (ma_int32**)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_s32[iChannel][iFrame] = src_s32[iFrame*channels + iChannel];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_deinterleave_s32__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_s32__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_s32(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_s32__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_s32__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+/* f32 */
+static MA_INLINE void ma_pcm_f32_to_u8__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const float* src_f32 = (const float*)src;
+
+    float ditherMin = 0;
+    float ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -128;
+        ditherMax = 1.0f /  127;
+    }
+
+    for (i = 0; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+        x = x + 1;                                  /* -1..1 to 0..2 */
+        x = x * 127.5f;                             /* 0..2 to 0..255 */
+
+        dst_u8[i] = (ma_uint8)x;
+    }
+}
+
+static MA_INLINE void ma_pcm_f32_to_u8__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_u8__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_f32_to_u8__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_f32_to_u8__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_f32_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_f32_to_u8__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_f32_to_u8__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_f32_to_u8__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_f32_to_u8__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+static MA_INLINE void ma_pcm_f32_to_s16__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const float* src_f32 = (const float*)src;
+
+    float ditherMin = 0;
+    float ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -32768;
+        ditherMax = 1.0f /  32767;
+    }
+
+    for (i = 0; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+
+#if 0
+        /* The accurate way. */
+        x = x + 1;                                  /* -1..1 to 0..2 */
+        x = x * 32767.5f;                           /* 0..2 to 0..65535 */
+        x = x - 32768.0f;                           /* 0...65535 to -32768..32767 */
+#else
+        /* The fast way. */
+        x = x * 32767.0f;                           /* -1..1 to -32767..32767 */
+#endif
+
+        dst_s16[i] = (ma_int16)x;
+    }
+}
+#else
+static MA_INLINE void ma_pcm_f32_to_s16__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+    ma_uint64 i4;
+    ma_uint64 count4;
+
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const float* src_f32 = (const float*)src;
+
+    float ditherMin = 0;
+    float ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -32768;
+        ditherMax = 1.0f /  32767;
+    }
+
+    /* Unrolled. */
+    i = 0;
+    count4 = count >> 2;
+    for (i4 = 0; i4 < count4; i4 += 1) {
+        float d0 = ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        float d1 = ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        float d2 = ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        float d3 = ma_dither_f32(ditherMode, ditherMin, ditherMax);
+
+        float x0 = src_f32[i+0];
+        float x1 = src_f32[i+1];
+        float x2 = src_f32[i+2];
+        float x3 = src_f32[i+3];
+
+        x0 = x0 + d0;
+        x1 = x1 + d1;
+        x2 = x2 + d2;
+        x3 = x3 + d3;
+
+        x0 = ((x0 < -1) ? -1 : ((x0 > 1) ? 1 : x0));
+        x1 = ((x1 < -1) ? -1 : ((x1 > 1) ? 1 : x1));
+        x2 = ((x2 < -1) ? -1 : ((x2 > 1) ? 1 : x2));
+        x3 = ((x3 < -1) ? -1 : ((x3 > 1) ? 1 : x3));
+
+        x0 = x0 * 32767.0f;
+        x1 = x1 * 32767.0f;
+        x2 = x2 * 32767.0f;
+        x3 = x3 * 32767.0f;
+
+        dst_s16[i+0] = (ma_int16)x0;
+        dst_s16[i+1] = (ma_int16)x1;
+        dst_s16[i+2] = (ma_int16)x2;
+        dst_s16[i+3] = (ma_int16)x3;
+
+        i += 4;
+    }
+
+    /* Leftover. */
+    for (; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+        x = x * 32767.0f;                           /* -1..1 to -32767..32767 */
+
+        dst_s16[i] = (ma_int16)x;
+    }
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_f32_to_s16__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+    ma_uint64 i8;
+    ma_uint64 count8;
+    ma_int16* dst_s16;
+    const float* src_f32;
+    float ditherMin;
+    float ditherMax;
+
+    /* Both the input and output buffers need to be aligned to 16 bytes. */
+    if ((((ma_uintptr)dst & 15) != 0) || (((ma_uintptr)src & 15) != 0)) {
+        ma_pcm_f32_to_s16__optimized(dst, src, count, ditherMode);
+        return;
+    }
+
+    dst_s16 = (ma_int16*)dst;
+    src_f32 = (const float*)src;
+
+    ditherMin = 0;
+    ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -32768;
+        ditherMax = 1.0f /  32767;
+    }
+
+    i = 0;
+
+    /* SSE2. SSE allows us to output 8 s16's at a time which means our loop is unrolled 8 times. */
+    count8 = count >> 3;
+    for (i8 = 0; i8 < count8; i8 += 1) {
+        __m128 d0;
+        __m128 d1;
+        __m128 x0;
+        __m128 x1;
+
+        if (ditherMode == ma_dither_mode_none) {
+            d0 = _mm_set1_ps(0);
+            d1 = _mm_set1_ps(0);
+        } else if (ditherMode == ma_dither_mode_rectangle) {
+            d0 = _mm_set_ps(
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax)
+            );
+            d1 = _mm_set_ps(
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax)
+            );
+        } else {
+            d0 = _mm_set_ps(
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax)
+            );
+            d1 = _mm_set_ps(
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax)
+            );
+        }
+
+        x0 = *((__m128*)(src_f32 + i) + 0);
+        x1 = *((__m128*)(src_f32 + i) + 1);
+
+        x0 = _mm_add_ps(x0, d0);
+        x1 = _mm_add_ps(x1, d1);
+
+        x0 = _mm_mul_ps(x0, _mm_set1_ps(32767.0f));
+        x1 = _mm_mul_ps(x1, _mm_set1_ps(32767.0f));
+
+        _mm_stream_si128(((__m128i*)(dst_s16 + i)), _mm_packs_epi32(_mm_cvttps_epi32(x0), _mm_cvttps_epi32(x1)));
+
+        i += 8;
+    }
+
+
+    /* Leftover. */
+    for (; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+        x = x * 32767.0f;                           /* -1..1 to -32767..32767 */
+
+        dst_s16[i] = (ma_int16)x;
+    }
+}
+#endif  /* SSE2 */
+
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_f32_to_s16__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+    ma_uint64 i8;
+    ma_uint64 count8;
+    ma_int16* dst_s16;
+    const float* src_f32;
+    float ditherMin;
+    float ditherMax;
+
+    if (!ma_has_neon()) {
+        ma_pcm_f32_to_s16__optimized(dst, src, count, ditherMode);
+        return;
+    }
+
+    /* Both the input and output buffers need to be aligned to 16 bytes. */
+    if ((((ma_uintptr)dst & 15) != 0) || (((ma_uintptr)src & 15) != 0)) {
+        ma_pcm_f32_to_s16__optimized(dst, src, count, ditherMode);
+        return;
+    }
+
+    dst_s16 = (ma_int16*)dst;
+    src_f32 = (const float*)src;
+
+    ditherMin = 0;
+    ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -32768;
+        ditherMax = 1.0f /  32767;
+    }
+
+    i = 0;
+
+    /* NEON. NEON allows us to output 8 s16's at a time which means our loop is unrolled 8 times. */
+    count8 = count >> 3;
+    for (i8 = 0; i8 < count8; i8 += 1) {
+        float32x4_t d0;
+        float32x4_t d1;
+        float32x4_t x0;
+        float32x4_t x1;
+        int32x4_t i0;
+        int32x4_t i1;
+
+        if (ditherMode == ma_dither_mode_none) {
+            d0 = vmovq_n_f32(0);
+            d1 = vmovq_n_f32(0);
+        } else if (ditherMode == ma_dither_mode_rectangle) {
+            float d0v[4];
+            float d1v[4];
+
+            d0v[0] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d0v[1] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d0v[2] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d0v[3] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d0 = vld1q_f32(d0v);
+
+            d1v[0] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d1v[1] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d1v[2] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d1v[3] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d1 = vld1q_f32(d1v);
+        } else {
+            float d0v[4];
+            float d1v[4];
+
+            d0v[0] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d0v[1] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d0v[2] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d0v[3] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d0 = vld1q_f32(d0v);
+
+            d1v[0] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d1v[1] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d1v[2] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d1v[3] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d1 = vld1q_f32(d1v);
+        }
+
+        x0 = *((float32x4_t*)(src_f32 + i) + 0);
+        x1 = *((float32x4_t*)(src_f32 + i) + 1);
+
+        x0 = vaddq_f32(x0, d0);
+        x1 = vaddq_f32(x1, d1);
+
+        x0 = vmulq_n_f32(x0, 32767.0f);
+        x1 = vmulq_n_f32(x1, 32767.0f);
+
+        i0 = vcvtq_s32_f32(x0);
+        i1 = vcvtq_s32_f32(x1);
+        *((int16x8_t*)(dst_s16 + i)) = vcombine_s16(vqmovn_s32(i0), vqmovn_s32(i1));
+
+        i += 8;
+    }
+
+
+    /* Leftover. */
+    for (; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+        x = x * 32767.0f;                           /* -1..1 to -32767..32767 */
+
+        dst_s16[i] = (ma_int16)x;
+    }
+}
+#endif  /* Neon */
+#endif  /* MA_USE_REFERENCE_CONVERSION_APIS */
+
+MA_API void ma_pcm_f32_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_f32_to_s16__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_f32_to_s16__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_f32_to_s16__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_f32_to_s16__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_f32_to_s24__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_s24 = (ma_uint8*)dst;
+    const float* src_f32 = (const float*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_int32 r;
+        float x = src_f32[i];
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+
+#if 0
+        /* The accurate way. */
+        x = x + 1;                                  /* -1..1 to 0..2 */
+        x = x * 8388607.5f;                         /* 0..2 to 0..16777215 */
+        x = x - 8388608.0f;                         /* 0..16777215 to -8388608..8388607 */
+#else
+        /* The fast way. */
+        x = x * 8388607.0f;                         /* -1..1 to -8388607..8388607 */
+#endif
+
+        r = (ma_int32)x;
+        dst_s24[(i*3)+0] = (ma_uint8)((r & 0x0000FF) >>  0);
+        dst_s24[(i*3)+1] = (ma_uint8)((r & 0x00FF00) >>  8);
+        dst_s24[(i*3)+2] = (ma_uint8)((r & 0xFF0000) >> 16);
+    }
+
+    (void)ditherMode;   /* No dithering for f32 -> s24. */
+}
+
+static MA_INLINE void ma_pcm_f32_to_s24__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s24__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_f32_to_s24__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_f32_to_s24__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_f32_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_f32_to_s24__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_f32_to_s24__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_f32_to_s24__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_f32_to_s24__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_f32_to_s32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const float* src_f32 = (const float*)src;
+
+    ma_uint32 i;
+    for (i = 0; i < count; i += 1) {
+        double x = src_f32[i];
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+
+#if 0
+        /* The accurate way. */
+        x = x + 1;                                  /* -1..1 to 0..2 */
+        x = x * 2147483647.5;                       /* 0..2 to 0..4294967295 */
+        x = x - 2147483648.0;                       /* 0...4294967295 to -2147483648..2147483647 */
+#else
+        /* The fast way. */
+        x = x * 2147483647.0;                       /* -1..1 to -2147483647..2147483647 */
+#endif
+
+        dst_s32[i] = (ma_int32)x;
+    }
+
+    (void)ditherMode;   /* No dithering for f32 -> s32. */
+}
+
+static MA_INLINE void ma_pcm_f32_to_s32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_f32_to_s32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_f32_to_s32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_f32_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_f32_to_s32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_f32_to_s32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_f32_to_s32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_f32_to_s32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+MA_API void ma_pcm_f32_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+
+    ma_copy_memory_64(dst, src, count * sizeof(float));
+}
+
+
+static void ma_pcm_interleave_f32__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    float* dst_f32 = (float*)dst;
+    const float** src_f32 = (const float**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_f32[iFrame*channels + iChannel] = src_f32[iChannel][iFrame];
+        }
+    }
+}
+
+static void ma_pcm_interleave_f32__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_interleave_f32__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_interleave_f32(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_f32__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_f32__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static void ma_pcm_deinterleave_f32__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    float** dst_f32 = (float**)dst;
+    const float* src_f32 = (const float*)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_f32[iChannel][iFrame] = src_f32[iFrame*channels + iChannel];
+        }
+    }
+}
+
+static void ma_pcm_deinterleave_f32__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_f32__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_f32(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_f32__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_f32__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+MA_API void ma_pcm_convert(void* pOut, ma_format formatOut, const void* pIn, ma_format formatIn, ma_uint64 sampleCount, ma_dither_mode ditherMode)
+{
+    if (formatOut == formatIn) {
+        ma_copy_memory_64(pOut, pIn, sampleCount * ma_get_bytes_per_sample(formatOut));
+        return;
+    }
+
+    switch (formatIn)
+    {
+        case ma_format_u8:
+        {
+            switch (formatOut)
+            {
+                case ma_format_s16: ma_pcm_u8_to_s16(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s24: ma_pcm_u8_to_s24(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s32: ma_pcm_u8_to_s32(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_f32: ma_pcm_u8_to_f32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        case ma_format_s16:
+        {
+            switch (formatOut)
+            {
+                case ma_format_u8:  ma_pcm_s16_to_u8( pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s24: ma_pcm_s16_to_s24(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s32: ma_pcm_s16_to_s32(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_f32: ma_pcm_s16_to_f32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        case ma_format_s24:
+        {
+            switch (formatOut)
+            {
+                case ma_format_u8:  ma_pcm_s24_to_u8( pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s16: ma_pcm_s24_to_s16(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s32: ma_pcm_s24_to_s32(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_f32: ma_pcm_s24_to_f32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        case ma_format_s32:
+        {
+            switch (formatOut)
+            {
+                case ma_format_u8:  ma_pcm_s32_to_u8( pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s16: ma_pcm_s32_to_s16(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s24: ma_pcm_s32_to_s24(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_f32: ma_pcm_s32_to_f32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            switch (formatOut)
+            {
+                case ma_format_u8:  ma_pcm_f32_to_u8( pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s16: ma_pcm_f32_to_s16(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s24: ma_pcm_f32_to_s24(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s32: ma_pcm_f32_to_s32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        default: break;
+    }
+}
+
+MA_API void ma_convert_pcm_frames_format(void* pOut, ma_format formatOut, const void* pIn, ma_format formatIn, ma_uint64 frameCount, ma_uint32 channels, ma_dither_mode ditherMode)
+{
+    ma_pcm_convert(pOut, formatOut, pIn, formatIn, frameCount * channels, ditherMode);
+}
+
+MA_API void ma_deinterleave_pcm_frames(ma_format format, ma_uint32 channels, ma_uint64 frameCount, const void* pInterleavedPCMFrames, void** ppDeinterleavedPCMFrames)
+{
+    if (pInterleavedPCMFrames == NULL || ppDeinterleavedPCMFrames == NULL) {
+        return; /* Invalid args. */
+    }
+
+    /* For efficiency we do this per format. */
+    switch (format) {
+        case ma_format_s16:
+        {
+            const ma_int16* pSrcS16 = (const ma_int16*)pInterleavedPCMFrames;
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                    ma_int16* pDstS16 = (ma_int16*)ppDeinterleavedPCMFrames[iChannel];
+                    pDstS16[iPCMFrame] = pSrcS16[iPCMFrame*channels+iChannel];
+                }
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            const float* pSrcF32 = (const float*)pInterleavedPCMFrames;
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                    float* pDstF32 = (float*)ppDeinterleavedPCMFrames[iChannel];
+                    pDstF32[iPCMFrame] = pSrcF32[iPCMFrame*channels+iChannel];
+                }
+            }
+        } break;
+
+        default:
+        {
+            ma_uint32 sampleSizeInBytes = ma_get_bytes_per_sample(format);
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                          void* pDst = ma_offset_ptr(ppDeinterleavedPCMFrames[iChannel], iPCMFrame*sampleSizeInBytes);
+                    const void* pSrc = ma_offset_ptr(pInterleavedPCMFrames, (iPCMFrame*channels+iChannel)*sampleSizeInBytes);
+                    memcpy(pDst, pSrc, sampleSizeInBytes);
+                }
+            }
+        } break;
+    }
+}
+
+MA_API void ma_interleave_pcm_frames(ma_format format, ma_uint32 channels, ma_uint64 frameCount, const void** ppDeinterleavedPCMFrames, void* pInterleavedPCMFrames)
+{
+    switch (format)
+    {
+        case ma_format_s16:
+        {
+            ma_int16* pDstS16 = (ma_int16*)pInterleavedPCMFrames;
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                    const ma_int16* pSrcS16 = (const ma_int16*)ppDeinterleavedPCMFrames[iChannel];
+                    pDstS16[iPCMFrame*channels+iChannel] = pSrcS16[iPCMFrame];
+                }
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            float* pDstF32 = (float*)pInterleavedPCMFrames;
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                    const float* pSrcF32 = (const float*)ppDeinterleavedPCMFrames[iChannel];
+                    pDstF32[iPCMFrame*channels+iChannel] = pSrcF32[iPCMFrame];
+                }
+            }
+        } break;
+
+        default:
+        {
+            ma_uint32 sampleSizeInBytes = ma_get_bytes_per_sample(format);
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                          void* pDst = ma_offset_ptr(pInterleavedPCMFrames, (iPCMFrame*channels+iChannel)*sampleSizeInBytes);
+                    const void* pSrc = ma_offset_ptr(ppDeinterleavedPCMFrames[iChannel], iPCMFrame*sampleSizeInBytes);
+                    memcpy(pDst, pSrc, sampleSizeInBytes);
+                }
+            }
+        } break;
+    }
+}
+
+
+/**************************************************************************************************************************************************************
+
+Biquad Filter
+
+**************************************************************************************************************************************************************/
+#ifndef MA_BIQUAD_FIXED_POINT_SHIFT
+#define MA_BIQUAD_FIXED_POINT_SHIFT 14
+#endif
+
+static ma_int32 ma_biquad_float_to_fp(double x)
+{
+    return (ma_int32)(x * (1 << MA_BIQUAD_FIXED_POINT_SHIFT));
+}
+
+MA_API ma_biquad_config ma_biquad_config_init(ma_format format, ma_uint32 channels, double b0, double b1, double b2, double a0, double a1, double a2)
+{
+    ma_biquad_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.b0 = b0;
+    config.b1 = b1;
+    config.b2 = b2;
+    config.a0 = a0;
+    config.a1 = a1;
+    config.a2 = a2;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t r1Offset;
+    size_t r2Offset;
+} ma_biquad_heap_layout;
+
+static ma_result ma_biquad_get_heap_layout(const ma_biquad_config* pConfig, ma_biquad_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* R0 */
+    pHeapLayout->r1Offset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(ma_biquad_coefficient) * pConfig->channels;
+
+    /* R1 */
+    pHeapLayout->r2Offset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(ma_biquad_coefficient) * pConfig->channels;
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_biquad_get_heap_size(const ma_biquad_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_biquad_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_biquad_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_biquad_init_preallocated(const ma_biquad_config* pConfig, void* pHeap, ma_biquad* pBQ)
+{
+    ma_result result;
+    ma_biquad_heap_layout heapLayout;
+
+    if (pBQ == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pBQ);
+
+    result = ma_biquad_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pBQ->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pBQ->pR1 = (ma_biquad_coefficient*)ma_offset_ptr(pHeap, heapLayout.r1Offset);
+    pBQ->pR2 = (ma_biquad_coefficient*)ma_offset_ptr(pHeap, heapLayout.r2Offset);
+
+    return ma_biquad_reinit(pConfig, pBQ);
+}
+
+MA_API ma_result ma_biquad_init(const ma_biquad_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_biquad* pBQ)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_biquad_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_biquad_init_preallocated(pConfig, pHeap, pBQ);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pBQ->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_biquad_uninit(ma_biquad* pBQ, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pBQ == NULL) {
+        return;
+    }
+
+    if (pBQ->_ownsHeap) {
+        ma_free(pBQ->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_biquad_reinit(const ma_biquad_config* pConfig, ma_biquad* pBQ)
+{
+    if (pBQ == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->a0 == 0) {
+        return MA_INVALID_ARGS; /* Division by zero. */
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pBQ->format != ma_format_unknown && pBQ->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pBQ->channels != 0 && pBQ->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+
+    pBQ->format   = pConfig->format;
+    pBQ->channels = pConfig->channels;
+
+    /* Normalize. */
+    if (pConfig->format == ma_format_f32) {
+        pBQ->b0.f32 = (float)(pConfig->b0 / pConfig->a0);
+        pBQ->b1.f32 = (float)(pConfig->b1 / pConfig->a0);
+        pBQ->b2.f32 = (float)(pConfig->b2 / pConfig->a0);
+        pBQ->a1.f32 = (float)(pConfig->a1 / pConfig->a0);
+        pBQ->a2.f32 = (float)(pConfig->a2 / pConfig->a0);
+    } else {
+        pBQ->b0.s32 = ma_biquad_float_to_fp(pConfig->b0 / pConfig->a0);
+        pBQ->b1.s32 = ma_biquad_float_to_fp(pConfig->b1 / pConfig->a0);
+        pBQ->b2.s32 = ma_biquad_float_to_fp(pConfig->b2 / pConfig->a0);
+        pBQ->a1.s32 = ma_biquad_float_to_fp(pConfig->a1 / pConfig->a0);
+        pBQ->a2.s32 = ma_biquad_float_to_fp(pConfig->a2 / pConfig->a0);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_biquad_clear_cache(ma_biquad* pBQ)
+{
+    if (pBQ == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pBQ->format == ma_format_f32) {
+        pBQ->pR1->f32 = 0;
+        pBQ->pR2->f32 = 0;
+    } else {
+        pBQ->pR1->s32 = 0;
+        pBQ->pR2->s32 = 0;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_biquad_process_pcm_frame_f32__direct_form_2_transposed(ma_biquad* pBQ, float* pY, const float* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pBQ->channels;
+    const float b0 = pBQ->b0.f32;
+    const float b1 = pBQ->b1.f32;
+    const float b2 = pBQ->b2.f32;
+    const float a1 = pBQ->a1.f32;
+    const float a2 = pBQ->a2.f32;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        float r1 = pBQ->pR1[c].f32;
+        float r2 = pBQ->pR2[c].f32;
+        float x  = pX[c];
+        float y;
+
+        y  = b0*x        + r1;
+        r1 = b1*x - a1*y + r2;
+        r2 = b2*x - a2*y;
+
+        pY[c]           = y;
+        pBQ->pR1[c].f32 = r1;
+        pBQ->pR2[c].f32 = r2;
+    }
+}
+
+static MA_INLINE void ma_biquad_process_pcm_frame_f32(ma_biquad* pBQ, float* pY, const float* pX)
+{
+    ma_biquad_process_pcm_frame_f32__direct_form_2_transposed(pBQ, pY, pX);
+}
+
+static MA_INLINE void ma_biquad_process_pcm_frame_s16__direct_form_2_transposed(ma_biquad* pBQ, ma_int16* pY, const ma_int16* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pBQ->channels;
+    const ma_int32 b0 = pBQ->b0.s32;
+    const ma_int32 b1 = pBQ->b1.s32;
+    const ma_int32 b2 = pBQ->b2.s32;
+    const ma_int32 a1 = pBQ->a1.s32;
+    const ma_int32 a2 = pBQ->a2.s32;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        ma_int32 r1 = pBQ->pR1[c].s32;
+        ma_int32 r2 = pBQ->pR2[c].s32;
+        ma_int32 x  = pX[c];
+        ma_int32 y;
+
+        y  = (b0*x        + r1) >> MA_BIQUAD_FIXED_POINT_SHIFT;
+        r1 = (b1*x - a1*y + r2);
+        r2 = (b2*x - a2*y);
+
+        pY[c]           = (ma_int16)ma_clamp(y, -32768, 32767);
+        pBQ->pR1[c].s32 = r1;
+        pBQ->pR2[c].s32 = r2;
+    }
+}
+
+static MA_INLINE void ma_biquad_process_pcm_frame_s16(ma_biquad* pBQ, ma_int16* pY, const ma_int16* pX)
+{
+    ma_biquad_process_pcm_frame_s16__direct_form_2_transposed(pBQ, pY, pX);
+}
+
+MA_API ma_result ma_biquad_process_pcm_frames(ma_biquad* pBQ, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint32 n;
+
+    if (pBQ == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Note that the logic below needs to support in-place filtering. That is, it must support the case where pFramesOut and pFramesIn are the same. */
+
+    if (pBQ->format == ma_format_f32) {
+        /* */ float* pY = (      float*)pFramesOut;
+        const float* pX = (const float*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_biquad_process_pcm_frame_f32__direct_form_2_transposed(pBQ, pY, pX);
+            pY += pBQ->channels;
+            pX += pBQ->channels;
+        }
+    } else if (pBQ->format == ma_format_s16) {
+        /* */ ma_int16* pY = (      ma_int16*)pFramesOut;
+        const ma_int16* pX = (const ma_int16*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_biquad_process_pcm_frame_s16__direct_form_2_transposed(pBQ, pY, pX);
+            pY += pBQ->channels;
+            pX += pBQ->channels;
+        }
+    } else {
+        MA_ASSERT(MA_FALSE);
+        return MA_INVALID_ARGS; /* Format not supported. Should never hit this because it's checked in ma_biquad_init() and ma_biquad_reinit(). */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_biquad_get_latency(const ma_biquad* pBQ)
+{
+    if (pBQ == NULL) {
+        return 0;
+    }
+
+    return 2;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Low-Pass Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_lpf1_config ma_lpf1_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency)
+{
+    ma_lpf1_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.q = 0.5;
+
+    return config;
+}
+
+MA_API ma_lpf2_config ma_lpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q)
+{
+    ma_lpf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.q = q;
+
+    /* Q cannot be 0 or else it'll result in a division by 0. In this case just default to 0.707107. */
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t r1Offset;
+} ma_lpf1_heap_layout;
+
+static ma_result ma_lpf1_get_heap_layout(const ma_lpf1_config* pConfig, ma_lpf1_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* R1 */
+    pHeapLayout->r1Offset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(ma_biquad_coefficient) * pConfig->channels;
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf1_get_heap_size(const ma_lpf1_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_lpf1_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_lpf1_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf1_init_preallocated(const ma_lpf1_config* pConfig, void* pHeap, ma_lpf1* pLPF)
+{
+    ma_result result;
+    ma_lpf1_heap_layout heapLayout;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    result = ma_lpf1_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pLPF->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pLPF->pR1 = (ma_biquad_coefficient*)ma_offset_ptr(pHeap, heapLayout.r1Offset);
+
+    return ma_lpf1_reinit(pConfig, pLPF);
+}
+
+MA_API ma_result ma_lpf1_init(const ma_lpf1_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf1* pLPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_lpf1_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_lpf1_init_preallocated(pConfig, pHeap, pLPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pLPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_lpf1_uninit(ma_lpf1* pLPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pLPF == NULL) {
+        return;
+    }
+
+    if (pLPF->_ownsHeap) {
+        ma_free(pLPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_lpf1_reinit(const ma_lpf1_config* pConfig, ma_lpf1* pLPF)
+{
+    double a;
+
+    if (pLPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pLPF->format != ma_format_unknown && pLPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pLPF->channels != 0 && pLPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    pLPF->format   = pConfig->format;
+    pLPF->channels = pConfig->channels;
+
+    a = ma_expd(-2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate);
+    if (pConfig->format == ma_format_f32) {
+        pLPF->a.f32 = (float)a;
+    } else {
+        pLPF->a.s32 = ma_biquad_float_to_fp(a);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf1_clear_cache(ma_lpf1* pLPF)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pLPF->format == ma_format_f32) {
+        pLPF->a.f32 = 0;
+    } else {
+        pLPF->a.s32 = 0;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_lpf1_process_pcm_frame_f32(ma_lpf1* pLPF, float* pY, const float* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pLPF->channels;
+    const float a = pLPF->a.f32;
+    const float b = 1 - a;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        float r1 = pLPF->pR1[c].f32;
+        float x  = pX[c];
+        float y;
+
+        y = b*x + a*r1;
+
+        pY[c]           = y;
+        pLPF->pR1[c].f32 = y;
+    }
+}
+
+static MA_INLINE void ma_lpf1_process_pcm_frame_s16(ma_lpf1* pLPF, ma_int16* pY, const ma_int16* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pLPF->channels;
+    const ma_int32 a = pLPF->a.s32;
+    const ma_int32 b = ((1 << MA_BIQUAD_FIXED_POINT_SHIFT) - a);
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        ma_int32 r1 = pLPF->pR1[c].s32;
+        ma_int32 x  = pX[c];
+        ma_int32 y;
+
+        y = (b*x + a*r1) >> MA_BIQUAD_FIXED_POINT_SHIFT;
+
+        pY[c]            = (ma_int16)y;
+        pLPF->pR1[c].s32 = (ma_int32)y;
+    }
+}
+
+MA_API ma_result ma_lpf1_process_pcm_frames(ma_lpf1* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint32 n;
+
+    if (pLPF == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Note that the logic below needs to support in-place filtering. That is, it must support the case where pFramesOut and pFramesIn are the same. */
+
+    if (pLPF->format == ma_format_f32) {
+        /* */ float* pY = (      float*)pFramesOut;
+        const float* pX = (const float*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_lpf1_process_pcm_frame_f32(pLPF, pY, pX);
+            pY += pLPF->channels;
+            pX += pLPF->channels;
+        }
+    } else if (pLPF->format == ma_format_s16) {
+        /* */ ma_int16* pY = (      ma_int16*)pFramesOut;
+        const ma_int16* pX = (const ma_int16*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_lpf1_process_pcm_frame_s16(pLPF, pY, pX);
+            pY += pLPF->channels;
+            pX += pLPF->channels;
+        }
+    } else {
+        MA_ASSERT(MA_FALSE);
+        return MA_INVALID_ARGS; /* Format not supported. Should never hit this because it's checked in ma_biquad_init() and ma_biquad_reinit(). */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_lpf1_get_latency(const ma_lpf1* pLPF)
+{
+    if (pLPF == NULL) {
+        return 0;
+    }
+
+    return 1;
+}
+
+
+static MA_INLINE ma_biquad_config ma_lpf2__get_biquad_config(const ma_lpf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+
+    bqConfig.b0 = (1 - c) / 2;
+    bqConfig.b1 =  1 - c;
+    bqConfig.b2 = (1 - c) / 2;
+    bqConfig.a0 =  1 + a;
+    bqConfig.a1 = -2 * c;
+    bqConfig.a2 =  1 - a;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_lpf2_get_heap_size(const ma_lpf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_lpf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_lpf2_init_preallocated(const ma_lpf2_config* pConfig, void* pHeap, ma_lpf2* pLPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_lpf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pLPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf2_init(const ma_lpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf2* pLPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_lpf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_lpf2_init_preallocated(pConfig, pHeap, pLPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pLPF->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_lpf2_uninit(ma_lpf2* pLPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pLPF == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pLPF->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_lpf2_reinit(const ma_lpf2_config* pConfig, ma_lpf2* pLPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pLPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_lpf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pLPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf2_clear_cache(ma_lpf2* pLPF)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_biquad_clear_cache(&pLPF->bq);
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_lpf2_process_pcm_frame_s16(ma_lpf2* pLPF, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pLPF->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_lpf2_process_pcm_frame_f32(ma_lpf2* pLPF, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pLPF->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_lpf2_process_pcm_frames(ma_lpf2* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pLPF->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_lpf2_get_latency(const ma_lpf2* pLPF)
+{
+    if (pLPF == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pLPF->bq);
+}
+
+
+MA_API ma_lpf_config ma_lpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_lpf_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format          = format;
+    config.channels        = channels;
+    config.sampleRate      = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.order           = ma_min(order, MA_MAX_FILTER_ORDER);
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t lpf1Offset;
+    size_t lpf2Offset;  /* Offset of the first second order filter. Subsequent filters will come straight after, and will each have the same heap size. */
+} ma_lpf_heap_layout;
+
+static void ma_lpf_calculate_sub_lpf_counts(ma_uint32 order, ma_uint32* pLPF1Count, ma_uint32* pLPF2Count)
+{
+    MA_ASSERT(pLPF1Count != NULL);
+    MA_ASSERT(pLPF2Count != NULL);
+
+    *pLPF1Count = order % 2;
+    *pLPF2Count = order / 2;
+}
+
+static ma_result ma_lpf_get_heap_layout(const ma_lpf_config* pConfig, ma_lpf_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    ma_uint32 lpf1Count;
+    ma_uint32 lpf2Count;
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_lpf_calculate_sub_lpf_counts(pConfig->order, &lpf1Count, &lpf2Count);
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* LPF 1 */
+    pHeapLayout->lpf1Offset = pHeapLayout->sizeInBytes;
+    for (ilpf1 = 0; ilpf1 < lpf1Count; ilpf1 += 1) {
+        size_t lpf1HeapSizeInBytes;
+        ma_lpf1_config lpf1Config = ma_lpf1_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency);
+
+        result = ma_lpf1_get_heap_size(&lpf1Config, &lpf1HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_lpf1) + lpf1HeapSizeInBytes;
+    }
+
+    /* LPF 2*/
+    pHeapLayout->lpf2Offset = pHeapLayout->sizeInBytes;
+    for (ilpf2 = 0; ilpf2 < lpf2Count; ilpf2 += 1) {
+        size_t lpf2HeapSizeInBytes;
+        ma_lpf2_config lpf2Config = ma_lpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, 0.707107);   /* <-- The "q" parameter does not matter for the purpose of calculating the heap size. */
+
+        result = ma_lpf2_get_heap_size(&lpf2Config, &lpf2HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_lpf2) + lpf2HeapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_lpf_reinit__internal(const ma_lpf_config* pConfig, void* pHeap, ma_lpf* pLPF, ma_bool32 isNew)
+{
+    ma_result result;
+    ma_uint32 lpf1Count;
+    ma_uint32 lpf2Count;
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+    ma_lpf_heap_layout heapLayout;  /* Only used if isNew is true. */
+
+    if (pLPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pLPF->format != ma_format_unknown && pLPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pLPF->channels != 0 && pLPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_lpf_calculate_sub_lpf_counts(pConfig->order, &lpf1Count, &lpf2Count);
+
+    /* The filter order can't change between reinits. */
+    if (!isNew) {
+        if (pLPF->lpf1Count != lpf1Count || pLPF->lpf2Count != lpf2Count) {
+            return MA_INVALID_OPERATION;
+        }
+    }
+
+    if (isNew) {
+        result = ma_lpf_get_heap_layout(pConfig, &heapLayout);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pLPF->_pHeap = pHeap;
+        MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+        pLPF->pLPF1 = (ma_lpf1*)ma_offset_ptr(pHeap, heapLayout.lpf1Offset);
+        pLPF->pLPF2 = (ma_lpf2*)ma_offset_ptr(pHeap, heapLayout.lpf2Offset);
+    } else {
+        MA_ZERO_OBJECT(&heapLayout);    /* To silence a compiler warning. */
+    }
+
+    for (ilpf1 = 0; ilpf1 < lpf1Count; ilpf1 += 1) {
+        ma_lpf1_config lpf1Config = ma_lpf1_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency);
+
+        if (isNew) {
+            size_t lpf1HeapSizeInBytes;
+
+            result = ma_lpf1_get_heap_size(&lpf1Config, &lpf1HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_lpf1_init_preallocated(&lpf1Config, ma_offset_ptr(pHeap, heapLayout.lpf1Offset + (sizeof(ma_lpf1) * lpf1Count) + (ilpf1 * lpf1HeapSizeInBytes)), &pLPF->pLPF1[ilpf1]);
+            }
+        } else {
+            result = ma_lpf1_reinit(&lpf1Config, &pLPF->pLPF1[ilpf1]);
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_uint32 jlpf1;
+
+            for (jlpf1 = 0; jlpf1 < ilpf1; jlpf1 += 1) {
+                ma_lpf1_uninit(&pLPF->pLPF1[jlpf1], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            return result;
+        }
+    }
+
+    for (ilpf2 = 0; ilpf2 < lpf2Count; ilpf2 += 1) {
+        ma_lpf2_config lpf2Config;
+        double q;
+        double a;
+
+        /* Tempting to use 0.707107, but won't result in a Butterworth filter if the order is > 2. */
+        if (lpf1Count == 1) {
+            a = (1 + ilpf2*1) * (MA_PI_D/(pConfig->order*1));   /* Odd order. */
+        } else {
+            a = (1 + ilpf2*2) * (MA_PI_D/(pConfig->order*2));   /* Even order. */
+        }
+        q = 1 / (2*ma_cosd(a));
+
+        lpf2Config = ma_lpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, q);
+
+        if (isNew) {
+            size_t lpf2HeapSizeInBytes;
+
+            result = ma_lpf2_get_heap_size(&lpf2Config, &lpf2HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_lpf2_init_preallocated(&lpf2Config, ma_offset_ptr(pHeap, heapLayout.lpf2Offset + (sizeof(ma_lpf2) * lpf2Count) + (ilpf2 * lpf2HeapSizeInBytes)), &pLPF->pLPF2[ilpf2]);
+            }
+        } else {
+            result = ma_lpf2_reinit(&lpf2Config, &pLPF->pLPF2[ilpf2]);
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_uint32 jlpf1;
+            ma_uint32 jlpf2;
+
+            for (jlpf1 = 0; jlpf1 < lpf1Count; jlpf1 += 1) {
+                ma_lpf1_uninit(&pLPF->pLPF1[jlpf1], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            for (jlpf2 = 0; jlpf2 < ilpf2; jlpf2 += 1) {
+                ma_lpf2_uninit(&pLPF->pLPF2[jlpf2], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            return result;
+        }
+    }
+
+    pLPF->lpf1Count  = lpf1Count;
+    pLPF->lpf2Count  = lpf2Count;
+    pLPF->format     = pConfig->format;
+    pLPF->channels   = pConfig->channels;
+    pLPF->sampleRate = pConfig->sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf_get_heap_size(const ma_lpf_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_lpf_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_lpf_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return result;
+}
+
+MA_API ma_result ma_lpf_init_preallocated(const ma_lpf_config* pConfig, void* pHeap, ma_lpf* pLPF)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    return ma_lpf_reinit__internal(pConfig, pHeap, pLPF, /*isNew*/MA_TRUE);
+}
+
+MA_API ma_result ma_lpf_init(const ma_lpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf* pLPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_lpf_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_lpf_init_preallocated(pConfig, pHeap, pLPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pLPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_lpf_uninit(ma_lpf* pLPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    if (pLPF == NULL) {
+        return;
+    }
+
+    for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+        ma_lpf1_uninit(&pLPF->pLPF1[ilpf1], pAllocationCallbacks);
+    }
+
+    for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+        ma_lpf2_uninit(&pLPF->pLPF2[ilpf2], pAllocationCallbacks);
+    }
+
+    if (pLPF->_ownsHeap) {
+        ma_free(pLPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_lpf_reinit(const ma_lpf_config* pConfig, ma_lpf* pLPF)
+{
+    return ma_lpf_reinit__internal(pConfig, NULL, pLPF, /*isNew*/MA_FALSE);
+}
+
+MA_API ma_result ma_lpf_clear_cache(ma_lpf* pLPF)
+{
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+        ma_lpf1_clear_cache(&pLPF->pLPF1[ilpf1]);
+    }
+
+    for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+        ma_lpf2_clear_cache(&pLPF->pLPF2[ilpf2]);
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_lpf_process_pcm_frame_f32(ma_lpf* pLPF, float* pY, const void* pX)
+{
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    MA_ASSERT(pLPF->format == ma_format_f32);
+
+    MA_MOVE_MEMORY(pY, pX, ma_get_bytes_per_frame(pLPF->format, pLPF->channels));
+
+    for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+        ma_lpf1_process_pcm_frame_f32(&pLPF->pLPF1[ilpf1], pY, pY);
+    }
+
+    for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+        ma_lpf2_process_pcm_frame_f32(&pLPF->pLPF2[ilpf2], pY, pY);
+    }
+}
+
+static MA_INLINE void ma_lpf_process_pcm_frame_s16(ma_lpf* pLPF, ma_int16* pY, const ma_int16* pX)
+{
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    MA_ASSERT(pLPF->format == ma_format_s16);
+
+    MA_MOVE_MEMORY(pY, pX, ma_get_bytes_per_frame(pLPF->format, pLPF->channels));
+
+    for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+        ma_lpf1_process_pcm_frame_s16(&pLPF->pLPF1[ilpf1], pY, pY);
+    }
+
+    for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+        ma_lpf2_process_pcm_frame_s16(&pLPF->pLPF2[ilpf2], pY, pY);
+    }
+}
+
+MA_API ma_result ma_lpf_process_pcm_frames(ma_lpf* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_result result;
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Faster path for in-place. */
+    if (pFramesOut == pFramesIn) {
+        for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+            result = ma_lpf1_process_pcm_frames(&pLPF->pLPF1[ilpf1], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+
+        for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+            result = ma_lpf2_process_pcm_frames(&pLPF->pLPF2[ilpf2], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+    }
+
+    /* Slightly slower path for copying. */
+    if (pFramesOut != pFramesIn) {
+        ma_uint32 iFrame;
+
+        /*  */ if (pLPF->format == ma_format_f32) {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_lpf_process_pcm_frame_f32(pLPF, pFramesOutF32, pFramesInF32);
+                pFramesOutF32 += pLPF->channels;
+                pFramesInF32  += pLPF->channels;
+            }
+        } else if (pLPF->format == ma_format_s16) {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_lpf_process_pcm_frame_s16(pLPF, pFramesOutS16, pFramesInS16);
+                pFramesOutS16 += pLPF->channels;
+                pFramesInS16  += pLPF->channels;
+            }
+        } else {
+            MA_ASSERT(MA_FALSE);
+            return MA_INVALID_OPERATION;    /* Should never hit this. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_lpf_get_latency(const ma_lpf* pLPF)
+{
+    if (pLPF == NULL) {
+        return 0;
+    }
+
+    return pLPF->lpf2Count*2 + pLPF->lpf1Count;
+}
+
+
+/**************************************************************************************************************************************************************
+
+High-Pass Filtering
+
+**************************************************************************************************************************************************************/
+MA_API ma_hpf1_config ma_hpf1_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency)
+{
+    ma_hpf1_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+
+    return config;
+}
+
+MA_API ma_hpf2_config ma_hpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q)
+{
+    ma_hpf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.q = q;
+
+    /* Q cannot be 0 or else it'll result in a division by 0. In this case just default to 0.707107. */
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t r1Offset;
+} ma_hpf1_heap_layout;
+
+static ma_result ma_hpf1_get_heap_layout(const ma_hpf1_config* pConfig, ma_hpf1_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* R1 */
+    pHeapLayout->r1Offset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(ma_biquad_coefficient) * pConfig->channels;
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hpf1_get_heap_size(const ma_hpf1_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_hpf1_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_hpf1_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hpf1_init_preallocated(const ma_hpf1_config* pConfig, void* pHeap, ma_hpf1* pLPF)
+{
+    ma_result result;
+    ma_hpf1_heap_layout heapLayout;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    result = ma_hpf1_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pLPF->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pLPF->pR1 = (ma_biquad_coefficient*)ma_offset_ptr(pHeap, heapLayout.r1Offset);
+
+    return ma_hpf1_reinit(pConfig, pLPF);
+}
+
+MA_API ma_result ma_hpf1_init(const ma_hpf1_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf1* pLPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_hpf1_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_hpf1_init_preallocated(pConfig, pHeap, pLPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pLPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_hpf1_uninit(ma_hpf1* pHPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pHPF == NULL) {
+        return;
+    }
+
+    if (pHPF->_ownsHeap) {
+        ma_free(pHPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_hpf1_reinit(const ma_hpf1_config* pConfig, ma_hpf1* pHPF)
+{
+    double a;
+
+    if (pHPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pHPF->format != ma_format_unknown && pHPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pHPF->channels != 0 && pHPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    pHPF->format   = pConfig->format;
+    pHPF->channels = pConfig->channels;
+
+    a = ma_expd(-2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate);
+    if (pConfig->format == ma_format_f32) {
+        pHPF->a.f32 = (float)a;
+    } else {
+        pHPF->a.s32 = ma_biquad_float_to_fp(a);
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_hpf1_process_pcm_frame_f32(ma_hpf1* pHPF, float* pY, const float* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pHPF->channels;
+    const float a = 1 - pHPF->a.f32;
+    const float b = 1 - a;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        float r1 = pHPF->pR1[c].f32;
+        float x  = pX[c];
+        float y;
+
+        y = b*x - a*r1;
+
+        pY[c]            = y;
+        pHPF->pR1[c].f32 = y;
+    }
+}
+
+static MA_INLINE void ma_hpf1_process_pcm_frame_s16(ma_hpf1* pHPF, ma_int16* pY, const ma_int16* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pHPF->channels;
+    const ma_int32 a = ((1 << MA_BIQUAD_FIXED_POINT_SHIFT) - pHPF->a.s32);
+    const ma_int32 b = ((1 << MA_BIQUAD_FIXED_POINT_SHIFT) - a);
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        ma_int32 r1 = pHPF->pR1[c].s32;
+        ma_int32 x  = pX[c];
+        ma_int32 y;
+
+        y = (b*x - a*r1) >> MA_BIQUAD_FIXED_POINT_SHIFT;
+
+        pY[c]            = (ma_int16)y;
+        pHPF->pR1[c].s32 = (ma_int32)y;
+    }
+}
+
+MA_API ma_result ma_hpf1_process_pcm_frames(ma_hpf1* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint32 n;
+
+    if (pHPF == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Note that the logic below needs to support in-place filtering. That is, it must support the case where pFramesOut and pFramesIn are the same. */
+
+    if (pHPF->format == ma_format_f32) {
+        /* */ float* pY = (      float*)pFramesOut;
+        const float* pX = (const float*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_hpf1_process_pcm_frame_f32(pHPF, pY, pX);
+            pY += pHPF->channels;
+            pX += pHPF->channels;
+        }
+    } else if (pHPF->format == ma_format_s16) {
+        /* */ ma_int16* pY = (      ma_int16*)pFramesOut;
+        const ma_int16* pX = (const ma_int16*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_hpf1_process_pcm_frame_s16(pHPF, pY, pX);
+            pY += pHPF->channels;
+            pX += pHPF->channels;
+        }
+    } else {
+        MA_ASSERT(MA_FALSE);
+        return MA_INVALID_ARGS; /* Format not supported. Should never hit this because it's checked in ma_biquad_init() and ma_biquad_reinit(). */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_hpf1_get_latency(const ma_hpf1* pHPF)
+{
+    if (pHPF == NULL) {
+        return 0;
+    }
+
+    return 1;
+}
+
+
+static MA_INLINE ma_biquad_config ma_hpf2__get_biquad_config(const ma_hpf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+
+    bqConfig.b0 =  (1 + c) / 2;
+    bqConfig.b1 = -(1 + c);
+    bqConfig.b2 =  (1 + c) / 2;
+    bqConfig.a0 =   1 + a;
+    bqConfig.a1 =  -2 * c;
+    bqConfig.a2 =   1 - a;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_hpf2_get_heap_size(const ma_hpf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_hpf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_hpf2_init_preallocated(const ma_hpf2_config* pConfig, void* pHeap, ma_hpf2* pHPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pHPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pHPF);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_hpf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pHPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hpf2_init(const ma_hpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf2* pHPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_hpf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_hpf2_init_preallocated(pConfig, pHeap, pHPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pHPF->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_hpf2_uninit(ma_hpf2* pHPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pHPF == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pHPF->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_hpf2_reinit(const ma_hpf2_config* pConfig, ma_hpf2* pHPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pHPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_hpf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pHPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_hpf2_process_pcm_frame_s16(ma_hpf2* pHPF, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pHPF->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_hpf2_process_pcm_frame_f32(ma_hpf2* pHPF, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pHPF->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_hpf2_process_pcm_frames(ma_hpf2* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pHPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pHPF->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_hpf2_get_latency(const ma_hpf2* pHPF)
+{
+    if (pHPF == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pHPF->bq);
+}
+
+
+MA_API ma_hpf_config ma_hpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_hpf_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format          = format;
+    config.channels        = channels;
+    config.sampleRate      = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.order           = ma_min(order, MA_MAX_FILTER_ORDER);
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t hpf1Offset;
+    size_t hpf2Offset;  /* Offset of the first second order filter. Subsequent filters will come straight after, and will each have the same heap size. */
+} ma_hpf_heap_layout;
+
+static void ma_hpf_calculate_sub_hpf_counts(ma_uint32 order, ma_uint32* pHPF1Count, ma_uint32* pHPF2Count)
+{
+    MA_ASSERT(pHPF1Count != NULL);
+    MA_ASSERT(pHPF2Count != NULL);
+
+    *pHPF1Count = order % 2;
+    *pHPF2Count = order / 2;
+}
+
+static ma_result ma_hpf_get_heap_layout(const ma_hpf_config* pConfig, ma_hpf_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    ma_uint32 hpf1Count;
+    ma_uint32 hpf2Count;
+    ma_uint32 ihpf1;
+    ma_uint32 ihpf2;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_hpf_calculate_sub_hpf_counts(pConfig->order, &hpf1Count, &hpf2Count);
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* HPF 1 */
+    pHeapLayout->hpf1Offset = pHeapLayout->sizeInBytes;
+    for (ihpf1 = 0; ihpf1 < hpf1Count; ihpf1 += 1) {
+        size_t hpf1HeapSizeInBytes;
+        ma_hpf1_config hpf1Config = ma_hpf1_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency);
+
+        result = ma_hpf1_get_heap_size(&hpf1Config, &hpf1HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_hpf1) + hpf1HeapSizeInBytes;
+    }
+
+    /* HPF 2*/
+    pHeapLayout->hpf2Offset = pHeapLayout->sizeInBytes;
+    for (ihpf2 = 0; ihpf2 < hpf2Count; ihpf2 += 1) {
+        size_t hpf2HeapSizeInBytes;
+        ma_hpf2_config hpf2Config = ma_hpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, 0.707107);   /* <-- The "q" parameter does not matter for the purpose of calculating the heap size. */
+
+        result = ma_hpf2_get_heap_size(&hpf2Config, &hpf2HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_hpf2) + hpf2HeapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_hpf_reinit__internal(const ma_hpf_config* pConfig, void* pHeap, ma_hpf* pHPF, ma_bool32 isNew)
+{
+    ma_result result;
+    ma_uint32 hpf1Count;
+    ma_uint32 hpf2Count;
+    ma_uint32 ihpf1;
+    ma_uint32 ihpf2;
+    ma_hpf_heap_layout heapLayout;  /* Only used if isNew is true. */
+
+    if (pHPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pHPF->format != ma_format_unknown && pHPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pHPF->channels != 0 && pHPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_hpf_calculate_sub_hpf_counts(pConfig->order, &hpf1Count, &hpf2Count);
+
+    /* The filter order can't change between reinits. */
+    if (!isNew) {
+        if (pHPF->hpf1Count != hpf1Count || pHPF->hpf2Count != hpf2Count) {
+            return MA_INVALID_OPERATION;
+        }
+    }
+
+    if (isNew) {
+        result = ma_hpf_get_heap_layout(pConfig, &heapLayout);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHPF->_pHeap = pHeap;
+        MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+        pHPF->pHPF1 = (ma_hpf1*)ma_offset_ptr(pHeap, heapLayout.hpf1Offset);
+        pHPF->pHPF2 = (ma_hpf2*)ma_offset_ptr(pHeap, heapLayout.hpf2Offset);
+    } else {
+        MA_ZERO_OBJECT(&heapLayout);    /* To silence a compiler warning. */
+    }
+
+    for (ihpf1 = 0; ihpf1 < hpf1Count; ihpf1 += 1) {
+        ma_hpf1_config hpf1Config = ma_hpf1_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency);
+
+        if (isNew) {
+            size_t hpf1HeapSizeInBytes;
+
+            result = ma_hpf1_get_heap_size(&hpf1Config, &hpf1HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_hpf1_init_preallocated(&hpf1Config, ma_offset_ptr(pHeap, heapLayout.hpf1Offset + (sizeof(ma_hpf1) * hpf1Count) + (ihpf1 * hpf1HeapSizeInBytes)), &pHPF->pHPF1[ihpf1]);
+            }
+        } else {
+            result = ma_hpf1_reinit(&hpf1Config, &pHPF->pHPF1[ihpf1]);
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_uint32 jhpf1;
+
+            for (jhpf1 = 0; jhpf1 < ihpf1; jhpf1 += 1) {
+                ma_hpf1_uninit(&pHPF->pHPF1[jhpf1], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            return result;
+        }
+    }
+
+    for (ihpf2 = 0; ihpf2 < hpf2Count; ihpf2 += 1) {
+        ma_hpf2_config hpf2Config;
+        double q;
+        double a;
+
+        /* Tempting to use 0.707107, but won't result in a Butterworth filter if the order is > 2. */
+        if (hpf1Count == 1) {
+            a = (1 + ihpf2*1) * (MA_PI_D/(pConfig->order*1));   /* Odd order. */
+        } else {
+            a = (1 + ihpf2*2) * (MA_PI_D/(pConfig->order*2));   /* Even order. */
+        }
+        q = 1 / (2*ma_cosd(a));
+
+        hpf2Config = ma_hpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, q);
+
+        if (isNew) {
+            size_t hpf2HeapSizeInBytes;
+
+            result = ma_hpf2_get_heap_size(&hpf2Config, &hpf2HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_hpf2_init_preallocated(&hpf2Config, ma_offset_ptr(pHeap, heapLayout.hpf2Offset + (sizeof(ma_hpf2) * hpf2Count) + (ihpf2 * hpf2HeapSizeInBytes)), &pHPF->pHPF2[ihpf2]);
+            }
+        } else {
+            result = ma_hpf2_reinit(&hpf2Config, &pHPF->pHPF2[ihpf2]);
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_uint32 jhpf1;
+            ma_uint32 jhpf2;
+
+            for (jhpf1 = 0; jhpf1 < hpf1Count; jhpf1 += 1) {
+                ma_hpf1_uninit(&pHPF->pHPF1[jhpf1], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            for (jhpf2 = 0; jhpf2 < ihpf2; jhpf2 += 1) {
+                ma_hpf2_uninit(&pHPF->pHPF2[jhpf2], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            return result;
+        }
+    }
+
+    pHPF->hpf1Count  = hpf1Count;
+    pHPF->hpf2Count  = hpf2Count;
+    pHPF->format     = pConfig->format;
+    pHPF->channels   = pConfig->channels;
+    pHPF->sampleRate = pConfig->sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hpf_get_heap_size(const ma_hpf_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_hpf_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_hpf_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return result;
+}
+
+MA_API ma_result ma_hpf_init_preallocated(const ma_hpf_config* pConfig, void* pHeap, ma_hpf* pLPF)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    return ma_hpf_reinit__internal(pConfig, pHeap, pLPF, /*isNew*/MA_TRUE);
+}
+
+MA_API ma_result ma_hpf_init(const ma_hpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf* pHPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_hpf_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_hpf_init_preallocated(pConfig, pHeap, pHPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pHPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_hpf_uninit(ma_hpf* pHPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_uint32 ihpf1;
+    ma_uint32 ihpf2;
+
+    if (pHPF == NULL) {
+        return;
+    }
+
+    for (ihpf1 = 0; ihpf1 < pHPF->hpf1Count; ihpf1 += 1) {
+        ma_hpf1_uninit(&pHPF->pHPF1[ihpf1], pAllocationCallbacks);
+    }
+
+    for (ihpf2 = 0; ihpf2 < pHPF->hpf2Count; ihpf2 += 1) {
+        ma_hpf2_uninit(&pHPF->pHPF2[ihpf2], pAllocationCallbacks);
+    }
+
+    if (pHPF->_ownsHeap) {
+        ma_free(pHPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_hpf_reinit(const ma_hpf_config* pConfig, ma_hpf* pHPF)
+{
+    return ma_hpf_reinit__internal(pConfig, NULL, pHPF, /*isNew*/MA_FALSE);
+}
+
+MA_API ma_result ma_hpf_process_pcm_frames(ma_hpf* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_result result;
+    ma_uint32 ihpf1;
+    ma_uint32 ihpf2;
+
+    if (pHPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Faster path for in-place. */
+    if (pFramesOut == pFramesIn) {
+        for (ihpf1 = 0; ihpf1 < pHPF->hpf1Count; ihpf1 += 1) {
+            result = ma_hpf1_process_pcm_frames(&pHPF->pHPF1[ihpf1], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+
+        for (ihpf2 = 0; ihpf2 < pHPF->hpf2Count; ihpf2 += 1) {
+            result = ma_hpf2_process_pcm_frames(&pHPF->pHPF2[ihpf2], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+    }
+
+    /* Slightly slower path for copying. */
+    if (pFramesOut != pFramesIn) {
+        ma_uint32 iFrame;
+
+        /*  */ if (pHPF->format == ma_format_f32) {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                MA_COPY_MEMORY(pFramesOutF32, pFramesInF32, ma_get_bytes_per_frame(pHPF->format, pHPF->channels));
+
+                for (ihpf1 = 0; ihpf1 < pHPF->hpf1Count; ihpf1 += 1) {
+                    ma_hpf1_process_pcm_frame_f32(&pHPF->pHPF1[ihpf1], pFramesOutF32, pFramesOutF32);
+                }
+
+                for (ihpf2 = 0; ihpf2 < pHPF->hpf2Count; ihpf2 += 1) {
+                    ma_hpf2_process_pcm_frame_f32(&pHPF->pHPF2[ihpf2], pFramesOutF32, pFramesOutF32);
+                }
+
+                pFramesOutF32 += pHPF->channels;
+                pFramesInF32  += pHPF->channels;
+            }
+        } else if (pHPF->format == ma_format_s16) {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                MA_COPY_MEMORY(pFramesOutS16, pFramesInS16, ma_get_bytes_per_frame(pHPF->format, pHPF->channels));
+
+                for (ihpf1 = 0; ihpf1 < pHPF->hpf1Count; ihpf1 += 1) {
+                    ma_hpf1_process_pcm_frame_s16(&pHPF->pHPF1[ihpf1], pFramesOutS16, pFramesOutS16);
+                }
+
+                for (ihpf2 = 0; ihpf2 < pHPF->hpf2Count; ihpf2 += 1) {
+                    ma_hpf2_process_pcm_frame_s16(&pHPF->pHPF2[ihpf2], pFramesOutS16, pFramesOutS16);
+                }
+
+                pFramesOutS16 += pHPF->channels;
+                pFramesInS16  += pHPF->channels;
+            }
+        } else {
+            MA_ASSERT(MA_FALSE);
+            return MA_INVALID_OPERATION;    /* Should never hit this. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_hpf_get_latency(const ma_hpf* pHPF)
+{
+    if (pHPF == NULL) {
+        return 0;
+    }
+
+    return pHPF->hpf2Count*2 + pHPF->hpf1Count;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Band-Pass Filtering
+
+**************************************************************************************************************************************************************/
+MA_API ma_bpf2_config ma_bpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q)
+{
+    ma_bpf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.q = q;
+
+    /* Q cannot be 0 or else it'll result in a division by 0. In this case just default to 0.707107. */
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_bpf2__get_biquad_config(const ma_bpf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+
+    bqConfig.b0 =  q * a;
+    bqConfig.b1 =  0;
+    bqConfig.b2 = -q * a;
+    bqConfig.a0 =  1 + a;
+    bqConfig.a1 = -2 * c;
+    bqConfig.a2 =  1 - a;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_bpf2_get_heap_size(const ma_bpf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_bpf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_bpf2_init_preallocated(const ma_bpf2_config* pConfig, void* pHeap, ma_bpf2* pBPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pBPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pBPF);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_bpf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pBPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_bpf2_init(const ma_bpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf2* pBPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_bpf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_bpf2_init_preallocated(pConfig, pHeap, pBPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pBPF->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_bpf2_uninit(ma_bpf2* pBPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pBPF == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pBPF->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_bpf2_reinit(const ma_bpf2_config* pConfig, ma_bpf2* pBPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pBPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_bpf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pBPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_bpf2_process_pcm_frame_s16(ma_bpf2* pBPF, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pBPF->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_bpf2_process_pcm_frame_f32(ma_bpf2* pBPF, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pBPF->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_bpf2_process_pcm_frames(ma_bpf2* pBPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pBPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pBPF->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_bpf2_get_latency(const ma_bpf2* pBPF)
+{
+    if (pBPF == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pBPF->bq);
+}
+
+
+MA_API ma_bpf_config ma_bpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_bpf_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format          = format;
+    config.channels        = channels;
+    config.sampleRate      = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.order           = ma_min(order, MA_MAX_FILTER_ORDER);
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t bpf2Offset;
+} ma_bpf_heap_layout;
+
+static ma_result ma_bpf_get_heap_layout(const ma_bpf_config* pConfig, ma_bpf_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    ma_uint32 bpf2Count;
+    ma_uint32 ibpf2;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* We must have an even number of order. */
+    if ((pConfig->order & 0x1) != 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    bpf2Count = pConfig->order / 2;
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* BPF 2 */
+    pHeapLayout->bpf2Offset = pHeapLayout->sizeInBytes;
+    for (ibpf2 = 0; ibpf2 < bpf2Count; ibpf2 += 1) {
+        size_t bpf2HeapSizeInBytes;
+        ma_bpf2_config bpf2Config = ma_bpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, 0.707107);   /* <-- The "q" parameter does not matter for the purpose of calculating the heap size. */
+
+        result = ma_bpf2_get_heap_size(&bpf2Config, &bpf2HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_bpf2) + bpf2HeapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_bpf_reinit__internal(const ma_bpf_config* pConfig, void* pHeap, ma_bpf* pBPF, ma_bool32 isNew)
+{
+    ma_result result;
+    ma_uint32 bpf2Count;
+    ma_uint32 ibpf2;
+    ma_bpf_heap_layout heapLayout;  /* Only used if isNew is true. */
+
+    if (pBPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pBPF->format != ma_format_unknown && pBPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pBPF->channels != 0 && pBPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* We must have an even number of order. */
+    if ((pConfig->order & 0x1) != 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    bpf2Count = pConfig->order / 2;
+
+    /* The filter order can't change between reinits. */
+    if (!isNew) {
+        if (pBPF->bpf2Count != bpf2Count) {
+            return MA_INVALID_OPERATION;
+        }
+    }
+
+    if (isNew) {
+        result = ma_bpf_get_heap_layout(pConfig, &heapLayout);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pBPF->_pHeap = pHeap;
+        MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+        pBPF->pBPF2 = (ma_bpf2*)ma_offset_ptr(pHeap, heapLayout.bpf2Offset);
+    } else {
+        MA_ZERO_OBJECT(&heapLayout);
+    }
+
+    for (ibpf2 = 0; ibpf2 < bpf2Count; ibpf2 += 1) {
+        ma_bpf2_config bpf2Config;
+        double q;
+
+        /* TODO: Calculate Q to make this a proper Butterworth filter. */
+        q = 0.707107;
+
+        bpf2Config = ma_bpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, q);
+
+        if (isNew) {
+            size_t bpf2HeapSizeInBytes;
+
+            result = ma_bpf2_get_heap_size(&bpf2Config, &bpf2HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_bpf2_init_preallocated(&bpf2Config, ma_offset_ptr(pHeap, heapLayout.bpf2Offset + (sizeof(ma_bpf2) * bpf2Count) + (ibpf2 * bpf2HeapSizeInBytes)), &pBPF->pBPF2[ibpf2]);
+            }
+        } else {
+            result = ma_bpf2_reinit(&bpf2Config, &pBPF->pBPF2[ibpf2]);
+        }
+
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    pBPF->bpf2Count = bpf2Count;
+    pBPF->format    = pConfig->format;
+    pBPF->channels  = pConfig->channels;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_bpf_get_heap_size(const ma_bpf_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_bpf_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_bpf_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_bpf_init_preallocated(const ma_bpf_config* pConfig, void* pHeap, ma_bpf* pBPF)
+{
+    if (pBPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pBPF);
+
+    return ma_bpf_reinit__internal(pConfig, pHeap, pBPF, /*isNew*/MA_TRUE);
+}
+
+MA_API ma_result ma_bpf_init(const ma_bpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf* pBPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_bpf_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_bpf_init_preallocated(pConfig, pHeap, pBPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pBPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_bpf_uninit(ma_bpf* pBPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_uint32 ibpf2;
+
+    if (pBPF == NULL) {
+        return;
+    }
+
+    for (ibpf2 = 0; ibpf2 < pBPF->bpf2Count; ibpf2 += 1) {
+        ma_bpf2_uninit(&pBPF->pBPF2[ibpf2], pAllocationCallbacks);
+    }
+
+    if (pBPF->_ownsHeap) {
+        ma_free(pBPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_bpf_reinit(const ma_bpf_config* pConfig, ma_bpf* pBPF)
+{
+    return ma_bpf_reinit__internal(pConfig, NULL, pBPF, /*isNew*/MA_FALSE);
+}
+
+MA_API ma_result ma_bpf_process_pcm_frames(ma_bpf* pBPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_result result;
+    ma_uint32 ibpf2;
+
+    if (pBPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Faster path for in-place. */
+    if (pFramesOut == pFramesIn) {
+        for (ibpf2 = 0; ibpf2 < pBPF->bpf2Count; ibpf2 += 1) {
+            result = ma_bpf2_process_pcm_frames(&pBPF->pBPF2[ibpf2], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+    }
+
+    /* Slightly slower path for copying. */
+    if (pFramesOut != pFramesIn) {
+        ma_uint32 iFrame;
+
+        /*  */ if (pBPF->format == ma_format_f32) {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                MA_COPY_MEMORY(pFramesOutF32, pFramesInF32, ma_get_bytes_per_frame(pBPF->format, pBPF->channels));
+
+                for (ibpf2 = 0; ibpf2 < pBPF->bpf2Count; ibpf2 += 1) {
+                    ma_bpf2_process_pcm_frame_f32(&pBPF->pBPF2[ibpf2], pFramesOutF32, pFramesOutF32);
+                }
+
+                pFramesOutF32 += pBPF->channels;
+                pFramesInF32  += pBPF->channels;
+            }
+        } else if (pBPF->format == ma_format_s16) {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                MA_COPY_MEMORY(pFramesOutS16, pFramesInS16, ma_get_bytes_per_frame(pBPF->format, pBPF->channels));
+
+                for (ibpf2 = 0; ibpf2 < pBPF->bpf2Count; ibpf2 += 1) {
+                    ma_bpf2_process_pcm_frame_s16(&pBPF->pBPF2[ibpf2], pFramesOutS16, pFramesOutS16);
+                }
+
+                pFramesOutS16 += pBPF->channels;
+                pFramesInS16  += pBPF->channels;
+            }
+        } else {
+            MA_ASSERT(MA_FALSE);
+            return MA_INVALID_OPERATION;    /* Should never hit this. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_bpf_get_latency(const ma_bpf* pBPF)
+{
+    if (pBPF == NULL) {
+        return 0;
+    }
+
+    return pBPF->bpf2Count*2;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Notching Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_notch2_config ma_notch2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double q, double frequency)
+{
+    ma_notch2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.q          = q;
+    config.frequency  = frequency;
+
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_notch2__get_biquad_config(const ma_notch2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->frequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+
+    bqConfig.b0 =  1;
+    bqConfig.b1 = -2 * c;
+    bqConfig.b2 =  1;
+    bqConfig.a0 =  1 + a;
+    bqConfig.a1 = -2 * c;
+    bqConfig.a2 =  1 - a;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_notch2_get_heap_size(const ma_notch2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_notch2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_notch2_init_preallocated(const ma_notch2_config* pConfig, void* pHeap, ma_notch2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFilter);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_notch2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_notch2_init(const ma_notch2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_notch2* pFilter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_notch2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_notch2_init_preallocated(pConfig, pHeap, pFilter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pFilter->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_notch2_uninit(ma_notch2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFilter == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pFilter->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_notch2_reinit(const ma_notch2_config* pConfig, ma_notch2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_notch2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_notch2_process_pcm_frame_s16(ma_notch2* pFilter, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_notch2_process_pcm_frame_f32(ma_notch2* pFilter, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_notch2_process_pcm_frames(ma_notch2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pFilter->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_notch2_get_latency(const ma_notch2* pFilter)
+{
+    if (pFilter == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pFilter->bq);
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Peaking EQ Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_peak2_config ma_peak2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency)
+{
+    ma_peak2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.gainDB     = gainDB;
+    config.q          = q;
+    config.frequency  = frequency;
+
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_peak2__get_biquad_config(const ma_peak2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+    double A;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->frequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+    A = ma_powd(10, (pConfig->gainDB / 40));
+
+    bqConfig.b0 =  1 + (a * A);
+    bqConfig.b1 = -2 * c;
+    bqConfig.b2 =  1 - (a * A);
+    bqConfig.a0 =  1 + (a / A);
+    bqConfig.a1 = -2 * c;
+    bqConfig.a2 =  1 - (a / A);
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_peak2_get_heap_size(const ma_peak2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_peak2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_peak2_init_preallocated(const ma_peak2_config* pConfig, void* pHeap, ma_peak2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFilter);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_peak2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_peak2_init(const ma_peak2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_peak2* pFilter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_peak2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_peak2_init_preallocated(pConfig, pHeap, pFilter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pFilter->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_peak2_uninit(ma_peak2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFilter == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pFilter->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_peak2_reinit(const ma_peak2_config* pConfig, ma_peak2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_peak2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_peak2_process_pcm_frame_s16(ma_peak2* pFilter, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_peak2_process_pcm_frame_f32(ma_peak2* pFilter, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_peak2_process_pcm_frames(ma_peak2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pFilter->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_peak2_get_latency(const ma_peak2* pFilter)
+{
+    if (pFilter == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pFilter->bq);
+}
+
+
+/**************************************************************************************************************************************************************
+
+Low Shelf Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_loshelf2_config ma_loshelf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency)
+{
+    ma_loshelf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.gainDB     = gainDB;
+    config.shelfSlope = shelfSlope;
+    config.frequency  = frequency;
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_loshelf2__get_biquad_config(const ma_loshelf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double w;
+    double s;
+    double c;
+    double A;
+    double S;
+    double a;
+    double sqrtA;
+
+    MA_ASSERT(pConfig != NULL);
+
+    w = 2 * MA_PI_D * pConfig->frequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    A = ma_powd(10, (pConfig->gainDB / 40));
+    S = pConfig->shelfSlope;
+    a = s/2 * ma_sqrtd((A + 1/A) * (1/S - 1) + 2);
+    sqrtA = 2*ma_sqrtd(A)*a;
+
+    bqConfig.b0 =  A * ((A + 1) - (A - 1)*c + sqrtA);
+    bqConfig.b1 =  2 * A * ((A - 1) - (A + 1)*c);
+    bqConfig.b2 =  A * ((A + 1) - (A - 1)*c - sqrtA);
+    bqConfig.a0 =  (A + 1) + (A - 1)*c + sqrtA;
+    bqConfig.a1 = -2 * ((A - 1) + (A + 1)*c);
+    bqConfig.a2 =  (A + 1) + (A - 1)*c - sqrtA;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_loshelf2_get_heap_size(const ma_loshelf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_loshelf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_loshelf2_init_preallocated(const ma_loshelf2_config* pConfig, void* pHeap, ma_loshelf2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFilter);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_loshelf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_loshelf2_init(const ma_loshelf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_loshelf2* pFilter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_loshelf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_loshelf2_init_preallocated(pConfig, pHeap, pFilter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pFilter->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_loshelf2_uninit(ma_loshelf2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFilter == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pFilter->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_loshelf2_reinit(const ma_loshelf2_config* pConfig, ma_loshelf2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_loshelf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_loshelf2_process_pcm_frame_s16(ma_loshelf2* pFilter, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_loshelf2_process_pcm_frame_f32(ma_loshelf2* pFilter, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_loshelf2_process_pcm_frames(ma_loshelf2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pFilter->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_loshelf2_get_latency(const ma_loshelf2* pFilter)
+{
+    if (pFilter == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pFilter->bq);
+}
+
+
+/**************************************************************************************************************************************************************
+
+High Shelf Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_hishelf2_config ma_hishelf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency)
+{
+    ma_hishelf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.gainDB     = gainDB;
+    config.shelfSlope = shelfSlope;
+    config.frequency  = frequency;
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_hishelf2__get_biquad_config(const ma_hishelf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double w;
+    double s;
+    double c;
+    double A;
+    double S;
+    double a;
+    double sqrtA;
+
+    MA_ASSERT(pConfig != NULL);
+
+    w = 2 * MA_PI_D * pConfig->frequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    A = ma_powd(10, (pConfig->gainDB / 40));
+    S = pConfig->shelfSlope;
+    a = s/2 * ma_sqrtd((A + 1/A) * (1/S - 1) + 2);
+    sqrtA = 2*ma_sqrtd(A)*a;
+
+    bqConfig.b0 =  A * ((A + 1) + (A - 1)*c + sqrtA);
+    bqConfig.b1 = -2 * A * ((A - 1) + (A + 1)*c);
+    bqConfig.b2 =  A * ((A + 1) + (A - 1)*c - sqrtA);
+    bqConfig.a0 =  (A + 1) - (A - 1)*c + sqrtA;
+    bqConfig.a1 =  2 * ((A - 1) - (A + 1)*c);
+    bqConfig.a2 =  (A + 1) - (A - 1)*c - sqrtA;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_hishelf2_get_heap_size(const ma_hishelf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_hishelf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_hishelf2_init_preallocated(const ma_hishelf2_config* pConfig, void* pHeap, ma_hishelf2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFilter);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_hishelf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hishelf2_init(const ma_hishelf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hishelf2* pFilter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_hishelf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_hishelf2_init_preallocated(pConfig, pHeap, pFilter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pFilter->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_hishelf2_uninit(ma_hishelf2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFilter == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pFilter->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_hishelf2_reinit(const ma_hishelf2_config* pConfig, ma_hishelf2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_hishelf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_hishelf2_process_pcm_frame_s16(ma_hishelf2* pFilter, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_hishelf2_process_pcm_frame_f32(ma_hishelf2* pFilter, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_hishelf2_process_pcm_frames(ma_hishelf2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pFilter->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_hishelf2_get_latency(const ma_hishelf2* pFilter)
+{
+    if (pFilter == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pFilter->bq);
+}
+
+
+
+/*
+Delay
+*/
+MA_API ma_delay_config ma_delay_config_init(ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 delayInFrames, float decay)
+{
+    ma_delay_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channels      = channels;
+    config.sampleRate    = sampleRate;
+    config.delayInFrames = delayInFrames;
+    config.delayStart    = (decay == 0) ? MA_TRUE : MA_FALSE;   /* Delay the start if it looks like we're not configuring an echo. */
+    config.wet           = 1;
+    config.dry           = 1;
+    config.decay         = decay;
+
+    return config;
+}
+
+
+MA_API ma_result ma_delay_init(const ma_delay_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_delay* pDelay)
+{
+    if (pDelay == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDelay);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->decay < 0 || pConfig->decay > 1) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDelay->config             = *pConfig;
+    pDelay->bufferSizeInFrames = pConfig->delayInFrames;
+    pDelay->cursor             = 0;
+
+    pDelay->pBuffer = (float*)ma_malloc((size_t)(pDelay->bufferSizeInFrames * ma_get_bytes_per_frame(ma_format_f32, pConfig->channels)), pAllocationCallbacks);
+    if (pDelay->pBuffer == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    ma_silence_pcm_frames(pDelay->pBuffer, pDelay->bufferSizeInFrames, ma_format_f32, pConfig->channels);
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_delay_uninit(ma_delay* pDelay, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pDelay == NULL) {
+        return;
+    }
+
+    ma_free(pDelay->pBuffer, pAllocationCallbacks);
+}
+
+MA_API ma_result ma_delay_process_pcm_frames(ma_delay* pDelay, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    ma_uint32 iFrame;
+    ma_uint32 iChannel;
+    float* pFramesOutF32 = (float*)pFramesOut;
+    const float* pFramesInF32 = (const float*)pFramesIn;
+
+    if (pDelay == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannel = 0; iChannel < pDelay->config.channels; iChannel += 1) {
+            ma_uint32 iBuffer = (pDelay->cursor * pDelay->config.channels) + iChannel;
+
+            if (pDelay->config.delayStart) {
+                /* Delayed start. */
+
+                /* Read */
+                pFramesOutF32[iChannel] = pDelay->pBuffer[iBuffer] * pDelay->config.wet;
+
+                /* Feedback */
+                pDelay->pBuffer[iBuffer] = (pDelay->pBuffer[iBuffer] * pDelay->config.decay) + (pFramesInF32[iChannel] * pDelay->config.dry);
+            } else {
+                /* Immediate start */
+
+                /* Feedback */
+                pDelay->pBuffer[iBuffer] = (pDelay->pBuffer[iBuffer] * pDelay->config.decay) + (pFramesInF32[iChannel] * pDelay->config.dry);
+
+                /* Read */
+                pFramesOutF32[iChannel] = pDelay->pBuffer[iBuffer] * pDelay->config.wet;
+            }
+        }
+
+        pDelay->cursor = (pDelay->cursor + 1) % pDelay->bufferSizeInFrames;
+
+        pFramesOutF32 += pDelay->config.channels;
+        pFramesInF32  += pDelay->config.channels;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_delay_set_wet(ma_delay* pDelay, float value)
+{
+    if (pDelay == NULL) {
+        return;
+    }
+
+    pDelay->config.wet = value;
+}
+
+MA_API float ma_delay_get_wet(const ma_delay* pDelay)
+{
+    if (pDelay == NULL) {
+        return 0;
+    }
+
+    return pDelay->config.wet;
+}
+
+MA_API void ma_delay_set_dry(ma_delay* pDelay, float value)
+{
+    if (pDelay == NULL) {
+        return;
+    }
+
+    pDelay->config.dry = value;
+}
+
+MA_API float ma_delay_get_dry(const ma_delay* pDelay)
+{
+    if (pDelay == NULL) {
+        return 0;
+    }
+
+    return pDelay->config.dry;
+}
+
+MA_API void ma_delay_set_decay(ma_delay* pDelay, float value)
+{
+    if (pDelay == NULL) {
+        return;
+    }
+
+    pDelay->config.decay = value;
+}
+
+MA_API float ma_delay_get_decay(const ma_delay* pDelay)
+{
+    if (pDelay == NULL) {
+        return 0;
+    }
+
+    return pDelay->config.decay;
+}
+
+
+MA_API ma_gainer_config ma_gainer_config_init(ma_uint32 channels, ma_uint32 smoothTimeInFrames)
+{
+    ma_gainer_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channels           = channels;
+    config.smoothTimeInFrames = smoothTimeInFrames;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t oldGainsOffset;
+    size_t newGainsOffset;
+} ma_gainer_heap_layout;
+
+static ma_result ma_gainer_get_heap_layout(const ma_gainer_config* pConfig, ma_gainer_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Old gains. */
+    pHeapLayout->oldGainsOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(float) * pConfig->channels;
+
+    /* New gains. */
+    pHeapLayout->newGainsOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(float) * pConfig->channels;
+
+    /* Alignment. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_gainer_get_heap_size(const ma_gainer_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_gainer_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_gainer_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_gainer_init_preallocated(const ma_gainer_config* pConfig, void* pHeap, ma_gainer* pGainer)
+{
+    ma_result result;
+    ma_gainer_heap_layout heapLayout;
+    ma_uint32 iChannel;
+
+    if (pGainer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pGainer);
+
+    if (pConfig == NULL || pHeap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_gainer_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pGainer->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pGainer->pOldGains = (float*)ma_offset_ptr(pHeap, heapLayout.oldGainsOffset);
+    pGainer->pNewGains = (float*)ma_offset_ptr(pHeap, heapLayout.newGainsOffset);
+    pGainer->masterVolume = 1;
+
+    pGainer->config = *pConfig;
+    pGainer->t      = (ma_uint32)-1;  /* No interpolation by default. */
+
+    for (iChannel = 0; iChannel < pConfig->channels; iChannel += 1) {
+        pGainer->pOldGains[iChannel] = 1;
+        pGainer->pNewGains[iChannel] = 1;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_init(const ma_gainer_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_gainer* pGainer)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_gainer_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap allocation. */
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_gainer_init_preallocated(pConfig, pHeap, pGainer);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pGainer->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_gainer_uninit(ma_gainer* pGainer, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pGainer == NULL) {
+        return;
+    }
+
+    if (pGainer->_ownsHeap) {
+        ma_free(pGainer->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static float ma_gainer_calculate_current_gain(const ma_gainer* pGainer, ma_uint32 channel)
+{
+    float a = (float)pGainer->t / pGainer->config.smoothTimeInFrames;
+    return ma_mix_f32_fast(pGainer->pOldGains[channel], pGainer->pNewGains[channel], a);
+}
+
+static /*__attribute__((noinline))*/ ma_result ma_gainer_process_pcm_frames_internal(ma_gainer * pGainer, void* MA_RESTRICT pFramesOut, const void* MA_RESTRICT pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+    ma_uint64 interpolatedFrameCount;
+
+    MA_ASSERT(pGainer != NULL);
+
+    /*
+    We don't necessarily need to apply a linear interpolation for the entire frameCount frames. When
+    linear interpolation is not needed we can do a simple volume adjustment which will be more
+    efficient than a lerp with an alpha value of 1.
+
+    To do this, all we need to do is determine how many frames need to have a lerp applied. Then we
+    just process that number of frames with linear interpolation. After that we run on an optimized
+    path which just applies the new gains without a lerp.
+    */
+    if (pGainer->t >= pGainer->config.smoothTimeInFrames) {
+        interpolatedFrameCount = 0;
+    } else {
+        interpolatedFrameCount = pGainer->t - pGainer->config.smoothTimeInFrames;
+        if (interpolatedFrameCount > frameCount) {
+            interpolatedFrameCount = frameCount;
+        }
+    }
+
+    /*
+    Start off with our interpolated frames. When we do this, we'll adjust frameCount and our pointers
+    so that the fast path can work naturally without consideration of the interpolated path.
+    */
+    if (interpolatedFrameCount > 0) {
+        /* We can allow the input and output buffers to be null in which case we'll just update the internal timer. */
+        if (pFramesOut != NULL && pFramesIn != NULL) {
+            /*
+            All we're really doing here is moving the old gains towards the new gains. We don't want to
+            be modifying the gains inside the ma_gainer object because that will break things. Instead
+            we can make a copy here on the stack. For extreme channel counts we can fall back to a slower
+            implementation which just uses a standard lerp.
+            */
+            float* pFramesOutF32 = (float*)pFramesOut;
+            const float* pFramesInF32 = (const float*)pFramesIn;
+            float a = (float)pGainer->t / pGainer->config.smoothTimeInFrames;
+            float d = 1.0f / pGainer->config.smoothTimeInFrames;
+
+            if (pGainer->config.channels <= 32) {
+                float pRunningGain[32];
+                float pRunningGainDelta[32];    /* Could this be heap-allocated as part of the ma_gainer object? */
+
+                /* Initialize the running gain. */
+                for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                    float t = (pGainer->pNewGains[iChannel] - pGainer->pOldGains[iChannel]) * pGainer->masterVolume;
+                    pRunningGainDelta[iChannel] = t * d;
+                    pRunningGain[iChannel] = (pGainer->pOldGains[iChannel] * pGainer->masterVolume) + (t * a);
+                }
+
+                iFrame = 0;
+
+                /* Optimized paths for common channel counts. This is mostly just experimenting with some SIMD ideas. It's not necessarily final. */
+                if (pGainer->config.channels == 2) {
+                #if defined(MA_SUPPORT_SSE2)
+                    if (ma_has_sse2()) {
+                        ma_uint64 unrolledLoopCount = interpolatedFrameCount >> 1;
+
+                        /* Expand some arrays so we can have a clean SIMD loop below. */
+                        __m128 runningGainDelta0 = _mm_set_ps(pRunningGainDelta[1], pRunningGainDelta[0], pRunningGainDelta[1], pRunningGainDelta[0]);
+                        __m128 runningGain0      = _mm_set_ps(pRunningGain[1] + pRunningGainDelta[1], pRunningGain[0] + pRunningGainDelta[0], pRunningGain[1], pRunningGain[0]);
+
+                        for (; iFrame < unrolledLoopCount; iFrame += 1) {
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*4 + 0], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*4 + 0]), runningGain0));
+                            runningGain0 = _mm_add_ps(runningGain0, runningGainDelta0);
+                        }
+
+                        iFrame = unrolledLoopCount << 1;
+                    } else
+                #endif
+                    {
+                        /*
+                        Two different scalar implementations here. Clang (and I assume GCC) will vectorize
+                        both of these, but the bottom version results in a nicer vectorization with less
+                        instructions emitted. The problem, however, is that the bottom version runs slower
+                        when compiled with MSVC. The top version will be partially vectorized by MSVC.
+                        */
+                    #if defined(_MSC_VER) && !defined(__clang__)
+                        ma_uint64 unrolledLoopCount = interpolatedFrameCount >> 1;
+
+                        /* Expand some arrays so we can have a clean 4x SIMD operation in the loop. */
+                        pRunningGainDelta[2] = pRunningGainDelta[0];
+                        pRunningGainDelta[3] = pRunningGainDelta[1];
+                        pRunningGain[2] = pRunningGain[0] + pRunningGainDelta[0];
+                        pRunningGain[3] = pRunningGain[1] + pRunningGainDelta[1];
+
+                        for (; iFrame < unrolledLoopCount; iFrame += 1) {
+                            pFramesOutF32[iFrame*4 + 0] = pFramesInF32[iFrame*4 + 0] * pRunningGain[0];
+                            pFramesOutF32[iFrame*4 + 1] = pFramesInF32[iFrame*4 + 1] * pRunningGain[1];
+                            pFramesOutF32[iFrame*4 + 2] = pFramesInF32[iFrame*4 + 2] * pRunningGain[2];
+                            pFramesOutF32[iFrame*4 + 3] = pFramesInF32[iFrame*4 + 3] * pRunningGain[3];
+
+                            /* Move the running gain forward towards the new gain. */
+                            pRunningGain[0] += pRunningGainDelta[0];
+                            pRunningGain[1] += pRunningGainDelta[1];
+                            pRunningGain[2] += pRunningGainDelta[2];
+                            pRunningGain[3] += pRunningGainDelta[3];
+                        }
+
+                        iFrame = unrolledLoopCount << 1;
+                    #else
+                        for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                            for (iChannel = 0; iChannel < 2; iChannel += 1) {
+                                pFramesOutF32[iFrame*2 + iChannel] = pFramesInF32[iFrame*2 + iChannel] * pRunningGain[iChannel];
+                            }
+
+                            for (iChannel = 0; iChannel < 2; iChannel += 1) {
+                                pRunningGain[iChannel] += pRunningGainDelta[iChannel];
+                            }
+                        }
+                    #endif
+                    }
+                } else if (pGainer->config.channels == 6) {
+                #if defined(MA_SUPPORT_SSE2)
+                    if (ma_has_sse2()) {
+                        /*
+                        For 6 channels things are a bit more complicated because 6 isn't cleanly divisible by 4. We need to do 2 frames
+                        at a time, meaning we'll be doing 12 samples in a group. Like the stereo case we'll need to expand some arrays
+                        so we can do clean 4x SIMD operations.
+                        */
+                        ma_uint64 unrolledLoopCount = interpolatedFrameCount >> 1;
+
+                        /* Expand some arrays so we can have a clean SIMD loop below. */
+                        __m128 runningGainDelta0 = _mm_set_ps(pRunningGainDelta[3], pRunningGainDelta[2], pRunningGainDelta[1], pRunningGainDelta[0]);
+                        __m128 runningGainDelta1 = _mm_set_ps(pRunningGainDelta[1], pRunningGainDelta[0], pRunningGainDelta[5], pRunningGainDelta[4]);
+                        __m128 runningGainDelta2 = _mm_set_ps(pRunningGainDelta[5], pRunningGainDelta[4], pRunningGainDelta[3], pRunningGainDelta[2]);
+
+                        __m128 runningGain0      = _mm_set_ps(pRunningGain[3],                        pRunningGain[2],                        pRunningGain[1],                        pRunningGain[0]);
+                        __m128 runningGain1      = _mm_set_ps(pRunningGain[1] + pRunningGainDelta[1], pRunningGain[0] + pRunningGainDelta[0], pRunningGain[5],                        pRunningGain[4]);
+                        __m128 runningGain2      = _mm_set_ps(pRunningGain[5] + pRunningGainDelta[5], pRunningGain[4] + pRunningGainDelta[4], pRunningGain[3] + pRunningGainDelta[3], pRunningGain[2] + pRunningGainDelta[2]);
+
+                        for (; iFrame < unrolledLoopCount; iFrame += 1) {
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*12 + 0], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*12 + 0]), runningGain0));
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*12 + 4], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*12 + 4]), runningGain1));
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*12 + 8], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*12 + 8]), runningGain2));
+
+                            runningGain0 = _mm_add_ps(runningGain0, runningGainDelta0);
+                            runningGain1 = _mm_add_ps(runningGain1, runningGainDelta1);
+                            runningGain2 = _mm_add_ps(runningGain2, runningGainDelta2);
+                        }
+
+                        iFrame = unrolledLoopCount << 1;
+                    } else
+                #endif
+                    {
+                        for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                            for (iChannel = 0; iChannel < 6; iChannel += 1) {
+                                pFramesOutF32[iFrame*6 + iChannel] = pFramesInF32[iFrame*6 + iChannel] * pRunningGain[iChannel];
+                            }
+
+                            /* Move the running gain forward towards the new gain. */
+                            for (iChannel = 0; iChannel < 6; iChannel += 1) {
+                                pRunningGain[iChannel] += pRunningGainDelta[iChannel];
+                            }
+                        }
+                    }
+                } else if (pGainer->config.channels == 8) {
+                    /* For 8 channels we can just go over frame by frame and do all eight channels as 2 separate 4x SIMD operations. */
+                #if defined(MA_SUPPORT_SSE2)
+                    if (ma_has_sse2()) {
+                        __m128 runningGainDelta0 = _mm_loadu_ps(&pRunningGainDelta[0]);
+                        __m128 runningGainDelta1 = _mm_loadu_ps(&pRunningGainDelta[4]);
+                        __m128 runningGain0      = _mm_loadu_ps(&pRunningGain[0]);
+                        __m128 runningGain1      = _mm_loadu_ps(&pRunningGain[4]);
+
+                        for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*8 + 0], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*8 + 0]), runningGain0));
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*8 + 4], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*8 + 4]), runningGain1));
+
+                            runningGain0 = _mm_add_ps(runningGain0, runningGainDelta0);
+                            runningGain1 = _mm_add_ps(runningGain1, runningGainDelta1);
+                        }
+                    } else
+                #endif
+                    {
+                        /* This is crafted so that it auto-vectorizes when compiled with Clang. */
+                        for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                            for (iChannel = 0; iChannel < 8; iChannel += 1) {
+                                pFramesOutF32[iFrame*8 + iChannel] = pFramesInF32[iFrame*8 + iChannel] * pRunningGain[iChannel];
+                            }
+
+                            /* Move the running gain forward towards the new gain. */
+                            for (iChannel = 0; iChannel < 8; iChannel += 1) {
+                                pRunningGain[iChannel] += pRunningGainDelta[iChannel];
+                            }
+                        }
+                    }
+                }
+
+                for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                    for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                        pFramesOutF32[iFrame*pGainer->config.channels + iChannel] = pFramesInF32[iFrame*pGainer->config.channels + iChannel] * pRunningGain[iChannel];
+                        pRunningGain[iChannel] += pRunningGainDelta[iChannel];
+                    }
+                }
+            } else {
+                /* Slower path for extreme channel counts where we can't fit enough on the stack. We could also move this to the heap as part of the ma_gainer object which might even be better since it'll only be updated when the gains actually change. */
+                for (iFrame = 0; iFrame < interpolatedFrameCount; iFrame += 1) {
+                    for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                        pFramesOutF32[iFrame*pGainer->config.channels + iChannel] = pFramesInF32[iFrame*pGainer->config.channels + iChannel] * ma_mix_f32_fast(pGainer->pOldGains[iChannel], pGainer->pNewGains[iChannel], a) * pGainer->masterVolume;
+                    }
+
+                    a += d;
+                }
+            }
+        }
+
+        /* Make sure the timer is updated. */
+        pGainer->t = (ma_uint32)ma_min(pGainer->t + interpolatedFrameCount, pGainer->config.smoothTimeInFrames);
+
+        /* Adjust our arguments so the next part can work normally. */
+        frameCount -= interpolatedFrameCount;
+        pFramesOut  = ma_offset_ptr(pFramesOut, interpolatedFrameCount * sizeof(float));
+        pFramesIn   = ma_offset_ptr(pFramesIn,  interpolatedFrameCount * sizeof(float));
+    }
+
+    /* All we need to do here is apply the new gains using an optimized path. */
+    if (pFramesOut != NULL && pFramesIn != NULL) {
+        if (pGainer->config.channels <= 32) {
+            float gains[32];
+            for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                gains[iChannel] = pGainer->pNewGains[iChannel] * pGainer->masterVolume;
+            }
+
+            ma_copy_and_apply_volume_factor_per_channel_f32((float*)pFramesOut, (const float*)pFramesIn, frameCount, pGainer->config.channels, gains);
+        } else {
+            /* Slow path. Too many channels to fit on the stack. Need to apply a master volume as a separate path. */
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                    ((float*)pFramesOut)[iFrame*pGainer->config.channels + iChannel] = ((const float*)pFramesIn)[iFrame*pGainer->config.channels + iChannel] * pGainer->pNewGains[iChannel] * pGainer->masterVolume;
+                }
+            }
+        }
+    }
+
+    /* Now that some frames have been processed we need to make sure future changes to the gain are interpolated. */
+    if (pGainer->t == (ma_uint32)-1) {
+        pGainer->t  = (ma_uint32)ma_min(pGainer->config.smoothTimeInFrames, frameCount);
+    }
+
+#if 0
+    if (pGainer->t >= pGainer->config.smoothTimeInFrames) {
+        /* Fast path. No gain calculation required. */
+        ma_copy_and_apply_volume_factor_per_channel_f32(pFramesOutF32, pFramesInF32, frameCount, pGainer->config.channels, pGainer->pNewGains);
+        ma_apply_volume_factor_f32(pFramesOutF32, frameCount * pGainer->config.channels, pGainer->masterVolume);
+
+        /* Now that some frames have been processed we need to make sure future changes to the gain are interpolated. */
+        if (pGainer->t == (ma_uint32)-1) {
+            pGainer->t = pGainer->config.smoothTimeInFrames;
+        }
+    } else {
+        /* Slow path. Need to interpolate the gain for each channel individually. */
+
+        /* We can allow the input and output buffers to be null in which case we'll just update the internal timer. */
+        if (pFramesOut != NULL && pFramesIn != NULL) {
+            float a = (float)pGainer->t / pGainer->config.smoothTimeInFrames;
+            float d = 1.0f / pGainer->config.smoothTimeInFrames;
+            ma_uint32 channelCount = pGainer->config.channels;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channelCount; iChannel += 1) {
+                    pFramesOutF32[iChannel] = pFramesInF32[iChannel] * ma_mix_f32_fast(pGainer->pOldGains[iChannel], pGainer->pNewGains[iChannel], a) * pGainer->masterVolume;
+                }
+
+                pFramesOutF32 += channelCount;
+                pFramesInF32  += channelCount;
+
+                a += d;
+                if (a > 1) {
+                    a = 1;
+                }
+            }
+        }
+
+        pGainer->t = (ma_uint32)ma_min(pGainer->t + frameCount, pGainer->config.smoothTimeInFrames);
+
+    #if 0   /* Reference implementation. */
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            /* We can allow the input and output buffers to be null in which case we'll just update the internal timer. */
+            if (pFramesOut != NULL && pFramesIn != NULL) {
+                for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                    pFramesOutF32[iFrame * pGainer->config.channels + iChannel] = pFramesInF32[iFrame * pGainer->config.channels + iChannel] * ma_gainer_calculate_current_gain(pGainer, iChannel) * pGainer->masterVolume;
+                }
+            }
+
+            /* Move interpolation time forward, but don't go beyond our smoothing time. */
+            pGainer->t = ma_min(pGainer->t + 1, pGainer->config.smoothTimeInFrames);
+        }
+    #endif
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_process_pcm_frames(ma_gainer* pGainer, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pGainer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    ma_gainer_process_pcm_frames_internal() marks pFramesOut and pFramesIn with MA_RESTRICT which
+    helps with auto-vectorization.
+    */
+    return ma_gainer_process_pcm_frames_internal(pGainer, pFramesOut, pFramesIn, frameCount);
+}
+
+static void ma_gainer_set_gain_by_index(ma_gainer* pGainer, float newGain, ma_uint32 iChannel)
+{
+    pGainer->pOldGains[iChannel] = ma_gainer_calculate_current_gain(pGainer, iChannel);
+    pGainer->pNewGains[iChannel] = newGain;
+}
+
+static void ma_gainer_reset_smoothing_time(ma_gainer* pGainer)
+{
+    if (pGainer->t == (ma_uint32)-1) {
+        pGainer->t = pGainer->config.smoothTimeInFrames;    /* No smoothing required for initial gains setting. */
+    } else {
+        pGainer->t = 0;
+    }
+}
+
+MA_API ma_result ma_gainer_set_gain(ma_gainer* pGainer, float newGain)
+{
+    ma_uint32 iChannel;
+
+    if (pGainer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+        ma_gainer_set_gain_by_index(pGainer, newGain, iChannel);
+    }
+
+    /* The smoothing time needs to be reset to ensure we always interpolate by the configured smoothing time, but only if it's not the first setting. */
+    ma_gainer_reset_smoothing_time(pGainer);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_set_gains(ma_gainer* pGainer, float* pNewGains)
+{
+    ma_uint32 iChannel;
+
+    if (pGainer == NULL || pNewGains == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+        ma_gainer_set_gain_by_index(pGainer, pNewGains[iChannel], iChannel);
+    }
+
+    /* The smoothing time needs to be reset to ensure we always interpolate by the configured smoothing time, but only if it's not the first setting. */
+    ma_gainer_reset_smoothing_time(pGainer);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_set_master_volume(ma_gainer* pGainer, float volume)
+{
+    if (pGainer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pGainer->masterVolume = volume;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_get_master_volume(const ma_gainer* pGainer, float* pVolume)
+{
+    if (pGainer == NULL || pVolume == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pVolume = pGainer->masterVolume;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_panner_config ma_panner_config_init(ma_format format, ma_uint32 channels)
+{
+    ma_panner_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format   = format;
+    config.channels = channels;
+    config.mode     = ma_pan_mode_balance;  /* Set to balancing mode by default because it's consistent with other audio engines and most likely what the caller is expecting. */
+    config.pan      = 0;
+
+    return config;
+}
+
+
+MA_API ma_result ma_panner_init(const ma_panner_config* pConfig, ma_panner* pPanner)
+{
+    if (pPanner == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pPanner);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pPanner->format   = pConfig->format;
+    pPanner->channels = pConfig->channels;
+    pPanner->mode     = pConfig->mode;
+    pPanner->pan      = pConfig->pan;
+
+    return MA_SUCCESS;
+}
+
+static void ma_stereo_balance_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, float pan)
+{
+    ma_uint64 iFrame;
+
+    if (pan > 0) {
+        float factor = 1.0f - pan;
+        if (pFramesOut == pFramesIn) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pFramesOut[iFrame*2 + 0] = pFramesIn[iFrame*2 + 0] * factor;
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pFramesOut[iFrame*2 + 0] = pFramesIn[iFrame*2 + 0] * factor;
+                pFramesOut[iFrame*2 + 1] = pFramesIn[iFrame*2 + 1];
+            }
+        }
+    } else {
+        float factor = 1.0f + pan;
+        if (pFramesOut == pFramesIn) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pFramesOut[iFrame*2 + 1] = pFramesIn[iFrame*2 + 1] * factor;
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pFramesOut[iFrame*2 + 0] = pFramesIn[iFrame*2 + 0];
+                pFramesOut[iFrame*2 + 1] = pFramesIn[iFrame*2 + 1] * factor;
+            }
+        }
+    }
+}
+
+static void ma_stereo_balance_pcm_frames(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_format format, float pan)
+{
+    if (pan == 0) {
+        /* Fast path. No panning required. */
+        if (pFramesOut == pFramesIn) {
+            /* No-op */
+        } else {
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, format, 2);
+        }
+
+        return;
+    }
+
+    switch (format) {
+        case ma_format_f32: ma_stereo_balance_pcm_frames_f32((float*)pFramesOut, (float*)pFramesIn, frameCount, pan); break;
+
+        /* Unknown format. Just copy. */
+        default:
+        {
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, format, 2);
+        } break;
+    }
+}
+
+
+static void ma_stereo_pan_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, float pan)
+{
+    ma_uint64 iFrame;
+
+    if (pan > 0) {
+        float factorL0 = 1.0f - pan;
+        float factorL1 = 0.0f + pan;
+
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float sample0 = (pFramesIn[iFrame*2 + 0] * factorL0);
+            float sample1 = (pFramesIn[iFrame*2 + 0] * factorL1) + pFramesIn[iFrame*2 + 1];
+
+            pFramesOut[iFrame*2 + 0] = sample0;
+            pFramesOut[iFrame*2 + 1] = sample1;
+        }
+    } else {
+        float factorR0 = 0.0f - pan;
+        float factorR1 = 1.0f + pan;
+
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float sample0 = pFramesIn[iFrame*2 + 0] + (pFramesIn[iFrame*2 + 1] * factorR0);
+            float sample1 =                           (pFramesIn[iFrame*2 + 1] * factorR1);
+
+            pFramesOut[iFrame*2 + 0] = sample0;
+            pFramesOut[iFrame*2 + 1] = sample1;
+        }
+    }
+}
+
+static void ma_stereo_pan_pcm_frames(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_format format, float pan)
+{
+    if (pan == 0) {
+        /* Fast path. No panning required. */
+        if (pFramesOut == pFramesIn) {
+            /* No-op */
+        } else {
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, format, 2);
+        }
+
+        return;
+    }
+
+    switch (format) {
+        case ma_format_f32: ma_stereo_pan_pcm_frames_f32((float*)pFramesOut, (float*)pFramesIn, frameCount, pan); break;
+
+        /* Unknown format. Just copy. */
+        default:
+        {
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, format, 2);
+        } break;
+    }
+}
+
+MA_API ma_result ma_panner_process_pcm_frames(ma_panner* pPanner, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pPanner == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pPanner->channels == 2) {
+        /* Stereo case. For now assume channel 0 is left and channel right is 1, but should probably add support for a channel map. */
+        if (pPanner->mode == ma_pan_mode_balance) {
+            ma_stereo_balance_pcm_frames(pFramesOut, pFramesIn, frameCount, pPanner->format, pPanner->pan);
+        } else {
+            ma_stereo_pan_pcm_frames(pFramesOut, pFramesIn, frameCount, pPanner->format, pPanner->pan);
+        }
+    } else {
+        if (pPanner->channels == 1) {
+            /* Panning has no effect on mono streams. */
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, pPanner->format, pPanner->channels);
+        } else {
+            /* For now we're not going to support non-stereo set ups. Not sure how I want to handle this case just yet. */
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, pPanner->format, pPanner->channels);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_panner_set_mode(ma_panner* pPanner, ma_pan_mode mode)
+{
+    if (pPanner == NULL) {
+        return;
+    }
+
+    pPanner->mode = mode;
+}
+
+MA_API ma_pan_mode ma_panner_get_mode(const ma_panner* pPanner)
+{
+    if (pPanner == NULL) {
+        return ma_pan_mode_balance;
+    }
+
+    return pPanner->mode;
+}
+
+MA_API void ma_panner_set_pan(ma_panner* pPanner, float pan)
+{
+    if (pPanner == NULL) {
+        return;
+    }
+
+    pPanner->pan = ma_clamp(pan, -1.0f, 1.0f);
+}
+
+MA_API float ma_panner_get_pan(const ma_panner* pPanner)
+{
+    if (pPanner == NULL) {
+        return 0;
+    }
+
+    return pPanner->pan;
+}
+
+
+
+
+MA_API ma_fader_config ma_fader_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    ma_fader_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+
+    return config;
+}
+
+
+MA_API ma_result ma_fader_init(const ma_fader_config* pConfig, ma_fader* pFader)
+{
+    if (pFader == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFader);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only f32 is supported for now. */
+    if (pConfig->format != ma_format_f32) {
+        return MA_INVALID_ARGS;
+    }
+
+    pFader->config         = *pConfig;
+    pFader->volumeBeg      = 1;
+    pFader->volumeEnd      = 1;
+    pFader->lengthInFrames = 0;
+    pFader->cursorInFrames = 0;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_fader_process_pcm_frames(ma_fader* pFader, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFader == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If the cursor is still negative we need to just copy the absolute number of those frames, but no more than frameCount. */
+    if (pFader->cursorInFrames < 0) {
+        ma_uint64 absCursorInFrames = (ma_uint64)0 - pFader->cursorInFrames;
+        if (absCursorInFrames > frameCount) {
+            absCursorInFrames = frameCount;
+        }
+
+        ma_copy_pcm_frames(pFramesOut, pFramesIn, absCursorInFrames, pFader->config.format, pFader->config.channels);
+
+        pFader->cursorInFrames += absCursorInFrames;
+        frameCount -= absCursorInFrames;
+        pFramesOut  = ma_offset_ptr(pFramesOut, ma_get_bytes_per_frame(pFader->config.format, pFader->config.channels)*absCursorInFrames);
+        pFramesIn   = ma_offset_ptr(pFramesIn,  ma_get_bytes_per_frame(pFader->config.format, pFader->config.channels)*absCursorInFrames);
+    }
+
+    if (pFader->cursorInFrames >= 0) {
+        /*
+        For now we need to clamp frameCount so that the cursor never overflows 32-bits. This is required for
+        the conversion to a float which we use for the linear interpolation. This might be changed later.
+        */
+        if (frameCount + pFader->cursorInFrames > UINT_MAX) {
+            frameCount = UINT_MAX - pFader->cursorInFrames;
+        }
+
+        /* Optimized path if volumeBeg and volumeEnd are equal. */
+        if (pFader->volumeBeg == pFader->volumeEnd) {
+            if (pFader->volumeBeg == 1) {
+                /* Straight copy. */
+                ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, pFader->config.format, pFader->config.channels);
+            } else {
+                /* Copy with volume. */
+                ma_copy_and_apply_volume_and_clip_pcm_frames(pFramesOut, pFramesIn, frameCount, pFader->config.format, pFader->config.channels, pFader->volumeBeg);
+            }
+        } else {
+            /* Slower path. Volumes are different, so may need to do an interpolation. */
+            if ((ma_uint64)pFader->cursorInFrames >= pFader->lengthInFrames) {
+                /* Fast path. We've gone past the end of the fade period so just apply the end volume to all samples. */
+                ma_copy_and_apply_volume_and_clip_pcm_frames(pFramesOut, pFramesIn, frameCount, pFader->config.format, pFader->config.channels, pFader->volumeEnd);
+            } else {
+                /* Slow path. This is where we do the actual fading. */
+                ma_uint64 iFrame;
+                ma_uint32 iChannel;
+
+                /* For now we only support f32. Support for other formats might be added later. */
+                if (pFader->config.format == ma_format_f32) {
+                    const float* pFramesInF32  = (const float*)pFramesIn;
+                    /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+
+                    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                        float a = (ma_uint32)ma_min(pFader->cursorInFrames + iFrame, pFader->lengthInFrames) / (float)((ma_uint32)pFader->lengthInFrames);   /* Safe cast due to the frameCount clamp at the top of this function. */
+                        float volume = ma_mix_f32_fast(pFader->volumeBeg, pFader->volumeEnd, a);
+
+                        for (iChannel = 0; iChannel < pFader->config.channels; iChannel += 1) {
+                            pFramesOutF32[iFrame*pFader->config.channels + iChannel] = pFramesInF32[iFrame*pFader->config.channels + iChannel] * volume;
+                        }
+                    }
+                } else {
+                    return MA_NOT_IMPLEMENTED;
+                }
+            }
+        }
+    }
+
+    pFader->cursorInFrames += frameCount;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_fader_get_data_format(const ma_fader* pFader, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate)
+{
+    if (pFader == NULL) {
+        return;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pFader->config.format;
+    }
+
+    if (pChannels != NULL) {
+        *pChannels = pFader->config.channels;
+    }
+
+    if (pSampleRate != NULL) {
+        *pSampleRate = pFader->config.sampleRate;
+    }
+}
+
+MA_API void ma_fader_set_fade(ma_fader* pFader, float volumeBeg, float volumeEnd, ma_uint64 lengthInFrames)
+{
+    ma_fader_set_fade_ex(pFader, volumeBeg, volumeEnd, lengthInFrames, 0);
+}
+
+MA_API void ma_fader_set_fade_ex(ma_fader* pFader, float volumeBeg, float volumeEnd, ma_uint64 lengthInFrames, ma_int64 startOffsetInFrames)
+{
+    if (pFader == NULL) {
+        return;
+    }
+
+    /* If the volume is negative, use current volume. */
+    if (volumeBeg < 0) {
+        volumeBeg = ma_fader_get_current_volume(pFader);
+    }
+
+    /*
+    The length needs to be clamped to 32-bits due to how we convert it to a float for linear
+    interpolation reasons. I might change this requirement later, but for now it's not important.
+    */
+    if (lengthInFrames > UINT_MAX) {
+        lengthInFrames = UINT_MAX;
+    }
+
+    /* The start offset needs to be clamped to ensure it doesn't overflow a signed number. */
+    if (startOffsetInFrames > INT_MAX) {
+        startOffsetInFrames = INT_MAX;
+    }
+
+    pFader->volumeBeg      = volumeBeg;
+    pFader->volumeEnd      = volumeEnd;
+    pFader->lengthInFrames = lengthInFrames;
+    pFader->cursorInFrames = -startOffsetInFrames;
+}
+
+MA_API float ma_fader_get_current_volume(const ma_fader* pFader)
+{
+    if (pFader == NULL) {
+        return 0.0f;
+    }
+
+    /* Any frames prior to the start of the fade period will be at unfaded volume. */
+    if (pFader->cursorInFrames < 0) {
+        return 1.0f;
+    }
+
+    /* The current volume depends on the position of the cursor. */
+    if (pFader->cursorInFrames == 0) {
+        return pFader->volumeBeg;
+    } else if ((ma_uint64)pFader->cursorInFrames >= pFader->lengthInFrames) {   /* Safe case because the < 0 case was checked above. */
+        return pFader->volumeEnd;
+    } else {
+        /* The cursor is somewhere inside the fading period. We can figure this out with a simple linear interpolation between volumeBeg and volumeEnd based on our cursor position. */
+        return ma_mix_f32_fast(pFader->volumeBeg, pFader->volumeEnd, (ma_uint32)pFader->cursorInFrames / (float)((ma_uint32)pFader->lengthInFrames));    /* Safe cast to uint32 because we clamp it in ma_fader_process_pcm_frames(). */
+    }
+}
+
+
+
+
+
+MA_API ma_vec3f ma_vec3f_init_3f(float x, float y, float z)
+{
+    ma_vec3f v;
+
+    v.x = x;
+    v.y = y;
+    v.z = z;
+
+    return v;
+}
+
+MA_API ma_vec3f ma_vec3f_sub(ma_vec3f a, ma_vec3f b)
+{
+    return ma_vec3f_init_3f(
+        a.x - b.x,
+        a.y - b.y,
+        a.z - b.z
+    );
+}
+
+MA_API ma_vec3f ma_vec3f_neg(ma_vec3f a)
+{
+    return ma_vec3f_init_3f(
+        -a.x,
+        -a.y,
+        -a.z
+    );
+}
+
+MA_API float ma_vec3f_dot(ma_vec3f a, ma_vec3f b)
+{
+    return a.x*b.x + a.y*b.y + a.z*b.z;
+}
+
+MA_API float ma_vec3f_len2(ma_vec3f v)
+{
+    return ma_vec3f_dot(v, v);
+}
+
+MA_API float ma_vec3f_len(ma_vec3f v)
+{
+    return (float)ma_sqrtd(ma_vec3f_len2(v));
+}
+
+
+
+MA_API float ma_vec3f_dist(ma_vec3f a, ma_vec3f b)
+{
+    return ma_vec3f_len(ma_vec3f_sub(a, b));
+}
+
+MA_API ma_vec3f ma_vec3f_normalize(ma_vec3f v)
+{
+    float invLen;
+    float len2 = ma_vec3f_len2(v);
+    if (len2 == 0) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    invLen = ma_rsqrtf(len2);
+    v.x *= invLen;
+    v.y *= invLen;
+    v.z *= invLen;
+
+    return v;
+}
+
+MA_API ma_vec3f ma_vec3f_cross(ma_vec3f a, ma_vec3f b)
+{
+    return ma_vec3f_init_3f(
+        a.y*b.z - a.z*b.y,
+        a.z*b.x - a.x*b.z,
+        a.x*b.y - a.y*b.x
+    );
+}
+
+
+MA_API void ma_atomic_vec3f_init(ma_atomic_vec3f* v, ma_vec3f value)
+{
+    v->v = value;
+    v->lock = 0;    /* Important this is initialized to 0. */
+}
+
+MA_API void ma_atomic_vec3f_set(ma_atomic_vec3f* v, ma_vec3f value)
+{
+    ma_spinlock_lock(&v->lock);
+    {
+        v->v = value;
+    }
+    ma_spinlock_unlock(&v->lock);
+}
+
+MA_API ma_vec3f ma_atomic_vec3f_get(ma_atomic_vec3f* v)
+{
+    ma_vec3f r;
+
+    ma_spinlock_lock(&v->lock);
+    {
+        r = v->v;
+    }
+    ma_spinlock_unlock(&v->lock);
+
+    return r;
+}
+
+
+
+static void ma_channel_map_apply_f32(float* pFramesOut, const ma_channel* pChannelMapOut, ma_uint32 channelsOut, const float* pFramesIn, const ma_channel* pChannelMapIn, ma_uint32 channelsIn, ma_uint64 frameCount, ma_channel_mix_mode mode, ma_mono_expansion_mode monoExpansionMode);
+static ma_bool32 ma_is_spatial_channel_position(ma_channel channelPosition);
+
+
+#ifndef MA_DEFAULT_SPEED_OF_SOUND
+#define MA_DEFAULT_SPEED_OF_SOUND   343.3f
+#endif
+
+/*
+These vectors represent the direction that speakers are facing from the center point. They're used
+for panning in the spatializer. Must be normalized.
+*/
+static ma_vec3f g_maChannelDirections[MA_CHANNEL_POSITION_COUNT] = {
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_NONE */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_MONO */
+    {-0.7071f,  0.0f,    -0.7071f },  /* MA_CHANNEL_FRONT_LEFT */
+    {+0.7071f,  0.0f,    -0.7071f },  /* MA_CHANNEL_FRONT_RIGHT */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_FRONT_CENTER */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_LFE */
+    {-0.7071f,  0.0f,    +0.7071f },  /* MA_CHANNEL_BACK_LEFT */
+    {+0.7071f,  0.0f,    +0.7071f },  /* MA_CHANNEL_BACK_RIGHT */
+    {-0.3162f,  0.0f,    -0.9487f },  /* MA_CHANNEL_FRONT_LEFT_CENTER */
+    {+0.3162f,  0.0f,    -0.9487f },  /* MA_CHANNEL_FRONT_RIGHT_CENTER */
+    { 0.0f,     0.0f,    +1.0f    },  /* MA_CHANNEL_BACK_CENTER */
+    {-1.0f,     0.0f,     0.0f    },  /* MA_CHANNEL_SIDE_LEFT */
+    {+1.0f,     0.0f,     0.0f    },  /* MA_CHANNEL_SIDE_RIGHT */
+    { 0.0f,    +1.0f,     0.0f    },  /* MA_CHANNEL_TOP_CENTER */
+    {-0.5774f, +0.5774f, -0.5774f },  /* MA_CHANNEL_TOP_FRONT_LEFT */
+    { 0.0f,    +0.7071f, -0.7071f },  /* MA_CHANNEL_TOP_FRONT_CENTER */
+    {+0.5774f, +0.5774f, -0.5774f },  /* MA_CHANNEL_TOP_FRONT_RIGHT */
+    {-0.5774f, +0.5774f, +0.5774f },  /* MA_CHANNEL_TOP_BACK_LEFT */
+    { 0.0f,    +0.7071f, +0.7071f },  /* MA_CHANNEL_TOP_BACK_CENTER */
+    {+0.5774f, +0.5774f, +0.5774f },  /* MA_CHANNEL_TOP_BACK_RIGHT */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_0 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_1 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_2 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_3 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_4 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_5 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_6 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_7 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_8 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_9 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_10 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_11 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_12 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_13 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_14 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_15 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_16 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_17 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_18 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_19 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_20 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_21 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_22 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_23 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_24 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_25 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_26 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_27 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_28 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_29 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_30 */
+    { 0.0f,     0.0f,    -1.0f    }   /* MA_CHANNEL_AUX_31 */
+};
+
+static ma_vec3f ma_get_channel_direction(ma_channel channel)
+{
+    if (channel >= MA_CHANNEL_POSITION_COUNT) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    } else {
+        return g_maChannelDirections[channel];
+    }
+}
+
+
+
+static float ma_attenuation_inverse(float distance, float minDistance, float maxDistance, float rolloff)
+{
+    if (minDistance >= maxDistance) {
+        return 1;   /* To avoid division by zero. Do not attenuate. */
+    }
+
+    return minDistance / (minDistance + rolloff * (ma_clamp(distance, minDistance, maxDistance) - minDistance));
+}
+
+static float ma_attenuation_linear(float distance, float minDistance, float maxDistance, float rolloff)
+{
+    if (minDistance >= maxDistance) {
+        return 1;   /* To avoid division by zero. Do not attenuate. */
+    }
+
+    return 1 - rolloff * (ma_clamp(distance, minDistance, maxDistance) - minDistance) / (maxDistance - minDistance);
+}
+
+static float ma_attenuation_exponential(float distance, float minDistance, float maxDistance, float rolloff)
+{
+    if (minDistance >= maxDistance) {
+        return 1;   /* To avoid division by zero. Do not attenuate. */
+    }
+
+    return (float)ma_powd(ma_clamp(distance, minDistance, maxDistance) / minDistance, -rolloff);
+}
+
+
+/*
+Doppler Effect calculation taken from the OpenAL spec, with two main differences:
+
+  1) The source to listener vector will have already been calculated at an earlier step so we can
+     just use that directly. We need only the position of the source relative to the origin.
+
+  2) We don't scale by a frequency because we actually just want the ratio which we'll plug straight
+     into the resampler directly.
+*/
+static float ma_doppler_pitch(ma_vec3f relativePosition, ma_vec3f sourceVelocity, ma_vec3f listenVelocity, float speedOfSound, float dopplerFactor)
+{
+    float len;
+    float vls;
+    float vss;
+
+    len = ma_vec3f_len(relativePosition);
+
+    /*
+    There's a case where the position of the source will be right on top of the listener in which
+    case the length will be 0 and we'll end up with a division by zero. We can just return a ratio
+    of 1.0 in this case. This is not considered in the OpenAL spec, but is necessary.
+    */
+    if (len == 0) {
+        return 1.0;
+    }
+
+    vls = ma_vec3f_dot(relativePosition, listenVelocity) / len;
+    vss = ma_vec3f_dot(relativePosition, sourceVelocity) / len;
+
+    vls = ma_min(vls, speedOfSound / dopplerFactor);
+    vss = ma_min(vss, speedOfSound / dopplerFactor);
+
+    return (speedOfSound - dopplerFactor*vls) / (speedOfSound - dopplerFactor*vss);
+}
+
+
+static void ma_get_default_channel_map_for_spatializer(ma_channel* pChannelMap, size_t channelMapCap, ma_uint32 channelCount)
+{
+    /*
+    Special case for stereo. Want to default the left and right speakers to side left and side
+    right so that they're facing directly down the X axis rather than slightly forward. Not
+    doing this will result in sounds being quieter when behind the listener. This might
+    actually be good for some scenarios, but I don't think it's an appropriate default because
+    it can be a bit unexpected.
+    */
+    if (channelCount == 2) {
+        pChannelMap[0] = MA_CHANNEL_SIDE_LEFT;
+        pChannelMap[1] = MA_CHANNEL_SIDE_RIGHT;
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, channelCount);
+    }
+}
+
+
+MA_API ma_spatializer_listener_config ma_spatializer_listener_config_init(ma_uint32 channelsOut)
+{
+    ma_spatializer_listener_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channelsOut             = channelsOut;
+    config.pChannelMapOut          = NULL;
+    config.handedness              = ma_handedness_right;
+    config.worldUp                 = ma_vec3f_init_3f(0, 1,  0);
+    config.coneInnerAngleInRadians = 6.283185f; /* 360 degrees. */
+    config.coneOuterAngleInRadians = 6.283185f; /* 360 degrees. */
+    config.coneOuterGain           = 0;
+    config.speedOfSound            = 343.3f;    /* Same as OpenAL. Used for doppler effect. */
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t channelMapOutOffset;
+} ma_spatializer_listener_heap_layout;
+
+static ma_result ma_spatializer_listener_get_heap_layout(const ma_spatializer_listener_config* pConfig, ma_spatializer_listener_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channelsOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Channel map. We always need this, even for passthroughs. */
+    pHeapLayout->channelMapOutOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(sizeof(*pConfig->pChannelMapOut) * pConfig->channelsOut);
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_spatializer_listener_get_heap_size(const ma_spatializer_listener_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_spatializer_listener_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_spatializer_listener_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_listener_init_preallocated(const ma_spatializer_listener_config* pConfig, void* pHeap, ma_spatializer_listener* pListener)
+{
+    ma_result result;
+    ma_spatializer_listener_heap_layout heapLayout;
+
+    if (pListener == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pListener);
+
+    result = ma_spatializer_listener_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pListener->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pListener->config    = *pConfig;
+    ma_atomic_vec3f_init(&pListener->position,  ma_vec3f_init_3f(0, 0, 0));
+    ma_atomic_vec3f_init(&pListener->direction, ma_vec3f_init_3f(0, 0, -1));
+    ma_atomic_vec3f_init(&pListener->velocity,  ma_vec3f_init_3f(0, 0,  0));
+    pListener->isEnabled = MA_TRUE;
+
+    /* Swap the forward direction if we're left handed (it was initialized based on right handed). */
+    if (pListener->config.handedness == ma_handedness_left) {
+        ma_vec3f negDir = ma_vec3f_neg(ma_spatializer_listener_get_direction(pListener));
+        ma_spatializer_listener_set_direction(pListener, negDir.x, negDir.y, negDir.z);
+    }
+
+
+    /* We must always have a valid channel map. */
+    pListener->config.pChannelMapOut = (ma_channel*)ma_offset_ptr(pHeap, heapLayout.channelMapOutOffset);
+
+    /* Use a slightly different default channel map for stereo. */
+    if (pConfig->pChannelMapOut == NULL) {
+        ma_get_default_channel_map_for_spatializer(pListener->config.pChannelMapOut, pConfig->channelsOut, pConfig->channelsOut);
+    } else {
+        ma_channel_map_copy_or_default(pListener->config.pChannelMapOut, pConfig->channelsOut, pConfig->pChannelMapOut, pConfig->channelsOut);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_listener_init(const ma_spatializer_listener_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_spatializer_listener* pListener)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_spatializer_listener_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_spatializer_listener_init_preallocated(pConfig, pHeap, pListener);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pListener->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_spatializer_listener_uninit(ma_spatializer_listener* pListener, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    if (pListener->_ownsHeap) {
+        ma_free(pListener->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_channel* ma_spatializer_listener_get_channel_map(ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return NULL;
+    }
+
+    return pListener->config.pChannelMapOut;
+}
+
+MA_API void ma_spatializer_listener_set_cone(ma_spatializer_listener* pListener, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    pListener->config.coneInnerAngleInRadians = innerAngleInRadians;
+    pListener->config.coneOuterAngleInRadians = outerAngleInRadians;
+    pListener->config.coneOuterGain           = outerGain;
+}
+
+MA_API void ma_spatializer_listener_get_cone(const ma_spatializer_listener* pListener, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    if (pInnerAngleInRadians != NULL) {
+        *pInnerAngleInRadians = pListener->config.coneInnerAngleInRadians;
+    }
+
+    if (pOuterAngleInRadians != NULL) {
+        *pOuterAngleInRadians = pListener->config.coneOuterAngleInRadians;
+    }
+
+    if (pOuterGain != NULL) {
+        *pOuterGain = pListener->config.coneOuterGain;
+    }
+}
+
+MA_API void ma_spatializer_listener_set_position(ma_spatializer_listener* pListener, float x, float y, float z)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pListener->position, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_listener_get_position(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pListener->position); /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_listener_set_direction(ma_spatializer_listener* pListener, float x, float y, float z)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pListener->direction, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_listener_get_direction(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pListener->direction);    /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_listener_set_velocity(ma_spatializer_listener* pListener, float x, float y, float z)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pListener->velocity, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_listener_get_velocity(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pListener->velocity); /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_listener_set_speed_of_sound(ma_spatializer_listener* pListener, float speedOfSound)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    pListener->config.speedOfSound = speedOfSound;
+}
+
+MA_API float ma_spatializer_listener_get_speed_of_sound(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return 0;
+    }
+
+    return pListener->config.speedOfSound;
+}
+
+MA_API void ma_spatializer_listener_set_world_up(ma_spatializer_listener* pListener, float x, float y, float z)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    pListener->config.worldUp = ma_vec3f_init_3f(x, y, z);
+}
+
+MA_API ma_vec3f ma_spatializer_listener_get_world_up(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return ma_vec3f_init_3f(0, 1, 0);
+    }
+
+    return pListener->config.worldUp;
+}
+
+MA_API void ma_spatializer_listener_set_enabled(ma_spatializer_listener* pListener, ma_bool32 isEnabled)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    pListener->isEnabled = isEnabled;
+}
+
+MA_API ma_bool32 ma_spatializer_listener_is_enabled(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return MA_FALSE;
+    }
+
+    return pListener->isEnabled;
+}
+
+
+
+
+MA_API ma_spatializer_config ma_spatializer_config_init(ma_uint32 channelsIn, ma_uint32 channelsOut)
+{
+    ma_spatializer_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channelsIn                   = channelsIn;
+    config.channelsOut                  = channelsOut;
+    config.pChannelMapIn                = NULL;
+    config.attenuationModel             = ma_attenuation_model_inverse;
+    config.positioning                  = ma_positioning_absolute;
+    config.handedness                   = ma_handedness_right;
+    config.minGain                      = 0;
+    config.maxGain                      = 1;
+    config.minDistance                  = 1;
+    config.maxDistance                  = MA_FLT_MAX;
+    config.rolloff                      = 1;
+    config.coneInnerAngleInRadians      = 6.283185f; /* 360 degrees. */
+    config.coneOuterAngleInRadians      = 6.283185f; /* 360 degrees. */
+    config.coneOuterGain                = 0.0f;
+    config.dopplerFactor                = 1;
+    config.directionalAttenuationFactor = 1;
+    config.minSpatializationChannelGain = 0.2f;
+    config.gainSmoothTimeInFrames       = 360;       /* 7.5ms @ 48K. */
+
+    return config;
+}
+
+
+static ma_gainer_config ma_spatializer_gainer_config_init(const ma_spatializer_config* pConfig)
+{
+    MA_ASSERT(pConfig != NULL);
+    return ma_gainer_config_init(pConfig->channelsOut, pConfig->gainSmoothTimeInFrames);
+}
+
+static ma_result ma_spatializer_validate_config(const ma_spatializer_config* pConfig)
+{
+    MA_ASSERT(pConfig != NULL);
+
+    if (pConfig->channelsIn == 0 || pConfig->channelsOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t channelMapInOffset;
+    size_t newChannelGainsOffset;
+    size_t gainerOffset;
+} ma_spatializer_heap_layout;
+
+static ma_result ma_spatializer_get_heap_layout(const ma_spatializer_config* pConfig, ma_spatializer_heap_layout* pHeapLayout)
+{
+    ma_result result;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_spatializer_validate_config(pConfig);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Channel map. */
+    pHeapLayout->channelMapInOffset = MA_SIZE_MAX;  /* <-- MA_SIZE_MAX indicates no allocation necessary. */
+    if (pConfig->pChannelMapIn != NULL) {
+        pHeapLayout->channelMapInOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(sizeof(*pConfig->pChannelMapIn) * pConfig->channelsIn);
+    }
+
+    /* New channel gains for output. */
+    pHeapLayout->newChannelGainsOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(sizeof(float) * pConfig->channelsOut);
+
+    /* Gainer. */
+    {
+        size_t gainerHeapSizeInBytes;
+        ma_gainer_config gainerConfig;
+
+        gainerConfig = ma_spatializer_gainer_config_init(pConfig);
+
+        result = ma_gainer_get_heap_size(&gainerConfig, &gainerHeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->gainerOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(gainerHeapSizeInBytes);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_get_heap_size(const ma_spatializer_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_spatializer_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;  /* Safety. */
+
+    result = ma_spatializer_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_spatializer_init_preallocated(const ma_spatializer_config* pConfig, void* pHeap, ma_spatializer* pSpatializer)
+{
+    ma_result result;
+    ma_spatializer_heap_layout heapLayout;
+    ma_gainer_config gainerConfig;
+
+    if (pSpatializer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pSpatializer);
+
+    if (pConfig == NULL || pHeap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_spatializer_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pSpatializer->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pSpatializer->channelsIn                   = pConfig->channelsIn;
+    pSpatializer->channelsOut                  = pConfig->channelsOut;
+    pSpatializer->attenuationModel             = pConfig->attenuationModel;
+    pSpatializer->positioning                  = pConfig->positioning;
+    pSpatializer->handedness                   = pConfig->handedness;
+    pSpatializer->minGain                      = pConfig->minGain;
+    pSpatializer->maxGain                      = pConfig->maxGain;
+    pSpatializer->minDistance                  = pConfig->minDistance;
+    pSpatializer->maxDistance                  = pConfig->maxDistance;
+    pSpatializer->rolloff                      = pConfig->rolloff;
+    pSpatializer->coneInnerAngleInRadians      = pConfig->coneInnerAngleInRadians;
+    pSpatializer->coneOuterAngleInRadians      = pConfig->coneOuterAngleInRadians;
+    pSpatializer->coneOuterGain                = pConfig->coneOuterGain;
+    pSpatializer->dopplerFactor                = pConfig->dopplerFactor;
+    pSpatializer->minSpatializationChannelGain = pConfig->minSpatializationChannelGain;
+    pSpatializer->directionalAttenuationFactor = pConfig->directionalAttenuationFactor;
+    pSpatializer->gainSmoothTimeInFrames       = pConfig->gainSmoothTimeInFrames;
+    ma_atomic_vec3f_init(&pSpatializer->position,  ma_vec3f_init_3f(0, 0,  0));
+    ma_atomic_vec3f_init(&pSpatializer->direction, ma_vec3f_init_3f(0, 0, -1));
+    ma_atomic_vec3f_init(&pSpatializer->velocity,  ma_vec3f_init_3f(0, 0,  0));
+    pSpatializer->dopplerPitch                 = 1;
+
+    /* Swap the forward direction if we're left handed (it was initialized based on right handed). */
+    if (pSpatializer->handedness == ma_handedness_left) {
+        ma_vec3f negDir = ma_vec3f_neg(ma_spatializer_get_direction(pSpatializer));
+        ma_spatializer_set_direction(pSpatializer, negDir.x, negDir.y, negDir.z);
+    }
+
+    /* Channel map. This will be on the heap. */
+    if (pConfig->pChannelMapIn != NULL) {
+        pSpatializer->pChannelMapIn = (ma_channel*)ma_offset_ptr(pHeap, heapLayout.channelMapInOffset);
+        ma_channel_map_copy_or_default(pSpatializer->pChannelMapIn, pSpatializer->channelsIn, pConfig->pChannelMapIn, pSpatializer->channelsIn);
+    }
+
+    /* New channel gains for output channels. */
+    pSpatializer->pNewChannelGainsOut = (float*)ma_offset_ptr(pHeap, heapLayout.newChannelGainsOffset);
+
+    /* Gainer. */
+    gainerConfig = ma_spatializer_gainer_config_init(pConfig);
+
+    result = ma_gainer_init_preallocated(&gainerConfig, ma_offset_ptr(pHeap, heapLayout.gainerOffset), &pSpatializer->gainer);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the gainer. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_init(const ma_spatializer_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_spatializer* pSpatializer)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    /* We'll need a heap allocation to retrieve the size. */
+    result = ma_spatializer_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_spatializer_init_preallocated(pConfig, pHeap, pSpatializer);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pSpatializer->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_spatializer_uninit(ma_spatializer* pSpatializer, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_gainer_uninit(&pSpatializer->gainer, pAllocationCallbacks);
+
+    if (pSpatializer->_ownsHeap) {
+        ma_free(pSpatializer->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static float ma_calculate_angular_gain(ma_vec3f dirA, ma_vec3f dirB, float coneInnerAngleInRadians, float coneOuterAngleInRadians, float coneOuterGain)
+{
+    /*
+    Angular attenuation.
+
+    Unlike distance gain, the math for this is not specified by the OpenAL spec so we'll just go ahead and figure
+    this out for ourselves at the expense of possibly being inconsistent with other implementations.
+
+    To do cone attenuation, I'm just using the same math that we'd use to implement a basic spotlight in OpenGL. We
+    just need to get the direction from the source to the listener and then do a dot product against that and the
+    direction of the spotlight. Then we just compare that dot product against the cosine of the inner and outer
+    angles. If the dot product is greater than the outer angle, we just use coneOuterGain. If it's less than
+    the inner angle, we just use a gain of 1. Otherwise we linearly interpolate between 1 and coneOuterGain.
+    */
+    if (coneInnerAngleInRadians < 6.283185f) {
+        float angularGain = 1;
+        float cutoffInner = (float)ma_cosd(coneInnerAngleInRadians*0.5f);
+        float cutoffOuter = (float)ma_cosd(coneOuterAngleInRadians*0.5f);
+        float d;
+
+        d = ma_vec3f_dot(dirA, dirB);
+
+        if (d > cutoffInner) {
+            /* It's inside the inner angle. */
+            angularGain = 1;
+        } else {
+            /* It's outside the inner angle. */
+            if (d > cutoffOuter) {
+                /* It's between the inner and outer angle. We need to linearly interpolate between 1 and coneOuterGain. */
+                angularGain = ma_mix_f32(coneOuterGain, 1, (d - cutoffOuter) / (cutoffInner - cutoffOuter));
+            } else {
+                /* It's outside the outer angle. */
+                angularGain = coneOuterGain;
+            }
+        }
+
+        /*printf("d = %f; cutoffInner = %f; cutoffOuter = %f; angularGain = %f\n", d, cutoffInner, cutoffOuter, angularGain);*/
+        return angularGain;
+    } else {
+        /* Inner angle is 360 degrees so no need to do any attenuation. */
+        return 1;
+    }
+}
+
+MA_API ma_result ma_spatializer_process_pcm_frames(ma_spatializer* pSpatializer, ma_spatializer_listener* pListener, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_channel* pChannelMapIn  = pSpatializer->pChannelMapIn;
+    ma_channel* pChannelMapOut = pListener->config.pChannelMapOut;
+
+    if (pSpatializer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If we're not spatializing we need to run an optimized path. */
+    if (ma_atomic_load_i32(&pSpatializer->attenuationModel) == ma_attenuation_model_none) {
+        if (ma_spatializer_listener_is_enabled(pListener)) {
+            /* No attenuation is required, but we'll need to do some channel conversion. */
+            if (pSpatializer->channelsIn == pSpatializer->channelsOut) {
+                ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, ma_format_f32, pSpatializer->channelsIn);
+            } else {
+                ma_channel_map_apply_f32((float*)pFramesOut, pChannelMapOut, pSpatializer->channelsOut, (const float*)pFramesIn, pChannelMapIn, pSpatializer->channelsIn, frameCount, ma_channel_mix_mode_rectangular, ma_mono_expansion_mode_default);   /* Safe casts to float* because f32 is the only supported format. */
+            }
+        } else {
+            /* The listener is disabled. Output silence. */
+            ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, pSpatializer->channelsOut);
+        }
+
+        /*
+        We're not doing attenuation so don't bother with doppler for now. I'm not sure if this is
+        the correct thinking so might need to review this later.
+        */
+        pSpatializer->dopplerPitch = 1;
+    } else {
+        /*
+        Let's first determine which listener the sound is closest to. Need to keep in mind that we
+        might not have a world or any listeners, in which case we just spatializer based on the
+        listener being positioned at the origin (0, 0, 0).
+        */
+        ma_vec3f relativePosNormalized;
+        ma_vec3f relativePos;   /* The position relative to the listener. */
+        ma_vec3f relativeDir;   /* The direction of the sound, relative to the listener. */
+        ma_vec3f listenerVel;   /* The velocity of the listener. For doppler pitch calculation. */
+        float speedOfSound;
+        float distance = 0;
+        float gain = 1;
+        ma_uint32 iChannel;
+        const ma_uint32 channelsOut = pSpatializer->channelsOut;
+        const ma_uint32 channelsIn  = pSpatializer->channelsIn;
+        float minDistance = ma_spatializer_get_min_distance(pSpatializer);
+        float maxDistance = ma_spatializer_get_max_distance(pSpatializer);
+        float rolloff = ma_spatializer_get_rolloff(pSpatializer);
+        float dopplerFactor = ma_spatializer_get_doppler_factor(pSpatializer);
+
+        /*
+        We'll need the listener velocity for doppler pitch calculations. The speed of sound is
+        defined by the listener, so we'll grab that here too.
+        */
+        if (pListener != NULL) {
+            listenerVel  = ma_spatializer_listener_get_velocity(pListener);
+            speedOfSound = pListener->config.speedOfSound;
+        } else {
+            listenerVel  = ma_vec3f_init_3f(0, 0, 0);
+            speedOfSound = MA_DEFAULT_SPEED_OF_SOUND;
+        }
+
+        if (pListener == NULL || ma_spatializer_get_positioning(pSpatializer) == ma_positioning_relative) {
+            /* There's no listener or we're using relative positioning. */
+            relativePos = ma_spatializer_get_position(pSpatializer);
+            relativeDir = ma_spatializer_get_direction(pSpatializer);
+        } else {
+            /*
+            We've found a listener and we're using absolute positioning. We need to transform the
+            sound's position and direction so that it's relative to listener. Later on we'll use
+            this for determining the factors to apply to each channel to apply the panning effect.
+            */
+            ma_spatializer_get_relative_position_and_direction(pSpatializer, pListener, &relativePos, &relativeDir);
+        }
+
+        distance = ma_vec3f_len(relativePos);
+
+        /* We've gathered the data, so now we can apply some spatialization. */
+        switch (ma_spatializer_get_attenuation_model(pSpatializer)) {
+            case ma_attenuation_model_inverse:
+            {
+                gain = ma_attenuation_inverse(distance, minDistance, maxDistance, rolloff);
+            } break;
+            case ma_attenuation_model_linear:
+            {
+                gain = ma_attenuation_linear(distance, minDistance, maxDistance, rolloff);
+            } break;
+            case ma_attenuation_model_exponential:
+            {
+                gain = ma_attenuation_exponential(distance, minDistance, maxDistance, rolloff);
+            } break;
+            case ma_attenuation_model_none:
+            default:
+            {
+                gain = 1;
+            } break;
+        }
+
+        /* Normalize the position. */
+        if (distance > 0.001f) {
+            float distanceInv = 1/distance;
+            relativePosNormalized    = relativePos;
+            relativePosNormalized.x *= distanceInv;
+            relativePosNormalized.y *= distanceInv;
+            relativePosNormalized.z *= distanceInv;
+        } else {
+            distance = 0;
+            relativePosNormalized = ma_vec3f_init_3f(0, 0, 0);
+        }
+
+        /*
+        Angular attenuation.
+
+        Unlike distance gain, the math for this is not specified by the OpenAL spec so we'll just go ahead and figure
+        this out for ourselves at the expense of possibly being inconsistent with other implementations.
+
+        To do cone attenuation, I'm just using the same math that we'd use to implement a basic spotlight in OpenGL. We
+        just need to get the direction from the source to the listener and then do a dot product against that and the
+        direction of the spotlight. Then we just compare that dot product against the cosine of the inner and outer
+        angles. If the dot product is greater than the outer angle, we just use coneOuterGain. If it's less than
+        the inner angle, we just use a gain of 1. Otherwise we linearly interpolate between 1 and coneOuterGain.
+        */
+        if (distance > 0) {
+            /* Source angular gain. */
+            float spatializerConeInnerAngle;
+            float spatializerConeOuterAngle;
+            float spatializerConeOuterGain;
+            ma_spatializer_get_cone(pSpatializer, &spatializerConeInnerAngle, &spatializerConeOuterAngle, &spatializerConeOuterGain);
+
+            gain *= ma_calculate_angular_gain(relativeDir, ma_vec3f_neg(relativePosNormalized), spatializerConeInnerAngle, spatializerConeOuterAngle, spatializerConeOuterGain);
+
+            /*
+            We're supporting angular gain on the listener as well for those who want to reduce the volume of sounds that
+            are positioned behind the listener. On default settings, this will have no effect.
+            */
+            if (pListener != NULL && pListener->config.coneInnerAngleInRadians < 6.283185f) {
+                ma_vec3f listenerDirection;
+                float listenerInnerAngle;
+                float listenerOuterAngle;
+                float listenerOuterGain;
+
+                if (pListener->config.handedness == ma_handedness_right) {
+                    listenerDirection = ma_vec3f_init_3f(0, 0, -1);
+                } else {
+                    listenerDirection = ma_vec3f_init_3f(0, 0, +1);
+                }
+
+                listenerInnerAngle = pListener->config.coneInnerAngleInRadians;
+                listenerOuterAngle = pListener->config.coneOuterAngleInRadians;
+                listenerOuterGain  = pListener->config.coneOuterGain;
+
+                gain *= ma_calculate_angular_gain(listenerDirection, relativePosNormalized, listenerInnerAngle, listenerOuterAngle, listenerOuterGain);
+            }
+        } else {
+            /* The sound is right on top of the listener. Don't do any angular attenuation. */
+        }
+
+
+        /* Clamp the gain. */
+        gain = ma_clamp(gain, ma_spatializer_get_min_gain(pSpatializer), ma_spatializer_get_max_gain(pSpatializer));
+
+        /*
+        The gain needs to be applied per-channel here. The spatialization code below will be changing the per-channel
+        gains which will then eventually be passed into the gainer which will deal with smoothing the gain transitions
+        to avoid harsh changes in gain.
+        */
+        for (iChannel = 0; iChannel < channelsOut; iChannel += 1) {
+            pSpatializer->pNewChannelGainsOut[iChannel] = gain;
+        }
+
+        /*
+        Convert to our output channel count. If the listener is disabled we just output silence here. We cannot ignore
+        the whole section of code here because we need to update some internal spatialization state.
+        */
+        if (ma_spatializer_listener_is_enabled(pListener)) {
+            ma_channel_map_apply_f32((float*)pFramesOut, pChannelMapOut, channelsOut, (const float*)pFramesIn, pChannelMapIn, channelsIn, frameCount, ma_channel_mix_mode_rectangular, ma_mono_expansion_mode_default);
+        } else {
+            ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, pSpatializer->channelsOut);
+        }
+
+
+        /*
+        Panning. This is where we'll apply the gain and convert to the output channel count. We have an optimized path for
+        when we're converting to a mono stream. In that case we don't really need to do any panning - we just apply the
+        gain to the final output.
+        */
+        /*printf("distance=%f; gain=%f\n", distance, gain);*/
+
+        /* We must have a valid channel map here to ensure we spatialize properly. */
+        MA_ASSERT(pChannelMapOut != NULL);
+
+        /*
+        We're not converting to mono so we'll want to apply some panning. This is where the feeling of something being
+        to the left, right, infront or behind the listener is calculated. I'm just using a basic model here. Note that
+        the code below is not based on any specific algorithm. I'm just implementing this off the top of my head and
+        seeing how it goes. There might be better ways to do this.
+
+        To determine the direction of the sound relative to a speaker I'm using dot products. Each speaker is given a
+        direction. For example, the left channel in a stereo system will be -1 on the X axis and the right channel will
+        be +1 on the X axis. A dot product is performed against the direction vector of the channel and the normalized
+        position of the sound.
+        */
+
+        /*
+        Calculate our per-channel gains. We do this based on the normalized relative position of the sound and it's
+        relation to the direction of the channel.
+        */
+        if (distance > 0) {
+            ma_vec3f unitPos = relativePos;
+            float distanceInv = 1/distance;
+            unitPos.x *= distanceInv;
+            unitPos.y *= distanceInv;
+            unitPos.z *= distanceInv;
+
+            for (iChannel = 0; iChannel < channelsOut; iChannel += 1) {
+                ma_channel channelOut;
+                float d;
+                float dMin;
+
+                channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannel);
+                if (ma_is_spatial_channel_position(channelOut)) {
+                    d = ma_mix_f32_fast(1, ma_vec3f_dot(unitPos, ma_get_channel_direction(channelOut)), ma_spatializer_get_directional_attenuation_factor(pSpatializer));
+                } else {
+                    d = 1;  /* It's not a spatial channel so there's no real notion of direction. */
+                }
+
+                /*
+                In my testing, if the panning effect is too aggressive it makes spatialization feel uncomfortable.
+                The "dMin" variable below is used to control the aggressiveness of the panning effect. When set to
+                0, panning will be most extreme and any sounds that are positioned on the opposite side of the
+                speaker will be completely silent from that speaker. Not only does this feel uncomfortable, it
+                doesn't even remotely represent the real world at all because sounds that come from your right side
+                are still clearly audible from your left side. Setting "dMin" to 1 will result in no panning at
+                all, which is also not ideal. By setting it to something greater than 0, the spatialization effect
+                becomes much less dramatic and a lot more bearable.
+
+                Summary: 0 = more extreme panning; 1 = no panning.
+                */
+                dMin = pSpatializer->minSpatializationChannelGain;
+
+                /*
+                At this point, "d" will be positive if the sound is on the same side as the channel and negative if
+                it's on the opposite side. It will be in the range of -1..1. There's two ways I can think of to
+                calculate a panning value. The first is to simply convert it to 0..1, however this has a problem
+                which I'm not entirely happy with. Considering a stereo system, when a sound is positioned right
+                in front of the listener it'll result in each speaker getting a gain of 0.5. I don't know if I like
+                the idea of having a scaling factor of 0.5 being applied to a sound when it's sitting right in front
+                of the listener. I would intuitively expect that to be played at full volume, or close to it.
+
+                The second idea I think of is to only apply a reduction in gain when the sound is on the opposite
+                side of the speaker. That is, reduce the gain only when the dot product is negative. The problem
+                with this is that there will not be any attenuation as the sound sweeps around the 180 degrees
+                where the dot product is positive. The idea with this option is that you leave the gain at 1 when
+                the sound is being played on the same side as the speaker and then you just reduce the volume when
+                the sound is on the other side.
+
+                The summarize, I think the first option should give a better sense of spatialization, but the second
+                option is better for preserving the sound's power.
+
+                UPDATE: In my testing, I find the first option to sound better. You can feel the sense of space a
+                bit better, but you can also hear the reduction in volume when it's right in front.
+                */
+                #if 1
+                {
+                    /*
+                    Scale the dot product from -1..1 to 0..1. Will result in a sound directly in front losing power
+                    by being played at 0.5 gain.
+                    */
+                    d = (d + 1) * 0.5f;  /* -1..1 to 0..1 */
+                    d = ma_max(d, dMin);
+                    pSpatializer->pNewChannelGainsOut[iChannel] *= d;
+                }
+                #else
+                {
+                    /*
+                    Only reduce the volume of the sound if it's on the opposite side. This path keeps the volume more
+                    consistent, but comes at the expense of a worse sense of space and positioning.
+                    */
+                    if (d < 0) {
+                        d += 1; /* Move into the positive range. */
+                        d = ma_max(d, dMin);
+                        channelGainsOut[iChannel] *= d;
+                    }
+                }
+                #endif
+            }
+        } else {
+            /* Assume the sound is right on top of us. Don't do any panning. */
+        }
+
+        /* Now we need to apply the volume to each channel. This needs to run through the gainer to ensure we get a smooth volume transition. */
+        ma_gainer_set_gains(&pSpatializer->gainer, pSpatializer->pNewChannelGainsOut);
+        ma_gainer_process_pcm_frames(&pSpatializer->gainer, pFramesOut, pFramesOut, frameCount);
+
+        /*
+        Before leaving we'll want to update our doppler pitch so that the caller can apply some
+        pitch shifting if they desire. Note that we need to negate the relative position here
+        because the doppler calculation needs to be source-to-listener, but ours is listener-to-
+        source.
+        */
+        if (dopplerFactor > 0) {
+            pSpatializer->dopplerPitch = ma_doppler_pitch(ma_vec3f_sub(ma_spatializer_listener_get_position(pListener), ma_spatializer_get_position(pSpatializer)), ma_spatializer_get_velocity(pSpatializer), listenerVel, speedOfSound, dopplerFactor);
+        } else {
+            pSpatializer->dopplerPitch = 1;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_set_master_volume(ma_spatializer* pSpatializer, float volume)
+{
+    if (pSpatializer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_gainer_set_master_volume(&pSpatializer->gainer, volume);
+}
+
+MA_API ma_result ma_spatializer_get_master_volume(const ma_spatializer* pSpatializer, float* pVolume)
+{
+    if (pSpatializer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_gainer_get_master_volume(&pSpatializer->gainer, pVolume);
+}
+
+MA_API ma_uint32 ma_spatializer_get_input_channels(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return pSpatializer->channelsIn;
+}
+
+MA_API ma_uint32 ma_spatializer_get_output_channels(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return pSpatializer->channelsOut;
+}
+
+MA_API void ma_spatializer_set_attenuation_model(ma_spatializer* pSpatializer, ma_attenuation_model attenuationModel)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_i32(&pSpatializer->attenuationModel, attenuationModel);
+}
+
+MA_API ma_attenuation_model ma_spatializer_get_attenuation_model(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_attenuation_model_none;
+    }
+
+    return (ma_attenuation_model)ma_atomic_load_i32(&pSpatializer->attenuationModel);
+}
+
+MA_API void ma_spatializer_set_positioning(ma_spatializer* pSpatializer, ma_positioning positioning)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_i32(&pSpatializer->positioning, positioning);
+}
+
+MA_API ma_positioning ma_spatializer_get_positioning(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_positioning_absolute;
+    }
+
+    return (ma_positioning)ma_atomic_load_i32(&pSpatializer->positioning);
+}
+
+MA_API void ma_spatializer_set_rolloff(ma_spatializer* pSpatializer, float rolloff)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->rolloff, rolloff);
+}
+
+MA_API float ma_spatializer_get_rolloff(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->rolloff);
+}
+
+MA_API void ma_spatializer_set_min_gain(ma_spatializer* pSpatializer, float minGain)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->minGain, minGain);
+}
+
+MA_API float ma_spatializer_get_min_gain(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->minGain);
+}
+
+MA_API void ma_spatializer_set_max_gain(ma_spatializer* pSpatializer, float maxGain)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->maxGain, maxGain);
+}
+
+MA_API float ma_spatializer_get_max_gain(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->maxGain);
+}
+
+MA_API void ma_spatializer_set_min_distance(ma_spatializer* pSpatializer, float minDistance)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->minDistance, minDistance);
+}
+
+MA_API float ma_spatializer_get_min_distance(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->minDistance);
+}
+
+MA_API void ma_spatializer_set_max_distance(ma_spatializer* pSpatializer, float maxDistance)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->maxDistance, maxDistance);
+}
+
+MA_API float ma_spatializer_get_max_distance(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->maxDistance);
+}
+
+MA_API void ma_spatializer_set_cone(ma_spatializer* pSpatializer, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->coneInnerAngleInRadians, innerAngleInRadians);
+    ma_atomic_exchange_f32(&pSpatializer->coneOuterAngleInRadians, outerAngleInRadians);
+    ma_atomic_exchange_f32(&pSpatializer->coneOuterGain,           outerGain);
+}
+
+MA_API void ma_spatializer_get_cone(const ma_spatializer* pSpatializer, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    if (pInnerAngleInRadians != NULL) {
+        *pInnerAngleInRadians = ma_atomic_load_f32(&pSpatializer->coneInnerAngleInRadians);
+    }
+
+    if (pOuterAngleInRadians != NULL) {
+        *pOuterAngleInRadians = ma_atomic_load_f32(&pSpatializer->coneOuterAngleInRadians);
+    }
+
+    if (pOuterGain != NULL) {
+        *pOuterGain = ma_atomic_load_f32(&pSpatializer->coneOuterGain);
+    }
+}
+
+MA_API void ma_spatializer_set_doppler_factor(ma_spatializer* pSpatializer, float dopplerFactor)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->dopplerFactor, dopplerFactor);
+}
+
+MA_API float ma_spatializer_get_doppler_factor(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 1;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->dopplerFactor);
+}
+
+MA_API void ma_spatializer_set_directional_attenuation_factor(ma_spatializer* pSpatializer, float directionalAttenuationFactor)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->directionalAttenuationFactor, directionalAttenuationFactor);
+}
+
+MA_API float ma_spatializer_get_directional_attenuation_factor(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 1;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->directionalAttenuationFactor);
+}
+
+MA_API void ma_spatializer_set_position(ma_spatializer* pSpatializer, float x, float y, float z)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pSpatializer->position, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_get_position(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pSpatializer->position);  /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_set_direction(ma_spatializer* pSpatializer, float x, float y, float z)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pSpatializer->direction, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_get_direction(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pSpatializer->direction); /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_set_velocity(ma_spatializer* pSpatializer, float x, float y, float z)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pSpatializer->velocity, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_get_velocity(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pSpatializer->velocity);  /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_get_relative_position_and_direction(const ma_spatializer* pSpatializer, const ma_spatializer_listener* pListener, ma_vec3f* pRelativePos, ma_vec3f* pRelativeDir)
+{
+    if (pRelativePos != NULL) {
+        pRelativePos->x = 0;
+        pRelativePos->y = 0;
+        pRelativePos->z = 0;
+    }
+
+    if (pRelativeDir != NULL) {
+        pRelativeDir->x = 0;
+        pRelativeDir->y = 0;
+        pRelativeDir->z = -1;
+    }
+
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    if (pListener == NULL || ma_spatializer_get_positioning(pSpatializer) == ma_positioning_relative) {
+        /* There's no listener or we're using relative positioning. */
+        if (pRelativePos != NULL) {
+            *pRelativePos = ma_spatializer_get_position(pSpatializer);
+        }
+        if (pRelativeDir != NULL) {
+            *pRelativeDir = ma_spatializer_get_direction(pSpatializer);
+        }
+    } else {
+        ma_vec3f spatializerPosition;
+        ma_vec3f spatializerDirection;
+        ma_vec3f listenerPosition;
+        ma_vec3f listenerDirection;
+        ma_vec3f v;
+        ma_vec3f axisX;
+        ma_vec3f axisY;
+        ma_vec3f axisZ;
+        float m[4][4];
+
+        spatializerPosition  = ma_spatializer_get_position(pSpatializer);
+        spatializerDirection = ma_spatializer_get_direction(pSpatializer);
+        listenerPosition     = ma_spatializer_listener_get_position(pListener);
+        listenerDirection    = ma_spatializer_listener_get_direction(pListener);
+
+        /*
+        We need to calculate the right vector from our forward and up vectors. This is done with
+        a cross product.
+        */
+        axisZ = ma_vec3f_normalize(listenerDirection);                                  /* Normalization required here because we can't trust the caller. */
+        axisX = ma_vec3f_normalize(ma_vec3f_cross(axisZ, pListener->config.worldUp));   /* Normalization required here because the world up vector may not be perpendicular with the forward vector. */
+
+        /*
+        The calculation of axisX above can result in a zero-length vector if the listener is
+        looking straight up on the Y axis. We'll need to fall back to a +X in this case so that
+        the calculations below don't fall apart. This is where a quaternion based listener and
+        sound orientation would come in handy.
+        */
+        if (ma_vec3f_len2(axisX) == 0) {
+            axisX = ma_vec3f_init_3f(1, 0, 0);
+        }
+
+        axisY = ma_vec3f_cross(axisX, axisZ);                                           /* No normalization is required here because axisX and axisZ are unit length and perpendicular. */
+
+        /*
+        We need to swap the X axis if we're left handed because otherwise the cross product above
+        will have resulted in it pointing in the wrong direction (right handed was assumed in the
+        cross products above).
+        */
+        if (pListener->config.handedness == ma_handedness_left) {
+            axisX = ma_vec3f_neg(axisX);
+        }
+
+        /* Lookat. */
+        m[0][0] =  axisX.x; m[1][0] =  axisX.y; m[2][0] =  axisX.z; m[3][0] = -ma_vec3f_dot(axisX,               listenerPosition);
+        m[0][1] =  axisY.x; m[1][1] =  axisY.y; m[2][1] =  axisY.z; m[3][1] = -ma_vec3f_dot(axisY,               listenerPosition);
+        m[0][2] = -axisZ.x; m[1][2] = -axisZ.y; m[2][2] = -axisZ.z; m[3][2] = -ma_vec3f_dot(ma_vec3f_neg(axisZ), listenerPosition);
+        m[0][3] = 0;        m[1][3] = 0;        m[2][3] = 0;        m[3][3] = 1;
+
+        /*
+        Multiply the lookat matrix by the spatializer position to transform it to listener
+        space. This allows calculations to work based on the sound being relative to the
+        origin which makes things simpler.
+        */
+        if (pRelativePos != NULL) {
+            v = spatializerPosition;
+            pRelativePos->x = m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * 1;
+            pRelativePos->y = m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * 1;
+            pRelativePos->z = m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * 1;
+        }
+
+        /*
+        The direction of the sound needs to also be transformed so that it's relative to the
+        rotation of the listener.
+        */
+        if (pRelativeDir != NULL) {
+            v = spatializerDirection;
+            pRelativeDir->x = m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z;
+            pRelativeDir->y = m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z;
+            pRelativeDir->z = m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z;
+        }
+    }
+}
+
+
+
+
+/**************************************************************************************************************************************************************
+
+Resampling
+
+**************************************************************************************************************************************************************/
+MA_API ma_linear_resampler_config ma_linear_resampler_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    ma_linear_resampler_config config;
+    MA_ZERO_OBJECT(&config);
+    config.format           = format;
+    config.channels         = channels;
+    config.sampleRateIn     = sampleRateIn;
+    config.sampleRateOut    = sampleRateOut;
+    config.lpfOrder         = ma_min(MA_DEFAULT_RESAMPLER_LPF_ORDER, MA_MAX_FILTER_ORDER);
+    config.lpfNyquistFactor = 1;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t x0Offset;
+    size_t x1Offset;
+    size_t lpfOffset;
+} ma_linear_resampler_heap_layout;
+
+
+static void ma_linear_resampler_adjust_timer_for_new_rate(ma_linear_resampler* pResampler, ma_uint32 oldSampleRateOut, ma_uint32 newSampleRateOut)
+{
+    /*
+    So what's happening here? Basically we need to adjust the fractional component of the time advance based on the new rate. The old time advance will
+    be based on the old sample rate, but we are needing to adjust it to that it's based on the new sample rate.
+    */
+    ma_uint32 oldRateTimeWhole = pResampler->inTimeFrac / oldSampleRateOut;  /* <-- This should almost never be anything other than 0, but leaving it here to make this more general and robust just in case. */
+    ma_uint32 oldRateTimeFract = pResampler->inTimeFrac % oldSampleRateOut;
+
+    pResampler->inTimeFrac =
+         (oldRateTimeWhole * newSampleRateOut) +
+        ((oldRateTimeFract * newSampleRateOut) / oldSampleRateOut);
+
+    /* Make sure the fractional part is less than the output sample rate. */
+    pResampler->inTimeInt += pResampler->inTimeFrac / pResampler->config.sampleRateOut;
+    pResampler->inTimeFrac = pResampler->inTimeFrac % pResampler->config.sampleRateOut;
+}
+
+static ma_result ma_linear_resampler_set_rate_internal(ma_linear_resampler* pResampler, void* pHeap, ma_linear_resampler_heap_layout* pHeapLayout, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut, ma_bool32 isResamplerAlreadyInitialized)
+{
+    ma_result result;
+    ma_uint32 gcf;
+    ma_uint32 lpfSampleRate;
+    double lpfCutoffFrequency;
+    ma_lpf_config lpfConfig;
+    ma_uint32 oldSampleRateOut; /* Required for adjusting time advance down the bottom. */
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (sampleRateIn == 0 || sampleRateOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    oldSampleRateOut = pResampler->config.sampleRateOut;
+
+    pResampler->config.sampleRateIn  = sampleRateIn;
+    pResampler->config.sampleRateOut = sampleRateOut;
+
+    /* Simplify the sample rate. */
+    gcf = ma_gcf_u32(pResampler->config.sampleRateIn, pResampler->config.sampleRateOut);
+    pResampler->config.sampleRateIn  /= gcf;
+    pResampler->config.sampleRateOut /= gcf;
+
+    /* Always initialize the low-pass filter, even when the order is 0. */
+    if (pResampler->config.lpfOrder > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    lpfSampleRate      = (ma_uint32)(ma_max(pResampler->config.sampleRateIn, pResampler->config.sampleRateOut));
+    lpfCutoffFrequency = (   double)(ma_min(pResampler->config.sampleRateIn, pResampler->config.sampleRateOut) * 0.5 * pResampler->config.lpfNyquistFactor);
+
+    lpfConfig = ma_lpf_config_init(pResampler->config.format, pResampler->config.channels, lpfSampleRate, lpfCutoffFrequency, pResampler->config.lpfOrder);
+
+    /*
+    If the resampler is already initialized we don't want to do a fresh initialization of the low-pass filter because it will result in the cached frames
+    getting cleared. Instead we re-initialize the filter which will maintain any cached frames.
+    */
+    if (isResamplerAlreadyInitialized) {
+        result = ma_lpf_reinit(&lpfConfig, &pResampler->lpf);
+    } else {
+        result = ma_lpf_init_preallocated(&lpfConfig, ma_offset_ptr(pHeap, pHeapLayout->lpfOffset), &pResampler->lpf);
+    }
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+
+    pResampler->inAdvanceInt  = pResampler->config.sampleRateIn / pResampler->config.sampleRateOut;
+    pResampler->inAdvanceFrac = pResampler->config.sampleRateIn % pResampler->config.sampleRateOut;
+
+    /* Our timer was based on the old rate. We need to adjust it so that it's based on the new rate. */
+    ma_linear_resampler_adjust_timer_for_new_rate(pResampler, oldSampleRateOut, pResampler->config.sampleRateOut);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_get_heap_layout(const ma_linear_resampler_config* pConfig, ma_linear_resampler_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* x0 */
+    pHeapLayout->x0Offset = pHeapLayout->sizeInBytes;
+    if (pConfig->format == ma_format_f32) {
+        pHeapLayout->sizeInBytes += sizeof(float) * pConfig->channels;
+    } else {
+        pHeapLayout->sizeInBytes += sizeof(ma_int16) * pConfig->channels;
+    }
+
+    /* x1 */
+    pHeapLayout->x1Offset = pHeapLayout->sizeInBytes;
+    if (pConfig->format == ma_format_f32) {
+        pHeapLayout->sizeInBytes += sizeof(float) * pConfig->channels;
+    } else {
+        pHeapLayout->sizeInBytes += sizeof(ma_int16) * pConfig->channels;
+    }
+
+    /* LPF */
+    pHeapLayout->lpfOffset = ma_align_64(pHeapLayout->sizeInBytes);
+    {
+        ma_result result;
+        size_t lpfHeapSizeInBytes;
+        ma_lpf_config lpfConfig = ma_lpf_config_init(pConfig->format, pConfig->channels, 1, 1, pConfig->lpfOrder);  /* Sample rate and cutoff frequency do not matter. */
+
+        result = ma_lpf_get_heap_size(&lpfConfig, &lpfHeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += lpfHeapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_get_heap_size(const ma_linear_resampler_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_linear_resampler_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_linear_resampler_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_init_preallocated(const ma_linear_resampler_config* pConfig, void* pHeap, ma_linear_resampler* pResampler)
+{
+    ma_result result;
+    ma_linear_resampler_heap_layout heapLayout;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pResampler);
+
+    result = ma_linear_resampler_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pResampler->config = *pConfig;
+
+    pResampler->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    if (pConfig->format == ma_format_f32) {
+        pResampler->x0.f32 = (float*)ma_offset_ptr(pHeap, heapLayout.x0Offset);
+        pResampler->x1.f32 = (float*)ma_offset_ptr(pHeap, heapLayout.x1Offset);
+    } else {
+        pResampler->x0.s16 = (ma_int16*)ma_offset_ptr(pHeap, heapLayout.x0Offset);
+        pResampler->x1.s16 = (ma_int16*)ma_offset_ptr(pHeap, heapLayout.x1Offset);
+    }
+
+    /* Setting the rate will set up the filter and time advances for us. */
+    result = ma_linear_resampler_set_rate_internal(pResampler, pHeap, &heapLayout, pConfig->sampleRateIn, pConfig->sampleRateOut, /* isResamplerAlreadyInitialized = */ MA_FALSE);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pResampler->inTimeInt  = 1;  /* Set this to one to force an input sample to always be loaded for the first output frame. */
+    pResampler->inTimeFrac = 0;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_init(const ma_linear_resampler_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_linear_resampler* pResampler)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_linear_resampler_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_linear_resampler_init_preallocated(pConfig, pHeap, pResampler);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pResampler->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_linear_resampler_uninit(ma_linear_resampler* pResampler, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pResampler == NULL) {
+        return;
+    }
+
+    ma_lpf_uninit(&pResampler->lpf, pAllocationCallbacks);
+
+    if (pResampler->_ownsHeap) {
+        ma_free(pResampler->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static MA_INLINE ma_int16 ma_linear_resampler_mix_s16(ma_int16 x, ma_int16 y, ma_int32 a, const ma_int32 shift)
+{
+    ma_int32 b;
+    ma_int32 c;
+    ma_int32 r;
+
+    MA_ASSERT(a <= (1<<shift));
+
+    b = x * ((1<<shift) - a);
+    c = y * a;
+    r = b + c;
+
+    return (ma_int16)(r >> shift);
+}
+
+static void ma_linear_resampler_interpolate_frame_s16(ma_linear_resampler* pResampler, ma_int16* MA_RESTRICT pFrameOut)
+{
+    ma_uint32 c;
+    ma_uint32 a;
+    const ma_uint32 channels = pResampler->config.channels;
+    const ma_uint32 shift = 12;
+
+    MA_ASSERT(pResampler != NULL);
+    MA_ASSERT(pFrameOut  != NULL);
+
+    a = (pResampler->inTimeFrac << shift) / pResampler->config.sampleRateOut;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        ma_int16 s = ma_linear_resampler_mix_s16(pResampler->x0.s16[c], pResampler->x1.s16[c], a, shift);
+        pFrameOut[c] = s;
+    }
+}
+
+
+static void ma_linear_resampler_interpolate_frame_f32(ma_linear_resampler* pResampler, float* MA_RESTRICT pFrameOut)
+{
+    ma_uint32 c;
+    float a;
+    const ma_uint32 channels = pResampler->config.channels;
+
+    MA_ASSERT(pResampler != NULL);
+    MA_ASSERT(pFrameOut  != NULL);
+
+    a = (float)pResampler->inTimeFrac / pResampler->config.sampleRateOut;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        float s = ma_mix_f32_fast(pResampler->x0.f32[c], pResampler->x1.f32[c], a);
+        pFrameOut[c] = s;
+    }
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_s16_downsample(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    const ma_int16* pFramesInS16;
+    /* */ ma_int16* pFramesOutS16;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pResampler     != NULL);
+    MA_ASSERT(pFrameCountIn  != NULL);
+    MA_ASSERT(pFrameCountOut != NULL);
+
+    pFramesInS16       = (const ma_int16*)pFramesIn;
+    pFramesOutS16      = (      ma_int16*)pFramesOut;
+    frameCountIn       = *pFrameCountIn;
+    frameCountOut      = *pFrameCountOut;
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        /* Before interpolating we need to load the buffers. When doing this we need to ensure we run every input sample through the filter. */
+        while (pResampler->inTimeInt > 0 && frameCountIn > framesProcessedIn) {
+            ma_uint32 iChannel;
+
+            if (pFramesInS16 != NULL) {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.s16[iChannel] = pResampler->x1.s16[iChannel];
+                    pResampler->x1.s16[iChannel] = pFramesInS16[iChannel];
+                }
+                pFramesInS16 += pResampler->config.channels;
+            } else {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.s16[iChannel] = pResampler->x1.s16[iChannel];
+                    pResampler->x1.s16[iChannel] = 0;
+                }
+            }
+
+            /* Filter. Do not apply filtering if sample rates are the same or else you'll get dangerous glitching. */
+            if (pResampler->config.sampleRateIn != pResampler->config.sampleRateOut) {
+                ma_lpf_process_pcm_frame_s16(&pResampler->lpf, pResampler->x1.s16, pResampler->x1.s16);
+            }
+
+            framesProcessedIn     += 1;
+            pResampler->inTimeInt -= 1;
+        }
+
+        if (pResampler->inTimeInt > 0) {
+            break;  /* Ran out of input data. */
+        }
+
+        /* Getting here means the frames have been loaded and filtered and we can generate the next output frame. */
+        if (pFramesOutS16 != NULL) {
+            MA_ASSERT(pResampler->inTimeInt == 0);
+            ma_linear_resampler_interpolate_frame_s16(pResampler, pFramesOutS16);
+
+            pFramesOutS16 += pResampler->config.channels;
+        }
+
+        framesProcessedOut += 1;
+
+        /* Advance time forward. */
+        pResampler->inTimeInt  += pResampler->inAdvanceInt;
+        pResampler->inTimeFrac += pResampler->inAdvanceFrac;
+        if (pResampler->inTimeFrac >= pResampler->config.sampleRateOut) {
+            pResampler->inTimeFrac -= pResampler->config.sampleRateOut;
+            pResampler->inTimeInt  += 1;
+        }
+    }
+
+    *pFrameCountIn  = framesProcessedIn;
+    *pFrameCountOut = framesProcessedOut;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_s16_upsample(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    const ma_int16* pFramesInS16;
+    /* */ ma_int16* pFramesOutS16;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pResampler     != NULL);
+    MA_ASSERT(pFrameCountIn  != NULL);
+    MA_ASSERT(pFrameCountOut != NULL);
+
+    pFramesInS16       = (const ma_int16*)pFramesIn;
+    pFramesOutS16      = (      ma_int16*)pFramesOut;
+    frameCountIn       = *pFrameCountIn;
+    frameCountOut      = *pFrameCountOut;
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        /* Before interpolating we need to load the buffers. */
+        while (pResampler->inTimeInt > 0 && frameCountIn > framesProcessedIn) {
+            ma_uint32 iChannel;
+
+            if (pFramesInS16 != NULL) {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.s16[iChannel] = pResampler->x1.s16[iChannel];
+                    pResampler->x1.s16[iChannel] = pFramesInS16[iChannel];
+                }
+                pFramesInS16 += pResampler->config.channels;
+            } else {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.s16[iChannel] = pResampler->x1.s16[iChannel];
+                    pResampler->x1.s16[iChannel] = 0;
+                }
+            }
+
+            framesProcessedIn     += 1;
+            pResampler->inTimeInt -= 1;
+        }
+
+        if (pResampler->inTimeInt > 0) {
+            break;  /* Ran out of input data. */
+        }
+
+        /* Getting here means the frames have been loaded and we can generate the next output frame. */
+        if (pFramesOutS16 != NULL) {
+            MA_ASSERT(pResampler->inTimeInt == 0);
+            ma_linear_resampler_interpolate_frame_s16(pResampler, pFramesOutS16);
+
+            /* Filter. Do not apply filtering if sample rates are the same or else you'll get dangerous glitching. */
+            if (pResampler->config.sampleRateIn != pResampler->config.sampleRateOut) {
+                ma_lpf_process_pcm_frame_s16(&pResampler->lpf, pFramesOutS16, pFramesOutS16);
+            }
+
+            pFramesOutS16 += pResampler->config.channels;
+        }
+
+        framesProcessedOut += 1;
+
+        /* Advance time forward. */
+        pResampler->inTimeInt  += pResampler->inAdvanceInt;
+        pResampler->inTimeFrac += pResampler->inAdvanceFrac;
+        if (pResampler->inTimeFrac >= pResampler->config.sampleRateOut) {
+            pResampler->inTimeFrac -= pResampler->config.sampleRateOut;
+            pResampler->inTimeInt  += 1;
+        }
+    }
+
+    *pFrameCountIn  = framesProcessedIn;
+    *pFrameCountOut = framesProcessedOut;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_s16(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    MA_ASSERT(pResampler != NULL);
+
+    if (pResampler->config.sampleRateIn > pResampler->config.sampleRateOut) {
+        return ma_linear_resampler_process_pcm_frames_s16_downsample(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else {
+        return ma_linear_resampler_process_pcm_frames_s16_upsample(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    }
+}
+
+
+static ma_result ma_linear_resampler_process_pcm_frames_f32_downsample(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    const float* pFramesInF32;
+    /* */ float* pFramesOutF32;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pResampler     != NULL);
+    MA_ASSERT(pFrameCountIn  != NULL);
+    MA_ASSERT(pFrameCountOut != NULL);
+
+    pFramesInF32       = (const float*)pFramesIn;
+    pFramesOutF32      = (      float*)pFramesOut;
+    frameCountIn       = *pFrameCountIn;
+    frameCountOut      = *pFrameCountOut;
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        /* Before interpolating we need to load the buffers. When doing this we need to ensure we run every input sample through the filter. */
+        while (pResampler->inTimeInt > 0 && frameCountIn > framesProcessedIn) {
+            ma_uint32 iChannel;
+
+            if (pFramesInF32 != NULL) {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.f32[iChannel] = pResampler->x1.f32[iChannel];
+                    pResampler->x1.f32[iChannel] = pFramesInF32[iChannel];
+                }
+                pFramesInF32 += pResampler->config.channels;
+            } else {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.f32[iChannel] = pResampler->x1.f32[iChannel];
+                    pResampler->x1.f32[iChannel] = 0;
+                }
+            }
+
+            /* Filter. Do not apply filtering if sample rates are the same or else you'll get dangerous glitching. */
+            if (pResampler->config.sampleRateIn != pResampler->config.sampleRateOut) {
+                ma_lpf_process_pcm_frame_f32(&pResampler->lpf, pResampler->x1.f32, pResampler->x1.f32);
+            }
+
+            framesProcessedIn     += 1;
+            pResampler->inTimeInt -= 1;
+        }
+
+        if (pResampler->inTimeInt > 0) {
+            break;  /* Ran out of input data. */
+        }
+
+        /* Getting here means the frames have been loaded and filtered and we can generate the next output frame. */
+        if (pFramesOutF32 != NULL) {
+            MA_ASSERT(pResampler->inTimeInt == 0);
+            ma_linear_resampler_interpolate_frame_f32(pResampler, pFramesOutF32);
+
+            pFramesOutF32 += pResampler->config.channels;
+        }
+
+        framesProcessedOut += 1;
+
+        /* Advance time forward. */
+        pResampler->inTimeInt  += pResampler->inAdvanceInt;
+        pResampler->inTimeFrac += pResampler->inAdvanceFrac;
+        if (pResampler->inTimeFrac >= pResampler->config.sampleRateOut) {
+            pResampler->inTimeFrac -= pResampler->config.sampleRateOut;
+            pResampler->inTimeInt  += 1;
+        }
+    }
+
+    *pFrameCountIn  = framesProcessedIn;
+    *pFrameCountOut = framesProcessedOut;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_f32_upsample(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    const float* pFramesInF32;
+    /* */ float* pFramesOutF32;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pResampler     != NULL);
+    MA_ASSERT(pFrameCountIn  != NULL);
+    MA_ASSERT(pFrameCountOut != NULL);
+
+    pFramesInF32       = (const float*)pFramesIn;
+    pFramesOutF32      = (      float*)pFramesOut;
+    frameCountIn       = *pFrameCountIn;
+    frameCountOut      = *pFrameCountOut;
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        /* Before interpolating we need to load the buffers. */
+        while (pResampler->inTimeInt > 0 && frameCountIn > framesProcessedIn) {
+            ma_uint32 iChannel;
+
+            if (pFramesInF32 != NULL) {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.f32[iChannel] = pResampler->x1.f32[iChannel];
+                    pResampler->x1.f32[iChannel] = pFramesInF32[iChannel];
+                }
+                pFramesInF32 += pResampler->config.channels;
+            } else {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.f32[iChannel] = pResampler->x1.f32[iChannel];
+                    pResampler->x1.f32[iChannel] = 0;
+                }
+            }
+
+            framesProcessedIn     += 1;
+            pResampler->inTimeInt -= 1;
+        }
+
+        if (pResampler->inTimeInt > 0) {
+            break;  /* Ran out of input data. */
+        }
+
+        /* Getting here means the frames have been loaded and we can generate the next output frame. */
+        if (pFramesOutF32 != NULL) {
+            MA_ASSERT(pResampler->inTimeInt == 0);
+            ma_linear_resampler_interpolate_frame_f32(pResampler, pFramesOutF32);
+
+            /* Filter. Do not apply filtering if sample rates are the same or else you'll get dangerous glitching. */
+            if (pResampler->config.sampleRateIn != pResampler->config.sampleRateOut) {
+                ma_lpf_process_pcm_frame_f32(&pResampler->lpf, pFramesOutF32, pFramesOutF32);
+            }
+
+            pFramesOutF32 += pResampler->config.channels;
+        }
+
+        framesProcessedOut += 1;
+
+        /* Advance time forward. */
+        pResampler->inTimeInt  += pResampler->inAdvanceInt;
+        pResampler->inTimeFrac += pResampler->inAdvanceFrac;
+        if (pResampler->inTimeFrac >= pResampler->config.sampleRateOut) {
+            pResampler->inTimeFrac -= pResampler->config.sampleRateOut;
+            pResampler->inTimeInt  += 1;
+        }
+    }
+
+    *pFrameCountIn  = framesProcessedIn;
+    *pFrameCountOut = framesProcessedOut;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_f32(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    MA_ASSERT(pResampler != NULL);
+
+    if (pResampler->config.sampleRateIn > pResampler->config.sampleRateOut) {
+        return ma_linear_resampler_process_pcm_frames_f32_downsample(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else {
+        return ma_linear_resampler_process_pcm_frames_f32_upsample(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    }
+}
+
+
+MA_API ma_result ma_linear_resampler_process_pcm_frames(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*  */ if (pResampler->config.format == ma_format_s16) {
+        return ma_linear_resampler_process_pcm_frames_s16(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else if (pResampler->config.format == ma_format_f32) {
+        return ma_linear_resampler_process_pcm_frames_f32(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else {
+        /* Should never get here. Getting here means the format is not supported and you didn't check the return value of ma_linear_resampler_init(). */
+        MA_ASSERT(MA_FALSE);
+        return MA_INVALID_ARGS;
+    }
+}
+
+
+MA_API ma_result ma_linear_resampler_set_rate(ma_linear_resampler* pResampler, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    return ma_linear_resampler_set_rate_internal(pResampler, NULL, NULL, sampleRateIn, sampleRateOut, /* isResamplerAlreadyInitialized = */ MA_TRUE);
+}
+
+MA_API ma_result ma_linear_resampler_set_rate_ratio(ma_linear_resampler* pResampler, float ratioInOut)
+{
+    ma_uint32 n;
+    ma_uint32 d;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ratioInOut <= 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    d = 1000000;
+    n = (ma_uint32)(ratioInOut * d);
+
+    if (n == 0) {
+        return MA_INVALID_ARGS; /* Ratio too small. */
+    }
+
+    MA_ASSERT(n != 0);
+
+    return ma_linear_resampler_set_rate(pResampler, n, d);
+}
+
+MA_API ma_uint64 ma_linear_resampler_get_input_latency(const ma_linear_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return 0;
+    }
+
+    return 1 + ma_lpf_get_latency(&pResampler->lpf);
+}
+
+MA_API ma_uint64 ma_linear_resampler_get_output_latency(const ma_linear_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return 0;
+    }
+
+    return ma_linear_resampler_get_input_latency(pResampler) * pResampler->config.sampleRateOut / pResampler->config.sampleRateIn;
+}
+
+MA_API ma_result ma_linear_resampler_get_required_input_frame_count(const ma_linear_resampler* pResampler, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount)
+{
+    ma_uint64 inputFrameCount;
+
+    if (pInputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pInputFrameCount = 0;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (outputFrameCount == 0) {
+        return MA_SUCCESS;
+    }
+
+    /* Any whole input frames are consumed before the first output frame is generated. */
+    inputFrameCount = pResampler->inTimeInt;
+    outputFrameCount -= 1;
+
+    /* The rest of the output frames can be calculated in constant time. */
+    inputFrameCount += outputFrameCount * pResampler->inAdvanceInt;
+    inputFrameCount += (pResampler->inTimeFrac + (outputFrameCount * pResampler->inAdvanceFrac)) / pResampler->config.sampleRateOut;
+
+    *pInputFrameCount = inputFrameCount;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_get_expected_output_frame_count(const ma_linear_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount)
+{
+    ma_uint64 outputFrameCount;
+    ma_uint64 preliminaryInputFrameCountFromFrac;
+    ma_uint64 preliminaryInputFrameCount;
+
+    if (pOutputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pOutputFrameCount = 0;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    The first step is to get a preliminary output frame count. This will either be exactly equal to what we need, or less by 1. We need to
+    determine how many input frames will be consumed by this value. If it's greater than our original input frame count it means we won't
+    be able to generate an extra frame because we will have run out of input data. Otherwise we will have enough input for the generation
+    of an extra output frame. This add-by-one logic is necessary due to how the data loading logic works when processing frames.
+    */
+    outputFrameCount = (inputFrameCount * pResampler->config.sampleRateOut) / pResampler->config.sampleRateIn;
+
+    /*
+    We need to determine how many *whole* input frames will have been processed to generate our preliminary output frame count. This is
+    used in the logic below to determine whether or not we need to add an extra output frame.
+    */
+    preliminaryInputFrameCountFromFrac = (pResampler->inTimeFrac + outputFrameCount*pResampler->inAdvanceFrac) / pResampler->config.sampleRateOut;
+    preliminaryInputFrameCount         = (pResampler->inTimeInt  + outputFrameCount*pResampler->inAdvanceInt ) + preliminaryInputFrameCountFromFrac;
+
+    /*
+    If the total number of *whole* input frames that would be required to generate our preliminary output frame count is greater than
+    the amount of whole input frames we have available as input we need to *not* add an extra output frame as there won't be enough data
+    to actually process. Otherwise we need to add the extra output frame.
+    */
+    if (preliminaryInputFrameCount <= inputFrameCount) {
+        outputFrameCount += 1;
+    }
+
+    *pOutputFrameCount = outputFrameCount;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_reset(ma_linear_resampler* pResampler)
+{
+    ma_uint32 iChannel;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Timers need to be cleared back to zero. */
+    pResampler->inTimeInt  = 1;  /* Set this to one to force an input sample to always be loaded for the first output frame. */
+    pResampler->inTimeFrac = 0;
+
+    /* Cached samples need to be cleared. */
+    if (pResampler->config.format == ma_format_f32) {
+        for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+            pResampler->x0.f32[iChannel] = 0;
+            pResampler->x1.f32[iChannel] = 0;
+        }
+    } else {
+        for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+            pResampler->x0.s16[iChannel] = 0;
+            pResampler->x1.s16[iChannel] = 0;
+        }
+    }
+
+    /* The low pass filter needs to have its cache reset. */
+    ma_lpf_clear_cache(&pResampler->lpf);
+
+    return MA_SUCCESS;
+}
+
+
+
+/* Linear resampler backend vtable. */
+static ma_linear_resampler_config ma_resampling_backend_get_config__linear(const ma_resampler_config* pConfig)
+{
+    ma_linear_resampler_config linearConfig;
+
+    linearConfig = ma_linear_resampler_config_init(pConfig->format, pConfig->channels, pConfig->sampleRateIn, pConfig->sampleRateOut);
+    linearConfig.lpfOrder = pConfig->linear.lpfOrder;
+
+    return linearConfig;
+}
+
+static ma_result ma_resampling_backend_get_heap_size__linear(void* pUserData, const ma_resampler_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_linear_resampler_config linearConfig;
+
+    (void)pUserData;
+
+    linearConfig = ma_resampling_backend_get_config__linear(pConfig);
+
+    return ma_linear_resampler_get_heap_size(&linearConfig, pHeapSizeInBytes);
+}
+
+static ma_result ma_resampling_backend_init__linear(void* pUserData, const ma_resampler_config* pConfig, void* pHeap, ma_resampling_backend** ppBackend)
+{
+    ma_resampler* pResampler = (ma_resampler*)pUserData;
+    ma_result result;
+    ma_linear_resampler_config linearConfig;
+
+    (void)pUserData;
+
+    linearConfig = ma_resampling_backend_get_config__linear(pConfig);
+
+    result = ma_linear_resampler_init_preallocated(&linearConfig, pHeap, &pResampler->state.linear);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *ppBackend = &pResampler->state.linear;
+
+    return MA_SUCCESS;
+}
+
+static void ma_resampling_backend_uninit__linear(void* pUserData, ma_resampling_backend* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    (void)pUserData;
+
+    ma_linear_resampler_uninit((ma_linear_resampler*)pBackend, pAllocationCallbacks);
+}
+
+static ma_result ma_resampling_backend_process__linear(void* pUserData, ma_resampling_backend* pBackend, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_process_pcm_frames((ma_linear_resampler*)pBackend, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+}
+
+static ma_result ma_resampling_backend_set_rate__linear(void* pUserData, ma_resampling_backend* pBackend, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_set_rate((ma_linear_resampler*)pBackend, sampleRateIn, sampleRateOut);
+}
+
+static ma_uint64 ma_resampling_backend_get_input_latency__linear(void* pUserData, const ma_resampling_backend* pBackend)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_get_input_latency((const ma_linear_resampler*)pBackend);
+}
+
+static ma_uint64 ma_resampling_backend_get_output_latency__linear(void* pUserData, const ma_resampling_backend* pBackend)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_get_output_latency((const ma_linear_resampler*)pBackend);
+}
+
+static ma_result ma_resampling_backend_get_required_input_frame_count__linear(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_get_required_input_frame_count((const ma_linear_resampler*)pBackend, outputFrameCount, pInputFrameCount);
+}
+
+static ma_result ma_resampling_backend_get_expected_output_frame_count__linear(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_get_expected_output_frame_count((const ma_linear_resampler*)pBackend, inputFrameCount, pOutputFrameCount);
+}
+
+static ma_result ma_resampling_backend_reset__linear(void* pUserData, ma_resampling_backend* pBackend)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_reset((ma_linear_resampler*)pBackend);
+}
+
+static ma_resampling_backend_vtable g_ma_linear_resampler_vtable =
+{
+    ma_resampling_backend_get_heap_size__linear,
+    ma_resampling_backend_init__linear,
+    ma_resampling_backend_uninit__linear,
+    ma_resampling_backend_process__linear,
+    ma_resampling_backend_set_rate__linear,
+    ma_resampling_backend_get_input_latency__linear,
+    ma_resampling_backend_get_output_latency__linear,
+    ma_resampling_backend_get_required_input_frame_count__linear,
+    ma_resampling_backend_get_expected_output_frame_count__linear,
+    ma_resampling_backend_reset__linear
+};
+
+
+
+MA_API ma_resampler_config ma_resampler_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut, ma_resample_algorithm algorithm)
+{
+    ma_resampler_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRateIn = sampleRateIn;
+    config.sampleRateOut = sampleRateOut;
+    config.algorithm = algorithm;
+
+    /* Linear. */
+    config.linear.lpfOrder = ma_min(MA_DEFAULT_RESAMPLER_LPF_ORDER, MA_MAX_FILTER_ORDER);
+
+    return config;
+}
+
+static ma_result ma_resampler_get_vtable(const ma_resampler_config* pConfig, ma_resampler* pResampler, ma_resampling_backend_vtable** ppVTable, void** ppUserData)
+{
+    MA_ASSERT(pConfig    != NULL);
+    MA_ASSERT(ppVTable   != NULL);
+    MA_ASSERT(ppUserData != NULL);
+
+    /* Safety. */
+    *ppVTable   = NULL;
+    *ppUserData = NULL;
+
+    switch (pConfig->algorithm)
+    {
+        case ma_resample_algorithm_linear:
+        {
+            *ppVTable   = &g_ma_linear_resampler_vtable;
+            *ppUserData = pResampler;
+        } break;
+
+        case ma_resample_algorithm_custom:
+        {
+            *ppVTable   = pConfig->pBackendVTable;
+            *ppUserData = pConfig->pBackendUserData;
+        } break;
+
+        default: return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resampler_get_heap_size(const ma_resampler_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_resampling_backend_vtable* pVTable;
+    void* pVTableUserData;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_resampler_get_vtable(pConfig, NULL, &pVTable, &pVTableUserData);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pVTable == NULL || pVTable->onGetHeapSize == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pVTable->onGetHeapSize(pVTableUserData, pConfig, pHeapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resampler_init_preallocated(const ma_resampler_config* pConfig, void* pHeap, ma_resampler* pResampler)
+{
+    ma_result result;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pResampler);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pResampler->_pHeap        = pHeap;
+    pResampler->format        = pConfig->format;
+    pResampler->channels      = pConfig->channels;
+    pResampler->sampleRateIn  = pConfig->sampleRateIn;
+    pResampler->sampleRateOut = pConfig->sampleRateOut;
+
+    result = ma_resampler_get_vtable(pConfig, pResampler, &pResampler->pBackendVTable, &pResampler->pBackendUserData);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onInit == NULL) {
+        return MA_NOT_IMPLEMENTED;  /* onInit not implemented. */
+    }
+
+    result = pResampler->pBackendVTable->onInit(pResampler->pBackendUserData, pConfig, pHeap, &pResampler->pBackend);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resampler_init(const ma_resampler_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_resampler* pResampler)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_resampler_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_resampler_init_preallocated(pConfig, pHeap, pResampler);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pResampler->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_resampler_uninit(ma_resampler* pResampler, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pResampler == NULL) {
+        return;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onUninit == NULL) {
+        return;
+    }
+
+    pResampler->pBackendVTable->onUninit(pResampler->pBackendUserData, pResampler->pBackend, pAllocationCallbacks);
+
+    if (pResampler->_ownsHeap) {
+        ma_free(pResampler->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_resampler_process_pcm_frames(ma_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFrameCountOut == NULL && pFrameCountIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onProcess == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pResampler->pBackendVTable->onProcess(pResampler->pBackendUserData, pResampler->pBackend, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+}
+
+MA_API ma_result ma_resampler_set_rate(ma_resampler* pResampler, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    ma_result result;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (sampleRateIn == 0 || sampleRateOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onSetRate == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pResampler->pBackendVTable->onSetRate(pResampler->pBackendUserData, pResampler->pBackend, sampleRateIn, sampleRateOut);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pResampler->sampleRateIn  = sampleRateIn;
+    pResampler->sampleRateOut = sampleRateOut;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resampler_set_rate_ratio(ma_resampler* pResampler, float ratio)
+{
+    ma_uint32 n;
+    ma_uint32 d;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ratio <= 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    d = 1000;
+    n = (ma_uint32)(ratio * d);
+
+    if (n == 0) {
+        return MA_INVALID_ARGS; /* Ratio too small. */
+    }
+
+    MA_ASSERT(n != 0);
+
+    return ma_resampler_set_rate(pResampler, n, d);
+}
+
+MA_API ma_uint64 ma_resampler_get_input_latency(const ma_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return 0;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onGetInputLatency == NULL) {
+        return 0;
+    }
+
+    return pResampler->pBackendVTable->onGetInputLatency(pResampler->pBackendUserData, pResampler->pBackend);
+}
+
+MA_API ma_uint64 ma_resampler_get_output_latency(const ma_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return 0;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onGetOutputLatency == NULL) {
+        return 0;
+    }
+
+    return pResampler->pBackendVTable->onGetOutputLatency(pResampler->pBackendUserData, pResampler->pBackend);
+}
+
+MA_API ma_result ma_resampler_get_required_input_frame_count(const ma_resampler* pResampler, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount)
+{
+    if (pInputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pInputFrameCount = 0;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onGetRequiredInputFrameCount == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pResampler->pBackendVTable->onGetRequiredInputFrameCount(pResampler->pBackendUserData, pResampler->pBackend, outputFrameCount, pInputFrameCount);
+}
+
+MA_API ma_result ma_resampler_get_expected_output_frame_count(const ma_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount)
+{
+    if (pOutputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pOutputFrameCount = 0;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onGetExpectedOutputFrameCount == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pResampler->pBackendVTable->onGetExpectedOutputFrameCount(pResampler->pBackendUserData, pResampler->pBackend, inputFrameCount, pOutputFrameCount);
+}
+
+MA_API ma_result ma_resampler_reset(ma_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onReset == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pResampler->pBackendVTable->onReset(pResampler->pBackendUserData, pResampler->pBackend);
+}
+
+/**************************************************************************************************************************************************************
+
+Channel Conversion
+
+**************************************************************************************************************************************************************/
+#ifndef MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT
+#define MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT  12
+#endif
+
+#define MA_PLANE_LEFT      0
+#define MA_PLANE_RIGHT     1
+#define MA_PLANE_FRONT     2
+#define MA_PLANE_BACK      3
+#define MA_PLANE_BOTTOM    4
+#define MA_PLANE_TOP       5
+
+static float g_maChannelPlaneRatios[MA_CHANNEL_POSITION_COUNT][6] = {
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_NONE */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_MONO */
+    { 0.5f,  0.0f,  0.5f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_LEFT */
+    { 0.0f,  0.5f,  0.5f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_RIGHT */
+    { 0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_CENTER */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_LFE */
+    { 0.5f,  0.0f,  0.0f,  0.5f,  0.0f,  0.0f},  /* MA_CHANNEL_BACK_LEFT */
+    { 0.0f,  0.5f,  0.0f,  0.5f,  0.0f,  0.0f},  /* MA_CHANNEL_BACK_RIGHT */
+    { 0.25f, 0.0f,  0.75f, 0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_LEFT_CENTER */
+    { 0.0f,  0.25f, 0.75f, 0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_RIGHT_CENTER */
+    { 0.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f},  /* MA_CHANNEL_BACK_CENTER */
+    { 1.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_SIDE_LEFT */
+    { 0.0f,  1.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_SIDE_RIGHT */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  1.0f},  /* MA_CHANNEL_TOP_CENTER */
+    { 0.33f, 0.0f,  0.33f, 0.0f,  0.0f,  0.34f}, /* MA_CHANNEL_TOP_FRONT_LEFT */
+    { 0.0f,  0.0f,  0.5f,  0.0f,  0.0f,  0.5f},  /* MA_CHANNEL_TOP_FRONT_CENTER */
+    { 0.0f,  0.33f, 0.33f, 0.0f,  0.0f,  0.34f}, /* MA_CHANNEL_TOP_FRONT_RIGHT */
+    { 0.33f, 0.0f,  0.0f,  0.33f, 0.0f,  0.34f}, /* MA_CHANNEL_TOP_BACK_LEFT */
+    { 0.0f,  0.0f,  0.0f,  0.5f,  0.0f,  0.5f},  /* MA_CHANNEL_TOP_BACK_CENTER */
+    { 0.0f,  0.33f, 0.0f,  0.33f, 0.0f,  0.34f}, /* MA_CHANNEL_TOP_BACK_RIGHT */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_0 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_1 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_2 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_3 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_4 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_5 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_6 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_7 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_8 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_9 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_10 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_11 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_12 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_13 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_14 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_15 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_16 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_17 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_18 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_19 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_20 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_21 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_22 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_23 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_24 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_25 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_26 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_27 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_28 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_29 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_30 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_31 */
+};
+
+static float ma_calculate_channel_position_rectangular_weight(ma_channel channelPositionA, ma_channel channelPositionB)
+{
+    /*
+    Imagine the following simplified example: You have a single input speaker which is the front/left speaker which you want to convert to
+    the following output configuration:
+
+     - front/left
+     - side/left
+     - back/left
+
+    The front/left output is easy - it the same speaker position so it receives the full contribution of the front/left input. The amount
+    of contribution to apply to the side/left and back/left speakers, however, is a bit more complicated.
+
+    Imagine the front/left speaker as emitting audio from two planes - the front plane and the left plane. You can think of the front/left
+    speaker emitting half of its total volume from the front, and the other half from the left. Since part of its volume is being emitted
+    from the left side, and the side/left and back/left channels also emit audio from the left plane, one would expect that they would
+    receive some amount of contribution from front/left speaker. The amount of contribution depends on how many planes are shared between
+    the two speakers. Note that in the examples below I've added a top/front/left speaker as an example just to show how the math works
+    across 3 spatial dimensions.
+
+    The first thing to do is figure out how each speaker's volume is spread over each of plane:
+     - front/left:     2 planes (front and left)      = 1/2 = half its total volume on each plane
+     - side/left:      1 plane (left only)            = 1/1 = entire volume from left plane
+     - back/left:      2 planes (back and left)       = 1/2 = half its total volume on each plane
+     - top/front/left: 3 planes (top, front and left) = 1/3 = one third its total volume on each plane
+
+    The amount of volume each channel contributes to each of its planes is what controls how much it is willing to given and take to other
+    channels on the same plane. The volume that is willing to the given by one channel is multiplied by the volume that is willing to be
+    taken by the other to produce the final contribution.
+    */
+
+    /* Contribution = Sum(Volume to Give * Volume to Take) */
+    float contribution =
+        g_maChannelPlaneRatios[channelPositionA][0] * g_maChannelPlaneRatios[channelPositionB][0] +
+        g_maChannelPlaneRatios[channelPositionA][1] * g_maChannelPlaneRatios[channelPositionB][1] +
+        g_maChannelPlaneRatios[channelPositionA][2] * g_maChannelPlaneRatios[channelPositionB][2] +
+        g_maChannelPlaneRatios[channelPositionA][3] * g_maChannelPlaneRatios[channelPositionB][3] +
+        g_maChannelPlaneRatios[channelPositionA][4] * g_maChannelPlaneRatios[channelPositionB][4] +
+        g_maChannelPlaneRatios[channelPositionA][5] * g_maChannelPlaneRatios[channelPositionB][5];
+
+    return contribution;
+}
+
+MA_API ma_channel_converter_config ma_channel_converter_config_init(ma_format format, ma_uint32 channelsIn, const ma_channel* pChannelMapIn, ma_uint32 channelsOut, const ma_channel* pChannelMapOut, ma_channel_mix_mode mixingMode)
+{
+    ma_channel_converter_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format         = format;
+    config.channelsIn     = channelsIn;
+    config.channelsOut    = channelsOut;
+    config.pChannelMapIn  = pChannelMapIn;
+    config.pChannelMapOut = pChannelMapOut;
+    config.mixingMode     = mixingMode;
+
+    return config;
+}
+
+static ma_int32 ma_channel_converter_float_to_fixed(float x)
+{
+    return (ma_int32)(x * (1<<MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT));
+}
+
+static ma_uint32 ma_channel_map_get_spatial_channel_count(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    ma_uint32 spatialChannelCount = 0;
+    ma_uint32 iChannel;
+
+    MA_ASSERT(pChannelMap != NULL);
+    MA_ASSERT(channels > 0);
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        if (ma_is_spatial_channel_position(ma_channel_map_get_channel(pChannelMap, channels, iChannel))) {
+            spatialChannelCount++;
+        }
+    }
+
+    return spatialChannelCount;
+}
+
+static ma_bool32 ma_is_spatial_channel_position(ma_channel channelPosition)
+{
+    int i;
+
+    if (channelPosition == MA_CHANNEL_NONE || channelPosition == MA_CHANNEL_MONO || channelPosition == MA_CHANNEL_LFE) {
+        return MA_FALSE;
+    }
+
+    if (channelPosition >= MA_CHANNEL_AUX_0 && channelPosition <= MA_CHANNEL_AUX_31) {
+        return MA_FALSE;
+    }
+
+    for (i = 0; i < 6; ++i) {   /* Each side of a cube. */
+        if (g_maChannelPlaneRatios[channelPosition][i] != 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+
+static ma_bool32 ma_channel_map_is_passthrough(const ma_channel* pChannelMapIn, ma_uint32 channelsIn, const ma_channel* pChannelMapOut, ma_uint32 channelsOut)
+{
+    if (channelsOut == channelsIn) {
+        return ma_channel_map_is_equal(pChannelMapOut, pChannelMapIn, channelsOut);
+    } else {
+        return MA_FALSE;    /* Channel counts differ, so cannot be a passthrough. */
+    }
+}
+
+static ma_channel_conversion_path ma_channel_map_get_conversion_path(const ma_channel* pChannelMapIn, ma_uint32 channelsIn, const ma_channel* pChannelMapOut, ma_uint32 channelsOut, ma_channel_mix_mode mode)
+{
+    if (ma_channel_map_is_passthrough(pChannelMapIn, channelsIn, pChannelMapOut, channelsOut)) {
+        return ma_channel_conversion_path_passthrough;
+    }
+
+    if (channelsOut == 1 && (pChannelMapOut == NULL || pChannelMapOut[0] == MA_CHANNEL_MONO)) {
+        return ma_channel_conversion_path_mono_out;
+    }
+
+    if (channelsIn == 1 && (pChannelMapIn == NULL || pChannelMapIn[0] == MA_CHANNEL_MONO)) {
+        return ma_channel_conversion_path_mono_in;
+    }
+
+    if (mode == ma_channel_mix_mode_custom_weights) {
+        return ma_channel_conversion_path_weights;
+    }
+
+    /*
+    We can use a simple shuffle if both channel maps have the same channel count and all channel
+    positions are present in both.
+    */
+    if (channelsIn == channelsOut) {
+        ma_uint32 iChannelIn;
+        ma_bool32 areAllChannelPositionsPresent = MA_TRUE;
+        for (iChannelIn = 0; iChannelIn < channelsIn; ++iChannelIn) {
+            ma_bool32 isInputChannelPositionInOutput = ma_channel_map_contains_channel_position(channelsOut, pChannelMapOut, ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn));
+            if (!isInputChannelPositionInOutput) {
+                areAllChannelPositionsPresent = MA_FALSE;
+                break;
+            }
+        }
+
+        if (areAllChannelPositionsPresent) {
+            return ma_channel_conversion_path_shuffle;
+        }
+    }
+
+    /* Getting here means we'll need to use weights. */
+    return ma_channel_conversion_path_weights;
+}
+
+
+static ma_result ma_channel_map_build_shuffle_table(const ma_channel* pChannelMapIn, ma_uint32 channelCountIn, const ma_channel* pChannelMapOut, ma_uint32 channelCountOut, ma_uint8* pShuffleTable)
+{
+    ma_uint32 iChannelIn;
+    ma_uint32 iChannelOut;
+
+    if (pShuffleTable == NULL || channelCountIn == 0 || channelCountOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    When building the shuffle table we just do a 1:1 mapping based on the first occurrence of a channel. If the
+    input channel has more than one occurrence of a channel position, the second one will be ignored.
+    */
+    for (iChannelOut = 0; iChannelOut < channelCountOut; iChannelOut += 1) {
+        ma_channel channelOut;
+
+        /* Default to MA_CHANNEL_INDEX_NULL so that if a mapping is not found it'll be set appropriately. */
+        pShuffleTable[iChannelOut] = MA_CHANNEL_INDEX_NULL;
+
+        channelOut = ma_channel_map_get_channel(pChannelMapOut, channelCountOut, iChannelOut);
+        for (iChannelIn = 0; iChannelIn < channelCountIn; iChannelIn += 1) {
+            ma_channel channelIn;
+
+            channelIn = ma_channel_map_get_channel(pChannelMapIn, channelCountIn, iChannelIn);
+            if (channelOut == channelIn) {
+                pShuffleTable[iChannelOut] = (ma_uint8)iChannelIn;
+                break;
+            }
+
+            /*
+            Getting here means the channels don't exactly match, but we are going to support some
+            relaxed matching for practicality. If, for example, there are two stereo channel maps,
+            but one uses front left/right and the other uses side left/right, it makes logical
+            sense to just map these. The way we'll do it is we'll check if there is a logical
+            corresponding mapping, and if so, apply it, but we will *not* break from the loop,
+            thereby giving the loop a chance to find an exact match later which will take priority.
+            */
+            switch (channelOut)
+            {
+                /* Left channels. */
+                case MA_CHANNEL_FRONT_LEFT:
+                case MA_CHANNEL_SIDE_LEFT:
+                {
+                    switch (channelIn) {
+                        case MA_CHANNEL_FRONT_LEFT:
+                        case MA_CHANNEL_SIDE_LEFT:
+                        {
+                            pShuffleTable[iChannelOut] = (ma_uint8)iChannelIn;
+                        } break;
+                    }
+                } break;
+
+                /* Right channels. */
+                case MA_CHANNEL_FRONT_RIGHT:
+                case MA_CHANNEL_SIDE_RIGHT:
+                {
+                    switch (channelIn) {
+                        case MA_CHANNEL_FRONT_RIGHT:
+                        case MA_CHANNEL_SIDE_RIGHT:
+                        {
+                            pShuffleTable[iChannelOut] = (ma_uint8)iChannelIn;
+                        } break;
+                    }
+                } break;
+
+                default: break;
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static void ma_channel_map_apply_shuffle_table_u8(ma_uint8* pFramesOut, ma_uint32 channelsOut, const ma_uint8* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut] = pFramesIn[iChannelIn];
+            } else {
+                pFramesOut[iChannelOut] = 0;
+            }
+        }
+
+        pFramesOut += channelsOut;
+        pFramesIn  += channelsIn;
+    }
+}
+
+static void ma_channel_map_apply_shuffle_table_s16(ma_int16* pFramesOut, ma_uint32 channelsOut, const ma_int16* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut] = pFramesIn[iChannelIn];
+            } else {
+                pFramesOut[iChannelOut] = 0;
+            }
+        }
+
+        pFramesOut += channelsOut;
+        pFramesIn  += channelsIn;
+    }
+}
+
+static void ma_channel_map_apply_shuffle_table_s24(ma_uint8* pFramesOut, ma_uint32 channelsOut, const ma_uint8* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut*3 + 0] = pFramesIn[iChannelIn*3 + 0];
+                pFramesOut[iChannelOut*3 + 1] = pFramesIn[iChannelIn*3 + 1];
+                pFramesOut[iChannelOut*3 + 2] = pFramesIn[iChannelIn*3 + 2];
+            } else {
+                pFramesOut[iChannelOut*3 + 0] = 0;
+            }   pFramesOut[iChannelOut*3 + 1] = 0;
+        }       pFramesOut[iChannelOut*3 + 2] = 0;
+
+        pFramesOut += channelsOut*3;
+        pFramesIn  += channelsIn*3;
+    }
+}
+
+static void ma_channel_map_apply_shuffle_table_s32(ma_int32* pFramesOut, ma_uint32 channelsOut, const ma_int32* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut] = pFramesIn[iChannelIn];
+            } else {
+                pFramesOut[iChannelOut] = 0;
+            }
+        }
+
+        pFramesOut += channelsOut;
+        pFramesIn  += channelsIn;
+    }
+}
+
+static void ma_channel_map_apply_shuffle_table_f32(float* pFramesOut, ma_uint32 channelsOut, const float* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut] = pFramesIn[iChannelIn];
+            } else {
+                pFramesOut[iChannelOut] = 0;
+            }
+        }
+
+        pFramesOut += channelsOut;
+        pFramesIn  += channelsIn;
+    }
+}
+
+static ma_result ma_channel_map_apply_shuffle_table(void* pFramesOut, ma_uint32 channelsOut, const void* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable, ma_format format)
+{
+    if (pFramesOut == NULL || pFramesIn == NULL || channelsOut == 0 || pShuffleTable == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    switch (format)
+    {
+        case ma_format_u8:
+        {
+            ma_channel_map_apply_shuffle_table_u8((ma_uint8*)pFramesOut, channelsOut, (const ma_uint8*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        case ma_format_s16:
+        {
+            ma_channel_map_apply_shuffle_table_s16((ma_int16*)pFramesOut, channelsOut, (const ma_int16*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        case ma_format_s24:
+        {
+            ma_channel_map_apply_shuffle_table_s24((ma_uint8*)pFramesOut, channelsOut, (const ma_uint8*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        case ma_format_s32:
+        {
+            ma_channel_map_apply_shuffle_table_s32((ma_int32*)pFramesOut, channelsOut, (const ma_int32*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        case ma_format_f32:
+        {
+            ma_channel_map_apply_shuffle_table_f32((float*)pFramesOut, channelsOut, (const float*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        default: return MA_INVALID_ARGS;    /* Unknown format. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_map_apply_mono_out_f32(float* pFramesOut, const float* pFramesIn, const ma_channel* pChannelMapIn, ma_uint32 channelsIn, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelIn;
+    ma_uint32 accumulationCount;
+
+    if (pFramesOut == NULL || pFramesIn == NULL || channelsIn == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* In this case the output stream needs to be the average of all channels, ignoring NONE. */
+
+    /* A quick pre-processing step to get the accumulation counter since we're ignoring NONE channels. */
+    accumulationCount = 0;
+    for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+        if (ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn) != MA_CHANNEL_NONE) {
+            accumulationCount += 1;
+        }
+    }
+
+    if (accumulationCount > 0) {    /* <-- Prevent a division by zero. */
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float accumulation = 0;
+
+            for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                ma_channel channelIn = ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn);
+                if (channelIn != MA_CHANNEL_NONE) {
+                    accumulation += pFramesIn[iChannelIn];
+                }
+            }
+
+            pFramesOut[0] = accumulation / accumulationCount;
+            pFramesOut += 1;
+            pFramesIn  += channelsIn;
+        }
+    } else {
+        ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, 1);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_map_apply_mono_in_f32(float* MA_RESTRICT pFramesOut, const ma_channel* pChannelMapOut, ma_uint32 channelsOut, const float* MA_RESTRICT pFramesIn, ma_uint64 frameCount, ma_mono_expansion_mode monoExpansionMode)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    if (pFramesOut == NULL || channelsOut == 0 || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Note that the MA_CHANNEL_NONE channel must be ignored in all cases. */
+    switch (monoExpansionMode)
+    {
+        case ma_mono_expansion_mode_average:
+        {
+            float weight;
+            ma_uint32 validChannelCount = 0;
+
+            for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                if (channelOut != MA_CHANNEL_NONE) {
+                    validChannelCount += 1;
+                }
+            }
+
+            weight = 1.0f / validChannelCount;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                    ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                    if (channelOut != MA_CHANNEL_NONE) {
+                        pFramesOut[iChannelOut] = pFramesIn[0] * weight;
+                    }
+                }
+
+                pFramesOut += channelsOut;
+                pFramesIn  += 1;
+            }
+        } break;
+
+        case ma_mono_expansion_mode_stereo_only:
+        {
+            if (channelsOut >= 2) {
+                ma_uint32 iChannelLeft  = (ma_uint32)-1;
+                ma_uint32 iChannelRight = (ma_uint32)-1;
+
+                /*
+                We first need to find our stereo channels. We prefer front-left and front-right, but
+                if they're not available, we'll also try side-left and side-right. If neither are
+                available we'll fall through to the default case below.
+                */
+                for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                    ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                    if (channelOut == MA_CHANNEL_SIDE_LEFT) {
+                        iChannelLeft  = iChannelOut;
+                    }
+                    if (channelOut == MA_CHANNEL_SIDE_RIGHT) {
+                        iChannelRight = iChannelOut;
+                    }
+                }
+
+                for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                    ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                    if (channelOut == MA_CHANNEL_FRONT_LEFT) {
+                        iChannelLeft  = iChannelOut;
+                    }
+                    if (channelOut == MA_CHANNEL_FRONT_RIGHT) {
+                        iChannelRight = iChannelOut;
+                    }
+                }
+
+
+                if (iChannelLeft != (ma_uint32)-1 && iChannelRight != (ma_uint32)-1) {
+                    /* We found our stereo channels so we can duplicate the signal across those channels. */
+                    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                            ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                            if (channelOut != MA_CHANNEL_NONE) {
+                                if (iChannelOut == iChannelLeft || iChannelOut == iChannelRight) {
+                                    pFramesOut[iChannelOut] = pFramesIn[0];
+                                } else {
+                                    pFramesOut[iChannelOut] = 0.0f;
+                                }
+                            }
+                        }
+
+                        pFramesOut += channelsOut;
+                        pFramesIn  += 1;
+                    }
+
+                    break;  /* Get out of the switch. */
+                } else {
+                    /* Fallthrough. Does not have left and right channels. */
+                    goto default_handler;
+                }
+            } else {
+                /* Fallthrough. Does not have stereo channels. */
+                goto default_handler;
+            }
+        };  /* Fallthrough. See comments above. */
+
+        case ma_mono_expansion_mode_duplicate:
+        default:
+        {
+            default_handler:
+            {
+                if (channelsOut <= MA_MAX_CHANNELS) {
+                    ma_bool32 hasEmptyChannel = MA_FALSE;
+                    ma_channel channelPositions[MA_MAX_CHANNELS];
+                    for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                        channelPositions[iChannelOut] = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                        if (channelPositions[iChannelOut] == MA_CHANNEL_NONE) {
+                            hasEmptyChannel = MA_TRUE;
+                        }
+                    }
+
+                    if (hasEmptyChannel == MA_FALSE) {
+                        /*
+                        Faster path when there's no MA_CHANNEL_NONE channel positions. This should hopefully
+                        help the compiler with auto-vectorization.m
+                        */
+                        if (channelsOut == 2) {
+                        #if defined(MA_SUPPORT_SSE2)
+                            if (ma_has_sse2()) {
+                                /* We want to do two frames in each iteration. */
+                                ma_uint64 unrolledFrameCount = frameCount >> 1;
+
+                                for (iFrame = 0; iFrame < unrolledFrameCount; iFrame += 1) {
+                                    __m128 in0 = _mm_set1_ps(pFramesIn[iFrame*2 + 0]);
+                                    __m128 in1 = _mm_set1_ps(pFramesIn[iFrame*2 + 1]);
+                                    _mm_storeu_ps(&pFramesOut[iFrame*4 + 0], _mm_shuffle_ps(in0, in1, _MM_SHUFFLE(0, 0, 0, 0)));
+                                }
+
+                                /* Tail. */
+                                iFrame = unrolledFrameCount << 1;
+                                goto generic_on_fastpath;
+                            } else
+                        #endif
+                            {
+                                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                                    for (iChannelOut = 0; iChannelOut < 2; iChannelOut += 1) {
+                                        pFramesOut[iFrame*2 + iChannelOut] = pFramesIn[iFrame];
+                                    }
+                                }
+                            }
+                        } else if (channelsOut == 6) {
+                        #if defined(MA_SUPPORT_SSE2)
+                            if (ma_has_sse2()) {
+                                /* We want to do two frames in each iteration so we can have a multiple of 4 samples. */
+                                ma_uint64 unrolledFrameCount = frameCount >> 1;
+
+                                for (iFrame = 0; iFrame < unrolledFrameCount; iFrame += 1) {
+                                    __m128 in0 = _mm_set1_ps(pFramesIn[iFrame*2 + 0]);
+                                    __m128 in1 = _mm_set1_ps(pFramesIn[iFrame*2 + 1]);
+
+                                    _mm_storeu_ps(&pFramesOut[iFrame*12 + 0], in0);
+                                    _mm_storeu_ps(&pFramesOut[iFrame*12 + 4], _mm_shuffle_ps(in0, in1, _MM_SHUFFLE(0, 0, 0, 0)));
+                                    _mm_storeu_ps(&pFramesOut[iFrame*12 + 8], in1);
+                                }
+
+                                /* Tail. */
+                                iFrame = unrolledFrameCount << 1;
+                                goto generic_on_fastpath;
+                            } else
+                        #endif
+                            {
+                                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                                    for (iChannelOut = 0; iChannelOut < 6; iChannelOut += 1) {
+                                        pFramesOut[iFrame*6 + iChannelOut] = pFramesIn[iFrame];
+                                    }
+                                }
+                            }
+                        } else if (channelsOut == 8) {
+                        #if defined(MA_SUPPORT_SSE2)
+                            if (ma_has_sse2()) {
+                                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                                    __m128 in = _mm_set1_ps(pFramesIn[iFrame]);
+                                    _mm_storeu_ps(&pFramesOut[iFrame*8 + 0], in);
+                                    _mm_storeu_ps(&pFramesOut[iFrame*8 + 4], in);
+                                }
+                            } else
+                        #endif
+                            {
+                                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                                    for (iChannelOut = 0; iChannelOut < 8; iChannelOut += 1) {
+                                        pFramesOut[iFrame*8 + iChannelOut] = pFramesIn[iFrame];
+                                    }
+                                }
+                            }
+                        } else {
+                            iFrame = 0;
+
+                            #if defined(MA_SUPPORT_SSE2)    /* For silencing a warning with non-x86 builds. */
+                            generic_on_fastpath:
+                            #endif
+                            {
+                                for (; iFrame < frameCount; iFrame += 1) {
+                                    for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                                        pFramesOut[iFrame*channelsOut + iChannelOut] = pFramesIn[iFrame];
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        /* Slow path. Need to handle MA_CHANNEL_NONE. */
+                        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                            for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                                if (channelPositions[iChannelOut] != MA_CHANNEL_NONE) {
+                                    pFramesOut[iFrame*channelsOut + iChannelOut] = pFramesIn[iFrame];
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    /* Slow path. Too many channels to store on the stack. */
+                    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                            ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                            if (channelOut != MA_CHANNEL_NONE) {
+                                pFramesOut[iFrame*channelsOut + iChannelOut] = pFramesIn[iFrame];
+                            }
+                        }
+                    }
+                }
+            }
+        } break;
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_channel_map_apply_f32(float* pFramesOut, const ma_channel* pChannelMapOut, ma_uint32 channelsOut, const float* pFramesIn, const ma_channel* pChannelMapIn, ma_uint32 channelsIn, ma_uint64 frameCount, ma_channel_mix_mode mode, ma_mono_expansion_mode monoExpansionMode)
+{
+    ma_channel_conversion_path conversionPath = ma_channel_map_get_conversion_path(pChannelMapIn, channelsIn, pChannelMapOut, channelsOut, mode);
+
+    /* Optimized Path: Passthrough */
+    if (conversionPath == ma_channel_conversion_path_passthrough) {
+        ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, ma_format_f32, channelsOut);
+        return;
+    }
+
+    /* Special Path: Mono Output. */
+    if (conversionPath == ma_channel_conversion_path_mono_out) {
+        ma_channel_map_apply_mono_out_f32(pFramesOut, pFramesIn, pChannelMapIn, channelsIn, frameCount);
+        return;
+    }
+
+    /* Special Path: Mono Input. */
+    if (conversionPath == ma_channel_conversion_path_mono_in) {
+        ma_channel_map_apply_mono_in_f32(pFramesOut, pChannelMapOut, channelsOut, pFramesIn, frameCount, monoExpansionMode);
+        return;
+    }
+
+    /* Getting here means we aren't running on an optimized conversion path. */
+    if (channelsOut <= MA_MAX_CHANNELS) {
+        ma_result result;
+
+        if (mode == ma_channel_mix_mode_simple) {
+            ma_channel shuffleTable[MA_MAX_CHANNELS];
+
+            result = ma_channel_map_build_shuffle_table(pChannelMapIn, channelsIn, pChannelMapOut, channelsOut, shuffleTable);
+            if (result != MA_SUCCESS) {
+                return;
+            }
+
+            result = ma_channel_map_apply_shuffle_table(pFramesOut, channelsOut, pFramesIn, channelsIn, frameCount, shuffleTable, ma_format_f32);
+            if (result != MA_SUCCESS) {
+                return;
+            }
+        } else {
+            ma_uint32 iFrame;
+            ma_uint32 iChannelOut;
+            ma_uint32 iChannelIn;
+            float weights[32][32];  /* Do not use MA_MAX_CHANNELS here! */
+
+            /*
+            If we have a small enough number of channels, pre-compute the weights. Otherwise we'll just need to
+            fall back to a slower path because otherwise we'll run out of stack space.
+            */
+            if (channelsIn <= ma_countof(weights) && channelsOut <= ma_countof(weights)) {
+                /* Pre-compute weights. */
+                for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                    ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                    for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                        ma_channel channelIn = ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn);
+                        weights[iChannelOut][iChannelIn] = ma_calculate_channel_position_rectangular_weight(channelOut, channelIn);
+                    }
+                }
+
+                iFrame = 0;
+
+                /* Experiment: Try an optimized unroll for some specific cases to see how it improves performance. RESULT: Good gains. */
+                if (channelsOut == 8) {
+                    /* Experiment 2: Expand the inner loop to see what kind of different it makes. RESULT: Small, but worthwhile gain. */
+                    if (channelsIn == 2) {
+                        for (; iFrame < frameCount; iFrame += 1) {
+                            float accumulation[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+                            accumulation[0] += pFramesIn[iFrame*2 + 0] * weights[0][0];
+                            accumulation[1] += pFramesIn[iFrame*2 + 0] * weights[1][0];
+                            accumulation[2] += pFramesIn[iFrame*2 + 0] * weights[2][0];
+                            accumulation[3] += pFramesIn[iFrame*2 + 0] * weights[3][0];
+                            accumulation[4] += pFramesIn[iFrame*2 + 0] * weights[4][0];
+                            accumulation[5] += pFramesIn[iFrame*2 + 0] * weights[5][0];
+                            accumulation[6] += pFramesIn[iFrame*2 + 0] * weights[6][0];
+                            accumulation[7] += pFramesIn[iFrame*2 + 0] * weights[7][0];
+
+                            accumulation[0] += pFramesIn[iFrame*2 + 1] * weights[0][1];
+                            accumulation[1] += pFramesIn[iFrame*2 + 1] * weights[1][1];
+                            accumulation[2] += pFramesIn[iFrame*2 + 1] * weights[2][1];
+                            accumulation[3] += pFramesIn[iFrame*2 + 1] * weights[3][1];
+                            accumulation[4] += pFramesIn[iFrame*2 + 1] * weights[4][1];
+                            accumulation[5] += pFramesIn[iFrame*2 + 1] * weights[5][1];
+                            accumulation[6] += pFramesIn[iFrame*2 + 1] * weights[6][1];
+                            accumulation[7] += pFramesIn[iFrame*2 + 1] * weights[7][1];
+
+                            pFramesOut[iFrame*8 + 0] = accumulation[0];
+                            pFramesOut[iFrame*8 + 1] = accumulation[1];
+                            pFramesOut[iFrame*8 + 2] = accumulation[2];
+                            pFramesOut[iFrame*8 + 3] = accumulation[3];
+                            pFramesOut[iFrame*8 + 4] = accumulation[4];
+                            pFramesOut[iFrame*8 + 5] = accumulation[5];
+                            pFramesOut[iFrame*8 + 6] = accumulation[6];
+                            pFramesOut[iFrame*8 + 7] = accumulation[7];
+                        }
+                    } else {
+                        /* When outputting to 8 channels, we can do everything in groups of two 4x SIMD operations. */
+                        for (; iFrame < frameCount; iFrame += 1) {
+                            float accumulation[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+                            for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                                accumulation[0] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[0][iChannelIn];
+                                accumulation[1] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[1][iChannelIn];
+                                accumulation[2] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[2][iChannelIn];
+                                accumulation[3] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[3][iChannelIn];
+                                accumulation[4] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[4][iChannelIn];
+                                accumulation[5] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[5][iChannelIn];
+                                accumulation[6] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[6][iChannelIn];
+                                accumulation[7] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[7][iChannelIn];
+                            }
+
+                            pFramesOut[iFrame*8 + 0] = accumulation[0];
+                            pFramesOut[iFrame*8 + 1] = accumulation[1];
+                            pFramesOut[iFrame*8 + 2] = accumulation[2];
+                            pFramesOut[iFrame*8 + 3] = accumulation[3];
+                            pFramesOut[iFrame*8 + 4] = accumulation[4];
+                            pFramesOut[iFrame*8 + 5] = accumulation[5];
+                            pFramesOut[iFrame*8 + 6] = accumulation[6];
+                            pFramesOut[iFrame*8 + 7] = accumulation[7];
+                        }
+                    }
+                } else if (channelsOut == 6) {
+                    /*
+                    When outputting to 6 channels we unfortunately don't have a nice multiple of 4 to do 4x SIMD operations. Instead we'll
+                    expand our weights and do two frames at a time.
+                    */
+                    for (; iFrame < frameCount; iFrame += 1) {
+                        float accumulation[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+                        for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                            accumulation[0] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[0][iChannelIn];
+                            accumulation[1] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[1][iChannelIn];
+                            accumulation[2] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[2][iChannelIn];
+                            accumulation[3] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[3][iChannelIn];
+                            accumulation[4] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[4][iChannelIn];
+                            accumulation[5] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[5][iChannelIn];
+                        }
+
+                        pFramesOut[iFrame*6 + 0] = accumulation[0];
+                        pFramesOut[iFrame*6 + 1] = accumulation[1];
+                        pFramesOut[iFrame*6 + 2] = accumulation[2];
+                        pFramesOut[iFrame*6 + 3] = accumulation[3];
+                        pFramesOut[iFrame*6 + 4] = accumulation[4];
+                        pFramesOut[iFrame*6 + 5] = accumulation[5];
+                    }
+                }
+
+                /* Leftover frames. */
+                for (; iFrame < frameCount; iFrame += 1) {
+                    for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                        float accumulation = 0;
+
+                        for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                            accumulation += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[iChannelOut][iChannelIn];
+                        }
+
+                        pFramesOut[iFrame*channelsOut + iChannelOut] = accumulation;
+                    }
+                }
+            } else {
+                /* Cannot pre-compute weights because not enough room in stack-allocated buffer. */
+                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                    for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                        float accumulation = 0;
+                        ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+
+                        for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                            ma_channel channelIn = ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn);
+                            accumulation += pFramesIn[iFrame*channelsIn + iChannelIn] * ma_calculate_channel_position_rectangular_weight(channelOut, channelIn);
+                        }
+
+                        pFramesOut[iFrame*channelsOut + iChannelOut] = accumulation;
+                    }
+                }
+            }
+        }
+    } else {
+        /* Fall back to silence. If you hit this, what are you doing with so many channels?! */
+        ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, channelsOut);
+    }
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t channelMapInOffset;
+    size_t channelMapOutOffset;
+    size_t shuffleTableOffset;
+    size_t weightsOffset;
+} ma_channel_converter_heap_layout;
+
+static ma_channel_conversion_path ma_channel_converter_config_get_conversion_path(const ma_channel_converter_config* pConfig)
+{
+    return ma_channel_map_get_conversion_path(pConfig->pChannelMapIn, pConfig->channelsIn, pConfig->pChannelMapOut, pConfig->channelsOut, pConfig->mixingMode);
+}
+
+static ma_result ma_channel_converter_get_heap_layout(const ma_channel_converter_config* pConfig, ma_channel_converter_heap_layout* pHeapLayout)
+{
+    ma_channel_conversion_path conversionPath;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channelsIn == 0 || pConfig->channelsOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (!ma_channel_map_is_valid(pConfig->pChannelMapIn, pConfig->channelsIn)) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (!ma_channel_map_is_valid(pConfig->pChannelMapOut, pConfig->channelsOut)) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Input channel map. Only need to allocate this if we have an input channel map (otherwise default channel map is assumed). */
+    pHeapLayout->channelMapInOffset = pHeapLayout->sizeInBytes;
+    if (pConfig->pChannelMapIn != NULL) {
+        pHeapLayout->sizeInBytes += sizeof(ma_channel) * pConfig->channelsIn;
+    }
+
+    /* Output channel map. Only need to allocate this if we have an output channel map (otherwise default channel map is assumed). */
+    pHeapLayout->channelMapOutOffset = pHeapLayout->sizeInBytes;
+    if (pConfig->pChannelMapOut != NULL) {
+        pHeapLayout->sizeInBytes += sizeof(ma_channel) * pConfig->channelsOut;
+    }
+
+    /* Alignment for the next section. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    /* Whether or not we use weights of a shuffle table depends on the channel map themselves and the algorithm we've chosen. */
+    conversionPath = ma_channel_converter_config_get_conversion_path(pConfig);
+
+    /* Shuffle table */
+    pHeapLayout->shuffleTableOffset = pHeapLayout->sizeInBytes;
+    if (conversionPath == ma_channel_conversion_path_shuffle) {
+        pHeapLayout->sizeInBytes += sizeof(ma_uint8) * pConfig->channelsOut;
+    }
+
+    /* Weights */
+    pHeapLayout->weightsOffset = pHeapLayout->sizeInBytes;
+    if (conversionPath == ma_channel_conversion_path_weights) {
+        pHeapLayout->sizeInBytes += sizeof(float*) * pConfig->channelsIn;
+        pHeapLayout->sizeInBytes += sizeof(float ) * pConfig->channelsIn * pConfig->channelsOut;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_get_heap_size(const ma_channel_converter_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_channel_converter_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_channel_converter_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_init_preallocated(const ma_channel_converter_config* pConfig, void* pHeap, ma_channel_converter* pConverter)
+{
+    ma_result result;
+    ma_channel_converter_heap_layout heapLayout;
+
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pConverter);
+
+    result = ma_channel_converter_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pConverter->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pConverter->_pHeap, heapLayout.sizeInBytes);
+
+    pConverter->format      = pConfig->format;
+    pConverter->channelsIn  = pConfig->channelsIn;
+    pConverter->channelsOut = pConfig->channelsOut;
+    pConverter->mixingMode  = pConfig->mixingMode;
+
+    if (pConfig->pChannelMapIn != NULL) {
+        pConverter->pChannelMapIn = (ma_channel*)ma_offset_ptr(pHeap, heapLayout.channelMapInOffset);
+        ma_channel_map_copy_or_default(pConverter->pChannelMapIn, pConfig->channelsIn, pConfig->pChannelMapIn, pConfig->channelsIn);
+    } else {
+        pConverter->pChannelMapIn = NULL;   /* Use default channel map. */
+    }
+
+    if (pConfig->pChannelMapOut != NULL) {
+        pConverter->pChannelMapOut = (ma_channel*)ma_offset_ptr(pHeap, heapLayout.channelMapOutOffset);
+        ma_channel_map_copy_or_default(pConverter->pChannelMapOut, pConfig->channelsOut, pConfig->pChannelMapOut, pConfig->channelsOut);
+    } else {
+        pConverter->pChannelMapOut = NULL;  /* Use default channel map. */
+    }
+
+    pConverter->conversionPath = ma_channel_converter_config_get_conversion_path(pConfig);
+
+    if (pConverter->conversionPath == ma_channel_conversion_path_shuffle) {
+        pConverter->pShuffleTable = (ma_uint8*)ma_offset_ptr(pHeap, heapLayout.shuffleTableOffset);
+        ma_channel_map_build_shuffle_table(pConverter->pChannelMapIn, pConverter->channelsIn, pConverter->pChannelMapOut, pConverter->channelsOut, pConverter->pShuffleTable);
+    }
+
+    if (pConverter->conversionPath == ma_channel_conversion_path_weights) {
+        ma_uint32 iChannelIn;
+        ma_uint32 iChannelOut;
+
+        if (pConverter->format == ma_format_f32) {
+            pConverter->weights.f32 = (float**   )ma_offset_ptr(pHeap, heapLayout.weightsOffset);
+            for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; iChannelIn += 1) {
+                pConverter->weights.f32[iChannelIn] = (float*)ma_offset_ptr(pHeap, heapLayout.weightsOffset + ((sizeof(float*) * pConverter->channelsIn) + (sizeof(float) * pConverter->channelsOut * iChannelIn)));
+            }
+        } else {
+            pConverter->weights.s16 = (ma_int32**)ma_offset_ptr(pHeap, heapLayout.weightsOffset);
+            for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; iChannelIn += 1) {
+                pConverter->weights.s16[iChannelIn] = (ma_int32*)ma_offset_ptr(pHeap, heapLayout.weightsOffset + ((sizeof(ma_int32*) * pConverter->channelsIn) + (sizeof(ma_int32) * pConverter->channelsOut * iChannelIn)));
+            }
+        }
+
+        /* Silence our weights by default. */
+        for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; iChannelIn += 1) {
+            for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; iChannelOut += 1) {
+                if (pConverter->format == ma_format_f32) {
+                    pConverter->weights.f32[iChannelIn][iChannelOut] = 0.0f;
+                } else {
+                    pConverter->weights.s16[iChannelIn][iChannelOut] = 0;
+                }
+            }
+        }
+
+        /*
+        We now need to fill out our weights table. This is determined by the mixing mode.
+        */
+
+        /* In all cases we need to make sure all channels that are present in both channel maps have a 1:1 mapping. */
+        for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+            ma_channel channelPosIn = ma_channel_map_get_channel(pConverter->pChannelMapIn, pConverter->channelsIn, iChannelIn);
+
+            for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                ma_channel channelPosOut = ma_channel_map_get_channel(pConverter->pChannelMapOut, pConverter->channelsOut, iChannelOut);
+
+                if (channelPosIn == channelPosOut) {
+                    float weight = 1;
+
+                    if (pConverter->format == ma_format_f32) {
+                        pConverter->weights.f32[iChannelIn][iChannelOut] = weight;
+                    } else {
+                        pConverter->weights.s16[iChannelIn][iChannelOut] = ma_channel_converter_float_to_fixed(weight);
+                    }
+                }
+            }
+        }
+
+        switch (pConverter->mixingMode)
+        {
+            case ma_channel_mix_mode_custom_weights:
+            {
+                if (pConfig->ppWeights == NULL) {
+                    return MA_INVALID_ARGS; /* Config specified a custom weights mixing mode, but no custom weights have been specified. */
+                }
+
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; iChannelIn += 1) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; iChannelOut += 1) {
+                        float weight = pConfig->ppWeights[iChannelIn][iChannelOut];
+
+                        if (pConverter->format == ma_format_f32) {
+                            pConverter->weights.f32[iChannelIn][iChannelOut] = weight;
+                        } else {
+                            pConverter->weights.s16[iChannelIn][iChannelOut] = ma_channel_converter_float_to_fixed(weight);
+                        }
+                    }
+                }
+            } break;
+
+            case ma_channel_mix_mode_simple:
+            {
+                /*
+                In simple mode, only set weights for channels that have exactly matching types, leave the rest at
+                zero. The 1:1 mappings have already been covered before this switch statement.
+                */
+            } break;
+
+            case ma_channel_mix_mode_rectangular:
+            default:
+            {
+                /* Unmapped input channels. */
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    ma_channel channelPosIn = ma_channel_map_get_channel(pConverter->pChannelMapIn, pConverter->channelsIn, iChannelIn);
+
+                    if (ma_is_spatial_channel_position(channelPosIn)) {
+                        if (!ma_channel_map_contains_channel_position(pConverter->channelsOut, pConverter->pChannelMapOut, channelPosIn)) {
+                            for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                                ma_channel channelPosOut = ma_channel_map_get_channel(pConverter->pChannelMapOut, pConverter->channelsOut, iChannelOut);
+
+                                if (ma_is_spatial_channel_position(channelPosOut)) {
+                                    float weight = 0;
+                                    if (pConverter->mixingMode == ma_channel_mix_mode_rectangular) {
+                                        weight = ma_calculate_channel_position_rectangular_weight(channelPosIn, channelPosOut);
+                                    }
+
+                                    /* Only apply the weight if we haven't already got some contribution from the respective channels. */
+                                    if (pConverter->format == ma_format_f32) {
+                                        if (pConverter->weights.f32[iChannelIn][iChannelOut] == 0) {
+                                            pConverter->weights.f32[iChannelIn][iChannelOut] = weight;
+                                        }
+                                    } else {
+                                        if (pConverter->weights.s16[iChannelIn][iChannelOut] == 0) {
+                                            pConverter->weights.s16[iChannelIn][iChannelOut] = ma_channel_converter_float_to_fixed(weight);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                /* Unmapped output channels. */
+                for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                    ma_channel channelPosOut = ma_channel_map_get_channel(pConverter->pChannelMapOut, pConverter->channelsOut, iChannelOut);
+
+                    if (ma_is_spatial_channel_position(channelPosOut)) {
+                        if (!ma_channel_map_contains_channel_position(pConverter->channelsIn, pConverter->pChannelMapIn, channelPosOut)) {
+                            for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                                ma_channel channelPosIn = ma_channel_map_get_channel(pConverter->pChannelMapIn, pConverter->channelsIn, iChannelIn);
+
+                                if (ma_is_spatial_channel_position(channelPosIn)) {
+                                    float weight = 0;
+                                    if (pConverter->mixingMode == ma_channel_mix_mode_rectangular) {
+                                        weight = ma_calculate_channel_position_rectangular_weight(channelPosIn, channelPosOut);
+                                    }
+
+                                    /* Only apply the weight if we haven't already got some contribution from the respective channels. */
+                                    if (pConverter->format == ma_format_f32) {
+                                        if (pConverter->weights.f32[iChannelIn][iChannelOut] == 0) {
+                                            pConverter->weights.f32[iChannelIn][iChannelOut] = weight;
+                                        }
+                                    } else {
+                                        if (pConverter->weights.s16[iChannelIn][iChannelOut] == 0) {
+                                            pConverter->weights.s16[iChannelIn][iChannelOut] = ma_channel_converter_float_to_fixed(weight);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                /* If LFE is in the output channel map but was not present in the input channel map, configure its weight now */
+                if (pConfig->calculateLFEFromSpatialChannels) {
+                    if (!ma_channel_map_contains_channel_position(pConverter->channelsIn, pConverter->pChannelMapIn, MA_CHANNEL_LFE)) {
+                        ma_uint32 spatialChannelCount = ma_channel_map_get_spatial_channel_count(pConverter->pChannelMapIn, pConverter->channelsIn);
+                        ma_uint32 iChannelOutLFE;
+
+                        if (spatialChannelCount > 0 && ma_channel_map_find_channel_position(pConverter->channelsOut, pConverter->pChannelMapOut, MA_CHANNEL_LFE, &iChannelOutLFE)) {
+                            const float weightForLFE = 1.0f / spatialChannelCount;
+                            for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                                const ma_channel channelPosIn = ma_channel_map_get_channel(pConverter->pChannelMapIn, pConverter->channelsIn, iChannelIn);
+                                if (ma_is_spatial_channel_position(channelPosIn)) {
+                                    if (pConverter->format == ma_format_f32) {
+                                        if (pConverter->weights.f32[iChannelIn][iChannelOutLFE] == 0) {
+                                            pConverter->weights.f32[iChannelIn][iChannelOutLFE] = weightForLFE;
+                                        }
+                                    } else {
+                                        if (pConverter->weights.s16[iChannelIn][iChannelOutLFE] == 0) {
+                                            pConverter->weights.s16[iChannelIn][iChannelOutLFE] = ma_channel_converter_float_to_fixed(weightForLFE);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } break;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_init(const ma_channel_converter_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_channel_converter* pConverter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_channel_converter_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_channel_converter_init_preallocated(pConfig, pHeap, pConverter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pConverter->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_channel_converter_uninit(ma_channel_converter* pConverter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pConverter == NULL) {
+        return;
+    }
+
+    if (pConverter->_ownsHeap) {
+        ma_free(pConverter->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__passthrough(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+
+    ma_copy_memory_64(pFramesOut, pFramesIn, frameCount * ma_get_bytes_per_frame(pConverter->format, pConverter->channelsOut));
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__shuffle(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+    MA_ASSERT(pConverter->channelsIn == pConverter->channelsOut);
+
+    return ma_channel_map_apply_shuffle_table(pFramesOut, pConverter->channelsOut, pFramesIn, pConverter->channelsIn, frameCount, pConverter->pShuffleTable, pConverter->format);
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__mono_in(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+    MA_ASSERT(pConverter->channelsIn == 1);
+
+    switch (pConverter->format)
+    {
+        case ma_format_u8:
+        {
+            /* */ ma_uint8* pFramesOutU8 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInU8  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                    pFramesOutU8[iFrame*pConverter->channelsOut + iChannel] = pFramesInU8[iFrame];
+                }
+            }
+        } break;
+
+        case ma_format_s16:
+        {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            if (pConverter->channelsOut == 2) {
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    pFramesOutS16[iFrame*2 + 0] = pFramesInS16[iFrame];
+                    pFramesOutS16[iFrame*2 + 1] = pFramesInS16[iFrame];
+                }
+            } else {
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    ma_uint32 iChannel;
+                    for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                        pFramesOutS16[iFrame*pConverter->channelsOut + iChannel] = pFramesInS16[iFrame];
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_s24:
+        {
+            /* */ ma_uint8* pFramesOutS24 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInS24  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                    ma_uint64 iSampleOut = iFrame*pConverter->channelsOut + iChannel;
+                    ma_uint64 iSampleIn  = iFrame;
+                    pFramesOutS24[iSampleOut*3 + 0] = pFramesInS24[iSampleIn*3 + 0];
+                    pFramesOutS24[iSampleOut*3 + 1] = pFramesInS24[iSampleIn*3 + 1];
+                    pFramesOutS24[iSampleOut*3 + 2] = pFramesInS24[iSampleIn*3 + 2];
+                }
+            }
+        } break;
+
+        case ma_format_s32:
+        {
+            /* */ ma_int32* pFramesOutS32 = (      ma_int32*)pFramesOut;
+            const ma_int32* pFramesInS32  = (const ma_int32*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                    pFramesOutS32[iFrame*pConverter->channelsOut + iChannel] = pFramesInS32[iFrame];
+                }
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            if (pConverter->channelsOut == 2) {
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    pFramesOutF32[iFrame*2 + 0] = pFramesInF32[iFrame];
+                    pFramesOutF32[iFrame*2 + 1] = pFramesInF32[iFrame];
+                }
+            } else {
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    ma_uint32 iChannel;
+                    for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                        pFramesOutF32[iFrame*pConverter->channelsOut + iChannel] = pFramesInF32[iFrame];
+                    }
+                }
+            }
+        } break;
+
+        default: return MA_INVALID_OPERATION;   /* Unknown format. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__mono_out(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+    MA_ASSERT(pConverter->channelsOut == 1);
+
+    switch (pConverter->format)
+    {
+        case ma_format_u8:
+        {
+            /* */ ma_uint8* pFramesOutU8 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInU8  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_int32 t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += ma_pcm_sample_u8_to_s16_no_scale(pFramesInU8[iFrame*pConverter->channelsIn + iChannel]);
+                }
+
+                pFramesOutU8[iFrame] = ma_clip_u8(t / pConverter->channelsOut);
+            }
+        } break;
+
+        case ma_format_s16:
+        {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_int32 t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += pFramesInS16[iFrame*pConverter->channelsIn + iChannel];
+                }
+
+                pFramesOutS16[iFrame] = (ma_int16)(t / pConverter->channelsIn);
+            }
+        } break;
+
+        case ma_format_s24:
+        {
+            /* */ ma_uint8* pFramesOutS24 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInS24  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_int64 t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += ma_pcm_sample_s24_to_s32_no_scale(&pFramesInS24[(iFrame*pConverter->channelsIn + iChannel)*3]);
+                }
+
+                ma_pcm_sample_s32_to_s24_no_scale(t / pConverter->channelsIn, &pFramesOutS24[iFrame*3]);
+            }
+        } break;
+
+        case ma_format_s32:
+        {
+            /* */ ma_int32* pFramesOutS32 = (      ma_int32*)pFramesOut;
+            const ma_int32* pFramesInS32  = (const ma_int32*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_int64 t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += pFramesInS32[iFrame*pConverter->channelsIn + iChannel];
+                }
+
+                pFramesOutS32[iFrame] = (ma_int32)(t / pConverter->channelsIn);
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                float t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += pFramesInF32[iFrame*pConverter->channelsIn + iChannel];
+                }
+
+                pFramesOutF32[iFrame] = t / pConverter->channelsIn;
+            }
+        } break;
+
+        default: return MA_INVALID_OPERATION;   /* Unknown format. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__weights(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint32 iFrame;
+    ma_uint32 iChannelIn;
+    ma_uint32 iChannelOut;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+
+    /* This is the more complicated case. Each of the output channels is accumulated with 0 or more input channels. */
+
+    /* Clear. */
+    ma_zero_memory_64(pFramesOut, frameCount * ma_get_bytes_per_frame(pConverter->format, pConverter->channelsOut));
+
+    /* Accumulate. */
+    switch (pConverter->format)
+    {
+        case ma_format_u8:
+        {
+            /* */ ma_uint8* pFramesOutU8 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInU8  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        ma_int16 u8_O = ma_pcm_sample_u8_to_s16_no_scale(pFramesOutU8[iFrame*pConverter->channelsOut + iChannelOut]);
+                        ma_int16 u8_I = ma_pcm_sample_u8_to_s16_no_scale(pFramesInU8 [iFrame*pConverter->channelsIn  + iChannelIn ]);
+                        ma_int32 s    = (ma_int32)ma_clamp(u8_O + ((u8_I * pConverter->weights.s16[iChannelIn][iChannelOut]) >> MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT), -128, 127);
+                        pFramesOutU8[iFrame*pConverter->channelsOut + iChannelOut] = ma_clip_u8((ma_int16)s);
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_s16:
+        {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        ma_int32 s = pFramesOutS16[iFrame*pConverter->channelsOut + iChannelOut];
+                        s += (pFramesInS16[iFrame*pConverter->channelsIn + iChannelIn] * pConverter->weights.s16[iChannelIn][iChannelOut]) >> MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT;
+
+                        pFramesOutS16[iFrame*pConverter->channelsOut + iChannelOut] = (ma_int16)ma_clamp(s, -32768, 32767);
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_s24:
+        {
+            /* */ ma_uint8* pFramesOutS24 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInS24  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        ma_int64 s24_O = ma_pcm_sample_s24_to_s32_no_scale(&pFramesOutS24[(iFrame*pConverter->channelsOut + iChannelOut)*3]);
+                        ma_int64 s24_I = ma_pcm_sample_s24_to_s32_no_scale(&pFramesInS24 [(iFrame*pConverter->channelsIn  + iChannelIn )*3]);
+                        ma_int64 s24   = (ma_int32)ma_clamp(s24_O + ((s24_I * pConverter->weights.s16[iChannelIn][iChannelOut]) >> MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT), -8388608, 8388607);
+                        ma_pcm_sample_s32_to_s24_no_scale(s24, &pFramesOutS24[(iFrame*pConverter->channelsOut + iChannelOut)*3]);
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_s32:
+        {
+            /* */ ma_int32* pFramesOutS32 = (      ma_int32*)pFramesOut;
+            const ma_int32* pFramesInS32  = (const ma_int32*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        ma_int64 s = pFramesOutS32[iFrame*pConverter->channelsOut + iChannelOut];
+                        s += ((ma_int64)pFramesInS32[iFrame*pConverter->channelsIn + iChannelIn] * pConverter->weights.s16[iChannelIn][iChannelOut]) >> MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT;
+
+                        pFramesOutS32[iFrame*pConverter->channelsOut + iChannelOut] = ma_clip_s32(s);
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        pFramesOutF32[iFrame*pConverter->channelsOut + iChannelOut] += pFramesInF32[iFrame*pConverter->channelsIn + iChannelIn] * pConverter->weights.f32[iChannelIn][iChannelOut];
+                    }
+                }
+            }
+        } break;
+
+        default: return MA_INVALID_OPERATION;   /* Unknown format. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_process_pcm_frames(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFramesOut == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFramesIn == NULL) {
+        ma_zero_memory_64(pFramesOut, frameCount * ma_get_bytes_per_frame(pConverter->format, pConverter->channelsOut));
+        return MA_SUCCESS;
+    }
+
+    switch (pConverter->conversionPath)
+    {
+        case ma_channel_conversion_path_passthrough: return ma_channel_converter_process_pcm_frames__passthrough(pConverter, pFramesOut, pFramesIn, frameCount);
+        case ma_channel_conversion_path_mono_out:    return ma_channel_converter_process_pcm_frames__mono_out(pConverter, pFramesOut, pFramesIn, frameCount);
+        case ma_channel_conversion_path_mono_in:     return ma_channel_converter_process_pcm_frames__mono_in(pConverter, pFramesOut, pFramesIn, frameCount);
+        case ma_channel_conversion_path_shuffle:     return ma_channel_converter_process_pcm_frames__shuffle(pConverter, pFramesOut, pFramesIn, frameCount);
+        case ma_channel_conversion_path_weights:
+        default:
+        {
+            return ma_channel_converter_process_pcm_frames__weights(pConverter, pFramesOut, pFramesIn, frameCount);
+        }
+    }
+}
+
+MA_API ma_result ma_channel_converter_get_input_channel_map(const ma_channel_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pConverter == NULL || pChannelMap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_channel_map_copy_or_default(pChannelMap, channelMapCap, pConverter->pChannelMapIn, pConverter->channelsIn);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_get_output_channel_map(const ma_channel_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pConverter == NULL || pChannelMap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_channel_map_copy_or_default(pChannelMap, channelMapCap, pConverter->pChannelMapOut, pConverter->channelsOut);
+
+    return MA_SUCCESS;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Data Conversion
+
+**************************************************************************************************************************************************************/
+MA_API ma_data_converter_config ma_data_converter_config_init_default(void)
+{
+    ma_data_converter_config config;
+    MA_ZERO_OBJECT(&config);
+
+    config.ditherMode = ma_dither_mode_none;
+    config.resampling.algorithm = ma_resample_algorithm_linear;
+    config.allowDynamicSampleRate = MA_FALSE; /* Disable dynamic sample rates by default because dynamic rate adjustments should be quite rare and it allows an optimization for cases when the in and out sample rates are the same. */
+
+    /* Linear resampling defaults. */
+    config.resampling.linear.lpfOrder = 1;
+
+    return config;
+}
+
+MA_API ma_data_converter_config ma_data_converter_config_init(ma_format formatIn, ma_format formatOut, ma_uint32 channelsIn, ma_uint32 channelsOut, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    ma_data_converter_config config = ma_data_converter_config_init_default();
+    config.formatIn      = formatIn;
+    config.formatOut     = formatOut;
+    config.channelsIn    = channelsIn;
+    config.channelsOut   = channelsOut;
+    config.sampleRateIn  = sampleRateIn;
+    config.sampleRateOut = sampleRateOut;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t channelConverterOffset;
+    size_t resamplerOffset;
+} ma_data_converter_heap_layout;
+
+static ma_bool32 ma_data_converter_config_is_resampler_required(const ma_data_converter_config* pConfig)
+{
+    MA_ASSERT(pConfig != NULL);
+
+    return pConfig->allowDynamicSampleRate || pConfig->sampleRateIn != pConfig->sampleRateOut;
+}
+
+static ma_format ma_data_converter_config_get_mid_format(const ma_data_converter_config* pConfig)
+{
+    MA_ASSERT(pConfig != NULL);
+
+    /*
+    We want to avoid as much data conversion as possible. The channel converter and linear
+    resampler both support s16 and f32 natively. We need to decide on the format to use for this
+    stage. We call this the mid format because it's used in the middle stage of the conversion
+    pipeline. If the output format is either s16 or f32 we use that one. If that is not the case it
+    will do the same thing for the input format. If it's neither we just use f32. If we are using a
+    custom resampling backend, we can only guarantee that f32 will be supported so we'll be forced
+    to use that if resampling is required.
+    */
+    if (ma_data_converter_config_is_resampler_required(pConfig) && pConfig->resampling.algorithm != ma_resample_algorithm_linear) {
+        return ma_format_f32;  /* <-- Force f32 since that is the only one we can guarantee will be supported by the resampler. */
+    } else {
+        /*  */ if (pConfig->formatOut == ma_format_s16 || pConfig->formatOut == ma_format_f32) {
+            return pConfig->formatOut;
+        } else if (pConfig->formatIn  == ma_format_s16 || pConfig->formatIn  == ma_format_f32) {
+            return pConfig->formatIn;
+        } else {
+            return ma_format_f32;
+        }
+    }
+}
+
+static ma_channel_converter_config ma_channel_converter_config_init_from_data_converter_config(const ma_data_converter_config* pConfig)
+{
+    ma_channel_converter_config channelConverterConfig;
+
+    MA_ASSERT(pConfig != NULL);
+
+    channelConverterConfig = ma_channel_converter_config_init(ma_data_converter_config_get_mid_format(pConfig), pConfig->channelsIn, pConfig->pChannelMapIn, pConfig->channelsOut, pConfig->pChannelMapOut, pConfig->channelMixMode);
+    channelConverterConfig.ppWeights = pConfig->ppChannelWeights;
+    channelConverterConfig.calculateLFEFromSpatialChannels = pConfig->calculateLFEFromSpatialChannels;
+
+    return channelConverterConfig;
+}
+
+static ma_resampler_config ma_resampler_config_init_from_data_converter_config(const ma_data_converter_config* pConfig)
+{
+    ma_resampler_config resamplerConfig;
+    ma_uint32 resamplerChannels;
+
+    MA_ASSERT(pConfig != NULL);
+
+    /* The resampler is the most expensive part of the conversion process, so we need to do it at the stage where the channel count is at it's lowest. */
+    if (pConfig->channelsIn < pConfig->channelsOut) {
+        resamplerChannels = pConfig->channelsIn;
+    } else {
+        resamplerChannels = pConfig->channelsOut;
+    }
+
+    resamplerConfig = ma_resampler_config_init(ma_data_converter_config_get_mid_format(pConfig), resamplerChannels, pConfig->sampleRateIn, pConfig->sampleRateOut, pConfig->resampling.algorithm);
+    resamplerConfig.linear           = pConfig->resampling.linear;
+    resamplerConfig.pBackendVTable   = pConfig->resampling.pBackendVTable;
+    resamplerConfig.pBackendUserData = pConfig->resampling.pBackendUserData;
+
+    return resamplerConfig;
+}
+
+static ma_result ma_data_converter_get_heap_layout(const ma_data_converter_config* pConfig, ma_data_converter_heap_layout* pHeapLayout)
+{
+    ma_result result;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channelsIn == 0 || pConfig->channelsOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Channel converter. */
+    pHeapLayout->channelConverterOffset = pHeapLayout->sizeInBytes;
+    {
+        size_t heapSizeInBytes;
+        ma_channel_converter_config channelConverterConfig = ma_channel_converter_config_init_from_data_converter_config(pConfig);
+
+        result = ma_channel_converter_get_heap_size(&channelConverterConfig, &heapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += heapSizeInBytes;
+    }
+
+    /* Resampler. */
+    pHeapLayout->resamplerOffset = pHeapLayout->sizeInBytes;
+    if (ma_data_converter_config_is_resampler_required(pConfig)) {
+        size_t heapSizeInBytes;
+        ma_resampler_config resamplerConfig = ma_resampler_config_init_from_data_converter_config(pConfig);
+
+        result = ma_resampler_get_heap_size(&resamplerConfig, &heapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += heapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_get_heap_size(const ma_data_converter_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_data_converter_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_data_converter_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_init_preallocated(const ma_data_converter_config* pConfig, void* pHeap, ma_data_converter* pConverter)
+{
+    ma_result result;
+    ma_data_converter_heap_layout heapLayout;
+    ma_format midFormat;
+    ma_bool32 isResamplingRequired;
+
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pConverter);
+
+    result = ma_data_converter_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pConverter->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pConverter->formatIn      = pConfig->formatIn;
+    pConverter->formatOut     = pConfig->formatOut;
+    pConverter->channelsIn    = pConfig->channelsIn;
+    pConverter->channelsOut   = pConfig->channelsOut;
+    pConverter->sampleRateIn  = pConfig->sampleRateIn;
+    pConverter->sampleRateOut = pConfig->sampleRateOut;
+    pConverter->ditherMode    = pConfig->ditherMode;
+
+    /*
+    Determine if resampling is required. We need to do this so we can determine an appropriate
+    mid format to use. If resampling is required, the mid format must be ma_format_f32 since
+    that is the only one that is guaranteed to supported by custom resampling backends.
+    */
+    isResamplingRequired = ma_data_converter_config_is_resampler_required(pConfig);
+    midFormat = ma_data_converter_config_get_mid_format(pConfig);
+
+
+    /* Channel converter. We always initialize this, but we check if it configures itself as a passthrough to determine whether or not it's needed. */
+    {
+        ma_channel_converter_config channelConverterConfig = ma_channel_converter_config_init_from_data_converter_config(pConfig);
+
+        result = ma_channel_converter_init_preallocated(&channelConverterConfig, ma_offset_ptr(pHeap, heapLayout.channelConverterOffset), &pConverter->channelConverter);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        /* If the channel converter is not a passthrough we need to enable it. Otherwise we can skip it. */
+        if (pConverter->channelConverter.conversionPath != ma_channel_conversion_path_passthrough) {
+            pConverter->hasChannelConverter = MA_TRUE;
+        }
+    }
+
+
+    /* Resampler. */
+    if (isResamplingRequired) {
+        ma_resampler_config resamplerConfig = ma_resampler_config_init_from_data_converter_config(pConfig);
+
+        result = ma_resampler_init_preallocated(&resamplerConfig, ma_offset_ptr(pHeap, heapLayout.resamplerOffset), &pConverter->resampler);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pConverter->hasResampler = MA_TRUE;
+    }
+
+
+    /* We can simplify pre- and post-format conversion if we have neither channel conversion nor resampling. */
+    if (pConverter->hasChannelConverter == MA_FALSE && pConverter->hasResampler == MA_FALSE) {
+        /* We have neither channel conversion nor resampling so we'll only need one of pre- or post-format conversion, or none if the input and output formats are the same. */
+        if (pConverter->formatIn == pConverter->formatOut) {
+            /* The formats are the same so we can just pass through. */
+            pConverter->hasPreFormatConversion  = MA_FALSE;
+            pConverter->hasPostFormatConversion = MA_FALSE;
+        } else {
+            /* The formats are different so we need to do either pre- or post-format conversion. It doesn't matter which. */
+            pConverter->hasPreFormatConversion  = MA_FALSE;
+            pConverter->hasPostFormatConversion = MA_TRUE;
+        }
+    } else {
+        /* We have a channel converter and/or resampler so we'll need channel conversion based on the mid format. */
+        if (pConverter->formatIn != midFormat) {
+            pConverter->hasPreFormatConversion  = MA_TRUE;
+        }
+        if (pConverter->formatOut != midFormat) {
+            pConverter->hasPostFormatConversion = MA_TRUE;
+        }
+    }
+
+    /* We can enable passthrough optimizations if applicable. Note that we'll only be able to do this if the sample rate is static. */
+    if (pConverter->hasPreFormatConversion  == MA_FALSE &&
+        pConverter->hasPostFormatConversion == MA_FALSE &&
+        pConverter->hasChannelConverter     == MA_FALSE &&
+        pConverter->hasResampler            == MA_FALSE) {
+        pConverter->isPassthrough = MA_TRUE;
+    }
+
+
+    /* We now need to determine our execution path. */
+    if (pConverter->isPassthrough) {
+        pConverter->executionPath = ma_data_converter_execution_path_passthrough;
+    } else {
+        if (pConverter->channelsIn < pConverter->channelsOut) {
+            /* Do resampling first, if necessary. */
+            MA_ASSERT(pConverter->hasChannelConverter == MA_TRUE);
+
+            if (pConverter->hasResampler) {
+                pConverter->executionPath = ma_data_converter_execution_path_resample_first;
+            } else {
+                pConverter->executionPath = ma_data_converter_execution_path_channels_only;
+            }
+        } else {
+            /* Do channel conversion first, if necessary. */
+            if (pConverter->hasChannelConverter) {
+                if (pConverter->hasResampler) {
+                    pConverter->executionPath = ma_data_converter_execution_path_channels_first;
+                } else {
+                    pConverter->executionPath = ma_data_converter_execution_path_channels_only;
+                }
+            } else {
+                /* Channel routing not required. */
+                if (pConverter->hasResampler) {
+                    pConverter->executionPath = ma_data_converter_execution_path_resample_only;
+                } else {
+                    pConverter->executionPath = ma_data_converter_execution_path_format_only;
+                }
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_init(const ma_data_converter_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_converter* pConverter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_data_converter_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_data_converter_init_preallocated(pConfig, pHeap, pConverter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pConverter->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_converter_uninit(ma_data_converter* pConverter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pConverter == NULL) {
+        return;
+    }
+
+    if (pConverter->hasResampler) {
+        ma_resampler_uninit(&pConverter->resampler, pAllocationCallbacks);
+    }
+
+    ma_channel_converter_uninit(&pConverter->channelConverter, pAllocationCallbacks);
+
+    if (pConverter->_ownsHeap) {
+        ma_free(pConverter->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static ma_result ma_data_converter_process_pcm_frames__passthrough(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 frameCount;
+
+    MA_ASSERT(pConverter != NULL);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    frameCount = ma_min(frameCountIn, frameCountOut);
+
+    if (pFramesOut != NULL) {
+        if (pFramesIn != NULL) {
+            ma_copy_memory_64(pFramesOut, pFramesIn, frameCount * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        } else {
+            ma_zero_memory_64(pFramesOut,            frameCount * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = frameCount;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_data_converter_process_pcm_frames__format_only(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 frameCount;
+
+    MA_ASSERT(pConverter != NULL);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    frameCount = ma_min(frameCountIn, frameCountOut);
+
+    if (pFramesOut != NULL) {
+        if (pFramesIn != NULL) {
+            ma_convert_pcm_frames_format(pFramesOut, pConverter->formatOut, pFramesIn, pConverter->formatIn, frameCount, pConverter->channelsIn, pConverter->ditherMode);
+        } else {
+            ma_zero_memory_64(pFramesOut, frameCount * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = frameCount;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_data_converter_process_pcm_frames__resample_with_format_conversion(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pConverter != NULL);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        ma_uint8 pTempBufferOut[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+        const ma_uint32 tempBufferOutCap = sizeof(pTempBufferOut) / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+        const void* pFramesInThisIteration;
+        /* */ void* pFramesOutThisIteration;
+        ma_uint64 frameCountInThisIteration;
+        ma_uint64 frameCountOutThisIteration;
+
+        if (pFramesIn != NULL) {
+            pFramesInThisIteration = ma_offset_ptr(pFramesIn, framesProcessedIn * ma_get_bytes_per_frame(pConverter->formatIn, pConverter->channelsIn));
+        } else {
+            pFramesInThisIteration = NULL;
+        }
+
+        if (pFramesOut != NULL) {
+            pFramesOutThisIteration = ma_offset_ptr(pFramesOut, framesProcessedOut * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        } else {
+            pFramesOutThisIteration = NULL;
+        }
+
+        /* Do a pre format conversion if necessary. */
+        if (pConverter->hasPreFormatConversion) {
+            ma_uint8 pTempBufferIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+            const ma_uint32 tempBufferInCap = sizeof(pTempBufferIn) / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+
+            frameCountInThisIteration  = (frameCountIn - framesProcessedIn);
+            if (frameCountInThisIteration > tempBufferInCap) {
+                frameCountInThisIteration = tempBufferInCap;
+            }
+
+            if (pConverter->hasPostFormatConversion) {
+               if (frameCountInThisIteration > tempBufferOutCap) {
+                   frameCountInThisIteration = tempBufferOutCap;
+               }
+            }
+
+            if (pFramesInThisIteration != NULL) {
+                ma_convert_pcm_frames_format(pTempBufferIn, pConverter->resampler.format, pFramesInThisIteration, pConverter->formatIn, frameCountInThisIteration, pConverter->channelsIn, pConverter->ditherMode);
+            } else {
+                MA_ZERO_MEMORY(pTempBufferIn, sizeof(pTempBufferIn));
+            }
+
+            frameCountOutThisIteration = (frameCountOut - framesProcessedOut);
+
+            if (pConverter->hasPostFormatConversion) {
+                /* Both input and output conversion required. Output to the temp buffer. */
+                if (frameCountOutThisIteration > tempBufferOutCap) {
+                    frameCountOutThisIteration = tempBufferOutCap;
+                }
+
+                result = ma_resampler_process_pcm_frames(&pConverter->resampler, pTempBufferIn, &frameCountInThisIteration, pTempBufferOut, &frameCountOutThisIteration);
+            } else {
+                /* Only pre-format required. Output straight to the output buffer. */
+                result = ma_resampler_process_pcm_frames(&pConverter->resampler, pTempBufferIn, &frameCountInThisIteration, pFramesOutThisIteration, &frameCountOutThisIteration);
+            }
+
+            if (result != MA_SUCCESS) {
+                break;
+            }
+        } else {
+            /* No pre-format required. Just read straight from the input buffer. */
+            MA_ASSERT(pConverter->hasPostFormatConversion == MA_TRUE);
+
+            frameCountInThisIteration  = (frameCountIn  - framesProcessedIn);
+            frameCountOutThisIteration = (frameCountOut - framesProcessedOut);
+            if (frameCountOutThisIteration > tempBufferOutCap) {
+                frameCountOutThisIteration = tempBufferOutCap;
+            }
+
+            result = ma_resampler_process_pcm_frames(&pConverter->resampler, pFramesInThisIteration, &frameCountInThisIteration, pTempBufferOut, &frameCountOutThisIteration);
+            if (result != MA_SUCCESS) {
+                break;
+            }
+        }
+
+        /* If we are doing a post format conversion we need to do that now. */
+        if (pConverter->hasPostFormatConversion) {
+            if (pFramesOutThisIteration != NULL) {
+                ma_convert_pcm_frames_format(pFramesOutThisIteration, pConverter->formatOut, pTempBufferOut, pConverter->resampler.format, frameCountOutThisIteration, pConverter->resampler.channels, pConverter->ditherMode);
+            }
+        }
+
+        framesProcessedIn  += frameCountInThisIteration;
+        framesProcessedOut += frameCountOutThisIteration;
+
+        MA_ASSERT(framesProcessedIn  <= frameCountIn);
+        MA_ASSERT(framesProcessedOut <= frameCountOut);
+
+        if (frameCountOutThisIteration == 0) {
+            break;  /* Consumed all of our input data. */
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = framesProcessedIn;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = framesProcessedOut;
+    }
+
+    return result;
+}
+
+static ma_result ma_data_converter_process_pcm_frames__resample_only(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    MA_ASSERT(pConverter != NULL);
+
+    if (pConverter->hasPreFormatConversion == MA_FALSE && pConverter->hasPostFormatConversion == MA_FALSE) {
+        /* Neither pre- nor post-format required. This is simple case where only resampling is required. */
+        return ma_resampler_process_pcm_frames(&pConverter->resampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else {
+        /* Format conversion required. */
+        return ma_data_converter_process_pcm_frames__resample_with_format_conversion(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    }
+}
+
+static ma_result ma_data_converter_process_pcm_frames__channels_only(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_result result;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 frameCount;
+
+    MA_ASSERT(pConverter != NULL);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    frameCount = ma_min(frameCountIn, frameCountOut);
+
+    if (pConverter->hasPreFormatConversion == MA_FALSE && pConverter->hasPostFormatConversion == MA_FALSE) {
+        /* No format conversion required. */
+        result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pFramesOut, pFramesIn, frameCount);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    } else {
+        /* Format conversion required. */
+        ma_uint64 framesProcessed = 0;
+
+        while (framesProcessed < frameCount) {
+            ma_uint8 pTempBufferOut[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+            const ma_uint32 tempBufferOutCap = sizeof(pTempBufferOut) / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsOut);
+            const void* pFramesInThisIteration;
+            /* */ void* pFramesOutThisIteration;
+            ma_uint64 frameCountThisIteration;
+
+            if (pFramesIn != NULL) {
+                pFramesInThisIteration = ma_offset_ptr(pFramesIn, framesProcessed * ma_get_bytes_per_frame(pConverter->formatIn, pConverter->channelsIn));
+            } else {
+                pFramesInThisIteration = NULL;
+            }
+
+            if (pFramesOut != NULL) {
+                pFramesOutThisIteration = ma_offset_ptr(pFramesOut, framesProcessed * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+            } else {
+                pFramesOutThisIteration = NULL;
+            }
+
+            /* Do a pre format conversion if necessary. */
+            if (pConverter->hasPreFormatConversion) {
+                ma_uint8 pTempBufferIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                const ma_uint32 tempBufferInCap = sizeof(pTempBufferIn) / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsIn);
+
+                frameCountThisIteration = (frameCount - framesProcessed);
+                if (frameCountThisIteration > tempBufferInCap) {
+                    frameCountThisIteration = tempBufferInCap;
+                }
+
+                if (pConverter->hasPostFormatConversion) {
+                    if (frameCountThisIteration > tempBufferOutCap) {
+                        frameCountThisIteration = tempBufferOutCap;
+                    }
+                }
+
+                if (pFramesInThisIteration != NULL) {
+                    ma_convert_pcm_frames_format(pTempBufferIn, pConverter->channelConverter.format, pFramesInThisIteration, pConverter->formatIn, frameCountThisIteration, pConverter->channelsIn, pConverter->ditherMode);
+                } else {
+                    MA_ZERO_MEMORY(pTempBufferIn, sizeof(pTempBufferIn));
+                }
+
+                if (pConverter->hasPostFormatConversion) {
+                    /* Both input and output conversion required. Output to the temp buffer. */
+                    result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pTempBufferOut, pTempBufferIn, frameCountThisIteration);
+                } else {
+                    /* Only pre-format required. Output straight to the output buffer. */
+                    result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pFramesOutThisIteration, pTempBufferIn, frameCountThisIteration);
+                }
+
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+            } else {
+                /* No pre-format required. Just read straight from the input buffer. */
+                MA_ASSERT(pConverter->hasPostFormatConversion == MA_TRUE);
+
+                frameCountThisIteration = (frameCount - framesProcessed);
+                if (frameCountThisIteration > tempBufferOutCap) {
+                    frameCountThisIteration = tempBufferOutCap;
+                }
+
+                result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pTempBufferOut, pFramesInThisIteration, frameCountThisIteration);
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+            }
+
+            /* If we are doing a post format conversion we need to do that now. */
+            if (pConverter->hasPostFormatConversion) {
+                if (pFramesOutThisIteration != NULL) {
+                    ma_convert_pcm_frames_format(pFramesOutThisIteration, pConverter->formatOut, pTempBufferOut, pConverter->channelConverter.format, frameCountThisIteration, pConverter->channelConverter.channelsOut, pConverter->ditherMode);
+                }
+            }
+
+            framesProcessed += frameCountThisIteration;
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = frameCount;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_data_converter_process_pcm_frames__resample_first(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_result result;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+    ma_uint8  pTempBufferIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];   /* In resampler format. */
+    ma_uint64 tempBufferInCap;
+    ma_uint8  pTempBufferMid[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In resampler format, channel converter input format. */
+    ma_uint64 tempBufferMidCap;
+    ma_uint8  pTempBufferOut[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In channel converter output format. */
+    ma_uint64 tempBufferOutCap;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pConverter->resampler.format   == pConverter->channelConverter.format);
+    MA_ASSERT(pConverter->resampler.channels == pConverter->channelConverter.channelsIn);
+    MA_ASSERT(pConverter->resampler.channels <  pConverter->channelConverter.channelsOut);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    tempBufferInCap  = sizeof(pTempBufferIn)  / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+    tempBufferMidCap = sizeof(pTempBufferIn)  / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+    tempBufferOutCap = sizeof(pTempBufferOut) / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsOut);
+
+    while (framesProcessedOut < frameCountOut) {
+        ma_uint64 frameCountInThisIteration;
+        ma_uint64 frameCountOutThisIteration;
+        const void* pRunningFramesIn = NULL;
+        void* pRunningFramesOut = NULL;
+        const void* pResampleBufferIn;
+        void* pChannelsBufferOut;
+
+        if (pFramesIn != NULL) {
+            pRunningFramesIn  = ma_offset_ptr(pFramesIn,  framesProcessedIn  * ma_get_bytes_per_frame(pConverter->formatIn, pConverter->channelsIn));
+        }
+        if (pFramesOut != NULL) {
+            pRunningFramesOut = ma_offset_ptr(pFramesOut, framesProcessedOut * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        }
+
+        /* Run input data through the resampler and output it to the temporary buffer. */
+        frameCountInThisIteration = (frameCountIn - framesProcessedIn);
+
+        if (pConverter->hasPreFormatConversion) {
+            if (frameCountInThisIteration > tempBufferInCap) {
+                frameCountInThisIteration = tempBufferInCap;
+            }
+        }
+
+        frameCountOutThisIteration = (frameCountOut - framesProcessedOut);
+        if (frameCountOutThisIteration > tempBufferMidCap) {
+            frameCountOutThisIteration = tempBufferMidCap;
+        }
+
+        /* We can't read more frames than can fit in the output buffer. */
+        if (pConverter->hasPostFormatConversion) {
+            if (frameCountOutThisIteration > tempBufferOutCap) {
+                frameCountOutThisIteration = tempBufferOutCap;
+            }
+        }
+
+        /* We need to ensure we don't try to process too many input frames that we run out of room in the output buffer. If this happens we'll end up glitching. */
+
+        /*
+        We need to try to predict how many input frames will be required for the resampler. If the
+        resampler can tell us, we'll use that. Otherwise we'll need to make a best guess. The further
+        off we are from this, the more wasted format conversions we'll end up doing.
+        */
+        #if 1
+        {
+            ma_uint64 requiredInputFrameCount;
+
+            result = ma_resampler_get_required_input_frame_count(&pConverter->resampler, frameCountOutThisIteration, &requiredInputFrameCount);
+            if (result != MA_SUCCESS) {
+                /* Fall back to a best guess. */
+                requiredInputFrameCount = (frameCountOutThisIteration * pConverter->resampler.sampleRateIn) / pConverter->resampler.sampleRateOut;
+            }
+
+            if (frameCountInThisIteration > requiredInputFrameCount) {
+                frameCountInThisIteration = requiredInputFrameCount;
+            }
+        }
+        #endif
+
+        if (pConverter->hasPreFormatConversion) {
+            if (pFramesIn != NULL) {
+                ma_convert_pcm_frames_format(pTempBufferIn, pConverter->resampler.format, pRunningFramesIn, pConverter->formatIn, frameCountInThisIteration, pConverter->channelsIn, pConverter->ditherMode);
+                pResampleBufferIn = pTempBufferIn;
+            } else {
+                pResampleBufferIn = NULL;
+            }
+        } else {
+            pResampleBufferIn = pRunningFramesIn;
+        }
+
+        result = ma_resampler_process_pcm_frames(&pConverter->resampler, pResampleBufferIn, &frameCountInThisIteration, pTempBufferMid, &frameCountOutThisIteration);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+
+        /*
+        The input data has been resampled so now we need to run it through the channel converter. The input data is always contained in pTempBufferMid. We only need to do
+        this part if we have an output buffer.
+        */
+        if (pFramesOut != NULL) {
+            if (pConverter->hasPostFormatConversion) {
+                pChannelsBufferOut = pTempBufferOut;
+            } else {
+                pChannelsBufferOut = pRunningFramesOut;
+            }
+
+            result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pChannelsBufferOut, pTempBufferMid, frameCountOutThisIteration);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+
+            /* Finally we do post format conversion. */
+            if (pConverter->hasPostFormatConversion) {
+                ma_convert_pcm_frames_format(pRunningFramesOut, pConverter->formatOut, pChannelsBufferOut, pConverter->channelConverter.format, frameCountOutThisIteration, pConverter->channelConverter.channelsOut, pConverter->ditherMode);
+            }
+        }
+
+
+        framesProcessedIn  += frameCountInThisIteration;
+        framesProcessedOut += frameCountOutThisIteration;
+
+        MA_ASSERT(framesProcessedIn  <= frameCountIn);
+        MA_ASSERT(framesProcessedOut <= frameCountOut);
+
+        if (frameCountOutThisIteration == 0) {
+            break;  /* Consumed all of our input data. */
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = framesProcessedIn;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = framesProcessedOut;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_data_converter_process_pcm_frames__channels_first(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_result result;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+    ma_uint8  pTempBufferIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];   /* In resampler format. */
+    ma_uint64 tempBufferInCap;
+    ma_uint8  pTempBufferMid[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In resampler format, channel converter input format. */
+    ma_uint64 tempBufferMidCap;
+    ma_uint8  pTempBufferOut[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In channel converter output format. */
+    ma_uint64 tempBufferOutCap;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pConverter->resampler.format   == pConverter->channelConverter.format);
+    MA_ASSERT(pConverter->resampler.channels == pConverter->channelConverter.channelsOut);
+    MA_ASSERT(pConverter->resampler.channels <= pConverter->channelConverter.channelsIn);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    tempBufferInCap  = sizeof(pTempBufferIn)  / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsIn);
+    tempBufferMidCap = sizeof(pTempBufferIn)  / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsOut);
+    tempBufferOutCap = sizeof(pTempBufferOut) / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+
+    while (framesProcessedOut < frameCountOut) {
+        ma_uint64 frameCountInThisIteration;
+        ma_uint64 frameCountOutThisIteration;
+        const void* pRunningFramesIn = NULL;
+        void* pRunningFramesOut = NULL;
+        const void* pChannelsBufferIn;
+        void* pResampleBufferOut;
+
+        if (pFramesIn != NULL) {
+            pRunningFramesIn  = ma_offset_ptr(pFramesIn,  framesProcessedIn  * ma_get_bytes_per_frame(pConverter->formatIn, pConverter->channelsIn));
+        }
+        if (pFramesOut != NULL) {
+            pRunningFramesOut = ma_offset_ptr(pFramesOut, framesProcessedOut * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        }
+
+        /*
+        Before doing any processing we need to determine how many frames we should try processing
+        this iteration, for both input and output. The resampler requires us to perform format and
+        channel conversion before passing any data into it. If we get our input count wrong, we'll
+        end up performing redundant pre-processing. This isn't the end of the world, but it does
+        result in some inefficiencies proportionate to how far our estimates are off.
+
+        If the resampler has a means to calculate exactly how much we'll need, we'll use that.
+        Otherwise we'll make a best guess. In order to do this, we'll need to calculate the output
+        frame count first.
+        */
+        frameCountOutThisIteration = (frameCountOut - framesProcessedOut);
+        if (frameCountOutThisIteration > tempBufferMidCap) {
+            frameCountOutThisIteration = tempBufferMidCap;
+        }
+
+        if (pConverter->hasPostFormatConversion) {
+            if (frameCountOutThisIteration > tempBufferOutCap) {
+                frameCountOutThisIteration = tempBufferOutCap;
+            }
+        }
+
+        /* Now that we have the output frame count we can determine the input frame count. */
+        frameCountInThisIteration = (frameCountIn - framesProcessedIn);
+        if (pConverter->hasPreFormatConversion) {
+            if (frameCountInThisIteration > tempBufferInCap) {
+                frameCountInThisIteration = tempBufferInCap;
+            }
+        }
+
+        if (frameCountInThisIteration > tempBufferMidCap) {
+            frameCountInThisIteration = tempBufferMidCap;
+        }
+
+        #if 1
+        {
+            ma_uint64 requiredInputFrameCount;
+
+            result = ma_resampler_get_required_input_frame_count(&pConverter->resampler, frameCountOutThisIteration, &requiredInputFrameCount);
+            if (result != MA_SUCCESS) {
+                /* Fall back to a best guess. */
+                requiredInputFrameCount = (frameCountOutThisIteration * pConverter->resampler.sampleRateIn) / pConverter->resampler.sampleRateOut;
+            }
+
+            if (frameCountInThisIteration > requiredInputFrameCount) {
+                frameCountInThisIteration = requiredInputFrameCount;
+            }
+        }
+        #endif
+
+
+        /* Pre format conversion. */
+        if (pConverter->hasPreFormatConversion) {
+            if (pRunningFramesIn != NULL) {
+                ma_convert_pcm_frames_format(pTempBufferIn, pConverter->channelConverter.format, pRunningFramesIn, pConverter->formatIn, frameCountInThisIteration, pConverter->channelsIn, pConverter->ditherMode);
+                pChannelsBufferIn = pTempBufferIn;
+            } else {
+                pChannelsBufferIn = NULL;
+            }
+        } else {
+            pChannelsBufferIn = pRunningFramesIn;
+        }
+
+
+        /* Channel conversion. */
+        result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pTempBufferMid, pChannelsBufferIn, frameCountInThisIteration);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+
+        /* Resampling. */
+        if (pConverter->hasPostFormatConversion) {
+            pResampleBufferOut = pTempBufferOut;
+        } else {
+            pResampleBufferOut = pRunningFramesOut;
+        }
+
+        result = ma_resampler_process_pcm_frames(&pConverter->resampler, pTempBufferMid, &frameCountInThisIteration, pResampleBufferOut, &frameCountOutThisIteration);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+
+        /* Post format conversion. */
+        if (pConverter->hasPostFormatConversion) {
+            if (pRunningFramesOut != NULL) {
+                ma_convert_pcm_frames_format(pRunningFramesOut, pConverter->formatOut, pResampleBufferOut, pConverter->resampler.format, frameCountOutThisIteration, pConverter->channelsOut, pConverter->ditherMode);
+            }
+        }
+
+
+        framesProcessedIn  += frameCountInThisIteration;
+        framesProcessedOut += frameCountOutThisIteration;
+
+        MA_ASSERT(framesProcessedIn  <= frameCountIn);
+        MA_ASSERT(framesProcessedOut <= frameCountOut);
+
+        if (frameCountOutThisIteration == 0) {
+            break;  /* Consumed all of our input data. */
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = framesProcessedIn;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = framesProcessedOut;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_process_pcm_frames(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    switch (pConverter->executionPath)
+    {
+        case ma_data_converter_execution_path_passthrough:    return ma_data_converter_process_pcm_frames__passthrough(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_format_only:    return ma_data_converter_process_pcm_frames__format_only(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_channels_only:  return ma_data_converter_process_pcm_frames__channels_only(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_resample_only:  return ma_data_converter_process_pcm_frames__resample_only(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_resample_first: return ma_data_converter_process_pcm_frames__resample_first(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_channels_first: return ma_data_converter_process_pcm_frames__channels_first(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        default: return MA_INVALID_OPERATION;   /* Should never hit this. */
+    }
+}
+
+MA_API ma_result ma_data_converter_set_rate(ma_data_converter* pConverter, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasResampler == MA_FALSE) {
+        return MA_INVALID_OPERATION;    /* Dynamic resampling not enabled. */
+    }
+
+    return ma_resampler_set_rate(&pConverter->resampler, sampleRateIn, sampleRateOut);
+}
+
+MA_API ma_result ma_data_converter_set_rate_ratio(ma_data_converter* pConverter, float ratioInOut)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasResampler == MA_FALSE) {
+        return MA_INVALID_OPERATION;    /* Dynamic resampling not enabled. */
+    }
+
+    return ma_resampler_set_rate_ratio(&pConverter->resampler, ratioInOut);
+}
+
+MA_API ma_uint64 ma_data_converter_get_input_latency(const ma_data_converter* pConverter)
+{
+    if (pConverter == NULL) {
+        return 0;
+    }
+
+    if (pConverter->hasResampler) {
+        return ma_resampler_get_input_latency(&pConverter->resampler);
+    }
+
+    return 0;   /* No latency without a resampler. */
+}
+
+MA_API ma_uint64 ma_data_converter_get_output_latency(const ma_data_converter* pConverter)
+{
+    if (pConverter == NULL) {
+        return 0;
+    }
+
+    if (pConverter->hasResampler) {
+        return ma_resampler_get_output_latency(&pConverter->resampler);
+    }
+
+    return 0;   /* No latency without a resampler. */
+}
+
+MA_API ma_result ma_data_converter_get_required_input_frame_count(const ma_data_converter* pConverter, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount)
+{
+    if (pInputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pInputFrameCount = 0;
+
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasResampler) {
+        return ma_resampler_get_required_input_frame_count(&pConverter->resampler, outputFrameCount, pInputFrameCount);
+    } else {
+        *pInputFrameCount = outputFrameCount;   /* 1:1 */
+        return MA_SUCCESS;
+    }
+}
+
+MA_API ma_result ma_data_converter_get_expected_output_frame_count(const ma_data_converter* pConverter, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount)
+{
+    if (pOutputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pOutputFrameCount = 0;
+
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasResampler) {
+        return ma_resampler_get_expected_output_frame_count(&pConverter->resampler, inputFrameCount, pOutputFrameCount);
+    } else {
+        *pOutputFrameCount = inputFrameCount;   /* 1:1 */
+        return MA_SUCCESS;
+    }
+}
+
+MA_API ma_result ma_data_converter_get_input_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pConverter == NULL || pChannelMap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasChannelConverter) {
+        ma_channel_converter_get_output_channel_map(&pConverter->channelConverter, pChannelMap, channelMapCap);
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pConverter->channelsOut);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_get_output_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pConverter == NULL || pChannelMap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasChannelConverter) {
+        ma_channel_converter_get_input_channel_map(&pConverter->channelConverter, pChannelMap, channelMapCap);
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pConverter->channelsIn);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_reset(ma_data_converter* pConverter)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* There's nothing to do if we're not resampling. */
+    if (pConverter->hasResampler == MA_FALSE) {
+        return MA_SUCCESS;
+    }
+
+    return ma_resampler_reset(&pConverter->resampler);
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Channel Maps
+
+**************************************************************************************************************************************************************/
+static ma_channel ma_channel_map_init_standard_channel(ma_standard_channel_map standardChannelMap, ma_uint32 channelCount, ma_uint32 channelIndex);
+
+MA_API ma_channel ma_channel_map_get_channel(const ma_channel* pChannelMap, ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    if (pChannelMap == NULL) {
+        return ma_channel_map_init_standard_channel(ma_standard_channel_map_default, channelCount, channelIndex);
+    } else {
+        if (channelIndex >= channelCount) {
+            return MA_CHANNEL_NONE;
+        }
+
+        return pChannelMap[channelIndex];
+    }
+}
+
+MA_API void ma_channel_map_init_blank(ma_channel* pChannelMap, ma_uint32 channels)
+{
+    if (pChannelMap == NULL) {
+        return;
+    }
+
+    MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channels);
+}
+
+
+static ma_channel ma_channel_map_init_standard_channel_microsoft(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    if (channelCount == 0 || channelIndex >= channelCount) {
+        return MA_CHANNEL_NONE;
+    }
+
+    /* This is the Microsoft channel map. Based off the speaker configurations mentioned here: https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ksmedia/ns-ksmedia-ksaudio_channel_config */
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3: /* No defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+            #ifndef MA_USE_QUAD_MICROSOFT_CHANNEL_MAP
+                /* Surround. Using the Surround profile has the advantage of the 3rd channel (MA_CHANNEL_FRONT_CENTER) mapping nicely with higher channel counts. */
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_CENTER;
+            #else
+                /* Quad. */
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            #endif
+            }
+        } break;
+
+        case 5: /* Not defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_SIDE_LEFT;
+                case 5: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+
+        case 7: /* Not defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_CENTER;
+                case 5: return MA_CHANNEL_SIDE_LEFT;
+                case 6: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_LEFT;
+                case 5: return MA_CHANNEL_BACK_RIGHT;
+                case 6: return MA_CHANNEL_SIDE_LEFT;
+                case 7: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_alsa(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+                case 5: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 7:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+                case 5: return MA_CHANNEL_LFE;
+                case 6: return MA_CHANNEL_BACK_CENTER;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+                case 5: return MA_CHANNEL_LFE;
+                case 6: return MA_CHANNEL_SIDE_LEFT;
+                case 7: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_rfc3551(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_BACK_CENTER;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_SIDE_LEFT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_FRONT_RIGHT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_CENTER;
+            }
+        } break;
+    }
+
+    if (channelCount > 6) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 6));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_flac(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_LEFT;
+                case 5: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 7:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_CENTER;
+                case 5: return MA_CHANNEL_SIDE_LEFT;
+                case 6: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_LEFT;
+                case 5: return MA_CHANNEL_BACK_RIGHT;
+                case 6: return MA_CHANNEL_SIDE_LEFT;
+                case 7: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_vorbis(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+                case 5: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 7:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_SIDE_LEFT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_CENTER;
+                case 6: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_SIDE_LEFT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_LEFT;
+                case 6: return MA_CHANNEL_BACK_RIGHT;
+                case 7: return MA_CHANNEL_LFE;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_sound4(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+                case 5: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 7:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_SIDE_LEFT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_CENTER;
+                case 6: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_SIDE_LEFT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_LEFT;
+                case 6: return MA_CHANNEL_BACK_RIGHT;
+                case 7: return MA_CHANNEL_LFE;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_sndio(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3: /* No defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5: /* Not defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 6:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+                case 5: return MA_CHANNEL_LFE;
+            }
+        } break;
+    }
+
+    if (channelCount > 6) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 6));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+
+static ma_channel ma_channel_map_init_standard_channel(ma_standard_channel_map standardChannelMap, ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    if (channelCount == 0 || channelIndex >= channelCount) {
+        return MA_CHANNEL_NONE;
+    }
+
+    switch (standardChannelMap)
+    {
+        case ma_standard_channel_map_alsa:
+        {
+            return ma_channel_map_init_standard_channel_alsa(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_rfc3551:
+        {
+            return ma_channel_map_init_standard_channel_rfc3551(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_flac:
+        {
+            return ma_channel_map_init_standard_channel_flac(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_vorbis:
+        {
+            return ma_channel_map_init_standard_channel_vorbis(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_sound4:
+        {
+            return ma_channel_map_init_standard_channel_sound4(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_sndio:
+        {
+            return ma_channel_map_init_standard_channel_sndio(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_microsoft: /* Also default. */
+        /*case ma_standard_channel_map_default;*/
+        default:
+        {
+            return ma_channel_map_init_standard_channel_microsoft(channelCount, channelIndex);
+        } break;
+    }
+}
+
+MA_API void ma_channel_map_init_standard(ma_standard_channel_map standardChannelMap, ma_channel* pChannelMap, size_t channelMapCap, ma_uint32 channels)
+{
+    ma_uint32 iChannel;
+
+    if (pChannelMap == NULL || channelMapCap == 0 || channels == 0) {
+        return;
+    }
+
+    for (iChannel = 0; iChannel < channels; iChannel += 1) {
+        if (channelMapCap == 0) {
+            break;  /* Ran out of room. */
+        }
+
+        pChannelMap[0] = ma_channel_map_init_standard_channel(standardChannelMap, channels, iChannel);
+        pChannelMap   += 1;
+        channelMapCap -= 1;
+    }
+}
+
+MA_API void ma_channel_map_copy(ma_channel* pOut, const ma_channel* pIn, ma_uint32 channels)
+{
+    if (pOut != NULL && pIn != NULL && channels > 0) {
+        MA_COPY_MEMORY(pOut, pIn, sizeof(*pOut) * channels);
+    }
+}
+
+MA_API void ma_channel_map_copy_or_default(ma_channel* pOut, size_t channelMapCapOut, const ma_channel* pIn, ma_uint32 channels)
+{
+    if (pOut == NULL || channels == 0) {
+        return;
+    }
+
+    if (pIn != NULL) {
+        ma_channel_map_copy(pOut, pIn, channels);
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pOut, channelMapCapOut, channels);
+    }
+}
+
+MA_API ma_bool32 ma_channel_map_is_valid(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    /* A channel count of 0 is invalid. */
+    if (channels == 0) {
+        return MA_FALSE;
+    }
+
+    /* It does not make sense to have a mono channel when there is more than 1 channel. */
+    if (channels > 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; ++iChannel) {
+            if (ma_channel_map_get_channel(pChannelMap, channels, iChannel) == MA_CHANNEL_MONO) {
+                return MA_FALSE;
+            }
+        }
+    }
+
+    return MA_TRUE;
+}
+
+MA_API ma_bool32 ma_channel_map_is_equal(const ma_channel* pChannelMapA, const ma_channel* pChannelMapB, ma_uint32 channels)
+{
+    ma_uint32 iChannel;
+
+    if (pChannelMapA == pChannelMapB) {
+        return MA_TRUE;
+    }
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        if (ma_channel_map_get_channel(pChannelMapA, channels, iChannel) != ma_channel_map_get_channel(pChannelMapB, channels, iChannel)) {
+            return MA_FALSE;
+        }
+    }
+
+    return MA_TRUE;
+}
+
+MA_API ma_bool32 ma_channel_map_is_blank(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    ma_uint32 iChannel;
+
+    /* A null channel map is equivalent to the default channel map. */
+    if (pChannelMap == NULL) {
+        return MA_FALSE;
+    }
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        if (pChannelMap[iChannel] != MA_CHANNEL_NONE) {
+            return MA_FALSE;
+        }
+    }
+
+    return MA_TRUE;
+}
+
+MA_API ma_bool32 ma_channel_map_contains_channel_position(ma_uint32 channels, const ma_channel* pChannelMap, ma_channel channelPosition)
+{
+    return ma_channel_map_find_channel_position(channels, pChannelMap, channelPosition, NULL);
+}
+
+MA_API ma_bool32 ma_channel_map_find_channel_position(ma_uint32 channels, const ma_channel* pChannelMap, ma_channel channelPosition, ma_uint32* pChannelIndex)
+{
+    ma_uint32 iChannel;
+
+    if (pChannelIndex != NULL) {
+        *pChannelIndex = (ma_uint32)-1;
+    }
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        if (ma_channel_map_get_channel(pChannelMap, channels, iChannel) == channelPosition) {
+            if (pChannelIndex != NULL) {
+                *pChannelIndex = iChannel;
+            }
+
+            return MA_TRUE;
+        }
+    }
+
+    /* Getting here means the channel position was not found. */
+    return MA_FALSE;
+}
+
+MA_API size_t ma_channel_map_to_string(const ma_channel* pChannelMap, ma_uint32 channels, char* pBufferOut, size_t bufferCap)
+{
+    size_t len;
+    ma_uint32 iChannel;
+
+    len = 0;
+
+    for (iChannel = 0; iChannel < channels; iChannel += 1) {
+        const char* pChannelStr = ma_channel_position_to_string(ma_channel_map_get_channel(pChannelMap, channels, iChannel));
+        size_t channelStrLen = strlen(pChannelStr);
+
+        /* Append the string if necessary. */
+        if (pBufferOut != NULL && bufferCap > len + channelStrLen) {
+            MA_COPY_MEMORY(pBufferOut + len, pChannelStr, channelStrLen);
+        }
+        len += channelStrLen;
+
+        /* Append a space if it's not the last item. */
+        if (iChannel+1 < channels) {
+            if (pBufferOut != NULL && bufferCap > len + 1) {
+                pBufferOut[len] = ' ';
+            }
+            len += 1;
+        }
+    }
+
+    /* Null terminate. Don't increment the length here. */
+    if (pBufferOut != NULL) {
+        if (bufferCap > len) {
+            pBufferOut[len] = '\0';
+        } else if (bufferCap > 0) {
+            pBufferOut[bufferCap - 1] = '\0';
+        }
+    }
+
+    return len;
+}
+
+MA_API const char* ma_channel_position_to_string(ma_channel channel)
+{
+    switch (channel)
+    {
+        case MA_CHANNEL_NONE              : return "CHANNEL_NONE";
+        case MA_CHANNEL_MONO              : return "CHANNEL_MONO";
+        case MA_CHANNEL_FRONT_LEFT        : return "CHANNEL_FRONT_LEFT";
+        case MA_CHANNEL_FRONT_RIGHT       : return "CHANNEL_FRONT_RIGHT";
+        case MA_CHANNEL_FRONT_CENTER      : return "CHANNEL_FRONT_CENTER";
+        case MA_CHANNEL_LFE               : return "CHANNEL_LFE";
+        case MA_CHANNEL_BACK_LEFT         : return "CHANNEL_BACK_LEFT";
+        case MA_CHANNEL_BACK_RIGHT        : return "CHANNEL_BACK_RIGHT";
+        case MA_CHANNEL_FRONT_LEFT_CENTER : return "CHANNEL_FRONT_LEFT_CENTER";
+        case MA_CHANNEL_FRONT_RIGHT_CENTER: return "CHANNEL_FRONT_RIGHT_CENTER";
+        case MA_CHANNEL_BACK_CENTER       : return "CHANNEL_BACK_CENTER";
+        case MA_CHANNEL_SIDE_LEFT         : return "CHANNEL_SIDE_LEFT";
+        case MA_CHANNEL_SIDE_RIGHT        : return "CHANNEL_SIDE_RIGHT";
+        case MA_CHANNEL_TOP_CENTER        : return "CHANNEL_TOP_CENTER";
+        case MA_CHANNEL_TOP_FRONT_LEFT    : return "CHANNEL_TOP_FRONT_LEFT";
+        case MA_CHANNEL_TOP_FRONT_CENTER  : return "CHANNEL_TOP_FRONT_CENTER";
+        case MA_CHANNEL_TOP_FRONT_RIGHT   : return "CHANNEL_TOP_FRONT_RIGHT";
+        case MA_CHANNEL_TOP_BACK_LEFT     : return "CHANNEL_TOP_BACK_LEFT";
+        case MA_CHANNEL_TOP_BACK_CENTER   : return "CHANNEL_TOP_BACK_CENTER";
+        case MA_CHANNEL_TOP_BACK_RIGHT    : return "CHANNEL_TOP_BACK_RIGHT";
+        case MA_CHANNEL_AUX_0             : return "CHANNEL_AUX_0";
+        case MA_CHANNEL_AUX_1             : return "CHANNEL_AUX_1";
+        case MA_CHANNEL_AUX_2             : return "CHANNEL_AUX_2";
+        case MA_CHANNEL_AUX_3             : return "CHANNEL_AUX_3";
+        case MA_CHANNEL_AUX_4             : return "CHANNEL_AUX_4";
+        case MA_CHANNEL_AUX_5             : return "CHANNEL_AUX_5";
+        case MA_CHANNEL_AUX_6             : return "CHANNEL_AUX_6";
+        case MA_CHANNEL_AUX_7             : return "CHANNEL_AUX_7";
+        case MA_CHANNEL_AUX_8             : return "CHANNEL_AUX_8";
+        case MA_CHANNEL_AUX_9             : return "CHANNEL_AUX_9";
+        case MA_CHANNEL_AUX_10            : return "CHANNEL_AUX_10";
+        case MA_CHANNEL_AUX_11            : return "CHANNEL_AUX_11";
+        case MA_CHANNEL_AUX_12            : return "CHANNEL_AUX_12";
+        case MA_CHANNEL_AUX_13            : return "CHANNEL_AUX_13";
+        case MA_CHANNEL_AUX_14            : return "CHANNEL_AUX_14";
+        case MA_CHANNEL_AUX_15            : return "CHANNEL_AUX_15";
+        case MA_CHANNEL_AUX_16            : return "CHANNEL_AUX_16";
+        case MA_CHANNEL_AUX_17            : return "CHANNEL_AUX_17";
+        case MA_CHANNEL_AUX_18            : return "CHANNEL_AUX_18";
+        case MA_CHANNEL_AUX_19            : return "CHANNEL_AUX_19";
+        case MA_CHANNEL_AUX_20            : return "CHANNEL_AUX_20";
+        case MA_CHANNEL_AUX_21            : return "CHANNEL_AUX_21";
+        case MA_CHANNEL_AUX_22            : return "CHANNEL_AUX_22";
+        case MA_CHANNEL_AUX_23            : return "CHANNEL_AUX_23";
+        case MA_CHANNEL_AUX_24            : return "CHANNEL_AUX_24";
+        case MA_CHANNEL_AUX_25            : return "CHANNEL_AUX_25";
+        case MA_CHANNEL_AUX_26            : return "CHANNEL_AUX_26";
+        case MA_CHANNEL_AUX_27            : return "CHANNEL_AUX_27";
+        case MA_CHANNEL_AUX_28            : return "CHANNEL_AUX_28";
+        case MA_CHANNEL_AUX_29            : return "CHANNEL_AUX_29";
+        case MA_CHANNEL_AUX_30            : return "CHANNEL_AUX_30";
+        case MA_CHANNEL_AUX_31            : return "CHANNEL_AUX_31";
+        default: break;
+    }
+
+    return "UNKNOWN";
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Conversion Helpers
+
+**************************************************************************************************************************************************************/
+MA_API ma_uint64 ma_convert_frames(void* pOut, ma_uint64 frameCountOut, ma_format formatOut, ma_uint32 channelsOut, ma_uint32 sampleRateOut, const void* pIn, ma_uint64 frameCountIn, ma_format formatIn, ma_uint32 channelsIn, ma_uint32 sampleRateIn)
+{
+    ma_data_converter_config config;
+
+    config = ma_data_converter_config_init(formatIn, formatOut, channelsIn, channelsOut, sampleRateIn, sampleRateOut);
+    config.resampling.linear.lpfOrder = ma_min(MA_DEFAULT_RESAMPLER_LPF_ORDER, MA_MAX_FILTER_ORDER);
+
+    return ma_convert_frames_ex(pOut, frameCountOut, pIn, frameCountIn, &config);
+}
+
+MA_API ma_uint64 ma_convert_frames_ex(void* pOut, ma_uint64 frameCountOut, const void* pIn, ma_uint64 frameCountIn, const ma_data_converter_config* pConfig)
+{
+    ma_result result;
+    ma_data_converter converter;
+
+    if (frameCountIn == 0 || pConfig == NULL) {
+        return 0;
+    }
+
+    result = ma_data_converter_init(pConfig, NULL, &converter);
+    if (result != MA_SUCCESS) {
+        return 0;   /* Failed to initialize the data converter. */
+    }
+
+    if (pOut == NULL) {
+        result = ma_data_converter_get_expected_output_frame_count(&converter, frameCountIn, &frameCountOut);
+        if (result != MA_SUCCESS) {
+            if (result == MA_NOT_IMPLEMENTED) {
+                /* No way to calculate the number of frames, so we'll need to brute force it and loop. */
+                frameCountOut = 0;
+
+                while (frameCountIn > 0) {
+                    ma_uint64 framesProcessedIn  = frameCountIn;
+                    ma_uint64 framesProcessedOut = 0xFFFFFFFF;
+
+                    result = ma_data_converter_process_pcm_frames(&converter, pIn, &framesProcessedIn, NULL, &framesProcessedOut);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    frameCountIn  -= framesProcessedIn;
+                }
+            }
+        }
+    } else {
+        result = ma_data_converter_process_pcm_frames(&converter, pIn, &frameCountIn, pOut, &frameCountOut);
+        if (result != MA_SUCCESS) {
+            frameCountOut = 0;
+        }
+    }
+
+    ma_data_converter_uninit(&converter, NULL);
+    return frameCountOut;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Ring Buffer
+
+**************************************************************************************************************************************************************/
+static MA_INLINE ma_uint32 ma_rb__extract_offset_in_bytes(ma_uint32 encodedOffset)
+{
+    return encodedOffset & 0x7FFFFFFF;
+}
+
+static MA_INLINE ma_uint32 ma_rb__extract_offset_loop_flag(ma_uint32 encodedOffset)
+{
+    return encodedOffset & 0x80000000;
+}
+
+static MA_INLINE void* ma_rb__get_read_ptr(ma_rb* pRB)
+{
+    MA_ASSERT(pRB != NULL);
+    return ma_offset_ptr(pRB->pBuffer, ma_rb__extract_offset_in_bytes(ma_atomic_load_32(&pRB->encodedReadOffset)));
+}
+
+static MA_INLINE void* ma_rb__get_write_ptr(ma_rb* pRB)
+{
+    MA_ASSERT(pRB != NULL);
+    return ma_offset_ptr(pRB->pBuffer, ma_rb__extract_offset_in_bytes(ma_atomic_load_32(&pRB->encodedWriteOffset)));
+}
+
+static MA_INLINE ma_uint32 ma_rb__construct_offset(ma_uint32 offsetInBytes, ma_uint32 offsetLoopFlag)
+{
+    return offsetLoopFlag | offsetInBytes;
+}
+
+static MA_INLINE void ma_rb__deconstruct_offset(ma_uint32 encodedOffset, ma_uint32* pOffsetInBytes, ma_uint32* pOffsetLoopFlag)
+{
+    MA_ASSERT(pOffsetInBytes != NULL);
+    MA_ASSERT(pOffsetLoopFlag != NULL);
+
+    *pOffsetInBytes  = ma_rb__extract_offset_in_bytes(encodedOffset);
+    *pOffsetLoopFlag = ma_rb__extract_offset_loop_flag(encodedOffset);
+}
+
+
+MA_API ma_result ma_rb_init_ex(size_t subbufferSizeInBytes, size_t subbufferCount, size_t subbufferStrideInBytes, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_rb* pRB)
+{
+    ma_result result;
+    const ma_uint32 maxSubBufferSize = 0x7FFFFFFF - (MA_SIMD_ALIGNMENT-1);
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (subbufferSizeInBytes == 0 || subbufferCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (subbufferSizeInBytes > maxSubBufferSize) {
+        return MA_INVALID_ARGS;    /* Maximum buffer size is ~2GB. The most significant bit is a flag for use internally. */
+    }
+
+
+    MA_ZERO_OBJECT(pRB);
+
+    result = ma_allocation_callbacks_init_copy(&pRB->allocationCallbacks, pAllocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pRB->subbufferSizeInBytes = (ma_uint32)subbufferSizeInBytes;
+    pRB->subbufferCount = (ma_uint32)subbufferCount;
+
+    if (pOptionalPreallocatedBuffer != NULL) {
+        pRB->subbufferStrideInBytes = (ma_uint32)subbufferStrideInBytes;
+        pRB->pBuffer = pOptionalPreallocatedBuffer;
+    } else {
+        size_t bufferSizeInBytes;
+
+        /*
+        Here is where we allocate our own buffer. We always want to align this to MA_SIMD_ALIGNMENT for future SIMD optimization opportunity. To do this
+        we need to make sure the stride is a multiple of MA_SIMD_ALIGNMENT.
+        */
+        pRB->subbufferStrideInBytes = ma_align(pRB->subbufferSizeInBytes, MA_SIMD_ALIGNMENT);
+
+        bufferSizeInBytes = (size_t)pRB->subbufferCount*pRB->subbufferStrideInBytes;
+        pRB->pBuffer = ma_aligned_malloc(bufferSizeInBytes, MA_SIMD_ALIGNMENT, &pRB->allocationCallbacks);
+        if (pRB->pBuffer == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        MA_ZERO_MEMORY(pRB->pBuffer, bufferSizeInBytes);
+        pRB->ownsBuffer = MA_TRUE;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_init(size_t bufferSizeInBytes, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_rb* pRB)
+{
+    return ma_rb_init_ex(bufferSizeInBytes, 1, 0, pOptionalPreallocatedBuffer, pAllocationCallbacks, pRB);
+}
+
+MA_API void ma_rb_uninit(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    if (pRB->ownsBuffer) {
+        ma_aligned_free(pRB->pBuffer, &pRB->allocationCallbacks);
+    }
+}
+
+MA_API void ma_rb_reset(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedReadOffset, 0);
+    ma_atomic_exchange_32(&pRB->encodedWriteOffset, 0);
+}
+
+MA_API ma_result ma_rb_acquire_read(ma_rb* pRB, size_t* pSizeInBytes, void** ppBufferOut)
+{
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    size_t bytesAvailable;
+    size_t bytesRequested;
+
+    if (pRB == NULL || pSizeInBytes == NULL || ppBufferOut == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The returned buffer should never move ahead of the write pointer. */
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    /*
+    The number of bytes available depends on whether or not the read and write pointers are on the same loop iteration. If so, we
+    can only read up to the write pointer. If not, we can only read up to the end of the buffer.
+    */
+    if (readOffsetLoopFlag == writeOffsetLoopFlag) {
+        bytesAvailable = writeOffsetInBytes - readOffsetInBytes;
+    } else {
+        bytesAvailable = pRB->subbufferSizeInBytes - readOffsetInBytes;
+    }
+
+    bytesRequested = *pSizeInBytes;
+    if (bytesRequested > bytesAvailable) {
+        bytesRequested = bytesAvailable;
+    }
+
+    *pSizeInBytes = bytesRequested;
+    (*ppBufferOut) = ma_rb__get_read_ptr(pRB);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_commit_read(ma_rb* pRB, size_t sizeInBytes)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 newReadOffsetInBytes;
+    ma_uint32 newReadOffsetLoopFlag;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    /* Check that sizeInBytes is correct. It should never go beyond the end of the buffer. */
+    newReadOffsetInBytes = (ma_uint32)(readOffsetInBytes + sizeInBytes);
+    if (newReadOffsetInBytes > pRB->subbufferSizeInBytes) {
+        return MA_INVALID_ARGS;    /* <-- sizeInBytes will cause the read offset to overflow. */
+    }
+
+    /* Move the read pointer back to the start if necessary. */
+    newReadOffsetLoopFlag = readOffsetLoopFlag;
+    if (newReadOffsetInBytes == pRB->subbufferSizeInBytes) {
+        newReadOffsetInBytes = 0;
+        newReadOffsetLoopFlag ^= 0x80000000;
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedReadOffset, ma_rb__construct_offset(newReadOffsetInBytes, newReadOffsetLoopFlag));
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_acquire_write(ma_rb* pRB, size_t* pSizeInBytes, void** ppBufferOut)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    size_t bytesAvailable;
+    size_t bytesRequested;
+
+    if (pRB == NULL || pSizeInBytes == NULL || ppBufferOut == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The returned buffer should never overtake the read buffer. */
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    /*
+    In the case of writing, if the write pointer and the read pointer are on the same loop iteration we can only
+    write up to the end of the buffer. Otherwise we can only write up to the read pointer. The write pointer should
+    never overtake the read pointer.
+    */
+    if (writeOffsetLoopFlag == readOffsetLoopFlag) {
+        bytesAvailable = pRB->subbufferSizeInBytes - writeOffsetInBytes;
+    } else {
+        bytesAvailable = readOffsetInBytes - writeOffsetInBytes;
+    }
+
+    bytesRequested = *pSizeInBytes;
+    if (bytesRequested > bytesAvailable) {
+        bytesRequested = bytesAvailable;
+    }
+
+    *pSizeInBytes = bytesRequested;
+    *ppBufferOut  = ma_rb__get_write_ptr(pRB);
+
+    /* Clear the buffer if desired. */
+    if (pRB->clearOnWriteAcquire) {
+        MA_ZERO_MEMORY(*ppBufferOut, *pSizeInBytes);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_commit_write(ma_rb* pRB, size_t sizeInBytes)
+{
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    ma_uint32 newWriteOffsetInBytes;
+    ma_uint32 newWriteOffsetLoopFlag;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    /* Check that sizeInBytes is correct. It should never go beyond the end of the buffer. */
+    newWriteOffsetInBytes = (ma_uint32)(writeOffsetInBytes + sizeInBytes);
+    if (newWriteOffsetInBytes > pRB->subbufferSizeInBytes) {
+        return MA_INVALID_ARGS;    /* <-- sizeInBytes will cause the read offset to overflow. */
+    }
+
+    /* Move the read pointer back to the start if necessary. */
+    newWriteOffsetLoopFlag = writeOffsetLoopFlag;
+    if (newWriteOffsetInBytes == pRB->subbufferSizeInBytes) {
+        newWriteOffsetInBytes = 0;
+        newWriteOffsetLoopFlag ^= 0x80000000;
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedWriteOffset, ma_rb__construct_offset(newWriteOffsetInBytes, newWriteOffsetLoopFlag));
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_seek_read(ma_rb* pRB, size_t offsetInBytes)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    ma_uint32 newReadOffsetInBytes;
+    ma_uint32 newReadOffsetLoopFlag;
+
+    if (pRB == NULL || offsetInBytes > pRB->subbufferSizeInBytes) {
+        return MA_INVALID_ARGS;
+    }
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    newReadOffsetLoopFlag = readOffsetLoopFlag;
+
+    /* We cannot go past the write buffer. */
+    if (readOffsetLoopFlag == writeOffsetLoopFlag) {
+        if ((readOffsetInBytes + offsetInBytes) > writeOffsetInBytes) {
+            newReadOffsetInBytes = writeOffsetInBytes;
+        } else {
+            newReadOffsetInBytes = (ma_uint32)(readOffsetInBytes + offsetInBytes);
+        }
+    } else {
+        /* May end up looping. */
+        if ((readOffsetInBytes + offsetInBytes) >= pRB->subbufferSizeInBytes) {
+            newReadOffsetInBytes = (ma_uint32)(readOffsetInBytes + offsetInBytes) - pRB->subbufferSizeInBytes;
+            newReadOffsetLoopFlag ^= 0x80000000;    /* <-- Looped. */
+        } else {
+            newReadOffsetInBytes = (ma_uint32)(readOffsetInBytes + offsetInBytes);
+        }
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedReadOffset, ma_rb__construct_offset(newReadOffsetInBytes, newReadOffsetLoopFlag));
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_seek_write(ma_rb* pRB, size_t offsetInBytes)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    ma_uint32 newWriteOffsetInBytes;
+    ma_uint32 newWriteOffsetLoopFlag;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    newWriteOffsetLoopFlag = writeOffsetLoopFlag;
+
+    /* We cannot go past the write buffer. */
+    if (readOffsetLoopFlag == writeOffsetLoopFlag) {
+        /* May end up looping. */
+        if ((writeOffsetInBytes + offsetInBytes) >= pRB->subbufferSizeInBytes) {
+            newWriteOffsetInBytes = (ma_uint32)(writeOffsetInBytes + offsetInBytes) - pRB->subbufferSizeInBytes;
+            newWriteOffsetLoopFlag ^= 0x80000000;    /* <-- Looped. */
+        } else {
+            newWriteOffsetInBytes = (ma_uint32)(writeOffsetInBytes + offsetInBytes);
+        }
+    } else {
+        if ((writeOffsetInBytes + offsetInBytes) > readOffsetInBytes) {
+            newWriteOffsetInBytes = readOffsetInBytes;
+        } else {
+            newWriteOffsetInBytes = (ma_uint32)(writeOffsetInBytes + offsetInBytes);
+        }
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedWriteOffset, ma_rb__construct_offset(newWriteOffsetInBytes, newWriteOffsetLoopFlag));
+    return MA_SUCCESS;
+}
+
+MA_API ma_int32 ma_rb_pointer_distance(ma_rb* pRB)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    if (readOffsetLoopFlag == writeOffsetLoopFlag) {
+        return writeOffsetInBytes - readOffsetInBytes;
+    } else {
+        return writeOffsetInBytes + (pRB->subbufferSizeInBytes - readOffsetInBytes);
+    }
+}
+
+MA_API ma_uint32 ma_rb_available_read(ma_rb* pRB)
+{
+    ma_int32 dist;
+
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    dist = ma_rb_pointer_distance(pRB);
+    if (dist < 0) {
+        return 0;
+    }
+
+    return dist;
+}
+
+MA_API ma_uint32 ma_rb_available_write(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return (ma_uint32)(ma_rb_get_subbuffer_size(pRB) - ma_rb_pointer_distance(pRB));
+}
+
+MA_API size_t ma_rb_get_subbuffer_size(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return pRB->subbufferSizeInBytes;
+}
+
+MA_API size_t ma_rb_get_subbuffer_stride(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    if (pRB->subbufferStrideInBytes == 0) {
+        return (size_t)pRB->subbufferSizeInBytes;
+    }
+
+    return (size_t)pRB->subbufferStrideInBytes;
+}
+
+MA_API size_t ma_rb_get_subbuffer_offset(ma_rb* pRB, size_t subbufferIndex)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return subbufferIndex * ma_rb_get_subbuffer_stride(pRB);
+}
+
+MA_API void* ma_rb_get_subbuffer_ptr(ma_rb* pRB, size_t subbufferIndex, void* pBuffer)
+{
+    if (pRB == NULL) {
+        return NULL;
+    }
+
+    return ma_offset_ptr(pBuffer, ma_rb_get_subbuffer_offset(pRB, subbufferIndex));
+}
+
+
+
+static ma_result ma_pcm_rb_data_source__on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    /* Since there's no notion of an end, we don't ever want to return MA_AT_END here. But it is possible to return 0. */
+    ma_pcm_rb* pRB = (ma_pcm_rb*)pDataSource;
+    ma_result result;
+    ma_uint64 totalFramesRead;
+
+    MA_ASSERT(pRB != NULL);
+
+    /* We need to run this in a loop since the ring buffer itself may loop. */
+    totalFramesRead = 0;
+    while (totalFramesRead < frameCount) {
+        void* pMappedBuffer;
+        ma_uint32 mappedFrameCount;
+        ma_uint64 framesToRead = frameCount - totalFramesRead;
+        if (framesToRead > 0xFFFFFFFF) {
+            framesToRead = 0xFFFFFFFF;
+        }
+
+        mappedFrameCount = (ma_uint32)framesToRead;
+        result = ma_pcm_rb_acquire_read(pRB, &mappedFrameCount, &pMappedBuffer);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        if (mappedFrameCount == 0) {
+            break;  /* <-- End of ring buffer. */
+        }
+
+        ma_copy_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, pRB->format, pRB->channels), pMappedBuffer, mappedFrameCount, pRB->format, pRB->channels);
+
+        result = ma_pcm_rb_commit_read(pRB, mappedFrameCount);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        totalFramesRead += mappedFrameCount;
+    }
+
+    /*
+    There is no notion of an "end" in a ring buffer. If we didn't have enough data to fill the requested frame
+    count we'll need to pad with silence. If we don't do this, totalFramesRead might equal 0 which will result
+    in the data source layer at a higher level translating this to MA_AT_END which is incorrect for a ring buffer.
+    */
+    if (totalFramesRead < frameCount) {
+        ma_silence_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, pRB->format, pRB->channels), (frameCount - totalFramesRead), pRB->format, pRB->channels);
+        totalFramesRead = frameCount;
+    }
+
+    *pFramesRead = totalFramesRead;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_pcm_rb_data_source__on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_pcm_rb* pRB = (ma_pcm_rb*)pDataSource;
+    MA_ASSERT(pRB != NULL);
+
+    if (pFormat != NULL) {
+        *pFormat = pRB->format;
+    }
+
+    if (pChannels != NULL) {
+        *pChannels = pRB->channels;
+    }
+
+    if (pSampleRate != NULL) {
+        *pSampleRate = pRB->sampleRate;
+    }
+
+    /* Just assume the default channel map. */
+    if (pChannelMap != NULL) {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pRB->channels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable ma_gRBDataSourceVTable =
+{
+    ma_pcm_rb_data_source__on_read,
+    NULL,   /* onSeek */
+    ma_pcm_rb_data_source__on_get_data_format,
+    NULL,   /* onGetCursor */
+    NULL,   /* onGetLength */
+    NULL,   /* onSetLooping */
+    0
+};
+
+static MA_INLINE ma_uint32 ma_pcm_rb_get_bpf(ma_pcm_rb* pRB)
+{
+    MA_ASSERT(pRB != NULL);
+
+    return ma_get_bytes_per_frame(pRB->format, pRB->channels);
+}
+
+MA_API ma_result ma_pcm_rb_init_ex(ma_format format, ma_uint32 channels, ma_uint32 subbufferSizeInFrames, ma_uint32 subbufferCount, ma_uint32 subbufferStrideInFrames, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_pcm_rb* pRB)
+{
+    ma_uint32 bpf;
+    ma_result result;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pRB);
+
+    bpf = ma_get_bytes_per_frame(format, channels);
+    if (bpf == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_rb_init_ex(subbufferSizeInFrames*bpf, subbufferCount, subbufferStrideInFrames*bpf, pOptionalPreallocatedBuffer, pAllocationCallbacks, &pRB->rb);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pRB->format     = format;
+    pRB->channels   = channels;
+    pRB->sampleRate = 0;    /* The sample rate is not passed in as a parameter. */
+
+    /* The PCM ring buffer is a data source. We need to get that set up as well. */
+    {
+        ma_data_source_config dataSourceConfig = ma_data_source_config_init();
+        dataSourceConfig.vtable = &ma_gRBDataSourceVTable;
+
+        result = ma_data_source_init(&dataSourceConfig, &pRB->ds);
+        if (result != MA_SUCCESS) {
+            ma_rb_uninit(&pRB->rb);
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pcm_rb_init(ma_format format, ma_uint32 channels, ma_uint32 bufferSizeInFrames, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_pcm_rb* pRB)
+{
+    return ma_pcm_rb_init_ex(format, channels, bufferSizeInFrames, 1, 0, pOptionalPreallocatedBuffer, pAllocationCallbacks, pRB);
+}
+
+MA_API void ma_pcm_rb_uninit(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    ma_data_source_uninit(&pRB->ds);
+    ma_rb_uninit(&pRB->rb);
+}
+
+MA_API void ma_pcm_rb_reset(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    ma_rb_reset(&pRB->rb);
+}
+
+MA_API ma_result ma_pcm_rb_acquire_read(ma_pcm_rb* pRB, ma_uint32* pSizeInFrames, void** ppBufferOut)
+{
+    size_t sizeInBytes;
+    ma_result result;
+
+    if (pRB == NULL || pSizeInFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    sizeInBytes = *pSizeInFrames * ma_pcm_rb_get_bpf(pRB);
+
+    result = ma_rb_acquire_read(&pRB->rb, &sizeInBytes, ppBufferOut);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pSizeInFrames = (ma_uint32)(sizeInBytes / (size_t)ma_pcm_rb_get_bpf(pRB));
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pcm_rb_commit_read(ma_pcm_rb* pRB, ma_uint32 sizeInFrames)
+{
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_rb_commit_read(&pRB->rb, sizeInFrames * ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_result ma_pcm_rb_acquire_write(ma_pcm_rb* pRB, ma_uint32* pSizeInFrames, void** ppBufferOut)
+{
+    size_t sizeInBytes;
+    ma_result result;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    sizeInBytes = *pSizeInFrames * ma_pcm_rb_get_bpf(pRB);
+
+    result = ma_rb_acquire_write(&pRB->rb, &sizeInBytes, ppBufferOut);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pSizeInFrames = (ma_uint32)(sizeInBytes / ma_pcm_rb_get_bpf(pRB));
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pcm_rb_commit_write(ma_pcm_rb* pRB, ma_uint32 sizeInFrames)
+{
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_rb_commit_write(&pRB->rb, sizeInFrames * ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_result ma_pcm_rb_seek_read(ma_pcm_rb* pRB, ma_uint32 offsetInFrames)
+{
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_rb_seek_read(&pRB->rb, offsetInFrames * ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_result ma_pcm_rb_seek_write(ma_pcm_rb* pRB, ma_uint32 offsetInFrames)
+{
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_rb_seek_write(&pRB->rb, offsetInFrames * ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_int32 ma_pcm_rb_pointer_distance(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return ma_rb_pointer_distance(&pRB->rb) / ma_pcm_rb_get_bpf(pRB);
+}
+
+MA_API ma_uint32 ma_pcm_rb_available_read(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return ma_rb_available_read(&pRB->rb) / ma_pcm_rb_get_bpf(pRB);
+}
+
+MA_API ma_uint32 ma_pcm_rb_available_write(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return ma_rb_available_write(&pRB->rb) / ma_pcm_rb_get_bpf(pRB);
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_size(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return (ma_uint32)(ma_rb_get_subbuffer_size(&pRB->rb) / ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_stride(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return (ma_uint32)(ma_rb_get_subbuffer_stride(&pRB->rb) / ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_offset(ma_pcm_rb* pRB, ma_uint32 subbufferIndex)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return (ma_uint32)(ma_rb_get_subbuffer_offset(&pRB->rb, subbufferIndex) / ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API void* ma_pcm_rb_get_subbuffer_ptr(ma_pcm_rb* pRB, ma_uint32 subbufferIndex, void* pBuffer)
+{
+    if (pRB == NULL) {
+        return NULL;
+    }
+
+    return ma_rb_get_subbuffer_ptr(&pRB->rb, subbufferIndex, pBuffer);
+}
+
+MA_API ma_format ma_pcm_rb_get_format(const ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return ma_format_unknown;
+    }
+
+    return pRB->format;
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_channels(const ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return pRB->channels;
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_sample_rate(const ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return pRB->sampleRate;
+}
+
+MA_API void ma_pcm_rb_set_sample_rate(ma_pcm_rb* pRB, ma_uint32 sampleRate)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    pRB->sampleRate = sampleRate;
+}
+
+
+
+MA_API ma_result ma_duplex_rb_init(ma_format captureFormat, ma_uint32 captureChannels, ma_uint32 sampleRate, ma_uint32 captureInternalSampleRate, ma_uint32 captureInternalPeriodSizeInFrames, const ma_allocation_callbacks* pAllocationCallbacks, ma_duplex_rb* pRB)
+{
+    ma_result result;
+    ma_uint32 sizeInFrames;
+
+    sizeInFrames = (ma_uint32)ma_calculate_frame_count_after_resampling(sampleRate, captureInternalSampleRate, captureInternalPeriodSizeInFrames * 5);
+    if (sizeInFrames == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_pcm_rb_init(captureFormat, captureChannels, sizeInFrames, NULL, pAllocationCallbacks, &pRB->rb);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Seek forward a bit so we have a bit of a buffer in case of desyncs. */
+    ma_pcm_rb_seek_write((ma_pcm_rb*)pRB, captureInternalPeriodSizeInFrames * 2);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_duplex_rb_uninit(ma_duplex_rb* pRB)
+{
+    ma_pcm_rb_uninit((ma_pcm_rb*)pRB);
+    return MA_SUCCESS;
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Miscellaneous Helpers
+
+**************************************************************************************************************************************************************/
+MA_API const char* ma_result_description(ma_result result)
+{
+    switch (result)
+    {
+        case MA_SUCCESS:                       return "No error";
+        case MA_ERROR:                         return "Unknown error";
+        case MA_INVALID_ARGS:                  return "Invalid argument";
+        case MA_INVALID_OPERATION:             return "Invalid operation";
+        case MA_OUT_OF_MEMORY:                 return "Out of memory";
+        case MA_OUT_OF_RANGE:                  return "Out of range";
+        case MA_ACCESS_DENIED:                 return "Permission denied";
+        case MA_DOES_NOT_EXIST:                return "Resource does not exist";
+        case MA_ALREADY_EXISTS:                return "Resource already exists";
+        case MA_TOO_MANY_OPEN_FILES:           return "Too many open files";
+        case MA_INVALID_FILE:                  return "Invalid file";
+        case MA_TOO_BIG:                       return "Too large";
+        case MA_PATH_TOO_LONG:                 return "Path too long";
+        case MA_NAME_TOO_LONG:                 return "Name too long";
+        case MA_NOT_DIRECTORY:                 return "Not a directory";
+        case MA_IS_DIRECTORY:                  return "Is a directory";
+        case MA_DIRECTORY_NOT_EMPTY:           return "Directory not empty";
+        case MA_AT_END:                        return "At end";
+        case MA_NO_SPACE:                      return "No space available";
+        case MA_BUSY:                          return "Device or resource busy";
+        case MA_IO_ERROR:                      return "Input/output error";
+        case MA_INTERRUPT:                     return "Interrupted";
+        case MA_UNAVAILABLE:                   return "Resource unavailable";
+        case MA_ALREADY_IN_USE:                return "Resource already in use";
+        case MA_BAD_ADDRESS:                   return "Bad address";
+        case MA_BAD_SEEK:                      return "Illegal seek";
+        case MA_BAD_PIPE:                      return "Broken pipe";
+        case MA_DEADLOCK:                      return "Deadlock";
+        case MA_TOO_MANY_LINKS:                return "Too many links";
+        case MA_NOT_IMPLEMENTED:               return "Not implemented";
+        case MA_NO_MESSAGE:                    return "No message of desired type";
+        case MA_BAD_MESSAGE:                   return "Invalid message";
+        case MA_NO_DATA_AVAILABLE:             return "No data available";
+        case MA_INVALID_DATA:                  return "Invalid data";
+        case MA_TIMEOUT:                       return "Timeout";
+        case MA_NO_NETWORK:                    return "Network unavailable";
+        case MA_NOT_UNIQUE:                    return "Not unique";
+        case MA_NOT_SOCKET:                    return "Socket operation on non-socket";
+        case MA_NO_ADDRESS:                    return "Destination address required";
+        case MA_BAD_PROTOCOL:                  return "Protocol wrong type for socket";
+        case MA_PROTOCOL_UNAVAILABLE:          return "Protocol not available";
+        case MA_PROTOCOL_NOT_SUPPORTED:        return "Protocol not supported";
+        case MA_PROTOCOL_FAMILY_NOT_SUPPORTED: return "Protocol family not supported";
+        case MA_ADDRESS_FAMILY_NOT_SUPPORTED:  return "Address family not supported";
+        case MA_SOCKET_NOT_SUPPORTED:          return "Socket type not supported";
+        case MA_CONNECTION_RESET:              return "Connection reset";
+        case MA_ALREADY_CONNECTED:             return "Already connected";
+        case MA_NOT_CONNECTED:                 return "Not connected";
+        case MA_CONNECTION_REFUSED:            return "Connection refused";
+        case MA_NO_HOST:                       return "No host";
+        case MA_IN_PROGRESS:                   return "Operation in progress";
+        case MA_CANCELLED:                     return "Operation cancelled";
+        case MA_MEMORY_ALREADY_MAPPED:         return "Memory already mapped";
+
+        case MA_FORMAT_NOT_SUPPORTED:          return "Format not supported";
+        case MA_DEVICE_TYPE_NOT_SUPPORTED:     return "Device type not supported";
+        case MA_SHARE_MODE_NOT_SUPPORTED:      return "Share mode not supported";
+        case MA_NO_BACKEND:                    return "No backend";
+        case MA_NO_DEVICE:                     return "No device";
+        case MA_API_NOT_FOUND:                 return "API not found";
+        case MA_INVALID_DEVICE_CONFIG:         return "Invalid device config";
+
+        case MA_DEVICE_NOT_INITIALIZED:        return "Device not initialized";
+        case MA_DEVICE_NOT_STARTED:            return "Device not started";
+
+        case MA_FAILED_TO_INIT_BACKEND:        return "Failed to initialize backend";
+        case MA_FAILED_TO_OPEN_BACKEND_DEVICE: return "Failed to open backend device";
+        case MA_FAILED_TO_START_BACKEND_DEVICE: return "Failed to start backend device";
+        case MA_FAILED_TO_STOP_BACKEND_DEVICE: return "Failed to stop backend device";
+
+        default:                               return "Unknown error";
+    }
+}
+
+MA_API void* ma_malloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        if (pAllocationCallbacks->onMalloc != NULL) {
+            return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
+        } else {
+            return NULL;    /* Do not fall back to the default implementation. */
+        }
+    } else {
+        return ma__malloc_default(sz, NULL);
+    }
+}
+
+MA_API void* ma_calloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    void* p = ma_malloc(sz, pAllocationCallbacks);
+    if (p != NULL) {
+        MA_ZERO_MEMORY(p, sz);
+    }
+
+    return p;
+}
+
+MA_API void* ma_realloc(void* p, size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        if (pAllocationCallbacks->onRealloc != NULL) {
+            return pAllocationCallbacks->onRealloc(p, sz, pAllocationCallbacks->pUserData);
+        } else {
+            return NULL;    /* Do not fall back to the default implementation. */
+        }
+    } else {
+        return ma__realloc_default(p, sz, NULL);
+    }
+}
+
+MA_API void ma_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (p == NULL) {
+        return;
+    }
+
+    if (pAllocationCallbacks != NULL) {
+        if (pAllocationCallbacks->onFree != NULL) {
+            pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+        } else {
+            return; /* Do no fall back to the default implementation. */
+        }
+    } else {
+        ma__free_default(p, NULL);
+    }
+}
+
+MA_API void* ma_aligned_malloc(size_t sz, size_t alignment, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    size_t extraBytes;
+    void* pUnaligned;
+    void* pAligned;
+
+    if (alignment == 0) {
+        return 0;
+    }
+
+    extraBytes = alignment-1 + sizeof(void*);
+
+    pUnaligned = ma_malloc(sz + extraBytes, pAllocationCallbacks);
+    if (pUnaligned == NULL) {
+        return NULL;
+    }
+
+    pAligned = (void*)(((ma_uintptr)pUnaligned + extraBytes) & ~((ma_uintptr)(alignment-1)));
+    ((void**)pAligned)[-1] = pUnaligned;
+
+    return pAligned;
+}
+
+MA_API void ma_aligned_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_free(((void**)p)[-1], pAllocationCallbacks);
+}
+
+MA_API const char* ma_get_format_name(ma_format format)
+{
+    switch (format)
+    {
+        case ma_format_unknown: return "Unknown";
+        case ma_format_u8:      return "8-bit Unsigned Integer";
+        case ma_format_s16:     return "16-bit Signed Integer";
+        case ma_format_s24:     return "24-bit Signed Integer (Tightly Packed)";
+        case ma_format_s32:     return "32-bit Signed Integer";
+        case ma_format_f32:     return "32-bit IEEE Floating Point";
+        default:                return "Invalid";
+    }
+}
+
+MA_API void ma_blend_f32(float* pOut, float* pInA, float* pInB, float factor, ma_uint32 channels)
+{
+    ma_uint32 i;
+    for (i = 0; i < channels; ++i) {
+        pOut[i] = ma_mix_f32(pInA[i], pInB[i], factor);
+    }
+}
+
+
+MA_API ma_uint32 ma_get_bytes_per_sample(ma_format format)
+{
+    ma_uint32 sizes[] = {
+        0,  /* unknown */
+        1,  /* u8 */
+        2,  /* s16 */
+        3,  /* s24 */
+        4,  /* s32 */
+        4,  /* f32 */
+    };
+    return sizes[format];
+}
+
+
+
+#define MA_DATA_SOURCE_DEFAULT_RANGE_BEG        0
+#define MA_DATA_SOURCE_DEFAULT_RANGE_END        ~((ma_uint64)0)
+#define MA_DATA_SOURCE_DEFAULT_LOOP_POINT_BEG   0
+#define MA_DATA_SOURCE_DEFAULT_LOOP_POINT_END   ~((ma_uint64)0)
+
+MA_API ma_data_source_config ma_data_source_config_init(void)
+{
+    ma_data_source_config config;
+
+    MA_ZERO_OBJECT(&config);
+
+    return config;
+}
+
+
+MA_API ma_result ma_data_source_init(const ma_data_source_config* pConfig, ma_data_source* pDataSource)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataSourceBase);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->vtable == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSourceBase->vtable           = pConfig->vtable;
+    pDataSourceBase->rangeBegInFrames = MA_DATA_SOURCE_DEFAULT_RANGE_BEG;
+    pDataSourceBase->rangeEndInFrames = MA_DATA_SOURCE_DEFAULT_RANGE_END;
+    pDataSourceBase->loopBegInFrames  = MA_DATA_SOURCE_DEFAULT_LOOP_POINT_BEG;
+    pDataSourceBase->loopEndInFrames  = MA_DATA_SOURCE_DEFAULT_LOOP_POINT_END;
+    pDataSourceBase->pCurrent         = pDataSource;    /* Always read from ourself by default. */
+    pDataSourceBase->pNext            = NULL;
+    pDataSourceBase->onGetNext        = NULL;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_source_uninit(ma_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return;
+    }
+
+    /*
+    This is placeholder in case we need this later. Data sources need to call this in their
+    uninitialization routine to ensure things work later on if something is added here.
+    */
+}
+
+static ma_result ma_data_source_resolve_current(ma_data_source* pDataSource, ma_data_source** ppCurrentDataSource)
+{
+    ma_data_source_base* pCurrentDataSource = (ma_data_source_base*)pDataSource;
+
+    MA_ASSERT(pDataSource         != NULL);
+    MA_ASSERT(ppCurrentDataSource != NULL);
+
+    if (pCurrentDataSource->pCurrent == NULL) {
+        /*
+        The current data source is NULL. If we're using this in the context of a chain we need to return NULL
+        here so that we don't end up looping. Otherwise we just return the data source itself.
+        */
+        if (pCurrentDataSource->pNext != NULL || pCurrentDataSource->onGetNext != NULL) {
+            pCurrentDataSource = NULL;
+        } else {
+            pCurrentDataSource = (ma_data_source_base*)pDataSource; /* Not being used in a chain. Make sure we just always read from the data source itself at all times. */
+        }
+    } else {
+        pCurrentDataSource = (ma_data_source_base*)pCurrentDataSource->pCurrent;
+    }
+
+    *ppCurrentDataSource = pCurrentDataSource;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_data_source_read_pcm_frames_from_backend(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    MA_ASSERT(pDataSourceBase                 != NULL);
+    MA_ASSERT(pDataSourceBase->vtable         != NULL);
+    MA_ASSERT(pDataSourceBase->vtable->onRead != NULL);
+    MA_ASSERT(pFramesRead != NULL);
+
+    if (pFramesOut != NULL) {
+        return pDataSourceBase->vtable->onRead(pDataSourceBase, pFramesOut, frameCount, pFramesRead);
+    } else {
+        /*
+        No output buffer. Probably seeking forward. Read and discard. Can probably optimize this in terms of
+        onSeek and onGetCursor, but need to keep in mind that the data source may not implement these functions.
+        */
+        ma_result result;
+        ma_uint64 framesRead;
+        ma_format format;
+        ma_uint32 channels;
+        ma_uint64 discardBufferCapInFrames;
+        ma_uint8  pDiscardBuffer[4096];
+
+        result = ma_data_source_get_data_format(pDataSource, &format, &channels, NULL, NULL, 0);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        discardBufferCapInFrames = sizeof(pDiscardBuffer) / ma_get_bytes_per_frame(format, channels);
+
+        framesRead = 0;
+        while (framesRead < frameCount) {
+            ma_uint64 framesReadThisIteration = 0;
+            ma_uint64 framesToRead = frameCount - framesRead;
+            if (framesToRead > discardBufferCapInFrames) {
+                framesToRead = discardBufferCapInFrames;
+            }
+
+            result = pDataSourceBase->vtable->onRead(pDataSourceBase, pDiscardBuffer, framesToRead, &framesReadThisIteration);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+
+            framesRead += framesReadThisIteration;
+        }
+
+        *pFramesRead = framesRead;
+
+        return MA_SUCCESS;
+    }
+}
+
+static ma_result ma_data_source_read_pcm_frames_within_range(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_result result;
+    ma_uint64 framesRead = 0;
+    ma_bool32 loop = ma_data_source_is_looping(pDataSource);
+
+    if (pDataSourceBase == NULL) {
+        return MA_AT_END;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ASSERT(pDataSourceBase->vtable != NULL);
+
+    if ((pDataSourceBase->vtable->flags & MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT) != 0 || (pDataSourceBase->rangeEndInFrames == ~((ma_uint64)0) && (pDataSourceBase->loopEndInFrames == ~((ma_uint64)0) || loop == MA_FALSE))) {
+        /* Either the data source is self-managing the range, or no range is set - just read like normal. The data source itself will tell us when the end is reached. */
+        result = ma_data_source_read_pcm_frames_from_backend(pDataSource, pFramesOut, frameCount, &framesRead);
+    } else {
+        /* Need to clamp to within the range. */
+        ma_uint64 relativeCursor;
+        ma_uint64 absoluteCursor;
+
+        result = ma_data_source_get_cursor_in_pcm_frames(pDataSourceBase, &relativeCursor);
+        if (result != MA_SUCCESS) {
+            /* Failed to retrieve the cursor. Cannot read within a range or loop points. Just read like normal - this may happen for things like noise data sources where it doesn't really matter. */
+            result = ma_data_source_read_pcm_frames_from_backend(pDataSource, pFramesOut, frameCount, &framesRead);
+        } else {
+            ma_uint64 rangeBeg;
+            ma_uint64 rangeEnd;
+
+            /* We have the cursor. We need to make sure we don't read beyond our range. */
+            rangeBeg = pDataSourceBase->rangeBegInFrames;
+            rangeEnd = pDataSourceBase->rangeEndInFrames;
+
+            absoluteCursor = rangeBeg + relativeCursor;
+
+            /* If looping, make sure we're within range. */
+            if (loop) {
+                if (pDataSourceBase->loopEndInFrames != ~((ma_uint64)0)) {
+                    rangeEnd = ma_min(rangeEnd, pDataSourceBase->rangeBegInFrames + pDataSourceBase->loopEndInFrames);
+                }
+            }
+
+            if (frameCount > (rangeEnd - absoluteCursor) && rangeEnd != ~((ma_uint64)0)) {
+                frameCount = (rangeEnd - absoluteCursor);
+            }
+
+            /*
+            If the cursor is sitting on the end of the range the frame count will be set to 0 which can
+            result in MA_INVALID_ARGS. In this case, we don't want to try reading, but instead return
+            MA_AT_END so the higher level function can know about it.
+            */
+            if (frameCount > 0) {
+                result = ma_data_source_read_pcm_frames_from_backend(pDataSource, pFramesOut, frameCount, &framesRead);
+            } else {
+                result = MA_AT_END; /* The cursor is sitting on the end of the range which means we're at the end. */
+            }
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    /* We need to make sure MA_AT_END is returned if we hit the end of the range. */
+    if (result == MA_SUCCESS && framesRead == 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_data_source_read_pcm_frames(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_data_source_base* pCurrentDataSource;
+    void* pRunningFramesOut = pFramesOut;
+    ma_uint64 totalFramesProcessed = 0;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 emptyLoopCounter = 0; /* Keeps track of how many times 0 frames have been read. For infinite loop detection of sounds with no audio data. */
+    ma_bool32 loop;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDataSourceBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    loop = ma_data_source_is_looping(pDataSource);
+
+    /*
+    We need to know the data format so we can advance the output buffer as we read frames. If this
+    fails, chaining will not work and we'll just read as much as we can from the current source.
+    */
+    if (ma_data_source_get_data_format(pDataSource, &format, &channels, NULL, NULL, 0) != MA_SUCCESS) {
+        result = ma_data_source_resolve_current(pDataSource, (ma_data_source**)&pCurrentDataSource);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        return ma_data_source_read_pcm_frames_within_range(pCurrentDataSource, pFramesOut, frameCount, pFramesRead);
+    }
+
+    /*
+    Looping is a bit of a special case. When the `loop` argument is true, chaining will not work and
+    only the current data source will be read from.
+    */
+
+    /* Keep reading until we've read as many frames as possible. */
+    while (totalFramesProcessed < frameCount) {
+        ma_uint64 framesProcessed;
+        ma_uint64 framesRemaining = frameCount - totalFramesProcessed;
+
+        /* We need to resolve the data source that we'll actually be reading from. */
+        result = ma_data_source_resolve_current(pDataSource, (ma_data_source**)&pCurrentDataSource);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        if (pCurrentDataSource == NULL) {
+            break;
+        }
+
+        result = ma_data_source_read_pcm_frames_within_range(pCurrentDataSource, pRunningFramesOut, framesRemaining, &framesProcessed);
+        totalFramesProcessed += framesProcessed;
+
+        /*
+        If we encountered an error from the read callback, make sure it's propagated to the caller. The caller may need to know whether or not MA_BUSY is returned which is
+        not necessarily considered an error.
+        */
+        if (result != MA_SUCCESS && result != MA_AT_END) {
+            break;
+        }
+
+        /*
+        We can determine if we've reached the end by checking if ma_data_source_read_pcm_frames_within_range() returned
+        MA_AT_END. To loop back to the start, all we need to do is seek back to the first frame.
+        */
+        if (result == MA_AT_END) {
+            /*
+            The result needs to be reset back to MA_SUCCESS (from MA_AT_END) so that we don't
+            accidentally return MA_AT_END when data has been read in prior loop iterations. at the
+            end of this function, the result will be checked for MA_SUCCESS, and if the total
+            number of frames processed is 0, will be explicitly set to MA_AT_END.
+            */
+            result = MA_SUCCESS;
+
+            /*
+            We reached the end. If we're looping, we just loop back to the start of the current
+            data source. If we're not looping we need to check if we have another in the chain, and
+            if so, switch to it.
+            */
+            if (loop) {
+                if (framesProcessed == 0) {
+                    emptyLoopCounter += 1;
+                    if (emptyLoopCounter > 1) {
+                        break;  /* Infinite loop detected. Get out. */
+                    }
+                } else {
+                    emptyLoopCounter = 0;
+                }
+
+                result = ma_data_source_seek_to_pcm_frame(pCurrentDataSource, pCurrentDataSource->loopBegInFrames);
+                if (result != MA_SUCCESS) {
+                    break;  /* Failed to loop. Abort. */
+                }
+
+                /* Don't return MA_AT_END for looping sounds. */
+                result = MA_SUCCESS;
+            } else {
+                if (pCurrentDataSource->pNext != NULL) {
+                    pDataSourceBase->pCurrent = pCurrentDataSource->pNext;
+                } else if (pCurrentDataSource->onGetNext != NULL) {
+                    pDataSourceBase->pCurrent = pCurrentDataSource->onGetNext(pCurrentDataSource);
+                    if (pDataSourceBase->pCurrent == NULL) {
+                        break;  /* Our callback did not return a next data source. We're done. */
+                    }
+                } else {
+                    /* Reached the end of the chain. We're done. */
+                    break;
+                }
+
+                /* The next data source needs to be rewound to ensure data is read in looping scenarios. */
+                result = ma_data_source_seek_to_pcm_frame(pDataSourceBase->pCurrent, 0);
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+            }
+        }
+
+        if (pRunningFramesOut != NULL) {
+            pRunningFramesOut = ma_offset_ptr(pRunningFramesOut, framesProcessed * ma_get_bytes_per_frame(format, channels));
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesProcessed;
+    }
+
+    MA_ASSERT(!(result == MA_AT_END && totalFramesProcessed > 0));  /* We should never be returning MA_AT_END if we read some data. */
+
+    if (result == MA_SUCCESS && totalFramesProcessed == 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_data_source_seek_pcm_frames(ma_data_source* pDataSource, ma_uint64 frameCount, ma_uint64* pFramesSeeked)
+{
+    return ma_data_source_read_pcm_frames(pDataSource, NULL, frameCount, pFramesSeeked);
+}
+
+MA_API ma_result ma_data_source_seek_to_pcm_frame(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSourceBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDataSourceBase->vtable->onSeek == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    if (frameIndex > pDataSourceBase->rangeEndInFrames) {
+        return MA_INVALID_OPERATION;    /* Trying to seek too far forward. */
+    }
+
+    MA_ASSERT(pDataSourceBase->vtable != NULL);
+
+    return pDataSourceBase->vtable->onSeek(pDataSource, pDataSourceBase->rangeBegInFrames + frameIndex);
+}
+
+MA_API ma_result ma_data_source_seek_seconds(ma_data_source* pDataSource, float secondCount, float* pSecondsSeeked)
+{
+    ma_uint64 frameCount;
+    ma_uint64 framesSeeked = 0;
+    ma_uint32 sampleRate;
+    ma_result result;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_data_source_get_data_format(pDataSource, NULL, NULL, &sampleRate, NULL, 0);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* We need PCM frames instead of seconds */
+    frameCount = (ma_uint64)(secondCount * sampleRate);
+
+    result = ma_data_source_seek_pcm_frames(pDataSource, frameCount, &framesSeeked);
+
+    /* VC6 doesn't support division between unsigned 64-bit integer and floating point number. Signed integer needed. This shouldn't affect anything in practice */
+    *pSecondsSeeked = (ma_int64)framesSeeked / (float)sampleRate;
+    return result;
+}
+
+MA_API ma_result ma_data_source_seek_to_second(ma_data_source* pDataSource, float seekPointInSeconds)
+{
+    ma_uint64 frameIndex;
+    ma_uint32 sampleRate;
+    ma_result result;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_data_source_get_data_format(pDataSource, NULL, NULL, &sampleRate, NULL, 0);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* We need PCM frames instead of seconds */
+    frameIndex = (ma_uint64)(seekPointInSeconds * sampleRate);
+
+    return ma_data_source_seek_to_pcm_frame(pDataSource, frameIndex);
+}
+
+MA_API ma_result ma_data_source_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_result result;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+
+    /* Initialize to defaults for safety just in case the data source does not implement this callback. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pDataSourceBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ASSERT(pDataSourceBase->vtable != NULL);
+
+    if (pDataSourceBase->vtable->onGetDataFormat == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pDataSourceBase->vtable->onGetDataFormat(pDataSource, &format, &channels, &sampleRate, pChannelMap, channelMapCap);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = format;
+    }
+    if (pChannels != NULL) {
+        *pChannels = channels;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = sampleRate;
+    }
+
+    /* Channel map was passed in directly to the callback. This is safe due to the channelMapCap parameter. */
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_source_get_cursor_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_result result;
+    ma_uint64 cursor;
+
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (pDataSourceBase == NULL) {
+        return MA_SUCCESS;
+    }
+
+    MA_ASSERT(pDataSourceBase->vtable != NULL);
+
+    if (pDataSourceBase->vtable->onGetCursor == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pDataSourceBase->vtable->onGetCursor(pDataSourceBase, &cursor);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* The cursor needs to be made relative to the start of the range. */
+    if (cursor < pDataSourceBase->rangeBegInFrames) {   /* Safety check so we don't return some huge number. */
+        *pCursor = 0;
+    } else {
+        *pCursor = cursor - pDataSourceBase->rangeBegInFrames;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_source_get_length_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    if (pDataSourceBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ASSERT(pDataSourceBase->vtable != NULL);
+
+    /*
+    If we have a range defined we'll use that to determine the length. This is one of rare times
+    where we'll actually trust the caller. If they've set the range, I think it's mostly safe to
+    assume they've set it based on some higher level knowledge of the structure of the sound bank.
+    */
+    if (pDataSourceBase->rangeEndInFrames != ~((ma_uint64)0)) {
+        *pLength = pDataSourceBase->rangeEndInFrames - pDataSourceBase->rangeBegInFrames;
+        return MA_SUCCESS;
+    }
+
+    /*
+    Getting here means a range is not defined so we'll need to get the data source itself to tell
+    us the length.
+    */
+    if (pDataSourceBase->vtable->onGetLength == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pDataSourceBase->vtable->onGetLength(pDataSource, pLength);
+}
+
+MA_API ma_result ma_data_source_get_cursor_in_seconds(ma_data_source* pDataSource, float* pCursor)
+{
+    ma_result result;
+    ma_uint64 cursorInPCMFrames;
+    ma_uint32 sampleRate;
+
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    result = ma_data_source_get_cursor_in_pcm_frames(pDataSource, &cursorInPCMFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_data_source_get_data_format(pDataSource, NULL, NULL, &sampleRate, NULL, 0);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* VC6 does not support division of unsigned 64-bit integers with floating point numbers. Need to use a signed number. This shouldn't effect anything in practice. */
+    *pCursor = (ma_int64)cursorInPCMFrames / (float)sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_source_get_length_in_seconds(ma_data_source* pDataSource, float* pLength)
+{
+    ma_result result;
+    ma_uint64 lengthInPCMFrames;
+    ma_uint32 sampleRate;
+
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    result = ma_data_source_get_length_in_pcm_frames(pDataSource, &lengthInPCMFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_data_source_get_data_format(pDataSource, NULL, NULL, &sampleRate, NULL, 0);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* VC6 does not support division of unsigned 64-bit integers with floating point numbers. Need to use a signed number. This shouldn't effect anything in practice. */
+    *pLength = (ma_int64)lengthInPCMFrames / (float)sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_source_set_looping(ma_data_source* pDataSource, ma_bool32 isLooping)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_exchange_32(&pDataSourceBase->isLooping, isLooping);
+
+    MA_ASSERT(pDataSourceBase->vtable != NULL);
+
+    /* If there's no callback for this just treat it as a successful no-op. */
+    if (pDataSourceBase->vtable->onSetLooping == NULL) {
+        return MA_SUCCESS;
+    }
+
+    return pDataSourceBase->vtable->onSetLooping(pDataSource, isLooping);
+}
+
+MA_API ma_bool32 ma_data_source_is_looping(const ma_data_source* pDataSource)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_atomic_load_32(&pDataSourceBase->isLooping);
+}
+
+MA_API ma_result ma_data_source_set_range_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 rangeBegInFrames, ma_uint64 rangeEndInFrames)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_result result;
+    ma_uint64 relativeCursor;
+    ma_uint64 absoluteCursor;
+    ma_bool32 doSeekAdjustment = MA_FALSE;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (rangeEndInFrames < rangeBegInFrames) {
+        return MA_INVALID_ARGS; /* The end of the range must come after the beginning. */
+    }
+
+    /*
+    We may need to adjust the position of the cursor to ensure it's clamped to the range. Grab it now
+    so we can calculate its absolute position before we change the range.
+    */
+    result = ma_data_source_get_cursor_in_pcm_frames(pDataSource, &relativeCursor);
+    if (result == MA_SUCCESS) {
+        doSeekAdjustment = MA_TRUE;
+        absoluteCursor = relativeCursor + pDataSourceBase->rangeBegInFrames;
+    } else {
+        /*
+        We couldn't get the position of the cursor. It probably means the data source has no notion
+        of a cursor. We'll just leave it at position 0. Don't treat this as an error.
+        */
+        doSeekAdjustment = MA_FALSE;
+        relativeCursor = 0;
+        absoluteCursor = 0;
+    }
+
+    pDataSourceBase->rangeBegInFrames = rangeBegInFrames;
+    pDataSourceBase->rangeEndInFrames = rangeEndInFrames;
+
+    /*
+    The commented out logic below was intended to maintain loop points in response to a change in the
+    range. However, this is not useful because it results in the sound breaking when you move the range
+    outside of the old loop points. I'm simplifying this by simply resetting the loop points. The
+    caller is expected to update their loop points if they change the range.
+
+    In practice this should be mostly a non-issue because the majority of the time the range will be
+    set once right after initialization.
+    */
+    pDataSourceBase->loopBegInFrames = 0;
+    pDataSourceBase->loopEndInFrames = ~((ma_uint64)0);
+
+
+    /*
+    Seek to within range. Note that our seek positions here are relative to the new range. We don't want
+    to do this if we failed to retrieve the cursor earlier on because it probably means the data source
+    has no notion of a cursor. In practice the seek would probably fail (which we silently ignore), but
+    I'm just not even going to attempt it.
+    */
+    if (doSeekAdjustment) {
+        if (absoluteCursor < rangeBegInFrames) {
+            ma_data_source_seek_to_pcm_frame(pDataSource, 0);
+        } else if (absoluteCursor > rangeEndInFrames) {
+            ma_data_source_seek_to_pcm_frame(pDataSource, rangeEndInFrames - rangeBegInFrames);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_source_get_range_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pRangeBegInFrames, ma_uint64* pRangeEndInFrames)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pRangeBegInFrames != NULL) {
+        *pRangeBegInFrames = 0;
+    }
+    if (pRangeEndInFrames != NULL) {
+        *pRangeEndInFrames = 0;
+    }
+
+    if (pDataSource == NULL) {
+        return;
+    }
+
+    if (pRangeBegInFrames != NULL) {
+        *pRangeBegInFrames = pDataSourceBase->rangeBegInFrames;
+    }
+
+    if (pRangeEndInFrames != NULL) {
+        *pRangeEndInFrames = pDataSourceBase->rangeEndInFrames;
+    }
+}
+
+MA_API ma_result ma_data_source_set_loop_point_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 loopBegInFrames, ma_uint64 loopEndInFrames)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (loopEndInFrames < loopBegInFrames) {
+        return MA_INVALID_ARGS; /* The end of the loop point must come after the beginning. */
+    }
+
+    if (loopEndInFrames > pDataSourceBase->rangeEndInFrames && loopEndInFrames != ~((ma_uint64)0)) {
+        return MA_INVALID_ARGS; /* The end of the loop point must not go beyond the range. */
+    }
+
+    pDataSourceBase->loopBegInFrames = loopBegInFrames;
+    pDataSourceBase->loopEndInFrames = loopEndInFrames;
+
+    /* The end cannot exceed the range. */
+    if (pDataSourceBase->loopEndInFrames > (pDataSourceBase->rangeEndInFrames - pDataSourceBase->rangeBegInFrames) && pDataSourceBase->loopEndInFrames != ~((ma_uint64)0)) {
+        pDataSourceBase->loopEndInFrames = (pDataSourceBase->rangeEndInFrames - pDataSourceBase->rangeBegInFrames);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_source_get_loop_point_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pLoopBegInFrames, ma_uint64* pLoopEndInFrames)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pLoopBegInFrames != NULL) {
+        *pLoopBegInFrames = 0;
+    }
+    if (pLoopEndInFrames != NULL) {
+        *pLoopEndInFrames = 0;
+    }
+
+    if (pDataSource == NULL) {
+        return;
+    }
+
+    if (pLoopBegInFrames != NULL) {
+        *pLoopBegInFrames = pDataSourceBase->loopBegInFrames;
+    }
+
+    if (pLoopEndInFrames != NULL) {
+        *pLoopEndInFrames = pDataSourceBase->loopEndInFrames;
+    }
+}
+
+MA_API ma_result ma_data_source_set_current(ma_data_source* pDataSource, ma_data_source* pCurrentDataSource)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSourceBase->pCurrent = pCurrentDataSource;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_data_source* ma_data_source_get_current(const ma_data_source* pDataSource)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return NULL;
+    }
+
+    return pDataSourceBase->pCurrent;
+}
+
+MA_API ma_result ma_data_source_set_next(ma_data_source* pDataSource, ma_data_source* pNextDataSource)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSourceBase->pNext = pNextDataSource;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_data_source* ma_data_source_get_next(const ma_data_source* pDataSource)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return NULL;
+    }
+
+    return pDataSourceBase->pNext;
+}
+
+MA_API ma_result ma_data_source_set_next_callback(ma_data_source* pDataSource, ma_data_source_get_next_proc onGetNext)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSourceBase->onGetNext = onGetNext;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_data_source_get_next_proc ma_data_source_get_next_callback(const ma_data_source* pDataSource)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return NULL;
+    }
+
+    return pDataSourceBase->onGetNext;
+}
+
+
+static ma_result ma_audio_buffer_ref__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_audio_buffer_ref* pAudioBufferRef = (ma_audio_buffer_ref*)pDataSource;
+    ma_uint64 framesRead = ma_audio_buffer_ref_read_pcm_frames(pAudioBufferRef, pFramesOut, frameCount, MA_FALSE);
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    if (framesRead < frameCount || framesRead == 0) {
+        return MA_AT_END;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_audio_buffer_ref__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_audio_buffer_ref_seek_to_pcm_frame((ma_audio_buffer_ref*)pDataSource, frameIndex);
+}
+
+static ma_result ma_audio_buffer_ref__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_audio_buffer_ref* pAudioBufferRef = (ma_audio_buffer_ref*)pDataSource;
+
+    *pFormat     = pAudioBufferRef->format;
+    *pChannels   = pAudioBufferRef->channels;
+    *pSampleRate = pAudioBufferRef->sampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pAudioBufferRef->channels);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_audio_buffer_ref__data_source_on_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    ma_audio_buffer_ref* pAudioBufferRef = (ma_audio_buffer_ref*)pDataSource;
+
+    *pCursor = pAudioBufferRef->cursor;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_audio_buffer_ref__data_source_on_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    ma_audio_buffer_ref* pAudioBufferRef = (ma_audio_buffer_ref*)pDataSource;
+
+    *pLength = pAudioBufferRef->sizeInFrames;
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable g_ma_audio_buffer_ref_data_source_vtable =
+{
+    ma_audio_buffer_ref__data_source_on_read,
+    ma_audio_buffer_ref__data_source_on_seek,
+    ma_audio_buffer_ref__data_source_on_get_data_format,
+    ma_audio_buffer_ref__data_source_on_get_cursor,
+    ma_audio_buffer_ref__data_source_on_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+MA_API ma_result ma_audio_buffer_ref_init(ma_format format, ma_uint32 channels, const void* pData, ma_uint64 sizeInFrames, ma_audio_buffer_ref* pAudioBufferRef)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pAudioBufferRef);
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_audio_buffer_ref_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pAudioBufferRef->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pAudioBufferRef->format       = format;
+    pAudioBufferRef->channels     = channels;
+    pAudioBufferRef->sampleRate   = 0;  /* TODO: Version 0.12. Set this to sampleRate. */
+    pAudioBufferRef->cursor       = 0;
+    pAudioBufferRef->sizeInFrames = sizeInFrames;
+    pAudioBufferRef->pData        = pData;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_audio_buffer_ref_uninit(ma_audio_buffer_ref* pAudioBufferRef)
+{
+    if (pAudioBufferRef == NULL) {
+        return;
+    }
+
+    ma_data_source_uninit(&pAudioBufferRef->ds);
+}
+
+MA_API ma_result ma_audio_buffer_ref_set_data(ma_audio_buffer_ref* pAudioBufferRef, const void* pData, ma_uint64 sizeInFrames)
+{
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pAudioBufferRef->cursor       = 0;
+    pAudioBufferRef->sizeInFrames = sizeInFrames;
+    pAudioBufferRef->pData        = pData;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint64 ma_audio_buffer_ref_read_pcm_frames(ma_audio_buffer_ref* pAudioBufferRef, void* pFramesOut, ma_uint64 frameCount, ma_bool32 loop)
+{
+    ma_uint64 totalFramesRead = 0;
+
+    if (pAudioBufferRef == NULL) {
+        return 0;
+    }
+
+    if (frameCount == 0) {
+        return 0;
+    }
+
+    while (totalFramesRead < frameCount) {
+        ma_uint64 framesAvailable = pAudioBufferRef->sizeInFrames - pAudioBufferRef->cursor;
+        ma_uint64 framesRemaining = frameCount - totalFramesRead;
+        ma_uint64 framesToRead;
+
+        framesToRead = framesRemaining;
+        if (framesToRead > framesAvailable) {
+            framesToRead = framesAvailable;
+        }
+
+        if (pFramesOut != NULL) {
+            ma_copy_pcm_frames(ma_offset_ptr(pFramesOut, totalFramesRead * ma_get_bytes_per_frame(pAudioBufferRef->format, pAudioBufferRef->channels)), ma_offset_ptr(pAudioBufferRef->pData, pAudioBufferRef->cursor * ma_get_bytes_per_frame(pAudioBufferRef->format, pAudioBufferRef->channels)), framesToRead, pAudioBufferRef->format, pAudioBufferRef->channels);
+        }
+
+        totalFramesRead += framesToRead;
+
+        pAudioBufferRef->cursor += framesToRead;
+        if (pAudioBufferRef->cursor == pAudioBufferRef->sizeInFrames) {
+            if (loop) {
+                pAudioBufferRef->cursor = 0;
+            } else {
+                break;  /* We've reached the end and we're not looping. Done. */
+            }
+        }
+
+        MA_ASSERT(pAudioBufferRef->cursor < pAudioBufferRef->sizeInFrames);
+    }
+
+    return totalFramesRead;
+}
+
+MA_API ma_result ma_audio_buffer_ref_seek_to_pcm_frame(ma_audio_buffer_ref* pAudioBufferRef, ma_uint64 frameIndex)
+{
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (frameIndex > pAudioBufferRef->sizeInFrames) {
+        return MA_INVALID_ARGS;
+    }
+
+    pAudioBufferRef->cursor = (size_t)frameIndex;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_audio_buffer_ref_map(ma_audio_buffer_ref* pAudioBufferRef, void** ppFramesOut, ma_uint64* pFrameCount)
+{
+    ma_uint64 framesAvailable;
+    ma_uint64 frameCount = 0;
+
+    if (ppFramesOut != NULL) {
+        *ppFramesOut = NULL;    /* Safety. */
+    }
+
+    if (pFrameCount != NULL) {
+        frameCount = *pFrameCount;
+        *pFrameCount = 0;       /* Safety. */
+    }
+
+    if (pAudioBufferRef == NULL || ppFramesOut == NULL || pFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    framesAvailable = pAudioBufferRef->sizeInFrames - pAudioBufferRef->cursor;
+    if (frameCount > framesAvailable) {
+        frameCount = framesAvailable;
+    }
+
+    *ppFramesOut = ma_offset_ptr(pAudioBufferRef->pData, pAudioBufferRef->cursor * ma_get_bytes_per_frame(pAudioBufferRef->format, pAudioBufferRef->channels));
+    *pFrameCount = frameCount;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_audio_buffer_ref_unmap(ma_audio_buffer_ref* pAudioBufferRef, ma_uint64 frameCount)
+{
+    ma_uint64 framesAvailable;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    framesAvailable = pAudioBufferRef->sizeInFrames - pAudioBufferRef->cursor;
+    if (frameCount > framesAvailable) {
+        return MA_INVALID_ARGS;   /* The frame count was too big. This should never happen in an unmapping. Need to make sure the caller is aware of this. */
+    }
+
+    pAudioBufferRef->cursor += frameCount;
+
+    if (pAudioBufferRef->cursor == pAudioBufferRef->sizeInFrames) {
+        return MA_AT_END;   /* Successful. Need to tell the caller that the end has been reached so that it can loop if desired. */
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+MA_API ma_bool32 ma_audio_buffer_ref_at_end(const ma_audio_buffer_ref* pAudioBufferRef)
+{
+    if (pAudioBufferRef == NULL) {
+        return MA_FALSE;
+    }
+
+    return pAudioBufferRef->cursor == pAudioBufferRef->sizeInFrames;
+}
+
+MA_API ma_result ma_audio_buffer_ref_get_cursor_in_pcm_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = pAudioBufferRef->cursor;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_audio_buffer_ref_get_length_in_pcm_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = pAudioBufferRef->sizeInFrames;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_audio_buffer_ref_get_available_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pAvailableFrames)
+{
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pAudioBufferRef->sizeInFrames <= pAudioBufferRef->cursor) {
+        *pAvailableFrames = 0;
+    } else {
+        *pAvailableFrames = pAudioBufferRef->sizeInFrames - pAudioBufferRef->cursor;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+
+MA_API ma_audio_buffer_config ma_audio_buffer_config_init(ma_format format, ma_uint32 channels, ma_uint64 sizeInFrames, const void* pData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_audio_buffer_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format       = format;
+    config.channels     = channels;
+    config.sampleRate   = 0;    /* TODO: Version 0.12. Set this to sampleRate. */
+    config.sizeInFrames = sizeInFrames;
+    config.pData        = pData;
+    ma_allocation_callbacks_init_copy(&config.allocationCallbacks, pAllocationCallbacks);
+
+    return config;
+}
+
+static ma_result ma_audio_buffer_init_ex(const ma_audio_buffer_config* pConfig, ma_bool32 doCopy, ma_audio_buffer* pAudioBuffer)
+{
+    ma_result result;
+
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_MEMORY(pAudioBuffer, sizeof(*pAudioBuffer) - sizeof(pAudioBuffer->_pExtraData));   /* Safety. Don't overwrite the extra data. */
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->sizeInFrames == 0) {
+        return MA_INVALID_ARGS; /* Not allowing buffer sizes of 0 frames. */
+    }
+
+    result = ma_audio_buffer_ref_init(pConfig->format, pConfig->channels, NULL, 0, &pAudioBuffer->ref);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* TODO: Version 0.12. Set this in ma_audio_buffer_ref_init() instead of here. */
+    pAudioBuffer->ref.sampleRate = pConfig->sampleRate;
+
+    ma_allocation_callbacks_init_copy(&pAudioBuffer->allocationCallbacks, &pConfig->allocationCallbacks);
+
+    if (doCopy) {
+        ma_uint64 allocationSizeInBytes;
+        void* pData;
+
+        allocationSizeInBytes = pConfig->sizeInFrames * ma_get_bytes_per_frame(pConfig->format, pConfig->channels);
+        if (allocationSizeInBytes > MA_SIZE_MAX) {
+            return MA_OUT_OF_MEMORY;    /* Too big. */
+        }
+
+        pData = ma_malloc((size_t)allocationSizeInBytes, &pAudioBuffer->allocationCallbacks);   /* Safe cast to size_t. */
+        if (pData == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        if (pConfig->pData != NULL) {
+            ma_copy_pcm_frames(pData, pConfig->pData, pConfig->sizeInFrames, pConfig->format, pConfig->channels);
+        } else {
+            ma_silence_pcm_frames(pData, pConfig->sizeInFrames, pConfig->format, pConfig->channels);
+        }
+
+        ma_audio_buffer_ref_set_data(&pAudioBuffer->ref, pData, pConfig->sizeInFrames);
+        pAudioBuffer->ownsData = MA_TRUE;
+    } else {
+        ma_audio_buffer_ref_set_data(&pAudioBuffer->ref, pConfig->pData, pConfig->sizeInFrames);
+        pAudioBuffer->ownsData = MA_FALSE;
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_audio_buffer_uninit_ex(ma_audio_buffer* pAudioBuffer, ma_bool32 doFree)
+{
+    if (pAudioBuffer == NULL) {
+        return;
+    }
+
+    if (pAudioBuffer->ownsData && pAudioBuffer->ref.pData != &pAudioBuffer->_pExtraData[0]) {
+        ma_free((void*)pAudioBuffer->ref.pData, &pAudioBuffer->allocationCallbacks);    /* Naugty const cast, but OK in this case since we've guarded it with the ownsData check. */
+    }
+
+    if (doFree) {
+        ma_free(pAudioBuffer, &pAudioBuffer->allocationCallbacks);
+    }
+
+    ma_audio_buffer_ref_uninit(&pAudioBuffer->ref);
+}
+
+MA_API ma_result ma_audio_buffer_init(const ma_audio_buffer_config* pConfig, ma_audio_buffer* pAudioBuffer)
+{
+    return ma_audio_buffer_init_ex(pConfig, MA_FALSE, pAudioBuffer);
+}
+
+MA_API ma_result ma_audio_buffer_init_copy(const ma_audio_buffer_config* pConfig, ma_audio_buffer* pAudioBuffer)
+{
+    return ma_audio_buffer_init_ex(pConfig, MA_TRUE, pAudioBuffer);
+}
+
+MA_API ma_result ma_audio_buffer_alloc_and_init(const ma_audio_buffer_config* pConfig, ma_audio_buffer** ppAudioBuffer)
+{
+    ma_result result;
+    ma_audio_buffer* pAudioBuffer;
+    ma_audio_buffer_config innerConfig; /* We'll be making some changes to the config, so need to make a copy. */
+    ma_uint64 allocationSizeInBytes;
+
+    if (ppAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *ppAudioBuffer = NULL;  /* Safety. */
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    innerConfig = *pConfig;
+    ma_allocation_callbacks_init_copy(&innerConfig.allocationCallbacks, &pConfig->allocationCallbacks);
+
+    allocationSizeInBytes = sizeof(*pAudioBuffer) - sizeof(pAudioBuffer->_pExtraData) + (pConfig->sizeInFrames * ma_get_bytes_per_frame(pConfig->format, pConfig->channels));
+    if (allocationSizeInBytes > MA_SIZE_MAX) {
+        return MA_OUT_OF_MEMORY;    /* Too big. */
+    }
+
+    pAudioBuffer = (ma_audio_buffer*)ma_malloc((size_t)allocationSizeInBytes, &innerConfig.allocationCallbacks);  /* Safe cast to size_t. */
+    if (pAudioBuffer == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    if (pConfig->pData != NULL) {
+        ma_copy_pcm_frames(&pAudioBuffer->_pExtraData[0], pConfig->pData, pConfig->sizeInFrames, pConfig->format, pConfig->channels);
+    } else {
+        ma_silence_pcm_frames(&pAudioBuffer->_pExtraData[0], pConfig->sizeInFrames, pConfig->format, pConfig->channels);
+    }
+
+    innerConfig.pData = &pAudioBuffer->_pExtraData[0];
+
+    result = ma_audio_buffer_init_ex(&innerConfig, MA_FALSE, pAudioBuffer);
+    if (result != MA_SUCCESS) {
+        ma_free(pAudioBuffer, &innerConfig.allocationCallbacks);
+        return result;
+    }
+
+    *ppAudioBuffer = pAudioBuffer;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_audio_buffer_uninit(ma_audio_buffer* pAudioBuffer)
+{
+    ma_audio_buffer_uninit_ex(pAudioBuffer, MA_FALSE);
+}
+
+MA_API void ma_audio_buffer_uninit_and_free(ma_audio_buffer* pAudioBuffer)
+{
+    ma_audio_buffer_uninit_ex(pAudioBuffer, MA_TRUE);
+}
+
+MA_API ma_uint64 ma_audio_buffer_read_pcm_frames(ma_audio_buffer* pAudioBuffer, void* pFramesOut, ma_uint64 frameCount, ma_bool32 loop)
+{
+    if (pAudioBuffer == NULL) {
+        return 0;
+    }
+
+    return ma_audio_buffer_ref_read_pcm_frames(&pAudioBuffer->ref, pFramesOut, frameCount, loop);
+}
+
+MA_API ma_result ma_audio_buffer_seek_to_pcm_frame(ma_audio_buffer* pAudioBuffer, ma_uint64 frameIndex)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_seek_to_pcm_frame(&pAudioBuffer->ref, frameIndex);
+}
+
+MA_API ma_result ma_audio_buffer_map(ma_audio_buffer* pAudioBuffer, void** ppFramesOut, ma_uint64* pFrameCount)
+{
+    if (ppFramesOut != NULL) {
+        *ppFramesOut = NULL;    /* Safety. */
+    }
+
+    if (pAudioBuffer == NULL) {
+        if (pFrameCount != NULL) {
+            *pFrameCount = 0;
+        }
+
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_map(&pAudioBuffer->ref, ppFramesOut, pFrameCount);
+}
+
+MA_API ma_result ma_audio_buffer_unmap(ma_audio_buffer* pAudioBuffer, ma_uint64 frameCount)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_unmap(&pAudioBuffer->ref, frameCount);
+}
+
+MA_API ma_bool32 ma_audio_buffer_at_end(const ma_audio_buffer* pAudioBuffer)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_audio_buffer_ref_at_end(&pAudioBuffer->ref);
+}
+
+MA_API ma_result ma_audio_buffer_get_cursor_in_pcm_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pCursor)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_get_cursor_in_pcm_frames(&pAudioBuffer->ref, pCursor);
+}
+
+MA_API ma_result ma_audio_buffer_get_length_in_pcm_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pLength)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_get_length_in_pcm_frames(&pAudioBuffer->ref, pLength);
+}
+
+MA_API ma_result ma_audio_buffer_get_available_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pAvailableFrames)
+{
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_get_available_frames(&pAudioBuffer->ref, pAvailableFrames);
+}
+
+
+
+
+
+MA_API ma_result ma_paged_audio_buffer_data_init(ma_format format, ma_uint32 channels, ma_paged_audio_buffer_data* pData)
+{
+    if (pData == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pData);
+
+    pData->format   = format;
+    pData->channels = channels;
+    pData->pTail    = &pData->head;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_paged_audio_buffer_data_uninit(ma_paged_audio_buffer_data* pData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_paged_audio_buffer_page* pPage;
+
+    if (pData == NULL) {
+        return;
+    }
+
+    /* All pages need to be freed. */
+    pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pData->head.pNext);
+    while (pPage != NULL) {
+        ma_paged_audio_buffer_page* pNext = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pPage->pNext);
+
+        ma_free(pPage, pAllocationCallbacks);
+        pPage = pNext;
+    }
+}
+
+MA_API ma_paged_audio_buffer_page* ma_paged_audio_buffer_data_get_head(ma_paged_audio_buffer_data* pData)
+{
+    if (pData == NULL) {
+        return NULL;
+    }
+
+    return &pData->head;
+}
+
+MA_API ma_paged_audio_buffer_page* ma_paged_audio_buffer_data_get_tail(ma_paged_audio_buffer_data* pData)
+{
+    if (pData == NULL) {
+        return NULL;
+    }
+
+    return pData->pTail;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_get_length_in_pcm_frames(ma_paged_audio_buffer_data* pData, ma_uint64* pLength)
+{
+    ma_paged_audio_buffer_page* pPage;
+
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    if (pData == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Calculate the length from the linked list. */
+    for (pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pData->head.pNext); pPage != NULL; pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pPage->pNext)) {
+        *pLength += pPage->sizeInFrames;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_allocate_page(ma_paged_audio_buffer_data* pData, ma_uint64 pageSizeInFrames, const void* pInitialData, const ma_allocation_callbacks* pAllocationCallbacks, ma_paged_audio_buffer_page** ppPage)
+{
+    ma_paged_audio_buffer_page* pPage;
+    ma_uint64 allocationSize;
+
+    if (ppPage == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *ppPage = NULL;
+
+    if (pData == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    allocationSize = sizeof(*pPage) + (pageSizeInFrames * ma_get_bytes_per_frame(pData->format, pData->channels));
+    if (allocationSize > MA_SIZE_MAX) {
+        return MA_OUT_OF_MEMORY;    /* Too big. */
+    }
+
+    pPage = (ma_paged_audio_buffer_page*)ma_malloc((size_t)allocationSize, pAllocationCallbacks);   /* Safe cast to size_t. */
+    if (pPage == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    pPage->pNext = NULL;
+    pPage->sizeInFrames = pageSizeInFrames;
+
+    if (pInitialData != NULL) {
+        ma_copy_pcm_frames(pPage->pAudioData, pInitialData, pageSizeInFrames, pData->format, pData->channels);
+    }
+
+    *ppPage = pPage;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_free_page(ma_paged_audio_buffer_data* pData, ma_paged_audio_buffer_page* pPage, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pData == NULL || pPage == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* It's assumed the page is not attached to the list. */
+    ma_free(pPage, pAllocationCallbacks);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_append_page(ma_paged_audio_buffer_data* pData, ma_paged_audio_buffer_page* pPage)
+{
+    if (pData == NULL || pPage == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* This function assumes the page has been filled with audio data by this point. As soon as we append, the page will be available for reading. */
+
+    /* First thing to do is update the tail. */
+    for (;;) {
+        ma_paged_audio_buffer_page* pOldTail = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pData->pTail);
+        ma_paged_audio_buffer_page* pNewTail = pPage;
+
+        if (ma_atomic_compare_exchange_weak_ptr((volatile void**)&pData->pTail, (void**)&pOldTail, pNewTail)) {
+            /* Here is where we append the page to the list. After this, the page is attached to the list and ready to be read from. */
+            ma_atomic_exchange_ptr(&pOldTail->pNext, pPage);
+            break;  /* Done. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_allocate_and_append_page(ma_paged_audio_buffer_data* pData, ma_uint32 pageSizeInFrames, const void* pInitialData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+    ma_paged_audio_buffer_page* pPage;
+
+    result = ma_paged_audio_buffer_data_allocate_page(pData, pageSizeInFrames, pInitialData, pAllocationCallbacks, &pPage);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_paged_audio_buffer_data_append_page(pData, pPage);    /* <-- Should never fail. */
+}
+
+
+MA_API ma_paged_audio_buffer_config ma_paged_audio_buffer_config_init(ma_paged_audio_buffer_data* pData)
+{
+    ma_paged_audio_buffer_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.pData = pData;
+
+    return config;
+}
+
+
+static ma_result ma_paged_audio_buffer__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_paged_audio_buffer_read_pcm_frames((ma_paged_audio_buffer*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_paged_audio_buffer__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_paged_audio_buffer_seek_to_pcm_frame((ma_paged_audio_buffer*)pDataSource, frameIndex);
+}
+
+static ma_result ma_paged_audio_buffer__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_paged_audio_buffer* pPagedAudioBuffer = (ma_paged_audio_buffer*)pDataSource;
+
+    *pFormat     = pPagedAudioBuffer->pData->format;
+    *pChannels   = pPagedAudioBuffer->pData->channels;
+    *pSampleRate = 0;   /* There is no notion of a sample rate with audio buffers. */
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pPagedAudioBuffer->pData->channels);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_paged_audio_buffer__data_source_on_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_paged_audio_buffer_get_cursor_in_pcm_frames((ma_paged_audio_buffer*)pDataSource, pCursor);
+}
+
+static ma_result ma_paged_audio_buffer__data_source_on_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_paged_audio_buffer_get_length_in_pcm_frames((ma_paged_audio_buffer*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_paged_audio_buffer_data_source_vtable =
+{
+    ma_paged_audio_buffer__data_source_on_read,
+    ma_paged_audio_buffer__data_source_on_seek,
+    ma_paged_audio_buffer__data_source_on_get_data_format,
+    ma_paged_audio_buffer__data_source_on_get_cursor,
+    ma_paged_audio_buffer__data_source_on_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+MA_API ma_result ma_paged_audio_buffer_init(const ma_paged_audio_buffer_config* pConfig, ma_paged_audio_buffer* pPagedAudioBuffer)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pPagedAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pPagedAudioBuffer);
+
+    /* A config is required for the format and channel count. */
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->pData == NULL) {
+        return MA_INVALID_ARGS; /* No underlying data specified. */
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_paged_audio_buffer_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pPagedAudioBuffer->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pPagedAudioBuffer->pData          = pConfig->pData;
+    pPagedAudioBuffer->pCurrent       = ma_paged_audio_buffer_data_get_head(pConfig->pData);
+    pPagedAudioBuffer->relativeCursor = 0;
+    pPagedAudioBuffer->absoluteCursor = 0;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_paged_audio_buffer_uninit(ma_paged_audio_buffer* pPagedAudioBuffer)
+{
+    if (pPagedAudioBuffer == NULL) {
+        return;
+    }
+
+    /* Nothing to do. The data needs to be deleted separately. */
+}
+
+MA_API ma_result ma_paged_audio_buffer_read_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 totalFramesRead = 0;
+    ma_format format;
+    ma_uint32 channels;
+
+    if (pPagedAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    format   = pPagedAudioBuffer->pData->format;
+    channels = pPagedAudioBuffer->pData->channels;
+
+    while (totalFramesRead < frameCount) {
+        /* Read from the current page. The buffer should never be in a state where this is NULL. */
+        ma_uint64 framesRemainingInCurrentPage;
+        ma_uint64 framesRemainingToRead = frameCount - totalFramesRead;
+        ma_uint64 framesToReadThisIteration;
+
+        MA_ASSERT(pPagedAudioBuffer->pCurrent != NULL);
+
+        framesRemainingInCurrentPage = pPagedAudioBuffer->pCurrent->sizeInFrames - pPagedAudioBuffer->relativeCursor;
+
+        framesToReadThisIteration = ma_min(framesRemainingInCurrentPage, framesRemainingToRead);
+        ma_copy_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, format, channels), ma_offset_pcm_frames_ptr(pPagedAudioBuffer->pCurrent->pAudioData, pPagedAudioBuffer->relativeCursor, format, channels), framesToReadThisIteration, format, channels);
+        totalFramesRead += framesToReadThisIteration;
+
+        pPagedAudioBuffer->absoluteCursor += framesToReadThisIteration;
+        pPagedAudioBuffer->relativeCursor += framesToReadThisIteration;
+
+        /* Move to the next page if necessary. If there's no more pages, we need to return MA_AT_END. */
+        MA_ASSERT(pPagedAudioBuffer->relativeCursor <= pPagedAudioBuffer->pCurrent->sizeInFrames);
+
+        if (pPagedAudioBuffer->relativeCursor == pPagedAudioBuffer->pCurrent->sizeInFrames) {
+            /* We reached the end of the page. Need to move to the next. If there's no more pages, we're done. */
+            ma_paged_audio_buffer_page* pNext = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pPagedAudioBuffer->pCurrent->pNext);
+            if (pNext == NULL) {
+                result = MA_AT_END;
+                break;  /* We've reached the end. */
+            } else {
+                pPagedAudioBuffer->pCurrent       = pNext;
+                pPagedAudioBuffer->relativeCursor = 0;
+            }
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesRead;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_paged_audio_buffer_seek_to_pcm_frame(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64 frameIndex)
+{
+    if (pPagedAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (frameIndex == pPagedAudioBuffer->absoluteCursor) {
+        return MA_SUCCESS;  /* Nothing to do. */
+    }
+
+    if (frameIndex < pPagedAudioBuffer->absoluteCursor) {
+        /* Moving backwards. Need to move the cursor back to the start, and then move forward. */
+        pPagedAudioBuffer->pCurrent       = ma_paged_audio_buffer_data_get_head(pPagedAudioBuffer->pData);
+        pPagedAudioBuffer->absoluteCursor = 0;
+        pPagedAudioBuffer->relativeCursor = 0;
+
+        /* Fall through to the forward seeking section below. */
+    }
+
+    if (frameIndex > pPagedAudioBuffer->absoluteCursor) {
+        /* Moving forward. */
+        ma_paged_audio_buffer_page* pPage;
+        ma_uint64 runningCursor = 0;
+
+        for (pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&ma_paged_audio_buffer_data_get_head(pPagedAudioBuffer->pData)->pNext); pPage != NULL; pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pPage->pNext)) {
+            ma_uint64 pageRangeBeg = runningCursor;
+            ma_uint64 pageRangeEnd = pageRangeBeg + pPage->sizeInFrames;
+
+            if (frameIndex >= pageRangeBeg) {
+                if (frameIndex < pageRangeEnd || (frameIndex == pageRangeEnd && pPage == (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(ma_paged_audio_buffer_data_get_tail(pPagedAudioBuffer->pData)))) {  /* A small edge case - allow seeking to the very end of the buffer. */
+                    /* We found the page. */
+                    pPagedAudioBuffer->pCurrent       = pPage;
+                    pPagedAudioBuffer->absoluteCursor = frameIndex;
+                    pPagedAudioBuffer->relativeCursor = frameIndex - pageRangeBeg;
+                    return MA_SUCCESS;
+                }
+            }
+
+            runningCursor = pageRangeEnd;
+        }
+
+        /* Getting here means we tried seeking too far forward. Don't change any state. */
+        return MA_BAD_SEEK;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_get_cursor_in_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pPagedAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = pPagedAudioBuffer->absoluteCursor;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_get_length_in_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64* pLength)
+{
+    return ma_paged_audio_buffer_data_get_length_in_pcm_frames(pPagedAudioBuffer->pData, pLength);
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+VFS
+
+**************************************************************************************************************************************************************/
+MA_API ma_result ma_vfs_open(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFile = NULL;
+
+    if (pVFS == NULL || pFilePath == NULL || openMode == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onOpen == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onOpen(pVFS, pFilePath, openMode, pFile);
+}
+
+MA_API ma_result ma_vfs_open_w(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFile = NULL;
+
+    if (pVFS == NULL || pFilePath == NULL || openMode == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onOpenW == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onOpenW(pVFS, pFilePath, openMode, pFile);
+}
+
+MA_API ma_result ma_vfs_close(ma_vfs* pVFS, ma_vfs_file file)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pVFS == NULL || file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onClose == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onClose(pVFS, file);
+}
+
+MA_API ma_result ma_vfs_read(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+    ma_result result;
+    size_t bytesRead = 0;
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = 0;
+    }
+
+    if (pVFS == NULL || file == NULL || pDst == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onRead == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pCallbacks->onRead(pVFS, file, pDst, sizeInBytes, &bytesRead);
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = bytesRead;
+    }
+
+    if (result == MA_SUCCESS && bytesRead == 0 && sizeInBytes > 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_vfs_write(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pBytesWritten != NULL) {
+        *pBytesWritten = 0;
+    }
+
+    if (pVFS == NULL || file == NULL || pSrc == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onWrite == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onWrite(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+}
+
+MA_API ma_result ma_vfs_seek(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pVFS == NULL || file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onSeek == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onSeek(pVFS, file, offset, origin);
+}
+
+MA_API ma_result ma_vfs_tell(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (pVFS == NULL || file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onTell == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onTell(pVFS, file, pCursor);
+}
+
+MA_API ma_result ma_vfs_info(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pInfo == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pInfo);
+
+    if (pVFS == NULL || file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onInfo == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onInfo(pVFS, file, pInfo);
+}
+
+
+#if !defined(MA_USE_WIN32_FILEIO) && (defined(MA_WIN32) && (defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_NXDK)) && !defined(MA_NO_WIN32_FILEIO) && !defined(MA_POSIX))
+    #define MA_USE_WIN32_FILEIO
+#endif
+
+#if defined(MA_USE_WIN32_FILEIO)
+/*
+We need to dynamically load SetFilePointer or SetFilePointerEx because older versions of Windows do
+not have the Ex version. We therefore need to do some dynamic branching depending on what's available.
+
+We load these when we load our first file from the default VFS. It's left open for the life of the
+program and is left to the OS to uninitialize when the program terminates.
+*/
+typedef DWORD (__stdcall * ma_SetFilePointer_proc)(HANDLE hFile, LONG lDistanceToMove, LONG* lpDistanceToMoveHigh, DWORD dwMoveMethod);
+typedef BOOL  (__stdcall * ma_SetFilePointerEx_proc)(HANDLE hFile, LARGE_INTEGER liDistanceToMove, LARGE_INTEGER* lpNewFilePointer, DWORD dwMoveMethod);
+
+static ma_handle hKernel32DLL = NULL;
+static ma_SetFilePointer_proc   ma_SetFilePointer   = NULL;
+static ma_SetFilePointerEx_proc ma_SetFilePointerEx = NULL;
+
+static void ma_win32_fileio_init(void)
+{
+    if (hKernel32DLL == NULL) {
+        hKernel32DLL = ma_dlopen(NULL, "kernel32.dll");
+        if (hKernel32DLL != NULL) {
+            ma_SetFilePointer   = (ma_SetFilePointer_proc)  ma_dlsym(NULL, hKernel32DLL, "SetFilePointer");
+            ma_SetFilePointerEx = (ma_SetFilePointerEx_proc)ma_dlsym(NULL, hKernel32DLL, "SetFilePointerEx");
+        }
+    }
+}
+
+static void ma_default_vfs__get_open_settings_win32(ma_uint32 openMode, DWORD* pDesiredAccess, DWORD* pShareMode, DWORD* pCreationDisposition)
+{
+    *pDesiredAccess = 0;
+    if ((openMode & MA_OPEN_MODE_READ) != 0) {
+        *pDesiredAccess |= GENERIC_READ;
+    }
+    if ((openMode & MA_OPEN_MODE_WRITE) != 0) {
+        *pDesiredAccess |= GENERIC_WRITE;
+    }
+
+    *pShareMode = 0;
+    if ((openMode & MA_OPEN_MODE_READ) != 0) {
+        *pShareMode |= FILE_SHARE_READ;
+    }
+
+    if ((openMode & MA_OPEN_MODE_WRITE) != 0) {
+        *pCreationDisposition = CREATE_ALWAYS;  /* Opening in write mode. Truncate. */
+    } else {
+        *pCreationDisposition = OPEN_EXISTING;  /* Opening in read mode. File must exist. */
+    }
+}
+
+static ma_result ma_default_vfs_open__win32(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    HANDLE hFile;
+    DWORD dwDesiredAccess;
+    DWORD dwShareMode;
+    DWORD dwCreationDisposition;
+
+    (void)pVFS;
+
+    /* Load some Win32 symbols dynamically so we can dynamically check for the existence of SetFilePointerEx. */
+    ma_win32_fileio_init();
+
+    ma_default_vfs__get_open_settings_win32(openMode, &dwDesiredAccess, &dwShareMode, &dwCreationDisposition);
+
+    hFile = CreateFileA(pFilePath, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (hFile == INVALID_HANDLE_VALUE) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    *pFile = hFile;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_open_w__win32(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    #if !defined(MA_XBOX_NXDK)
+    {
+        HANDLE hFile;
+        DWORD dwDesiredAccess;
+        DWORD dwShareMode;
+        DWORD dwCreationDisposition;
+
+        (void)pVFS;
+
+        /* Load some Win32 symbols dynamically so we can dynamically check for the existence of SetFilePointerEx. */
+        ma_win32_fileio_init();
+
+        ma_default_vfs__get_open_settings_win32(openMode, &dwDesiredAccess, &dwShareMode, &dwCreationDisposition);
+
+        hFile = CreateFileW(pFilePath, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
+        if (hFile == INVALID_HANDLE_VALUE) {
+            return ma_result_from_GetLastError(GetLastError());
+        }
+
+        *pFile = hFile;
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* No CreateFileW() available. */
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+static ma_result ma_default_vfs_close__win32(ma_vfs* pVFS, ma_vfs_file file)
+{
+    (void)pVFS;
+
+    if (CloseHandle((HANDLE)file) == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_default_vfs_read__win32(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    ma_result result = MA_SUCCESS;
+    size_t totalBytesRead;
+
+    (void)pVFS;
+
+    totalBytesRead = 0;
+    while (totalBytesRead < sizeInBytes) {
+        size_t bytesRemaining;
+        DWORD bytesToRead;
+        DWORD bytesRead;
+        BOOL readResult;
+
+        bytesRemaining = sizeInBytes - totalBytesRead;
+        if (bytesRemaining >= 0xFFFFFFFF) {
+            bytesToRead = 0xFFFFFFFF;
+        } else {
+            bytesToRead = (DWORD)bytesRemaining;
+        }
+
+        readResult = ReadFile((HANDLE)file, ma_offset_ptr(pDst, totalBytesRead), bytesToRead, &bytesRead, NULL);
+        if (readResult == 1 && bytesRead == 0) {
+            result = MA_AT_END;
+            break;  /* EOF */
+        }
+
+        totalBytesRead += bytesRead;
+
+        if (bytesRead < bytesToRead) {
+            break;  /* EOF */
+        }
+
+        if (readResult == 0) {
+            result = ma_result_from_GetLastError(GetLastError());
+            break;
+        }
+    }
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = totalBytesRead;
+    }
+
+    return result;
+}
+
+static ma_result ma_default_vfs_write__win32(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    ma_result result = MA_SUCCESS;
+    size_t totalBytesWritten;
+
+    (void)pVFS;
+
+    totalBytesWritten = 0;
+    while (totalBytesWritten < sizeInBytes) {
+        size_t bytesRemaining;
+        DWORD bytesToWrite;
+        DWORD bytesWritten;
+        BOOL writeResult;
+
+        bytesRemaining = sizeInBytes - totalBytesWritten;
+        if (bytesRemaining >= 0xFFFFFFFF) {
+            bytesToWrite = 0xFFFFFFFF;
+        } else {
+            bytesToWrite = (DWORD)bytesRemaining;
+        }
+
+        writeResult = WriteFile((HANDLE)file, ma_offset_ptr(pSrc, totalBytesWritten), bytesToWrite, &bytesWritten, NULL);
+        totalBytesWritten += bytesWritten;
+
+        if (writeResult == 0) {
+            result = ma_result_from_GetLastError(GetLastError());
+            break;
+        }
+    }
+
+    if (pBytesWritten != NULL) {
+        *pBytesWritten = totalBytesWritten;
+    }
+
+    return result;
+}
+
+
+static ma_result ma_default_vfs_seek__win32(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    LARGE_INTEGER liDistanceToMove;
+    DWORD dwMoveMethod;
+    BOOL result;
+
+    (void)pVFS;
+
+    liDistanceToMove.QuadPart = offset;
+
+    /*  */ if (origin == ma_seek_origin_current) {
+        dwMoveMethod = FILE_CURRENT;
+    } else if (origin == ma_seek_origin_end) {
+        dwMoveMethod = FILE_END;
+    } else {
+        dwMoveMethod = FILE_BEGIN;
+    }
+
+    if (ma_SetFilePointerEx != NULL) {
+        result = ma_SetFilePointerEx((HANDLE)file, liDistanceToMove, NULL, dwMoveMethod);
+    } else if (ma_SetFilePointer != NULL) {
+        /* No SetFilePointerEx() so restrict to 31 bits. */
+        if (offset > 0x7FFFFFFF) {
+            return MA_OUT_OF_RANGE;
+        }
+
+        result = ma_SetFilePointer((HANDLE)file, (LONG)liDistanceToMove.QuadPart, NULL, dwMoveMethod);
+    } else {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    if (result == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_tell__win32(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    LARGE_INTEGER liZero;
+    LARGE_INTEGER liTell;
+    BOOL result;
+
+    (void)pVFS;
+
+    liZero.QuadPart = 0;
+
+    if (ma_SetFilePointerEx != NULL) {
+        result = ma_SetFilePointerEx((HANDLE)file, liZero, &liTell, FILE_CURRENT);
+    } else if (ma_SetFilePointer != NULL) {
+        LONG tell;
+
+        result = ma_SetFilePointer((HANDLE)file, (LONG)liZero.QuadPart, &tell, FILE_CURRENT);
+        liTell.QuadPart = tell;
+    } else {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    if (result == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    if (pCursor != NULL) {
+        *pCursor = liTell.QuadPart;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_info__win32(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    (void)pVFS;
+
+    #if !defined(MA_XBOX_NXDK)
+    {
+        BY_HANDLE_FILE_INFORMATION fi;
+        BOOL result;
+
+        result = GetFileInformationByHandle((HANDLE)file, &fi);
+        if (result == 0) {
+            return ma_result_from_GetLastError(GetLastError());
+        }
+
+        pInfo->sizeInBytes = ((ma_uint64)fi.nFileSizeHigh << 32) | ((ma_uint64)fi.nFileSizeLow);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* GetFileInformationByHandle() is unavailable. */
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+#else
+static ma_result ma_default_vfs_open__stdio(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    ma_result result;
+    FILE* pFileStd;
+    const char* pOpenModeStr;
+
+    MA_ASSERT(pFilePath != NULL);
+    MA_ASSERT(openMode  != 0);
+    MA_ASSERT(pFile     != NULL);
+
+    (void)pVFS;
+
+    if ((openMode & MA_OPEN_MODE_READ) != 0) {
+        if ((openMode & MA_OPEN_MODE_WRITE) != 0) {
+            pOpenModeStr = "r+";
+        } else {
+            pOpenModeStr = "rb";
+        }
+    } else {
+        pOpenModeStr = "wb";
+    }
+
+    result = ma_fopen(&pFileStd, pFilePath, pOpenModeStr);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pFile = pFileStd;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_open_w__stdio(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    ma_result result;
+    FILE* pFileStd;
+    const wchar_t* pOpenModeStr;
+
+    MA_ASSERT(pFilePath != NULL);
+    MA_ASSERT(openMode  != 0);
+    MA_ASSERT(pFile     != NULL);
+
+    (void)pVFS;
+
+    if ((openMode & MA_OPEN_MODE_READ) != 0) {
+        if ((openMode & MA_OPEN_MODE_WRITE) != 0) {
+            pOpenModeStr = L"r+";
+        } else {
+            pOpenModeStr = L"rb";
+        }
+    } else {
+        pOpenModeStr = L"wb";
+    }
+
+    result = ma_wfopen(&pFileStd, pFilePath, pOpenModeStr, (pVFS != NULL) ? &((ma_default_vfs*)pVFS)->allocationCallbacks : NULL);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pFile = pFileStd;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_close__stdio(ma_vfs* pVFS, ma_vfs_file file)
+{
+    MA_ASSERT(file != NULL);
+
+    (void)pVFS;
+
+    fclose((FILE*)file);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_read__stdio(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    size_t result;
+
+    MA_ASSERT(file != NULL);
+    MA_ASSERT(pDst != NULL);
+
+    (void)pVFS;
+
+    result = fread(pDst, 1, sizeInBytes, (FILE*)file);
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = result;
+    }
+
+    if (result != sizeInBytes) {
+        if (result == 0 && feof((FILE*)file)) {
+            return MA_AT_END;
+        } else {
+            return ma_result_from_errno(ferror((FILE*)file));
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_write__stdio(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    size_t result;
+
+    MA_ASSERT(file != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    (void)pVFS;
+
+    result = fwrite(pSrc, 1, sizeInBytes, (FILE*)file);
+
+    if (pBytesWritten != NULL) {
+        *pBytesWritten = result;
+    }
+
+    if (result != sizeInBytes) {
+        return ma_result_from_errno(ferror((FILE*)file));
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_seek__stdio(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    int result;
+    int whence;
+
+    MA_ASSERT(file != NULL);
+
+    (void)pVFS;
+
+    if (origin == ma_seek_origin_start) {
+        whence = SEEK_SET;
+    } else if (origin == ma_seek_origin_end) {
+        whence = SEEK_END;
+    } else {
+        whence = SEEK_CUR;
+    }
+
+#if defined(_WIN32)
+    #if defined(_MSC_VER) && _MSC_VER > 1200
+        result = _fseeki64((FILE*)file, offset, whence);
+    #else
+        /* No _fseeki64() so restrict to 31 bits. */
+        if (offset > 0x7FFFFFFF) {
+            return MA_OUT_OF_RANGE;
+        }
+
+        result = fseek((FILE*)file, (int)offset, whence);
+    #endif
+#else
+    result = fseek((FILE*)file, (long int)offset, whence);
+#endif
+    if (result != 0) {
+        return MA_ERROR;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_tell__stdio(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    ma_int64 result;
+
+    MA_ASSERT(file    != NULL);
+    MA_ASSERT(pCursor != NULL);
+
+    (void)pVFS;
+
+#if defined(_WIN32)
+    #if defined(_MSC_VER) && _MSC_VER > 1200
+        result = _ftelli64((FILE*)file);
+    #else
+        result = ftell((FILE*)file);
+    #endif
+#else
+    result = ftell((FILE*)file);
+#endif
+
+    *pCursor = result;
+
+    return MA_SUCCESS;
+}
+
+#if !defined(_MSC_VER) && !((defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_POSIX_SOURCE)) && !defined(MA_BSD)
+int fileno(FILE *stream);
+#endif
+
+static ma_result ma_default_vfs_info__stdio(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    int fd;
+    struct stat info;
+
+    MA_ASSERT(file  != NULL);
+    MA_ASSERT(pInfo != NULL);
+
+    (void)pVFS;
+
+#if defined(_MSC_VER)
+    fd = _fileno((FILE*)file);
+#else
+    fd =  fileno((FILE*)file);
+#endif
+
+    if (fstat(fd, &info) != 0) {
+        return ma_result_from_errno(errno);
+    }
+
+    pInfo->sizeInBytes = info.st_size;
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+static ma_result ma_default_vfs_open(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    if (pFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFile = NULL;
+
+    if (pFilePath == NULL || openMode == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_open__win32(pVFS, pFilePath, openMode, pFile);
+#else
+    return ma_default_vfs_open__stdio(pVFS, pFilePath, openMode, pFile);
+#endif
+}
+
+static ma_result ma_default_vfs_open_w(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    if (pFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFile = NULL;
+
+    if (pFilePath == NULL || openMode == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_open_w__win32(pVFS, pFilePath, openMode, pFile);
+#else
+    return ma_default_vfs_open_w__stdio(pVFS, pFilePath, openMode, pFile);
+#endif
+}
+
+static ma_result ma_default_vfs_close(ma_vfs* pVFS, ma_vfs_file file)
+{
+    if (file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_close__win32(pVFS, file);
+#else
+    return ma_default_vfs_close__stdio(pVFS, file);
+#endif
+}
+
+static ma_result ma_default_vfs_read(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    if (pBytesRead != NULL) {
+        *pBytesRead = 0;
+    }
+
+    if (file == NULL || pDst == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_read__win32(pVFS, file, pDst, sizeInBytes, pBytesRead);
+#else
+    return ma_default_vfs_read__stdio(pVFS, file, pDst, sizeInBytes, pBytesRead);
+#endif
+}
+
+static ma_result ma_default_vfs_write(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    if (pBytesWritten != NULL) {
+        *pBytesWritten = 0;
+    }
+
+    if (file == NULL || pSrc == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_write__win32(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+#else
+    return ma_default_vfs_write__stdio(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+#endif
+}
+
+static ma_result ma_default_vfs_seek(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    if (file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_seek__win32(pVFS, file, offset, origin);
+#else
+    return ma_default_vfs_seek__stdio(pVFS, file, offset, origin);
+#endif
+}
+
+static ma_result ma_default_vfs_tell(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_tell__win32(pVFS, file, pCursor);
+#else
+    return ma_default_vfs_tell__stdio(pVFS, file, pCursor);
+#endif
+}
+
+static ma_result ma_default_vfs_info(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    ma_result result;
+
+    if (pInfo == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pInfo);
+
+    if (file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    result = ma_default_vfs_info__win32(pVFS, file, pInfo);
+#else
+    result = ma_default_vfs_info__stdio(pVFS, file, pInfo);
+#endif
+
+    if (result == MA_NOT_IMPLEMENTED) {
+        /* Not implemented. Fall back to seek/tell/seek. */
+        ma_result result;
+        ma_int64 cursor;
+        ma_int64 sizeInBytes;
+        
+        result = ma_default_vfs_tell(pVFS, file, &cursor);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_default_vfs_seek(pVFS, file, 0, ma_seek_origin_end);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_default_vfs_tell(pVFS, file, &sizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pInfo->sizeInBytes = sizeInBytes;
+
+        result = ma_default_vfs_seek(pVFS, file, cursor, ma_seek_origin_start);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        MA_ASSERT(result == MA_SUCCESS);
+    }
+
+    return result;
+}
+
+
+MA_API ma_result ma_default_vfs_init(ma_default_vfs* pVFS, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pVFS == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pVFS->cb.onOpen  = ma_default_vfs_open;
+    pVFS->cb.onOpenW = ma_default_vfs_open_w;
+    pVFS->cb.onClose = ma_default_vfs_close;
+    pVFS->cb.onRead  = ma_default_vfs_read;
+    pVFS->cb.onWrite = ma_default_vfs_write;
+    pVFS->cb.onSeek  = ma_default_vfs_seek;
+    pVFS->cb.onTell  = ma_default_vfs_tell;
+    pVFS->cb.onInfo  = ma_default_vfs_info;
+    ma_allocation_callbacks_init_copy(&pVFS->allocationCallbacks, pAllocationCallbacks);
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_vfs_or_default_open(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_open(pVFS, pFilePath, openMode, pFile);
+    } else {
+        return ma_default_vfs_open(pVFS, pFilePath, openMode, pFile);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_open_w(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_open_w(pVFS, pFilePath, openMode, pFile);
+    } else {
+        return ma_default_vfs_open_w(pVFS, pFilePath, openMode, pFile);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_close(ma_vfs* pVFS, ma_vfs_file file)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_close(pVFS, file);
+    } else {
+        return ma_default_vfs_close(pVFS, file);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_read(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_read(pVFS, file, pDst, sizeInBytes, pBytesRead);
+    } else {
+        return ma_default_vfs_read(pVFS, file, pDst, sizeInBytes, pBytesRead);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_write(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_write(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+    } else {
+        return ma_default_vfs_write(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_seek(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_seek(pVFS, file, offset, origin);
+    } else {
+        return ma_default_vfs_seek(pVFS, file, offset, origin);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_tell(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_tell(pVFS, file, pCursor);
+    } else {
+        return ma_default_vfs_tell(pVFS, file, pCursor);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_info(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_info(pVFS, file, pInfo);
+    } else {
+        return ma_default_vfs_info(pVFS, file, pInfo);
+    }
+}
+
+
+
+static ma_result ma_vfs_open_and_read_file_ex(ma_vfs* pVFS, const char* pFilePath, const wchar_t* pFilePathW, void** ppData, size_t* pSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+    ma_vfs_file file;
+    ma_file_info info;
+    void* pData;
+    size_t bytesRead;
+
+    if (ppData != NULL) {
+        *ppData = NULL;
+    }
+    if (pSize != NULL) {
+        *pSize = 0;
+    }
+
+    if (ppData == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFilePath != NULL) {
+        result = ma_vfs_or_default_open(pVFS, pFilePath, MA_OPEN_MODE_READ, &file);
+    } else {
+        result = ma_vfs_or_default_open_w(pVFS, pFilePathW, MA_OPEN_MODE_READ, &file);
+    }
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_vfs_or_default_info(pVFS, file, &info);
+    if (result != MA_SUCCESS) {
+        ma_vfs_or_default_close(pVFS, file);
+        return result;
+    }
+
+    if (info.sizeInBytes > MA_SIZE_MAX) {
+        ma_vfs_or_default_close(pVFS, file);
+        return MA_TOO_BIG;
+    }
+
+    pData = ma_malloc((size_t)info.sizeInBytes, pAllocationCallbacks);  /* Safe cast. */
+    if (pData == NULL) {
+        ma_vfs_or_default_close(pVFS, file);
+        return result;
+    }
+
+    result = ma_vfs_or_default_read(pVFS, file, pData, (size_t)info.sizeInBytes, &bytesRead);  /* Safe cast. */
+    ma_vfs_or_default_close(pVFS, file);
+
+    if (result != MA_SUCCESS) {
+        ma_free(pData, pAllocationCallbacks);
+        return result;
+    }
+
+    if (pSize != NULL) {
+        *pSize = bytesRead;
+    }
+
+    MA_ASSERT(ppData != NULL);
+    *ppData = pData;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_vfs_open_and_read_file(ma_vfs* pVFS, const char* pFilePath, void** ppData, size_t* pSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_vfs_open_and_read_file_ex(pVFS, pFilePath, NULL, ppData, pSize, pAllocationCallbacks);
+}
+
+MA_API ma_result ma_vfs_open_and_read_file_w(ma_vfs* pVFS, const wchar_t* pFilePath, void** ppData, size_t* pSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_vfs_open_and_read_file_ex(pVFS, NULL, pFilePath, ppData, pSize, pAllocationCallbacks);
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Decoding and Encoding Headers. These are auto-generated from a tool.
+
+**************************************************************************************************************************************************************/
+#if !defined(MA_NO_WAV) && (!defined(MA_NO_DECODING) || !defined(MA_NO_ENCODING))
+/* dr_wav_h begin */
+#ifndef ma_dr_wav_h
+#define ma_dr_wav_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define MA_DR_WAV_STRINGIFY(x)      #x
+#define MA_DR_WAV_XSTRINGIFY(x)     MA_DR_WAV_STRINGIFY(x)
+#define MA_DR_WAV_VERSION_MAJOR     0
+#define MA_DR_WAV_VERSION_MINOR     14
+#define MA_DR_WAV_VERSION_REVISION  1
+#define MA_DR_WAV_VERSION_STRING    MA_DR_WAV_XSTRINGIFY(MA_DR_WAV_VERSION_MAJOR) "." MA_DR_WAV_XSTRINGIFY(MA_DR_WAV_VERSION_MINOR) "." MA_DR_WAV_XSTRINGIFY(MA_DR_WAV_VERSION_REVISION)
+#include <stddef.h>
+#define MA_DR_WAVE_FORMAT_PCM          0x1
+#define MA_DR_WAVE_FORMAT_ADPCM        0x2
+#define MA_DR_WAVE_FORMAT_IEEE_FLOAT   0x3
+#define MA_DR_WAVE_FORMAT_ALAW         0x6
+#define MA_DR_WAVE_FORMAT_MULAW        0x7
+#define MA_DR_WAVE_FORMAT_DVI_ADPCM    0x11
+#define MA_DR_WAVE_FORMAT_EXTENSIBLE   0xFFFE
+#define MA_DR_WAV_SEQUENTIAL            0x00000001
+#define MA_DR_WAV_WITH_METADATA         0x00000002
+MA_API void ma_dr_wav_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
+MA_API const char* ma_dr_wav_version_string(void);
+typedef enum
+{
+    MA_DR_WAV_SEEK_SET,
+    MA_DR_WAV_SEEK_CUR,
+    MA_DR_WAV_SEEK_END
+} ma_dr_wav_seek_origin;
+typedef enum
+{
+    ma_dr_wav_container_riff,
+    ma_dr_wav_container_rifx,
+    ma_dr_wav_container_w64,
+    ma_dr_wav_container_rf64,
+    ma_dr_wav_container_aiff
+} ma_dr_wav_container;
+typedef struct
+{
+    union
+    {
+        ma_uint8 fourcc[4];
+        ma_uint8 guid[16];
+    } id;
+    ma_uint64 sizeInBytes;
+    unsigned int paddingSize;
+} ma_dr_wav_chunk_header;
+typedef struct
+{
+    ma_uint16 formatTag;
+    ma_uint16 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 avgBytesPerSec;
+    ma_uint16 blockAlign;
+    ma_uint16 bitsPerSample;
+    ma_uint16 extendedSize;
+    ma_uint16 validBitsPerSample;
+    ma_uint32 channelMask;
+    ma_uint8 subFormat[16];
+} ma_dr_wav_fmt;
+MA_API ma_uint16 ma_dr_wav_fmt_get_format(const ma_dr_wav_fmt* pFMT);
+typedef size_t (* ma_dr_wav_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
+typedef size_t (* ma_dr_wav_write_proc)(void* pUserData, const void* pData, size_t bytesToWrite);
+typedef ma_bool32 (* ma_dr_wav_seek_proc)(void* pUserData, int offset, ma_dr_wav_seek_origin origin);
+typedef ma_bool32 (* ma_dr_wav_tell_proc)(void* pUserData, ma_int64* pCursor);
+typedef ma_uint64 (* ma_dr_wav_chunk_proc)(void* pChunkUserData, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pReadSeekUserData, const ma_dr_wav_chunk_header* pChunkHeader, ma_dr_wav_container container, const ma_dr_wav_fmt* pFMT);
+typedef struct
+{
+    const ma_uint8* data;
+    size_t dataSize;
+    size_t currentReadPos;
+} ma_dr_wav__memory_stream;
+typedef struct
+{
+    void** ppData;
+    size_t* pDataSize;
+    size_t dataSize;
+    size_t dataCapacity;
+    size_t currentWritePos;
+} ma_dr_wav__memory_stream_write;
+typedef struct
+{
+    ma_dr_wav_container container;
+    ma_uint32 format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 bitsPerSample;
+} ma_dr_wav_data_format;
+typedef enum
+{
+    ma_dr_wav_metadata_type_none                        = 0,
+    ma_dr_wav_metadata_type_unknown                     = 1 << 0,
+    ma_dr_wav_metadata_type_smpl                        = 1 << 1,
+    ma_dr_wav_metadata_type_inst                        = 1 << 2,
+    ma_dr_wav_metadata_type_cue                         = 1 << 3,
+    ma_dr_wav_metadata_type_acid                        = 1 << 4,
+    ma_dr_wav_metadata_type_bext                        = 1 << 5,
+    ma_dr_wav_metadata_type_list_label                  = 1 << 6,
+    ma_dr_wav_metadata_type_list_note                   = 1 << 7,
+    ma_dr_wav_metadata_type_list_labelled_cue_region    = 1 << 8,
+    ma_dr_wav_metadata_type_list_info_software          = 1 << 9,
+    ma_dr_wav_metadata_type_list_info_copyright         = 1 << 10,
+    ma_dr_wav_metadata_type_list_info_title             = 1 << 11,
+    ma_dr_wav_metadata_type_list_info_artist            = 1 << 12,
+    ma_dr_wav_metadata_type_list_info_comment           = 1 << 13,
+    ma_dr_wav_metadata_type_list_info_date              = 1 << 14,
+    ma_dr_wav_metadata_type_list_info_genre             = 1 << 15,
+    ma_dr_wav_metadata_type_list_info_album             = 1 << 16,
+    ma_dr_wav_metadata_type_list_info_tracknumber       = 1 << 17,
+    ma_dr_wav_metadata_type_list_info_location          = 1 << 18,
+    ma_dr_wav_metadata_type_list_info_organization      = 1 << 19,
+    ma_dr_wav_metadata_type_list_info_keywords          = 1 << 20,
+    ma_dr_wav_metadata_type_list_info_medium            = 1 << 21,
+    ma_dr_wav_metadata_type_list_info_description       = 1 << 22,
+    ma_dr_wav_metadata_type_list_all_info_strings       = ma_dr_wav_metadata_type_list_info_software
+                                                    | ma_dr_wav_metadata_type_list_info_copyright
+                                                    | ma_dr_wav_metadata_type_list_info_title
+                                                    | ma_dr_wav_metadata_type_list_info_artist
+                                                    | ma_dr_wav_metadata_type_list_info_comment
+                                                    | ma_dr_wav_metadata_type_list_info_date
+                                                    | ma_dr_wav_metadata_type_list_info_genre
+                                                    | ma_dr_wav_metadata_type_list_info_album
+                                                    | ma_dr_wav_metadata_type_list_info_tracknumber
+                                                    | ma_dr_wav_metadata_type_list_info_location
+                                                    | ma_dr_wav_metadata_type_list_info_organization
+                                                    | ma_dr_wav_metadata_type_list_info_keywords
+                                                    | ma_dr_wav_metadata_type_list_info_medium
+                                                    | ma_dr_wav_metadata_type_list_info_description,
+    ma_dr_wav_metadata_type_list_all_adtl               = ma_dr_wav_metadata_type_list_label
+                                                    | ma_dr_wav_metadata_type_list_note
+                                                    | ma_dr_wav_metadata_type_list_labelled_cue_region,
+    ma_dr_wav_metadata_type_all                         = -2,
+    ma_dr_wav_metadata_type_all_including_unknown       = -1
+} ma_dr_wav_metadata_type;
+typedef enum
+{
+    ma_dr_wav_smpl_loop_type_forward  = 0,
+    ma_dr_wav_smpl_loop_type_pingpong = 1,
+    ma_dr_wav_smpl_loop_type_backward = 2
+} ma_dr_wav_smpl_loop_type;
+typedef struct
+{
+    ma_uint32 cuePointId;
+    ma_uint32 type;
+    ma_uint32 firstSampleOffset;
+    ma_uint32 lastSampleOffset;
+    ma_uint32 sampleFraction;
+    ma_uint32 playCount;
+} ma_dr_wav_smpl_loop;
+typedef struct
+{
+    ma_uint32 manufacturerId;
+    ma_uint32 productId;
+    ma_uint32 samplePeriodNanoseconds;
+    ma_uint32 midiUnityNote;
+    ma_uint32 midiPitchFraction;
+    ma_uint32 smpteFormat;
+    ma_uint32 smpteOffset;
+    ma_uint32 sampleLoopCount;
+    ma_uint32 samplerSpecificDataSizeInBytes;
+    ma_dr_wav_smpl_loop* pLoops;
+    ma_uint8* pSamplerSpecificData;
+} ma_dr_wav_smpl;
+typedef struct
+{
+    ma_int8 midiUnityNote;
+    ma_int8 fineTuneCents;
+    ma_int8 gainDecibels;
+    ma_int8 lowNote;
+    ma_int8 highNote;
+    ma_int8 lowVelocity;
+    ma_int8 highVelocity;
+} ma_dr_wav_inst;
+typedef struct
+{
+    ma_uint32 id;
+    ma_uint32 playOrderPosition;
+    ma_uint8 dataChunkId[4];
+    ma_uint32 chunkStart;
+    ma_uint32 blockStart;
+    ma_uint32 sampleOffset;
+} ma_dr_wav_cue_point;
+typedef struct
+{
+    ma_uint32 cuePointCount;
+    ma_dr_wav_cue_point *pCuePoints;
+} ma_dr_wav_cue;
+typedef enum
+{
+    ma_dr_wav_acid_flag_one_shot      = 1,
+    ma_dr_wav_acid_flag_root_note_set = 2,
+    ma_dr_wav_acid_flag_stretch       = 4,
+    ma_dr_wav_acid_flag_disk_based    = 8,
+    ma_dr_wav_acid_flag_acidizer      = 16
+} ma_dr_wav_acid_flag;
+typedef struct
+{
+    ma_uint32 flags;
+    ma_uint16 midiUnityNote;
+    ma_uint16 reserved1;
+    float reserved2;
+    ma_uint32 numBeats;
+    ma_uint16 meterDenominator;
+    ma_uint16 meterNumerator;
+    float tempo;
+} ma_dr_wav_acid;
+typedef struct
+{
+    ma_uint32 cuePointId;
+    ma_uint32 stringLength;
+    char* pString;
+} ma_dr_wav_list_label_or_note;
+typedef struct
+{
+    char* pDescription;
+    char* pOriginatorName;
+    char* pOriginatorReference;
+    char  pOriginationDate[10];
+    char  pOriginationTime[8];
+    ma_uint64 timeReference;
+    ma_uint16 version;
+    char* pCodingHistory;
+    ma_uint32 codingHistorySize;
+    ma_uint8* pUMID;
+    ma_uint16 loudnessValue;
+    ma_uint16 loudnessRange;
+    ma_uint16 maxTruePeakLevel;
+    ma_uint16 maxMomentaryLoudness;
+    ma_uint16 maxShortTermLoudness;
+} ma_dr_wav_bext;
+typedef struct
+{
+    ma_uint32 stringLength;
+    char* pString;
+} ma_dr_wav_list_info_text;
+typedef struct
+{
+    ma_uint32 cuePointId;
+    ma_uint32 sampleLength;
+    ma_uint8 purposeId[4];
+    ma_uint16 country;
+    ma_uint16 language;
+    ma_uint16 dialect;
+    ma_uint16 codePage;
+    ma_uint32 stringLength;
+    char* pString;
+} ma_dr_wav_list_labelled_cue_region;
+typedef enum
+{
+    ma_dr_wav_metadata_location_invalid,
+    ma_dr_wav_metadata_location_top_level,
+    ma_dr_wav_metadata_location_inside_info_list,
+    ma_dr_wav_metadata_location_inside_adtl_list
+} ma_dr_wav_metadata_location;
+typedef struct
+{
+    ma_uint8 id[4];
+    ma_dr_wav_metadata_location chunkLocation;
+    ma_uint32 dataSizeInBytes;
+    ma_uint8* pData;
+} ma_dr_wav_unknown_metadata;
+typedef struct
+{
+    ma_dr_wav_metadata_type type;
+    union
+    {
+        ma_dr_wav_cue cue;
+        ma_dr_wav_smpl smpl;
+        ma_dr_wav_acid acid;
+        ma_dr_wav_inst inst;
+        ma_dr_wav_bext bext;
+        ma_dr_wav_list_label_or_note labelOrNote;
+        ma_dr_wav_list_labelled_cue_region labelledCueRegion;
+        ma_dr_wav_list_info_text infoText;
+        ma_dr_wav_unknown_metadata unknown;
+    } data;
+} ma_dr_wav_metadata;
+typedef struct
+{
+    ma_dr_wav_read_proc onRead;
+    ma_dr_wav_write_proc onWrite;
+    ma_dr_wav_seek_proc onSeek;
+    ma_dr_wav_tell_proc onTell;
+    void* pUserData;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_dr_wav_container container;
+    ma_dr_wav_fmt fmt;
+    ma_uint32 sampleRate;
+    ma_uint16 channels;
+    ma_uint16 bitsPerSample;
+    ma_uint16 translatedFormatTag;
+    ma_uint64 totalPCMFrameCount;
+    ma_uint64 dataChunkDataSize;
+    ma_uint64 dataChunkDataPos;
+    ma_uint64 bytesRemaining;
+    ma_uint64 readCursorInPCMFrames;
+    ma_uint64 dataChunkDataSizeTargetWrite;
+    ma_bool32 isSequentialWrite;
+    ma_dr_wav_metadata* pMetadata;
+    ma_uint32 metadataCount;
+    ma_dr_wav__memory_stream memoryStream;
+    ma_dr_wav__memory_stream_write memoryStreamWrite;
+    struct
+    {
+        ma_uint32 bytesRemainingInBlock;
+        ma_uint16 predictor[2];
+        ma_int32  delta[2];
+        ma_int32  cachedFrames[4];
+        ma_uint32 cachedFrameCount;
+        ma_int32  prevFrames[2][2];
+    } msadpcm;
+    struct
+    {
+        ma_uint32 bytesRemainingInBlock;
+        ma_int32  predictor[2];
+        ma_int32  stepIndex[2];
+        ma_int32  cachedFrames[16];
+        ma_uint32 cachedFrameCount;
+    } ima;
+    struct
+    {
+        ma_bool8 isLE;
+        ma_bool8 isUnsigned;
+    } aiff;
+} ma_dr_wav;
+MA_API ma_bool32 ma_dr_wav_init(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_ex(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, ma_dr_wav_chunk_proc onChunk, void* pReadSeekTellUserData, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_with_metadata(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_write(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_write_sequential(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_dr_wav_write_proc onWrite, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_write_sequential_pcm_frames(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, ma_dr_wav_write_proc onWrite, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_write_with_metadata(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount);
+MA_API ma_uint64 ma_dr_wav_target_write_size_bytes(const ma_dr_wav_data_format* pFormat, ma_uint64 totalFrameCount, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount);
+MA_API ma_dr_wav_metadata* ma_dr_wav_take_ownership_of_metadata(ma_dr_wav* pWav);
+MA_API ma_result ma_dr_wav_uninit(ma_dr_wav* pWav);
+MA_API size_t ma_dr_wav_read_raw(ma_dr_wav* pWav, size_t bytesToRead, void* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_le(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_be(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut);
+MA_API ma_bool32 ma_dr_wav_seek_to_pcm_frame(ma_dr_wav* pWav, ma_uint64 targetFrameIndex);
+MA_API ma_result ma_dr_wav_get_cursor_in_pcm_frames(ma_dr_wav* pWav, ma_uint64* pCursor);
+MA_API ma_result ma_dr_wav_get_length_in_pcm_frames(ma_dr_wav* pWav, ma_uint64* pLength);
+MA_API size_t ma_dr_wav_write_raw(ma_dr_wav* pWav, size_t bytesToWrite, const void* pData);
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData);
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames_le(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData);
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames_be(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData);
+#ifndef MA_DR_WAV_NO_CONVERSION_API
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16le(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16be(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API void ma_dr_wav_u8_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s24_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s32_to_s16(ma_int16* pOut, const ma_int32* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f32_to_s16(ma_int16* pOut, const float* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f64_to_s16(ma_int16* pOut, const double* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_alaw_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_mulaw_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32le(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32be(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut);
+MA_API void ma_dr_wav_u8_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s16_to_f32(float* pOut, const ma_int16* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s24_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s32_to_f32(float* pOut, const ma_int32* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_alaw_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_mulaw_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32le(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32be(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut);
+MA_API void ma_dr_wav_u8_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s16_to_s32(ma_int32* pOut, const ma_int16* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s24_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f32_to_s32(ma_int32* pOut, const float* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f64_to_s32(ma_int32* pOut, const double* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_alaw_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_mulaw_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount);
+#endif
+#ifndef MA_DR_WAV_NO_STDIO
+MA_API ma_bool32 ma_dr_wav_init_file(ma_dr_wav* pWav, const char* filename, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_ex(ma_dr_wav* pWav, const char* filename, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_ex_w(ma_dr_wav* pWav, const wchar_t* filename, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_with_metadata(ma_dr_wav* pWav, const char* filename, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_with_metadata_w(ma_dr_wav* pWav, const wchar_t* filename, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_pcm_frames(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_pcm_frames_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API ma_bool32 ma_dr_wav_init_memory(ma_dr_wav* pWav, const void* data, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_ex(ma_dr_wav* pWav, const void* data, size_t dataSize, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_with_metadata(ma_dr_wav* pWav, const void* data, size_t dataSize, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_write(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_write_sequential(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_write_sequential_pcm_frames(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_WAV_NO_CONVERSION_API
+MA_API ma_int16* ma_dr_wav_open_and_read_pcm_frames_s16(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_wav_open_and_read_pcm_frames_f32(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_wav_open_and_read_pcm_frames_s32(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_WAV_NO_STDIO
+MA_API ma_int16* ma_dr_wav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_wav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_wav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_wav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_wav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_wav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API ma_int16* ma_dr_wav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_wav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_wav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API void ma_dr_wav_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_uint16 ma_dr_wav_bytes_to_u16(const ma_uint8* data);
+MA_API ma_int16 ma_dr_wav_bytes_to_s16(const ma_uint8* data);
+MA_API ma_uint32 ma_dr_wav_bytes_to_u32(const ma_uint8* data);
+MA_API ma_int32 ma_dr_wav_bytes_to_s32(const ma_uint8* data);
+MA_API ma_uint64 ma_dr_wav_bytes_to_u64(const ma_uint8* data);
+MA_API ma_int64 ma_dr_wav_bytes_to_s64(const ma_uint8* data);
+MA_API float ma_dr_wav_bytes_to_f32(const ma_uint8* data);
+MA_API ma_bool32 ma_dr_wav_guid_equal(const ma_uint8 a[16], const ma_uint8 b[16]);
+MA_API ma_bool32 ma_dr_wav_fourcc_equal(const ma_uint8* a, const char* b);
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* dr_wav_h end */
+#endif  /* MA_NO_WAV */
+
+#if !defined(MA_NO_FLAC) && !defined(MA_NO_DECODING)
+/* dr_flac_h begin */
+#ifndef ma_dr_flac_h
+#define ma_dr_flac_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define MA_DR_FLAC_STRINGIFY(x)      #x
+#define MA_DR_FLAC_XSTRINGIFY(x)     MA_DR_FLAC_STRINGIFY(x)
+#define MA_DR_FLAC_VERSION_MAJOR     0
+#define MA_DR_FLAC_VERSION_MINOR     13
+#define MA_DR_FLAC_VERSION_REVISION  1
+#define MA_DR_FLAC_VERSION_STRING    MA_DR_FLAC_XSTRINGIFY(MA_DR_FLAC_VERSION_MAJOR) "." MA_DR_FLAC_XSTRINGIFY(MA_DR_FLAC_VERSION_MINOR) "." MA_DR_FLAC_XSTRINGIFY(MA_DR_FLAC_VERSION_REVISION)
+#include <stddef.h>
+#if defined(_MSC_VER) && _MSC_VER >= 1700
+    #define MA_DR_FLAC_DEPRECATED       __declspec(deprecated)
+#elif (defined(__GNUC__) && __GNUC__ >= 4)
+    #define MA_DR_FLAC_DEPRECATED       __attribute__((deprecated))
+#elif defined(__has_feature)
+    #if __has_feature(attribute_deprecated)
+        #define MA_DR_FLAC_DEPRECATED   __attribute__((deprecated))
+    #else
+        #define MA_DR_FLAC_DEPRECATED
+    #endif
+#else
+    #define MA_DR_FLAC_DEPRECATED
+#endif
+MA_API void ma_dr_flac_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
+MA_API const char* ma_dr_flac_version_string(void);
+#ifndef MA_DR_FLAC_BUFFER_SIZE
+#define MA_DR_FLAC_BUFFER_SIZE   4096
+#endif
+#ifdef MA_64BIT
+typedef ma_uint64 ma_dr_flac_cache_t;
+#else
+typedef ma_uint32 ma_dr_flac_cache_t;
+#endif
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO       0
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_PADDING          1
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_APPLICATION      2
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_SEEKTABLE        3
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT   4
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_CUESHEET         5
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_PICTURE          6
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_INVALID          127
+#define MA_DR_FLAC_PICTURE_TYPE_OTHER                   0
+#define MA_DR_FLAC_PICTURE_TYPE_FILE_ICON               1
+#define MA_DR_FLAC_PICTURE_TYPE_OTHER_FILE_ICON         2
+#define MA_DR_FLAC_PICTURE_TYPE_COVER_FRONT             3
+#define MA_DR_FLAC_PICTURE_TYPE_COVER_BACK              4
+#define MA_DR_FLAC_PICTURE_TYPE_LEAFLET_PAGE            5
+#define MA_DR_FLAC_PICTURE_TYPE_MEDIA                   6
+#define MA_DR_FLAC_PICTURE_TYPE_LEAD_ARTIST             7
+#define MA_DR_FLAC_PICTURE_TYPE_ARTIST                  8
+#define MA_DR_FLAC_PICTURE_TYPE_CONDUCTOR               9
+#define MA_DR_FLAC_PICTURE_TYPE_BAND                    10
+#define MA_DR_FLAC_PICTURE_TYPE_COMPOSER                11
+#define MA_DR_FLAC_PICTURE_TYPE_LYRICIST                12
+#define MA_DR_FLAC_PICTURE_TYPE_RECORDING_LOCATION      13
+#define MA_DR_FLAC_PICTURE_TYPE_DURING_RECORDING        14
+#define MA_DR_FLAC_PICTURE_TYPE_DURING_PERFORMANCE      15
+#define MA_DR_FLAC_PICTURE_TYPE_SCREEN_CAPTURE          16
+#define MA_DR_FLAC_PICTURE_TYPE_BRIGHT_COLORED_FISH     17
+#define MA_DR_FLAC_PICTURE_TYPE_ILLUSTRATION            18
+#define MA_DR_FLAC_PICTURE_TYPE_BAND_LOGOTYPE           19
+#define MA_DR_FLAC_PICTURE_TYPE_PUBLISHER_LOGOTYPE      20
+typedef enum
+{
+    ma_dr_flac_container_native,
+    ma_dr_flac_container_ogg,
+    ma_dr_flac_container_unknown
+} ma_dr_flac_container;
+typedef enum
+{
+    MA_DR_FLAC_SEEK_SET,
+    MA_DR_FLAC_SEEK_CUR,
+    MA_DR_FLAC_SEEK_END
+} ma_dr_flac_seek_origin;
+typedef struct
+{
+    ma_uint64 firstPCMFrame;
+    ma_uint64 flacFrameOffset;
+    ma_uint16 pcmFrameCount;
+} ma_dr_flac_seekpoint;
+typedef struct
+{
+    ma_uint16 minBlockSizeInPCMFrames;
+    ma_uint16 maxBlockSizeInPCMFrames;
+    ma_uint32 minFrameSizeInPCMFrames;
+    ma_uint32 maxFrameSizeInPCMFrames;
+    ma_uint32 sampleRate;
+    ma_uint8  channels;
+    ma_uint8  bitsPerSample;
+    ma_uint64 totalPCMFrameCount;
+    ma_uint8  md5[16];
+} ma_dr_flac_streaminfo;
+typedef struct
+{
+    ma_uint32 type;
+    const void* pRawData;
+    ma_uint32 rawDataSize;
+    union
+    {
+        ma_dr_flac_streaminfo streaminfo;
+        struct
+        {
+            int unused;
+        } padding;
+        struct
+        {
+            ma_uint32 id;
+            const void* pData;
+            ma_uint32 dataSize;
+        } application;
+        struct
+        {
+            ma_uint32 seekpointCount;
+            const ma_dr_flac_seekpoint* pSeekpoints;
+        } seektable;
+        struct
+        {
+            ma_uint32 vendorLength;
+            const char* vendor;
+            ma_uint32 commentCount;
+            const void* pComments;
+        } vorbis_comment;
+        struct
+        {
+            char catalog[128];
+            ma_uint64 leadInSampleCount;
+            ma_bool32 isCD;
+            ma_uint8 trackCount;
+            const void* pTrackData;
+        } cuesheet;
+        struct
+        {
+            ma_uint32 type;
+            ma_uint32 mimeLength;
+            const char* mime;
+            ma_uint32 descriptionLength;
+            const char* description;
+            ma_uint32 width;
+            ma_uint32 height;
+            ma_uint32 colorDepth;
+            ma_uint32 indexColorCount;
+            ma_uint32 pictureDataSize;
+            const ma_uint8* pPictureData;
+        } picture;
+    } data;
+} ma_dr_flac_metadata;
+typedef size_t (* ma_dr_flac_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
+typedef ma_bool32 (* ma_dr_flac_seek_proc)(void* pUserData, int offset, ma_dr_flac_seek_origin origin);
+typedef ma_bool32 (* ma_dr_flac_tell_proc)(void* pUserData, ma_int64* pCursor);
+typedef void (* ma_dr_flac_meta_proc)(void* pUserData, ma_dr_flac_metadata* pMetadata);
+typedef struct
+{
+    const ma_uint8* data;
+    size_t dataSize;
+    size_t currentReadPos;
+} ma_dr_flac__memory_stream;
+typedef struct
+{
+    ma_dr_flac_read_proc onRead;
+    ma_dr_flac_seek_proc onSeek;
+    ma_dr_flac_tell_proc onTell;
+    void* pUserData;
+    size_t unalignedByteCount;
+    ma_dr_flac_cache_t unalignedCache;
+    ma_uint32 nextL2Line;
+    ma_uint32 consumedBits;
+    ma_dr_flac_cache_t cacheL2[MA_DR_FLAC_BUFFER_SIZE/sizeof(ma_dr_flac_cache_t)];
+    ma_dr_flac_cache_t cache;
+    ma_uint16 crc16;
+    ma_dr_flac_cache_t crc16Cache;
+    ma_uint32 crc16CacheIgnoredBytes;
+} ma_dr_flac_bs;
+typedef struct
+{
+    ma_uint8 subframeType;
+    ma_uint8 wastedBitsPerSample;
+    ma_uint8 lpcOrder;
+    ma_int32* pSamplesS32;
+} ma_dr_flac_subframe;
+typedef struct
+{
+    ma_uint64 pcmFrameNumber;
+    ma_uint32 flacFrameNumber;
+    ma_uint32 sampleRate;
+    ma_uint16 blockSizeInPCMFrames;
+    ma_uint8 channelAssignment;
+    ma_uint8 bitsPerSample;
+    ma_uint8 crc8;
+} ma_dr_flac_frame_header;
+typedef struct
+{
+    ma_dr_flac_frame_header header;
+    ma_uint32 pcmFramesRemaining;
+    ma_dr_flac_subframe subframes[8];
+} ma_dr_flac_frame;
+typedef struct
+{
+    ma_dr_flac_meta_proc onMeta;
+    void* pUserDataMD;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_uint32 sampleRate;
+    ma_uint8 channels;
+    ma_uint8 bitsPerSample;
+    ma_uint16 maxBlockSizeInPCMFrames;
+    ma_uint64 totalPCMFrameCount;
+    ma_dr_flac_container container;
+    ma_uint32 seekpointCount;
+    ma_dr_flac_frame currentFLACFrame;
+    ma_uint64 currentPCMFrame;
+    ma_uint64 firstFLACFramePosInBytes;
+    ma_dr_flac__memory_stream memoryStream;
+    ma_int32* pDecodedSamples;
+    ma_dr_flac_seekpoint* pSeekpoints;
+    void* _oggbs;
+    ma_bool32 _noSeekTableSeek    : 1;
+    ma_bool32 _noBinarySearchSeek : 1;
+    ma_bool32 _noBruteForceSeek   : 1;
+    ma_dr_flac_bs bs;
+    ma_uint8 pExtraData[1];
+} ma_dr_flac;
+MA_API ma_dr_flac* ma_dr_flac_open(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_relaxed(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, ma_dr_flac_container container, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_with_metadata(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_with_metadata_relaxed(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, ma_dr_flac_meta_proc onMeta, ma_dr_flac_container container, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API void ma_dr_flac_close(ma_dr_flac* pFlac);
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_s32(ma_dr_flac* pFlac, ma_uint64 framesToRead, ma_int32* pBufferOut);
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_s16(ma_dr_flac* pFlac, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_f32(ma_dr_flac* pFlac, ma_uint64 framesToRead, float* pBufferOut);
+MA_API ma_bool32 ma_dr_flac_seek_to_pcm_frame(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex);
+#ifndef MA_DR_FLAC_NO_STDIO
+MA_API ma_dr_flac* ma_dr_flac_open_file(const char* pFileName, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_file_w(const wchar_t* pFileName, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_file_with_metadata(const char* pFileName, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_file_with_metadata_w(const wchar_t* pFileName, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API ma_dr_flac* ma_dr_flac_open_memory(const void* pData, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_memory_with_metadata(const void* pData, size_t dataSize, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_flac_open_and_read_pcm_frames_s32(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, void* pUserData, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_flac_open_and_read_pcm_frames_s16(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, void* pUserData, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_flac_open_and_read_pcm_frames_f32(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, void* pUserData, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_FLAC_NO_STDIO
+MA_API ma_int32* ma_dr_flac_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_flac_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_flac_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API ma_int32* ma_dr_flac_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_flac_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_flac_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API void ma_dr_flac_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+typedef struct
+{
+    ma_uint32 countRemaining;
+    const char* pRunningData;
+} ma_dr_flac_vorbis_comment_iterator;
+MA_API void ma_dr_flac_init_vorbis_comment_iterator(ma_dr_flac_vorbis_comment_iterator* pIter, ma_uint32 commentCount, const void* pComments);
+MA_API const char* ma_dr_flac_next_vorbis_comment(ma_dr_flac_vorbis_comment_iterator* pIter, ma_uint32* pCommentLengthOut);
+typedef struct
+{
+    ma_uint32 countRemaining;
+    const char* pRunningData;
+} ma_dr_flac_cuesheet_track_iterator;
+typedef struct
+{
+    ma_uint64 offset;
+    ma_uint8 index;
+    ma_uint8 reserved[3];
+} ma_dr_flac_cuesheet_track_index;
+typedef struct
+{
+    ma_uint64 offset;
+    ma_uint8 trackNumber;
+    char ISRC[12];
+    ma_bool8 isAudio;
+    ma_bool8 preEmphasis;
+    ma_uint8 indexCount;
+    const ma_dr_flac_cuesheet_track_index* pIndexPoints;
+} ma_dr_flac_cuesheet_track;
+MA_API void ma_dr_flac_init_cuesheet_track_iterator(ma_dr_flac_cuesheet_track_iterator* pIter, ma_uint32 trackCount, const void* pTrackData);
+MA_API ma_bool32 ma_dr_flac_next_cuesheet_track(ma_dr_flac_cuesheet_track_iterator* pIter, ma_dr_flac_cuesheet_track* pCuesheetTrack);
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* dr_flac_h end */
+#endif  /* MA_NO_FLAC */
+
+#if !defined(MA_NO_MP3) && !defined(MA_NO_DECODING)
+#ifndef MA_DR_MP3_NO_SIMD
+    #if (defined(MA_NO_NEON) && defined(MA_ARM)) || (defined(MA_NO_SSE2) && (defined(MA_X86) || defined(MA_X64)))
+    #define MA_DR_MP3_NO_SIMD
+    #endif
+#endif
+
+/* dr_mp3_h begin */
+#ifndef ma_dr_mp3_h
+#define ma_dr_mp3_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define MA_DR_MP3_STRINGIFY(x)      #x
+#define MA_DR_MP3_XSTRINGIFY(x)     MA_DR_MP3_STRINGIFY(x)
+#define MA_DR_MP3_VERSION_MAJOR     0
+#define MA_DR_MP3_VERSION_MINOR     7
+#define MA_DR_MP3_VERSION_REVISION  1
+#define MA_DR_MP3_VERSION_STRING    MA_DR_MP3_XSTRINGIFY(MA_DR_MP3_VERSION_MAJOR) "." MA_DR_MP3_XSTRINGIFY(MA_DR_MP3_VERSION_MINOR) "." MA_DR_MP3_XSTRINGIFY(MA_DR_MP3_VERSION_REVISION)
+#include <stddef.h>
+#define MA_DR_MP3_MAX_PCM_FRAMES_PER_MP3_FRAME  1152
+#define MA_DR_MP3_MAX_SAMPLES_PER_FRAME         (MA_DR_MP3_MAX_PCM_FRAMES_PER_MP3_FRAME*2)
+MA_API void ma_dr_mp3_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
+MA_API const char* ma_dr_mp3_version_string(void);
+typedef struct
+{
+    int frame_bytes, channels, sample_rate, layer, bitrate_kbps;
+} ma_dr_mp3dec_frame_info;
+typedef struct
+{
+    float mdct_overlap[2][9*32], qmf_state[15*2*32];
+    int reserv, free_format_bytes;
+    ma_uint8 header[4], reserv_buf[511];
+} ma_dr_mp3dec;
+MA_API void ma_dr_mp3dec_init(ma_dr_mp3dec *dec);
+MA_API int ma_dr_mp3dec_decode_frame(ma_dr_mp3dec *dec, const ma_uint8 *mp3, int mp3_bytes, void *pcm, ma_dr_mp3dec_frame_info *info);
+MA_API void ma_dr_mp3dec_f32_to_s16(const float *in, ma_int16 *out, size_t num_samples);
+typedef enum
+{
+    MA_DR_MP3_SEEK_SET,
+    MA_DR_MP3_SEEK_CUR,
+    MA_DR_MP3_SEEK_END
+} ma_dr_mp3_seek_origin;
+typedef struct
+{
+    ma_uint64 seekPosInBytes;
+    ma_uint64 pcmFrameIndex;
+    ma_uint16 mp3FramesToDiscard;
+    ma_uint16 pcmFramesToDiscard;
+} ma_dr_mp3_seek_point;
+typedef enum
+{
+    MA_DR_MP3_METADATA_TYPE_ID3V1,
+    MA_DR_MP3_METADATA_TYPE_ID3V2,
+    MA_DR_MP3_METADATA_TYPE_APE,
+    MA_DR_MP3_METADATA_TYPE_XING,
+    MA_DR_MP3_METADATA_TYPE_VBRI
+} ma_dr_mp3_metadata_type;
+typedef struct
+{
+    ma_dr_mp3_metadata_type type;
+    const void* pRawData;
+    size_t rawDataSize;
+} ma_dr_mp3_metadata;
+typedef size_t (* ma_dr_mp3_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
+typedef ma_bool32 (* ma_dr_mp3_seek_proc)(void* pUserData, int offset, ma_dr_mp3_seek_origin origin);
+typedef ma_bool32 (* ma_dr_mp3_tell_proc)(void* pUserData, ma_int64* pCursor);
+typedef void (* ma_dr_mp3_meta_proc)(void* pUserData, const ma_dr_mp3_metadata* pMetadata);
+typedef struct
+{
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+} ma_dr_mp3_config;
+typedef struct
+{
+    ma_dr_mp3dec decoder;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_dr_mp3_read_proc onRead;
+    ma_dr_mp3_seek_proc onSeek;
+    ma_dr_mp3_meta_proc onMeta;
+    void* pUserData;
+    void* pUserDataMeta;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_uint32 mp3FrameChannels;
+    ma_uint32 mp3FrameSampleRate;
+    ma_uint32 pcmFramesConsumedInMP3Frame;
+    ma_uint32 pcmFramesRemainingInMP3Frame;
+    ma_uint8 pcmFrames[sizeof(float)*MA_DR_MP3_MAX_SAMPLES_PER_FRAME];
+    ma_uint64 currentPCMFrame;
+    ma_uint64 streamCursor;
+    ma_uint64 streamLength;
+    ma_uint64 streamStartOffset;
+    ma_dr_mp3_seek_point* pSeekPoints;
+    ma_uint32 seekPointCount;
+    ma_uint32 delayInPCMFrames;
+    ma_uint32 paddingInPCMFrames;
+    ma_uint64 totalPCMFrameCount;
+    ma_bool32 isVBR;
+    ma_bool32 isCBR;
+    size_t dataSize;
+    size_t dataCapacity;
+    size_t dataConsumed;
+    ma_uint8* pData;
+    ma_bool32 atEnd;
+    struct
+    {
+        const ma_uint8* pData;
+        size_t dataSize;
+        size_t currentReadPos;
+    } memory;
+} ma_dr_mp3;
+MA_API ma_bool32 ma_dr_mp3_init(ma_dr_mp3* pMP3, ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, ma_dr_mp3_tell_proc onTell, ma_dr_mp3_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_mp3_init_memory_with_metadata(ma_dr_mp3* pMP3, const void* pData, size_t dataSize, ma_dr_mp3_meta_proc onMeta, void* pUserDataMeta, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_mp3_init_memory(ma_dr_mp3* pMP3, const void* pData, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_MP3_NO_STDIO
+MA_API ma_bool32 ma_dr_mp3_init_file_with_metadata(ma_dr_mp3* pMP3, const char* pFilePath, ma_dr_mp3_meta_proc onMeta, void* pUserDataMeta, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_mp3_init_file_with_metadata_w(ma_dr_mp3* pMP3, const wchar_t* pFilePath, ma_dr_mp3_meta_proc onMeta, void* pUserDataMeta, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_mp3_init_file(ma_dr_mp3* pMP3, const char* pFilePath, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_mp3_init_file_w(ma_dr_mp3* pMP3, const wchar_t* pFilePath, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API void ma_dr_mp3_uninit(ma_dr_mp3* pMP3);
+MA_API ma_uint64 ma_dr_mp3_read_pcm_frames_f32(ma_dr_mp3* pMP3, ma_uint64 framesToRead, float* pBufferOut);
+MA_API ma_uint64 ma_dr_mp3_read_pcm_frames_s16(ma_dr_mp3* pMP3, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API ma_bool32 ma_dr_mp3_seek_to_pcm_frame(ma_dr_mp3* pMP3, ma_uint64 frameIndex);
+MA_API ma_uint64 ma_dr_mp3_get_pcm_frame_count(ma_dr_mp3* pMP3);
+MA_API ma_uint64 ma_dr_mp3_get_mp3_frame_count(ma_dr_mp3* pMP3);
+MA_API ma_bool32 ma_dr_mp3_get_mp3_and_pcm_frame_count(ma_dr_mp3* pMP3, ma_uint64* pMP3FrameCount, ma_uint64* pPCMFrameCount);
+MA_API ma_bool32 ma_dr_mp3_calculate_seek_points(ma_dr_mp3* pMP3, ma_uint32* pSeekPointCount, ma_dr_mp3_seek_point* pSeekPoints);
+MA_API ma_bool32 ma_dr_mp3_bind_seek_table(ma_dr_mp3* pMP3, ma_uint32 seekPointCount, ma_dr_mp3_seek_point* pSeekPoints);
+MA_API float* ma_dr_mp3_open_and_read_pcm_frames_f32(ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, ma_dr_mp3_tell_proc onTell, void* pUserData, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_mp3_open_and_read_pcm_frames_s16(ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, ma_dr_mp3_tell_proc onTell, void* pUserData, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_mp3_open_memory_and_read_pcm_frames_f32(const void* pData, size_t dataSize, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_mp3_open_memory_and_read_pcm_frames_s16(const void* pData, size_t dataSize, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_MP3_NO_STDIO
+MA_API float* ma_dr_mp3_open_file_and_read_pcm_frames_f32(const char* filePath, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_mp3_open_file_and_read_pcm_frames_s16(const char* filePath, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API void* ma_dr_mp3_malloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API void ma_dr_mp3_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* dr_mp3_h end */
+#endif  /* MA_NO_MP3 */
+
+
+/**************************************************************************************************************************************************************
+
+Decoding
+
+**************************************************************************************************************************************************************/
+#ifndef MA_NO_DECODING
+
+static ma_result ma_decoder_read_bytes(ma_decoder* pDecoder, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    return pDecoder->onRead(pDecoder, pBufferOut, bytesToRead, pBytesRead);
+}
+
+static ma_result ma_decoder_seek_bytes(ma_decoder* pDecoder, ma_int64 byteOffset, ma_seek_origin origin)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    return pDecoder->onSeek(pDecoder, byteOffset, origin);
+}
+
+static ma_result ma_decoder_tell_bytes(ma_decoder* pDecoder, ma_int64* pCursor)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pDecoder->onTell == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pDecoder->onTell(pDecoder, pCursor);
+}
+
+
+MA_API ma_decoding_backend_config ma_decoding_backend_config_init(ma_format preferredFormat, ma_uint32 seekPointCount)
+{
+    ma_decoding_backend_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.preferredFormat = preferredFormat;
+    config.seekPointCount  = seekPointCount;
+
+    return config;
+}
+
+
+MA_API ma_decoder_config ma_decoder_config_init(ma_format outputFormat, ma_uint32 outputChannels, ma_uint32 outputSampleRate)
+{
+    ma_decoder_config config;
+    MA_ZERO_OBJECT(&config);
+    config.format         = outputFormat;
+    config.channels       = outputChannels;
+    config.sampleRate     = outputSampleRate;
+    config.resampling     = ma_resampler_config_init(ma_format_unknown, 0, 0, 0, ma_resample_algorithm_linear); /* Format/channels/rate doesn't matter here. */
+    config.encodingFormat = ma_encoding_format_unknown;
+
+    /* Note that we are intentionally leaving the channel map empty here which will cause the default channel map to be used. */
+
+    return config;
+}
+
+MA_API ma_decoder_config ma_decoder_config_init_default(void)
+{
+    return ma_decoder_config_init(ma_format_unknown, 0, 0);
+}
+
+MA_API ma_decoder_config ma_decoder_config_init_copy(const ma_decoder_config* pConfig)
+{
+    ma_decoder_config config;
+    if (pConfig != NULL) {
+        config = *pConfig;
+    } else {
+        MA_ZERO_OBJECT(&config);
+    }
+
+    return config;
+}
+
+static ma_result ma_decoder__init_data_converter(ma_decoder* pDecoder, const ma_decoder_config* pConfig)
+{
+    ma_result result;
+    ma_data_converter_config converterConfig;
+    ma_format internalFormat;
+    ma_uint32 internalChannels;
+    ma_uint32 internalSampleRate;
+    ma_channel internalChannelMap[MA_MAX_CHANNELS];
+
+    MA_ASSERT(pDecoder != NULL);
+    MA_ASSERT(pConfig  != NULL);
+
+    result = ma_data_source_get_data_format(pDecoder->pBackend, &internalFormat, &internalChannels, &internalSampleRate, internalChannelMap, ma_countof(internalChannelMap));
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the internal data format. */
+    }
+
+
+    /* Make sure we're not asking for too many channels. */
+    if (pConfig->channels > MA_MAX_CHANNELS) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The internal channels should have already been validated at a higher level, but we'll do it again explicitly here for safety. */
+    if (internalChannels > MA_MAX_CHANNELS) {
+        return MA_INVALID_ARGS;
+    }
+
+
+    /* Output format. */
+    if (pConfig->format == ma_format_unknown) {
+        pDecoder->outputFormat = internalFormat;
+    } else {
+        pDecoder->outputFormat = pConfig->format;
+    }
+
+    if (pConfig->channels == 0) {
+        pDecoder->outputChannels = internalChannels;
+    } else {
+        pDecoder->outputChannels = pConfig->channels;
+    }
+
+    if (pConfig->sampleRate == 0) {
+        pDecoder->outputSampleRate = internalSampleRate;
+    } else {
+        pDecoder->outputSampleRate = pConfig->sampleRate;
+    }
+
+    converterConfig = ma_data_converter_config_init(
+        internalFormat,     pDecoder->outputFormat,
+        internalChannels,   pDecoder->outputChannels,
+        internalSampleRate, pDecoder->outputSampleRate
+    );
+    converterConfig.pChannelMapIn          = internalChannelMap;
+    converterConfig.pChannelMapOut         = pConfig->pChannelMap;
+    converterConfig.channelMixMode         = pConfig->channelMixMode;
+    converterConfig.ditherMode             = pConfig->ditherMode;
+    converterConfig.allowDynamicSampleRate = MA_FALSE;   /* Never allow dynamic sample rate conversion. Setting this to true will disable passthrough optimizations. */
+    converterConfig.resampling             = pConfig->resampling;
+
+    result = ma_data_converter_init(&converterConfig, &pDecoder->allocationCallbacks, &pDecoder->converter);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /*
+    Now that we have the decoder we need to determine whether or not we need a heap-allocated cache. We'll
+    need this if the data converter does not support calculation of the required input frame count. To
+    determine support for this we'll just run a test.
+    */
+    {
+        ma_uint64 unused;
+
+        result = ma_data_converter_get_required_input_frame_count(&pDecoder->converter, 1, &unused);
+        if (result != MA_SUCCESS) {
+            /*
+            We were unable to calculate the required input frame count which means we'll need to use
+            a heap-allocated cache.
+            */
+            ma_uint64 inputCacheCapSizeInBytes;
+
+            pDecoder->inputCacheCap = MA_DATA_CONVERTER_STACK_BUFFER_SIZE / ma_get_bytes_per_frame(internalFormat, internalChannels);
+
+            /* Not strictly necessary, but keeping here for safety in case we change the default value of pDecoder->inputCacheCap. */
+            inputCacheCapSizeInBytes = pDecoder->inputCacheCap * ma_get_bytes_per_frame(internalFormat, internalChannels);
+            if (inputCacheCapSizeInBytes > MA_SIZE_MAX) {
+                ma_data_converter_uninit(&pDecoder->converter, &pDecoder->allocationCallbacks);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            pDecoder->pInputCache = ma_malloc((size_t)inputCacheCapSizeInBytes, &pDecoder->allocationCallbacks);    /* Safe cast to size_t. */
+            if (pDecoder->pInputCache == NULL) {
+                ma_data_converter_uninit(&pDecoder->converter, &pDecoder->allocationCallbacks);
+                return MA_OUT_OF_MEMORY;
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+static ma_result ma_decoder_internal_on_read__custom(void* pUserData, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead)
+{
+    ma_decoder* pDecoder = (ma_decoder*)pUserData;
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_decoder_read_bytes(pDecoder, pBufferOut, bytesToRead, pBytesRead);
+}
+
+static ma_result ma_decoder_internal_on_seek__custom(void* pUserData, ma_int64 offset, ma_seek_origin origin)
+{
+    ma_decoder* pDecoder = (ma_decoder*)pUserData;
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_decoder_seek_bytes(pDecoder, offset, origin);
+}
+
+static ma_result ma_decoder_internal_on_tell__custom(void* pUserData, ma_int64* pCursor)
+{
+    ma_decoder* pDecoder = (ma_decoder*)pUserData;
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_decoder_tell_bytes(pDecoder, pCursor);
+}
+
+
+static ma_result ma_decoder_init_from_vtable__internal(const ma_decoding_backend_vtable* pVTable, void* pVTableUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoding_backend_config backendConfig;
+    ma_data_source* pBackend;
+
+    MA_ASSERT(pVTable  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pVTable->onInit == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    backendConfig = ma_decoding_backend_config_init(pConfig->format, pConfig->seekPointCount);
+
+    result = pVTable->onInit(pVTableUserData, ma_decoder_internal_on_read__custom, ma_decoder_internal_on_seek__custom, ma_decoder_internal_on_tell__custom, pDecoder, &backendConfig, &pDecoder->allocationCallbacks, &pBackend);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the backend from this vtable. */
+    }
+
+    /* Getting here means we were able to initialize the backend so we can now initialize the decoder. */
+    pDecoder->pBackend         = pBackend;
+    pDecoder->pBackendVTable   = pVTable;
+    pDecoder->pBackendUserData = pConfig->pCustomBackendUserData;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder_init_from_file__internal(const ma_decoding_backend_vtable* pVTable, void* pVTableUserData, const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoding_backend_config backendConfig;
+    ma_data_source* pBackend;
+
+    MA_ASSERT(pVTable  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pVTable->onInitFile == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    backendConfig = ma_decoding_backend_config_init(pConfig->format, pConfig->seekPointCount);
+
+    result = pVTable->onInitFile(pVTableUserData, pFilePath, &backendConfig, &pDecoder->allocationCallbacks, &pBackend);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the backend from this vtable. */
+    }
+
+    /* Getting here means we were able to initialize the backend so we can now initialize the decoder. */
+    pDecoder->pBackend         = pBackend;
+    pDecoder->pBackendVTable   = pVTable;
+    pDecoder->pBackendUserData = pConfig->pCustomBackendUserData;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder_init_from_file_w__internal(const ma_decoding_backend_vtable* pVTable, void* pVTableUserData, const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoding_backend_config backendConfig;
+    ma_data_source* pBackend;
+
+    MA_ASSERT(pVTable  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pVTable->onInitFileW == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    backendConfig = ma_decoding_backend_config_init(pConfig->format, pConfig->seekPointCount);
+
+    result = pVTable->onInitFileW(pVTableUserData, pFilePath, &backendConfig, &pDecoder->allocationCallbacks, &pBackend);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the backend from this vtable. */
+    }
+
+    /* Getting here means we were able to initialize the backend so we can now initialize the decoder. */
+    pDecoder->pBackend         = pBackend;
+    pDecoder->pBackendVTable   = pVTable;
+    pDecoder->pBackendUserData = pConfig->pCustomBackendUserData;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder_init_from_memory__internal(const ma_decoding_backend_vtable* pVTable, void* pVTableUserData, const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoding_backend_config backendConfig;
+    ma_data_source* pBackend;
+
+    MA_ASSERT(pVTable  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pVTable->onInitMemory == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    backendConfig = ma_decoding_backend_config_init(pConfig->format, pConfig->seekPointCount);
+
+    result = pVTable->onInitMemory(pVTableUserData, pData, dataSize, &backendConfig, &pDecoder->allocationCallbacks, &pBackend);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the backend from this vtable. */
+    }
+
+    /* Getting here means we were able to initialize the backend so we can now initialize the decoder. */
+    pDecoder->pBackend         = pBackend;
+    pDecoder->pBackendVTable   = pVTable;
+    pDecoder->pBackendUserData = pConfig->pCustomBackendUserData;
+
+    return MA_SUCCESS;
+}
+
+
+
+static ma_result ma_decoder_init_custom__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+    size_t ivtable;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig->ppCustomBackendVTables == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    /* The order each backend is listed is what defines the priority. */
+    for (ivtable = 0; ivtable < pConfig->customBackendCount; ivtable += 1) {
+        const ma_decoding_backend_vtable* pVTable = pConfig->ppCustomBackendVTables[ivtable];
+        if (pVTable != NULL) {
+            result = ma_decoder_init_from_vtable__internal(pVTable, pConfig->pCustomBackendUserData, pConfig, pDecoder);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            } else {
+                /* Initialization failed. Move on to the next one, but seek back to the start first so the next vtable starts from the first byte of the file. */
+                result = ma_decoder_seek_bytes(pDecoder, 0, ma_seek_origin_start);
+                if (result != MA_SUCCESS) {
+                    return result;  /* Failed to seek back to the start. */
+                }
+            }
+        } else {
+            /* No vtable. */
+        }
+    }
+
+    /* Getting here means we couldn't find a backend. */
+    return MA_NO_BACKEND;
+}
+
+static ma_result ma_decoder_init_custom_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+    size_t ivtable;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig->ppCustomBackendVTables == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    /* The order each backend is listed is what defines the priority. */
+    for (ivtable = 0; ivtable < pConfig->customBackendCount; ivtable += 1) {
+        const ma_decoding_backend_vtable* pVTable = pConfig->ppCustomBackendVTables[ivtable];
+        if (pVTable != NULL) {
+            result = ma_decoder_init_from_file__internal(pVTable, pConfig->pCustomBackendUserData, pFilePath, pConfig, pDecoder);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            }
+        } else {
+            /* No vtable. */
+        }
+    }
+
+    /* Getting here means we couldn't find a backend. */
+    return MA_NO_BACKEND;
+}
+
+static ma_result ma_decoder_init_custom_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+    size_t ivtable;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig->ppCustomBackendVTables == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    /* The order each backend is listed is what defines the priority. */
+    for (ivtable = 0; ivtable < pConfig->customBackendCount; ivtable += 1) {
+        const ma_decoding_backend_vtable* pVTable = pConfig->ppCustomBackendVTables[ivtable];
+        if (pVTable != NULL) {
+            result = ma_decoder_init_from_file_w__internal(pVTable, pConfig->pCustomBackendUserData, pFilePath, pConfig, pDecoder);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            }
+        } else {
+            /* No vtable. */
+        }
+    }
+
+    /* Getting here means we couldn't find a backend. */
+    return MA_NO_BACKEND;
+}
+
+static ma_result ma_decoder_init_custom_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+    size_t ivtable;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig->ppCustomBackendVTables == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    /* The order each backend is listed is what defines the priority. */
+    for (ivtable = 0; ivtable < pConfig->customBackendCount; ivtable += 1) {
+        const ma_decoding_backend_vtable* pVTable = pConfig->ppCustomBackendVTables[ivtable];
+        if (pVTable != NULL) {
+            result = ma_decoder_init_from_memory__internal(pVTable, pConfig->pCustomBackendUserData, pData, dataSize, pConfig, pDecoder);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            }
+        } else {
+            /* No vtable. */
+        }
+    }
+
+    /* Getting here means we couldn't find a backend. */
+    return MA_NO_BACKEND;
+}
+
+
+/* WAV */
+#ifdef ma_dr_wav_h
+#define MA_HAS_WAV
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_read_proc onRead;
+    ma_seek_proc onSeek;
+    ma_tell_proc onTell;
+    void* pReadSeekTellUserData;
+    ma_format format;           /* Can be f32, s16 or s32. */
+#if !defined(MA_NO_WAV)
+    ma_dr_wav dr;
+#endif
+} ma_wav;
+
+MA_API ma_result ma_wav_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav);
+MA_API ma_result ma_wav_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav);
+MA_API ma_result ma_wav_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav);
+MA_API ma_result ma_wav_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav);
+MA_API void ma_wav_uninit(ma_wav* pWav, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_wav_read_pcm_frames(ma_wav* pWav, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_wav_seek_to_pcm_frame(ma_wav* pWav, ma_uint64 frameIndex);
+MA_API ma_result ma_wav_get_data_format(ma_wav* pWav, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_wav_get_cursor_in_pcm_frames(ma_wav* pWav, ma_uint64* pCursor);
+MA_API ma_result ma_wav_get_length_in_pcm_frames(ma_wav* pWav, ma_uint64* pLength);
+
+
+static ma_result ma_wav_ds_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_wav_read_pcm_frames((ma_wav*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_wav_ds_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_wav_seek_to_pcm_frame((ma_wav*)pDataSource, frameIndex);
+}
+
+static ma_result ma_wav_ds_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_wav_get_data_format((ma_wav*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_wav_ds_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_wav_get_cursor_in_pcm_frames((ma_wav*)pDataSource, pCursor);
+}
+
+static ma_result ma_wav_ds_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_wav_get_length_in_pcm_frames((ma_wav*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_wav_ds_vtable =
+{
+    ma_wav_ds_read,
+    ma_wav_ds_seek,
+    ma_wav_ds_get_data_format,
+    ma_wav_ds_get_cursor,
+    ma_wav_ds_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+#if !defined(MA_NO_WAV)
+static size_t ma_wav_dr_callback__read(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_wav* pWav = (ma_wav*)pUserData;
+    ma_result result;
+    size_t bytesRead;
+
+    MA_ASSERT(pWav != NULL);
+
+    result = pWav->onRead(pWav->pReadSeekTellUserData, pBufferOut, bytesToRead, &bytesRead);
+    (void)result;
+
+    return bytesRead;
+}
+
+static ma_bool32 ma_wav_dr_callback__seek(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    ma_wav* pWav = (ma_wav*)pUserData;
+    ma_result result;
+    ma_seek_origin maSeekOrigin;
+
+    MA_ASSERT(pWav != NULL);
+
+    maSeekOrigin = ma_seek_origin_start;
+    if (origin == MA_DR_WAV_SEEK_CUR) {
+        maSeekOrigin = ma_seek_origin_current;
+    } else if (origin == MA_DR_WAV_SEEK_END) {
+        maSeekOrigin = ma_seek_origin_end;
+    }
+
+    result = pWav->onSeek(pWav->pReadSeekTellUserData, offset, maSeekOrigin);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+
+    return MA_TRUE;
+}
+
+static ma_bool32 ma_wav_dr_callback__tell(void* pUserData, ma_int64* pCursor)
+{
+    ma_wav* pWav = (ma_wav*)pUserData;
+    ma_result result;
+
+    MA_ASSERT(pWav != NULL);
+    MA_ASSERT(pCursor != NULL);
+
+    if (pWav->onTell == NULL) {
+        return MA_FALSE;  /* Not implemented. */
+    }
+
+    result = pWav->onTell(pWav->pReadSeekTellUserData, pCursor);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;  /* Failed to tell. */
+    }
+
+    return MA_TRUE;
+}
+#endif
+
+static ma_result ma_wav_init_internal(const ma_decoding_backend_config* pConfig, ma_wav* pWav)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pWav);
+    pWav->format = ma_format_unknown;   /* Use closest match to source file by default. */
+
+    if (pConfig != NULL && (pConfig->preferredFormat == ma_format_f32 || pConfig->preferredFormat == ma_format_s16 || pConfig->preferredFormat == ma_format_s32)) {
+        pWav->format = pConfig->preferredFormat;
+    } else {
+        /* Getting here means something other than f32 and s16 was specified. Just leave this unset to use the default format. */
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_wav_ds_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pWav->ds);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base data source. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_wav_post_init(ma_wav* pWav)
+{
+    /*
+    If an explicit format was not specified, try picking the closest match based on the internal
+    format. The format needs to be supported by miniaudio.
+    */
+    if (pWav->format == ma_format_unknown) {
+        switch (pWav->dr.translatedFormatTag)
+        {
+            case MA_DR_WAVE_FORMAT_PCM:
+            {
+                if (pWav->dr.bitsPerSample == 8) {
+                    pWav->format = ma_format_u8;
+                } else if (pWav->dr.bitsPerSample == 16) {
+                    pWav->format = ma_format_s16;
+                } else if (pWav->dr.bitsPerSample == 24) {
+                    pWav->format = ma_format_s24;
+                } else if (pWav->dr.bitsPerSample == 32) {
+                    pWav->format = ma_format_s32;
+                }
+            } break;
+
+            case MA_DR_WAVE_FORMAT_IEEE_FLOAT:
+            {
+                if (pWav->dr.bitsPerSample == 32) {
+                    pWav->format = ma_format_f32;
+                }
+            } break;
+
+            default: break;
+        }
+
+        /* Fall back to f32 if we couldn't find anything. */
+        if (pWav->format == ma_format_unknown) {
+            pWav->format =  ma_format_f32;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_wav_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav)
+{
+    ma_result result;
+
+    result = ma_wav_init_internal(pConfig, pWav);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (onRead == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS; /* onRead and onSeek are mandatory. */
+    }
+
+    pWav->onRead = onRead;
+    pWav->onSeek = onSeek;
+    pWav->onTell = onTell;
+    pWav->pReadSeekTellUserData = pReadSeekTellUserData;
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_init(&pWav->dr, ma_wav_dr_callback__read, ma_wav_dr_callback__seek, ma_wav_dr_callback__tell, pWav, pAllocationCallbacks);
+        if (wavResult != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_wav_post_init(pWav);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. */
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav)
+{
+    ma_result result;
+
+    result = ma_wav_init_internal(pConfig, pWav);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_init_file(&pWav->dr, pFilePath, pAllocationCallbacks);
+        if (wavResult != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_wav_post_init(pWav);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav)
+{
+    ma_result result;
+
+    result = ma_wav_init_internal(pConfig, pWav);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_init_file_w(&pWav->dr, pFilePath, pAllocationCallbacks);
+        if (wavResult != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_wav_post_init(pWav);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav)
+{
+    ma_result result;
+
+    result = ma_wav_init_internal(pConfig, pWav);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_init_memory(&pWav->dr, pData, dataSize, pAllocationCallbacks);
+        if (wavResult != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_wav_post_init(pWav);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. */
+        (void)pData;
+        (void)dataSize;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API void ma_wav_uninit(ma_wav* pWav, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pWav == NULL) {
+        return;
+    }
+
+    (void)pAllocationCallbacks;
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_dr_wav_uninit(&pWav->dr);
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+    }
+    #endif
+
+    ma_data_source_uninit(&pWav->ds);
+}
+
+MA_API ma_result ma_wav_read_pcm_frames(ma_wav* pWav, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        /* We always use floating point format. */
+        ma_result result = MA_SUCCESS;  /* Must be initialized to MA_SUCCESS. */
+        ma_uint64 totalFramesRead = 0;
+        ma_format format;
+
+        ma_wav_get_data_format(pWav, &format, NULL, NULL, NULL, 0);
+
+        switch (format)
+        {
+            case ma_format_f32:
+            {
+                totalFramesRead = ma_dr_wav_read_pcm_frames_f32(&pWav->dr, frameCount, (float*)pFramesOut);
+            } break;
+
+            case ma_format_s16:
+            {
+                totalFramesRead = ma_dr_wav_read_pcm_frames_s16(&pWav->dr, frameCount, (ma_int16*)pFramesOut);
+            } break;
+
+            case ma_format_s32:
+            {
+                totalFramesRead = ma_dr_wav_read_pcm_frames_s32(&pWav->dr, frameCount, (ma_int32*)pFramesOut);
+            } break;
+
+            /* Fallback to a raw read. */
+            case ma_format_unknown: return MA_INVALID_OPERATION; /* <-- this should never be hit because initialization would just fall back to a supported format. */
+            default:
+            {
+                totalFramesRead = ma_dr_wav_read_pcm_frames(&pWav->dr, frameCount, pFramesOut);
+            } break;
+        }
+
+        /* In the future we'll update ma_dr_wav to return MA_AT_END for us. */
+        if (totalFramesRead == 0) {
+            result = MA_AT_END;
+        }
+
+        if (pFramesRead != NULL) {
+            *pFramesRead = totalFramesRead;
+        }
+
+        if (result == MA_SUCCESS && totalFramesRead == 0) {
+            result  = MA_AT_END;
+        }
+
+        return result;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)pFramesRead;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_seek_to_pcm_frame(ma_wav* pWav, ma_uint64 frameIndex)
+{
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_seek_to_pcm_frame(&pWav->dr, frameIndex);
+        if (wavResult != MA_TRUE) {
+            return MA_ERROR;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)frameIndex;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_get_data_format(ma_wav* pWav, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* Defaults for safety. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pWav == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pWav->format;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        if (pChannels != NULL) {
+            *pChannels = pWav->dr.channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pWav->dr.sampleRate;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pChannelMap, channelMapCap, pWav->dr.channels);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_get_cursor_in_pcm_frames(ma_wav* pWav, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_result wavResult = ma_dr_wav_get_cursor_in_pcm_frames(&pWav->dr, pCursor);
+        if (wavResult != MA_SUCCESS) {
+            return (ma_result)wavResult;    /* ma_dr_wav result codes map to miniaudio's. */
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_get_length_in_pcm_frames(ma_wav* pWav, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;   /* Safety. */
+
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_result wavResult = ma_dr_wav_get_length_in_pcm_frames(&pWav->dr, pLength);
+        if (wavResult != MA_SUCCESS) {
+            return (ma_result)wavResult;    /* ma_dr_wav result codes map to miniaudio's. */
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+
+static ma_result ma_decoding_backend_init__wav(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_wav* pWav;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pWav = (ma_wav*)ma_malloc(sizeof(*pWav), pAllocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_wav_init(onRead, onSeek, onTell, pReadSeekTellUserData, pConfig, pAllocationCallbacks, pWav);
+    if (result != MA_SUCCESS) {
+        ma_free(pWav, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pWav;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file__wav(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_wav* pWav;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pWav = (ma_wav*)ma_malloc(sizeof(*pWav), pAllocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_wav_init_file(pFilePath, pConfig, pAllocationCallbacks, pWav);
+    if (result != MA_SUCCESS) {
+        ma_free(pWav, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pWav;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file_w__wav(void* pUserData, const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_wav* pWav;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pWav = (ma_wav*)ma_malloc(sizeof(*pWav), pAllocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_wav_init_file_w(pFilePath, pConfig, pAllocationCallbacks, pWav);
+    if (result != MA_SUCCESS) {
+        ma_free(pWav, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pWav;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_memory__wav(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_wav* pWav;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pWav = (ma_wav*)ma_malloc(sizeof(*pWav), pAllocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_wav_init_memory(pData, dataSize, pConfig, pAllocationCallbacks, pWav);
+    if (result != MA_SUCCESS) {
+        ma_free(pWav, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pWav;
+
+    return MA_SUCCESS;
+}
+
+static void ma_decoding_backend_uninit__wav(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_wav* pWav = (ma_wav*)pBackend;
+
+    (void)pUserData;
+
+    ma_wav_uninit(pWav, pAllocationCallbacks);
+    ma_free(pWav, pAllocationCallbacks);
+}
+
+static ma_decoding_backend_vtable g_ma_decoding_backend_vtable_wav =
+{
+    ma_decoding_backend_init__wav,
+    ma_decoding_backend_init_file__wav,
+    ma_decoding_backend_init_file_w__wav,
+    ma_decoding_backend_init_memory__wav,
+    ma_decoding_backend_uninit__wav
+};
+
+static ma_result ma_decoder_init_wav__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_vtable__internal(&g_ma_decoding_backend_vtable_wav, NULL, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_wav_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file__internal(&g_ma_decoding_backend_vtable_wav, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_wav_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file_w__internal(&g_ma_decoding_backend_vtable_wav, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_wav_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_memory__internal(&g_ma_decoding_backend_vtable_wav, NULL, pData, dataSize, pConfig, pDecoder);
+}
+#endif  /* ma_dr_wav_h */
+
+/* FLAC */
+#ifdef ma_dr_flac_h
+#define MA_HAS_FLAC
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_read_proc onRead;
+    ma_seek_proc onSeek;
+    ma_tell_proc onTell;
+    void* pReadSeekTellUserData;
+    ma_format format;           /* Can be f32, s16 or s32. */
+#if !defined(MA_NO_FLAC)
+    ma_dr_flac* dr;
+#endif
+} ma_flac;
+
+MA_API ma_result ma_flac_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac);
+MA_API ma_result ma_flac_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac);
+MA_API ma_result ma_flac_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac);
+MA_API ma_result ma_flac_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac);
+MA_API void ma_flac_uninit(ma_flac* pFlac, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_flac_read_pcm_frames(ma_flac* pFlac, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_flac_seek_to_pcm_frame(ma_flac* pFlac, ma_uint64 frameIndex);
+MA_API ma_result ma_flac_get_data_format(ma_flac* pFlac, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_flac_get_cursor_in_pcm_frames(ma_flac* pFlac, ma_uint64* pCursor);
+MA_API ma_result ma_flac_get_length_in_pcm_frames(ma_flac* pFlac, ma_uint64* pLength);
+
+
+static ma_result ma_flac_ds_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_flac_read_pcm_frames((ma_flac*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_flac_ds_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_flac_seek_to_pcm_frame((ma_flac*)pDataSource, frameIndex);
+}
+
+static ma_result ma_flac_ds_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_flac_get_data_format((ma_flac*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_flac_ds_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_flac_get_cursor_in_pcm_frames((ma_flac*)pDataSource, pCursor);
+}
+
+static ma_result ma_flac_ds_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_flac_get_length_in_pcm_frames((ma_flac*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_flac_ds_vtable =
+{
+    ma_flac_ds_read,
+    ma_flac_ds_seek,
+    ma_flac_ds_get_data_format,
+    ma_flac_ds_get_cursor,
+    ma_flac_ds_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+#if !defined(MA_NO_FLAC)
+static size_t ma_flac_dr_callback__read(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_flac* pFlac = (ma_flac*)pUserData;
+    ma_result result;
+    size_t bytesRead;
+
+    MA_ASSERT(pFlac != NULL);
+
+    result = pFlac->onRead(pFlac->pReadSeekTellUserData, pBufferOut, bytesToRead, &bytesRead);
+    (void)result;
+
+    return bytesRead;
+}
+
+static ma_bool32 ma_flac_dr_callback__seek(void* pUserData, int offset, ma_dr_flac_seek_origin origin)
+{
+    ma_flac* pFlac = (ma_flac*)pUserData;
+    ma_result result;
+    ma_seek_origin maSeekOrigin;
+
+    MA_ASSERT(pFlac != NULL);
+
+    maSeekOrigin = ma_seek_origin_start;
+    if (origin == MA_DR_FLAC_SEEK_CUR) {
+        maSeekOrigin = ma_seek_origin_current;
+    } else if (origin == MA_DR_FLAC_SEEK_END) {
+        maSeekOrigin = ma_seek_origin_end;
+    }
+
+    result = pFlac->onSeek(pFlac->pReadSeekTellUserData, offset, maSeekOrigin);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+
+    return MA_TRUE;
+}
+
+static ma_bool32 ma_flac_dr_callback__tell(void* pUserData, ma_int64* pCursor)
+{
+    ma_flac* pFlac = (ma_flac*)pUserData;
+    ma_result result;
+
+    MA_ASSERT(pFlac != NULL);
+    MA_ASSERT(pCursor != NULL);
+
+    if (pFlac->onTell == NULL) {
+        return MA_FALSE;  /* Not implemented. */
+    }
+
+    result = pFlac->onTell(pFlac->pReadSeekTellUserData, pCursor);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;  /* Failed to tell. */
+    }
+
+    return MA_TRUE;
+}
+#endif
+
+static ma_result ma_flac_init_internal(const ma_decoding_backend_config* pConfig, ma_flac* pFlac)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFlac);
+    pFlac->format = ma_format_f32;    /* f32 by default. */
+
+    if (pConfig != NULL && (pConfig->preferredFormat == ma_format_f32 || pConfig->preferredFormat == ma_format_s16 || pConfig->preferredFormat == ma_format_s32)) {
+        pFlac->format = pConfig->preferredFormat;
+    } else {
+        /* Getting here means something other than f32 and s16 was specified. Just leave this unset to use the default format. */
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_flac_ds_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pFlac->ds);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base data source. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_flac_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac)
+{
+    ma_result result;
+
+    result = ma_flac_init_internal(pConfig, pFlac);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (onRead == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS; /* onRead and onSeek are mandatory. */
+    }
+
+    pFlac->onRead = onRead;
+    pFlac->onSeek = onSeek;
+    pFlac->onTell = onTell;
+    pFlac->pReadSeekTellUserData = pReadSeekTellUserData;
+
+    #if !defined(MA_NO_FLAC)
+    {
+        pFlac->dr = ma_dr_flac_open(ma_flac_dr_callback__read, ma_flac_dr_callback__seek, ma_flac_dr_callback__tell, pFlac, pAllocationCallbacks);
+        if (pFlac->dr == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. */
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac)
+{
+    ma_result result;
+
+    result = ma_flac_init_internal(pConfig, pFlac);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        pFlac->dr = ma_dr_flac_open_file(pFilePath, pAllocationCallbacks);
+        if (pFlac->dr == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac)
+{
+    ma_result result;
+
+    result = ma_flac_init_internal(pConfig, pFlac);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        pFlac->dr = ma_dr_flac_open_file_w(pFilePath, pAllocationCallbacks);
+        if (pFlac->dr == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac)
+{
+    ma_result result;
+
+    result = ma_flac_init_internal(pConfig, pFlac);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        pFlac->dr = ma_dr_flac_open_memory(pData, dataSize, pAllocationCallbacks);
+        if (pFlac->dr == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. */
+        (void)pData;
+        (void)dataSize;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API void ma_flac_uninit(ma_flac* pFlac, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFlac == NULL) {
+        return;
+    }
+
+    (void)pAllocationCallbacks;
+
+    #if !defined(MA_NO_FLAC)
+    {
+        ma_dr_flac_close(pFlac->dr);
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+    }
+    #endif
+
+    ma_data_source_uninit(&pFlac->ds);
+}
+
+MA_API ma_result ma_flac_read_pcm_frames(ma_flac* pFlac, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        /* We always use floating point format. */
+        ma_result result = MA_SUCCESS;  /* Must be initialized to MA_SUCCESS. */
+        ma_uint64 totalFramesRead = 0;
+        ma_format format;
+
+        ma_flac_get_data_format(pFlac, &format, NULL, NULL, NULL, 0);
+
+        switch (format)
+        {
+            case ma_format_f32:
+            {
+                totalFramesRead = ma_dr_flac_read_pcm_frames_f32(pFlac->dr, frameCount, (float*)pFramesOut);
+            } break;
+
+            case ma_format_s16:
+            {
+                totalFramesRead = ma_dr_flac_read_pcm_frames_s16(pFlac->dr, frameCount, (ma_int16*)pFramesOut);
+            } break;
+
+            case ma_format_s32:
+            {
+                totalFramesRead = ma_dr_flac_read_pcm_frames_s32(pFlac->dr, frameCount, (ma_int32*)pFramesOut);
+            } break;
+
+            case ma_format_u8:
+            case ma_format_s24:
+            case ma_format_unknown:
+            default:
+            {
+                return MA_INVALID_OPERATION;
+            };
+        }
+
+        /* In the future we'll update ma_dr_flac to return MA_AT_END for us. */
+        if (totalFramesRead == 0) {
+            result = MA_AT_END;
+        }
+
+        if (pFramesRead != NULL) {
+            *pFramesRead = totalFramesRead;
+        }
+
+        if (result == MA_SUCCESS && totalFramesRead == 0) {
+            result  = MA_AT_END;
+        }
+
+        return result;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)pFramesRead;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_seek_to_pcm_frame(ma_flac* pFlac, ma_uint64 frameIndex)
+{
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        ma_bool32 flacResult;
+
+        flacResult = ma_dr_flac_seek_to_pcm_frame(pFlac->dr, frameIndex);
+        if (flacResult != MA_TRUE) {
+            return MA_ERROR;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)frameIndex;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_get_data_format(ma_flac* pFlac, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* Defaults for safety. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pFlac == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pFlac->format;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        if (pChannels != NULL) {
+            *pChannels = pFlac->dr->channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pFlac->dr->sampleRate;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pChannelMap, channelMapCap, pFlac->dr->channels);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_get_cursor_in_pcm_frames(ma_flac* pFlac, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        *pCursor = pFlac->dr->currentPCMFrame;
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_get_length_in_pcm_frames(ma_flac* pFlac, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;   /* Safety. */
+
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        *pLength = pFlac->dr->totalPCMFrameCount;
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+
+static ma_result ma_decoding_backend_init__flac(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_flac* pFlac;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pFlac = (ma_flac*)ma_malloc(sizeof(*pFlac), pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_flac_init(onRead, onSeek, onTell, pReadSeekTellUserData, pConfig, pAllocationCallbacks, pFlac);
+    if (result != MA_SUCCESS) {
+        ma_free(pFlac, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pFlac;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file__flac(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_flac* pFlac;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pFlac = (ma_flac*)ma_malloc(sizeof(*pFlac), pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_flac_init_file(pFilePath, pConfig, pAllocationCallbacks, pFlac);
+    if (result != MA_SUCCESS) {
+        ma_free(pFlac, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pFlac;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file_w__flac(void* pUserData, const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_flac* pFlac;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pFlac = (ma_flac*)ma_malloc(sizeof(*pFlac), pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_flac_init_file_w(pFilePath, pConfig, pAllocationCallbacks, pFlac);
+    if (result != MA_SUCCESS) {
+        ma_free(pFlac, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pFlac;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_memory__flac(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_flac* pFlac;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pFlac = (ma_flac*)ma_malloc(sizeof(*pFlac), pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_flac_init_memory(pData, dataSize, pConfig, pAllocationCallbacks, pFlac);
+    if (result != MA_SUCCESS) {
+        ma_free(pFlac, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pFlac;
+
+    return MA_SUCCESS;
+}
+
+static void ma_decoding_backend_uninit__flac(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_flac* pFlac = (ma_flac*)pBackend;
+
+    (void)pUserData;
+
+    ma_flac_uninit(pFlac, pAllocationCallbacks);
+    ma_free(pFlac, pAllocationCallbacks);
+}
+
+static ma_decoding_backend_vtable g_ma_decoding_backend_vtable_flac =
+{
+    ma_decoding_backend_init__flac,
+    ma_decoding_backend_init_file__flac,
+    ma_decoding_backend_init_file_w__flac,
+    ma_decoding_backend_init_memory__flac,
+    ma_decoding_backend_uninit__flac
+};
+
+static ma_result ma_decoder_init_flac__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_vtable__internal(&g_ma_decoding_backend_vtable_flac, NULL, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_flac_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file__internal(&g_ma_decoding_backend_vtable_flac, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_flac_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file_w__internal(&g_ma_decoding_backend_vtable_flac, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_flac_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_memory__internal(&g_ma_decoding_backend_vtable_flac, NULL, pData, dataSize, pConfig, pDecoder);
+}
+#endif  /* ma_dr_flac_h */
+
+/* MP3 */
+#ifdef ma_dr_mp3_h
+#define MA_HAS_MP3
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_read_proc onRead;
+    ma_seek_proc onSeek;
+    ma_tell_proc onTell;
+    void* pReadSeekTellUserData;
+    ma_format format;           /* Can be f32 or s16. */
+#if !defined(MA_NO_MP3)
+    ma_dr_mp3 dr;
+    ma_uint32 seekPointCount;
+    ma_dr_mp3_seek_point* pSeekPoints;  /* Only used if seek table generation is used. */
+#endif
+} ma_mp3;
+
+MA_API ma_result ma_mp3_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3);
+MA_API ma_result ma_mp3_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3);
+MA_API ma_result ma_mp3_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3);
+MA_API ma_result ma_mp3_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3);
+MA_API void ma_mp3_uninit(ma_mp3* pMP3, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_mp3_read_pcm_frames(ma_mp3* pMP3, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_mp3_seek_to_pcm_frame(ma_mp3* pMP3, ma_uint64 frameIndex);
+MA_API ma_result ma_mp3_get_data_format(ma_mp3* pMP3, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_mp3_get_cursor_in_pcm_frames(ma_mp3* pMP3, ma_uint64* pCursor);
+MA_API ma_result ma_mp3_get_length_in_pcm_frames(ma_mp3* pMP3, ma_uint64* pLength);
+
+
+static ma_result ma_mp3_ds_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_mp3_read_pcm_frames((ma_mp3*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_mp3_ds_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_mp3_seek_to_pcm_frame((ma_mp3*)pDataSource, frameIndex);
+}
+
+static ma_result ma_mp3_ds_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_mp3_get_data_format((ma_mp3*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_mp3_ds_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_mp3_get_cursor_in_pcm_frames((ma_mp3*)pDataSource, pCursor);
+}
+
+static ma_result ma_mp3_ds_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_mp3_get_length_in_pcm_frames((ma_mp3*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_mp3_ds_vtable =
+{
+    ma_mp3_ds_read,
+    ma_mp3_ds_seek,
+    ma_mp3_ds_get_data_format,
+    ma_mp3_ds_get_cursor,
+    ma_mp3_ds_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+#if !defined(MA_NO_MP3)
+static size_t ma_mp3_dr_callback__read(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_mp3* pMP3 = (ma_mp3*)pUserData;
+    ma_result result;
+    size_t bytesRead;
+
+    MA_ASSERT(pMP3 != NULL);
+
+    result = pMP3->onRead(pMP3->pReadSeekTellUserData, pBufferOut, bytesToRead, &bytesRead);
+    (void)result;
+
+    return bytesRead;
+}
+
+static ma_bool32 ma_mp3_dr_callback__seek(void* pUserData, int offset, ma_dr_mp3_seek_origin origin)
+{
+    ma_mp3* pMP3 = (ma_mp3*)pUserData;
+    ma_result result;
+    ma_seek_origin maSeekOrigin;
+
+    MA_ASSERT(pMP3 != NULL);
+
+    if (origin == MA_DR_MP3_SEEK_SET) {
+        maSeekOrigin = ma_seek_origin_start;
+    } else if (origin == MA_DR_MP3_SEEK_END) {
+        maSeekOrigin = ma_seek_origin_end;
+    } else {
+        maSeekOrigin = ma_seek_origin_current;
+    }
+
+    result = pMP3->onSeek(pMP3->pReadSeekTellUserData, offset, maSeekOrigin);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+
+    return MA_TRUE;
+}
+
+static ma_bool32 ma_mp3_dr_callback__tell(void* pUserData, ma_int64* pCursor)
+{
+    ma_mp3* pMP3 = (ma_mp3*)pUserData;
+    ma_result result;
+
+    MA_ASSERT(pMP3 != NULL);
+
+    result = pMP3->onTell(pMP3->pReadSeekTellUserData, pCursor);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+
+    return MA_TRUE;
+}
+#endif
+
+static ma_result ma_mp3_init_internal(const ma_decoding_backend_config* pConfig, ma_mp3* pMP3)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pMP3);
+    pMP3->format = ma_format_f32;    /* f32 by default. */
+
+    if (pConfig != NULL && (pConfig->preferredFormat == ma_format_f32 || pConfig->preferredFormat == ma_format_s16)) {
+        pMP3->format = pConfig->preferredFormat;
+    } else {
+        /* Getting here means something other than f32 and s16 was specified. Just leave this unset to use the default format. */
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_mp3_ds_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pMP3->ds);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base data source. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_mp3_generate_seek_table(ma_mp3* pMP3, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 mp3Result;
+    ma_uint32 seekPointCount = 0;
+    ma_dr_mp3_seek_point* pSeekPoints = NULL;
+
+    MA_ASSERT(pMP3    != NULL);
+    MA_ASSERT(pConfig != NULL);
+
+    seekPointCount = pConfig->seekPointCount;
+    if (seekPointCount > 0) {
+        pSeekPoints = (ma_dr_mp3_seek_point*)ma_malloc(sizeof(*pMP3->pSeekPoints) * seekPointCount, pAllocationCallbacks);
+        if (pSeekPoints == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+    mp3Result = ma_dr_mp3_calculate_seek_points(&pMP3->dr, &seekPointCount, pSeekPoints);
+    if (mp3Result != MA_TRUE) {
+        ma_free(pSeekPoints, pAllocationCallbacks);
+        return MA_ERROR;
+    }
+
+    mp3Result = ma_dr_mp3_bind_seek_table(&pMP3->dr, seekPointCount, pSeekPoints);
+    if (mp3Result != MA_TRUE) {
+        ma_free(pSeekPoints, pAllocationCallbacks);
+        return MA_ERROR;
+    }
+
+    pMP3->seekPointCount = seekPointCount;
+    pMP3->pSeekPoints    = pSeekPoints;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_mp3_post_init(ma_mp3* pMP3, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+
+    result = ma_mp3_generate_seek_table(pMP3, pConfig, pAllocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_mp3_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3)
+{
+    ma_result result;
+
+    result = ma_mp3_init_internal(pConfig, pMP3);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (onRead == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS; /* onRead and onSeek are mandatory. */
+    }
+
+    pMP3->onRead = onRead;
+    pMP3->onSeek = onSeek;
+    pMP3->onTell = onTell;
+    pMP3->pReadSeekTellUserData = pReadSeekTellUserData;
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_init(&pMP3->dr, ma_mp3_dr_callback__read, ma_mp3_dr_callback__seek, ma_mp3_dr_callback__tell, NULL, pMP3, pAllocationCallbacks);
+        if (mp3Result != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_mp3_post_init(pMP3, pConfig, pAllocationCallbacks);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. */
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3)
+{
+    ma_result result;
+
+    result = ma_mp3_init_internal(pConfig, pMP3);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_init_file(&pMP3->dr, pFilePath, pAllocationCallbacks);
+        if (mp3Result != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_mp3_post_init(pMP3, pConfig, pAllocationCallbacks);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3)
+{
+    ma_result result;
+
+    result = ma_mp3_init_internal(pConfig, pMP3);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_init_file_w(&pMP3->dr, pFilePath, pAllocationCallbacks);
+        if (mp3Result != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_mp3_post_init(pMP3, pConfig, pAllocationCallbacks);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3)
+{
+    ma_result result;
+
+    result = ma_mp3_init_internal(pConfig, pMP3);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_init_memory(&pMP3->dr, pData, dataSize, pAllocationCallbacks);
+        if (mp3Result != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_mp3_post_init(pMP3, pConfig, pAllocationCallbacks);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. */
+        (void)pData;
+        (void)dataSize;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API void ma_mp3_uninit(ma_mp3* pMP3, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pMP3 == NULL) {
+        return;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_dr_mp3_uninit(&pMP3->dr);
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+    }
+    #endif
+
+    /* Seek points need to be freed after the MP3 decoder has been uninitialized to ensure they're no longer being referenced. */
+    ma_free(pMP3->pSeekPoints, pAllocationCallbacks);
+
+    ma_data_source_uninit(&pMP3->ds);
+}
+
+MA_API ma_result ma_mp3_read_pcm_frames(ma_mp3* pMP3, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        /* We always use floating point format. */
+        ma_result result = MA_SUCCESS;  /* Must be initialized to MA_SUCCESS. */
+        ma_uint64 totalFramesRead = 0;
+        ma_format format;
+
+        ma_mp3_get_data_format(pMP3, &format, NULL, NULL, NULL, 0);
+
+        switch (format)
+        {
+            case ma_format_f32:
+            {
+                totalFramesRead = ma_dr_mp3_read_pcm_frames_f32(&pMP3->dr, frameCount, (float*)pFramesOut);
+            } break;
+
+            case ma_format_s16:
+            {
+                totalFramesRead = ma_dr_mp3_read_pcm_frames_s16(&pMP3->dr, frameCount, (ma_int16*)pFramesOut);
+            } break;
+
+            case ma_format_u8:
+            case ma_format_s24:
+            case ma_format_s32:
+            case ma_format_unknown:
+            default:
+            {
+                return MA_INVALID_OPERATION;
+            };
+        }
+
+        /* In the future we'll update ma_dr_mp3 to return MA_AT_END for us. */
+        if (totalFramesRead == 0) {
+            result = MA_AT_END;
+        }
+
+        if (pFramesRead != NULL) {
+            *pFramesRead = totalFramesRead;
+        }
+
+        return result;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)pFramesRead;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_seek_to_pcm_frame(ma_mp3* pMP3, ma_uint64 frameIndex)
+{
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_seek_to_pcm_frame(&pMP3->dr, frameIndex);
+        if (mp3Result != MA_TRUE) {
+            return MA_ERROR;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)frameIndex;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_get_data_format(ma_mp3* pMP3, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* Defaults for safety. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pMP3->format;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        if (pChannels != NULL) {
+            *pChannels = pMP3->dr.channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pMP3->dr.sampleRate;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pMP3->dr.channels);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_get_cursor_in_pcm_frames(ma_mp3* pMP3, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        *pCursor = pMP3->dr.currentPCMFrame;
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_get_length_in_pcm_frames(ma_mp3* pMP3, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;   /* Safety. */
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        *pLength = ma_dr_mp3_get_pcm_frame_count(&pMP3->dr);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+
+static ma_result ma_decoding_backend_init__mp3(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_mp3* pMP3;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pMP3 = (ma_mp3*)ma_malloc(sizeof(*pMP3), pAllocationCallbacks);
+    if (pMP3 == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_mp3_init(onRead, onSeek, onTell, pReadSeekTellUserData, pConfig, pAllocationCallbacks, pMP3);
+    if (result != MA_SUCCESS) {
+        ma_free(pMP3, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pMP3;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file__mp3(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_mp3* pMP3;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pMP3 = (ma_mp3*)ma_malloc(sizeof(*pMP3), pAllocationCallbacks);
+    if (pMP3 == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_mp3_init_file(pFilePath, pConfig, pAllocationCallbacks, pMP3);
+    if (result != MA_SUCCESS) {
+        ma_free(pMP3, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pMP3;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file_w__mp3(void* pUserData, const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_mp3* pMP3;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pMP3 = (ma_mp3*)ma_malloc(sizeof(*pMP3), pAllocationCallbacks);
+    if (pMP3 == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_mp3_init_file_w(pFilePath, pConfig, pAllocationCallbacks, pMP3);
+    if (result != MA_SUCCESS) {
+        ma_free(pMP3, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pMP3;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_memory__mp3(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_mp3* pMP3;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pMP3 = (ma_mp3*)ma_malloc(sizeof(*pMP3), pAllocationCallbacks);
+    if (pMP3 == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_mp3_init_memory(pData, dataSize, pConfig, pAllocationCallbacks, pMP3);
+    if (result != MA_SUCCESS) {
+        ma_free(pMP3, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pMP3;
+
+    return MA_SUCCESS;
+}
+
+static void ma_decoding_backend_uninit__mp3(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_mp3* pMP3 = (ma_mp3*)pBackend;
+
+    (void)pUserData;
+
+    ma_mp3_uninit(pMP3, pAllocationCallbacks);
+    ma_free(pMP3, pAllocationCallbacks);
+}
+
+static ma_decoding_backend_vtable g_ma_decoding_backend_vtable_mp3 =
+{
+    ma_decoding_backend_init__mp3,
+    ma_decoding_backend_init_file__mp3,
+    ma_decoding_backend_init_file_w__mp3,
+    ma_decoding_backend_init_memory__mp3,
+    ma_decoding_backend_uninit__mp3
+};
+
+static ma_result ma_decoder_init_mp3__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_vtable__internal(&g_ma_decoding_backend_vtable_mp3, NULL, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_mp3_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file__internal(&g_ma_decoding_backend_vtable_mp3, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_mp3_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file_w__internal(&g_ma_decoding_backend_vtable_mp3, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_mp3_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_memory__internal(&g_ma_decoding_backend_vtable_mp3, NULL, pData, dataSize, pConfig, pDecoder);
+}
+#endif  /* ma_dr_mp3_h */
+
+/* Vorbis */
+#ifdef STB_VORBIS_INCLUDE_STB_VORBIS_H
+#define MA_HAS_VORBIS
+
+/* The size in bytes of each chunk of data to read from the Vorbis stream. */
+#define MA_VORBIS_DATA_CHUNK_SIZE  4096
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_read_proc onRead;
+    ma_seek_proc onSeek;
+    ma_tell_proc onTell;
+    void* pReadSeekTellUserData;
+    ma_allocation_callbacks allocationCallbacks;    /* Store the allocation callbacks within the structure because we may need to dynamically expand a buffer in ma_stbvorbis_read_pcm_frames() when using push mode. */
+    ma_format format;               /* Only f32 is allowed with stb_vorbis. */
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint64 cursor;
+#if !defined(MA_NO_VORBIS)
+    stb_vorbis* stb;
+    ma_bool32 usingPushMode;
+    struct
+    {
+        ma_uint8* pData;
+        size_t dataSize;
+        size_t dataCapacity;
+        size_t audioStartOffsetInBytes;
+        ma_uint32 framesConsumed;   /* The number of frames consumed in ppPacketData. */
+        ma_uint32 framesRemaining;  /* The number of frames remaining in ppPacketData. */
+        float** ppPacketData;
+    } push;
+#endif
+} ma_stbvorbis;
+
+MA_API ma_result ma_stbvorbis_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis);
+MA_API ma_result ma_stbvorbis_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis);
+MA_API ma_result ma_stbvorbis_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis);
+MA_API void ma_stbvorbis_uninit(ma_stbvorbis* pVorbis, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_stbvorbis_read_pcm_frames(ma_stbvorbis* pVorbis, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_stbvorbis_seek_to_pcm_frame(ma_stbvorbis* pVorbis, ma_uint64 frameIndex);
+MA_API ma_result ma_stbvorbis_get_data_format(ma_stbvorbis* pVorbis, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_stbvorbis_get_cursor_in_pcm_frames(ma_stbvorbis* pVorbis, ma_uint64* pCursor);
+MA_API ma_result ma_stbvorbis_get_length_in_pcm_frames(ma_stbvorbis* pVorbis, ma_uint64* pLength);
+
+
+static ma_result ma_stbvorbis_ds_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_stbvorbis_read_pcm_frames((ma_stbvorbis*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_stbvorbis_ds_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_stbvorbis_seek_to_pcm_frame((ma_stbvorbis*)pDataSource, frameIndex);
+}
+
+static ma_result ma_stbvorbis_ds_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_stbvorbis_get_data_format((ma_stbvorbis*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_stbvorbis_ds_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_stbvorbis_get_cursor_in_pcm_frames((ma_stbvorbis*)pDataSource, pCursor);
+}
+
+static ma_result ma_stbvorbis_ds_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_stbvorbis_get_length_in_pcm_frames((ma_stbvorbis*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_stbvorbis_ds_vtable =
+{
+    ma_stbvorbis_ds_read,
+    ma_stbvorbis_ds_seek,
+    ma_stbvorbis_ds_get_data_format,
+    ma_stbvorbis_ds_get_cursor,
+    ma_stbvorbis_ds_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+static ma_result ma_stbvorbis_init_internal(const ma_decoding_backend_config* pConfig, ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    (void)pConfig;
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pVorbis);
+    pVorbis->format = ma_format_f32;    /* Only supporting f32. */
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_stbvorbis_ds_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pVorbis->ds);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base data source. */
+    }
+
+    return MA_SUCCESS;
+}
+
+#if !defined(MA_NO_VORBIS)
+static ma_result ma_stbvorbis_post_init(ma_stbvorbis* pVorbis)
+{
+    stb_vorbis_info info;
+
+    MA_ASSERT(pVorbis != NULL);
+
+    info = stb_vorbis_get_info(pVorbis->stb);
+
+    pVorbis->channels   = info.channels;
+    pVorbis->sampleRate = info.sample_rate;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_stbvorbis_init_internal_decoder_push(ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+    stb_vorbis* stb;
+    size_t dataSize = 0;
+    size_t dataCapacity = 0;
+    ma_uint8* pData = NULL; /* <-- Must be initialized to NULL. */
+
+    for (;;) {
+        int vorbisError;
+        int consumedDataSize;   /* <-- Fill by stb_vorbis_open_pushdata(). */
+        size_t bytesRead;
+        ma_uint8* pNewData;
+
+        /* Allocate memory for the new chunk. */
+        dataCapacity += MA_VORBIS_DATA_CHUNK_SIZE;
+        pNewData = (ma_uint8*)ma_realloc(pData, dataCapacity, &pVorbis->allocationCallbacks);
+        if (pNewData == NULL) {
+            ma_free(pData, &pVorbis->allocationCallbacks);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        pData = pNewData;
+
+        /* Read in the next chunk. */
+        result = pVorbis->onRead(pVorbis->pReadSeekTellUserData, ma_offset_ptr(pData, dataSize), (dataCapacity - dataSize), &bytesRead);
+        dataSize += bytesRead;
+
+        if (result != MA_SUCCESS) {
+            ma_free(pData, &pVorbis->allocationCallbacks);
+            return result;
+        }
+
+        /* We have a maximum of 31 bits with stb_vorbis. */
+        if (dataSize > INT_MAX) {
+            ma_free(pData, &pVorbis->allocationCallbacks);
+            return MA_TOO_BIG;
+        }
+
+        stb = stb_vorbis_open_pushdata(pData, (int)dataSize, &consumedDataSize, &vorbisError, NULL);
+        if (stb != NULL) {
+            /*
+            Successfully opened the Vorbis decoder. We might have some leftover unprocessed
+            data so we'll need to move that down to the front.
+            */
+            dataSize -= (size_t)consumedDataSize;   /* Consume the data. */
+            MA_MOVE_MEMORY(pData, ma_offset_ptr(pData, consumedDataSize), dataSize);
+
+            /*
+            We need to track the start point so we can seek back to the start of the audio
+            data when seeking.
+            */
+            pVorbis->push.audioStartOffsetInBytes = consumedDataSize;
+
+            break;
+        } else {
+            /* Failed to open the decoder. */
+            if (vorbisError == VORBIS_need_more_data) {
+                continue;
+            } else {
+                ma_free(pData, &pVorbis->allocationCallbacks);
+                return MA_ERROR;   /* Failed to open the stb_vorbis decoder. */
+            }
+        }
+    }
+
+    MA_ASSERT(stb != NULL);
+    pVorbis->stb = stb;
+    pVorbis->push.pData = pData;
+    pVorbis->push.dataSize = dataSize;
+    pVorbis->push.dataCapacity = dataCapacity;
+
+    return MA_SUCCESS;
+}
+#endif
+
+MA_API ma_result ma_stbvorbis_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+
+    result = ma_stbvorbis_init_internal(pConfig, pVorbis);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (onRead == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS; /* onRead and onSeek are mandatory. */
+    }
+
+    pVorbis->onRead = onRead;
+    pVorbis->onSeek = onSeek;
+    pVorbis->onTell = onTell;
+    pVorbis->pReadSeekTellUserData = pReadSeekTellUserData;
+    ma_allocation_callbacks_init_copy(&pVorbis->allocationCallbacks, pAllocationCallbacks);
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        /*
+        stb_vorbis lacks a callback based API for its pulling API which means we're stuck with the
+        pushing API. In order for us to be able to successfully initialize the decoder we need to
+        supply it with enough data. We need to keep loading data until we have enough.
+        */
+        result = ma_stbvorbis_init_internal_decoder_push(pVorbis);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pVorbis->usingPushMode = MA_TRUE;
+
+        result = ma_stbvorbis_post_init(pVorbis);
+        if (result != MA_SUCCESS) {
+            stb_vorbis_close(pVorbis->stb);
+            ma_free(pVorbis->push.pData, pAllocationCallbacks);
+            return result;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. */
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+
+    result = ma_stbvorbis_init_internal(pConfig, pVorbis);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        (void)pAllocationCallbacks; /* Don't know how to make use of this with stb_vorbis. */
+
+        /* We can use stb_vorbis' pull mode for file based streams. */
+        pVorbis->stb = stb_vorbis_open_filename(pFilePath, NULL, NULL);
+        if (pVorbis->stb == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        pVorbis->usingPushMode = MA_FALSE;
+
+        result = ma_stbvorbis_post_init(pVorbis);
+        if (result != MA_SUCCESS) {
+            stb_vorbis_close(pVorbis->stb);
+            return result;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+
+    result = ma_stbvorbis_init_internal(pConfig, pVorbis);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        (void)pAllocationCallbacks;
+
+        /* stb_vorbis uses an int as its size specifier, restricting it to 32-bit even on 64-bit systems. *sigh*. */
+        if (dataSize > INT_MAX) {
+            return MA_TOO_BIG;
+        }
+
+        pVorbis->stb = stb_vorbis_open_memory((const unsigned char*)pData, (int)dataSize, NULL, NULL);
+        if (pVorbis->stb == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        pVorbis->usingPushMode = MA_FALSE;
+
+        result = ma_stbvorbis_post_init(pVorbis);
+        if (result != MA_SUCCESS) {
+            stb_vorbis_close(pVorbis->stb);
+            return result;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. */
+        (void)pData;
+        (void)dataSize;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API void ma_stbvorbis_uninit(ma_stbvorbis* pVorbis, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pVorbis == NULL) {
+        return;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        stb_vorbis_close(pVorbis->stb);
+
+        /* We'll have to clear some memory if we're using push mode. */
+        if (pVorbis->usingPushMode) {
+            ma_free(pVorbis->push.pData, pAllocationCallbacks);
+        }
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+    }
+    #endif
+
+    ma_data_source_uninit(&pVorbis->ds);
+}
+
+MA_API ma_result ma_stbvorbis_read_pcm_frames(ma_stbvorbis* pVorbis, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        /* We always use floating point format. */
+        ma_result result = MA_SUCCESS;  /* Must be initialized to MA_SUCCESS. */
+        ma_uint64 totalFramesRead = 0;
+        ma_format format;
+        ma_uint32 channels;
+
+        ma_stbvorbis_get_data_format(pVorbis, &format, &channels, NULL, NULL, 0);
+
+        if (format == ma_format_f32) {
+            /* We read differently depending on whether or not we're using push mode. */
+            if (pVorbis->usingPushMode) {
+                /* Push mode. This is the complex case. */
+                float* pFramesOutF32 = (float*)pFramesOut;
+
+                while (totalFramesRead < frameCount) {
+                    /* The first thing to do is read from any already-cached frames. */
+                    ma_uint32 framesToReadFromCache = (ma_uint32)ma_min(pVorbis->push.framesRemaining, (frameCount - totalFramesRead));  /* Safe cast because pVorbis->framesRemaining is 32-bit. */
+
+                    /* The output pointer can be null in which case we just treat it as a seek. */
+                    if (pFramesOut != NULL) {
+                        ma_uint64 iFrame;
+                        for (iFrame = 0; iFrame < framesToReadFromCache; iFrame += 1) {
+                            ma_uint32 iChannel;
+                            for (iChannel = 0; iChannel < pVorbis->channels; iChannel += 1) {
+                                pFramesOutF32[iChannel] = pVorbis->push.ppPacketData[iChannel][pVorbis->push.framesConsumed + iFrame];
+                            }
+
+                            pFramesOutF32 += pVorbis->channels;
+                        }
+                    }
+
+                    /* Update pointers and counters. */
+                    pVorbis->push.framesConsumed  += framesToReadFromCache;
+                    pVorbis->push.framesRemaining -= framesToReadFromCache;
+                    totalFramesRead               += framesToReadFromCache;
+
+                    /* Don't bother reading any more frames right now if we've just finished loading. */
+                    if (totalFramesRead == frameCount) {
+                        break;
+                    }
+
+                    MA_ASSERT(pVorbis->push.framesRemaining == 0);
+
+                    /* Getting here means we've run out of cached frames. We'll need to load some more. */
+                    for (;;) {
+                        int samplesRead = 0;
+                        int consumedDataSize;
+
+                        /* We need to case dataSize to an int, so make sure we can do it safely. */
+                        if (pVorbis->push.dataSize > INT_MAX) {
+                            break;  /* Too big. */
+                        }
+
+                        consumedDataSize = stb_vorbis_decode_frame_pushdata(pVorbis->stb, pVorbis->push.pData, (int)pVorbis->push.dataSize, NULL, &pVorbis->push.ppPacketData, &samplesRead);
+                        if (consumedDataSize != 0) {
+                            /* Successfully decoded a Vorbis frame. Consume the data. */
+                            pVorbis->push.dataSize -= (size_t)consumedDataSize;
+                            MA_MOVE_MEMORY(pVorbis->push.pData, ma_offset_ptr(pVorbis->push.pData, consumedDataSize), pVorbis->push.dataSize);
+
+                            pVorbis->push.framesConsumed  = 0;
+                            pVorbis->push.framesRemaining = samplesRead;
+
+                            break;
+                        } else {
+                            /* Not enough data. Read more. */
+                            size_t bytesRead;
+
+                            /* Expand the data buffer if necessary. */
+                            if (pVorbis->push.dataCapacity == pVorbis->push.dataSize) {
+                                size_t newCap = pVorbis->push.dataCapacity + MA_VORBIS_DATA_CHUNK_SIZE;
+                                ma_uint8* pNewData;
+
+                                pNewData = (ma_uint8*)ma_realloc(pVorbis->push.pData, newCap, &pVorbis->allocationCallbacks);
+                                if (pNewData == NULL) {
+                                    result = MA_OUT_OF_MEMORY;
+                                    break;
+                                }
+
+                                pVorbis->push.pData = pNewData;
+                                pVorbis->push.dataCapacity = newCap;
+                            }
+
+                            /* We should have enough room to load some data. */
+                            result = pVorbis->onRead(pVorbis->pReadSeekTellUserData, ma_offset_ptr(pVorbis->push.pData, pVorbis->push.dataSize), (pVorbis->push.dataCapacity - pVorbis->push.dataSize), &bytesRead);
+                            pVorbis->push.dataSize += bytesRead;
+
+                            if (result != MA_SUCCESS) {
+                                break;  /* Failed to read any data. Get out. */
+                            }
+                        }
+                    }
+
+                    /* If we don't have a success code at this point it means we've encountered an error or the end of the file has been reached (probably the latter). */
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+                }
+            } else {
+                /* Pull mode. This is the simple case, but we still need to run in a loop because stb_vorbis loves using 32-bit instead of 64-bit. */
+                while (totalFramesRead < frameCount) {
+                    ma_uint64 framesRemaining = (frameCount - totalFramesRead);
+                    int framesRead;
+
+                    if (framesRemaining > INT_MAX) {
+                        framesRemaining = INT_MAX;
+                    }
+
+                    framesRead = stb_vorbis_get_samples_float_interleaved(pVorbis->stb, channels, (float*)ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, format, channels), (int)framesRemaining * channels);   /* Safe cast. */
+                    totalFramesRead += framesRead;
+
+                    if (framesRead < (int)framesRemaining) {
+                        break;  /* Nothing left to read. Get out. */
+                    }
+                }
+            }
+        } else {
+            result = MA_INVALID_ARGS;
+        }
+
+        pVorbis->cursor += totalFramesRead;
+
+        if (totalFramesRead == 0) {
+            result = MA_AT_END;
+        }
+
+        if (pFramesRead != NULL) {
+            *pFramesRead = totalFramesRead;
+        }
+
+        if (result == MA_SUCCESS && totalFramesRead == 0) {
+            result  = MA_AT_END;
+        }
+
+        return result;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)pFramesRead;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_seek_to_pcm_frame(ma_stbvorbis* pVorbis, ma_uint64 frameIndex)
+{
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        /* Different seeking methods depending on whether or not we're using push mode. */
+        if (pVorbis->usingPushMode) {
+            /* Push mode. This is the complex case. */
+            ma_result result;
+            float buffer[4096];
+
+            /* If we're seeking backwards, we need to seek back to the start and then brute-force forward. */
+            if (frameIndex < pVorbis->cursor) {
+                if (frameIndex > 0x7FFFFFFF) {
+                    return MA_INVALID_ARGS; /* Trying to seek beyond the 32-bit maximum of stb_vorbis. */
+                }
+
+                /*
+                This is wildly inefficient due to me having trouble getting sample exact seeking working
+                robustly with stb_vorbis_flush_pushdata(). The only way I can think to make this work
+                perfectly is to reinitialize the decoder. Note that we only enter this path when seeking
+                backwards. This will hopefully be removed once we get our own Vorbis decoder implemented.
+                */
+                stb_vorbis_close(pVorbis->stb);
+                ma_free(pVorbis->push.pData, &pVorbis->allocationCallbacks);
+
+                MA_ZERO_OBJECT(&pVorbis->push);
+
+                /* Seek to the start of the file. */
+                result = pVorbis->onSeek(pVorbis->pReadSeekTellUserData, 0, ma_seek_origin_start);
+                if (result != MA_SUCCESS) {
+                    return result;
+                }
+
+                result = ma_stbvorbis_init_internal_decoder_push(pVorbis);
+                if (result != MA_SUCCESS) {
+                    return result;
+                }
+
+                /* At this point we should be sitting on the first frame. */
+                pVorbis->cursor = 0;
+            }
+
+            /* We're just brute-forcing this for now. */
+            while (pVorbis->cursor < frameIndex) {
+                ma_uint64 framesRead;
+                ma_uint64 framesToRead = ma_countof(buffer)/pVorbis->channels;
+                if (framesToRead > (frameIndex - pVorbis->cursor)) {
+                    framesToRead = (frameIndex - pVorbis->cursor);
+                }
+
+                result = ma_stbvorbis_read_pcm_frames(pVorbis, buffer, framesToRead, &framesRead);
+                if (result != MA_SUCCESS) {
+                    return result;
+                }
+            }
+        } else {
+            /* Pull mode. This is the simple case. */
+            int vorbisResult;
+
+            if (frameIndex > UINT_MAX) {
+                return MA_INVALID_ARGS; /* Trying to seek beyond the 32-bit maximum of stb_vorbis. */
+            }
+
+            vorbisResult = stb_vorbis_seek(pVorbis->stb, (unsigned int)frameIndex);  /* Safe cast. */
+            if (vorbisResult == 0) {
+                return MA_ERROR;    /* See failed. */
+            }
+
+            pVorbis->cursor = frameIndex;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)frameIndex;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_get_data_format(ma_stbvorbis* pVorbis, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* Defaults for safety. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pVorbis->format;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        if (pChannels != NULL) {
+            *pChannels = pVorbis->channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pVorbis->sampleRate;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_vorbis, pChannelMap, channelMapCap, pVorbis->channels);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_get_cursor_in_pcm_frames(ma_stbvorbis* pVorbis, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        *pCursor = pVorbis->cursor;
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_get_length_in_pcm_frames(ma_stbvorbis* pVorbis, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;   /* Safety. */
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        if (pVorbis->usingPushMode) {
+            *pLength = 0;   /* I don't know of a good way to determine this reliably with stb_vorbis and push mode. */
+        } else {
+            *pLength = stb_vorbis_stream_length_in_samples(pVorbis->stb);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+
+static ma_result ma_decoding_backend_init__stbvorbis(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_stbvorbis* pVorbis;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pVorbis = (ma_stbvorbis*)ma_malloc(sizeof(*pVorbis), pAllocationCallbacks);
+    if (pVorbis == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_stbvorbis_init(onRead, onSeek, onTell, pReadSeekTellUserData, pConfig, pAllocationCallbacks, pVorbis);
+    if (result != MA_SUCCESS) {
+        ma_free(pVorbis, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pVorbis;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file__stbvorbis(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_stbvorbis* pVorbis;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pVorbis = (ma_stbvorbis*)ma_malloc(sizeof(*pVorbis), pAllocationCallbacks);
+    if (pVorbis == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_stbvorbis_init_file(pFilePath, pConfig, pAllocationCallbacks, pVorbis);
+    if (result != MA_SUCCESS) {
+        ma_free(pVorbis, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pVorbis;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_memory__stbvorbis(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_stbvorbis* pVorbis;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pVorbis = (ma_stbvorbis*)ma_malloc(sizeof(*pVorbis), pAllocationCallbacks);
+    if (pVorbis == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_stbvorbis_init_memory(pData, dataSize, pConfig, pAllocationCallbacks, pVorbis);
+    if (result != MA_SUCCESS) {
+        ma_free(pVorbis, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pVorbis;
+
+    return MA_SUCCESS;
+}
+
+static void ma_decoding_backend_uninit__stbvorbis(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_stbvorbis* pVorbis = (ma_stbvorbis*)pBackend;
+
+    (void)pUserData;
+
+    ma_stbvorbis_uninit(pVorbis, pAllocationCallbacks);
+    ma_free(pVorbis, pAllocationCallbacks);
+}
+
+static ma_decoding_backend_vtable g_ma_decoding_backend_vtable_stbvorbis =
+{
+    ma_decoding_backend_init__stbvorbis,
+    ma_decoding_backend_init_file__stbvorbis,
+    NULL, /* onInitFileW() */
+    ma_decoding_backend_init_memory__stbvorbis,
+    ma_decoding_backend_uninit__stbvorbis
+};
+
+static ma_result ma_decoder_init_vorbis__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_vtable__internal(&g_ma_decoding_backend_vtable_stbvorbis, NULL, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_vorbis_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file__internal(&g_ma_decoding_backend_vtable_stbvorbis, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_vorbis_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file_w__internal(&g_ma_decoding_backend_vtable_stbvorbis, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_vorbis_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_memory__internal(&g_ma_decoding_backend_vtable_stbvorbis, NULL, pData, dataSize, pConfig, pDecoder);
+}
+#endif  /* STB_VORBIS_INCLUDE_STB_VORBIS_H */
+
+
+
+static ma_result ma_decoder__init_allocation_callbacks(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig != NULL) {
+        return ma_allocation_callbacks_init_copy(&pDecoder->allocationCallbacks, &pConfig->allocationCallbacks);
+    } else {
+        pDecoder->allocationCallbacks = ma_allocation_callbacks_init_default();
+        return MA_SUCCESS;
+    }
+}
+
+static ma_result ma_decoder__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_decoder_read_pcm_frames((ma_decoder*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_decoder__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_decoder_seek_to_pcm_frame((ma_decoder*)pDataSource, frameIndex);
+}
+
+static ma_result ma_decoder__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_decoder_get_data_format((ma_decoder*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_decoder__data_source_on_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_decoder_get_cursor_in_pcm_frames((ma_decoder*)pDataSource, pCursor);
+}
+
+static ma_result ma_decoder__data_source_on_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_decoder_get_length_in_pcm_frames((ma_decoder*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_decoder_data_source_vtable =
+{
+    ma_decoder__data_source_on_read,
+    ma_decoder__data_source_on_seek,
+    ma_decoder__data_source_on_get_data_format,
+    ma_decoder__data_source_on_get_cursor,
+    ma_decoder__data_source_on_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+static ma_result ma_decoder__preinit(ma_decoder_read_proc onRead, ma_decoder_seek_proc onSeek, ma_decoder_tell_proc onTell, void* pUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    MA_ASSERT(pConfig != NULL);
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDecoder);
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_decoder_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pDecoder->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDecoder->onRead    = onRead;
+    pDecoder->onSeek    = onSeek;
+    pDecoder->onTell    = onTell;
+    pDecoder->pUserData = pUserData;
+
+    result = ma_decoder__init_allocation_callbacks(pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        ma_data_source_uninit(&pDecoder->ds);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__postinit(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+
+    result = ma_decoder__init_data_converter(pDecoder, pConfig);
+
+    /* If we failed post initialization we need to uninitialize the decoder before returning to prevent a memory leak. */
+    if (result != MA_SUCCESS) {
+        ma_decoder_uninit(pDecoder);
+        return result;
+    }
+
+    return result;
+}
+
+
+static ma_result ma_decoder_init__internal(ma_decoder_read_proc onRead, ma_decoder_seek_proc onSeek, void* pUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    /* Silence some warnings in the case that we don't have any decoder backends enabled. */
+    (void)onRead;
+    (void)onSeek;
+    (void)pUserData;
+
+
+    /* If we've specified a specific encoding type, try that first. */
+    if (pConfig->encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (pConfig->encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav__internal(pConfig, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (pConfig->encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac__internal(pConfig, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (pConfig->encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3__internal(pConfig, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (pConfig->encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis__internal(pConfig, pDecoder);
+        }
+    #endif
+
+        /* If we weren't able to initialize the decoder, seek back to the start to give the next attempts a clean start. */
+        if (result != MA_SUCCESS) {
+            onSeek(pDecoder, 0, ma_seek_origin_start);
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we couldn't load a specific decoding backend based on the encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_custom__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (pConfig->encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_wav__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_flac__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_mp3__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_vorbis__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    }
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_decoder__postinit(pConfig, pDecoder);
+}
+
+MA_API ma_result ma_decoder_init(ma_decoder_read_proc onRead, ma_decoder_seek_proc onSeek, void* pUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_decoder_config config;
+    ma_result result;
+
+    config = ma_decoder_config_init_copy(pConfig);
+
+    result = ma_decoder__preinit(onRead, onSeek, NULL, pUserData, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_decoder_init__internal(onRead, onSeek, pUserData, &config, pDecoder);
+}
+
+
+static ma_result ma_decoder__on_read_memory(ma_decoder* pDecoder, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead)
+{
+    size_t bytesRemaining;
+
+    MA_ASSERT(pDecoder->data.memory.dataSize >= pDecoder->data.memory.currentReadPos);
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = 0;
+    }
+
+    bytesRemaining = pDecoder->data.memory.dataSize - pDecoder->data.memory.currentReadPos;
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+
+    if (bytesRemaining == 0) {
+        return MA_AT_END;
+    }
+
+    if (bytesToRead > 0) {
+        MA_COPY_MEMORY(pBufferOut, pDecoder->data.memory.pData + pDecoder->data.memory.currentReadPos, bytesToRead);
+        pDecoder->data.memory.currentReadPos += bytesToRead;
+    }
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = bytesToRead;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__on_seek_memory(ma_decoder* pDecoder, ma_int64 byteOffset, ma_seek_origin origin)
+{
+    if (byteOffset > 0 && (ma_uint64)byteOffset > MA_SIZE_MAX) {
+        return MA_BAD_SEEK;
+    }
+
+    if (origin == ma_seek_origin_current) {
+        if (byteOffset > 0) {
+            if (pDecoder->data.memory.currentReadPos + byteOffset > pDecoder->data.memory.dataSize) {
+                byteOffset = (ma_int64)(pDecoder->data.memory.dataSize - pDecoder->data.memory.currentReadPos);  /* Trying to seek too far forward. */
+            }
+
+            pDecoder->data.memory.currentReadPos += (size_t)byteOffset;
+        } else {
+            if (pDecoder->data.memory.currentReadPos < (size_t)-byteOffset) {
+                byteOffset = -(ma_int64)pDecoder->data.memory.currentReadPos;  /* Trying to seek too far backwards. */
+            }
+
+            pDecoder->data.memory.currentReadPos -= (size_t)-byteOffset;
+        }
+    } else {
+        if (origin == ma_seek_origin_end) {
+            if (byteOffset < 0) {
+                byteOffset = -byteOffset;
+            }
+
+            if (byteOffset > (ma_int64)pDecoder->data.memory.dataSize) {
+                pDecoder->data.memory.currentReadPos = 0;   /* Trying to seek too far back. */
+            } else {
+                pDecoder->data.memory.currentReadPos = pDecoder->data.memory.dataSize - (size_t)byteOffset;
+            }
+        } else {
+            if ((size_t)byteOffset <= pDecoder->data.memory.dataSize) {
+                pDecoder->data.memory.currentReadPos = (size_t)byteOffset;
+            } else {
+                pDecoder->data.memory.currentReadPos = pDecoder->data.memory.dataSize;  /* Trying to seek too far forward. */
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__on_tell_memory(ma_decoder* pDecoder, ma_int64* pCursor)
+{
+    MA_ASSERT(pDecoder != NULL);
+    MA_ASSERT(pCursor  != NULL);
+
+    *pCursor = (ma_int64)pDecoder->data.memory.currentReadPos;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__preinit_memory_wrapper(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = ma_decoder__preinit(ma_decoder__on_read_memory, ma_decoder__on_seek_memory, ma_decoder__on_tell_memory, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pData == NULL || dataSize == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDecoder->data.memory.pData = (const ma_uint8*)pData;
+    pDecoder->data.memory.dataSize = dataSize;
+    pDecoder->data.memory.currentReadPos = 0;
+
+    (void)pConfig;
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_memory(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+
+    result = ma_decoder__preinit(NULL, NULL, NULL, NULL, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pData == NULL || dataSize == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If the backend has support for loading from a file path we'll want to use that. If that all fails we'll fall back to the VFS path. */
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav_from_memory__internal(pData, dataSize, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac_from_memory__internal(pData, dataSize, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3_from_memory__internal(pData, dataSize, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis_from_memory__internal(pData, dataSize, &config, pDecoder);
+        }
+    #endif
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        result = ma_decoder_init_custom_from_memory__internal(pData, dataSize, &config, pDecoder);
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (result != MA_SUCCESS && config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+        /* Use trial and error for stock decoders. */
+        if (result != MA_SUCCESS) {
+        #ifdef MA_HAS_WAV
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_wav_from_memory__internal(pData, dataSize, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_FLAC
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_flac_from_memory__internal(pData, dataSize, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_MP3
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_mp3_from_memory__internal(pData, dataSize, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_VORBIS
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_vorbis_from_memory__internal(pData, dataSize, &config, pDecoder);
+            }
+        #endif
+        }
+    }
+
+    /*
+    If at this point we still haven't successfully initialized the decoder it most likely means
+    the backend doesn't have an implementation for loading from a file path. We'll try using
+    miniaudio's built-in file IO for loading file.
+    */
+    if (result == MA_SUCCESS) {
+        /* Initialization was successful. Finish up. */
+        result = ma_decoder__postinit(&config, pDecoder);
+        if (result != MA_SUCCESS) {
+            /*
+            The backend was initialized successfully, but for some reason post-initialization failed. This is most likely
+            due to an out of memory error. We're going to abort with an error here and not try to recover.
+            */
+            if (pDecoder->pBackendVTable != NULL && pDecoder->pBackendVTable->onUninit != NULL) {
+                pDecoder->pBackendVTable->onUninit(pDecoder->pBackendUserData, &pDecoder->pBackend, &pDecoder->allocationCallbacks);
+            }
+
+            return result;
+        }
+    } else {
+        /* Probably no implementation for loading from a block of memory. Use miniaudio's abstraction instead. */
+        result = ma_decoder__preinit_memory_wrapper(pData, dataSize, &config, pDecoder);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_decoder_init__internal(ma_decoder__on_read_memory, ma_decoder__on_seek_memory, NULL, &config, pDecoder);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+#if defined(MA_HAS_WAV)    || \
+    defined(MA_HAS_MP3)    || \
+    defined(MA_HAS_FLAC)   || \
+    defined(MA_HAS_VORBIS)
+#define MA_HAS_PATH_API
+#endif
+
+#if defined(MA_HAS_PATH_API)
+static const char* ma_path_file_name(const char* path)
+{
+    const char* fileName;
+
+    if (path == NULL) {
+        return NULL;
+    }
+
+    fileName = path;
+
+    /* We just loop through the path until we find the last slash. */
+    while (path[0] != '\0') {
+        if (path[0] == '/' || path[0] == '\\') {
+            fileName = path;
+        }
+
+        path += 1;
+    }
+
+    /* At this point the file name is sitting on a slash, so just move forward. */
+    while (fileName[0] != '\0' && (fileName[0] == '/' || fileName[0] == '\\')) {
+        fileName += 1;
+    }
+
+    return fileName;
+}
+
+static const wchar_t* ma_path_file_name_w(const wchar_t* path)
+{
+    const wchar_t* fileName;
+
+    if (path == NULL) {
+        return NULL;
+    }
+
+    fileName = path;
+
+    /* We just loop through the path until we find the last slash. */
+    while (path[0] != '\0') {
+        if (path[0] == '/' || path[0] == '\\') {
+            fileName = path;
+        }
+
+        path += 1;
+    }
+
+    /* At this point the file name is sitting on a slash, so just move forward. */
+    while (fileName[0] != '\0' && (fileName[0] == '/' || fileName[0] == '\\')) {
+        fileName += 1;
+    }
+
+    return fileName;
+}
+
+
+static const char* ma_path_extension(const char* path)
+{
+    const char* extension;
+    const char* lastOccurance;
+
+    if (path == NULL) {
+        path = "";
+    }
+
+    extension = ma_path_file_name(path);
+    lastOccurance = NULL;
+
+    /* Just find the last '.' and return. */
+    while (extension[0] != '\0') {
+        if (extension[0] == '.') {
+            extension += 1;
+            lastOccurance = extension;
+        }
+
+        extension += 1;
+    }
+
+    return (lastOccurance != NULL) ? lastOccurance : extension;
+}
+
+static const wchar_t* ma_path_extension_w(const wchar_t* path)
+{
+    const wchar_t* extension;
+    const wchar_t* lastOccurance;
+
+    if (path == NULL) {
+        path = L"";
+    }
+
+    extension = ma_path_file_name_w(path);
+    lastOccurance = NULL;
+
+    /* Just find the last '.' and return. */
+    while (extension[0] != '\0') {
+        if (extension[0] == '.') {
+            extension += 1;
+            lastOccurance = extension;
+        }
+
+        extension += 1;
+    }
+
+    return (lastOccurance != NULL) ? lastOccurance : extension;
+}
+
+
+static ma_bool32 ma_path_extension_equal(const char* path, const char* extension)
+{
+    const char* ext1;
+    const char* ext2;
+
+    if (path == NULL || extension == NULL) {
+        return MA_FALSE;
+    }
+
+    ext1 = extension;
+    ext2 = ma_path_extension(path);
+
+#if defined(_MSC_VER) || defined(__DMC__)
+    return _stricmp(ext1, ext2) == 0;
+#else
+    return strcasecmp(ext1, ext2) == 0;
+#endif
+}
+
+static ma_bool32 ma_path_extension_equal_w(const wchar_t* path, const wchar_t* extension)
+{
+    const wchar_t* ext1;
+    const wchar_t* ext2;
+
+    if (path == NULL || extension == NULL) {
+        return MA_FALSE;
+    }
+
+    ext1 = extension;
+    ext2 = ma_path_extension_w(path);
+
+    #if (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__DMC__)) && !defined(MA_XBOX_NXDK)
+    {
+        return _wcsicmp(ext1, ext2) == 0;
+    }
+    #elif !defined(MA_XBOX_NXDK) && !defined(MA_DOS)
+    {
+        /*
+        I'm not aware of a wide character version of strcasecmp(). I'm therefore converting the extensions to multibyte strings and comparing those. This
+        isn't the most efficient way to do it, but it should work OK.
+        */
+        char ext1MB[4096];
+        char ext2MB[4096];
+        const wchar_t* pext1 = ext1;
+        const wchar_t* pext2 = ext2;
+        mbstate_t mbs1;
+        mbstate_t mbs2;
+
+        MA_ZERO_OBJECT(&mbs1);
+        MA_ZERO_OBJECT(&mbs2);
+
+        if (wcsrtombs(ext1MB, &pext1, sizeof(ext1MB), &mbs1) == (size_t)-1) {
+            return MA_FALSE;
+        }
+        if (wcsrtombs(ext2MB, &pext2, sizeof(ext2MB), &mbs2) == (size_t)-1) {
+            return MA_FALSE;
+        }
+
+        return strcasecmp(ext1MB, ext2MB) == 0;
+    }
+    #else
+    {
+        /* Getting here means we don't have a way to do a case-sensitive comparison for wide strings. Fall back to a simple case-sensitive comparison. */
+        /* TODO: Implement our own wchar_t-to-char conversion routine and then use the char* version for comparing. */
+        return ma_wcscmp(ext1, ext2) == 0;
+    }
+    #endif
+}
+#endif  /* MA_HAS_PATH_API */
+
+
+
+static ma_result ma_decoder__on_read_vfs(ma_decoder* pDecoder, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead)
+{
+    MA_ASSERT(pDecoder   != NULL);
+    MA_ASSERT(pBufferOut != NULL);
+
+    return ma_vfs_or_default_read(pDecoder->data.vfs.pVFS, pDecoder->data.vfs.file, pBufferOut, bytesToRead, pBytesRead);
+}
+
+static ma_result ma_decoder__on_seek_vfs(ma_decoder* pDecoder, ma_int64 offset, ma_seek_origin origin)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_vfs_or_default_seek(pDecoder->data.vfs.pVFS, pDecoder->data.vfs.file, offset, origin);
+}
+
+static ma_result ma_decoder__on_tell_vfs(ma_decoder* pDecoder, ma_int64* pCursor)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_vfs_or_default_tell(pDecoder->data.vfs.pVFS, pDecoder->data.vfs.file, pCursor);
+}
+
+static ma_result ma_decoder__preinit_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_vfs_file file;
+
+    result = ma_decoder__preinit(ma_decoder__on_read_vfs, ma_decoder__on_seek_vfs, ma_decoder__on_tell_vfs, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFilePath == NULL || pFilePath[0] == '\0') {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_vfs_or_default_open(pVFS, pFilePath, MA_OPEN_MODE_READ, &file);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDecoder->data.vfs.pVFS = pVFS;
+    pDecoder->data.vfs.file = file;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+    result = ma_decoder__preinit_vfs(pVFS, pFilePath, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis__internal(&config, pDecoder);
+        }
+    #endif
+
+        /* Make sure we seek back to the start if we didn't initialize a decoder successfully so the next attempts have a fresh start. */
+        if (result != MA_SUCCESS) {
+            ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_custom__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "wav")) {
+            result = ma_decoder_init_wav__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "flac")) {
+            result = ma_decoder_init_flac__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "mp3")) {
+            result = ma_decoder_init_mp3__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    }
+
+    /* If we still haven't got a result just use trial and error. Otherwise we can finish up. */
+    if (result != MA_SUCCESS) {
+        result = ma_decoder_init__internal(ma_decoder__on_read_vfs, ma_decoder__on_seek_vfs, NULL, &config, pDecoder);
+    } else {
+        result = ma_decoder__postinit(&config, pDecoder);
+    }
+
+    if (result != MA_SUCCESS) {
+        if (pDecoder->data.vfs.file != NULL) {   /* <-- Will be reset to NULL if ma_decoder_uninit() is called in one of the steps above which allows us to avoid a double close of the file. */
+            ma_vfs_or_default_close(pVFS, pDecoder->data.vfs.file);
+        }
+
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_decoder__preinit_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_vfs_file file;
+
+    result = ma_decoder__preinit(ma_decoder__on_read_vfs, ma_decoder__on_seek_vfs, ma_decoder__on_tell_vfs, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFilePath == NULL || pFilePath[0] == '\0') {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_vfs_or_default_open_w(pVFS, pFilePath, MA_OPEN_MODE_READ, &file);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDecoder->data.vfs.pVFS = pVFS;
+    pDecoder->data.vfs.file = file;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+    result = ma_decoder__preinit_vfs_w(pVFS, pFilePath, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis__internal(&config, pDecoder);
+        }
+    #endif
+
+        /* Make sure we seek back to the start if we didn't initialize a decoder successfully so the next attempts have a fresh start. */
+        if (result != MA_SUCCESS) {
+            ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_custom__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"wav")) {
+            result = ma_decoder_init_wav__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"flac")) {
+            result = ma_decoder_init_flac__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"mp3")) {
+            result = ma_decoder_init_mp3__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    }
+
+    /* If we still haven't got a result just use trial and error. Otherwise we can finish up. */
+    if (result != MA_SUCCESS) {
+        result = ma_decoder_init__internal(ma_decoder__on_read_vfs, ma_decoder__on_seek_vfs, NULL, &config, pDecoder);
+    } else {
+        result = ma_decoder__postinit(&config, pDecoder);
+    }
+
+    if (result != MA_SUCCESS) {
+        ma_vfs_or_default_close(pVFS, pDecoder->data.vfs.file);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_decoder__preinit_file(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+
+    result = ma_decoder__preinit(NULL, NULL, NULL, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFilePath == NULL || pFilePath[0] == '\0') {
+        return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_file(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+    result = ma_decoder__preinit_file(pFilePath, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* If the backend has support for loading from a file path we'll want to use that. If that all fails we'll fall back to the VFS path. */
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        result = ma_decoder_init_custom_from_file__internal(pFilePath, &config, pDecoder);
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (result != MA_SUCCESS && config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+        /* First try loading based on the file extension so we don't waste time opening and closing files. */
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "wav")) {
+            result = ma_decoder_init_wav_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "flac")) {
+            result = ma_decoder_init_flac_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "mp3")) {
+            result = ma_decoder_init_mp3_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "ogg")) {
+            result = ma_decoder_init_vorbis_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+
+        /*
+        If we still haven't got a result just use trial and error. Custom decoders have already been attempted, so here we
+        need only iterate over our stock decoders.
+        */
+        if (result != MA_SUCCESS) {
+        #ifdef MA_HAS_WAV
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_wav_from_file__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_FLAC
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_flac_from_file__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_MP3
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_mp3_from_file__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_VORBIS
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_vorbis_from_file__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        }
+    }
+
+    /*
+    If at this point we still haven't successfully initialized the decoder it most likely means
+    the backend doesn't have an implementation for loading from a file path. We'll try using
+    miniaudio's built-in file IO for loading file.
+    */
+    if (result == MA_SUCCESS) {
+        /* Initialization was successful. Finish up. */
+        result = ma_decoder__postinit(&config, pDecoder);
+        if (result != MA_SUCCESS) {
+            /*
+            The backend was initialized successfully, but for some reason post-initialization failed. This is most likely
+            due to an out of memory error. We're going to abort with an error here and not try to recover.
+            */
+            if (pDecoder->pBackendVTable != NULL && pDecoder->pBackendVTable->onUninit != NULL) {
+                pDecoder->pBackendVTable->onUninit(pDecoder->pBackendUserData, &pDecoder->pBackend, &pDecoder->allocationCallbacks);
+            }
+
+            return result;
+        }
+    } else {
+        /* Probably no implementation for loading from a file path. Use miniaudio's file IO instead. */
+        result = ma_decoder_init_vfs(NULL, pFilePath, pConfig, pDecoder);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__preinit_file_w(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+
+    result = ma_decoder__preinit(NULL, NULL, NULL, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFilePath == NULL || pFilePath[0] == '\0') {
+        return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_file_w(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+    result = ma_decoder__preinit_file_w(pFilePath, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* If the backend has support for loading from a file path we'll want to use that. If that all fails we'll fall back to the VFS path. */
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        result = ma_decoder_init_custom_from_file_w__internal(pFilePath, &config, pDecoder);
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (result != MA_SUCCESS && config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+        /* First try loading based on the file extension so we don't waste time opening and closing files. */
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"wav")) {
+            result = ma_decoder_init_wav_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"flac")) {
+            result = ma_decoder_init_flac_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"mp3")) {
+            result = ma_decoder_init_mp3_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"ogg")) {
+            result = ma_decoder_init_vorbis_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+
+        /*
+        If we still haven't got a result just use trial and error. Custom decoders have already been attempted, so here we
+        need only iterate over our stock decoders.
+        */
+        if (result != MA_SUCCESS) {
+        #ifdef MA_HAS_WAV
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_wav_from_file_w__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_FLAC
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_flac_from_file_w__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_MP3
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_mp3_from_file_w__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_VORBIS
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_vorbis_from_file_w__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        }
+    }
+
+    /*
+    If at this point we still haven't successfully initialized the decoder it most likely means
+    the backend doesn't have an implementation for loading from a file path. We'll try using
+    miniaudio's built-in file IO for loading file.
+    */
+    if (result == MA_SUCCESS) {
+        /* Initialization was successful. Finish up. */
+        result = ma_decoder__postinit(&config, pDecoder);
+        if (result != MA_SUCCESS) {
+            /*
+            The backend was initialized successfully, but for some reason post-initialization failed. This is most likely
+            due to an out of memory error. We're going to abort with an error here and not try to recover.
+            */
+            if (pDecoder->pBackendVTable != NULL && pDecoder->pBackendVTable->onUninit != NULL) {
+                pDecoder->pBackendVTable->onUninit(pDecoder->pBackendUserData, &pDecoder->pBackend, &pDecoder->allocationCallbacks);
+            }
+
+            return result;
+        }
+    } else {
+        /* Probably no implementation for loading from a file path. Use miniaudio's file IO instead. */
+        result = ma_decoder_init_vfs_w(NULL, pFilePath, pConfig, pDecoder);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_uninit(ma_decoder* pDecoder)
+{
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder->pBackend != NULL) {
+        if (pDecoder->pBackendVTable != NULL && pDecoder->pBackendVTable->onUninit != NULL) {
+            pDecoder->pBackendVTable->onUninit(pDecoder->pBackendUserData, pDecoder->pBackend, &pDecoder->allocationCallbacks);
+        }
+    }
+
+    if (pDecoder->onRead == ma_decoder__on_read_vfs) {
+        ma_vfs_or_default_close(pDecoder->data.vfs.pVFS, pDecoder->data.vfs.file);
+        pDecoder->data.vfs.file = NULL;
+    }
+
+    ma_data_converter_uninit(&pDecoder->converter, &pDecoder->allocationCallbacks);
+    ma_data_source_uninit(&pDecoder->ds);
+
+    if (pDecoder->pInputCache != NULL) {
+        ma_free(pDecoder->pInputCache, &pDecoder->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_read_pcm_frames(ma_decoder* pDecoder, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 totalFramesReadOut;
+    void* pRunningFramesOut;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;   /* Safety. */
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder->pBackend == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Fast path. */
+    if (pDecoder->converter.isPassthrough) {
+        result = ma_data_source_read_pcm_frames(pDecoder->pBackend, pFramesOut, frameCount, &totalFramesReadOut);
+    } else {
+        /*
+        Getting here means we need to do data conversion. If we're seeking forward and are _not_ doing resampling we can run this in a fast path. If we're doing resampling we
+        need to run through each sample because we need to ensure its internal cache is updated.
+        */
+        if (pFramesOut == NULL && pDecoder->converter.hasResampler == MA_FALSE) {
+            result = ma_data_source_read_pcm_frames(pDecoder->pBackend, NULL, frameCount, &totalFramesReadOut);
+        } else {
+            /* Slow path. Need to run everything through the data converter. */
+            ma_format internalFormat;
+            ma_uint32 internalChannels;
+
+            totalFramesReadOut = 0;
+            pRunningFramesOut  = pFramesOut;
+
+            result = ma_data_source_get_data_format(pDecoder->pBackend, &internalFormat, &internalChannels, NULL, NULL, 0);
+            if (result != MA_SUCCESS) {
+                return result;   /* Failed to retrieve the internal format and channel count. */
+            }
+
+            /*
+            We run a different path depending on whether or not we are using a heap-allocated
+            intermediary buffer or not. If the data converter does not support the calculation of
+            the required number of input frames, we'll use the heap-allocated path. Otherwise we'll
+            use the stack-allocated path.
+            */
+            if (pDecoder->pInputCache != NULL) {
+                /* We don't have a way of determining the required number of input frames, so need to persistently store input data in a cache. */
+                while (totalFramesReadOut < frameCount) {
+                    ma_uint64 framesToReadThisIterationIn;
+                    ma_uint64 framesToReadThisIterationOut;
+
+                    /* If there's any data available in the cache, that needs to get processed first. */
+                    if (pDecoder->inputCacheRemaining > 0) {
+                        framesToReadThisIterationOut = (frameCount - totalFramesReadOut);
+                        framesToReadThisIterationIn  = framesToReadThisIterationOut;
+                        if (framesToReadThisIterationIn > pDecoder->inputCacheRemaining) {
+                            framesToReadThisIterationIn = pDecoder->inputCacheRemaining;
+                        }
+
+                        result = ma_data_converter_process_pcm_frames(&pDecoder->converter, ma_offset_pcm_frames_ptr(pDecoder->pInputCache, pDecoder->inputCacheConsumed, internalFormat, internalChannels), &framesToReadThisIterationIn, pRunningFramesOut, &framesToReadThisIterationOut);
+                        if (result != MA_SUCCESS) {
+                            break;
+                        }
+
+                        pDecoder->inputCacheConsumed  += framesToReadThisIterationIn;
+                        pDecoder->inputCacheRemaining -= framesToReadThisIterationIn;
+
+                        totalFramesReadOut += framesToReadThisIterationOut;
+
+                        if (pRunningFramesOut != NULL) {
+                            pRunningFramesOut = ma_offset_ptr(pRunningFramesOut, framesToReadThisIterationOut * ma_get_bytes_per_frame(pDecoder->outputFormat, pDecoder->outputChannels));
+                        }
+
+                        if (framesToReadThisIterationIn == 0 && framesToReadThisIterationOut == 0) {
+                            break;  /* We're done. */
+                        }
+                    }
+
+                    /* Getting here means there's no data in the cache and we need to fill it up from the data source. */
+                    if (pDecoder->inputCacheRemaining == 0) {
+                        pDecoder->inputCacheConsumed = 0;
+
+                        result = ma_data_source_read_pcm_frames(pDecoder->pBackend, pDecoder->pInputCache, pDecoder->inputCacheCap, &pDecoder->inputCacheRemaining);
+                        if (result != MA_SUCCESS) {
+                            break;
+                        }
+                    }
+                }
+            } else {
+                /* We have a way of determining the required number of input frames so just use the stack. */
+                while (totalFramesReadOut < frameCount) {
+                    ma_uint8 pIntermediaryBuffer[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In internal format. */
+                    ma_uint64 intermediaryBufferCap = sizeof(pIntermediaryBuffer) / ma_get_bytes_per_frame(internalFormat, internalChannels);
+                    ma_uint64 framesToReadThisIterationIn;
+                    ma_uint64 framesReadThisIterationIn;
+                    ma_uint64 framesToReadThisIterationOut;
+                    ma_uint64 framesReadThisIterationOut;
+                    ma_uint64 requiredInputFrameCount;
+
+                    framesToReadThisIterationOut = (frameCount - totalFramesReadOut);
+                    framesToReadThisIterationIn = framesToReadThisIterationOut;
+                    if (framesToReadThisIterationIn > intermediaryBufferCap) {
+                        framesToReadThisIterationIn = intermediaryBufferCap;
+                    }
+
+                    ma_data_converter_get_required_input_frame_count(&pDecoder->converter, framesToReadThisIterationOut, &requiredInputFrameCount);
+                    if (framesToReadThisIterationIn > requiredInputFrameCount) {
+                        framesToReadThisIterationIn = requiredInputFrameCount;
+                    }
+
+                    if (requiredInputFrameCount > 0) {
+                        result = ma_data_source_read_pcm_frames(pDecoder->pBackend, pIntermediaryBuffer, framesToReadThisIterationIn, &framesReadThisIterationIn);
+
+                        /*
+                        Note here that even if we've reached the end, we don't want to abort because there might be more output frames needing to be
+                        generated from cached input data, which might happen if resampling is being performed.
+                        */
+                        if (result != MA_SUCCESS && result != MA_AT_END) {
+                            break;
+                        }
+                    } else {
+                        framesReadThisIterationIn = 0;
+                        pIntermediaryBuffer[0] = 0; /* <-- This is just to silence a static analysis warning. */
+                    }
+
+                    /*
+                    At this point we have our decoded data in input format and now we need to convert to output format. Note that even if we didn't read any
+                    input frames, we still want to try processing frames because there may some output frames generated from cached input data.
+                    */
+                    framesReadThisIterationOut = framesToReadThisIterationOut;
+                    result = ma_data_converter_process_pcm_frames(&pDecoder->converter, pIntermediaryBuffer, &framesReadThisIterationIn, pRunningFramesOut, &framesReadThisIterationOut);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    totalFramesReadOut += framesReadThisIterationOut;
+
+                    if (pRunningFramesOut != NULL) {
+                        pRunningFramesOut = ma_offset_ptr(pRunningFramesOut, framesReadThisIterationOut * ma_get_bytes_per_frame(pDecoder->outputFormat, pDecoder->outputChannels));
+                    }
+
+                    if (framesReadThisIterationIn == 0 && framesReadThisIterationOut == 0) {
+                        break;  /* We're done. */
+                    }
+                }
+            }
+        }
+    }
+
+    pDecoder->readPointerInPCMFrames += totalFramesReadOut;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesReadOut;
+    }
+
+    if (result == MA_SUCCESS && totalFramesReadOut == 0) {
+        result =  MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_decoder_seek_to_pcm_frame(ma_decoder* pDecoder, ma_uint64 frameIndex)
+{
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder->pBackend != NULL) {
+        ma_result result;
+        ma_uint64 internalFrameIndex;
+        ma_uint32 internalSampleRate;
+        ma_uint64 currentFrameIndex;
+
+        result = ma_data_source_get_data_format(pDecoder->pBackend, NULL, NULL, &internalSampleRate, NULL, 0);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to retrieve the internal sample rate. */
+        }
+
+        if (internalSampleRate == pDecoder->outputSampleRate) {
+            internalFrameIndex = frameIndex;
+        } else {
+            internalFrameIndex = ma_calculate_frame_count_after_resampling(internalSampleRate, pDecoder->outputSampleRate, frameIndex);
+        }
+
+        /* Only seek if we're requesting a different frame to what we're currently sitting on. */
+        ma_data_source_get_cursor_in_pcm_frames(pDecoder->pBackend, &currentFrameIndex);
+        if (currentFrameIndex != internalFrameIndex) {
+            result = ma_data_source_seek_to_pcm_frame(pDecoder->pBackend, internalFrameIndex);
+            if (result == MA_SUCCESS) {
+                pDecoder->readPointerInPCMFrames = frameIndex;
+            }
+
+            /* Reset the data converter so that any cached data in the resampler is cleared. */
+            ma_data_converter_reset(&pDecoder->converter);
+        }
+
+        return result;
+    }
+
+    /* Should never get here, but if we do it means onSeekToPCMFrame was not set by the backend. */
+    return MA_INVALID_ARGS;
+}
+
+MA_API ma_result ma_decoder_get_data_format(ma_decoder* pDecoder, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pDecoder->outputFormat;
+    }
+
+    if (pChannels != NULL) {
+        *pChannels = pDecoder->outputChannels;
+    }
+
+    if (pSampleRate != NULL) {
+        *pSampleRate = pDecoder->outputSampleRate;
+    }
+
+    if (pChannelMap != NULL) {
+        ma_data_converter_get_output_channel_map(&pDecoder->converter, pChannelMap, channelMapCap);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_get_cursor_in_pcm_frames(ma_decoder* pDecoder, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = pDecoder->readPointerInPCMFrames;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_get_length_in_pcm_frames(ma_decoder* pDecoder, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder->pBackend != NULL) {
+        ma_result result;
+        ma_uint64 internalLengthInPCMFrames;
+        ma_uint32 internalSampleRate;
+
+        result = ma_data_source_get_length_in_pcm_frames(pDecoder->pBackend, &internalLengthInPCMFrames);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to retrieve the internal length. */
+        }
+
+        result = ma_data_source_get_data_format(pDecoder->pBackend, NULL, NULL, &internalSampleRate, NULL, 0);
+        if (result != MA_SUCCESS) {
+            return result;   /* Failed to retrieve the internal sample rate. */
+        }
+
+        if (internalSampleRate == pDecoder->outputSampleRate) {
+            *pLength = internalLengthInPCMFrames;
+        } else {
+            *pLength = ma_calculate_frame_count_after_resampling(pDecoder->outputSampleRate, internalSampleRate, internalLengthInPCMFrames);
+        }
+
+        return MA_SUCCESS;
+    } else {
+        return MA_NO_BACKEND;
+    }
+}
+
+MA_API ma_result ma_decoder_get_available_frames(ma_decoder* pDecoder, ma_uint64* pAvailableFrames)
+{
+    ma_result result;
+    ma_uint64 totalFrameCount;
+
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_decoder_get_length_in_pcm_frames(pDecoder, &totalFrameCount);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (totalFrameCount <= pDecoder->readPointerInPCMFrames) {
+        *pAvailableFrames = 0;
+    } else {
+        *pAvailableFrames = totalFrameCount - pDecoder->readPointerInPCMFrames;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_decoder__full_decode_and_uninit(ma_decoder* pDecoder, ma_decoder_config* pConfigOut, ma_uint64* pFrameCountOut, void** ppPCMFramesOut)
+{
+    ma_result result;
+    ma_uint64 totalFrameCount;
+    ma_uint64 bpf;
+    ma_uint64 dataCapInFrames;
+    void* pPCMFramesOut;
+
+    MA_ASSERT(pDecoder != NULL);
+
+    totalFrameCount = 0;
+    bpf = ma_get_bytes_per_frame(pDecoder->outputFormat, pDecoder->outputChannels);
+
+    /* The frame count is unknown until we try reading. Thus, we just run in a loop. */
+    dataCapInFrames = 0;
+    pPCMFramesOut = NULL;
+    for (;;) {
+        ma_uint64 frameCountToTryReading;
+        ma_uint64 framesJustRead;
+
+        /* Make room if there's not enough. */
+        if (totalFrameCount == dataCapInFrames) {
+            void* pNewPCMFramesOut;
+            ma_uint64 newDataCapInFrames = dataCapInFrames*2;
+            if (newDataCapInFrames == 0) {
+                newDataCapInFrames = 4096;
+            }
+
+            if ((newDataCapInFrames * bpf) > MA_SIZE_MAX) {
+                ma_free(pPCMFramesOut, &pDecoder->allocationCallbacks);
+                return MA_TOO_BIG;
+            }
+
+            pNewPCMFramesOut = (void*)ma_realloc(pPCMFramesOut, (size_t)(newDataCapInFrames * bpf), &pDecoder->allocationCallbacks);
+            if (pNewPCMFramesOut == NULL) {
+                ma_free(pPCMFramesOut, &pDecoder->allocationCallbacks);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            dataCapInFrames = newDataCapInFrames;
+            pPCMFramesOut = pNewPCMFramesOut;
+        }
+
+        frameCountToTryReading = dataCapInFrames - totalFrameCount;
+        MA_ASSERT(frameCountToTryReading > 0);
+
+        result = ma_decoder_read_pcm_frames(pDecoder, (ma_uint8*)pPCMFramesOut + (totalFrameCount * bpf), frameCountToTryReading, &framesJustRead);
+        totalFrameCount += framesJustRead;
+
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        if (framesJustRead < frameCountToTryReading) {
+            break;
+        }
+    }
+
+
+    if (pConfigOut != NULL) {
+        pConfigOut->format     = pDecoder->outputFormat;
+        pConfigOut->channels   = pDecoder->outputChannels;
+        pConfigOut->sampleRate = pDecoder->outputSampleRate;
+    }
+
+    if (ppPCMFramesOut != NULL) {
+        *ppPCMFramesOut = pPCMFramesOut;
+    } else {
+        ma_free(pPCMFramesOut, &pDecoder->allocationCallbacks);
+    }
+
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = totalFrameCount;
+    }
+
+    ma_decoder_uninit(pDecoder);
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decode_from_vfs(ma_vfs* pVFS, const char* pFilePath, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut)
+{
+    ma_result result;
+    ma_decoder_config config;
+    ma_decoder decoder;
+
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = 0;
+    }
+    if (ppPCMFramesOut != NULL) {
+        *ppPCMFramesOut = NULL;
+    }
+
+    config = ma_decoder_config_init_copy(pConfig);
+
+    result = ma_decoder_init_vfs(pVFS, pFilePath, &config, &decoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_decoder__full_decode_and_uninit(&decoder, pConfig, pFrameCountOut, ppPCMFramesOut);
+
+    return result;
+}
+
+MA_API ma_result ma_decode_file(const char* pFilePath, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut)
+{
+    return ma_decode_from_vfs(NULL, pFilePath, pConfig, pFrameCountOut, ppPCMFramesOut);
+}
+
+MA_API ma_result ma_decode_memory(const void* pData, size_t dataSize, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut)
+{
+    ma_decoder_config config;
+    ma_decoder decoder;
+    ma_result result;
+
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = 0;
+    }
+    if (ppPCMFramesOut != NULL) {
+        *ppPCMFramesOut = NULL;
+    }
+
+    if (pData == NULL || dataSize == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    config = ma_decoder_config_init_copy(pConfig);
+
+    result = ma_decoder_init_memory(pData, dataSize, &config, &decoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_decoder__full_decode_and_uninit(&decoder, pConfig, pFrameCountOut, ppPCMFramesOut);
+}
+#endif  /* MA_NO_DECODING */
+
+
+#ifndef MA_NO_ENCODING
+
+#if defined(MA_HAS_WAV)
+static size_t ma_encoder__internal_on_write_wav(void* pUserData, const void* pData, size_t bytesToWrite)
+{
+    ma_encoder* pEncoder = (ma_encoder*)pUserData;
+    size_t bytesWritten = 0;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    pEncoder->onWrite(pEncoder, pData, bytesToWrite, &bytesWritten);
+    return bytesWritten;
+}
+
+static ma_bool32 ma_encoder__internal_on_seek_wav(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    ma_encoder* pEncoder = (ma_encoder*)pUserData;
+    ma_result result;
+    ma_seek_origin maSeekOrigin;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    maSeekOrigin = ma_seek_origin_start;
+    if (origin == MA_DR_WAV_SEEK_CUR) {
+        maSeekOrigin = ma_seek_origin_current;
+    } else if (origin == MA_DR_WAV_SEEK_END) {
+        maSeekOrigin = ma_seek_origin_end;
+    }
+
+    result = pEncoder->onSeek(pEncoder, offset, maSeekOrigin);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    } else {
+        return MA_TRUE;
+    }
+}
+
+static ma_result ma_encoder__on_init_wav(ma_encoder* pEncoder)
+{
+    ma_dr_wav_data_format wavFormat;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_dr_wav* pWav;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    pWav = (ma_dr_wav*)ma_malloc(sizeof(*pWav), &pEncoder->config.allocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    wavFormat.container     = ma_dr_wav_container_riff;
+    wavFormat.channels      = pEncoder->config.channels;
+    wavFormat.sampleRate    = pEncoder->config.sampleRate;
+    wavFormat.bitsPerSample = ma_get_bytes_per_sample(pEncoder->config.format) * 8;
+    if (pEncoder->config.format == ma_format_f32) {
+        wavFormat.format    = MA_DR_WAVE_FORMAT_IEEE_FLOAT;
+    } else {
+        wavFormat.format    = MA_DR_WAVE_FORMAT_PCM;
+    }
+
+    allocationCallbacks.pUserData = pEncoder->config.allocationCallbacks.pUserData;
+    allocationCallbacks.onMalloc  = pEncoder->config.allocationCallbacks.onMalloc;
+    allocationCallbacks.onRealloc = pEncoder->config.allocationCallbacks.onRealloc;
+    allocationCallbacks.onFree    = pEncoder->config.allocationCallbacks.onFree;
+
+    if (!ma_dr_wav_init_write(pWav, &wavFormat, ma_encoder__internal_on_write_wav, ma_encoder__internal_on_seek_wav, pEncoder, &allocationCallbacks)) {
+        return MA_ERROR;
+    }
+
+    pEncoder->pInternalEncoder = pWav;
+
+    return MA_SUCCESS;
+}
+
+static void ma_encoder__on_uninit_wav(ma_encoder* pEncoder)
+{
+    ma_dr_wav* pWav;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    pWav = (ma_dr_wav*)pEncoder->pInternalEncoder;
+    MA_ASSERT(pWav != NULL);
+
+    ma_dr_wav_uninit(pWav);
+    ma_free(pWav, &pEncoder->config.allocationCallbacks);
+}
+
+static ma_result ma_encoder__on_write_pcm_frames_wav(ma_encoder* pEncoder, const void* pFramesIn, ma_uint64 frameCount, ma_uint64* pFramesWritten)
+{
+    ma_dr_wav* pWav;
+    ma_uint64 framesWritten;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    pWav = (ma_dr_wav*)pEncoder->pInternalEncoder;
+    MA_ASSERT(pWav != NULL);
+
+    framesWritten = ma_dr_wav_write_pcm_frames(pWav, frameCount, pFramesIn);
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = framesWritten;
+    }
+
+    return MA_SUCCESS;
+}
+#endif
+
+MA_API ma_encoder_config ma_encoder_config_init(ma_encoding_format encodingFormat, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    ma_encoder_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.encodingFormat = encodingFormat;
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+
+    return config;
+}
+
+MA_API ma_result ma_encoder_preinit(const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    ma_result result;
+
+    if (pEncoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pEncoder);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->format == ma_format_unknown || pConfig->channels == 0 || pConfig->sampleRate == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pEncoder->config = *pConfig;
+
+    result = ma_allocation_callbacks_init_copy(&pEncoder->config.allocationCallbacks, &pConfig->allocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_encoder_init__internal(ma_encoder_write_proc onWrite, ma_encoder_seek_proc onSeek, void* pUserData, ma_encoder* pEncoder)
+{
+    ma_result result = MA_SUCCESS;
+
+    /* This assumes ma_encoder_preinit() has been called prior. */
+    MA_ASSERT(pEncoder != NULL);
+
+    if (onWrite == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pEncoder->onWrite   = onWrite;
+    pEncoder->onSeek    = onSeek;
+    pEncoder->pUserData = pUserData;
+
+    switch (pEncoder->config.encodingFormat)
+    {
+        case ma_encoding_format_wav:
+        {
+        #if defined(MA_HAS_WAV)
+            pEncoder->onInit           = ma_encoder__on_init_wav;
+            pEncoder->onUninit         = ma_encoder__on_uninit_wav;
+            pEncoder->onWritePCMFrames = ma_encoder__on_write_pcm_frames_wav;
+        #else
+            result = MA_NO_BACKEND;
+        #endif
+        } break;
+
+        default:
+        {
+            result = MA_INVALID_ARGS;
+        } break;
+    }
+
+    /* Getting here means we should have our backend callbacks set up. */
+    if (result == MA_SUCCESS) {
+        result = pEncoder->onInit(pEncoder);
+    }
+
+    return result;
+}
+
+static ma_result ma_encoder__on_write_vfs(ma_encoder* pEncoder, const void* pBufferIn, size_t bytesToWrite, size_t* pBytesWritten)
+{
+    return ma_vfs_or_default_write(pEncoder->data.vfs.pVFS, pEncoder->data.vfs.file, pBufferIn, bytesToWrite, pBytesWritten);
+}
+
+static ma_result ma_encoder__on_seek_vfs(ma_encoder* pEncoder, ma_int64 offset, ma_seek_origin origin)
+{
+    return ma_vfs_or_default_seek(pEncoder->data.vfs.pVFS, pEncoder->data.vfs.file, offset, origin);
+}
+
+MA_API ma_result ma_encoder_init_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    ma_result result;
+    ma_vfs_file file;
+
+    result = ma_encoder_preinit(pConfig, pEncoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Now open the file. If this fails we don't need to uninitialize the encoder. */
+    result = ma_vfs_or_default_open(pVFS, pFilePath, MA_OPEN_MODE_WRITE, &file);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pEncoder->data.vfs.pVFS = pVFS;
+    pEncoder->data.vfs.file = file;
+
+    result = ma_encoder_init__internal(ma_encoder__on_write_vfs, ma_encoder__on_seek_vfs, NULL, pEncoder);
+    if (result != MA_SUCCESS) {
+        ma_vfs_or_default_close(pVFS, file);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_encoder_init_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    ma_result result;
+    ma_vfs_file file;
+
+    result = ma_encoder_preinit(pConfig, pEncoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Now open the file. If this fails we don't need to uninitialize the encoder. */
+    result = ma_vfs_or_default_open_w(pVFS, pFilePath, MA_OPEN_MODE_WRITE, &file);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pEncoder->data.vfs.pVFS = pVFS;
+    pEncoder->data.vfs.file = file;
+
+    result = ma_encoder_init__internal(ma_encoder__on_write_vfs, ma_encoder__on_seek_vfs, NULL, pEncoder);
+    if (result != MA_SUCCESS) {
+        ma_vfs_or_default_close(pVFS, file);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_encoder_init_file(const char* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    return ma_encoder_init_vfs(NULL, pFilePath, pConfig, pEncoder);
+}
+
+MA_API ma_result ma_encoder_init_file_w(const wchar_t* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    return ma_encoder_init_vfs_w(NULL, pFilePath, pConfig, pEncoder);
+}
+
+MA_API ma_result ma_encoder_init(ma_encoder_write_proc onWrite, ma_encoder_seek_proc onSeek, void* pUserData, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    ma_result result;
+
+    result = ma_encoder_preinit(pConfig, pEncoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_encoder_init__internal(onWrite, onSeek, pUserData, pEncoder);
+}
+
+
+MA_API void ma_encoder_uninit(ma_encoder* pEncoder)
+{
+    if (pEncoder == NULL) {
+        return;
+    }
+
+    if (pEncoder->onUninit) {
+        pEncoder->onUninit(pEncoder);
+    }
+
+    /* If we have a file handle, close it. */
+    if (pEncoder->onWrite == ma_encoder__on_write_vfs) {
+        ma_vfs_or_default_close(pEncoder->data.vfs.pVFS, pEncoder->data.vfs.file);
+        pEncoder->data.vfs.file = NULL;
+    }
+}
+
+
+MA_API ma_result ma_encoder_write_pcm_frames(ma_encoder* pEncoder, const void* pFramesIn, ma_uint64 frameCount, ma_uint64* pFramesWritten)
+{
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    if (pEncoder == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return pEncoder->onWritePCMFrames(pEncoder, pFramesIn, frameCount, pFramesWritten);
+}
+#endif  /* MA_NO_ENCODING */
+
+
+
+/**************************************************************************************************************************************************************
+
+Generation
+
+**************************************************************************************************************************************************************/
+#ifndef MA_NO_GENERATION
+MA_API ma_waveform_config ma_waveform_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_waveform_type type, double amplitude, double frequency)
+{
+    ma_waveform_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.type       = type;
+    config.amplitude  = amplitude;
+    config.frequency  = frequency;
+
+    return config;
+}
+
+static ma_result ma_waveform__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_waveform_read_pcm_frames((ma_waveform*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_waveform__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_waveform_seek_to_pcm_frame((ma_waveform*)pDataSource, frameIndex);
+}
+
+static ma_result ma_waveform__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_waveform* pWaveform = (ma_waveform*)pDataSource;
+
+    *pFormat     = pWaveform->config.format;
+    *pChannels   = pWaveform->config.channels;
+    *pSampleRate = pWaveform->config.sampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pWaveform->config.channels);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_waveform__data_source_on_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    ma_waveform* pWaveform = (ma_waveform*)pDataSource;
+
+    *pCursor = (ma_uint64)(pWaveform->time / pWaveform->advance);
+
+    return MA_SUCCESS;
+}
+
+static double ma_waveform__calculate_advance(ma_uint32 sampleRate, double frequency)
+{
+    return (1.0 / (sampleRate / frequency));
+}
+
+static void ma_waveform__update_advance(ma_waveform* pWaveform)
+{
+    pWaveform->advance = ma_waveform__calculate_advance(pWaveform->config.sampleRate, pWaveform->config.frequency);
+}
+
+static ma_data_source_vtable g_ma_waveform_data_source_vtable =
+{
+    ma_waveform__data_source_on_read,
+    ma_waveform__data_source_on_seek,
+    ma_waveform__data_source_on_get_data_format,
+    ma_waveform__data_source_on_get_cursor,
+    NULL,   /* onGetLength. There's no notion of a length in waveforms. */
+    NULL,   /* onSetLooping */
+    0
+};
+
+MA_API ma_result ma_waveform_init(const ma_waveform_config* pConfig, ma_waveform* pWaveform)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pWaveform);
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_waveform_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pWaveform->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pWaveform->config  = *pConfig;
+    pWaveform->advance = ma_waveform__calculate_advance(pWaveform->config.sampleRate, pWaveform->config.frequency);
+    pWaveform->time    = 0;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_waveform_uninit(ma_waveform* pWaveform)
+{
+    if (pWaveform == NULL) {
+        return;
+    }
+
+    ma_data_source_uninit(&pWaveform->ds);
+}
+
+MA_API ma_result ma_waveform_set_amplitude(ma_waveform* pWaveform, double amplitude)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.amplitude = amplitude;
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_waveform_set_frequency(ma_waveform* pWaveform, double frequency)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.frequency = frequency;
+    ma_waveform__update_advance(pWaveform);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_waveform_set_type(ma_waveform* pWaveform, ma_waveform_type type)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.type = type;
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_waveform_set_sample_rate(ma_waveform* pWaveform, ma_uint32 sampleRate)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.sampleRate = sampleRate;
+    ma_waveform__update_advance(pWaveform);
+
+    return MA_SUCCESS;
+}
+
+static float ma_waveform_sine_f32(double time, double amplitude)
+{
+    return (float)(ma_sind(MA_TAU_D * time) * amplitude);
+}
+
+static ma_int16 ma_waveform_sine_s16(double time, double amplitude)
+{
+    return ma_pcm_sample_f32_to_s16(ma_waveform_sine_f32(time, amplitude));
+}
+
+static float ma_waveform_square_f32(double time, double dutyCycle, double amplitude)
+{
+    double f = time - (ma_int64)time;
+    double r;
+
+    if (f < dutyCycle) {
+        r =  amplitude;
+    } else {
+        r = -amplitude;
+    }
+
+    return (float)r;
+}
+
+static ma_int16 ma_waveform_square_s16(double time, double dutyCycle, double amplitude)
+{
+    return ma_pcm_sample_f32_to_s16(ma_waveform_square_f32(time, dutyCycle, amplitude));
+}
+
+static float ma_waveform_triangle_f32(double time, double amplitude)
+{
+    double f = time - (ma_int64)time;
+    double r;
+
+    r = 2 * ma_abs(2 * (f - 0.5)) - 1;
+
+    return (float)(r * amplitude);
+}
+
+static ma_int16 ma_waveform_triangle_s16(double time, double amplitude)
+{
+    return ma_pcm_sample_f32_to_s16(ma_waveform_triangle_f32(time, amplitude));
+}
+
+static float ma_waveform_sawtooth_f32(double time, double amplitude)
+{
+    double f = time - (ma_int64)time;
+    double r;
+
+    r = 2 * (f - 0.5);
+
+    return (float)(r * amplitude);
+}
+
+static ma_int16 ma_waveform_sawtooth_s16(double time, double amplitude)
+{
+    return ma_pcm_sample_f32_to_s16(ma_waveform_sawtooth_f32(time, amplitude));
+}
+
+static void ma_waveform_read_pcm_frames__sine(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint64 iChannel;
+    ma_uint32 bps = ma_get_bytes_per_sample(pWaveform->config.format);
+    ma_uint32 bpf = bps * pWaveform->config.channels;
+
+    MA_ASSERT(pWaveform  != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pWaveform->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_sine_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutF32[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else if (pWaveform->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_int16 s = ma_waveform_sine_s16(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutS16[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else {
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_sine_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pWaveform->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+            }
+        }
+    }
+}
+
+static void ma_waveform_read_pcm_frames__square(ma_waveform* pWaveform, double dutyCycle, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint64 iChannel;
+    ma_uint32 bps = ma_get_bytes_per_sample(pWaveform->config.format);
+    ma_uint32 bpf = bps * pWaveform->config.channels;
+
+    MA_ASSERT(pWaveform  != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pWaveform->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_square_f32(pWaveform->time, dutyCycle, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutF32[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else if (pWaveform->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_int16 s = ma_waveform_square_s16(pWaveform->time, dutyCycle, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutS16[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else {
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_square_f32(pWaveform->time, dutyCycle, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pWaveform->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+            }
+        }
+    }
+}
+
+static void ma_waveform_read_pcm_frames__triangle(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint64 iChannel;
+    ma_uint32 bps = ma_get_bytes_per_sample(pWaveform->config.format);
+    ma_uint32 bpf = bps * pWaveform->config.channels;
+
+    MA_ASSERT(pWaveform  != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pWaveform->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_triangle_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutF32[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else if (pWaveform->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_int16 s = ma_waveform_triangle_s16(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutS16[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else {
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_triangle_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pWaveform->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+            }
+        }
+    }
+}
+
+static void ma_waveform_read_pcm_frames__sawtooth(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint64 iChannel;
+    ma_uint32 bps = ma_get_bytes_per_sample(pWaveform->config.format);
+    ma_uint32 bpf = bps * pWaveform->config.channels;
+
+    MA_ASSERT(pWaveform  != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pWaveform->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_sawtooth_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutF32[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else if (pWaveform->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_int16 s = ma_waveform_sawtooth_s16(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutS16[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else {
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_sawtooth_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pWaveform->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+            }
+        }
+    }
+}
+
+MA_API ma_result ma_waveform_read_pcm_frames(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFramesOut != NULL) {
+        switch (pWaveform->config.type)
+        {
+            case ma_waveform_type_sine:
+            {
+                ma_waveform_read_pcm_frames__sine(pWaveform, pFramesOut, frameCount);
+            } break;
+
+            case ma_waveform_type_square:
+            {
+                ma_waveform_read_pcm_frames__square(pWaveform, 0.5, pFramesOut, frameCount);
+            } break;
+
+            case ma_waveform_type_triangle:
+            {
+                ma_waveform_read_pcm_frames__triangle(pWaveform, pFramesOut, frameCount);
+            } break;
+
+            case ma_waveform_type_sawtooth:
+            {
+                ma_waveform_read_pcm_frames__sawtooth(pWaveform, pFramesOut, frameCount);
+            } break;
+
+            default: return MA_INVALID_OPERATION;   /* Unknown waveform type. */
+        }
+    } else {
+        pWaveform->time += pWaveform->advance * (ma_int64)frameCount; /* Cast to int64 required for VC6. Won't affect anything in practice. */
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_waveform_seek_to_pcm_frame(ma_waveform* pWaveform, ma_uint64 frameIndex)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->time = pWaveform->advance * (ma_int64)frameIndex;    /* Casting for VC6. Won't be an issue in practice. */
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_pulsewave_config ma_pulsewave_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double dutyCycle, double amplitude, double frequency)
+{
+    ma_pulsewave_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.dutyCycle  = dutyCycle;
+    config.amplitude  = amplitude;
+    config.frequency  = frequency;
+
+    return config;
+}
+
+MA_API ma_result ma_pulsewave_init(const ma_pulsewave_config* pConfig, ma_pulsewave* pWaveform)
+{
+    ma_result result;
+    ma_waveform_config config;
+
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pWaveform);
+
+    config = ma_waveform_config_init(
+        pConfig->format,
+        pConfig->channels,
+        pConfig->sampleRate,
+        ma_waveform_type_square,
+        pConfig->amplitude,
+        pConfig->frequency
+    );
+
+    result = ma_waveform_init(&config, &pWaveform->waveform);
+    ma_pulsewave_set_duty_cycle(pWaveform, pConfig->dutyCycle);
+
+    return result;
+}
+
+MA_API void ma_pulsewave_uninit(ma_pulsewave* pWaveform)
+{
+    if (pWaveform == NULL) {
+        return;
+    }
+
+    ma_waveform_uninit(&pWaveform->waveform);
+}
+
+MA_API ma_result ma_pulsewave_read_pcm_frames(ma_pulsewave* pWaveform, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFramesOut != NULL) {
+        ma_waveform_read_pcm_frames__square(&pWaveform->waveform, pWaveform->config.dutyCycle, pFramesOut, frameCount);
+    } else {
+        pWaveform->waveform.time += pWaveform->waveform.advance * (ma_int64)frameCount; /* Cast to int64 required for VC6. Won't affect anything in practice. */
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_seek_to_pcm_frame(ma_pulsewave* pWaveform, ma_uint64 frameIndex)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_waveform_seek_to_pcm_frame(&pWaveform->waveform, frameIndex);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_set_amplitude(ma_pulsewave* pWaveform, double amplitude)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.amplitude = amplitude;
+    ma_waveform_set_amplitude(&pWaveform->waveform, amplitude);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_set_frequency(ma_pulsewave* pWaveform, double frequency)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.frequency = frequency;
+    ma_waveform_set_frequency(&pWaveform->waveform, frequency);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_set_sample_rate(ma_pulsewave* pWaveform, ma_uint32 sampleRate)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.sampleRate = sampleRate;
+    ma_waveform_set_sample_rate(&pWaveform->waveform, sampleRate);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_set_duty_cycle(ma_pulsewave* pWaveform, double dutyCycle)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.dutyCycle = dutyCycle;
+
+    return MA_SUCCESS;
+}
+
+
+
+MA_API ma_noise_config ma_noise_config_init(ma_format format, ma_uint32 channels, ma_noise_type type, ma_int32 seed, double amplitude)
+{
+    ma_noise_config config;
+    MA_ZERO_OBJECT(&config);
+
+    config.format    = format;
+    config.channels  = channels;
+    config.type      = type;
+    config.seed      = seed;
+    config.amplitude = amplitude;
+
+    if (config.seed == 0) {
+        config.seed = MA_DEFAULT_LCG_SEED;
+    }
+
+    return config;
+}
+
+
+static ma_result ma_noise__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_noise_read_pcm_frames((ma_noise*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_noise__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    /* No-op. Just pretend to be successful. */
+    (void)pDataSource;
+    (void)frameIndex;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_noise__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_noise* pNoise = (ma_noise*)pDataSource;
+
+    *pFormat     = pNoise->config.format;
+    *pChannels   = pNoise->config.channels;
+    *pSampleRate = 0;   /* There is no notion of sample rate with noise generation. */
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pNoise->config.channels);
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable g_ma_noise_data_source_vtable =
+{
+    ma_noise__data_source_on_read,
+    ma_noise__data_source_on_seek,  /* No-op for noise. */
+    ma_noise__data_source_on_get_data_format,
+    NULL,   /* onGetCursor. No notion of a cursor for noise. */
+    NULL,   /* onGetLength. No notion of a length for noise. */
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+#ifndef MA_PINK_NOISE_BIN_SIZE
+#define MA_PINK_NOISE_BIN_SIZE 16
+#endif
+
+typedef struct
+{
+    size_t sizeInBytes;
+    struct
+    {
+        size_t binOffset;
+        size_t accumulationOffset;
+        size_t counterOffset;
+    } pink;
+    struct
+    {
+        size_t accumulationOffset;
+    } brownian;
+} ma_noise_heap_layout;
+
+static ma_result ma_noise_get_heap_layout(const ma_noise_config* pConfig, ma_noise_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Pink. */
+    if (pConfig->type == ma_noise_type_pink) {
+        /* bin */
+        pHeapLayout->pink.binOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += sizeof(double*) * pConfig->channels;
+        pHeapLayout->sizeInBytes += sizeof(double ) * pConfig->channels * MA_PINK_NOISE_BIN_SIZE;
+
+        /* accumulation */
+        pHeapLayout->pink.accumulationOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += sizeof(double) * pConfig->channels;
+
+        /* counter */
+        pHeapLayout->pink.counterOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += sizeof(ma_uint32) * pConfig->channels;
+    }
+
+    /* Brownian. */
+    if (pConfig->type == ma_noise_type_brownian) {
+        /* accumulation */
+        pHeapLayout->brownian.accumulationOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += sizeof(double) * pConfig->channels;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_noise_get_heap_size(const ma_noise_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_noise_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_noise_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_noise_init_preallocated(const ma_noise_config* pConfig, void* pHeap, ma_noise* pNoise)
+{
+    ma_result result;
+    ma_noise_heap_layout heapLayout;
+    ma_data_source_config dataSourceConfig;
+    ma_uint32 iChannel;
+
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNoise);
+
+    result = ma_noise_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pNoise->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pNoise->_pHeap, heapLayout.sizeInBytes);
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_noise_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pNoise->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pNoise->config = *pConfig;
+    ma_lcg_seed(&pNoise->lcg, pConfig->seed);
+
+    if (pNoise->config.type == ma_noise_type_pink) {
+        pNoise->state.pink.bin          = (double**  )ma_offset_ptr(pHeap, heapLayout.pink.binOffset);
+        pNoise->state.pink.accumulation = (double*   )ma_offset_ptr(pHeap, heapLayout.pink.accumulationOffset);
+        pNoise->state.pink.counter      = (ma_uint32*)ma_offset_ptr(pHeap, heapLayout.pink.counterOffset);
+
+        for (iChannel = 0; iChannel < pConfig->channels; iChannel += 1) {
+            pNoise->state.pink.bin[iChannel]          = (double*)ma_offset_ptr(pHeap, heapLayout.pink.binOffset + (sizeof(double*) * pConfig->channels) + (sizeof(double) * MA_PINK_NOISE_BIN_SIZE * iChannel));
+            pNoise->state.pink.accumulation[iChannel] = 0;
+            pNoise->state.pink.counter[iChannel]      = 1;
+        }
+    }
+
+    if (pNoise->config.type == ma_noise_type_brownian) {
+        pNoise->state.brownian.accumulation = (double*)ma_offset_ptr(pHeap, heapLayout.brownian.accumulationOffset);
+
+        for (iChannel = 0; iChannel < pConfig->channels; iChannel += 1) {
+            pNoise->state.brownian.accumulation[iChannel] = 0;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_noise_init(const ma_noise_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_noise* pNoise)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_noise_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_noise_init_preallocated(pConfig, pHeap, pNoise);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pNoise->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_noise_uninit(ma_noise* pNoise, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pNoise == NULL) {
+        return;
+    }
+
+    ma_data_source_uninit(&pNoise->ds);
+
+    if (pNoise->_ownsHeap) {
+        ma_free(pNoise->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_noise_set_amplitude(ma_noise* pNoise, double amplitude)
+{
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pNoise->config.amplitude = amplitude;
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_noise_set_seed(ma_noise* pNoise, ma_int32 seed)
+{
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pNoise->lcg.state = seed;
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_noise_set_type(ma_noise* pNoise, ma_noise_type type)
+{
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    This function should never have been implemented in the first place. Changing the type dynamically is not
+    supported. Instead you need to uninitialize and reinitialize a fresh `ma_noise` object. This function
+    will be removed in version 0.12.
+    */
+    MA_ASSERT(MA_FALSE);
+    (void)type;
+
+    return MA_INVALID_OPERATION;
+}
+
+static MA_INLINE float ma_noise_f32_white(ma_noise* pNoise)
+{
+    return (float)(ma_lcg_rand_f64(&pNoise->lcg) * pNoise->config.amplitude);
+}
+
+static MA_INLINE ma_int16 ma_noise_s16_white(ma_noise* pNoise)
+{
+    return ma_pcm_sample_f32_to_s16(ma_noise_f32_white(pNoise));
+}
+
+static MA_INLINE ma_uint64 ma_noise_read_pcm_frames__white(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+    const ma_uint32 channels = pNoise->config.channels;
+    MA_ASSUME(channels > 0);
+
+    if (pNoise->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_white(pNoise);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = ma_noise_f32_white(pNoise);
+                }
+            }
+        }
+    } else if (pNoise->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_int16 s = ma_noise_s16_white(pNoise);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = ma_noise_s16_white(pNoise);
+                }
+            }
+        }
+    } else {
+        const ma_uint32 bps = ma_get_bytes_per_sample(pNoise->config.format);
+        const ma_uint32 bpf = bps * channels;
+
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_white(pNoise);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    float s = ma_noise_f32_white(pNoise);
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        }
+    }
+
+    return frameCount;
+}
+
+
+static MA_INLINE unsigned int ma_tzcnt32(unsigned int x)
+{
+    unsigned int n;
+
+    /* Special case for odd numbers since they should happen about half the time. */
+    if (x & 0x1)  {
+        return 0;
+    }
+
+    if (x == 0) {
+        return sizeof(x) << 3;
+    }
+
+    n = 1;
+    if ((x & 0x0000FFFF) == 0) { x >>= 16; n += 16; }
+    if ((x & 0x000000FF) == 0) { x >>=  8; n +=  8; }
+    if ((x & 0x0000000F) == 0) { x >>=  4; n +=  4; }
+    if ((x & 0x00000003) == 0) { x >>=  2; n +=  2; }
+    n -= x & 0x00000001;
+
+    return n;
+}
+
+/*
+Pink noise generation based on Tonic (public domain) with modifications. https://github.com/TonicAudio/Tonic/blob/master/src/Tonic/Noise.h
+
+This is basically _the_ reference for pink noise from what I've found: http://www.firstpr.com.au/dsp/pink-noise/
+*/
+static MA_INLINE float ma_noise_f32_pink(ma_noise* pNoise, ma_uint32 iChannel)
+{
+    double result;
+    double binPrev;
+    double binNext;
+    unsigned int ibin;
+
+    ibin = ma_tzcnt32(pNoise->state.pink.counter[iChannel]) & (MA_PINK_NOISE_BIN_SIZE - 1);
+
+    binPrev = pNoise->state.pink.bin[iChannel][ibin];
+    binNext = ma_lcg_rand_f64(&pNoise->lcg);
+    pNoise->state.pink.bin[iChannel][ibin] = binNext;
+
+    pNoise->state.pink.accumulation[iChannel] += (binNext - binPrev);
+    pNoise->state.pink.counter[iChannel]      += 1;
+
+    result = (ma_lcg_rand_f64(&pNoise->lcg) + pNoise->state.pink.accumulation[iChannel]);
+    result /= 10;
+
+    return (float)(result * pNoise->config.amplitude);
+}
+
+static MA_INLINE ma_int16 ma_noise_s16_pink(ma_noise* pNoise, ma_uint32 iChannel)
+{
+    return ma_pcm_sample_f32_to_s16(ma_noise_f32_pink(pNoise, iChannel));
+}
+
+static MA_INLINE ma_uint64 ma_noise_read_pcm_frames__pink(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+    const ma_uint32 channels = pNoise->config.channels;
+    MA_ASSUME(channels > 0);
+
+    if (pNoise->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_pink(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = ma_noise_f32_pink(pNoise, iChannel);
+                }
+            }
+        }
+    } else if (pNoise->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_int16 s = ma_noise_s16_pink(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = ma_noise_s16_pink(pNoise, iChannel);
+                }
+            }
+        }
+    } else {
+        const ma_uint32 bps = ma_get_bytes_per_sample(pNoise->config.format);
+        const ma_uint32 bpf = bps * channels;
+
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_pink(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    float s = ma_noise_f32_pink(pNoise, iChannel);
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        }
+    }
+
+    return frameCount;
+}
+
+
+static MA_INLINE float ma_noise_f32_brownian(ma_noise* pNoise, ma_uint32 iChannel)
+{
+    double result;
+
+    result = (ma_lcg_rand_f64(&pNoise->lcg) + pNoise->state.brownian.accumulation[iChannel]);
+    result /= 1.005; /* Don't escape the -1..1 range on average. */
+
+    pNoise->state.brownian.accumulation[iChannel] = result;
+    result /= 20;
+
+    return (float)(result * pNoise->config.amplitude);
+}
+
+static MA_INLINE ma_int16 ma_noise_s16_brownian(ma_noise* pNoise, ma_uint32 iChannel)
+{
+    return ma_pcm_sample_f32_to_s16(ma_noise_f32_brownian(pNoise, iChannel));
+}
+
+static MA_INLINE ma_uint64 ma_noise_read_pcm_frames__brownian(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+    const ma_uint32 channels = pNoise->config.channels;
+    MA_ASSUME(channels > 0);
+
+    if (pNoise->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_brownian(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = ma_noise_f32_brownian(pNoise, iChannel);
+                }
+            }
+        }
+    } else if (pNoise->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_int16 s = ma_noise_s16_brownian(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = ma_noise_s16_brownian(pNoise, iChannel);
+                }
+            }
+        }
+    } else {
+        const ma_uint32 bps = ma_get_bytes_per_sample(pNoise->config.format);
+        const ma_uint32 bpf = bps * channels;
+
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_brownian(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    float s = ma_noise_f32_brownian(pNoise, iChannel);
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        }
+    }
+
+    return frameCount;
+}
+
+MA_API ma_result ma_noise_read_pcm_frames(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_uint64 framesRead = 0;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The output buffer is allowed to be NULL. Since we aren't tracking cursors or anything we can just do nothing and pretend to be successful. */
+    if (pFramesOut == NULL) {
+        framesRead = frameCount;
+    } else {
+        switch (pNoise->config.type) {
+            case ma_noise_type_white:    framesRead = ma_noise_read_pcm_frames__white   (pNoise, pFramesOut, frameCount); break;
+            case ma_noise_type_pink:     framesRead = ma_noise_read_pcm_frames__pink    (pNoise, pFramesOut, frameCount); break;
+            case ma_noise_type_brownian: framesRead = ma_noise_read_pcm_frames__brownian(pNoise, pFramesOut, frameCount); break;
+            default: return MA_INVALID_OPERATION;   /* Unknown noise type. */
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    return MA_SUCCESS;
+}
+#endif /* MA_NO_GENERATION */
+
+
+
+#ifndef MA_NO_RESOURCE_MANAGER
+#ifndef MA_RESOURCE_MANAGER_PAGE_SIZE_IN_MILLISECONDS
+#define MA_RESOURCE_MANAGER_PAGE_SIZE_IN_MILLISECONDS   1000
+#endif
+
+#ifndef MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_CAPACITY
+#define MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_CAPACITY          1024
+#endif
+
+MA_API ma_resource_manager_pipeline_notifications ma_resource_manager_pipeline_notifications_init(void)
+{
+    ma_resource_manager_pipeline_notifications notifications;
+
+    MA_ZERO_OBJECT(&notifications);
+
+    return notifications;
+}
+
+static void ma_resource_manager_pipeline_notifications_signal_all_notifications(const ma_resource_manager_pipeline_notifications* pPipelineNotifications)
+{
+    if (pPipelineNotifications == NULL) {
+        return;
+    }
+
+    if (pPipelineNotifications->init.pNotification) { ma_async_notification_signal(pPipelineNotifications->init.pNotification); }
+    if (pPipelineNotifications->done.pNotification) { ma_async_notification_signal(pPipelineNotifications->done.pNotification); }
+}
+
+static void ma_resource_manager_pipeline_notifications_acquire_all_fences(const ma_resource_manager_pipeline_notifications* pPipelineNotifications)
+{
+    if (pPipelineNotifications == NULL) {
+        return;
+    }
+
+    if (pPipelineNotifications->init.pFence != NULL) { ma_fence_acquire(pPipelineNotifications->init.pFence); }
+    if (pPipelineNotifications->done.pFence != NULL) { ma_fence_acquire(pPipelineNotifications->done.pFence); }
+}
+
+static void ma_resource_manager_pipeline_notifications_release_all_fences(const ma_resource_manager_pipeline_notifications* pPipelineNotifications)
+{
+    if (pPipelineNotifications == NULL) {
+        return;
+    }
+
+    if (pPipelineNotifications->init.pFence != NULL) { ma_fence_release(pPipelineNotifications->init.pFence); }
+    if (pPipelineNotifications->done.pFence != NULL) { ma_fence_release(pPipelineNotifications->done.pFence); }
+}
+
+
+
+#ifndef MA_DEFAULT_HASH_SEED
+#define MA_DEFAULT_HASH_SEED    42
+#endif
+
+/* MurmurHash3. Based on code from https://github.com/PeterScott/murmur3/blob/master/murmur3.c (public domain). */
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+    #if __GNUC__ >= 7
+    #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+    #endif
+#endif
+
+static MA_INLINE ma_uint32 ma_rotl32(ma_uint32 x, ma_int8 r)
+{
+    return (x << r) | (x >> (32 - r));
+}
+
+static MA_INLINE ma_uint32 ma_hash_getblock(const ma_uint32* blocks, int i)
+{
+    ma_uint32 block;
+
+    /* Try silencing a sanitization warning about unaligned access by doing a memcpy() instead of assignment. */
+    MA_COPY_MEMORY(&block, ma_offset_ptr(blocks, i * (int) sizeof(block)), sizeof(block));
+
+    if (ma_is_little_endian()) {
+        return block;
+    } else {
+        return ma_swap_endian_uint32(block);
+    }
+}
+
+static MA_INLINE ma_uint32 ma_hash_fmix32(ma_uint32 h)
+{
+    h ^= h >> 16;
+    h *= 0x85ebca6b;
+    h ^= h >> 13;
+    h *= 0xc2b2ae35;
+    h ^= h >> 16;
+
+    return h;
+}
+
+static ma_uint32 ma_hash_32(const void* key, int len, ma_uint32 seed)
+{
+    const ma_uint8* data = (const ma_uint8*)key;
+    const ma_uint32* blocks;
+    const ma_uint8* tail;
+    const int nblocks = len / 4;
+    ma_uint32 h1 = seed;
+    ma_uint32 c1 = 0xcc9e2d51;
+    ma_uint32 c2 = 0x1b873593;
+    ma_uint32 k1;
+    int i;
+
+    blocks = (const ma_uint32 *)(data + nblocks*4);
+
+    for(i = -nblocks; i; i++) {
+        k1 = ma_hash_getblock(blocks,i);
+
+        k1 *= c1;
+        k1 = ma_rotl32(k1, 15);
+        k1 *= c2;
+
+        h1 ^= k1;
+        h1 = ma_rotl32(h1, 13);
+        h1 = h1*5 + 0xe6546b64;
+    }
+
+
+    tail = (const ma_uint8*)(data + nblocks*4);
+
+    k1 = 0;
+    switch(len & 3) {
+        case 3: k1 ^= tail[2] << 16;
+        case 2: k1 ^= tail[1] << 8;
+        case 1: k1 ^= tail[0];
+                k1 *= c1; k1 = ma_rotl32(k1, 15); k1 *= c2; h1 ^= k1;
+    };
+
+
+    h1 ^= len;
+    h1  = ma_hash_fmix32(h1);
+
+    return h1;
+}
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+#endif
+/* End MurmurHash3 */
+
+static ma_uint32 ma_hash_string_32(const char* str)
+{
+    return ma_hash_32(str, (int)strlen(str), MA_DEFAULT_HASH_SEED);
+}
+
+static ma_uint32 ma_hash_string_w_32(const wchar_t* str)
+{
+    return ma_hash_32(str, (int)ma_wcslen(str) * sizeof(*str), MA_DEFAULT_HASH_SEED);
+}
+
+
+
+
+/*
+Basic BST Functions
+*/
+static ma_result ma_resource_manager_data_buffer_node_search(ma_resource_manager* pResourceManager, ma_uint32 hashedName32, ma_resource_manager_data_buffer_node** ppDataBufferNode)
+{
+    ma_resource_manager_data_buffer_node* pCurrentNode;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(ppDataBufferNode != NULL);
+
+    pCurrentNode = pResourceManager->pRootDataBufferNode;
+    while (pCurrentNode != NULL) {
+        if (hashedName32 == pCurrentNode->hashedName32) {
+            break;  /* Found. */
+        } else if (hashedName32 < pCurrentNode->hashedName32) {
+            pCurrentNode = pCurrentNode->pChildLo;
+        } else {
+            pCurrentNode = pCurrentNode->pChildHi;
+        }
+    }
+
+    *ppDataBufferNode = pCurrentNode;
+
+    if (pCurrentNode == NULL) {
+        return MA_DOES_NOT_EXIST;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+static ma_result ma_resource_manager_data_buffer_node_insert_point(ma_resource_manager* pResourceManager, ma_uint32 hashedName32, ma_resource_manager_data_buffer_node** ppInsertPoint)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager_data_buffer_node* pCurrentNode;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(ppInsertPoint    != NULL);
+
+    *ppInsertPoint = NULL;
+
+    if (pResourceManager->pRootDataBufferNode == NULL) {
+        return MA_SUCCESS;  /* No items. */
+    }
+
+    /* We need to find the node that will become the parent of the new node. If a node is found that already has the same hashed name we need to return MA_ALREADY_EXISTS. */
+    pCurrentNode = pResourceManager->pRootDataBufferNode;
+    while (pCurrentNode != NULL) {
+        if (hashedName32 == pCurrentNode->hashedName32) {
+            result = MA_ALREADY_EXISTS;
+            break;
+        } else {
+            if (hashedName32 < pCurrentNode->hashedName32) {
+                if (pCurrentNode->pChildLo == NULL) {
+                    result = MA_SUCCESS;
+                    break;
+                } else {
+                    pCurrentNode = pCurrentNode->pChildLo;
+                }
+            } else {
+                if (pCurrentNode->pChildHi == NULL) {
+                    result = MA_SUCCESS;
+                    break;
+                } else {
+                    pCurrentNode = pCurrentNode->pChildHi;
+                }
+            }
+        }
+    }
+
+    *ppInsertPoint = pCurrentNode;
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_insert_at(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, ma_resource_manager_data_buffer_node* pInsertPoint)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    /* The key must have been set before calling this function. */
+    MA_ASSERT(pDataBufferNode->hashedName32 != 0);
+
+    if (pInsertPoint == NULL) {
+        /* It's the first node. */
+        pResourceManager->pRootDataBufferNode = pDataBufferNode;
+    } else {
+        /* It's not the first node. It needs to be inserted. */
+        if (pDataBufferNode->hashedName32 < pInsertPoint->hashedName32) {
+            MA_ASSERT(pInsertPoint->pChildLo == NULL);
+            pInsertPoint->pChildLo = pDataBufferNode;
+        } else {
+            MA_ASSERT(pInsertPoint->pChildHi == NULL);
+            pInsertPoint->pChildHi = pDataBufferNode;
+        }
+    }
+
+    pDataBufferNode->pParent = pInsertPoint;
+
+    return MA_SUCCESS;
+}
+
+#if 0   /* Unused for now. */
+static ma_result ma_resource_manager_data_buffer_node_insert(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    ma_result result;
+    ma_resource_manager_data_buffer_node* pInsertPoint;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    result = ma_resource_manager_data_buffer_node_insert_point(pResourceManager, pDataBufferNode->hashedName32, &pInsertPoint);
+    if (result != MA_SUCCESS) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_resource_manager_data_buffer_node_insert_at(pResourceManager, pDataBufferNode, pInsertPoint);
+}
+#endif
+
+static MA_INLINE ma_resource_manager_data_buffer_node* ma_resource_manager_data_buffer_node_find_min(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    ma_resource_manager_data_buffer_node* pCurrentNode;
+
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    pCurrentNode = pDataBufferNode;
+    while (pCurrentNode->pChildLo != NULL) {
+        pCurrentNode = pCurrentNode->pChildLo;
+    }
+
+    return pCurrentNode;
+}
+
+static MA_INLINE ma_resource_manager_data_buffer_node* ma_resource_manager_data_buffer_node_find_max(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    ma_resource_manager_data_buffer_node* pCurrentNode;
+
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    pCurrentNode = pDataBufferNode;
+    while (pCurrentNode->pChildHi != NULL) {
+        pCurrentNode = pCurrentNode->pChildHi;
+    }
+
+    return pCurrentNode;
+}
+
+static MA_INLINE ma_resource_manager_data_buffer_node* ma_resource_manager_data_buffer_node_find_inorder_successor(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pDataBufferNode           != NULL);
+    MA_ASSERT(pDataBufferNode->pChildHi != NULL);
+
+    return ma_resource_manager_data_buffer_node_find_min(pDataBufferNode->pChildHi);
+}
+
+#if 0   /* Currently unused, but might make use of this later. */
+static MA_INLINE ma_resource_manager_data_buffer_node* ma_resource_manager_data_buffer_node_find_inorder_predecessor(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pDataBufferNode           != NULL);
+    MA_ASSERT(pDataBufferNode->pChildLo != NULL);
+
+    return ma_resource_manager_data_buffer_node_find_max(pDataBufferNode->pChildLo);
+}
+#endif
+
+static ma_result ma_resource_manager_data_buffer_node_remove(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    if (pDataBufferNode->pChildLo == NULL) {
+        if (pDataBufferNode->pChildHi == NULL) {
+            /* Simple case - deleting a buffer with no children. */
+            if (pDataBufferNode->pParent == NULL) {
+                MA_ASSERT(pResourceManager->pRootDataBufferNode == pDataBufferNode);    /* There is only a single buffer in the tree which should be equal to the root node. */
+                pResourceManager->pRootDataBufferNode = NULL;
+            } else {
+                if (pDataBufferNode->pParent->pChildLo == pDataBufferNode) {
+                    pDataBufferNode->pParent->pChildLo = NULL;
+                } else {
+                    pDataBufferNode->pParent->pChildHi = NULL;
+                }
+            }
+        } else {
+            /* Node has one child - pChildHi != NULL. */
+            pDataBufferNode->pChildHi->pParent = pDataBufferNode->pParent;
+
+            if (pDataBufferNode->pParent == NULL) {
+                MA_ASSERT(pResourceManager->pRootDataBufferNode == pDataBufferNode);
+                pResourceManager->pRootDataBufferNode = pDataBufferNode->pChildHi;
+            } else {
+                if (pDataBufferNode->pParent->pChildLo == pDataBufferNode) {
+                    pDataBufferNode->pParent->pChildLo = pDataBufferNode->pChildHi;
+                } else {
+                    pDataBufferNode->pParent->pChildHi = pDataBufferNode->pChildHi;
+                }
+            }
+        }
+    } else {
+        if (pDataBufferNode->pChildHi == NULL) {
+            /* Node has one child - pChildLo != NULL. */
+            pDataBufferNode->pChildLo->pParent = pDataBufferNode->pParent;
+
+            if (pDataBufferNode->pParent == NULL) {
+                MA_ASSERT(pResourceManager->pRootDataBufferNode == pDataBufferNode);
+                pResourceManager->pRootDataBufferNode = pDataBufferNode->pChildLo;
+            } else {
+                if (pDataBufferNode->pParent->pChildLo == pDataBufferNode) {
+                    pDataBufferNode->pParent->pChildLo = pDataBufferNode->pChildLo;
+                } else {
+                    pDataBufferNode->pParent->pChildHi = pDataBufferNode->pChildLo;
+                }
+            }
+        } else {
+            /* Complex case - deleting a node with two children. */
+            ma_resource_manager_data_buffer_node* pReplacementDataBufferNode;
+
+            /* For now we are just going to use the in-order successor as the replacement, but we may want to try to keep this balanced by switching between the two. */
+            pReplacementDataBufferNode = ma_resource_manager_data_buffer_node_find_inorder_successor(pDataBufferNode);
+            MA_ASSERT(pReplacementDataBufferNode != NULL);
+
+            /*
+            Now that we have our replacement node we can make the change. The simple way to do this would be to just exchange the values, and then remove the replacement
+            node, however we track specific nodes via pointers which means we can't just swap out the values. We need to instead just change the pointers around. The
+            replacement node should have at most 1 child. Therefore, we can detach it in terms of our simpler cases above. What we're essentially doing is detaching the
+            replacement node and reinserting it into the same position as the deleted node.
+            */
+            MA_ASSERT(pReplacementDataBufferNode->pParent  != NULL);  /* The replacement node should never be the root which means it should always have a parent. */
+            MA_ASSERT(pReplacementDataBufferNode->pChildLo == NULL);  /* Because we used in-order successor. This would be pChildHi == NULL if we used in-order predecessor. */
+
+            if (pReplacementDataBufferNode->pChildHi == NULL) {
+                if (pReplacementDataBufferNode->pParent->pChildLo == pReplacementDataBufferNode) {
+                    pReplacementDataBufferNode->pParent->pChildLo = NULL;
+                } else {
+                    pReplacementDataBufferNode->pParent->pChildHi = NULL;
+                }
+            } else {
+                pReplacementDataBufferNode->pChildHi->pParent = pReplacementDataBufferNode->pParent;
+                if (pReplacementDataBufferNode->pParent->pChildLo == pReplacementDataBufferNode) {
+                    pReplacementDataBufferNode->pParent->pChildLo = pReplacementDataBufferNode->pChildHi;
+                } else {
+                    pReplacementDataBufferNode->pParent->pChildHi = pReplacementDataBufferNode->pChildHi;
+                }
+            }
+
+
+            /* The replacement node has essentially been detached from the binary tree, so now we need to replace the old data buffer with it. The first thing to update is the parent */
+            if (pDataBufferNode->pParent != NULL) {
+                if (pDataBufferNode->pParent->pChildLo == pDataBufferNode) {
+                    pDataBufferNode->pParent->pChildLo = pReplacementDataBufferNode;
+                } else {
+                    pDataBufferNode->pParent->pChildHi = pReplacementDataBufferNode;
+                }
+            }
+
+            /* Now need to update the replacement node's pointers. */
+            pReplacementDataBufferNode->pParent  = pDataBufferNode->pParent;
+            pReplacementDataBufferNode->pChildLo = pDataBufferNode->pChildLo;
+            pReplacementDataBufferNode->pChildHi = pDataBufferNode->pChildHi;
+
+            /* Now the children of the replacement node need to have their parent pointers updated. */
+            if (pReplacementDataBufferNode->pChildLo != NULL) {
+                pReplacementDataBufferNode->pChildLo->pParent = pReplacementDataBufferNode;
+            }
+            if (pReplacementDataBufferNode->pChildHi != NULL) {
+                pReplacementDataBufferNode->pChildHi->pParent = pReplacementDataBufferNode;
+            }
+
+            /* Now the root node needs to be updated. */
+            if (pResourceManager->pRootDataBufferNode == pDataBufferNode) {
+                pResourceManager->pRootDataBufferNode = pReplacementDataBufferNode;
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+#if 0   /* Unused for now. */
+static ma_result ma_resource_manager_data_buffer_node_remove_by_key(ma_resource_manager* pResourceManager, ma_uint32 hashedName32)
+{
+    ma_result result;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+
+    result = ma_resource_manager_data_buffer_search(pResourceManager, hashedName32, &pDataBufferNode);
+    if (result != MA_SUCCESS) {
+        return result;  /* Could not find the data buffer. */
+    }
+
+    return ma_resource_manager_data_buffer_remove(pResourceManager, pDataBufferNode);
+}
+#endif
+
+static ma_resource_manager_data_supply_type ma_resource_manager_data_buffer_node_get_data_supply_type(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    return (ma_resource_manager_data_supply_type)ma_atomic_load_i32(&pDataBufferNode->data.type);
+}
+
+static void ma_resource_manager_data_buffer_node_set_data_supply_type(ma_resource_manager_data_buffer_node* pDataBufferNode, ma_resource_manager_data_supply_type supplyType)
+{
+    ma_atomic_exchange_i32(&pDataBufferNode->data.type, supplyType);
+}
+
+static ma_result ma_resource_manager_data_buffer_node_increment_ref(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, ma_uint32* pNewRefCount)
+{
+    ma_uint32 refCount;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    (void)pResourceManager;
+
+    refCount = ma_atomic_fetch_add_32(&pDataBufferNode->refCount, 1) + 1;
+
+    if (pNewRefCount != NULL) {
+        *pNewRefCount = refCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_decrement_ref(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, ma_uint32* pNewRefCount)
+{
+    ma_uint32 refCount;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    (void)pResourceManager;
+
+    refCount = ma_atomic_fetch_sub_32(&pDataBufferNode->refCount, 1) - 1;
+
+    if (pNewRefCount != NULL) {
+        *pNewRefCount = refCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_resource_manager_data_buffer_node_free(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    if (pDataBufferNode->isDataOwnedByResourceManager) {
+        if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode) == ma_resource_manager_data_supply_type_encoded) {
+            ma_free((void*)pDataBufferNode->data.backend.encoded.pData, &pResourceManager->config.allocationCallbacks);
+            pDataBufferNode->data.backend.encoded.pData       = NULL;
+            pDataBufferNode->data.backend.encoded.sizeInBytes = 0;
+        } else if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode) == ma_resource_manager_data_supply_type_decoded) {
+            ma_free((void*)pDataBufferNode->data.backend.decoded.pData, &pResourceManager->config.allocationCallbacks);
+            pDataBufferNode->data.backend.decoded.pData           = NULL;
+            pDataBufferNode->data.backend.decoded.totalFrameCount = 0;
+        } else if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode) == ma_resource_manager_data_supply_type_decoded_paged) {
+            ma_paged_audio_buffer_data_uninit(&pDataBufferNode->data.backend.decodedPaged.data, &pResourceManager->config.allocationCallbacks);
+        } else {
+            /* Should never hit this if the node was successfully initialized. */
+            MA_ASSERT(pDataBufferNode->result != MA_SUCCESS);
+        }
+    }
+
+    /* The data buffer itself needs to be freed. */
+    ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+}
+
+static ma_result ma_resource_manager_data_buffer_node_result(const ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    return (ma_result)ma_atomic_load_i32((ma_result*)&pDataBufferNode->result);    /* Need a naughty const-cast here. */
+}
+
+
+static ma_bool32 ma_resource_manager_is_threading_enabled(const ma_resource_manager* pResourceManager)
+{
+    MA_ASSERT(pResourceManager != NULL);
+
+    return (pResourceManager->config.flags & MA_RESOURCE_MANAGER_FLAG_NO_THREADING) == 0;
+}
+
+
+typedef struct
+{
+    union
+    {
+        ma_async_notification_event e;
+        ma_async_notification_poll p;
+    } backend;  /* Must be the first member. */
+    ma_resource_manager* pResourceManager;
+} ma_resource_manager_inline_notification;
+
+static ma_result ma_resource_manager_inline_notification_init(ma_resource_manager* pResourceManager, ma_resource_manager_inline_notification* pNotification)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pNotification    != NULL);
+
+    pNotification->pResourceManager = pResourceManager;
+
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        return ma_async_notification_event_init(&pNotification->backend.e);
+    } else {
+        return ma_async_notification_poll_init(&pNotification->backend.p);
+    }
+}
+
+static void ma_resource_manager_inline_notification_uninit(ma_resource_manager_inline_notification* pNotification)
+{
+    MA_ASSERT(pNotification != NULL);
+
+    if (ma_resource_manager_is_threading_enabled(pNotification->pResourceManager)) {
+        ma_async_notification_event_uninit(&pNotification->backend.e);
+    } else {
+        /* No need to uninitialize a polling notification. */
+    }
+}
+
+static void ma_resource_manager_inline_notification_wait(ma_resource_manager_inline_notification* pNotification)
+{
+    MA_ASSERT(pNotification != NULL);
+
+    if (ma_resource_manager_is_threading_enabled(pNotification->pResourceManager)) {
+        ma_async_notification_event_wait(&pNotification->backend.e);
+    } else {
+        while (ma_async_notification_poll_is_signalled(&pNotification->backend.p) == MA_FALSE) {
+            ma_result result = ma_resource_manager_process_next_job(pNotification->pResourceManager);
+            if (result == MA_NO_DATA_AVAILABLE || result == MA_CANCELLED) {
+                break;
+            }
+        }
+    }
+}
+
+static void ma_resource_manager_inline_notification_wait_and_uninit(ma_resource_manager_inline_notification* pNotification)
+{
+    ma_resource_manager_inline_notification_wait(pNotification);
+    ma_resource_manager_inline_notification_uninit(pNotification);
+}
+
+
+static void ma_resource_manager_data_buffer_bst_lock(ma_resource_manager* pResourceManager)
+{
+    MA_ASSERT(pResourceManager != NULL);
+
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_mutex_lock(&pResourceManager->dataBufferBSTLock);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+        }
+        #endif
+    } else {
+        /* Threading not enabled. Do nothing. */
+    }
+}
+
+static void ma_resource_manager_data_buffer_bst_unlock(ma_resource_manager* pResourceManager)
+{
+    MA_ASSERT(pResourceManager != NULL);
+
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_mutex_unlock(&pResourceManager->dataBufferBSTLock);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+        }
+        #endif
+    } else {
+        /* Threading not enabled. Do nothing. */
+    }
+}
+
+#ifndef MA_NO_THREADING
+static ma_thread_result MA_THREADCALL ma_resource_manager_job_thread(void* pUserData)
+{
+    ma_resource_manager* pResourceManager = (ma_resource_manager*)pUserData;
+    MA_ASSERT(pResourceManager != NULL);
+
+    for (;;) {
+        ma_result result;
+        ma_job job;
+
+        result = ma_resource_manager_next_job(pResourceManager, &job);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        /* Terminate if we got a quit message. */
+        if (job.toc.breakup.code == MA_JOB_TYPE_QUIT) {
+            break;
+        }
+
+        ma_job_process(&job);
+    }
+
+    return (ma_thread_result)0;
+}
+#endif
+
+MA_API ma_resource_manager_config ma_resource_manager_config_init(void)
+{
+    ma_resource_manager_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.decodedFormat     = ma_format_unknown;
+    config.decodedChannels   = 0;
+    config.decodedSampleRate = 0;
+    config.jobThreadCount    = 1;   /* A single miniaudio-managed job thread by default. */
+    config.jobQueueCapacity  = MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_CAPACITY;
+
+    /* Flags. */
+    config.flags = 0;
+    #ifdef MA_NO_THREADING
+    {
+        /* Threading is disabled at compile time so disable threading at runtime as well by default. */
+        config.flags |= MA_RESOURCE_MANAGER_FLAG_NO_THREADING;
+        config.jobThreadCount = 0;
+    }
+    #endif
+
+    return config;
+}
+
+
+MA_API ma_result ma_resource_manager_init(const ma_resource_manager_config* pConfig, ma_resource_manager* pResourceManager)
+{
+    ma_result result;
+    ma_job_queue_config jobQueueConfig;
+
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pResourceManager);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        if (pConfig->jobThreadCount > ma_countof(pResourceManager->jobThreads)) {
+            return MA_INVALID_ARGS; /* Requesting too many job threads. */
+        }
+    }
+    #endif
+
+    pResourceManager->config = *pConfig;
+    ma_allocation_callbacks_init_copy(&pResourceManager->config.allocationCallbacks, &pConfig->allocationCallbacks);
+
+    /* Get the log set up early so we can start using it as soon as possible. */
+    if (pResourceManager->config.pLog == NULL) {
+        result = ma_log_init(&pResourceManager->config.allocationCallbacks, &pResourceManager->log);
+        if (result == MA_SUCCESS) {
+            pResourceManager->config.pLog = &pResourceManager->log;
+        } else {
+            pResourceManager->config.pLog = NULL;   /* Logging is unavailable. */
+        }
+    }
+
+    if (pResourceManager->config.pVFS == NULL) {
+        result = ma_default_vfs_init(&pResourceManager->defaultVFS, &pResourceManager->config.allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to initialize the default file system. */
+        }
+
+        pResourceManager->config.pVFS = &pResourceManager->defaultVFS;
+    }
+
+    /* If threading has been disabled at compile time, enforce it at run time as well. */
+    #ifdef MA_NO_THREADING
+    {
+        pResourceManager->config.flags |= MA_RESOURCE_MANAGER_FLAG_NO_THREADING;
+    }
+    #endif
+
+    /* We need to force MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING if MA_RESOURCE_MANAGER_FLAG_NO_THREADING is set. */
+    if ((pResourceManager->config.flags & MA_RESOURCE_MANAGER_FLAG_NO_THREADING) != 0) {
+        pResourceManager->config.flags |= MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING;
+
+        /* We cannot allow job threads when MA_RESOURCE_MANAGER_FLAG_NO_THREADING has been set. This is an invalid use case. */
+        if (pResourceManager->config.jobThreadCount > 0) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    /* Job queue. */
+    jobQueueConfig.capacity = pResourceManager->config.jobQueueCapacity;
+    jobQueueConfig.flags    = 0;
+    if ((pResourceManager->config.flags & MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING) != 0) {
+        if (pResourceManager->config.jobThreadCount > 0) {
+            return MA_INVALID_ARGS; /* Non-blocking mode is only valid for self-managed job threads. */
+        }
+
+        jobQueueConfig.flags |= MA_JOB_QUEUE_FLAG_NON_BLOCKING;
+    }
+
+    result = ma_job_queue_init(&jobQueueConfig, &pResourceManager->config.allocationCallbacks, &pResourceManager->jobQueue);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+
+    /* Custom decoding backends. */
+    if (pConfig->ppCustomDecodingBackendVTables != NULL && pConfig->customDecodingBackendCount > 0) {
+        size_t sizeInBytes = sizeof(*pResourceManager->config.ppCustomDecodingBackendVTables) * pConfig->customDecodingBackendCount;
+        ma_decoding_backend_vtable** ppCustomDecodingBackendVTables;
+
+        ppCustomDecodingBackendVTables = (ma_decoding_backend_vtable**)ma_malloc(sizeInBytes, &pResourceManager->config.allocationCallbacks);
+        if (pResourceManager->config.ppCustomDecodingBackendVTables == NULL) {
+            ma_job_queue_uninit(&pResourceManager->jobQueue, &pResourceManager->config.allocationCallbacks);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        MA_COPY_MEMORY(ppCustomDecodingBackendVTables, pConfig->ppCustomDecodingBackendVTables, sizeInBytes);
+
+        pResourceManager->config.ppCustomDecodingBackendVTables = ppCustomDecodingBackendVTables;
+        pResourceManager->config.customDecodingBackendCount     = pConfig->customDecodingBackendCount;
+        pResourceManager->config.pCustomDecodingBackendUserData = pConfig->pCustomDecodingBackendUserData;
+    }
+
+
+
+    /* Here is where we initialize our threading stuff. We don't do this if we don't support threading. */
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_uint32 iJobThread;
+
+            /* Data buffer lock. */
+            result = ma_mutex_init(&pResourceManager->dataBufferBSTLock);
+            if (result != MA_SUCCESS) {
+                ma_job_queue_uninit(&pResourceManager->jobQueue, &pResourceManager->config.allocationCallbacks);
+                return result;
+            }
+
+            /* Create the job threads last to ensure the threads has access to valid data. */
+            for (iJobThread = 0; iJobThread < pResourceManager->config.jobThreadCount; iJobThread += 1) {
+                result = ma_thread_create(&pResourceManager->jobThreads[iJobThread], ma_thread_priority_normal, pResourceManager->config.jobThreadStackSize, ma_resource_manager_job_thread, pResourceManager, &pResourceManager->config.allocationCallbacks);
+                if (result != MA_SUCCESS) {
+                    ma_mutex_uninit(&pResourceManager->dataBufferBSTLock);
+                    ma_job_queue_uninit(&pResourceManager->jobQueue, &pResourceManager->config.allocationCallbacks);
+                    return result;
+                }
+            }
+        }
+        #else
+        {
+            /* Threading is disabled at compile time. We should never get here because validation checks should have already been performed. */
+            MA_ASSERT(MA_FALSE);
+        }
+        #endif
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static void ma_resource_manager_delete_all_data_buffer_nodes(ma_resource_manager* pResourceManager)
+{
+    MA_ASSERT(pResourceManager);
+
+    /* If everything was done properly, there shouldn't be any active data buffers. */
+    while (pResourceManager->pRootDataBufferNode != NULL) {
+        ma_resource_manager_data_buffer_node* pDataBufferNode = pResourceManager->pRootDataBufferNode;
+        ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+
+        /* The data buffer has been removed from the BST, so now we need to free its data. */
+        ma_resource_manager_data_buffer_node_free(pResourceManager, pDataBufferNode);
+    }
+}
+
+MA_API void ma_resource_manager_uninit(ma_resource_manager* pResourceManager)
+{
+    if (pResourceManager == NULL) {
+        return;
+    }
+
+    /*
+    Job threads need to be killed first. To do this we need to post a quit message to the message queue and then wait for the thread. The quit message will never be removed from the
+    queue which means it will never not be returned after being encountered for the first time which means all threads will eventually receive it.
+    */
+    ma_resource_manager_post_job_quit(pResourceManager);
+
+    /* Wait for every job to finish before continuing to ensure nothing is sill trying to access any of our objects below. */
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_uint32 iJobThread;
+
+            for (iJobThread = 0; iJobThread < pResourceManager->config.jobThreadCount; iJobThread += 1) {
+                ma_thread_wait(&pResourceManager->jobThreads[iJobThread]);
+            }
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+        }
+        #endif
+    }
+
+    /* At this point the thread should have returned and no other thread should be accessing our data. We can now delete all data buffers. */
+    ma_resource_manager_delete_all_data_buffer_nodes(pResourceManager);
+
+    /* The job queue is no longer needed. */
+    ma_job_queue_uninit(&pResourceManager->jobQueue, &pResourceManager->config.allocationCallbacks);
+
+    /* We're no longer doing anything with data buffers so the lock can now be uninitialized. */
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_mutex_uninit(&pResourceManager->dataBufferBSTLock);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+        }
+        #endif
+    }
+
+    ma_free((ma_decoding_backend_vtable**)pResourceManager->config.ppCustomDecodingBackendVTables, &pResourceManager->config.allocationCallbacks);  /* <-- Naughty const-cast, but this is safe. */
+
+    if (pResourceManager->config.pLog == &pResourceManager->log) {
+        ma_log_uninit(&pResourceManager->log);
+    }
+}
+
+MA_API ma_log* ma_resource_manager_get_log(ma_resource_manager* pResourceManager)
+{
+    if (pResourceManager == NULL) {
+        return NULL;
+    }
+
+    return pResourceManager->config.pLog;
+}
+
+
+
+MA_API ma_resource_manager_data_source_config ma_resource_manager_data_source_config_init(void)
+{
+    ma_resource_manager_data_source_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.rangeBegInPCMFrames     = MA_DATA_SOURCE_DEFAULT_RANGE_BEG;
+    config.rangeEndInPCMFrames     = MA_DATA_SOURCE_DEFAULT_RANGE_END;
+    config.loopPointBegInPCMFrames = MA_DATA_SOURCE_DEFAULT_LOOP_POINT_BEG;
+    config.loopPointEndInPCMFrames = MA_DATA_SOURCE_DEFAULT_LOOP_POINT_END;
+    config.isLooping               = MA_FALSE;
+
+    return config;
+}
+
+
+static ma_decoder_config ma_resource_manager__init_decoder_config(ma_resource_manager* pResourceManager)
+{
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init(pResourceManager->config.decodedFormat, pResourceManager->config.decodedChannels, pResourceManager->config.decodedSampleRate);
+    config.allocationCallbacks    = pResourceManager->config.allocationCallbacks;
+    config.ppCustomBackendVTables = pResourceManager->config.ppCustomDecodingBackendVTables;
+    config.customBackendCount     = pResourceManager->config.customDecodingBackendCount;
+    config.pCustomBackendUserData = pResourceManager->config.pCustomDecodingBackendUserData;
+
+    return config;
+}
+
+static ma_result ma_resource_manager__init_decoder(ma_resource_manager* pResourceManager, const char* pFilePath, const wchar_t* pFilePathW, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pFilePath        != NULL || pFilePathW != NULL);
+    MA_ASSERT(pDecoder         != NULL);
+
+    config = ma_resource_manager__init_decoder_config(pResourceManager);
+
+    if (pFilePath != NULL) {
+        result = ma_decoder_init_vfs(pResourceManager->config.pVFS, pFilePath, &config, pDecoder);
+        if (result != MA_SUCCESS) {
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to load file \"%s\". %s.\n", pFilePath, ma_result_description(result));
+            return result;
+        }
+    } else {
+        result = ma_decoder_init_vfs_w(pResourceManager->config.pVFS, pFilePathW, &config, pDecoder);
+        if (result != MA_SUCCESS) {
+            #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(_MSC_VER)
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to load file \"%ls\". %s.\n", pFilePathW, ma_result_description(result));
+            #endif
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_bool32 ma_resource_manager_data_buffer_has_connector(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    return ma_atomic_bool32_get(&pDataBuffer->isConnectorInitialized);
+}
+
+static ma_data_source* ma_resource_manager_data_buffer_get_connector(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    if (ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE) {
+        return NULL;    /* Connector not yet initialized. */
+    }
+
+    switch (pDataBuffer->pNode->data.type)
+    {
+        case ma_resource_manager_data_supply_type_encoded:       return &pDataBuffer->connector.decoder;
+        case ma_resource_manager_data_supply_type_decoded:       return &pDataBuffer->connector.buffer;
+        case ma_resource_manager_data_supply_type_decoded_paged: return &pDataBuffer->connector.pagedBuffer;
+
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            ma_log_postf(ma_resource_manager_get_log(pDataBuffer->pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to retrieve data buffer connector. Unknown data supply type.\n");
+            return NULL;
+        };
+    };
+}
+
+static ma_result ma_resource_manager_data_buffer_init_connector(ma_resource_manager_data_buffer* pDataBuffer, const ma_resource_manager_data_source_config* pConfig, ma_async_notification* pInitNotification, ma_fence* pInitFence)
+{
+    ma_result result;
+
+    MA_ASSERT(pDataBuffer != NULL);
+    MA_ASSERT(pConfig     != NULL);
+    MA_ASSERT(ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE);
+
+    /* The underlying data buffer must be initialized before we'll be able to know how to initialize the backend. */
+    result = ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode);
+    if (result != MA_SUCCESS && result != MA_BUSY) {
+        return result;  /* The data buffer is in an erroneous state. */
+    }
+
+    /*
+    We need to initialize either a ma_decoder or an ma_audio_buffer depending on whether or not the backing data is encoded or decoded. These act as the
+    "instance" to the data and are used to form the connection between underlying data buffer and the data source. If the data buffer is decoded, we can use
+    an ma_audio_buffer. This enables us to use memory mapping when mixing which saves us a bit of data movement overhead.
+    */
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:          /* Connector is a decoder. */
+        {
+            ma_decoder_config config;
+            config = ma_resource_manager__init_decoder_config(pDataBuffer->pResourceManager);
+            result = ma_decoder_init_memory(pDataBuffer->pNode->data.backend.encoded.pData, pDataBuffer->pNode->data.backend.encoded.sizeInBytes, &config, &pDataBuffer->connector.decoder);
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded:          /* Connector is an audio buffer. */
+        {
+            ma_audio_buffer_config config;
+            config = ma_audio_buffer_config_init(pDataBuffer->pNode->data.backend.decoded.format, pDataBuffer->pNode->data.backend.decoded.channels, pDataBuffer->pNode->data.backend.decoded.totalFrameCount, pDataBuffer->pNode->data.backend.decoded.pData, NULL);
+            result = ma_audio_buffer_init(&config, &pDataBuffer->connector.buffer);
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded_paged:    /* Connector is a paged audio buffer. */
+        {
+            ma_paged_audio_buffer_config config;
+            config = ma_paged_audio_buffer_config_init(&pDataBuffer->pNode->data.backend.decodedPaged.data);
+            result = ma_paged_audio_buffer_init(&config, &pDataBuffer->connector.pagedBuffer);
+        } break;
+
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            /* Unknown data supply type. Should never happen. Need to post an error here. */
+            return MA_INVALID_ARGS;
+        };
+    }
+
+    /*
+    Initialization of the connector is when we can fire the init notification. This will give the application access to
+    the format/channels/rate of the data source.
+    */
+    if (result == MA_SUCCESS) {
+        /*
+        The resource manager supports the ability to set the range and loop settings via a config at
+        initialization time. This results in an case where the ranges could be set explicitly via
+        ma_data_source_set_*() before we get to this point here. If this happens, we'll end up
+        hitting a case where we just override those settings which results in what feels like a bug.
+
+        To address this we only change the relevant properties if they're not equal to defaults. If
+        they're equal to defaults there's no need to change them anyway. If they're *not* set to the
+        default values, we can assume the user has set the range and loop settings via the config. If
+        they're doing their own calls to ma_data_source_set_*() in addition to setting them via the
+        config, that's entirely on the caller and any synchronization issue becomes their problem.
+        */
+        if (pConfig->rangeBegInPCMFrames != MA_DATA_SOURCE_DEFAULT_RANGE_BEG || pConfig->rangeEndInPCMFrames != MA_DATA_SOURCE_DEFAULT_RANGE_END) {
+            ma_data_source_set_range_in_pcm_frames(pDataBuffer, pConfig->rangeBegInPCMFrames, pConfig->rangeEndInPCMFrames);
+        }
+
+        if (pConfig->loopPointBegInPCMFrames != MA_DATA_SOURCE_DEFAULT_LOOP_POINT_BEG || pConfig->loopPointEndInPCMFrames != MA_DATA_SOURCE_DEFAULT_LOOP_POINT_END) {
+            ma_data_source_set_loop_point_in_pcm_frames(pDataBuffer, pConfig->loopPointBegInPCMFrames, pConfig->loopPointEndInPCMFrames);
+        }
+
+        if (pConfig->isLooping != MA_FALSE) {
+            ma_data_source_set_looping(pDataBuffer, pConfig->isLooping);
+        }
+
+        ma_atomic_bool32_set(&pDataBuffer->isConnectorInitialized, MA_TRUE);
+
+        if (pInitNotification != NULL) {
+            ma_async_notification_signal(pInitNotification);
+        }
+
+        if (pInitFence != NULL) {
+            ma_fence_release(pInitFence);
+        }
+    }
+
+    /* At this point the backend should be initialized. We do *not* want to set pDataSource->result here - that needs to be done at a higher level to ensure it's done as the last step. */
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_uninit_connector(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBuffer      != NULL);
+
+    (void)pResourceManager;
+
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:          /* Connector is a decoder. */
+        {
+            ma_decoder_uninit(&pDataBuffer->connector.decoder);
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded:          /* Connector is an audio buffer. */
+        {
+            ma_audio_buffer_uninit(&pDataBuffer->connector.buffer);
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded_paged:    /* Connector is a paged audio buffer. */
+        {
+            ma_paged_audio_buffer_uninit(&pDataBuffer->connector.pagedBuffer);
+        } break;
+
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            /* Unknown data supply type. Should never happen. Need to post an error here. */
+            return MA_INVALID_ARGS;
+        };
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_uint32 ma_resource_manager_data_buffer_node_next_execution_order(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pDataBufferNode != NULL);
+    return ma_atomic_fetch_add_32(&pDataBufferNode->executionCounter, 1);
+}
+
+static ma_result ma_resource_manager_data_buffer_node_init_supply_encoded(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, const char* pFilePath, const wchar_t* pFilePathW)
+{
+    ma_result result;
+    size_t dataSizeInBytes;
+    void* pData;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+    MA_ASSERT(pFilePath != NULL || pFilePathW != NULL);
+
+    result = ma_vfs_open_and_read_file_ex(pResourceManager->config.pVFS, pFilePath, pFilePathW, &pData, &dataSizeInBytes, &pResourceManager->config.allocationCallbacks);
+    if (result != MA_SUCCESS) {
+        if (pFilePath != NULL) {
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to load file \"%s\". %s.\n", pFilePath, ma_result_description(result));
+        } else {
+            #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(_MSC_VER)
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to load file \"%ls\". %s.\n", pFilePathW, ma_result_description(result));
+            #endif
+        }
+
+        return result;
+    }
+
+    pDataBufferNode->data.backend.encoded.pData       = pData;
+    pDataBufferNode->data.backend.encoded.sizeInBytes = dataSizeInBytes;
+    ma_resource_manager_data_buffer_node_set_data_supply_type(pDataBufferNode, ma_resource_manager_data_supply_type_encoded);  /* <-- Must be set last. */
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_init_supply_decoded(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, const char* pFilePath, const wchar_t* pFilePathW, ma_uint32 flags, ma_decoder** ppDecoder)
+{
+    ma_result result = MA_SUCCESS;
+    ma_decoder* pDecoder;
+    ma_uint64 totalFrameCount;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+    MA_ASSERT(ppDecoder         != NULL);
+    MA_ASSERT(pFilePath != NULL || pFilePathW != NULL);
+
+    *ppDecoder = NULL;  /* For safety. */
+
+    pDecoder = (ma_decoder*)ma_malloc(sizeof(*pDecoder), &pResourceManager->config.allocationCallbacks);
+    if (pDecoder == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_resource_manager__init_decoder(pResourceManager, pFilePath, pFilePathW, pDecoder);
+    if (result != MA_SUCCESS) {
+        ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+        return result;
+    }
+
+    /*
+    At this point we have the decoder and we now need to initialize the data supply. This will
+    be either a decoded buffer, or a decoded paged buffer. A regular buffer is just one big heap
+    allocated buffer, whereas a paged buffer is a linked list of paged-sized buffers. The latter
+    is used when the length of a sound is unknown until a full decode has been performed.
+    */
+    if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH) == 0) {
+        result = ma_decoder_get_length_in_pcm_frames(pDecoder, &totalFrameCount);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    } else {
+        totalFrameCount = 0;
+    }
+
+    if (totalFrameCount > 0) {
+        /* It's a known length. The data supply is a regular decoded buffer. */
+        ma_uint64 dataSizeInBytes;
+        void* pData;
+
+        dataSizeInBytes = totalFrameCount * ma_get_bytes_per_frame(pDecoder->outputFormat, pDecoder->outputChannels);
+        if (dataSizeInBytes > MA_SIZE_MAX) {
+            ma_decoder_uninit(pDecoder);
+            ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+            return MA_TOO_BIG;
+        }
+
+        pData = ma_malloc((size_t)dataSizeInBytes, &pResourceManager->config.allocationCallbacks);
+        if (pData == NULL) {
+            ma_decoder_uninit(pDecoder);
+            ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        /* The buffer needs to be initialized to silence in case the caller reads from it. */
+        ma_silence_pcm_frames(pData, totalFrameCount, pDecoder->outputFormat, pDecoder->outputChannels);
+
+        /* Data has been allocated and the data supply can now be initialized. */
+        pDataBufferNode->data.backend.decoded.pData             = pData;
+        pDataBufferNode->data.backend.decoded.totalFrameCount   = totalFrameCount;
+        pDataBufferNode->data.backend.decoded.format            = pDecoder->outputFormat;
+        pDataBufferNode->data.backend.decoded.channels          = pDecoder->outputChannels;
+        pDataBufferNode->data.backend.decoded.sampleRate        = pDecoder->outputSampleRate;
+        pDataBufferNode->data.backend.decoded.decodedFrameCount = 0;
+        ma_resource_manager_data_buffer_node_set_data_supply_type(pDataBufferNode, ma_resource_manager_data_supply_type_decoded);  /* <-- Must be set last. */
+    } else {
+        /*
+        It's an unknown length. The data supply is a paged decoded buffer. Setting this up is
+        actually easier than the non-paged decoded buffer because we just need to initialize
+        a ma_paged_audio_buffer object.
+        */
+        result = ma_paged_audio_buffer_data_init(pDecoder->outputFormat, pDecoder->outputChannels, &pDataBufferNode->data.backend.decodedPaged.data);
+        if (result != MA_SUCCESS) {
+            ma_decoder_uninit(pDecoder);
+            ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+            return result;
+        }
+
+        pDataBufferNode->data.backend.decodedPaged.sampleRate        = pDecoder->outputSampleRate;
+        pDataBufferNode->data.backend.decodedPaged.decodedFrameCount = 0;
+        ma_resource_manager_data_buffer_node_set_data_supply_type(pDataBufferNode, ma_resource_manager_data_supply_type_decoded_paged);  /* <-- Must be set last. */
+    }
+
+    *ppDecoder = pDecoder;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_decode_next_page(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, ma_decoder* pDecoder)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 pageSizeInFrames;
+    ma_uint64 framesToTryReading;
+    ma_uint64 framesRead;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+    MA_ASSERT(pDecoder         != NULL);
+
+    /* We need to know the size of a page in frames to know how many frames to decode. */
+    pageSizeInFrames = MA_RESOURCE_MANAGER_PAGE_SIZE_IN_MILLISECONDS * (pDecoder->outputSampleRate/1000);
+    framesToTryReading = pageSizeInFrames;
+
+    /*
+    Here is where we do the decoding of the next page. We'll run a slightly different path depending
+    on whether or not we're using a flat or paged buffer because the allocation of the page differs
+    between the two. For a flat buffer it's an offset to an already-allocated buffer. For a paged
+    buffer, we need to allocate a new page and attach it to the linked list.
+    */
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode))
+    {
+        case ma_resource_manager_data_supply_type_decoded:
+        {
+            /* The destination buffer is an offset to the existing buffer. Don't read more than we originally retrieved when we first initialized the decoder. */
+            void* pDst;
+            ma_uint64 framesRemaining = pDataBufferNode->data.backend.decoded.totalFrameCount - pDataBufferNode->data.backend.decoded.decodedFrameCount;
+            if (framesToTryReading > framesRemaining) {
+                framesToTryReading = framesRemaining;
+            }
+
+            if (framesToTryReading > 0) {
+                pDst = ma_offset_ptr(
+                    pDataBufferNode->data.backend.decoded.pData,
+                    pDataBufferNode->data.backend.decoded.decodedFrameCount * ma_get_bytes_per_frame(pDataBufferNode->data.backend.decoded.format, pDataBufferNode->data.backend.decoded.channels)
+                );
+                MA_ASSERT(pDst != NULL);
+
+                result = ma_decoder_read_pcm_frames(pDecoder, pDst, framesToTryReading, &framesRead);
+                if (framesRead > 0) {
+                    pDataBufferNode->data.backend.decoded.decodedFrameCount += framesRead;
+                }
+            } else {
+                framesRead = 0;
+            }
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded_paged:
+        {
+            /* The destination buffer is a freshly allocated page. */
+            ma_paged_audio_buffer_page* pPage;
+
+            result = ma_paged_audio_buffer_data_allocate_page(&pDataBufferNode->data.backend.decodedPaged.data, framesToTryReading, NULL, &pResourceManager->config.allocationCallbacks, &pPage);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+
+            result = ma_decoder_read_pcm_frames(pDecoder, pPage->pAudioData, framesToTryReading, &framesRead);
+            if (result == MA_SUCCESS && framesRead > 0) {
+                pPage->sizeInFrames = framesRead;
+
+                result = ma_paged_audio_buffer_data_append_page(&pDataBufferNode->data.backend.decodedPaged.data, pPage);
+                if (result == MA_SUCCESS) {
+                    pDataBufferNode->data.backend.decodedPaged.decodedFrameCount += framesRead;
+                } else {
+                    /* Failed to append the page. Just abort and set the status to MA_AT_END. */
+                    ma_paged_audio_buffer_data_free_page(&pDataBufferNode->data.backend.decodedPaged.data, pPage, &pResourceManager->config.allocationCallbacks);
+                    result = MA_AT_END;
+                }
+            } else {
+                /* No frames were read. Free the page and just set the status to MA_AT_END. */
+                ma_paged_audio_buffer_data_free_page(&pDataBufferNode->data.backend.decodedPaged.data, pPage, &pResourceManager->config.allocationCallbacks);
+                result = MA_AT_END;
+            }
+        } break;
+
+        case ma_resource_manager_data_supply_type_encoded:
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            /* Unexpected data supply type. */
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Unexpected data supply type (%d) when decoding page.", ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode));
+            return MA_ERROR;
+        };
+    }
+
+    if (result == MA_SUCCESS && framesRead == 0) {
+        result = MA_AT_END;
+    }
+
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_acquire_critical_section(ma_resource_manager* pResourceManager, const char* pFilePath, const wchar_t* pFilePathW, ma_uint32 hashedName32, ma_uint32 flags, const ma_resource_manager_data_supply* pExistingData, ma_fence* pInitFence, ma_fence* pDoneFence, ma_resource_manager_inline_notification* pInitNotification, ma_resource_manager_data_buffer_node** ppDataBufferNode)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager_data_buffer_node* pDataBufferNode = NULL;
+    ma_resource_manager_data_buffer_node* pInsertPoint;
+
+    if (ppDataBufferNode != NULL) {
+        *ppDataBufferNode = NULL;
+    }
+
+    result = ma_resource_manager_data_buffer_node_insert_point(pResourceManager, hashedName32, &pInsertPoint);
+    if (result == MA_ALREADY_EXISTS) {
+        /* The node already exists. We just need to increment the reference count. */
+        pDataBufferNode = pInsertPoint;
+
+        result = ma_resource_manager_data_buffer_node_increment_ref(pResourceManager, pDataBufferNode, NULL);
+        if (result != MA_SUCCESS) {
+            return result;  /* Should never happen. Failed to increment the reference count. */
+        }
+
+        result = MA_ALREADY_EXISTS;
+        goto done;
+    } else {
+        /*
+        The node does not already exist. We need to post a LOAD_DATA_BUFFER_NODE job here. This
+        needs to be done inside the critical section to ensure an uninitialization of the node
+        does not occur before initialization on another thread.
+        */
+        pDataBufferNode = (ma_resource_manager_data_buffer_node*)ma_malloc(sizeof(*pDataBufferNode), &pResourceManager->config.allocationCallbacks);
+        if (pDataBufferNode == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        MA_ZERO_OBJECT(pDataBufferNode);
+        pDataBufferNode->hashedName32 = hashedName32;
+        pDataBufferNode->refCount     = 1;        /* Always set to 1 by default (this is our first reference). */
+
+        if (pExistingData == NULL) {
+            pDataBufferNode->data.type    = ma_resource_manager_data_supply_type_unknown;    /* <-- We won't know this until we start decoding. */
+            pDataBufferNode->result       = MA_BUSY;  /* Must be set to MA_BUSY before we leave the critical section, so might as well do it now. */
+            pDataBufferNode->isDataOwnedByResourceManager = MA_TRUE;
+        } else {
+            pDataBufferNode->data         = *pExistingData;
+            pDataBufferNode->result       = MA_SUCCESS;   /* Not loading asynchronously, so just set the status */
+            pDataBufferNode->isDataOwnedByResourceManager = MA_FALSE;
+        }
+
+        result = ma_resource_manager_data_buffer_node_insert_at(pResourceManager, pDataBufferNode, pInsertPoint);
+        if (result != MA_SUCCESS) {
+            ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+            return result;  /* Should never happen. Failed to insert the data buffer into the BST. */
+        }
+
+        /*
+        Here is where we'll post the job, but only if we're loading asynchronously. If we're
+        loading synchronously we'll defer loading to a later stage, outside of the critical
+        section.
+        */
+        if (pDataBufferNode->isDataOwnedByResourceManager && (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) != 0) {
+            /* Loading asynchronously. Post the job. */
+            ma_job job;
+            char* pFilePathCopy = NULL;
+            wchar_t* pFilePathWCopy = NULL;
+
+            /* We need a copy of the file path. We should probably make this more efficient, but for now we'll do a transient memory allocation. */
+            if (pFilePath != NULL) {
+                pFilePathCopy = ma_copy_string(pFilePath, &pResourceManager->config.allocationCallbacks);
+            } else {
+                pFilePathWCopy = ma_copy_string_w(pFilePathW, &pResourceManager->config.allocationCallbacks);
+            }
+
+            if (pFilePathCopy == NULL && pFilePathWCopy == NULL) {
+                ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+                ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                ma_resource_manager_inline_notification_init(pResourceManager, pInitNotification);
+            }
+
+            /* Acquire init and done fences before posting the job. These will be unacquired by the job thread. */
+            if (pInitFence != NULL) { ma_fence_acquire(pInitFence); }
+            if (pDoneFence != NULL) { ma_fence_acquire(pDoneFence); }
+
+            /* We now have everything we need to post the job to the job thread. */
+            job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE);
+            job.order = ma_resource_manager_data_buffer_node_next_execution_order(pDataBufferNode);
+            job.data.resourceManager.loadDataBufferNode.pResourceManager  = pResourceManager;
+            job.data.resourceManager.loadDataBufferNode.pDataBufferNode   = pDataBufferNode;
+            job.data.resourceManager.loadDataBufferNode.pFilePath         = pFilePathCopy;
+            job.data.resourceManager.loadDataBufferNode.pFilePathW        = pFilePathWCopy;
+            job.data.resourceManager.loadDataBufferNode.flags             = flags;
+            job.data.resourceManager.loadDataBufferNode.pInitNotification = ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) ? pInitNotification : NULL;
+            job.data.resourceManager.loadDataBufferNode.pDoneNotification = NULL;
+            job.data.resourceManager.loadDataBufferNode.pInitFence        = pInitFence;
+            job.data.resourceManager.loadDataBufferNode.pDoneFence        = pDoneFence;
+
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                result = ma_job_process(&job);
+            } else {
+                result = ma_resource_manager_post_job(pResourceManager, &job);
+            }
+
+            if (result != MA_SUCCESS) {
+                /* Failed to post job. Probably ran out of memory. */
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to post MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE job. %s.\n", ma_result_description(result));
+
+                if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                    ma_resource_manager_inline_notification_uninit(pInitNotification);
+                } else {
+                    /*
+                    Fences were acquired before posting the job, but since the job was not able to
+                    be posted, we need to make sure we release them so nothing gets stuck waiting.
+
+                    In the WAIT_INIT case, these will have already been released in ma_job_process()
+                    so we should only release fences in this branch.
+                    */
+                    if (pInitFence != NULL) { ma_fence_release(pInitFence); }
+                    if (pDoneFence != NULL) { ma_fence_release(pDoneFence); }
+
+                    /* These will have been freed by the job thread, but with WAIT_INIT they will already have happened since the job has already been handled. */
+                    ma_free(pFilePathCopy,  &pResourceManager->config.allocationCallbacks);
+                    ma_free(pFilePathWCopy, &pResourceManager->config.allocationCallbacks);
+                }
+
+                ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+                ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+
+                return result;
+            }
+        }
+    }
+
+done:
+    if (ppDataBufferNode != NULL) {
+        *ppDataBufferNode = pDataBufferNode;
+    }
+
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_acquire(ma_resource_manager* pResourceManager, const char* pFilePath, const wchar_t* pFilePathW, ma_uint32 hashedName32, ma_uint32 flags, const ma_resource_manager_data_supply* pExistingData, ma_fence* pInitFence, ma_fence* pDoneFence, ma_resource_manager_data_buffer_node** ppDataBufferNode)
+{
+    ma_result result = MA_SUCCESS;
+    ma_bool32 nodeAlreadyExists = MA_FALSE;
+    ma_resource_manager_data_buffer_node* pDataBufferNode = NULL;
+    ma_resource_manager_inline_notification initNotification;   /* Used when the WAIT_INIT flag is set. */
+
+    if (ppDataBufferNode != NULL) {
+        *ppDataBufferNode = NULL;   /* Safety. */
+    }
+
+    if (pResourceManager == NULL || (pFilePath == NULL && pFilePathW == NULL && hashedName32 == 0)) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If we're specifying existing data, it must be valid. */
+    if (pExistingData != NULL && pExistingData->type == ma_resource_manager_data_supply_type_unknown) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If we don't support threading, remove the ASYNC flag to make the rest of this a bit simpler. */
+    if (ma_resource_manager_is_threading_enabled(pResourceManager) == MA_FALSE) {
+        flags &= ~MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC;
+    }
+
+    if (hashedName32 == 0) {
+        if (pFilePath != NULL) {
+            hashedName32 = ma_hash_string_32(pFilePath);
+        } else {
+            hashedName32 = ma_hash_string_w_32(pFilePathW);
+        }
+    }
+
+    /*
+    Here is where we either increment the node's reference count or allocate a new one and add it
+    to the BST. When allocating a new node, we need to make sure the LOAD_DATA_BUFFER_NODE job is
+    posted inside the critical section just in case the caller immediately uninitializes the node
+    as this will ensure the FREE_DATA_BUFFER_NODE job is given an execution order such that the
+    node is not uninitialized before initialization.
+    */
+    ma_resource_manager_data_buffer_bst_lock(pResourceManager);
+    {
+        result = ma_resource_manager_data_buffer_node_acquire_critical_section(pResourceManager, pFilePath, pFilePathW, hashedName32, flags, pExistingData, pInitFence, pDoneFence, &initNotification, &pDataBufferNode);
+    }
+    ma_resource_manager_data_buffer_bst_unlock(pResourceManager);
+
+    if (result == MA_ALREADY_EXISTS) {
+        nodeAlreadyExists = MA_TRUE;
+        result = MA_SUCCESS;
+    } else {
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    /*
+    If we're loading synchronously, we'll need to load everything now. When loading asynchronously,
+    a job will have been posted inside the BST critical section so that an uninitialization can be
+    allocated an appropriate execution order thereby preventing it from being uninitialized before
+    the node is initialized by the decoding thread(s).
+    */
+    if (nodeAlreadyExists == MA_FALSE) {    /* Don't need to try loading anything if the node already exists. */
+        if (pFilePath == NULL && pFilePathW == NULL) {
+            /*
+            If this path is hit, it means a buffer is being copied (i.e. initialized from only the
+            hashed name), but that node has been freed in the meantime, probably from some other
+            thread. This is an invalid operation.
+            */
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Cloning data buffer node failed because the source node was released. The source node must remain valid until the cloning has completed.\n");
+            result = MA_INVALID_OPERATION;
+            goto done;
+        }
+
+        if (pDataBufferNode->isDataOwnedByResourceManager) {
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) == 0) {
+                /* Loading synchronously. Load the sound in it's entirety here. */
+                if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE) == 0) {
+                    /* No decoding. This is the simple case - just store the file contents in memory. */
+                    result = ma_resource_manager_data_buffer_node_init_supply_encoded(pResourceManager, pDataBufferNode, pFilePath, pFilePathW);
+                    if (result != MA_SUCCESS) {
+                        goto done;
+                    }
+                } else {
+                    /* Decoding. We do this the same way as we do when loading asynchronously. */
+                    ma_decoder* pDecoder;
+                    result = ma_resource_manager_data_buffer_node_init_supply_decoded(pResourceManager, pDataBufferNode, pFilePath, pFilePathW, flags, &pDecoder);
+                    if (result != MA_SUCCESS) {
+                        goto done;
+                    }
+
+                    /* We have the decoder, now decode page by page just like we do when loading asynchronously. */
+                    for (;;) {
+                        /* Decode next page. */
+                        result = ma_resource_manager_data_buffer_node_decode_next_page(pResourceManager, pDataBufferNode, pDecoder);
+                        if (result != MA_SUCCESS) {
+                            break;  /* Will return MA_AT_END when the last page has been decoded. */
+                        }
+                    }
+
+                    /* Reaching the end needs to be considered successful. */
+                    if (result == MA_AT_END) {
+                        result  = MA_SUCCESS;
+                    }
+
+                    /*
+                    At this point the data buffer is either fully decoded or some error occurred. Either
+                    way, the decoder is no longer necessary.
+                    */
+                    ma_decoder_uninit(pDecoder);
+                    ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+                }
+
+                /* Getting here means we were successful. Make sure the status of the node is updated accordingly. */
+                ma_atomic_exchange_i32(&pDataBufferNode->result, result);
+            } else {
+                /* Loading asynchronously. We may need to wait for initialization. */
+                if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                    ma_resource_manager_inline_notification_wait(&initNotification);
+                }
+            }
+        } else {
+            /* The data is not managed by the resource manager so there's nothing else to do. */
+            MA_ASSERT(pExistingData != NULL);
+        }
+    }
+
+done:
+    /* If we failed to initialize the data buffer we need to free it. */
+    if (result != MA_SUCCESS) {
+        if (nodeAlreadyExists == MA_FALSE) {
+            ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+            ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+        }
+    }
+
+    /*
+    The init notification needs to be uninitialized. This will be used if the node does not already
+    exist, and we've specified ASYNC | WAIT_INIT.
+    */
+    if (nodeAlreadyExists == MA_FALSE && pDataBufferNode->isDataOwnedByResourceManager && (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) != 0) {
+        if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+            ma_resource_manager_inline_notification_uninit(&initNotification);
+        }
+    }
+
+    if (ppDataBufferNode != NULL) {
+        *ppDataBufferNode = pDataBufferNode;
+    }
+
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_unacquire(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, const char* pName, const wchar_t* pNameW)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 refCount = 0xFFFFFFFF; /* The new reference count of the node after decrementing. Initialize to non-0 to be safe we don't fall into the freeing path. */
+    ma_uint32 hashedName32 = 0;
+
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDataBufferNode == NULL) {
+        if (pName == NULL && pNameW == NULL) {
+            return MA_INVALID_ARGS;
+        }
+
+        if (pName != NULL) {
+            hashedName32 = ma_hash_string_32(pName);
+        } else {
+            hashedName32 = ma_hash_string_w_32(pNameW);
+        }
+    }
+
+    /*
+    The first thing to do is decrement the reference counter of the node. Then, if the reference
+    count is zero, we need to free the node. If the node is still in the process of loading, we'll
+    need to post a job to the job queue to free the node. Otherwise we'll just do it here.
+    */
+    ma_resource_manager_data_buffer_bst_lock(pResourceManager);
+    {
+        /* Might need to find the node. Must be done inside the critical section. */
+        if (pDataBufferNode == NULL) {
+            result = ma_resource_manager_data_buffer_node_search(pResourceManager, hashedName32, &pDataBufferNode);
+            if (result != MA_SUCCESS) {
+                goto stage2;    /* Couldn't find the node. */
+            }
+        }
+
+        result = ma_resource_manager_data_buffer_node_decrement_ref(pResourceManager, pDataBufferNode, &refCount);
+        if (result != MA_SUCCESS) {
+            goto stage2;    /* Should never happen. */
+        }
+
+        if (refCount == 0) {
+            result = ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+            if (result != MA_SUCCESS) {
+                goto stage2;  /* An error occurred when trying to remove the data buffer. This should never happen. */
+            }
+        }
+    }
+    ma_resource_manager_data_buffer_bst_unlock(pResourceManager);
+
+stage2:
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /*
+    Here is where we need to free the node. We don't want to do this inside the critical section
+    above because we want to keep that as small as possible for multi-threaded efficiency.
+    */
+    if (refCount == 0) {
+        if (ma_resource_manager_data_buffer_node_result(pDataBufferNode) == MA_BUSY) {
+            /* The sound is still loading. We need to delay the freeing of the node to a safe time. */
+            ma_job job;
+
+            /* We need to mark the node as unavailable for the sake of the resource manager worker threads. */
+            ma_atomic_exchange_i32(&pDataBufferNode->result, MA_UNAVAILABLE);
+
+            job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE);
+            job.order = ma_resource_manager_data_buffer_node_next_execution_order(pDataBufferNode);
+            job.data.resourceManager.freeDataBufferNode.pResourceManager = pResourceManager;
+            job.data.resourceManager.freeDataBufferNode.pDataBufferNode  = pDataBufferNode;
+
+            result = ma_resource_manager_post_job(pResourceManager, &job);
+            if (result != MA_SUCCESS) {
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to post MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE job. %s.\n", ma_result_description(result));
+                return result;
+            }
+
+            /* If we don't support threading, process the job queue here. */
+            if (ma_resource_manager_is_threading_enabled(pResourceManager) == MA_FALSE) {
+                while (ma_resource_manager_data_buffer_node_result(pDataBufferNode) == MA_BUSY) {
+                    result = ma_resource_manager_process_next_job(pResourceManager);
+                    if (result == MA_NO_DATA_AVAILABLE || result == MA_CANCELLED) {
+                        result = MA_SUCCESS;
+                        break;
+                    }
+                }
+            } else {
+                /* Threading is enabled. The job queue will deal with the rest of the cleanup from here. */
+            }
+        } else {
+            /* The sound isn't loading so we can just free the node here. */
+            ma_resource_manager_data_buffer_node_free(pResourceManager, pDataBufferNode);
+        }
+    }
+
+    return result;
+}
+
+
+
+static ma_uint32 ma_resource_manager_data_buffer_next_execution_order(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    MA_ASSERT(pDataBuffer != NULL);
+    return ma_atomic_fetch_add_32(&pDataBuffer->executionCounter, 1);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__read_pcm_frames(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_resource_manager_data_buffer_read_pcm_frames((ma_resource_manager_data_buffer*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__seek_to_pcm_frame(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_resource_manager_data_buffer_seek_to_pcm_frame((ma_resource_manager_data_buffer*)pDataSource, frameIndex);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_resource_manager_data_buffer_get_data_format((ma_resource_manager_data_buffer*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__get_cursor_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_resource_manager_data_buffer_get_cursor_in_pcm_frames((ma_resource_manager_data_buffer*)pDataSource, pCursor);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__get_length_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_resource_manager_data_buffer_get_length_in_pcm_frames((ma_resource_manager_data_buffer*)pDataSource, pLength);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__set_looping(ma_data_source* pDataSource, ma_bool32 isLooping)
+{
+    ma_resource_manager_data_buffer* pDataBuffer = (ma_resource_manager_data_buffer*)pDataSource;
+    MA_ASSERT(pDataBuffer != NULL);
+
+    ma_atomic_exchange_32(&pDataBuffer->isLooping, isLooping);
+
+    /* The looping state needs to be set on the connector as well or else looping won't work when we read audio data. */
+    ma_data_source_set_looping(ma_resource_manager_data_buffer_get_connector(pDataBuffer), isLooping);
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable g_ma_resource_manager_data_buffer_vtable =
+{
+    ma_resource_manager_data_buffer_cb__read_pcm_frames,
+    ma_resource_manager_data_buffer_cb__seek_to_pcm_frame,
+    ma_resource_manager_data_buffer_cb__get_data_format,
+    ma_resource_manager_data_buffer_cb__get_cursor_in_pcm_frames,
+    ma_resource_manager_data_buffer_cb__get_length_in_pcm_frames,
+    ma_resource_manager_data_buffer_cb__set_looping,
+    0
+};
+
+static ma_result ma_resource_manager_data_buffer_init_ex_internal(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_uint32 hashedName32, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+    ma_data_source_config dataSourceConfig;
+    ma_bool32 async;
+    ma_uint32 flags;
+    ma_resource_manager_pipeline_notifications notifications;
+
+    if (pDataBuffer == NULL) {
+        if (pConfig != NULL && pConfig->pNotifications != NULL) {
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(pConfig->pNotifications);
+        }
+
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataBuffer);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->pNotifications != NULL) {
+        notifications = *pConfig->pNotifications;   /* From here on out we should be referencing `notifications` instead of `pNotifications`. Set this to NULL to catch errors at testing time. */
+    } else {
+        MA_ZERO_OBJECT(&notifications);
+    }
+
+    /* For safety, always remove the ASYNC flag if threading is disabled on the resource manager. */
+    flags = pConfig->flags;
+    if (ma_resource_manager_is_threading_enabled(pResourceManager) == MA_FALSE) {
+        flags &= ~MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC;
+    }
+
+    if (pConfig->isLooping) {
+        flags |= MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING;
+    }
+
+    async = (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) != 0;
+
+    /*
+    Fences need to be acquired before doing anything. These must be acquired and released outside of
+    the node to ensure there's no holes where ma_fence_wait() could prematurely return before the
+    data buffer has completed initialization.
+
+    When loading asynchronously, the node acquisition routine below will acquire the fences on this
+    thread and then release them on the async thread when the operation is complete.
+
+    These fences are always released at the "done" tag at the end of this function. They'll be
+    acquired a second if loading asynchronously. This double acquisition system is just done to
+    simplify code maintenance.
+    */
+    ma_resource_manager_pipeline_notifications_acquire_all_fences(&notifications);
+    {
+        /* We first need to acquire a node. If ASYNC is not set, this will not return until the entire sound has been loaded. */
+        result = ma_resource_manager_data_buffer_node_acquire(pResourceManager, pConfig->pFilePath, pConfig->pFilePathW, hashedName32, flags, NULL, notifications.init.pFence, notifications.done.pFence, &pDataBufferNode);
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+            goto done;
+        }
+
+        dataSourceConfig = ma_data_source_config_init();
+        dataSourceConfig.vtable = &g_ma_resource_manager_data_buffer_vtable;
+
+        result = ma_data_source_init(&dataSourceConfig, &pDataBuffer->ds);
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_data_buffer_node_unacquire(pResourceManager, pDataBufferNode, NULL, NULL);
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+            goto done;
+        }
+
+        pDataBuffer->pResourceManager = pResourceManager;
+        pDataBuffer->pNode  = pDataBufferNode;
+        pDataBuffer->flags  = flags;
+        pDataBuffer->result = MA_BUSY;  /* Always default to MA_BUSY for safety. It'll be overwritten when loading completes or an error occurs. */
+
+        /* If we're loading asynchronously we need to post a job to the job queue to initialize the connector. */
+        if (async == MA_FALSE || ma_resource_manager_data_buffer_node_result(pDataBufferNode) == MA_SUCCESS) {
+            /* Loading synchronously or the data has already been fully loaded. We can just initialize the connector from here without a job. */
+            result = ma_resource_manager_data_buffer_init_connector(pDataBuffer, pConfig, NULL, NULL);
+            ma_atomic_exchange_i32(&pDataBuffer->result, result);
+
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+            goto done;
+        } else {
+            /* The node's data supply isn't initialized yet. The caller has requested that we load asynchronously so we need to post a job to do this. */
+            ma_job job;
+            ma_resource_manager_inline_notification initNotification;   /* Used when the WAIT_INIT flag is set. */
+
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                ma_resource_manager_inline_notification_init(pResourceManager, &initNotification);
+            }
+
+            /*
+            The status of the data buffer needs to be set to MA_BUSY before posting the job so that the
+            worker thread is aware of its busy state. If the LOAD_DATA_BUFFER job sees a status other
+            than MA_BUSY, it'll assume an error and fall through to an early exit.
+            */
+            ma_atomic_exchange_i32(&pDataBuffer->result, MA_BUSY);
+
+            /* Acquire fences a second time. These will be released by the async thread. */
+            ma_resource_manager_pipeline_notifications_acquire_all_fences(&notifications);
+
+            job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER);
+            job.order = ma_resource_manager_data_buffer_next_execution_order(pDataBuffer);
+            job.data.resourceManager.loadDataBuffer.pDataBuffer             = pDataBuffer;
+            job.data.resourceManager.loadDataBuffer.pInitNotification       = ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) ? &initNotification : notifications.init.pNotification;
+            job.data.resourceManager.loadDataBuffer.pDoneNotification       = notifications.done.pNotification;
+            job.data.resourceManager.loadDataBuffer.pInitFence              = notifications.init.pFence;
+            job.data.resourceManager.loadDataBuffer.pDoneFence              = notifications.done.pFence;
+            job.data.resourceManager.loadDataBuffer.rangeBegInPCMFrames     = pConfig->rangeBegInPCMFrames;
+            job.data.resourceManager.loadDataBuffer.rangeEndInPCMFrames     = pConfig->rangeEndInPCMFrames;
+            job.data.resourceManager.loadDataBuffer.loopPointBegInPCMFrames = pConfig->loopPointBegInPCMFrames;
+            job.data.resourceManager.loadDataBuffer.loopPointEndInPCMFrames = pConfig->loopPointEndInPCMFrames;
+            job.data.resourceManager.loadDataBuffer.isLooping               = (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING) != 0;
+
+            /* If we need to wait for initialization to complete we can just process the job in place. */
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                result = ma_job_process(&job);
+            } else {
+                result = ma_resource_manager_post_job(pResourceManager, &job);
+            }
+
+            if (result != MA_SUCCESS) {
+                /* We failed to post the job. Most likely there isn't enough room in the queue's buffer. */
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to post MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER job. %s.\n", ma_result_description(result));
+                ma_atomic_exchange_i32(&pDataBuffer->result, result);
+
+                /* Release the fences after the result has been set on the data buffer. */
+                ma_resource_manager_pipeline_notifications_release_all_fences(&notifications);
+            } else {
+                if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                    ma_resource_manager_inline_notification_wait(&initNotification);
+
+                    if (notifications.init.pNotification != NULL) {
+                        ma_async_notification_signal(notifications.init.pNotification);
+                    }
+
+                    /* NOTE: Do not release the init fence here. It will have been done by the job. */
+
+                    /* Make sure we return an error if initialization failed on the async thread. */
+                    result = ma_resource_manager_data_buffer_result(pDataBuffer);
+                    if (result == MA_BUSY) {
+                        result  = MA_SUCCESS;
+                    }
+                }
+            }
+
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                ma_resource_manager_inline_notification_uninit(&initNotification);
+            }
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_data_buffer_node_unacquire(pResourceManager, pDataBufferNode, NULL, NULL);
+            goto done;
+        }
+    }
+done:
+    if (result == MA_SUCCESS) {
+        if (pConfig->initialSeekPointInPCMFrames > 0) {
+            ma_resource_manager_data_buffer_seek_to_pcm_frame(pDataBuffer, pConfig->initialSeekPointInPCMFrames);
+        }
+    }
+
+    ma_resource_manager_pipeline_notifications_release_all_fences(&notifications);
+
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    return ma_resource_manager_data_buffer_init_ex_internal(pResourceManager, pConfig, 0, pDataBuffer);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_init(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePath      = pFilePath;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_buffer_init_ex(pResourceManager, &config, pDataBuffer);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_init_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePathW     = pFilePath;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_buffer_init_ex(pResourceManager, &config, pDataBuffer);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_init_copy(ma_resource_manager* pResourceManager, const ma_resource_manager_data_buffer* pExistingDataBuffer, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_resource_manager_data_source_config config;
+
+    if (pExistingDataBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ASSERT(pExistingDataBuffer->pNode != NULL);  /* <-- If you've triggered this, you've passed in an invalid existing data buffer. */
+
+    config = ma_resource_manager_data_source_config_init();
+    config.flags = pExistingDataBuffer->flags;
+
+    return ma_resource_manager_data_buffer_init_ex_internal(pResourceManager, &config, pExistingDataBuffer->pNode->hashedName32, pDataBuffer);
+}
+
+static ma_result ma_resource_manager_data_buffer_uninit_internal(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    MA_ASSERT(pDataBuffer != NULL);
+
+    /* The connector should be uninitialized first. */
+    ma_resource_manager_data_buffer_uninit_connector(pDataBuffer->pResourceManager, pDataBuffer);
+
+    /* With the connector uninitialized we can unacquire the node. */
+    ma_resource_manager_data_buffer_node_unacquire(pDataBuffer->pResourceManager, pDataBuffer->pNode, NULL, NULL);
+
+    /* The base data source needs to be uninitialized as well. */
+    ma_data_source_uninit(&pDataBuffer->ds);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_uninit(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_result result;
+
+    if (pDataBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_buffer_result(pDataBuffer) == MA_SUCCESS) {
+        /* The data buffer can be deleted synchronously. */
+        return ma_resource_manager_data_buffer_uninit_internal(pDataBuffer);
+    } else {
+        /*
+        The data buffer needs to be deleted asynchronously because it's still loading. With the status set to MA_UNAVAILABLE, no more pages will
+        be loaded and the uninitialization should happen fairly quickly. Since the caller owns the data buffer, we need to wait for this event
+        to get processed before returning.
+        */
+        ma_resource_manager_inline_notification notification;
+        ma_job job;
+
+        /*
+        We need to mark the node as unavailable so we don't try reading from it anymore, but also to
+        let the loading thread know that it needs to abort it's loading procedure.
+        */
+        ma_atomic_exchange_i32(&pDataBuffer->result, MA_UNAVAILABLE);
+
+        result = ma_resource_manager_inline_notification_init(pDataBuffer->pResourceManager, &notification);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to create the notification. This should rarely, if ever, happen. */
+        }
+
+        job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER);
+        job.order = ma_resource_manager_data_buffer_next_execution_order(pDataBuffer);
+        job.data.resourceManager.freeDataBuffer.pDataBuffer       = pDataBuffer;
+        job.data.resourceManager.freeDataBuffer.pDoneNotification = &notification;
+        job.data.resourceManager.freeDataBuffer.pDoneFence        = NULL;
+
+        result = ma_resource_manager_post_job(pDataBuffer->pResourceManager, &job);
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_inline_notification_uninit(&notification);
+            return result;
+        }
+
+        ma_resource_manager_inline_notification_wait_and_uninit(&notification);
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_read_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 framesRead = 0;
+    ma_bool32 isDecodedBufferBusy = MA_FALSE;
+
+    /* Safety. */
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    We cannot be using the data buffer after it's been uninitialized. If you trigger this assert it means you're trying to read from the data buffer after
+    it's been uninitialized or is in the process of uninitializing.
+    */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    /* If the node is not initialized we need to abort with a busy code. */
+    if (ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE) {
+        return MA_BUSY; /* Still loading. */
+    }
+
+    /*
+    If we've got a seek scheduled we'll want to do that before reading. However, for paged buffers, there's
+    a chance that the sound hasn't yet been decoded up to the seek point will result in the seek failing. If
+    this happens, we need to keep the seek scheduled and return MA_BUSY.
+    */
+    if (pDataBuffer->seekToCursorOnNextRead) {
+        pDataBuffer->seekToCursorOnNextRead = MA_FALSE;
+
+        result = ma_data_source_seek_to_pcm_frame(ma_resource_manager_data_buffer_get_connector(pDataBuffer), pDataBuffer->seekTargetInPCMFrames);
+        if (result != MA_SUCCESS) {
+            if (result == MA_BAD_SEEK && ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode) == ma_resource_manager_data_supply_type_decoded_paged) {
+                pDataBuffer->seekToCursorOnNextRead = MA_TRUE;  /* Keep the seek scheduled. We just haven't loaded enough data yet to do the seek properly. */
+                return MA_BUSY;
+            }
+
+            return result;
+        }
+    }
+
+    /*
+    For decoded buffers (not paged) we need to check beforehand how many frames we have available. We cannot
+    exceed this amount. We'll read as much as we can, and then return MA_BUSY.
+    */
+    if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode) == ma_resource_manager_data_supply_type_decoded) {
+        ma_uint64 availableFrames;
+
+        isDecodedBufferBusy = (ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) == MA_BUSY);
+
+        if (ma_resource_manager_data_buffer_get_available_frames(pDataBuffer, &availableFrames) == MA_SUCCESS) {
+            /* Don't try reading more than the available frame count if the data buffer node is still loading. */
+            if (isDecodedBufferBusy) {
+                if (frameCount > availableFrames) {
+                    frameCount = availableFrames;
+
+                    /*
+                    If there's no frames available we want to set the status to MA_AT_END. The logic below
+                    will check if the node is busy, and if so, change it to MA_BUSY. The reason we do this
+                    is because we don't want to call `ma_data_source_read_pcm_frames()` if the frame count
+                    is 0 because that'll result in a situation where it's possible MA_AT_END won't get
+                    returned.
+                    */
+                    if (frameCount == 0) {
+                        result = MA_AT_END;
+                    }
+                } else {
+                    isDecodedBufferBusy = MA_FALSE; /* We have enough frames available in the buffer to avoid a MA_BUSY status. */
+                }
+            } else {
+                /*
+                Getting here means the buffer has been fully loaded. We can just pass the frame count straight
+                into ma_data_source_read_pcm_frames() below and let ma_data_source handle it.
+                */
+            }
+        }
+    }
+
+    /* Don't attempt to read anything if we've got no frames available. */
+    if (frameCount > 0) {
+        result = ma_data_source_read_pcm_frames(ma_resource_manager_data_buffer_get_connector(pDataBuffer), pFramesOut, frameCount, &framesRead);
+    }
+
+    /*
+    If we returned MA_AT_END, but the node is still loading, we don't want to return that code or else the caller will interpret the sound
+    as at the end and terminate decoding.
+    */
+    if (result == MA_AT_END) {
+        if (ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) == MA_BUSY) {
+            result = MA_BUSY;
+        }
+    }
+
+    if (isDecodedBufferBusy) {
+        result = MA_BUSY;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    if (result == MA_SUCCESS && framesRead == 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_seek_to_pcm_frame(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64 frameIndex)
+{
+    ma_result result;
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    /* If we haven't yet got a connector we need to abort. */
+    if (ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE) {
+        pDataBuffer->seekTargetInPCMFrames = frameIndex;
+        pDataBuffer->seekToCursorOnNextRead = MA_TRUE;
+        return MA_BUSY; /* Still loading. */
+    }
+
+    result = ma_data_source_seek_to_pcm_frame(ma_resource_manager_data_buffer_get_connector(pDataBuffer), frameIndex);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDataBuffer->seekTargetInPCMFrames = ~(ma_uint64)0; /* <-- For identification purposes. */
+    pDataBuffer->seekToCursorOnNextRead = MA_FALSE;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_get_data_format(ma_resource_manager_data_buffer* pDataBuffer, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:
+        {
+            return ma_data_source_get_data_format(&pDataBuffer->connector.decoder, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded:
+        {
+            *pFormat     = pDataBuffer->pNode->data.backend.decoded.format;
+            *pChannels   = pDataBuffer->pNode->data.backend.decoded.channels;
+            *pSampleRate = pDataBuffer->pNode->data.backend.decoded.sampleRate;
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pDataBuffer->pNode->data.backend.decoded.channels);
+            return MA_SUCCESS;
+        };
+
+        case ma_resource_manager_data_supply_type_decoded_paged:
+        {
+            *pFormat     = pDataBuffer->pNode->data.backend.decodedPaged.data.format;
+            *pChannels   = pDataBuffer->pNode->data.backend.decodedPaged.data.channels;
+            *pSampleRate = pDataBuffer->pNode->data.backend.decodedPaged.sampleRate;
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pDataBuffer->pNode->data.backend.decoded.channels);
+            return MA_SUCCESS;
+        };
+
+        case ma_resource_manager_data_supply_type_unknown:
+        {
+            return MA_BUSY; /* Still loading. */
+        };
+
+        default:
+        {
+            /* Unknown supply type. Should never hit this. */
+            return MA_INVALID_ARGS;
+        }
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_get_cursor_in_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pCursor)
+{
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    if (pDataBuffer == NULL || pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:
+        {
+            return ma_decoder_get_cursor_in_pcm_frames(&pDataBuffer->connector.decoder, pCursor);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded:
+        {
+            return ma_audio_buffer_get_cursor_in_pcm_frames(&pDataBuffer->connector.buffer, pCursor);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded_paged:
+        {
+            return ma_paged_audio_buffer_get_cursor_in_pcm_frames(&pDataBuffer->connector.pagedBuffer, pCursor);
+        };
+
+        case ma_resource_manager_data_supply_type_unknown:
+        {
+            return MA_BUSY;
+        };
+
+        default:
+        {
+            return MA_INVALID_ARGS;
+        }
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_get_length_in_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pLength)
+{
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    if (pDataBuffer == NULL || pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode) == ma_resource_manager_data_supply_type_unknown) {
+        return MA_BUSY; /* Still loading. */
+    }
+
+    return ma_data_source_get_length_in_pcm_frames(ma_resource_manager_data_buffer_get_connector(pDataBuffer), pLength);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_result(const ma_resource_manager_data_buffer* pDataBuffer)
+{
+    if (pDataBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return (ma_result)ma_atomic_load_i32((ma_result*)&pDataBuffer->result);    /* Need a naughty const-cast here. */
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_set_looping(ma_resource_manager_data_buffer* pDataBuffer, ma_bool32 isLooping)
+{
+    return ma_data_source_set_looping(pDataBuffer, isLooping);
+}
+
+MA_API ma_bool32 ma_resource_manager_data_buffer_is_looping(const ma_resource_manager_data_buffer* pDataBuffer)
+{
+    return ma_data_source_is_looping(pDataBuffer);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_get_available_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pAvailableFrames)
+{
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pDataBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode) == ma_resource_manager_data_supply_type_unknown) {
+        if (ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) == MA_BUSY) {
+            return MA_BUSY;
+        } else {
+            return MA_INVALID_OPERATION;    /* No connector. */
+        }
+    }
+
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:
+        {
+            return ma_decoder_get_available_frames(&pDataBuffer->connector.decoder, pAvailableFrames);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded:
+        {
+            return ma_audio_buffer_get_available_frames(&pDataBuffer->connector.buffer, pAvailableFrames);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded_paged:
+        {
+            ma_uint64 cursor;
+            ma_paged_audio_buffer_get_cursor_in_pcm_frames(&pDataBuffer->connector.pagedBuffer, &cursor);
+
+            if (pDataBuffer->pNode->data.backend.decodedPaged.decodedFrameCount > cursor) {
+                *pAvailableFrames = pDataBuffer->pNode->data.backend.decodedPaged.decodedFrameCount - cursor;
+            } else {
+                *pAvailableFrames = 0;
+            }
+
+            return MA_SUCCESS;
+        };
+
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            /* Unknown supply type. Should never hit this. */
+            return MA_INVALID_ARGS;
+        }
+    }
+}
+
+MA_API ma_result ma_resource_manager_register_file(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags)
+{
+    return ma_resource_manager_data_buffer_node_acquire(pResourceManager, pFilePath, NULL, 0, flags, NULL, NULL, NULL, NULL);
+}
+
+MA_API ma_result ma_resource_manager_register_file_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags)
+{
+    return ma_resource_manager_data_buffer_node_acquire(pResourceManager, NULL, pFilePath, 0, flags, NULL, NULL, NULL, NULL);
+}
+
+
+static ma_result ma_resource_manager_register_data(ma_resource_manager* pResourceManager, const char* pName, const wchar_t* pNameW, ma_resource_manager_data_supply* pExistingData)
+{
+    return ma_resource_manager_data_buffer_node_acquire(pResourceManager, pName, pNameW, 0, 0, pExistingData, NULL, NULL, NULL);
+}
+
+static ma_result ma_resource_manager_register_decoded_data_internal(ma_resource_manager* pResourceManager, const char* pName, const wchar_t* pNameW, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    ma_resource_manager_data_supply data;
+    data.type                            = ma_resource_manager_data_supply_type_decoded;
+    data.backend.decoded.pData           = pData;
+    data.backend.decoded.totalFrameCount = frameCount;
+    data.backend.decoded.format          = format;
+    data.backend.decoded.channels        = channels;
+    data.backend.decoded.sampleRate      = sampleRate;
+
+    return ma_resource_manager_register_data(pResourceManager, pName, pNameW, &data);
+}
+
+MA_API ma_result ma_resource_manager_register_decoded_data(ma_resource_manager* pResourceManager, const char* pName, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    return ma_resource_manager_register_decoded_data_internal(pResourceManager, pName, NULL, pData, frameCount, format, channels, sampleRate);
+}
+
+MA_API ma_result ma_resource_manager_register_decoded_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    return ma_resource_manager_register_decoded_data_internal(pResourceManager, NULL, pName, pData, frameCount, format, channels, sampleRate);
+}
+
+
+static ma_result ma_resource_manager_register_encoded_data_internal(ma_resource_manager* pResourceManager, const char* pName, const wchar_t* pNameW, const void* pData, size_t sizeInBytes)
+{
+    ma_resource_manager_data_supply data;
+    data.type                        = ma_resource_manager_data_supply_type_encoded;
+    data.backend.encoded.pData       = pData;
+    data.backend.encoded.sizeInBytes = sizeInBytes;
+
+    return ma_resource_manager_register_data(pResourceManager, pName, pNameW, &data);
+}
+
+MA_API ma_result ma_resource_manager_register_encoded_data(ma_resource_manager* pResourceManager, const char* pName, const void* pData, size_t sizeInBytes)
+{
+    return ma_resource_manager_register_encoded_data_internal(pResourceManager, pName, NULL, pData, sizeInBytes);
+}
+
+MA_API ma_result ma_resource_manager_register_encoded_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName, const void* pData, size_t sizeInBytes)
+{
+    return ma_resource_manager_register_encoded_data_internal(pResourceManager, NULL, pName, pData, sizeInBytes);
+}
+
+
+MA_API ma_result ma_resource_manager_unregister_file(ma_resource_manager* pResourceManager, const char* pFilePath)
+{
+    return ma_resource_manager_unregister_data(pResourceManager, pFilePath);
+}
+
+MA_API ma_result ma_resource_manager_unregister_file_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath)
+{
+    return ma_resource_manager_unregister_data_w(pResourceManager, pFilePath);
+}
+
+MA_API ma_result ma_resource_manager_unregister_data(ma_resource_manager* pResourceManager, const char* pName)
+{
+    return ma_resource_manager_data_buffer_node_unacquire(pResourceManager, NULL, pName, NULL);
+}
+
+MA_API ma_result ma_resource_manager_unregister_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName)
+{
+    return ma_resource_manager_data_buffer_node_unacquire(pResourceManager, NULL, NULL, pName);
+}
+
+
+static ma_uint32 ma_resource_manager_data_stream_next_execution_order(ma_resource_manager_data_stream* pDataStream)
+{
+    MA_ASSERT(pDataStream != NULL);
+    return ma_atomic_fetch_add_32(&pDataStream->executionCounter, 1);
+}
+
+static ma_bool32 ma_resource_manager_data_stream_is_decoder_at_end(const ma_resource_manager_data_stream* pDataStream)
+{
+    MA_ASSERT(pDataStream != NULL);
+    return ma_atomic_load_32((ma_bool32*)&pDataStream->isDecoderAtEnd);
+}
+
+static ma_uint32 ma_resource_manager_data_stream_seek_counter(const ma_resource_manager_data_stream* pDataStream)
+{
+    MA_ASSERT(pDataStream != NULL);
+    return ma_atomic_load_32((ma_uint32*)&pDataStream->seekCounter);
+}
+
+
+static ma_result ma_resource_manager_data_stream_cb__read_pcm_frames(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_resource_manager_data_stream_read_pcm_frames((ma_resource_manager_data_stream*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__seek_to_pcm_frame(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_resource_manager_data_stream_seek_to_pcm_frame((ma_resource_manager_data_stream*)pDataSource, frameIndex);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_resource_manager_data_stream_get_data_format((ma_resource_manager_data_stream*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__get_cursor_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_resource_manager_data_stream_get_cursor_in_pcm_frames((ma_resource_manager_data_stream*)pDataSource, pCursor);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__get_length_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_resource_manager_data_stream_get_length_in_pcm_frames((ma_resource_manager_data_stream*)pDataSource, pLength);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__set_looping(ma_data_source* pDataSource, ma_bool32 isLooping)
+{
+    ma_resource_manager_data_stream* pDataStream = (ma_resource_manager_data_stream*)pDataSource;
+    MA_ASSERT(pDataStream != NULL);
+
+    ma_atomic_exchange_32(&pDataStream->isLooping, isLooping);
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable g_ma_resource_manager_data_stream_vtable =
+{
+    ma_resource_manager_data_stream_cb__read_pcm_frames,
+    ma_resource_manager_data_stream_cb__seek_to_pcm_frame,
+    ma_resource_manager_data_stream_cb__get_data_format,
+    ma_resource_manager_data_stream_cb__get_cursor_in_pcm_frames,
+    ma_resource_manager_data_stream_cb__get_length_in_pcm_frames,
+    ma_resource_manager_data_stream_cb__set_looping,
+    0 /*MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT*/
+};
+
+static void ma_resource_manager_data_stream_set_absolute_cursor(ma_resource_manager_data_stream* pDataStream, ma_uint64 absoluteCursor)
+{
+    /* Loop if possible. */
+    if (absoluteCursor > pDataStream->totalLengthInPCMFrames && pDataStream->totalLengthInPCMFrames > 0) {
+        absoluteCursor = absoluteCursor % pDataStream->totalLengthInPCMFrames;
+    }
+
+    ma_atomic_exchange_64(&pDataStream->absoluteCursor, absoluteCursor);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_stream* pDataStream)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+    char* pFilePathCopy = NULL;
+    wchar_t* pFilePathWCopy = NULL;
+    ma_job job;
+    ma_bool32 waitBeforeReturning = MA_FALSE;
+    ma_resource_manager_inline_notification waitNotification;
+    ma_resource_manager_pipeline_notifications notifications;
+    ma_uint32 flags;
+
+    if (pDataStream == NULL) {
+        if (pConfig != NULL && pConfig->pNotifications != NULL) {
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(pConfig->pNotifications);
+        }
+
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataStream);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->pNotifications != NULL) {
+        notifications = *pConfig->pNotifications;    /* From here on out, `notifications` should be used instead of `pNotifications`. Setting this to NULL to catch any errors at testing time. */
+    } else {
+        MA_ZERO_OBJECT(&notifications);
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_resource_manager_data_stream_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pDataStream->ds);
+    if (result != MA_SUCCESS) {
+        ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+        return result;
+    }
+
+    flags = pConfig->flags;
+    if (pConfig->isLooping) {
+        flags |= MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING;
+    }
+
+    pDataStream->pResourceManager = pResourceManager;
+    pDataStream->flags            = pConfig->flags;
+    pDataStream->result           = MA_BUSY;
+
+    ma_data_source_set_range_in_pcm_frames(pDataStream, pConfig->rangeBegInPCMFrames, pConfig->rangeEndInPCMFrames);
+    ma_data_source_set_loop_point_in_pcm_frames(pDataStream, pConfig->loopPointBegInPCMFrames, pConfig->loopPointEndInPCMFrames);
+    ma_data_source_set_looping(pDataStream, (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING) != 0);
+
+    if (pResourceManager == NULL || (pConfig->pFilePath == NULL && pConfig->pFilePathW == NULL)) {
+        ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+        return MA_INVALID_ARGS;
+    }
+
+    /* We want all access to the VFS and the internal decoder to happen on the job thread just to keep things easier to manage for the VFS.  */
+
+    /* We need a copy of the file path. We should probably make this more efficient, but for now we'll do a transient memory allocation. */
+    if (pConfig->pFilePath != NULL) {
+        pFilePathCopy  = ma_copy_string(pConfig->pFilePath, &pResourceManager->config.allocationCallbacks);
+    } else {
+        pFilePathWCopy = ma_copy_string_w(pConfig->pFilePathW, &pResourceManager->config.allocationCallbacks);
+    }
+
+    if (pFilePathCopy == NULL && pFilePathWCopy == NULL) {
+        ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+        return MA_OUT_OF_MEMORY;
+    }
+
+    /*
+    We need to check for the presence of MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC. If it's not set, we need to wait before returning. Otherwise we
+    can return immediately. Likewise, we'll also check for MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT and do the same.
+    */
+    if ((pConfig->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) == 0 || (pConfig->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+        waitBeforeReturning = MA_TRUE;
+        ma_resource_manager_inline_notification_init(pResourceManager, &waitNotification);
+    }
+
+    ma_resource_manager_pipeline_notifications_acquire_all_fences(&notifications);
+
+    /* Set the absolute cursor to our initial seek position so retrieval of the cursor returns a good value. */
+    ma_resource_manager_data_stream_set_absolute_cursor(pDataStream, pConfig->initialSeekPointInPCMFrames);
+
+    /* We now have everything we need to post the job. This is the last thing we need to do from here. The rest will be done by the job thread. */
+    job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM);
+    job.order = ma_resource_manager_data_stream_next_execution_order(pDataStream);
+    job.data.resourceManager.loadDataStream.pDataStream       = pDataStream;
+    job.data.resourceManager.loadDataStream.pFilePath         = pFilePathCopy;
+    job.data.resourceManager.loadDataStream.pFilePathW        = pFilePathWCopy;
+    job.data.resourceManager.loadDataStream.initialSeekPoint  = pConfig->initialSeekPointInPCMFrames;
+    job.data.resourceManager.loadDataStream.pInitNotification = (waitBeforeReturning == MA_TRUE) ? &waitNotification : notifications.init.pNotification;
+    job.data.resourceManager.loadDataStream.pInitFence        = notifications.init.pFence;
+    result = ma_resource_manager_post_job(pResourceManager, &job);
+    if (result != MA_SUCCESS) {
+        ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+        ma_resource_manager_pipeline_notifications_release_all_fences(&notifications);
+
+        if (waitBeforeReturning) {
+            ma_resource_manager_inline_notification_uninit(&waitNotification);
+        }
+
+        ma_free(pFilePathCopy,  &pResourceManager->config.allocationCallbacks);
+        ma_free(pFilePathWCopy, &pResourceManager->config.allocationCallbacks);
+        return result;
+    }
+
+    /* Wait if needed. */
+    if (waitBeforeReturning) {
+        ma_resource_manager_inline_notification_wait_and_uninit(&waitNotification);
+
+        if (notifications.init.pNotification != NULL) {
+            ma_async_notification_signal(notifications.init.pNotification);
+        }
+
+        /*
+        If there was an error during initialization make sure we return that result here. We don't want to do this
+        if we're not waiting because it will most likely be in a busy state.
+        */
+        if (pDataStream->result != MA_SUCCESS) {
+            return pDataStream->result;
+        }
+
+        /* NOTE: Do not release pInitFence here. That will be done by the job. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_stream_init(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_stream* pDataStream)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePath      = pFilePath;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_stream_init_ex(pResourceManager, &config, pDataStream);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_init_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_stream* pDataStream)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePathW     = pFilePath;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_stream_init_ex(pResourceManager, &config, pDataStream);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_uninit(ma_resource_manager_data_stream* pDataStream)
+{
+    ma_resource_manager_inline_notification freeEvent;
+    ma_job job;
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The first thing to do is set the result to unavailable. This will prevent future page decoding. */
+    ma_atomic_exchange_i32(&pDataStream->result, MA_UNAVAILABLE);
+
+    /*
+    We need to post a job to ensure we're not in the middle or decoding or anything. Because the object is owned by the caller, we'll need
+    to wait for it to complete before returning which means we need an event.
+    */
+    ma_resource_manager_inline_notification_init(pDataStream->pResourceManager, &freeEvent);
+
+    job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM);
+    job.order = ma_resource_manager_data_stream_next_execution_order(pDataStream);
+    job.data.resourceManager.freeDataStream.pDataStream       = pDataStream;
+    job.data.resourceManager.freeDataStream.pDoneNotification = &freeEvent;
+    job.data.resourceManager.freeDataStream.pDoneFence        = NULL;
+    ma_resource_manager_post_job(pDataStream->pResourceManager, &job);
+
+    /* We need to wait for the job to finish processing before we return. */
+    ma_resource_manager_inline_notification_wait_and_uninit(&freeEvent);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_uint32 ma_resource_manager_data_stream_get_page_size_in_frames(ma_resource_manager_data_stream* pDataStream)
+{
+    MA_ASSERT(pDataStream != NULL);
+    MA_ASSERT(pDataStream->isDecoderInitialized == MA_TRUE);
+
+    return MA_RESOURCE_MANAGER_PAGE_SIZE_IN_MILLISECONDS * (pDataStream->decoder.outputSampleRate/1000);
+}
+
+static void* ma_resource_manager_data_stream_get_page_data_pointer(ma_resource_manager_data_stream* pDataStream, ma_uint32 pageIndex, ma_uint32 relativeCursor)
+{
+    MA_ASSERT(pDataStream != NULL);
+    MA_ASSERT(pDataStream->isDecoderInitialized == MA_TRUE);
+    MA_ASSERT(pageIndex == 0 || pageIndex == 1);
+
+    return ma_offset_ptr(pDataStream->pPageData, ((ma_resource_manager_data_stream_get_page_size_in_frames(pDataStream) * pageIndex) + relativeCursor) * ma_get_bytes_per_frame(pDataStream->decoder.outputFormat, pDataStream->decoder.outputChannels));
+}
+
+static void ma_resource_manager_data_stream_fill_page(ma_resource_manager_data_stream* pDataStream, ma_uint32 pageIndex)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 pageSizeInFrames;
+    ma_uint64 totalFramesReadForThisPage = 0;
+    void* pPageData = ma_resource_manager_data_stream_get_page_data_pointer(pDataStream, pageIndex, 0);
+
+    pageSizeInFrames = ma_resource_manager_data_stream_get_page_size_in_frames(pDataStream);
+
+    /* The decoder needs to inherit the stream's looping and range state. */
+    {
+        ma_uint64 rangeBeg;
+        ma_uint64 rangeEnd;
+        ma_uint64 loopPointBeg;
+        ma_uint64 loopPointEnd;
+
+        ma_data_source_set_looping(&pDataStream->decoder, ma_resource_manager_data_stream_is_looping(pDataStream));
+
+        ma_data_source_get_range_in_pcm_frames(pDataStream, &rangeBeg, &rangeEnd);
+        ma_data_source_set_range_in_pcm_frames(&pDataStream->decoder, rangeBeg, rangeEnd);
+
+        ma_data_source_get_loop_point_in_pcm_frames(pDataStream, &loopPointBeg, &loopPointEnd);
+        ma_data_source_set_loop_point_in_pcm_frames(&pDataStream->decoder, loopPointBeg, loopPointEnd);
+    }
+
+    /* Just read straight from the decoder. It will deal with ranges and looping for us. */
+    result = ma_data_source_read_pcm_frames(&pDataStream->decoder, pPageData, pageSizeInFrames, &totalFramesReadForThisPage);
+    if (result == MA_AT_END || totalFramesReadForThisPage < pageSizeInFrames) {
+        ma_atomic_exchange_32(&pDataStream->isDecoderAtEnd, MA_TRUE);
+    }
+
+    ma_atomic_exchange_32(&pDataStream->pageFrameCount[pageIndex], (ma_uint32)totalFramesReadForThisPage);
+    ma_atomic_exchange_32(&pDataStream->isPageValid[pageIndex], MA_TRUE);
+}
+
+static void ma_resource_manager_data_stream_fill_pages(ma_resource_manager_data_stream* pDataStream)
+{
+    ma_uint32 iPage;
+
+    MA_ASSERT(pDataStream != NULL);
+
+    for (iPage = 0; iPage < 2; iPage += 1) {
+        ma_resource_manager_data_stream_fill_page(pDataStream, iPage);
+    }
+}
+
+
+static ma_result ma_resource_manager_data_stream_map(ma_resource_manager_data_stream* pDataStream, void** ppFramesOut, ma_uint64* pFrameCount)
+{
+    ma_uint64 framesAvailable;
+    ma_uint64 frameCount = 0;
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pFrameCount != NULL) {
+        frameCount = *pFrameCount;
+        *pFrameCount = 0;
+    }
+    if (ppFramesOut != NULL) {
+        *ppFramesOut = NULL;
+    }
+
+    if (pDataStream == NULL || ppFramesOut == NULL || pFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Don't attempt to read while we're in the middle of seeking. Tell the caller that we're busy. */
+    if (ma_resource_manager_data_stream_seek_counter(pDataStream) > 0) {
+        return MA_BUSY;
+    }
+
+    /* If the page we're on is invalid it means we've caught up to the job thread. */
+    if (ma_atomic_load_32(&pDataStream->isPageValid[pDataStream->currentPageIndex]) == MA_FALSE) {
+        framesAvailable = 0;
+    } else {
+        /*
+        The page we're on is valid so we must have some frames available. We need to make sure that we don't overflow into the next page, even if it's valid. The reason is
+        that the unmap process will only post an update for one page at a time. Keeping mapping tied to page boundaries makes this simpler.
+        */
+        ma_uint32 currentPageFrameCount = ma_atomic_load_32(&pDataStream->pageFrameCount[pDataStream->currentPageIndex]);
+        MA_ASSERT(currentPageFrameCount >= pDataStream->relativeCursor);
+
+        framesAvailable = currentPageFrameCount - pDataStream->relativeCursor;
+    }
+
+    /* If there's no frames available and the result is set to MA_AT_END we need to return MA_AT_END. */
+    if (framesAvailable == 0) {
+        if (ma_resource_manager_data_stream_is_decoder_at_end(pDataStream)) {
+            return MA_AT_END;
+        } else {
+            return MA_BUSY; /* There are no frames available, but we're not marked as EOF so we might have caught up to the job thread. Need to return MA_BUSY and wait for more data. */
+        }
+    }
+
+    MA_ASSERT(framesAvailable > 0);
+
+    if (frameCount > framesAvailable) {
+        frameCount = framesAvailable;
+    }
+
+    *ppFramesOut = ma_resource_manager_data_stream_get_page_data_pointer(pDataStream, pDataStream->currentPageIndex, pDataStream->relativeCursor);
+    *pFrameCount = frameCount;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_resource_manager_data_stream_unmap(ma_resource_manager_data_stream* pDataStream, ma_uint64 frameCount)
+{
+    ma_uint32 newRelativeCursor;
+    ma_uint32 pageSizeInFrames;
+    ma_job job;
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The frame count should always fit inside a 32-bit integer. */
+    if (frameCount > 0xFFFFFFFF) {
+        return MA_INVALID_ARGS;
+    }
+
+    pageSizeInFrames = ma_resource_manager_data_stream_get_page_size_in_frames(pDataStream);
+
+    /* The absolute cursor needs to be updated for ma_resource_manager_data_stream_get_cursor_in_pcm_frames(). */
+    ma_resource_manager_data_stream_set_absolute_cursor(pDataStream, ma_atomic_load_64(&pDataStream->absoluteCursor) + frameCount);
+
+    /* Here is where we need to check if we need to load a new page, and if so, post a job to load it. */
+    newRelativeCursor = pDataStream->relativeCursor + (ma_uint32)frameCount;
+
+    /* If the new cursor has flowed over to the next page we need to mark the old one as invalid and post an event for it. */
+    if (newRelativeCursor >= pageSizeInFrames) {
+        newRelativeCursor -= pageSizeInFrames;
+
+        /* Here is where we post the job start decoding. */
+        job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_STREAM);
+        job.order = ma_resource_manager_data_stream_next_execution_order(pDataStream);
+        job.data.resourceManager.pageDataStream.pDataStream = pDataStream;
+        job.data.resourceManager.pageDataStream.pageIndex   = pDataStream->currentPageIndex;
+
+        /* The page needs to be marked as invalid so that the public API doesn't try reading from it. */
+        ma_atomic_exchange_32(&pDataStream->isPageValid[pDataStream->currentPageIndex], MA_FALSE);
+
+        /* Before posting the job we need to make sure we set some state. */
+        pDataStream->relativeCursor   = newRelativeCursor;
+        pDataStream->currentPageIndex = (pDataStream->currentPageIndex + 1) & 0x01;
+        return ma_resource_manager_post_job(pDataStream->pResourceManager, &job);
+    } else {
+        /* We haven't moved into a new page so we can just move the cursor forward. */
+        pDataStream->relativeCursor = newRelativeCursor;
+        return MA_SUCCESS;
+    }
+}
+
+
+MA_API ma_result ma_resource_manager_data_stream_read_pcm_frames(ma_resource_manager_data_stream* pDataStream, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 totalFramesProcessed;
+    ma_format format;
+    ma_uint32 channels;
+
+    /* Safety. */
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Don't attempt to read while we're in the middle of seeking. Tell the caller that we're busy. */
+    if (ma_resource_manager_data_stream_seek_counter(pDataStream) > 0) {
+        return MA_BUSY;
+    }
+
+    ma_resource_manager_data_stream_get_data_format(pDataStream, &format, &channels, NULL, NULL, 0);
+
+    /* Reading is implemented in terms of map/unmap. We need to run this in a loop because mapping is clamped against page boundaries. */
+    totalFramesProcessed = 0;
+    while (totalFramesProcessed < frameCount) {
+        void* pMappedFrames;
+        ma_uint64 mappedFrameCount;
+
+        mappedFrameCount = frameCount - totalFramesProcessed;
+        result = ma_resource_manager_data_stream_map(pDataStream, &pMappedFrames, &mappedFrameCount);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        /* Copy the mapped data to the output buffer if we have one. It's allowed for pFramesOut to be NULL in which case a relative forward seek is performed. */
+        if (pFramesOut != NULL) {
+            ma_copy_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, totalFramesProcessed, format, channels), pMappedFrames, mappedFrameCount, format, channels);
+        }
+
+        totalFramesProcessed += mappedFrameCount;
+
+        result = ma_resource_manager_data_stream_unmap(pDataStream, mappedFrameCount);
+        if (result != MA_SUCCESS) {
+            break;  /* This is really bad - will only get an error here if we failed to post a job to the queue for loading the next page. */
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesProcessed;
+    }
+
+    if (result == MA_SUCCESS && totalFramesProcessed == 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_data_stream_seek_to_pcm_frame(ma_resource_manager_data_stream* pDataStream, ma_uint64 frameIndex)
+{
+    ma_job job;
+    ma_result streamResult;
+
+    streamResult = ma_resource_manager_data_stream_result(pDataStream);
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(streamResult != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (streamResult != MA_SUCCESS && streamResult != MA_BUSY) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* If we're not already seeking and we're sitting on the same frame, just make this a no-op. */
+    if (ma_atomic_load_32(&pDataStream->seekCounter) == 0) {
+        if (ma_atomic_load_64(&pDataStream->absoluteCursor) == frameIndex) {
+            return MA_SUCCESS;
+        }
+    }
+
+
+    /* Increment the seek counter first to indicate to read_paged_pcm_frames() and map_paged_pcm_frames() that we are in the middle of a seek and MA_BUSY should be returned. */
+    ma_atomic_fetch_add_32(&pDataStream->seekCounter, 1);
+
+    /* Update the absolute cursor so that ma_resource_manager_data_stream_get_cursor_in_pcm_frames() returns the new position. */
+    ma_resource_manager_data_stream_set_absolute_cursor(pDataStream, frameIndex);
+
+    /*
+    We need to clear our currently loaded pages so that the stream starts playback from the new seek point as soon as possible. These are for the purpose of the public
+    API and will be ignored by the seek job. The seek job will operate on the assumption that both pages have been marked as invalid and the cursor is at the start of
+    the first page.
+    */
+    pDataStream->relativeCursor   = 0;
+    pDataStream->currentPageIndex = 0;
+    ma_atomic_exchange_32(&pDataStream->isPageValid[0], MA_FALSE);
+    ma_atomic_exchange_32(&pDataStream->isPageValid[1], MA_FALSE);
+
+    /* Make sure the data stream is not marked as at the end or else if we seek in response to hitting the end, we won't be able to read any more data. */
+    ma_atomic_exchange_32(&pDataStream->isDecoderAtEnd, MA_FALSE);
+
+    /*
+    The public API is not allowed to touch the internal decoder so we need to use a job to perform the seek. When seeking, the job thread will assume both pages
+    are invalid and any content contained within them will be discarded and replaced with newly decoded data.
+    */
+    job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_SEEK_DATA_STREAM);
+    job.order = ma_resource_manager_data_stream_next_execution_order(pDataStream);
+    job.data.resourceManager.seekDataStream.pDataStream = pDataStream;
+    job.data.resourceManager.seekDataStream.frameIndex  = frameIndex;
+    return ma_resource_manager_post_job(pDataStream->pResourceManager, &job);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_get_data_format(ma_resource_manager_data_stream* pDataStream, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    We're being a little bit naughty here and accessing the internal decoder from the public API. The output data format is constant, and we've defined this function
+    such that the application is responsible for ensuring it's not called while uninitializing so it should be safe.
+    */
+    return ma_data_source_get_data_format(&pDataStream->decoder, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_get_cursor_in_pcm_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pCursor)
+{
+    ma_result result;
+
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    If the stream is in an erroneous state we need to return an invalid operation. We can allow
+    this to be called when the data stream is in a busy state because the caller may have asked
+    for an initial seek position and it's convenient to return that as the cursor position.
+    */
+    result = ma_resource_manager_data_stream_result(pDataStream);
+    if (result != MA_SUCCESS && result != MA_BUSY) {
+        return MA_INVALID_OPERATION;
+    }
+
+    *pCursor = ma_atomic_load_64(&pDataStream->absoluteCursor);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_stream_get_length_in_pcm_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pLength)
+{
+    ma_result streamResult;
+
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    streamResult = ma_resource_manager_data_stream_result(pDataStream);
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(streamResult != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (streamResult != MA_SUCCESS) {
+        return streamResult;
+    }
+
+    /*
+    We most definitely do not want to be calling ma_decoder_get_length_in_pcm_frames() directly. Instead we want to use a cached value that we
+    calculated when we initialized it on the job thread.
+    */
+    *pLength = pDataStream->totalLengthInPCMFrames;
+    if (*pLength == 0) {
+        return MA_NOT_IMPLEMENTED;  /* Some decoders may not have a known length. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_stream_result(const ma_resource_manager_data_stream* pDataStream)
+{
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return (ma_result)ma_atomic_load_i32(&pDataStream->result);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_set_looping(ma_resource_manager_data_stream* pDataStream, ma_bool32 isLooping)
+{
+    return ma_data_source_set_looping(pDataStream, isLooping);
+}
+
+MA_API ma_bool32 ma_resource_manager_data_stream_is_looping(const ma_resource_manager_data_stream* pDataStream)
+{
+    if (pDataStream == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_atomic_load_32((ma_bool32*)&pDataStream->isLooping);   /* Naughty const-cast. Value won't change from here in practice (maybe from another thread). */
+}
+
+MA_API ma_result ma_resource_manager_data_stream_get_available_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pAvailableFrames)
+{
+    ma_uint32 pageIndex0;
+    ma_uint32 pageIndex1;
+    ma_uint32 relativeCursor;
+    ma_uint64 availableFrames;
+
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pageIndex0     =  pDataStream->currentPageIndex;
+    pageIndex1     = (pDataStream->currentPageIndex + 1) & 0x01;
+    relativeCursor =  pDataStream->relativeCursor;
+
+    availableFrames = 0;
+    if (ma_atomic_load_32(&pDataStream->isPageValid[pageIndex0])) {
+        availableFrames += ma_atomic_load_32(&pDataStream->pageFrameCount[pageIndex0]) - relativeCursor;
+        if (ma_atomic_load_32(&pDataStream->isPageValid[pageIndex1])) {
+            availableFrames += ma_atomic_load_32(&pDataStream->pageFrameCount[pageIndex1]);
+        }
+    }
+
+    *pAvailableFrames = availableFrames;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_resource_manager_data_source_preinit(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataSource);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSource->flags = pConfig->flags;
+    if (pConfig->isLooping) {
+        pDataSource->flags |= MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_source_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_source* pDataSource)
+{
+    ma_result result;
+
+    result = ma_resource_manager_data_source_preinit(pResourceManager, pConfig, pDataSource);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* The data source itself is just a data stream or a data buffer. */
+    if ((pConfig->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_init_ex(pResourceManager, pConfig, &pDataSource->backend.stream);
+    } else {
+        return ma_resource_manager_data_buffer_init_ex(pResourceManager, pConfig, &pDataSource->backend.buffer);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_init(ma_resource_manager* pResourceManager, const char* pName, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_source* pDataSource)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePath      = pName;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_source_init_ex(pResourceManager, &config, pDataSource);
+}
+
+MA_API ma_result ma_resource_manager_data_source_init_w(ma_resource_manager* pResourceManager, const wchar_t* pName, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_source* pDataSource)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePathW     = pName;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_source_init_ex(pResourceManager, &config, pDataSource);
+}
+
+MA_API ma_result ma_resource_manager_data_source_init_copy(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source* pExistingDataSource, ma_resource_manager_data_source* pDataSource)
+{
+    ma_result result;
+    ma_resource_manager_data_source_config config;
+
+    if (pExistingDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    config = ma_resource_manager_data_source_config_init();
+    config.flags = pExistingDataSource->flags;
+
+    result = ma_resource_manager_data_source_preinit(pResourceManager, &config, pDataSource);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Copying can only be done from data buffers. Streams cannot be copied. */
+    if ((pExistingDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    return ma_resource_manager_data_buffer_init_copy(pResourceManager, &pExistingDataSource->backend.buffer, &pDataSource->backend.buffer);
+}
+
+MA_API ma_result ma_resource_manager_data_source_uninit(ma_resource_manager_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* All we need to is uninitialize the underlying data buffer or data stream. */
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_uninit(&pDataSource->backend.stream);
+    } else {
+        return ma_resource_manager_data_buffer_uninit(&pDataSource->backend.buffer);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_read_pcm_frames(ma_resource_manager_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    /* Safety. */
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_read_pcm_frames(&pDataSource->backend.stream, pFramesOut, frameCount, pFramesRead);
+    } else {
+        return ma_resource_manager_data_buffer_read_pcm_frames(&pDataSource->backend.buffer, pFramesOut, frameCount, pFramesRead);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_seek_to_pcm_frame(ma_resource_manager_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_seek_to_pcm_frame(&pDataSource->backend.stream, frameIndex);
+    } else {
+        return ma_resource_manager_data_buffer_seek_to_pcm_frame(&pDataSource->backend.buffer, frameIndex);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_map(ma_resource_manager_data_source* pDataSource, void** ppFramesOut, ma_uint64* pFrameCount)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_map(&pDataSource->backend.stream, ppFramesOut, pFrameCount);
+    } else {
+        return MA_NOT_IMPLEMENTED;  /* Mapping not supported with data buffers. */
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_unmap(ma_resource_manager_data_source* pDataSource, ma_uint64 frameCount)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_unmap(&pDataSource->backend.stream, frameCount);
+    } else {
+        return MA_NOT_IMPLEMENTED;  /* Mapping not supported with data buffers. */
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_get_data_format(ma_resource_manager_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_get_data_format(&pDataSource->backend.stream, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+    } else {
+        return ma_resource_manager_data_buffer_get_data_format(&pDataSource->backend.buffer, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_get_cursor_in_pcm_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pCursor)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_get_cursor_in_pcm_frames(&pDataSource->backend.stream, pCursor);
+    } else {
+        return ma_resource_manager_data_buffer_get_cursor_in_pcm_frames(&pDataSource->backend.buffer, pCursor);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_get_length_in_pcm_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pLength)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_get_length_in_pcm_frames(&pDataSource->backend.stream, pLength);
+    } else {
+        return ma_resource_manager_data_buffer_get_length_in_pcm_frames(&pDataSource->backend.buffer, pLength);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_result(const ma_resource_manager_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_result(&pDataSource->backend.stream);
+    } else {
+        return ma_resource_manager_data_buffer_result(&pDataSource->backend.buffer);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_set_looping(ma_resource_manager_data_source* pDataSource, ma_bool32 isLooping)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_set_looping(&pDataSource->backend.stream, isLooping);
+    } else {
+        return ma_resource_manager_data_buffer_set_looping(&pDataSource->backend.buffer, isLooping);
+    }
+}
+
+MA_API ma_bool32 ma_resource_manager_data_source_is_looping(const ma_resource_manager_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return MA_FALSE;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_is_looping(&pDataSource->backend.stream);
+    } else {
+        return ma_resource_manager_data_buffer_is_looping(&pDataSource->backend.buffer);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_get_available_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pAvailableFrames)
+{
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_get_available_frames(&pDataSource->backend.stream, pAvailableFrames);
+    } else {
+        return ma_resource_manager_data_buffer_get_available_frames(&pDataSource->backend.buffer, pAvailableFrames);
+    }
+}
+
+
+MA_API ma_result ma_resource_manager_post_job(ma_resource_manager* pResourceManager, const ma_job* pJob)
+{
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_queue_post(&pResourceManager->jobQueue, pJob);
+}
+
+MA_API ma_result ma_resource_manager_post_job_quit(ma_resource_manager* pResourceManager)
+{
+    ma_job job = ma_job_init(MA_JOB_TYPE_QUIT);
+    return ma_resource_manager_post_job(pResourceManager, &job);
+}
+
+MA_API ma_result ma_resource_manager_next_job(ma_resource_manager* pResourceManager, ma_job* pJob)
+{
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_queue_next(&pResourceManager->jobQueue, pJob);
+}
+
+
+static ma_result ma_job_process__resource_manager__load_data_buffer_node(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+
+    MA_ASSERT(pJob != NULL);
+
+    pResourceManager = (ma_resource_manager*)pJob->data.resourceManager.loadDataBufferNode.pResourceManager;
+    MA_ASSERT(pResourceManager != NULL);
+
+    pDataBufferNode = (ma_resource_manager_data_buffer_node*)pJob->data.resourceManager.loadDataBufferNode.pDataBufferNode;
+    MA_ASSERT(pDataBufferNode != NULL);
+    MA_ASSERT(pDataBufferNode->isDataOwnedByResourceManager == MA_TRUE);  /* The data should always be owned by the resource manager. */
+
+    /* The data buffer is not getting deleted, but we may be getting executed out of order. If so, we need to push the job back onto the queue and return. */
+    if (pJob->order != ma_atomic_load_32(&pDataBufferNode->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Attempting to execute out of order. Probably interleaved with a MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER job. */
+    }
+
+    /* First thing we need to do is check whether or not the data buffer is getting deleted. If so we just abort. */
+    if (ma_resource_manager_data_buffer_node_result(pDataBufferNode) != MA_BUSY) {
+        result = ma_resource_manager_data_buffer_node_result(pDataBufferNode);    /* The data buffer may be getting deleted before it's even been loaded. */
+        goto done;
+    }
+
+    /*
+    We're ready to start loading. Essentially what we're doing here is initializing the data supply
+    of the node. Once this is complete, data buffers can have their connectors initialized which
+    will allow then to have audio data read from them.
+
+    Note that when the data supply type has been moved away from "unknown", that is when other threads
+    will determine that the node is available for data delivery and the data buffer connectors can be
+    initialized. Therefore, it's important that it is set after the data supply has been initialized.
+    */
+    if ((pJob->data.resourceManager.loadDataBufferNode.flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE) != 0) {
+        /*
+        Decoding. This is the complex case because we're not going to be doing the entire decoding
+        process here. Instead it's going to be split of multiple jobs and loaded in pages. The
+        reason for this is to evenly distribute decoding time across multiple sounds, rather than
+        having one huge sound hog all the available processing resources.
+
+        The first thing we do is initialize a decoder. This is allocated on the heap and is passed
+        around to the paging jobs. When the last paging job has completed it's processing, it'll
+        free the decoder for us.
+
+        This job does not do any actual decoding. It instead just posts a PAGE_DATA_BUFFER_NODE job
+        which is where the actual decoding work will be done. However, once this job is complete,
+        the node will be in a state where data buffer connectors can be initialized.
+        */
+        ma_decoder* pDecoder;   /* <-- Free'd on the last page decode. */
+        ma_job pageDataBufferNodeJob;
+
+        /* Allocate the decoder by initializing a decoded data supply. */
+        result = ma_resource_manager_data_buffer_node_init_supply_decoded(pResourceManager, pDataBufferNode, pJob->data.resourceManager.loadDataBufferNode.pFilePath, pJob->data.resourceManager.loadDataBufferNode.pFilePathW, pJob->data.resourceManager.loadDataBufferNode.flags, &pDecoder);
+
+        /*
+        Don't ever propagate an MA_BUSY result code or else the resource manager will think the
+        node is just busy decoding rather than in an error state. This should never happen, but
+        including this logic for safety just in case.
+        */
+        if (result == MA_BUSY) {
+            result  = MA_ERROR;
+        }
+
+        if (result != MA_SUCCESS) {
+            if (pJob->data.resourceManager.loadDataBufferNode.pFilePath != NULL) {
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to initialize data supply for \"%s\". %s.\n", pJob->data.resourceManager.loadDataBufferNode.pFilePath, ma_result_description(result));
+            } else {
+                #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(_MSC_VER)
+                    ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to initialize data supply for \"%ls\", %s.\n", pJob->data.resourceManager.loadDataBufferNode.pFilePathW, ma_result_description(result));
+                #endif
+            }
+
+            goto done;
+        }
+
+        /*
+        At this point the node's data supply is initialized and other threads can start initializing
+        their data buffer connectors. However, no data will actually be available until we start to
+        actually decode it. To do this, we need to post a paging job which is where the decoding
+        work is done.
+
+        Note that if an error occurred at an earlier point, this section will have been skipped.
+        */
+        pageDataBufferNodeJob = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE);
+        pageDataBufferNodeJob.order = ma_resource_manager_data_buffer_node_next_execution_order(pDataBufferNode);
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pResourceManager  = pResourceManager;
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pDataBufferNode   = pDataBufferNode;
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pDecoder          = pDecoder;
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pDoneNotification = pJob->data.resourceManager.loadDataBufferNode.pDoneNotification;
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pDoneFence        = pJob->data.resourceManager.loadDataBufferNode.pDoneFence;
+
+        /* The job has been set up so it can now be posted. */
+        result = ma_resource_manager_post_job(pResourceManager, &pageDataBufferNodeJob);
+
+        /*
+        When we get here, we want to make sure the result code is set to MA_BUSY. The reason for
+        this is that the result will be copied over to the node's internal result variable. In
+        this case, since the decoding is still in-progress, we need to make sure the result code
+        is set to MA_BUSY.
+        */
+        if (result != MA_SUCCESS) {
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to post MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE job. %s\n", ma_result_description(result));
+            ma_decoder_uninit(pDecoder);
+            ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+        } else {
+            result = MA_BUSY;
+        }
+    } else {
+        /* No decoding. This is the simple case. We need only read the file content into memory and we're done. */
+        result = ma_resource_manager_data_buffer_node_init_supply_encoded(pResourceManager, pDataBufferNode, pJob->data.resourceManager.loadDataBufferNode.pFilePath, pJob->data.resourceManager.loadDataBufferNode.pFilePathW);
+    }
+
+
+done:
+    /* File paths are no longer needed. */
+    ma_free(pJob->data.resourceManager.loadDataBufferNode.pFilePath,  &pResourceManager->config.allocationCallbacks);
+    ma_free(pJob->data.resourceManager.loadDataBufferNode.pFilePathW, &pResourceManager->config.allocationCallbacks);
+
+    /*
+    We need to set the result to at the very end to ensure no other threads try reading the data before we've fully initialized the object. Other threads
+    are going to be inspecting this variable to determine whether or not they're ready to read data. We can only change the result if it's set to MA_BUSY
+    because otherwise we may be changing away from an error code which would be bad. An example is if the application creates a data buffer, but then
+    immediately deletes it before we've got to this point. In this case, pDataBuffer->result will be MA_UNAVAILABLE, and setting it to MA_SUCCESS or any
+    other error code would cause the buffer to look like it's in a state that it's not.
+    */
+    ma_atomic_compare_and_swap_i32(&pDataBufferNode->result, MA_BUSY, result);
+
+    /* At this point initialization is complete and we can signal the notification if any. */
+    if (pJob->data.resourceManager.loadDataBufferNode.pInitNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.loadDataBufferNode.pInitNotification);
+    }
+    if (pJob->data.resourceManager.loadDataBufferNode.pInitFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.loadDataBufferNode.pInitFence);
+    }
+
+    /* If we have a success result it means we've fully loaded the buffer. This will happen in the non-decoding case. */
+    if (result != MA_BUSY) {
+        if (pJob->data.resourceManager.loadDataBufferNode.pDoneNotification != NULL) {
+            ma_async_notification_signal(pJob->data.resourceManager.loadDataBufferNode.pDoneNotification);
+        }
+        if (pJob->data.resourceManager.loadDataBufferNode.pDoneFence != NULL) {
+            ma_fence_release(pJob->data.resourceManager.loadDataBufferNode.pDoneFence);
+        }
+    }
+
+    /* Increment the node's execution pointer so that the next jobs can be processed. This is how we keep decoding of pages in-order. */
+    ma_atomic_fetch_add_32(&pDataBufferNode->executionPointer, 1);
+
+    /* A busy result should be considered successful from the point of view of the job system. */
+    if (result == MA_BUSY) {
+        result  = MA_SUCCESS;
+    }
+
+    return result;
+}
+
+static ma_result ma_job_process__resource_manager__free_data_buffer_node(ma_job* pJob)
+{
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+
+    MA_ASSERT(pJob != NULL);
+
+    pResourceManager = (ma_resource_manager*)pJob->data.resourceManager.freeDataBufferNode.pResourceManager;
+    MA_ASSERT(pResourceManager != NULL);
+
+    pDataBufferNode = (ma_resource_manager_data_buffer_node*)pJob->data.resourceManager.freeDataBufferNode.pDataBufferNode;
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    if (pJob->order != ma_atomic_load_32(&pDataBufferNode->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    ma_resource_manager_data_buffer_node_free(pResourceManager, pDataBufferNode);
+
+    /* The event needs to be signalled last. */
+    if (pJob->data.resourceManager.freeDataBufferNode.pDoneNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.freeDataBufferNode.pDoneNotification);
+    }
+
+    if (pJob->data.resourceManager.freeDataBufferNode.pDoneFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.freeDataBufferNode.pDoneFence);
+    }
+
+    ma_atomic_fetch_add_32(&pDataBufferNode->executionPointer, 1);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__resource_manager__page_data_buffer_node(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+
+    MA_ASSERT(pJob != NULL);
+
+    pResourceManager = (ma_resource_manager*)pJob->data.resourceManager.pageDataBufferNode.pResourceManager;
+    MA_ASSERT(pResourceManager != NULL);
+
+    pDataBufferNode = (ma_resource_manager_data_buffer_node*)pJob->data.resourceManager.pageDataBufferNode.pDataBufferNode;
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    if (pJob->order != ma_atomic_load_32(&pDataBufferNode->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    /* Don't do any more decoding if the data buffer has started the uninitialization process. */
+    result = ma_resource_manager_data_buffer_node_result(pDataBufferNode);
+    if (result != MA_BUSY) {
+        goto done;
+    }
+
+    /* We're ready to decode the next page. */
+    result = ma_resource_manager_data_buffer_node_decode_next_page(pResourceManager, pDataBufferNode, (ma_decoder*)pJob->data.resourceManager.pageDataBufferNode.pDecoder);
+
+    /*
+    If we have a success code by this point, we want to post another job. We're going to set the
+    result back to MA_BUSY to make it clear that there's still more to load.
+    */
+    if (result == MA_SUCCESS) {
+        ma_job newJob;
+        newJob = *pJob; /* Everything is the same as the input job, except the execution order. */
+        newJob.order = ma_resource_manager_data_buffer_node_next_execution_order(pDataBufferNode);   /* We need a fresh execution order. */
+
+        result = ma_resource_manager_post_job(pResourceManager, &newJob);
+
+        /* Since the sound isn't yet fully decoded we want the status to be set to busy. */
+        if (result == MA_SUCCESS) {
+            result  = MA_BUSY;
+        }
+    }
+
+done:
+    /* If there's still more to decode the result will be set to MA_BUSY. Otherwise we can free the decoder. */
+    if (result != MA_BUSY) {
+        ma_decoder_uninit((ma_decoder*)pJob->data.resourceManager.pageDataBufferNode.pDecoder);
+        ma_free(pJob->data.resourceManager.pageDataBufferNode.pDecoder, &pResourceManager->config.allocationCallbacks);
+    }
+
+    /* If we reached the end we need to treat it as successful. */
+    if (result == MA_AT_END) {
+        result  = MA_SUCCESS;
+    }
+
+    /* Make sure we set the result of node in case some error occurred. */
+    ma_atomic_compare_and_swap_i32(&pDataBufferNode->result, MA_BUSY, result);
+
+    /* Signal the notification after setting the result in case the notification callback wants to inspect the result code. */
+    if (result != MA_BUSY) {
+        if (pJob->data.resourceManager.pageDataBufferNode.pDoneNotification != NULL) {
+            ma_async_notification_signal(pJob->data.resourceManager.pageDataBufferNode.pDoneNotification);
+        }
+
+        if (pJob->data.resourceManager.pageDataBufferNode.pDoneFence != NULL) {
+            ma_fence_release(pJob->data.resourceManager.pageDataBufferNode.pDoneFence);
+        }
+    }
+
+    ma_atomic_fetch_add_32(&pDataBufferNode->executionPointer, 1);
+    return result;
+}
+
+
+static ma_result ma_job_process__resource_manager__load_data_buffer(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer* pDataBuffer;
+    ma_resource_manager_data_supply_type dataSupplyType = ma_resource_manager_data_supply_type_unknown;
+    ma_bool32 isConnectorInitialized = MA_FALSE;
+
+    /*
+    All we're doing here is checking if the node has finished loading. If not, we just re-post the job
+    and keep waiting. Otherwise we increment the execution counter and set the buffer's result code.
+    */
+    MA_ASSERT(pJob != NULL);
+
+    pDataBuffer = (ma_resource_manager_data_buffer*)pJob->data.resourceManager.loadDataBuffer.pDataBuffer;
+    MA_ASSERT(pDataBuffer != NULL);
+
+    pResourceManager = pDataBuffer->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataBuffer->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Attempting to execute out of order. Probably interleaved with a MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER job. */
+    }
+
+    /*
+    First thing we need to do is check whether or not the data buffer is getting deleted. If so we
+    just abort, but making sure we increment the execution pointer.
+    */
+    result = ma_resource_manager_data_buffer_result(pDataBuffer);
+    if (result != MA_BUSY) {
+        goto done;  /* <-- This will ensure the execution pointer is incremented. */
+    } else {
+        result = MA_SUCCESS;    /* <-- Make sure this is reset. */
+        (void)result;           /* <-- This is to suppress a static analysis diagnostic about "result" not being used. But for safety when I do future maintenance I don't want to delete that assignment. */
+    }
+
+    /* Try initializing the connector if we haven't already. */
+    isConnectorInitialized = ma_resource_manager_data_buffer_has_connector(pDataBuffer);
+    if (isConnectorInitialized == MA_FALSE) {
+        dataSupplyType = ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode);
+
+        if (dataSupplyType != ma_resource_manager_data_supply_type_unknown) {
+            /* We can now initialize the connector. If this fails, we need to abort. It's very rare for this to fail. */
+            ma_resource_manager_data_source_config dataSourceConfig;    /* For setting initial looping state and range. */
+            dataSourceConfig = ma_resource_manager_data_source_config_init();
+            dataSourceConfig.rangeBegInPCMFrames     = pJob->data.resourceManager.loadDataBuffer.rangeBegInPCMFrames;
+            dataSourceConfig.rangeEndInPCMFrames     = pJob->data.resourceManager.loadDataBuffer.rangeEndInPCMFrames;
+            dataSourceConfig.loopPointBegInPCMFrames = pJob->data.resourceManager.loadDataBuffer.loopPointBegInPCMFrames;
+            dataSourceConfig.loopPointEndInPCMFrames = pJob->data.resourceManager.loadDataBuffer.loopPointEndInPCMFrames;
+            dataSourceConfig.isLooping               = pJob->data.resourceManager.loadDataBuffer.isLooping;
+
+            result = ma_resource_manager_data_buffer_init_connector(pDataBuffer, &dataSourceConfig, pJob->data.resourceManager.loadDataBuffer.pInitNotification, pJob->data.resourceManager.loadDataBuffer.pInitFence);
+            if (result != MA_SUCCESS) {
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to initialize connector for data buffer. %s.\n", ma_result_description(result));
+                goto done;
+            }
+        } else {
+            /* Don't have a known data supply type. Most likely the data buffer node is still loading, but it could be that an error occurred. */
+        }
+    } else {
+        /* The connector is already initialized. Nothing to do here. */
+    }
+
+    /*
+    If the data node is still loading, we need to repost the job and *not* increment the execution
+    pointer (i.e. we need to not fall through to the "done" label).
+
+    There is a hole between here and the where the data connector is initialized where the data
+    buffer node may have finished initializing. We need to check for this by checking the result of
+    the data buffer node and whether or not we had an unknown data supply type at the time of
+    trying to initialize the data connector.
+    */
+    result = ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode);
+    if (result == MA_BUSY || (result == MA_SUCCESS && isConnectorInitialized == MA_FALSE && dataSupplyType == ma_resource_manager_data_supply_type_unknown)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);
+    }
+
+done:
+    /* Only move away from a busy code so that we don't trash any existing error codes. */
+    ma_atomic_compare_and_swap_i32(&pDataBuffer->result, MA_BUSY, result);
+
+    /* Only signal the other threads after the result has been set just for cleanliness sake. */
+    if (pJob->data.resourceManager.loadDataBuffer.pDoneNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.loadDataBuffer.pDoneNotification);
+    }
+    if (pJob->data.resourceManager.loadDataBuffer.pDoneFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.loadDataBuffer.pDoneFence);
+    }
+
+    /*
+    If at this point the data buffer has not had it's connector initialized, it means the
+    notification event was never signalled which means we need to signal it here.
+    */
+    if (ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE && result != MA_SUCCESS) {
+        if (pJob->data.resourceManager.loadDataBuffer.pInitNotification != NULL) {
+            ma_async_notification_signal(pJob->data.resourceManager.loadDataBuffer.pInitNotification);
+        }
+        if (pJob->data.resourceManager.loadDataBuffer.pInitFence != NULL) {
+            ma_fence_release(pJob->data.resourceManager.loadDataBuffer.pInitFence);
+        }
+    }
+
+    ma_atomic_fetch_add_32(&pDataBuffer->executionPointer, 1);
+    return result;
+}
+
+static ma_result ma_job_process__resource_manager__free_data_buffer(ma_job* pJob)
+{
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer* pDataBuffer;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataBuffer = (ma_resource_manager_data_buffer*)pJob->data.resourceManager.freeDataBuffer.pDataBuffer;
+    MA_ASSERT(pDataBuffer != NULL);
+
+    pResourceManager = pDataBuffer->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataBuffer->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    ma_resource_manager_data_buffer_uninit_internal(pDataBuffer);
+
+    /* The event needs to be signalled last. */
+    if (pJob->data.resourceManager.freeDataBuffer.pDoneNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.freeDataBuffer.pDoneNotification);
+    }
+
+    if (pJob->data.resourceManager.freeDataBuffer.pDoneFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.freeDataBuffer.pDoneFence);
+    }
+
+    ma_atomic_fetch_add_32(&pDataBuffer->executionPointer, 1);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__resource_manager__load_data_stream(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_decoder_config decoderConfig;
+    ma_uint32 pageBufferSizeInBytes;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_stream* pDataStream;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataStream = (ma_resource_manager_data_stream*)pJob->data.resourceManager.loadDataStream.pDataStream;
+    MA_ASSERT(pDataStream != NULL);
+
+    pResourceManager = pDataStream->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataStream->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_BUSY) {
+        result = MA_INVALID_OPERATION;  /* Most likely the data stream is being uninitialized. */
+        goto done;
+    }
+
+    /* We need to initialize the decoder first so we can determine the size of the pages. */
+    decoderConfig = ma_resource_manager__init_decoder_config(pResourceManager);
+
+    if (pJob->data.resourceManager.loadDataStream.pFilePath != NULL) {
+        result = ma_decoder_init_vfs(pResourceManager->config.pVFS, pJob->data.resourceManager.loadDataStream.pFilePath, &decoderConfig, &pDataStream->decoder);
+    } else {
+        result = ma_decoder_init_vfs_w(pResourceManager->config.pVFS, pJob->data.resourceManager.loadDataStream.pFilePathW, &decoderConfig, &pDataStream->decoder);
+    }
+    if (result != MA_SUCCESS) {
+        goto done;
+    }
+
+    /* Retrieve the total length of the file before marking the decoder as loaded. */
+    if ((pDataStream->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH) == 0) {
+        result = ma_decoder_get_length_in_pcm_frames(&pDataStream->decoder, &pDataStream->totalLengthInPCMFrames);
+        if (result != MA_SUCCESS) {
+            goto done;  /* Failed to retrieve the length. */
+        }
+    } else {
+        pDataStream->totalLengthInPCMFrames = 0;
+    }
+
+    /*
+    Only mark the decoder as initialized when the length of the decoder has been retrieved because that can possibly require a scan over the whole file
+    and we don't want to have another thread trying to access the decoder while it's scanning.
+    */
+    pDataStream->isDecoderInitialized = MA_TRUE;
+
+    /* We have the decoder so we can now initialize our page buffer. */
+    pageBufferSizeInBytes = ma_resource_manager_data_stream_get_page_size_in_frames(pDataStream) * 2 * ma_get_bytes_per_frame(pDataStream->decoder.outputFormat, pDataStream->decoder.outputChannels);
+
+    pDataStream->pPageData = ma_malloc(pageBufferSizeInBytes, &pResourceManager->config.allocationCallbacks);
+    if (pDataStream->pPageData == NULL) {
+        ma_decoder_uninit(&pDataStream->decoder);
+        result = MA_OUT_OF_MEMORY;
+        goto done;
+    }
+
+    /* Seek to our initial seek point before filling the initial pages. */
+    ma_decoder_seek_to_pcm_frame(&pDataStream->decoder, pJob->data.resourceManager.loadDataStream.initialSeekPoint);
+
+    /* We have our decoder and our page buffer, so now we need to fill our pages. */
+    ma_resource_manager_data_stream_fill_pages(pDataStream);
+
+    /* And now we're done. We want to make sure the result is MA_SUCCESS. */
+    result = MA_SUCCESS;
+
+done:
+    ma_free(pJob->data.resourceManager.loadDataStream.pFilePath,  &pResourceManager->config.allocationCallbacks);
+    ma_free(pJob->data.resourceManager.loadDataStream.pFilePathW, &pResourceManager->config.allocationCallbacks);
+
+    /* We can only change the status away from MA_BUSY. If it's set to anything else it means an error has occurred somewhere or the uninitialization process has started (most likely). */
+    ma_atomic_compare_and_swap_i32(&pDataStream->result, MA_BUSY, result);
+
+    /* Only signal the other threads after the result has been set just for cleanliness sake. */
+    if (pJob->data.resourceManager.loadDataStream.pInitNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.loadDataStream.pInitNotification);
+    }
+    if (pJob->data.resourceManager.loadDataStream.pInitFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.loadDataStream.pInitFence);
+    }
+
+    ma_atomic_fetch_add_32(&pDataStream->executionPointer, 1);
+    return result;
+}
+
+static ma_result ma_job_process__resource_manager__free_data_stream(ma_job* pJob)
+{
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_stream* pDataStream;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataStream = (ma_resource_manager_data_stream*)pJob->data.resourceManager.freeDataStream.pDataStream;
+    MA_ASSERT(pDataStream != NULL);
+
+    pResourceManager = pDataStream->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataStream->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    /* If our status is not MA_UNAVAILABLE we have a bug somewhere. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) == MA_UNAVAILABLE);
+
+    if (pDataStream->isDecoderInitialized) {
+        ma_decoder_uninit(&pDataStream->decoder);
+    }
+
+    if (pDataStream->pPageData != NULL) {
+        ma_free(pDataStream->pPageData, &pResourceManager->config.allocationCallbacks);
+        pDataStream->pPageData = NULL;  /* Just in case... */
+    }
+
+    ma_data_source_uninit(&pDataStream->ds);
+
+    /* The event needs to be signalled last. */
+    if (pJob->data.resourceManager.freeDataStream.pDoneNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.freeDataStream.pDoneNotification);
+    }
+    if (pJob->data.resourceManager.freeDataStream.pDoneFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.freeDataStream.pDoneFence);
+    }
+
+    /*ma_atomic_fetch_add_32(&pDataStream->executionPointer, 1);*/
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__resource_manager__page_data_stream(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_stream* pDataStream;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataStream = (ma_resource_manager_data_stream*)pJob->data.resourceManager.pageDataStream.pDataStream;
+    MA_ASSERT(pDataStream != NULL);
+
+    pResourceManager = pDataStream->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataStream->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    /* For streams, the status should be MA_SUCCESS. */
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        result = MA_INVALID_OPERATION;
+        goto done;
+    }
+
+    ma_resource_manager_data_stream_fill_page(pDataStream, pJob->data.resourceManager.pageDataStream.pageIndex);
+
+done:
+    ma_atomic_fetch_add_32(&pDataStream->executionPointer, 1);
+    return result;
+}
+
+static ma_result ma_job_process__resource_manager__seek_data_stream(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_stream* pDataStream;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataStream = (ma_resource_manager_data_stream*)pJob->data.resourceManager.seekDataStream.pDataStream;
+    MA_ASSERT(pDataStream != NULL);
+
+    pResourceManager = pDataStream->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataStream->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    /* For streams the status should be MA_SUCCESS for this to do anything. */
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS || pDataStream->isDecoderInitialized == MA_FALSE) {
+        result = MA_INVALID_OPERATION;
+        goto done;
+    }
+
+    /*
+    With seeking we just assume both pages are invalid and the relative frame cursor at position 0. This is basically exactly the same as loading, except
+    instead of initializing the decoder, we seek to a frame.
+    */
+    ma_decoder_seek_to_pcm_frame(&pDataStream->decoder, pJob->data.resourceManager.seekDataStream.frameIndex);
+
+    /* After seeking we'll need to reload the pages. */
+    ma_resource_manager_data_stream_fill_pages(pDataStream);
+
+    /* We need to let the public API know that we're done seeking. */
+    ma_atomic_fetch_sub_32(&pDataStream->seekCounter, 1);
+
+done:
+    ma_atomic_fetch_add_32(&pDataStream->executionPointer, 1);
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_process_job(ma_resource_manager* pResourceManager, ma_job* pJob)
+{
+    if (pResourceManager == NULL || pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_process(pJob);
+}
+
+MA_API ma_result ma_resource_manager_process_next_job(ma_resource_manager* pResourceManager)
+{
+    ma_result result;
+    ma_job job;
+
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* This will return MA_CANCELLED if the next job is a quit job. */
+    result = ma_resource_manager_next_job(pResourceManager, &job);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_job_process(&job);
+}
+#else
+/* We'll get here if the resource manager is being excluded from the build. We need to define the job processing callbacks as no-ops. */
+static ma_result ma_job_process__resource_manager__load_data_buffer_node(ma_job* pJob) { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__free_data_buffer_node(ma_job* pJob) { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__page_data_buffer_node(ma_job* pJob) { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__load_data_buffer(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__free_data_buffer(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__load_data_stream(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__free_data_stream(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__page_data_stream(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__seek_data_stream(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+#endif  /* MA_NO_RESOURCE_MANAGER */
+
+
+#ifndef MA_NO_NODE_GRAPH
+
+static ma_stack* ma_stack_init(size_t sizeInBytes, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_stack* pStack;
+
+    if (sizeInBytes == 0) {
+        return NULL;
+    }
+
+    pStack = (ma_stack*)ma_malloc(sizeof(*pStack) - sizeof(pStack->_data) + sizeInBytes, pAllocationCallbacks);
+    if (pStack == NULL) {
+        return NULL;
+    }
+
+    pStack->offset = 0;
+    pStack->sizeInBytes = sizeInBytes;
+
+    return pStack;
+}
+
+static void ma_stack_uninit(ma_stack* pStack, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pStack == NULL) {
+        return;
+    }
+
+    ma_free(pStack, pAllocationCallbacks);
+}
+
+static void* ma_stack_alloc(ma_stack* pStack, size_t sz)
+{
+    /* The size of the allocation is stored in the memory directly before the pointer. This needs to include padding to keep it aligned to ma_uintptr */
+    void* p = (void*)((char*)pStack->_data + pStack->offset);
+    size_t* pSize = (size_t*)p;
+
+    sz = (sz + (sizeof(ma_uintptr) - 1)) & ~(sizeof(ma_uintptr) - 1);  /* Padding. */
+    if (pStack->offset + sz + sizeof(size_t) > pStack->sizeInBytes) {
+        return NULL;    /* Out of memory. */
+    }
+
+    pStack->offset += sz + sizeof(size_t);
+
+    *pSize = sz;
+    return (void*)((char*)p + sizeof(size_t));
+}
+
+static void ma_stack_free(ma_stack* pStack, void* p)
+{
+    size_t* pSize;
+
+    if (p == NULL) {
+        return;
+    }
+
+    pSize = (size_t*)p - 1;
+    pStack->offset -= *pSize + sizeof(size_t);
+}
+
+
+
+/* 10ms @ 48K = 480. Must never exceed 65535. */
+#ifndef MA_DEFAULT_NODE_CACHE_CAP_IN_FRAMES_PER_BUS
+#define MA_DEFAULT_NODE_CACHE_CAP_IN_FRAMES_PER_BUS 480
+#endif
+
+#ifndef MA_DEFAULT_PREMIX_STACK_SIZE_PER_CHANNEL
+#define MA_DEFAULT_PREMIX_STACK_SIZE_PER_CHANNEL    524288
+#endif
+
+static ma_result ma_node_read_pcm_frames(ma_node* pNode, ma_uint32 outputBusIndex, float* pFramesOut, ma_uint32 frameCount, ma_uint32* pFramesRead, ma_uint64 globalTime);
+
+MA_API void ma_debug_fill_pcm_frames_with_sine_wave(float* pFramesOut, ma_uint32 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    #ifndef MA_NO_GENERATION
+    {
+        ma_waveform_config waveformConfig;
+        ma_waveform waveform;
+
+        waveformConfig = ma_waveform_config_init(format, channels, sampleRate, ma_waveform_type_sine, 1.0, 400);
+        ma_waveform_init(&waveformConfig, &waveform);
+        ma_waveform_read_pcm_frames(&waveform, pFramesOut, frameCount, NULL);
+    }
+    #else
+    {
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)format;
+        (void)channels;
+        (void)sampleRate;
+        #if defined(MA_DEBUG_OUTPUT)
+        {
+            #if _MSC_VER
+                #pragma message ("ma_debug_fill_pcm_frames_with_sine_wave() will do nothing because MA_NO_GENERATION is enabled.")
+            #endif
+        }
+        #endif
+    }
+    #endif
+}
+
+
+
+MA_API ma_node_graph_config ma_node_graph_config_init(ma_uint32 channels)
+{
+    ma_node_graph_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channels               = channels;
+    config.processingSizeInFrames = 0;
+
+    return config;
+}
+
+
+static void ma_node_graph_set_is_reading(ma_node_graph* pNodeGraph, ma_bool32 isReading)
+{
+    MA_ASSERT(pNodeGraph != NULL);
+    ma_atomic_exchange_32(&pNodeGraph->isReading, isReading);
+}
+
+#if 0
+static ma_bool32 ma_node_graph_is_reading(ma_node_graph* pNodeGraph)
+{
+    MA_ASSERT(pNodeGraph != NULL);
+    return ma_atomic_load_32(&pNodeGraph->isReading);
+}
+#endif
+
+
+static void ma_node_graph_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_node_graph* pNodeGraph = (ma_node_graph*)pNode;
+    ma_uint64 framesRead;
+
+    ma_node_graph_read_pcm_frames(pNodeGraph, ppFramesOut[0], *pFrameCountOut, &framesRead);
+
+    *pFrameCountOut = (ma_uint32)framesRead;    /* Safe cast. */
+
+    (void)ppFramesIn;
+    (void)pFrameCountIn;
+}
+
+static ma_node_vtable g_node_graph_node_vtable =
+{
+    ma_node_graph_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    0,      /* 0 input buses. */
+    1,      /* 1 output bus. */
+    0       /* Flags. */
+};
+
+static void ma_node_graph_endpoint_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    MA_ASSERT(pNode != NULL);
+    MA_ASSERT(ma_node_get_input_bus_count(pNode)  == 1);
+    MA_ASSERT(ma_node_get_output_bus_count(pNode) == 1);
+
+    /* Input channel count needs to be the same as the output channel count. */
+    MA_ASSERT(ma_node_get_input_channels(pNode, 0) == ma_node_get_output_channels(pNode, 0));
+
+    /* We don't need to do anything here because it's a passthrough. */
+    (void)pNode;
+    (void)ppFramesIn;
+    (void)pFrameCountIn;
+    (void)ppFramesOut;
+    (void)pFrameCountOut;
+
+#if 0
+    /* The data has already been mixed. We just need to move it to the output buffer. */
+    if (ppFramesIn != NULL) {
+        ma_copy_pcm_frames(ppFramesOut[0], ppFramesIn[0], *pFrameCountOut, ma_format_f32, ma_node_get_output_channels(pNode, 0));
+    }
+#endif
+}
+
+static ma_node_vtable g_node_graph_endpoint_vtable =
+{
+    ma_node_graph_endpoint_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* 1 input bus. */
+    1,      /* 1 output bus. */
+    MA_NODE_FLAG_PASSTHROUGH    /* Flags. The endpoint is a passthrough. */
+};
+
+MA_API ma_result ma_node_graph_init(const ma_node_graph_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node_graph* pNodeGraph)
+{
+    ma_result result;
+    ma_node_config baseConfig;
+    ma_node_config endpointConfig;
+
+    if (pNodeGraph == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNodeGraph);
+    pNodeGraph->processingSizeInFrames = pConfig->processingSizeInFrames;
+
+    /* Base node so we can use the node graph as a node into another graph. */
+    baseConfig = ma_node_config_init();
+    baseConfig.vtable = &g_node_graph_node_vtable;
+    baseConfig.pOutputChannels = &pConfig->channels;
+
+    result = ma_node_init(pNodeGraph, &baseConfig, pAllocationCallbacks, &pNodeGraph->base);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+
+    /* Endpoint. */
+    endpointConfig = ma_node_config_init();
+    endpointConfig.vtable          = &g_node_graph_endpoint_vtable;
+    endpointConfig.pInputChannels  = &pConfig->channels;
+    endpointConfig.pOutputChannels = &pConfig->channels;
+
+    result = ma_node_init(pNodeGraph, &endpointConfig, pAllocationCallbacks, &pNodeGraph->endpoint);
+    if (result != MA_SUCCESS) {
+        ma_node_uninit(&pNodeGraph->base, pAllocationCallbacks);
+        return result;
+    }
+
+
+    /* Processing cache. */
+    if (pConfig->processingSizeInFrames > 0) {
+        pNodeGraph->pProcessingCache = (float*)ma_malloc(pConfig->processingSizeInFrames * pConfig->channels * sizeof(float), pAllocationCallbacks);
+        if (pNodeGraph->pProcessingCache == NULL) {
+            ma_node_uninit(&pNodeGraph->endpoint, pAllocationCallbacks);
+            ma_node_uninit(&pNodeGraph->base, pAllocationCallbacks);
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+
+    /*
+    We need a pre-mix stack. The size of this stack is configurable via the config. The default value depends on the channel count.
+    */
+    {
+        size_t preMixStackSizeInBytes = pConfig->preMixStackSizeInBytes;
+        if (preMixStackSizeInBytes == 0) {
+            preMixStackSizeInBytes = pConfig->channels * MA_DEFAULT_PREMIX_STACK_SIZE_PER_CHANNEL;
+        }
+
+        pNodeGraph->pPreMixStack = ma_stack_init(preMixStackSizeInBytes, pAllocationCallbacks);
+        if (pNodeGraph->pPreMixStack == NULL) {
+            ma_node_uninit(&pNodeGraph->endpoint, pAllocationCallbacks);
+            ma_node_uninit(&pNodeGraph->base, pAllocationCallbacks);
+            if (pNodeGraph->pProcessingCache != NULL) {
+                ma_free(pNodeGraph->pProcessingCache, pAllocationCallbacks);
+            }
+
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_node_graph_uninit(ma_node_graph* pNodeGraph, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pNodeGraph == NULL) {
+        return;
+    }
+
+    ma_node_uninit(&pNodeGraph->endpoint, pAllocationCallbacks);
+    ma_node_uninit(&pNodeGraph->base, pAllocationCallbacks);
+
+    if (pNodeGraph->pProcessingCache != NULL) {
+        ma_free(pNodeGraph->pProcessingCache, pAllocationCallbacks);
+        pNodeGraph->pProcessingCache = NULL;
+    }
+
+    if (pNodeGraph->pPreMixStack != NULL) {
+        ma_stack_uninit(pNodeGraph->pPreMixStack, pAllocationCallbacks);
+        pNodeGraph->pPreMixStack = NULL;
+    }
+}
+
+MA_API ma_node* ma_node_graph_get_endpoint(ma_node_graph* pNodeGraph)
+{
+    if (pNodeGraph == NULL) {
+        return NULL;
+    }
+
+    return &pNodeGraph->endpoint;
+}
+
+MA_API ma_result ma_node_graph_read_pcm_frames(ma_node_graph* pNodeGraph, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 totalFramesRead;
+    ma_uint32 channels;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;   /* Safety. */
+    }
+
+    if (pNodeGraph == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    channels = ma_node_get_output_channels(&pNodeGraph->endpoint, 0);
+
+
+    /* We'll be nice and try to do a full read of all frameCount frames. */
+    totalFramesRead = 0;
+    while (totalFramesRead < frameCount) {
+        ma_uint32 framesJustRead;
+        ma_uint64 framesToRead;
+        float* pRunningFramesOut;
+
+        framesToRead = frameCount - totalFramesRead;
+        if (framesToRead > 0xFFFFFFFF) {
+            framesToRead = 0xFFFFFFFF;
+        }
+
+        pRunningFramesOut = (float*)ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, ma_format_f32, channels);
+
+        /* If there's anything in the cache, consume that first. */
+        if (pNodeGraph->processingCacheFramesRemaining > 0) {
+            ma_uint32 framesToReadFromCache;
+
+            framesToReadFromCache = (ma_uint32)framesToRead;
+            if (framesToReadFromCache > pNodeGraph->processingCacheFramesRemaining) {
+                framesToReadFromCache = pNodeGraph->processingCacheFramesRemaining;
+            }
+
+            MA_COPY_MEMORY(pRunningFramesOut, pNodeGraph->pProcessingCache, framesToReadFromCache * channels * sizeof(float));
+            MA_MOVE_MEMORY(pNodeGraph->pProcessingCache, pNodeGraph->pProcessingCache + (framesToReadFromCache * channels), (pNodeGraph->processingCacheFramesRemaining - framesToReadFromCache) * channels * sizeof(float));
+            pNodeGraph->processingCacheFramesRemaining -= framesToReadFromCache;
+
+            totalFramesRead += framesToReadFromCache;
+            continue;
+        } else {
+            /*
+            If processingSizeInFrames is non-zero, we need to make sure we always read in chunks of that size. If the frame count is less than
+            that, we need to read into the cache and then continue on.
+            */
+            float* pReadDst = pRunningFramesOut;
+
+            if (pNodeGraph->processingSizeInFrames > 0) {
+                if (framesToRead < pNodeGraph->processingSizeInFrames) {
+                    pReadDst = pNodeGraph->pProcessingCache;    /* We need to read into the cache because otherwise we'll overflow the output buffer. */
+                }
+
+                framesToRead = pNodeGraph->processingSizeInFrames;
+            }
+
+            ma_node_graph_set_is_reading(pNodeGraph, MA_TRUE);
+            {
+                result = ma_node_read_pcm_frames(&pNodeGraph->endpoint, 0, pReadDst, (ma_uint32)framesToRead, &framesJustRead, ma_node_get_time(&pNodeGraph->endpoint));
+            }
+            ma_node_graph_set_is_reading(pNodeGraph, MA_FALSE);
+
+            /*
+            Do not increment the total frames read counter if we read into the cache. We use this to determine how many frames have
+            been written to the final output buffer.
+            */
+            if (pReadDst == pNodeGraph->pProcessingCache) {
+                /* We read into the cache. */
+                pNodeGraph->processingCacheFramesRemaining = framesJustRead;
+            } else {
+                /* We read straight into the output buffer. */
+                totalFramesRead += framesJustRead;
+            }
+
+            if (result != MA_SUCCESS) {
+                break;
+            }
+
+            /* Abort if we weren't able to read any frames or else we risk getting stuck in a loop. */
+            if (framesJustRead == 0) {
+                break;
+            }
+        }
+    }
+
+    /* Let's go ahead and silence any leftover frames just for some added safety to ensure the caller doesn't try emitting garbage out of the speakers. */
+    if (totalFramesRead < frameCount) {
+        ma_silence_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, ma_format_f32, channels), (frameCount - totalFramesRead), ma_format_f32, channels);
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesRead;
+    }
+
+    return result;
+}
+
+MA_API ma_uint32 ma_node_graph_get_channels(const ma_node_graph* pNodeGraph)
+{
+    if (pNodeGraph == NULL) {
+        return 0;
+    }
+
+    return ma_node_get_output_channels(&pNodeGraph->endpoint, 0);
+}
+
+MA_API ma_uint64 ma_node_graph_get_time(const ma_node_graph* pNodeGraph)
+{
+    if (pNodeGraph == NULL) {
+        return 0;
+    }
+
+    return ma_node_get_time(&pNodeGraph->endpoint); /* Global time is just the local time of the endpoint. */
+}
+
+MA_API ma_result ma_node_graph_set_time(ma_node_graph* pNodeGraph, ma_uint64 globalTime)
+{
+    if (pNodeGraph == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_node_set_time(&pNodeGraph->endpoint, globalTime); /* Global time is just the local time of the endpoint. */
+}
+
+
+#define MA_NODE_OUTPUT_BUS_FLAG_HAS_READ    0x01    /* Whether or not this bus ready to read more data. Only used on nodes with multiple output buses. */
+
+static ma_result ma_node_output_bus_init(ma_node* pNode, ma_uint32 outputBusIndex, ma_uint32 channels, ma_node_output_bus* pOutputBus)
+{
+    MA_ASSERT(pOutputBus != NULL);
+    MA_ASSERT(outputBusIndex < MA_MAX_NODE_BUS_COUNT);
+    MA_ASSERT(outputBusIndex < ma_node_get_output_bus_count(pNode));
+    MA_ASSERT(channels < 256);
+
+    MA_ZERO_OBJECT(pOutputBus);
+
+    if (channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pOutputBus->pNode          = pNode;
+    pOutputBus->outputBusIndex = (ma_uint8)outputBusIndex;
+    pOutputBus->channels       = (ma_uint8)channels;
+    pOutputBus->flags          = MA_NODE_OUTPUT_BUS_FLAG_HAS_READ; /* <-- Important that this flag is set by default. */
+    pOutputBus->volume         = 1;
+
+    return MA_SUCCESS;
+}
+
+static void ma_node_output_bus_lock(ma_node_output_bus* pOutputBus)
+{
+    ma_spinlock_lock(&pOutputBus->lock);
+}
+
+static void ma_node_output_bus_unlock(ma_node_output_bus* pOutputBus)
+{
+    ma_spinlock_unlock(&pOutputBus->lock);
+}
+
+
+static ma_uint32 ma_node_output_bus_get_channels(const ma_node_output_bus* pOutputBus)
+{
+    return pOutputBus->channels;
+}
+
+
+static void ma_node_output_bus_set_has_read(ma_node_output_bus* pOutputBus, ma_bool32 hasRead)
+{
+    if (hasRead) {
+        ma_atomic_fetch_or_32(&pOutputBus->flags, MA_NODE_OUTPUT_BUS_FLAG_HAS_READ);
+    } else {
+        ma_atomic_fetch_and_32(&pOutputBus->flags, (ma_uint32)~MA_NODE_OUTPUT_BUS_FLAG_HAS_READ);
+    }
+}
+
+static ma_bool32 ma_node_output_bus_has_read(ma_node_output_bus* pOutputBus)
+{
+    return (ma_atomic_load_32(&pOutputBus->flags) & MA_NODE_OUTPUT_BUS_FLAG_HAS_READ) != 0;
+}
+
+
+static void ma_node_output_bus_set_is_attached(ma_node_output_bus* pOutputBus, ma_bool32 isAttached)
+{
+    ma_atomic_exchange_32(&pOutputBus->isAttached, isAttached);
+}
+
+static ma_bool32 ma_node_output_bus_is_attached(ma_node_output_bus* pOutputBus)
+{
+    return ma_atomic_load_32(&pOutputBus->isAttached);
+}
+
+
+static ma_result ma_node_output_bus_set_volume(ma_node_output_bus* pOutputBus, float volume)
+{
+    MA_ASSERT(pOutputBus != NULL);
+
+    if (volume < 0.0f) {
+        volume = 0.0f;
+    }
+
+    ma_atomic_exchange_f32(&pOutputBus->volume, volume);
+
+    return MA_SUCCESS;
+}
+
+static float ma_node_output_bus_get_volume(const ma_node_output_bus* pOutputBus)
+{
+    return ma_atomic_load_f32((float*)&pOutputBus->volume);
+}
+
+
+static ma_result ma_node_input_bus_init(ma_uint32 channels, ma_node_input_bus* pInputBus)
+{
+    MA_ASSERT(pInputBus != NULL);
+    MA_ASSERT(channels < 256);
+
+    MA_ZERO_OBJECT(pInputBus);
+
+    if (channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pInputBus->channels = (ma_uint8)channels;
+
+    return MA_SUCCESS;
+}
+
+static void ma_node_input_bus_lock(ma_node_input_bus* pInputBus)
+{
+    MA_ASSERT(pInputBus != NULL);
+
+    ma_spinlock_lock(&pInputBus->lock);
+}
+
+static void ma_node_input_bus_unlock(ma_node_input_bus* pInputBus)
+{
+    MA_ASSERT(pInputBus != NULL);
+
+    ma_spinlock_unlock(&pInputBus->lock);
+}
+
+
+static void ma_node_input_bus_next_begin(ma_node_input_bus* pInputBus)
+{
+    ma_atomic_fetch_add_32(&pInputBus->nextCounter, 1);
+}
+
+static void ma_node_input_bus_next_end(ma_node_input_bus* pInputBus)
+{
+    ma_atomic_fetch_sub_32(&pInputBus->nextCounter, 1);
+}
+
+static ma_uint32 ma_node_input_bus_get_next_counter(ma_node_input_bus* pInputBus)
+{
+    return ma_atomic_load_32(&pInputBus->nextCounter);
+}
+
+
+static ma_uint32 ma_node_input_bus_get_channels(const ma_node_input_bus* pInputBus)
+{
+    return pInputBus->channels;
+}
+
+
+static void ma_node_input_bus_detach__no_output_bus_lock(ma_node_input_bus* pInputBus, ma_node_output_bus* pOutputBus)
+{
+    MA_ASSERT(pInputBus  != NULL);
+    MA_ASSERT(pOutputBus != NULL);
+
+    /*
+    Mark the output bus as detached first. This will prevent future iterations on the audio thread
+    from iterating this output bus.
+    */
+    ma_node_output_bus_set_is_attached(pOutputBus, MA_FALSE);
+
+    /*
+    We cannot use the output bus lock here since it'll be getting used at a higher level, but we do
+    still need to use the input bus lock since we'll be updating pointers on two different output
+    buses. The same rules apply here as the attaching case. Although we're using a lock here, we're
+    *not* using a lock when iterating over the list in the audio thread. We therefore need to craft
+    this in a way such that the iteration on the audio thread doesn't break.
+
+    The first thing to do is swap out the "next" pointer of the previous output bus with the
+    new "next" output bus. This is the operation that matters for iteration on the audio thread.
+    After that, the previous pointer on the new "next" pointer needs to be updated, after which
+    point the linked list will be in a good state.
+    */
+    ma_node_input_bus_lock(pInputBus);
+    {
+        ma_node_output_bus* pOldPrev = (ma_node_output_bus*)ma_atomic_load_ptr(&pOutputBus->pPrev);
+        ma_node_output_bus* pOldNext = (ma_node_output_bus*)ma_atomic_load_ptr(&pOutputBus->pNext);
+
+        if (pOldPrev != NULL) {
+            ma_atomic_exchange_ptr(&pOldPrev->pNext, pOldNext); /* <-- This is where the output bus is detached from the list. */
+        }
+        if (pOldNext != NULL) {
+            ma_atomic_exchange_ptr(&pOldNext->pPrev, pOldPrev); /* <-- This is required for detachment. */
+        }
+    }
+    ma_node_input_bus_unlock(pInputBus);
+
+    /* At this point the output bus is detached and the linked list is completely unaware of it. Reset some data for safety. */
+    ma_atomic_exchange_ptr(&pOutputBus->pNext, NULL);   /* Using atomic exchanges here, mainly for the benefit of analysis tools which don't always recognize spinlocks. */
+    ma_atomic_exchange_ptr(&pOutputBus->pPrev, NULL);   /* As above. */
+    pOutputBus->pInputNode             = NULL;
+    pOutputBus->inputNodeInputBusIndex = 0;
+
+
+    /*
+    For thread-safety reasons, we don't want to be returning from this straight away. We need to
+    wait for the audio thread to finish with the output bus. There's two things we need to wait
+    for. The first is the part that selects the next output bus in the list, and the other is the
+    part that reads from the output bus. Basically all we're doing is waiting for the input bus
+    to stop referencing the output bus.
+
+    We're doing this part last because we want the section above to run while the audio thread
+    is finishing up with the output bus, just for efficiency reasons. We marked the output bus as
+    detached right at the top of this function which is going to prevent the audio thread from
+    iterating the output bus again.
+    */
+
+    /* Part 1: Wait for the current iteration to complete. */
+    while (ma_node_input_bus_get_next_counter(pInputBus) > 0) {
+        ma_yield();
+    }
+
+    /* Part 2: Wait for any reads to complete. */
+    while (ma_atomic_load_32(&pOutputBus->refCount) > 0) {
+        ma_yield();
+    }
+
+    /*
+    At this point we're done detaching and we can be guaranteed that the audio thread is not going
+    to attempt to reference this output bus again (until attached again).
+    */
+}
+
+#if 0   /* Not used at the moment, but leaving here in case I need it later. */
+static void ma_node_input_bus_detach(ma_node_input_bus* pInputBus, ma_node_output_bus* pOutputBus)
+{
+    MA_ASSERT(pInputBus  != NULL);
+    MA_ASSERT(pOutputBus != NULL);
+
+    ma_node_output_bus_lock(pOutputBus);
+    {
+        ma_node_input_bus_detach__no_output_bus_lock(pInputBus, pOutputBus);
+    }
+    ma_node_output_bus_unlock(pOutputBus);
+}
+#endif
+
+static void ma_node_input_bus_attach(ma_node_input_bus* pInputBus, ma_node_output_bus* pOutputBus, ma_node* pNewInputNode, ma_uint32 inputNodeInputBusIndex)
+{
+    MA_ASSERT(pInputBus  != NULL);
+    MA_ASSERT(pOutputBus != NULL);
+
+    ma_node_output_bus_lock(pOutputBus);
+    {
+        ma_node_output_bus* pOldInputNode = (ma_node_output_bus*)ma_atomic_load_ptr(&pOutputBus->pInputNode);
+
+        /* Detach from any existing attachment first if necessary. */
+        if (pOldInputNode != NULL) {
+            ma_node_input_bus_detach__no_output_bus_lock(pInputBus, pOutputBus);
+        }
+
+        /*
+        At this point we can be sure the output bus is not attached to anything. The linked list in the
+        old input bus has been updated so that pOutputBus will not get iterated again.
+        */
+        pOutputBus->pInputNode             = pNewInputNode;                     /* No need for an atomic assignment here because modification of this variable always happens within a lock. */
+        pOutputBus->inputNodeInputBusIndex = (ma_uint8)inputNodeInputBusIndex;
+
+        /*
+        Now we need to attach the output bus to the linked list. This involves updating two pointers on
+        two different output buses so I'm going to go ahead and keep this simple and just use a lock.
+        There are ways to do this without a lock, but it's just too hard to maintain for its value.
+
+        Although we're locking here, it's important to remember that we're *not* locking when iterating
+        and reading audio data since that'll be running on the audio thread. As a result we need to be
+        careful how we craft this so that we don't break iteration. What we're going to do is always
+        attach the new item so that it becomes the first item in the list. That way, as we're iterating
+        we won't break any links in the list and iteration will continue safely. The detaching case will
+        also be crafted in a way as to not break list iteration. It's important to remember to use
+        atomic exchanges here since no locking is happening on the audio thread during iteration.
+        */
+        ma_node_input_bus_lock(pInputBus);
+        {
+            ma_node_output_bus* pNewPrev = &pInputBus->head;
+            ma_node_output_bus* pNewNext = (ma_node_output_bus*)ma_atomic_load_ptr(&pInputBus->head.pNext);
+
+            /* Update the local output bus. */
+            ma_atomic_exchange_ptr(&pOutputBus->pPrev, pNewPrev);
+            ma_atomic_exchange_ptr(&pOutputBus->pNext, pNewNext);
+
+            /* Update the other output buses to point back to the local output bus. */
+            ma_atomic_exchange_ptr(&pInputBus->head.pNext, pOutputBus); /* <-- This is where the output bus is actually attached to the input bus. */
+
+            /* Do the previous pointer last. This is only used for detachment. */
+            if (pNewNext != NULL) {
+                ma_atomic_exchange_ptr(&pNewNext->pPrev,  pOutputBus);
+            }
+        }
+        ma_node_input_bus_unlock(pInputBus);
+
+        /*
+        Mark the node as attached last. This is used to controlling whether or the output bus will be
+        iterated on the audio thread. Mainly required for detachment purposes.
+        */
+        ma_node_output_bus_set_is_attached(pOutputBus, MA_TRUE);
+    }
+    ma_node_output_bus_unlock(pOutputBus);
+}
+
+static ma_node_output_bus* ma_node_input_bus_next(ma_node_input_bus* pInputBus, ma_node_output_bus* pOutputBus)
+{
+    ma_node_output_bus* pNext;
+
+    MA_ASSERT(pInputBus != NULL);
+
+    if (pOutputBus == NULL) {
+        return NULL;
+    }
+
+    ma_node_input_bus_next_begin(pInputBus);
+    {
+        pNext = pOutputBus;
+        for (;;) {
+            pNext = (ma_node_output_bus*)ma_atomic_load_ptr(&pNext->pNext);
+            if (pNext == NULL) {
+                break;      /* Reached the end. */
+            }
+
+            if (ma_node_output_bus_is_attached(pNext) == MA_FALSE) {
+                continue;   /* The node is not attached. Keep checking. */
+            }
+
+            /* The next node has been selected. */
+            break;
+        }
+
+        /* We need to increment the reference count of the selected node. */
+        if (pNext != NULL) {
+            ma_atomic_fetch_add_32(&pNext->refCount, 1);
+        }
+
+        /* The previous node is no longer being referenced. */
+        ma_atomic_fetch_sub_32(&pOutputBus->refCount, 1);
+    }
+    ma_node_input_bus_next_end(pInputBus);
+
+    return pNext;
+}
+
+static ma_node_output_bus* ma_node_input_bus_first(ma_node_input_bus* pInputBus)
+{
+    return ma_node_input_bus_next(pInputBus, &pInputBus->head);
+}
+
+
+
+static ma_result ma_node_input_bus_read_pcm_frames(ma_node* pInputNode, ma_node_input_bus* pInputBus, float* pFramesOut, ma_uint32 frameCount, ma_uint32* pFramesRead, ma_uint64 globalTime)
+{
+    ma_result result = MA_SUCCESS;
+    ma_node_output_bus* pOutputBus;
+    ma_node_output_bus* pFirst;
+    ma_uint32 inputChannels;
+    ma_bool32 doesOutputBufferHaveContent = MA_FALSE;
+
+    /*
+    This will be called from the audio thread which means we can't be doing any locking. Basically,
+    this function will not perform any locking, whereas attaching and detaching will, but crafted in
+    such a way that we don't need to perform any locking here. The important thing to remember is
+    to always iterate in a forward direction.
+
+    In order to process any data we need to first read from all input buses. That's where this
+    function comes in. This iterates over each of the attachments and accumulates/mixes them. We
+    also convert the channels to the nodes output channel count before mixing. We want to do this
+    channel conversion so that the caller of this function can invoke the processing callback
+    without having to do it themselves.
+
+    When we iterate over each of the attachments on the input bus, we need to read as much data as
+    we can from each of them so that we don't end up with holes between each of the attachments. To
+    do this, we need to read from each attachment in a loop and read as many frames as we can, up
+    to `frameCount`.
+    */
+    MA_ASSERT(pInputNode  != NULL);
+    MA_ASSERT(pFramesRead != NULL); /* pFramesRead is critical and must always be specified. On input it's undefined and on output it'll be set to the number of frames actually read. */
+
+    *pFramesRead = 0;   /* Safety. */
+
+    inputChannels = ma_node_input_bus_get_channels(pInputBus);
+
+    /*
+    We need to be careful with how we call ma_node_input_bus_first() and ma_node_input_bus_next(). They
+    are both critical to our lock-free thread-safety system. We can only call ma_node_input_bus_first()
+    once per iteration, however we have an optimization to checks whether or not it's the first item in
+    the list. We therefore need to store a pointer to the first item rather than repeatedly calling
+    ma_node_input_bus_first(). It's safe to keep hold of this pointer, so long as we don't dereference it
+    after calling ma_node_input_bus_next(), which we won't be.
+    */
+    pFirst = ma_node_input_bus_first(pInputBus);
+    if (pFirst == NULL) {
+        return MA_SUCCESS;  /* No attachments. Read nothing. */
+    }
+
+    for (pOutputBus = pFirst; pOutputBus != NULL; pOutputBus = ma_node_input_bus_next(pInputBus, pOutputBus)) {
+        ma_uint32 framesProcessed = 0;
+        ma_bool32 isSilentOutput = MA_FALSE;
+
+        MA_ASSERT(pOutputBus->pNode != NULL);
+        MA_ASSERT(((ma_node_base*)pOutputBus->pNode)->vtable != NULL);
+
+        isSilentOutput = (((ma_node_base*)pOutputBus->pNode)->vtable->flags & MA_NODE_FLAG_SILENT_OUTPUT) != 0;
+
+        if (pFramesOut != NULL) {
+            /* Read. */
+            while (framesProcessed < frameCount) {
+                float* pRunningFramesOut;
+                ma_uint32 framesToRead;
+                ma_uint32 framesJustRead = 0;
+
+                framesToRead = frameCount - framesProcessed;
+                pRunningFramesOut = ma_offset_pcm_frames_ptr_f32(pFramesOut, framesProcessed, inputChannels);
+
+                if (doesOutputBufferHaveContent == MA_FALSE) {
+                    /* Fast path. First attachment. We just read straight into the output buffer (no mixing required). */
+                    result = ma_node_read_pcm_frames(pOutputBus->pNode, pOutputBus->outputBusIndex, pRunningFramesOut, framesToRead, &framesJustRead, globalTime + framesProcessed);
+                } else {
+                    /* Slow path. Not the first attachment. Mixing required. */
+                    ma_uint32 preMixBufferCapInFrames = ((ma_node_base*)pInputNode)->cachedDataCapInFramesPerBus;
+                    float* pPreMixBuffer = (float*)ma_stack_alloc(((ma_node_base*)pInputNode)->pNodeGraph->pPreMixStack, preMixBufferCapInFrames * inputChannels * sizeof(float));
+
+                    if (pPreMixBuffer == NULL) {
+                        /*
+                        If you're hitting this assert it means you've got an unusually deep chain of nodes, you've got an excessively large processing
+                        size, or you have a combination of both, and as a result have run out of stack space. You can increase this using the
+                        preMixStackSizeInBytes variable in ma_node_graph_config. If you're using ma_engine, you can do it via the preMixStackSizeInBytes
+                        variable in ma_engine_config. It defaults to 512KB per output channel.
+                        */
+                        MA_ASSERT(MA_FALSE);
+                    } else {
+                        if (framesToRead > preMixBufferCapInFrames) {
+                            framesToRead = preMixBufferCapInFrames;
+                        }
+
+                        result = ma_node_read_pcm_frames(pOutputBus->pNode, pOutputBus->outputBusIndex, pPreMixBuffer, framesToRead, &framesJustRead, globalTime + framesProcessed);
+                        if (result == MA_SUCCESS || result == MA_AT_END) {
+                            if (isSilentOutput == MA_FALSE) {   /* Don't mix if the node outputs silence. */
+                                ma_mix_pcm_frames_f32(pRunningFramesOut, pPreMixBuffer, framesJustRead, inputChannels, /*volume*/1);
+                            }
+                        }
+
+                        /* The pre-mix buffer is no longer required. */
+                        ma_stack_free(((ma_node_base*)pInputNode)->pNodeGraph->pPreMixStack, pPreMixBuffer);
+                        pPreMixBuffer = NULL;
+                    }
+                }
+
+                framesProcessed += framesJustRead;
+
+                /* If we reached the end or otherwise failed to read any data we need to finish up with this output node. */
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+
+                /* If we didn't read anything, abort so we don't get stuck in a loop. */
+                if (framesJustRead == 0) {
+                    break;
+                }
+            }
+
+            /* If it's the first attachment we didn't do any mixing. Any leftover samples need to be silenced. */
+            if (pOutputBus == pFirst && framesProcessed < frameCount) {
+                ma_silence_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, framesProcessed, ma_format_f32, inputChannels), (frameCount - framesProcessed), ma_format_f32, inputChannels);
+            }
+
+            if (isSilentOutput == MA_FALSE) {
+                doesOutputBufferHaveContent = MA_TRUE;
+            }
+        } else {
+            /* Seek. */
+            ma_node_read_pcm_frames(pOutputBus->pNode, pOutputBus->outputBusIndex, NULL, frameCount, &framesProcessed, globalTime);
+        }
+    }
+
+    /* If we didn't output anything, output silence. */
+    if (doesOutputBufferHaveContent == MA_FALSE && pFramesOut != NULL) {
+        ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, inputChannels);
+    }
+
+    /* In this path we always "process" the entire amount. */
+    *pFramesRead = frameCount;
+
+    return result;
+}
+
+
+MA_API ma_node_config ma_node_config_init(void)
+{
+    ma_node_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.initialState   = ma_node_state_started;    /* Nodes are started by default. */
+    config.inputBusCount  = MA_NODE_BUS_COUNT_UNKNOWN;
+    config.outputBusCount = MA_NODE_BUS_COUNT_UNKNOWN;
+
+    return config;
+}
+
+static ma_uint16 ma_node_config_get_cache_size_in_frames(const ma_node_config* pConfig, const ma_node_graph* pNodeGraph)
+{
+    ma_uint32 cacheSizeInFrames;
+
+    (void)pConfig;
+
+    if (pNodeGraph->processingSizeInFrames > 0) {
+        cacheSizeInFrames = pNodeGraph->processingSizeInFrames;
+    } else {
+        cacheSizeInFrames = MA_DEFAULT_NODE_CACHE_CAP_IN_FRAMES_PER_BUS;
+    }
+
+    if (cacheSizeInFrames > 0xFFFF) {
+        cacheSizeInFrames = 0xFFFF;
+    }
+
+    return (ma_uint16)cacheSizeInFrames;
+}
+
+
+
+static ma_result ma_node_detach_full(ma_node* pNode);
+
+static float* ma_node_get_cached_input_ptr(ma_node* pNode, ma_uint32 inputBusIndex)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_uint32 iInputBus;
+    float* pBasePtr;
+
+    MA_ASSERT(pNodeBase != NULL);
+
+    /* Input data is stored at the front of the buffer. */
+    pBasePtr = pNodeBase->pCachedData;
+    for (iInputBus = 0; iInputBus < inputBusIndex; iInputBus += 1) {
+        pBasePtr += pNodeBase->cachedDataCapInFramesPerBus * ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[iInputBus]);
+    }
+
+    return pBasePtr;
+}
+
+static float* ma_node_get_cached_output_ptr(ma_node* pNode, ma_uint32 outputBusIndex)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_uint32 iInputBus;
+    ma_uint32 iOutputBus;
+    float* pBasePtr;
+
+    MA_ASSERT(pNodeBase != NULL);
+
+    /* Cached output data starts after the input data. */
+    pBasePtr = pNodeBase->pCachedData;
+    for (iInputBus = 0; iInputBus < ma_node_get_input_bus_count(pNodeBase); iInputBus += 1) {
+        pBasePtr += pNodeBase->cachedDataCapInFramesPerBus * ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[iInputBus]);
+    }
+
+    for (iOutputBus = 0; iOutputBus < outputBusIndex; iOutputBus += 1) {
+        pBasePtr += pNodeBase->cachedDataCapInFramesPerBus * ma_node_output_bus_get_channels(&pNodeBase->pOutputBuses[iOutputBus]);
+    }
+
+    return pBasePtr;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t inputBusOffset;
+    size_t outputBusOffset;
+    size_t cachedDataOffset;
+    ma_uint32 inputBusCount;    /* So it doesn't have to be calculated twice. */
+    ma_uint32 outputBusCount;   /* So it doesn't have to be calculated twice. */
+} ma_node_heap_layout;
+
+static ma_result ma_node_translate_bus_counts(const ma_node_config* pConfig, ma_uint32* pInputBusCount, ma_uint32* pOutputBusCount)
+{
+    ma_uint32 inputBusCount;
+    ma_uint32 outputBusCount;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pInputBusCount  != NULL);
+    MA_ASSERT(pOutputBusCount != NULL);
+
+    /* Bus counts are determined by the vtable, unless they're set to `MA_NODE_BUS_COUNT_UNKNWON`, in which case they're taken from the config. */
+    if (pConfig->vtable->inputBusCount == MA_NODE_BUS_COUNT_UNKNOWN) {
+        inputBusCount = pConfig->inputBusCount;
+    } else {
+        inputBusCount = pConfig->vtable->inputBusCount;
+
+        if (pConfig->inputBusCount != MA_NODE_BUS_COUNT_UNKNOWN && pConfig->inputBusCount != pConfig->vtable->inputBusCount) {
+            return MA_INVALID_ARGS; /* Invalid configuration. You must not specify a conflicting bus count between the node's config and the vtable. */
+        }
+    }
+
+    if (pConfig->vtable->outputBusCount == MA_NODE_BUS_COUNT_UNKNOWN) {
+        outputBusCount = pConfig->outputBusCount;
+    } else {
+        outputBusCount = pConfig->vtable->outputBusCount;
+
+        if (pConfig->outputBusCount != MA_NODE_BUS_COUNT_UNKNOWN && pConfig->outputBusCount != pConfig->vtable->outputBusCount) {
+            return MA_INVALID_ARGS; /* Invalid configuration. You must not specify a conflicting bus count between the node's config and the vtable. */
+        }
+    }
+
+    /* Bus counts must be within limits. */
+    if (inputBusCount > MA_MAX_NODE_BUS_COUNT || outputBusCount > MA_MAX_NODE_BUS_COUNT) {
+        return MA_INVALID_ARGS;
+    }
+
+
+    /* We must have channel counts for each bus. */
+    if ((inputBusCount > 0 && pConfig->pInputChannels == NULL) || (outputBusCount > 0 && pConfig->pOutputChannels == NULL)) {
+        return MA_INVALID_ARGS; /* You must specify channel counts for each input and output bus. */
+    }
+
+
+    /* Some special rules for passthrough nodes. */
+    if ((pConfig->vtable->flags & MA_NODE_FLAG_PASSTHROUGH) != 0) {
+        if ((pConfig->vtable->inputBusCount != 0 && pConfig->vtable->inputBusCount != 1) || pConfig->vtable->outputBusCount != 1) {
+            return MA_INVALID_ARGS; /* Passthrough nodes must have exactly 1 output bus and either 0 or 1 input bus. */
+        }
+
+        if (pConfig->pInputChannels[0] != pConfig->pOutputChannels[0]) {
+            return MA_INVALID_ARGS; /* Passthrough nodes must have the same number of channels between input and output nodes. */
+        }
+    }
+
+
+    *pInputBusCount  = inputBusCount;
+    *pOutputBusCount = outputBusCount;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_node_get_heap_layout(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, ma_node_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    ma_uint32 inputBusCount;
+    ma_uint32 outputBusCount;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL || pConfig->vtable == NULL || pConfig->vtable->onProcess == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_node_translate_bus_counts(pConfig, &inputBusCount, &outputBusCount);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Input buses. */
+    if (inputBusCount > MA_MAX_NODE_LOCAL_BUS_COUNT) {
+        pHeapLayout->inputBusOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(sizeof(ma_node_input_bus) * inputBusCount);
+    } else {
+        pHeapLayout->inputBusOffset = MA_SIZE_MAX;  /* MA_SIZE_MAX indicates that no heap allocation is required for the input bus. */
+    }
+
+    /* Output buses. */
+    if (outputBusCount > MA_MAX_NODE_LOCAL_BUS_COUNT) {
+        pHeapLayout->outputBusOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(sizeof(ma_node_output_bus) * outputBusCount);
+    } else {
+        pHeapLayout->outputBusOffset = MA_SIZE_MAX;
+    }
+
+    /*
+    Cached audio data.
+
+    We need to allocate memory for caching both input and output data. We have an optimization
+    where no caching is necessary for specific conditions:
+
+        - The node has 0 inputs and 1 output.
+
+    When a node meets the above conditions, no cache is allocated.
+
+    The size choice for this buffer is a little bit finicky. We don't want to be too wasteful by
+    allocating too much, but at the same time we want it be large enough so that enough frames can
+    be processed for each call to ma_node_read_pcm_frames() so that it keeps things efficient. For
+    now I'm going with 10ms @ 48K which is 480 frames per bus. This is configurable at compile
+    time. It might also be worth investigating whether or not this can be configured at run time.
+    */
+    if (inputBusCount == 0 && outputBusCount == 1) {
+        /* Fast path. No cache needed. */
+        pHeapLayout->cachedDataOffset = MA_SIZE_MAX;
+    } else {
+        /* Slow path. Cache needed. */
+        size_t cachedDataSizeInBytes = 0;
+        ma_uint32 cacheCapInFrames;
+        ma_uint32 iBus;
+
+        /* The capacity of the cache is based on our callback processing size. */
+        cacheCapInFrames = ma_node_config_get_cache_size_in_frames(pConfig, pNodeGraph);
+
+        for (iBus = 0; iBus < inputBusCount; iBus += 1) {
+            cachedDataSizeInBytes += cacheCapInFrames * ma_get_bytes_per_frame(ma_format_f32, pConfig->pInputChannels[iBus]);
+        }
+
+        for (iBus = 0; iBus < outputBusCount; iBus += 1) {
+            cachedDataSizeInBytes += cacheCapInFrames * ma_get_bytes_per_frame(ma_format_f32, pConfig->pOutputChannels[iBus]);
+        }
+
+        pHeapLayout->cachedDataOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(cachedDataSizeInBytes);
+    }
+
+
+    /*
+    Not technically part of the heap, but we can output the input and output bus counts so we can
+    avoid a redundant call to ma_node_translate_bus_counts().
+    */
+    pHeapLayout->inputBusCount  = inputBusCount;
+    pHeapLayout->outputBusCount = outputBusCount;
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_get_heap_size(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_node_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_node_get_heap_layout(pNodeGraph, pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_init_preallocated(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, void* pHeap, ma_node* pNode)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_result result;
+    ma_node_heap_layout heapLayout;
+    ma_uint32 iInputBus;
+    ma_uint32 iOutputBus;
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNodeBase);
+
+    result = ma_node_get_heap_layout(pNodeGraph, pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pNodeBase->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pNodeBase->pNodeGraph     = pNodeGraph;
+    pNodeBase->vtable         = pConfig->vtable;
+    pNodeBase->state          = pConfig->initialState;
+    pNodeBase->stateTimes[ma_node_state_started] = 0;
+    pNodeBase->stateTimes[ma_node_state_stopped] = (ma_uint64)(ma_int64)-1; /* Weird casting for VC6 compatibility. */
+    pNodeBase->inputBusCount  = heapLayout.inputBusCount;
+    pNodeBase->outputBusCount = heapLayout.outputBusCount;
+
+    if (heapLayout.inputBusOffset != MA_SIZE_MAX) {
+        pNodeBase->pInputBuses = (ma_node_input_bus*)ma_offset_ptr(pHeap, heapLayout.inputBusOffset);
+    } else {
+        pNodeBase->pInputBuses = pNodeBase->_inputBuses;
+    }
+
+    if (heapLayout.outputBusOffset != MA_SIZE_MAX) {
+        pNodeBase->pOutputBuses = (ma_node_output_bus*)ma_offset_ptr(pHeap, heapLayout.outputBusOffset);
+    } else {
+        pNodeBase->pOutputBuses = pNodeBase->_outputBuses;
+    }
+
+    if (heapLayout.cachedDataOffset != MA_SIZE_MAX) {
+        pNodeBase->pCachedData = (float*)ma_offset_ptr(pHeap, heapLayout.cachedDataOffset);
+        pNodeBase->cachedDataCapInFramesPerBus = ma_node_config_get_cache_size_in_frames(pConfig, pNodeGraph);
+    } else {
+        pNodeBase->pCachedData = NULL;
+    }
+
+
+    /* We need to run an initialization step for each input and output bus. */
+    for (iInputBus = 0; iInputBus < ma_node_get_input_bus_count(pNodeBase); iInputBus += 1) {
+        result = ma_node_input_bus_init(pConfig->pInputChannels[iInputBus], &pNodeBase->pInputBuses[iInputBus]);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    for (iOutputBus = 0; iOutputBus < ma_node_get_output_bus_count(pNodeBase); iOutputBus += 1) {
+        result = ma_node_output_bus_init(pNodeBase, iOutputBus, pConfig->pOutputChannels[iOutputBus], &pNodeBase->pOutputBuses[iOutputBus]);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+
+    /* The cached data needs to be initialized to silence (or a sine wave tone if we're debugging). */
+    if (pNodeBase->pCachedData != NULL) {
+        ma_uint32 iBus;
+
+    #if 1   /* Toggle this between 0 and 1 to turn debugging on or off. 1 = fill with a sine wave for debugging; 0 = fill with silence. */
+        /* For safety we'll go ahead and default the buffer to silence. */
+        for (iBus = 0; iBus < ma_node_get_input_bus_count(pNodeBase); iBus += 1) {
+            ma_silence_pcm_frames(ma_node_get_cached_input_ptr(pNode, iBus), pNodeBase->cachedDataCapInFramesPerBus, ma_format_f32, ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[iBus]));
+        }
+        for (iBus = 0; iBus < ma_node_get_output_bus_count(pNodeBase); iBus += 1) {
+            ma_silence_pcm_frames(ma_node_get_cached_output_ptr(pNode, iBus), pNodeBase->cachedDataCapInFramesPerBus, ma_format_f32, ma_node_output_bus_get_channels(&pNodeBase->pOutputBuses[iBus]));
+        }
+    #else
+        /* For debugging. Default to a sine wave. */
+        for (iBus = 0; iBus < ma_node_get_input_bus_count(pNodeBase); iBus += 1) {
+            ma_debug_fill_pcm_frames_with_sine_wave(ma_node_get_cached_input_ptr(pNode, iBus), pNodeBase->cachedDataCapInFramesPerBus, ma_format_f32, ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[iBus]), 48000);
+        }
+        for (iBus = 0; iBus < ma_node_get_output_bus_count(pNodeBase); iBus += 1) {
+            ma_debug_fill_pcm_frames_with_sine_wave(ma_node_get_cached_output_ptr(pNode, iBus), pNodeBase->cachedDataCapInFramesPerBus, ma_format_f32, ma_node_output_bus_get_channels(&pNodeBase->pOutputBuses[iBus]), 48000);
+        }
+    #endif
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_init(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node* pNode)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_node_get_heap_size(pNodeGraph, pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_node_init_preallocated(pNodeGraph, pConfig, pHeap, pNode);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    ((ma_node_base*)pNode)->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_node_uninit(ma_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return;
+    }
+
+    /*
+    The first thing we need to do is fully detach the node. This will detach all inputs and
+    outputs. We need to do this first because it will sever the connection with the node graph and
+    allow us to complete uninitialization without needing to worry about thread-safety with the
+    audio thread. The detachment process will wait for any local processing of the node to finish.
+    */
+    ma_node_detach_full(pNode);
+
+    /*
+    At this point the node should be completely unreferenced by the node graph and we can finish up
+    the uninitialization process without needing to worry about thread-safety.
+    */
+    if (pNodeBase->_ownsHeap) {
+        ma_free(pNodeBase->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_node_graph* ma_node_get_node_graph(const ma_node* pNode)
+{
+    if (pNode == NULL) {
+        return NULL;
+    }
+
+    return ((const ma_node_base*)pNode)->pNodeGraph;
+}
+
+MA_API ma_uint32 ma_node_get_input_bus_count(const ma_node* pNode)
+{
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    return ((ma_node_base*)pNode)->inputBusCount;
+}
+
+MA_API ma_uint32 ma_node_get_output_bus_count(const ma_node* pNode)
+{
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    return ((ma_node_base*)pNode)->outputBusCount;
+}
+
+
+MA_API ma_uint32 ma_node_get_input_channels(const ma_node* pNode, ma_uint32 inputBusIndex)
+{
+    const ma_node_base* pNodeBase = (const ma_node_base*)pNode;
+
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    if (inputBusIndex >= ma_node_get_input_bus_count(pNode)) {
+        return 0;   /* Invalid bus index. */
+    }
+
+    return ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[inputBusIndex]);
+}
+
+MA_API ma_uint32 ma_node_get_output_channels(const ma_node* pNode, ma_uint32 outputBusIndex)
+{
+    const ma_node_base* pNodeBase = (const ma_node_base*)pNode;
+
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode)) {
+        return 0;   /* Invalid bus index. */
+    }
+
+    return ma_node_output_bus_get_channels(&pNodeBase->pOutputBuses[outputBusIndex]);
+}
+
+
+static ma_result ma_node_detach_full(ma_node* pNode)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_uint32 iInputBus;
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    Make sure the node is completely detached first. This will not return until the output bus is
+    guaranteed to no longer be referenced by the audio thread.
+    */
+    ma_node_detach_all_output_buses(pNode);
+
+    /*
+    At this point all output buses will have been detached from the graph and we can be guaranteed
+    that none of its input nodes will be getting processed by the graph. We can detach these
+    without needing to worry about the audio thread touching them.
+    */
+    for (iInputBus = 0; iInputBus < ma_node_get_input_bus_count(pNode); iInputBus += 1) {
+        ma_node_input_bus* pInputBus;
+        ma_node_output_bus* pOutputBus;
+
+        pInputBus = &pNodeBase->pInputBuses[iInputBus];
+
+        /*
+        This is important. We cannot be using ma_node_input_bus_first() or ma_node_input_bus_next(). Those
+        functions are specifically for the audio thread. We'll instead just manually iterate using standard
+        linked list logic. We don't need to worry about the audio thread referencing these because the step
+        above severed the connection to the graph.
+        */
+        for (pOutputBus = (ma_node_output_bus*)ma_atomic_load_ptr(&pInputBus->head.pNext); pOutputBus != NULL; pOutputBus = (ma_node_output_bus*)ma_atomic_load_ptr(&pInputBus->head.pNext)) {
+            ma_node_detach_output_bus(pOutputBus->pNode, pOutputBus->outputBusIndex);   /* This won't do any waiting in practice and should be efficient. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_detach_output_bus(ma_node* pNode, ma_uint32 outputBusIndex)
+{
+    ma_result result = MA_SUCCESS;
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_node_base* pInputNodeBase;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode)) {
+        return MA_INVALID_ARGS; /* Invalid output bus index. */
+    }
+
+    /* We need to lock the output bus because we need to inspect the input node and grab its input bus. */
+    ma_node_output_bus_lock(&pNodeBase->pOutputBuses[outputBusIndex]);
+    {
+        pInputNodeBase = (ma_node_base*)pNodeBase->pOutputBuses[outputBusIndex].pInputNode;
+        if (pInputNodeBase != NULL) {
+            ma_node_input_bus_detach__no_output_bus_lock(&pInputNodeBase->pInputBuses[pNodeBase->pOutputBuses[outputBusIndex].inputNodeInputBusIndex], &pNodeBase->pOutputBuses[outputBusIndex]);
+        }
+    }
+    ma_node_output_bus_unlock(&pNodeBase->pOutputBuses[outputBusIndex]);
+
+    return result;
+}
+
+MA_API ma_result ma_node_detach_all_output_buses(ma_node* pNode)
+{
+    ma_uint32 iOutputBus;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iOutputBus = 0; iOutputBus < ma_node_get_output_bus_count(pNode); iOutputBus += 1) {
+        ma_node_detach_output_bus(pNode, iOutputBus);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_attach_output_bus(ma_node* pNode, ma_uint32 outputBusIndex, ma_node* pOtherNode, ma_uint32 otherNodeInputBusIndex)
+{
+    ma_node_base* pNodeBase  = (ma_node_base*)pNode;
+    ma_node_base* pOtherNodeBase = (ma_node_base*)pOtherNode;
+
+    if (pNodeBase == NULL || pOtherNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pNodeBase == pOtherNodeBase) {
+        return MA_INVALID_OPERATION;    /* Cannot attach a node to itself. */
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode) || otherNodeInputBusIndex >= ma_node_get_input_bus_count(pOtherNode)) {
+        return MA_INVALID_OPERATION;    /* Invalid bus index. */
+    }
+
+    /* The output channel count of the output node must be the same as the input channel count of the input node. */
+    if (ma_node_get_output_channels(pNode, outputBusIndex) != ma_node_get_input_channels(pOtherNode, otherNodeInputBusIndex)) {
+        return MA_INVALID_OPERATION;    /* Channel count is incompatible. */
+    }
+
+    /* This will deal with detaching if the output bus is already attached to something. */
+    ma_node_input_bus_attach(&pOtherNodeBase->pInputBuses[otherNodeInputBusIndex], &pNodeBase->pOutputBuses[outputBusIndex], pOtherNode, otherNodeInputBusIndex);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_set_output_bus_volume(ma_node* pNode, ma_uint32 outputBusIndex, float volume)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode)) {
+        return MA_INVALID_ARGS; /* Invalid bus index. */
+    }
+
+    return ma_node_output_bus_set_volume(&pNodeBase->pOutputBuses[outputBusIndex], volume);
+}
+
+MA_API float ma_node_get_output_bus_volume(const ma_node* pNode, ma_uint32 outputBusIndex)
+{
+    const ma_node_base* pNodeBase = (const ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return 0;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode)) {
+        return 0;   /* Invalid bus index. */
+    }
+
+    return ma_node_output_bus_get_volume(&pNodeBase->pOutputBuses[outputBusIndex]);
+}
+
+MA_API ma_result ma_node_set_state(ma_node* pNode, ma_node_state state)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_exchange_i32(&pNodeBase->state, state);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_node_state ma_node_get_state(const ma_node* pNode)
+{
+    const ma_node_base* pNodeBase = (const ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return ma_node_state_stopped;
+    }
+
+    return (ma_node_state)ma_atomic_load_i32(&pNodeBase->state);
+}
+
+MA_API ma_result ma_node_set_state_time(ma_node* pNode, ma_node_state state, ma_uint64 globalTime)
+{
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Validation check for safety since we'll be using this as an index into stateTimes[]. */
+    if (state != ma_node_state_started && state != ma_node_state_stopped) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_exchange_64(&((ma_node_base*)pNode)->stateTimes[state], globalTime);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint64 ma_node_get_state_time(const ma_node* pNode, ma_node_state state)
+{
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    /* Validation check for safety since we'll be using this as an index into stateTimes[]. */
+    if (state != ma_node_state_started && state != ma_node_state_stopped) {
+        return 0;
+    }
+
+    return ma_atomic_load_64(&((ma_node_base*)pNode)->stateTimes[state]);
+}
+
+MA_API ma_node_state ma_node_get_state_by_time(const ma_node* pNode, ma_uint64 globalTime)
+{
+    if (pNode == NULL) {
+        return ma_node_state_stopped;
+    }
+
+    return ma_node_get_state_by_time_range(pNode, globalTime, globalTime);
+}
+
+MA_API ma_node_state ma_node_get_state_by_time_range(const ma_node* pNode, ma_uint64 globalTimeBeg, ma_uint64 globalTimeEnd)
+{
+    ma_node_state state;
+
+    if (pNode == NULL) {
+        return ma_node_state_stopped;
+    }
+
+    state = ma_node_get_state(pNode);
+
+    /* An explicitly stopped node is always stopped. */
+    if (state == ma_node_state_stopped) {
+        return ma_node_state_stopped;
+    }
+
+    /*
+    Getting here means the node is marked as started, but it may still not be truly started due to
+    its start time not having been reached yet. Also, the stop time may have also been reached in
+    which case it'll be considered stopped.
+    */
+    if (ma_node_get_state_time(pNode, ma_node_state_started) > globalTimeBeg) {
+        return ma_node_state_stopped;   /* Start time has not yet been reached. */
+    }
+
+    if (ma_node_get_state_time(pNode, ma_node_state_stopped) <= globalTimeEnd) {
+        return ma_node_state_stopped;   /* Stop time has been reached. */
+    }
+
+    /* Getting here means the node is marked as started and is within its start/stop times. */
+    return ma_node_state_started;
+}
+
+MA_API ma_uint64 ma_node_get_time(const ma_node* pNode)
+{
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_64(&((ma_node_base*)pNode)->localTime);
+}
+
+MA_API ma_result ma_node_set_time(ma_node* pNode, ma_uint64 localTime)
+{
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_exchange_64(&((ma_node_base*)pNode)->localTime, localTime);
+
+    return MA_SUCCESS;
+}
+
+
+
+static void ma_node_process_pcm_frames_internal(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+
+    if (pNodeBase->vtable->onProcess) {
+        pNodeBase->vtable->onProcess(pNode, ppFramesIn, pFrameCountIn, ppFramesOut, pFrameCountOut);
+    }
+}
+
+static ma_result ma_node_read_pcm_frames(ma_node* pNode, ma_uint32 outputBusIndex, float* pFramesOut, ma_uint32 frameCount, ma_uint32* pFramesRead, ma_uint64 globalTime)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_result result = MA_SUCCESS;
+    ma_uint32 iInputBus;
+    ma_uint32 iOutputBus;
+    ma_uint32 inputBusCount;
+    ma_uint32 outputBusCount;
+    ma_uint32 totalFramesRead = 0;
+    float* ppFramesIn[MA_MAX_NODE_BUS_COUNT];
+    float* ppFramesOut[MA_MAX_NODE_BUS_COUNT];
+    ma_uint64 globalTimeBeg;
+    ma_uint64 globalTimeEnd;
+    ma_uint64 startTime;
+    ma_uint64 stopTime;
+    ma_uint32 timeOffsetBeg;
+    ma_uint32 timeOffsetEnd;
+    ma_uint32 frameCountIn;
+    ma_uint32 frameCountOut;
+
+    /*
+    pFramesRead is mandatory. It must be used to determine how many frames were read. It's normal and
+    expected that the number of frames read may be different to that requested. Therefore, the caller
+    must look at this value to correctly determine how many frames were read.
+    */
+    MA_ASSERT(pFramesRead != NULL); /* <-- If you've triggered this assert, you're using this function wrong. You *must* use this variable and inspect it after the call returns. */
+    if (pFramesRead == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFramesRead = 0;   /* Safety. */
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNodeBase)) {
+        return MA_INVALID_ARGS; /* Invalid output bus index. */
+    }
+
+    /* Don't do anything if we're in a stopped state. */
+    if (ma_node_get_state_by_time_range(pNode, globalTime, globalTime + frameCount) != ma_node_state_started) {
+        return MA_SUCCESS;  /* We're in a stopped state. This is not an error - we just need to not read anything. */
+    }
+
+
+    globalTimeBeg = globalTime;
+    globalTimeEnd = globalTime + frameCount;
+    startTime = ma_node_get_state_time(pNode, ma_node_state_started);
+    stopTime  = ma_node_get_state_time(pNode, ma_node_state_stopped);
+
+    /*
+    At this point we know that we are inside our start/stop times. However, we may need to adjust
+    our frame count and output pointer to accommodate since we could be straddling the time period
+    that this function is getting called for.
+
+    It's possible (and likely) that the start time does not line up with the output buffer. We
+    therefore need to offset it by a number of frames to accommodate. The same thing applies for
+    the stop time.
+    */
+    timeOffsetBeg = (globalTimeBeg < startTime) ? (ma_uint32)(globalTimeEnd - startTime) : 0;
+    timeOffsetEnd = (globalTimeEnd > stopTime)  ? (ma_uint32)(globalTimeEnd - stopTime)  : 0;
+
+    /* Trim based on the start offset. We need to silence the start of the buffer. */
+    if (timeOffsetBeg > 0) {
+        ma_silence_pcm_frames(pFramesOut, timeOffsetBeg, ma_format_f32, ma_node_get_output_channels(pNode, outputBusIndex));
+        pFramesOut += timeOffsetBeg * ma_node_get_output_channels(pNode, outputBusIndex);
+        frameCount -= timeOffsetBeg;
+    }
+
+    /* Trim based on the end offset. We don't need to silence the tail section because we'll just have a reduced value written to pFramesRead. */
+    if (timeOffsetEnd > 0) {
+        frameCount -= timeOffsetEnd;
+    }
+
+
+    /* We run on different paths depending on the bus counts. */
+    inputBusCount  = ma_node_get_input_bus_count(pNode);
+    outputBusCount = ma_node_get_output_bus_count(pNode);
+
+    /*
+    Run a simplified path when there are no inputs and one output. In this case there's nothing to
+    actually read and we can go straight to output. This is a very common scenario because the vast
+    majority of data source nodes will use this setup so this optimization I think is worthwhile.
+    */
+    if (inputBusCount == 0 && outputBusCount == 1) {
+        /* Fast path. No need to read from input and no need for any caching. */
+        frameCountIn  = 0;
+        frameCountOut = frameCount;    /* Just read as much as we can. The callback will return what was actually read. */
+
+        ppFramesOut[0] = pFramesOut;
+
+        /*
+        If it's a passthrough we won't be expecting the callback to output anything, so we'll
+        need to pre-silence the output buffer.
+        */
+        if ((pNodeBase->vtable->flags & MA_NODE_FLAG_PASSTHROUGH) != 0) {
+            ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, ma_node_get_output_channels(pNode, outputBusIndex));
+        }
+
+        ma_node_process_pcm_frames_internal(pNode, NULL, &frameCountIn, ppFramesOut, &frameCountOut);
+        totalFramesRead = frameCountOut;
+    } else {
+        /* Slow path. Need to read input data. */
+        if ((pNodeBase->vtable->flags & MA_NODE_FLAG_PASSTHROUGH) != 0) {
+            /*
+            Fast path. We're running a passthrough. We need to read directly into the output buffer, but
+            still fire the callback so that event handling and trigger nodes can do their thing. Since
+            it's a passthrough there's no need for any kind of caching logic.
+            */
+            MA_ASSERT(outputBusCount == inputBusCount);
+            MA_ASSERT(outputBusCount == 1);
+            MA_ASSERT(outputBusIndex == 0);
+
+            /* We just read directly from input bus to output buffer, and then afterwards fire the callback. */
+            ppFramesOut[0] = pFramesOut;
+            ppFramesIn[0] = ppFramesOut[0];
+
+            result = ma_node_input_bus_read_pcm_frames(pNodeBase, &pNodeBase->pInputBuses[0], ppFramesIn[0], frameCount, &totalFramesRead, globalTime);
+            if (result == MA_SUCCESS) {
+                /* Even though it's a passthrough, we still need to fire the callback. */
+                frameCountIn  = totalFramesRead;
+                frameCountOut = totalFramesRead;
+
+                if (totalFramesRead > 0) {
+                    ma_node_process_pcm_frames_internal(pNode, (const float**)ppFramesIn, &frameCountIn, ppFramesOut, &frameCountOut);  /* From GCC: expected 'const float **' but argument is of type 'float **'. Shouldn't this be implicit? Explicit cast to silence the warning. */
+                }
+
+                /*
+                A passthrough should never have modified the input and output frame counts. If you're
+                triggering these asserts you need to fix your processing callback.
+                */
+                MA_ASSERT(frameCountIn  == totalFramesRead);
+                MA_ASSERT(frameCountOut == totalFramesRead);
+            }
+        } else {
+            /* Slow path. Need to do caching. */
+            ma_uint32 framesToProcessIn;
+            ma_uint32 framesToProcessOut;
+            ma_bool32 consumeNullInput = MA_FALSE;
+
+            /*
+            We use frameCount as a basis for the number of frames to read since that's what's being
+            requested, however we still need to clamp it to whatever can fit in the cache.
+
+            This will also be used as the basis for determining how many input frames to read. This is
+            not ideal because it can result in too many input frames being read which introduces latency.
+            To solve this, nodes can implement an optional callback called onGetRequiredInputFrameCount
+            which is used as hint to miniaudio as to how many input frames it needs to read at a time. This
+            callback is completely optional, and if it's not set, miniaudio will assume `frameCount`.
+
+            This function will be called multiple times for each period of time, once for each output node.
+            We cannot read from each input node each time this function is called. Instead we need to check
+            whether or not this is first output bus to be read from for this time period, and if so, read
+            from our input data.
+
+            To determine whether or not we're ready to read data, we check a flag. There will be one flag
+            for each output. When the flag is set, it means data has been read previously and that we're
+            ready to advance time forward for our input nodes by reading fresh data.
+            */
+            framesToProcessOut = frameCount;
+            if (framesToProcessOut > pNodeBase->cachedDataCapInFramesPerBus) {
+                framesToProcessOut = pNodeBase->cachedDataCapInFramesPerBus;
+            }
+
+            framesToProcessIn  = frameCount;
+            if (pNodeBase->vtable->onGetRequiredInputFrameCount) {
+                pNodeBase->vtable->onGetRequiredInputFrameCount(pNode, framesToProcessOut, &framesToProcessIn); /* <-- It does not matter if this fails. */
+            }
+            if (framesToProcessIn > pNodeBase->cachedDataCapInFramesPerBus) {
+                framesToProcessIn = pNodeBase->cachedDataCapInFramesPerBus;
+            }
+
+
+            MA_ASSERT(framesToProcessIn  <= 0xFFFF);
+            MA_ASSERT(framesToProcessOut <= 0xFFFF);
+
+            if (ma_node_output_bus_has_read(&pNodeBase->pOutputBuses[outputBusIndex])) {
+                /* Getting here means we need to do another round of processing. */
+                pNodeBase->cachedFrameCountOut = 0;
+
+                for (;;) {
+                    frameCountOut = 0;
+
+                    /*
+                    We need to prepare our output frame pointers for processing. In the same iteration we need
+                    to mark every output bus as unread so that future calls to this function for different buses
+                    for the current time period don't pull in data when they should instead be reading from cache.
+                    */
+                    for (iOutputBus = 0; iOutputBus < outputBusCount; iOutputBus += 1) {
+                        ma_node_output_bus_set_has_read(&pNodeBase->pOutputBuses[iOutputBus], MA_FALSE); /* <-- This is what tells the next calls to this function for other output buses for this time period to read from cache instead of pulling in more data. */
+                        ppFramesOut[iOutputBus] = ma_node_get_cached_output_ptr(pNode, iOutputBus);
+                    }
+
+                    /* We only need to read from input buses if there isn't already some data in the cache. */
+                    if (pNodeBase->cachedFrameCountIn == 0) {
+                        ma_uint32 maxFramesReadIn = 0;
+
+                        /* Here is where we pull in data from the input buses. This is what will trigger an advance in time. */
+                        for (iInputBus = 0; iInputBus < inputBusCount; iInputBus += 1) {
+                            ma_uint32 framesRead;
+
+                            /* The first thing to do is get the offset within our bulk allocation to store this input data. */
+                            ppFramesIn[iInputBus] = ma_node_get_cached_input_ptr(pNode, iInputBus);
+
+                            /* Once we've determined our destination pointer we can read. Note that we must inspect the number of frames read and fill any leftovers with silence for safety. */
+                            result = ma_node_input_bus_read_pcm_frames(pNodeBase, &pNodeBase->pInputBuses[iInputBus], ppFramesIn[iInputBus], framesToProcessIn, &framesRead, globalTime);
+                            if (result != MA_SUCCESS) {
+                                /* It doesn't really matter if we fail because we'll just fill with silence. */
+                                framesRead = 0; /* Just for safety, but I don't think it's really needed. */
+                            }
+
+                            /* TODO: Minor optimization opportunity here. If no frames were read and the buffer is already filled with silence, no need to re-silence it. */
+                            /* Any leftover frames need to silenced for safety. */
+                            if (framesRead < framesToProcessIn) {
+                                ma_silence_pcm_frames(ppFramesIn[iInputBus] + (framesRead * ma_node_get_input_channels(pNodeBase, iInputBus)), (framesToProcessIn - framesRead), ma_format_f32, ma_node_get_input_channels(pNodeBase, iInputBus));
+                            }
+
+                            maxFramesReadIn = ma_max(maxFramesReadIn, framesRead);
+                        }
+
+                        /* This was a fresh load of input data so reset our consumption counter. */
+                        pNodeBase->consumedFrameCountIn = 0;
+
+                        /*
+                        We don't want to keep processing if there's nothing to process, so set the number of cached
+                        input frames to the maximum number we read from each attachment (the lesser will be padded
+                        with silence). If we didn't read anything, this will be set to 0 and the entire buffer will
+                        have been assigned to silence. This being equal to 0 is an important property for us because
+                        it allows us to detect when NULL can be passed into the processing callback for the input
+                        buffer for the purpose of continuous processing.
+                        */
+                        pNodeBase->cachedFrameCountIn = (ma_uint16)maxFramesReadIn;
+                    } else {
+                        /* We don't need to read anything, but we do need to prepare our input frame pointers. */
+                        for (iInputBus = 0; iInputBus < inputBusCount; iInputBus += 1) {
+                            ppFramesIn[iInputBus] = ma_node_get_cached_input_ptr(pNode, iInputBus) + (pNodeBase->consumedFrameCountIn * ma_node_get_input_channels(pNodeBase, iInputBus));
+                        }
+                    }
+
+                    /*
+                    At this point we have our input data so now we need to do some processing. Sneaky little
+                    optimization here - we can set the pointer to the output buffer for this output bus so
+                    that the final copy into the output buffer is done directly by onProcess().
+                    */
+                    if (pFramesOut != NULL) {
+                        ppFramesOut[outputBusIndex] = ma_offset_pcm_frames_ptr_f32(pFramesOut, pNodeBase->cachedFrameCountOut, ma_node_get_output_channels(pNode, outputBusIndex));
+                    }
+
+
+                    /* Give the processing function the entire capacity of the output buffer. */
+                    frameCountOut = (framesToProcessOut - pNodeBase->cachedFrameCountOut);
+
+                    /*
+                    We need to treat nodes with continuous processing a little differently. For these ones,
+                    we always want to fire the callback with the requested number of frames, regardless of
+                    pNodeBase->cachedFrameCountIn, which could be 0. Also, we want to check if we can pass
+                    in NULL for the input buffer to the callback.
+                    */
+                    if ((pNodeBase->vtable->flags & MA_NODE_FLAG_CONTINUOUS_PROCESSING) != 0) {
+                        /* We're using continuous processing. Make sure we specify the whole frame count at all times. */
+                        frameCountIn = framesToProcessIn;    /* Give the processing function as much input data as we've got in the buffer, including any silenced padding from short reads. */
+
+                        if ((pNodeBase->vtable->flags & MA_NODE_FLAG_ALLOW_NULL_INPUT) != 0 && pNodeBase->consumedFrameCountIn == 0 && pNodeBase->cachedFrameCountIn == 0) {
+                            consumeNullInput = MA_TRUE;
+                        } else {
+                            consumeNullInput = MA_FALSE;
+                        }
+
+                        /*
+                        Since we're using continuous processing we're always passing in a full frame count
+                        regardless of how much input data was read. If this is greater than what we read as
+                        input, we'll end up with an underflow. We instead need to make sure our cached frame
+                        count is set to the number of frames we'll be passing to the data callback. Not
+                        doing this will result in an underflow when we "consume" the cached data later on.
+
+                        Note that this check needs to be done after the "consumeNullInput" check above because
+                        we use the property of cachedFrameCountIn being 0 to determine whether or not we
+                        should be passing in a null pointer to the processing callback for when the node is
+                        configured with MA_NODE_FLAG_ALLOW_NULL_INPUT.
+                        */
+                        if (pNodeBase->cachedFrameCountIn < (ma_uint16)frameCountIn) {
+                            pNodeBase->cachedFrameCountIn = (ma_uint16)frameCountIn;
+                        }
+                    } else {
+                        frameCountIn = pNodeBase->cachedFrameCountIn;  /* Give the processing function as much valid input data as we've got. */
+                        consumeNullInput = MA_FALSE;
+                    }
+
+                    /*
+                    Process data slightly differently depending on whether or not we're consuming NULL
+                    input (checked just above).
+                    */
+                    if (consumeNullInput) {
+                        ma_node_process_pcm_frames_internal(pNode, NULL, &frameCountIn, ppFramesOut, &frameCountOut);
+                    } else {
+                        /*
+                        We want to skip processing if there's no input data, but we can only do that safely if
+                        we know that there is no chance of any output frames being produced. If continuous
+                        processing is being used, this won't be a problem because the input frame count will
+                        always be non-0. However, if continuous processing is *not* enabled and input and output
+                        data is processed at different rates, we still need to process that last input frame
+                        because there could be a few excess output frames needing to be produced from cached
+                        data. The `MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES` flag is used as the indicator for
+                        determining whether or not we need to process the node even when there are no input
+                        frames available right now.
+                        */
+                        if (frameCountIn > 0 || (pNodeBase->vtable->flags & MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES) != 0) {
+                            ma_node_process_pcm_frames_internal(pNode, (const float**)ppFramesIn, &frameCountIn, ppFramesOut, &frameCountOut);    /* From GCC: expected 'const float **' but argument is of type 'float **'. Shouldn't this be implicit? Explicit cast to silence the warning. */
+                        } else {
+                            frameCountOut = 0;  /* No data was processed. */
+                        }
+                    }
+
+                    /*
+                    Thanks to our sneaky optimization above we don't need to do any data copying directly into
+                    the output buffer - the onProcess() callback just did that for us. We do, however, need to
+                    apply the number of input and output frames that were processed. Note that due to continuous
+                    processing above, we need to do explicit checks here. If we just consumed a NULL input
+                    buffer it means that no actual input data was processed from the internal buffers and we
+                    don't want to be modifying any counters.
+                    */
+                    if (consumeNullInput == MA_FALSE) {
+                        pNodeBase->consumedFrameCountIn += (ma_uint16)frameCountIn;
+                        pNodeBase->cachedFrameCountIn   -= (ma_uint16)frameCountIn;
+                    }
+
+                    /* The cached output frame count is always equal to what we just read. */
+                    pNodeBase->cachedFrameCountOut += (ma_uint16)frameCountOut;
+
+                    /* If we couldn't process any data, we're done. The loop needs to be terminated here or else we'll get stuck in a loop. */
+                    if (pNodeBase->cachedFrameCountOut == framesToProcessOut || (frameCountOut == 0 && frameCountIn == 0)) {
+                        break;
+                    }
+                }
+            } else {
+                /*
+                We're not needing to read anything from the input buffer so just read directly from our
+                already-processed data.
+                */
+                if (pFramesOut != NULL) {
+                    ma_copy_pcm_frames(pFramesOut, ma_node_get_cached_output_ptr(pNodeBase, outputBusIndex), pNodeBase->cachedFrameCountOut, ma_format_f32, ma_node_get_output_channels(pNodeBase, outputBusIndex));
+                }
+            }
+
+            /* The number of frames read is always equal to the number of cached output frames. */
+            totalFramesRead = pNodeBase->cachedFrameCountOut;
+
+            /* Now that we've read the data, make sure our read flag is set. */
+            ma_node_output_bus_set_has_read(&pNodeBase->pOutputBuses[outputBusIndex], MA_TRUE);
+        }
+    }
+
+    /* Apply volume, if necessary. */
+    ma_apply_volume_factor_f32(pFramesOut, totalFramesRead * ma_node_get_output_channels(pNodeBase, outputBusIndex), ma_node_output_bus_get_volume(&pNodeBase->pOutputBuses[outputBusIndex]));
+
+    /* Advance our local time forward. */
+    ma_atomic_fetch_add_64(&pNodeBase->localTime, (ma_uint64)totalFramesRead);
+
+    *pFramesRead = totalFramesRead + timeOffsetBeg; /* Must include the silenced section at the start of the buffer. */
+    return result;
+}
+
+
+
+
+/* Data source node. */
+MA_API ma_data_source_node_config ma_data_source_node_config_init(ma_data_source* pDataSource)
+{
+    ma_data_source_node_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.nodeConfig  = ma_node_config_init();
+    config.pDataSource = pDataSource;
+
+    return config;
+}
+
+
+static void ma_data_source_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_data_source_node* pDataSourceNode = (ma_data_source_node*)pNode;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 frameCount;
+    ma_uint64 framesRead = 0;
+
+    MA_ASSERT(pDataSourceNode != NULL);
+    MA_ASSERT(pDataSourceNode->pDataSource != NULL);
+    MA_ASSERT(ma_node_get_input_bus_count(pDataSourceNode)  == 0);
+    MA_ASSERT(ma_node_get_output_bus_count(pDataSourceNode) == 1);
+
+    /* We don't want to read from ppFramesIn at all. Instead we read from the data source. */
+    (void)ppFramesIn;
+    (void)pFrameCountIn;
+
+    frameCount = *pFrameCountOut;
+
+    /* miniaudio should never be calling this with a frame count of zero. */
+    MA_ASSERT(frameCount > 0);
+
+    if (ma_data_source_get_data_format(pDataSourceNode->pDataSource, &format, &channels, NULL, NULL, 0) == MA_SUCCESS) { /* <-- Don't care about sample rate here. */
+        /* The node graph system requires samples be in floating point format. This is checked in ma_data_source_node_init(). */
+        MA_ASSERT(format == ma_format_f32);
+        (void)format;   /* Just to silence some static analysis tools. */
+
+        ma_data_source_read_pcm_frames(pDataSourceNode->pDataSource, ppFramesOut[0], frameCount, &framesRead);
+    }
+
+    *pFrameCountOut = (ma_uint32)framesRead;
+}
+
+static ma_node_vtable g_ma_data_source_node_vtable =
+{
+    ma_data_source_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    0,      /* 0 input buses. */
+    1,      /* 1 output bus. */
+    0
+};
+
+MA_API ma_result ma_data_source_node_init(ma_node_graph* pNodeGraph, const ma_data_source_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source_node* pDataSourceNode)
+{
+    ma_result result;
+    ma_format format;   /* For validating the format, which must be ma_format_f32. */
+    ma_uint32 channels; /* For specifying the channel count of the output bus. */
+    ma_node_config baseConfig;
+
+    if (pDataSourceNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataSourceNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_data_source_get_data_format(pConfig->pDataSource, &format, &channels, NULL, NULL, 0);    /* Don't care about sample rate. This will check pDataSource for NULL. */
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    MA_ASSERT(format == ma_format_f32); /* <-- If you've triggered this it means your data source is not outputting floating-point samples. You must configure your data source to use ma_format_f32. */
+    if (format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* Invalid format. */
+    }
+
+    /* The channel count is defined by the data source. If the caller has manually changed the channels we just ignore it. */
+    baseConfig = pConfig->nodeConfig;
+    baseConfig.vtable = &g_ma_data_source_node_vtable;  /* Explicitly set the vtable here to prevent callers from setting it incorrectly. */
+
+    /*
+    The channel count is defined by the data source. It is invalid for the caller to manually set
+    the channel counts in the config. `ma_data_source_node_config_init()` will have defaulted the
+    channel count pointer to NULL which is how it must remain. If you trigger any of these asserts
+    it means you're explicitly setting the channel count. Instead, configure the output channel
+    count of your data source to be the necessary channel count.
+    */
+    if (baseConfig.pOutputChannels != NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    baseConfig.pOutputChannels = &channels;
+
+    result = ma_node_init(pNodeGraph, &baseConfig, pAllocationCallbacks, &pDataSourceNode->base);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDataSourceNode->pDataSource = pConfig->pDataSource;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_source_node_uninit(ma_data_source_node* pDataSourceNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_node_uninit(&pDataSourceNode->base, pAllocationCallbacks);
+}
+
+MA_API ma_result ma_data_source_node_set_looping(ma_data_source_node* pDataSourceNode, ma_bool32 isLooping)
+{
+    if (pDataSourceNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_data_source_set_looping(pDataSourceNode->pDataSource, isLooping);
+}
+
+MA_API ma_bool32 ma_data_source_node_is_looping(ma_data_source_node* pDataSourceNode)
+{
+    if (pDataSourceNode == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_data_source_is_looping(pDataSourceNode->pDataSource);
+}
+
+
+
+/* Splitter Node. */
+MA_API ma_splitter_node_config ma_splitter_node_config_init(ma_uint32 channels)
+{
+    ma_splitter_node_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.nodeConfig     = ma_node_config_init();
+    config.channels       = channels;
+    config.outputBusCount = 2;
+
+    return config;
+}
+
+
+static void ma_splitter_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_uint32 iOutputBus;
+    ma_uint32 channels;
+
+    MA_ASSERT(pNodeBase != NULL);
+    MA_ASSERT(ma_node_get_input_bus_count(pNodeBase) == 1);
+
+    /* We don't need to consider the input frame count - it'll be the same as the output frame count and we process everything. */
+    (void)pFrameCountIn;
+
+    /* NOTE: This assumes the same number of channels for all inputs and outputs. This was checked in ma_splitter_node_init(). */
+    channels = ma_node_get_input_channels(pNodeBase, 0);
+
+    /* Splitting is just copying the first input bus and copying it over to each output bus. */
+    for (iOutputBus = 0; iOutputBus < ma_node_get_output_bus_count(pNodeBase); iOutputBus += 1) {
+        ma_copy_pcm_frames(ppFramesOut[iOutputBus], ppFramesIn[0], *pFrameCountOut, ma_format_f32, channels);
+    }
+}
+
+static ma_node_vtable g_ma_splitter_node_vtable =
+{
+    ma_splitter_node_process_pcm_frames,
+    NULL,                       /* onGetRequiredInputFrameCount */
+    1,                          /* 1 input bus. */
+    MA_NODE_BUS_COUNT_UNKNOWN,  /* The output bus count is specified on a per-node basis. */
+    0
+};
+
+MA_API ma_result ma_splitter_node_init(ma_node_graph* pNodeGraph, const ma_splitter_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_splitter_node* pSplitterNode)
+{
+    ma_result result;
+    ma_node_config baseConfig;
+    ma_uint32 pInputChannels[1];
+    ma_uint32 pOutputChannels[MA_MAX_NODE_BUS_COUNT];
+    ma_uint32 iOutputBus;
+
+    if (pSplitterNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pSplitterNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->outputBusCount > MA_MAX_NODE_BUS_COUNT) {
+        return MA_INVALID_ARGS; /* Too many output buses. */
+    }
+
+    /* Splitters require the same number of channels between inputs and outputs. */
+    pInputChannels[0]  = pConfig->channels;
+    for (iOutputBus = 0; iOutputBus < pConfig->outputBusCount; iOutputBus += 1) {
+        pOutputChannels[iOutputBus] = pConfig->channels;
+    }
+
+    baseConfig = pConfig->nodeConfig;
+    baseConfig.vtable = &g_ma_splitter_node_vtable;
+    baseConfig.pInputChannels  = pInputChannels;
+    baseConfig.pOutputChannels = pOutputChannels;
+    baseConfig.outputBusCount  = pConfig->outputBusCount;
+
+    result = ma_node_init(pNodeGraph, &baseConfig, pAllocationCallbacks, &pSplitterNode->base);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base node. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_splitter_node_uninit(ma_splitter_node* pSplitterNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_node_uninit(pSplitterNode, pAllocationCallbacks);
+}
+
+
+/*
+Biquad Node
+*/
+MA_API ma_biquad_node_config ma_biquad_node_config_init(ma_uint32 channels, float b0, float b1, float b2, float a0, float a1, float a2)
+{
+    ma_biquad_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.biquad = ma_biquad_config_init(ma_format_f32, channels, b0, b1, b2, a0, a1, a2);
+
+    return config;
+}
+
+static void ma_biquad_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_biquad_node* pLPFNode = (ma_biquad_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_biquad_process_pcm_frames(&pLPFNode->biquad, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_biquad_node_vtable =
+{
+    ma_biquad_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_biquad_node_init(ma_node_graph* pNodeGraph, const ma_biquad_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_biquad_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->biquad.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_biquad_init(&pConfig->biquad, pAllocationCallbacks, &pNode->biquad);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_biquad_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->biquad.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->biquad.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_biquad_node_reinit(const ma_biquad_config* pConfig, ma_biquad_node* pNode)
+{
+    ma_biquad_node* pLPFNode = (ma_biquad_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+
+    return ma_biquad_reinit(pConfig, &pLPFNode->biquad);
+}
+
+MA_API void ma_biquad_node_uninit(ma_biquad_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_biquad_node* pLPFNode = (ma_biquad_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_biquad_uninit(&pLPFNode->biquad, pAllocationCallbacks);
+}
+
+
+
+/*
+Low Pass Filter Node
+*/
+MA_API ma_lpf_node_config ma_lpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_lpf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.lpf = ma_lpf_config_init(ma_format_f32, channels, sampleRate, cutoffFrequency, order);
+
+    return config;
+}
+
+static void ma_lpf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_lpf_node* pLPFNode = (ma_lpf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_lpf_process_pcm_frames(&pLPFNode->lpf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_lpf_node_vtable =
+{
+    ma_lpf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_lpf_node_init(ma_node_graph* pNodeGraph, const ma_lpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->lpf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_lpf_init(&pConfig->lpf, pAllocationCallbacks, &pNode->lpf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_lpf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->lpf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->lpf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_lpf_node_reinit(const ma_lpf_config* pConfig, ma_lpf_node* pNode)
+{
+    ma_lpf_node* pLPFNode = (ma_lpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_lpf_reinit(pConfig, &pLPFNode->lpf);
+}
+
+MA_API void ma_lpf_node_uninit(ma_lpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_lpf_node* pLPFNode = (ma_lpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_lpf_uninit(&pLPFNode->lpf, pAllocationCallbacks);
+}
+
+
+
+/*
+High Pass Filter Node
+*/
+MA_API ma_hpf_node_config ma_hpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_hpf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.hpf = ma_hpf_config_init(ma_format_f32, channels, sampleRate, cutoffFrequency, order);
+
+    return config;
+}
+
+static void ma_hpf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_hpf_node* pHPFNode = (ma_hpf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_hpf_process_pcm_frames(&pHPFNode->hpf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_hpf_node_vtable =
+{
+    ma_hpf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_hpf_node_init(ma_node_graph* pNodeGraph, const ma_hpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->hpf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_hpf_init(&pConfig->hpf, pAllocationCallbacks, &pNode->hpf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_hpf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->hpf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->hpf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_hpf_node_reinit(const ma_hpf_config* pConfig, ma_hpf_node* pNode)
+{
+    ma_hpf_node* pHPFNode = (ma_hpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_hpf_reinit(pConfig, &pHPFNode->hpf);
+}
+
+MA_API void ma_hpf_node_uninit(ma_hpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_hpf_node* pHPFNode = (ma_hpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_hpf_uninit(&pHPFNode->hpf, pAllocationCallbacks);
+}
+
+
+
+
+/*
+Band Pass Filter Node
+*/
+MA_API ma_bpf_node_config ma_bpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_bpf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.bpf = ma_bpf_config_init(ma_format_f32, channels, sampleRate, cutoffFrequency, order);
+
+    return config;
+}
+
+static void ma_bpf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_bpf_node* pBPFNode = (ma_bpf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_bpf_process_pcm_frames(&pBPFNode->bpf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_bpf_node_vtable =
+{
+    ma_bpf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_bpf_node_init(ma_node_graph* pNodeGraph, const ma_bpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->bpf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_bpf_init(&pConfig->bpf, pAllocationCallbacks, &pNode->bpf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_bpf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->bpf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->bpf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_bpf_node_reinit(const ma_bpf_config* pConfig, ma_bpf_node* pNode)
+{
+    ma_bpf_node* pBPFNode = (ma_bpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_bpf_reinit(pConfig, &pBPFNode->bpf);
+}
+
+MA_API void ma_bpf_node_uninit(ma_bpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bpf_node* pBPFNode = (ma_bpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_bpf_uninit(&pBPFNode->bpf, pAllocationCallbacks);
+}
+
+
+
+/*
+Notching Filter Node
+*/
+MA_API ma_notch_node_config ma_notch_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double q, double frequency)
+{
+    ma_notch_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.notch = ma_notch2_config_init(ma_format_f32, channels, sampleRate, q, frequency);
+
+    return config;
+}
+
+static void ma_notch_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_notch_node* pBPFNode = (ma_notch_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_notch2_process_pcm_frames(&pBPFNode->notch, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_notch_node_vtable =
+{
+    ma_notch_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_notch_node_init(ma_node_graph* pNodeGraph, const ma_notch_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_notch_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->notch.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_notch2_init(&pConfig->notch, pAllocationCallbacks, &pNode->notch);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_notch_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->notch.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->notch.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_notch_node_reinit(const ma_notch_config* pConfig, ma_notch_node* pNode)
+{
+    ma_notch_node* pNotchNode = (ma_notch_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_notch2_reinit(pConfig, &pNotchNode->notch);
+}
+
+MA_API void ma_notch_node_uninit(ma_notch_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_notch_node* pNotchNode = (ma_notch_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_notch2_uninit(&pNotchNode->notch, pAllocationCallbacks);
+}
+
+
+
+/*
+Peaking Filter Node
+*/
+MA_API ma_peak_node_config ma_peak_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency)
+{
+    ma_peak_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.peak = ma_peak2_config_init(ma_format_f32, channels, sampleRate, gainDB, q, frequency);
+
+    return config;
+}
+
+static void ma_peak_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_peak_node* pBPFNode = (ma_peak_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_peak2_process_pcm_frames(&pBPFNode->peak, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_peak_node_vtable =
+{
+    ma_peak_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_peak_node_init(ma_node_graph* pNodeGraph, const ma_peak_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_peak_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->peak.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_peak2_init(&pConfig->peak, pAllocationCallbacks, &pNode->peak);
+    if (result != MA_SUCCESS) {
+        ma_node_uninit(pNode, pAllocationCallbacks);
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_peak_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->peak.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->peak.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_peak_node_reinit(const ma_peak_config* pConfig, ma_peak_node* pNode)
+{
+    ma_peak_node* pPeakNode = (ma_peak_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_peak2_reinit(pConfig, &pPeakNode->peak);
+}
+
+MA_API void ma_peak_node_uninit(ma_peak_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_peak_node* pPeakNode = (ma_peak_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_peak2_uninit(&pPeakNode->peak, pAllocationCallbacks);
+}
+
+
+
+/*
+Low Shelf Filter Node
+*/
+MA_API ma_loshelf_node_config ma_loshelf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency)
+{
+    ma_loshelf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.loshelf = ma_loshelf2_config_init(ma_format_f32, channels, sampleRate, gainDB, q, frequency);
+
+    return config;
+}
+
+static void ma_loshelf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_loshelf_node* pBPFNode = (ma_loshelf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_loshelf2_process_pcm_frames(&pBPFNode->loshelf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_loshelf_node_vtable =
+{
+    ma_loshelf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_loshelf_node_init(ma_node_graph* pNodeGraph, const ma_loshelf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_loshelf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->loshelf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_loshelf2_init(&pConfig->loshelf, pAllocationCallbacks, &pNode->loshelf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_loshelf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->loshelf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->loshelf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_loshelf_node_reinit(const ma_loshelf_config* pConfig, ma_loshelf_node* pNode)
+{
+    ma_loshelf_node* pLoshelfNode = (ma_loshelf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_loshelf2_reinit(pConfig, &pLoshelfNode->loshelf);
+}
+
+MA_API void ma_loshelf_node_uninit(ma_loshelf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_loshelf_node* pLoshelfNode = (ma_loshelf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_loshelf2_uninit(&pLoshelfNode->loshelf, pAllocationCallbacks);
+}
+
+
+
+/*
+High Shelf Filter Node
+*/
+MA_API ma_hishelf_node_config ma_hishelf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency)
+{
+    ma_hishelf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.hishelf = ma_hishelf2_config_init(ma_format_f32, channels, sampleRate, gainDB, q, frequency);
+
+    return config;
+}
+
+static void ma_hishelf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_hishelf_node* pBPFNode = (ma_hishelf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_hishelf2_process_pcm_frames(&pBPFNode->hishelf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_hishelf_node_vtable =
+{
+    ma_hishelf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_hishelf_node_init(ma_node_graph* pNodeGraph, const ma_hishelf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hishelf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->hishelf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_hishelf2_init(&pConfig->hishelf, pAllocationCallbacks, &pNode->hishelf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_hishelf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->hishelf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->hishelf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_hishelf_node_reinit(const ma_hishelf_config* pConfig, ma_hishelf_node* pNode)
+{
+    ma_hishelf_node* pHishelfNode = (ma_hishelf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_hishelf2_reinit(pConfig, &pHishelfNode->hishelf);
+}
+
+MA_API void ma_hishelf_node_uninit(ma_hishelf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_hishelf_node* pHishelfNode = (ma_hishelf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_hishelf2_uninit(&pHishelfNode->hishelf, pAllocationCallbacks);
+}
+
+
+
+
+MA_API ma_delay_node_config ma_delay_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 delayInFrames, float decay)
+{
+    ma_delay_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.delay = ma_delay_config_init(channels, sampleRate, delayInFrames, decay);
+
+    return config;
+}
+
+
+static void ma_delay_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_delay_node* pDelayNode = (ma_delay_node*)pNode;
+
+    (void)pFrameCountIn;
+
+    ma_delay_process_pcm_frames(&pDelayNode->delay, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_delay_node_vtable =
+{
+    ma_delay_node_process_pcm_frames,
+    NULL,
+    1,  /* 1 input channels. */
+    1,  /* 1 output channel. */
+    MA_NODE_FLAG_CONTINUOUS_PROCESSING  /* Delay requires continuous processing to ensure the tail get's processed. */
+};
+
+MA_API ma_result ma_delay_node_init(ma_node_graph* pNodeGraph, const ma_delay_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_delay_node* pDelayNode)
+{
+    ma_result result;
+    ma_node_config baseConfig;
+
+    if (pDelayNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDelayNode);
+
+    result = ma_delay_init(&pConfig->delay, pAllocationCallbacks, &pDelayNode->delay);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseConfig = pConfig->nodeConfig;
+    baseConfig.vtable          = &g_ma_delay_node_vtable;
+    baseConfig.pInputChannels  = &pConfig->delay.channels;
+    baseConfig.pOutputChannels = &pConfig->delay.channels;
+
+    result = ma_node_init(pNodeGraph, &baseConfig, pAllocationCallbacks, &pDelayNode->baseNode);
+    if (result != MA_SUCCESS) {
+        ma_delay_uninit(&pDelayNode->delay, pAllocationCallbacks);
+        return result;
+    }
+
+    return result;
+}
+
+MA_API void ma_delay_node_uninit(ma_delay_node* pDelayNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pDelayNode == NULL) {
+        return;
+    }
+
+    /* The base node is always uninitialized first. */
+    ma_node_uninit(pDelayNode, pAllocationCallbacks);
+    ma_delay_uninit(&pDelayNode->delay, pAllocationCallbacks);
+}
+
+MA_API void ma_delay_node_set_wet(ma_delay_node* pDelayNode, float value)
+{
+    if (pDelayNode == NULL) {
+        return;
+    }
+
+    ma_delay_set_wet(&pDelayNode->delay, value);
+}
+
+MA_API float ma_delay_node_get_wet(const ma_delay_node* pDelayNode)
+{
+    if (pDelayNode == NULL) {
+        return 0;
+    }
+
+    return ma_delay_get_wet(&pDelayNode->delay);
+}
+
+MA_API void ma_delay_node_set_dry(ma_delay_node* pDelayNode, float value)
+{
+    if (pDelayNode == NULL) {
+        return;
+    }
+
+    ma_delay_set_dry(&pDelayNode->delay, value);
+}
+
+MA_API float ma_delay_node_get_dry(const ma_delay_node* pDelayNode)
+{
+    if (pDelayNode == NULL) {
+        return 0;
+    }
+
+    return ma_delay_get_dry(&pDelayNode->delay);
+}
+
+MA_API void ma_delay_node_set_decay(ma_delay_node* pDelayNode, float value)
+{
+    if (pDelayNode == NULL) {
+        return;
+    }
+
+    ma_delay_set_decay(&pDelayNode->delay, value);
+}
+
+MA_API float ma_delay_node_get_decay(const ma_delay_node* pDelayNode)
+{
+    if (pDelayNode == NULL) {
+        return 0;
+    }
+
+    return ma_delay_get_decay(&pDelayNode->delay);
+}
+#endif  /* MA_NO_NODE_GRAPH */
+
+
+/* SECTION: miniaudio_engine.c */
+#if !defined(MA_NO_ENGINE) && !defined(MA_NO_NODE_GRAPH)
+/**************************************************************************************************************************************************************
+
+Engine
+
+**************************************************************************************************************************************************************/
+#define MA_SEEK_TARGET_NONE         (~(ma_uint64)0)
+
+
+static void ma_sound_set_at_end(ma_sound* pSound, ma_bool32 atEnd)
+{
+    MA_ASSERT(pSound != NULL);
+    ma_atomic_exchange_32(&pSound->atEnd, atEnd);
+
+    /* Fire any callbacks or events. */
+    if (atEnd) {
+        if (pSound->endCallback != NULL) {
+            pSound->endCallback(pSound->pEndCallbackUserData, pSound);
+        }
+    }
+}
+
+static ma_bool32 ma_sound_get_at_end(const ma_sound* pSound)
+{
+    MA_ASSERT(pSound != NULL);
+    return ma_atomic_load_32(&pSound->atEnd);
+}
+
+
+MA_API ma_engine_node_config ma_engine_node_config_init(ma_engine* pEngine, ma_engine_node_type type, ma_uint32 flags)
+{
+    ma_engine_node_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.pEngine                  = pEngine;
+    config.type                     = type;
+    config.isPitchDisabled          = (flags & MA_SOUND_FLAG_NO_PITCH) != 0;
+    config.isSpatializationDisabled = (flags & MA_SOUND_FLAG_NO_SPATIALIZATION) != 0;
+    config.monoExpansionMode        = pEngine->monoExpansionMode;
+
+    return config;
+}
+
+
+static void ma_engine_node_update_pitch_if_required(ma_engine_node* pEngineNode)
+{
+    ma_bool32 isUpdateRequired = MA_FALSE;
+    float newPitch;
+
+    MA_ASSERT(pEngineNode != NULL);
+
+    newPitch = ma_atomic_load_explicit_f32(&pEngineNode->pitch, ma_atomic_memory_order_acquire);
+
+    if (pEngineNode->oldPitch != newPitch) {
+        pEngineNode->oldPitch  = newPitch;
+        isUpdateRequired = MA_TRUE;
+    }
+
+    if (pEngineNode->oldDopplerPitch != pEngineNode->spatializer.dopplerPitch) {
+        pEngineNode->oldDopplerPitch  = pEngineNode->spatializer.dopplerPitch;
+        isUpdateRequired = MA_TRUE;
+    }
+
+    if (isUpdateRequired) {
+        float basePitch = (float)pEngineNode->sampleRate / ma_engine_get_sample_rate(pEngineNode->pEngine);
+        ma_linear_resampler_set_rate_ratio(&pEngineNode->resampler, basePitch * pEngineNode->oldPitch * pEngineNode->oldDopplerPitch);
+    }
+}
+
+static ma_bool32 ma_engine_node_is_pitching_enabled(const ma_engine_node* pEngineNode)
+{
+    MA_ASSERT(pEngineNode != NULL);
+
+    /* Don't try to be clever by skipping resampling in the pitch=1 case or else you'll glitch when moving away from 1. */
+    return !ma_atomic_load_explicit_32(&pEngineNode->isPitchDisabled, ma_atomic_memory_order_acquire);
+}
+
+static ma_bool32 ma_engine_node_is_spatialization_enabled(const ma_engine_node* pEngineNode)
+{
+    MA_ASSERT(pEngineNode != NULL);
+
+    return !ma_atomic_load_explicit_32(&pEngineNode->isSpatializationDisabled, ma_atomic_memory_order_acquire);
+}
+
+static ma_uint64 ma_engine_node_get_required_input_frame_count(const ma_engine_node* pEngineNode, ma_uint64 outputFrameCount)
+{
+    ma_uint64 inputFrameCount = 0;
+
+    if (ma_engine_node_is_pitching_enabled(pEngineNode)) {
+        ma_result result = ma_linear_resampler_get_required_input_frame_count(&pEngineNode->resampler, outputFrameCount, &inputFrameCount);
+        if (result != MA_SUCCESS) {
+            inputFrameCount = 0;
+        }
+    } else {
+        inputFrameCount = outputFrameCount;    /* No resampling, so 1:1. */
+    }
+
+    return inputFrameCount;
+}
+
+static ma_result ma_engine_node_set_volume(ma_engine_node* pEngineNode, float volume)
+{
+    if (pEngineNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_float_set(&pEngineNode->volume, volume);
+
+    /* If we're not smoothing we should bypass the volume gainer entirely. */
+    if (pEngineNode->volumeSmoothTimeInPCMFrames == 0) {
+        /* We should always have an active spatializer because it can be enabled and disabled dynamically. We can just use that for holding our volume. */
+        ma_spatializer_set_master_volume(&pEngineNode->spatializer, volume);
+    } else {
+        /* We're using volume smoothing, so apply the master volume to the gainer. */
+        ma_gainer_set_gain(&pEngineNode->volumeGainer, volume);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_engine_node_get_volume(const ma_engine_node* pEngineNode, float* pVolume)
+{
+    if (pVolume == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pVolume = 0.0f;
+
+    if (pEngineNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pVolume = ma_atomic_float_get((ma_atomic_float*)&pEngineNode->volume);
+
+    return MA_SUCCESS;
+}
+
+
+static void ma_engine_node_process_pcm_frames__general(ma_engine_node* pEngineNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_uint32 frameCountIn;
+    ma_uint32 frameCountOut;
+    ma_uint32 totalFramesProcessedIn;
+    ma_uint32 totalFramesProcessedOut;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_bool32 isPitchingEnabled;
+    ma_bool32 isFadingEnabled;
+    ma_bool32 isSpatializationEnabled;
+    ma_bool32 isPanningEnabled;
+    ma_bool32 isVolumeSmoothingEnabled;
+
+    frameCountIn  = *pFrameCountIn;
+    frameCountOut = *pFrameCountOut;
+
+    channelsIn  = ma_spatializer_get_input_channels(&pEngineNode->spatializer);
+    channelsOut = ma_spatializer_get_output_channels(&pEngineNode->spatializer);
+
+    totalFramesProcessedIn  = 0;
+    totalFramesProcessedOut = 0;
+
+    /* Update the fader if applicable. */
+    {
+        ma_uint64 fadeLengthInFrames = ma_atomic_uint64_get(&pEngineNode->fadeSettings.fadeLengthInFrames);
+        if (fadeLengthInFrames != ~(ma_uint64)0) {
+            float fadeVolumeBeg = ma_atomic_float_get(&pEngineNode->fadeSettings.volumeBeg);
+            float fadeVolumeEnd = ma_atomic_float_get(&pEngineNode->fadeSettings.volumeEnd);
+            ma_int64 fadeStartOffsetInFrames = (ma_int64)ma_atomic_uint64_get(&pEngineNode->fadeSettings.absoluteGlobalTimeInFrames);
+            if (fadeStartOffsetInFrames == (ma_int64)(~(ma_uint64)0)) {
+                fadeStartOffsetInFrames = 0;
+            } else {
+                fadeStartOffsetInFrames -= ma_engine_get_time_in_pcm_frames(pEngineNode->pEngine);
+            }
+
+            ma_fader_set_fade_ex(&pEngineNode->fader, fadeVolumeBeg, fadeVolumeEnd, fadeLengthInFrames, fadeStartOffsetInFrames);
+
+            /* Reset the fade length so we don't erroneously apply it again. */
+            ma_atomic_uint64_set(&pEngineNode->fadeSettings.fadeLengthInFrames, ~(ma_uint64)0);
+        }
+    }
+
+    isPitchingEnabled        = ma_engine_node_is_pitching_enabled(pEngineNode);
+    isFadingEnabled          = pEngineNode->fader.volumeBeg != 1 || pEngineNode->fader.volumeEnd != 1;
+    isSpatializationEnabled  = ma_engine_node_is_spatialization_enabled(pEngineNode);
+    isPanningEnabled         = pEngineNode->panner.pan != 0 && channelsOut != 1;
+    isVolumeSmoothingEnabled = pEngineNode->volumeSmoothTimeInPCMFrames > 0;
+
+    /* Keep going while we've still got data available for processing. */
+    while (totalFramesProcessedOut < frameCountOut) {
+        /*
+        We need to process in a specific order. We always do resampling first because it's likely
+        we're going to be increasing the channel count after spatialization. Also, I want to do
+        fading based on the output sample rate.
+
+        We'll first read into a buffer from the resampler. Then we'll do all processing that
+        operates on the on the input channel count. We'll then get the spatializer to output to
+        the output buffer and then do all effects from that point directly in the output buffer
+        in-place.
+
+        Note that we're always running the resampler if pitching is enabled, even when the pitch
+        is 1. If we try to be clever and skip resampling when the pitch is 1, we'll get a glitch
+        when we move away from 1, back to 1, and then away from 1 again. We'll want to implement
+        any pitch=1 optimizations in the resampler itself.
+
+        There's a small optimization here that we'll utilize since it might be a fairly common
+        case. When the input and output channel counts are the same, we'll read straight into the
+        output buffer from the resampler and do everything in-place.
+        */
+        const float* pRunningFramesIn;
+        float* pRunningFramesOut;
+        float* pWorkingBuffer;   /* This is the buffer that we'll be processing frames in. This is in input channels. */
+        float temp[MA_DATA_CONVERTER_STACK_BUFFER_SIZE / sizeof(float)];
+        ma_uint32 tempCapInFrames = ma_countof(temp) / channelsIn;
+        ma_uint32 framesAvailableIn;
+        ma_uint32 framesAvailableOut;
+        ma_uint32 framesJustProcessedIn;
+        ma_uint32 framesJustProcessedOut;
+        ma_bool32 isWorkingBufferValid = MA_FALSE;
+
+        framesAvailableIn  = frameCountIn  - totalFramesProcessedIn;
+        framesAvailableOut = frameCountOut - totalFramesProcessedOut;
+
+        pRunningFramesIn  = ma_offset_pcm_frames_const_ptr_f32(ppFramesIn[0], totalFramesProcessedIn, channelsIn);
+        pRunningFramesOut = ma_offset_pcm_frames_ptr_f32(ppFramesOut[0], totalFramesProcessedOut, channelsOut);
+
+        if (channelsIn == channelsOut) {
+            /* Fast path. Channel counts are the same. No need for an intermediary input buffer. */
+            pWorkingBuffer = pRunningFramesOut;
+        } else {
+            /* Slow path. Channel counts are different. Need to use an intermediary input buffer. */
+            pWorkingBuffer = temp;
+            if (framesAvailableOut > tempCapInFrames) {
+                framesAvailableOut = tempCapInFrames;
+            }
+        }
+
+        /* First is resampler. */
+        if (isPitchingEnabled) {
+            ma_uint64 resampleFrameCountIn  = framesAvailableIn;
+            ma_uint64 resampleFrameCountOut = framesAvailableOut;
+
+            ma_linear_resampler_process_pcm_frames(&pEngineNode->resampler, pRunningFramesIn, &resampleFrameCountIn, pWorkingBuffer, &resampleFrameCountOut);
+            isWorkingBufferValid = MA_TRUE;
+
+            framesJustProcessedIn  = (ma_uint32)resampleFrameCountIn;
+            framesJustProcessedOut = (ma_uint32)resampleFrameCountOut;
+        } else {
+            framesJustProcessedIn  = ma_min(framesAvailableIn, framesAvailableOut);
+            framesJustProcessedOut = framesJustProcessedIn; /* When no resampling is being performed, the number of output frames is the same as input frames. */
+        }
+
+        /* Fading. */
+        if (isFadingEnabled) {
+            if (isWorkingBufferValid) {
+                ma_fader_process_pcm_frames(&pEngineNode->fader, pWorkingBuffer, pWorkingBuffer, framesJustProcessedOut);   /* In-place processing. */
+            } else {
+                ma_fader_process_pcm_frames(&pEngineNode->fader, pWorkingBuffer, pRunningFramesIn, framesJustProcessedOut);
+                isWorkingBufferValid = MA_TRUE;
+            }
+        }
+
+        /*
+        If we're using smoothing, we won't be applying volume via the spatializer, but instead from a ma_gainer. In this case
+        we'll want to apply our volume now.
+        */
+        if (isVolumeSmoothingEnabled) {
+            if (isWorkingBufferValid) {
+                ma_gainer_process_pcm_frames(&pEngineNode->volumeGainer, pWorkingBuffer, pWorkingBuffer, framesJustProcessedOut);
+            } else {
+                ma_gainer_process_pcm_frames(&pEngineNode->volumeGainer, pWorkingBuffer, pRunningFramesIn, framesJustProcessedOut);
+                isWorkingBufferValid = MA_TRUE;
+            }
+        }
+
+        /*
+        If at this point we still haven't actually done anything with the working buffer we need
+        to just read straight from the input buffer.
+        */
+        if (isWorkingBufferValid == MA_FALSE) {
+            pWorkingBuffer = (float*)pRunningFramesIn;  /* Naughty const cast, but it's safe at this point because we won't ever be writing to it from this point out. */
+        }
+
+        /* Spatialization. */
+        if (isSpatializationEnabled) {
+            ma_uint32 iListener;
+
+            /*
+            When determining the listener to use, we first check to see if the sound is pinned to a
+            specific listener. If so, we use that. Otherwise we just use the closest listener.
+            */
+            if (pEngineNode->pinnedListenerIndex != MA_LISTENER_INDEX_CLOSEST && pEngineNode->pinnedListenerIndex < ma_engine_get_listener_count(pEngineNode->pEngine)) {
+                iListener = pEngineNode->pinnedListenerIndex;
+            } else {
+                ma_vec3f spatializerPosition = ma_spatializer_get_position(&pEngineNode->spatializer);
+                iListener = ma_engine_find_closest_listener(pEngineNode->pEngine, spatializerPosition.x, spatializerPosition.y, spatializerPosition.z);
+            }
+
+            ma_spatializer_process_pcm_frames(&pEngineNode->spatializer, &pEngineNode->pEngine->listeners[iListener], pRunningFramesOut, pWorkingBuffer, framesJustProcessedOut);
+        } else {
+            /* No spatialization, but we still need to do channel conversion and master volume. */
+            float volume;
+            ma_engine_node_get_volume(pEngineNode, &volume);    /* Should never fail. */
+
+            if (channelsIn == channelsOut) {
+                /* No channel conversion required. Just copy straight to the output buffer. */
+                if (isVolumeSmoothingEnabled) {
+                    /* Volume has already been applied. Just copy straight to the output buffer. */
+                    ma_copy_pcm_frames(pRunningFramesOut, pWorkingBuffer, framesJustProcessedOut * channelsOut, ma_format_f32, channelsOut);
+                } else {
+                    /* Volume has not been applied yet. Copy and apply volume in the same pass. */
+                    ma_copy_and_apply_volume_factor_f32(pRunningFramesOut, pWorkingBuffer, framesJustProcessedOut * channelsOut, volume);
+                }
+            } else {
+                /* Channel conversion required. TODO: Add support for channel maps here. */
+                ma_channel_map_apply_f32(pRunningFramesOut, NULL, channelsOut, pWorkingBuffer, NULL, channelsIn, framesJustProcessedOut, ma_channel_mix_mode_simple, pEngineNode->monoExpansionMode);
+
+                /* If we're using smoothing, the volume will have already been applied. */
+                if (!isVolumeSmoothingEnabled) {
+                    ma_apply_volume_factor_f32(pRunningFramesOut, framesJustProcessedOut * channelsOut, volume);
+                }
+            }
+        }
+
+        /* At this point we can guarantee that the output buffer contains valid data. We can process everything in place now. */
+
+        /* Panning. */
+        if (isPanningEnabled) {
+            ma_panner_process_pcm_frames(&pEngineNode->panner, pRunningFramesOut, pRunningFramesOut, framesJustProcessedOut);   /* In-place processing. */
+        }
+
+        /* We're done for this chunk. */
+        totalFramesProcessedIn  += framesJustProcessedIn;
+        totalFramesProcessedOut += framesJustProcessedOut;
+
+        /* If we didn't process any output frames this iteration it means we've either run out of input data, or run out of room in the output buffer. */
+        if (framesJustProcessedOut == 0) {
+            break;
+        }
+    }
+
+    /* At this point we're done processing. */
+    *pFrameCountIn  = totalFramesProcessedIn;
+    *pFrameCountOut = totalFramesProcessedOut;
+}
+
+static void ma_engine_node_process_pcm_frames__sound(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    /* For sounds, we need to first read from the data source. Then we need to apply the engine effects (pan, pitch, fades, etc.). */
+    ma_result result = MA_SUCCESS;
+    ma_sound* pSound = (ma_sound*)pNode;
+    ma_uint32 frameCount = *pFrameCountOut;
+    ma_uint32 totalFramesRead = 0;
+    ma_format dataSourceFormat;
+    ma_uint32 dataSourceChannels;
+    ma_uint8 temp[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+    ma_uint32 tempCapInFrames;
+    ma_uint64 seekTarget;
+
+    /* This is a data source node which means no input buses. */
+    (void)ppFramesIn;
+    (void)pFrameCountIn;
+
+    /* If we're marked at the end we need to stop the sound and do nothing. */
+    if (ma_sound_at_end(pSound)) {
+        ma_sound_stop(pSound);
+        *pFrameCountOut = 0;
+        return;
+    }
+
+    /* If we're seeking, do so now before reading. */
+    seekTarget = ma_atomic_load_64(&pSound->seekTarget);
+    if (seekTarget != MA_SEEK_TARGET_NONE) {
+        ma_data_source_seek_to_pcm_frame(pSound->pDataSource, seekTarget);
+
+        /* Any time-dependant effects need to have their times updated. */
+        ma_node_set_time(pSound, seekTarget);
+
+        ma_atomic_exchange_64(&pSound->seekTarget, MA_SEEK_TARGET_NONE);
+    }
+
+    /*
+    We want to update the pitch once. For sounds, this can be either at the start or at the end. If
+    we don't force this to only ever be updating once, we could end up in a situation where
+    retrieving the required input frame count ends up being different to what we actually retrieve.
+    What could happen is that the required input frame count is calculated, the pitch is update,
+    and then this processing function is called resulting in a different number of input frames
+    being processed. Do not call this in ma_engine_node_process_pcm_frames__general() or else
+    you'll hit the aforementioned bug.
+    */
+    ma_engine_node_update_pitch_if_required(&pSound->engineNode);
+
+    /*
+    For the convenience of the caller, we're doing to allow data sources to use non-floating-point formats and channel counts that differ
+    from the main engine.
+    */
+    result = ma_data_source_get_data_format(pSound->pDataSource, &dataSourceFormat, &dataSourceChannels, NULL, NULL, 0);
+    if (result == MA_SUCCESS) {
+        tempCapInFrames = sizeof(temp) / ma_get_bytes_per_frame(dataSourceFormat, dataSourceChannels);
+
+        /* Keep reading until we've read as much as was requested or we reach the end of the data source. */
+        while (totalFramesRead < frameCount) {
+            ma_uint32 framesRemaining = frameCount - totalFramesRead;
+            ma_uint32 framesToRead;
+            ma_uint64 framesJustRead;
+            ma_uint32 frameCountIn;
+            ma_uint32 frameCountOut;
+            const float* pRunningFramesIn;
+            float* pRunningFramesOut;
+
+            /*
+            The first thing we need to do is read into the temporary buffer. We can calculate exactly
+            how many input frames we'll need after resampling.
+            */
+            framesToRead = (ma_uint32)ma_engine_node_get_required_input_frame_count(&pSound->engineNode, framesRemaining);
+            if (framesToRead > tempCapInFrames) {
+                framesToRead = tempCapInFrames;
+            }
+
+            result = ma_data_source_read_pcm_frames(pSound->pDataSource, temp, framesToRead, &framesJustRead);
+
+            /* If we reached the end of the sound we'll want to mark it as at the end and stop it. This should never be returned for looping sounds. */
+            if (result == MA_AT_END) {
+                ma_sound_set_at_end(pSound, MA_TRUE);   /* This will be set to false in ma_sound_start(). */
+            }
+
+            pRunningFramesOut = ma_offset_pcm_frames_ptr_f32(ppFramesOut[0], totalFramesRead, ma_node_get_output_channels(pNode, 0));
+
+            frameCountIn = (ma_uint32)framesJustRead;
+            frameCountOut = framesRemaining;
+
+            /* Convert if necessary. */
+            if (dataSourceFormat == ma_format_f32) {
+                /* Fast path. No data conversion necessary. */
+                pRunningFramesIn = (float*)temp;
+                ma_engine_node_process_pcm_frames__general(&pSound->engineNode, &pRunningFramesIn, &frameCountIn, &pRunningFramesOut, &frameCountOut);
+            } else {
+                /* Slow path. Need to do sample format conversion to f32. If we give the f32 buffer the same count as the first temp buffer, we're guaranteed it'll be large enough. */
+                float tempf32[MA_DATA_CONVERTER_STACK_BUFFER_SIZE]; /* Do not do `MA_DATA_CONVERTER_STACK_BUFFER_SIZE/sizeof(float)` here like we've done in other places. */
+                ma_convert_pcm_frames_format(tempf32, ma_format_f32, temp, dataSourceFormat, framesJustRead, dataSourceChannels, ma_dither_mode_none);
+
+                /* Now that we have our samples in f32 format we can process like normal. */
+                pRunningFramesIn = tempf32;
+                ma_engine_node_process_pcm_frames__general(&pSound->engineNode, &pRunningFramesIn, &frameCountIn, &pRunningFramesOut, &frameCountOut);
+            }
+
+            /* We should have processed all of our input frames since we calculated the required number of input frames at the top. */
+            MA_ASSERT(frameCountIn == framesJustRead);
+            totalFramesRead += (ma_uint32)frameCountOut;   /* Safe cast. */
+
+            if (result != MA_SUCCESS || ma_sound_at_end(pSound)) {
+                break;  /* Might have reached the end. */
+            }
+        }
+    }
+
+    *pFrameCountOut = totalFramesRead;
+}
+
+static void ma_engine_node_process_pcm_frames__group(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    /*
+    Make sure the pitch is updated before trying to read anything. It's important that this is done
+    only once and not in ma_engine_node_process_pcm_frames__general(). The reason for this is that
+    ma_engine_node_process_pcm_frames__general() will call ma_engine_node_get_required_input_frame_count(),
+    and if another thread modifies the pitch just after that call it can result in a glitch due to
+    the input rate changing.
+    */
+    ma_engine_node_update_pitch_if_required((ma_engine_node*)pNode);
+
+    /* For groups, the input data has already been read and we just need to apply the effect. */
+    ma_engine_node_process_pcm_frames__general((ma_engine_node*)pNode, ppFramesIn, pFrameCountIn, ppFramesOut, pFrameCountOut);
+}
+
+static ma_result ma_engine_node_get_required_input_frame_count__group(ma_node* pNode, ma_uint32 outputFrameCount, ma_uint32* pInputFrameCount)
+{
+    ma_uint64 inputFrameCount;
+
+    MA_ASSERT(pInputFrameCount != NULL);
+
+    /* Our pitch will affect this calculation. We need to update it. */
+    ma_engine_node_update_pitch_if_required((ma_engine_node*)pNode);
+
+    inputFrameCount = ma_engine_node_get_required_input_frame_count((ma_engine_node*)pNode, outputFrameCount);
+    if (inputFrameCount > 0xFFFFFFFF) {
+        inputFrameCount = 0xFFFFFFFF;    /* Will never happen because miniaudio will only ever process in relatively small chunks. */
+    }
+
+    *pInputFrameCount = (ma_uint32)inputFrameCount;
+
+    return MA_SUCCESS;
+}
+
+
+static ma_node_vtable g_ma_engine_node_vtable__sound =
+{
+    ma_engine_node_process_pcm_frames__sound,
+    NULL,   /* onGetRequiredInputFrameCount */
+    0,      /* Sounds are data source nodes which means they have zero inputs (their input is drawn from the data source itself). */
+    1,      /* Sounds have one output bus. */
+    0       /* Default flags. */
+};
+
+static ma_node_vtable g_ma_engine_node_vtable__group =
+{
+    ma_engine_node_process_pcm_frames__group,
+    ma_engine_node_get_required_input_frame_count__group,
+    1,      /* Groups have one input bus. */
+    1,      /* Groups have one output bus. */
+    MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES /* The engine node does resampling so should let miniaudio know about it. */
+};
+
+
+
+static ma_node_config ma_engine_node_base_node_config_init(const ma_engine_node_config* pConfig)
+{
+    ma_node_config baseNodeConfig;
+
+    if (pConfig->type == ma_engine_node_type_sound) {
+        /* Sound. */
+        baseNodeConfig = ma_node_config_init();
+        baseNodeConfig.vtable       = &g_ma_engine_node_vtable__sound;
+        baseNodeConfig.initialState = ma_node_state_stopped;    /* Sounds are stopped by default. */
+    } else {
+        /* Group. */
+        baseNodeConfig = ma_node_config_init();
+        baseNodeConfig.vtable       = &g_ma_engine_node_vtable__group;
+        baseNodeConfig.initialState = ma_node_state_started;    /* Groups are started by default. */
+    }
+
+    return baseNodeConfig;
+}
+
+static ma_spatializer_config ma_engine_node_spatializer_config_init(const ma_node_config* pBaseNodeConfig)
+{
+    return ma_spatializer_config_init(pBaseNodeConfig->pInputChannels[0], pBaseNodeConfig->pOutputChannels[0]);
+}
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t baseNodeOffset;
+    size_t resamplerOffset;
+    size_t spatializerOffset;
+    size_t gainerOffset;
+} ma_engine_node_heap_layout;
+
+static ma_result ma_engine_node_get_heap_layout(const ma_engine_node_config* pConfig, ma_engine_node_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    size_t tempHeapSize;
+    ma_node_config baseNodeConfig;
+    ma_linear_resampler_config resamplerConfig;
+    ma_spatializer_config spatializerConfig;
+    ma_gainer_config gainerConfig;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel defaultStereoChannelMap[2] = {MA_CHANNEL_SIDE_LEFT, MA_CHANNEL_SIDE_RIGHT};  /* <-- Consistent with the default channel map of a stereo listener. Means channel conversion can run on a fast path. */
+
+    MA_ASSERT(pHeapLayout);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->pEngine == NULL) {
+        return MA_INVALID_ARGS; /* An engine must be specified. */
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    channelsIn  = (pConfig->channelsIn  != 0) ? pConfig->channelsIn  : ma_engine_get_channels(pConfig->pEngine);
+    channelsOut = (pConfig->channelsOut != 0) ? pConfig->channelsOut : ma_engine_get_channels(pConfig->pEngine);
+
+
+    /* Base node. */
+    baseNodeConfig = ma_engine_node_base_node_config_init(pConfig);
+    baseNodeConfig.pInputChannels  = &channelsIn;
+    baseNodeConfig.pOutputChannels = &channelsOut;
+
+    result = ma_node_get_heap_size(ma_engine_get_node_graph(pConfig->pEngine), &baseNodeConfig, &tempHeapSize);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap for the base node. */
+    }
+
+    pHeapLayout->baseNodeOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(tempHeapSize);
+
+
+    /* Resmapler. */
+    resamplerConfig = ma_linear_resampler_config_init(ma_format_f32, channelsIn, 1, 1); /* Input and output sample rates don't affect the calculation of the heap size. */
+    resamplerConfig.lpfOrder = 0;
+
+    result = ma_linear_resampler_get_heap_size(&resamplerConfig, &tempHeapSize);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap for the resampler. */
+    }
+
+    pHeapLayout->resamplerOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(tempHeapSize);
+
+
+    /* Spatializer. */
+    spatializerConfig = ma_engine_node_spatializer_config_init(&baseNodeConfig);
+
+    if (spatializerConfig.channelsIn == 2) {
+        spatializerConfig.pChannelMapIn = defaultStereoChannelMap;
+    }
+
+    result = ma_spatializer_get_heap_size(&spatializerConfig, &tempHeapSize);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap for the spatializer. */
+    }
+
+    pHeapLayout->spatializerOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(tempHeapSize);
+
+
+    /* Gainer. Will not be used if we are not using smoothing. */
+    if (pConfig->volumeSmoothTimeInPCMFrames > 0) {
+        gainerConfig = ma_gainer_config_init(channelsIn, pConfig->volumeSmoothTimeInPCMFrames);
+
+        result = ma_gainer_get_heap_size(&gainerConfig, &tempHeapSize);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->gainerOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(tempHeapSize);
+    }
+
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_engine_node_get_heap_size(const ma_engine_node_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_engine_node_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_engine_node_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_engine_node_init_preallocated(const ma_engine_node_config* pConfig, void* pHeap, ma_engine_node* pEngineNode)
+{
+    ma_result result;
+    ma_engine_node_heap_layout heapLayout;
+    ma_node_config baseNodeConfig;
+    ma_linear_resampler_config resamplerConfig;
+    ma_fader_config faderConfig;
+    ma_spatializer_config spatializerConfig;
+    ma_panner_config pannerConfig;
+    ma_gainer_config gainerConfig;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel defaultStereoChannelMap[2] = {MA_CHANNEL_SIDE_LEFT, MA_CHANNEL_SIDE_RIGHT};  /* <-- Consistent with the default channel map of a stereo listener. Means channel conversion can run on a fast path. */
+
+    if (pEngineNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pEngineNode);
+
+    result = ma_engine_node_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pConfig->pinnedListenerIndex != MA_LISTENER_INDEX_CLOSEST && pConfig->pinnedListenerIndex >= ma_engine_get_listener_count(pConfig->pEngine)) {
+        return MA_INVALID_ARGS; /* Invalid listener. */
+    }
+
+    pEngineNode->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pEngineNode->pEngine                     = pConfig->pEngine;
+    pEngineNode->sampleRate                  = (pConfig->sampleRate > 0) ? pConfig->sampleRate : ma_engine_get_sample_rate(pEngineNode->pEngine);
+    pEngineNode->volumeSmoothTimeInPCMFrames = pConfig->volumeSmoothTimeInPCMFrames;
+    pEngineNode->monoExpansionMode           = pConfig->monoExpansionMode;
+    ma_atomic_float_set(&pEngineNode->volume, 1);
+    pEngineNode->pitch                       = 1;
+    pEngineNode->oldPitch                    = 1;
+    pEngineNode->oldDopplerPitch             = 1;
+    pEngineNode->isPitchDisabled             = pConfig->isPitchDisabled;
+    pEngineNode->isSpatializationDisabled    = pConfig->isSpatializationDisabled;
+    pEngineNode->pinnedListenerIndex         = pConfig->pinnedListenerIndex;
+    ma_atomic_float_set(&pEngineNode->fadeSettings.volumeBeg, 1);
+    ma_atomic_float_set(&pEngineNode->fadeSettings.volumeEnd, 1);
+    ma_atomic_uint64_set(&pEngineNode->fadeSettings.fadeLengthInFrames, (~(ma_uint64)0));
+    ma_atomic_uint64_set(&pEngineNode->fadeSettings.absoluteGlobalTimeInFrames, (~(ma_uint64)0));   /* <-- Indicates that the fade should start immediately. */
+
+    channelsIn  = (pConfig->channelsIn  != 0) ? pConfig->channelsIn  : ma_engine_get_channels(pConfig->pEngine);
+    channelsOut = (pConfig->channelsOut != 0) ? pConfig->channelsOut : ma_engine_get_channels(pConfig->pEngine);
+
+    /*
+    If the sample rate of the sound is different to the engine, make sure pitching is enabled so that the resampler
+    is activated. Not doing this will result in the sound not being resampled if MA_SOUND_FLAG_NO_PITCH is used.
+    */
+    if (pEngineNode->sampleRate != ma_engine_get_sample_rate(pEngineNode->pEngine)) {
+        pEngineNode->isPitchDisabled = MA_FALSE;
+    }
+
+
+    /* Base node. */
+    baseNodeConfig = ma_engine_node_base_node_config_init(pConfig);
+    baseNodeConfig.pInputChannels  = &channelsIn;
+    baseNodeConfig.pOutputChannels = &channelsOut;
+
+    result = ma_node_init_preallocated(&pConfig->pEngine->nodeGraph, &baseNodeConfig, ma_offset_ptr(pHeap, heapLayout.baseNodeOffset), &pEngineNode->baseNode);
+    if (result != MA_SUCCESS) {
+        goto error0;
+    }
+
+
+    /*
+    We can now initialize the effects we need in order to implement the engine node. There's a
+    defined order of operations here, mainly centered around when we convert our channels from the
+    data source's native channel count to the engine's channel count. As a rule, we want to do as
+    much computation as possible before spatialization because there's a chance that will increase
+    the channel count, thereby increasing the amount of work needing to be done to process.
+    */
+
+    /* We'll always do resampling first. */
+    resamplerConfig = ma_linear_resampler_config_init(ma_format_f32, baseNodeConfig.pInputChannels[0], pEngineNode->sampleRate, ma_engine_get_sample_rate(pEngineNode->pEngine));
+    resamplerConfig.lpfOrder = 0;    /* <-- Need to disable low-pass filtering for pitch shifting for now because there's cases where the biquads are becoming unstable. Need to figure out a better fix for this. */
+
+    result = ma_linear_resampler_init_preallocated(&resamplerConfig, ma_offset_ptr(pHeap, heapLayout.resamplerOffset), &pEngineNode->resampler);
+    if (result != MA_SUCCESS) {
+        goto error1;
+    }
+
+
+    /* After resampling will come the fader. */
+    faderConfig = ma_fader_config_init(ma_format_f32, baseNodeConfig.pInputChannels[0], ma_engine_get_sample_rate(pEngineNode->pEngine));
+
+    result = ma_fader_init(&faderConfig, &pEngineNode->fader);
+    if (result != MA_SUCCESS) {
+        goto error2;
+    }
+
+
+    /*
+    Spatialization comes next. We spatialize based on the node's output channel count. It's up the caller to
+    ensure channels counts link up correctly in the node graph.
+    */
+    spatializerConfig = ma_engine_node_spatializer_config_init(&baseNodeConfig);
+    spatializerConfig.gainSmoothTimeInFrames = pEngineNode->pEngine->gainSmoothTimeInFrames;
+
+    if (spatializerConfig.channelsIn == 2) {
+        spatializerConfig.pChannelMapIn = defaultStereoChannelMap;
+    }
+
+    result = ma_spatializer_init_preallocated(&spatializerConfig, ma_offset_ptr(pHeap, heapLayout.spatializerOffset), &pEngineNode->spatializer);
+    if (result != MA_SUCCESS) {
+        goto error2;
+    }
+
+
+    /*
+    After spatialization comes panning. We need to do this after spatialization because otherwise we wouldn't
+    be able to pan mono sounds.
+    */
+    pannerConfig = ma_panner_config_init(ma_format_f32, baseNodeConfig.pOutputChannels[0]);
+
+    result = ma_panner_init(&pannerConfig, &pEngineNode->panner);
+    if (result != MA_SUCCESS) {
+        goto error3;
+    }
+
+
+    /* We'll need a gainer for smoothing out volume changes if we have a non-zero smooth time. We apply this before converting to the output channel count. */
+    if (pConfig->volumeSmoothTimeInPCMFrames > 0) {
+        gainerConfig = ma_gainer_config_init(channelsIn, pConfig->volumeSmoothTimeInPCMFrames);
+
+        result = ma_gainer_init_preallocated(&gainerConfig, ma_offset_ptr(pHeap, heapLayout.gainerOffset), &pEngineNode->volumeGainer);
+        if (result != MA_SUCCESS) {
+            goto error3;
+        }
+    }
+
+
+    return MA_SUCCESS;
+
+    /* No need for allocation callbacks here because we use a preallocated heap. */
+error3: ma_spatializer_uninit(&pEngineNode->spatializer, NULL);
+error2: ma_linear_resampler_uninit(&pEngineNode->resampler, NULL);
+error1: ma_node_uninit(&pEngineNode->baseNode, NULL);
+error0: return result;
+}
+
+MA_API ma_result ma_engine_node_init(const ma_engine_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_engine_node* pEngineNode)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_engine_node_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_engine_node_init_preallocated(pConfig, pHeap, pEngineNode);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pEngineNode->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_engine_node_uninit(ma_engine_node* pEngineNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    /*
+    The base node always needs to be uninitialized first to ensure it's detached from the graph completely before we
+    destroy anything that might be in the middle of being used by the processing function.
+    */
+    ma_node_uninit(&pEngineNode->baseNode, pAllocationCallbacks);
+
+    /* Now that the node has been uninitialized we can safely uninitialize the rest. */
+    if (pEngineNode->volumeSmoothTimeInPCMFrames > 0) {
+        ma_gainer_uninit(&pEngineNode->volumeGainer, pAllocationCallbacks);
+    }
+
+    ma_spatializer_uninit(&pEngineNode->spatializer, pAllocationCallbacks);
+    ma_linear_resampler_uninit(&pEngineNode->resampler, pAllocationCallbacks);
+
+    /* Free the heap last. */
+    if (pEngineNode->_ownsHeap) {
+        ma_free(pEngineNode->_pHeap, pAllocationCallbacks);
+    }
+}
+
+
+MA_API ma_sound_config ma_sound_config_init(void)
+{
+    return ma_sound_config_init_2(NULL);
+}
+
+MA_API ma_sound_config ma_sound_config_init_2(ma_engine* pEngine)
+{
+    ma_sound_config config;
+
+    MA_ZERO_OBJECT(&config);
+
+    if (pEngine != NULL) {
+        config.monoExpansionMode = pEngine->monoExpansionMode;
+    } else {
+        config.monoExpansionMode = ma_mono_expansion_mode_default;
+    }
+
+    config.rangeEndInPCMFrames     = ~((ma_uint64)0);
+    config.loopPointEndInPCMFrames = ~((ma_uint64)0);
+
+    return config;
+}
+
+MA_API ma_sound_group_config ma_sound_group_config_init(void)
+{
+    return ma_sound_group_config_init_2(NULL);
+}
+
+MA_API ma_sound_group_config ma_sound_group_config_init_2(ma_engine* pEngine)
+{
+    ma_sound_group_config config;
+
+    MA_ZERO_OBJECT(&config);
+
+    if (pEngine != NULL) {
+        config.monoExpansionMode = pEngine->monoExpansionMode;
+    } else {
+        config.monoExpansionMode = ma_mono_expansion_mode_default;
+    }
+
+    return config;
+}
+
+
+MA_API ma_engine_config ma_engine_config_init(void)
+{
+    ma_engine_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.listenerCount     = 1;   /* Always want at least one listener. */
+    config.monoExpansionMode = ma_mono_expansion_mode_default;
+
+    return config;
+}
+
+
+#if !defined(MA_NO_DEVICE_IO)
+static void ma_engine_data_callback_internal(ma_device* pDevice, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    ma_engine* pEngine = (ma_engine*)pDevice->pUserData;
+
+    (void)pFramesIn;
+
+    /*
+    Experiment: Try processing a resource manager job if we're on the Emscripten build.
+
+    This serves two purposes:
+
+        1) It ensures jobs are actually processed at some point since we cannot guarantee that the
+           caller is doing the right thing and calling ma_resource_manager_process_next_job(); and
+
+        2) It's an attempt at working around an issue where processing jobs on the Emscripten main
+           loop doesn't work as well as it should. When trying to load sounds without the `DECODE`
+           flag or with the `ASYNC` flag, the sound data is just not able to be loaded in time
+           before the callback is processed. I think it's got something to do with the single-
+           threaded nature of Web, but I'm not entirely sure.
+    */
+    #if !defined(MA_NO_RESOURCE_MANAGER) && defined(MA_EMSCRIPTEN)
+    {
+        if (pEngine->pResourceManager != NULL) {
+            if ((pEngine->pResourceManager->config.flags & MA_RESOURCE_MANAGER_FLAG_NO_THREADING) != 0) {
+                ma_resource_manager_process_next_job(pEngine->pResourceManager);
+            }
+        }
+    }
+    #endif
+
+    ma_engine_read_pcm_frames(pEngine, pFramesOut, frameCount, NULL);
+}
+
+static ma_uint32 ma_device__get_processing_size_in_frames(ma_device* pDevice)
+{
+    /*
+    The processing size is the period size. The device can have a fixed sized processing size, or
+    it can be decided by the backend in which case it can be variable.
+    */
+    if (pDevice->playback.intermediaryBufferCap > 0) {
+        /* Using a fixed sized processing callback. */
+        return pDevice->playback.intermediaryBufferCap;
+    } else {
+        /* Not using a fixed sized processing callback. Need to estimate the processing size based on the backend. */
+        return pDevice->playback.internalPeriodSizeInFrames;
+    }
+}
+#endif
+
+MA_API ma_result ma_engine_init(const ma_engine_config* pConfig, ma_engine* pEngine)
+{
+    ma_result result;
+    ma_node_graph_config nodeGraphConfig;
+    ma_engine_config engineConfig;
+    ma_spatializer_listener_config listenerConfig;
+    ma_uint32 iListener;
+
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pEngine);
+
+    /* The config is allowed to be NULL in which case we use defaults for everything. */
+    if (pConfig != NULL) {
+        engineConfig = *pConfig;
+    } else {
+        engineConfig = ma_engine_config_init();
+    }
+
+    pEngine->monoExpansionMode = engineConfig.monoExpansionMode;
+    pEngine->defaultVolumeSmoothTimeInPCMFrames = engineConfig.defaultVolumeSmoothTimeInPCMFrames;
+    pEngine->onProcess = engineConfig.onProcess;
+    pEngine->pProcessUserData = engineConfig.pProcessUserData;
+    ma_allocation_callbacks_init_copy(&pEngine->allocationCallbacks, &engineConfig.allocationCallbacks);
+
+    #if !defined(MA_NO_RESOURCE_MANAGER)
+    {
+        pEngine->pResourceManager = engineConfig.pResourceManager;
+    }
+    #endif
+
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        pEngine->pDevice = engineConfig.pDevice;
+
+        /* If we don't have a device, we need one. */
+        if (pEngine->pDevice == NULL && engineConfig.noDevice == MA_FALSE) {
+            ma_device_config deviceConfig;
+
+            pEngine->pDevice = (ma_device*)ma_malloc(sizeof(*pEngine->pDevice), &pEngine->allocationCallbacks);
+            if (pEngine->pDevice == NULL) {
+                return MA_OUT_OF_MEMORY;
+            }
+
+            deviceConfig = ma_device_config_init(ma_device_type_playback);
+            deviceConfig.playback.pDeviceID        = engineConfig.pPlaybackDeviceID;
+            deviceConfig.playback.format           = ma_format_f32;
+            deviceConfig.playback.channels         = engineConfig.channels;
+            deviceConfig.sampleRate                = engineConfig.sampleRate;
+            deviceConfig.dataCallback              = (engineConfig.dataCallback != NULL) ? engineConfig.dataCallback : ma_engine_data_callback_internal;
+            deviceConfig.pUserData                 = pEngine;
+            deviceConfig.notificationCallback      = engineConfig.notificationCallback;
+            deviceConfig.periodSizeInFrames        = engineConfig.periodSizeInFrames;
+            deviceConfig.periodSizeInMilliseconds  = engineConfig.periodSizeInMilliseconds;
+            deviceConfig.noPreSilencedOutputBuffer = MA_TRUE;    /* We'll always be outputting to every frame in the callback so there's no need for a pre-silenced buffer. */
+            deviceConfig.noClip                    = MA_TRUE;    /* The engine will do clipping itself. */
+
+            if (engineConfig.pContext == NULL) {
+                ma_context_config contextConfig = ma_context_config_init();
+                contextConfig.allocationCallbacks = pEngine->allocationCallbacks;
+                contextConfig.pLog = engineConfig.pLog;
+
+                /* If the engine config does not specify a log, use the resource manager's if we have one. */
+                #ifndef MA_NO_RESOURCE_MANAGER
+                {
+                    if (contextConfig.pLog == NULL && engineConfig.pResourceManager != NULL) {
+                        contextConfig.pLog = ma_resource_manager_get_log(engineConfig.pResourceManager);
+                    }
+                }
+                #endif
+
+                result = ma_device_init_ex(NULL, 0, &contextConfig, &deviceConfig, pEngine->pDevice);
+            } else {
+                result = ma_device_init(engineConfig.pContext, &deviceConfig, pEngine->pDevice);
+            }
+
+            if (result != MA_SUCCESS) {
+                ma_free(pEngine->pDevice, &pEngine->allocationCallbacks);
+                pEngine->pDevice = NULL;
+                return result;
+            }
+
+            pEngine->ownsDevice = MA_TRUE;
+        }
+
+        /* Update the channel count and sample rate of the engine config so we can reference it below. */
+        if (pEngine->pDevice != NULL) {
+            engineConfig.channels   = pEngine->pDevice->playback.channels;
+            engineConfig.sampleRate = pEngine->pDevice->sampleRate;
+
+            /*
+            The processing size used by the engine is determined by engineConfig.periodSizeInFrames. We want
+            to make this equal to what the device is using for it's period size. If we don't do that, it's
+            possible that the node graph will split it's processing into multiple passes which can introduce
+            glitching.
+            */
+            engineConfig.periodSizeInFrames = ma_device__get_processing_size_in_frames(pEngine->pDevice);
+        }
+    }
+    #endif
+
+    if (engineConfig.channels == 0 || engineConfig.sampleRate == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pEngine->sampleRate = engineConfig.sampleRate;
+
+    /* The engine always uses either the log that was passed into the config, or the context's log is available. */
+    if (engineConfig.pLog != NULL) {
+        pEngine->pLog = engineConfig.pLog;
+    } else {
+        #if !defined(MA_NO_DEVICE_IO)
+        {
+            pEngine->pLog = ma_device_get_log(pEngine->pDevice);
+        }
+        #else
+        {
+            pEngine->pLog = NULL;
+        }
+        #endif
+    }
+
+
+    /* The engine is a node graph. This needs to be initialized after we have the device so we can determine the channel count. */
+    nodeGraphConfig = ma_node_graph_config_init(engineConfig.channels);
+    nodeGraphConfig.processingSizeInFrames = engineConfig.periodSizeInFrames;
+    nodeGraphConfig.preMixStackSizeInBytes = engineConfig.preMixStackSizeInBytes;
+
+    result = ma_node_graph_init(&nodeGraphConfig, &pEngine->allocationCallbacks, &pEngine->nodeGraph);
+    if (result != MA_SUCCESS) {
+        goto on_error_1;
+    }
+
+
+    /* We need at least one listener. */
+    if (engineConfig.listenerCount == 0) {
+        engineConfig.listenerCount = 1;
+    }
+
+    if (engineConfig.listenerCount > MA_ENGINE_MAX_LISTENERS) {
+        result = MA_INVALID_ARGS;   /* Too many listeners. */
+        goto on_error_1;
+    }
+
+    for (iListener = 0; iListener < engineConfig.listenerCount; iListener += 1) {
+        listenerConfig = ma_spatializer_listener_config_init(ma_node_graph_get_channels(&pEngine->nodeGraph));
+
+        /*
+        If we're using a device, use the device's channel map for the listener. Otherwise just use
+        miniaudio's default channel map.
+        */
+        #if !defined(MA_NO_DEVICE_IO)
+        {
+            if (pEngine->pDevice != NULL) {
+                /*
+                Temporarily disabled. There is a subtle bug here where front-left and front-right
+                will be used by the device's channel map, but this is not what we want to use for
+                spatialization. Instead we want to use side-left and side-right. I need to figure
+                out a better solution for this. For now, disabling the use of device channel maps.
+                */
+                /*listenerConfig.pChannelMapOut = pEngine->pDevice->playback.channelMap;*/
+            }
+        }
+        #endif
+
+        result = ma_spatializer_listener_init(&listenerConfig, &pEngine->allocationCallbacks, &pEngine->listeners[iListener]);  /* TODO: Change this to a pre-allocated heap. */
+        if (result != MA_SUCCESS) {
+            goto on_error_2;
+        }
+
+        pEngine->listenerCount += 1;
+    }
+
+
+    /* Gain smoothing for spatialized sounds. */
+    pEngine->gainSmoothTimeInFrames = engineConfig.gainSmoothTimeInFrames;
+    if (pEngine->gainSmoothTimeInFrames == 0) {
+        ma_uint32 gainSmoothTimeInMilliseconds = engineConfig.gainSmoothTimeInMilliseconds;
+        if (gainSmoothTimeInMilliseconds == 0) {
+            gainSmoothTimeInMilliseconds = 8;
+        }
+
+        pEngine->gainSmoothTimeInFrames = (gainSmoothTimeInMilliseconds * ma_engine_get_sample_rate(pEngine)) / 1000;  /* 8ms by default. */
+    }
+
+
+    /* We need a resource manager. */
+    #ifndef MA_NO_RESOURCE_MANAGER
+    {
+        if (pEngine->pResourceManager == NULL) {
+            ma_resource_manager_config resourceManagerConfig;
+
+            pEngine->pResourceManager = (ma_resource_manager*)ma_malloc(sizeof(*pEngine->pResourceManager), &pEngine->allocationCallbacks);
+            if (pEngine->pResourceManager == NULL) {
+                result = MA_OUT_OF_MEMORY;
+                goto on_error_2;
+            }
+
+            resourceManagerConfig = ma_resource_manager_config_init();
+            resourceManagerConfig.pLog              = pEngine->pLog;    /* Always use the engine's log for internally-managed resource managers. */
+            resourceManagerConfig.decodedFormat     = ma_format_f32;
+            resourceManagerConfig.decodedChannels   = 0;  /* Leave the decoded channel count as 0 so we can get good spatialization. */
+            resourceManagerConfig.decodedSampleRate = ma_engine_get_sample_rate(pEngine);
+            ma_allocation_callbacks_init_copy(&resourceManagerConfig.allocationCallbacks, &pEngine->allocationCallbacks);
+            resourceManagerConfig.pVFS              = engineConfig.pResourceManagerVFS;
+
+            /* The Emscripten build cannot use threads unless it's targeting pthreads. */
+            #if defined(MA_EMSCRIPTEN) && !defined(__EMSCRIPTEN_PTHREADS__)
+            {
+                resourceManagerConfig.jobThreadCount = 0;
+                resourceManagerConfig.flags |= MA_RESOURCE_MANAGER_FLAG_NO_THREADING;
+            }
+            #endif
+
+            result = ma_resource_manager_init(&resourceManagerConfig, pEngine->pResourceManager);
+            if (result != MA_SUCCESS) {
+                goto on_error_3;
+            }
+
+            pEngine->ownsResourceManager = MA_TRUE;
+        }
+    }
+    #endif
+
+    /* Setup some stuff for inlined sounds. That is sounds played with ma_engine_play_sound(). */
+    pEngine->inlinedSoundLock  = 0;
+    pEngine->pInlinedSoundHead = NULL;
+
+    /* Start the engine if required. This should always be the last step. */
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (engineConfig.noAutoStart == MA_FALSE && pEngine->pDevice != NULL) {
+            result = ma_engine_start(pEngine);
+            if (result != MA_SUCCESS) {
+                goto on_error_4;    /* Failed to start the engine. */
+            }
+        }
+    }
+    #endif
+
+    return MA_SUCCESS;
+
+#if !defined(MA_NO_DEVICE_IO)
+on_error_4:
+#endif
+#if !defined(MA_NO_RESOURCE_MANAGER)
+on_error_3:
+    if (pEngine->ownsResourceManager) {
+        ma_free(pEngine->pResourceManager, &pEngine->allocationCallbacks);
+    }
+#endif  /* MA_NO_RESOURCE_MANAGER */
+on_error_2:
+    for (iListener = 0; iListener < pEngine->listenerCount; iListener += 1) {
+        ma_spatializer_listener_uninit(&pEngine->listeners[iListener], &pEngine->allocationCallbacks);
+    }
+
+    ma_node_graph_uninit(&pEngine->nodeGraph, &pEngine->allocationCallbacks);
+on_error_1:
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (pEngine->ownsDevice) {
+            ma_device_uninit(pEngine->pDevice);
+            ma_free(pEngine->pDevice, &pEngine->allocationCallbacks);
+        }
+    }
+    #endif
+
+    return result;
+}
+
+MA_API void ma_engine_uninit(ma_engine* pEngine)
+{
+    ma_uint32 iListener;
+
+    if (pEngine == NULL) {
+        return;
+    }
+
+    /* The device must be uninitialized before the node graph to ensure the audio thread doesn't try accessing it. */
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (pEngine->ownsDevice) {
+            ma_device_uninit(pEngine->pDevice);
+            ma_free(pEngine->pDevice, &pEngine->allocationCallbacks);
+        } else {
+            if (pEngine->pDevice != NULL) {
+                ma_device_stop(pEngine->pDevice);
+            }
+        }
+    }
+    #endif
+
+    /*
+    All inlined sounds need to be deleted. I'm going to use a lock here just to future proof in case
+    I want to do some kind of garbage collection later on.
+    */
+    ma_spinlock_lock(&pEngine->inlinedSoundLock);
+    {
+        for (;;) {
+            ma_sound_inlined* pSoundToDelete = pEngine->pInlinedSoundHead;
+            if (pSoundToDelete == NULL) {
+                break;  /* Done. */
+            }
+
+            pEngine->pInlinedSoundHead = pSoundToDelete->pNext;
+
+            ma_sound_uninit(&pSoundToDelete->sound);
+            ma_free(pSoundToDelete, &pEngine->allocationCallbacks);
+        }
+    }
+    ma_spinlock_unlock(&pEngine->inlinedSoundLock);
+
+    for (iListener = 0; iListener < pEngine->listenerCount; iListener += 1) {
+        ma_spatializer_listener_uninit(&pEngine->listeners[iListener], &pEngine->allocationCallbacks);
+    }
+
+    /* Make sure the node graph is uninitialized after the audio thread has been shutdown to prevent accessing of the node graph after being uninitialized. */
+    ma_node_graph_uninit(&pEngine->nodeGraph, &pEngine->allocationCallbacks);
+
+    /* Uninitialize the resource manager last to ensure we don't have a thread still trying to access it. */
+#ifndef MA_NO_RESOURCE_MANAGER
+    if (pEngine->ownsResourceManager) {
+        ma_resource_manager_uninit(pEngine->pResourceManager);
+        ma_free(pEngine->pResourceManager, &pEngine->allocationCallbacks);
+    }
+#endif
+}
+
+MA_API ma_result ma_engine_read_pcm_frames(ma_engine* pEngine, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result;
+    ma_uint64 framesRead = 0;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    result = ma_node_graph_read_pcm_frames(&pEngine->nodeGraph, pFramesOut, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    if (pEngine->onProcess) {
+        pEngine->onProcess(pEngine->pProcessUserData, (float*)pFramesOut, framesRead);  /* Safe cast to float* because the engine always works on floating point samples. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_node_graph* ma_engine_get_node_graph(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return NULL;
+    }
+
+    return &pEngine->nodeGraph;
+}
+
+#if !defined(MA_NO_RESOURCE_MANAGER)
+MA_API ma_resource_manager* ma_engine_get_resource_manager(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return NULL;
+    }
+
+    #if !defined(MA_NO_RESOURCE_MANAGER)
+    {
+        return pEngine->pResourceManager;
+    }
+    #else
+    {
+        return NULL;
+    }
+    #endif
+}
+#endif
+
+MA_API ma_device* ma_engine_get_device(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return NULL;
+    }
+
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        return pEngine->pDevice;
+    }
+    #else
+    {
+        return NULL;
+    }
+    #endif
+}
+
+MA_API ma_log* ma_engine_get_log(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return NULL;
+    }
+
+    if (pEngine->pLog != NULL) {
+        return pEngine->pLog;
+    } else {
+        #if !defined(MA_NO_DEVICE_IO)
+        {
+            return ma_device_get_log(ma_engine_get_device(pEngine));
+        }
+        #else
+        {
+            return NULL;
+        }
+        #endif
+    }
+}
+
+MA_API ma_node* ma_engine_get_endpoint(ma_engine* pEngine)
+{
+    return ma_node_graph_get_endpoint(&pEngine->nodeGraph);
+}
+
+MA_API ma_uint64 ma_engine_get_time_in_pcm_frames(const ma_engine* pEngine)
+{
+    return ma_node_graph_get_time(&pEngine->nodeGraph);
+}
+
+MA_API ma_uint64 ma_engine_get_time_in_milliseconds(const ma_engine* pEngine)
+{
+    return ma_engine_get_time_in_pcm_frames(pEngine) * 1000 / ma_engine_get_sample_rate(pEngine);
+}
+
+MA_API ma_result ma_engine_set_time_in_pcm_frames(ma_engine* pEngine, ma_uint64 globalTime)
+{
+    return ma_node_graph_set_time(&pEngine->nodeGraph, globalTime);
+}
+
+MA_API ma_result ma_engine_set_time_in_milliseconds(ma_engine* pEngine, ma_uint64 globalTime)
+{
+    return ma_engine_set_time_in_pcm_frames(pEngine, globalTime * ma_engine_get_sample_rate(pEngine) / 1000);
+}
+
+MA_API ma_uint64 ma_engine_get_time(const ma_engine* pEngine)
+{
+    return ma_engine_get_time_in_pcm_frames(pEngine);
+}
+
+MA_API ma_result ma_engine_set_time(ma_engine* pEngine, ma_uint64 globalTime)
+{
+    return ma_engine_set_time_in_pcm_frames(pEngine, globalTime);
+}
+
+MA_API ma_uint32 ma_engine_get_channels(const ma_engine* pEngine)
+{
+    return ma_node_graph_get_channels(&pEngine->nodeGraph);
+}
+
+MA_API ma_uint32 ma_engine_get_sample_rate(const ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return 0;
+    }
+
+    return pEngine->sampleRate;
+}
+
+
+MA_API ma_result ma_engine_start(ma_engine* pEngine)
+{
+    ma_result result;
+
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (pEngine->pDevice != NULL) {
+            result = ma_device_start(pEngine->pDevice);
+        } else {
+            result = MA_INVALID_OPERATION;  /* The engine is running without a device which means there's no real notion of "starting" the engine. */
+        }
+    }
+    #else
+    {
+        result = MA_INVALID_OPERATION;  /* Device IO is disabled, so there's no real notion of "starting" the engine. */
+    }
+    #endif
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_engine_stop(ma_engine* pEngine)
+{
+    ma_result result;
+
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (pEngine->pDevice != NULL) {
+            result = ma_device_stop(pEngine->pDevice);
+        } else {
+            result = MA_INVALID_OPERATION;  /* The engine is running without a device which means there's no real notion of "stopping" the engine. */
+        }
+    }
+    #else
+    {
+        result = MA_INVALID_OPERATION;  /* Device IO is disabled, so there's no real notion of "stopping" the engine. */
+    }
+    #endif
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_engine_set_volume(ma_engine* pEngine, float volume)
+{
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_node_set_output_bus_volume(ma_node_graph_get_endpoint(&pEngine->nodeGraph), 0, volume);
+}
+
+MA_API float ma_engine_get_volume(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return 0;
+    }
+
+    return ma_node_get_output_bus_volume(ma_node_graph_get_endpoint(&pEngine->nodeGraph), 0);
+}
+
+MA_API ma_result ma_engine_set_gain_db(ma_engine* pEngine, float gainDB)
+{
+    return ma_engine_set_volume(pEngine, ma_volume_db_to_linear(gainDB));
+}
+
+MA_API float ma_engine_get_gain_db(ma_engine* pEngine)
+{
+    return ma_volume_linear_to_db(ma_engine_get_volume(pEngine));
+}
+
+
+MA_API ma_uint32 ma_engine_get_listener_count(const ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return 0;
+    }
+
+    return pEngine->listenerCount;
+}
+
+MA_API ma_uint32 ma_engine_find_closest_listener(const ma_engine* pEngine, float absolutePosX, float absolutePosY, float absolutePosZ)
+{
+    ma_uint32 iListener;
+    ma_uint32 iListenerClosest;
+    float closestLen2 = MA_FLT_MAX;
+
+    if (pEngine == NULL || pEngine->listenerCount == 1) {
+        return 0;
+    }
+
+    iListenerClosest = 0;
+    for (iListener = 0; iListener < pEngine->listenerCount; iListener += 1) {
+        if (ma_engine_listener_is_enabled(pEngine, iListener)) {
+            float len2 = ma_vec3f_len2(ma_vec3f_sub(ma_spatializer_listener_get_position(&pEngine->listeners[iListener]), ma_vec3f_init_3f(absolutePosX, absolutePosY, absolutePosZ)));
+            if (closestLen2 > len2) {
+                closestLen2 = len2;
+                iListenerClosest = iListener;
+            }
+        }
+    }
+
+    MA_ASSERT(iListenerClosest < 255);
+    return iListenerClosest;
+}
+
+MA_API void ma_engine_listener_set_position(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_position(&pEngine->listeners[listenerIndex], x, y, z);
+}
+
+MA_API ma_vec3f ma_engine_listener_get_position(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_listener_get_position(&pEngine->listeners[listenerIndex]);
+}
+
+MA_API void ma_engine_listener_set_direction(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_direction(&pEngine->listeners[listenerIndex], x, y, z);
+}
+
+MA_API ma_vec3f ma_engine_listener_get_direction(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    return ma_spatializer_listener_get_direction(&pEngine->listeners[listenerIndex]);
+}
+
+MA_API void ma_engine_listener_set_velocity(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_velocity(&pEngine->listeners[listenerIndex], x, y, z);
+}
+
+MA_API ma_vec3f ma_engine_listener_get_velocity(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_listener_get_velocity(&pEngine->listeners[listenerIndex]);
+}
+
+MA_API void ma_engine_listener_set_cone(ma_engine* pEngine, ma_uint32 listenerIndex, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_cone(&pEngine->listeners[listenerIndex], innerAngleInRadians, outerAngleInRadians, outerGain);
+}
+
+MA_API void ma_engine_listener_get_cone(const ma_engine* pEngine, ma_uint32 listenerIndex, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    if (pInnerAngleInRadians != NULL) {
+        *pInnerAngleInRadians = 0;
+    }
+
+    if (pOuterAngleInRadians != NULL) {
+        *pOuterAngleInRadians = 0;
+    }
+
+    if (pOuterGain != NULL) {
+        *pOuterGain = 0;
+    }
+
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_get_cone(&pEngine->listeners[listenerIndex], pInnerAngleInRadians, pOuterAngleInRadians, pOuterGain);
+}
+
+MA_API void ma_engine_listener_set_world_up(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_world_up(&pEngine->listeners[listenerIndex], x, y, z);
+}
+
+MA_API ma_vec3f ma_engine_listener_get_world_up(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return ma_vec3f_init_3f(0, 1, 0);
+    }
+
+    return ma_spatializer_listener_get_world_up(&pEngine->listeners[listenerIndex]);
+}
+
+MA_API void ma_engine_listener_set_enabled(ma_engine* pEngine, ma_uint32 listenerIndex, ma_bool32 isEnabled)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_enabled(&pEngine->listeners[listenerIndex], isEnabled);
+}
+
+MA_API ma_bool32 ma_engine_listener_is_enabled(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return MA_FALSE;
+    }
+
+    return ma_spatializer_listener_is_enabled(&pEngine->listeners[listenerIndex]);
+}
+
+
+#ifndef MA_NO_RESOURCE_MANAGER
+MA_API ma_result ma_engine_play_sound_ex(ma_engine* pEngine, const char* pFilePath, ma_node* pNode, ma_uint32 nodeInputBusIndex)
+{
+    ma_result result = MA_SUCCESS;
+    ma_sound_inlined* pSound = NULL;
+    ma_sound_inlined* pNextSound = NULL;
+
+    if (pEngine == NULL || pFilePath == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Attach to the endpoint node if nothing is specified. */
+    if (pNode == NULL) {
+        pNode = ma_node_graph_get_endpoint(&pEngine->nodeGraph);
+        nodeInputBusIndex = 0;
+    }
+
+    /*
+    We want to check if we can recycle an already-allocated inlined sound. Since this is just a
+    helper I'm not *too* concerned about performance here and I'm happy to use a lock to keep
+    the implementation simple. Maybe this can be optimized later if there's enough demand, but
+    if this function is being used it probably means the caller doesn't really care too much.
+
+    What we do is check the atEnd flag. When this is true, we can recycle the sound. Otherwise
+    we just keep iterating. If we reach the end without finding a sound to recycle we just
+    allocate a new one. This doesn't scale well for a massive number of sounds being played
+    simultaneously as we don't ever actually free the sound objects. Some kind of garbage
+    collection routine might be valuable for this which I'll think about.
+    */
+    ma_spinlock_lock(&pEngine->inlinedSoundLock);
+    {
+        ma_uint32 soundFlags = 0;
+
+        for (pNextSound = pEngine->pInlinedSoundHead; pNextSound != NULL; pNextSound = pNextSound->pNext) {
+            if (ma_sound_at_end(&pNextSound->sound)) {
+                /*
+                The sound is at the end which means it's available for recycling. All we need to do
+                is uninitialize it and reinitialize it. All we're doing is recycling memory.
+                */
+                pSound = pNextSound;
+                ma_atomic_fetch_sub_32(&pEngine->inlinedSoundCount, 1);
+                break;
+            }
+        }
+
+        if (pSound != NULL) {
+            /*
+            We actually want to detach the sound from the list here. The reason is because we want the sound
+            to be in a consistent state at the non-recycled case to simplify the logic below.
+            */
+            if (pEngine->pInlinedSoundHead == pSound) {
+                pEngine->pInlinedSoundHead =  pSound->pNext;
+            }
+
+            if (pSound->pPrev != NULL) {
+                pSound->pPrev->pNext = pSound->pNext;
+            }
+            if (pSound->pNext != NULL) {
+                pSound->pNext->pPrev = pSound->pPrev;
+            }
+
+            /* Now the previous sound needs to be uninitialized. */
+            ma_sound_uninit(&pNextSound->sound);
+        } else {
+            /* No sound available for recycling. Allocate one now. */
+            pSound = (ma_sound_inlined*)ma_malloc(sizeof(*pSound), &pEngine->allocationCallbacks);
+        }
+
+        if (pSound != NULL) {   /* Safety check for the allocation above. */
+            /*
+            At this point we should have memory allocated for the inlined sound. We just need
+            to initialize it like a normal sound now.
+            */
+            soundFlags |= MA_SOUND_FLAG_ASYNC;                 /* For inlined sounds we don't want to be sitting around waiting for stuff to load so force an async load. */
+            soundFlags |= MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT; /* We want specific control over where the sound is attached in the graph. We'll attach it manually just before playing the sound. */
+            soundFlags |= MA_SOUND_FLAG_NO_PITCH;              /* Pitching isn't usable with inlined sounds, so disable it to save on speed. */
+            soundFlags |= MA_SOUND_FLAG_NO_SPATIALIZATION;     /* Not currently doing spatialization with inlined sounds, but this might actually change later. For now disable spatialization. Will be removed if we ever add support for spatialization here. */
+
+            result = ma_sound_init_from_file(pEngine, pFilePath, soundFlags, NULL, NULL, &pSound->sound);
+            if (result == MA_SUCCESS) {
+                /* Now attach the sound to the graph. */
+                result = ma_node_attach_output_bus(pSound, 0, pNode, nodeInputBusIndex);
+                if (result == MA_SUCCESS) {
+                    /* At this point the sound should be loaded and we can go ahead and add it to the list. The new item becomes the new head. */
+                    pSound->pNext = pEngine->pInlinedSoundHead;
+                    pSound->pPrev = NULL;
+
+                    pEngine->pInlinedSoundHead = pSound;    /* <-- This is what attaches the sound to the list. */
+                    if (pSound->pNext != NULL) {
+                        pSound->pNext->pPrev = pSound;
+                    }
+                } else {
+                    ma_free(pSound, &pEngine->allocationCallbacks);
+                }
+            } else {
+                ma_free(pSound, &pEngine->allocationCallbacks);
+            }
+        } else {
+            result = MA_OUT_OF_MEMORY;
+        }
+    }
+    ma_spinlock_unlock(&pEngine->inlinedSoundLock);
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Finally we can start playing the sound. */
+    result = ma_sound_start(&pSound->sound);
+    if (result != MA_SUCCESS) {
+        /* Failed to start the sound. We need to mark it for recycling and return an error. */
+        ma_atomic_exchange_32(&pSound->sound.atEnd, MA_TRUE);
+        return result;
+    }
+
+    ma_atomic_fetch_add_32(&pEngine->inlinedSoundCount, 1);
+    return result;
+}
+
+MA_API ma_result ma_engine_play_sound(ma_engine* pEngine, const char* pFilePath, ma_sound_group* pGroup)
+{
+    return ma_engine_play_sound_ex(pEngine, pFilePath, pGroup, 0);
+}
+#endif
+
+
+static ma_result ma_sound_preinit(ma_engine* pEngine, ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pSound);
+    pSound->seekTarget = MA_SEEK_TARGET_NONE;
+
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_sound_init_from_data_source_internal(ma_engine* pEngine, const ma_sound_config* pConfig, ma_sound* pSound)
+{
+    ma_result result;
+    ma_engine_node_config engineNodeConfig;
+    ma_engine_node_type type;   /* Will be set to ma_engine_node_type_group if no data source is specified. */
+
+    /* Do not clear pSound to zero here - that's done at a higher level with ma_sound_preinit(). */
+    MA_ASSERT(pEngine != NULL);
+    MA_ASSERT(pSound  != NULL);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pSound->pDataSource = pConfig->pDataSource;
+
+    if (pConfig->pDataSource != NULL) {
+        type = ma_engine_node_type_sound;
+    } else {
+        type = ma_engine_node_type_group;
+    }
+
+    /*
+    Sounds are engine nodes. Before we can initialize this we need to determine the channel count.
+    If we can't do this we need to abort. It's up to the caller to ensure they're using a data
+    source that provides this information upfront.
+    */
+    engineNodeConfig = ma_engine_node_config_init(pEngine, type, pConfig->flags);
+    engineNodeConfig.channelsIn                  = pConfig->channelsIn;
+    engineNodeConfig.channelsOut                 = pConfig->channelsOut;
+    engineNodeConfig.volumeSmoothTimeInPCMFrames = pConfig->volumeSmoothTimeInPCMFrames;
+    engineNodeConfig.monoExpansionMode           = pConfig->monoExpansionMode;
+
+    if (engineNodeConfig.volumeSmoothTimeInPCMFrames == 0) {
+        engineNodeConfig.volumeSmoothTimeInPCMFrames = pEngine->defaultVolumeSmoothTimeInPCMFrames;
+    }
+
+    /* If we're loading from a data source the input channel count needs to be the data source's native channel count. */
+    if (pConfig->pDataSource != NULL) {
+        result = ma_data_source_get_data_format(pConfig->pDataSource, NULL, &engineNodeConfig.channelsIn, &engineNodeConfig.sampleRate, NULL, 0);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to retrieve the channel count. */
+        }
+
+        if (engineNodeConfig.channelsIn == 0) {
+            return MA_INVALID_OPERATION;    /* Invalid channel count. */
+        }
+
+        if (engineNodeConfig.channelsOut == MA_SOUND_SOURCE_CHANNEL_COUNT) {
+            engineNodeConfig.channelsOut = engineNodeConfig.channelsIn;
+        }
+    }
+
+
+    /* Getting here means we should have a valid channel count and we can initialize the engine node. */
+    result = ma_engine_node_init(&engineNodeConfig, &pEngine->allocationCallbacks, &pSound->engineNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* If no attachment is specified, attach the sound straight to the endpoint. */
+    if (pConfig->pInitialAttachment == NULL) {
+        /* No group. Attach straight to the endpoint by default, unless the caller has requested that it not. */
+        if ((pConfig->flags & MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT) == 0) {
+            result = ma_node_attach_output_bus(pSound, 0, ma_node_graph_get_endpoint(&pEngine->nodeGraph), 0);
+        }
+    } else {
+        /* An attachment is specified. Attach to it by default. The sound has only a single output bus, and the config will specify which input bus to attach to. */
+        result = ma_node_attach_output_bus(pSound, 0, pConfig->pInitialAttachment, pConfig->initialAttachmentInputBusIndex);
+    }
+
+    if (result != MA_SUCCESS) {
+        ma_engine_node_uninit(&pSound->engineNode, &pEngine->allocationCallbacks);
+        return result;
+    }
+
+
+    /* Apply initial range and looping state to the data source if applicable. */
+    if (pConfig->rangeBegInPCMFrames != 0 || pConfig->rangeEndInPCMFrames != ~((ma_uint64)0)) {
+        ma_data_source_set_range_in_pcm_frames(ma_sound_get_data_source(pSound), pConfig->rangeBegInPCMFrames, pConfig->rangeEndInPCMFrames);
+    }
+
+    if (pConfig->loopPointBegInPCMFrames != 0 || pConfig->loopPointEndInPCMFrames != ~((ma_uint64)0)) {
+        ma_data_source_set_loop_point_in_pcm_frames(ma_sound_get_data_source(pSound), pConfig->loopPointBegInPCMFrames, pConfig->loopPointEndInPCMFrames);
+    }
+
+    ma_sound_set_looping(pSound, pConfig->isLooping || ((pConfig->flags & MA_SOUND_FLAG_LOOPING) != 0));
+
+    return MA_SUCCESS;
+}
+
+#ifndef MA_NO_RESOURCE_MANAGER
+MA_API ma_result ma_sound_init_from_file_internal(ma_engine* pEngine, const ma_sound_config* pConfig, ma_sound* pSound)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 flags;
+    ma_sound_config config;
+    ma_resource_manager_pipeline_notifications notifications;
+
+    /*
+    The engine requires knowledge of the channel count of the underlying data source before it can
+    initialize the sound. Therefore, we need to make the resource manager wait until initialization
+    of the underlying data source to be initialized so we can get access to the channel count. To
+    do this, the MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT is forced.
+
+    Because we're initializing the data source before the sound, there's a chance the notification
+    will get triggered before this function returns. This is OK, so long as the caller is aware of
+    it and can avoid accessing the sound from within the notification.
+    */
+    flags = pConfig->flags | MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT;
+    if (pConfig->isLooping) {
+        flags |= MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING;
+    }
+
+    pSound->pResourceManagerDataSource = (ma_resource_manager_data_source*)ma_malloc(sizeof(*pSound->pResourceManagerDataSource), &pEngine->allocationCallbacks);
+    if (pSound->pResourceManagerDataSource == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    /* Removed in 0.12. Set pDoneFence on the notifications. */
+    notifications = pConfig->initNotifications;
+    if (pConfig->pDoneFence != NULL && notifications.done.pFence == NULL) {
+        notifications.done.pFence = pConfig->pDoneFence;
+    }
+
+    /*
+    We must wrap everything around the fence if one was specified. This ensures ma_fence_wait() does
+    not return prematurely before the sound has finished initializing.
+    */
+    if (notifications.done.pFence) { ma_fence_acquire(notifications.done.pFence); }
+    {
+        ma_resource_manager_data_source_config resourceManagerDataSourceConfig = ma_resource_manager_data_source_config_init();
+        resourceManagerDataSourceConfig.pFilePath                   = pConfig->pFilePath;
+        resourceManagerDataSourceConfig.pFilePathW                  = pConfig->pFilePathW;
+        resourceManagerDataSourceConfig.flags                       = flags;
+        resourceManagerDataSourceConfig.pNotifications              = &notifications;
+        resourceManagerDataSourceConfig.initialSeekPointInPCMFrames = pConfig->initialSeekPointInPCMFrames;
+        resourceManagerDataSourceConfig.rangeBegInPCMFrames         = pConfig->rangeBegInPCMFrames;
+        resourceManagerDataSourceConfig.rangeEndInPCMFrames         = pConfig->rangeEndInPCMFrames;
+        resourceManagerDataSourceConfig.loopPointBegInPCMFrames     = pConfig->loopPointBegInPCMFrames;
+        resourceManagerDataSourceConfig.loopPointEndInPCMFrames     = pConfig->loopPointEndInPCMFrames;
+        resourceManagerDataSourceConfig.isLooping                   = (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING) != 0;
+
+        result = ma_resource_manager_data_source_init_ex(pEngine->pResourceManager, &resourceManagerDataSourceConfig, pSound->pResourceManagerDataSource);
+        if (result != MA_SUCCESS) {
+            ma_free(pSound->pResourceManagerDataSource, &pEngine->allocationCallbacks);
+            goto done;
+        }
+
+        pSound->ownsDataSource = MA_TRUE;   /* <-- Important. Not setting this will result in the resource manager data source never getting uninitialized. */
+
+        /* We need to use a slightly customized version of the config so we'll need to make a copy. */
+        config = *pConfig;
+        config.pFilePath   = NULL;
+        config.pFilePathW  = NULL;
+        config.pDataSource = pSound->pResourceManagerDataSource;
+
+        result = ma_sound_init_from_data_source_internal(pEngine, &config, pSound);
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_data_source_uninit(pSound->pResourceManagerDataSource);
+            ma_free(pSound->pResourceManagerDataSource, &pEngine->allocationCallbacks);
+            MA_ZERO_OBJECT(pSound);
+            goto done;
+        }
+    }
+done:
+    if (notifications.done.pFence) { ma_fence_release(notifications.done.pFence); }
+    return result;
+}
+
+MA_API ma_result ma_sound_init_from_file(ma_engine* pEngine, const char* pFilePath, ma_uint32 flags, ma_sound_group* pGroup, ma_fence* pDoneFence, ma_sound* pSound)
+{
+    ma_sound_config config;
+
+    if (pFilePath == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    config = ma_sound_config_init_2(pEngine);
+    config.pFilePath          = pFilePath;
+    config.flags              = flags;
+    config.pInitialAttachment = pGroup;
+    config.pDoneFence         = pDoneFence;
+
+    return ma_sound_init_ex(pEngine, &config, pSound);
+}
+
+MA_API ma_result ma_sound_init_from_file_w(ma_engine* pEngine, const wchar_t* pFilePath, ma_uint32 flags, ma_sound_group* pGroup, ma_fence* pDoneFence, ma_sound* pSound)
+{
+    ma_sound_config config;
+
+    if (pFilePath == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    config = ma_sound_config_init_2(pEngine);
+    config.pFilePathW         = pFilePath;
+    config.flags              = flags;
+    config.pInitialAttachment = pGroup;
+    config.pDoneFence         = pDoneFence;
+
+    return ma_sound_init_ex(pEngine, &config, pSound);
+}
+
+MA_API ma_result ma_sound_init_copy(ma_engine* pEngine, const ma_sound* pExistingSound, ma_uint32 flags, ma_sound_group* pGroup, ma_sound* pSound)
+{
+    ma_result result;
+    ma_sound_config config;
+
+    result = ma_sound_preinit(pEngine, pSound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pExistingSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Cloning only works for data buffers (not streams) that are loaded from the resource manager. */
+    if (pExistingSound->pResourceManagerDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    We need to make a clone of the data source. If the data source is not a data buffer (i.e. a stream)
+    this will fail.
+    */
+    pSound->pResourceManagerDataSource = (ma_resource_manager_data_source*)ma_malloc(sizeof(*pSound->pResourceManagerDataSource), &pEngine->allocationCallbacks);
+    if (pSound->pResourceManagerDataSource == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_resource_manager_data_source_init_copy(pEngine->pResourceManager, pExistingSound->pResourceManagerDataSource, pSound->pResourceManagerDataSource);
+    if (result != MA_SUCCESS) {
+        ma_free(pSound->pResourceManagerDataSource, &pEngine->allocationCallbacks);
+        return result;
+    }
+
+    config = ma_sound_config_init_2(pEngine);
+    config.pDataSource                 = pSound->pResourceManagerDataSource;
+    config.flags                       = flags;
+    config.pInitialAttachment          = pGroup;
+    config.monoExpansionMode           = pExistingSound->engineNode.monoExpansionMode;
+    config.volumeSmoothTimeInPCMFrames = pExistingSound->engineNode.volumeSmoothTimeInPCMFrames;
+
+    result = ma_sound_init_from_data_source_internal(pEngine, &config, pSound);
+    if (result != MA_SUCCESS) {
+        ma_resource_manager_data_source_uninit(pSound->pResourceManagerDataSource);
+        ma_free(pSound->pResourceManagerDataSource, &pEngine->allocationCallbacks);
+        MA_ZERO_OBJECT(pSound);
+        return result;
+    }
+
+    /* Make sure the sound is marked as the owner of the data source or else it will never get uninitialized. */
+    pSound->ownsDataSource = MA_TRUE;
+
+    return MA_SUCCESS;
+}
+#endif
+
+MA_API ma_result ma_sound_init_from_data_source(ma_engine* pEngine, ma_data_source* pDataSource, ma_uint32 flags, ma_sound_group* pGroup, ma_sound* pSound)
+{
+    ma_sound_config config = ma_sound_config_init_2(pEngine);
+    config.pDataSource        = pDataSource;
+    config.flags              = flags;
+    config.pInitialAttachment = pGroup;
+    return ma_sound_init_ex(pEngine, &config, pSound);
+}
+
+MA_API ma_result ma_sound_init_ex(ma_engine* pEngine, const ma_sound_config* pConfig, ma_sound* pSound)
+{
+    ma_result result;
+
+    result = ma_sound_preinit(pEngine, pSound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pSound->endCallback          = pConfig->endCallback;
+    pSound->pEndCallbackUserData = pConfig->pEndCallbackUserData;
+
+    /* We need to load the sound differently depending on whether or not we're loading from a file. */
+#ifndef MA_NO_RESOURCE_MANAGER
+    if (pConfig->pFilePath != NULL || pConfig->pFilePathW != NULL) {
+        return ma_sound_init_from_file_internal(pEngine, pConfig, pSound);
+    } else
+#endif
+    {
+        /*
+        Getting here means we're not loading from a file. We may be loading from an already-initialized
+        data source, or none at all. If we aren't specifying any data source, we'll be initializing
+        the equivalent to a group. ma_data_source_init_from_data_source_internal() will deal with this
+        for us, so no special treatment required here.
+        */
+        return ma_sound_init_from_data_source_internal(pEngine, pConfig, pSound);
+    }
+}
+
+MA_API void ma_sound_uninit(ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    /*
+    Always uninitialize the node first. This ensures it's detached from the graph and does not return until it has done
+    so which makes thread safety beyond this point trivial.
+    */
+    ma_engine_node_uninit(&pSound->engineNode, &pSound->engineNode.pEngine->allocationCallbacks);
+
+    /* Once the sound is detached from the group we can guarantee that it won't be referenced by the mixer thread which means it's safe for us to destroy the data source. */
+#ifndef MA_NO_RESOURCE_MANAGER
+    if (pSound->ownsDataSource) {
+        ma_resource_manager_data_source_uninit(pSound->pResourceManagerDataSource);
+        ma_free(pSound->pResourceManagerDataSource, &pSound->engineNode.pEngine->allocationCallbacks);
+        pSound->pDataSource = NULL;
+    }
+#else
+    MA_ASSERT(pSound->ownsDataSource == MA_FALSE);
+#endif
+}
+
+MA_API ma_engine* ma_sound_get_engine(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return NULL;
+    }
+
+    return pSound->engineNode.pEngine;
+}
+
+MA_API ma_data_source* ma_sound_get_data_source(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return NULL;
+    }
+
+    return pSound->pDataSource;
+}
+
+MA_API ma_result ma_sound_start(ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If the sound is already playing, do nothing. */
+    if (ma_sound_is_playing(pSound)) {
+        return MA_SUCCESS;
+    }
+
+    /* If the sound is at the end it means we want to start from the start again. */
+    if (ma_sound_at_end(pSound)) {
+        ma_result result = ma_data_source_seek_to_pcm_frame(pSound->pDataSource, 0);
+        if (result != MA_SUCCESS && result != MA_NOT_IMPLEMENTED) {
+            return result;  /* Failed to seek back to the start. */
+        }
+
+        /* Make sure we clear the end indicator. */
+        ma_atomic_exchange_32(&pSound->atEnd, MA_FALSE);
+    }
+
+    /* Make sure the sound is started. If there's a start delay, the sound won't actually start until the start time is reached. */
+    ma_node_set_state(pSound, ma_node_state_started);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_stop(ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* This will stop the sound immediately. Use ma_sound_set_stop_time() to stop the sound at a specific time. */
+    ma_node_set_state(pSound, ma_node_state_stopped);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_stop_with_fade_in_pcm_frames(ma_sound* pSound, ma_uint64 fadeLengthInFrames)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Stopping with a fade out requires us to schedule the stop into the future by the fade length. */
+    ma_sound_set_stop_time_with_fade_in_pcm_frames(pSound, ma_engine_get_time_in_pcm_frames(ma_sound_get_engine(pSound)) + fadeLengthInFrames, fadeLengthInFrames);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_stop_with_fade_in_milliseconds(ma_sound* pSound, ma_uint64 fadeLengthInMilliseconds)
+{
+    ma_uint64 sampleRate;
+
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    sampleRate = ma_engine_get_sample_rate(ma_sound_get_engine(pSound));
+
+    return ma_sound_stop_with_fade_in_pcm_frames(pSound, (fadeLengthInMilliseconds * sampleRate) / 1000);
+}
+
+MA_API void ma_sound_set_volume(ma_sound* pSound, float volume)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_engine_node_set_volume(&pSound->engineNode, volume);
+}
+
+MA_API float ma_sound_get_volume(const ma_sound* pSound)
+{
+    float volume = 0;
+
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    ma_engine_node_get_volume(&pSound->engineNode, &volume);
+
+    return volume;
+}
+
+MA_API void ma_sound_set_pan(ma_sound* pSound, float pan)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_panner_set_pan(&pSound->engineNode.panner, pan);
+}
+
+MA_API float ma_sound_get_pan(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_panner_get_pan(&pSound->engineNode.panner);
+}
+
+MA_API void ma_sound_set_pan_mode(ma_sound* pSound, ma_pan_mode panMode)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_panner_set_mode(&pSound->engineNode.panner, panMode);
+}
+
+MA_API ma_pan_mode ma_sound_get_pan_mode(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_pan_mode_balance;
+    }
+
+    return ma_panner_get_mode(&pSound->engineNode.panner);
+}
+
+MA_API void ma_sound_set_pitch(ma_sound* pSound, float pitch)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    if (pitch <= 0) {
+        return;
+    }
+
+    ma_atomic_exchange_explicit_f32(&pSound->engineNode.pitch, pitch, ma_atomic_memory_order_release);
+}
+
+MA_API float ma_sound_get_pitch(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSound->engineNode.pitch);    /* Naughty const-cast for this. */
+}
+
+MA_API void ma_sound_set_spatialization_enabled(ma_sound* pSound, ma_bool32 enabled)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_explicit_32(&pSound->engineNode.isSpatializationDisabled, !enabled, ma_atomic_memory_order_release);
+}
+
+MA_API ma_bool32 ma_sound_is_spatialization_enabled(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_engine_node_is_spatialization_enabled(&pSound->engineNode);
+}
+
+MA_API void ma_sound_set_pinned_listener_index(ma_sound* pSound, ma_uint32 listenerIndex)
+{
+    if (pSound == NULL || listenerIndex >= ma_engine_get_listener_count(ma_sound_get_engine(pSound))) {
+        return;
+    }
+
+    ma_atomic_exchange_explicit_32(&pSound->engineNode.pinnedListenerIndex, listenerIndex, ma_atomic_memory_order_release);
+}
+
+MA_API ma_uint32 ma_sound_get_pinned_listener_index(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_LISTENER_INDEX_CLOSEST;
+    }
+
+    return ma_atomic_load_explicit_32(&pSound->engineNode.pinnedListenerIndex, ma_atomic_memory_order_acquire);
+}
+
+MA_API ma_uint32 ma_sound_get_listener_index(const ma_sound* pSound)
+{
+    ma_uint32 listenerIndex;
+
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    listenerIndex = ma_sound_get_pinned_listener_index(pSound);
+    if (listenerIndex == MA_LISTENER_INDEX_CLOSEST) {
+        ma_vec3f position = ma_sound_get_position(pSound);
+        return ma_engine_find_closest_listener(ma_sound_get_engine(pSound), position.x, position.y, position.z);
+    }
+
+    return listenerIndex;
+}
+
+MA_API ma_vec3f ma_sound_get_direction_to_listener(const ma_sound* pSound)
+{
+    ma_vec3f relativePos;
+    ma_engine* pEngine;
+
+    if (pSound == NULL) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    pEngine = ma_sound_get_engine(pSound);
+    if (pEngine == NULL) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    ma_spatializer_get_relative_position_and_direction(&pSound->engineNode.spatializer, &pEngine->listeners[ma_sound_get_listener_index(pSound)], &relativePos, NULL);
+
+    return ma_vec3f_normalize(ma_vec3f_neg(relativePos));
+}
+
+MA_API void ma_sound_set_position(ma_sound* pSound, float x, float y, float z)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_position(&pSound->engineNode.spatializer, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_get_position(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_get_position(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_direction(ma_sound* pSound, float x, float y, float z)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_direction(&pSound->engineNode.spatializer, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_get_direction(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_get_direction(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_velocity(ma_sound* pSound, float x, float y, float z)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_velocity(&pSound->engineNode.spatializer, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_get_velocity(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_get_velocity(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_attenuation_model(ma_sound* pSound, ma_attenuation_model attenuationModel)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_attenuation_model(&pSound->engineNode.spatializer, attenuationModel);
+}
+
+MA_API ma_attenuation_model ma_sound_get_attenuation_model(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_attenuation_model_none;
+    }
+
+    return ma_spatializer_get_attenuation_model(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_positioning(ma_sound* pSound, ma_positioning positioning)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_positioning(&pSound->engineNode.spatializer, positioning);
+}
+
+MA_API ma_positioning ma_sound_get_positioning(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_positioning_absolute;
+    }
+
+    return ma_spatializer_get_positioning(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_rolloff(ma_sound* pSound, float rolloff)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_rolloff(&pSound->engineNode.spatializer, rolloff);
+}
+
+MA_API float ma_sound_get_rolloff(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_rolloff(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_min_gain(ma_sound* pSound, float minGain)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_min_gain(&pSound->engineNode.spatializer, minGain);
+}
+
+MA_API float ma_sound_get_min_gain(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_min_gain(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_max_gain(ma_sound* pSound, float maxGain)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_max_gain(&pSound->engineNode.spatializer, maxGain);
+}
+
+MA_API float ma_sound_get_max_gain(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_max_gain(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_min_distance(ma_sound* pSound, float minDistance)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_min_distance(&pSound->engineNode.spatializer, minDistance);
+}
+
+MA_API float ma_sound_get_min_distance(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_min_distance(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_max_distance(ma_sound* pSound, float maxDistance)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_max_distance(&pSound->engineNode.spatializer, maxDistance);
+}
+
+MA_API float ma_sound_get_max_distance(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_max_distance(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_cone(ma_sound* pSound, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_cone(&pSound->engineNode.spatializer, innerAngleInRadians, outerAngleInRadians, outerGain);
+}
+
+MA_API void ma_sound_get_cone(const ma_sound* pSound, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    if (pInnerAngleInRadians != NULL) {
+        *pInnerAngleInRadians = 0;
+    }
+
+    if (pOuterAngleInRadians != NULL) {
+        *pOuterAngleInRadians = 0;
+    }
+
+    if (pOuterGain != NULL) {
+        *pOuterGain = 0;
+    }
+
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_get_cone(&pSound->engineNode.spatializer, pInnerAngleInRadians, pOuterAngleInRadians, pOuterGain);
+}
+
+MA_API void ma_sound_set_doppler_factor(ma_sound* pSound, float dopplerFactor)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_doppler_factor(&pSound->engineNode.spatializer, dopplerFactor);
+}
+
+MA_API float ma_sound_get_doppler_factor(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_doppler_factor(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_directional_attenuation_factor(ma_sound* pSound, float directionalAttenuationFactor)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_directional_attenuation_factor(&pSound->engineNode.spatializer, directionalAttenuationFactor);
+}
+
+MA_API float ma_sound_get_directional_attenuation_factor(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 1;
+    }
+
+    return ma_spatializer_get_directional_attenuation_factor(&pSound->engineNode.spatializer);
+}
+
+
+MA_API void ma_sound_set_fade_in_pcm_frames(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_fade_start_in_pcm_frames(pSound, volumeBeg, volumeEnd, fadeLengthInFrames, (~(ma_uint64)0));
+}
+
+MA_API void ma_sound_set_fade_in_milliseconds(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_fade_in_pcm_frames(pSound, volumeBeg, volumeEnd, (fadeLengthInMilliseconds * pSound->engineNode.fader.config.sampleRate) / 1000);
+}
+
+MA_API void ma_sound_set_fade_start_in_pcm_frames(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    /*
+    We don't want to update the fader at this point because we need to use the engine's current time
+    to derive the fader's start offset. The timer is being updated on the audio thread so in order to
+    do this as accurately as possible we'll need to defer this to the audio thread.
+    */
+    ma_atomic_float_set(&pSound->engineNode.fadeSettings.volumeBeg, volumeBeg);
+    ma_atomic_float_set(&pSound->engineNode.fadeSettings.volumeEnd, volumeEnd);
+    ma_atomic_uint64_set(&pSound->engineNode.fadeSettings.fadeLengthInFrames, fadeLengthInFrames);
+    ma_atomic_uint64_set(&pSound->engineNode.fadeSettings.absoluteGlobalTimeInFrames, absoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_set_fade_start_in_milliseconds(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    ma_uint32 sampleRate;
+
+    if (pSound == NULL) {
+        return;
+    }
+
+    sampleRate = ma_engine_get_sample_rate(ma_sound_get_engine(pSound));
+
+    ma_sound_set_fade_start_in_pcm_frames(pSound, volumeBeg, volumeEnd, (fadeLengthInMilliseconds * sampleRate) / 1000, (absoluteGlobalTimeInMilliseconds * sampleRate) / 1000);
+}
+
+MA_API float ma_sound_get_current_fade_volume(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_fader_get_current_volume(&pSound->engineNode.fader);
+}
+
+MA_API void ma_sound_set_start_time_in_pcm_frames(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_node_set_state_time(pSound, ma_node_state_started, absoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_set_start_time_in_milliseconds(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_start_time_in_pcm_frames(pSound, absoluteGlobalTimeInMilliseconds * ma_engine_get_sample_rate(ma_sound_get_engine(pSound)) / 1000);
+}
+
+MA_API void ma_sound_set_stop_time_in_pcm_frames(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_stop_time_with_fade_in_pcm_frames(pSound, absoluteGlobalTimeInFrames, 0);
+}
+
+MA_API void ma_sound_set_stop_time_in_milliseconds(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_stop_time_in_pcm_frames(pSound, absoluteGlobalTimeInMilliseconds * ma_engine_get_sample_rate(ma_sound_get_engine(pSound)) / 1000);
+}
+
+MA_API void ma_sound_set_stop_time_with_fade_in_pcm_frames(ma_sound* pSound, ma_uint64 stopAbsoluteGlobalTimeInFrames, ma_uint64 fadeLengthInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    if (fadeLengthInFrames > 0) {
+        if (fadeLengthInFrames > stopAbsoluteGlobalTimeInFrames) {
+            fadeLengthInFrames = stopAbsoluteGlobalTimeInFrames;
+        }
+
+        ma_sound_set_fade_start_in_pcm_frames(pSound, -1, 0, fadeLengthInFrames, stopAbsoluteGlobalTimeInFrames - fadeLengthInFrames);
+    }
+
+    ma_node_set_state_time(pSound, ma_node_state_stopped, stopAbsoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_set_stop_time_with_fade_in_milliseconds(ma_sound* pSound, ma_uint64 stopAbsoluteGlobalTimeInMilliseconds, ma_uint64 fadeLengthInMilliseconds)
+{
+    ma_uint32 sampleRate;
+
+    if (pSound == NULL) {
+        return;
+    }
+
+    sampleRate = ma_engine_get_sample_rate(ma_sound_get_engine(pSound));
+
+    ma_sound_set_stop_time_with_fade_in_pcm_frames(pSound, (stopAbsoluteGlobalTimeInMilliseconds * sampleRate) / 1000, (fadeLengthInMilliseconds * sampleRate) / 1000);
+}
+
+MA_API ma_bool32 ma_sound_is_playing(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_node_get_state_by_time(pSound, ma_engine_get_time_in_pcm_frames(ma_sound_get_engine(pSound))) == ma_node_state_started;
+}
+
+MA_API ma_uint64 ma_sound_get_time_in_pcm_frames(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_node_get_time(pSound);
+}
+
+MA_API ma_uint64 ma_sound_get_time_in_milliseconds(const ma_sound* pSound)
+{
+    ma_uint32 sampleRate = ma_engine_get_sample_rate(ma_sound_get_engine(pSound));
+    if (sampleRate == 0) {
+        return 0;   /* Prevent a division by zero. */
+    }
+
+    return ma_sound_get_time_in_pcm_frames(pSound) * 1000 / sampleRate;
+}
+
+MA_API void ma_sound_set_looping(ma_sound* pSound, ma_bool32 isLooping)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    /* Looping is only a valid concept if the sound is backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return;
+    }
+
+    /* The looping state needs to be applied to the data source in order for any looping to actually happen. */
+    ma_data_source_set_looping(pSound->pDataSource, isLooping);
+}
+
+MA_API ma_bool32 ma_sound_is_looping(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_FALSE;
+    }
+
+    /* There is no notion of looping for sounds that are not backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_data_source_is_looping(pSound->pDataSource);
+}
+
+MA_API ma_bool32 ma_sound_at_end(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_FALSE;
+    }
+
+    /* There is no notion of an end of a sound if it's not backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_sound_get_at_end(pSound);
+}
+
+MA_API ma_result ma_sound_seek_to_pcm_frame(ma_sound* pSound, ma_uint64 frameIndex)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Seeking is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* We can't be seeking while reading at the same time. We just set the seek target and get the mixing thread to do the actual seek. */
+    ma_atomic_exchange_64(&pSound->seekTarget, frameIndex);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_seek_to_second(ma_sound* pSound, float seekPointInSeconds)
+{
+    ma_uint64 frameIndex;
+    ma_uint32 sampleRate;
+    ma_result result;
+
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_sound_get_data_format(pSound, NULL, NULL, &sampleRate, NULL, 0);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* We need PCM frames. We need to convert first */
+    frameIndex = (ma_uint64)(seekPointInSeconds * sampleRate);
+
+    return ma_sound_seek_to_pcm_frame(pSound, frameIndex);
+}
+
+MA_API ma_result ma_sound_get_data_format(const ma_sound* pSound, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The data format is retrieved directly from the data source if the sound is backed by one. Otherwise we pull it from the node. */
+    if (pSound->pDataSource == NULL) {
+        ma_uint32 channels;
+
+        if (pFormat != NULL) {
+            *pFormat = ma_format_f32;
+        }
+
+        channels = ma_node_get_input_channels(&pSound->engineNode, 0);
+        if (pChannels != NULL) {
+            *pChannels = channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pSound->engineNode.resampler.config.sampleRateIn;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, channels);
+        }
+
+        return MA_SUCCESS;
+    } else {
+        return ma_data_source_get_data_format(pSound->pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+    }
+}
+
+MA_API ma_result ma_sound_get_cursor_in_pcm_frames(const ma_sound* pSound, ma_uint64* pCursor)
+{
+    ma_uint64 seekTarget;
+
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The notion of a cursor is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    seekTarget = ma_atomic_load_64(&pSound->seekTarget);
+    if (seekTarget != MA_SEEK_TARGET_NONE) {
+        *pCursor = seekTarget;
+        return MA_SUCCESS;
+    } else {
+        return ma_data_source_get_cursor_in_pcm_frames(pSound->pDataSource, pCursor);
+    }
+}
+
+MA_API ma_result ma_sound_get_length_in_pcm_frames(const ma_sound* pSound, ma_uint64* pLength)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The notion of a sound length is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    return ma_data_source_get_length_in_pcm_frames(pSound->pDataSource, pLength);
+}
+
+MA_API ma_result ma_sound_get_cursor_in_seconds(const ma_sound* pSound, float* pCursor)
+{
+    ma_result result;
+    ma_uint64 cursorInPCMFrames;
+    ma_uint32 sampleRate;
+
+    if (pCursor != NULL) {
+        *pCursor = 0;
+    }
+
+    result = ma_sound_get_cursor_in_pcm_frames(pSound, &cursorInPCMFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_sound_get_data_format(pSound, NULL, NULL, &sampleRate, NULL, 0);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* VC6 does not support division of unsigned 64-bit integers with floating point numbers. Need to use a signed number. This shouldn't effect anything in practice. */
+    *pCursor = (ma_int64)cursorInPCMFrames / (float)sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_get_length_in_seconds(const ma_sound* pSound, float* pLength)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The notion of a sound length is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    return ma_data_source_get_length_in_seconds(pSound->pDataSource, pLength);
+}
+
+MA_API ma_result ma_sound_set_end_callback(ma_sound* pSound, ma_sound_end_proc callback, void* pUserData)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The notion of an end is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    pSound->endCallback          = callback;
+    pSound->pEndCallbackUserData = pUserData;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_sound_group_init(ma_engine* pEngine, ma_uint32 flags, ma_sound_group* pParentGroup, ma_sound_group* pGroup)
+{
+    ma_sound_group_config config = ma_sound_group_config_init_2(pEngine);
+    config.flags              = flags;
+    config.pInitialAttachment = pParentGroup;
+    return ma_sound_group_init_ex(pEngine, &config, pGroup);
+}
+
+MA_API ma_result ma_sound_group_init_ex(ma_engine* pEngine, const ma_sound_group_config* pConfig, ma_sound_group* pGroup)
+{
+    ma_sound_config soundConfig;
+
+    if (pGroup == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pGroup);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* A sound group is just a sound without a data source. */
+    soundConfig = *pConfig;
+    soundConfig.pFilePath   = NULL;
+    soundConfig.pFilePathW  = NULL;
+    soundConfig.pDataSource = NULL;
+
+    /*
+    Groups need to have spatialization disabled by default because I think it'll be pretty rare
+    that programs will want to spatialize groups (but not unheard of). Certainly it feels like
+    disabling this by default feels like the right option. Spatialization can be enabled with a
+    call to ma_sound_group_set_spatialization_enabled().
+    */
+    soundConfig.flags |= MA_SOUND_FLAG_NO_SPATIALIZATION;
+
+    return ma_sound_init_ex(pEngine, &soundConfig, pGroup);
+}
+
+MA_API void ma_sound_group_uninit(ma_sound_group* pGroup)
+{
+    ma_sound_uninit(pGroup);
+}
+
+MA_API ma_engine* ma_sound_group_get_engine(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_engine(pGroup);
+}
+
+MA_API ma_result ma_sound_group_start(ma_sound_group* pGroup)
+{
+    return ma_sound_start(pGroup);
+}
+
+MA_API ma_result ma_sound_group_stop(ma_sound_group* pGroup)
+{
+    return ma_sound_stop(pGroup);
+}
+
+MA_API void ma_sound_group_set_volume(ma_sound_group* pGroup, float volume)
+{
+    ma_sound_set_volume(pGroup, volume);
+}
+
+MA_API float ma_sound_group_get_volume(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_volume(pGroup);
+}
+
+MA_API void ma_sound_group_set_pan(ma_sound_group* pGroup, float pan)
+{
+    ma_sound_set_pan(pGroup, pan);
+}
+
+MA_API float ma_sound_group_get_pan(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_pan(pGroup);
+}
+
+MA_API void ma_sound_group_set_pan_mode(ma_sound_group* pGroup, ma_pan_mode panMode)
+{
+    ma_sound_set_pan_mode(pGroup, panMode);
+}
+
+MA_API ma_pan_mode ma_sound_group_get_pan_mode(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_pan_mode(pGroup);
+}
+
+MA_API void ma_sound_group_set_pitch(ma_sound_group* pGroup, float pitch)
+{
+    ma_sound_set_pitch(pGroup, pitch);
+}
+
+MA_API float ma_sound_group_get_pitch(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_pitch(pGroup);
+}
+
+MA_API void ma_sound_group_set_spatialization_enabled(ma_sound_group* pGroup, ma_bool32 enabled)
+{
+    ma_sound_set_spatialization_enabled(pGroup, enabled);
+}
+
+MA_API ma_bool32 ma_sound_group_is_spatialization_enabled(const ma_sound_group* pGroup)
+{
+    return ma_sound_is_spatialization_enabled(pGroup);
+}
+
+MA_API void ma_sound_group_set_pinned_listener_index(ma_sound_group* pGroup, ma_uint32 listenerIndex)
+{
+    ma_sound_set_pinned_listener_index(pGroup, listenerIndex);
+}
+
+MA_API ma_uint32 ma_sound_group_get_pinned_listener_index(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_pinned_listener_index(pGroup);
+}
+
+MA_API ma_uint32 ma_sound_group_get_listener_index(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_listener_index(pGroup);
+}
+
+MA_API ma_vec3f ma_sound_group_get_direction_to_listener(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_direction_to_listener(pGroup);
+}
+
+MA_API void ma_sound_group_set_position(ma_sound_group* pGroup, float x, float y, float z)
+{
+    ma_sound_set_position(pGroup, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_group_get_position(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_position(pGroup);
+}
+
+MA_API void ma_sound_group_set_direction(ma_sound_group* pGroup, float x, float y, float z)
+{
+    ma_sound_set_direction(pGroup, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_group_get_direction(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_direction(pGroup);
+}
+
+MA_API void ma_sound_group_set_velocity(ma_sound_group* pGroup, float x, float y, float z)
+{
+    ma_sound_set_velocity(pGroup, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_group_get_velocity(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_velocity(pGroup);
+}
+
+MA_API void ma_sound_group_set_attenuation_model(ma_sound_group* pGroup, ma_attenuation_model attenuationModel)
+{
+    ma_sound_set_attenuation_model(pGroup, attenuationModel);
+}
+
+MA_API ma_attenuation_model ma_sound_group_get_attenuation_model(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_attenuation_model(pGroup);
+}
+
+MA_API void ma_sound_group_set_positioning(ma_sound_group* pGroup, ma_positioning positioning)
+{
+    ma_sound_set_positioning(pGroup, positioning);
+}
+
+MA_API ma_positioning ma_sound_group_get_positioning(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_positioning(pGroup);
+}
+
+MA_API void ma_sound_group_set_rolloff(ma_sound_group* pGroup, float rolloff)
+{
+    ma_sound_set_rolloff(pGroup, rolloff);
+}
+
+MA_API float ma_sound_group_get_rolloff(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_rolloff(pGroup);
+}
+
+MA_API void ma_sound_group_set_min_gain(ma_sound_group* pGroup, float minGain)
+{
+    ma_sound_set_min_gain(pGroup, minGain);
+}
+
+MA_API float ma_sound_group_get_min_gain(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_min_gain(pGroup);
+}
+
+MA_API void ma_sound_group_set_max_gain(ma_sound_group* pGroup, float maxGain)
+{
+    ma_sound_set_max_gain(pGroup, maxGain);
+}
+
+MA_API float ma_sound_group_get_max_gain(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_max_gain(pGroup);
+}
+
+MA_API void ma_sound_group_set_min_distance(ma_sound_group* pGroup, float minDistance)
+{
+    ma_sound_set_min_distance(pGroup, minDistance);
+}
+
+MA_API float ma_sound_group_get_min_distance(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_min_distance(pGroup);
+}
+
+MA_API void ma_sound_group_set_max_distance(ma_sound_group* pGroup, float maxDistance)
+{
+    ma_sound_set_max_distance(pGroup, maxDistance);
+}
+
+MA_API float ma_sound_group_get_max_distance(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_max_distance(pGroup);
+}
+
+MA_API void ma_sound_group_set_cone(ma_sound_group* pGroup, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    ma_sound_set_cone(pGroup, innerAngleInRadians, outerAngleInRadians, outerGain);
+}
+
+MA_API void ma_sound_group_get_cone(const ma_sound_group* pGroup, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    ma_sound_get_cone(pGroup, pInnerAngleInRadians, pOuterAngleInRadians, pOuterGain);
+}
+
+MA_API void ma_sound_group_set_doppler_factor(ma_sound_group* pGroup, float dopplerFactor)
+{
+    ma_sound_set_doppler_factor(pGroup, dopplerFactor);
+}
+
+MA_API float ma_sound_group_get_doppler_factor(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_doppler_factor(pGroup);
+}
+
+MA_API void ma_sound_group_set_directional_attenuation_factor(ma_sound_group* pGroup, float directionalAttenuationFactor)
+{
+    ma_sound_set_directional_attenuation_factor(pGroup, directionalAttenuationFactor);
+}
+
+MA_API float ma_sound_group_get_directional_attenuation_factor(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_directional_attenuation_factor(pGroup);
+}
+
+MA_API void ma_sound_group_set_fade_in_pcm_frames(ma_sound_group* pGroup, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames)
+{
+    ma_sound_set_fade_in_pcm_frames(pGroup, volumeBeg, volumeEnd, fadeLengthInFrames);
+}
+
+MA_API void ma_sound_group_set_fade_in_milliseconds(ma_sound_group* pGroup, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds)
+{
+    ma_sound_set_fade_in_milliseconds(pGroup, volumeBeg, volumeEnd, fadeLengthInMilliseconds);
+}
+
+MA_API float ma_sound_group_get_current_fade_volume(ma_sound_group* pGroup)
+{
+    return ma_sound_get_current_fade_volume(pGroup);
+}
+
+MA_API void ma_sound_group_set_start_time_in_pcm_frames(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    ma_sound_set_start_time_in_pcm_frames(pGroup, absoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_group_set_start_time_in_milliseconds(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    ma_sound_set_start_time_in_milliseconds(pGroup, absoluteGlobalTimeInMilliseconds);
+}
+
+MA_API void ma_sound_group_set_stop_time_in_pcm_frames(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    ma_sound_set_stop_time_in_pcm_frames(pGroup, absoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_group_set_stop_time_in_milliseconds(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    ma_sound_set_stop_time_in_milliseconds(pGroup, absoluteGlobalTimeInMilliseconds);
+}
+
+MA_API ma_bool32 ma_sound_group_is_playing(const ma_sound_group* pGroup)
+{
+    return ma_sound_is_playing(pGroup);
+}
+
+MA_API ma_uint64 ma_sound_group_get_time_in_pcm_frames(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_time_in_pcm_frames(pGroup);
+}
+#endif  /* MA_NO_ENGINE */
+/* END SECTION: miniaudio_engine.c */
+
+
+
+/**************************************************************************************************************************************************************
+***************************************************************************************************************************************************************
+
+Auto Generated
+==============
+All code below is auto-generated from a tool. This mostly consists of decoding backend implementations such as ma_dr_wav, ma_dr_flac, etc. If you find a bug in the
+code below please report the bug to the respective repository for the relevant project (probably dr_libs).
+
+***************************************************************************************************************************************************************
+**************************************************************************************************************************************************************/
+#if !defined(MA_NO_WAV) && (!defined(MA_NO_DECODING) || !defined(MA_NO_ENCODING))
+#if !defined(MA_DR_WAV_IMPLEMENTATION)
+/* dr_wav_c begin */
+#ifndef ma_dr_wav_c
+#define ma_dr_wav_c
+#ifdef __MRC__
+#pragma options opt off
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#ifndef MA_DR_WAV_NO_STDIO
+#include <stdio.h>
+#ifndef MA_DR_WAV_NO_WCHAR
+#include <wchar.h>
+#endif
+#endif
+#ifndef MA_DR_WAV_ASSERT
+#include <assert.h>
+#define MA_DR_WAV_ASSERT(expression)           assert(expression)
+#endif
+#ifndef MA_DR_WAV_MALLOC
+#define MA_DR_WAV_MALLOC(sz)                   malloc((sz))
+#endif
+#ifndef MA_DR_WAV_REALLOC
+#define MA_DR_WAV_REALLOC(p, sz)               realloc((p), (sz))
+#endif
+#ifndef MA_DR_WAV_FREE
+#define MA_DR_WAV_FREE(p)                      free((p))
+#endif
+#ifndef MA_DR_WAV_COPY_MEMORY
+#define MA_DR_WAV_COPY_MEMORY(dst, src, sz)    memcpy((dst), (src), (sz))
+#endif
+#ifndef MA_DR_WAV_ZERO_MEMORY
+#define MA_DR_WAV_ZERO_MEMORY(p, sz)           memset((p), 0, (sz))
+#endif
+#ifndef MA_DR_WAV_ZERO_OBJECT
+#define MA_DR_WAV_ZERO_OBJECT(p)               MA_DR_WAV_ZERO_MEMORY((p), sizeof(*p))
+#endif
+#define ma_dr_wav_countof(x)                   (sizeof(x) / sizeof(x[0]))
+#define ma_dr_wav_align(x, a)                  ((((x) + (a) - 1) / (a)) * (a))
+#define ma_dr_wav_min(a, b)                    (((a) < (b)) ? (a) : (b))
+#define ma_dr_wav_max(a, b)                    (((a) > (b)) ? (a) : (b))
+#define ma_dr_wav_clamp(x, lo, hi)             (ma_dr_wav_max((lo), ma_dr_wav_min((hi), (x))))
+#define ma_dr_wav_offset_ptr(p, offset)        (((ma_uint8*)(p)) + (offset))
+#define MA_DR_WAV_MAX_SIMD_VECTOR_SIZE         32
+#define MA_DR_WAV_INT64_MIN ((ma_int64) ((ma_uint64)0x80000000 << 32))
+#define MA_DR_WAV_INT64_MAX ((ma_int64)(((ma_uint64)0x7FFFFFFF << 32) | 0xFFFFFFFF))
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    #define MA_DR_WAV_HAS_BYTESWAP16_INTRINSIC
+    #define MA_DR_WAV_HAS_BYTESWAP32_INTRINSIC
+    #define MA_DR_WAV_HAS_BYTESWAP64_INTRINSIC
+#elif defined(__clang__)
+    #if defined(__has_builtin)
+        #if __has_builtin(__builtin_bswap16)
+            #define MA_DR_WAV_HAS_BYTESWAP16_INTRINSIC
+        #endif
+        #if __has_builtin(__builtin_bswap32)
+            #define MA_DR_WAV_HAS_BYTESWAP32_INTRINSIC
+        #endif
+        #if __has_builtin(__builtin_bswap64)
+            #define MA_DR_WAV_HAS_BYTESWAP64_INTRINSIC
+        #endif
+    #endif
+#elif defined(__GNUC__)
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+        #define MA_DR_WAV_HAS_BYTESWAP32_INTRINSIC
+        #define MA_DR_WAV_HAS_BYTESWAP64_INTRINSIC
+    #endif
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+        #define MA_DR_WAV_HAS_BYTESWAP16_INTRINSIC
+    #endif
+#endif
+MA_API void ma_dr_wav_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision)
+{
+    if (pMajor) {
+        *pMajor = MA_DR_WAV_VERSION_MAJOR;
+    }
+    if (pMinor) {
+        *pMinor = MA_DR_WAV_VERSION_MINOR;
+    }
+    if (pRevision) {
+        *pRevision = MA_DR_WAV_VERSION_REVISION;
+    }
+}
+MA_API const char* ma_dr_wav_version_string(void)
+{
+    return MA_DR_WAV_VERSION_STRING;
+}
+#ifndef MA_DR_WAV_MAX_SAMPLE_RATE
+#define MA_DR_WAV_MAX_SAMPLE_RATE       384000
+#endif
+#ifndef MA_DR_WAV_MAX_CHANNELS
+#define MA_DR_WAV_MAX_CHANNELS          256
+#endif
+#ifndef MA_DR_WAV_MAX_BITS_PER_SAMPLE
+#define MA_DR_WAV_MAX_BITS_PER_SAMPLE   64
+#endif
+static const ma_uint8 ma_dr_wavGUID_W64_RIFF[16] = {0x72,0x69,0x66,0x66, 0x2E,0x91, 0xCF,0x11, 0xA5,0xD6, 0x28,0xDB,0x04,0xC1,0x00,0x00};
+static const ma_uint8 ma_dr_wavGUID_W64_WAVE[16] = {0x77,0x61,0x76,0x65, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
+static const ma_uint8 ma_dr_wavGUID_W64_FMT [16] = {0x66,0x6D,0x74,0x20, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
+static const ma_uint8 ma_dr_wavGUID_W64_FACT[16] = {0x66,0x61,0x63,0x74, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
+static const ma_uint8 ma_dr_wavGUID_W64_DATA[16] = {0x64,0x61,0x74,0x61, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
+static MA_INLINE int ma_dr_wav__is_little_endian(void)
+{
+#if defined(MA_X86) || defined(MA_X64)
+    return MA_TRUE;
+#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
+    return MA_TRUE;
+#else
+    int n = 1;
+    return (*(char*)&n) == 1;
+#endif
+}
+static MA_INLINE void ma_dr_wav_bytes_to_guid(const ma_uint8* data, ma_uint8* guid)
+{
+    int i;
+    for (i = 0; i < 16; ++i) {
+        guid[i] = data[i];
+    }
+}
+static MA_INLINE ma_uint16 ma_dr_wav__bswap16(ma_uint16 n)
+{
+#ifdef MA_DR_WAV_HAS_BYTESWAP16_INTRINSIC
+    #if defined(_MSC_VER)
+        return _byteswap_ushort(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        return __builtin_bswap16(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF00) >> 8) |
+           ((n & 0x00FF) << 8);
+#endif
+}
+static MA_INLINE ma_uint32 ma_dr_wav__bswap32(ma_uint32 n)
+{
+#ifdef MA_DR_WAV_HAS_BYTESWAP32_INTRINSIC
+    #if defined(_MSC_VER)
+        return _byteswap_ulong(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        #if defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(MA_64BIT)
+            ma_uint32 r;
+            __asm__ __volatile__ (
+            #if defined(MA_64BIT)
+                "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n)
+            #else
+                "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n)
+            #endif
+            );
+            return r;
+        #else
+            return __builtin_bswap32(n);
+        #endif
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF000000) >> 24) |
+           ((n & 0x00FF0000) >>  8) |
+           ((n & 0x0000FF00) <<  8) |
+           ((n & 0x000000FF) << 24);
+#endif
+}
+static MA_INLINE ma_uint64 ma_dr_wav__bswap64(ma_uint64 n)
+{
+#ifdef MA_DR_WAV_HAS_BYTESWAP64_INTRINSIC
+    #if defined(_MSC_VER)
+        return _byteswap_uint64(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        return __builtin_bswap64(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & ((ma_uint64)0xFF000000 << 32)) >> 56) |
+           ((n & ((ma_uint64)0x00FF0000 << 32)) >> 40) |
+           ((n & ((ma_uint64)0x0000FF00 << 32)) >> 24) |
+           ((n & ((ma_uint64)0x000000FF << 32)) >>  8) |
+           ((n & ((ma_uint64)0xFF000000      )) <<  8) |
+           ((n & ((ma_uint64)0x00FF0000      )) << 24) |
+           ((n & ((ma_uint64)0x0000FF00      )) << 40) |
+           ((n & ((ma_uint64)0x000000FF      )) << 56);
+#endif
+}
+static MA_INLINE ma_int16 ma_dr_wav__bswap_s16(ma_int16 n)
+{
+    return (ma_int16)ma_dr_wav__bswap16((ma_uint16)n);
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_s16(ma_int16* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamples[iSample] = ma_dr_wav__bswap_s16(pSamples[iSample]);
+    }
+}
+static MA_INLINE void ma_dr_wav__bswap_s24(ma_uint8* p)
+{
+    ma_uint8 t;
+    t = p[0];
+    p[0] = p[2];
+    p[2] = t;
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_s24(ma_uint8* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        ma_uint8* pSample = pSamples + (iSample*3);
+        ma_dr_wav__bswap_s24(pSample);
+    }
+}
+static MA_INLINE ma_int32 ma_dr_wav__bswap_s32(ma_int32 n)
+{
+    return (ma_int32)ma_dr_wav__bswap32((ma_uint32)n);
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_s32(ma_int32* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamples[iSample] = ma_dr_wav__bswap_s32(pSamples[iSample]);
+    }
+}
+static MA_INLINE ma_int64 ma_dr_wav__bswap_s64(ma_int64 n)
+{
+    return (ma_int64)ma_dr_wav__bswap64((ma_uint64)n);
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_s64(ma_int64* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamples[iSample] = ma_dr_wav__bswap_s64(pSamples[iSample]);
+    }
+}
+static MA_INLINE float ma_dr_wav__bswap_f32(float n)
+{
+    union {
+        ma_uint32 i;
+        float f;
+    } x;
+    x.f = n;
+    x.i = ma_dr_wav__bswap32(x.i);
+    return x.f;
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_f32(float* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamples[iSample] = ma_dr_wav__bswap_f32(pSamples[iSample]);
+    }
+}
+static MA_INLINE void ma_dr_wav__bswap_samples(void* pSamples, ma_uint64 sampleCount, ma_uint32 bytesPerSample)
+{
+    switch (bytesPerSample)
+    {
+        case 1:
+        {
+        } break;
+        case 2:
+        {
+            ma_dr_wav__bswap_samples_s16((ma_int16*)pSamples, sampleCount);
+        } break;
+        case 3:
+        {
+            ma_dr_wav__bswap_samples_s24((ma_uint8*)pSamples, sampleCount);
+        } break;
+        case 4:
+        {
+            ma_dr_wav__bswap_samples_s32((ma_int32*)pSamples, sampleCount);
+        } break;
+        case 8:
+        {
+            ma_dr_wav__bswap_samples_s64((ma_int64*)pSamples, sampleCount);
+        } break;
+        default:
+        {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+        } break;
+    }
+}
+MA_PRIVATE MA_INLINE ma_bool32 ma_dr_wav_is_container_be(ma_dr_wav_container container)
+{
+    if (container == ma_dr_wav_container_rifx || container == ma_dr_wav_container_aiff) {
+        return MA_TRUE;
+    } else {
+        return MA_FALSE;
+    }
+}
+MA_PRIVATE MA_INLINE ma_uint16 ma_dr_wav_bytes_to_u16_le(const ma_uint8* data)
+{
+    return ((ma_uint16)data[0] << 0) | ((ma_uint16)data[1] << 8);
+}
+MA_PRIVATE MA_INLINE ma_uint16 ma_dr_wav_bytes_to_u16_be(const ma_uint8* data)
+{
+    return ((ma_uint16)data[1] << 0) | ((ma_uint16)data[0] << 8);
+}
+MA_PRIVATE MA_INLINE ma_uint16 ma_dr_wav_bytes_to_u16_ex(const ma_uint8* data, ma_dr_wav_container container)
+{
+    if (ma_dr_wav_is_container_be(container)) {
+        return ma_dr_wav_bytes_to_u16_be(data);
+    } else {
+        return ma_dr_wav_bytes_to_u16_le(data);
+    }
+}
+MA_PRIVATE MA_INLINE ma_uint32 ma_dr_wav_bytes_to_u32_le(const ma_uint8* data)
+{
+    return ((ma_uint32)data[0] << 0) | ((ma_uint32)data[1] << 8) | ((ma_uint32)data[2] << 16) | ((ma_uint32)data[3] << 24);
+}
+MA_PRIVATE MA_INLINE ma_uint32 ma_dr_wav_bytes_to_u32_be(const ma_uint8* data)
+{
+    return ((ma_uint32)data[3] << 0) | ((ma_uint32)data[2] << 8) | ((ma_uint32)data[1] << 16) | ((ma_uint32)data[0] << 24);
+}
+MA_PRIVATE MA_INLINE ma_uint32 ma_dr_wav_bytes_to_u32_ex(const ma_uint8* data, ma_dr_wav_container container)
+{
+    if (ma_dr_wav_is_container_be(container)) {
+        return ma_dr_wav_bytes_to_u32_be(data);
+    } else {
+        return ma_dr_wav_bytes_to_u32_le(data);
+    }
+}
+MA_PRIVATE ma_int64 ma_dr_wav_aiff_extented_to_s64(const ma_uint8* data)
+{
+    ma_uint32 exponent = ((ma_uint32)data[0] << 8) | data[1];
+    ma_uint64 hi = ((ma_uint64)data[2] << 24) | ((ma_uint64)data[3] << 16) | ((ma_uint64)data[4] <<  8) | ((ma_uint64)data[5] <<  0);
+    ma_uint64 lo = ((ma_uint64)data[6] << 24) | ((ma_uint64)data[7] << 16) | ((ma_uint64)data[8] <<  8) | ((ma_uint64)data[9] <<  0);
+    ma_uint64 significand = (hi << 32) | lo;
+    int sign = exponent >> 15;
+    exponent &= 0x7FFF;
+    if (exponent == 0 && significand == 0) {
+        return 0;
+    } else if (exponent == 0x7FFF) {
+        return sign ? MA_DR_WAV_INT64_MIN : MA_DR_WAV_INT64_MAX;
+    }
+    exponent -= 16383;
+    if (exponent > 63) {
+        return sign ? MA_DR_WAV_INT64_MIN : MA_DR_WAV_INT64_MAX;
+    } else if (exponent < 1) {
+        return 0;
+    }
+    significand >>= (63 - exponent);
+    if (sign) {
+        return -(ma_int64)significand;
+    } else {
+        return  (ma_int64)significand;
+    }
+}
+MA_PRIVATE void* ma_dr_wav__malloc_default(size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_WAV_MALLOC(sz);
+}
+MA_PRIVATE void* ma_dr_wav__realloc_default(void* p, size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_WAV_REALLOC(p, sz);
+}
+MA_PRIVATE void ma_dr_wav__free_default(void* p, void* pUserData)
+{
+    (void)pUserData;
+    MA_DR_WAV_FREE(p);
+}
+MA_PRIVATE void* ma_dr_wav__malloc_from_callbacks(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onMalloc != NULL) {
+        return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData);
+    }
+    return NULL;
+}
+MA_PRIVATE void* ma_dr_wav__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) {
+        void* p2;
+        p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData);
+        if (p2 == NULL) {
+            return NULL;
+        }
+        if (p != NULL) {
+            MA_DR_WAV_COPY_MEMORY(p2, p, szOld);
+            pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+        }
+        return p2;
+    }
+    return NULL;
+}
+MA_PRIVATE void ma_dr_wav__free_from_callbacks(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (p == NULL || pAllocationCallbacks == NULL) {
+        return;
+    }
+    if (pAllocationCallbacks->onFree != NULL) {
+        pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+    }
+}
+MA_PRIVATE ma_allocation_callbacks ma_dr_wav_copy_allocation_callbacks_or_defaults(const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        return *pAllocationCallbacks;
+    } else {
+        ma_allocation_callbacks allocationCallbacks;
+        allocationCallbacks.pUserData = NULL;
+        allocationCallbacks.onMalloc  = ma_dr_wav__malloc_default;
+        allocationCallbacks.onRealloc = ma_dr_wav__realloc_default;
+        allocationCallbacks.onFree    = ma_dr_wav__free_default;
+        return allocationCallbacks;
+    }
+}
+static MA_INLINE ma_bool32 ma_dr_wav__is_compressed_format_tag(ma_uint16 formatTag)
+{
+    return
+        formatTag == MA_DR_WAVE_FORMAT_ADPCM ||
+        formatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM;
+}
+MA_PRIVATE unsigned int ma_dr_wav__chunk_padding_size_riff(ma_uint64 chunkSize)
+{
+    return (unsigned int)(chunkSize % 2);
+}
+MA_PRIVATE unsigned int ma_dr_wav__chunk_padding_size_w64(ma_uint64 chunkSize)
+{
+    return (unsigned int)(chunkSize % 8);
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__msadpcm(ma_dr_wav* pWav, ma_uint64 samplesToRead, ma_int16* pBufferOut);
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__ima(ma_dr_wav* pWav, ma_uint64 samplesToRead, ma_int16* pBufferOut);
+MA_PRIVATE ma_bool32 ma_dr_wav_init_write__internal(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount);
+MA_PRIVATE ma_result ma_dr_wav__read_chunk_header(ma_dr_wav_read_proc onRead, void* pUserData, ma_dr_wav_container container, ma_uint64* pRunningBytesReadOut, ma_dr_wav_chunk_header* pHeaderOut)
+{
+    if (container == ma_dr_wav_container_riff || container == ma_dr_wav_container_rifx || container == ma_dr_wav_container_rf64 || container == ma_dr_wav_container_aiff) {
+        ma_uint8 sizeInBytes[4];
+        if (onRead(pUserData, pHeaderOut->id.fourcc, 4) != 4) {
+            return MA_AT_END;
+        }
+        if (onRead(pUserData, sizeInBytes, 4) != 4) {
+            return MA_INVALID_FILE;
+        }
+        pHeaderOut->sizeInBytes = ma_dr_wav_bytes_to_u32_ex(sizeInBytes, container);
+        pHeaderOut->paddingSize = ma_dr_wav__chunk_padding_size_riff(pHeaderOut->sizeInBytes);
+        *pRunningBytesReadOut += 8;
+    } else if (container == ma_dr_wav_container_w64) {
+        ma_uint8 sizeInBytes[8];
+        if (onRead(pUserData, pHeaderOut->id.guid, 16) != 16) {
+            return MA_AT_END;
+        }
+        if (onRead(pUserData, sizeInBytes, 8) != 8) {
+            return MA_INVALID_FILE;
+        }
+        pHeaderOut->sizeInBytes = ma_dr_wav_bytes_to_u64(sizeInBytes) - 24;
+        pHeaderOut->paddingSize = ma_dr_wav__chunk_padding_size_w64(pHeaderOut->sizeInBytes);
+        *pRunningBytesReadOut += 24;
+    } else {
+        return MA_INVALID_FILE;
+    }
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__seek_forward(ma_dr_wav_seek_proc onSeek, ma_uint64 offset, void* pUserData)
+{
+    ma_uint64 bytesRemainingToSeek = offset;
+    while (bytesRemainingToSeek > 0) {
+        if (bytesRemainingToSeek > 0x7FFFFFFF) {
+            if (!onSeek(pUserData, 0x7FFFFFFF, MA_DR_WAV_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+            bytesRemainingToSeek -= 0x7FFFFFFF;
+        } else {
+            if (!onSeek(pUserData, (int)bytesRemainingToSeek, MA_DR_WAV_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+            bytesRemainingToSeek = 0;
+        }
+    }
+    return MA_TRUE;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__seek_from_start(ma_dr_wav_seek_proc onSeek, ma_uint64 offset, void* pUserData)
+{
+    if (offset <= 0x7FFFFFFF) {
+        return onSeek(pUserData, (int)offset, MA_DR_WAV_SEEK_SET);
+    }
+    if (!onSeek(pUserData, 0x7FFFFFFF, MA_DR_WAV_SEEK_SET)) {
+        return MA_FALSE;
+    }
+    offset -= 0x7FFFFFFF;
+    for (;;) {
+        if (offset <= 0x7FFFFFFF) {
+            return onSeek(pUserData, (int)offset, MA_DR_WAV_SEEK_CUR);
+        }
+        if (!onSeek(pUserData, 0x7FFFFFFF, MA_DR_WAV_SEEK_CUR)) {
+            return MA_FALSE;
+        }
+        offset -= 0x7FFFFFFF;
+    }
+}
+MA_PRIVATE size_t ma_dr_wav__on_read(ma_dr_wav_read_proc onRead, void* pUserData, void* pBufferOut, size_t bytesToRead, ma_uint64* pCursor)
+{
+    size_t bytesRead;
+    MA_DR_WAV_ASSERT(onRead != NULL);
+    MA_DR_WAV_ASSERT(pCursor != NULL);
+    bytesRead = onRead(pUserData, pBufferOut, bytesToRead);
+    *pCursor += bytesRead;
+    return bytesRead;
+}
+#if 0
+MA_PRIVATE ma_bool32 ma_dr_wav__on_seek(ma_dr_wav_seek_proc onSeek, void* pUserData, int offset, ma_dr_wav_seek_origin origin, ma_uint64* pCursor)
+{
+    MA_DR_WAV_ASSERT(onSeek != NULL);
+    MA_DR_WAV_ASSERT(pCursor != NULL);
+    if (!onSeek(pUserData, offset, origin)) {
+        return MA_FALSE;
+    }
+    if (origin == MA_DR_WAV_SEEK_SET) {
+        *pCursor = offset;
+    } else {
+        *pCursor += offset;
+    }
+    return MA_TRUE;
+}
+#endif
+#define MA_DR_WAV_SMPL_BYTES                    36
+#define MA_DR_WAV_SMPL_LOOP_BYTES               24
+#define MA_DR_WAV_INST_BYTES                    7
+#define MA_DR_WAV_ACID_BYTES                    24
+#define MA_DR_WAV_CUE_BYTES                     4
+#define MA_DR_WAV_BEXT_BYTES                    602
+#define MA_DR_WAV_BEXT_DESCRIPTION_BYTES        256
+#define MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES    32
+#define MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES     32
+#define MA_DR_WAV_BEXT_RESERVED_BYTES           180
+#define MA_DR_WAV_BEXT_UMID_BYTES               64
+#define MA_DR_WAV_CUE_POINT_BYTES               24
+#define MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES      4
+#define MA_DR_WAV_LIST_LABELLED_TEXT_BYTES      20
+#define MA_DR_WAV_METADATA_ALIGNMENT            8
+typedef enum
+{
+    ma_dr_wav__metadata_parser_stage_count,
+    ma_dr_wav__metadata_parser_stage_read
+} ma_dr_wav__metadata_parser_stage;
+typedef struct
+{
+    ma_dr_wav_read_proc onRead;
+    ma_dr_wav_seek_proc onSeek;
+    void *pReadSeekUserData;
+    ma_dr_wav__metadata_parser_stage stage;
+    ma_dr_wav_metadata *pMetadata;
+    ma_uint32 metadataCount;
+    ma_uint8 *pData;
+    ma_uint8 *pDataCursor;
+    ma_uint64 metadataCursor;
+    ma_uint64 extraCapacity;
+} ma_dr_wav__metadata_parser;
+MA_PRIVATE size_t ma_dr_wav__metadata_memory_capacity(ma_dr_wav__metadata_parser* pParser)
+{
+    ma_uint64 cap = sizeof(ma_dr_wav_metadata) * (ma_uint64)pParser->metadataCount + pParser->extraCapacity;
+    if (cap > MA_SIZE_MAX) {
+        return 0;
+    }
+    return (size_t)cap;
+}
+MA_PRIVATE ma_uint8* ma_dr_wav__metadata_get_memory(ma_dr_wav__metadata_parser* pParser, size_t size, size_t align)
+{
+    ma_uint8* pResult;
+    if (align) {
+        ma_uintptr modulo = (ma_uintptr)pParser->pDataCursor % align;
+        if (modulo != 0) {
+            pParser->pDataCursor += align - modulo;
+        }
+    }
+    pResult = pParser->pDataCursor;
+    MA_DR_WAV_ASSERT((pResult + size) <= (pParser->pData + ma_dr_wav__metadata_memory_capacity(pParser)));
+    pParser->pDataCursor += size;
+    return pResult;
+}
+MA_PRIVATE void ma_dr_wav__metadata_request_extra_memory_for_stage_2(ma_dr_wav__metadata_parser* pParser, size_t bytes, size_t align)
+{
+    size_t extra = bytes + (align ? (align - 1) : 0);
+    pParser->extraCapacity += extra;
+}
+MA_PRIVATE ma_result ma_dr_wav__metadata_alloc(ma_dr_wav__metadata_parser* pParser, ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pParser->extraCapacity != 0 || pParser->metadataCount != 0) {
+        pAllocationCallbacks->onFree(pParser->pData, pAllocationCallbacks->pUserData);
+        pParser->pData = (ma_uint8*)pAllocationCallbacks->onMalloc(ma_dr_wav__metadata_memory_capacity(pParser), pAllocationCallbacks->pUserData);
+        pParser->pDataCursor = pParser->pData;
+        if (pParser->pData == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+        pParser->pMetadata = (ma_dr_wav_metadata*)ma_dr_wav__metadata_get_memory(pParser, sizeof(ma_dr_wav_metadata) * pParser->metadataCount, 1);
+        pParser->metadataCursor = 0;
+    }
+    return MA_SUCCESS;
+}
+MA_PRIVATE size_t ma_dr_wav__metadata_parser_read(ma_dr_wav__metadata_parser* pParser, void* pBufferOut, size_t bytesToRead, ma_uint64* pCursor)
+{
+    if (pCursor != NULL) {
+        return ma_dr_wav__on_read(pParser->onRead, pParser->pReadSeekUserData, pBufferOut, bytesToRead, pCursor);
+    } else {
+        return pParser->onRead(pParser->pReadSeekUserData, pBufferOut, bytesToRead);
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_smpl_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, const ma_dr_wav_chunk_header* pChunkHeader, ma_dr_wav_metadata* pMetadata)
+{
+    ma_uint8 smplHeaderData[MA_DR_WAV_SMPL_BYTES];
+    ma_uint64 totalBytesRead = 0;
+    size_t bytesJustRead;
+    if (pMetadata == NULL) {
+        return 0;
+    }
+    bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, smplHeaderData, sizeof(smplHeaderData), &totalBytesRead);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    MA_DR_WAV_ASSERT(pChunkHeader != NULL);
+    if (pMetadata != NULL && bytesJustRead == sizeof(smplHeaderData)) {
+        ma_uint32 iSampleLoop;
+        pMetadata->type                                     = ma_dr_wav_metadata_type_smpl;
+        pMetadata->data.smpl.manufacturerId                 = ma_dr_wav_bytes_to_u32(smplHeaderData + 0);
+        pMetadata->data.smpl.productId                      = ma_dr_wav_bytes_to_u32(smplHeaderData + 4);
+        pMetadata->data.smpl.samplePeriodNanoseconds        = ma_dr_wav_bytes_to_u32(smplHeaderData + 8);
+        pMetadata->data.smpl.midiUnityNote                  = ma_dr_wav_bytes_to_u32(smplHeaderData + 12);
+        pMetadata->data.smpl.midiPitchFraction              = ma_dr_wav_bytes_to_u32(smplHeaderData + 16);
+        pMetadata->data.smpl.smpteFormat                    = ma_dr_wav_bytes_to_u32(smplHeaderData + 20);
+        pMetadata->data.smpl.smpteOffset                    = ma_dr_wav_bytes_to_u32(smplHeaderData + 24);
+        pMetadata->data.smpl.sampleLoopCount                = ma_dr_wav_bytes_to_u32(smplHeaderData + 28);
+        pMetadata->data.smpl.samplerSpecificDataSizeInBytes = ma_dr_wav_bytes_to_u32(smplHeaderData + 32);
+        if (pMetadata->data.smpl.sampleLoopCount == (pChunkHeader->sizeInBytes - MA_DR_WAV_SMPL_BYTES) / MA_DR_WAV_SMPL_LOOP_BYTES) {
+            pMetadata->data.smpl.pLoops = (ma_dr_wav_smpl_loop*)ma_dr_wav__metadata_get_memory(pParser, sizeof(ma_dr_wav_smpl_loop) * pMetadata->data.smpl.sampleLoopCount, MA_DR_WAV_METADATA_ALIGNMENT);
+            for (iSampleLoop = 0; iSampleLoop < pMetadata->data.smpl.sampleLoopCount; ++iSampleLoop) {
+                ma_uint8 smplLoopData[MA_DR_WAV_SMPL_LOOP_BYTES];
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, smplLoopData, sizeof(smplLoopData), &totalBytesRead);
+                if (bytesJustRead == sizeof(smplLoopData)) {
+                    pMetadata->data.smpl.pLoops[iSampleLoop].cuePointId        = ma_dr_wav_bytes_to_u32(smplLoopData + 0);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].type              = ma_dr_wav_bytes_to_u32(smplLoopData + 4);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].firstSampleOffset = ma_dr_wav_bytes_to_u32(smplLoopData + 8);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].lastSampleOffset  = ma_dr_wav_bytes_to_u32(smplLoopData + 12);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].sampleFraction    = ma_dr_wav_bytes_to_u32(smplLoopData + 16);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].playCount         = ma_dr_wav_bytes_to_u32(smplLoopData + 20);
+                } else {
+                    break;
+                }
+            }
+            if (pMetadata->data.smpl.samplerSpecificDataSizeInBytes > 0) {
+                pMetadata->data.smpl.pSamplerSpecificData = ma_dr_wav__metadata_get_memory(pParser, pMetadata->data.smpl.samplerSpecificDataSizeInBytes, 1);
+                MA_DR_WAV_ASSERT(pMetadata->data.smpl.pSamplerSpecificData != NULL);
+                ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.smpl.pSamplerSpecificData, pMetadata->data.smpl.samplerSpecificDataSizeInBytes, &totalBytesRead);
+            }
+        }
+    }
+    return totalBytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_cue_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, const ma_dr_wav_chunk_header* pChunkHeader, ma_dr_wav_metadata* pMetadata)
+{
+    ma_uint8 cueHeaderSectionData[MA_DR_WAV_CUE_BYTES];
+    ma_uint64 totalBytesRead = 0;
+    size_t bytesJustRead;
+    if (pMetadata == NULL) {
+        return 0;
+    }
+    bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, cueHeaderSectionData, sizeof(cueHeaderSectionData), &totalBytesRead);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesJustRead == sizeof(cueHeaderSectionData)) {
+        pMetadata->type                   = ma_dr_wav_metadata_type_cue;
+        pMetadata->data.cue.cuePointCount = ma_dr_wav_bytes_to_u32(cueHeaderSectionData);
+        if (pMetadata->data.cue.cuePointCount == (pChunkHeader->sizeInBytes - MA_DR_WAV_CUE_BYTES) / MA_DR_WAV_CUE_POINT_BYTES) {
+            pMetadata->data.cue.pCuePoints    = (ma_dr_wav_cue_point*)ma_dr_wav__metadata_get_memory(pParser, sizeof(ma_dr_wav_cue_point) * pMetadata->data.cue.cuePointCount, MA_DR_WAV_METADATA_ALIGNMENT);
+            MA_DR_WAV_ASSERT(pMetadata->data.cue.pCuePoints != NULL);
+            if (pMetadata->data.cue.cuePointCount > 0) {
+                ma_uint32 iCuePoint;
+                for (iCuePoint = 0; iCuePoint < pMetadata->data.cue.cuePointCount; ++iCuePoint) {
+                    ma_uint8 cuePointData[MA_DR_WAV_CUE_POINT_BYTES];
+                    bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, cuePointData, sizeof(cuePointData), &totalBytesRead);
+                    if (bytesJustRead == sizeof(cuePointData)) {
+                        pMetadata->data.cue.pCuePoints[iCuePoint].id                = ma_dr_wav_bytes_to_u32(cuePointData + 0);
+                        pMetadata->data.cue.pCuePoints[iCuePoint].playOrderPosition = ma_dr_wav_bytes_to_u32(cuePointData + 4);
+                        pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId[0]    = cuePointData[8];
+                        pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId[1]    = cuePointData[9];
+                        pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId[2]    = cuePointData[10];
+                        pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId[3]    = cuePointData[11];
+                        pMetadata->data.cue.pCuePoints[iCuePoint].chunkStart        = ma_dr_wav_bytes_to_u32(cuePointData + 12);
+                        pMetadata->data.cue.pCuePoints[iCuePoint].blockStart        = ma_dr_wav_bytes_to_u32(cuePointData + 16);
+                        pMetadata->data.cue.pCuePoints[iCuePoint].sampleOffset      = ma_dr_wav_bytes_to_u32(cuePointData + 20);
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return totalBytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_inst_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata)
+{
+    ma_uint8 instData[MA_DR_WAV_INST_BYTES];
+    ma_uint64 bytesRead;
+    if (pMetadata == NULL) {
+        return 0;
+    }
+    bytesRead = ma_dr_wav__metadata_parser_read(pParser, instData, sizeof(instData), NULL);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesRead == sizeof(instData)) {
+        pMetadata->type                    = ma_dr_wav_metadata_type_inst;
+        pMetadata->data.inst.midiUnityNote = (ma_int8)instData[0];
+        pMetadata->data.inst.fineTuneCents = (ma_int8)instData[1];
+        pMetadata->data.inst.gainDecibels  = (ma_int8)instData[2];
+        pMetadata->data.inst.lowNote       = (ma_int8)instData[3];
+        pMetadata->data.inst.highNote      = (ma_int8)instData[4];
+        pMetadata->data.inst.lowVelocity   = (ma_int8)instData[5];
+        pMetadata->data.inst.highVelocity  = (ma_int8)instData[6];
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_acid_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata)
+{
+    ma_uint8 acidData[MA_DR_WAV_ACID_BYTES];
+    ma_uint64 bytesRead;
+    if (pMetadata == NULL) {
+        return 0;
+    }
+    bytesRead = ma_dr_wav__metadata_parser_read(pParser, acidData, sizeof(acidData), NULL);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesRead == sizeof(acidData)) {
+        pMetadata->type                       = ma_dr_wav_metadata_type_acid;
+        pMetadata->data.acid.flags            = ma_dr_wav_bytes_to_u32(acidData + 0);
+        pMetadata->data.acid.midiUnityNote    = ma_dr_wav_bytes_to_u16(acidData + 4);
+        pMetadata->data.acid.reserved1        = ma_dr_wav_bytes_to_u16(acidData + 6);
+        pMetadata->data.acid.reserved2        = ma_dr_wav_bytes_to_f32(acidData + 8);
+        pMetadata->data.acid.numBeats         = ma_dr_wav_bytes_to_u32(acidData + 12);
+        pMetadata->data.acid.meterDenominator = ma_dr_wav_bytes_to_u16(acidData + 16);
+        pMetadata->data.acid.meterNumerator   = ma_dr_wav_bytes_to_u16(acidData + 18);
+        pMetadata->data.acid.tempo            = ma_dr_wav_bytes_to_f32(acidData + 20);
+    }
+    return bytesRead;
+}
+MA_PRIVATE size_t ma_dr_wav__strlen(const char* str)
+{
+    size_t result = 0;
+    while (*str++) {
+        result += 1;
+    }
+    return result;
+}
+MA_PRIVATE size_t ma_dr_wav__strlen_clamped(const char* str, size_t maxToRead)
+{
+    size_t result = 0;
+    while (*str++ && result < maxToRead) {
+        result += 1;
+    }
+    return result;
+}
+MA_PRIVATE char* ma_dr_wav__metadata_copy_string(ma_dr_wav__metadata_parser* pParser, const char* str, size_t maxToRead)
+{
+    size_t len = ma_dr_wav__strlen_clamped(str, maxToRead);
+    if (len) {
+        char* result = (char*)ma_dr_wav__metadata_get_memory(pParser, len + 1, 1);
+        MA_DR_WAV_ASSERT(result != NULL);
+        MA_DR_WAV_COPY_MEMORY(result, str, len);
+        result[len] = '\0';
+        return result;
+    } else {
+        return NULL;
+    }
+}
+typedef struct
+{
+    const void* pBuffer;
+    size_t sizeInBytes;
+    size_t cursor;
+} ma_dr_wav_buffer_reader;
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_init(const void* pBuffer, size_t sizeInBytes, ma_dr_wav_buffer_reader* pReader)
+{
+    MA_DR_WAV_ASSERT(pBuffer != NULL);
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    MA_DR_WAV_ZERO_OBJECT(pReader);
+    pReader->pBuffer     = pBuffer;
+    pReader->sizeInBytes = sizeInBytes;
+    pReader->cursor      = 0;
+    return MA_SUCCESS;
+}
+MA_PRIVATE const void* ma_dr_wav_buffer_reader_ptr(const ma_dr_wav_buffer_reader* pReader)
+{
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    return ma_dr_wav_offset_ptr(pReader->pBuffer, pReader->cursor);
+}
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_seek(ma_dr_wav_buffer_reader* pReader, size_t bytesToSeek)
+{
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    if (pReader->cursor + bytesToSeek > pReader->sizeInBytes) {
+        return MA_BAD_SEEK;
+    }
+    pReader->cursor += bytesToSeek;
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_read(ma_dr_wav_buffer_reader* pReader, void* pDst, size_t bytesToRead, size_t* pBytesRead)
+{
+    ma_result result = MA_SUCCESS;
+    size_t bytesRemaining;
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    if (pBytesRead != NULL) {
+        *pBytesRead = 0;
+    }
+    bytesRemaining = (pReader->sizeInBytes - pReader->cursor);
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+    if (pDst == NULL) {
+        result = ma_dr_wav_buffer_reader_seek(pReader, bytesToRead);
+    } else {
+        MA_DR_WAV_COPY_MEMORY(pDst, ma_dr_wav_buffer_reader_ptr(pReader), bytesToRead);
+        pReader->cursor += bytesToRead;
+    }
+    MA_DR_WAV_ASSERT(pReader->cursor <= pReader->sizeInBytes);
+    if (result == MA_SUCCESS) {
+        if (pBytesRead != NULL) {
+            *pBytesRead = bytesToRead;
+        }
+    }
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_read_u16(ma_dr_wav_buffer_reader* pReader, ma_uint16* pDst)
+{
+    ma_result result;
+    size_t bytesRead;
+    ma_uint8 data[2];
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    MA_DR_WAV_ASSERT(pDst != NULL);
+    *pDst = 0;
+    result = ma_dr_wav_buffer_reader_read(pReader, data, sizeof(*pDst), &bytesRead);
+    if (result != MA_SUCCESS || bytesRead != sizeof(*pDst)) {
+        return result;
+    }
+    *pDst = ma_dr_wav_bytes_to_u16(data);
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_read_u32(ma_dr_wav_buffer_reader* pReader, ma_uint32* pDst)
+{
+    ma_result result;
+    size_t bytesRead;
+    ma_uint8 data[4];
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    MA_DR_WAV_ASSERT(pDst != NULL);
+    *pDst = 0;
+    result = ma_dr_wav_buffer_reader_read(pReader, data, sizeof(*pDst), &bytesRead);
+    if (result != MA_SUCCESS || bytesRead != sizeof(*pDst)) {
+        return result;
+    }
+    *pDst = ma_dr_wav_bytes_to_u32(data);
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_bext_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata, ma_uint64 chunkSize)
+{
+    ma_uint8 bextData[MA_DR_WAV_BEXT_BYTES];
+    size_t bytesRead = ma_dr_wav__metadata_parser_read(pParser, bextData, sizeof(bextData), NULL);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesRead == sizeof(bextData)) {
+        ma_dr_wav_buffer_reader reader;
+        ma_uint32 timeReferenceLow;
+        ma_uint32 timeReferenceHigh;
+        size_t extraBytes;
+        pMetadata->type = ma_dr_wav_metadata_type_bext;
+        if (ma_dr_wav_buffer_reader_init(bextData, bytesRead, &reader) == MA_SUCCESS) {
+            pMetadata->data.bext.pDescription = ma_dr_wav__metadata_copy_string(pParser, (const char*)ma_dr_wav_buffer_reader_ptr(&reader), MA_DR_WAV_BEXT_DESCRIPTION_BYTES);
+            ma_dr_wav_buffer_reader_seek(&reader, MA_DR_WAV_BEXT_DESCRIPTION_BYTES);
+            pMetadata->data.bext.pOriginatorName = ma_dr_wav__metadata_copy_string(pParser, (const char*)ma_dr_wav_buffer_reader_ptr(&reader), MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES);
+            ma_dr_wav_buffer_reader_seek(&reader, MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES);
+            pMetadata->data.bext.pOriginatorReference = ma_dr_wav__metadata_copy_string(pParser, (const char*)ma_dr_wav_buffer_reader_ptr(&reader), MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES);
+            ma_dr_wav_buffer_reader_seek(&reader, MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES);
+            ma_dr_wav_buffer_reader_read(&reader, pMetadata->data.bext.pOriginationDate, sizeof(pMetadata->data.bext.pOriginationDate), NULL);
+            ma_dr_wav_buffer_reader_read(&reader, pMetadata->data.bext.pOriginationTime, sizeof(pMetadata->data.bext.pOriginationTime), NULL);
+            ma_dr_wav_buffer_reader_read_u32(&reader, &timeReferenceLow);
+            ma_dr_wav_buffer_reader_read_u32(&reader, &timeReferenceHigh);
+            pMetadata->data.bext.timeReference = ((ma_uint64)timeReferenceHigh << 32) + timeReferenceLow;
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.version);
+            pMetadata->data.bext.pUMID = ma_dr_wav__metadata_get_memory(pParser, MA_DR_WAV_BEXT_UMID_BYTES, 1);
+            ma_dr_wav_buffer_reader_read(&reader, pMetadata->data.bext.pUMID, MA_DR_WAV_BEXT_UMID_BYTES, NULL);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.loudnessValue);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.loudnessRange);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.maxTruePeakLevel);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.maxMomentaryLoudness);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.maxShortTermLoudness);
+            MA_DR_WAV_ASSERT((ma_dr_wav_offset_ptr(ma_dr_wav_buffer_reader_ptr(&reader), MA_DR_WAV_BEXT_RESERVED_BYTES)) == (bextData + MA_DR_WAV_BEXT_BYTES));
+            extraBytes = (size_t)(chunkSize - MA_DR_WAV_BEXT_BYTES);
+            if (extraBytes > 0) {
+                pMetadata->data.bext.pCodingHistory = (char*)ma_dr_wav__metadata_get_memory(pParser, extraBytes + 1, 1);
+                MA_DR_WAV_ASSERT(pMetadata->data.bext.pCodingHistory != NULL);
+                bytesRead += ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.bext.pCodingHistory, extraBytes, NULL);
+                pMetadata->data.bext.codingHistorySize = (ma_uint32)ma_dr_wav__strlen(pMetadata->data.bext.pCodingHistory);
+            } else {
+                pMetadata->data.bext.pCodingHistory    = NULL;
+                pMetadata->data.bext.codingHistorySize = 0;
+            }
+        }
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_list_label_or_note_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata, ma_uint64 chunkSize, ma_dr_wav_metadata_type type)
+{
+    ma_uint8 cueIDBuffer[MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES];
+    ma_uint64 totalBytesRead = 0;
+    size_t bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, cueIDBuffer, sizeof(cueIDBuffer), &totalBytesRead);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesJustRead == sizeof(cueIDBuffer)) {
+        ma_uint32 sizeIncludingNullTerminator;
+        pMetadata->type = type;
+        pMetadata->data.labelOrNote.cuePointId = ma_dr_wav_bytes_to_u32(cueIDBuffer);
+        sizeIncludingNullTerminator = (ma_uint32)chunkSize - MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES;
+        if (sizeIncludingNullTerminator > 0) {
+            pMetadata->data.labelOrNote.stringLength = sizeIncludingNullTerminator - 1;
+            pMetadata->data.labelOrNote.pString      = (char*)ma_dr_wav__metadata_get_memory(pParser, sizeIncludingNullTerminator, 1);
+            MA_DR_WAV_ASSERT(pMetadata->data.labelOrNote.pString != NULL);
+            ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.labelOrNote.pString, sizeIncludingNullTerminator, &totalBytesRead);
+        } else {
+            pMetadata->data.labelOrNote.stringLength = 0;
+            pMetadata->data.labelOrNote.pString      = NULL;
+        }
+    }
+    return totalBytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_list_labelled_cue_region_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata, ma_uint64 chunkSize)
+{
+    ma_uint8 buffer[MA_DR_WAV_LIST_LABELLED_TEXT_BYTES];
+    ma_uint64 totalBytesRead = 0;
+    size_t bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, sizeof(buffer), &totalBytesRead);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesJustRead == sizeof(buffer)) {
+        ma_uint32 sizeIncludingNullTerminator;
+        pMetadata->type                                = ma_dr_wav_metadata_type_list_labelled_cue_region;
+        pMetadata->data.labelledCueRegion.cuePointId   = ma_dr_wav_bytes_to_u32(buffer + 0);
+        pMetadata->data.labelledCueRegion.sampleLength = ma_dr_wav_bytes_to_u32(buffer + 4);
+        pMetadata->data.labelledCueRegion.purposeId[0] = buffer[8];
+        pMetadata->data.labelledCueRegion.purposeId[1] = buffer[9];
+        pMetadata->data.labelledCueRegion.purposeId[2] = buffer[10];
+        pMetadata->data.labelledCueRegion.purposeId[3] = buffer[11];
+        pMetadata->data.labelledCueRegion.country      = ma_dr_wav_bytes_to_u16(buffer + 12);
+        pMetadata->data.labelledCueRegion.language     = ma_dr_wav_bytes_to_u16(buffer + 14);
+        pMetadata->data.labelledCueRegion.dialect      = ma_dr_wav_bytes_to_u16(buffer + 16);
+        pMetadata->data.labelledCueRegion.codePage     = ma_dr_wav_bytes_to_u16(buffer + 18);
+        sizeIncludingNullTerminator = (ma_uint32)chunkSize - MA_DR_WAV_LIST_LABELLED_TEXT_BYTES;
+        if (sizeIncludingNullTerminator > 0) {
+            pMetadata->data.labelledCueRegion.stringLength = sizeIncludingNullTerminator - 1;
+            pMetadata->data.labelledCueRegion.pString      = (char*)ma_dr_wav__metadata_get_memory(pParser, sizeIncludingNullTerminator, 1);
+            MA_DR_WAV_ASSERT(pMetadata->data.labelledCueRegion.pString != NULL);
+            ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.labelledCueRegion.pString, sizeIncludingNullTerminator, &totalBytesRead);
+        } else {
+            pMetadata->data.labelledCueRegion.stringLength = 0;
+            pMetadata->data.labelledCueRegion.pString      = NULL;
+        }
+    }
+    return totalBytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__metadata_process_info_text_chunk(ma_dr_wav__metadata_parser* pParser, ma_uint64 chunkSize, ma_dr_wav_metadata_type type)
+{
+    ma_uint64 bytesRead = 0;
+    ma_uint32 stringSizeWithNullTerminator = (ma_uint32)chunkSize;
+    if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+        pParser->metadataCount += 1;
+        ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, stringSizeWithNullTerminator, 1);
+    } else {
+        ma_dr_wav_metadata* pMetadata = &pParser->pMetadata[pParser->metadataCursor];
+        pMetadata->type = type;
+        if (stringSizeWithNullTerminator > 0) {
+            pMetadata->data.infoText.stringLength = stringSizeWithNullTerminator - 1;
+            pMetadata->data.infoText.pString = (char*)ma_dr_wav__metadata_get_memory(pParser, stringSizeWithNullTerminator, 1);
+            MA_DR_WAV_ASSERT(pMetadata->data.infoText.pString != NULL);
+            bytesRead = ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.infoText.pString, (size_t)stringSizeWithNullTerminator, NULL);
+            if (bytesRead == chunkSize) {
+                pParser->metadataCursor += 1;
+            } else {
+            }
+        } else {
+            pMetadata->data.infoText.stringLength = 0;
+            pMetadata->data.infoText.pString      = NULL;
+            pParser->metadataCursor += 1;
+        }
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__metadata_process_unknown_chunk(ma_dr_wav__metadata_parser* pParser, const ma_uint8* pChunkId, ma_uint64 chunkSize, ma_dr_wav_metadata_location location)
+{
+    ma_uint64 bytesRead = 0;
+    if (location == ma_dr_wav_metadata_location_invalid) {
+        return 0;
+    }
+    if (ma_dr_wav_fourcc_equal(pChunkId, "data") || ma_dr_wav_fourcc_equal(pChunkId, "fmt ") || ma_dr_wav_fourcc_equal(pChunkId, "fact")) {
+        return 0;
+    }
+    if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+        pParser->metadataCount += 1;
+        ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, (size_t)chunkSize, 1);
+    } else {
+        ma_dr_wav_metadata* pMetadata = &pParser->pMetadata[pParser->metadataCursor];
+        pMetadata->type                         = ma_dr_wav_metadata_type_unknown;
+        pMetadata->data.unknown.chunkLocation   = location;
+        pMetadata->data.unknown.id[0]           = pChunkId[0];
+        pMetadata->data.unknown.id[1]           = pChunkId[1];
+        pMetadata->data.unknown.id[2]           = pChunkId[2];
+        pMetadata->data.unknown.id[3]           = pChunkId[3];
+        pMetadata->data.unknown.dataSizeInBytes = (ma_uint32)chunkSize;
+        pMetadata->data.unknown.pData           = (ma_uint8 *)ma_dr_wav__metadata_get_memory(pParser, (size_t)chunkSize, 1);
+        MA_DR_WAV_ASSERT(pMetadata->data.unknown.pData != NULL);
+        bytesRead = ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.unknown.pData, pMetadata->data.unknown.dataSizeInBytes, NULL);
+        if (bytesRead == pMetadata->data.unknown.dataSizeInBytes) {
+            pParser->metadataCursor += 1;
+        } else {
+        }
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__chunk_matches(ma_dr_wav_metadata_type allowedMetadataTypes, const ma_uint8* pChunkID, ma_dr_wav_metadata_type type, const char* pID)
+{
+    return (allowedMetadataTypes & type) && ma_dr_wav_fourcc_equal(pChunkID, pID);
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__metadata_process_chunk(ma_dr_wav__metadata_parser* pParser, const ma_dr_wav_chunk_header* pChunkHeader, ma_dr_wav_metadata_type allowedMetadataTypes)
+{
+    const ma_uint8 *pChunkID = pChunkHeader->id.fourcc;
+    ma_uint64 bytesRead = 0;
+    if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_smpl, "smpl")) {
+        if (pChunkHeader->sizeInBytes >= MA_DR_WAV_SMPL_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                ma_uint8 buffer[4];
+                size_t bytesJustRead;
+                if (!pParser->onSeek(pParser->pReadSeekUserData, 28, MA_DR_WAV_SEEK_CUR)) {
+                    return bytesRead;
+                }
+                bytesRead += 28;
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, sizeof(buffer), &bytesRead);
+                if (bytesJustRead == sizeof(buffer)) {
+                    ma_uint32 loopCount = ma_dr_wav_bytes_to_u32(buffer);
+                    ma_uint64 calculatedLoopCount;
+                    calculatedLoopCount = (pChunkHeader->sizeInBytes - MA_DR_WAV_SMPL_BYTES) / MA_DR_WAV_SMPL_LOOP_BYTES;
+                    if (calculatedLoopCount == loopCount) {
+                        bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, sizeof(buffer), &bytesRead);
+                        if (bytesJustRead == sizeof(buffer)) {
+                            ma_uint32 samplerSpecificDataSizeInBytes = ma_dr_wav_bytes_to_u32(buffer);
+                            pParser->metadataCount += 1;
+                            ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, sizeof(ma_dr_wav_smpl_loop) * loopCount, MA_DR_WAV_METADATA_ALIGNMENT);
+                            ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, samplerSpecificDataSizeInBytes, 1);
+                        }
+                    } else {
+                    }
+                }
+            } else {
+                bytesRead = ma_dr_wav__read_smpl_to_metadata_obj(pParser, pChunkHeader, &pParser->pMetadata[pParser->metadataCursor]);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_inst, "inst")) {
+        if (pChunkHeader->sizeInBytes == MA_DR_WAV_INST_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                pParser->metadataCount += 1;
+            } else {
+                bytesRead = ma_dr_wav__read_inst_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor]);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_acid, "acid")) {
+        if (pChunkHeader->sizeInBytes == MA_DR_WAV_ACID_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                pParser->metadataCount += 1;
+            } else {
+                bytesRead = ma_dr_wav__read_acid_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor]);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_cue, "cue ")) {
+        if (pChunkHeader->sizeInBytes >= MA_DR_WAV_CUE_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                size_t cueCount;
+                pParser->metadataCount += 1;
+                cueCount = (size_t)(pChunkHeader->sizeInBytes - MA_DR_WAV_CUE_BYTES) / MA_DR_WAV_CUE_POINT_BYTES;
+                ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, sizeof(ma_dr_wav_cue_point) * cueCount, MA_DR_WAV_METADATA_ALIGNMENT);
+            } else {
+                bytesRead = ma_dr_wav__read_cue_to_metadata_obj(pParser, pChunkHeader, &pParser->pMetadata[pParser->metadataCursor]);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_bext, "bext")) {
+        if (pChunkHeader->sizeInBytes >= MA_DR_WAV_BEXT_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                char buffer[MA_DR_WAV_BEXT_DESCRIPTION_BYTES + 1];
+                size_t allocSizeNeeded = MA_DR_WAV_BEXT_UMID_BYTES;
+                size_t bytesJustRead;
+                buffer[MA_DR_WAV_BEXT_DESCRIPTION_BYTES] = '\0';
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, MA_DR_WAV_BEXT_DESCRIPTION_BYTES, &bytesRead);
+                if (bytesJustRead != MA_DR_WAV_BEXT_DESCRIPTION_BYTES) {
+                    return bytesRead;
+                }
+                allocSizeNeeded += ma_dr_wav__strlen(buffer) + 1;
+                buffer[MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES] = '\0';
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES, &bytesRead);
+                if (bytesJustRead != MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES) {
+                    return bytesRead;
+                }
+                allocSizeNeeded += ma_dr_wav__strlen(buffer) + 1;
+                buffer[MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES] = '\0';
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES, &bytesRead);
+                if (bytesJustRead != MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES) {
+                    return bytesRead;
+                }
+                allocSizeNeeded += ma_dr_wav__strlen(buffer) + 1;
+                allocSizeNeeded += (size_t)pChunkHeader->sizeInBytes - MA_DR_WAV_BEXT_BYTES + 1;
+                ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, allocSizeNeeded, 1);
+                pParser->metadataCount += 1;
+            } else {
+                bytesRead = ma_dr_wav__read_bext_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor], pChunkHeader->sizeInBytes);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav_fourcc_equal(pChunkID, "LIST") || ma_dr_wav_fourcc_equal(pChunkID, "list")) {
+        ma_dr_wav_metadata_location listType = ma_dr_wav_metadata_location_invalid;
+        while (bytesRead < pChunkHeader->sizeInBytes) {
+            ma_uint8 subchunkId[4];
+            ma_uint8 subchunkSizeBuffer[4];
+            ma_uint64 subchunkDataSize;
+            ma_uint64 subchunkBytesRead = 0;
+            ma_uint64 bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, subchunkId, sizeof(subchunkId), &bytesRead);
+            if (bytesJustRead != sizeof(subchunkId)) {
+                break;
+            }
+            if (ma_dr_wav_fourcc_equal(subchunkId, "adtl")) {
+                listType = ma_dr_wav_metadata_location_inside_adtl_list;
+                continue;
+            } else if (ma_dr_wav_fourcc_equal(subchunkId, "INFO")) {
+                listType = ma_dr_wav_metadata_location_inside_info_list;
+                continue;
+            }
+            bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, subchunkSizeBuffer, sizeof(subchunkSizeBuffer), &bytesRead);
+            if (bytesJustRead != sizeof(subchunkSizeBuffer)) {
+                break;
+            }
+            subchunkDataSize = ma_dr_wav_bytes_to_u32(subchunkSizeBuffer);
+            if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_label, "labl") || ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_note, "note")) {
+                if (subchunkDataSize >= MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES) {
+                    ma_uint64 stringSizeWithNullTerm = subchunkDataSize - MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES;
+                    if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                        pParser->metadataCount += 1;
+                        ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, (size_t)stringSizeWithNullTerm, 1);
+                    } else {
+                        subchunkBytesRead = ma_dr_wav__read_list_label_or_note_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor], subchunkDataSize, ma_dr_wav_fourcc_equal(subchunkId, "labl") ? ma_dr_wav_metadata_type_list_label : ma_dr_wav_metadata_type_list_note);
+                        if (subchunkBytesRead == subchunkDataSize) {
+                            pParser->metadataCursor += 1;
+                        } else {
+                        }
+                    }
+                } else {
+                }
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_labelled_cue_region, "ltxt")) {
+                if (subchunkDataSize >= MA_DR_WAV_LIST_LABELLED_TEXT_BYTES) {
+                    ma_uint64 stringSizeWithNullTerminator = subchunkDataSize - MA_DR_WAV_LIST_LABELLED_TEXT_BYTES;
+                    if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                        pParser->metadataCount += 1;
+                        ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, (size_t)stringSizeWithNullTerminator, 1);
+                    } else {
+                        subchunkBytesRead = ma_dr_wav__read_list_labelled_cue_region_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor], subchunkDataSize);
+                        if (subchunkBytesRead == subchunkDataSize) {
+                            pParser->metadataCursor += 1;
+                        } else {
+                        }
+                    }
+                } else {
+                }
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_software, "ISFT")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_software);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_copyright, "ICOP")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_copyright);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_title, "INAM")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_title);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_artist, "IART")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_artist);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_comment, "ICMT")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_comment);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_date, "ICRD")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_date);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_genre, "IGNR")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_genre);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_album, "IPRD")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_album);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_tracknumber, "ITRK")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_tracknumber);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_location, "IARL")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_location);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_organization, "ICMS")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_organization);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_keywords, "IKEY")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_keywords);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_medium, "IMED")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_medium);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_description, "ISBJ")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_description);
+            } else if ((allowedMetadataTypes & ma_dr_wav_metadata_type_unknown) != 0) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_unknown_chunk(pParser, subchunkId, subchunkDataSize, listType);
+            }
+            bytesRead += subchunkBytesRead;
+            MA_DR_WAV_ASSERT(subchunkBytesRead <= subchunkDataSize);
+            if (subchunkBytesRead < subchunkDataSize) {
+                ma_uint64 bytesToSeek = subchunkDataSize - subchunkBytesRead;
+                if (!pParser->onSeek(pParser->pReadSeekUserData, (int)bytesToSeek, MA_DR_WAV_SEEK_CUR)) {
+                    break;
+                }
+                bytesRead += bytesToSeek;
+            }
+            if ((subchunkDataSize % 2) == 1) {
+                if (!pParser->onSeek(pParser->pReadSeekUserData, 1, MA_DR_WAV_SEEK_CUR)) {
+                    break;
+                }
+                bytesRead += 1;
+            }
+        }
+    } else if ((allowedMetadataTypes & ma_dr_wav_metadata_type_unknown) != 0) {
+        bytesRead = ma_dr_wav__metadata_process_unknown_chunk(pParser, pChunkID, pChunkHeader->sizeInBytes, ma_dr_wav_metadata_location_top_level);
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_uint32 ma_dr_wav_get_bytes_per_pcm_frame(ma_dr_wav* pWav)
+{
+    ma_uint32 bytesPerFrame;
+    if ((pWav->bitsPerSample & 0x7) == 0) {
+        bytesPerFrame = (pWav->bitsPerSample * pWav->fmt.channels) >> 3;
+    } else {
+        bytesPerFrame = pWav->fmt.blockAlign;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ALAW || pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_MULAW) {
+        if (bytesPerFrame != pWav->fmt.channels) {
+            return 0;
+        }
+    }
+    return bytesPerFrame;
+}
+MA_API ma_uint16 ma_dr_wav_fmt_get_format(const ma_dr_wav_fmt* pFMT)
+{
+    if (pFMT == NULL) {
+        return 0;
+    }
+    if (pFMT->formatTag != MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+        return pFMT->formatTag;
+    } else {
+        return ma_dr_wav_bytes_to_u16(pFMT->subFormat);
+    }
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_preinit(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pReadSeekTellUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pWav == NULL || onRead == NULL || onSeek == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_WAV_ZERO_MEMORY(pWav, sizeof(*pWav));
+    pWav->onRead    = onRead;
+    pWav->onSeek    = onSeek;
+    pWav->onTell    = onTell;
+    pWav->pUserData = pReadSeekTellUserData;
+    pWav->allocationCallbacks = ma_dr_wav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
+    if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init__internal(ma_dr_wav* pWav, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags)
+{
+    ma_result result;
+    ma_uint64 cursor;
+    ma_bool32 sequential;
+    ma_uint8 riff[4];
+    ma_dr_wav_fmt fmt;
+    unsigned short translatedFormatTag;
+    ma_uint64 dataChunkSize = 0;
+    ma_uint64 sampleCountFromFactChunk = 0;
+    ma_uint64 metadataStartPos;
+    ma_dr_wav__metadata_parser metadataParser;
+    ma_bool8 isProcessingMetadata = MA_FALSE;
+    ma_bool8 foundChunk_fmt  = MA_FALSE;
+    ma_bool8 foundChunk_data = MA_FALSE;
+    ma_bool8 isAIFCFormType = MA_FALSE;
+    ma_uint64 aiffFrameCount = 0;
+    cursor = 0;
+    sequential = (flags & MA_DR_WAV_SEQUENTIAL) != 0;
+    MA_DR_WAV_ZERO_OBJECT(&fmt);
+    if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, riff, sizeof(riff), &cursor) != sizeof(riff)) {
+        return MA_FALSE;
+    }
+    if (ma_dr_wav_fourcc_equal(riff, "RIFF")) {
+        pWav->container = ma_dr_wav_container_riff;
+    } else if (ma_dr_wav_fourcc_equal(riff, "RIFX")) {
+        pWav->container = ma_dr_wav_container_rifx;
+    } else if (ma_dr_wav_fourcc_equal(riff, "riff")) {
+        int i;
+        ma_uint8 riff2[12];
+        pWav->container = ma_dr_wav_container_w64;
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, riff2, sizeof(riff2), &cursor) != sizeof(riff2)) {
+            return MA_FALSE;
+        }
+        for (i = 0; i < 12; ++i) {
+            if (riff2[i] != ma_dr_wavGUID_W64_RIFF[i+4]) {
+                return MA_FALSE;
+            }
+        }
+    } else if (ma_dr_wav_fourcc_equal(riff, "RF64")) {
+        pWav->container = ma_dr_wav_container_rf64;
+    } else if (ma_dr_wav_fourcc_equal(riff, "FORM")) {
+        pWav->container = ma_dr_wav_container_aiff;
+    } else {
+        return MA_FALSE;
+    }
+    if (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx || pWav->container == ma_dr_wav_container_rf64) {
+        ma_uint8 chunkSizeBytes[4];
+        ma_uint8 wave[4];
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
+            return MA_FALSE;
+        }
+        if (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx) {
+            if (ma_dr_wav_bytes_to_u32_ex(chunkSizeBytes, pWav->container) < 36) {
+            }
+        } else if (pWav->container == ma_dr_wav_container_rf64) {
+            if (ma_dr_wav_bytes_to_u32_le(chunkSizeBytes) != 0xFFFFFFFF) {
+                return MA_FALSE;
+            }
+        } else {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, wave, sizeof(wave), &cursor) != sizeof(wave)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_wav_fourcc_equal(wave, "WAVE")) {
+            return MA_FALSE;
+        }
+    } else if (pWav->container == ma_dr_wav_container_w64) {
+        ma_uint8 chunkSizeBytes[8];
+        ma_uint8 wave[16];
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav_bytes_to_u64(chunkSizeBytes) < 80) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, wave, sizeof(wave), &cursor) != sizeof(wave)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_wav_guid_equal(wave, ma_dr_wavGUID_W64_WAVE)) {
+            return MA_FALSE;
+        }
+    } else if (pWav->container == ma_dr_wav_container_aiff) {
+        ma_uint8 chunkSizeBytes[4];
+        ma_uint8 aiff[4];
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav_bytes_to_u32_be(chunkSizeBytes) < 18) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, aiff, sizeof(aiff), &cursor) != sizeof(aiff)) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav_fourcc_equal(aiff, "AIFF")) {
+            isAIFCFormType = MA_FALSE;
+        } else if (ma_dr_wav_fourcc_equal(aiff, "AIFC")) {
+            isAIFCFormType = MA_TRUE;
+        } else {
+            return MA_FALSE;
+        }
+    } else {
+        return MA_FALSE;
+    }
+    if (pWav->container == ma_dr_wav_container_rf64) {
+        ma_uint8 sizeBytes[8];
+        ma_uint64 bytesRemainingInChunk;
+        ma_dr_wav_chunk_header header;
+        result = ma_dr_wav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
+        if (result != MA_SUCCESS) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_wav_fourcc_equal(header.id.fourcc, "ds64")) {
+            return MA_FALSE;
+        }
+        bytesRemainingInChunk = header.sizeInBytes + header.paddingSize;
+        if (!ma_dr_wav__seek_forward(pWav->onSeek, 8, pWav->pUserData)) {
+            return MA_FALSE;
+        }
+        bytesRemainingInChunk -= 8;
+        cursor += 8;
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, sizeBytes, sizeof(sizeBytes), &cursor) != sizeof(sizeBytes)) {
+            return MA_FALSE;
+        }
+        bytesRemainingInChunk -= 8;
+        dataChunkSize = ma_dr_wav_bytes_to_u64(sizeBytes);
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, sizeBytes, sizeof(sizeBytes), &cursor) != sizeof(sizeBytes)) {
+            return MA_FALSE;
+        }
+        bytesRemainingInChunk -= 8;
+        sampleCountFromFactChunk = ma_dr_wav_bytes_to_u64(sizeBytes);
+        if (!ma_dr_wav__seek_forward(pWav->onSeek, bytesRemainingInChunk, pWav->pUserData)) {
+            return MA_FALSE;
+        }
+        cursor += bytesRemainingInChunk;
+    }
+    metadataStartPos = cursor;
+    isProcessingMetadata = !sequential && ((flags & MA_DR_WAV_WITH_METADATA) != 0);
+    if (pWav->container != ma_dr_wav_container_riff && pWav->container != ma_dr_wav_container_rf64) {
+        isProcessingMetadata = MA_FALSE;
+    }
+    MA_DR_WAV_ZERO_MEMORY(&metadataParser, sizeof(metadataParser));
+    if (isProcessingMetadata) {
+        metadataParser.onRead = pWav->onRead;
+        metadataParser.onSeek = pWav->onSeek;
+        metadataParser.pReadSeekUserData = pWav->pUserData;
+        metadataParser.stage  = ma_dr_wav__metadata_parser_stage_count;
+    }
+    for (;;) {
+        ma_dr_wav_chunk_header header;
+        ma_uint64 chunkSize;
+        result = ma_dr_wav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+        chunkSize = header.sizeInBytes;
+        if (!sequential && onChunk != NULL) {
+            ma_uint64 callbackBytesRead = onChunk(pChunkUserData, pWav->onRead, pWav->onSeek, pWav->pUserData, &header, pWav->container, &fmt);
+            if (callbackBytesRead > 0) {
+                if (ma_dr_wav__seek_from_start(pWav->onSeek, cursor, pWav->pUserData) == MA_FALSE) {
+                    return MA_FALSE;
+                }
+            }
+        }
+        if (((pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx || pWav->container == ma_dr_wav_container_rf64) && ma_dr_wav_fourcc_equal(header.id.fourcc, "fmt ")) ||
+            ((pWav->container == ma_dr_wav_container_w64) && ma_dr_wav_guid_equal(header.id.guid, ma_dr_wavGUID_W64_FMT))) {
+            ma_uint8 fmtData[16];
+            foundChunk_fmt = MA_TRUE;
+            if (pWav->onRead(pWav->pUserData, fmtData, sizeof(fmtData)) != sizeof(fmtData)) {
+                return MA_FALSE;
+            }
+            cursor += sizeof(fmtData);
+            fmt.formatTag      = ma_dr_wav_bytes_to_u16_ex(fmtData + 0,  pWav->container);
+            fmt.channels       = ma_dr_wav_bytes_to_u16_ex(fmtData + 2,  pWav->container);
+            fmt.sampleRate     = ma_dr_wav_bytes_to_u32_ex(fmtData + 4,  pWav->container);
+            fmt.avgBytesPerSec = ma_dr_wav_bytes_to_u32_ex(fmtData + 8,  pWav->container);
+            fmt.blockAlign     = ma_dr_wav_bytes_to_u16_ex(fmtData + 12, pWav->container);
+            fmt.bitsPerSample  = ma_dr_wav_bytes_to_u16_ex(fmtData + 14, pWav->container);
+            fmt.extendedSize       = 0;
+            fmt.validBitsPerSample = 0;
+            fmt.channelMask        = 0;
+            MA_DR_WAV_ZERO_MEMORY(fmt.subFormat, sizeof(fmt.subFormat));
+            if (header.sizeInBytes > 16) {
+                ma_uint8 fmt_cbSize[2];
+                int bytesReadSoFar = 0;
+                if (pWav->onRead(pWav->pUserData, fmt_cbSize, sizeof(fmt_cbSize)) != sizeof(fmt_cbSize)) {
+                    return MA_FALSE;
+                }
+                cursor += sizeof(fmt_cbSize);
+                bytesReadSoFar = 18;
+                fmt.extendedSize = ma_dr_wav_bytes_to_u16_ex(fmt_cbSize, pWav->container);
+                if (fmt.extendedSize > 0) {
+                    if (fmt.formatTag == MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+                        if (fmt.extendedSize != 22) {
+                            return MA_FALSE;
+                        }
+                    }
+                    if (fmt.formatTag == MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+                        ma_uint8 fmtext[22];
+                        if (pWav->onRead(pWav->pUserData, fmtext, fmt.extendedSize) != fmt.extendedSize) {
+                            return MA_FALSE;
+                        }
+                        fmt.validBitsPerSample = ma_dr_wav_bytes_to_u16_ex(fmtext + 0, pWav->container);
+                        fmt.channelMask        = ma_dr_wav_bytes_to_u32_ex(fmtext + 2, pWav->container);
+                        ma_dr_wav_bytes_to_guid(fmtext + 6, fmt.subFormat);
+                    } else {
+                        if (pWav->onSeek(pWav->pUserData, fmt.extendedSize, MA_DR_WAV_SEEK_CUR) == MA_FALSE) {
+                            return MA_FALSE;
+                        }
+                    }
+                    cursor += fmt.extendedSize;
+                    bytesReadSoFar += fmt.extendedSize;
+                }
+                if (pWav->onSeek(pWav->pUserData, (int)(header.sizeInBytes - bytesReadSoFar), MA_DR_WAV_SEEK_CUR) == MA_FALSE) {
+                    return MA_FALSE;
+                }
+                cursor += (header.sizeInBytes - bytesReadSoFar);
+            }
+            if (header.paddingSize > 0) {
+                if (ma_dr_wav__seek_forward(pWav->onSeek, header.paddingSize, pWav->pUserData) == MA_FALSE) {
+                    break;
+                }
+                cursor += header.paddingSize;
+            }
+            continue;
+        }
+        if (((pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx || pWav->container == ma_dr_wav_container_rf64) && ma_dr_wav_fourcc_equal(header.id.fourcc, "data")) ||
+            ((pWav->container == ma_dr_wav_container_w64) && ma_dr_wav_guid_equal(header.id.guid, ma_dr_wavGUID_W64_DATA))) {
+            foundChunk_data = MA_TRUE;
+            pWav->dataChunkDataPos  = cursor;
+            if (pWav->container != ma_dr_wav_container_rf64) {
+                dataChunkSize = chunkSize;
+            }
+            if (sequential || !isProcessingMetadata) {
+                break;
+            } else {
+                chunkSize += header.paddingSize;
+                if (ma_dr_wav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData) == MA_FALSE) {
+                    break;
+                }
+                cursor += chunkSize;
+                continue;
+            }
+        }
+        if (((pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx || pWav->container == ma_dr_wav_container_rf64) && ma_dr_wav_fourcc_equal(header.id.fourcc, "fact")) ||
+            ((pWav->container == ma_dr_wav_container_w64) && ma_dr_wav_guid_equal(header.id.guid, ma_dr_wavGUID_W64_FACT))) {
+            if (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx) {
+                ma_uint8 sampleCount[4];
+                if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, &sampleCount, 4, &cursor) != 4) {
+                    return MA_FALSE;
+                }
+                chunkSize -= 4;
+                if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+                    sampleCountFromFactChunk = ma_dr_wav_bytes_to_u32_ex(sampleCount, pWav->container);
+                } else {
+                    sampleCountFromFactChunk = 0;
+                }
+            } else if (pWav->container == ma_dr_wav_container_w64) {
+                if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, &sampleCountFromFactChunk, 8, &cursor) != 8) {
+                    return MA_FALSE;
+                }
+                chunkSize -= 8;
+            } else if (pWav->container == ma_dr_wav_container_rf64) {
+            }
+            chunkSize += header.paddingSize;
+            if (ma_dr_wav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData) == MA_FALSE) {
+                break;
+            }
+            cursor += chunkSize;
+            continue;
+        }
+        if (pWav->container == ma_dr_wav_container_aiff && ma_dr_wav_fourcc_equal(header.id.fourcc, "COMM")) {
+            ma_uint8 commData[24];
+            ma_uint32 commDataBytesToRead;
+            ma_uint16 channels;
+            ma_uint32 frameCount;
+            ma_uint16 sampleSizeInBits;
+            ma_int64  sampleRate;
+            ma_uint16 compressionFormat;
+            foundChunk_fmt = MA_TRUE;
+            if (isAIFCFormType) {
+                commDataBytesToRead = 24;
+                if (header.sizeInBytes < commDataBytesToRead) {
+                    return MA_FALSE;
+                }
+            } else {
+                commDataBytesToRead = 18;
+                if (header.sizeInBytes != commDataBytesToRead) {
+                    return MA_FALSE;
+                }
+            }
+            if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, commData, commDataBytesToRead, &cursor) != commDataBytesToRead) {
+                return MA_FALSE;
+            }
+            channels         = ma_dr_wav_bytes_to_u16_ex     (commData + 0, pWav->container);
+            frameCount       = ma_dr_wav_bytes_to_u32_ex     (commData + 2, pWav->container);
+            sampleSizeInBits = ma_dr_wav_bytes_to_u16_ex     (commData + 6, pWav->container);
+            sampleRate       = ma_dr_wav_aiff_extented_to_s64(commData + 8);
+            if (sampleRate < 0 || sampleRate > 0xFFFFFFFF) {
+                return MA_FALSE;
+            }
+            if (isAIFCFormType) {
+                const ma_uint8* type = commData + 18;
+                if (ma_dr_wav_fourcc_equal(type, "NONE")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_PCM;
+                } else if (ma_dr_wav_fourcc_equal(type, "raw ")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_PCM;
+                    if (sampleSizeInBits == 8) {
+                        pWav->aiff.isUnsigned = MA_TRUE;
+                    }
+                } else if (ma_dr_wav_fourcc_equal(type, "sowt")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_PCM;
+                    pWav->aiff.isLE = MA_TRUE;
+                } else if (ma_dr_wav_fourcc_equal(type, "fl32") || ma_dr_wav_fourcc_equal(type, "fl64") || ma_dr_wav_fourcc_equal(type, "FL32") || ma_dr_wav_fourcc_equal(type, "FL64")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_IEEE_FLOAT;
+                } else if (ma_dr_wav_fourcc_equal(type, "alaw") || ma_dr_wav_fourcc_equal(type, "ALAW")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_ALAW;
+                } else if (ma_dr_wav_fourcc_equal(type, "ulaw") || ma_dr_wav_fourcc_equal(type, "ULAW")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_MULAW;
+                } else if (ma_dr_wav_fourcc_equal(type, "ima4")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_DVI_ADPCM;
+                    sampleSizeInBits  = 4;
+                    (void)compressionFormat;
+                    (void)sampleSizeInBits;
+                    return MA_FALSE;
+                } else {
+                    return MA_FALSE;
+                }
+            } else {
+                compressionFormat = MA_DR_WAVE_FORMAT_PCM;
+            }
+            aiffFrameCount = frameCount;
+            fmt.formatTag      = compressionFormat;
+            fmt.channels       = channels;
+            fmt.sampleRate     = (ma_uint32)sampleRate;
+            fmt.bitsPerSample  = sampleSizeInBits;
+            fmt.blockAlign     = (ma_uint16)(fmt.channels * fmt.bitsPerSample / 8);
+            fmt.avgBytesPerSec = fmt.blockAlign * fmt.sampleRate;
+            if (fmt.blockAlign == 0 && compressionFormat == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+                fmt.blockAlign = 34 * fmt.channels;
+            }
+            if (compressionFormat == MA_DR_WAVE_FORMAT_ALAW || compressionFormat == MA_DR_WAVE_FORMAT_MULAW) {
+                if (fmt.bitsPerSample > 8) {
+                    fmt.bitsPerSample = 8;
+                    fmt.blockAlign = fmt.channels;
+                }
+            }
+            fmt.bitsPerSample += (fmt.bitsPerSample & 7);
+            if (isAIFCFormType) {
+                if (ma_dr_wav__seek_forward(pWav->onSeek, (chunkSize - commDataBytesToRead), pWav->pUserData) == MA_FALSE) {
+                    return MA_FALSE;
+                }
+                cursor += (chunkSize - commDataBytesToRead);
+            }
+            continue;
+        }
+        if (pWav->container == ma_dr_wav_container_aiff && ma_dr_wav_fourcc_equal(header.id.fourcc, "SSND")) {
+            ma_uint8 offsetAndBlockSizeData[8];
+            ma_uint32 offset;
+            foundChunk_data = MA_TRUE;
+            if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, offsetAndBlockSizeData, sizeof(offsetAndBlockSizeData), &cursor) != sizeof(offsetAndBlockSizeData)) {
+                return MA_FALSE;
+            }
+            offset = ma_dr_wav_bytes_to_u32_ex(offsetAndBlockSizeData + 0, pWav->container);
+            pWav->dataChunkDataPos = cursor + offset;
+            dataChunkSize = chunkSize;
+            if (dataChunkSize  > offset) {
+                dataChunkSize -= offset;
+            } else {
+                dataChunkSize = 0;
+            }
+            if (sequential) {
+                if (foundChunk_fmt) {
+                    if (ma_dr_wav__seek_forward(pWav->onSeek, offset, pWav->pUserData) == MA_FALSE) {
+                        return MA_FALSE;
+                    }
+                    cursor += offset;
+                    break;
+                } else {
+                    return MA_FALSE;
+                }
+            } else {
+                chunkSize += header.paddingSize;
+                chunkSize -= sizeof(offsetAndBlockSizeData);
+                if (ma_dr_wav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData) == MA_FALSE) {
+                    break;
+                }
+                cursor += chunkSize;
+                continue;
+            }
+        }
+        if (isProcessingMetadata) {
+            ma_dr_wav__metadata_process_chunk(&metadataParser, &header, ma_dr_wav_metadata_type_all_including_unknown);
+            if (ma_dr_wav__seek_from_start(pWav->onSeek, cursor, pWav->pUserData) == MA_FALSE) {
+                break;
+            }
+        }
+        chunkSize += header.paddingSize;
+        if (ma_dr_wav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData) == MA_FALSE) {
+            break;
+        }
+        cursor += chunkSize;
+    }
+    if (!foundChunk_fmt || !foundChunk_data) {
+        return MA_FALSE;
+    }
+    if ((fmt.sampleRate    == 0 || fmt.sampleRate    > MA_DR_WAV_MAX_SAMPLE_RATE    ) ||
+        (fmt.channels      == 0 || fmt.channels      > MA_DR_WAV_MAX_CHANNELS       ) ||
+        (fmt.bitsPerSample == 0 || fmt.bitsPerSample > MA_DR_WAV_MAX_BITS_PER_SAMPLE) ||
+        fmt.blockAlign == 0) {
+        return MA_FALSE;
+    }
+    translatedFormatTag = fmt.formatTag;
+    if (translatedFormatTag == MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+        translatedFormatTag = ma_dr_wav_bytes_to_u16_ex(fmt.subFormat + 0, pWav->container);
+    }
+    if (!sequential) {
+        if (!ma_dr_wav__seek_from_start(pWav->onSeek, pWav->dataChunkDataPos, pWav->pUserData)) {
+            return MA_FALSE;
+        }
+        cursor = pWav->dataChunkDataPos;
+    }
+    if (isProcessingMetadata && metadataParser.metadataCount > 0) {
+        if (ma_dr_wav__seek_from_start(pWav->onSeek, metadataStartPos, pWav->pUserData) == MA_FALSE) {
+            return MA_FALSE;
+        }
+        result = ma_dr_wav__metadata_alloc(&metadataParser, &pWav->allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            return MA_FALSE;
+        }
+        metadataParser.stage = ma_dr_wav__metadata_parser_stage_read;
+        for (;;) {
+            ma_dr_wav_chunk_header header;
+            ma_uint64 metadataBytesRead;
+            result = ma_dr_wav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
+            if (result != MA_SUCCESS) {
+                break;
+            }
+            metadataBytesRead = ma_dr_wav__metadata_process_chunk(&metadataParser, &header, ma_dr_wav_metadata_type_all_including_unknown);
+            if (ma_dr_wav__seek_forward(pWav->onSeek, (header.sizeInBytes + header.paddingSize) - metadataBytesRead, pWav->pUserData) == MA_FALSE) {
+                ma_dr_wav_free(metadataParser.pMetadata, &pWav->allocationCallbacks);
+                return MA_FALSE;
+            }
+        }
+        pWav->pMetadata     = metadataParser.pMetadata;
+        pWav->metadataCount = metadataParser.metadataCount;
+    }
+    if (pWav->onTell != NULL && pWav->onSeek != NULL) {
+        if (pWav->onSeek(pWav->pUserData, 0, MA_DR_WAV_SEEK_END) == MA_TRUE) {
+            ma_int64 fileSize;
+            if (pWav->onTell(pWav->pUserData, &fileSize)) {
+                if (dataChunkSize + pWav->dataChunkDataPos > (ma_uint64)fileSize) {
+                    dataChunkSize = (ma_uint64)fileSize - pWav->dataChunkDataPos;
+                }
+            }
+        } else {
+        }
+    }
+    if (dataChunkSize == 0xFFFFFFFF && (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx) && pWav->isSequentialWrite == MA_FALSE) {
+        dataChunkSize = 0;
+        for (;;) {
+            ma_uint8 temp[4096];
+            size_t bytesRead = pWav->onRead(pWav->pUserData, temp, sizeof(temp));
+            dataChunkSize += bytesRead;
+            if (bytesRead < sizeof(temp)) {
+                break;
+            }
+        }
+    }
+    if (ma_dr_wav__seek_from_start(pWav->onSeek, pWav->dataChunkDataPos, pWav->pUserData) == MA_FALSE) {
+        ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+        return MA_FALSE;
+    }
+    pWav->fmt                 = fmt;
+    pWav->sampleRate          = fmt.sampleRate;
+    pWav->channels            = fmt.channels;
+    pWav->bitsPerSample       = fmt.bitsPerSample;
+    pWav->translatedFormatTag = translatedFormatTag;
+    if (!ma_dr_wav__is_compressed_format_tag(translatedFormatTag)) {
+        ma_uint32 bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+        if (bytesPerFrame > 0) {
+            dataChunkSize -= (dataChunkSize % bytesPerFrame);
+        }
+    }
+    pWav->bytesRemaining      = dataChunkSize;
+    pWav->dataChunkDataSize   = dataChunkSize;
+    if (sampleCountFromFactChunk != 0) {
+        pWav->totalPCMFrameCount = sampleCountFromFactChunk;
+    } else if (aiffFrameCount != 0) {
+        pWav->totalPCMFrameCount = aiffFrameCount;
+    } else {
+        ma_uint32 bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+        if (bytesPerFrame == 0) {
+            ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+            return MA_FALSE;
+        }
+        pWav->totalPCMFrameCount = dataChunkSize / bytesPerFrame;
+        if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+            ma_uint64 totalBlockHeaderSizeInBytes;
+            ma_uint64 blockCount = dataChunkSize / fmt.blockAlign;
+            if ((blockCount * fmt.blockAlign) < dataChunkSize) {
+                blockCount += 1;
+            }
+            totalBlockHeaderSizeInBytes = blockCount * (6*fmt.channels);
+            pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
+        }
+        if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+            ma_uint64 totalBlockHeaderSizeInBytes;
+            ma_uint64 blockCount = dataChunkSize / fmt.blockAlign;
+            if ((blockCount * fmt.blockAlign) < dataChunkSize) {
+                blockCount += 1;
+            }
+            totalBlockHeaderSizeInBytes = blockCount * (4*fmt.channels);
+            pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
+            pWav->totalPCMFrameCount += blockCount;
+        }
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM || pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        if (pWav->channels > 2) {
+            ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+            return MA_FALSE;
+        }
+    }
+    if (ma_dr_wav_get_bytes_per_pcm_frame(pWav) == 0) {
+        ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+        return MA_FALSE;
+    }
+#ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+        ma_uint64 blockCount = dataChunkSize / fmt.blockAlign;
+        pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (6*pWav->channels))) * 2)) / fmt.channels;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        ma_uint64 blockCount = dataChunkSize / fmt.blockAlign;
+        pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (4*pWav->channels))) * 2) + (blockCount * pWav->channels)) / fmt.channels;
+    }
+#endif
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_init(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_ex(pWav, onRead, onSeek, onTell, NULL, pUserData, NULL, 0, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_ex(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, ma_dr_wav_chunk_proc onChunk, void* pReadSeekTellUserData, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (!ma_dr_wav_preinit(pWav, onRead, onSeek, onTell, pReadSeekTellUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init__internal(pWav, onChunk, pChunkUserData, flags);
+}
+MA_API ma_bool32 ma_dr_wav_init_with_metadata(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (!ma_dr_wav_preinit(pWav, onRead, onSeek, onTell, pUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init__internal(pWav, NULL, NULL, flags | MA_DR_WAV_WITH_METADATA);
+}
+MA_API ma_dr_wav_metadata* ma_dr_wav_take_ownership_of_metadata(ma_dr_wav* pWav)
+{
+    ma_dr_wav_metadata *result = pWav->pMetadata;
+    pWav->pMetadata     = NULL;
+    pWav->metadataCount = 0;
+    return result;
+}
+MA_PRIVATE size_t ma_dr_wav__write(ma_dr_wav* pWav, const void* pData, size_t dataSize)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    return pWav->onWrite(pWav->pUserData, pData, dataSize);
+}
+MA_PRIVATE size_t ma_dr_wav__write_byte(ma_dr_wav* pWav, ma_uint8 byte)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    return pWav->onWrite(pWav->pUserData, &byte, 1);
+}
+MA_PRIVATE size_t ma_dr_wav__write_u16ne_to_le(ma_dr_wav* pWav, ma_uint16 value)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    if (!ma_dr_wav__is_little_endian()) {
+        value = ma_dr_wav__bswap16(value);
+    }
+    return ma_dr_wav__write(pWav, &value, 2);
+}
+MA_PRIVATE size_t ma_dr_wav__write_u32ne_to_le(ma_dr_wav* pWav, ma_uint32 value)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    if (!ma_dr_wav__is_little_endian()) {
+        value = ma_dr_wav__bswap32(value);
+    }
+    return ma_dr_wav__write(pWav, &value, 4);
+}
+MA_PRIVATE size_t ma_dr_wav__write_u64ne_to_le(ma_dr_wav* pWav, ma_uint64 value)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    if (!ma_dr_wav__is_little_endian()) {
+        value = ma_dr_wav__bswap64(value);
+    }
+    return ma_dr_wav__write(pWav, &value, 8);
+}
+MA_PRIVATE size_t ma_dr_wav__write_f32ne_to_le(ma_dr_wav* pWav, float value)
+{
+    union {
+       ma_uint32 u32;
+       float f32;
+    } u;
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    u.f32 = value;
+    if (!ma_dr_wav__is_little_endian()) {
+        u.u32 = ma_dr_wav__bswap32(u.u32);
+    }
+    return ma_dr_wav__write(pWav, &u.u32, 4);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count(ma_dr_wav* pWav, const void* pData, size_t dataSize)
+{
+    if (pWav == NULL) {
+        return dataSize;
+    }
+    return ma_dr_wav__write(pWav, pData, dataSize);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_byte(ma_dr_wav* pWav, ma_uint8 byte)
+{
+    if (pWav == NULL) {
+        return 1;
+    }
+    return ma_dr_wav__write_byte(pWav, byte);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_u16ne_to_le(ma_dr_wav* pWav, ma_uint16 value)
+{
+    if (pWav == NULL) {
+        return 2;
+    }
+    return ma_dr_wav__write_u16ne_to_le(pWav, value);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_u32ne_to_le(ma_dr_wav* pWav, ma_uint32 value)
+{
+    if (pWav == NULL) {
+        return 4;
+    }
+    return ma_dr_wav__write_u32ne_to_le(pWav, value);
+}
+#if 0
+MA_PRIVATE size_t ma_dr_wav__write_or_count_u64ne_to_le(ma_dr_wav* pWav, ma_uint64 value)
+{
+    if (pWav == NULL) {
+        return 8;
+    }
+    return ma_dr_wav__write_u64ne_to_le(pWav, value);
+}
+#endif
+MA_PRIVATE size_t ma_dr_wav__write_or_count_f32ne_to_le(ma_dr_wav* pWav, float value)
+{
+    if (pWav == NULL) {
+        return 4;
+    }
+    return ma_dr_wav__write_f32ne_to_le(pWav, value);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_string_to_fixed_size_buf(ma_dr_wav* pWav, char* str, size_t bufFixedSize)
+{
+    size_t len;
+    if (pWav == NULL) {
+        return bufFixedSize;
+    }
+    len = ma_dr_wav__strlen_clamped(str, bufFixedSize);
+    ma_dr_wav__write_or_count(pWav, str, len);
+    if (len < bufFixedSize) {
+        size_t i;
+        for (i = 0; i < bufFixedSize - len; ++i) {
+            ma_dr_wav__write_byte(pWav, 0);
+        }
+    }
+    return bufFixedSize;
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_metadata(ma_dr_wav* pWav, ma_dr_wav_metadata* pMetadatas, ma_uint32 metadataCount)
+{
+    size_t bytesWritten = 0;
+    ma_bool32 hasListAdtl = MA_FALSE;
+    ma_bool32 hasListInfo = MA_FALSE;
+    ma_uint32 iMetadata;
+    if (pMetadatas == NULL || metadataCount == 0) {
+        return 0;
+    }
+    for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+        ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+        ma_uint32 chunkSize = 0;
+        if ((pMetadata->type & ma_dr_wav_metadata_type_list_all_info_strings) || (pMetadata->type == ma_dr_wav_metadata_type_unknown && pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_info_list)) {
+            hasListInfo = MA_TRUE;
+        }
+        if ((pMetadata->type & ma_dr_wav_metadata_type_list_all_adtl) || (pMetadata->type == ma_dr_wav_metadata_type_unknown && pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_adtl_list)) {
+            hasListAdtl = MA_TRUE;
+        }
+        switch (pMetadata->type) {
+            case ma_dr_wav_metadata_type_smpl:
+            {
+                ma_uint32 iLoop;
+                chunkSize = MA_DR_WAV_SMPL_BYTES + MA_DR_WAV_SMPL_LOOP_BYTES * pMetadata->data.smpl.sampleLoopCount + pMetadata->data.smpl.samplerSpecificDataSizeInBytes;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "smpl", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.manufacturerId);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.productId);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.samplePeriodNanoseconds);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.midiUnityNote);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.midiPitchFraction);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.smpteFormat);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.smpteOffset);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.sampleLoopCount);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.samplerSpecificDataSizeInBytes);
+                for (iLoop = 0; iLoop < pMetadata->data.smpl.sampleLoopCount; ++iLoop) {
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].cuePointId);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].type);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].firstSampleOffset);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].lastSampleOffset);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].sampleFraction);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].playCount);
+                }
+                if (pMetadata->data.smpl.samplerSpecificDataSizeInBytes > 0) {
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.smpl.pSamplerSpecificData, pMetadata->data.smpl.samplerSpecificDataSizeInBytes);
+                }
+            } break;
+            case ma_dr_wav_metadata_type_inst:
+            {
+                chunkSize = MA_DR_WAV_INST_BYTES;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "inst", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.midiUnityNote, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.fineTuneCents, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.gainDecibels, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.lowNote, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.highNote, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.lowVelocity, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.highVelocity, 1);
+            } break;
+            case ma_dr_wav_metadata_type_cue:
+            {
+                ma_uint32 iCuePoint;
+                chunkSize = MA_DR_WAV_CUE_BYTES + MA_DR_WAV_CUE_POINT_BYTES * pMetadata->data.cue.cuePointCount;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "cue ", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.cuePointCount);
+                for (iCuePoint = 0; iCuePoint < pMetadata->data.cue.cuePointCount; ++iCuePoint) {
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].id);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].playOrderPosition);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].chunkStart);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].blockStart);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].sampleOffset);
+                }
+            } break;
+            case ma_dr_wav_metadata_type_acid:
+            {
+                chunkSize = MA_DR_WAV_ACID_BYTES;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "acid", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.acid.flags);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.acid.midiUnityNote);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.acid.reserved1);
+                bytesWritten += ma_dr_wav__write_or_count_f32ne_to_le(pWav, pMetadata->data.acid.reserved2);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.acid.numBeats);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.acid.meterDenominator);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.acid.meterNumerator);
+                bytesWritten += ma_dr_wav__write_or_count_f32ne_to_le(pWav, pMetadata->data.acid.tempo);
+            } break;
+            case ma_dr_wav_metadata_type_bext:
+            {
+                char reservedBuf[MA_DR_WAV_BEXT_RESERVED_BYTES];
+                ma_uint32 timeReferenceLow;
+                ma_uint32 timeReferenceHigh;
+                chunkSize = MA_DR_WAV_BEXT_BYTES + pMetadata->data.bext.codingHistorySize;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "bext", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count_string_to_fixed_size_buf(pWav, pMetadata->data.bext.pDescription, MA_DR_WAV_BEXT_DESCRIPTION_BYTES);
+                bytesWritten += ma_dr_wav__write_or_count_string_to_fixed_size_buf(pWav, pMetadata->data.bext.pOriginatorName, MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES);
+                bytesWritten += ma_dr_wav__write_or_count_string_to_fixed_size_buf(pWav, pMetadata->data.bext.pOriginatorReference, MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.bext.pOriginationDate, sizeof(pMetadata->data.bext.pOriginationDate));
+                bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.bext.pOriginationTime, sizeof(pMetadata->data.bext.pOriginationTime));
+                timeReferenceLow  = (ma_uint32)(pMetadata->data.bext.timeReference & 0xFFFFFFFF);
+                timeReferenceHigh = (ma_uint32)(pMetadata->data.bext.timeReference >> 32);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, timeReferenceLow);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, timeReferenceHigh);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.version);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.bext.pUMID, MA_DR_WAV_BEXT_UMID_BYTES);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.loudnessValue);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.loudnessRange);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.maxTruePeakLevel);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.maxMomentaryLoudness);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.maxShortTermLoudness);
+                MA_DR_WAV_ZERO_MEMORY(reservedBuf, sizeof(reservedBuf));
+                bytesWritten += ma_dr_wav__write_or_count(pWav, reservedBuf, sizeof(reservedBuf));
+                if (pMetadata->data.bext.codingHistorySize > 0) {
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.bext.pCodingHistory, pMetadata->data.bext.codingHistorySize);
+                }
+            } break;
+            case ma_dr_wav_metadata_type_unknown:
+            {
+                if (pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_top_level) {
+                    chunkSize = pMetadata->data.unknown.dataSizeInBytes;
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.id, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.pData, pMetadata->data.unknown.dataSizeInBytes);
+                }
+            } break;
+            default: break;
+        }
+        if ((chunkSize % 2) != 0) {
+            bytesWritten += ma_dr_wav__write_or_count_byte(pWav, 0);
+        }
+    }
+    if (hasListInfo) {
+        ma_uint32 chunkSize = 4;
+        for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+            ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+            if ((pMetadata->type & ma_dr_wav_metadata_type_list_all_info_strings)) {
+                chunkSize += 8;
+                chunkSize += pMetadata->data.infoText.stringLength + 1;
+            } else if (pMetadata->type == ma_dr_wav_metadata_type_unknown && pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_info_list) {
+                chunkSize += 8;
+                chunkSize += pMetadata->data.unknown.dataSizeInBytes;
+            }
+            if ((chunkSize % 2) != 0) {
+                chunkSize += 1;
+            }
+        }
+        bytesWritten += ma_dr_wav__write_or_count(pWav, "LIST", 4);
+        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+        bytesWritten += ma_dr_wav__write_or_count(pWav, "INFO", 4);
+        for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+            ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+            ma_uint32 subchunkSize = 0;
+            if (pMetadata->type & ma_dr_wav_metadata_type_list_all_info_strings) {
+                const char* pID = NULL;
+                switch (pMetadata->type) {
+                    case ma_dr_wav_metadata_type_list_info_software:     pID = "ISFT"; break;
+                    case ma_dr_wav_metadata_type_list_info_copyright:    pID = "ICOP"; break;
+                    case ma_dr_wav_metadata_type_list_info_title:        pID = "INAM"; break;
+                    case ma_dr_wav_metadata_type_list_info_artist:       pID = "IART"; break;
+                    case ma_dr_wav_metadata_type_list_info_comment:      pID = "ICMT"; break;
+                    case ma_dr_wav_metadata_type_list_info_date:         pID = "ICRD"; break;
+                    case ma_dr_wav_metadata_type_list_info_genre:        pID = "IGNR"; break;
+                    case ma_dr_wav_metadata_type_list_info_album:        pID = "IPRD"; break;
+                    case ma_dr_wav_metadata_type_list_info_tracknumber:  pID = "ITRK"; break;
+                    case ma_dr_wav_metadata_type_list_info_location:     pID = "IARL"; break;
+                    case ma_dr_wav_metadata_type_list_info_organization: pID = "ICMS"; break;
+                    case ma_dr_wav_metadata_type_list_info_keywords:     pID = "IKEY"; break;
+                    case ma_dr_wav_metadata_type_list_info_medium:       pID = "IMED"; break;
+                    case ma_dr_wav_metadata_type_list_info_description:  pID = "ISBJ"; break;
+                    default: break;
+                }
+                MA_DR_WAV_ASSERT(pID != NULL);
+                if (pMetadata->data.infoText.stringLength) {
+                    subchunkSize = pMetadata->data.infoText.stringLength + 1;
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pID, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, subchunkSize);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.infoText.pString, pMetadata->data.infoText.stringLength);
+                    bytesWritten += ma_dr_wav__write_or_count_byte(pWav, '\0');
+                }
+            } else if (pMetadata->type == ma_dr_wav_metadata_type_unknown && pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_info_list) {
+                if (pMetadata->data.unknown.dataSizeInBytes) {
+                    subchunkSize = pMetadata->data.unknown.dataSizeInBytes;
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.id, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.unknown.dataSizeInBytes);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.pData, subchunkSize);
+                }
+            }
+            if ((subchunkSize % 2) != 0) {
+                bytesWritten += ma_dr_wav__write_or_count_byte(pWav, 0);
+            }
+        }
+    }
+    if (hasListAdtl) {
+        ma_uint32 chunkSize = 4;
+        for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+            ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+            switch (pMetadata->type)
+            {
+                case ma_dr_wav_metadata_type_list_label:
+                case ma_dr_wav_metadata_type_list_note:
+                {
+                    chunkSize += 8;
+                    chunkSize += MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES;
+                    if (pMetadata->data.labelOrNote.stringLength > 0) {
+                        chunkSize += pMetadata->data.labelOrNote.stringLength + 1;
+                    }
+                } break;
+                case ma_dr_wav_metadata_type_list_labelled_cue_region:
+                {
+                    chunkSize += 8;
+                    chunkSize += MA_DR_WAV_LIST_LABELLED_TEXT_BYTES;
+                    if (pMetadata->data.labelledCueRegion.stringLength > 0) {
+                        chunkSize += pMetadata->data.labelledCueRegion.stringLength + 1;
+                    }
+                } break;
+                case ma_dr_wav_metadata_type_unknown:
+                {
+                    if (pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_adtl_list) {
+                        chunkSize += 8;
+                        chunkSize += pMetadata->data.unknown.dataSizeInBytes;
+                    }
+                } break;
+                default: break;
+            }
+            if ((chunkSize % 2) != 0) {
+                chunkSize += 1;
+            }
+        }
+        bytesWritten += ma_dr_wav__write_or_count(pWav, "LIST", 4);
+        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+        bytesWritten += ma_dr_wav__write_or_count(pWav, "adtl", 4);
+        for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+            ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+            ma_uint32 subchunkSize = 0;
+            switch (pMetadata->type)
+            {
+                case ma_dr_wav_metadata_type_list_label:
+                case ma_dr_wav_metadata_type_list_note:
+                {
+                    if (pMetadata->data.labelOrNote.stringLength > 0) {
+                        const char *pID = NULL;
+                        if (pMetadata->type == ma_dr_wav_metadata_type_list_label) {
+                            pID = "labl";
+                        }
+                        else if (pMetadata->type == ma_dr_wav_metadata_type_list_note) {
+                            pID = "note";
+                        }
+                        MA_DR_WAV_ASSERT(pID != NULL);
+                        MA_DR_WAV_ASSERT(pMetadata->data.labelOrNote.pString != NULL);
+                        subchunkSize = MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES;
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pID, 4);
+                        subchunkSize += pMetadata->data.labelOrNote.stringLength + 1;
+                        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, subchunkSize);
+                        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.labelOrNote.cuePointId);
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.labelOrNote.pString, pMetadata->data.labelOrNote.stringLength);
+                        bytesWritten += ma_dr_wav__write_or_count_byte(pWav, '\0');
+                    }
+                } break;
+                case ma_dr_wav_metadata_type_list_labelled_cue_region:
+                {
+                    subchunkSize = MA_DR_WAV_LIST_LABELLED_TEXT_BYTES;
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, "ltxt", 4);
+                    if (pMetadata->data.labelledCueRegion.stringLength > 0) {
+                        subchunkSize += pMetadata->data.labelledCueRegion.stringLength + 1;
+                    }
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, subchunkSize);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.labelledCueRegion.cuePointId);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.labelledCueRegion.sampleLength);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.labelledCueRegion.purposeId, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.labelledCueRegion.country);
+                    bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.labelledCueRegion.language);
+                    bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.labelledCueRegion.dialect);
+                    bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.labelledCueRegion.codePage);
+                    if (pMetadata->data.labelledCueRegion.stringLength > 0) {
+                        MA_DR_WAV_ASSERT(pMetadata->data.labelledCueRegion.pString != NULL);
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.labelledCueRegion.pString, pMetadata->data.labelledCueRegion.stringLength);
+                        bytesWritten += ma_dr_wav__write_or_count_byte(pWav, '\0');
+                    }
+                } break;
+                case ma_dr_wav_metadata_type_unknown:
+                {
+                    if (pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_adtl_list) {
+                        subchunkSize = pMetadata->data.unknown.dataSizeInBytes;
+                        MA_DR_WAV_ASSERT(pMetadata->data.unknown.pData != NULL);
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.id, 4);
+                        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, subchunkSize);
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.pData, subchunkSize);
+                    }
+                } break;
+                default: break;
+            }
+            if ((subchunkSize % 2) != 0) {
+                bytesWritten += ma_dr_wav__write_or_count_byte(pWav, 0);
+            }
+        }
+    }
+    MA_DR_WAV_ASSERT((bytesWritten % 2) == 0);
+    return bytesWritten;
+}
+MA_PRIVATE ma_uint32 ma_dr_wav__riff_chunk_size_riff(ma_uint64 dataChunkSize, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount)
+{
+    ma_uint64 chunkSize = 4 + 24 + (ma_uint64)ma_dr_wav__write_or_count_metadata(NULL, pMetadata, metadataCount) + 8 + dataChunkSize + ma_dr_wav__chunk_padding_size_riff(dataChunkSize);
+    if (chunkSize > 0xFFFFFFFFUL) {
+        chunkSize = 0xFFFFFFFFUL;
+    }
+    return (ma_uint32)chunkSize;
+}
+MA_PRIVATE ma_uint32 ma_dr_wav__data_chunk_size_riff(ma_uint64 dataChunkSize)
+{
+    if (dataChunkSize <= 0xFFFFFFFFUL) {
+        return (ma_uint32)dataChunkSize;
+    } else {
+        return 0xFFFFFFFFUL;
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__riff_chunk_size_w64(ma_uint64 dataChunkSize)
+{
+    ma_uint64 dataSubchunkPaddingSize = ma_dr_wav__chunk_padding_size_w64(dataChunkSize);
+    return 80 + 24 + dataChunkSize + dataSubchunkPaddingSize;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__data_chunk_size_w64(ma_uint64 dataChunkSize)
+{
+    return 24 + dataChunkSize;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__riff_chunk_size_rf64(ma_uint64 dataChunkSize, ma_dr_wav_metadata *metadata, ma_uint32 numMetadata)
+{
+    ma_uint64 chunkSize = 4 + 36 + 24 + (ma_uint64)ma_dr_wav__write_or_count_metadata(NULL, metadata, numMetadata) + 8 + dataChunkSize + ma_dr_wav__chunk_padding_size_riff(dataChunkSize);
+    if (chunkSize > 0xFFFFFFFFUL) {
+        chunkSize = 0xFFFFFFFFUL;
+    }
+    return chunkSize;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__data_chunk_size_rf64(ma_uint64 dataChunkSize)
+{
+    return dataChunkSize;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_preinit_write(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_bool32 isSequential, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pWav == NULL || onWrite == NULL) {
+        return MA_FALSE;
+    }
+    if (!isSequential && onSeek == NULL) {
+        return MA_FALSE;
+    }
+    if (pFormat->format == MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+        return MA_FALSE;
+    }
+    if (pFormat->format == MA_DR_WAVE_FORMAT_ADPCM || pFormat->format == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        return MA_FALSE;
+    }
+    MA_DR_WAV_ZERO_MEMORY(pWav, sizeof(*pWav));
+    pWav->onWrite   = onWrite;
+    pWav->onSeek    = onSeek;
+    pWav->pUserData = pUserData;
+    pWav->allocationCallbacks = ma_dr_wav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
+    if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
+        return MA_FALSE;
+    }
+    pWav->fmt.formatTag = (ma_uint16)pFormat->format;
+    pWav->fmt.channels = (ma_uint16)pFormat->channels;
+    pWav->fmt.sampleRate = pFormat->sampleRate;
+    pWav->fmt.avgBytesPerSec = (ma_uint32)((pFormat->bitsPerSample * pFormat->sampleRate * pFormat->channels) / 8);
+    pWav->fmt.blockAlign = (ma_uint16)((pFormat->channels * pFormat->bitsPerSample) / 8);
+    pWav->fmt.bitsPerSample = (ma_uint16)pFormat->bitsPerSample;
+    pWav->fmt.extendedSize = 0;
+    pWav->isSequentialWrite = isSequential;
+    return MA_TRUE;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init_write__internal(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount)
+{
+    size_t runningPos = 0;
+    ma_uint64 initialDataChunkSize = 0;
+    ma_uint64 chunkSizeFMT;
+    if (pWav->isSequentialWrite) {
+        initialDataChunkSize = (totalSampleCount * pWav->fmt.bitsPerSample) / 8;
+        if (pFormat->container == ma_dr_wav_container_riff) {
+            if (initialDataChunkSize > (0xFFFFFFFFUL - 36)) {
+                return MA_FALSE;
+            }
+        }
+    }
+    pWav->dataChunkDataSizeTargetWrite = initialDataChunkSize;
+    if (pFormat->container == ma_dr_wav_container_riff) {
+        ma_uint32 chunkSizeRIFF = 36 + (ma_uint32)initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, "RIFF", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, chunkSizeRIFF);
+        runningPos += ma_dr_wav__write(pWav, "WAVE", 4);
+    } else if (pFormat->container == ma_dr_wav_container_w64) {
+        ma_uint64 chunkSizeRIFF = 80 + 24 + initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, ma_dr_wavGUID_W64_RIFF, 16);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, chunkSizeRIFF);
+        runningPos += ma_dr_wav__write(pWav, ma_dr_wavGUID_W64_WAVE, 16);
+    } else if (pFormat->container == ma_dr_wav_container_rf64) {
+        runningPos += ma_dr_wav__write(pWav, "RF64", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, 0xFFFFFFFF);
+        runningPos += ma_dr_wav__write(pWav, "WAVE", 4);
+    } else {
+        return MA_FALSE;
+    }
+    if (pFormat->container == ma_dr_wav_container_rf64) {
+        ma_uint32 initialds64ChunkSize = 28;
+        ma_uint64 initialRiffChunkSize = 8 + initialds64ChunkSize + initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, "ds64", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, initialds64ChunkSize);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, initialRiffChunkSize);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, initialDataChunkSize);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, totalSampleCount);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, 0);
+    }
+    if (pFormat->container == ma_dr_wav_container_riff || pFormat->container == ma_dr_wav_container_rf64) {
+        chunkSizeFMT = 16;
+        runningPos += ma_dr_wav__write(pWav, "fmt ", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, (ma_uint32)chunkSizeFMT);
+    } else if (pFormat->container == ma_dr_wav_container_w64) {
+        chunkSizeFMT = 40;
+        runningPos += ma_dr_wav__write(pWav, ma_dr_wavGUID_W64_FMT, 16);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, chunkSizeFMT);
+    }
+    runningPos += ma_dr_wav__write_u16ne_to_le(pWav, pWav->fmt.formatTag);
+    runningPos += ma_dr_wav__write_u16ne_to_le(pWav, pWav->fmt.channels);
+    runningPos += ma_dr_wav__write_u32ne_to_le(pWav, pWav->fmt.sampleRate);
+    runningPos += ma_dr_wav__write_u32ne_to_le(pWav, pWav->fmt.avgBytesPerSec);
+    runningPos += ma_dr_wav__write_u16ne_to_le(pWav, pWav->fmt.blockAlign);
+    runningPos += ma_dr_wav__write_u16ne_to_le(pWav, pWav->fmt.bitsPerSample);
+    if (!pWav->isSequentialWrite && pWav->pMetadata != NULL && pWav->metadataCount > 0 && (pFormat->container == ma_dr_wav_container_riff || pFormat->container == ma_dr_wav_container_rf64)) {
+        runningPos += ma_dr_wav__write_or_count_metadata(pWav, pWav->pMetadata, pWav->metadataCount);
+    }
+    pWav->dataChunkDataPos = runningPos;
+    if (pFormat->container == ma_dr_wav_container_riff) {
+        ma_uint32 chunkSizeDATA = (ma_uint32)initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, "data", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, chunkSizeDATA);
+    } else if (pFormat->container == ma_dr_wav_container_w64) {
+        ma_uint64 chunkSizeDATA = 24 + initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, ma_dr_wavGUID_W64_DATA, 16);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, chunkSizeDATA);
+    } else if (pFormat->container == ma_dr_wav_container_rf64) {
+        runningPos += ma_dr_wav__write(pWav, "data", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, 0xFFFFFFFF);
+    }
+    pWav->container = pFormat->container;
+    pWav->channels = (ma_uint16)pFormat->channels;
+    pWav->sampleRate = pFormat->sampleRate;
+    pWav->bitsPerSample = (ma_uint16)pFormat->bitsPerSample;
+    pWav->translatedFormatTag = (ma_uint16)pFormat->format;
+    pWav->dataChunkDataPos = runningPos;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_init_write(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (!ma_dr_wav_preinit_write(pWav, pFormat, MA_FALSE, onWrite, onSeek, pUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_write__internal(pWav, pFormat, 0);
+}
+MA_API ma_bool32 ma_dr_wav_init_write_sequential(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_dr_wav_write_proc onWrite, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (!ma_dr_wav_preinit_write(pWav, pFormat, MA_TRUE, onWrite, NULL, pUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_write__internal(pWav, pFormat, totalSampleCount);
+}
+MA_API ma_bool32 ma_dr_wav_init_write_sequential_pcm_frames(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, ma_dr_wav_write_proc onWrite, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFormat == NULL) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_write_sequential(pWav, pFormat, totalPCMFrameCount*pFormat->channels, onWrite, pUserData, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_write_with_metadata(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount)
+{
+    if (!ma_dr_wav_preinit_write(pWav, pFormat, MA_FALSE, onWrite, onSeek, pUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    pWav->pMetadata     = pMetadata;
+    pWav->metadataCount = metadataCount;
+    return ma_dr_wav_init_write__internal(pWav, pFormat, 0);
+}
+MA_API ma_uint64 ma_dr_wav_target_write_size_bytes(const ma_dr_wav_data_format* pFormat, ma_uint64 totalFrameCount, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount)
+{
+    ma_uint64 targetDataSizeBytes = (ma_uint64)((ma_int64)totalFrameCount * pFormat->channels * pFormat->bitsPerSample/8.0);
+    ma_uint64 riffChunkSizeBytes;
+    ma_uint64 fileSizeBytes = 0;
+    if (pFormat->container == ma_dr_wav_container_riff) {
+        riffChunkSizeBytes = ma_dr_wav__riff_chunk_size_riff(targetDataSizeBytes, pMetadata, metadataCount);
+        fileSizeBytes = (8 + riffChunkSizeBytes);
+    } else if (pFormat->container == ma_dr_wav_container_w64) {
+        riffChunkSizeBytes = ma_dr_wav__riff_chunk_size_w64(targetDataSizeBytes);
+        fileSizeBytes = riffChunkSizeBytes;
+    } else if (pFormat->container == ma_dr_wav_container_rf64) {
+        riffChunkSizeBytes = ma_dr_wav__riff_chunk_size_rf64(targetDataSizeBytes, pMetadata, metadataCount);
+        fileSizeBytes = (8 + riffChunkSizeBytes);
+    }
+    return fileSizeBytes;
+}
+#ifndef MA_DR_WAV_NO_STDIO
+MA_PRIVATE size_t ma_dr_wav__on_read_stdio(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    return fread(pBufferOut, 1, bytesToRead, (FILE*)pUserData);
+}
+MA_PRIVATE size_t ma_dr_wav__on_write_stdio(void* pUserData, const void* pData, size_t bytesToWrite)
+{
+    return fwrite(pData, 1, bytesToWrite, (FILE*)pUserData);
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__on_seek_stdio(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    int whence = SEEK_SET;
+    if (origin == MA_DR_WAV_SEEK_CUR) {
+        whence = SEEK_CUR;
+    } else if (origin == MA_DR_WAV_SEEK_END) {
+        whence = SEEK_END;
+    }
+    return fseek((FILE*)pUserData, offset, whence) == 0;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__on_tell_stdio(void* pUserData, ma_int64* pCursor)
+{
+    FILE* pFileStdio = (FILE*)pUserData;
+    ma_int64 result;
+    MA_DR_WAV_ASSERT(pFileStdio != NULL);
+    MA_DR_WAV_ASSERT(pCursor    != NULL);
+#if defined(_WIN32) && !defined(NXDK)
+    #if defined(_MSC_VER) && _MSC_VER > 1200
+        result = _ftelli64(pFileStdio);
+    #else
+        result = ftell(pFileStdio);
+    #endif
+#else
+    result = ftell(pFileStdio);
+#endif
+    *pCursor = result;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_init_file(ma_dr_wav* pWav, const char* filename, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_ex(pWav, filename, NULL, NULL, 0, pAllocationCallbacks);
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init_file__internal_FILE(ma_dr_wav* pWav, FILE* pFile, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 result;
+    result = ma_dr_wav_preinit(pWav, ma_dr_wav__on_read_stdio, ma_dr_wav__on_seek_stdio, ma_dr_wav__on_tell_stdio, (void*)pFile, pAllocationCallbacks);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    result = ma_dr_wav_init__internal(pWav, onChunk, pChunkUserData, flags);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_init_file_ex(ma_dr_wav* pWav, const char* filename, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_fopen(&pFile, filename, "rb") != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_API ma_bool32 ma_dr_wav_init_file_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_ex_w(pWav, filename, NULL, NULL, 0, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_ex_w(ma_dr_wav* pWav, const wchar_t* filename, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_wfopen(&pFile, filename, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
+}
+#endif
+MA_API ma_bool32 ma_dr_wav_init_file_with_metadata(ma_dr_wav* pWav, const char* filename, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_fopen(&pFile, filename, "rb") != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file__internal_FILE(pWav, pFile, NULL, NULL, flags | MA_DR_WAV_WITH_METADATA, pAllocationCallbacks);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_API ma_bool32 ma_dr_wav_init_file_with_metadata_w(ma_dr_wav* pWav, const wchar_t* filename, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_wfopen(&pFile, filename, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file__internal_FILE(pWav, pFile, NULL, NULL, flags | MA_DR_WAV_WITH_METADATA, pAllocationCallbacks);
+}
+#endif
+MA_PRIVATE ma_bool32 ma_dr_wav_init_file_write__internal_FILE(ma_dr_wav* pWav, FILE* pFile, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_bool32 isSequential, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 result;
+    result = ma_dr_wav_preinit_write(pWav, pFormat, isSequential, ma_dr_wav__on_write_stdio, ma_dr_wav__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    result = ma_dr_wav_init_write__internal(pWav, pFormat, totalSampleCount);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    return MA_TRUE;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init_file_write__internal(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_bool32 isSequential, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_fopen(&pFile, filename, "wb") != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_PRIVATE ma_bool32 ma_dr_wav_init_file_write_w__internal(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_bool32 isSequential, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_wfopen(&pFile, filename, L"wb", pAllocationCallbacks) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
+}
+#endif
+MA_API ma_bool32 ma_dr_wav_init_file_write(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_write__internal(pWav, filename, pFormat, 0, MA_FALSE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_write__internal(pWav, filename, pFormat, totalSampleCount, MA_TRUE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_pcm_frames(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFormat == NULL) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file_write_sequential(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_API ma_bool32 ma_dr_wav_init_file_write_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_write_w__internal(pWav, filename, pFormat, 0, MA_FALSE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_write_w__internal(pWav, filename, pFormat, totalSampleCount, MA_TRUE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_pcm_frames_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFormat == NULL) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file_write_sequential_w(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
+}
+#endif
+#endif
+MA_PRIVATE size_t ma_dr_wav__on_read_memory(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_dr_wav* pWav = (ma_dr_wav*)pUserData;
+    size_t bytesRemaining;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    MA_DR_WAV_ASSERT(pWav->memoryStream.dataSize >= pWav->memoryStream.currentReadPos);
+    bytesRemaining = pWav->memoryStream.dataSize - pWav->memoryStream.currentReadPos;
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+    if (bytesToRead > 0) {
+        MA_DR_WAV_COPY_MEMORY(pBufferOut, pWav->memoryStream.data + pWav->memoryStream.currentReadPos, bytesToRead);
+        pWav->memoryStream.currentReadPos += bytesToRead;
+    }
+    return bytesToRead;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__on_seek_memory(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    ma_dr_wav* pWav = (ma_dr_wav*)pUserData;
+    ma_int64 newCursor;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    newCursor = pWav->memoryStream.currentReadPos;
+    if (origin == MA_DR_WAV_SEEK_SET) {
+        newCursor = 0;
+    } else if (origin == MA_DR_WAV_SEEK_CUR) {
+        newCursor = (ma_int64)pWav->memoryStream.currentReadPos;
+    } else if (origin == MA_DR_WAV_SEEK_END) {
+        newCursor = (ma_int64)pWav->memoryStream.dataSize;
+    } else {
+        MA_DR_WAV_ASSERT(!"Invalid seek origin");
+        return MA_FALSE;
+    }
+    newCursor += offset;
+    if (newCursor < 0) {
+        return MA_FALSE;
+    }
+    if ((size_t)newCursor > pWav->memoryStream.dataSize) {
+        return MA_FALSE;
+    }
+    pWav->memoryStream.currentReadPos = (size_t)newCursor;
+    return MA_TRUE;
+}
+MA_PRIVATE size_t ma_dr_wav__on_write_memory(void* pUserData, const void* pDataIn, size_t bytesToWrite)
+{
+    ma_dr_wav* pWav = (ma_dr_wav*)pUserData;
+    size_t bytesRemaining;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    MA_DR_WAV_ASSERT(pWav->memoryStreamWrite.dataCapacity >= pWav->memoryStreamWrite.currentWritePos);
+    bytesRemaining = pWav->memoryStreamWrite.dataCapacity - pWav->memoryStreamWrite.currentWritePos;
+    if (bytesRemaining < bytesToWrite) {
+        void* pNewData;
+        size_t newDataCapacity = (pWav->memoryStreamWrite.dataCapacity == 0) ? 256 : pWav->memoryStreamWrite.dataCapacity * 2;
+        if ((newDataCapacity - pWav->memoryStreamWrite.currentWritePos) < bytesToWrite) {
+            newDataCapacity = pWav->memoryStreamWrite.currentWritePos + bytesToWrite;
+        }
+        pNewData = ma_dr_wav__realloc_from_callbacks(*pWav->memoryStreamWrite.ppData, newDataCapacity, pWav->memoryStreamWrite.dataCapacity, &pWav->allocationCallbacks);
+        if (pNewData == NULL) {
+            return 0;
+        }
+        *pWav->memoryStreamWrite.ppData = pNewData;
+        pWav->memoryStreamWrite.dataCapacity = newDataCapacity;
+    }
+    MA_DR_WAV_COPY_MEMORY(((ma_uint8*)(*pWav->memoryStreamWrite.ppData)) + pWav->memoryStreamWrite.currentWritePos, pDataIn, bytesToWrite);
+    pWav->memoryStreamWrite.currentWritePos += bytesToWrite;
+    if (pWav->memoryStreamWrite.dataSize < pWav->memoryStreamWrite.currentWritePos) {
+        pWav->memoryStreamWrite.dataSize = pWav->memoryStreamWrite.currentWritePos;
+    }
+    *pWav->memoryStreamWrite.pDataSize = pWav->memoryStreamWrite.dataSize;
+    return bytesToWrite;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__on_seek_memory_write(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    ma_dr_wav* pWav = (ma_dr_wav*)pUserData;
+    ma_int64 newCursor;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    newCursor = pWav->memoryStreamWrite.currentWritePos;
+    if (origin == MA_DR_WAV_SEEK_SET) {
+        newCursor = 0;
+    } else if (origin == MA_DR_WAV_SEEK_CUR) {
+        newCursor = (ma_int64)pWav->memoryStreamWrite.currentWritePos;
+    } else if (origin == MA_DR_WAV_SEEK_END) {
+        newCursor = (ma_int64)pWav->memoryStreamWrite.dataSize;
+    } else {
+        MA_DR_WAV_ASSERT(!"Invalid seek origin");
+        return MA_INVALID_ARGS;
+    }
+    newCursor += offset;
+    if (newCursor < 0) {
+        return MA_FALSE;
+    }
+    if ((size_t)newCursor > pWav->memoryStreamWrite.dataSize) {
+        return MA_FALSE;
+    }
+    pWav->memoryStreamWrite.currentWritePos = (size_t)newCursor;
+    return MA_TRUE;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__on_tell_memory(void* pUserData, ma_int64* pCursor)
+{
+    ma_dr_wav* pWav = (ma_dr_wav*)pUserData;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    MA_DR_WAV_ASSERT(pCursor != NULL);
+    *pCursor = (ma_int64)pWav->memoryStream.currentReadPos;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_init_memory(ma_dr_wav* pWav, const void* data, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_memory_ex(pWav, data, dataSize, NULL, NULL, 0, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_ex(ma_dr_wav* pWav, const void* data, size_t dataSize, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (data == NULL || dataSize == 0) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_wav_preinit(pWav, ma_dr_wav__on_read_memory, ma_dr_wav__on_seek_memory, ma_dr_wav__on_tell_memory, pWav, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    pWav->memoryStream.data = (const ma_uint8*)data;
+    pWav->memoryStream.dataSize = dataSize;
+    pWav->memoryStream.currentReadPos = 0;
+    return ma_dr_wav_init__internal(pWav, onChunk, pChunkUserData, flags);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_with_metadata(ma_dr_wav* pWav, const void* data, size_t dataSize, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (data == NULL || dataSize == 0) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_wav_preinit(pWav, ma_dr_wav__on_read_memory, ma_dr_wav__on_seek_memory, ma_dr_wav__on_tell_memory, pWav, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    pWav->memoryStream.data = (const ma_uint8*)data;
+    pWav->memoryStream.dataSize = dataSize;
+    pWav->memoryStream.currentReadPos = 0;
+    return ma_dr_wav_init__internal(pWav, NULL, NULL, flags | MA_DR_WAV_WITH_METADATA);
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init_memory_write__internal(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_bool32 isSequential, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (ppData == NULL || pDataSize == NULL) {
+        return MA_FALSE;
+    }
+    *ppData = NULL;
+    *pDataSize = 0;
+    if (!ma_dr_wav_preinit_write(pWav, pFormat, isSequential, ma_dr_wav__on_write_memory, ma_dr_wav__on_seek_memory_write, pWav, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    pWav->memoryStreamWrite.ppData = ppData;
+    pWav->memoryStreamWrite.pDataSize = pDataSize;
+    pWav->memoryStreamWrite.dataSize = 0;
+    pWav->memoryStreamWrite.dataCapacity = 0;
+    pWav->memoryStreamWrite.currentWritePos = 0;
+    return ma_dr_wav_init_write__internal(pWav, pFormat, totalSampleCount);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_write(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, 0, MA_FALSE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_write_sequential(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, totalSampleCount, MA_TRUE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_write_sequential_pcm_frames(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFormat == NULL) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_memory_write_sequential(pWav, ppData, pDataSize, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
+}
+MA_API ma_result ma_dr_wav_uninit(ma_dr_wav* pWav)
+{
+    ma_result result = MA_SUCCESS;
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    if (pWav->onWrite != NULL) {
+        ma_uint32 paddingSize = 0;
+        if (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rf64) {
+            paddingSize = ma_dr_wav__chunk_padding_size_riff(pWav->dataChunkDataSize);
+        } else {
+            paddingSize = ma_dr_wav__chunk_padding_size_w64(pWav->dataChunkDataSize);
+        }
+        if (paddingSize > 0) {
+            ma_uint64 paddingData = 0;
+            ma_dr_wav__write(pWav, &paddingData, paddingSize);
+        }
+        if (pWav->onSeek && !pWav->isSequentialWrite) {
+            if (pWav->container == ma_dr_wav_container_riff) {
+                if (pWav->onSeek(pWav->pUserData, 4, MA_DR_WAV_SEEK_SET)) {
+                    ma_uint32 riffChunkSize = ma_dr_wav__riff_chunk_size_riff(pWav->dataChunkDataSize, pWav->pMetadata, pWav->metadataCount);
+                    ma_dr_wav__write_u32ne_to_le(pWav, riffChunkSize);
+                }
+                if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos - 4, MA_DR_WAV_SEEK_SET)) {
+                    ma_uint32 dataChunkSize = ma_dr_wav__data_chunk_size_riff(pWav->dataChunkDataSize);
+                    ma_dr_wav__write_u32ne_to_le(pWav, dataChunkSize);
+                }
+            } else if (pWav->container == ma_dr_wav_container_w64) {
+                if (pWav->onSeek(pWav->pUserData, 16, MA_DR_WAV_SEEK_SET)) {
+                    ma_uint64 riffChunkSize = ma_dr_wav__riff_chunk_size_w64(pWav->dataChunkDataSize);
+                    ma_dr_wav__write_u64ne_to_le(pWav, riffChunkSize);
+                }
+                if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos - 8, MA_DR_WAV_SEEK_SET)) {
+                    ma_uint64 dataChunkSize = ma_dr_wav__data_chunk_size_w64(pWav->dataChunkDataSize);
+                    ma_dr_wav__write_u64ne_to_le(pWav, dataChunkSize);
+                }
+            } else if (pWav->container == ma_dr_wav_container_rf64) {
+                int ds64BodyPos = 12 + 8;
+                if (pWav->onSeek(pWav->pUserData, ds64BodyPos + 0, MA_DR_WAV_SEEK_SET)) {
+                    ma_uint64 riffChunkSize = ma_dr_wav__riff_chunk_size_rf64(pWav->dataChunkDataSize, pWav->pMetadata, pWav->metadataCount);
+                    ma_dr_wav__write_u64ne_to_le(pWav, riffChunkSize);
+                }
+                if (pWav->onSeek(pWav->pUserData, ds64BodyPos + 8, MA_DR_WAV_SEEK_SET)) {
+                    ma_uint64 dataChunkSize = ma_dr_wav__data_chunk_size_rf64(pWav->dataChunkDataSize);
+                    ma_dr_wav__write_u64ne_to_le(pWav, dataChunkSize);
+                }
+            }
+        }
+        if (pWav->isSequentialWrite) {
+            if (pWav->dataChunkDataSize != pWav->dataChunkDataSizeTargetWrite) {
+                result = MA_INVALID_FILE;
+            }
+        }
+    } else {
+        ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+    }
+#ifndef MA_DR_WAV_NO_STDIO
+    if (pWav->onRead == ma_dr_wav__on_read_stdio || pWav->onWrite == ma_dr_wav__on_write_stdio) {
+        fclose((FILE*)pWav->pUserData);
+    }
+#endif
+    return result;
+}
+MA_API size_t ma_dr_wav_read_raw(ma_dr_wav* pWav, size_t bytesToRead, void* pBufferOut)
+{
+    size_t bytesRead;
+    ma_uint32 bytesPerFrame;
+    if (pWav == NULL || bytesToRead == 0) {
+        return 0;
+    }
+    if (bytesToRead > pWav->bytesRemaining) {
+        bytesToRead = (size_t)pWav->bytesRemaining;
+    }
+    if (bytesToRead == 0) {
+        return 0;
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    if (pBufferOut != NULL) {
+        bytesRead = pWav->onRead(pWav->pUserData, pBufferOut, bytesToRead);
+    } else {
+        bytesRead = 0;
+        while (bytesRead < bytesToRead) {
+            size_t bytesToSeek = (bytesToRead - bytesRead);
+            if (bytesToSeek > 0x7FFFFFFF) {
+                bytesToSeek = 0x7FFFFFFF;
+            }
+            if (pWav->onSeek(pWav->pUserData, (int)bytesToSeek, MA_DR_WAV_SEEK_CUR) == MA_FALSE) {
+                break;
+            }
+            bytesRead += bytesToSeek;
+        }
+        while (bytesRead < bytesToRead) {
+            ma_uint8 buffer[4096];
+            size_t bytesSeeked;
+            size_t bytesToSeek = (bytesToRead - bytesRead);
+            if (bytesToSeek > sizeof(buffer)) {
+                bytesToSeek = sizeof(buffer);
+            }
+            bytesSeeked = pWav->onRead(pWav->pUserData, buffer, bytesToSeek);
+            bytesRead += bytesSeeked;
+            if (bytesSeeked < bytesToSeek) {
+                break;
+            }
+        }
+    }
+    pWav->readCursorInPCMFrames += bytesRead / bytesPerFrame;
+    pWav->bytesRemaining -= bytesRead;
+    return bytesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_le(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut)
+{
+    ma_uint32 bytesPerFrame;
+    ma_uint64 bytesToRead;
+    ma_uint64 framesRemainingInFile;
+    if (pWav == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (ma_dr_wav__is_compressed_format_tag(pWav->translatedFormatTag)) {
+        return 0;
+    }
+    framesRemainingInFile = pWav->totalPCMFrameCount - pWav->readCursorInPCMFrames;
+    if (framesToRead > framesRemainingInFile) {
+        framesToRead = framesRemainingInFile;
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesToRead = framesToRead * bytesPerFrame;
+    if (bytesToRead > MA_SIZE_MAX) {
+        bytesToRead = (MA_SIZE_MAX / bytesPerFrame) * bytesPerFrame;
+    }
+    if (bytesToRead == 0) {
+        return 0;
+    }
+    return ma_dr_wav_read_raw(pWav, (size_t)bytesToRead, pBufferOut) / bytesPerFrame;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_be(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL) {
+        ma_uint32 bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+        if (bytesPerFrame == 0) {
+            return 0;
+        }
+        ma_dr_wav__bswap_samples(pBufferOut, framesRead*pWav->channels, bytesPerFrame/pWav->channels);
+    }
+    return framesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut)
+{
+    ma_uint64 framesRead = 0;
+    if (ma_dr_wav_is_container_be(pWav->container)) {
+        if (pWav->container != ma_dr_wav_container_aiff || pWav->aiff.isLE == MA_FALSE) {
+            if (ma_dr_wav__is_little_endian()) {
+                framesRead = ma_dr_wav_read_pcm_frames_be(pWav, framesToRead, pBufferOut);
+            } else {
+                framesRead = ma_dr_wav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
+            }
+            goto post_process;
+        }
+    }
+    if (ma_dr_wav__is_little_endian()) {
+        framesRead = ma_dr_wav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
+    } else {
+        framesRead = ma_dr_wav_read_pcm_frames_be(pWav, framesToRead, pBufferOut);
+    }
+    post_process:
+    {
+        if (pWav->container == ma_dr_wav_container_aiff && pWav->bitsPerSample == 8 && pWav->aiff.isUnsigned == MA_FALSE) {
+            if (pBufferOut != NULL) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < framesRead * pWav->channels; iSample += 1) {
+                    ((ma_uint8*)pBufferOut)[iSample] += 128;
+                }
+            }
+        }
+    }
+    return framesRead;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_seek_to_first_pcm_frame(ma_dr_wav* pWav)
+{
+    if (pWav->onWrite != NULL) {
+        return MA_FALSE;
+    }
+    if (!pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos, MA_DR_WAV_SEEK_SET)) {
+        return MA_FALSE;
+    }
+    if (ma_dr_wav__is_compressed_format_tag(pWav->translatedFormatTag)) {
+        if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+            MA_DR_WAV_ZERO_OBJECT(&pWav->msadpcm);
+        } else if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+            MA_DR_WAV_ZERO_OBJECT(&pWav->ima);
+        } else {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+        }
+    }
+    pWav->readCursorInPCMFrames = 0;
+    pWav->bytesRemaining = pWav->dataChunkDataSize;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_seek_to_pcm_frame(ma_dr_wav* pWav, ma_uint64 targetFrameIndex)
+{
+    if (pWav == NULL || pWav->onSeek == NULL) {
+        return MA_FALSE;
+    }
+    if (pWav->onWrite != NULL) {
+        return MA_FALSE;
+    }
+    if (pWav->totalPCMFrameCount == 0) {
+        return MA_TRUE;
+    }
+    if (targetFrameIndex > pWav->totalPCMFrameCount) {
+        targetFrameIndex = pWav->totalPCMFrameCount;
+    }
+    if (ma_dr_wav__is_compressed_format_tag(pWav->translatedFormatTag)) {
+        if (targetFrameIndex < pWav->readCursorInPCMFrames) {
+            if (!ma_dr_wav_seek_to_first_pcm_frame(pWav)) {
+                return MA_FALSE;
+            }
+        }
+        if (targetFrameIndex > pWav->readCursorInPCMFrames) {
+            ma_uint64 offsetInFrames = targetFrameIndex - pWav->readCursorInPCMFrames;
+            ma_int16 devnull[2048];
+            while (offsetInFrames > 0) {
+                ma_uint64 framesRead = 0;
+                ma_uint64 framesToRead = offsetInFrames;
+                if (framesToRead > ma_dr_wav_countof(devnull)/pWav->channels) {
+                    framesToRead = ma_dr_wav_countof(devnull)/pWav->channels;
+                }
+                if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+                    framesRead = ma_dr_wav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, devnull);
+                } else if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+                    framesRead = ma_dr_wav_read_pcm_frames_s16__ima(pWav, framesToRead, devnull);
+                } else {
+                    MA_DR_WAV_ASSERT(MA_FALSE);
+                }
+                if (framesRead != framesToRead) {
+                    return MA_FALSE;
+                }
+                offsetInFrames -= framesRead;
+            }
+        }
+    } else {
+        ma_uint64 totalSizeInBytes;
+        ma_uint64 currentBytePos;
+        ma_uint64 targetBytePos;
+        ma_uint64 offset;
+        ma_uint32 bytesPerFrame;
+        bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+        if (bytesPerFrame == 0) {
+            return MA_FALSE;
+        }
+        totalSizeInBytes = pWav->totalPCMFrameCount * bytesPerFrame;
+        currentBytePos = totalSizeInBytes - pWav->bytesRemaining;
+        targetBytePos  = targetFrameIndex * bytesPerFrame;
+        if (currentBytePos < targetBytePos) {
+            offset = (targetBytePos - currentBytePos);
+        } else {
+            if (!ma_dr_wav_seek_to_first_pcm_frame(pWav)) {
+                return MA_FALSE;
+            }
+            offset = targetBytePos;
+        }
+        while (offset > 0) {
+            int offset32 = ((offset > INT_MAX) ? INT_MAX : (int)offset);
+            if (!pWav->onSeek(pWav->pUserData, offset32, MA_DR_WAV_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+            pWav->readCursorInPCMFrames += offset32 / bytesPerFrame;
+            pWav->bytesRemaining        -= offset32;
+            offset                      -= offset32;
+        }
+    }
+    return MA_TRUE;
+}
+MA_API ma_result ma_dr_wav_get_cursor_in_pcm_frames(ma_dr_wav* pWav, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    *pCursor = 0;
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    *pCursor = pWav->readCursorInPCMFrames;
+    return MA_SUCCESS;
+}
+MA_API ma_result ma_dr_wav_get_length_in_pcm_frames(ma_dr_wav* pWav, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    *pLength = 0;
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    *pLength = pWav->totalPCMFrameCount;
+    return MA_SUCCESS;
+}
+MA_API size_t ma_dr_wav_write_raw(ma_dr_wav* pWav, size_t bytesToWrite, const void* pData)
+{
+    size_t bytesWritten;
+    if (pWav == NULL || bytesToWrite == 0 || pData == NULL) {
+        return 0;
+    }
+    bytesWritten = pWav->onWrite(pWav->pUserData, pData, bytesToWrite);
+    pWav->dataChunkDataSize += bytesWritten;
+    return bytesWritten;
+}
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames_le(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData)
+{
+    ma_uint64 bytesToWrite;
+    ma_uint64 bytesWritten;
+    const ma_uint8* pRunningData;
+    if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
+        return 0;
+    }
+    bytesToWrite = ((framesToWrite * pWav->channels * pWav->bitsPerSample) / 8);
+    if (bytesToWrite > MA_SIZE_MAX) {
+        return 0;
+    }
+    bytesWritten = 0;
+    pRunningData = (const ma_uint8*)pData;
+    while (bytesToWrite > 0) {
+        size_t bytesJustWritten;
+        ma_uint64 bytesToWriteThisIteration;
+        bytesToWriteThisIteration = bytesToWrite;
+        MA_DR_WAV_ASSERT(bytesToWriteThisIteration <= MA_SIZE_MAX);
+        bytesJustWritten = ma_dr_wav_write_raw(pWav, (size_t)bytesToWriteThisIteration, pRunningData);
+        if (bytesJustWritten == 0) {
+            break;
+        }
+        bytesToWrite -= bytesJustWritten;
+        bytesWritten += bytesJustWritten;
+        pRunningData += bytesJustWritten;
+    }
+    return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels;
+}
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames_be(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData)
+{
+    ma_uint64 bytesToWrite;
+    ma_uint64 bytesWritten;
+    ma_uint32 bytesPerSample;
+    const ma_uint8* pRunningData;
+    if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
+        return 0;
+    }
+    bytesToWrite = ((framesToWrite * pWav->channels * pWav->bitsPerSample) / 8);
+    if (bytesToWrite > MA_SIZE_MAX) {
+        return 0;
+    }
+    bytesWritten = 0;
+    pRunningData = (const ma_uint8*)pData;
+    bytesPerSample = ma_dr_wav_get_bytes_per_pcm_frame(pWav) / pWav->channels;
+    if (bytesPerSample == 0) {
+        return 0;
+    }
+    while (bytesToWrite > 0) {
+        ma_uint8 temp[4096];
+        ma_uint32 sampleCount;
+        size_t bytesJustWritten;
+        ma_uint64 bytesToWriteThisIteration;
+        bytesToWriteThisIteration = bytesToWrite;
+        MA_DR_WAV_ASSERT(bytesToWriteThisIteration <= MA_SIZE_MAX);
+        sampleCount = sizeof(temp)/bytesPerSample;
+        if (bytesToWriteThisIteration > ((ma_uint64)sampleCount)*bytesPerSample) {
+            bytesToWriteThisIteration = ((ma_uint64)sampleCount)*bytesPerSample;
+        }
+        MA_DR_WAV_COPY_MEMORY(temp, pRunningData, (size_t)bytesToWriteThisIteration);
+        ma_dr_wav__bswap_samples(temp, sampleCount, bytesPerSample);
+        bytesJustWritten = ma_dr_wav_write_raw(pWav, (size_t)bytesToWriteThisIteration, temp);
+        if (bytesJustWritten == 0) {
+            break;
+        }
+        bytesToWrite -= bytesJustWritten;
+        bytesWritten += bytesJustWritten;
+        pRunningData += bytesJustWritten;
+    }
+    return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels;
+}
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData)
+{
+    if (ma_dr_wav__is_little_endian()) {
+        return ma_dr_wav_write_pcm_frames_le(pWav, framesToWrite, pData);
+    } else {
+        return ma_dr_wav_write_pcm_frames_be(pWav, framesToWrite, pData);
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__msadpcm(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead = 0;
+    static const ma_int32 adaptationTable[] = {
+        230, 230, 230, 230, 307, 409, 512, 614,
+        768, 614, 512, 409, 307, 230, 230, 230
+    };
+    static const ma_int32 coeff1Table[] = { 256, 512, 0, 192, 240, 460,  392 };
+    static const ma_int32 coeff2Table[] = { 0,  -256, 0, 64,  0,  -208, -232 };
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    MA_DR_WAV_ASSERT(framesToRead > 0);
+    while (pWav->readCursorInPCMFrames < pWav->totalPCMFrameCount) {
+        MA_DR_WAV_ASSERT(framesToRead > 0);
+        if (pWav->msadpcm.cachedFrameCount == 0 && pWav->msadpcm.bytesRemainingInBlock == 0) {
+            if (pWav->channels == 1) {
+                ma_uint8 header[7];
+                if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
+                    return totalFramesRead;
+                }
+                pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
+                pWav->msadpcm.predictor[0]     = header[0];
+                pWav->msadpcm.delta[0]         = ma_dr_wav_bytes_to_s16(header + 1);
+                pWav->msadpcm.prevFrames[0][1] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 3);
+                pWav->msadpcm.prevFrames[0][0] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 5);
+                pWav->msadpcm.cachedFrames[2]  = pWav->msadpcm.prevFrames[0][0];
+                pWav->msadpcm.cachedFrames[3]  = pWav->msadpcm.prevFrames[0][1];
+                pWav->msadpcm.cachedFrameCount = 2;
+                if (pWav->msadpcm.predictor[0] >= ma_dr_wav_countof(coeff1Table)) {
+                    return totalFramesRead;
+                }
+            } else {
+                ma_uint8 header[14];
+                if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
+                    return totalFramesRead;
+                }
+                pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
+                pWav->msadpcm.predictor[0] = header[0];
+                pWav->msadpcm.predictor[1] = header[1];
+                pWav->msadpcm.delta[0] = ma_dr_wav_bytes_to_s16(header + 2);
+                pWav->msadpcm.delta[1] = ma_dr_wav_bytes_to_s16(header + 4);
+                pWav->msadpcm.prevFrames[0][1] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 6);
+                pWav->msadpcm.prevFrames[1][1] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 8);
+                pWav->msadpcm.prevFrames[0][0] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 10);
+                pWav->msadpcm.prevFrames[1][0] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 12);
+                pWav->msadpcm.cachedFrames[0] = pWav->msadpcm.prevFrames[0][0];
+                pWav->msadpcm.cachedFrames[1] = pWav->msadpcm.prevFrames[1][0];
+                pWav->msadpcm.cachedFrames[2] = pWav->msadpcm.prevFrames[0][1];
+                pWav->msadpcm.cachedFrames[3] = pWav->msadpcm.prevFrames[1][1];
+                pWav->msadpcm.cachedFrameCount = 2;
+                if (pWav->msadpcm.predictor[0] >= ma_dr_wav_countof(coeff1Table) || pWav->msadpcm.predictor[1] >= ma_dr_wav_countof(coeff2Table)) {
+                    return totalFramesRead;
+                }
+            }
+        }
+        while (framesToRead > 0 && pWav->msadpcm.cachedFrameCount > 0 && pWav->readCursorInPCMFrames < pWav->totalPCMFrameCount) {
+            if (pBufferOut != NULL) {
+                ma_uint32 iSample = 0;
+                for (iSample = 0; iSample < pWav->channels; iSample += 1) {
+                    pBufferOut[iSample] = (ma_int16)pWav->msadpcm.cachedFrames[(ma_dr_wav_countof(pWav->msadpcm.cachedFrames) - (pWav->msadpcm.cachedFrameCount*pWav->channels)) + iSample];
+                }
+                pBufferOut += pWav->channels;
+            }
+            framesToRead    -= 1;
+            totalFramesRead += 1;
+            pWav->readCursorInPCMFrames += 1;
+            pWav->msadpcm.cachedFrameCount -= 1;
+        }
+        if (framesToRead == 0) {
+            break;
+        }
+        if (pWav->msadpcm.cachedFrameCount == 0) {
+            if (pWav->msadpcm.bytesRemainingInBlock == 0) {
+                continue;
+            } else {
+                ma_uint8 nibbles;
+                ma_int32 nibble0;
+                ma_int32 nibble1;
+                if (pWav->onRead(pWav->pUserData, &nibbles, 1) != 1) {
+                    return totalFramesRead;
+                }
+                pWav->msadpcm.bytesRemainingInBlock -= 1;
+                nibble0 = ((nibbles & 0xF0) >> 4); if ((nibbles & 0x80)) { nibble0 |= 0xFFFFFFF0UL; }
+                nibble1 = ((nibbles & 0x0F) >> 0); if ((nibbles & 0x08)) { nibble1 |= 0xFFFFFFF0UL; }
+                if (pWav->channels == 1) {
+                    ma_int32 newSample0;
+                    ma_int32 newSample1;
+                    newSample0  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
+                    newSample0 += nibble0 * pWav->msadpcm.delta[0];
+                    newSample0  = ma_dr_wav_clamp(newSample0, -32768, 32767);
+                    pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
+                    if (pWav->msadpcm.delta[0] < 16) {
+                        pWav->msadpcm.delta[0] = 16;
+                    }
+                    pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
+                    pWav->msadpcm.prevFrames[0][1] = newSample0;
+                    newSample1  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
+                    newSample1 += nibble1 * pWav->msadpcm.delta[0];
+                    newSample1  = ma_dr_wav_clamp(newSample1, -32768, 32767);
+                    pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[0]) >> 8;
+                    if (pWav->msadpcm.delta[0] < 16) {
+                        pWav->msadpcm.delta[0] = 16;
+                    }
+                    pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
+                    pWav->msadpcm.prevFrames[0][1] = newSample1;
+                    pWav->msadpcm.cachedFrames[2] = newSample0;
+                    pWav->msadpcm.cachedFrames[3] = newSample1;
+                    pWav->msadpcm.cachedFrameCount = 2;
+                } else {
+                    ma_int32 newSample0;
+                    ma_int32 newSample1;
+                    newSample0  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
+                    newSample0 += nibble0 * pWav->msadpcm.delta[0];
+                    newSample0  = ma_dr_wav_clamp(newSample0, -32768, 32767);
+                    pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
+                    if (pWav->msadpcm.delta[0] < 16) {
+                        pWav->msadpcm.delta[0] = 16;
+                    }
+                    pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
+                    pWav->msadpcm.prevFrames[0][1] = newSample0;
+                    newSample1  = ((pWav->msadpcm.prevFrames[1][1] * coeff1Table[pWav->msadpcm.predictor[1]]) + (pWav->msadpcm.prevFrames[1][0] * coeff2Table[pWav->msadpcm.predictor[1]])) >> 8;
+                    newSample1 += nibble1 * pWav->msadpcm.delta[1];
+                    newSample1  = ma_dr_wav_clamp(newSample1, -32768, 32767);
+                    pWav->msadpcm.delta[1] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[1]) >> 8;
+                    if (pWav->msadpcm.delta[1] < 16) {
+                        pWav->msadpcm.delta[1] = 16;
+                    }
+                    pWav->msadpcm.prevFrames[1][0] = pWav->msadpcm.prevFrames[1][1];
+                    pWav->msadpcm.prevFrames[1][1] = newSample1;
+                    pWav->msadpcm.cachedFrames[2] = newSample0;
+                    pWav->msadpcm.cachedFrames[3] = newSample1;
+                    pWav->msadpcm.cachedFrameCount = 1;
+                }
+            }
+        }
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__ima(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead = 0;
+    ma_uint32 iChannel;
+    static const ma_int32 indexTable[16] = {
+        -1, -1, -1, -1, 2, 4, 6, 8,
+        -1, -1, -1, -1, 2, 4, 6, 8
+    };
+    static const ma_int32 stepTable[89] = {
+        7,     8,     9,     10,    11,    12,    13,    14,    16,    17,
+        19,    21,    23,    25,    28,    31,    34,    37,    41,    45,
+        50,    55,    60,    66,    73,    80,    88,    97,    107,   118,
+        130,   143,   157,   173,   190,   209,   230,   253,   279,   307,
+        337,   371,   408,   449,   494,   544,   598,   658,   724,   796,
+        876,   963,   1060,  1166,  1282,  1411,  1552,  1707,  1878,  2066,
+        2272,  2499,  2749,  3024,  3327,  3660,  4026,  4428,  4871,  5358,
+        5894,  6484,  7132,  7845,  8630,  9493,  10442, 11487, 12635, 13899,
+        15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
+    };
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    MA_DR_WAV_ASSERT(framesToRead > 0);
+    while (pWav->readCursorInPCMFrames < pWav->totalPCMFrameCount) {
+        MA_DR_WAV_ASSERT(framesToRead > 0);
+        if (pWav->ima.cachedFrameCount == 0 && pWav->ima.bytesRemainingInBlock == 0) {
+            if (pWav->channels == 1) {
+                ma_uint8 header[4];
+                if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
+                    return totalFramesRead;
+                }
+                pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
+                if (header[2] >= ma_dr_wav_countof(stepTable)) {
+                    pWav->onSeek(pWav->pUserData, pWav->ima.bytesRemainingInBlock, MA_DR_WAV_SEEK_CUR);
+                    pWav->ima.bytesRemainingInBlock = 0;
+                    return totalFramesRead;
+                }
+                pWav->ima.predictor[0] = (ma_int16)ma_dr_wav_bytes_to_u16(header + 0);
+                pWav->ima.stepIndex[0] = ma_dr_wav_clamp(header[2], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                pWav->ima.cachedFrames[ma_dr_wav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[0];
+                pWav->ima.cachedFrameCount = 1;
+            } else {
+                ma_uint8 header[8];
+                if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
+                    return totalFramesRead;
+                }
+                pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
+                if (header[2] >= ma_dr_wav_countof(stepTable) || header[6] >= ma_dr_wav_countof(stepTable)) {
+                    pWav->onSeek(pWav->pUserData, pWav->ima.bytesRemainingInBlock, MA_DR_WAV_SEEK_CUR);
+                    pWav->ima.bytesRemainingInBlock = 0;
+                    return totalFramesRead;
+                }
+                pWav->ima.predictor[0] = ma_dr_wav_bytes_to_s16(header + 0);
+                pWav->ima.stepIndex[0] = ma_dr_wav_clamp(header[2], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                pWav->ima.predictor[1] = ma_dr_wav_bytes_to_s16(header + 4);
+                pWav->ima.stepIndex[1] = ma_dr_wav_clamp(header[6], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                pWav->ima.cachedFrames[ma_dr_wav_countof(pWav->ima.cachedFrames) - 2] = pWav->ima.predictor[0];
+                pWav->ima.cachedFrames[ma_dr_wav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[1];
+                pWav->ima.cachedFrameCount = 1;
+            }
+        }
+        while (framesToRead > 0 && pWav->ima.cachedFrameCount > 0 && pWav->readCursorInPCMFrames < pWav->totalPCMFrameCount) {
+            if (pBufferOut != NULL) {
+                ma_uint32 iSample;
+                for (iSample = 0; iSample < pWav->channels; iSample += 1) {
+                    pBufferOut[iSample] = (ma_int16)pWav->ima.cachedFrames[(ma_dr_wav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + iSample];
+                }
+                pBufferOut += pWav->channels;
+            }
+            framesToRead    -= 1;
+            totalFramesRead += 1;
+            pWav->readCursorInPCMFrames += 1;
+            pWav->ima.cachedFrameCount -= 1;
+        }
+        if (framesToRead == 0) {
+            break;
+        }
+        if (pWav->ima.cachedFrameCount == 0) {
+            if (pWav->ima.bytesRemainingInBlock == 0) {
+                continue;
+            } else {
+                pWav->ima.cachedFrameCount = 8;
+                for (iChannel = 0; iChannel < pWav->channels; ++iChannel) {
+                    ma_uint32 iByte;
+                    ma_uint8 nibbles[4];
+                    if (pWav->onRead(pWav->pUserData, &nibbles, 4) != 4) {
+                        pWav->ima.cachedFrameCount = 0;
+                        return totalFramesRead;
+                    }
+                    pWav->ima.bytesRemainingInBlock -= 4;
+                    for (iByte = 0; iByte < 4; ++iByte) {
+                        ma_uint8 nibble0 = ((nibbles[iByte] & 0x0F) >> 0);
+                        ma_uint8 nibble1 = ((nibbles[iByte] & 0xF0) >> 4);
+                        ma_int32 step      = stepTable[pWav->ima.stepIndex[iChannel]];
+                        ma_int32 predictor = pWav->ima.predictor[iChannel];
+                        ma_int32      diff  = step >> 3;
+                        if (nibble0 & 1) diff += step >> 2;
+                        if (nibble0 & 2) diff += step >> 1;
+                        if (nibble0 & 4) diff += step;
+                        if (nibble0 & 8) diff  = -diff;
+                        predictor = ma_dr_wav_clamp(predictor + diff, -32768, 32767);
+                        pWav->ima.predictor[iChannel] = predictor;
+                        pWav->ima.stepIndex[iChannel] = ma_dr_wav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble0], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                        pWav->ima.cachedFrames[(ma_dr_wav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+0)*pWav->channels + iChannel] = predictor;
+                        step      = stepTable[pWav->ima.stepIndex[iChannel]];
+                        predictor = pWav->ima.predictor[iChannel];
+                                         diff  = step >> 3;
+                        if (nibble1 & 1) diff += step >> 2;
+                        if (nibble1 & 2) diff += step >> 1;
+                        if (nibble1 & 4) diff += step;
+                        if (nibble1 & 8) diff  = -diff;
+                        predictor = ma_dr_wav_clamp(predictor + diff, -32768, 32767);
+                        pWav->ima.predictor[iChannel] = predictor;
+                        pWav->ima.stepIndex[iChannel] = ma_dr_wav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble1], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                        pWav->ima.cachedFrames[(ma_dr_wav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+1)*pWav->channels + iChannel] = predictor;
+                    }
+                }
+            }
+        }
+    }
+    return totalFramesRead;
+}
+#ifndef MA_DR_WAV_NO_CONVERSION_API
+static const unsigned short ma_dr_wav_gAlawTable[256] = {
+    0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80, 0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780, 0xE480, 0xE580,
+    0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0, 0xF140, 0xF1C0, 0xF040, 0xF0C0, 0xF340, 0xF3C0, 0xF240, 0xF2C0,
+    0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600, 0x8A00, 0x8E00, 0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600,
+    0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00, 0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00,
+    0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8, 0xFEC8, 0xFED8, 0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58,
+    0xFFA8, 0xFFB8, 0xFF88, 0xFF98, 0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8, 0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58,
+    0xFAA0, 0xFAE0, 0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60, 0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960,
+    0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0, 0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0, 0xFC90, 0xFCB0,
+    0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280, 0x1D80, 0x1C80, 0x1F80, 0x1E80, 0x1980, 0x1880, 0x1B80, 0x1A80,
+    0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940, 0x0EC0, 0x0E40, 0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40,
+    0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00, 0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00,
+    0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100, 0x2700, 0x2500, 0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500,
+    0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128, 0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8,
+    0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028, 0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8,
+    0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0, 0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620, 0x06E0, 0x06A0,
+    0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250, 0x03B0, 0x0390, 0x03F0, 0x03D0, 0x0330, 0x0310, 0x0370, 0x0350
+};
+static const unsigned short ma_dr_wav_gMulawTable[256] = {
+    0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84, 0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684, 0xBA84, 0xBE84,
+    0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84, 0xD184, 0xD384, 0xD584, 0xD784, 0xD984, 0xDB84, 0xDD84, 0xDF84,
+    0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804, 0xE904, 0xEA04, 0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004,
+    0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444, 0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844,
+    0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4, 0xFA24, 0xFA64, 0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64,
+    0xFC94, 0xFCB4, 0xFCD4, 0xFCF4, 0xFD14, 0xFD34, 0xFD54, 0xFD74, 0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74,
+    0xFE8C, 0xFE9C, 0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC, 0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C,
+    0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0, 0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0, 0xFFF8, 0x0000,
+    0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C, 0x5D7C, 0x597C, 0x557C, 0x517C, 0x4D7C, 0x497C, 0x457C, 0x417C,
+    0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C, 0x2E7C, 0x2C7C, 0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C,
+    0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC, 0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC,
+    0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC, 0x0C3C, 0x0BBC, 0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC,
+    0x075C, 0x071C, 0x06DC, 0x069C, 0x065C, 0x061C, 0x05DC, 0x059C, 0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C,
+    0x036C, 0x034C, 0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C, 0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C,
+    0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104, 0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4, 0x0094, 0x0084,
+    0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040, 0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000
+};
+static MA_INLINE ma_int16 ma_dr_wav__alaw_to_s16(ma_uint8 sampleIn)
+{
+    return (short)ma_dr_wav_gAlawTable[sampleIn];
+}
+static MA_INLINE ma_int16 ma_dr_wav__mulaw_to_s16(ma_uint8 sampleIn)
+{
+    return (short)ma_dr_wav_gMulawTable[sampleIn];
+}
+MA_PRIVATE void ma_dr_wav__pcm_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
+{
+    size_t i;
+    if (bytesPerSample == 1) {
+        ma_dr_wav_u8_to_s16(pOut, pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 2) {
+        for (i = 0; i < totalSampleCount; ++i) {
+           *pOut++ = ((const ma_int16*)pIn)[i];
+        }
+        return;
+    }
+    if (bytesPerSample == 3) {
+        ma_dr_wav_s24_to_s16(pOut, pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 4) {
+        ma_dr_wav_s32_to_s16(pOut, (const ma_int32*)pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample > 8) {
+        MA_DR_WAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
+        return;
+    }
+    for (i = 0; i < totalSampleCount; ++i) {
+        ma_uint64 sample = 0;
+        unsigned int shift  = (8 - bytesPerSample) * 8;
+        unsigned int j;
+        for (j = 0; j < bytesPerSample; j += 1) {
+            MA_DR_WAV_ASSERT(j < 8);
+            sample |= (ma_uint64)(pIn[j]) << shift;
+            shift  += 8;
+        }
+        pIn += j;
+        *pOut++ = (ma_int16)((ma_int64)sample >> 48);
+    }
+}
+MA_PRIVATE void ma_dr_wav__ieee_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
+{
+    if (bytesPerSample == 4) {
+        ma_dr_wav_f32_to_s16(pOut, (const float*)pIn, totalSampleCount);
+        return;
+    } else if (bytesPerSample == 8) {
+        ma_dr_wav_f64_to_s16(pOut, (const double*)pIn, totalSampleCount);
+        return;
+    } else {
+        MA_DR_WAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
+        return;
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__pcm(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if ((pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 16) || pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, pBufferOut);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__pcm_to_s16(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__ieee(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__ieee_to_s16(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__alaw(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_alaw_to_s16(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__mulaw(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_mulaw_to_s16(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    if (pWav == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    if (framesToRead * pWav->channels * sizeof(ma_int16) > MA_SIZE_MAX) {
+        framesToRead = MA_SIZE_MAX / sizeof(ma_int16) / pWav->channels;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM) {
+        return ma_dr_wav_read_pcm_frames_s16__pcm(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_IEEE_FLOAT) {
+        return ma_dr_wav_read_pcm_frames_s16__ieee(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ALAW) {
+        return ma_dr_wav_read_pcm_frames_s16__alaw(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_MULAW) {
+        return ma_dr_wav_read_pcm_frames_s16__mulaw(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+        return ma_dr_wav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        return ma_dr_wav_read_pcm_frames_s16__ima(pWav, framesToRead, pBufferOut);
+    }
+    return 0;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16le(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_FALSE) {
+        ma_dr_wav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16be(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_TRUE) {
+        ma_dr_wav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API void ma_dr_wav_u8_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        int x = pIn[i];
+        r = x << 8;
+        r = r - 32768;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_s24_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        int x = ((int)(((unsigned int)(((const ma_uint8*)pIn)[i*3+0]) << 8) | ((unsigned int)(((const ma_uint8*)pIn)[i*3+1]) << 16) | ((unsigned int)(((const ma_uint8*)pIn)[i*3+2])) << 24)) >> 8;
+        r = x >> 8;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_s32_to_s16(ma_int16* pOut, const ma_int32* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        int x = pIn[i];
+        r = x >> 16;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_f32_to_s16(ma_int16* pOut, const float* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        float x = pIn[i];
+        float c;
+        c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
+        c = c + 1;
+        r = (int)(c * 32767.5f);
+        r = r - 32768;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_f64_to_s16(ma_int16* pOut, const double* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        double x = pIn[i];
+        double c;
+        c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
+        c = c + 1;
+        r = (int)(c * 32767.5);
+        r = r - 32768;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_alaw_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        pOut[i] = ma_dr_wav__alaw_to_s16(pIn[i]);
+    }
+}
+MA_API void ma_dr_wav_mulaw_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        pOut[i] = ma_dr_wav__mulaw_to_s16(pIn[i]);
+    }
+}
+MA_PRIVATE void ma_dr_wav__pcm_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample)
+{
+    unsigned int i;
+    if (bytesPerSample == 1) {
+        ma_dr_wav_u8_to_f32(pOut, pIn, sampleCount);
+        return;
+    }
+    if (bytesPerSample == 2) {
+        ma_dr_wav_s16_to_f32(pOut, (const ma_int16*)pIn, sampleCount);
+        return;
+    }
+    if (bytesPerSample == 3) {
+        ma_dr_wav_s24_to_f32(pOut, pIn, sampleCount);
+        return;
+    }
+    if (bytesPerSample == 4) {
+        ma_dr_wav_s32_to_f32(pOut, (const ma_int32*)pIn, sampleCount);
+        return;
+    }
+    if (bytesPerSample > 8) {
+        MA_DR_WAV_ZERO_MEMORY(pOut, sampleCount * sizeof(*pOut));
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        ma_uint64 sample = 0;
+        unsigned int shift  = (8 - bytesPerSample) * 8;
+        unsigned int j;
+        for (j = 0; j < bytesPerSample; j += 1) {
+            MA_DR_WAV_ASSERT(j < 8);
+            sample |= (ma_uint64)(pIn[j]) << shift;
+            shift  += 8;
+        }
+        pIn += j;
+        *pOut++ = (float)((ma_int64)sample / 9223372036854775807.0);
+    }
+}
+MA_PRIVATE void ma_dr_wav__ieee_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample)
+{
+    if (bytesPerSample == 4) {
+        unsigned int i;
+        for (i = 0; i < sampleCount; ++i) {
+            *pOut++ = ((const float*)pIn)[i];
+        }
+        return;
+    } else if (bytesPerSample == 8) {
+        ma_dr_wav_f64_to_f32(pOut, (const double*)pIn, sampleCount);
+        return;
+    } else {
+        MA_DR_WAV_ZERO_MEMORY(pOut, sampleCount * sizeof(*pOut));
+        return;
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__pcm(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__pcm_to_f32(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__msadpcm_ima(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_int16 samples16[2048];
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, ma_dr_wav_countof(samples16)/pWav->channels);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, framesToReadThisIteration, samples16);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        ma_dr_wav_s16_to_f32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels));
+        pBufferOut      += framesRead*pWav->channels;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__ieee(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_IEEE_FLOAT && pWav->bitsPerSample == 32) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, pBufferOut);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__ieee_to_f32(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__alaw(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_alaw_to_f32(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__mulaw(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_mulaw_to_f32(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    if (pWav == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    if (framesToRead * pWav->channels * sizeof(float) > MA_SIZE_MAX) {
+        framesToRead = MA_SIZE_MAX / sizeof(float) / pWav->channels;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM) {
+        return ma_dr_wav_read_pcm_frames_f32__pcm(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM || pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        return ma_dr_wav_read_pcm_frames_f32__msadpcm_ima(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_IEEE_FLOAT) {
+        return ma_dr_wav_read_pcm_frames_f32__ieee(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ALAW) {
+        return ma_dr_wav_read_pcm_frames_f32__alaw(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_MULAW) {
+        return ma_dr_wav_read_pcm_frames_f32__mulaw(pWav, framesToRead, pBufferOut);
+    }
+    return 0;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32le(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_FALSE) {
+        ma_dr_wav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32be(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_TRUE) {
+        ma_dr_wav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API void ma_dr_wav_u8_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+#ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (pIn[i] / 256.0f) * 2 - 1;
+    }
+#else
+    for (i = 0; i < sampleCount; ++i) {
+        float x = pIn[i];
+        x = x * 0.00784313725490196078f;
+        x = x - 1;
+        *pOut++ = x;
+    }
+#endif
+}
+MA_API void ma_dr_wav_s16_to_f32(float* pOut, const ma_int16* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = pIn[i] * 0.000030517578125f;
+    }
+}
+MA_API void ma_dr_wav_s24_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        double x;
+        ma_uint32 a = ((ma_uint32)(pIn[i*3+0]) <<  8);
+        ma_uint32 b = ((ma_uint32)(pIn[i*3+1]) << 16);
+        ma_uint32 c = ((ma_uint32)(pIn[i*3+2]) << 24);
+        x = (double)((ma_int32)(a | b | c) >> 8);
+        *pOut++ = (float)(x * 0.00000011920928955078125);
+    }
+}
+MA_API void ma_dr_wav_s32_to_f32(float* pOut, const ma_int32* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (float)(pIn[i] / 2147483648.0);
+    }
+}
+MA_API void ma_dr_wav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (float)pIn[i];
+    }
+}
+MA_API void ma_dr_wav_alaw_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = ma_dr_wav__alaw_to_s16(pIn[i]) / 32768.0f;
+    }
+}
+MA_API void ma_dr_wav_mulaw_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = ma_dr_wav__mulaw_to_s16(pIn[i]) / 32768.0f;
+    }
+}
+MA_PRIVATE void ma_dr_wav__pcm_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
+{
+    unsigned int i;
+    if (bytesPerSample == 1) {
+        ma_dr_wav_u8_to_s32(pOut, pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 2) {
+        ma_dr_wav_s16_to_s32(pOut, (const ma_int16*)pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 3) {
+        ma_dr_wav_s24_to_s32(pOut, pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 4) {
+        for (i = 0; i < totalSampleCount; ++i) {
+           *pOut++ = ((const ma_int32*)pIn)[i];
+        }
+        return;
+    }
+    if (bytesPerSample > 8) {
+        MA_DR_WAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
+        return;
+    }
+    for (i = 0; i < totalSampleCount; ++i) {
+        ma_uint64 sample = 0;
+        unsigned int shift  = (8 - bytesPerSample) * 8;
+        unsigned int j;
+        for (j = 0; j < bytesPerSample; j += 1) {
+            MA_DR_WAV_ASSERT(j < 8);
+            sample |= (ma_uint64)(pIn[j]) << shift;
+            shift  += 8;
+        }
+        pIn += j;
+        *pOut++ = (ma_int32)((ma_int64)sample >> 32);
+    }
+}
+MA_PRIVATE void ma_dr_wav__ieee_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
+{
+    if (bytesPerSample == 4) {
+        ma_dr_wav_f32_to_s32(pOut, (const float*)pIn, totalSampleCount);
+        return;
+    } else if (bytesPerSample == 8) {
+        ma_dr_wav_f64_to_s32(pOut, (const double*)pIn, totalSampleCount);
+        return;
+    } else {
+        MA_DR_WAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
+        return;
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__pcm(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 32) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, pBufferOut);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__pcm_to_s32(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__msadpcm_ima(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead = 0;
+    ma_int16 samples16[2048];
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, ma_dr_wav_countof(samples16)/pWav->channels);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, framesToReadThisIteration, samples16);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        ma_dr_wav_s16_to_s32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels));
+        pBufferOut      += framesRead*pWav->channels;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__ieee(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__ieee_to_s32(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__alaw(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_alaw_to_s32(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__mulaw(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_mulaw_to_s32(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    if (pWav == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    if (framesToRead * pWav->channels * sizeof(ma_int32) > MA_SIZE_MAX) {
+        framesToRead = MA_SIZE_MAX / sizeof(ma_int32) / pWav->channels;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM) {
+        return ma_dr_wav_read_pcm_frames_s32__pcm(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM || pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        return ma_dr_wav_read_pcm_frames_s32__msadpcm_ima(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_IEEE_FLOAT) {
+        return ma_dr_wav_read_pcm_frames_s32__ieee(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ALAW) {
+        return ma_dr_wav_read_pcm_frames_s32__alaw(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_MULAW) {
+        return ma_dr_wav_read_pcm_frames_s32__mulaw(pWav, framesToRead, pBufferOut);
+    }
+    return 0;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32le(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_FALSE) {
+        ma_dr_wav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32be(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_TRUE) {
+        ma_dr_wav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API void ma_dr_wav_u8_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = ((int)pIn[i] - 128) << 24;
+    }
+}
+MA_API void ma_dr_wav_s16_to_s32(ma_int32* pOut, const ma_int16* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = pIn[i] << 16;
+    }
+}
+MA_API void ma_dr_wav_s24_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        unsigned int s0 = pIn[i*3 + 0];
+        unsigned int s1 = pIn[i*3 + 1];
+        unsigned int s2 = pIn[i*3 + 2];
+        ma_int32 sample32 = (ma_int32)((s0 << 8) | (s1 << 16) | (s2 << 24));
+        *pOut++ = sample32;
+    }
+}
+MA_API void ma_dr_wav_f32_to_s32(ma_int32* pOut, const float* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (ma_int32)(2147483648.0f * pIn[i]);
+    }
+}
+MA_API void ma_dr_wav_f64_to_s32(ma_int32* pOut, const double* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (ma_int32)(2147483648.0 * pIn[i]);
+    }
+}
+MA_API void ma_dr_wav_alaw_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = ((ma_int32)ma_dr_wav__alaw_to_s16(pIn[i])) << 16;
+    }
+}
+MA_API void ma_dr_wav_mulaw_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i= 0; i < sampleCount; ++i) {
+        *pOut++ = ((ma_int32)ma_dr_wav__mulaw_to_s16(pIn[i])) << 16;
+    }
+}
+MA_PRIVATE ma_int16* ma_dr_wav__read_pcm_frames_and_close_s16(ma_dr_wav* pWav, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalFrameCount)
+{
+    ma_uint64 sampleDataSize;
+    ma_int16* pSampleData;
+    ma_uint64 framesRead;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(ma_int16);
+    if (sampleDataSize > MA_SIZE_MAX) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    pSampleData = (ma_int16*)ma_dr_wav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks);
+    if (pSampleData == NULL) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
+    if (framesRead != pWav->totalPCMFrameCount) {
+        ma_dr_wav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    ma_dr_wav_uninit(pWav);
+    if (sampleRate) {
+        *sampleRate = pWav->sampleRate;
+    }
+    if (channels) {
+        *channels = pWav->channels;
+    }
+    if (totalFrameCount) {
+        *totalFrameCount = pWav->totalPCMFrameCount;
+    }
+    return pSampleData;
+}
+MA_PRIVATE float* ma_dr_wav__read_pcm_frames_and_close_f32(ma_dr_wav* pWav, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalFrameCount)
+{
+    ma_uint64 sampleDataSize;
+    float* pSampleData;
+    ma_uint64 framesRead;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(float);
+    if (sampleDataSize > MA_SIZE_MAX) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    pSampleData = (float*)ma_dr_wav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks);
+    if (pSampleData == NULL) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    framesRead = ma_dr_wav_read_pcm_frames_f32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
+    if (framesRead != pWav->totalPCMFrameCount) {
+        ma_dr_wav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    ma_dr_wav_uninit(pWav);
+    if (sampleRate) {
+        *sampleRate = pWav->sampleRate;
+    }
+    if (channels) {
+        *channels = pWav->channels;
+    }
+    if (totalFrameCount) {
+        *totalFrameCount = pWav->totalPCMFrameCount;
+    }
+    return pSampleData;
+}
+MA_PRIVATE ma_int32* ma_dr_wav__read_pcm_frames_and_close_s32(ma_dr_wav* pWav, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalFrameCount)
+{
+    ma_uint64 sampleDataSize;
+    ma_int32* pSampleData;
+    ma_uint64 framesRead;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(ma_int32);
+    if (sampleDataSize > MA_SIZE_MAX) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    pSampleData = (ma_int32*)ma_dr_wav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks);
+    if (pSampleData == NULL) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    framesRead = ma_dr_wav_read_pcm_frames_s32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
+    if (framesRead != pWav->totalPCMFrameCount) {
+        ma_dr_wav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    ma_dr_wav_uninit(pWav);
+    if (sampleRate) {
+        *sampleRate = pWav->sampleRate;
+    }
+    if (channels) {
+        *channels = pWav->channels;
+    }
+    if (totalFrameCount) {
+        *totalFrameCount = pWav->totalPCMFrameCount;
+    }
+    return pSampleData;
+}
+MA_API ma_int16* ma_dr_wav_open_and_read_pcm_frames_s16(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init(&wav, onRead, onSeek, onTell, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API float* ma_dr_wav_open_and_read_pcm_frames_f32(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init(&wav, onRead, onSeek, onTell, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API ma_int32* ma_dr_wav_open_and_read_pcm_frames_s32(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_tell_proc onTell, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init(&wav, onRead, onSeek, onTell, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+#ifndef MA_DR_WAV_NO_STDIO
+MA_API ma_int16* ma_dr_wav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API float* ma_dr_wav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API ma_int32* ma_dr_wav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_API ma_int16* ma_dr_wav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file_w(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API float* ma_dr_wav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file_w(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API ma_int32* ma_dr_wav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file_w(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+#endif
+#endif
+MA_API ma_int16* ma_dr_wav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API float* ma_dr_wav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API ma_int32* ma_dr_wav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+#endif
+MA_API void ma_dr_wav_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        ma_dr_wav__free_from_callbacks(p, pAllocationCallbacks);
+    } else {
+        ma_dr_wav__free_default(p, NULL);
+    }
+}
+MA_API ma_uint16 ma_dr_wav_bytes_to_u16(const ma_uint8* data)
+{
+    return ((ma_uint16)data[0] << 0) | ((ma_uint16)data[1] << 8);
+}
+MA_API ma_int16 ma_dr_wav_bytes_to_s16(const ma_uint8* data)
+{
+    return (ma_int16)ma_dr_wav_bytes_to_u16(data);
+}
+MA_API ma_uint32 ma_dr_wav_bytes_to_u32(const ma_uint8* data)
+{
+    return ma_dr_wav_bytes_to_u32_le(data);
+}
+MA_API float ma_dr_wav_bytes_to_f32(const ma_uint8* data)
+{
+    union {
+        ma_uint32 u32;
+        float f32;
+    } value;
+    value.u32 = ma_dr_wav_bytes_to_u32(data);
+    return value.f32;
+}
+MA_API ma_int32 ma_dr_wav_bytes_to_s32(const ma_uint8* data)
+{
+    return (ma_int32)ma_dr_wav_bytes_to_u32(data);
+}
+MA_API ma_uint64 ma_dr_wav_bytes_to_u64(const ma_uint8* data)
+{
+    return
+        ((ma_uint64)data[0] <<  0) | ((ma_uint64)data[1] <<  8) | ((ma_uint64)data[2] << 16) | ((ma_uint64)data[3] << 24) |
+        ((ma_uint64)data[4] << 32) | ((ma_uint64)data[5] << 40) | ((ma_uint64)data[6] << 48) | ((ma_uint64)data[7] << 56);
+}
+MA_API ma_int64 ma_dr_wav_bytes_to_s64(const ma_uint8* data)
+{
+    return (ma_int64)ma_dr_wav_bytes_to_u64(data);
+}
+MA_API ma_bool32 ma_dr_wav_guid_equal(const ma_uint8 a[16], const ma_uint8 b[16])
+{
+    int i;
+    for (i = 0; i < 16; i += 1) {
+        if (a[i] != b[i]) {
+            return MA_FALSE;
+        }
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_fourcc_equal(const ma_uint8* a, const char* b)
+{
+    return
+        a[0] == b[0] &&
+        a[1] == b[1] &&
+        a[2] == b[2] &&
+        a[3] == b[3];
+}
+#ifdef __MRC__
+#pragma options opt reset
+#endif
+#endif
+/* dr_wav_c end */
+#endif  /* MA_DR_WAV_IMPLEMENTATION */
+#endif  /* MA_NO_WAV */
+
+#if !defined(MA_NO_FLAC) && !defined(MA_NO_DECODING)
+#if !defined(MA_DR_FLAC_IMPLEMENTATION)
+/* dr_flac_c begin */
+#ifndef ma_dr_flac_c
+#define ma_dr_flac_c
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+    #if __GNUC__ >= 7
+    #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+    #endif
+#endif
+#ifdef __linux__
+    #ifndef _BSD_SOURCE
+        #define _BSD_SOURCE
+    #endif
+    #ifndef _DEFAULT_SOURCE
+        #define _DEFAULT_SOURCE
+    #endif
+    #ifndef __USE_BSD
+        #define __USE_BSD
+    #endif
+    #include <endian.h>
+#endif
+#include <stdlib.h>
+#include <string.h>
+#if !defined(MA_DR_FLAC_NO_SIMD)
+    #if defined(MA_X64) || defined(MA_X86)
+        #if defined(_MSC_VER) && !defined(__clang__)
+            #if _MSC_VER >= 1400 && !defined(MA_DR_FLAC_NO_SSE2)
+                #define MA_DR_FLAC_SUPPORT_SSE2
+            #endif
+            #if _MSC_VER >= 1600 && !defined(MA_DR_FLAC_NO_SSE41)
+                #define MA_DR_FLAC_SUPPORT_SSE41
+            #endif
+        #elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)))
+            #if defined(__SSE2__) && !defined(MA_DR_FLAC_NO_SSE2)
+                #define MA_DR_FLAC_SUPPORT_SSE2
+            #endif
+            #if defined(__SSE4_1__) && !defined(MA_DR_FLAC_NO_SSE41)
+                #define MA_DR_FLAC_SUPPORT_SSE41
+            #endif
+        #endif
+        #if !defined(__GNUC__) && !defined(__clang__) && defined(__has_include)
+            #if !defined(MA_DR_FLAC_SUPPORT_SSE2) && !defined(MA_DR_FLAC_NO_SSE2) && __has_include(<emmintrin.h>)
+                #define MA_DR_FLAC_SUPPORT_SSE2
+            #endif
+            #if !defined(MA_DR_FLAC_SUPPORT_SSE41) && !defined(MA_DR_FLAC_NO_SSE41) && __has_include(<smmintrin.h>)
+                #define MA_DR_FLAC_SUPPORT_SSE41
+            #endif
+        #endif
+        #if defined(MA_DR_FLAC_SUPPORT_SSE41)
+            #include <smmintrin.h>
+        #elif defined(MA_DR_FLAC_SUPPORT_SSE2)
+            #include <emmintrin.h>
+        #endif
+    #endif
+    #if defined(MA_ARM)
+        #if !defined(MA_DR_FLAC_NO_NEON) && (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+            #define MA_DR_FLAC_SUPPORT_NEON
+            #include <arm_neon.h>
+        #endif
+    #endif
+#endif
+#if !defined(MA_DR_FLAC_NO_SIMD) && (defined(MA_X86) || defined(MA_X64))
+    #if defined(_MSC_VER) && !defined(__clang__)
+        #if _MSC_VER >= 1400
+            #include <intrin.h>
+            static void ma_dr_flac__cpuid(int info[4], int fid)
+            {
+                __cpuid(info, fid);
+            }
+        #else
+            #define MA_DR_FLAC_NO_CPUID
+        #endif
+    #else
+        #if defined(__GNUC__) || defined(__clang__)
+            static void ma_dr_flac__cpuid(int info[4], int fid)
+            {
+                #if defined(MA_X86) && defined(__PIC__)
+                    __asm__ __volatile__ (
+                        "xchg{l} {%%}ebx, %k1;"
+                        "cpuid;"
+                        "xchg{l} {%%}ebx, %k1;"
+                        : "=a"(info[0]), "=&r"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+                    );
+                #else
+                    __asm__ __volatile__ (
+                        "cpuid" : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+                    );
+                #endif
+            }
+        #else
+            #define MA_DR_FLAC_NO_CPUID
+        #endif
+    #endif
+#else
+    #define MA_DR_FLAC_NO_CPUID
+#endif
+static MA_INLINE ma_bool32 ma_dr_flac_has_sse2(void)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_DR_FLAC_NO_SSE2)
+        #if defined(MA_X64)
+            return MA_TRUE;
+        #elif (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__)
+            return MA_TRUE;
+        #else
+            #if defined(MA_DR_FLAC_NO_CPUID)
+                return MA_FALSE;
+            #else
+                int info[4];
+                ma_dr_flac__cpuid(info, 1);
+                return (info[3] & (1 << 26)) != 0;
+            #endif
+        #endif
+    #else
+        return MA_FALSE;
+    #endif
+#else
+    return MA_FALSE;
+#endif
+}
+static MA_INLINE ma_bool32 ma_dr_flac_has_sse41(void)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE41)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_DR_FLAC_NO_SSE41)
+        #if defined(__SSE4_1__) || defined(__AVX__)
+            return MA_TRUE;
+        #else
+            #if defined(MA_DR_FLAC_NO_CPUID)
+                return MA_FALSE;
+            #else
+                int info[4];
+                ma_dr_flac__cpuid(info, 1);
+                return (info[2] & (1 << 19)) != 0;
+            #endif
+        #endif
+    #else
+        return MA_FALSE;
+    #endif
+#else
+    return MA_FALSE;
+#endif
+}
+#if defined(_MSC_VER) && _MSC_VER >= 1500 && (defined(MA_X86) || defined(MA_X64)) && !defined(__clang__)
+    #define MA_DR_FLAC_HAS_LZCNT_INTRINSIC
+#elif (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)))
+    #define MA_DR_FLAC_HAS_LZCNT_INTRINSIC
+#elif defined(__clang__)
+    #if defined(__has_builtin)
+        #if __has_builtin(__builtin_clzll) || __has_builtin(__builtin_clzl)
+            #define MA_DR_FLAC_HAS_LZCNT_INTRINSIC
+        #endif
+    #endif
+#endif
+#if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(__clang__)
+    #define MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+    #define MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+    #define MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+#elif defined(__clang__)
+    #if defined(__has_builtin)
+        #if __has_builtin(__builtin_bswap16)
+            #define MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+        #endif
+        #if __has_builtin(__builtin_bswap32)
+            #define MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+        #endif
+        #if __has_builtin(__builtin_bswap64)
+            #define MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+        #endif
+    #endif
+#elif defined(__GNUC__)
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+        #define MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+        #define MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+    #endif
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+        #define MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+    #endif
+#elif defined(__WATCOMC__) && defined(__386__)
+    #define MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+    #define MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+    #define MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+    extern __inline ma_uint16 _watcom_bswap16(ma_uint16);
+    extern __inline ma_uint32 _watcom_bswap32(ma_uint32);
+    extern __inline ma_uint64 _watcom_bswap64(ma_uint64);
+#pragma aux _watcom_bswap16 = \
+    "xchg al, ah" \
+    parm  [ax]    \
+    value [ax]    \
+    modify nomemory;
+#pragma aux _watcom_bswap32 = \
+    "bswap eax" \
+    parm  [eax] \
+    value [eax] \
+    modify nomemory;
+#pragma aux _watcom_bswap64 = \
+    "bswap eax"     \
+    "bswap edx"     \
+    "xchg eax,edx"  \
+    parm [eax edx]  \
+    value [eax edx] \
+    modify nomemory;
+#endif
+#ifndef MA_DR_FLAC_ASSERT
+#include <assert.h>
+#define MA_DR_FLAC_ASSERT(expression)           assert(expression)
+#endif
+#ifndef MA_DR_FLAC_MALLOC
+#define MA_DR_FLAC_MALLOC(sz)                   malloc((sz))
+#endif
+#ifndef MA_DR_FLAC_REALLOC
+#define MA_DR_FLAC_REALLOC(p, sz)               realloc((p), (sz))
+#endif
+#ifndef MA_DR_FLAC_FREE
+#define MA_DR_FLAC_FREE(p)                      free((p))
+#endif
+#ifndef MA_DR_FLAC_COPY_MEMORY
+#define MA_DR_FLAC_COPY_MEMORY(dst, src, sz)    memcpy((dst), (src), (sz))
+#endif
+#ifndef MA_DR_FLAC_ZERO_MEMORY
+#define MA_DR_FLAC_ZERO_MEMORY(p, sz)           memset((p), 0, (sz))
+#endif
+#ifndef MA_DR_FLAC_ZERO_OBJECT
+#define MA_DR_FLAC_ZERO_OBJECT(p)               MA_DR_FLAC_ZERO_MEMORY((p), sizeof(*(p)))
+#endif
+#define MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE                     64
+#define MA_DR_FLAC_SUBFRAME_CONSTANT                        0
+#define MA_DR_FLAC_SUBFRAME_VERBATIM                        1
+#define MA_DR_FLAC_SUBFRAME_FIXED                           8
+#define MA_DR_FLAC_SUBFRAME_LPC                             32
+#define MA_DR_FLAC_SUBFRAME_RESERVED                        255
+#define MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE  0
+#define MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2 1
+#define MA_DR_FLAC_CHANNEL_ASSIGNMENT_INDEPENDENT           0
+#define MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE             8
+#define MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE            9
+#define MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE              10
+#define MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES                  18
+#define MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES             36
+#define MA_DR_FLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES       12
+#define ma_dr_flac_align(x, a)                              ((((x) + (a) - 1) / (a)) * (a))
+MA_API void ma_dr_flac_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision)
+{
+    if (pMajor) {
+        *pMajor = MA_DR_FLAC_VERSION_MAJOR;
+    }
+    if (pMinor) {
+        *pMinor = MA_DR_FLAC_VERSION_MINOR;
+    }
+    if (pRevision) {
+        *pRevision = MA_DR_FLAC_VERSION_REVISION;
+    }
+}
+MA_API const char* ma_dr_flac_version_string(void)
+{
+    return MA_DR_FLAC_VERSION_STRING;
+}
+#if defined(__has_feature)
+    #if __has_feature(thread_sanitizer)
+        #define MA_DR_FLAC_NO_THREAD_SANITIZE __attribute__((no_sanitize("thread")))
+    #else
+        #define MA_DR_FLAC_NO_THREAD_SANITIZE
+    #endif
+#else
+    #define MA_DR_FLAC_NO_THREAD_SANITIZE
+#endif
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC)
+static ma_bool32 ma_dr_flac__gIsLZCNTSupported = MA_FALSE;
+#endif
+#ifndef MA_DR_FLAC_NO_CPUID
+static ma_bool32 ma_dr_flac__gIsSSE2Supported  = MA_FALSE;
+static ma_bool32 ma_dr_flac__gIsSSE41Supported = MA_FALSE;
+MA_DR_FLAC_NO_THREAD_SANITIZE static void ma_dr_flac__init_cpu_caps(void)
+{
+    static ma_bool32 isCPUCapsInitialized = MA_FALSE;
+    if (!isCPUCapsInitialized) {
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC)
+        int info[4] = {0};
+        ma_dr_flac__cpuid(info, 0x80000001);
+        ma_dr_flac__gIsLZCNTSupported = (info[2] & (1 << 5)) != 0;
+#endif
+        ma_dr_flac__gIsSSE2Supported = ma_dr_flac_has_sse2();
+        ma_dr_flac__gIsSSE41Supported = ma_dr_flac_has_sse41();
+        isCPUCapsInitialized = MA_TRUE;
+    }
+}
+#else
+static ma_bool32 ma_dr_flac__gIsNEONSupported  = MA_FALSE;
+static MA_INLINE ma_bool32 ma_dr_flac__has_neon(void)
+{
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+    #if defined(MA_ARM) && !defined(MA_DR_FLAC_NO_NEON)
+        #if (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+    #else
+        return MA_FALSE;
+    #endif
+#else
+    return MA_FALSE;
+#endif
+}
+MA_DR_FLAC_NO_THREAD_SANITIZE static void ma_dr_flac__init_cpu_caps(void)
+{
+    ma_dr_flac__gIsNEONSupported = ma_dr_flac__has_neon();
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC) && defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5)
+    ma_dr_flac__gIsLZCNTSupported = MA_TRUE;
+#endif
+}
+#endif
+static MA_INLINE ma_bool32 ma_dr_flac__is_little_endian(void)
+{
+#if defined(MA_X86) || defined(MA_X64)
+    return MA_TRUE;
+#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
+    return MA_TRUE;
+#else
+    int n = 1;
+    return (*(char*)&n) == 1;
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac__swap_endian_uint16(ma_uint16 n)
+{
+#ifdef MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+    #if defined(_MSC_VER) && !defined(__clang__)
+        return _byteswap_ushort(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        return __builtin_bswap16(n);
+    #elif defined(__WATCOMC__) && defined(__386__)
+        return _watcom_bswap16(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF00) >> 8) |
+           ((n & 0x00FF) << 8);
+#endif
+}
+static MA_INLINE ma_uint32 ma_dr_flac__swap_endian_uint32(ma_uint32 n)
+{
+#ifdef MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+    #if defined(_MSC_VER) && !defined(__clang__)
+        return _byteswap_ulong(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        #if defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(__ARM_ARCH_6M__) && !defined(MA_64BIT)
+            ma_uint32 r;
+            __asm__ __volatile__ (
+            #if defined(MA_64BIT)
+                "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n)
+            #else
+                "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n)
+            #endif
+            );
+            return r;
+        #else
+            return __builtin_bswap32(n);
+        #endif
+    #elif defined(__WATCOMC__) && defined(__386__)
+        return _watcom_bswap32(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF000000) >> 24) |
+           ((n & 0x00FF0000) >>  8) |
+           ((n & 0x0000FF00) <<  8) |
+           ((n & 0x000000FF) << 24);
+#endif
+}
+static MA_INLINE ma_uint64 ma_dr_flac__swap_endian_uint64(ma_uint64 n)
+{
+#ifdef MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+    #if defined(_MSC_VER) && !defined(__clang__)
+        return _byteswap_uint64(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        return __builtin_bswap64(n);
+    #elif defined(__WATCOMC__) && defined(__386__)
+        return _watcom_bswap64(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & ((ma_uint64)0xFF000000 << 32)) >> 56) |
+           ((n & ((ma_uint64)0x00FF0000 << 32)) >> 40) |
+           ((n & ((ma_uint64)0x0000FF00 << 32)) >> 24) |
+           ((n & ((ma_uint64)0x000000FF << 32)) >>  8) |
+           ((n & ((ma_uint64)0xFF000000      )) <<  8) |
+           ((n & ((ma_uint64)0x00FF0000      )) << 24) |
+           ((n & ((ma_uint64)0x0000FF00      )) << 40) |
+           ((n & ((ma_uint64)0x000000FF      )) << 56);
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac__be2host_16(ma_uint16 n)
+{
+    if (ma_dr_flac__is_little_endian()) {
+        return ma_dr_flac__swap_endian_uint16(n);
+    }
+    return n;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__be2host_32(ma_uint32 n)
+{
+    if (ma_dr_flac__is_little_endian()) {
+        return ma_dr_flac__swap_endian_uint32(n);
+    }
+    return n;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__be2host_32_ptr_unaligned(const void* pData)
+{
+    const ma_uint8* pNum = (ma_uint8*)pData;
+    return *(pNum) << 24 | *(pNum+1) << 16 | *(pNum+2) << 8 | *(pNum+3);
+}
+static MA_INLINE ma_uint64 ma_dr_flac__be2host_64(ma_uint64 n)
+{
+    if (ma_dr_flac__is_little_endian()) {
+        return ma_dr_flac__swap_endian_uint64(n);
+    }
+    return n;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__le2host_32(ma_uint32 n)
+{
+    if (!ma_dr_flac__is_little_endian()) {
+        return ma_dr_flac__swap_endian_uint32(n);
+    }
+    return n;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__le2host_32_ptr_unaligned(const void* pData)
+{
+    const ma_uint8* pNum = (ma_uint8*)pData;
+    return *pNum | *(pNum+1) << 8 |  *(pNum+2) << 16 | *(pNum+3) << 24;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__unsynchsafe_32(ma_uint32 n)
+{
+    ma_uint32 result = 0;
+    result |= (n & 0x7F000000) >> 3;
+    result |= (n & 0x007F0000) >> 2;
+    result |= (n & 0x00007F00) >> 1;
+    result |= (n & 0x0000007F) >> 0;
+    return result;
+}
+static ma_uint8 ma_dr_flac__crc8_table[] = {
+    0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
+    0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
+    0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
+    0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
+    0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
+    0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
+    0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
+    0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
+    0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
+    0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
+    0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
+    0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
+    0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
+    0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
+    0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
+    0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
+};
+static ma_uint16 ma_dr_flac__crc16_table[] = {
+    0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011,
+    0x8033, 0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022,
+    0x8063, 0x0066, 0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072,
+    0x0050, 0x8055, 0x805F, 0x005A, 0x804B, 0x004E, 0x0044, 0x8041,
+    0x80C3, 0x00C6, 0x00CC, 0x80C9, 0x00D8, 0x80DD, 0x80D7, 0x00D2,
+    0x00F0, 0x80F5, 0x80FF, 0x00FA, 0x80EB, 0x00EE, 0x00E4, 0x80E1,
+    0x00A0, 0x80A5, 0x80AF, 0x00AA, 0x80BB, 0x00BE, 0x00B4, 0x80B1,
+    0x8093, 0x0096, 0x009C, 0x8099, 0x0088, 0x808D, 0x8087, 0x0082,
+    0x8183, 0x0186, 0x018C, 0x8189, 0x0198, 0x819D, 0x8197, 0x0192,
+    0x01B0, 0x81B5, 0x81BF, 0x01BA, 0x81AB, 0x01AE, 0x01A4, 0x81A1,
+    0x01E0, 0x81E5, 0x81EF, 0x01EA, 0x81FB, 0x01FE, 0x01F4, 0x81F1,
+    0x81D3, 0x01D6, 0x01DC, 0x81D9, 0x01C8, 0x81CD, 0x81C7, 0x01C2,
+    0x0140, 0x8145, 0x814F, 0x014A, 0x815B, 0x015E, 0x0154, 0x8151,
+    0x8173, 0x0176, 0x017C, 0x8179, 0x0168, 0x816D, 0x8167, 0x0162,
+    0x8123, 0x0126, 0x012C, 0x8129, 0x0138, 0x813D, 0x8137, 0x0132,
+    0x0110, 0x8115, 0x811F, 0x011A, 0x810B, 0x010E, 0x0104, 0x8101,
+    0x8303, 0x0306, 0x030C, 0x8309, 0x0318, 0x831D, 0x8317, 0x0312,
+    0x0330, 0x8335, 0x833F, 0x033A, 0x832B, 0x032E, 0x0324, 0x8321,
+    0x0360, 0x8365, 0x836F, 0x036A, 0x837B, 0x037E, 0x0374, 0x8371,
+    0x8353, 0x0356, 0x035C, 0x8359, 0x0348, 0x834D, 0x8347, 0x0342,
+    0x03C0, 0x83C5, 0x83CF, 0x03CA, 0x83DB, 0x03DE, 0x03D4, 0x83D1,
+    0x83F3, 0x03F6, 0x03FC, 0x83F9, 0x03E8, 0x83ED, 0x83E7, 0x03E2,
+    0x83A3, 0x03A6, 0x03AC, 0x83A9, 0x03B8, 0x83BD, 0x83B7, 0x03B2,
+    0x0390, 0x8395, 0x839F, 0x039A, 0x838B, 0x038E, 0x0384, 0x8381,
+    0x0280, 0x8285, 0x828F, 0x028A, 0x829B, 0x029E, 0x0294, 0x8291,
+    0x82B3, 0x02B6, 0x02BC, 0x82B9, 0x02A8, 0x82AD, 0x82A7, 0x02A2,
+    0x82E3, 0x02E6, 0x02EC, 0x82E9, 0x02F8, 0x82FD, 0x82F7, 0x02F2,
+    0x02D0, 0x82D5, 0x82DF, 0x02DA, 0x82CB, 0x02CE, 0x02C4, 0x82C1,
+    0x8243, 0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252,
+    0x0270, 0x8275, 0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261,
+    0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231,
+    0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202
+};
+static MA_INLINE ma_uint8 ma_dr_flac_crc8_byte(ma_uint8 crc, ma_uint8 data)
+{
+    return ma_dr_flac__crc8_table[crc ^ data];
+}
+static MA_INLINE ma_uint8 ma_dr_flac_crc8(ma_uint8 crc, ma_uint32 data, ma_uint32 count)
+{
+#ifdef MA_DR_FLAC_NO_CRC
+    (void)crc;
+    (void)data;
+    (void)count;
+    return 0;
+#else
+#if 0
+    ma_uint8 p = 0x07;
+    for (int i = count-1; i >= 0; --i) {
+        ma_uint8 bit = (data & (1 << i)) >> i;
+        if (crc & 0x80) {
+            crc = ((crc << 1) | bit) ^ p;
+        } else {
+            crc = ((crc << 1) | bit);
+        }
+    }
+    return crc;
+#else
+    ma_uint32 wholeBytes;
+    ma_uint32 leftoverBits;
+    ma_uint64 leftoverDataMask;
+    static ma_uint64 leftoverDataMaskTable[8] = {
+        0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F
+    };
+    MA_DR_FLAC_ASSERT(count <= 32);
+    wholeBytes = count >> 3;
+    leftoverBits = count - (wholeBytes*8);
+    leftoverDataMask = leftoverDataMaskTable[leftoverBits];
+    switch (wholeBytes) {
+        case 4: crc = ma_dr_flac_crc8_byte(crc, (ma_uint8)((data & (0xFF000000UL << leftoverBits)) >> (24 + leftoverBits)));
+        case 3: crc = ma_dr_flac_crc8_byte(crc, (ma_uint8)((data & (0x00FF0000UL << leftoverBits)) >> (16 + leftoverBits)));
+        case 2: crc = ma_dr_flac_crc8_byte(crc, (ma_uint8)((data & (0x0000FF00UL << leftoverBits)) >> ( 8 + leftoverBits)));
+        case 1: crc = ma_dr_flac_crc8_byte(crc, (ma_uint8)((data & (0x000000FFUL << leftoverBits)) >> ( 0 + leftoverBits)));
+        case 0: if (leftoverBits > 0) crc = (ma_uint8)((crc << leftoverBits) ^ ma_dr_flac__crc8_table[(crc >> (8 - leftoverBits)) ^ (data & leftoverDataMask)]);
+    }
+    return crc;
+#endif
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16_byte(ma_uint16 crc, ma_uint8 data)
+{
+    return (crc << 8) ^ ma_dr_flac__crc16_table[(ma_uint8)(crc >> 8) ^ data];
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16_cache(ma_uint16 crc, ma_dr_flac_cache_t data)
+{
+#ifdef MA_64BIT
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 56) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 48) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 40) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 32) & 0xFF));
+#endif
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 24) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 16) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >>  8) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >>  0) & 0xFF));
+    return crc;
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16_bytes(ma_uint16 crc, ma_dr_flac_cache_t data, ma_uint32 byteCount)
+{
+    switch (byteCount)
+    {
+#ifdef MA_64BIT
+    case 8: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 56) & 0xFF));
+    case 7: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 48) & 0xFF));
+    case 6: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 40) & 0xFF));
+    case 5: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 32) & 0xFF));
+#endif
+    case 4: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 24) & 0xFF));
+    case 3: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 16) & 0xFF));
+    case 2: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >>  8) & 0xFF));
+    case 1: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >>  0) & 0xFF));
+    }
+    return crc;
+}
+#if 0
+static MA_INLINE ma_uint16 ma_dr_flac_crc16__32bit(ma_uint16 crc, ma_uint32 data, ma_uint32 count)
+{
+#ifdef MA_DR_FLAC_NO_CRC
+    (void)crc;
+    (void)data;
+    (void)count;
+    return 0;
+#else
+#if 0
+    ma_uint16 p = 0x8005;
+    for (int i = count-1; i >= 0; --i) {
+        ma_uint16 bit = (data & (1ULL << i)) >> i;
+        if (r & 0x8000) {
+            r = ((r << 1) | bit) ^ p;
+        } else {
+            r = ((r << 1) | bit);
+        }
+    }
+    return crc;
+#else
+    ma_uint32 wholeBytes;
+    ma_uint32 leftoverBits;
+    ma_uint64 leftoverDataMask;
+    static ma_uint64 leftoverDataMaskTable[8] = {
+        0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F
+    };
+    MA_DR_FLAC_ASSERT(count <= 64);
+    wholeBytes = count >> 3;
+    leftoverBits = count & 7;
+    leftoverDataMask = leftoverDataMaskTable[leftoverBits];
+    switch (wholeBytes) {
+        default:
+        case 4: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (0xFF000000UL << leftoverBits)) >> (24 + leftoverBits)));
+        case 3: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (0x00FF0000UL << leftoverBits)) >> (16 + leftoverBits)));
+        case 2: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (0x0000FF00UL << leftoverBits)) >> ( 8 + leftoverBits)));
+        case 1: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (0x000000FFUL << leftoverBits)) >> ( 0 + leftoverBits)));
+        case 0: if (leftoverBits > 0) crc = (crc << leftoverBits) ^ ma_dr_flac__crc16_table[(crc >> (16 - leftoverBits)) ^ (data & leftoverDataMask)];
+    }
+    return crc;
+#endif
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16__64bit(ma_uint16 crc, ma_uint64 data, ma_uint32 count)
+{
+#ifdef MA_DR_FLAC_NO_CRC
+    (void)crc;
+    (void)data;
+    (void)count;
+    return 0;
+#else
+    ma_uint32 wholeBytes;
+    ma_uint32 leftoverBits;
+    ma_uint64 leftoverDataMask;
+    static ma_uint64 leftoverDataMaskTable[8] = {
+        0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F
+    };
+    MA_DR_FLAC_ASSERT(count <= 64);
+    wholeBytes = count >> 3;
+    leftoverBits = count & 7;
+    leftoverDataMask = leftoverDataMaskTable[leftoverBits];
+    switch (wholeBytes) {
+        default:
+        case 8: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0xFF000000 << 32) << leftoverBits)) >> (56 + leftoverBits)));
+        case 7: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x00FF0000 << 32) << leftoverBits)) >> (48 + leftoverBits)));
+        case 6: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x0000FF00 << 32) << leftoverBits)) >> (40 + leftoverBits)));
+        case 5: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x000000FF << 32) << leftoverBits)) >> (32 + leftoverBits)));
+        case 4: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0xFF000000      ) << leftoverBits)) >> (24 + leftoverBits)));
+        case 3: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x00FF0000      ) << leftoverBits)) >> (16 + leftoverBits)));
+        case 2: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x0000FF00      ) << leftoverBits)) >> ( 8 + leftoverBits)));
+        case 1: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x000000FF      ) << leftoverBits)) >> ( 0 + leftoverBits)));
+        case 0: if (leftoverBits > 0) crc = (crc << leftoverBits) ^ ma_dr_flac__crc16_table[(crc >> (16 - leftoverBits)) ^ (data & leftoverDataMask)];
+    }
+    return crc;
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16(ma_uint16 crc, ma_dr_flac_cache_t data, ma_uint32 count)
+{
+#ifdef MA_64BIT
+    return ma_dr_flac_crc16__64bit(crc, data, count);
+#else
+    return ma_dr_flac_crc16__32bit(crc, data, count);
+#endif
+}
+#endif
+#ifdef MA_64BIT
+#define ma_dr_flac__be2host__cache_line ma_dr_flac__be2host_64
+#else
+#define ma_dr_flac__be2host__cache_line ma_dr_flac__be2host_32
+#endif
+#define MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs)                      (sizeof((bs)->cache))
+#define MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)                       (sizeof((bs)->cache)*8)
+#define MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)                  (MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - (bs)->consumedBits)
+#define MA_DR_FLAC_CACHE_L1_SELECTION_MASK(_bitCount)           (~((~(ma_dr_flac_cache_t)0) >> (_bitCount)))
+#define MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT(bs, _bitCount)      (MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - (_bitCount))
+#define MA_DR_FLAC_CACHE_L1_SELECT(bs, _bitCount)               (((bs)->cache) & MA_DR_FLAC_CACHE_L1_SELECTION_MASK(_bitCount))
+#define MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, _bitCount)     (MA_DR_FLAC_CACHE_L1_SELECT((bs), (_bitCount)) >>  MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT((bs), (_bitCount)))
+#define MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE(bs, _bitCount)(MA_DR_FLAC_CACHE_L1_SELECT((bs), (_bitCount)) >> (MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT((bs), (_bitCount)) & (MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)-1)))
+#define MA_DR_FLAC_CACHE_L2_SIZE_BYTES(bs)                      (sizeof((bs)->cacheL2))
+#define MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)                      (MA_DR_FLAC_CACHE_L2_SIZE_BYTES(bs) / sizeof((bs)->cacheL2[0]))
+#define MA_DR_FLAC_CACHE_L2_LINES_REMAINING(bs)                 (MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs) - (bs)->nextL2Line)
+#ifndef MA_DR_FLAC_NO_CRC
+static MA_INLINE void ma_dr_flac__reset_crc16(ma_dr_flac_bs* bs)
+{
+    bs->crc16 = 0;
+    bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3;
+}
+static MA_INLINE void ma_dr_flac__update_crc16(ma_dr_flac_bs* bs)
+{
+    if (bs->crc16CacheIgnoredBytes == 0) {
+        bs->crc16 = ma_dr_flac_crc16_cache(bs->crc16, bs->crc16Cache);
+    } else {
+        bs->crc16 = ma_dr_flac_crc16_bytes(bs->crc16, bs->crc16Cache, MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs) - bs->crc16CacheIgnoredBytes);
+        bs->crc16CacheIgnoredBytes = 0;
+    }
+}
+static MA_INLINE ma_uint16 ma_dr_flac__flush_crc16(ma_dr_flac_bs* bs)
+{
+    MA_DR_FLAC_ASSERT((MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) & 7) == 0);
+    if (MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) == 0) {
+        ma_dr_flac__update_crc16(bs);
+    } else {
+        bs->crc16 = ma_dr_flac_crc16_bytes(bs->crc16, bs->crc16Cache >> MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs), (bs->consumedBits >> 3) - bs->crc16CacheIgnoredBytes);
+        bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3;
+    }
+    return bs->crc16;
+}
+#endif
+static MA_INLINE ma_bool32 ma_dr_flac__reload_l1_cache_from_l2(ma_dr_flac_bs* bs)
+{
+    size_t bytesRead;
+    size_t alignedL1LineCount;
+    if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+        bs->cache = bs->cacheL2[bs->nextL2Line++];
+        return MA_TRUE;
+    }
+    if (bs->unalignedByteCount > 0) {
+        return MA_FALSE;
+    }
+    bytesRead = bs->onRead(bs->pUserData, bs->cacheL2, MA_DR_FLAC_CACHE_L2_SIZE_BYTES(bs));
+    bs->nextL2Line = 0;
+    if (bytesRead == MA_DR_FLAC_CACHE_L2_SIZE_BYTES(bs)) {
+        bs->cache = bs->cacheL2[bs->nextL2Line++];
+        return MA_TRUE;
+    }
+    alignedL1LineCount = bytesRead / MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs);
+    bs->unalignedByteCount = bytesRead - (alignedL1LineCount * MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs));
+    if (bs->unalignedByteCount > 0) {
+        bs->unalignedCache = bs->cacheL2[alignedL1LineCount];
+    }
+    if (alignedL1LineCount > 0) {
+        size_t offset = MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs) - alignedL1LineCount;
+        size_t i;
+        for (i = alignedL1LineCount; i > 0; --i) {
+            bs->cacheL2[i-1 + offset] = bs->cacheL2[i-1];
+        }
+        bs->nextL2Line = (ma_uint32)offset;
+        bs->cache = bs->cacheL2[bs->nextL2Line++];
+        return MA_TRUE;
+    } else {
+        bs->nextL2Line = MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs);
+        return MA_FALSE;
+    }
+}
+static ma_bool32 ma_dr_flac__reload_cache(ma_dr_flac_bs* bs)
+{
+    size_t bytesRead;
+#ifndef MA_DR_FLAC_NO_CRC
+    ma_dr_flac__update_crc16(bs);
+#endif
+    if (ma_dr_flac__reload_l1_cache_from_l2(bs)) {
+        bs->cache = ma_dr_flac__be2host__cache_line(bs->cache);
+        bs->consumedBits = 0;
+#ifndef MA_DR_FLAC_NO_CRC
+        bs->crc16Cache = bs->cache;
+#endif
+        return MA_TRUE;
+    }
+    bytesRead = bs->unalignedByteCount;
+    if (bytesRead == 0) {
+        bs->consumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+        return MA_FALSE;
+    }
+    MA_DR_FLAC_ASSERT(bytesRead < MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs));
+    bs->consumedBits = (ma_uint32)(MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs) - bytesRead) * 8;
+    bs->cache = ma_dr_flac__be2host__cache_line(bs->unalignedCache);
+    bs->cache &= MA_DR_FLAC_CACHE_L1_SELECTION_MASK(MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs));
+    bs->unalignedByteCount = 0;
+#ifndef MA_DR_FLAC_NO_CRC
+    bs->crc16Cache = bs->cache >> bs->consumedBits;
+    bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3;
+#endif
+    return MA_TRUE;
+}
+static void ma_dr_flac__reset_cache(ma_dr_flac_bs* bs)
+{
+    bs->nextL2Line   = MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs);
+    bs->consumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+    bs->cache = 0;
+    bs->unalignedByteCount = 0;
+    bs->unalignedCache = 0;
+#ifndef MA_DR_FLAC_NO_CRC
+    bs->crc16Cache = 0;
+    bs->crc16CacheIgnoredBytes = 0;
+#endif
+}
+static MA_INLINE ma_bool32 ma_dr_flac__read_uint32(ma_dr_flac_bs* bs, unsigned int bitCount, ma_uint32* pResultOut)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResultOut != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 32);
+    if (bs->consumedBits == MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)) {
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+    }
+    if (bitCount <= MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+#ifdef MA_64BIT
+        *pResultOut = (ma_uint32)MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCount);
+        bs->consumedBits += bitCount;
+        bs->cache <<= bitCount;
+#else
+        if (bitCount < MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)) {
+            *pResultOut = (ma_uint32)MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCount);
+            bs->consumedBits += bitCount;
+            bs->cache <<= bitCount;
+        } else {
+            *pResultOut = (ma_uint32)bs->cache;
+            bs->consumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+            bs->cache = 0;
+        }
+#endif
+        return MA_TRUE;
+    } else {
+        ma_uint32 bitCountHi = MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        ma_uint32 bitCountLo = bitCount - bitCountHi;
+        ma_uint32 resultHi;
+        MA_DR_FLAC_ASSERT(bitCountHi > 0);
+        MA_DR_FLAC_ASSERT(bitCountHi < 32);
+        resultHi = (ma_uint32)MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCountHi);
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+        if (bitCountLo > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+            return MA_FALSE;
+        }
+        *pResultOut = (resultHi << bitCountLo) | (ma_uint32)MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCountLo);
+        bs->consumedBits += bitCountLo;
+        bs->cache <<= bitCountLo;
+        return MA_TRUE;
+    }
+}
+static ma_bool32 ma_dr_flac__read_int32(ma_dr_flac_bs* bs, unsigned int bitCount, ma_int32* pResult)
+{
+    ma_uint32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 32);
+    if (!ma_dr_flac__read_uint32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    if (bitCount < 32) {
+        ma_uint32 signbit;
+        signbit = ((result >> (bitCount-1)) & 0x01);
+        result |= (~signbit + 1) << bitCount;
+    }
+    *pResult = (ma_int32)result;
+    return MA_TRUE;
+}
+#ifdef MA_64BIT
+static ma_bool32 ma_dr_flac__read_uint64(ma_dr_flac_bs* bs, unsigned int bitCount, ma_uint64* pResultOut)
+{
+    ma_uint32 resultHi;
+    ma_uint32 resultLo;
+    MA_DR_FLAC_ASSERT(bitCount <= 64);
+    MA_DR_FLAC_ASSERT(bitCount >  32);
+    if (!ma_dr_flac__read_uint32(bs, bitCount - 32, &resultHi)) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_flac__read_uint32(bs, 32, &resultLo)) {
+        return MA_FALSE;
+    }
+    *pResultOut = (((ma_uint64)resultHi) << 32) | ((ma_uint64)resultLo);
+    return MA_TRUE;
+}
+#endif
+#if 0
+static ma_bool32 ma_dr_flac__read_int64(ma_dr_flac_bs* bs, unsigned int bitCount, ma_int64* pResultOut)
+{
+    ma_uint64 result;
+    ma_uint64 signbit;
+    MA_DR_FLAC_ASSERT(bitCount <= 64);
+    if (!ma_dr_flac__read_uint64(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    signbit = ((result >> (bitCount-1)) & 0x01);
+    result |= (~signbit + 1) << bitCount;
+    *pResultOut = (ma_int64)result;
+    return MA_TRUE;
+}
+#endif
+static ma_bool32 ma_dr_flac__read_uint16(ma_dr_flac_bs* bs, unsigned int bitCount, ma_uint16* pResult)
+{
+    ma_uint32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 16);
+    if (!ma_dr_flac__read_uint32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    *pResult = (ma_uint16)result;
+    return MA_TRUE;
+}
+#if 0
+static ma_bool32 ma_dr_flac__read_int16(ma_dr_flac_bs* bs, unsigned int bitCount, ma_int16* pResult)
+{
+    ma_int32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 16);
+    if (!ma_dr_flac__read_int32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    *pResult = (ma_int16)result;
+    return MA_TRUE;
+}
+#endif
+static ma_bool32 ma_dr_flac__read_uint8(ma_dr_flac_bs* bs, unsigned int bitCount, ma_uint8* pResult)
+{
+    ma_uint32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 8);
+    if (!ma_dr_flac__read_uint32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    *pResult = (ma_uint8)result;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__read_int8(ma_dr_flac_bs* bs, unsigned int bitCount, ma_int8* pResult)
+{
+    ma_int32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 8);
+    if (!ma_dr_flac__read_int32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    *pResult = (ma_int8)result;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__seek_bits(ma_dr_flac_bs* bs, size_t bitsToSeek)
+{
+    if (bitsToSeek <= MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+        bs->consumedBits += (ma_uint32)bitsToSeek;
+        bs->cache <<= bitsToSeek;
+        return MA_TRUE;
+    } else {
+        bitsToSeek       -= MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        bs->consumedBits += MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        bs->cache         = 0;
+#ifdef MA_64BIT
+        while (bitsToSeek >= MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)) {
+            ma_uint64 bin;
+            if (!ma_dr_flac__read_uint64(bs, MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
+                return MA_FALSE;
+            }
+            bitsToSeek -= MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+        }
+#else
+        while (bitsToSeek >= MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)) {
+            ma_uint32 bin;
+            if (!ma_dr_flac__read_uint32(bs, MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
+                return MA_FALSE;
+            }
+            bitsToSeek -= MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+        }
+#endif
+        while (bitsToSeek >= 8) {
+            ma_uint8 bin;
+            if (!ma_dr_flac__read_uint8(bs, 8, &bin)) {
+                return MA_FALSE;
+            }
+            bitsToSeek -= 8;
+        }
+        if (bitsToSeek > 0) {
+            ma_uint8 bin;
+            if (!ma_dr_flac__read_uint8(bs, (ma_uint32)bitsToSeek, &bin)) {
+                return MA_FALSE;
+            }
+            bitsToSeek = 0;
+        }
+        MA_DR_FLAC_ASSERT(bitsToSeek == 0);
+        return MA_TRUE;
+    }
+}
+static ma_bool32 ma_dr_flac__find_and_seek_to_next_sync_code(ma_dr_flac_bs* bs)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    if (!ma_dr_flac__seek_bits(bs, MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) {
+        return MA_FALSE;
+    }
+    for (;;) {
+        ma_uint8 hi;
+#ifndef MA_DR_FLAC_NO_CRC
+        ma_dr_flac__reset_crc16(bs);
+#endif
+        if (!ma_dr_flac__read_uint8(bs, 8, &hi)) {
+            return MA_FALSE;
+        }
+        if (hi == 0xFF) {
+            ma_uint8 lo;
+            if (!ma_dr_flac__read_uint8(bs, 6, &lo)) {
+                return MA_FALSE;
+            }
+            if (lo == 0x3E) {
+                return MA_TRUE;
+            } else {
+                if (!ma_dr_flac__seek_bits(bs, MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) {
+                    return MA_FALSE;
+                }
+            }
+        }
+    }
+}
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC)
+#define MA_DR_FLAC_IMPLEMENT_CLZ_LZCNT
+#endif
+#if  defined(_MSC_VER) && _MSC_VER >= 1400 && (defined(MA_X64) || defined(MA_X86)) && !defined(__clang__)
+#define MA_DR_FLAC_IMPLEMENT_CLZ_MSVC
+#endif
+#if  defined(__WATCOMC__) && defined(__386__)
+#define MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM
+#endif
+#ifdef __MRC__
+#include <intrinsics.h>
+#define MA_DR_FLAC_IMPLEMENT_CLZ_MRC
+#endif
+static MA_INLINE ma_uint32 ma_dr_flac__clz_software(ma_dr_flac_cache_t x)
+{
+    ma_uint32 n;
+    static ma_uint32 clz_table_4[] = {
+        0,
+        4,
+        3, 3,
+        2, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 1, 1
+    };
+    if (x == 0) {
+        return sizeof(x)*8;
+    }
+    n = clz_table_4[x >> (sizeof(x)*8 - 4)];
+    if (n == 0) {
+#ifdef MA_64BIT
+        if ((x & ((ma_uint64)0xFFFFFFFF << 32)) == 0) { n  = 32; x <<= 32; }
+        if ((x & ((ma_uint64)0xFFFF0000 << 32)) == 0) { n += 16; x <<= 16; }
+        if ((x & ((ma_uint64)0xFF000000 << 32)) == 0) { n += 8;  x <<= 8;  }
+        if ((x & ((ma_uint64)0xF0000000 << 32)) == 0) { n += 4;  x <<= 4;  }
+#else
+        if ((x & 0xFFFF0000) == 0) { n  = 16; x <<= 16; }
+        if ((x & 0xFF000000) == 0) { n += 8;  x <<= 8;  }
+        if ((x & 0xF0000000) == 0) { n += 4;  x <<= 4;  }
+#endif
+        n += clz_table_4[x >> (sizeof(x)*8 - 4)];
+    }
+    return n - 1;
+}
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_LZCNT
+static MA_INLINE ma_bool32 ma_dr_flac__is_lzcnt_supported(void)
+{
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC) && defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5)
+    return MA_TRUE;
+#elif defined(__MRC__)
+    return MA_TRUE;
+#else
+    #ifdef MA_DR_FLAC_HAS_LZCNT_INTRINSIC
+        return ma_dr_flac__gIsLZCNTSupported;
+    #else
+        return MA_FALSE;
+    #endif
+#endif
+}
+static MA_INLINE ma_uint32 ma_dr_flac__clz_lzcnt(ma_dr_flac_cache_t x)
+{
+#if defined(_MSC_VER)
+    #ifdef MA_64BIT
+        return (ma_uint32)__lzcnt64(x);
+    #else
+        return (ma_uint32)__lzcnt(x);
+    #endif
+#else
+    #if defined(__GNUC__) || defined(__clang__)
+        #if defined(MA_X64)
+            {
+                ma_uint64 r;
+                __asm__ __volatile__ (
+                    "lzcnt{ %1, %0| %0, %1}" : "=r"(r) : "r"(x) : "cc"
+                );
+                return (ma_uint32)r;
+            }
+        #elif defined(MA_X86)
+            {
+                ma_uint32 r;
+                __asm__ __volatile__ (
+                    "lzcnt{l %1, %0| %0, %1}" : "=r"(r) : "r"(x) : "cc"
+                );
+                return r;
+            }
+        #elif defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5) && !defined(__ARM_ARCH_6M__) && !defined(MA_64BIT)
+            {
+                unsigned int r;
+                __asm__ __volatile__ (
+                #if defined(MA_64BIT)
+                    "clz %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(x)
+                #else
+                    "clz %[out], %[in]" : [out]"=r"(r) : [in]"r"(x)
+                #endif
+                );
+                return r;
+            }
+        #else
+            if (x == 0) {
+                return sizeof(x)*8;
+            }
+            #ifdef MA_64BIT
+                return (ma_uint32)__builtin_clzll((ma_uint64)x);
+            #else
+                return (ma_uint32)__builtin_clzl((ma_uint32)x);
+            #endif
+        #endif
+    #else
+        #error "This compiler does not support the lzcnt intrinsic."
+    #endif
+#endif
+}
+#endif
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_MSVC
+#include <intrin.h>
+static MA_INLINE ma_uint32 ma_dr_flac__clz_msvc(ma_dr_flac_cache_t x)
+{
+    ma_uint32 n;
+    if (x == 0) {
+        return sizeof(x)*8;
+    }
+#ifdef MA_64BIT
+    _BitScanReverse64((unsigned long*)&n, x);
+#else
+    _BitScanReverse((unsigned long*)&n, x);
+#endif
+    return sizeof(x)*8 - n - 1;
+}
+#endif
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM
+static __inline ma_uint32 ma_dr_flac__clz_watcom (ma_uint32);
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM_LZCNT
+#pragma aux ma_dr_flac__clz_watcom_lzcnt = \
+    "db 0F3h, 0Fh, 0BDh, 0C0h"  \
+    parm [eax] \
+    value [eax] \
+    modify nomemory;
+#else
+#pragma aux ma_dr_flac__clz_watcom = \
+    "bsr eax, eax" \
+    "xor eax, 31" \
+    parm [eax] nomemory \
+    value [eax] \
+    modify exact [eax] nomemory;
+#endif
+#endif
+static MA_INLINE ma_uint32 ma_dr_flac__clz(ma_dr_flac_cache_t x)
+{
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_LZCNT
+    if (ma_dr_flac__is_lzcnt_supported()) {
+        return ma_dr_flac__clz_lzcnt(x);
+    } else
+#endif
+    {
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_MSVC
+        return ma_dr_flac__clz_msvc(x);
+#elif defined(MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM_LZCNT)
+        return ma_dr_flac__clz_watcom_lzcnt(x);
+#elif defined(MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM)
+        return (x == 0) ? sizeof(x)*8 : ma_dr_flac__clz_watcom(x);
+#elif defined(__MRC__)
+        return __cntlzw(x);
+#else
+        return ma_dr_flac__clz_software(x);
+#endif
+    }
+}
+static MA_INLINE ma_bool32 ma_dr_flac__seek_past_next_set_bit(ma_dr_flac_bs* bs, unsigned int* pOffsetOut)
+{
+    ma_uint32 zeroCounter = 0;
+    ma_uint32 setBitOffsetPlus1;
+    while (bs->cache == 0) {
+        zeroCounter += (ma_uint32)MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+    }
+    if (bs->cache == 1) {
+        *pOffsetOut = zeroCounter + (ma_uint32)MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) - 1;
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+        return MA_TRUE;
+    }
+    setBitOffsetPlus1 = ma_dr_flac__clz(bs->cache);
+    setBitOffsetPlus1 += 1;
+    if (setBitOffsetPlus1 > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+        return MA_FALSE;
+    }
+    bs->consumedBits += setBitOffsetPlus1;
+    bs->cache <<= setBitOffsetPlus1;
+    *pOffsetOut = zeroCounter + setBitOffsetPlus1 - 1;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__seek_to_byte(ma_dr_flac_bs* bs, ma_uint64 offsetFromStart)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(offsetFromStart > 0);
+    if (offsetFromStart > 0x7FFFFFFF) {
+        ma_uint64 bytesRemaining = offsetFromStart;
+        if (!bs->onSeek(bs->pUserData, 0x7FFFFFFF, MA_DR_FLAC_SEEK_SET)) {
+            return MA_FALSE;
+        }
+        bytesRemaining -= 0x7FFFFFFF;
+        while (bytesRemaining > 0x7FFFFFFF) {
+            if (!bs->onSeek(bs->pUserData, 0x7FFFFFFF, MA_DR_FLAC_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+            bytesRemaining -= 0x7FFFFFFF;
+        }
+        if (bytesRemaining > 0) {
+            if (!bs->onSeek(bs->pUserData, (int)bytesRemaining, MA_DR_FLAC_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+        }
+    } else {
+        if (!bs->onSeek(bs->pUserData, (int)offsetFromStart, MA_DR_FLAC_SEEK_SET)) {
+            return MA_FALSE;
+        }
+    }
+    ma_dr_flac__reset_cache(bs);
+    return MA_TRUE;
+}
+static ma_result ma_dr_flac__read_utf8_coded_number(ma_dr_flac_bs* bs, ma_uint64* pNumberOut, ma_uint8* pCRCOut)
+{
+    ma_uint8 crc;
+    ma_uint64 result;
+    ma_uint8 utf8[7] = {0};
+    int byteCount;
+    int i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pNumberOut != NULL);
+    MA_DR_FLAC_ASSERT(pCRCOut != NULL);
+    crc = *pCRCOut;
+    if (!ma_dr_flac__read_uint8(bs, 8, utf8)) {
+        *pNumberOut = 0;
+        return MA_AT_END;
+    }
+    crc = ma_dr_flac_crc8(crc, utf8[0], 8);
+    if ((utf8[0] & 0x80) == 0) {
+        *pNumberOut = utf8[0];
+        *pCRCOut = crc;
+        return MA_SUCCESS;
+    }
+    if ((utf8[0] & 0xE0) == 0xC0) {
+        byteCount = 2;
+    } else if ((utf8[0] & 0xF0) == 0xE0) {
+        byteCount = 3;
+    } else if ((utf8[0] & 0xF8) == 0xF0) {
+        byteCount = 4;
+    } else if ((utf8[0] & 0xFC) == 0xF8) {
+        byteCount = 5;
+    } else if ((utf8[0] & 0xFE) == 0xFC) {
+        byteCount = 6;
+    } else if ((utf8[0] & 0xFF) == 0xFE) {
+        byteCount = 7;
+    } else {
+        *pNumberOut = 0;
+        return MA_CRC_MISMATCH;
+    }
+    MA_DR_FLAC_ASSERT(byteCount > 1);
+    result = (ma_uint64)(utf8[0] & (0xFF >> (byteCount + 1)));
+    for (i = 1; i < byteCount; ++i) {
+        if (!ma_dr_flac__read_uint8(bs, 8, utf8 + i)) {
+            *pNumberOut = 0;
+            return MA_AT_END;
+        }
+        crc = ma_dr_flac_crc8(crc, utf8[i], 8);
+        result = (result << 6) | (utf8[i] & 0x3F);
+    }
+    *pNumberOut = result;
+    *pCRCOut = crc;
+    return MA_SUCCESS;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__ilog2_u32(ma_uint32 x)
+{
+#if 1
+    ma_uint32 result = 0;
+    while (x > 0) {
+        result += 1;
+        x >>= 1;
+    }
+    return result;
+#endif
+}
+static MA_INLINE ma_bool32 ma_dr_flac__use_64_bit_prediction(ma_uint32 bitsPerSample, ma_uint32 order, ma_uint32 precision)
+{
+    return bitsPerSample + precision + ma_dr_flac__ilog2_u32(order) > 32;
+}
+#if defined(__clang__)
+__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
+static MA_INLINE ma_int32 ma_dr_flac__calculate_prediction_32(ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pDecodedSamples)
+{
+    ma_int32 prediction = 0;
+    MA_DR_FLAC_ASSERT(order <= 32);
+    switch (order)
+    {
+    case 32: prediction += coefficients[31] * pDecodedSamples[-32];
+    case 31: prediction += coefficients[30] * pDecodedSamples[-31];
+    case 30: prediction += coefficients[29] * pDecodedSamples[-30];
+    case 29: prediction += coefficients[28] * pDecodedSamples[-29];
+    case 28: prediction += coefficients[27] * pDecodedSamples[-28];
+    case 27: prediction += coefficients[26] * pDecodedSamples[-27];
+    case 26: prediction += coefficients[25] * pDecodedSamples[-26];
+    case 25: prediction += coefficients[24] * pDecodedSamples[-25];
+    case 24: prediction += coefficients[23] * pDecodedSamples[-24];
+    case 23: prediction += coefficients[22] * pDecodedSamples[-23];
+    case 22: prediction += coefficients[21] * pDecodedSamples[-22];
+    case 21: prediction += coefficients[20] * pDecodedSamples[-21];
+    case 20: prediction += coefficients[19] * pDecodedSamples[-20];
+    case 19: prediction += coefficients[18] * pDecodedSamples[-19];
+    case 18: prediction += coefficients[17] * pDecodedSamples[-18];
+    case 17: prediction += coefficients[16] * pDecodedSamples[-17];
+    case 16: prediction += coefficients[15] * pDecodedSamples[-16];
+    case 15: prediction += coefficients[14] * pDecodedSamples[-15];
+    case 14: prediction += coefficients[13] * pDecodedSamples[-14];
+    case 13: prediction += coefficients[12] * pDecodedSamples[-13];
+    case 12: prediction += coefficients[11] * pDecodedSamples[-12];
+    case 11: prediction += coefficients[10] * pDecodedSamples[-11];
+    case 10: prediction += coefficients[ 9] * pDecodedSamples[-10];
+    case  9: prediction += coefficients[ 8] * pDecodedSamples[- 9];
+    case  8: prediction += coefficients[ 7] * pDecodedSamples[- 8];
+    case  7: prediction += coefficients[ 6] * pDecodedSamples[- 7];
+    case  6: prediction += coefficients[ 5] * pDecodedSamples[- 6];
+    case  5: prediction += coefficients[ 4] * pDecodedSamples[- 5];
+    case  4: prediction += coefficients[ 3] * pDecodedSamples[- 4];
+    case  3: prediction += coefficients[ 2] * pDecodedSamples[- 3];
+    case  2: prediction += coefficients[ 1] * pDecodedSamples[- 2];
+    case  1: prediction += coefficients[ 0] * pDecodedSamples[- 1];
+    }
+    return (ma_int32)(prediction >> shift);
+}
+static MA_INLINE ma_int32 ma_dr_flac__calculate_prediction_64(ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pDecodedSamples)
+{
+    ma_int64 prediction;
+    MA_DR_FLAC_ASSERT(order <= 32);
+#ifndef MA_64BIT
+    if (order == 8)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4] * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5] * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6] * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7] * (ma_int64)pDecodedSamples[-8];
+    }
+    else if (order == 7)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4] * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5] * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6] * (ma_int64)pDecodedSamples[-7];
+    }
+    else if (order == 3)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+    }
+    else if (order == 6)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4] * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5] * (ma_int64)pDecodedSamples[-6];
+    }
+    else if (order == 5)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4] * (ma_int64)pDecodedSamples[-5];
+    }
+    else if (order == 4)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+    }
+    else if (order == 12)
+    {
+        prediction  = coefficients[0]  * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1]  * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2]  * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3]  * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4]  * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5]  * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6]  * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7]  * (ma_int64)pDecodedSamples[-8];
+        prediction += coefficients[8]  * (ma_int64)pDecodedSamples[-9];
+        prediction += coefficients[9]  * (ma_int64)pDecodedSamples[-10];
+        prediction += coefficients[10] * (ma_int64)pDecodedSamples[-11];
+        prediction += coefficients[11] * (ma_int64)pDecodedSamples[-12];
+    }
+    else if (order == 2)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+    }
+    else if (order == 1)
+    {
+        prediction = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+    }
+    else if (order == 10)
+    {
+        prediction  = coefficients[0]  * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1]  * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2]  * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3]  * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4]  * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5]  * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6]  * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7]  * (ma_int64)pDecodedSamples[-8];
+        prediction += coefficients[8]  * (ma_int64)pDecodedSamples[-9];
+        prediction += coefficients[9]  * (ma_int64)pDecodedSamples[-10];
+    }
+    else if (order == 9)
+    {
+        prediction  = coefficients[0]  * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1]  * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2]  * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3]  * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4]  * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5]  * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6]  * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7]  * (ma_int64)pDecodedSamples[-8];
+        prediction += coefficients[8]  * (ma_int64)pDecodedSamples[-9];
+    }
+    else if (order == 11)
+    {
+        prediction  = coefficients[0]  * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1]  * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2]  * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3]  * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4]  * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5]  * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6]  * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7]  * (ma_int64)pDecodedSamples[-8];
+        prediction += coefficients[8]  * (ma_int64)pDecodedSamples[-9];
+        prediction += coefficients[9]  * (ma_int64)pDecodedSamples[-10];
+        prediction += coefficients[10] * (ma_int64)pDecodedSamples[-11];
+    }
+    else
+    {
+        int j;
+        prediction = 0;
+        for (j = 0; j < (int)order; ++j) {
+            prediction += coefficients[j] * (ma_int64)pDecodedSamples[-j-1];
+        }
+    }
+#endif
+#ifdef MA_64BIT
+    prediction = 0;
+    switch (order)
+    {
+    case 32: prediction += coefficients[31] * (ma_int64)pDecodedSamples[-32];
+    case 31: prediction += coefficients[30] * (ma_int64)pDecodedSamples[-31];
+    case 30: prediction += coefficients[29] * (ma_int64)pDecodedSamples[-30];
+    case 29: prediction += coefficients[28] * (ma_int64)pDecodedSamples[-29];
+    case 28: prediction += coefficients[27] * (ma_int64)pDecodedSamples[-28];
+    case 27: prediction += coefficients[26] * (ma_int64)pDecodedSamples[-27];
+    case 26: prediction += coefficients[25] * (ma_int64)pDecodedSamples[-26];
+    case 25: prediction += coefficients[24] * (ma_int64)pDecodedSamples[-25];
+    case 24: prediction += coefficients[23] * (ma_int64)pDecodedSamples[-24];
+    case 23: prediction += coefficients[22] * (ma_int64)pDecodedSamples[-23];
+    case 22: prediction += coefficients[21] * (ma_int64)pDecodedSamples[-22];
+    case 21: prediction += coefficients[20] * (ma_int64)pDecodedSamples[-21];
+    case 20: prediction += coefficients[19] * (ma_int64)pDecodedSamples[-20];
+    case 19: prediction += coefficients[18] * (ma_int64)pDecodedSamples[-19];
+    case 18: prediction += coefficients[17] * (ma_int64)pDecodedSamples[-18];
+    case 17: prediction += coefficients[16] * (ma_int64)pDecodedSamples[-17];
+    case 16: prediction += coefficients[15] * (ma_int64)pDecodedSamples[-16];
+    case 15: prediction += coefficients[14] * (ma_int64)pDecodedSamples[-15];
+    case 14: prediction += coefficients[13] * (ma_int64)pDecodedSamples[-14];
+    case 13: prediction += coefficients[12] * (ma_int64)pDecodedSamples[-13];
+    case 12: prediction += coefficients[11] * (ma_int64)pDecodedSamples[-12];
+    case 11: prediction += coefficients[10] * (ma_int64)pDecodedSamples[-11];
+    case 10: prediction += coefficients[ 9] * (ma_int64)pDecodedSamples[-10];
+    case  9: prediction += coefficients[ 8] * (ma_int64)pDecodedSamples[- 9];
+    case  8: prediction += coefficients[ 7] * (ma_int64)pDecodedSamples[- 8];
+    case  7: prediction += coefficients[ 6] * (ma_int64)pDecodedSamples[- 7];
+    case  6: prediction += coefficients[ 5] * (ma_int64)pDecodedSamples[- 6];
+    case  5: prediction += coefficients[ 4] * (ma_int64)pDecodedSamples[- 5];
+    case  4: prediction += coefficients[ 3] * (ma_int64)pDecodedSamples[- 4];
+    case  3: prediction += coefficients[ 2] * (ma_int64)pDecodedSamples[- 3];
+    case  2: prediction += coefficients[ 1] * (ma_int64)pDecodedSamples[- 2];
+    case  1: prediction += coefficients[ 0] * (ma_int64)pDecodedSamples[- 1];
+    }
+#endif
+    return (ma_int32)(prediction >> shift);
+}
+#if 0
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__reference(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    for (i = 0; i < count; ++i) {
+        ma_uint32 zeroCounter = 0;
+        for (;;) {
+            ma_uint8 bit;
+            if (!ma_dr_flac__read_uint8(bs, 1, &bit)) {
+                return MA_FALSE;
+            }
+            if (bit == 0) {
+                zeroCounter += 1;
+            } else {
+                break;
+            }
+        }
+        ma_uint32 decodedRice;
+        if (riceParam > 0) {
+            if (!ma_dr_flac__read_uint32(bs, riceParam, &decodedRice)) {
+                return MA_FALSE;
+            }
+        } else {
+            decodedRice = 0;
+        }
+        decodedRice |= (zeroCounter << riceParam);
+        if ((decodedRice & 0x01)) {
+            decodedRice = ~(decodedRice >> 1);
+        } else {
+            decodedRice =  (decodedRice >> 1);
+        }
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            pSamplesOut[i] = decodedRice + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+        } else {
+            pSamplesOut[i] = decodedRice + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+        }
+    }
+    return MA_TRUE;
+}
+#endif
+#if 0
+static ma_bool32 ma_dr_flac__read_rice_parts__reference(ma_dr_flac_bs* bs, ma_uint8 riceParam, ma_uint32* pZeroCounterOut, ma_uint32* pRiceParamPartOut)
+{
+    ma_uint32 zeroCounter = 0;
+    ma_uint32 decodedRice;
+    for (;;) {
+        ma_uint8 bit;
+        if (!ma_dr_flac__read_uint8(bs, 1, &bit)) {
+            return MA_FALSE;
+        }
+        if (bit == 0) {
+            zeroCounter += 1;
+        } else {
+            break;
+        }
+    }
+    if (riceParam > 0) {
+        if (!ma_dr_flac__read_uint32(bs, riceParam, &decodedRice)) {
+            return MA_FALSE;
+        }
+    } else {
+        decodedRice = 0;
+    }
+    *pZeroCounterOut = zeroCounter;
+    *pRiceParamPartOut = decodedRice;
+    return MA_TRUE;
+}
+#endif
+#if 0
+static MA_INLINE ma_bool32 ma_dr_flac__read_rice_parts(ma_dr_flac_bs* bs, ma_uint8 riceParam, ma_uint32* pZeroCounterOut, ma_uint32* pRiceParamPartOut)
+{
+    ma_dr_flac_cache_t riceParamMask;
+    ma_uint32 zeroCounter;
+    ma_uint32 setBitOffsetPlus1;
+    ma_uint32 riceParamPart;
+    ma_uint32 riceLength;
+    MA_DR_FLAC_ASSERT(riceParam > 0);
+    riceParamMask = MA_DR_FLAC_CACHE_L1_SELECTION_MASK(riceParam);
+    zeroCounter = 0;
+    while (bs->cache == 0) {
+        zeroCounter += (ma_uint32)MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+    }
+    setBitOffsetPlus1 = ma_dr_flac__clz(bs->cache);
+    zeroCounter += setBitOffsetPlus1;
+    setBitOffsetPlus1 += 1;
+    riceLength = setBitOffsetPlus1 + riceParam;
+    if (riceLength < MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+        riceParamPart = (ma_uint32)((bs->cache & (riceParamMask >> setBitOffsetPlus1)) >> MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT(bs, riceLength));
+        bs->consumedBits += riceLength;
+        bs->cache <<= riceLength;
+    } else {
+        ma_uint32 bitCountLo;
+        ma_dr_flac_cache_t resultHi;
+        bs->consumedBits += riceLength;
+        bs->cache <<= setBitOffsetPlus1 & (MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)-1);
+        bitCountLo = bs->consumedBits - MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+        resultHi = MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, riceParam);
+        if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+#ifndef MA_DR_FLAC_NO_CRC
+            ma_dr_flac__update_crc16(bs);
+#endif
+            bs->cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+            bs->consumedBits = 0;
+#ifndef MA_DR_FLAC_NO_CRC
+            bs->crc16Cache = bs->cache;
+#endif
+        } else {
+            if (!ma_dr_flac__reload_cache(bs)) {
+                return MA_FALSE;
+            }
+            if (bitCountLo > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+                return MA_FALSE;
+            }
+        }
+        riceParamPart = (ma_uint32)(resultHi | MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE(bs, bitCountLo));
+        bs->consumedBits += bitCountLo;
+        bs->cache <<= bitCountLo;
+    }
+    pZeroCounterOut[0] = zeroCounter;
+    pRiceParamPartOut[0] = riceParamPart;
+    return MA_TRUE;
+}
+#endif
+static MA_INLINE ma_bool32 ma_dr_flac__read_rice_parts_x1(ma_dr_flac_bs* bs, ma_uint8 riceParam, ma_uint32* pZeroCounterOut, ma_uint32* pRiceParamPartOut)
+{
+    ma_uint32  riceParamPlus1 = riceParam + 1;
+    ma_uint32  riceParamPlus1Shift = MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT(bs, riceParamPlus1);
+    ma_uint32  riceParamPlus1MaxConsumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - riceParamPlus1;
+    ma_dr_flac_cache_t bs_cache = bs->cache;
+    ma_uint32  bs_consumedBits = bs->consumedBits;
+    ma_uint32  lzcount = ma_dr_flac__clz(bs_cache);
+    if (lzcount < sizeof(bs_cache)*8) {
+        pZeroCounterOut[0] = lzcount;
+    extract_rice_param_part:
+        bs_cache       <<= lzcount;
+        bs_consumedBits += lzcount;
+        if (bs_consumedBits <= riceParamPlus1MaxConsumedBits) {
+            pRiceParamPartOut[0] = (ma_uint32)(bs_cache >> riceParamPlus1Shift);
+            bs_cache       <<= riceParamPlus1;
+            bs_consumedBits += riceParamPlus1;
+        } else {
+            ma_uint32 riceParamPartHi;
+            ma_uint32 riceParamPartLo;
+            ma_uint32 riceParamPartLoBitCount;
+            riceParamPartHi = (ma_uint32)(bs_cache >> riceParamPlus1Shift);
+            riceParamPartLoBitCount = bs_consumedBits - riceParamPlus1MaxConsumedBits;
+            MA_DR_FLAC_ASSERT(riceParamPartLoBitCount > 0 && riceParamPartLoBitCount < 32);
+            if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+            #ifndef MA_DR_FLAC_NO_CRC
+                ma_dr_flac__update_crc16(bs);
+            #endif
+                bs_cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+                bs_consumedBits = riceParamPartLoBitCount;
+            #ifndef MA_DR_FLAC_NO_CRC
+                bs->crc16Cache = bs_cache;
+            #endif
+            } else {
+                if (!ma_dr_flac__reload_cache(bs)) {
+                    return MA_FALSE;
+                }
+                if (riceParamPartLoBitCount > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+                    return MA_FALSE;
+                }
+                bs_cache = bs->cache;
+                bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount;
+            }
+            riceParamPartLo = (ma_uint32)(bs_cache >> (MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT(bs, riceParamPartLoBitCount)));
+            pRiceParamPartOut[0] = riceParamPartHi | riceParamPartLo;
+            bs_cache <<= riceParamPartLoBitCount;
+        }
+    } else {
+        ma_uint32 zeroCounter = (ma_uint32)(MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - bs_consumedBits);
+        for (;;) {
+            if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+            #ifndef MA_DR_FLAC_NO_CRC
+                ma_dr_flac__update_crc16(bs);
+            #endif
+                bs_cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+                bs_consumedBits = 0;
+            #ifndef MA_DR_FLAC_NO_CRC
+                bs->crc16Cache = bs_cache;
+            #endif
+            } else {
+                if (!ma_dr_flac__reload_cache(bs)) {
+                    return MA_FALSE;
+                }
+                bs_cache = bs->cache;
+                bs_consumedBits = bs->consumedBits;
+            }
+            lzcount = ma_dr_flac__clz(bs_cache);
+            zeroCounter += lzcount;
+            if (lzcount < sizeof(bs_cache)*8) {
+                break;
+            }
+        }
+        pZeroCounterOut[0] = zeroCounter;
+        goto extract_rice_param_part;
+    }
+    bs->cache = bs_cache;
+    bs->consumedBits = bs_consumedBits;
+    return MA_TRUE;
+}
+static MA_INLINE ma_bool32 ma_dr_flac__seek_rice_parts(ma_dr_flac_bs* bs, ma_uint8 riceParam)
+{
+    ma_uint32  riceParamPlus1 = riceParam + 1;
+    ma_uint32  riceParamPlus1MaxConsumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - riceParamPlus1;
+    ma_dr_flac_cache_t bs_cache = bs->cache;
+    ma_uint32  bs_consumedBits = bs->consumedBits;
+    ma_uint32  lzcount = ma_dr_flac__clz(bs_cache);
+    if (lzcount < sizeof(bs_cache)*8) {
+    extract_rice_param_part:
+        bs_cache       <<= lzcount;
+        bs_consumedBits += lzcount;
+        if (bs_consumedBits <= riceParamPlus1MaxConsumedBits) {
+            bs_cache       <<= riceParamPlus1;
+            bs_consumedBits += riceParamPlus1;
+        } else {
+            ma_uint32 riceParamPartLoBitCount = bs_consumedBits - riceParamPlus1MaxConsumedBits;
+            MA_DR_FLAC_ASSERT(riceParamPartLoBitCount > 0 && riceParamPartLoBitCount < 32);
+            if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+            #ifndef MA_DR_FLAC_NO_CRC
+                ma_dr_flac__update_crc16(bs);
+            #endif
+                bs_cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+                bs_consumedBits = riceParamPartLoBitCount;
+            #ifndef MA_DR_FLAC_NO_CRC
+                bs->crc16Cache = bs_cache;
+            #endif
+            } else {
+                if (!ma_dr_flac__reload_cache(bs)) {
+                    return MA_FALSE;
+                }
+                if (riceParamPartLoBitCount > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+                    return MA_FALSE;
+                }
+                bs_cache = bs->cache;
+                bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount;
+            }
+            bs_cache <<= riceParamPartLoBitCount;
+        }
+    } else {
+        for (;;) {
+            if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+            #ifndef MA_DR_FLAC_NO_CRC
+                ma_dr_flac__update_crc16(bs);
+            #endif
+                bs_cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+                bs_consumedBits = 0;
+            #ifndef MA_DR_FLAC_NO_CRC
+                bs->crc16Cache = bs_cache;
+            #endif
+            } else {
+                if (!ma_dr_flac__reload_cache(bs)) {
+                    return MA_FALSE;
+                }
+                bs_cache = bs->cache;
+                bs_consumedBits = bs->consumedBits;
+            }
+            lzcount = ma_dr_flac__clz(bs_cache);
+            if (lzcount < sizeof(bs_cache)*8) {
+                break;
+            }
+        }
+        goto extract_rice_param_part;
+    }
+    bs->cache = bs_cache;
+    bs->consumedBits = bs_consumedBits;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__scalar_zeroorder(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    ma_uint32 zeroCountPart0;
+    ma_uint32 riceParamPart0;
+    ma_uint32 riceParamMask;
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    (void)bitsPerSample;
+    (void)order;
+    (void)shift;
+    (void)coefficients;
+    riceParamMask  = (ma_uint32)~((~0UL) << riceParam);
+    i = 0;
+    while (i < count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0)) {
+            return MA_FALSE;
+        }
+        riceParamPart0 &= riceParamMask;
+        riceParamPart0 |= (zeroCountPart0 << riceParam);
+        riceParamPart0  = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+        pSamplesOut[i] = riceParamPart0;
+        i += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__scalar(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    ma_uint32 zeroCountPart0 = 0;
+    ma_uint32 zeroCountPart1 = 0;
+    ma_uint32 zeroCountPart2 = 0;
+    ma_uint32 zeroCountPart3 = 0;
+    ma_uint32 riceParamPart0 = 0;
+    ma_uint32 riceParamPart1 = 0;
+    ma_uint32 riceParamPart2 = 0;
+    ma_uint32 riceParamPart3 = 0;
+    ma_uint32 riceParamMask;
+    const ma_int32* pSamplesOutEnd;
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    if (lpcOrder == 0) {
+        return ma_dr_flac__decode_samples_with_residual__rice__scalar_zeroorder(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+    }
+    riceParamMask  = (ma_uint32)~((~0UL) << riceParam);
+    pSamplesOutEnd = pSamplesOut + (count & ~3);
+    if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+        while (pSamplesOut < pSamplesOutEnd) {
+            if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart1, &riceParamPart1) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart2, &riceParamPart2) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart3, &riceParamPart3)) {
+                return MA_FALSE;
+            }
+            riceParamPart0 &= riceParamMask;
+            riceParamPart1 &= riceParamMask;
+            riceParamPart2 &= riceParamMask;
+            riceParamPart3 &= riceParamMask;
+            riceParamPart0 |= (zeroCountPart0 << riceParam);
+            riceParamPart1 |= (zeroCountPart1 << riceParam);
+            riceParamPart2 |= (zeroCountPart2 << riceParam);
+            riceParamPart3 |= (zeroCountPart3 << riceParam);
+            riceParamPart0  = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+            riceParamPart1  = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01];
+            riceParamPart2  = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01];
+            riceParamPart3  = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01];
+            pSamplesOut[0] = riceParamPart0 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+            pSamplesOut[1] = riceParamPart1 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 1);
+            pSamplesOut[2] = riceParamPart2 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 2);
+            pSamplesOut[3] = riceParamPart3 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 3);
+            pSamplesOut += 4;
+        }
+    } else {
+        while (pSamplesOut < pSamplesOutEnd) {
+            if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart1, &riceParamPart1) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart2, &riceParamPart2) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart3, &riceParamPart3)) {
+                return MA_FALSE;
+            }
+            riceParamPart0 &= riceParamMask;
+            riceParamPart1 &= riceParamMask;
+            riceParamPart2 &= riceParamMask;
+            riceParamPart3 &= riceParamMask;
+            riceParamPart0 |= (zeroCountPart0 << riceParam);
+            riceParamPart1 |= (zeroCountPart1 << riceParam);
+            riceParamPart2 |= (zeroCountPart2 << riceParam);
+            riceParamPart3 |= (zeroCountPart3 << riceParam);
+            riceParamPart0  = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+            riceParamPart1  = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01];
+            riceParamPart2  = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01];
+            riceParamPart3  = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01];
+            pSamplesOut[0] = riceParamPart0 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+            pSamplesOut[1] = riceParamPart1 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 1);
+            pSamplesOut[2] = riceParamPart2 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 2);
+            pSamplesOut[3] = riceParamPart3 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 3);
+            pSamplesOut += 4;
+        }
+    }
+    i = (count & ~3);
+    while (i < count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0)) {
+            return MA_FALSE;
+        }
+        riceParamPart0 &= riceParamMask;
+        riceParamPart0 |= (zeroCountPart0 << riceParam);
+        riceParamPart0  = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            pSamplesOut[0] = riceParamPart0 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+        } else {
+            pSamplesOut[0] = riceParamPart0 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+        }
+        i += 1;
+        pSamplesOut += 1;
+    }
+    return MA_TRUE;
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE __m128i ma_dr_flac__mm_packs_interleaved_epi32(__m128i a, __m128i b)
+{
+    __m128i r;
+    r = _mm_packs_epi32(a, b);
+    r = _mm_shuffle_epi32(r, _MM_SHUFFLE(3, 1, 2, 0));
+    r = _mm_shufflehi_epi16(r, _MM_SHUFFLE(3, 1, 2, 0));
+    r = _mm_shufflelo_epi16(r, _MM_SHUFFLE(3, 1, 2, 0));
+    return r;
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_SSE41)
+static MA_INLINE __m128i ma_dr_flac__mm_not_si128(__m128i a)
+{
+    return _mm_xor_si128(a, _mm_cmpeq_epi32(_mm_setzero_si128(), _mm_setzero_si128()));
+}
+static MA_INLINE __m128i ma_dr_flac__mm_hadd_epi32(__m128i x)
+{
+    __m128i x64 = _mm_add_epi32(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2)));
+    __m128i x32 = _mm_shufflelo_epi16(x64, _MM_SHUFFLE(1, 0, 3, 2));
+    return _mm_add_epi32(x64, x32);
+}
+static MA_INLINE __m128i ma_dr_flac__mm_hadd_epi64(__m128i x)
+{
+    return _mm_add_epi64(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2)));
+}
+static MA_INLINE __m128i ma_dr_flac__mm_srai_epi64(__m128i x, int count)
+{
+    __m128i lo = _mm_srli_epi64(x, count);
+    __m128i hi = _mm_srai_epi32(x, count);
+    hi = _mm_and_si128(hi, _mm_set_epi32(0xFFFFFFFF, 0, 0xFFFFFFFF, 0));
+    return _mm_or_si128(lo, hi);
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__sse41_32(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    int i;
+    ma_uint32 riceParamMask;
+    ma_int32* pDecodedSamples    = pSamplesOut;
+    ma_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+    ma_uint32 zeroCountParts0 = 0;
+    ma_uint32 zeroCountParts1 = 0;
+    ma_uint32 zeroCountParts2 = 0;
+    ma_uint32 zeroCountParts3 = 0;
+    ma_uint32 riceParamParts0 = 0;
+    ma_uint32 riceParamParts1 = 0;
+    ma_uint32 riceParamParts2 = 0;
+    ma_uint32 riceParamParts3 = 0;
+    __m128i coefficients128_0;
+    __m128i coefficients128_4;
+    __m128i coefficients128_8;
+    __m128i samples128_0;
+    __m128i samples128_4;
+    __m128i samples128_8;
+    __m128i riceParamMask128;
+    const ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    riceParamMask    = (ma_uint32)~((~0UL) << riceParam);
+    riceParamMask128 = _mm_set1_epi32(riceParamMask);
+    coefficients128_0 = _mm_setzero_si128();
+    coefficients128_4 = _mm_setzero_si128();
+    coefficients128_8 = _mm_setzero_si128();
+    samples128_0 = _mm_setzero_si128();
+    samples128_4 = _mm_setzero_si128();
+    samples128_8 = _mm_setzero_si128();
+#if 1
+    {
+        int runningOrder = order;
+        if (runningOrder >= 4) {
+            coefficients128_0 = _mm_loadu_si128((const __m128i*)(coefficients + 0));
+            samples128_0      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 4));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_0 = _mm_set_epi32(0, coefficients[2], coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], pSamplesOut[-3], 0); break;
+                case 2: coefficients128_0 = _mm_set_epi32(0, 0,               coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], 0,               0); break;
+                case 1: coefficients128_0 = _mm_set_epi32(0, 0,               0,               coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], 0,               0,               0); break;
+            }
+            runningOrder = 0;
+        }
+        if (runningOrder >= 4) {
+            coefficients128_4 = _mm_loadu_si128((const __m128i*)(coefficients + 4));
+            samples128_4      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 8));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_4 = _mm_set_epi32(0, coefficients[6], coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], pSamplesOut[-7], 0); break;
+                case 2: coefficients128_4 = _mm_set_epi32(0, 0,               coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], 0,               0); break;
+                case 1: coefficients128_4 = _mm_set_epi32(0, 0,               0,               coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], 0,               0,               0); break;
+            }
+            runningOrder = 0;
+        }
+        if (runningOrder == 4) {
+            coefficients128_8 = _mm_loadu_si128((const __m128i*)(coefficients + 8));
+            samples128_8      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 12));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_8 = _mm_set_epi32(0, coefficients[10], coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], pSamplesOut[-11], 0); break;
+                case 2: coefficients128_8 = _mm_set_epi32(0, 0,                coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], 0,                0); break;
+                case 1: coefficients128_8 = _mm_set_epi32(0, 0,                0,               coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], 0,                0,                0); break;
+            }
+            runningOrder = 0;
+        }
+        coefficients128_0 = _mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(0, 1, 2, 3));
+        coefficients128_4 = _mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(0, 1, 2, 3));
+        coefficients128_8 = _mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(0, 1, 2, 3));
+    }
+#else
+    switch (order)
+    {
+    case 12: ((ma_int32*)&coefficients128_8)[0] = coefficients[11]; ((ma_int32*)&samples128_8)[0] = pDecodedSamples[-12];
+    case 11: ((ma_int32*)&coefficients128_8)[1] = coefficients[10]; ((ma_int32*)&samples128_8)[1] = pDecodedSamples[-11];
+    case 10: ((ma_int32*)&coefficients128_8)[2] = coefficients[ 9]; ((ma_int32*)&samples128_8)[2] = pDecodedSamples[-10];
+    case 9:  ((ma_int32*)&coefficients128_8)[3] = coefficients[ 8]; ((ma_int32*)&samples128_8)[3] = pDecodedSamples[- 9];
+    case 8:  ((ma_int32*)&coefficients128_4)[0] = coefficients[ 7]; ((ma_int32*)&samples128_4)[0] = pDecodedSamples[- 8];
+    case 7:  ((ma_int32*)&coefficients128_4)[1] = coefficients[ 6]; ((ma_int32*)&samples128_4)[1] = pDecodedSamples[- 7];
+    case 6:  ((ma_int32*)&coefficients128_4)[2] = coefficients[ 5]; ((ma_int32*)&samples128_4)[2] = pDecodedSamples[- 6];
+    case 5:  ((ma_int32*)&coefficients128_4)[3] = coefficients[ 4]; ((ma_int32*)&samples128_4)[3] = pDecodedSamples[- 5];
+    case 4:  ((ma_int32*)&coefficients128_0)[0] = coefficients[ 3]; ((ma_int32*)&samples128_0)[0] = pDecodedSamples[- 4];
+    case 3:  ((ma_int32*)&coefficients128_0)[1] = coefficients[ 2]; ((ma_int32*)&samples128_0)[1] = pDecodedSamples[- 3];
+    case 2:  ((ma_int32*)&coefficients128_0)[2] = coefficients[ 1]; ((ma_int32*)&samples128_0)[2] = pDecodedSamples[- 2];
+    case 1:  ((ma_int32*)&coefficients128_0)[3] = coefficients[ 0]; ((ma_int32*)&samples128_0)[3] = pDecodedSamples[- 1];
+    }
+#endif
+    while (pDecodedSamples < pDecodedSamplesEnd) {
+        __m128i prediction128;
+        __m128i zeroCountPart128;
+        __m128i riceParamPart128;
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts1, &riceParamParts1) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts2, &riceParamParts2) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts3, &riceParamParts3)) {
+            return MA_FALSE;
+        }
+        zeroCountPart128 = _mm_set_epi32(zeroCountParts3, zeroCountParts2, zeroCountParts1, zeroCountParts0);
+        riceParamPart128 = _mm_set_epi32(riceParamParts3, riceParamParts2, riceParamParts1, riceParamParts0);
+        riceParamPart128 = _mm_and_si128(riceParamPart128, riceParamMask128);
+        riceParamPart128 = _mm_or_si128(riceParamPart128, _mm_slli_epi32(zeroCountPart128, riceParam));
+        riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_add_epi32(ma_dr_flac__mm_not_si128(_mm_and_si128(riceParamPart128, _mm_set1_epi32(0x01))), _mm_set1_epi32(0x01)));
+        if (order <= 4) {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 = _mm_mullo_epi32(coefficients128_0, samples128_0);
+                prediction128 = ma_dr_flac__mm_hadd_epi32(prediction128);
+                prediction128 = _mm_srai_epi32(prediction128, shift);
+                prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+                samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+                riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+            }
+        } else if (order <= 8) {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 =                              _mm_mullo_epi32(coefficients128_4, samples128_4);
+                prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_0, samples128_0));
+                prediction128 = ma_dr_flac__mm_hadd_epi32(prediction128);
+                prediction128 = _mm_srai_epi32(prediction128, shift);
+                prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+                samples128_4 = _mm_alignr_epi8(samples128_0,  samples128_4, 4);
+                samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+                riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+            }
+        } else {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 =                              _mm_mullo_epi32(coefficients128_8, samples128_8);
+                prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_4, samples128_4));
+                prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_0, samples128_0));
+                prediction128 = ma_dr_flac__mm_hadd_epi32(prediction128);
+                prediction128 = _mm_srai_epi32(prediction128, shift);
+                prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+                samples128_8 = _mm_alignr_epi8(samples128_4,  samples128_8, 4);
+                samples128_4 = _mm_alignr_epi8(samples128_0,  samples128_4, 4);
+                samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+                riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+            }
+        }
+        _mm_storeu_si128((__m128i*)pDecodedSamples, samples128_0);
+        pDecodedSamples += 4;
+    }
+    i = (count & ~3);
+    while (i < (int)count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0)) {
+            return MA_FALSE;
+        }
+        riceParamParts0 &= riceParamMask;
+        riceParamParts0 |= (zeroCountParts0 << riceParam);
+        riceParamParts0  = (riceParamParts0 >> 1) ^ t[riceParamParts0 & 0x01];
+        pDecodedSamples[0] = riceParamParts0 + ma_dr_flac__calculate_prediction_32(order, shift, coefficients, pDecodedSamples);
+        i += 1;
+        pDecodedSamples += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__sse41_64(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    int i;
+    ma_uint32 riceParamMask;
+    ma_int32* pDecodedSamples    = pSamplesOut;
+    ma_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+    ma_uint32 zeroCountParts0 = 0;
+    ma_uint32 zeroCountParts1 = 0;
+    ma_uint32 zeroCountParts2 = 0;
+    ma_uint32 zeroCountParts3 = 0;
+    ma_uint32 riceParamParts0 = 0;
+    ma_uint32 riceParamParts1 = 0;
+    ma_uint32 riceParamParts2 = 0;
+    ma_uint32 riceParamParts3 = 0;
+    __m128i coefficients128_0;
+    __m128i coefficients128_4;
+    __m128i coefficients128_8;
+    __m128i samples128_0;
+    __m128i samples128_4;
+    __m128i samples128_8;
+    __m128i prediction128;
+    __m128i riceParamMask128;
+    const ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    MA_DR_FLAC_ASSERT(order <= 12);
+    riceParamMask    = (ma_uint32)~((~0UL) << riceParam);
+    riceParamMask128 = _mm_set1_epi32(riceParamMask);
+    prediction128 = _mm_setzero_si128();
+    coefficients128_0  = _mm_setzero_si128();
+    coefficients128_4  = _mm_setzero_si128();
+    coefficients128_8  = _mm_setzero_si128();
+    samples128_0  = _mm_setzero_si128();
+    samples128_4  = _mm_setzero_si128();
+    samples128_8  = _mm_setzero_si128();
+#if 1
+    {
+        int runningOrder = order;
+        if (runningOrder >= 4) {
+            coefficients128_0 = _mm_loadu_si128((const __m128i*)(coefficients + 0));
+            samples128_0      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 4));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_0 = _mm_set_epi32(0, coefficients[2], coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], pSamplesOut[-3], 0); break;
+                case 2: coefficients128_0 = _mm_set_epi32(0, 0,               coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], 0,               0); break;
+                case 1: coefficients128_0 = _mm_set_epi32(0, 0,               0,               coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], 0,               0,               0); break;
+            }
+            runningOrder = 0;
+        }
+        if (runningOrder >= 4) {
+            coefficients128_4 = _mm_loadu_si128((const __m128i*)(coefficients + 4));
+            samples128_4      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 8));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_4 = _mm_set_epi32(0, coefficients[6], coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], pSamplesOut[-7], 0); break;
+                case 2: coefficients128_4 = _mm_set_epi32(0, 0,               coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], 0,               0); break;
+                case 1: coefficients128_4 = _mm_set_epi32(0, 0,               0,               coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], 0,               0,               0); break;
+            }
+            runningOrder = 0;
+        }
+        if (runningOrder == 4) {
+            coefficients128_8 = _mm_loadu_si128((const __m128i*)(coefficients + 8));
+            samples128_8      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 12));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_8 = _mm_set_epi32(0, coefficients[10], coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], pSamplesOut[-11], 0); break;
+                case 2: coefficients128_8 = _mm_set_epi32(0, 0,                coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], 0,                0); break;
+                case 1: coefficients128_8 = _mm_set_epi32(0, 0,                0,               coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], 0,                0,                0); break;
+            }
+            runningOrder = 0;
+        }
+        coefficients128_0 = _mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(0, 1, 2, 3));
+        coefficients128_4 = _mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(0, 1, 2, 3));
+        coefficients128_8 = _mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(0, 1, 2, 3));
+    }
+#else
+    switch (order)
+    {
+    case 12: ((ma_int32*)&coefficients128_8)[0] = coefficients[11]; ((ma_int32*)&samples128_8)[0] = pDecodedSamples[-12];
+    case 11: ((ma_int32*)&coefficients128_8)[1] = coefficients[10]; ((ma_int32*)&samples128_8)[1] = pDecodedSamples[-11];
+    case 10: ((ma_int32*)&coefficients128_8)[2] = coefficients[ 9]; ((ma_int32*)&samples128_8)[2] = pDecodedSamples[-10];
+    case 9:  ((ma_int32*)&coefficients128_8)[3] = coefficients[ 8]; ((ma_int32*)&samples128_8)[3] = pDecodedSamples[- 9];
+    case 8:  ((ma_int32*)&coefficients128_4)[0] = coefficients[ 7]; ((ma_int32*)&samples128_4)[0] = pDecodedSamples[- 8];
+    case 7:  ((ma_int32*)&coefficients128_4)[1] = coefficients[ 6]; ((ma_int32*)&samples128_4)[1] = pDecodedSamples[- 7];
+    case 6:  ((ma_int32*)&coefficients128_4)[2] = coefficients[ 5]; ((ma_int32*)&samples128_4)[2] = pDecodedSamples[- 6];
+    case 5:  ((ma_int32*)&coefficients128_4)[3] = coefficients[ 4]; ((ma_int32*)&samples128_4)[3] = pDecodedSamples[- 5];
+    case 4:  ((ma_int32*)&coefficients128_0)[0] = coefficients[ 3]; ((ma_int32*)&samples128_0)[0] = pDecodedSamples[- 4];
+    case 3:  ((ma_int32*)&coefficients128_0)[1] = coefficients[ 2]; ((ma_int32*)&samples128_0)[1] = pDecodedSamples[- 3];
+    case 2:  ((ma_int32*)&coefficients128_0)[2] = coefficients[ 1]; ((ma_int32*)&samples128_0)[2] = pDecodedSamples[- 2];
+    case 1:  ((ma_int32*)&coefficients128_0)[3] = coefficients[ 0]; ((ma_int32*)&samples128_0)[3] = pDecodedSamples[- 1];
+    }
+#endif
+    while (pDecodedSamples < pDecodedSamplesEnd) {
+        __m128i zeroCountPart128;
+        __m128i riceParamPart128;
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts1, &riceParamParts1) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts2, &riceParamParts2) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts3, &riceParamParts3)) {
+            return MA_FALSE;
+        }
+        zeroCountPart128 = _mm_set_epi32(zeroCountParts3, zeroCountParts2, zeroCountParts1, zeroCountParts0);
+        riceParamPart128 = _mm_set_epi32(riceParamParts3, riceParamParts2, riceParamParts1, riceParamParts0);
+        riceParamPart128 = _mm_and_si128(riceParamPart128, riceParamMask128);
+        riceParamPart128 = _mm_or_si128(riceParamPart128, _mm_slli_epi32(zeroCountPart128, riceParam));
+        riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_add_epi32(ma_dr_flac__mm_not_si128(_mm_and_si128(riceParamPart128, _mm_set1_epi32(1))), _mm_set1_epi32(1)));
+        for (i = 0; i < 4; i += 1) {
+            prediction128 = _mm_xor_si128(prediction128, prediction128);
+            switch (order)
+            {
+            case 12:
+            case 11: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_8, _MM_SHUFFLE(1, 1, 0, 0))));
+            case 10:
+            case  9: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_8, _MM_SHUFFLE(3, 3, 2, 2))));
+            case  8:
+            case  7: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_4, _MM_SHUFFLE(1, 1, 0, 0))));
+            case  6:
+            case  5: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_4, _MM_SHUFFLE(3, 3, 2, 2))));
+            case  4:
+            case  3: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_0, _MM_SHUFFLE(1, 1, 0, 0))));
+            case  2:
+            case  1: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_0, _MM_SHUFFLE(3, 3, 2, 2))));
+            }
+            prediction128 = ma_dr_flac__mm_hadd_epi64(prediction128);
+            prediction128 = ma_dr_flac__mm_srai_epi64(prediction128, shift);
+            prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+            samples128_8 = _mm_alignr_epi8(samples128_4,  samples128_8, 4);
+            samples128_4 = _mm_alignr_epi8(samples128_0,  samples128_4, 4);
+            samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+            riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+        }
+        _mm_storeu_si128((__m128i*)pDecodedSamples, samples128_0);
+        pDecodedSamples += 4;
+    }
+    i = (count & ~3);
+    while (i < (int)count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0)) {
+            return MA_FALSE;
+        }
+        riceParamParts0 &= riceParamMask;
+        riceParamParts0 |= (zeroCountParts0 << riceParam);
+        riceParamParts0  = (riceParamParts0 >> 1) ^ t[riceParamParts0 & 0x01];
+        pDecodedSamples[0] = riceParamParts0 + ma_dr_flac__calculate_prediction_64(order, shift, coefficients, pDecodedSamples);
+        i += 1;
+        pDecodedSamples += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__sse41(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    if (lpcOrder > 0 && lpcOrder <= 12) {
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            return ma_dr_flac__decode_samples_with_residual__rice__sse41_64(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+        } else {
+            return ma_dr_flac__decode_samples_with_residual__rice__sse41_32(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+        }
+    } else {
+        return ma_dr_flac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac__vst2q_s32(ma_int32* p, int32x4x2_t x)
+{
+    vst1q_s32(p+0, x.val[0]);
+    vst1q_s32(p+4, x.val[1]);
+}
+static MA_INLINE void ma_dr_flac__vst2q_u32(ma_uint32* p, uint32x4x2_t x)
+{
+    vst1q_u32(p+0, x.val[0]);
+    vst1q_u32(p+4, x.val[1]);
+}
+static MA_INLINE void ma_dr_flac__vst2q_f32(float* p, float32x4x2_t x)
+{
+    vst1q_f32(p+0, x.val[0]);
+    vst1q_f32(p+4, x.val[1]);
+}
+static MA_INLINE void ma_dr_flac__vst2q_s16(ma_int16* p, int16x4x2_t x)
+{
+    vst1q_s16(p, vcombine_s16(x.val[0], x.val[1]));
+}
+static MA_INLINE void ma_dr_flac__vst2q_u16(ma_uint16* p, uint16x4x2_t x)
+{
+    vst1q_u16(p, vcombine_u16(x.val[0], x.val[1]));
+}
+static MA_INLINE int32x4_t ma_dr_flac__vdupq_n_s32x4(ma_int32 x3, ma_int32 x2, ma_int32 x1, ma_int32 x0)
+{
+    ma_int32 x[4];
+    x[3] = x3;
+    x[2] = x2;
+    x[1] = x1;
+    x[0] = x0;
+    return vld1q_s32(x);
+}
+static MA_INLINE int32x4_t ma_dr_flac__valignrq_s32_1(int32x4_t a, int32x4_t b)
+{
+    return vextq_s32(b, a, 1);
+}
+static MA_INLINE uint32x4_t ma_dr_flac__valignrq_u32_1(uint32x4_t a, uint32x4_t b)
+{
+    return vextq_u32(b, a, 1);
+}
+static MA_INLINE int32x2_t ma_dr_flac__vhaddq_s32(int32x4_t x)
+{
+    int32x2_t r = vadd_s32(vget_high_s32(x), vget_low_s32(x));
+    return vpadd_s32(r, r);
+}
+static MA_INLINE int64x1_t ma_dr_flac__vhaddq_s64(int64x2_t x)
+{
+    return vadd_s64(vget_high_s64(x), vget_low_s64(x));
+}
+static MA_INLINE int32x4_t ma_dr_flac__vrevq_s32(int32x4_t x)
+{
+    return vrev64q_s32(vcombine_s32(vget_high_s32(x), vget_low_s32(x)));
+}
+static MA_INLINE int32x4_t ma_dr_flac__vnotq_s32(int32x4_t x)
+{
+    return veorq_s32(x, vdupq_n_s32(0xFFFFFFFF));
+}
+static MA_INLINE uint32x4_t ma_dr_flac__vnotq_u32(uint32x4_t x)
+{
+    return veorq_u32(x, vdupq_n_u32(0xFFFFFFFF));
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__neon_32(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    int i;
+    ma_uint32 riceParamMask;
+    ma_int32* pDecodedSamples    = pSamplesOut;
+    ma_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+    ma_uint32 zeroCountParts[4];
+    ma_uint32 riceParamParts[4];
+    int32x4_t coefficients128_0;
+    int32x4_t coefficients128_4;
+    int32x4_t coefficients128_8;
+    int32x4_t samples128_0;
+    int32x4_t samples128_4;
+    int32x4_t samples128_8;
+    uint32x4_t riceParamMask128;
+    int32x4_t riceParam128;
+    int32x2_t shift64;
+    uint32x4_t one128;
+    const ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    riceParamMask    = (ma_uint32)~((~0UL) << riceParam);
+    riceParamMask128 = vdupq_n_u32(riceParamMask);
+    riceParam128 = vdupq_n_s32(riceParam);
+    shift64 = vdup_n_s32(-shift);
+    one128 = vdupq_n_u32(1);
+    {
+        int runningOrder = order;
+        ma_int32 tempC[4] = {0, 0, 0, 0};
+        ma_int32 tempS[4] = {0, 0, 0, 0};
+        if (runningOrder >= 4) {
+            coefficients128_0 = vld1q_s32(coefficients + 0);
+            samples128_0      = vld1q_s32(pSamplesOut  - 4);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[2]; tempS[1] = pSamplesOut[-3];
+                case 2: tempC[1] = coefficients[1]; tempS[2] = pSamplesOut[-2];
+                case 1: tempC[0] = coefficients[0]; tempS[3] = pSamplesOut[-1];
+            }
+            coefficients128_0 = vld1q_s32(tempC);
+            samples128_0      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        if (runningOrder >= 4) {
+            coefficients128_4 = vld1q_s32(coefficients + 4);
+            samples128_4      = vld1q_s32(pSamplesOut  - 8);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[6]; tempS[1] = pSamplesOut[-7];
+                case 2: tempC[1] = coefficients[5]; tempS[2] = pSamplesOut[-6];
+                case 1: tempC[0] = coefficients[4]; tempS[3] = pSamplesOut[-5];
+            }
+            coefficients128_4 = vld1q_s32(tempC);
+            samples128_4      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        if (runningOrder == 4) {
+            coefficients128_8 = vld1q_s32(coefficients + 8);
+            samples128_8      = vld1q_s32(pSamplesOut  - 12);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[10]; tempS[1] = pSamplesOut[-11];
+                case 2: tempC[1] = coefficients[ 9]; tempS[2] = pSamplesOut[-10];
+                case 1: tempC[0] = coefficients[ 8]; tempS[3] = pSamplesOut[- 9];
+            }
+            coefficients128_8 = vld1q_s32(tempC);
+            samples128_8      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        coefficients128_0 = ma_dr_flac__vrevq_s32(coefficients128_0);
+        coefficients128_4 = ma_dr_flac__vrevq_s32(coefficients128_4);
+        coefficients128_8 = ma_dr_flac__vrevq_s32(coefficients128_8);
+    }
+    while (pDecodedSamples < pDecodedSamplesEnd) {
+        int32x4_t prediction128;
+        int32x2_t prediction64;
+        uint32x4_t zeroCountPart128;
+        uint32x4_t riceParamPart128;
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[1], &riceParamParts[1]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[2], &riceParamParts[2]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[3], &riceParamParts[3])) {
+            return MA_FALSE;
+        }
+        zeroCountPart128 = vld1q_u32(zeroCountParts);
+        riceParamPart128 = vld1q_u32(riceParamParts);
+        riceParamPart128 = vandq_u32(riceParamPart128, riceParamMask128);
+        riceParamPart128 = vorrq_u32(riceParamPart128, vshlq_u32(zeroCountPart128, riceParam128));
+        riceParamPart128 = veorq_u32(vshrq_n_u32(riceParamPart128, 1), vaddq_u32(ma_dr_flac__vnotq_u32(vandq_u32(riceParamPart128, one128)), one128));
+        if (order <= 4) {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 = vmulq_s32(coefficients128_0, samples128_0);
+                prediction64 = ma_dr_flac__vhaddq_s32(prediction128);
+                prediction64 = vshl_s32(prediction64, shift64);
+                prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128)));
+                samples128_0 = ma_dr_flac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0);
+                riceParamPart128 = ma_dr_flac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+            }
+        } else if (order <= 8) {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 =                vmulq_s32(coefficients128_4, samples128_4);
+                prediction128 = vmlaq_s32(prediction128, coefficients128_0, samples128_0);
+                prediction64 = ma_dr_flac__vhaddq_s32(prediction128);
+                prediction64 = vshl_s32(prediction64, shift64);
+                prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128)));
+                samples128_4 = ma_dr_flac__valignrq_s32_1(samples128_0, samples128_4);
+                samples128_0 = ma_dr_flac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0);
+                riceParamPart128 = ma_dr_flac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+            }
+        } else {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 =                vmulq_s32(coefficients128_8, samples128_8);
+                prediction128 = vmlaq_s32(prediction128, coefficients128_4, samples128_4);
+                prediction128 = vmlaq_s32(prediction128, coefficients128_0, samples128_0);
+                prediction64 = ma_dr_flac__vhaddq_s32(prediction128);
+                prediction64 = vshl_s32(prediction64, shift64);
+                prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128)));
+                samples128_8 = ma_dr_flac__valignrq_s32_1(samples128_4, samples128_8);
+                samples128_4 = ma_dr_flac__valignrq_s32_1(samples128_0, samples128_4);
+                samples128_0 = ma_dr_flac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0);
+                riceParamPart128 = ma_dr_flac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+            }
+        }
+        vst1q_s32(pDecodedSamples, samples128_0);
+        pDecodedSamples += 4;
+    }
+    i = (count & ~3);
+    while (i < (int)count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0])) {
+            return MA_FALSE;
+        }
+        riceParamParts[0] &= riceParamMask;
+        riceParamParts[0] |= (zeroCountParts[0] << riceParam);
+        riceParamParts[0]  = (riceParamParts[0] >> 1) ^ t[riceParamParts[0] & 0x01];
+        pDecodedSamples[0] = riceParamParts[0] + ma_dr_flac__calculate_prediction_32(order, shift, coefficients, pDecodedSamples);
+        i += 1;
+        pDecodedSamples += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__neon_64(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    int i;
+    ma_uint32 riceParamMask;
+    ma_int32* pDecodedSamples    = pSamplesOut;
+    ma_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+    ma_uint32 zeroCountParts[4];
+    ma_uint32 riceParamParts[4];
+    int32x4_t coefficients128_0;
+    int32x4_t coefficients128_4;
+    int32x4_t coefficients128_8;
+    int32x4_t samples128_0;
+    int32x4_t samples128_4;
+    int32x4_t samples128_8;
+    uint32x4_t riceParamMask128;
+    int32x4_t riceParam128;
+    int64x1_t shift64;
+    uint32x4_t one128;
+    int64x2_t prediction128 = { 0 };
+    uint32x4_t zeroCountPart128;
+    uint32x4_t riceParamPart128;
+    const ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    riceParamMask    = (ma_uint32)~((~0UL) << riceParam);
+    riceParamMask128 = vdupq_n_u32(riceParamMask);
+    riceParam128 = vdupq_n_s32(riceParam);
+    shift64 = vdup_n_s64(-shift);
+    one128 = vdupq_n_u32(1);
+    {
+        int runningOrder = order;
+        ma_int32 tempC[4] = {0, 0, 0, 0};
+        ma_int32 tempS[4] = {0, 0, 0, 0};
+        if (runningOrder >= 4) {
+            coefficients128_0 = vld1q_s32(coefficients + 0);
+            samples128_0      = vld1q_s32(pSamplesOut  - 4);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[2]; tempS[1] = pSamplesOut[-3];
+                case 2: tempC[1] = coefficients[1]; tempS[2] = pSamplesOut[-2];
+                case 1: tempC[0] = coefficients[0]; tempS[3] = pSamplesOut[-1];
+            }
+            coefficients128_0 = vld1q_s32(tempC);
+            samples128_0      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        if (runningOrder >= 4) {
+            coefficients128_4 = vld1q_s32(coefficients + 4);
+            samples128_4      = vld1q_s32(pSamplesOut  - 8);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[6]; tempS[1] = pSamplesOut[-7];
+                case 2: tempC[1] = coefficients[5]; tempS[2] = pSamplesOut[-6];
+                case 1: tempC[0] = coefficients[4]; tempS[3] = pSamplesOut[-5];
+            }
+            coefficients128_4 = vld1q_s32(tempC);
+            samples128_4      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        if (runningOrder == 4) {
+            coefficients128_8 = vld1q_s32(coefficients + 8);
+            samples128_8      = vld1q_s32(pSamplesOut  - 12);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[10]; tempS[1] = pSamplesOut[-11];
+                case 2: tempC[1] = coefficients[ 9]; tempS[2] = pSamplesOut[-10];
+                case 1: tempC[0] = coefficients[ 8]; tempS[3] = pSamplesOut[- 9];
+            }
+            coefficients128_8 = vld1q_s32(tempC);
+            samples128_8      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        coefficients128_0 = ma_dr_flac__vrevq_s32(coefficients128_0);
+        coefficients128_4 = ma_dr_flac__vrevq_s32(coefficients128_4);
+        coefficients128_8 = ma_dr_flac__vrevq_s32(coefficients128_8);
+    }
+    while (pDecodedSamples < pDecodedSamplesEnd) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[1], &riceParamParts[1]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[2], &riceParamParts[2]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[3], &riceParamParts[3])) {
+            return MA_FALSE;
+        }
+        zeroCountPart128 = vld1q_u32(zeroCountParts);
+        riceParamPart128 = vld1q_u32(riceParamParts);
+        riceParamPart128 = vandq_u32(riceParamPart128, riceParamMask128);
+        riceParamPart128 = vorrq_u32(riceParamPart128, vshlq_u32(zeroCountPart128, riceParam128));
+        riceParamPart128 = veorq_u32(vshrq_n_u32(riceParamPart128, 1), vaddq_u32(ma_dr_flac__vnotq_u32(vandq_u32(riceParamPart128, one128)), one128));
+        for (i = 0; i < 4; i += 1) {
+            int64x1_t prediction64;
+            prediction128 = veorq_s64(prediction128, prediction128);
+            switch (order)
+            {
+            case 12:
+            case 11: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_8), vget_low_s32(samples128_8)));
+            case 10:
+            case  9: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_8), vget_high_s32(samples128_8)));
+            case  8:
+            case  7: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_4), vget_low_s32(samples128_4)));
+            case  6:
+            case  5: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_4), vget_high_s32(samples128_4)));
+            case  4:
+            case  3: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_0), vget_low_s32(samples128_0)));
+            case  2:
+            case  1: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_0), vget_high_s32(samples128_0)));
+            }
+            prediction64 = ma_dr_flac__vhaddq_s64(prediction128);
+            prediction64 = vshl_s64(prediction64, shift64);
+            prediction64 = vadd_s64(prediction64, vdup_n_s64(vgetq_lane_u32(riceParamPart128, 0)));
+            samples128_8 = ma_dr_flac__valignrq_s32_1(samples128_4, samples128_8);
+            samples128_4 = ma_dr_flac__valignrq_s32_1(samples128_0, samples128_4);
+            samples128_0 = ma_dr_flac__valignrq_s32_1(vcombine_s32(vreinterpret_s32_s64(prediction64), vdup_n_s32(0)), samples128_0);
+            riceParamPart128 = ma_dr_flac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+        }
+        vst1q_s32(pDecodedSamples, samples128_0);
+        pDecodedSamples += 4;
+    }
+    i = (count & ~3);
+    while (i < (int)count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0])) {
+            return MA_FALSE;
+        }
+        riceParamParts[0] &= riceParamMask;
+        riceParamParts[0] |= (zeroCountParts[0] << riceParam);
+        riceParamParts[0]  = (riceParamParts[0] >> 1) ^ t[riceParamParts[0] & 0x01];
+        pDecodedSamples[0] = riceParamParts[0] + ma_dr_flac__calculate_prediction_64(order, shift, coefficients, pDecodedSamples);
+        i += 1;
+        pDecodedSamples += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__neon(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    if (lpcOrder > 0 && lpcOrder <= 12) {
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            return ma_dr_flac__decode_samples_with_residual__rice__neon_64(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+        } else {
+            return ma_dr_flac__decode_samples_with_residual__rice__neon_32(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+        }
+    } else {
+        return ma_dr_flac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    }
+}
+#endif
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE41)
+    if (ma_dr_flac__gIsSSE41Supported) {
+        return ma_dr_flac__decode_samples_with_residual__rice__sse41(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported) {
+        return ma_dr_flac__decode_samples_with_residual__rice__neon(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    } else
+#endif
+    {
+    #if 0
+        return ma_dr_flac__decode_samples_with_residual__rice__reference(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    #else
+        return ma_dr_flac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    #endif
+    }
+}
+static ma_bool32 ma_dr_flac__read_and_seek_residual__rice(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam)
+{
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    for (i = 0; i < count; ++i) {
+        if (!ma_dr_flac__seek_rice_parts(bs, riceParam)) {
+            return MA_FALSE;
+        }
+    }
+    return MA_TRUE;
+}
+#if defined(__clang__)
+__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__unencoded(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 unencodedBitsPerSample, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(unencodedBitsPerSample <= 31);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    for (i = 0; i < count; ++i) {
+        if (unencodedBitsPerSample > 0) {
+            if (!ma_dr_flac__read_int32(bs, unencodedBitsPerSample, pSamplesOut + i)) {
+                return MA_FALSE;
+            }
+        } else {
+            pSamplesOut[i] = 0;
+        }
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            pSamplesOut[i] += ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+        } else {
+            pSamplesOut[i] += ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+        }
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 blockSize, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pDecodedSamples)
+{
+    ma_uint8 residualMethod;
+    ma_uint8 partitionOrder;
+    ma_uint32 samplesInPartition;
+    ma_uint32 partitionsRemaining;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(blockSize != 0);
+    MA_DR_FLAC_ASSERT(pDecodedSamples != NULL);
+    if (!ma_dr_flac__read_uint8(bs, 2, &residualMethod)) {
+        return MA_FALSE;
+    }
+    if (residualMethod != MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE && residualMethod != MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+        return MA_FALSE;
+    }
+    pDecodedSamples += lpcOrder;
+    if (!ma_dr_flac__read_uint8(bs, 4, &partitionOrder)) {
+        return MA_FALSE;
+    }
+    if (partitionOrder > 8) {
+        return MA_FALSE;
+    }
+    if ((blockSize / (1 << partitionOrder)) < lpcOrder) {
+        return MA_FALSE;
+    }
+    samplesInPartition = (blockSize / (1 << partitionOrder)) - lpcOrder;
+    partitionsRemaining = (1 << partitionOrder);
+    for (;;) {
+        ma_uint8 riceParam = 0;
+        if (residualMethod == MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE) {
+            if (!ma_dr_flac__read_uint8(bs, 4, &riceParam)) {
+                return MA_FALSE;
+            }
+            if (riceParam == 15) {
+                riceParam = 0xFF;
+            }
+        } else if (residualMethod == MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+            if (!ma_dr_flac__read_uint8(bs, 5, &riceParam)) {
+                return MA_FALSE;
+            }
+            if (riceParam == 31) {
+                riceParam = 0xFF;
+            }
+        }
+        if (riceParam != 0xFF) {
+            if (!ma_dr_flac__decode_samples_with_residual__rice(bs, bitsPerSample, samplesInPartition, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+                return MA_FALSE;
+            }
+        } else {
+            ma_uint8 unencodedBitsPerSample = 0;
+            if (!ma_dr_flac__read_uint8(bs, 5, &unencodedBitsPerSample)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__decode_samples_with_residual__unencoded(bs, bitsPerSample, samplesInPartition, unencodedBitsPerSample, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+                return MA_FALSE;
+            }
+        }
+        pDecodedSamples += samplesInPartition;
+        if (partitionsRemaining == 1) {
+            break;
+        }
+        partitionsRemaining -= 1;
+        if (partitionOrder != 0) {
+            samplesInPartition = blockSize / (1 << partitionOrder);
+        }
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__read_and_seek_residual(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 order)
+{
+    ma_uint8 residualMethod;
+    ma_uint8 partitionOrder;
+    ma_uint32 samplesInPartition;
+    ma_uint32 partitionsRemaining;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(blockSize != 0);
+    if (!ma_dr_flac__read_uint8(bs, 2, &residualMethod)) {
+        return MA_FALSE;
+    }
+    if (residualMethod != MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE && residualMethod != MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_flac__read_uint8(bs, 4, &partitionOrder)) {
+        return MA_FALSE;
+    }
+    if (partitionOrder > 8) {
+        return MA_FALSE;
+    }
+    if ((blockSize / (1 << partitionOrder)) <= order) {
+        return MA_FALSE;
+    }
+    samplesInPartition = (blockSize / (1 << partitionOrder)) - order;
+    partitionsRemaining = (1 << partitionOrder);
+    for (;;)
+    {
+        ma_uint8 riceParam = 0;
+        if (residualMethod == MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE) {
+            if (!ma_dr_flac__read_uint8(bs, 4, &riceParam)) {
+                return MA_FALSE;
+            }
+            if (riceParam == 15) {
+                riceParam = 0xFF;
+            }
+        } else if (residualMethod == MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+            if (!ma_dr_flac__read_uint8(bs, 5, &riceParam)) {
+                return MA_FALSE;
+            }
+            if (riceParam == 31) {
+                riceParam = 0xFF;
+            }
+        }
+        if (riceParam != 0xFF) {
+            if (!ma_dr_flac__read_and_seek_residual__rice(bs, samplesInPartition, riceParam)) {
+                return MA_FALSE;
+            }
+        } else {
+            ma_uint8 unencodedBitsPerSample = 0;
+            if (!ma_dr_flac__read_uint8(bs, 5, &unencodedBitsPerSample)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__seek_bits(bs, unencodedBitsPerSample * samplesInPartition)) {
+                return MA_FALSE;
+            }
+        }
+        if (partitionsRemaining == 1) {
+            break;
+        }
+        partitionsRemaining -= 1;
+        samplesInPartition = blockSize / (1 << partitionOrder);
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples__constant(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 subframeBitsPerSample, ma_int32* pDecodedSamples)
+{
+    ma_uint32 i;
+    ma_int32 sample;
+    if (!ma_dr_flac__read_int32(bs, subframeBitsPerSample, &sample)) {
+        return MA_FALSE;
+    }
+    for (i = 0; i < blockSize; ++i) {
+        pDecodedSamples[i] = sample;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples__verbatim(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 subframeBitsPerSample, ma_int32* pDecodedSamples)
+{
+    ma_uint32 i;
+    for (i = 0; i < blockSize; ++i) {
+        ma_int32 sample;
+        if (!ma_dr_flac__read_int32(bs, subframeBitsPerSample, &sample)) {
+            return MA_FALSE;
+        }
+        pDecodedSamples[i] = sample;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples__fixed(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 subframeBitsPerSample, ma_uint8 lpcOrder, ma_int32* pDecodedSamples)
+{
+    ma_uint32 i;
+    static ma_int32 lpcCoefficientsTable[5][4] = {
+        {0,  0, 0,  0},
+        {1,  0, 0,  0},
+        {2, -1, 0,  0},
+        {3, -3, 1,  0},
+        {4, -6, 4, -1}
+    };
+    for (i = 0; i < lpcOrder; ++i) {
+        ma_int32 sample;
+        if (!ma_dr_flac__read_int32(bs, subframeBitsPerSample, &sample)) {
+            return MA_FALSE;
+        }
+        pDecodedSamples[i] = sample;
+    }
+    if (!ma_dr_flac__decode_samples_with_residual(bs, subframeBitsPerSample, blockSize, lpcOrder, 0, 4, lpcCoefficientsTable[lpcOrder], pDecodedSamples)) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples__lpc(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 bitsPerSample, ma_uint8 lpcOrder, ma_int32* pDecodedSamples)
+{
+    ma_uint8 i;
+    ma_uint8 lpcPrecision;
+    ma_int8 lpcShift;
+    ma_int32 coefficients[32];
+    for (i = 0; i < lpcOrder; ++i) {
+        ma_int32 sample;
+        if (!ma_dr_flac__read_int32(bs, bitsPerSample, &sample)) {
+            return MA_FALSE;
+        }
+        pDecodedSamples[i] = sample;
+    }
+    if (!ma_dr_flac__read_uint8(bs, 4, &lpcPrecision)) {
+        return MA_FALSE;
+    }
+    if (lpcPrecision == 15) {
+        return MA_FALSE;
+    }
+    lpcPrecision += 1;
+    if (!ma_dr_flac__read_int8(bs, 5, &lpcShift)) {
+        return MA_FALSE;
+    }
+    if (lpcShift < 0) {
+        return MA_FALSE;
+    }
+    MA_DR_FLAC_ZERO_MEMORY(coefficients, sizeof(coefficients));
+    for (i = 0; i < lpcOrder; ++i) {
+        if (!ma_dr_flac__read_int32(bs, lpcPrecision, coefficients + i)) {
+            return MA_FALSE;
+        }
+    }
+    if (!ma_dr_flac__decode_samples_with_residual(bs, bitsPerSample, blockSize, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__read_next_flac_frame_header(ma_dr_flac_bs* bs, ma_uint8 streaminfoBitsPerSample, ma_dr_flac_frame_header* header)
+{
+    const ma_uint32 sampleRateTable[12]  = {0, 88200, 176400, 192000, 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000};
+    const ma_uint8 bitsPerSampleTable[8] = {0, 8, 12, (ma_uint8)-1, 16, 20, 24, (ma_uint8)-1};
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(header != NULL);
+    for (;;) {
+        ma_uint8 crc8 = 0xCE;
+        ma_uint8 reserved = 0;
+        ma_uint8 blockingStrategy = 0;
+        ma_uint8 blockSize = 0;
+        ma_uint8 sampleRate = 0;
+        ma_uint8 channelAssignment = 0;
+        ma_uint8 bitsPerSample = 0;
+        ma_bool32 isVariableBlockSize;
+        if (!ma_dr_flac__find_and_seek_to_next_sync_code(bs)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac__read_uint8(bs, 1, &reserved)) {
+            return MA_FALSE;
+        }
+        if (reserved == 1) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, reserved, 1);
+        if (!ma_dr_flac__read_uint8(bs, 1, &blockingStrategy)) {
+            return MA_FALSE;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, blockingStrategy, 1);
+        if (!ma_dr_flac__read_uint8(bs, 4, &blockSize)) {
+            return MA_FALSE;
+        }
+        if (blockSize == 0) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, blockSize, 4);
+        if (!ma_dr_flac__read_uint8(bs, 4, &sampleRate)) {
+            return MA_FALSE;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, sampleRate, 4);
+        if (!ma_dr_flac__read_uint8(bs, 4, &channelAssignment)) {
+            return MA_FALSE;
+        }
+        if (channelAssignment > 10) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, channelAssignment, 4);
+        if (!ma_dr_flac__read_uint8(bs, 3, &bitsPerSample)) {
+            return MA_FALSE;
+        }
+        if (bitsPerSample == 3 || bitsPerSample == 7) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, bitsPerSample, 3);
+        if (!ma_dr_flac__read_uint8(bs, 1, &reserved)) {
+            return MA_FALSE;
+        }
+        if (reserved == 1) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, reserved, 1);
+        isVariableBlockSize = blockingStrategy == 1;
+        if (isVariableBlockSize) {
+            ma_uint64 pcmFrameNumber;
+            ma_result result = ma_dr_flac__read_utf8_coded_number(bs, &pcmFrameNumber, &crc8);
+            if (result != MA_SUCCESS) {
+                if (result == MA_AT_END) {
+                    return MA_FALSE;
+                } else {
+                    continue;
+                }
+            }
+            header->flacFrameNumber  = 0;
+            header->pcmFrameNumber = pcmFrameNumber;
+        } else {
+            ma_uint64 flacFrameNumber = 0;
+            ma_result result = ma_dr_flac__read_utf8_coded_number(bs, &flacFrameNumber, &crc8);
+            if (result != MA_SUCCESS) {
+                if (result == MA_AT_END) {
+                    return MA_FALSE;
+                } else {
+                    continue;
+                }
+            }
+            header->flacFrameNumber  = (ma_uint32)flacFrameNumber;
+            header->pcmFrameNumber = 0;
+        }
+        MA_DR_FLAC_ASSERT(blockSize > 0);
+        if (blockSize == 1) {
+            header->blockSizeInPCMFrames = 192;
+        } else if (blockSize <= 5) {
+            MA_DR_FLAC_ASSERT(blockSize >= 2);
+            header->blockSizeInPCMFrames = 576 * (1 << (blockSize - 2));
+        } else if (blockSize == 6) {
+            if (!ma_dr_flac__read_uint16(bs, 8, &header->blockSizeInPCMFrames)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->blockSizeInPCMFrames, 8);
+            header->blockSizeInPCMFrames += 1;
+        } else if (blockSize == 7) {
+            if (!ma_dr_flac__read_uint16(bs, 16, &header->blockSizeInPCMFrames)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->blockSizeInPCMFrames, 16);
+            if (header->blockSizeInPCMFrames == 0xFFFF) {
+                return MA_FALSE;
+            }
+            header->blockSizeInPCMFrames += 1;
+        } else {
+            MA_DR_FLAC_ASSERT(blockSize >= 8);
+            header->blockSizeInPCMFrames = 256 * (1 << (blockSize - 8));
+        }
+        if (sampleRate <= 11) {
+            header->sampleRate = sampleRateTable[sampleRate];
+        } else if (sampleRate == 12) {
+            if (!ma_dr_flac__read_uint32(bs, 8, &header->sampleRate)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->sampleRate, 8);
+            header->sampleRate *= 1000;
+        } else if (sampleRate == 13) {
+            if (!ma_dr_flac__read_uint32(bs, 16, &header->sampleRate)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->sampleRate, 16);
+        } else if (sampleRate == 14) {
+            if (!ma_dr_flac__read_uint32(bs, 16, &header->sampleRate)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->sampleRate, 16);
+            header->sampleRate *= 10;
+        } else {
+            continue;
+        }
+        header->channelAssignment = channelAssignment;
+        header->bitsPerSample = bitsPerSampleTable[bitsPerSample];
+        if (header->bitsPerSample == 0) {
+            header->bitsPerSample = streaminfoBitsPerSample;
+        }
+        if (header->bitsPerSample != streaminfoBitsPerSample) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac__read_uint8(bs, 8, &header->crc8)) {
+            return MA_FALSE;
+        }
+#ifndef MA_DR_FLAC_NO_CRC
+        if (header->crc8 != crc8) {
+            continue;
+        }
+#endif
+        return MA_TRUE;
+    }
+}
+static ma_bool32 ma_dr_flac__read_subframe_header(ma_dr_flac_bs* bs, ma_dr_flac_subframe* pSubframe)
+{
+    ma_uint8 header;
+    int type;
+    if (!ma_dr_flac__read_uint8(bs, 8, &header)) {
+        return MA_FALSE;
+    }
+    if ((header & 0x80) != 0) {
+        return MA_FALSE;
+    }
+    pSubframe->lpcOrder = 0;
+    type = (header & 0x7E) >> 1;
+    if (type == 0) {
+        pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_CONSTANT;
+    } else if (type == 1) {
+        pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_VERBATIM;
+    } else {
+        if ((type & 0x20) != 0) {
+            pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_LPC;
+            pSubframe->lpcOrder = (ma_uint8)(type & 0x1F) + 1;
+        } else if ((type & 0x08) != 0) {
+            pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_FIXED;
+            pSubframe->lpcOrder = (ma_uint8)(type & 0x07);
+            if (pSubframe->lpcOrder > 4) {
+                pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_RESERVED;
+                pSubframe->lpcOrder = 0;
+            }
+        } else {
+            pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_RESERVED;
+        }
+    }
+    if (pSubframe->subframeType == MA_DR_FLAC_SUBFRAME_RESERVED) {
+        return MA_FALSE;
+    }
+    pSubframe->wastedBitsPerSample = 0;
+    if ((header & 0x01) == 1) {
+        unsigned int wastedBitsPerSample;
+        if (!ma_dr_flac__seek_past_next_set_bit(bs, &wastedBitsPerSample)) {
+            return MA_FALSE;
+        }
+        pSubframe->wastedBitsPerSample = (ma_uint8)wastedBitsPerSample + 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_subframe(ma_dr_flac_bs* bs, ma_dr_flac_frame* frame, int subframeIndex, ma_int32* pDecodedSamplesOut)
+{
+    ma_dr_flac_subframe* pSubframe;
+    ma_uint32 subframeBitsPerSample;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(frame != NULL);
+    pSubframe = frame->subframes + subframeIndex;
+    if (!ma_dr_flac__read_subframe_header(bs, pSubframe)) {
+        return MA_FALSE;
+    }
+    subframeBitsPerSample = frame->header.bitsPerSample;
+    if ((frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE || frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE) && subframeIndex == 1) {
+        subframeBitsPerSample += 1;
+    } else if (frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE && subframeIndex == 0) {
+        subframeBitsPerSample += 1;
+    }
+    if (subframeBitsPerSample > 32) {
+        return MA_FALSE;
+    }
+    if (pSubframe->wastedBitsPerSample >= subframeBitsPerSample) {
+        return MA_FALSE;
+    }
+    subframeBitsPerSample -= pSubframe->wastedBitsPerSample;
+    pSubframe->pSamplesS32 = pDecodedSamplesOut;
+    if (frame->header.blockSizeInPCMFrames < pSubframe->lpcOrder) {
+        return MA_FALSE;
+    }
+    switch (pSubframe->subframeType)
+    {
+        case MA_DR_FLAC_SUBFRAME_CONSTANT:
+        {
+            ma_dr_flac__decode_samples__constant(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->pSamplesS32);
+        } break;
+        case MA_DR_FLAC_SUBFRAME_VERBATIM:
+        {
+            ma_dr_flac__decode_samples__verbatim(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->pSamplesS32);
+        } break;
+        case MA_DR_FLAC_SUBFRAME_FIXED:
+        {
+            ma_dr_flac__decode_samples__fixed(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->lpcOrder, pSubframe->pSamplesS32);
+        } break;
+        case MA_DR_FLAC_SUBFRAME_LPC:
+        {
+            ma_dr_flac__decode_samples__lpc(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->lpcOrder, pSubframe->pSamplesS32);
+        } break;
+        default: return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__seek_subframe(ma_dr_flac_bs* bs, ma_dr_flac_frame* frame, int subframeIndex)
+{
+    ma_dr_flac_subframe* pSubframe;
+    ma_uint32 subframeBitsPerSample;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(frame != NULL);
+    pSubframe = frame->subframes + subframeIndex;
+    if (!ma_dr_flac__read_subframe_header(bs, pSubframe)) {
+        return MA_FALSE;
+    }
+    subframeBitsPerSample = frame->header.bitsPerSample;
+    if ((frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE || frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE) && subframeIndex == 1) {
+        subframeBitsPerSample += 1;
+    } else if (frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE && subframeIndex == 0) {
+        subframeBitsPerSample += 1;
+    }
+    if (pSubframe->wastedBitsPerSample >= subframeBitsPerSample) {
+        return MA_FALSE;
+    }
+    subframeBitsPerSample -= pSubframe->wastedBitsPerSample;
+    pSubframe->pSamplesS32 = NULL;
+    switch (pSubframe->subframeType)
+    {
+        case MA_DR_FLAC_SUBFRAME_CONSTANT:
+        {
+            if (!ma_dr_flac__seek_bits(bs, subframeBitsPerSample)) {
+                return MA_FALSE;
+            }
+        } break;
+        case MA_DR_FLAC_SUBFRAME_VERBATIM:
+        {
+            unsigned int bitsToSeek = frame->header.blockSizeInPCMFrames * subframeBitsPerSample;
+            if (!ma_dr_flac__seek_bits(bs, bitsToSeek)) {
+                return MA_FALSE;
+            }
+        } break;
+        case MA_DR_FLAC_SUBFRAME_FIXED:
+        {
+            unsigned int bitsToSeek = pSubframe->lpcOrder * subframeBitsPerSample;
+            if (!ma_dr_flac__seek_bits(bs, bitsToSeek)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__read_and_seek_residual(bs, frame->header.blockSizeInPCMFrames, pSubframe->lpcOrder)) {
+                return MA_FALSE;
+            }
+        } break;
+        case MA_DR_FLAC_SUBFRAME_LPC:
+        {
+            ma_uint8 lpcPrecision;
+            unsigned int bitsToSeek = pSubframe->lpcOrder * subframeBitsPerSample;
+            if (!ma_dr_flac__seek_bits(bs, bitsToSeek)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__read_uint8(bs, 4, &lpcPrecision)) {
+                return MA_FALSE;
+            }
+            if (lpcPrecision == 15) {
+                return MA_FALSE;
+            }
+            lpcPrecision += 1;
+            bitsToSeek = (pSubframe->lpcOrder * lpcPrecision) + 5;
+            if (!ma_dr_flac__seek_bits(bs, bitsToSeek)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__read_and_seek_residual(bs, frame->header.blockSizeInPCMFrames, pSubframe->lpcOrder)) {
+                return MA_FALSE;
+            }
+        } break;
+        default: return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static MA_INLINE ma_uint8 ma_dr_flac__get_channel_count_from_channel_assignment(ma_int8 channelAssignment)
+{
+    ma_uint8 lookup[] = {1, 2, 3, 4, 5, 6, 7, 8, 2, 2, 2};
+    MA_DR_FLAC_ASSERT(channelAssignment <= 10);
+    return lookup[channelAssignment];
+}
+static ma_result ma_dr_flac__decode_flac_frame(ma_dr_flac* pFlac)
+{
+    int channelCount;
+    int i;
+    ma_uint8 paddingSizeInBits;
+    ma_uint16 desiredCRC16;
+#ifndef MA_DR_FLAC_NO_CRC
+    ma_uint16 actualCRC16;
+#endif
+    MA_DR_FLAC_ZERO_MEMORY(pFlac->currentFLACFrame.subframes, sizeof(pFlac->currentFLACFrame.subframes));
+    if (pFlac->currentFLACFrame.header.blockSizeInPCMFrames > pFlac->maxBlockSizeInPCMFrames) {
+        return MA_ERROR;
+    }
+    channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+    if (channelCount != (int)pFlac->channels) {
+        return MA_ERROR;
+    }
+    for (i = 0; i < channelCount; ++i) {
+        if (!ma_dr_flac__decode_subframe(&pFlac->bs, &pFlac->currentFLACFrame, i, pFlac->pDecodedSamples + (pFlac->currentFLACFrame.header.blockSizeInPCMFrames * i))) {
+            return MA_ERROR;
+        }
+    }
+    paddingSizeInBits = (ma_uint8)(MA_DR_FLAC_CACHE_L1_BITS_REMAINING(&pFlac->bs) & 7);
+    if (paddingSizeInBits > 0) {
+        ma_uint8 padding = 0;
+        if (!ma_dr_flac__read_uint8(&pFlac->bs, paddingSizeInBits, &padding)) {
+            return MA_AT_END;
+        }
+    }
+#ifndef MA_DR_FLAC_NO_CRC
+    actualCRC16 = ma_dr_flac__flush_crc16(&pFlac->bs);
+#endif
+    if (!ma_dr_flac__read_uint16(&pFlac->bs, 16, &desiredCRC16)) {
+        return MA_AT_END;
+    }
+#ifndef MA_DR_FLAC_NO_CRC
+    if (actualCRC16 != desiredCRC16) {
+        return MA_CRC_MISMATCH;
+    }
+#endif
+    pFlac->currentFLACFrame.pcmFramesRemaining = pFlac->currentFLACFrame.header.blockSizeInPCMFrames;
+    return MA_SUCCESS;
+}
+static ma_result ma_dr_flac__seek_flac_frame(ma_dr_flac* pFlac)
+{
+    int channelCount;
+    int i;
+    ma_uint16 desiredCRC16;
+#ifndef MA_DR_FLAC_NO_CRC
+    ma_uint16 actualCRC16;
+#endif
+    channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+    for (i = 0; i < channelCount; ++i) {
+        if (!ma_dr_flac__seek_subframe(&pFlac->bs, &pFlac->currentFLACFrame, i)) {
+            return MA_ERROR;
+        }
+    }
+    if (!ma_dr_flac__seek_bits(&pFlac->bs, MA_DR_FLAC_CACHE_L1_BITS_REMAINING(&pFlac->bs) & 7)) {
+        return MA_ERROR;
+    }
+#ifndef MA_DR_FLAC_NO_CRC
+    actualCRC16 = ma_dr_flac__flush_crc16(&pFlac->bs);
+#endif
+    if (!ma_dr_flac__read_uint16(&pFlac->bs, 16, &desiredCRC16)) {
+        return MA_AT_END;
+    }
+#ifndef MA_DR_FLAC_NO_CRC
+    if (actualCRC16 != desiredCRC16) {
+        return MA_CRC_MISMATCH;
+    }
+#endif
+    return MA_SUCCESS;
+}
+static ma_bool32 ma_dr_flac__read_and_decode_next_flac_frame(ma_dr_flac* pFlac)
+{
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    for (;;) {
+        ma_result result;
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+        result = ma_dr_flac__decode_flac_frame(pFlac);
+        if (result != MA_SUCCESS) {
+            if (result == MA_CRC_MISMATCH) {
+                continue;
+            } else {
+                return MA_FALSE;
+            }
+        }
+        return MA_TRUE;
+    }
+}
+static void ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(ma_dr_flac* pFlac, ma_uint64* pFirstPCMFrame, ma_uint64* pLastPCMFrame)
+{
+    ma_uint64 firstPCMFrame;
+    ma_uint64 lastPCMFrame;
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    firstPCMFrame = pFlac->currentFLACFrame.header.pcmFrameNumber;
+    if (firstPCMFrame == 0) {
+        firstPCMFrame = ((ma_uint64)pFlac->currentFLACFrame.header.flacFrameNumber) * pFlac->maxBlockSizeInPCMFrames;
+    }
+    lastPCMFrame = firstPCMFrame + pFlac->currentFLACFrame.header.blockSizeInPCMFrames;
+    if (lastPCMFrame > 0) {
+        lastPCMFrame -= 1;
+    }
+    if (pFirstPCMFrame) {
+        *pFirstPCMFrame = firstPCMFrame;
+    }
+    if (pLastPCMFrame) {
+        *pLastPCMFrame = lastPCMFrame;
+    }
+}
+static ma_bool32 ma_dr_flac__seek_to_first_frame(ma_dr_flac* pFlac)
+{
+    ma_bool32 result;
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    result = ma_dr_flac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes);
+    MA_DR_FLAC_ZERO_MEMORY(&pFlac->currentFLACFrame, sizeof(pFlac->currentFLACFrame));
+    pFlac->currentPCMFrame = 0;
+    return result;
+}
+static MA_INLINE ma_result ma_dr_flac__seek_to_next_flac_frame(ma_dr_flac* pFlac)
+{
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    return ma_dr_flac__seek_flac_frame(pFlac);
+}
+static ma_uint64 ma_dr_flac__seek_forward_by_pcm_frames(ma_dr_flac* pFlac, ma_uint64 pcmFramesToSeek)
+{
+    ma_uint64 pcmFramesRead = 0;
+    while (pcmFramesToSeek > 0) {
+        if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                break;
+            }
+        } else {
+            if (pFlac->currentFLACFrame.pcmFramesRemaining > pcmFramesToSeek) {
+                pcmFramesRead   += pcmFramesToSeek;
+                pFlac->currentFLACFrame.pcmFramesRemaining -= (ma_uint32)pcmFramesToSeek;
+                pcmFramesToSeek  = 0;
+            } else {
+                pcmFramesRead   += pFlac->currentFLACFrame.pcmFramesRemaining;
+                pcmFramesToSeek -= pFlac->currentFLACFrame.pcmFramesRemaining;
+                pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+            }
+        }
+    }
+    pFlac->currentPCMFrame += pcmFramesRead;
+    return pcmFramesRead;
+}
+static ma_bool32 ma_dr_flac__seek_to_pcm_frame__brute_force(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    ma_bool32 isMidFrame = MA_FALSE;
+    ma_uint64 runningPCMFrameCount;
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    if (pcmFrameIndex >= pFlac->currentPCMFrame) {
+        runningPCMFrameCount = pFlac->currentPCMFrame;
+        if (pFlac->currentPCMFrame == 0 && pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                return MA_FALSE;
+            }
+        } else {
+            isMidFrame = MA_TRUE;
+        }
+    } else {
+        runningPCMFrameCount = 0;
+        if (!ma_dr_flac__seek_to_first_frame(pFlac)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+    }
+    for (;;) {
+        ma_uint64 pcmFrameCountInThisFLACFrame;
+        ma_uint64 firstPCMFrameInFLACFrame = 0;
+        ma_uint64 lastPCMFrameInFLACFrame = 0;
+        ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame);
+        pcmFrameCountInThisFLACFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1;
+        if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFLACFrame)) {
+            ma_uint64 pcmFramesToDecode = pcmFrameIndex - runningPCMFrameCount;
+            if (!isMidFrame) {
+                ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+                if (result == MA_SUCCESS) {
+                    return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+                } else {
+                    if (result == MA_CRC_MISMATCH) {
+                        goto next_iteration;
+                    } else {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+            }
+        } else {
+            if (!isMidFrame) {
+                ma_result result = ma_dr_flac__seek_to_next_flac_frame(pFlac);
+                if (result == MA_SUCCESS) {
+                    runningPCMFrameCount += pcmFrameCountInThisFLACFrame;
+                } else {
+                    if (result == MA_CRC_MISMATCH) {
+                        goto next_iteration;
+                    } else {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                runningPCMFrameCount += pFlac->currentFLACFrame.pcmFramesRemaining;
+                pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+                isMidFrame = MA_FALSE;
+            }
+            if (pcmFrameIndex == pFlac->totalPCMFrameCount && runningPCMFrameCount == pFlac->totalPCMFrameCount) {
+                return MA_TRUE;
+            }
+        }
+    next_iteration:
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+    }
+}
+#if !defined(MA_DR_FLAC_NO_CRC)
+#define MA_DR_FLAC_BINARY_SEARCH_APPROX_COMPRESSION_RATIO 0.6f
+static ma_bool32 ma_dr_flac__seek_to_approximate_flac_frame_to_byte(ma_dr_flac* pFlac, ma_uint64 targetByte, ma_uint64 rangeLo, ma_uint64 rangeHi, ma_uint64* pLastSuccessfulSeekOffset)
+{
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    MA_DR_FLAC_ASSERT(pLastSuccessfulSeekOffset != NULL);
+    MA_DR_FLAC_ASSERT(targetByte >= rangeLo);
+    MA_DR_FLAC_ASSERT(targetByte <= rangeHi);
+    *pLastSuccessfulSeekOffset = pFlac->firstFLACFramePosInBytes;
+    for (;;) {
+        ma_uint64 lastTargetByte = targetByte;
+        if (!ma_dr_flac__seek_to_byte(&pFlac->bs, targetByte)) {
+            if (targetByte == 0) {
+                ma_dr_flac__seek_to_first_frame(pFlac);
+                return MA_FALSE;
+            }
+            targetByte = rangeLo + ((rangeHi - rangeLo)/2);
+            rangeHi = targetByte;
+        } else {
+            MA_DR_FLAC_ZERO_MEMORY(&pFlac->currentFLACFrame, sizeof(pFlac->currentFLACFrame));
+#if 1
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                targetByte = rangeLo + ((rangeHi - rangeLo)/2);
+                rangeHi = targetByte;
+            } else {
+                break;
+            }
+#else
+            if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                targetByte = rangeLo + ((rangeHi - rangeLo)/2);
+                rangeHi = targetByte;
+            } else {
+                break;
+            }
+#endif
+        }
+        if(targetByte == lastTargetByte) {
+            return MA_FALSE;
+        }
+    }
+    ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &pFlac->currentPCMFrame, NULL);
+    MA_DR_FLAC_ASSERT(targetByte <= rangeHi);
+    *pLastSuccessfulSeekOffset = targetByte;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_flac_frame_and_seek_forward_by_pcm_frames(ma_dr_flac* pFlac, ma_uint64 offset)
+{
+#if 0
+    if (ma_dr_flac__decode_flac_frame(pFlac) != MA_SUCCESS) {
+        if (ma_dr_flac__read_and_decode_next_flac_frame(pFlac) == MA_FALSE) {
+            return MA_FALSE;
+        }
+    }
+#endif
+    return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, offset) == offset;
+}
+static ma_bool32 ma_dr_flac__seek_to_pcm_frame__binary_search_internal(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex, ma_uint64 byteRangeLo, ma_uint64 byteRangeHi)
+{
+    ma_uint64 targetByte;
+    ma_uint64 pcmRangeLo = pFlac->totalPCMFrameCount;
+    ma_uint64 pcmRangeHi = 0;
+    ma_uint64 lastSuccessfulSeekOffset = (ma_uint64)-1;
+    ma_uint64 closestSeekOffsetBeforeTargetPCMFrame = byteRangeLo;
+    ma_uint32 seekForwardThreshold = (pFlac->maxBlockSizeInPCMFrames != 0) ? pFlac->maxBlockSizeInPCMFrames*2 : 4096;
+    targetByte = byteRangeLo + (ma_uint64)(((ma_int64)((pcmFrameIndex - pFlac->currentPCMFrame) * pFlac->channels * pFlac->bitsPerSample)/8.0f) * MA_DR_FLAC_BINARY_SEARCH_APPROX_COMPRESSION_RATIO);
+    if (targetByte > byteRangeHi) {
+        targetByte = byteRangeHi;
+    }
+    for (;;) {
+        if (ma_dr_flac__seek_to_approximate_flac_frame_to_byte(pFlac, targetByte, byteRangeLo, byteRangeHi, &lastSuccessfulSeekOffset)) {
+            ma_uint64 newPCMRangeLo;
+            ma_uint64 newPCMRangeHi;
+            ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &newPCMRangeLo, &newPCMRangeHi);
+            if (pcmRangeLo == newPCMRangeLo) {
+                if (!ma_dr_flac__seek_to_approximate_flac_frame_to_byte(pFlac, closestSeekOffsetBeforeTargetPCMFrame, closestSeekOffsetBeforeTargetPCMFrame, byteRangeHi, &lastSuccessfulSeekOffset)) {
+                    break;
+                }
+                if (ma_dr_flac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame)) {
+                    return MA_TRUE;
+                } else {
+                    break;
+                }
+            }
+            pcmRangeLo = newPCMRangeLo;
+            pcmRangeHi = newPCMRangeHi;
+            if (pcmRangeLo <= pcmFrameIndex && pcmRangeHi >= pcmFrameIndex) {
+                if (ma_dr_flac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame) ) {
+                    return MA_TRUE;
+                } else {
+                    break;
+                }
+            } else {
+                const float approxCompressionRatio = (ma_int64)(lastSuccessfulSeekOffset - pFlac->firstFLACFramePosInBytes) / ((ma_int64)(pcmRangeLo * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+                if (pcmRangeLo > pcmFrameIndex) {
+                    byteRangeHi = lastSuccessfulSeekOffset;
+                    if (byteRangeLo > byteRangeHi) {
+                        byteRangeLo = byteRangeHi;
+                    }
+                    targetByte = byteRangeLo + ((byteRangeHi - byteRangeLo) / 2);
+                    if (targetByte < byteRangeLo) {
+                        targetByte = byteRangeLo;
+                    }
+                } else  {
+                    if ((pcmFrameIndex - pcmRangeLo) < seekForwardThreshold) {
+                        if (ma_dr_flac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame)) {
+                            return MA_TRUE;
+                        } else {
+                            break;
+                        }
+                    } else {
+                        byteRangeLo = lastSuccessfulSeekOffset;
+                        if (byteRangeHi < byteRangeLo) {
+                            byteRangeHi = byteRangeLo;
+                        }
+                        targetByte = lastSuccessfulSeekOffset + (ma_uint64)(((ma_int64)((pcmFrameIndex-pcmRangeLo) * pFlac->channels * pFlac->bitsPerSample)/8.0f) * approxCompressionRatio);
+                        if (targetByte > byteRangeHi) {
+                            targetByte = byteRangeHi;
+                        }
+                        if (closestSeekOffsetBeforeTargetPCMFrame < lastSuccessfulSeekOffset) {
+                            closestSeekOffsetBeforeTargetPCMFrame = lastSuccessfulSeekOffset;
+                        }
+                    }
+                }
+            }
+        } else {
+            break;
+        }
+    }
+    ma_dr_flac__seek_to_first_frame(pFlac);
+    return MA_FALSE;
+}
+static ma_bool32 ma_dr_flac__seek_to_pcm_frame__binary_search(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    ma_uint64 byteRangeLo;
+    ma_uint64 byteRangeHi;
+    ma_uint32 seekForwardThreshold = (pFlac->maxBlockSizeInPCMFrames != 0) ? pFlac->maxBlockSizeInPCMFrames*2 : 4096;
+    if (ma_dr_flac__seek_to_first_frame(pFlac) == MA_FALSE) {
+        return MA_FALSE;
+    }
+    if (pcmFrameIndex < seekForwardThreshold) {
+        return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFrameIndex) == pcmFrameIndex;
+    }
+    byteRangeLo = pFlac->firstFLACFramePosInBytes;
+    byteRangeHi = pFlac->firstFLACFramePosInBytes + (ma_uint64)((ma_int64)(pFlac->totalPCMFrameCount * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+    return ma_dr_flac__seek_to_pcm_frame__binary_search_internal(pFlac, pcmFrameIndex, byteRangeLo, byteRangeHi);
+}
+#endif
+static ma_bool32 ma_dr_flac__seek_to_pcm_frame__seek_table(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    ma_uint32 iClosestSeekpoint = 0;
+    ma_bool32 isMidFrame = MA_FALSE;
+    ma_uint64 runningPCMFrameCount;
+    ma_uint32 iSeekpoint;
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    if (pFlac->pSeekpoints == NULL || pFlac->seekpointCount == 0) {
+        return MA_FALSE;
+    }
+    if (pFlac->pSeekpoints[0].firstPCMFrame > pcmFrameIndex) {
+        return MA_FALSE;
+    }
+    for (iSeekpoint = 0; iSeekpoint < pFlac->seekpointCount; ++iSeekpoint) {
+        if (pFlac->pSeekpoints[iSeekpoint].firstPCMFrame >= pcmFrameIndex) {
+            break;
+        }
+        iClosestSeekpoint = iSeekpoint;
+    }
+    if (pFlac->pSeekpoints[iClosestSeekpoint].pcmFrameCount == 0 || pFlac->pSeekpoints[iClosestSeekpoint].pcmFrameCount > pFlac->maxBlockSizeInPCMFrames) {
+        return MA_FALSE;
+    }
+    if (pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame > pFlac->totalPCMFrameCount && pFlac->totalPCMFrameCount > 0) {
+        return MA_FALSE;
+    }
+#if !defined(MA_DR_FLAC_NO_CRC)
+    if (pFlac->totalPCMFrameCount > 0) {
+        ma_uint64 byteRangeLo;
+        ma_uint64 byteRangeHi;
+        byteRangeHi = pFlac->firstFLACFramePosInBytes + (ma_uint64)((ma_int64)(pFlac->totalPCMFrameCount * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+        byteRangeLo = pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset;
+        if (iClosestSeekpoint < pFlac->seekpointCount-1) {
+            ma_uint32 iNextSeekpoint = iClosestSeekpoint + 1;
+            if (pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset >= pFlac->pSeekpoints[iNextSeekpoint].flacFrameOffset || pFlac->pSeekpoints[iNextSeekpoint].pcmFrameCount == 0) {
+                return MA_FALSE;
+            }
+            if (pFlac->pSeekpoints[iNextSeekpoint].firstPCMFrame != (((ma_uint64)0xFFFFFFFF << 32) | 0xFFFFFFFF)) {
+                byteRangeHi = pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iNextSeekpoint].flacFrameOffset - 1;
+            }
+        }
+        if (ma_dr_flac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset)) {
+            if (ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &pFlac->currentPCMFrame, NULL);
+                if (ma_dr_flac__seek_to_pcm_frame__binary_search_internal(pFlac, pcmFrameIndex, byteRangeLo, byteRangeHi)) {
+                    return MA_TRUE;
+                }
+            }
+        }
+    }
+#endif
+    if (pcmFrameIndex >= pFlac->currentPCMFrame && pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame <= pFlac->currentPCMFrame) {
+        runningPCMFrameCount = pFlac->currentPCMFrame;
+        if (pFlac->currentPCMFrame == 0 && pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                return MA_FALSE;
+            }
+        } else {
+            isMidFrame = MA_TRUE;
+        }
+    } else {
+        runningPCMFrameCount = pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame;
+        if (!ma_dr_flac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+    }
+    for (;;) {
+        ma_uint64 pcmFrameCountInThisFLACFrame;
+        ma_uint64 firstPCMFrameInFLACFrame = 0;
+        ma_uint64 lastPCMFrameInFLACFrame = 0;
+        ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame);
+        pcmFrameCountInThisFLACFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1;
+        if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFLACFrame)) {
+            ma_uint64 pcmFramesToDecode = pcmFrameIndex - runningPCMFrameCount;
+            if (!isMidFrame) {
+                ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+                if (result == MA_SUCCESS) {
+                    return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+                } else {
+                    if (result == MA_CRC_MISMATCH) {
+                        goto next_iteration;
+                    } else {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+            }
+        } else {
+            if (!isMidFrame) {
+                ma_result result = ma_dr_flac__seek_to_next_flac_frame(pFlac);
+                if (result == MA_SUCCESS) {
+                    runningPCMFrameCount += pcmFrameCountInThisFLACFrame;
+                } else {
+                    if (result == MA_CRC_MISMATCH) {
+                        goto next_iteration;
+                    } else {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                runningPCMFrameCount += pFlac->currentFLACFrame.pcmFramesRemaining;
+                pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+                isMidFrame = MA_FALSE;
+            }
+            if (pcmFrameIndex == pFlac->totalPCMFrameCount && runningPCMFrameCount == pFlac->totalPCMFrameCount) {
+                return MA_TRUE;
+            }
+        }
+    next_iteration:
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+    }
+}
+#ifndef MA_DR_FLAC_NO_OGG
+typedef struct
+{
+    ma_uint8 capturePattern[4];
+    ma_uint8 structureVersion;
+    ma_uint8 headerType;
+    ma_uint64 granulePosition;
+    ma_uint32 serialNumber;
+    ma_uint32 sequenceNumber;
+    ma_uint32 checksum;
+    ma_uint8 segmentCount;
+    ma_uint8 segmentTable[255];
+} ma_dr_flac_ogg_page_header;
+#endif
+typedef struct
+{
+    ma_dr_flac_read_proc onRead;
+    ma_dr_flac_seek_proc onSeek;
+    ma_dr_flac_tell_proc onTell;
+    ma_dr_flac_meta_proc onMeta;
+    ma_dr_flac_container container;
+    void* pUserData;
+    void* pUserDataMD;
+    ma_uint32 sampleRate;
+    ma_uint8  channels;
+    ma_uint8  bitsPerSample;
+    ma_uint64 totalPCMFrameCount;
+    ma_uint16 maxBlockSizeInPCMFrames;
+    ma_uint64 runningFilePos;
+    ma_bool32 hasStreamInfoBlock;
+    ma_bool32 hasMetadataBlocks;
+    ma_dr_flac_bs bs;
+    ma_dr_flac_frame_header firstFrameHeader;
+#ifndef MA_DR_FLAC_NO_OGG
+    ma_uint32 oggSerial;
+    ma_uint64 oggFirstBytePos;
+    ma_dr_flac_ogg_page_header oggBosHeader;
+#endif
+} ma_dr_flac_init_info;
+static MA_INLINE void ma_dr_flac__decode_block_header(ma_uint32 blockHeader, ma_uint8* isLastBlock, ma_uint8* blockType, ma_uint32* blockSize)
+{
+    blockHeader = ma_dr_flac__be2host_32(blockHeader);
+    *isLastBlock = (ma_uint8)((blockHeader & 0x80000000UL) >> 31);
+    *blockType   = (ma_uint8)((blockHeader & 0x7F000000UL) >> 24);
+    *blockSize   =                (blockHeader & 0x00FFFFFFUL);
+}
+static MA_INLINE ma_bool32 ma_dr_flac__read_and_decode_block_header(ma_dr_flac_read_proc onRead, void* pUserData, ma_uint8* isLastBlock, ma_uint8* blockType, ma_uint32* blockSize)
+{
+    ma_uint32 blockHeader;
+    *blockSize = 0;
+    if (onRead(pUserData, &blockHeader, 4) != 4) {
+        return MA_FALSE;
+    }
+    ma_dr_flac__decode_block_header(blockHeader, isLastBlock, blockType, blockSize);
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__read_streaminfo(ma_dr_flac_read_proc onRead, void* pUserData, ma_dr_flac_streaminfo* pStreamInfo)
+{
+    ma_uint32 blockSizes;
+    ma_uint64 frameSizes = 0;
+    ma_uint64 importantProps;
+    ma_uint8 md5[16];
+    if (onRead(pUserData, &blockSizes, 4) != 4) {
+        return MA_FALSE;
+    }
+    if (onRead(pUserData, &frameSizes, 6) != 6) {
+        return MA_FALSE;
+    }
+    if (onRead(pUserData, &importantProps, 8) != 8) {
+        return MA_FALSE;
+    }
+    if (onRead(pUserData, md5, sizeof(md5)) != sizeof(md5)) {
+        return MA_FALSE;
+    }
+    blockSizes     = ma_dr_flac__be2host_32(blockSizes);
+    frameSizes     = ma_dr_flac__be2host_64(frameSizes);
+    importantProps = ma_dr_flac__be2host_64(importantProps);
+    pStreamInfo->minBlockSizeInPCMFrames = (ma_uint16)((blockSizes & 0xFFFF0000) >> 16);
+    pStreamInfo->maxBlockSizeInPCMFrames = (ma_uint16) (blockSizes & 0x0000FFFF);
+    pStreamInfo->minFrameSizeInPCMFrames = (ma_uint32)((frameSizes     &  (((ma_uint64)0x00FFFFFF << 16) << 24)) >> 40);
+    pStreamInfo->maxFrameSizeInPCMFrames = (ma_uint32)((frameSizes     &  (((ma_uint64)0x00FFFFFF << 16) <<  0)) >> 16);
+    pStreamInfo->sampleRate              = (ma_uint32)((importantProps &  (((ma_uint64)0x000FFFFF << 16) << 28)) >> 44);
+    pStreamInfo->channels                = (ma_uint8 )((importantProps &  (((ma_uint64)0x0000000E << 16) << 24)) >> 41) + 1;
+    pStreamInfo->bitsPerSample           = (ma_uint8 )((importantProps &  (((ma_uint64)0x0000001F << 16) << 20)) >> 36) + 1;
+    pStreamInfo->totalPCMFrameCount      =                ((importantProps & ((((ma_uint64)0x0000000F << 16) << 16) | 0xFFFFFFFF)));
+    MA_DR_FLAC_COPY_MEMORY(pStreamInfo->md5, md5, sizeof(md5));
+    return MA_TRUE;
+}
+static void* ma_dr_flac__malloc_default(size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_FLAC_MALLOC(sz);
+}
+static void* ma_dr_flac__realloc_default(void* p, size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_FLAC_REALLOC(p, sz);
+}
+static void ma_dr_flac__free_default(void* p, void* pUserData)
+{
+    (void)pUserData;
+    MA_DR_FLAC_FREE(p);
+}
+static void* ma_dr_flac__malloc_from_callbacks(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onMalloc != NULL) {
+        return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData);
+    }
+    return NULL;
+}
+static void* ma_dr_flac__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) {
+        void* p2;
+        p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData);
+        if (p2 == NULL) {
+            return NULL;
+        }
+        if (p != NULL) {
+            MA_DR_FLAC_COPY_MEMORY(p2, p, szOld);
+            pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+        }
+        return p2;
+    }
+    return NULL;
+}
+static void ma_dr_flac__free_from_callbacks(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (p == NULL || pAllocationCallbacks == NULL) {
+        return;
+    }
+    if (pAllocationCallbacks->onFree != NULL) {
+        pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+    }
+}
+static ma_bool32 ma_dr_flac__read_and_decode_metadata(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, ma_dr_flac_meta_proc onMeta, void* pUserData, void* pUserDataMD, ma_uint64* pFirstFramePos, ma_uint64* pSeektablePos, ma_uint32* pSeekpointCount, ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_uint64 runningFilePos = 42;
+    ma_uint64 seektablePos   = 0;
+    ma_uint32 seektableSize  = 0;
+    (void)onTell;
+    for (;;) {
+        ma_dr_flac_metadata metadata;
+        ma_uint8 isLastBlock = 0;
+        ma_uint8 blockType = 0;
+        ma_uint32 blockSize;
+        if (ma_dr_flac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize) == MA_FALSE) {
+            return MA_FALSE;
+        }
+        runningFilePos += 4;
+        metadata.type = blockType;
+        metadata.pRawData = NULL;
+        metadata.rawDataSize = 0;
+        switch (blockType)
+        {
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_APPLICATION:
+            {
+                if (blockSize < 4) {
+                    return MA_FALSE;
+                }
+                if (onMeta) {
+                    void* pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    metadata.data.application.id       = ma_dr_flac__be2host_32(*(ma_uint32*)pRawData);
+                    metadata.data.application.pData    = (const void*)((ma_uint8*)pRawData + sizeof(ma_uint32));
+                    metadata.data.application.dataSize = blockSize - sizeof(ma_uint32);
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_SEEKTABLE:
+            {
+                seektablePos  = runningFilePos;
+                seektableSize = blockSize;
+                if (onMeta) {
+                    ma_uint32 seekpointCount;
+                    ma_uint32 iSeekpoint;
+                    void* pRawData;
+                    seekpointCount = blockSize/MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES;
+                    pRawData = ma_dr_flac__malloc_from_callbacks(seekpointCount * sizeof(ma_dr_flac_seekpoint), pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    for (iSeekpoint = 0; iSeekpoint < seekpointCount; ++iSeekpoint) {
+                        ma_dr_flac_seekpoint* pSeekpoint = (ma_dr_flac_seekpoint*)pRawData + iSeekpoint;
+                        if (onRead(pUserData, pSeekpoint, MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES) != MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES) {
+                            ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                            return MA_FALSE;
+                        }
+                        pSeekpoint->firstPCMFrame   = ma_dr_flac__be2host_64(pSeekpoint->firstPCMFrame);
+                        pSeekpoint->flacFrameOffset = ma_dr_flac__be2host_64(pSeekpoint->flacFrameOffset);
+                        pSeekpoint->pcmFrameCount   = ma_dr_flac__be2host_16(pSeekpoint->pcmFrameCount);
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    metadata.data.seektable.seekpointCount = seekpointCount;
+                    metadata.data.seektable.pSeekpoints = (const ma_dr_flac_seekpoint*)pRawData;
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT:
+            {
+                if (blockSize < 8) {
+                    return MA_FALSE;
+                }
+                if (onMeta) {
+                    void* pRawData;
+                    const char* pRunningData;
+                    const char* pRunningDataEnd;
+                    ma_uint32 i;
+                    pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    pRunningData    = (const char*)pRawData;
+                    pRunningDataEnd = (const char*)pRawData + blockSize;
+                    metadata.data.vorbis_comment.vendorLength = ma_dr_flac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    if ((pRunningDataEnd - pRunningData) - 4 < (ma_int64)metadata.data.vorbis_comment.vendorLength) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.data.vorbis_comment.vendor       = pRunningData;                                            pRunningData += metadata.data.vorbis_comment.vendorLength;
+                    metadata.data.vorbis_comment.commentCount = ma_dr_flac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    if ((pRunningDataEnd - pRunningData) / sizeof(ma_uint32) < metadata.data.vorbis_comment.commentCount) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.data.vorbis_comment.pComments    = pRunningData;
+                    for (i = 0; i < metadata.data.vorbis_comment.commentCount; ++i) {
+                        ma_uint32 commentLength;
+                        if (pRunningDataEnd - pRunningData < 4) {
+                            ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                            return MA_FALSE;
+                        }
+                        commentLength = ma_dr_flac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                        if (pRunningDataEnd - pRunningData < (ma_int64)commentLength) {
+                            ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                            return MA_FALSE;
+                        }
+                        pRunningData += commentLength;
+                    }
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_CUESHEET:
+            {
+                if (blockSize < 396) {
+                    return MA_FALSE;
+                }
+                if (onMeta) {
+                    void* pRawData;
+                    const char* pRunningData;
+                    const char* pRunningDataEnd;
+                    size_t bufferSize;
+                    ma_uint8 iTrack;
+                    ma_uint8 iIndex;
+                    void* pTrackData;
+                    pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    pRunningData    = (const char*)pRawData;
+                    pRunningDataEnd = (const char*)pRawData + blockSize;
+                    MA_DR_FLAC_COPY_MEMORY(metadata.data.cuesheet.catalog, pRunningData, 128);                              pRunningData += 128;
+                    metadata.data.cuesheet.leadInSampleCount = ma_dr_flac__be2host_64(*(const ma_uint64*)pRunningData); pRunningData += 8;
+                    metadata.data.cuesheet.isCD              = (pRunningData[0] & 0x80) != 0;                           pRunningData += 259;
+                    metadata.data.cuesheet.trackCount        = pRunningData[0];                                         pRunningData += 1;
+                    metadata.data.cuesheet.pTrackData        = NULL;
+                    {
+                        const char* pRunningDataSaved = pRunningData;
+                        bufferSize = metadata.data.cuesheet.trackCount * MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES;
+                        for (iTrack = 0; iTrack < metadata.data.cuesheet.trackCount; ++iTrack) {
+                            ma_uint8 indexCount;
+                            ma_uint32 indexPointSize;
+                            if (pRunningDataEnd - pRunningData < MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES) {
+                                ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                                return MA_FALSE;
+                            }
+                            pRunningData += 35;
+                            indexCount = pRunningData[0];
+                            pRunningData += 1;
+                            bufferSize += indexCount * sizeof(ma_dr_flac_cuesheet_track_index);
+                            indexPointSize = indexCount * MA_DR_FLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES;
+                            if (pRunningDataEnd - pRunningData < (ma_int64)indexPointSize) {
+                                ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                                return MA_FALSE;
+                            }
+                            pRunningData += indexPointSize;
+                        }
+                        pRunningData = pRunningDataSaved;
+                    }
+                    {
+                        char* pRunningTrackData;
+                        pTrackData = ma_dr_flac__malloc_from_callbacks(bufferSize, pAllocationCallbacks);
+                        if (pTrackData == NULL) {
+                            ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                            return MA_FALSE;
+                        }
+                        pRunningTrackData = (char*)pTrackData;
+                        for (iTrack = 0; iTrack < metadata.data.cuesheet.trackCount; ++iTrack) {
+                            ma_uint8 indexCount;
+                            MA_DR_FLAC_COPY_MEMORY(pRunningTrackData, pRunningData, MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES);
+                            pRunningData      += MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES-1;
+                            pRunningTrackData += MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES-1;
+                            indexCount = pRunningData[0];
+                            pRunningData      += 1;
+                            pRunningTrackData += 1;
+                            for (iIndex = 0; iIndex < indexCount; ++iIndex) {
+                                ma_dr_flac_cuesheet_track_index* pTrackIndex = (ma_dr_flac_cuesheet_track_index*)pRunningTrackData;
+                                MA_DR_FLAC_COPY_MEMORY(pRunningTrackData, pRunningData, MA_DR_FLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES);
+                                pRunningData      += MA_DR_FLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES;
+                                pRunningTrackData += sizeof(ma_dr_flac_cuesheet_track_index);
+                                pTrackIndex->offset = ma_dr_flac__be2host_64(pTrackIndex->offset);
+                            }
+                        }
+                        metadata.data.cuesheet.pTrackData = pTrackData;
+                    }
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                    pRawData = NULL;
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pTrackData, pAllocationCallbacks);
+                    pTrackData = NULL;
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_PICTURE:
+            {
+                if (blockSize < 32) {
+                    return MA_FALSE;
+                }
+                if (onMeta) {
+                    void* pRawData;
+                    const char* pRunningData;
+                    const char* pRunningDataEnd;
+                    pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    pRunningData    = (const char*)pRawData;
+                    pRunningDataEnd = (const char*)pRawData + blockSize;
+                    metadata.data.picture.type       = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.mimeLength = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    if ((pRunningDataEnd - pRunningData) - 24 < (ma_int64)metadata.data.picture.mimeLength) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.data.picture.mime              = pRunningData;                                   pRunningData += metadata.data.picture.mimeLength;
+                    metadata.data.picture.descriptionLength = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    if ((pRunningDataEnd - pRunningData) - 20 < (ma_int64)metadata.data.picture.descriptionLength) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.data.picture.description     = pRunningData;                                   pRunningData += metadata.data.picture.descriptionLength;
+                    metadata.data.picture.width           = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.height          = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.colorDepth      = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.indexColorCount = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.pictureDataSize = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.pPictureData    = (const ma_uint8*)pRunningData;
+                    if (pRunningDataEnd - pRunningData < (ma_int64)metadata.data.picture.pictureDataSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_PADDING:
+            {
+                if (onMeta) {
+                    metadata.data.padding.unused = 0;
+                    if (!onSeek(pUserData, blockSize, MA_DR_FLAC_SEEK_CUR)) {
+                        isLastBlock = MA_TRUE;
+                    } else {
+                        onMeta(pUserDataMD, &metadata);
+                    }
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_INVALID:
+            {
+                if (onMeta) {
+                    if (!onSeek(pUserData, blockSize, MA_DR_FLAC_SEEK_CUR)) {
+                        isLastBlock = MA_TRUE;
+                    }
+                }
+            } break;
+            default:
+            {
+                if (onMeta) {
+                    void* pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+        }
+        if (onMeta == NULL && blockSize > 0) {
+            if (!onSeek(pUserData, blockSize, MA_DR_FLAC_SEEK_CUR)) {
+                isLastBlock = MA_TRUE;
+            }
+        }
+        runningFilePos += blockSize;
+        if (isLastBlock) {
+            break;
+        }
+    }
+    *pSeektablePos   = seektablePos;
+    *pSeekpointCount = seektableSize / MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES;
+    *pFirstFramePos  = runningFilePos;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__init_private__native(ma_dr_flac_init_info* pInit, ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, void* pUserData, void* pUserDataMD, ma_bool32 relaxed)
+{
+    ma_uint8 isLastBlock;
+    ma_uint8 blockType;
+    ma_uint32 blockSize;
+    (void)onSeek;
+    pInit->container = ma_dr_flac_container_native;
+    if (!ma_dr_flac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize)) {
+        return MA_FALSE;
+    }
+    if (blockType != MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO || blockSize != 34) {
+        if (!relaxed) {
+            return MA_FALSE;
+        } else {
+            pInit->hasStreamInfoBlock = MA_FALSE;
+            pInit->hasMetadataBlocks  = MA_FALSE;
+            if (!ma_dr_flac__read_next_flac_frame_header(&pInit->bs, 0, &pInit->firstFrameHeader)) {
+                return MA_FALSE;
+            }
+            if (pInit->firstFrameHeader.bitsPerSample == 0) {
+                return MA_FALSE;
+            }
+            pInit->sampleRate              = pInit->firstFrameHeader.sampleRate;
+            pInit->channels                = ma_dr_flac__get_channel_count_from_channel_assignment(pInit->firstFrameHeader.channelAssignment);
+            pInit->bitsPerSample           = pInit->firstFrameHeader.bitsPerSample;
+            pInit->maxBlockSizeInPCMFrames = 65535;
+            return MA_TRUE;
+        }
+    } else {
+        ma_dr_flac_streaminfo streaminfo;
+        if (!ma_dr_flac__read_streaminfo(onRead, pUserData, &streaminfo)) {
+            return MA_FALSE;
+        }
+        pInit->hasStreamInfoBlock      = MA_TRUE;
+        pInit->sampleRate              = streaminfo.sampleRate;
+        pInit->channels                = streaminfo.channels;
+        pInit->bitsPerSample           = streaminfo.bitsPerSample;
+        pInit->totalPCMFrameCount      = streaminfo.totalPCMFrameCount;
+        pInit->maxBlockSizeInPCMFrames = streaminfo.maxBlockSizeInPCMFrames;
+        pInit->hasMetadataBlocks       = !isLastBlock;
+        if (onMeta) {
+            ma_dr_flac_metadata metadata;
+            metadata.type = MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO;
+            metadata.pRawData = NULL;
+            metadata.rawDataSize = 0;
+            metadata.data.streaminfo = streaminfo;
+            onMeta(pUserDataMD, &metadata);
+        }
+        return MA_TRUE;
+    }
+}
+#ifndef MA_DR_FLAC_NO_OGG
+#define MA_DR_FLAC_OGG_MAX_PAGE_SIZE            65307
+#define MA_DR_FLAC_OGG_CAPTURE_PATTERN_CRC32    1605413199
+typedef enum
+{
+    ma_dr_flac_ogg_recover_on_crc_mismatch,
+    ma_dr_flac_ogg_fail_on_crc_mismatch
+} ma_dr_flac_ogg_crc_mismatch_recovery;
+#ifndef MA_DR_FLAC_NO_CRC
+static ma_uint32 ma_dr_flac__crc32_table[] = {
+    0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
+    0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
+    0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
+    0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
+    0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
+    0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
+    0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
+    0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
+    0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
+    0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
+    0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
+    0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
+    0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
+    0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
+    0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
+    0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
+    0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
+    0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
+    0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
+    0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
+    0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
+    0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
+    0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
+    0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
+    0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
+    0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
+    0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
+    0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
+    0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
+    0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
+    0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
+    0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
+    0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
+    0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
+    0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
+    0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
+    0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
+    0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
+    0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
+    0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
+    0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
+    0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
+    0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
+    0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
+    0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
+    0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
+    0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
+    0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
+    0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
+    0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
+    0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
+    0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
+    0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
+    0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
+    0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
+    0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
+    0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
+    0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
+    0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
+    0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
+    0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
+    0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
+    0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
+    0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
+};
+#endif
+static MA_INLINE ma_uint32 ma_dr_flac_crc32_byte(ma_uint32 crc32, ma_uint8 data)
+{
+#ifndef MA_DR_FLAC_NO_CRC
+    return (crc32 << 8) ^ ma_dr_flac__crc32_table[(ma_uint8)((crc32 >> 24) & 0xFF) ^ data];
+#else
+    (void)data;
+    return crc32;
+#endif
+}
+#if 0
+static MA_INLINE ma_uint32 ma_dr_flac_crc32_uint32(ma_uint32 crc32, ma_uint32 data)
+{
+    crc32 = ma_dr_flac_crc32_byte(crc32, (ma_uint8)((data >> 24) & 0xFF));
+    crc32 = ma_dr_flac_crc32_byte(crc32, (ma_uint8)((data >> 16) & 0xFF));
+    crc32 = ma_dr_flac_crc32_byte(crc32, (ma_uint8)((data >>  8) & 0xFF));
+    crc32 = ma_dr_flac_crc32_byte(crc32, (ma_uint8)((data >>  0) & 0xFF));
+    return crc32;
+}
+static MA_INLINE ma_uint32 ma_dr_flac_crc32_uint64(ma_uint32 crc32, ma_uint64 data)
+{
+    crc32 = ma_dr_flac_crc32_uint32(crc32, (ma_uint32)((data >> 32) & 0xFFFFFFFF));
+    crc32 = ma_dr_flac_crc32_uint32(crc32, (ma_uint32)((data >>  0) & 0xFFFFFFFF));
+    return crc32;
+}
+#endif
+static MA_INLINE ma_uint32 ma_dr_flac_crc32_buffer(ma_uint32 crc32, ma_uint8* pData, ma_uint32 dataSize)
+{
+    ma_uint32 i;
+    for (i = 0; i < dataSize; ++i) {
+        crc32 = ma_dr_flac_crc32_byte(crc32, pData[i]);
+    }
+    return crc32;
+}
+static MA_INLINE ma_bool32 ma_dr_flac_ogg__is_capture_pattern(ma_uint8 pattern[4])
+{
+    return pattern[0] == 'O' && pattern[1] == 'g' && pattern[2] == 'g' && pattern[3] == 'S';
+}
+static MA_INLINE ma_uint32 ma_dr_flac_ogg__get_page_header_size(ma_dr_flac_ogg_page_header* pHeader)
+{
+    return 27 + pHeader->segmentCount;
+}
+static MA_INLINE ma_uint32 ma_dr_flac_ogg__get_page_body_size(ma_dr_flac_ogg_page_header* pHeader)
+{
+    ma_uint32 pageBodySize = 0;
+    int i;
+    for (i = 0; i < pHeader->segmentCount; ++i) {
+        pageBodySize += pHeader->segmentTable[i];
+    }
+    return pageBodySize;
+}
+static ma_result ma_dr_flac_ogg__read_page_header_after_capture_pattern(ma_dr_flac_read_proc onRead, void* pUserData, ma_dr_flac_ogg_page_header* pHeader, ma_uint32* pBytesRead, ma_uint32* pCRC32)
+{
+    ma_uint8 data[23];
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(*pCRC32 == MA_DR_FLAC_OGG_CAPTURE_PATTERN_CRC32);
+    if (onRead(pUserData, data, 23) != 23) {
+        return MA_AT_END;
+    }
+    *pBytesRead += 23;
+    pHeader->capturePattern[0] = 'O';
+    pHeader->capturePattern[1] = 'g';
+    pHeader->capturePattern[2] = 'g';
+    pHeader->capturePattern[3] = 'S';
+    pHeader->structureVersion = data[0];
+    pHeader->headerType       = data[1];
+    MA_DR_FLAC_COPY_MEMORY(&pHeader->granulePosition, &data[ 2], 8);
+    MA_DR_FLAC_COPY_MEMORY(&pHeader->serialNumber,    &data[10], 4);
+    MA_DR_FLAC_COPY_MEMORY(&pHeader->sequenceNumber,  &data[14], 4);
+    MA_DR_FLAC_COPY_MEMORY(&pHeader->checksum,        &data[18], 4);
+    pHeader->segmentCount     = data[22];
+    data[18] = 0;
+    data[19] = 0;
+    data[20] = 0;
+    data[21] = 0;
+    for (i = 0; i < 23; ++i) {
+        *pCRC32 = ma_dr_flac_crc32_byte(*pCRC32, data[i]);
+    }
+    if (onRead(pUserData, pHeader->segmentTable, pHeader->segmentCount) != pHeader->segmentCount) {
+        return MA_AT_END;
+    }
+    *pBytesRead += pHeader->segmentCount;
+    for (i = 0; i < pHeader->segmentCount; ++i) {
+        *pCRC32 = ma_dr_flac_crc32_byte(*pCRC32, pHeader->segmentTable[i]);
+    }
+    return MA_SUCCESS;
+}
+static ma_result ma_dr_flac_ogg__read_page_header(ma_dr_flac_read_proc onRead, void* pUserData, ma_dr_flac_ogg_page_header* pHeader, ma_uint32* pBytesRead, ma_uint32* pCRC32)
+{
+    ma_uint8 id[4];
+    *pBytesRead = 0;
+    if (onRead(pUserData, id, 4) != 4) {
+        return MA_AT_END;
+    }
+    *pBytesRead += 4;
+    for (;;) {
+        if (ma_dr_flac_ogg__is_capture_pattern(id)) {
+            ma_result result;
+            *pCRC32 = MA_DR_FLAC_OGG_CAPTURE_PATTERN_CRC32;
+            result = ma_dr_flac_ogg__read_page_header_after_capture_pattern(onRead, pUserData, pHeader, pBytesRead, pCRC32);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            } else {
+                if (result == MA_CRC_MISMATCH) {
+                    continue;
+                } else {
+                    return result;
+                }
+            }
+        } else {
+            id[0] = id[1];
+            id[1] = id[2];
+            id[2] = id[3];
+            if (onRead(pUserData, &id[3], 1) != 1) {
+                return MA_AT_END;
+            }
+            *pBytesRead += 1;
+        }
+    }
+}
+typedef struct
+{
+    ma_dr_flac_read_proc onRead;
+    ma_dr_flac_seek_proc onSeek;
+    ma_dr_flac_tell_proc onTell;
+    void* pUserData;
+    ma_uint64 currentBytePos;
+    ma_uint64 firstBytePos;
+    ma_uint32 serialNumber;
+    ma_dr_flac_ogg_page_header bosPageHeader;
+    ma_dr_flac_ogg_page_header currentPageHeader;
+    ma_uint32 bytesRemainingInPage;
+    ma_uint32 pageDataSize;
+    ma_uint8 pageData[MA_DR_FLAC_OGG_MAX_PAGE_SIZE];
+} ma_dr_flac_oggbs;
+static size_t ma_dr_flac_oggbs__read_physical(ma_dr_flac_oggbs* oggbs, void* bufferOut, size_t bytesToRead)
+{
+    size_t bytesActuallyRead = oggbs->onRead(oggbs->pUserData, bufferOut, bytesToRead);
+    oggbs->currentBytePos += bytesActuallyRead;
+    return bytesActuallyRead;
+}
+static ma_bool32 ma_dr_flac_oggbs__seek_physical(ma_dr_flac_oggbs* oggbs, ma_uint64 offset, ma_dr_flac_seek_origin origin)
+{
+    if (origin == MA_DR_FLAC_SEEK_SET) {
+        if (offset <= 0x7FFFFFFF) {
+            if (!oggbs->onSeek(oggbs->pUserData, (int)offset, MA_DR_FLAC_SEEK_SET)) {
+                return MA_FALSE;
+            }
+            oggbs->currentBytePos = offset;
+            return MA_TRUE;
+        } else {
+            if (!oggbs->onSeek(oggbs->pUserData, 0x7FFFFFFF, MA_DR_FLAC_SEEK_SET)) {
+                return MA_FALSE;
+            }
+            oggbs->currentBytePos = offset;
+            return ma_dr_flac_oggbs__seek_physical(oggbs, offset - 0x7FFFFFFF, MA_DR_FLAC_SEEK_CUR);
+        }
+    } else {
+        while (offset > 0x7FFFFFFF) {
+            if (!oggbs->onSeek(oggbs->pUserData, 0x7FFFFFFF, MA_DR_FLAC_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+            oggbs->currentBytePos += 0x7FFFFFFF;
+            offset -= 0x7FFFFFFF;
+        }
+        if (!oggbs->onSeek(oggbs->pUserData, (int)offset, MA_DR_FLAC_SEEK_CUR)) {
+            return MA_FALSE;
+        }
+        oggbs->currentBytePos += offset;
+        return MA_TRUE;
+    }
+}
+static ma_bool32 ma_dr_flac_oggbs__goto_next_page(ma_dr_flac_oggbs* oggbs, ma_dr_flac_ogg_crc_mismatch_recovery recoveryMethod)
+{
+    ma_dr_flac_ogg_page_header header;
+    for (;;) {
+        ma_uint32 crc32 = 0;
+        ma_uint32 bytesRead;
+        ma_uint32 pageBodySize;
+#ifndef MA_DR_FLAC_NO_CRC
+        ma_uint32 actualCRC32;
+#endif
+        if (ma_dr_flac_ogg__read_page_header(oggbs->onRead, oggbs->pUserData, &header, &bytesRead, &crc32) != MA_SUCCESS) {
+            return MA_FALSE;
+        }
+        oggbs->currentBytePos += bytesRead;
+        pageBodySize = ma_dr_flac_ogg__get_page_body_size(&header);
+        if (pageBodySize > MA_DR_FLAC_OGG_MAX_PAGE_SIZE) {
+            continue;
+        }
+        if (header.serialNumber != oggbs->serialNumber) {
+            if (pageBodySize > 0 && !ma_dr_flac_oggbs__seek_physical(oggbs, pageBodySize, MA_DR_FLAC_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+            continue;
+        }
+        if (ma_dr_flac_oggbs__read_physical(oggbs, oggbs->pageData, pageBodySize) != pageBodySize) {
+            return MA_FALSE;
+        }
+        oggbs->pageDataSize = pageBodySize;
+#ifndef MA_DR_FLAC_NO_CRC
+        actualCRC32 = ma_dr_flac_crc32_buffer(crc32, oggbs->pageData, oggbs->pageDataSize);
+        if (actualCRC32 != header.checksum) {
+            if (recoveryMethod == ma_dr_flac_ogg_recover_on_crc_mismatch) {
+                continue;
+            } else {
+                ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_recover_on_crc_mismatch);
+                return MA_FALSE;
+            }
+        }
+#else
+        (void)recoveryMethod;
+#endif
+        oggbs->currentPageHeader = header;
+        oggbs->bytesRemainingInPage = pageBodySize;
+        return MA_TRUE;
+    }
+}
+#if 0
+static ma_uint8 ma_dr_flac_oggbs__get_current_segment_index(ma_dr_flac_oggbs* oggbs, ma_uint8* pBytesRemainingInSeg)
+{
+    ma_uint32 bytesConsumedInPage = ma_dr_flac_ogg__get_page_body_size(&oggbs->currentPageHeader) - oggbs->bytesRemainingInPage;
+    ma_uint8 iSeg = 0;
+    ma_uint32 iByte = 0;
+    while (iByte < bytesConsumedInPage) {
+        ma_uint8 segmentSize = oggbs->currentPageHeader.segmentTable[iSeg];
+        if (iByte + segmentSize > bytesConsumedInPage) {
+            break;
+        } else {
+            iSeg += 1;
+            iByte += segmentSize;
+        }
+    }
+    *pBytesRemainingInSeg = oggbs->currentPageHeader.segmentTable[iSeg] - (ma_uint8)(bytesConsumedInPage - iByte);
+    return iSeg;
+}
+static ma_bool32 ma_dr_flac_oggbs__seek_to_next_packet(ma_dr_flac_oggbs* oggbs)
+{
+    for (;;) {
+        ma_bool32 atEndOfPage = MA_FALSE;
+        ma_uint8 bytesRemainingInSeg;
+        ma_uint8 iFirstSeg = ma_dr_flac_oggbs__get_current_segment_index(oggbs, &bytesRemainingInSeg);
+        ma_uint32 bytesToEndOfPacketOrPage = bytesRemainingInSeg;
+        for (ma_uint8 iSeg = iFirstSeg; iSeg < oggbs->currentPageHeader.segmentCount; ++iSeg) {
+            ma_uint8 segmentSize = oggbs->currentPageHeader.segmentTable[iSeg];
+            if (segmentSize < 255) {
+                if (iSeg == oggbs->currentPageHeader.segmentCount-1) {
+                    atEndOfPage = MA_TRUE;
+                }
+                break;
+            }
+            bytesToEndOfPacketOrPage += segmentSize;
+        }
+        ma_dr_flac_oggbs__seek_physical(oggbs, bytesToEndOfPacketOrPage, MA_DR_FLAC_SEEK_CUR);
+        oggbs->bytesRemainingInPage -= bytesToEndOfPacketOrPage;
+        if (atEndOfPage) {
+            if (!ma_dr_flac_oggbs__goto_next_page(oggbs)) {
+                return MA_FALSE;
+            }
+            if ((oggbs->currentPageHeader.headerType & 0x01) == 0) {
+                return MA_TRUE;
+            }
+        } else {
+            return MA_TRUE;
+        }
+    }
+}
+static ma_bool32 ma_dr_flac_oggbs__seek_to_next_frame(ma_dr_flac_oggbs* oggbs)
+{
+    return ma_dr_flac_oggbs__seek_to_next_packet(oggbs);
+}
+#endif
+static size_t ma_dr_flac__on_read_ogg(void* pUserData, void* bufferOut, size_t bytesToRead)
+{
+    ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pUserData;
+    ma_uint8* pRunningBufferOut = (ma_uint8*)bufferOut;
+    size_t bytesRead = 0;
+    MA_DR_FLAC_ASSERT(oggbs != NULL);
+    MA_DR_FLAC_ASSERT(pRunningBufferOut != NULL);
+    while (bytesRead < bytesToRead) {
+        size_t bytesRemainingToRead = bytesToRead - bytesRead;
+        if (oggbs->bytesRemainingInPage >= bytesRemainingToRead) {
+            MA_DR_FLAC_COPY_MEMORY(pRunningBufferOut, oggbs->pageData + (oggbs->pageDataSize - oggbs->bytesRemainingInPage), bytesRemainingToRead);
+            bytesRead += bytesRemainingToRead;
+            oggbs->bytesRemainingInPage -= (ma_uint32)bytesRemainingToRead;
+            break;
+        }
+        if (oggbs->bytesRemainingInPage > 0) {
+            MA_DR_FLAC_COPY_MEMORY(pRunningBufferOut, oggbs->pageData + (oggbs->pageDataSize - oggbs->bytesRemainingInPage), oggbs->bytesRemainingInPage);
+            bytesRead += oggbs->bytesRemainingInPage;
+            pRunningBufferOut += oggbs->bytesRemainingInPage;
+            oggbs->bytesRemainingInPage = 0;
+        }
+        MA_DR_FLAC_ASSERT(bytesRemainingToRead > 0);
+        if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_recover_on_crc_mismatch)) {
+            break;
+        }
+    }
+    return bytesRead;
+}
+static ma_bool32 ma_dr_flac__on_seek_ogg(void* pUserData, int offset, ma_dr_flac_seek_origin origin)
+{
+    ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pUserData;
+    int bytesSeeked = 0;
+    MA_DR_FLAC_ASSERT(oggbs != NULL);
+    MA_DR_FLAC_ASSERT(offset >= 0);
+    if (origin == MA_DR_FLAC_SEEK_SET) {
+        if (!ma_dr_flac_oggbs__seek_physical(oggbs, (int)oggbs->firstBytePos, MA_DR_FLAC_SEEK_SET)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_fail_on_crc_mismatch)) {
+            return MA_FALSE;
+        }
+        return ma_dr_flac__on_seek_ogg(pUserData, offset, MA_DR_FLAC_SEEK_CUR);
+    } else if (origin == MA_DR_FLAC_SEEK_CUR) {
+        while (bytesSeeked < offset) {
+            int bytesRemainingToSeek = offset - bytesSeeked;
+            MA_DR_FLAC_ASSERT(bytesRemainingToSeek >= 0);
+            if (oggbs->bytesRemainingInPage >= (size_t)bytesRemainingToSeek) {
+                bytesSeeked += bytesRemainingToSeek;
+                (void)bytesSeeked;
+                oggbs->bytesRemainingInPage -= bytesRemainingToSeek;
+                break;
+            }
+            if (oggbs->bytesRemainingInPage > 0) {
+                bytesSeeked += (int)oggbs->bytesRemainingInPage;
+                oggbs->bytesRemainingInPage = 0;
+            }
+            MA_DR_FLAC_ASSERT(bytesRemainingToSeek > 0);
+            if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_fail_on_crc_mismatch)) {
+                return MA_FALSE;
+            }
+        }
+    } else if (origin == MA_DR_FLAC_SEEK_END) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__on_tell_ogg(void* pUserData, ma_int64* pCursor)
+{
+    (void)pUserData;
+    (void)pCursor;
+    return MA_FALSE;
+}
+static ma_bool32 ma_dr_flac_ogg__seek_to_pcm_frame(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pFlac->_oggbs;
+    ma_uint64 originalBytePos;
+    ma_uint64 runningGranulePosition;
+    ma_uint64 runningFrameBytePos;
+    ma_uint64 runningPCMFrameCount;
+    MA_DR_FLAC_ASSERT(oggbs != NULL);
+    originalBytePos = oggbs->currentBytePos;
+    if (!ma_dr_flac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes)) {
+        return MA_FALSE;
+    }
+    oggbs->bytesRemainingInPage = 0;
+    runningGranulePosition = 0;
+    for (;;) {
+        if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_recover_on_crc_mismatch)) {
+            ma_dr_flac_oggbs__seek_physical(oggbs, originalBytePos, MA_DR_FLAC_SEEK_SET);
+            return MA_FALSE;
+        }
+        runningFrameBytePos = oggbs->currentBytePos - ma_dr_flac_ogg__get_page_header_size(&oggbs->currentPageHeader) - oggbs->pageDataSize;
+        if (oggbs->currentPageHeader.granulePosition >= pcmFrameIndex) {
+            break;
+        }
+        if ((oggbs->currentPageHeader.headerType & 0x01) == 0) {
+            if (oggbs->currentPageHeader.segmentTable[0] >= 2) {
+                ma_uint8 firstBytesInPage[2];
+                firstBytesInPage[0] = oggbs->pageData[0];
+                firstBytesInPage[1] = oggbs->pageData[1];
+                if ((firstBytesInPage[0] == 0xFF) && (firstBytesInPage[1] & 0xFC) == 0xF8) {
+                    runningGranulePosition = oggbs->currentPageHeader.granulePosition;
+                }
+                continue;
+            }
+        }
+    }
+    if (!ma_dr_flac_oggbs__seek_physical(oggbs, runningFrameBytePos, MA_DR_FLAC_SEEK_SET)) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_recover_on_crc_mismatch)) {
+        return MA_FALSE;
+    }
+    runningPCMFrameCount = runningGranulePosition;
+    for (;;) {
+        ma_uint64 firstPCMFrameInFLACFrame = 0;
+        ma_uint64 lastPCMFrameInFLACFrame = 0;
+        ma_uint64 pcmFrameCountInThisFrame;
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+        ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame);
+        pcmFrameCountInThisFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1;
+        if (pcmFrameIndex == pFlac->totalPCMFrameCount && (runningPCMFrameCount + pcmFrameCountInThisFrame) == pFlac->totalPCMFrameCount) {
+            ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+            if (result == MA_SUCCESS) {
+                pFlac->currentPCMFrame = pcmFrameIndex;
+                pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+                return MA_TRUE;
+            } else {
+                return MA_FALSE;
+            }
+        }
+        if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFrame)) {
+            ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+            if (result == MA_SUCCESS) {
+                ma_uint64 pcmFramesToDecode = (size_t)(pcmFrameIndex - runningPCMFrameCount);
+                if (pcmFramesToDecode == 0) {
+                    return MA_TRUE;
+                }
+                pFlac->currentPCMFrame = runningPCMFrameCount;
+                return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+            } else {
+                if (result == MA_CRC_MISMATCH) {
+                    continue;
+                } else {
+                    return MA_FALSE;
+                }
+            }
+        } else {
+            ma_result result = ma_dr_flac__seek_to_next_flac_frame(pFlac);
+            if (result == MA_SUCCESS) {
+                runningPCMFrameCount += pcmFrameCountInThisFrame;
+            } else {
+                if (result == MA_CRC_MISMATCH) {
+                    continue;
+                } else {
+                    return MA_FALSE;
+                }
+            }
+        }
+    }
+}
+static ma_bool32 ma_dr_flac__init_private__ogg(ma_dr_flac_init_info* pInit, ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, void* pUserData, void* pUserDataMD, ma_bool32 relaxed)
+{
+    ma_dr_flac_ogg_page_header header;
+    ma_uint32 crc32 = MA_DR_FLAC_OGG_CAPTURE_PATTERN_CRC32;
+    ma_uint32 bytesRead = 0;
+    (void)relaxed;
+    pInit->container = ma_dr_flac_container_ogg;
+    pInit->oggFirstBytePos = 0;
+    if (ma_dr_flac_ogg__read_page_header_after_capture_pattern(onRead, pUserData, &header, &bytesRead, &crc32) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    pInit->runningFilePos += bytesRead;
+    for (;;) {
+        int pageBodySize;
+        if ((header.headerType & 0x02) == 0) {
+            return MA_FALSE;
+        }
+        pageBodySize = ma_dr_flac_ogg__get_page_body_size(&header);
+        if (pageBodySize == 51) {
+            ma_uint32 bytesRemainingInPage = pageBodySize;
+            ma_uint8 packetType;
+            if (onRead(pUserData, &packetType, 1) != 1) {
+                return MA_FALSE;
+            }
+            bytesRemainingInPage -= 1;
+            if (packetType == 0x7F) {
+                ma_uint8 sig[4];
+                if (onRead(pUserData, sig, 4) != 4) {
+                    return MA_FALSE;
+                }
+                bytesRemainingInPage -= 4;
+                if (sig[0] == 'F' && sig[1] == 'L' && sig[2] == 'A' && sig[3] == 'C') {
+                    ma_uint8 mappingVersion[2];
+                    if (onRead(pUserData, mappingVersion, 2) != 2) {
+                        return MA_FALSE;
+                    }
+                    if (mappingVersion[0] != 1) {
+                        return MA_FALSE;
+                    }
+                    if (!onSeek(pUserData, 2, MA_DR_FLAC_SEEK_CUR)) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, sig, 4) != 4) {
+                        return MA_FALSE;
+                    }
+                    if (sig[0] == 'f' && sig[1] == 'L' && sig[2] == 'a' && sig[3] == 'C') {
+                        ma_dr_flac_streaminfo streaminfo;
+                        ma_uint8 isLastBlock;
+                        ma_uint8 blockType;
+                        ma_uint32 blockSize;
+                        if (!ma_dr_flac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize)) {
+                            return MA_FALSE;
+                        }
+                        if (blockType != MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO || blockSize != 34) {
+                            return MA_FALSE;
+                        }
+                        if (ma_dr_flac__read_streaminfo(onRead, pUserData, &streaminfo)) {
+                            pInit->hasStreamInfoBlock      = MA_TRUE;
+                            pInit->sampleRate              = streaminfo.sampleRate;
+                            pInit->channels                = streaminfo.channels;
+                            pInit->bitsPerSample           = streaminfo.bitsPerSample;
+                            pInit->totalPCMFrameCount      = streaminfo.totalPCMFrameCount;
+                            pInit->maxBlockSizeInPCMFrames = streaminfo.maxBlockSizeInPCMFrames;
+                            pInit->hasMetadataBlocks       = !isLastBlock;
+                            if (onMeta) {
+                                ma_dr_flac_metadata metadata;
+                                metadata.type = MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO;
+                                metadata.pRawData = NULL;
+                                metadata.rawDataSize = 0;
+                                metadata.data.streaminfo = streaminfo;
+                                onMeta(pUserDataMD, &metadata);
+                            }
+                            pInit->runningFilePos  += pageBodySize;
+                            pInit->oggFirstBytePos  = pInit->runningFilePos - 79;
+                            pInit->oggSerial        = header.serialNumber;
+                            pInit->oggBosHeader     = header;
+                            break;
+                        } else {
+                            return MA_FALSE;
+                        }
+                    } else {
+                        return MA_FALSE;
+                    }
+                } else {
+                    if (!onSeek(pUserData, bytesRemainingInPage, MA_DR_FLAC_SEEK_CUR)) {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                if (!onSeek(pUserData, bytesRemainingInPage, MA_DR_FLAC_SEEK_CUR)) {
+                    return MA_FALSE;
+                }
+            }
+        } else {
+            if (!onSeek(pUserData, pageBodySize, MA_DR_FLAC_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+        }
+        pInit->runningFilePos += pageBodySize;
+        if (ma_dr_flac_ogg__read_page_header(onRead, pUserData, &header, &bytesRead, &crc32) != MA_SUCCESS) {
+            return MA_FALSE;
+        }
+        pInit->runningFilePos += bytesRead;
+    }
+    pInit->hasMetadataBlocks = MA_TRUE;
+    return MA_TRUE;
+}
+#endif
+static ma_bool32 ma_dr_flac__init_private(ma_dr_flac_init_info* pInit, ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, ma_dr_flac_meta_proc onMeta, ma_dr_flac_container container, void* pUserData, void* pUserDataMD)
+{
+    ma_bool32 relaxed;
+    ma_uint8 id[4];
+    if (pInit == NULL || onRead == NULL || onSeek == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_FLAC_ZERO_MEMORY(pInit, sizeof(*pInit));
+    pInit->onRead       = onRead;
+    pInit->onSeek       = onSeek;
+    pInit->onTell       = onTell;
+    pInit->onMeta       = onMeta;
+    pInit->container    = container;
+    pInit->pUserData    = pUserData;
+    pInit->pUserDataMD  = pUserDataMD;
+    pInit->bs.onRead    = onRead;
+    pInit->bs.onSeek    = onSeek;
+    pInit->bs.onTell    = onTell;
+    pInit->bs.pUserData = pUserData;
+    ma_dr_flac__reset_cache(&pInit->bs);
+    relaxed = container != ma_dr_flac_container_unknown;
+    for (;;) {
+        if (onRead(pUserData, id, 4) != 4) {
+            return MA_FALSE;
+        }
+        pInit->runningFilePos += 4;
+        if (id[0] == 'I' && id[1] == 'D' && id[2] == '3') {
+            ma_uint8 header[6];
+            ma_uint8 flags;
+            ma_uint32 headerSize;
+            if (onRead(pUserData, header, 6) != 6) {
+                return MA_FALSE;
+            }
+            pInit->runningFilePos += 6;
+            flags = header[1];
+            MA_DR_FLAC_COPY_MEMORY(&headerSize, header+2, 4);
+            headerSize = ma_dr_flac__unsynchsafe_32(ma_dr_flac__be2host_32(headerSize));
+            if (flags & 0x10) {
+                headerSize += 10;
+            }
+            if (!onSeek(pUserData, headerSize, MA_DR_FLAC_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+            pInit->runningFilePos += headerSize;
+        } else {
+            break;
+        }
+    }
+    if (id[0] == 'f' && id[1] == 'L' && id[2] == 'a' && id[3] == 'C') {
+        return ma_dr_flac__init_private__native(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+    }
+#ifndef MA_DR_FLAC_NO_OGG
+    if (id[0] == 'O' && id[1] == 'g' && id[2] == 'g' && id[3] == 'S') {
+        return ma_dr_flac__init_private__ogg(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+    }
+#endif
+    if (relaxed) {
+        if (container == ma_dr_flac_container_native) {
+            return ma_dr_flac__init_private__native(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+        }
+#ifndef MA_DR_FLAC_NO_OGG
+        if (container == ma_dr_flac_container_ogg) {
+            return ma_dr_flac__init_private__ogg(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+        }
+#endif
+    }
+    return MA_FALSE;
+}
+static void ma_dr_flac__init_from_info(ma_dr_flac* pFlac, const ma_dr_flac_init_info* pInit)
+{
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    MA_DR_FLAC_ASSERT(pInit != NULL);
+    MA_DR_FLAC_ZERO_MEMORY(pFlac, sizeof(*pFlac));
+    pFlac->bs                      = pInit->bs;
+    pFlac->onMeta                  = pInit->onMeta;
+    pFlac->pUserDataMD             = pInit->pUserDataMD;
+    pFlac->maxBlockSizeInPCMFrames = pInit->maxBlockSizeInPCMFrames;
+    pFlac->sampleRate              = pInit->sampleRate;
+    pFlac->channels                = (ma_uint8)pInit->channels;
+    pFlac->bitsPerSample           = (ma_uint8)pInit->bitsPerSample;
+    pFlac->totalPCMFrameCount      = pInit->totalPCMFrameCount;
+    pFlac->container               = pInit->container;
+}
+static ma_dr_flac* ma_dr_flac_open_with_metadata_private(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, ma_dr_flac_meta_proc onMeta, ma_dr_flac_container container, void* pUserData, void* pUserDataMD, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac_init_info init;
+    ma_uint32 allocationSize;
+    ma_uint32 wholeSIMDVectorCountPerChannel;
+    ma_uint32 decodedSamplesAllocationSize;
+#ifndef MA_DR_FLAC_NO_OGG
+    ma_dr_flac_oggbs* pOggbs = NULL;
+#endif
+    ma_uint64 firstFramePos;
+    ma_uint64 seektablePos;
+    ma_uint32 seekpointCount;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_dr_flac* pFlac;
+    ma_dr_flac__init_cpu_caps();
+    if (!ma_dr_flac__init_private(&init, onRead, onSeek, onTell, onMeta, container, pUserData, pUserDataMD)) {
+        return NULL;
+    }
+    if (pAllocationCallbacks != NULL) {
+        allocationCallbacks = *pAllocationCallbacks;
+        if (allocationCallbacks.onFree == NULL || (allocationCallbacks.onMalloc == NULL && allocationCallbacks.onRealloc == NULL)) {
+            return NULL;
+        }
+    } else {
+        allocationCallbacks.pUserData = NULL;
+        allocationCallbacks.onMalloc  = ma_dr_flac__malloc_default;
+        allocationCallbacks.onRealloc = ma_dr_flac__realloc_default;
+        allocationCallbacks.onFree    = ma_dr_flac__free_default;
+    }
+    allocationSize = sizeof(ma_dr_flac);
+    if ((init.maxBlockSizeInPCMFrames % (MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE / sizeof(ma_int32))) == 0) {
+        wholeSIMDVectorCountPerChannel = (init.maxBlockSizeInPCMFrames / (MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE / sizeof(ma_int32)));
+    } else {
+        wholeSIMDVectorCountPerChannel = (init.maxBlockSizeInPCMFrames / (MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE / sizeof(ma_int32))) + 1;
+    }
+    decodedSamplesAllocationSize = wholeSIMDVectorCountPerChannel * MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE * init.channels;
+    allocationSize += decodedSamplesAllocationSize;
+    allocationSize += MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE;
+#ifndef MA_DR_FLAC_NO_OGG
+    if (init.container == ma_dr_flac_container_ogg) {
+        allocationSize += sizeof(ma_dr_flac_oggbs);
+        pOggbs = (ma_dr_flac_oggbs*)ma_dr_flac__malloc_from_callbacks(sizeof(*pOggbs), &allocationCallbacks);
+        if (pOggbs == NULL) {
+            return NULL;
+        }
+        MA_DR_FLAC_ZERO_MEMORY(pOggbs, sizeof(*pOggbs));
+        pOggbs->onRead = onRead;
+        pOggbs->onSeek = onSeek;
+        pOggbs->onTell = onTell;
+        pOggbs->pUserData = pUserData;
+        pOggbs->currentBytePos = init.oggFirstBytePos;
+        pOggbs->firstBytePos = init.oggFirstBytePos;
+        pOggbs->serialNumber = init.oggSerial;
+        pOggbs->bosPageHeader = init.oggBosHeader;
+        pOggbs->bytesRemainingInPage = 0;
+    }
+#endif
+    firstFramePos  = 42;
+    seektablePos   = 0;
+    seekpointCount = 0;
+    if (init.hasMetadataBlocks) {
+        ma_dr_flac_read_proc onReadOverride = onRead;
+        ma_dr_flac_seek_proc onSeekOverride = onSeek;
+        ma_dr_flac_tell_proc onTellOverride = onTell;
+        void* pUserDataOverride = pUserData;
+#ifndef MA_DR_FLAC_NO_OGG
+        if (init.container == ma_dr_flac_container_ogg) {
+            onReadOverride = ma_dr_flac__on_read_ogg;
+            onSeekOverride = ma_dr_flac__on_seek_ogg;
+            onTellOverride = ma_dr_flac__on_tell_ogg;
+            pUserDataOverride = (void*)pOggbs;
+        }
+#endif
+        if (!ma_dr_flac__read_and_decode_metadata(onReadOverride, onSeekOverride, onTellOverride, onMeta, pUserDataOverride, pUserDataMD, &firstFramePos, &seektablePos, &seekpointCount, &allocationCallbacks)) {
+        #ifndef MA_DR_FLAC_NO_OGG
+            ma_dr_flac__free_from_callbacks(pOggbs, &allocationCallbacks);
+        #endif
+            return NULL;
+        }
+        allocationSize += seekpointCount * sizeof(ma_dr_flac_seekpoint);
+    }
+    pFlac = (ma_dr_flac*)ma_dr_flac__malloc_from_callbacks(allocationSize, &allocationCallbacks);
+    if (pFlac == NULL) {
+    #ifndef MA_DR_FLAC_NO_OGG
+        ma_dr_flac__free_from_callbacks(pOggbs, &allocationCallbacks);
+    #endif
+        return NULL;
+    }
+    ma_dr_flac__init_from_info(pFlac, &init);
+    pFlac->allocationCallbacks = allocationCallbacks;
+    pFlac->pDecodedSamples = (ma_int32*)ma_dr_flac_align((size_t)pFlac->pExtraData, MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE);
+#ifndef MA_DR_FLAC_NO_OGG
+    if (init.container == ma_dr_flac_container_ogg) {
+        ma_dr_flac_oggbs* pInternalOggbs = (ma_dr_flac_oggbs*)((ma_uint8*)pFlac->pDecodedSamples + decodedSamplesAllocationSize + (seekpointCount * sizeof(ma_dr_flac_seekpoint)));
+        MA_DR_FLAC_COPY_MEMORY(pInternalOggbs, pOggbs, sizeof(*pOggbs));
+        ma_dr_flac__free_from_callbacks(pOggbs, &allocationCallbacks);
+        pOggbs = NULL;
+        pFlac->bs.onRead = ma_dr_flac__on_read_ogg;
+        pFlac->bs.onSeek = ma_dr_flac__on_seek_ogg;
+        pFlac->bs.onTell = ma_dr_flac__on_tell_ogg;
+        pFlac->bs.pUserData = (void*)pInternalOggbs;
+        pFlac->_oggbs = (void*)pInternalOggbs;
+    }
+#endif
+    pFlac->firstFLACFramePosInBytes = firstFramePos;
+#ifndef MA_DR_FLAC_NO_OGG
+    if (init.container == ma_dr_flac_container_ogg)
+    {
+        pFlac->pSeekpoints = NULL;
+        pFlac->seekpointCount = 0;
+    }
+    else
+#endif
+    {
+        if (seektablePos != 0) {
+            pFlac->seekpointCount = seekpointCount;
+            pFlac->pSeekpoints = (ma_dr_flac_seekpoint*)((ma_uint8*)pFlac->pDecodedSamples + decodedSamplesAllocationSize);
+            MA_DR_FLAC_ASSERT(pFlac->bs.onSeek != NULL);
+            MA_DR_FLAC_ASSERT(pFlac->bs.onRead != NULL);
+            if (pFlac->bs.onSeek(pFlac->bs.pUserData, (int)seektablePos, MA_DR_FLAC_SEEK_SET)) {
+                ma_uint32 iSeekpoint;
+                for (iSeekpoint = 0; iSeekpoint < seekpointCount; iSeekpoint += 1) {
+                    if (pFlac->bs.onRead(pFlac->bs.pUserData, pFlac->pSeekpoints + iSeekpoint, MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES) == MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES) {
+                        pFlac->pSeekpoints[iSeekpoint].firstPCMFrame   = ma_dr_flac__be2host_64(pFlac->pSeekpoints[iSeekpoint].firstPCMFrame);
+                        pFlac->pSeekpoints[iSeekpoint].flacFrameOffset = ma_dr_flac__be2host_64(pFlac->pSeekpoints[iSeekpoint].flacFrameOffset);
+                        pFlac->pSeekpoints[iSeekpoint].pcmFrameCount   = ma_dr_flac__be2host_16(pFlac->pSeekpoints[iSeekpoint].pcmFrameCount);
+                    } else {
+                        pFlac->pSeekpoints = NULL;
+                        pFlac->seekpointCount = 0;
+                        break;
+                    }
+                }
+                if (!pFlac->bs.onSeek(pFlac->bs.pUserData, (int)pFlac->firstFLACFramePosInBytes, MA_DR_FLAC_SEEK_SET)) {
+                    ma_dr_flac__free_from_callbacks(pFlac, &allocationCallbacks);
+                    return NULL;
+                }
+            } else {
+                pFlac->pSeekpoints = NULL;
+                pFlac->seekpointCount = 0;
+            }
+        }
+    }
+    if (!init.hasStreamInfoBlock) {
+        pFlac->currentFLACFrame.header = init.firstFrameHeader;
+        for (;;) {
+            ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+            if (result == MA_SUCCESS) {
+                break;
+            } else {
+                if (result == MA_CRC_MISMATCH) {
+                    if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                        ma_dr_flac__free_from_callbacks(pFlac, &allocationCallbacks);
+                        return NULL;
+                    }
+                    continue;
+                } else {
+                    ma_dr_flac__free_from_callbacks(pFlac, &allocationCallbacks);
+                    return NULL;
+                }
+            }
+        }
+    }
+    return pFlac;
+}
+#ifndef MA_DR_FLAC_NO_STDIO
+#include <stdio.h>
+#ifndef MA_DR_FLAC_NO_WCHAR
+#include <wchar.h>
+#endif
+static size_t ma_dr_flac__on_read_stdio(void* pUserData, void* bufferOut, size_t bytesToRead)
+{
+    return fread(bufferOut, 1, bytesToRead, (FILE*)pUserData);
+}
+static ma_bool32 ma_dr_flac__on_seek_stdio(void* pUserData, int offset, ma_dr_flac_seek_origin origin)
+{
+    int whence = SEEK_SET;
+    if (origin == MA_DR_FLAC_SEEK_CUR) {
+        whence = SEEK_CUR;
+    } else if (origin == MA_DR_FLAC_SEEK_END) {
+        whence = SEEK_END;
+    }
+    return fseek((FILE*)pUserData, offset, whence) == 0;
+}
+static ma_bool32 ma_dr_flac__on_tell_stdio(void* pUserData, ma_int64* pCursor)
+{
+    FILE* pFileStdio = (FILE*)pUserData;
+    ma_int64 result;
+    MA_DR_FLAC_ASSERT(pFileStdio != NULL);
+    MA_DR_FLAC_ASSERT(pCursor    != NULL);
+#if defined(_WIN32) && !defined(NXDK)
+    #if defined(_MSC_VER) && _MSC_VER > 1200
+        result = _ftelli64(pFileStdio);
+    #else
+        result = ftell(pFileStdio);
+    #endif
+#else
+    result = ftell(pFileStdio);
+#endif
+    *pCursor = result;
+    return MA_TRUE;
+}
+MA_API ma_dr_flac* ma_dr_flac_open_file(const char* pFileName, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    FILE* pFile;
+    if (ma_fopen(&pFile, pFileName, "rb") != MA_SUCCESS) {
+        return NULL;
+    }
+    pFlac = ma_dr_flac_open(ma_dr_flac__on_read_stdio, ma_dr_flac__on_seek_stdio, ma_dr_flac__on_tell_stdio, (void*)pFile, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        fclose(pFile);
+        return NULL;
+    }
+    return pFlac;
+}
+#ifndef MA_DR_FLAC_NO_WCHAR
+MA_API ma_dr_flac* ma_dr_flac_open_file_w(const wchar_t* pFileName, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    FILE* pFile;
+    if (ma_wfopen(&pFile, pFileName, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return NULL;
+    }
+    pFlac = ma_dr_flac_open(ma_dr_flac__on_read_stdio, ma_dr_flac__on_seek_stdio, ma_dr_flac__on_tell_stdio, (void*)pFile, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        fclose(pFile);
+        return NULL;
+    }
+    return pFlac;
+}
+#endif
+MA_API ma_dr_flac* ma_dr_flac_open_file_with_metadata(const char* pFileName, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    FILE* pFile;
+    if (ma_fopen(&pFile, pFileName, "rb") != MA_SUCCESS) {
+        return NULL;
+    }
+    pFlac = ma_dr_flac_open_with_metadata_private(ma_dr_flac__on_read_stdio, ma_dr_flac__on_seek_stdio, ma_dr_flac__on_tell_stdio, onMeta, ma_dr_flac_container_unknown, (void*)pFile, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        fclose(pFile);
+        return pFlac;
+    }
+    return pFlac;
+}
+#ifndef MA_DR_FLAC_NO_WCHAR
+MA_API ma_dr_flac* ma_dr_flac_open_file_with_metadata_w(const wchar_t* pFileName, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    FILE* pFile;
+    if (ma_wfopen(&pFile, pFileName, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return NULL;
+    }
+    pFlac = ma_dr_flac_open_with_metadata_private(ma_dr_flac__on_read_stdio, ma_dr_flac__on_seek_stdio, ma_dr_flac__on_tell_stdio, onMeta, ma_dr_flac_container_unknown, (void*)pFile, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        fclose(pFile);
+        return pFlac;
+    }
+    return pFlac;
+}
+#endif
+#endif
+static size_t ma_dr_flac__on_read_memory(void* pUserData, void* bufferOut, size_t bytesToRead)
+{
+    ma_dr_flac__memory_stream* memoryStream = (ma_dr_flac__memory_stream*)pUserData;
+    size_t bytesRemaining;
+    MA_DR_FLAC_ASSERT(memoryStream != NULL);
+    MA_DR_FLAC_ASSERT(memoryStream->dataSize >= memoryStream->currentReadPos);
+    bytesRemaining = memoryStream->dataSize - memoryStream->currentReadPos;
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+    if (bytesToRead > 0) {
+        MA_DR_FLAC_COPY_MEMORY(bufferOut, memoryStream->data + memoryStream->currentReadPos, bytesToRead);
+        memoryStream->currentReadPos += bytesToRead;
+    }
+    return bytesToRead;
+}
+static ma_bool32 ma_dr_flac__on_seek_memory(void* pUserData, int offset, ma_dr_flac_seek_origin origin)
+{
+    ma_dr_flac__memory_stream* memoryStream = (ma_dr_flac__memory_stream*)pUserData;
+    ma_int64 newCursor;
+    MA_DR_FLAC_ASSERT(memoryStream != NULL);
+    newCursor = memoryStream->currentReadPos;
+    if (origin == MA_DR_FLAC_SEEK_SET) {
+        newCursor = 0;
+    } else if (origin == MA_DR_FLAC_SEEK_CUR) {
+        newCursor = (ma_int64)memoryStream->currentReadPos;
+    } else if (origin == MA_DR_FLAC_SEEK_END) {
+        newCursor = (ma_int64)memoryStream->dataSize;
+    } else {
+        MA_DR_FLAC_ASSERT(!"Invalid seek origin");
+        return MA_FALSE;
+    }
+    newCursor += offset;
+    if (newCursor < 0) {
+        return MA_FALSE;
+    }
+    if ((size_t)newCursor > memoryStream->dataSize) {
+        return MA_FALSE;
+    }
+    memoryStream->currentReadPos = (size_t)newCursor;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__on_tell_memory(void* pUserData, ma_int64* pCursor)
+{
+    ma_dr_flac__memory_stream* memoryStream = (ma_dr_flac__memory_stream*)pUserData;
+    MA_DR_FLAC_ASSERT(memoryStream != NULL);
+    MA_DR_FLAC_ASSERT(pCursor != NULL);
+    *pCursor = (ma_int64)memoryStream->currentReadPos;
+    return MA_TRUE;
+}
+MA_API ma_dr_flac* ma_dr_flac_open_memory(const void* pData, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac__memory_stream memoryStream;
+    ma_dr_flac* pFlac;
+    memoryStream.data = (const ma_uint8*)pData;
+    memoryStream.dataSize = dataSize;
+    memoryStream.currentReadPos = 0;
+    pFlac = ma_dr_flac_open(ma_dr_flac__on_read_memory, ma_dr_flac__on_seek_memory, ma_dr_flac__on_tell_memory, &memoryStream, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    pFlac->memoryStream = memoryStream;
+#ifndef MA_DR_FLAC_NO_OGG
+    if (pFlac->container == ma_dr_flac_container_ogg)
+    {
+        ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pFlac->_oggbs;
+        oggbs->pUserData = &pFlac->memoryStream;
+    }
+    else
+#endif
+    {
+        pFlac->bs.pUserData = &pFlac->memoryStream;
+    }
+    return pFlac;
+}
+MA_API ma_dr_flac* ma_dr_flac_open_memory_with_metadata(const void* pData, size_t dataSize, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac__memory_stream memoryStream;
+    ma_dr_flac* pFlac;
+    memoryStream.data = (const ma_uint8*)pData;
+    memoryStream.dataSize = dataSize;
+    memoryStream.currentReadPos = 0;
+    pFlac = ma_dr_flac_open_with_metadata_private(ma_dr_flac__on_read_memory, ma_dr_flac__on_seek_memory, ma_dr_flac__on_tell_memory, onMeta, ma_dr_flac_container_unknown, &memoryStream, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    pFlac->memoryStream = memoryStream;
+#ifndef MA_DR_FLAC_NO_OGG
+    if (pFlac->container == ma_dr_flac_container_ogg)
+    {
+        ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pFlac->_oggbs;
+        oggbs->pUserData = &pFlac->memoryStream;
+    }
+    else
+#endif
+    {
+        pFlac->bs.pUserData = &pFlac->memoryStream;
+    }
+    return pFlac;
+}
+MA_API ma_dr_flac* ma_dr_flac_open(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_flac_open_with_metadata_private(onRead, onSeek, onTell, NULL, ma_dr_flac_container_unknown, pUserData, pUserData, pAllocationCallbacks);
+}
+MA_API ma_dr_flac* ma_dr_flac_open_relaxed(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, ma_dr_flac_container container, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_flac_open_with_metadata_private(onRead, onSeek, onTell, NULL, container, pUserData, pUserData, pAllocationCallbacks);
+}
+MA_API ma_dr_flac* ma_dr_flac_open_with_metadata(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_flac_open_with_metadata_private(onRead, onSeek, onTell, onMeta, ma_dr_flac_container_unknown, pUserData, pUserData, pAllocationCallbacks);
+}
+MA_API ma_dr_flac* ma_dr_flac_open_with_metadata_relaxed(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, ma_dr_flac_meta_proc onMeta, ma_dr_flac_container container, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_flac_open_with_metadata_private(onRead, onSeek, onTell, onMeta, container, pUserData, pUserData, pAllocationCallbacks);
+}
+MA_API void ma_dr_flac_close(ma_dr_flac* pFlac)
+{
+    if (pFlac == NULL) {
+        return;
+    }
+#ifndef MA_DR_FLAC_NO_STDIO
+    if (pFlac->bs.onRead == ma_dr_flac__on_read_stdio) {
+        fclose((FILE*)pFlac->bs.pUserData);
+    }
+#ifndef MA_DR_FLAC_NO_OGG
+    if (pFlac->container == ma_dr_flac_container_ogg) {
+        ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pFlac->_oggbs;
+        MA_DR_FLAC_ASSERT(pFlac->bs.onRead == ma_dr_flac__on_read_ogg);
+        if (oggbs->onRead == ma_dr_flac__on_read_stdio) {
+            fclose((FILE*)oggbs->pUserData);
+        }
+    }
+#endif
+#endif
+    ma_dr_flac__free_from_callbacks(pFlac, &pFlac->allocationCallbacks);
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 left  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 side  = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 left0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 left1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 left2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 left3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 side0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 side1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 side2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 side3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 right0 = left0 - side0;
+        ma_uint32 right1 = left1 - side1;
+        ma_uint32 right2 = left2 - side2;
+        ma_uint32 right3 = left3 - side3;
+        pOutputSamples[i*8+0] = (ma_int32)left0;
+        pOutputSamples[i*8+1] = (ma_int32)right0;
+        pOutputSamples[i*8+2] = (ma_int32)left1;
+        pOutputSamples[i*8+3] = (ma_int32)right1;
+        pOutputSamples[i*8+4] = (ma_int32)left2;
+        pOutputSamples[i*8+5] = (ma_int32)right2;
+        pOutputSamples[i*8+6] = (ma_int32)left3;
+        pOutputSamples[i*8+7] = (ma_int32)right3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i right = _mm_sub_epi32(left, side);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t left;
+        uint32x4_t side;
+        uint32x4_t right;
+        left  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        right = vsubq_u32(left, side);
+        ma_dr_flac__vst2q_u32((ma_uint32*)pOutputSamples + i*8, vzipq_u32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s32__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s32__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 side  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 right = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 side0  = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 side1  = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 side2  = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 side3  = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 right0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 right1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 right2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 right3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 left0 = right0 + side0;
+        ma_uint32 left1 = right1 + side1;
+        ma_uint32 left2 = right2 + side2;
+        ma_uint32 left3 = right3 + side3;
+        pOutputSamples[i*8+0] = (ma_int32)left0;
+        pOutputSamples[i*8+1] = (ma_int32)right0;
+        pOutputSamples[i*8+2] = (ma_int32)left1;
+        pOutputSamples[i*8+3] = (ma_int32)right1;
+        pOutputSamples[i*8+4] = (ma_int32)left2;
+        pOutputSamples[i*8+5] = (ma_int32)right2;
+        pOutputSamples[i*8+6] = (ma_int32)left3;
+        pOutputSamples[i*8+7] = (ma_int32)right3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i left  = _mm_add_epi32(right, side);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t side;
+        uint32x4_t right;
+        uint32x4_t left;
+        side  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        left  = vaddq_u32(right, side);
+        ma_dr_flac__vst2q_u32((ma_uint32*)pOutputSamples + i*8, vzipq_u32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s32__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s32__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int32)((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample);
+        pOutputSamples[i*2+1] = (ma_int32)((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_int32 shift = unusedBitsPerSample;
+    if (shift > 0) {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (mid0 + side0) << shift;
+            temp1L = (mid1 + side1) << shift;
+            temp2L = (mid2 + side2) << shift;
+            temp3L = (mid3 + side3) << shift;
+            temp0R = (mid0 - side0) << shift;
+            temp1R = (mid1 - side1) << shift;
+            temp2R = (mid2 - side2) << shift;
+            temp3R = (mid3 - side3) << shift;
+            pOutputSamples[i*8+0] = (ma_int32)temp0L;
+            pOutputSamples[i*8+1] = (ma_int32)temp0R;
+            pOutputSamples[i*8+2] = (ma_int32)temp1L;
+            pOutputSamples[i*8+3] = (ma_int32)temp1R;
+            pOutputSamples[i*8+4] = (ma_int32)temp2L;
+            pOutputSamples[i*8+5] = (ma_int32)temp2R;
+            pOutputSamples[i*8+6] = (ma_int32)temp3L;
+            pOutputSamples[i*8+7] = (ma_int32)temp3R;
+        }
+    } else {
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (ma_uint32)((ma_int32)(mid0 + side0) >> 1);
+            temp1L = (ma_uint32)((ma_int32)(mid1 + side1) >> 1);
+            temp2L = (ma_uint32)((ma_int32)(mid2 + side2) >> 1);
+            temp3L = (ma_uint32)((ma_int32)(mid3 + side3) >> 1);
+            temp0R = (ma_uint32)((ma_int32)(mid0 - side0) >> 1);
+            temp1R = (ma_uint32)((ma_int32)(mid1 - side1) >> 1);
+            temp2R = (ma_uint32)((ma_int32)(mid2 - side2) >> 1);
+            temp3R = (ma_uint32)((ma_int32)(mid3 - side3) >> 1);
+            pOutputSamples[i*8+0] = (ma_int32)temp0L;
+            pOutputSamples[i*8+1] = (ma_int32)temp0R;
+            pOutputSamples[i*8+2] = (ma_int32)temp1L;
+            pOutputSamples[i*8+3] = (ma_int32)temp1R;
+            pOutputSamples[i*8+4] = (ma_int32)temp2L;
+            pOutputSamples[i*8+5] = (ma_int32)temp2R;
+            pOutputSamples[i*8+6] = (ma_int32)temp3L;
+            pOutputSamples[i*8+7] = (ma_int32)temp3R;
+        }
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int32)((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample);
+        pOutputSamples[i*2+1] = (ma_int32)((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample);
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_int32 shift = unusedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i left;
+            __m128i right;
+            mid   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid   = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            left  = _mm_srai_epi32(_mm_add_epi32(mid, side), 1);
+            right = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1);
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)(mid + side) >> 1;
+            pOutputSamples[i*2+1] = (ma_int32)(mid - side) >> 1;
+        }
+    } else {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i left;
+            __m128i right;
+            mid   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid   = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            left  = _mm_slli_epi32(_mm_add_epi32(mid, side), shift);
+            right = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift);
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)((mid + side) << shift);
+            pOutputSamples[i*2+1] = (ma_int32)((mid - side) << shift);
+        }
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_int32 shift = unusedBitsPerSample;
+    int32x4_t  wbpsShift0_4;
+    int32x4_t  wbpsShift1_4;
+    uint32x4_t one4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    wbpsShift0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+    wbpsShift1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+    one4         = vdupq_n_u32(1);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t left;
+            int32x4_t right;
+            mid   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+            side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+            mid   = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, one4));
+            left  = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1);
+            right = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1);
+            ma_dr_flac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)(mid + side) >> 1;
+            pOutputSamples[i*2+1] = (ma_int32)(mid - side) >> 1;
+        }
+    } else {
+        int32x4_t shift4;
+        shift -= 1;
+        shift4 = vdupq_n_s32(shift);
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t left;
+            int32x4_t right;
+            mid   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+            side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+            mid   = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, one4));
+            left  = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4));
+            right = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4));
+            ma_dr_flac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)((mid + side) << shift);
+            pOutputSamples[i*2+1] = (ma_int32)((mid - side) << shift);
+        }
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s32__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s32__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)((ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample));
+        pOutputSamples[i*2+1] = (ma_int32)((ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample));
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1;
+        pOutputSamples[i*8+0] = (ma_int32)tempL0;
+        pOutputSamples[i*8+1] = (ma_int32)tempR0;
+        pOutputSamples[i*8+2] = (ma_int32)tempL1;
+        pOutputSamples[i*8+3] = (ma_int32)tempR1;
+        pOutputSamples[i*8+4] = (ma_int32)tempL2;
+        pOutputSamples[i*8+5] = (ma_int32)tempR2;
+        pOutputSamples[i*8+6] = (ma_int32)tempL3;
+        pOutputSamples[i*8+7] = (ma_int32)tempR3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0);
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1);
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0);
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1);
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift4_0 = vdupq_n_s32(shift0);
+    int32x4_t shift4_1 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        int32x4_t left;
+        int32x4_t right;
+        left  = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift4_0));
+        right = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift4_1));
+        ma_dr_flac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0);
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_s32(ma_dr_flac* pFlac, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 framesRead;
+    ma_uint32 unusedBitsPerSample;
+    if (pFlac == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, framesToRead);
+    }
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 32);
+    unusedBitsPerSample = 32 - pFlac->bitsPerSample;
+    framesRead = 0;
+    while (framesToRead > 0) {
+        if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                break;
+            }
+        } else {
+            unsigned int channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+            ma_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining;
+            ma_uint64 frameCountThisIteration = framesToRead;
+            if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) {
+                frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining;
+            }
+            if (channelCount == 2) {
+                const ma_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame;
+                const ma_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame;
+                switch (pFlac->currentFLACFrame.header.channelAssignment)
+                {
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s32__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s32__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s32__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_INDEPENDENT:
+                    default:
+                    {
+                        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                }
+            } else {
+                ma_uint64 i;
+                for (i = 0; i < frameCountThisIteration; ++i) {
+                    unsigned int j;
+                    for (j = 0; j < channelCount; ++j) {
+                        pBufferOut[(i*channelCount)+j] = (ma_int32)((ma_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample));
+                    }
+                }
+            }
+            framesRead                += frameCountThisIteration;
+            pBufferOut                += frameCountThisIteration * channelCount;
+            framesToRead              -= frameCountThisIteration;
+            pFlac->currentPCMFrame    += frameCountThisIteration;
+            pFlac->currentFLACFrame.pcmFramesRemaining -= (ma_uint32)frameCountThisIteration;
+        }
+    }
+    return framesRead;
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 left  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 side  = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 right = left - side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 left0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 left1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 left2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 left3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 side0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 side1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 side2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 side3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 right0 = left0 - side0;
+        ma_uint32 right1 = left1 - side1;
+        ma_uint32 right2 = left2 - side2;
+        ma_uint32 right3 = left3 - side3;
+        left0  >>= 16;
+        left1  >>= 16;
+        left2  >>= 16;
+        left3  >>= 16;
+        right0 >>= 16;
+        right1 >>= 16;
+        right2 >>= 16;
+        right3 >>= 16;
+        pOutputSamples[i*8+0] = (ma_int16)left0;
+        pOutputSamples[i*8+1] = (ma_int16)right0;
+        pOutputSamples[i*8+2] = (ma_int16)left1;
+        pOutputSamples[i*8+3] = (ma_int16)right1;
+        pOutputSamples[i*8+4] = (ma_int16)left2;
+        pOutputSamples[i*8+5] = (ma_int16)right2;
+        pOutputSamples[i*8+6] = (ma_int16)left3;
+        pOutputSamples[i*8+7] = (ma_int16)right3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i right = _mm_sub_epi32(left, side);
+        left  = _mm_srai_epi32(left,  16);
+        right = _mm_srai_epi32(right, 16);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t left;
+        uint32x4_t side;
+        uint32x4_t right;
+        left  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        right = vsubq_u32(left, side);
+        left  = vshrq_n_u32(left,  16);
+        right = vshrq_n_u32(right, 16);
+        ma_dr_flac__vst2q_u16((ma_uint16*)pOutputSamples + i*8, vzip_u16(vmovn_u32(left), vmovn_u32(right)));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s16__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s16__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 side  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 right = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 left  = right + side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 side0  = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 side1  = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 side2  = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 side3  = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 right0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 right1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 right2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 right3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 left0 = right0 + side0;
+        ma_uint32 left1 = right1 + side1;
+        ma_uint32 left2 = right2 + side2;
+        ma_uint32 left3 = right3 + side3;
+        left0  >>= 16;
+        left1  >>= 16;
+        left2  >>= 16;
+        left3  >>= 16;
+        right0 >>= 16;
+        right1 >>= 16;
+        right2 >>= 16;
+        right3 >>= 16;
+        pOutputSamples[i*8+0] = (ma_int16)left0;
+        pOutputSamples[i*8+1] = (ma_int16)right0;
+        pOutputSamples[i*8+2] = (ma_int16)left1;
+        pOutputSamples[i*8+3] = (ma_int16)right1;
+        pOutputSamples[i*8+4] = (ma_int16)left2;
+        pOutputSamples[i*8+5] = (ma_int16)right2;
+        pOutputSamples[i*8+6] = (ma_int16)left3;
+        pOutputSamples[i*8+7] = (ma_int16)right3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i left  = _mm_add_epi32(right, side);
+        left  = _mm_srai_epi32(left,  16);
+        right = _mm_srai_epi32(right, 16);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t side;
+        uint32x4_t right;
+        uint32x4_t left;
+        side  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        left  = vaddq_u32(right, side);
+        left  = vshrq_n_u32(left,  16);
+        right = vshrq_n_u32(right, 16);
+        ma_dr_flac__vst2q_u16((ma_uint16*)pOutputSamples + i*8, vzip_u16(vmovn_u32(left), vmovn_u32(right)));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s16__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s16__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        ma_uint32 mid  = (ma_uint32)pInputSamples0[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = (ma_uint32)pInputSamples1[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int16)(((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)(((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample) >> 16);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample;
+    if (shift > 0) {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (mid0 + side0) << shift;
+            temp1L = (mid1 + side1) << shift;
+            temp2L = (mid2 + side2) << shift;
+            temp3L = (mid3 + side3) << shift;
+            temp0R = (mid0 - side0) << shift;
+            temp1R = (mid1 - side1) << shift;
+            temp2R = (mid2 - side2) << shift;
+            temp3R = (mid3 - side3) << shift;
+            temp0L >>= 16;
+            temp1L >>= 16;
+            temp2L >>= 16;
+            temp3L >>= 16;
+            temp0R >>= 16;
+            temp1R >>= 16;
+            temp2R >>= 16;
+            temp3R >>= 16;
+            pOutputSamples[i*8+0] = (ma_int16)temp0L;
+            pOutputSamples[i*8+1] = (ma_int16)temp0R;
+            pOutputSamples[i*8+2] = (ma_int16)temp1L;
+            pOutputSamples[i*8+3] = (ma_int16)temp1R;
+            pOutputSamples[i*8+4] = (ma_int16)temp2L;
+            pOutputSamples[i*8+5] = (ma_int16)temp2R;
+            pOutputSamples[i*8+6] = (ma_int16)temp3L;
+            pOutputSamples[i*8+7] = (ma_int16)temp3R;
+        }
+    } else {
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = ((ma_int32)(mid0 + side0) >> 1);
+            temp1L = ((ma_int32)(mid1 + side1) >> 1);
+            temp2L = ((ma_int32)(mid2 + side2) >> 1);
+            temp3L = ((ma_int32)(mid3 + side3) >> 1);
+            temp0R = ((ma_int32)(mid0 - side0) >> 1);
+            temp1R = ((ma_int32)(mid1 - side1) >> 1);
+            temp2R = ((ma_int32)(mid2 - side2) >> 1);
+            temp3R = ((ma_int32)(mid3 - side3) >> 1);
+            temp0L >>= 16;
+            temp1L >>= 16;
+            temp2L >>= 16;
+            temp3L >>= 16;
+            temp0R >>= 16;
+            temp1R >>= 16;
+            temp2R >>= 16;
+            temp3R >>= 16;
+            pOutputSamples[i*8+0] = (ma_int16)temp0L;
+            pOutputSamples[i*8+1] = (ma_int16)temp0R;
+            pOutputSamples[i*8+2] = (ma_int16)temp1L;
+            pOutputSamples[i*8+3] = (ma_int16)temp1R;
+            pOutputSamples[i*8+4] = (ma_int16)temp2L;
+            pOutputSamples[i*8+5] = (ma_int16)temp2R;
+            pOutputSamples[i*8+6] = (ma_int16)temp3L;
+            pOutputSamples[i*8+7] = (ma_int16)temp3R;
+        }
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int16)(((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)(((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample) >> 16);
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i left;
+            __m128i right;
+            mid   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid   = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            left  = _mm_srai_epi32(_mm_add_epi32(mid, side), 1);
+            right = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1);
+            left  = _mm_srai_epi32(left,  16);
+            right = _mm_srai_epi32(right, 16);
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int16)(((ma_int32)(mid + side) >> 1) >> 16);
+            pOutputSamples[i*2+1] = (ma_int16)(((ma_int32)(mid - side) >> 1) >> 16);
+        }
+    } else {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i left;
+            __m128i right;
+            mid   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid   = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            left  = _mm_slli_epi32(_mm_add_epi32(mid, side), shift);
+            right = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift);
+            left  = _mm_srai_epi32(left,  16);
+            right = _mm_srai_epi32(right, 16);
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int16)(((mid + side) << shift) >> 16);
+            pOutputSamples[i*2+1] = (ma_int16)(((mid - side) << shift) >> 16);
+        }
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample;
+    int32x4_t wbpsShift0_4;
+    int32x4_t wbpsShift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    wbpsShift0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+    wbpsShift1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t left;
+            int32x4_t right;
+            mid   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+            side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+            mid   = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+            left  = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1);
+            right = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1);
+            left  = vshrq_n_s32(left,  16);
+            right = vshrq_n_s32(right, 16);
+            ma_dr_flac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right)));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int16)(((ma_int32)(mid + side) >> 1) >> 16);
+            pOutputSamples[i*2+1] = (ma_int16)(((ma_int32)(mid - side) >> 1) >> 16);
+        }
+    } else {
+        int32x4_t shift4;
+        shift -= 1;
+        shift4 = vdupq_n_s32(shift);
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t left;
+            int32x4_t right;
+            mid   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+            side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+            mid   = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+            left  = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4));
+            right = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4));
+            left  = vshrq_n_s32(left,  16);
+            right = vshrq_n_s32(right, 16);
+            ma_dr_flac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right)));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int16)(((mid + side) << shift) >> 16);
+            pOutputSamples[i*2+1] = (ma_int16)(((mid - side) << shift) >> 16);
+        }
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s16__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s16__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int16)((ma_int32)((ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample)) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)((ma_int32)((ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample)) >> 16);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1;
+        tempL0 >>= 16;
+        tempL1 >>= 16;
+        tempL2 >>= 16;
+        tempL3 >>= 16;
+        tempR0 >>= 16;
+        tempR1 >>= 16;
+        tempR2 >>= 16;
+        tempR3 >>= 16;
+        pOutputSamples[i*8+0] = (ma_int16)tempL0;
+        pOutputSamples[i*8+1] = (ma_int16)tempR0;
+        pOutputSamples[i*8+2] = (ma_int16)tempL1;
+        pOutputSamples[i*8+3] = (ma_int16)tempR1;
+        pOutputSamples[i*8+4] = (ma_int16)tempL2;
+        pOutputSamples[i*8+5] = (ma_int16)tempR2;
+        pOutputSamples[i*8+6] = (ma_int16)tempL3;
+        pOutputSamples[i*8+7] = (ma_int16)tempR3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int16)((pInputSamples0U32[i] << shift0) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)((pInputSamples1U32[i] << shift1) >> 16);
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        left  = _mm_srai_epi32(left,  16);
+        right = _mm_srai_epi32(right, 16);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int16)((pInputSamples0U32[i] << shift0) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)((pInputSamples1U32[i] << shift1) >> 16);
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4 = vdupq_n_s32(shift0);
+    int32x4_t shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        int32x4_t left;
+        int32x4_t right;
+        left  = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4));
+        right = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4));
+        left  = vshrq_n_s32(left,  16);
+        right = vshrq_n_s32(right, 16);
+        ma_dr_flac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right)));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int16)((pInputSamples0U32[i] << shift0) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)((pInputSamples1U32[i] << shift1) >> 16);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_s16(ma_dr_flac* pFlac, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 framesRead;
+    ma_uint32 unusedBitsPerSample;
+    if (pFlac == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, framesToRead);
+    }
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 32);
+    unusedBitsPerSample = 32 - pFlac->bitsPerSample;
+    framesRead = 0;
+    while (framesToRead > 0) {
+        if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                break;
+            }
+        } else {
+            unsigned int channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+            ma_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining;
+            ma_uint64 frameCountThisIteration = framesToRead;
+            if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) {
+                frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining;
+            }
+            if (channelCount == 2) {
+                const ma_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame;
+                const ma_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame;
+                switch (pFlac->currentFLACFrame.header.channelAssignment)
+                {
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s16__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s16__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s16__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_INDEPENDENT:
+                    default:
+                    {
+                        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                }
+            } else {
+                ma_uint64 i;
+                for (i = 0; i < frameCountThisIteration; ++i) {
+                    unsigned int j;
+                    for (j = 0; j < channelCount; ++j) {
+                        ma_int32 sampleS32 = (ma_int32)((ma_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample));
+                        pBufferOut[(i*channelCount)+j] = (ma_int16)(sampleS32 >> 16);
+                    }
+                }
+            }
+            framesRead                += frameCountThisIteration;
+            pBufferOut                += frameCountThisIteration * channelCount;
+            framesToRead              -= frameCountThisIteration;
+            pFlac->currentPCMFrame    += frameCountThisIteration;
+            pFlac->currentFLACFrame.pcmFramesRemaining -= (ma_uint32)frameCountThisIteration;
+        }
+    }
+    return framesRead;
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 left  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 side  = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (float)((ma_int32)left  / 2147483648.0);
+        pOutputSamples[i*2+1] = (float)((ma_int32)right / 2147483648.0);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    float factor = 1 / 2147483648.0;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 left0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 left1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 left2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 left3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 side0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 side1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 side2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 side3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 right0 = left0 - side0;
+        ma_uint32 right1 = left1 - side1;
+        ma_uint32 right2 = left2 - side2;
+        ma_uint32 right3 = left3 - side3;
+        pOutputSamples[i*8+0] = (ma_int32)left0  * factor;
+        pOutputSamples[i*8+1] = (ma_int32)right0 * factor;
+        pOutputSamples[i*8+2] = (ma_int32)left1  * factor;
+        pOutputSamples[i*8+3] = (ma_int32)right1 * factor;
+        pOutputSamples[i*8+4] = (ma_int32)left2  * factor;
+        pOutputSamples[i*8+5] = (ma_int32)right2 * factor;
+        pOutputSamples[i*8+6] = (ma_int32)left3  * factor;
+        pOutputSamples[i*8+7] = (ma_int32)right3 * factor;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left  * factor;
+        pOutputSamples[i*2+1] = (ma_int32)right * factor;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    __m128 factor;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor = _mm_set1_ps(1.0f / 8388608.0f);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i right = _mm_sub_epi32(left, side);
+        __m128 leftf  = _mm_mul_ps(_mm_cvtepi32_ps(left),  factor);
+        __m128 rightf = _mm_mul_ps(_mm_cvtepi32_ps(right), factor);
+        _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+        _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left  / 8388608.0f;
+        pOutputSamples[i*2+1] = (ma_int32)right / 8388608.0f;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    float32x4_t factor4;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor4  = vdupq_n_f32(1.0f / 8388608.0f);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t left;
+        uint32x4_t side;
+        uint32x4_t right;
+        float32x4_t leftf;
+        float32x4_t rightf;
+        left   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        side   = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        right  = vsubq_u32(left, side);
+        leftf  = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(left)),  factor4);
+        rightf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(right)), factor4);
+        ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left  / 8388608.0f;
+        pOutputSamples[i*2+1] = (ma_int32)right / 8388608.0f;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_f32__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_f32__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 side  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 right = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (float)((ma_int32)left  / 2147483648.0);
+        pOutputSamples[i*2+1] = (float)((ma_int32)right / 2147483648.0);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    float factor = 1 / 2147483648.0;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 side0  = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 side1  = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 side2  = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 side3  = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 right0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 right1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 right2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 right3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 left0 = right0 + side0;
+        ma_uint32 left1 = right1 + side1;
+        ma_uint32 left2 = right2 + side2;
+        ma_uint32 left3 = right3 + side3;
+        pOutputSamples[i*8+0] = (ma_int32)left0  * factor;
+        pOutputSamples[i*8+1] = (ma_int32)right0 * factor;
+        pOutputSamples[i*8+2] = (ma_int32)left1  * factor;
+        pOutputSamples[i*8+3] = (ma_int32)right1 * factor;
+        pOutputSamples[i*8+4] = (ma_int32)left2  * factor;
+        pOutputSamples[i*8+5] = (ma_int32)right2 * factor;
+        pOutputSamples[i*8+6] = (ma_int32)left3  * factor;
+        pOutputSamples[i*8+7] = (ma_int32)right3 * factor;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left  * factor;
+        pOutputSamples[i*2+1] = (ma_int32)right * factor;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    __m128 factor;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor = _mm_set1_ps(1.0f / 8388608.0f);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i left  = _mm_add_epi32(right, side);
+        __m128 leftf  = _mm_mul_ps(_mm_cvtepi32_ps(left),  factor);
+        __m128 rightf = _mm_mul_ps(_mm_cvtepi32_ps(right), factor);
+        _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+        _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left  / 8388608.0f;
+        pOutputSamples[i*2+1] = (ma_int32)right / 8388608.0f;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    float32x4_t factor4;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor4  = vdupq_n_f32(1.0f / 8388608.0f);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t side;
+        uint32x4_t right;
+        uint32x4_t left;
+        float32x4_t leftf;
+        float32x4_t rightf;
+        side   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        right  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        left   = vaddq_u32(right, side);
+        leftf  = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(left)),  factor4);
+        rightf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(right)), factor4);
+        ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left  / 8388608.0f;
+        pOutputSamples[i*2+1] = (ma_int32)right / 8388608.0f;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_f32__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_f32__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        ma_uint32 mid  = (ma_uint32)pInputSamples0[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = (ma_uint32)pInputSamples1[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (float)((((ma_int32)(mid + side) >> 1) << (unusedBitsPerSample)) / 2147483648.0);
+        pOutputSamples[i*2+1] = (float)((((ma_int32)(mid - side) >> 1) << (unusedBitsPerSample)) / 2147483648.0);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample;
+    float factor = 1 / 2147483648.0;
+    if (shift > 0) {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (mid0 + side0) << shift;
+            temp1L = (mid1 + side1) << shift;
+            temp2L = (mid2 + side2) << shift;
+            temp3L = (mid3 + side3) << shift;
+            temp0R = (mid0 - side0) << shift;
+            temp1R = (mid1 - side1) << shift;
+            temp2R = (mid2 - side2) << shift;
+            temp3R = (mid3 - side3) << shift;
+            pOutputSamples[i*8+0] = (ma_int32)temp0L * factor;
+            pOutputSamples[i*8+1] = (ma_int32)temp0R * factor;
+            pOutputSamples[i*8+2] = (ma_int32)temp1L * factor;
+            pOutputSamples[i*8+3] = (ma_int32)temp1R * factor;
+            pOutputSamples[i*8+4] = (ma_int32)temp2L * factor;
+            pOutputSamples[i*8+5] = (ma_int32)temp2R * factor;
+            pOutputSamples[i*8+6] = (ma_int32)temp3L * factor;
+            pOutputSamples[i*8+7] = (ma_int32)temp3R * factor;
+        }
+    } else {
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (ma_uint32)((ma_int32)(mid0 + side0) >> 1);
+            temp1L = (ma_uint32)((ma_int32)(mid1 + side1) >> 1);
+            temp2L = (ma_uint32)((ma_int32)(mid2 + side2) >> 1);
+            temp3L = (ma_uint32)((ma_int32)(mid3 + side3) >> 1);
+            temp0R = (ma_uint32)((ma_int32)(mid0 - side0) >> 1);
+            temp1R = (ma_uint32)((ma_int32)(mid1 - side1) >> 1);
+            temp2R = (ma_uint32)((ma_int32)(mid2 - side2) >> 1);
+            temp3R = (ma_uint32)((ma_int32)(mid3 - side3) >> 1);
+            pOutputSamples[i*8+0] = (ma_int32)temp0L * factor;
+            pOutputSamples[i*8+1] = (ma_int32)temp0R * factor;
+            pOutputSamples[i*8+2] = (ma_int32)temp1L * factor;
+            pOutputSamples[i*8+3] = (ma_int32)temp1R * factor;
+            pOutputSamples[i*8+4] = (ma_int32)temp2L * factor;
+            pOutputSamples[i*8+5] = (ma_int32)temp2R * factor;
+            pOutputSamples[i*8+6] = (ma_int32)temp3L * factor;
+            pOutputSamples[i*8+7] = (ma_int32)temp3R * factor;
+        }
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int32)((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample) * factor;
+        pOutputSamples[i*2+1] = (ma_int32)((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample) * factor;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample - 8;
+    float factor;
+    __m128 factor128;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor = 1.0f / 8388608.0f;
+    factor128 = _mm_set1_ps(factor);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i tempL;
+            __m128i tempR;
+            __m128  leftf;
+            __m128  rightf;
+            mid    = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid    = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            tempL  = _mm_srai_epi32(_mm_add_epi32(mid, side), 1);
+            tempR  = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1);
+            leftf  = _mm_mul_ps(_mm_cvtepi32_ps(tempL), factor128);
+            rightf = _mm_mul_ps(_mm_cvtepi32_ps(tempR), factor128);
+            _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+            _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = ((ma_int32)(mid + side) >> 1) * factor;
+            pOutputSamples[i*2+1] = ((ma_int32)(mid - side) >> 1) * factor;
+        }
+    } else {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i tempL;
+            __m128i tempR;
+            __m128 leftf;
+            __m128 rightf;
+            mid    = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid    = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            tempL  = _mm_slli_epi32(_mm_add_epi32(mid, side), shift);
+            tempR  = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift);
+            leftf  = _mm_mul_ps(_mm_cvtepi32_ps(tempL), factor128);
+            rightf = _mm_mul_ps(_mm_cvtepi32_ps(tempR), factor128);
+            _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+            _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)((mid + side) << shift) * factor;
+            pOutputSamples[i*2+1] = (ma_int32)((mid - side) << shift) * factor;
+        }
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample - 8;
+    float factor;
+    float32x4_t factor4;
+    int32x4_t shift4;
+    int32x4_t wbps0_4;
+    int32x4_t wbps1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor  = 1.0f / 8388608.0f;
+    factor4 = vdupq_n_f32(factor);
+    wbps0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+    wbps1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            int32x4_t lefti;
+            int32x4_t righti;
+            float32x4_t leftf;
+            float32x4_t rightf;
+            uint32x4_t mid  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbps0_4);
+            uint32x4_t side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbps1_4);
+            mid    = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+            lefti  = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1);
+            righti = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1);
+            leftf  = vmulq_f32(vcvtq_f32_s32(lefti),  factor4);
+            rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4);
+            ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = ((ma_int32)(mid + side) >> 1) * factor;
+            pOutputSamples[i*2+1] = ((ma_int32)(mid - side) >> 1) * factor;
+        }
+    } else {
+        shift -= 1;
+        shift4 = vdupq_n_s32(shift);
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t lefti;
+            int32x4_t righti;
+            float32x4_t leftf;
+            float32x4_t rightf;
+            mid    = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbps0_4);
+            side   = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbps1_4);
+            mid    = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+            lefti  = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4));
+            righti = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4));
+            leftf  = vmulq_f32(vcvtq_f32_s32(lefti),  factor4);
+            rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4);
+            ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)((mid + side) << shift) * factor;
+            pOutputSamples[i*2+1] = (ma_int32)((mid - side) << shift) * factor;
+        }
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_f32__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_f32__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (float)((ma_int32)((ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample)) / 2147483648.0);
+        pOutputSamples[i*2+1] = (float)((ma_int32)((ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample)) / 2147483648.0);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    float factor = 1 / 2147483648.0;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1;
+        pOutputSamples[i*8+0] = (ma_int32)tempL0 * factor;
+        pOutputSamples[i*8+1] = (ma_int32)tempR0 * factor;
+        pOutputSamples[i*8+2] = (ma_int32)tempL1 * factor;
+        pOutputSamples[i*8+3] = (ma_int32)tempR1 * factor;
+        pOutputSamples[i*8+4] = (ma_int32)tempL2 * factor;
+        pOutputSamples[i*8+5] = (ma_int32)tempR2 * factor;
+        pOutputSamples[i*8+6] = (ma_int32)tempL3 * factor;
+        pOutputSamples[i*8+7] = (ma_int32)tempR3 * factor;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0) * factor;
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1) * factor;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    float factor = 1.0f / 8388608.0f;
+    __m128 factor128 = _mm_set1_ps(factor);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i lefti;
+        __m128i righti;
+        __m128 leftf;
+        __m128 rightf;
+        lefti  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        righti = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        leftf  = _mm_mul_ps(_mm_cvtepi32_ps(lefti),  factor128);
+        rightf = _mm_mul_ps(_mm_cvtepi32_ps(righti), factor128);
+        _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+        _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0) * factor;
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1) * factor;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    float factor = 1.0f / 8388608.0f;
+    float32x4_t factor4 = vdupq_n_f32(factor);
+    int32x4_t shift0_4  = vdupq_n_s32(shift0);
+    int32x4_t shift1_4  = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        int32x4_t lefti;
+        int32x4_t righti;
+        float32x4_t leftf;
+        float32x4_t rightf;
+        lefti  = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4));
+        righti = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4));
+        leftf  = vmulq_f32(vcvtq_f32_s32(lefti),  factor4);
+        rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4);
+        ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0) * factor;
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1) * factor;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_f32(ma_dr_flac* pFlac, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 framesRead;
+    ma_uint32 unusedBitsPerSample;
+    if (pFlac == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, framesToRead);
+    }
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 32);
+    unusedBitsPerSample = 32 - pFlac->bitsPerSample;
+    framesRead = 0;
+    while (framesToRead > 0) {
+        if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                break;
+            }
+        } else {
+            unsigned int channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+            ma_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining;
+            ma_uint64 frameCountThisIteration = framesToRead;
+            if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) {
+                frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining;
+            }
+            if (channelCount == 2) {
+                const ma_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame;
+                const ma_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame;
+                switch (pFlac->currentFLACFrame.header.channelAssignment)
+                {
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_f32__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_f32__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_f32__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_INDEPENDENT:
+                    default:
+                    {
+                        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                }
+            } else {
+                ma_uint64 i;
+                for (i = 0; i < frameCountThisIteration; ++i) {
+                    unsigned int j;
+                    for (j = 0; j < channelCount; ++j) {
+                        ma_int32 sampleS32 = (ma_int32)((ma_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample));
+                        pBufferOut[(i*channelCount)+j] = (float)(sampleS32 / 2147483648.0);
+                    }
+                }
+            }
+            framesRead                += frameCountThisIteration;
+            pBufferOut                += frameCountThisIteration * channelCount;
+            framesToRead              -= frameCountThisIteration;
+            pFlac->currentPCMFrame    += frameCountThisIteration;
+            pFlac->currentFLACFrame.pcmFramesRemaining -= (unsigned int)frameCountThisIteration;
+        }
+    }
+    return framesRead;
+}
+MA_API ma_bool32 ma_dr_flac_seek_to_pcm_frame(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    if (pFlac == NULL) {
+        return MA_FALSE;
+    }
+    if (pFlac->currentPCMFrame == pcmFrameIndex) {
+        return MA_TRUE;
+    }
+    if (pFlac->firstFLACFramePosInBytes == 0) {
+        return MA_FALSE;
+    }
+    if (pcmFrameIndex == 0) {
+        pFlac->currentPCMFrame = 0;
+        return ma_dr_flac__seek_to_first_frame(pFlac);
+    } else {
+        ma_bool32 wasSuccessful = MA_FALSE;
+        ma_uint64 originalPCMFrame = pFlac->currentPCMFrame;
+        if (pcmFrameIndex > pFlac->totalPCMFrameCount) {
+            pcmFrameIndex = pFlac->totalPCMFrameCount;
+        }
+        if (pcmFrameIndex > pFlac->currentPCMFrame) {
+            ma_uint32 offset = (ma_uint32)(pcmFrameIndex - pFlac->currentPCMFrame);
+            if (pFlac->currentFLACFrame.pcmFramesRemaining >  offset) {
+                pFlac->currentFLACFrame.pcmFramesRemaining -= offset;
+                pFlac->currentPCMFrame = pcmFrameIndex;
+                return MA_TRUE;
+            }
+        } else {
+            ma_uint32 offsetAbs = (ma_uint32)(pFlac->currentPCMFrame - pcmFrameIndex);
+            ma_uint32 currentFLACFramePCMFrameCount = pFlac->currentFLACFrame.header.blockSizeInPCMFrames;
+            ma_uint32 currentFLACFramePCMFramesConsumed = currentFLACFramePCMFrameCount - pFlac->currentFLACFrame.pcmFramesRemaining;
+            if (currentFLACFramePCMFramesConsumed > offsetAbs) {
+                pFlac->currentFLACFrame.pcmFramesRemaining += offsetAbs;
+                pFlac->currentPCMFrame = pcmFrameIndex;
+                return MA_TRUE;
+            }
+        }
+#ifndef MA_DR_FLAC_NO_OGG
+        if (pFlac->container == ma_dr_flac_container_ogg)
+        {
+            wasSuccessful = ma_dr_flac_ogg__seek_to_pcm_frame(pFlac, pcmFrameIndex);
+        }
+        else
+#endif
+        {
+            if (!pFlac->_noSeekTableSeek) {
+                wasSuccessful = ma_dr_flac__seek_to_pcm_frame__seek_table(pFlac, pcmFrameIndex);
+            }
+#if !defined(MA_DR_FLAC_NO_CRC)
+            if (!wasSuccessful && !pFlac->_noBinarySearchSeek && pFlac->totalPCMFrameCount > 0) {
+                wasSuccessful = ma_dr_flac__seek_to_pcm_frame__binary_search(pFlac, pcmFrameIndex);
+            }
+#endif
+            if (!wasSuccessful && !pFlac->_noBruteForceSeek) {
+                wasSuccessful = ma_dr_flac__seek_to_pcm_frame__brute_force(pFlac, pcmFrameIndex);
+            }
+        }
+        if (wasSuccessful) {
+            pFlac->currentPCMFrame = pcmFrameIndex;
+        } else {
+            if (ma_dr_flac_seek_to_pcm_frame(pFlac, originalPCMFrame) == MA_FALSE) {
+                ma_dr_flac_seek_to_pcm_frame(pFlac, 0);
+            }
+        }
+        return wasSuccessful;
+    }
+}
+#define MA_DR_FLAC_DEFINE_FULL_READ_AND_CLOSE(extension, type) \
+static type* ma_dr_flac__full_read_and_close_ ## extension (ma_dr_flac* pFlac, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalPCMFrameCountOut)\
+{                                                                                                                                                                   \
+    type* pSampleData = NULL;                                                                                                                                       \
+    ma_uint64 totalPCMFrameCount;                                                                                                                               \
+                                                                                                                                                                    \
+    MA_DR_FLAC_ASSERT(pFlac != NULL);                                                                                                                                   \
+                                                                                                                                                                    \
+    totalPCMFrameCount = pFlac->totalPCMFrameCount;                                                                                                                 \
+                                                                                                                                                                    \
+    if (totalPCMFrameCount == 0) {                                                                                                                                  \
+        type buffer[4096];                                                                                                                                          \
+        ma_uint64 pcmFramesRead;                                                                                                                                \
+        size_t sampleDataBufferSize = sizeof(buffer);                                                                                                               \
+                                                                                                                                                                    \
+        pSampleData = (type*)ma_dr_flac__malloc_from_callbacks(sampleDataBufferSize, &pFlac->allocationCallbacks);                                                      \
+        if (pSampleData == NULL) {                                                                                                                                  \
+            goto on_error;                                                                                                                                          \
+        }                                                                                                                                                           \
+                                                                                                                                                                    \
+        while ((pcmFramesRead = (ma_uint64)ma_dr_flac_read_pcm_frames_##extension(pFlac, sizeof(buffer)/sizeof(buffer[0])/pFlac->channels, buffer)) > 0) {          \
+            if (((totalPCMFrameCount + pcmFramesRead) * pFlac->channels * sizeof(type)) > sampleDataBufferSize) {                                                   \
+                type* pNewSampleData;                                                                                                                               \
+                size_t newSampleDataBufferSize;                                                                                                                     \
+                                                                                                                                                                    \
+                newSampleDataBufferSize = sampleDataBufferSize * 2;                                                                                                 \
+                pNewSampleData = (type*)ma_dr_flac__realloc_from_callbacks(pSampleData, newSampleDataBufferSize, sampleDataBufferSize, &pFlac->allocationCallbacks);    \
+                if (pNewSampleData == NULL) {                                                                                                                       \
+                    ma_dr_flac__free_from_callbacks(pSampleData, &pFlac->allocationCallbacks);                                                                          \
+                    goto on_error;                                                                                                                                  \
+                }                                                                                                                                                   \
+                                                                                                                                                                    \
+                sampleDataBufferSize = newSampleDataBufferSize;                                                                                                     \
+                pSampleData = pNewSampleData;                                                                                                                       \
+            }                                                                                                                                                       \
+                                                                                                                                                                    \
+            MA_DR_FLAC_COPY_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), buffer, (size_t)(pcmFramesRead*pFlac->channels*sizeof(type)));                   \
+            totalPCMFrameCount += pcmFramesRead;                                                                                                                    \
+        }                                                                                                                                                           \
+                                                                                                                                                                    \
+                                                                                                                         \
+        MA_DR_FLAC_ZERO_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), (size_t)(sampleDataBufferSize - totalPCMFrameCount*pFlac->channels*sizeof(type)));   \
+    } else {                                                                                                                                                        \
+        ma_uint64 dataSize = totalPCMFrameCount*pFlac->channels*sizeof(type);                                                                                   \
+        if (dataSize > (ma_uint64)MA_SIZE_MAX) {                                                                                                            \
+            goto on_error;                                                                                                        \
+        }                                                                                                                                                           \
+                                                                                                                                                                    \
+        pSampleData = (type*)ma_dr_flac__malloc_from_callbacks((size_t)dataSize, &pFlac->allocationCallbacks);               \
+        if (pSampleData == NULL) {                                                                                                                                  \
+            goto on_error;                                                                                                                                          \
+        }                                                                                                                                                           \
+                                                                                                                                                                    \
+        totalPCMFrameCount = ma_dr_flac_read_pcm_frames_##extension(pFlac, pFlac->totalPCMFrameCount, pSampleData);                                                     \
+    }                                                                                                                                                               \
+                                                                                                                                                                    \
+    if (sampleRateOut) *sampleRateOut = pFlac->sampleRate;                                                                                                          \
+    if (channelsOut) *channelsOut = pFlac->channels;                                                                                                                \
+    if (totalPCMFrameCountOut) *totalPCMFrameCountOut = totalPCMFrameCount;                                                                                         \
+                                                                                                                                                                    \
+    ma_dr_flac_close(pFlac);                                                                                                                                            \
+    return pSampleData;                                                                                                                                             \
+                                                                                                                                                                    \
+on_error:                                                                                                                                                           \
+    ma_dr_flac_close(pFlac);                                                                                                                                            \
+    return NULL;                                                                                                                                                    \
+}
+MA_DR_FLAC_DEFINE_FULL_READ_AND_CLOSE(s32, ma_int32)
+MA_DR_FLAC_DEFINE_FULL_READ_AND_CLOSE(s16, ma_int16)
+MA_DR_FLAC_DEFINE_FULL_READ_AND_CLOSE(f32, float)
+MA_API ma_int32* ma_dr_flac_open_and_read_pcm_frames_s32(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalPCMFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalPCMFrameCountOut) {
+        *totalPCMFrameCountOut = 0;
+    }
+    pFlac = ma_dr_flac_open(onRead, onSeek, onTell, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s32(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut);
+}
+MA_API ma_int16* ma_dr_flac_open_and_read_pcm_frames_s16(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalPCMFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalPCMFrameCountOut) {
+        *totalPCMFrameCountOut = 0;
+    }
+    pFlac = ma_dr_flac_open(onRead, onSeek, onTell, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s16(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut);
+}
+MA_API float* ma_dr_flac_open_and_read_pcm_frames_f32(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_tell_proc onTell, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalPCMFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalPCMFrameCountOut) {
+        *totalPCMFrameCountOut = 0;
+    }
+    pFlac = ma_dr_flac_open(onRead, onSeek, onTell, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_f32(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut);
+}
+#ifndef MA_DR_FLAC_NO_STDIO
+MA_API ma_int32* ma_dr_flac_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_file(filename, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API ma_int16* ma_dr_flac_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_file(filename, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s16(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API float* ma_dr_flac_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_file(filename, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_f32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+#endif
+MA_API ma_int32* ma_dr_flac_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_memory(data, dataSize, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API ma_int16* ma_dr_flac_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_memory(data, dataSize, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s16(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API float* ma_dr_flac_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_memory(data, dataSize, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_f32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API void ma_dr_flac_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        ma_dr_flac__free_from_callbacks(p, pAllocationCallbacks);
+    } else {
+        ma_dr_flac__free_default(p, NULL);
+    }
+}
+MA_API void ma_dr_flac_init_vorbis_comment_iterator(ma_dr_flac_vorbis_comment_iterator* pIter, ma_uint32 commentCount, const void* pComments)
+{
+    if (pIter == NULL) {
+        return;
+    }
+    pIter->countRemaining = commentCount;
+    pIter->pRunningData   = (const char*)pComments;
+}
+MA_API const char* ma_dr_flac_next_vorbis_comment(ma_dr_flac_vorbis_comment_iterator* pIter, ma_uint32* pCommentLengthOut)
+{
+    ma_int32 length;
+    const char* pComment;
+    if (pCommentLengthOut) {
+        *pCommentLengthOut = 0;
+    }
+    if (pIter == NULL || pIter->countRemaining == 0 || pIter->pRunningData == NULL) {
+        return NULL;
+    }
+    length = ma_dr_flac__le2host_32_ptr_unaligned(pIter->pRunningData);
+    pIter->pRunningData += 4;
+    pComment = pIter->pRunningData;
+    pIter->pRunningData += length;
+    pIter->countRemaining -= 1;
+    if (pCommentLengthOut) {
+        *pCommentLengthOut = length;
+    }
+    return pComment;
+}
+MA_API void ma_dr_flac_init_cuesheet_track_iterator(ma_dr_flac_cuesheet_track_iterator* pIter, ma_uint32 trackCount, const void* pTrackData)
+{
+    if (pIter == NULL) {
+        return;
+    }
+    pIter->countRemaining = trackCount;
+    pIter->pRunningData   = (const char*)pTrackData;
+}
+MA_API ma_bool32 ma_dr_flac_next_cuesheet_track(ma_dr_flac_cuesheet_track_iterator* pIter, ma_dr_flac_cuesheet_track* pCuesheetTrack)
+{
+    ma_dr_flac_cuesheet_track cuesheetTrack;
+    const char* pRunningData;
+    ma_uint64 offsetHi;
+    ma_uint64 offsetLo;
+    if (pIter == NULL || pIter->countRemaining == 0 || pIter->pRunningData == NULL) {
+        return MA_FALSE;
+    }
+    pRunningData = pIter->pRunningData;
+    offsetHi                   = ma_dr_flac__be2host_32(*(const ma_uint32*)pRunningData); pRunningData += 4;
+    offsetLo                   = ma_dr_flac__be2host_32(*(const ma_uint32*)pRunningData); pRunningData += 4;
+    cuesheetTrack.offset       = offsetLo | (offsetHi << 32);
+    cuesheetTrack.trackNumber  = pRunningData[0];                                         pRunningData += 1;
+    MA_DR_FLAC_COPY_MEMORY(cuesheetTrack.ISRC, pRunningData, sizeof(cuesheetTrack.ISRC));     pRunningData += 12;
+    cuesheetTrack.isAudio      = (pRunningData[0] & 0x80) != 0;
+    cuesheetTrack.preEmphasis  = (pRunningData[0] & 0x40) != 0;                           pRunningData += 14;
+    cuesheetTrack.indexCount   = pRunningData[0];                                         pRunningData += 1;
+    cuesheetTrack.pIndexPoints = (const ma_dr_flac_cuesheet_track_index*)pRunningData;        pRunningData += cuesheetTrack.indexCount * sizeof(ma_dr_flac_cuesheet_track_index);
+    pIter->pRunningData = pRunningData;
+    pIter->countRemaining -= 1;
+    if (pCuesheetTrack) {
+        *pCuesheetTrack = cuesheetTrack;
+    }
+    return MA_TRUE;
+}
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic pop
+#endif
+#endif
+/* dr_flac_c end */
+#endif  /* MA_DR_FLAC_IMPLEMENTATION */
+#endif  /* MA_NO_FLAC */
+
+#if !defined(MA_NO_MP3) && !defined(MA_NO_DECODING)
+#if !defined(MA_DR_MP3_IMPLEMENTATION)
+/* dr_mp3_c begin */
+#ifndef ma_dr_mp3_c
+#define ma_dr_mp3_c
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+MA_API void ma_dr_mp3_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision)
+{
+    if (pMajor) {
+        *pMajor = MA_DR_MP3_VERSION_MAJOR;
+    }
+    if (pMinor) {
+        *pMinor = MA_DR_MP3_VERSION_MINOR;
+    }
+    if (pRevision) {
+        *pRevision = MA_DR_MP3_VERSION_REVISION;
+    }
+}
+MA_API const char* ma_dr_mp3_version_string(void)
+{
+    return MA_DR_MP3_VERSION_STRING;
+}
+#if defined(__TINYC__)
+#define MA_DR_MP3_NO_SIMD
+#endif
+#define MA_DR_MP3_OFFSET_PTR(p, offset) ((void*)((ma_uint8*)(p) + (offset)))
+#define MA_DR_MP3_MAX_FREE_FORMAT_FRAME_SIZE  2304
+#ifndef MA_DR_MP3_MAX_FRAME_SYNC_MATCHES
+#define MA_DR_MP3_MAX_FRAME_SYNC_MATCHES      10
+#endif
+#define MA_DR_MP3_MAX_L3_FRAME_PAYLOAD_BYTES  MA_DR_MP3_MAX_FREE_FORMAT_FRAME_SIZE
+#define MA_DR_MP3_MAX_BITRESERVOIR_BYTES      511
+#define MA_DR_MP3_SHORT_BLOCK_TYPE            2
+#define MA_DR_MP3_STOP_BLOCK_TYPE             3
+#define MA_DR_MP3_MODE_MONO                   3
+#define MA_DR_MP3_MODE_JOINT_STEREO           1
+#define MA_DR_MP3_HDR_SIZE                    4
+#define MA_DR_MP3_HDR_IS_MONO(h)              (((h[3]) & 0xC0) == 0xC0)
+#define MA_DR_MP3_HDR_IS_MS_STEREO(h)         (((h[3]) & 0xE0) == 0x60)
+#define MA_DR_MP3_HDR_IS_FREE_FORMAT(h)       (((h[2]) & 0xF0) == 0)
+#define MA_DR_MP3_HDR_IS_CRC(h)               (!((h[1]) & 1))
+#define MA_DR_MP3_HDR_TEST_PADDING(h)         ((h[2]) & 0x2)
+#define MA_DR_MP3_HDR_TEST_MPEG1(h)           ((h[1]) & 0x8)
+#define MA_DR_MP3_HDR_TEST_NOT_MPEG25(h)      ((h[1]) & 0x10)
+#define MA_DR_MP3_HDR_TEST_I_STEREO(h)        ((h[3]) & 0x10)
+#define MA_DR_MP3_HDR_TEST_MS_STEREO(h)       ((h[3]) & 0x20)
+#define MA_DR_MP3_HDR_GET_STEREO_MODE(h)      (((h[3]) >> 6) & 3)
+#define MA_DR_MP3_HDR_GET_STEREO_MODE_EXT(h)  (((h[3]) >> 4) & 3)
+#define MA_DR_MP3_HDR_GET_LAYER(h)            (((h[1]) >> 1) & 3)
+#define MA_DR_MP3_HDR_GET_BITRATE(h)          ((h[2]) >> 4)
+#define MA_DR_MP3_HDR_GET_SAMPLE_RATE(h)      (((h[2]) >> 2) & 3)
+#define MA_DR_MP3_HDR_GET_MY_SAMPLE_RATE(h)   (MA_DR_MP3_HDR_GET_SAMPLE_RATE(h) + (((h[1] >> 3) & 1) + ((h[1] >> 4) & 1))*3)
+#define MA_DR_MP3_HDR_IS_FRAME_576(h)         ((h[1] & 14) == 2)
+#define MA_DR_MP3_HDR_IS_LAYER_1(h)           ((h[1] & 6) == 6)
+#define MA_DR_MP3_BITS_DEQUANTIZER_OUT        -1
+#define MA_DR_MP3_MAX_SCF                     (255 + MA_DR_MP3_BITS_DEQUANTIZER_OUT*4 - 210)
+#define MA_DR_MP3_MAX_SCFI                    ((MA_DR_MP3_MAX_SCF + 3) & ~3)
+#define MA_DR_MP3_MIN(a, b)           ((a) > (b) ? (b) : (a))
+#define MA_DR_MP3_MAX(a, b)           ((a) < (b) ? (b) : (a))
+#if !defined(MA_DR_MP3_NO_SIMD)
+#if !defined(MA_DR_MP3_ONLY_SIMD) && (defined(_M_X64) || defined(__x86_64__) || defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC))
+#define MA_DR_MP3_ONLY_SIMD
+#endif
+#if ((defined(_MSC_VER) && _MSC_VER >= 1400) && defined(_M_X64)) || ((defined(__i386) || defined(_M_IX86) || defined(__i386__) || defined(__x86_64__)) && ((defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__)))
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif
+#include <emmintrin.h>
+#define MA_DR_MP3_HAVE_SSE 1
+#define MA_DR_MP3_HAVE_SIMD 1
+#define MA_DR_MP3_VSTORE _mm_storeu_ps
+#define MA_DR_MP3_VLD _mm_loadu_ps
+#define MA_DR_MP3_VSET _mm_set1_ps
+#define MA_DR_MP3_VADD _mm_add_ps
+#define MA_DR_MP3_VSUB _mm_sub_ps
+#define MA_DR_MP3_VMUL _mm_mul_ps
+#define MA_DR_MP3_VMAC(a, x, y) _mm_add_ps(a, _mm_mul_ps(x, y))
+#define MA_DR_MP3_VMSB(a, x, y) _mm_sub_ps(a, _mm_mul_ps(x, y))
+#define MA_DR_MP3_VMUL_S(x, s)  _mm_mul_ps(x, _mm_set1_ps(s))
+#define MA_DR_MP3_VREV(x) _mm_shuffle_ps(x, x, _MM_SHUFFLE(0, 1, 2, 3))
+typedef __m128 ma_dr_mp3_f4;
+#if defined(_MSC_VER) || defined(MA_DR_MP3_ONLY_SIMD)
+#define ma_dr_mp3_cpuid __cpuid
+#else
+static __inline__ __attribute__((always_inline)) void ma_dr_mp3_cpuid(int CPUInfo[], const int InfoType)
+{
+#if defined(__PIC__)
+    __asm__ __volatile__(
+#if defined(__x86_64__)
+        "push %%rbx\n"
+        "cpuid\n"
+        "xchgl %%ebx, %1\n"
+        "pop  %%rbx\n"
+#else
+        "xchgl %%ebx, %1\n"
+        "cpuid\n"
+        "xchgl %%ebx, %1\n"
+#endif
+        : "=a" (CPUInfo[0]), "=r" (CPUInfo[1]), "=c" (CPUInfo[2]), "=d" (CPUInfo[3])
+        : "a" (InfoType));
+#else
+    __asm__ __volatile__(
+        "cpuid"
+        : "=a" (CPUInfo[0]), "=b" (CPUInfo[1]), "=c" (CPUInfo[2]), "=d" (CPUInfo[3])
+        : "a" (InfoType));
+#endif
+}
+#endif
+static int ma_dr_mp3_have_simd(void)
+{
+#ifdef MA_DR_MP3_ONLY_SIMD
+    return 1;
+#else
+    static int g_have_simd;
+    int CPUInfo[4];
+#ifdef MINIMP3_TEST
+    static int g_counter;
+    if (g_counter++ > 100)
+        return 0;
+#endif
+    if (g_have_simd)
+        goto end;
+    ma_dr_mp3_cpuid(CPUInfo, 0);
+    if (CPUInfo[0] > 0)
+    {
+        ma_dr_mp3_cpuid(CPUInfo, 1);
+        g_have_simd = (CPUInfo[3] & (1 << 26)) + 1;
+        return g_have_simd - 1;
+    }
+end:
+    return g_have_simd - 1;
+#endif
+}
+#elif defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64) || defined(_M_ARM64EC)
+#include <arm_neon.h>
+#define MA_DR_MP3_HAVE_SSE 0
+#define MA_DR_MP3_HAVE_SIMD 1
+#define MA_DR_MP3_VSTORE vst1q_f32
+#define MA_DR_MP3_VLD vld1q_f32
+#define MA_DR_MP3_VSET vmovq_n_f32
+#define MA_DR_MP3_VADD vaddq_f32
+#define MA_DR_MP3_VSUB vsubq_f32
+#define MA_DR_MP3_VMUL vmulq_f32
+#define MA_DR_MP3_VMAC(a, x, y) vmlaq_f32(a, x, y)
+#define MA_DR_MP3_VMSB(a, x, y) vmlsq_f32(a, x, y)
+#define MA_DR_MP3_VMUL_S(x, s)  vmulq_f32(x, vmovq_n_f32(s))
+#define MA_DR_MP3_VREV(x) vcombine_f32(vget_high_f32(vrev64q_f32(x)), vget_low_f32(vrev64q_f32(x)))
+typedef float32x4_t ma_dr_mp3_f4;
+static int ma_dr_mp3_have_simd(void)
+{
+    return 1;
+}
+#else
+#define MA_DR_MP3_HAVE_SSE 0
+#define MA_DR_MP3_HAVE_SIMD 0
+#ifdef MA_DR_MP3_ONLY_SIMD
+#error MA_DR_MP3_ONLY_SIMD used, but SSE/NEON not enabled
+#endif
+#endif
+#else
+#define MA_DR_MP3_HAVE_SIMD 0
+#endif
+#if defined(__ARM_ARCH) && (__ARM_ARCH >= 6) && !defined(__aarch64__) && !defined(_M_ARM64) && !defined(_M_ARM64EC) && !defined(__ARM_ARCH_6M__)
+#define MA_DR_MP3_HAVE_ARMV6 1
+static __inline__ __attribute__((always_inline)) ma_int32 ma_dr_mp3_clip_int16_arm(ma_int32 a)
+{
+    ma_int32 x = 0;
+    __asm__ ("ssat %0, #16, %1" : "=r"(x) : "r"(a));
+    return x;
+}
+#else
+#define MA_DR_MP3_HAVE_ARMV6 0
+#endif
+#ifndef MA_DR_MP3_ASSERT
+#include <assert.h>
+#define MA_DR_MP3_ASSERT(expression) assert(expression)
+#endif
+#ifndef MA_DR_MP3_COPY_MEMORY
+#define MA_DR_MP3_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz))
+#endif
+#ifndef MA_DR_MP3_MOVE_MEMORY
+#define MA_DR_MP3_MOVE_MEMORY(dst, src, sz) memmove((dst), (src), (sz))
+#endif
+#ifndef MA_DR_MP3_ZERO_MEMORY
+#define MA_DR_MP3_ZERO_MEMORY(p, sz) memset((p), 0, (sz))
+#endif
+#define MA_DR_MP3_ZERO_OBJECT(p) MA_DR_MP3_ZERO_MEMORY((p), sizeof(*(p)))
+#ifndef MA_DR_MP3_MALLOC
+#define MA_DR_MP3_MALLOC(sz) malloc((sz))
+#endif
+#ifndef MA_DR_MP3_REALLOC
+#define MA_DR_MP3_REALLOC(p, sz) realloc((p), (sz))
+#endif
+#ifndef MA_DR_MP3_FREE
+#define MA_DR_MP3_FREE(p) free((p))
+#endif
+typedef struct
+{
+    const ma_uint8 *buf;
+    int pos, limit;
+} ma_dr_mp3_bs;
+typedef struct
+{
+    float scf[3*64];
+    ma_uint8 total_bands, stereo_bands, bitalloc[64], scfcod[64];
+} ma_dr_mp3_L12_scale_info;
+typedef struct
+{
+    ma_uint8 tab_offset, code_tab_width, band_count;
+} ma_dr_mp3_L12_subband_alloc;
+typedef struct
+{
+    const ma_uint8 *sfbtab;
+    ma_uint16 part_23_length, big_values, scalefac_compress;
+    ma_uint8 global_gain, block_type, mixed_block_flag, n_long_sfb, n_short_sfb;
+    ma_uint8 table_select[3], region_count[3], subblock_gain[3];
+    ma_uint8 preflag, scalefac_scale, count1_table, scfsi;
+} ma_dr_mp3_L3_gr_info;
+typedef struct
+{
+    ma_dr_mp3_bs bs;
+    ma_uint8 maindata[MA_DR_MP3_MAX_BITRESERVOIR_BYTES + MA_DR_MP3_MAX_L3_FRAME_PAYLOAD_BYTES];
+    ma_dr_mp3_L3_gr_info gr_info[4];
+    float grbuf[2][576], scf[40], syn[18 + 15][2*32];
+    ma_uint8 ist_pos[2][39];
+} ma_dr_mp3dec_scratch;
+static void ma_dr_mp3_bs_init(ma_dr_mp3_bs *bs, const ma_uint8 *data, int bytes)
+{
+    bs->buf   = data;
+    bs->pos   = 0;
+    bs->limit = bytes*8;
+}
+static ma_uint32 ma_dr_mp3_bs_get_bits(ma_dr_mp3_bs *bs, int n)
+{
+    ma_uint32 next, cache = 0, s = bs->pos & 7;
+    int shl = n + s;
+    const ma_uint8 *p = bs->buf + (bs->pos >> 3);
+    if ((bs->pos += n) > bs->limit)
+        return 0;
+    next = *p++ & (255 >> s);
+    while ((shl -= 8) > 0)
+    {
+        cache |= next << shl;
+        next = *p++;
+    }
+    return cache | (next >> -shl);
+}
+static int ma_dr_mp3_hdr_valid(const ma_uint8 *h)
+{
+    return h[0] == 0xff &&
+        ((h[1] & 0xF0) == 0xf0 || (h[1] & 0xFE) == 0xe2) &&
+        (MA_DR_MP3_HDR_GET_LAYER(h) != 0) &&
+        (MA_DR_MP3_HDR_GET_BITRATE(h) != 15) &&
+        (MA_DR_MP3_HDR_GET_SAMPLE_RATE(h) != 3);
+}
+static int ma_dr_mp3_hdr_compare(const ma_uint8 *h1, const ma_uint8 *h2)
+{
+    return ma_dr_mp3_hdr_valid(h2) &&
+        ((h1[1] ^ h2[1]) & 0xFE) == 0 &&
+        ((h1[2] ^ h2[2]) & 0x0C) == 0 &&
+        !(MA_DR_MP3_HDR_IS_FREE_FORMAT(h1) ^ MA_DR_MP3_HDR_IS_FREE_FORMAT(h2));
+}
+static unsigned ma_dr_mp3_hdr_bitrate_kbps(const ma_uint8 *h)
+{
+    static const ma_uint8 halfrate[2][3][15] = {
+        { { 0,4,8,12,16,20,24,28,32,40,48,56,64,72,80 }, { 0,4,8,12,16,20,24,28,32,40,48,56,64,72,80 }, { 0,16,24,28,32,40,48,56,64,72,80,88,96,112,128 } },
+        { { 0,16,20,24,28,32,40,48,56,64,80,96,112,128,160 }, { 0,16,24,28,32,40,48,56,64,80,96,112,128,160,192 }, { 0,16,32,48,64,80,96,112,128,144,160,176,192,208,224 } },
+    };
+    return 2*halfrate[!!MA_DR_MP3_HDR_TEST_MPEG1(h)][MA_DR_MP3_HDR_GET_LAYER(h) - 1][MA_DR_MP3_HDR_GET_BITRATE(h)];
+}
+static unsigned ma_dr_mp3_hdr_sample_rate_hz(const ma_uint8 *h)
+{
+    static const unsigned g_hz[3] = { 44100, 48000, 32000 };
+    return g_hz[MA_DR_MP3_HDR_GET_SAMPLE_RATE(h)] >> (int)!MA_DR_MP3_HDR_TEST_MPEG1(h) >> (int)!MA_DR_MP3_HDR_TEST_NOT_MPEG25(h);
+}
+static unsigned ma_dr_mp3_hdr_frame_samples(const ma_uint8 *h)
+{
+    return MA_DR_MP3_HDR_IS_LAYER_1(h) ? 384 : (1152 >> (int)MA_DR_MP3_HDR_IS_FRAME_576(h));
+}
+static int ma_dr_mp3_hdr_frame_bytes(const ma_uint8 *h, int free_format_size)
+{
+    int frame_bytes = ma_dr_mp3_hdr_frame_samples(h)*ma_dr_mp3_hdr_bitrate_kbps(h)*125/ma_dr_mp3_hdr_sample_rate_hz(h);
+    if (MA_DR_MP3_HDR_IS_LAYER_1(h))
+    {
+        frame_bytes &= ~3;
+    }
+    return frame_bytes ? frame_bytes : free_format_size;
+}
+static int ma_dr_mp3_hdr_padding(const ma_uint8 *h)
+{
+    return MA_DR_MP3_HDR_TEST_PADDING(h) ? (MA_DR_MP3_HDR_IS_LAYER_1(h) ? 4 : 1) : 0;
+}
+#ifndef MA_DR_MP3_ONLY_MP3
+static const ma_dr_mp3_L12_subband_alloc *ma_dr_mp3_L12_subband_alloc_table(const ma_uint8 *hdr, ma_dr_mp3_L12_scale_info *sci)
+{
+    const ma_dr_mp3_L12_subband_alloc *alloc;
+    int mode = MA_DR_MP3_HDR_GET_STEREO_MODE(hdr);
+    int nbands, stereo_bands = (mode == MA_DR_MP3_MODE_MONO) ? 0 : (mode == MA_DR_MP3_MODE_JOINT_STEREO) ? (MA_DR_MP3_HDR_GET_STEREO_MODE_EXT(hdr) << 2) + 4 : 32;
+    if (MA_DR_MP3_HDR_IS_LAYER_1(hdr))
+    {
+        static const ma_dr_mp3_L12_subband_alloc g_alloc_L1[] = { { 76, 4, 32 } };
+        alloc = g_alloc_L1;
+        nbands = 32;
+    } else if (!MA_DR_MP3_HDR_TEST_MPEG1(hdr))
+    {
+        static const ma_dr_mp3_L12_subband_alloc g_alloc_L2M2[] = { { 60, 4, 4 }, { 44, 3, 7 }, { 44, 2, 19 } };
+        alloc = g_alloc_L2M2;
+        nbands = 30;
+    } else
+    {
+        static const ma_dr_mp3_L12_subband_alloc g_alloc_L2M1[] = { { 0, 4, 3 }, { 16, 4, 8 }, { 32, 3, 12 }, { 40, 2, 7 } };
+        int sample_rate_idx = MA_DR_MP3_HDR_GET_SAMPLE_RATE(hdr);
+        unsigned kbps = ma_dr_mp3_hdr_bitrate_kbps(hdr) >> (int)(mode != MA_DR_MP3_MODE_MONO);
+        if (!kbps)
+        {
+            kbps = 192;
+        }
+        alloc = g_alloc_L2M1;
+        nbands = 27;
+        if (kbps < 56)
+        {
+            static const ma_dr_mp3_L12_subband_alloc g_alloc_L2M1_lowrate[] = { { 44, 4, 2 }, { 44, 3, 10 } };
+            alloc = g_alloc_L2M1_lowrate;
+            nbands = sample_rate_idx == 2 ? 12 : 8;
+        } else if (kbps >= 96 && sample_rate_idx != 1)
+        {
+            nbands = 30;
+        }
+    }
+    sci->total_bands = (ma_uint8)nbands;
+    sci->stereo_bands = (ma_uint8)MA_DR_MP3_MIN(stereo_bands, nbands);
+    return alloc;
+}
+static void ma_dr_mp3_L12_read_scalefactors(ma_dr_mp3_bs *bs, ma_uint8 *pba, ma_uint8 *scfcod, int bands, float *scf)
+{
+    static const float g_deq_L12[18*3] = {
+#define MA_DR_MP3_DQ(x) 9.53674316e-07f/x, 7.56931807e-07f/x, 6.00777173e-07f/x
+        MA_DR_MP3_DQ(3),MA_DR_MP3_DQ(7),MA_DR_MP3_DQ(15),MA_DR_MP3_DQ(31),MA_DR_MP3_DQ(63),MA_DR_MP3_DQ(127),MA_DR_MP3_DQ(255),MA_DR_MP3_DQ(511),MA_DR_MP3_DQ(1023),MA_DR_MP3_DQ(2047),MA_DR_MP3_DQ(4095),MA_DR_MP3_DQ(8191),MA_DR_MP3_DQ(16383),MA_DR_MP3_DQ(32767),MA_DR_MP3_DQ(65535),MA_DR_MP3_DQ(3),MA_DR_MP3_DQ(5),MA_DR_MP3_DQ(9)
+    };
+    int i, m;
+    for (i = 0; i < bands; i++)
+    {
+        float s = 0;
+        int ba = *pba++;
+        int mask = ba ? 4 + ((19 >> scfcod[i]) & 3) : 0;
+        for (m = 4; m; m >>= 1)
+        {
+            if (mask & m)
+            {
+                int b = ma_dr_mp3_bs_get_bits(bs, 6);
+                s = g_deq_L12[ba*3 - 6 + b % 3]*(int)(1 << 21 >> b/3);
+            }
+            *scf++ = s;
+        }
+    }
+}
+static void ma_dr_mp3_L12_read_scale_info(const ma_uint8 *hdr, ma_dr_mp3_bs *bs, ma_dr_mp3_L12_scale_info *sci)
+{
+    static const ma_uint8 g_bitalloc_code_tab[] = {
+        0,17, 3, 4, 5,6,7, 8,9,10,11,12,13,14,15,16,
+        0,17,18, 3,19,4,5, 6,7, 8, 9,10,11,12,13,16,
+        0,17,18, 3,19,4,5,16,
+        0,17,18,16,
+        0,17,18,19, 4,5,6, 7,8, 9,10,11,12,13,14,15,
+        0,17,18, 3,19,4,5, 6,7, 8, 9,10,11,12,13,14,
+        0, 2, 3, 4, 5,6,7, 8,9,10,11,12,13,14,15,16
+    };
+    const ma_dr_mp3_L12_subband_alloc *subband_alloc = ma_dr_mp3_L12_subband_alloc_table(hdr, sci);
+    int i, k = 0, ba_bits = 0;
+    const ma_uint8 *ba_code_tab = g_bitalloc_code_tab;
+    for (i = 0; i < sci->total_bands; i++)
+    {
+        ma_uint8 ba;
+        if (i == k)
+        {
+            k += subband_alloc->band_count;
+            ba_bits = subband_alloc->code_tab_width;
+            ba_code_tab = g_bitalloc_code_tab + subband_alloc->tab_offset;
+            subband_alloc++;
+        }
+        ba = ba_code_tab[ma_dr_mp3_bs_get_bits(bs, ba_bits)];
+        sci->bitalloc[2*i] = ba;
+        if (i < sci->stereo_bands)
+        {
+            ba = ba_code_tab[ma_dr_mp3_bs_get_bits(bs, ba_bits)];
+        }
+        sci->bitalloc[2*i + 1] = sci->stereo_bands ? ba : 0;
+    }
+    for (i = 0; i < 2*sci->total_bands; i++)
+    {
+        sci->scfcod[i] = (ma_uint8)(sci->bitalloc[i] ? MA_DR_MP3_HDR_IS_LAYER_1(hdr) ? 2 : ma_dr_mp3_bs_get_bits(bs, 2) : 6);
+    }
+    ma_dr_mp3_L12_read_scalefactors(bs, sci->bitalloc, sci->scfcod, sci->total_bands*2, sci->scf);
+    for (i = sci->stereo_bands; i < sci->total_bands; i++)
+    {
+        sci->bitalloc[2*i + 1] = 0;
+    }
+}
+static int ma_dr_mp3_L12_dequantize_granule(float *grbuf, ma_dr_mp3_bs *bs, ma_dr_mp3_L12_scale_info *sci, int group_size)
+{
+    int i, j, k, choff = 576;
+    for (j = 0; j < 4; j++)
+    {
+        float *dst = grbuf + group_size*j;
+        for (i = 0; i < 2*sci->total_bands; i++)
+        {
+            int ba = sci->bitalloc[i];
+            if (ba != 0)
+            {
+                if (ba < 17)
+                {
+                    int half = (1 << (ba - 1)) - 1;
+                    for (k = 0; k < group_size; k++)
+                    {
+                        dst[k] = (float)((int)ma_dr_mp3_bs_get_bits(bs, ba) - half);
+                    }
+                } else
+                {
+                    unsigned mod = (2 << (ba - 17)) + 1;
+                    unsigned code = ma_dr_mp3_bs_get_bits(bs, mod + 2 - (mod >> 3));
+                    for (k = 0; k < group_size; k++, code /= mod)
+                    {
+                        dst[k] = (float)((int)(code % mod - mod/2));
+                    }
+                }
+            }
+            dst += choff;
+            choff = 18 - choff;
+        }
+    }
+    return group_size*4;
+}
+static void ma_dr_mp3_L12_apply_scf_384(ma_dr_mp3_L12_scale_info *sci, const float *scf, float *dst)
+{
+    int i, k;
+    MA_DR_MP3_COPY_MEMORY(dst + 576 + sci->stereo_bands*18, dst + sci->stereo_bands*18, (sci->total_bands - sci->stereo_bands)*18*sizeof(float));
+    for (i = 0; i < sci->total_bands; i++, dst += 18, scf += 6)
+    {
+        for (k = 0; k < 12; k++)
+        {
+            dst[k + 0]   *= scf[0];
+            dst[k + 576] *= scf[3];
+        }
+    }
+}
+#endif
+static int ma_dr_mp3_L3_read_side_info(ma_dr_mp3_bs *bs, ma_dr_mp3_L3_gr_info *gr, const ma_uint8 *hdr)
+{
+    static const ma_uint8 g_scf_long[8][23] = {
+        { 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 },
+        { 12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2,0 },
+        { 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 },
+        { 6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,54,62,70,76,36,0 },
+        { 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 },
+        { 4,4,4,4,4,4,6,6,8,8,10,12,16,20,24,28,34,42,50,54,76,158,0 },
+        { 4,4,4,4,4,4,6,6,6,8,10,12,16,18,22,28,34,40,46,54,54,192,0 },
+        { 4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102,26,0 }
+    };
+    static const ma_uint8 g_scf_short[8][40] = {
+        { 4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 },
+        { 8,8,8,8,8,8,8,8,8,12,12,12,16,16,16,20,20,20,24,24,24,28,28,28,36,36,36,2,2,2,2,2,2,2,2,2,26,26,26,0 },
+        { 4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,8,8,8,10,10,10,14,14,14,18,18,18,26,26,26,32,32,32,42,42,42,18,18,18,0 },
+        { 4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,32,32,32,44,44,44,12,12,12,0 },
+        { 4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 },
+        { 4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,22,22,22,30,30,30,56,56,56,0 },
+        { 4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,10,10,10,12,12,12,14,14,14,16,16,16,20,20,20,26,26,26,66,66,66,0 },
+        { 4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,12,12,12,16,16,16,20,20,20,26,26,26,34,34,34,42,42,42,12,12,12,0 }
+    };
+    static const ma_uint8 g_scf_mixed[8][40] = {
+        { 6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 },
+        { 12,12,12,4,4,4,8,8,8,12,12,12,16,16,16,20,20,20,24,24,24,28,28,28,36,36,36,2,2,2,2,2,2,2,2,2,26,26,26,0 },
+        { 6,6,6,6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,14,14,14,18,18,18,26,26,26,32,32,32,42,42,42,18,18,18,0 },
+        { 6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,32,32,32,44,44,44,12,12,12,0 },
+        { 6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 },
+        { 4,4,4,4,4,4,6,6,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,22,22,22,30,30,30,56,56,56,0 },
+        { 4,4,4,4,4,4,6,6,4,4,4,6,6,6,6,6,6,10,10,10,12,12,12,14,14,14,16,16,16,20,20,20,26,26,26,66,66,66,0 },
+        { 4,4,4,4,4,4,6,6,4,4,4,6,6,6,8,8,8,12,12,12,16,16,16,20,20,20,26,26,26,34,34,34,42,42,42,12,12,12,0 }
+    };
+    unsigned tables, scfsi = 0;
+    int main_data_begin, part_23_sum = 0;
+    int gr_count = MA_DR_MP3_HDR_IS_MONO(hdr) ? 1 : 2;
+    int sr_idx = MA_DR_MP3_HDR_GET_MY_SAMPLE_RATE(hdr); sr_idx -= (sr_idx != 0);
+    if (MA_DR_MP3_HDR_TEST_MPEG1(hdr))
+    {
+        gr_count *= 2;
+        main_data_begin = ma_dr_mp3_bs_get_bits(bs, 9);
+        scfsi = ma_dr_mp3_bs_get_bits(bs, 7 + gr_count);
+    } else
+    {
+        main_data_begin = ma_dr_mp3_bs_get_bits(bs, 8 + gr_count) >> gr_count;
+    }
+    do
+    {
+        if (MA_DR_MP3_HDR_IS_MONO(hdr))
+        {
+            scfsi <<= 4;
+        }
+        gr->part_23_length = (ma_uint16)ma_dr_mp3_bs_get_bits(bs, 12);
+        part_23_sum += gr->part_23_length;
+        gr->big_values = (ma_uint16)ma_dr_mp3_bs_get_bits(bs,  9);
+        if (gr->big_values > 288)
+        {
+            return -1;
+        }
+        gr->global_gain = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 8);
+        gr->scalefac_compress = (ma_uint16)ma_dr_mp3_bs_get_bits(bs, MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 4 : 9);
+        gr->sfbtab = g_scf_long[sr_idx];
+        gr->n_long_sfb  = 22;
+        gr->n_short_sfb = 0;
+        if (ma_dr_mp3_bs_get_bits(bs, 1))
+        {
+            gr->block_type = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 2);
+            if (!gr->block_type)
+            {
+                return -1;
+            }
+            gr->mixed_block_flag = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 1);
+            gr->region_count[0] = 7;
+            gr->region_count[1] = 255;
+            if (gr->block_type == MA_DR_MP3_SHORT_BLOCK_TYPE)
+            {
+                scfsi &= 0x0F0F;
+                if (!gr->mixed_block_flag)
+                {
+                    gr->region_count[0] = 8;
+                    gr->sfbtab = g_scf_short[sr_idx];
+                    gr->n_long_sfb = 0;
+                    gr->n_short_sfb = 39;
+                } else
+                {
+                    gr->sfbtab = g_scf_mixed[sr_idx];
+                    gr->n_long_sfb = MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 8 : 6;
+                    gr->n_short_sfb = 30;
+                }
+            }
+            tables = ma_dr_mp3_bs_get_bits(bs, 10);
+            tables <<= 5;
+            gr->subblock_gain[0] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 3);
+            gr->subblock_gain[1] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 3);
+            gr->subblock_gain[2] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 3);
+        } else
+        {
+            gr->block_type = 0;
+            gr->mixed_block_flag = 0;
+            tables = ma_dr_mp3_bs_get_bits(bs, 15);
+            gr->region_count[0] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 4);
+            gr->region_count[1] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 3);
+            gr->region_count[2] = 255;
+        }
+        gr->table_select[0] = (ma_uint8)(tables >> 10);
+        gr->table_select[1] = (ma_uint8)((tables >> 5) & 31);
+        gr->table_select[2] = (ma_uint8)((tables) & 31);
+        gr->preflag = (ma_uint8)(MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? ma_dr_mp3_bs_get_bits(bs, 1) : (gr->scalefac_compress >= 500));
+        gr->scalefac_scale = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 1);
+        gr->count1_table = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 1);
+        gr->scfsi = (ma_uint8)((scfsi >> 12) & 15);
+        scfsi <<= 4;
+        gr++;
+    } while(--gr_count);
+    if (part_23_sum + bs->pos > bs->limit + main_data_begin*8)
+    {
+        return -1;
+    }
+    return main_data_begin;
+}
+static void ma_dr_mp3_L3_read_scalefactors(ma_uint8 *scf, ma_uint8 *ist_pos, const ma_uint8 *scf_size, const ma_uint8 *scf_count, ma_dr_mp3_bs *bitbuf, int scfsi)
+{
+    int i, k;
+    for (i = 0; i < 4 && scf_count[i]; i++, scfsi *= 2)
+    {
+        int cnt = scf_count[i];
+        if (scfsi & 8)
+        {
+            MA_DR_MP3_COPY_MEMORY(scf, ist_pos, cnt);
+        } else
+        {
+            int bits = scf_size[i];
+            if (!bits)
+            {
+                MA_DR_MP3_ZERO_MEMORY(scf, cnt);
+                MA_DR_MP3_ZERO_MEMORY(ist_pos, cnt);
+            } else
+            {
+                int max_scf = (scfsi < 0) ? (1 << bits) - 1 : -1;
+                for (k = 0; k < cnt; k++)
+                {
+                    int s = ma_dr_mp3_bs_get_bits(bitbuf, bits);
+                    ist_pos[k] = (ma_uint8)(s == max_scf ? -1 : s);
+                    scf[k] = (ma_uint8)s;
+                }
+            }
+        }
+        ist_pos += cnt;
+        scf += cnt;
+    }
+    scf[0] = scf[1] = scf[2] = 0;
+}
+static float ma_dr_mp3_L3_ldexp_q2(float y, int exp_q2)
+{
+    static const float g_expfrac[4] = { 9.31322575e-10f,7.83145814e-10f,6.58544508e-10f,5.53767716e-10f };
+    int e;
+    do
+    {
+        e = MA_DR_MP3_MIN(30*4, exp_q2);
+        y *= g_expfrac[e & 3]*(1 << 30 >> (e >> 2));
+    } while ((exp_q2 -= e) > 0);
+    return y;
+}
+#if (defined(__GNUC__) && (__GNUC__ >= 14)) && !defined(__clang__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wstringop-overflow"
+#endif
+static void ma_dr_mp3_L3_decode_scalefactors(const ma_uint8 *hdr, ma_uint8 *ist_pos, ma_dr_mp3_bs *bs, const ma_dr_mp3_L3_gr_info *gr, float *scf, int ch)
+{
+    static const ma_uint8 g_scf_partitions[3][28] = {
+        { 6,5,5, 5,6,5,5,5,6,5, 7,3,11,10,0,0, 7, 7, 7,0, 6, 6,6,3, 8, 8,5,0 },
+        { 8,9,6,12,6,9,9,9,6,9,12,6,15,18,0,0, 6,15,12,0, 6,12,9,6, 6,18,9,0 },
+        { 9,9,6,12,9,9,9,9,9,9,12,6,18,18,0,0,12,12,12,0,12, 9,9,6,15,12,9,0 }
+    };
+    const ma_uint8 *scf_partition = g_scf_partitions[!!gr->n_short_sfb + !gr->n_long_sfb];
+    ma_uint8 scf_size[4], iscf[40];
+    int i, scf_shift = gr->scalefac_scale + 1, gain_exp, scfsi = gr->scfsi;
+    float gain;
+    if (MA_DR_MP3_HDR_TEST_MPEG1(hdr))
+    {
+        static const ma_uint8 g_scfc_decode[16] = { 0,1,2,3, 12,5,6,7, 9,10,11,13, 14,15,18,19 };
+        int part = g_scfc_decode[gr->scalefac_compress];
+        scf_size[1] = scf_size[0] = (ma_uint8)(part >> 2);
+        scf_size[3] = scf_size[2] = (ma_uint8)(part & 3);
+    } else
+    {
+        static const ma_uint8 g_mod[6*4] = { 5,5,4,4,5,5,4,1,4,3,1,1,5,6,6,1,4,4,4,1,4,3,1,1 };
+        int k, modprod, sfc, ist = MA_DR_MP3_HDR_TEST_I_STEREO(hdr) && ch;
+        sfc = gr->scalefac_compress >> ist;
+        for (k = ist*3*4; sfc >= 0; sfc -= modprod, k += 4)
+        {
+            for (modprod = 1, i = 3; i >= 0; i--)
+            {
+                scf_size[i] = (ma_uint8)(sfc / modprod % g_mod[k + i]);
+                modprod *= g_mod[k + i];
+            }
+        }
+        scf_partition += k;
+        scfsi = -16;
+    }
+    ma_dr_mp3_L3_read_scalefactors(iscf, ist_pos, scf_size, scf_partition, bs, scfsi);
+    if (gr->n_short_sfb)
+    {
+        int sh = 3 - scf_shift;
+        for (i = 0; i < gr->n_short_sfb; i += 3)
+        {
+            iscf[gr->n_long_sfb + i + 0] = (ma_uint8)(iscf[gr->n_long_sfb + i + 0] + (gr->subblock_gain[0] << sh));
+            iscf[gr->n_long_sfb + i + 1] = (ma_uint8)(iscf[gr->n_long_sfb + i + 1] + (gr->subblock_gain[1] << sh));
+            iscf[gr->n_long_sfb + i + 2] = (ma_uint8)(iscf[gr->n_long_sfb + i + 2] + (gr->subblock_gain[2] << sh));
+        }
+    } else if (gr->preflag)
+    {
+        static const ma_uint8 g_preamp[10] = { 1,1,1,1,2,2,3,3,3,2 };
+        for (i = 0; i < 10; i++)
+        {
+            iscf[11 + i] = (ma_uint8)(iscf[11 + i] + g_preamp[i]);
+        }
+    }
+    gain_exp = gr->global_gain + MA_DR_MP3_BITS_DEQUANTIZER_OUT*4 - 210 - (MA_DR_MP3_HDR_IS_MS_STEREO(hdr) ? 2 : 0);
+    gain = ma_dr_mp3_L3_ldexp_q2(1 << (MA_DR_MP3_MAX_SCFI/4),  MA_DR_MP3_MAX_SCFI - gain_exp);
+    for (i = 0; i < (int)(gr->n_long_sfb + gr->n_short_sfb); i++)
+    {
+        scf[i] = ma_dr_mp3_L3_ldexp_q2(gain, iscf[i] << scf_shift);
+    }
+}
+#if (defined(__GNUC__) && (__GNUC__ >= 14)) && !defined(__clang__)
+    #pragma GCC diagnostic pop
+#endif
+static const float ma_dr_mp3_g_pow43[129 + 16] = {
+    0,-1,-2.519842f,-4.326749f,-6.349604f,-8.549880f,-10.902724f,-13.390518f,-16.000000f,-18.720754f,-21.544347f,-24.463781f,-27.473142f,-30.567351f,-33.741992f,-36.993181f,
+    0,1,2.519842f,4.326749f,6.349604f,8.549880f,10.902724f,13.390518f,16.000000f,18.720754f,21.544347f,24.463781f,27.473142f,30.567351f,33.741992f,36.993181f,40.317474f,43.711787f,47.173345f,50.699631f,54.288352f,57.937408f,61.644865f,65.408941f,69.227979f,73.100443f,77.024898f,81.000000f,85.024491f,89.097188f,93.216975f,97.382800f,101.593667f,105.848633f,110.146801f,114.487321f,118.869381f,123.292209f,127.755065f,132.257246f,136.798076f,141.376907f,145.993119f,150.646117f,155.335327f,160.060199f,164.820202f,169.614826f,174.443577f,179.305980f,184.201575f,189.129918f,194.090580f,199.083145f,204.107210f,209.162385f,214.248292f,219.364564f,224.510845f,229.686789f,234.892058f,240.126328f,245.389280f,250.680604f,256.000000f,261.347174f,266.721841f,272.123723f,277.552547f,283.008049f,288.489971f,293.998060f,299.532071f,305.091761f,310.676898f,316.287249f,321.922592f,327.582707f,333.267377f,338.976394f,344.709550f,350.466646f,356.247482f,362.051866f,367.879608f,373.730522f,379.604427f,385.501143f,391.420496f,397.362314f,403.326427f,409.312672f,415.320884f,421.350905f,427.402579f,433.475750f,439.570269f,445.685987f,451.822757f,457.980436f,464.158883f,470.357960f,476.577530f,482.817459f,489.077615f,495.357868f,501.658090f,507.978156f,514.317941f,520.677324f,527.056184f,533.454404f,539.871867f,546.308458f,552.764065f,559.238575f,565.731879f,572.243870f,578.774440f,585.323483f,591.890898f,598.476581f,605.080431f,611.702349f,618.342238f,625.000000f,631.675540f,638.368763f,645.079578f
+};
+static float ma_dr_mp3_L3_pow_43(int x)
+{
+    float frac;
+    int sign, mult = 256;
+    if (x < 129)
+    {
+        return ma_dr_mp3_g_pow43[16 + x];
+    }
+    if (x < 1024)
+    {
+        mult = 16;
+        x <<= 3;
+    }
+    sign = 2*x & 64;
+    frac = (float)((x & 63) - sign) / ((x & ~63) + sign);
+    return ma_dr_mp3_g_pow43[16 + ((x + sign) >> 6)]*(1.f + frac*((4.f/3) + frac*(2.f/9)))*mult;
+}
+static void ma_dr_mp3_L3_huffman(float *dst, ma_dr_mp3_bs *bs, const ma_dr_mp3_L3_gr_info *gr_info, const float *scf, int layer3gr_limit)
+{
+    static const ma_int16 tabs[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        785,785,785,785,784,784,784,784,513,513,513,513,513,513,513,513,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,
+        -255,1313,1298,1282,785,785,785,785,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,290,288,
+        -255,1313,1298,1282,769,769,769,769,529,529,529,529,529,529,529,529,528,528,528,528,528,528,528,528,512,512,512,512,512,512,512,512,290,288,
+        -253,-318,-351,-367,785,785,785,785,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,819,818,547,547,275,275,275,275,561,560,515,546,289,274,288,258,
+        -254,-287,1329,1299,1314,1312,1057,1057,1042,1042,1026,1026,784,784,784,784,529,529,529,529,529,529,529,529,769,769,769,769,768,768,768,768,563,560,306,306,291,259,
+        -252,-413,-477,-542,1298,-575,1041,1041,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-383,-399,1107,1092,1106,1061,849,849,789,789,1104,1091,773,773,1076,1075,341,340,325,309,834,804,577,577,532,532,516,516,832,818,803,816,561,561,531,531,515,546,289,289,288,258,
+        -252,-429,-493,-559,1057,1057,1042,1042,529,529,529,529,529,529,529,529,784,784,784,784,769,769,769,769,512,512,512,512,512,512,512,512,-382,1077,-415,1106,1061,1104,849,849,789,789,1091,1076,1029,1075,834,834,597,581,340,340,339,324,804,833,532,532,832,772,818,803,817,787,816,771,290,290,290,290,288,258,
+        -253,-349,-414,-447,-463,1329,1299,-479,1314,1312,1057,1057,1042,1042,1026,1026,785,785,785,785,784,784,784,784,769,769,769,769,768,768,768,768,-319,851,821,-335,836,850,805,849,341,340,325,336,533,533,579,579,564,564,773,832,578,548,563,516,321,276,306,291,304,259,
+        -251,-572,-733,-830,-863,-879,1041,1041,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-511,-527,-543,1396,1351,1381,1366,1395,1335,1380,-559,1334,1138,1138,1063,1063,1350,1392,1031,1031,1062,1062,1364,1363,1120,1120,1333,1348,881,881,881,881,375,374,359,373,343,358,341,325,791,791,1123,1122,-703,1105,1045,-719,865,865,790,790,774,774,1104,1029,338,293,323,308,-799,-815,833,788,772,818,803,816,322,292,307,320,561,531,515,546,289,274,288,258,
+        -251,-525,-605,-685,-765,-831,-846,1298,1057,1057,1312,1282,785,785,785,785,784,784,784,784,769,769,769,769,512,512,512,512,512,512,512,512,1399,1398,1383,1367,1382,1396,1351,-511,1381,1366,1139,1139,1079,1079,1124,1124,1364,1349,1363,1333,882,882,882,882,807,807,807,807,1094,1094,1136,1136,373,341,535,535,881,775,867,822,774,-591,324,338,-671,849,550,550,866,864,609,609,293,336,534,534,789,835,773,-751,834,804,308,307,833,788,832,772,562,562,547,547,305,275,560,515,290,290,
+        -252,-397,-477,-557,-622,-653,-719,-735,-750,1329,1299,1314,1057,1057,1042,1042,1312,1282,1024,1024,785,785,785,785,784,784,784,784,769,769,769,769,-383,1127,1141,1111,1126,1140,1095,1110,869,869,883,883,1079,1109,882,882,375,374,807,868,838,881,791,-463,867,822,368,263,852,837,836,-543,610,610,550,550,352,336,534,534,865,774,851,821,850,805,593,533,579,564,773,832,578,578,548,548,577,577,307,276,306,291,516,560,259,259,
+        -250,-2107,-2507,-2764,-2909,-2974,-3007,-3023,1041,1041,1040,1040,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-767,-1052,-1213,-1277,-1358,-1405,-1469,-1535,-1550,-1582,-1614,-1647,-1662,-1694,-1726,-1759,-1774,-1807,-1822,-1854,-1886,1565,-1919,-1935,-1951,-1967,1731,1730,1580,1717,-1983,1729,1564,-1999,1548,-2015,-2031,1715,1595,-2047,1714,-2063,1610,-2079,1609,-2095,1323,1323,1457,1457,1307,1307,1712,1547,1641,1700,1699,1594,1685,1625,1442,1442,1322,1322,-780,-973,-910,1279,1278,1277,1262,1276,1261,1275,1215,1260,1229,-959,974,974,989,989,-943,735,478,478,495,463,506,414,-1039,1003,958,1017,927,942,987,957,431,476,1272,1167,1228,-1183,1256,-1199,895,895,941,941,1242,1227,1212,1135,1014,1014,490,489,503,487,910,1013,985,925,863,894,970,955,1012,847,-1343,831,755,755,984,909,428,366,754,559,-1391,752,486,457,924,997,698,698,983,893,740,740,908,877,739,739,667,667,953,938,497,287,271,271,683,606,590,712,726,574,302,302,738,736,481,286,526,725,605,711,636,724,696,651,589,681,666,710,364,467,573,695,466,466,301,465,379,379,709,604,665,679,316,316,634,633,436,436,464,269,424,394,452,332,438,363,347,408,393,448,331,422,362,407,392,421,346,406,391,376,375,359,1441,1306,-2367,1290,-2383,1337,-2399,-2415,1426,1321,-2431,1411,1336,-2447,-2463,-2479,1169,1169,1049,1049,1424,1289,1412,1352,1319,-2495,1154,1154,1064,1064,1153,1153,416,390,360,404,403,389,344,374,373,343,358,372,327,357,342,311,356,326,1395,1394,1137,1137,1047,1047,1365,1392,1287,1379,1334,1364,1349,1378,1318,1363,792,792,792,792,1152,1152,1032,1032,1121,1121,1046,1046,1120,1120,1030,1030,-2895,1106,1061,1104,849,849,789,789,1091,1076,1029,1090,1060,1075,833,833,309,324,532,532,832,772,818,803,561,561,531,560,515,546,289,274,288,258,
+        -250,-1179,-1579,-1836,-1996,-2124,-2253,-2333,-2413,-2477,-2542,-2574,-2607,-2622,-2655,1314,1313,1298,1312,1282,785,785,785,785,1040,1040,1025,1025,768,768,768,768,-766,-798,-830,-862,-895,-911,-927,-943,-959,-975,-991,-1007,-1023,-1039,-1055,-1070,1724,1647,-1103,-1119,1631,1767,1662,1738,1708,1723,-1135,1780,1615,1779,1599,1677,1646,1778,1583,-1151,1777,1567,1737,1692,1765,1722,1707,1630,1751,1661,1764,1614,1736,1676,1763,1750,1645,1598,1721,1691,1762,1706,1582,1761,1566,-1167,1749,1629,767,766,751,765,494,494,735,764,719,749,734,763,447,447,748,718,477,506,431,491,446,476,461,505,415,430,475,445,504,399,460,489,414,503,383,474,429,459,502,502,746,752,488,398,501,473,413,472,486,271,480,270,-1439,-1455,1357,-1471,-1487,-1503,1341,1325,-1519,1489,1463,1403,1309,-1535,1372,1448,1418,1476,1356,1462,1387,-1551,1475,1340,1447,1402,1386,-1567,1068,1068,1474,1461,455,380,468,440,395,425,410,454,364,467,466,464,453,269,409,448,268,432,1371,1473,1432,1417,1308,1460,1355,1446,1459,1431,1083,1083,1401,1416,1458,1445,1067,1067,1370,1457,1051,1051,1291,1430,1385,1444,1354,1415,1400,1443,1082,1082,1173,1113,1186,1066,1185,1050,-1967,1158,1128,1172,1097,1171,1081,-1983,1157,1112,416,266,375,400,1170,1142,1127,1065,793,793,1169,1033,1156,1096,1141,1111,1155,1080,1126,1140,898,898,808,808,897,897,792,792,1095,1152,1032,1125,1110,1139,1079,1124,882,807,838,881,853,791,-2319,867,368,263,822,852,837,866,806,865,-2399,851,352,262,534,534,821,836,594,594,549,549,593,593,533,533,848,773,579,579,564,578,548,563,276,276,577,576,306,291,516,560,305,305,275,259,
+        -251,-892,-2058,-2620,-2828,-2957,-3023,-3039,1041,1041,1040,1040,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-511,-527,-543,-559,1530,-575,-591,1528,1527,1407,1526,1391,1023,1023,1023,1023,1525,1375,1268,1268,1103,1103,1087,1087,1039,1039,1523,-604,815,815,815,815,510,495,509,479,508,463,507,447,431,505,415,399,-734,-782,1262,-815,1259,1244,-831,1258,1228,-847,-863,1196,-879,1253,987,987,748,-767,493,493,462,477,414,414,686,669,478,446,461,445,474,429,487,458,412,471,1266,1264,1009,1009,799,799,-1019,-1276,-1452,-1581,-1677,-1757,-1821,-1886,-1933,-1997,1257,1257,1483,1468,1512,1422,1497,1406,1467,1496,1421,1510,1134,1134,1225,1225,1466,1451,1374,1405,1252,1252,1358,1480,1164,1164,1251,1251,1238,1238,1389,1465,-1407,1054,1101,-1423,1207,-1439,830,830,1248,1038,1237,1117,1223,1148,1236,1208,411,426,395,410,379,269,1193,1222,1132,1235,1221,1116,976,976,1192,1162,1177,1220,1131,1191,963,963,-1647,961,780,-1663,558,558,994,993,437,408,393,407,829,978,813,797,947,-1743,721,721,377,392,844,950,828,890,706,706,812,859,796,960,948,843,934,874,571,571,-1919,690,555,689,421,346,539,539,944,779,918,873,932,842,903,888,570,570,931,917,674,674,-2575,1562,-2591,1609,-2607,1654,1322,1322,1441,1441,1696,1546,1683,1593,1669,1624,1426,1426,1321,1321,1639,1680,1425,1425,1305,1305,1545,1668,1608,1623,1667,1592,1638,1666,1320,1320,1652,1607,1409,1409,1304,1304,1288,1288,1664,1637,1395,1395,1335,1335,1622,1636,1394,1394,1319,1319,1606,1621,1392,1392,1137,1137,1137,1137,345,390,360,375,404,373,1047,-2751,-2767,-2783,1062,1121,1046,-2799,1077,-2815,1106,1061,789,789,1105,1104,263,355,310,340,325,354,352,262,339,324,1091,1076,1029,1090,1060,1075,833,833,788,788,1088,1028,818,818,803,803,561,561,531,531,816,771,546,546,289,274,288,258,
+        -253,-317,-381,-446,-478,-509,1279,1279,-811,-1179,-1451,-1756,-1900,-2028,-2189,-2253,-2333,-2414,-2445,-2511,-2526,1313,1298,-2559,1041,1041,1040,1040,1025,1025,1024,1024,1022,1007,1021,991,1020,975,1019,959,687,687,1018,1017,671,671,655,655,1016,1015,639,639,758,758,623,623,757,607,756,591,755,575,754,559,543,543,1009,783,-575,-621,-685,-749,496,-590,750,749,734,748,974,989,1003,958,988,973,1002,942,987,957,972,1001,926,986,941,971,956,1000,910,985,925,999,894,970,-1071,-1087,-1102,1390,-1135,1436,1509,1451,1374,-1151,1405,1358,1480,1420,-1167,1507,1494,1389,1342,1465,1435,1450,1326,1505,1310,1493,1373,1479,1404,1492,1464,1419,428,443,472,397,736,526,464,464,486,457,442,471,484,482,1357,1449,1434,1478,1388,1491,1341,1490,1325,1489,1463,1403,1309,1477,1372,1448,1418,1433,1476,1356,1462,1387,-1439,1475,1340,1447,1402,1474,1324,1461,1371,1473,269,448,1432,1417,1308,1460,-1711,1459,-1727,1441,1099,1099,1446,1386,1431,1401,-1743,1289,1083,1083,1160,1160,1458,1445,1067,1067,1370,1457,1307,1430,1129,1129,1098,1098,268,432,267,416,266,400,-1887,1144,1187,1082,1173,1113,1186,1066,1050,1158,1128,1143,1172,1097,1171,1081,420,391,1157,1112,1170,1142,1127,1065,1169,1049,1156,1096,1141,1111,1155,1080,1126,1154,1064,1153,1140,1095,1048,-2159,1125,1110,1137,-2175,823,823,1139,1138,807,807,384,264,368,263,868,838,853,791,867,822,852,837,866,806,865,790,-2319,851,821,836,352,262,850,805,849,-2399,533,533,835,820,336,261,578,548,563,577,532,532,832,772,562,562,547,547,305,275,560,515,290,290,288,258 };
+    static const ma_uint8 tab32[] = { 130,162,193,209,44,28,76,140,9,9,9,9,9,9,9,9,190,254,222,238,126,94,157,157,109,61,173,205};
+    static const ma_uint8 tab33[] = { 252,236,220,204,188,172,156,140,124,108,92,76,60,44,28,12 };
+    static const ma_int16 tabindex[2*16] = { 0,32,64,98,0,132,180,218,292,364,426,538,648,746,0,1126,1460,1460,1460,1460,1460,1460,1460,1460,1842,1842,1842,1842,1842,1842,1842,1842 };
+    static const ma_uint8 g_linbits[] =  { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,6,8,10,13,4,5,6,7,8,9,11,13 };
+#define MA_DR_MP3_PEEK_BITS(n)    (bs_cache >> (32 - (n)))
+#define MA_DR_MP3_FLUSH_BITS(n)   { bs_cache <<= (n); bs_sh += (n); }
+#define MA_DR_MP3_CHECK_BITS      while (bs_sh >= 0) { bs_cache |= (ma_uint32)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
+#define MA_DR_MP3_BSPOS           ((bs_next_ptr - bs->buf)*8 - 24 + bs_sh)
+    float one = 0.0f;
+    int ireg = 0, big_val_cnt = gr_info->big_values;
+    const ma_uint8 *sfb = gr_info->sfbtab;
+    const ma_uint8 *bs_next_ptr = bs->buf + bs->pos/8;
+    ma_uint32 bs_cache = (((bs_next_ptr[0]*256u + bs_next_ptr[1])*256u + bs_next_ptr[2])*256u + bs_next_ptr[3]) << (bs->pos & 7);
+    int pairs_to_decode, np, bs_sh = (bs->pos & 7) - 8;
+    bs_next_ptr += 4;
+    while (big_val_cnt > 0)
+    {
+        int tab_num = gr_info->table_select[ireg];
+        int sfb_cnt = gr_info->region_count[ireg++];
+        const ma_int16 *codebook = tabs + tabindex[tab_num];
+        int linbits = g_linbits[tab_num];
+        if (linbits)
+        {
+            do
+            {
+                np = *sfb++ / 2;
+                pairs_to_decode = MA_DR_MP3_MIN(big_val_cnt, np);
+                one = *scf++;
+                do
+                {
+                    int j, w = 5;
+                    int leaf = codebook[MA_DR_MP3_PEEK_BITS(w)];
+                    while (leaf < 0)
+                    {
+                        MA_DR_MP3_FLUSH_BITS(w);
+                        w = leaf & 7;
+                        leaf = codebook[MA_DR_MP3_PEEK_BITS(w) - (leaf >> 3)];
+                    }
+                    MA_DR_MP3_FLUSH_BITS(leaf >> 8);
+                    for (j = 0; j < 2; j++, dst++, leaf >>= 4)
+                    {
+                        int lsb = leaf & 0x0F;
+                        if (lsb == 15)
+                        {
+                            lsb += MA_DR_MP3_PEEK_BITS(linbits);
+                            MA_DR_MP3_FLUSH_BITS(linbits);
+                            MA_DR_MP3_CHECK_BITS;
+                            *dst = one*ma_dr_mp3_L3_pow_43(lsb)*((ma_int32)bs_cache < 0 ? -1: 1);
+                        } else
+                        {
+                            *dst = ma_dr_mp3_g_pow43[16 + lsb - 16*(bs_cache >> 31)]*one;
+                        }
+                        MA_DR_MP3_FLUSH_BITS(lsb ? 1 : 0);
+                    }
+                    MA_DR_MP3_CHECK_BITS;
+                } while (--pairs_to_decode);
+            } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
+        } else
+        {
+            do
+            {
+                np = *sfb++ / 2;
+                pairs_to_decode = MA_DR_MP3_MIN(big_val_cnt, np);
+                one = *scf++;
+                do
+                {
+                    int j, w = 5;
+                    int leaf = codebook[MA_DR_MP3_PEEK_BITS(w)];
+                    while (leaf < 0)
+                    {
+                        MA_DR_MP3_FLUSH_BITS(w);
+                        w = leaf & 7;
+                        leaf = codebook[MA_DR_MP3_PEEK_BITS(w) - (leaf >> 3)];
+                    }
+                    MA_DR_MP3_FLUSH_BITS(leaf >> 8);
+                    for (j = 0; j < 2; j++, dst++, leaf >>= 4)
+                    {
+                        int lsb = leaf & 0x0F;
+                        *dst = ma_dr_mp3_g_pow43[16 + lsb - 16*(bs_cache >> 31)]*one;
+                        MA_DR_MP3_FLUSH_BITS(lsb ? 1 : 0);
+                    }
+                    MA_DR_MP3_CHECK_BITS;
+                } while (--pairs_to_decode);
+            } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
+        }
+    }
+    for (np = 1 - big_val_cnt;; dst += 4)
+    {
+        const ma_uint8 *codebook_count1 = (gr_info->count1_table) ? tab33 : tab32;
+        int leaf = codebook_count1[MA_DR_MP3_PEEK_BITS(4)];
+        if (!(leaf & 8))
+        {
+            leaf = codebook_count1[(leaf >> 3) + (bs_cache << 4 >> (32 - (leaf & 3)))];
+        }
+        MA_DR_MP3_FLUSH_BITS(leaf & 7);
+        if (MA_DR_MP3_BSPOS > layer3gr_limit)
+        {
+            break;
+        }
+#define MA_DR_MP3_RELOAD_SCALEFACTOR  if (!--np) { np = *sfb++/2; if (!np) break; one = *scf++; }
+#define MA_DR_MP3_DEQ_COUNT1(s) if (leaf & (128 >> s)) { dst[s] = ((ma_int32)bs_cache < 0) ? -one : one; MA_DR_MP3_FLUSH_BITS(1) }
+        MA_DR_MP3_RELOAD_SCALEFACTOR;
+        MA_DR_MP3_DEQ_COUNT1(0);
+        MA_DR_MP3_DEQ_COUNT1(1);
+        MA_DR_MP3_RELOAD_SCALEFACTOR;
+        MA_DR_MP3_DEQ_COUNT1(2);
+        MA_DR_MP3_DEQ_COUNT1(3);
+        MA_DR_MP3_CHECK_BITS;
+    }
+    bs->pos = layer3gr_limit;
+}
+static void ma_dr_mp3_L3_midside_stereo(float *left, int n)
+{
+    int i = 0;
+    float *right = left + 576;
+#if MA_DR_MP3_HAVE_SIMD
+    if (ma_dr_mp3_have_simd())
+    {
+        for (; i < n - 3; i += 4)
+        {
+            ma_dr_mp3_f4 vl = MA_DR_MP3_VLD(left + i);
+            ma_dr_mp3_f4 vr = MA_DR_MP3_VLD(right + i);
+            MA_DR_MP3_VSTORE(left + i, MA_DR_MP3_VADD(vl, vr));
+            MA_DR_MP3_VSTORE(right + i, MA_DR_MP3_VSUB(vl, vr));
+        }
+#ifdef __GNUC__
+        if (__builtin_constant_p(n % 4 == 0) && n % 4 == 0)
+            return;
+#endif
+    }
+#endif
+    for (; i < n; i++)
+    {
+        float a = left[i];
+        float b = right[i];
+        left[i] = a + b;
+        right[i] = a - b;
+    }
+}
+static void ma_dr_mp3_L3_intensity_stereo_band(float *left, int n, float kl, float kr)
+{
+    int i;
+    for (i = 0; i < n; i++)
+    {
+        left[i + 576] = left[i]*kr;
+        left[i] = left[i]*kl;
+    }
+}
+static void ma_dr_mp3_L3_stereo_top_band(const float *right, const ma_uint8 *sfb, int nbands, int max_band[3])
+{
+    int i, k;
+    max_band[0] = max_band[1] = max_band[2] = -1;
+    for (i = 0; i < nbands; i++)
+    {
+        for (k = 0; k < sfb[i]; k += 2)
+        {
+            if (right[k] != 0 || right[k + 1] != 0)
+            {
+                max_band[i % 3] = i;
+                break;
+            }
+        }
+        right += sfb[i];
+    }
+}
+static void ma_dr_mp3_L3_stereo_process(float *left, const ma_uint8 *ist_pos, const ma_uint8 *sfb, const ma_uint8 *hdr, int max_band[3], int mpeg2_sh)
+{
+    static const float g_pan[7*2] = { 0,1,0.21132487f,0.78867513f,0.36602540f,0.63397460f,0.5f,0.5f,0.63397460f,0.36602540f,0.78867513f,0.21132487f,1,0 };
+    unsigned i, max_pos = MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 7 : 64;
+    for (i = 0; sfb[i]; i++)
+    {
+        unsigned ipos = ist_pos[i];
+        if ((int)i > max_band[i % 3] && ipos < max_pos)
+        {
+            float kl, kr, s = MA_DR_MP3_HDR_TEST_MS_STEREO(hdr) ? 1.41421356f : 1;
+            if (MA_DR_MP3_HDR_TEST_MPEG1(hdr))
+            {
+                kl = g_pan[2*ipos];
+                kr = g_pan[2*ipos + 1];
+            } else
+            {
+                kl = 1;
+                kr = ma_dr_mp3_L3_ldexp_q2(1, (ipos + 1) >> 1 << mpeg2_sh);
+                if (ipos & 1)
+                {
+                    kl = kr;
+                    kr = 1;
+                }
+            }
+            ma_dr_mp3_L3_intensity_stereo_band(left, sfb[i], kl*s, kr*s);
+        } else if (MA_DR_MP3_HDR_TEST_MS_STEREO(hdr))
+        {
+            ma_dr_mp3_L3_midside_stereo(left, sfb[i]);
+        }
+        left += sfb[i];
+    }
+}
+static void ma_dr_mp3_L3_intensity_stereo(float *left, ma_uint8 *ist_pos, const ma_dr_mp3_L3_gr_info *gr, const ma_uint8 *hdr)
+{
+    int max_band[3], n_sfb = gr->n_long_sfb + gr->n_short_sfb;
+    int i, max_blocks = gr->n_short_sfb ? 3 : 1;
+    ma_dr_mp3_L3_stereo_top_band(left + 576, gr->sfbtab, n_sfb, max_band);
+    if (gr->n_long_sfb)
+    {
+        max_band[0] = max_band[1] = max_band[2] = MA_DR_MP3_MAX(MA_DR_MP3_MAX(max_band[0], max_band[1]), max_band[2]);
+    }
+    for (i = 0; i < max_blocks; i++)
+    {
+        int default_pos = MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 3 : 0;
+        int itop = n_sfb - max_blocks + i;
+        int prev = itop - max_blocks;
+        ist_pos[itop] = (ma_uint8)(max_band[i] >= prev ? default_pos : ist_pos[prev]);
+    }
+    ma_dr_mp3_L3_stereo_process(left, ist_pos, gr->sfbtab, hdr, max_band, gr[1].scalefac_compress & 1);
+}
+static void ma_dr_mp3_L3_reorder(float *grbuf, float *scratch, const ma_uint8 *sfb)
+{
+    int i, len;
+    float *src = grbuf, *dst = scratch;
+    for (;0 != (len = *sfb); sfb += 3, src += 2*len)
+    {
+        for (i = 0; i < len; i++, src++)
+        {
+            *dst++ = src[0*len];
+            *dst++ = src[1*len];
+            *dst++ = src[2*len];
+        }
+    }
+    MA_DR_MP3_COPY_MEMORY(grbuf, scratch, (dst - scratch)*sizeof(float));
+}
+static void ma_dr_mp3_L3_antialias(float *grbuf, int nbands)
+{
+    static const float g_aa[2][8] = {
+        {0.85749293f,0.88174200f,0.94962865f,0.98331459f,0.99551782f,0.99916056f,0.99989920f,0.99999316f},
+        {0.51449576f,0.47173197f,0.31337745f,0.18191320f,0.09457419f,0.04096558f,0.01419856f,0.00369997f}
+    };
+    for (; nbands > 0; nbands--, grbuf += 18)
+    {
+        int i = 0;
+#if MA_DR_MP3_HAVE_SIMD
+        if (ma_dr_mp3_have_simd()) for (; i < 8; i += 4)
+        {
+            ma_dr_mp3_f4 vu = MA_DR_MP3_VLD(grbuf + 18 + i);
+            ma_dr_mp3_f4 vd = MA_DR_MP3_VLD(grbuf + 14 - i);
+            ma_dr_mp3_f4 vc0 = MA_DR_MP3_VLD(g_aa[0] + i);
+            ma_dr_mp3_f4 vc1 = MA_DR_MP3_VLD(g_aa[1] + i);
+            vd = MA_DR_MP3_VREV(vd);
+            MA_DR_MP3_VSTORE(grbuf + 18 + i, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vu, vc0), MA_DR_MP3_VMUL(vd, vc1)));
+            vd = MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vu, vc1), MA_DR_MP3_VMUL(vd, vc0));
+            MA_DR_MP3_VSTORE(grbuf + 14 - i, MA_DR_MP3_VREV(vd));
+        }
+#endif
+#ifndef MA_DR_MP3_ONLY_SIMD
+        for(; i < 8; i++)
+        {
+            float u = grbuf[18 + i];
+            float d = grbuf[17 - i];
+            grbuf[18 + i] = u*g_aa[0][i] - d*g_aa[1][i];
+            grbuf[17 - i] = u*g_aa[1][i] + d*g_aa[0][i];
+        }
+#endif
+    }
+}
+static void ma_dr_mp3_L3_dct3_9(float *y)
+{
+    float s0, s1, s2, s3, s4, s5, s6, s7, s8, t0, t2, t4;
+    s0 = y[0]; s2 = y[2]; s4 = y[4]; s6 = y[6]; s8 = y[8];
+    t0 = s0 + s6*0.5f;
+    s0 -= s6;
+    t4 = (s4 + s2)*0.93969262f;
+    t2 = (s8 + s2)*0.76604444f;
+    s6 = (s4 - s8)*0.17364818f;
+    s4 += s8 - s2;
+    s2 = s0 - s4*0.5f;
+    y[4] = s4 + s0;
+    s8 = t0 - t2 + s6;
+    s0 = t0 - t4 + t2;
+    s4 = t0 + t4 - s6;
+    s1 = y[1]; s3 = y[3]; s5 = y[5]; s7 = y[7];
+    s3 *= 0.86602540f;
+    t0 = (s5 + s1)*0.98480775f;
+    t4 = (s5 - s7)*0.34202014f;
+    t2 = (s1 + s7)*0.64278761f;
+    s1 = (s1 - s5 - s7)*0.86602540f;
+    s5 = t0 - s3 - t2;
+    s7 = t4 - s3 - t0;
+    s3 = t4 + s3 - t2;
+    y[0] = s4 - s7;
+    y[1] = s2 + s1;
+    y[2] = s0 - s3;
+    y[3] = s8 + s5;
+    y[5] = s8 - s5;
+    y[6] = s0 + s3;
+    y[7] = s2 - s1;
+    y[8] = s4 + s7;
+}
+static void ma_dr_mp3_L3_imdct36(float *grbuf, float *overlap, const float *window, int nbands)
+{
+    int i, j;
+    static const float g_twid9[18] = {
+        0.73727734f,0.79335334f,0.84339145f,0.88701083f,0.92387953f,0.95371695f,0.97629601f,0.99144486f,0.99904822f,0.67559021f,0.60876143f,0.53729961f,0.46174861f,0.38268343f,0.30070580f,0.21643961f,0.13052619f,0.04361938f
+    };
+    for (j = 0; j < nbands; j++, grbuf += 18, overlap += 9)
+    {
+        float co[9], si[9];
+        co[0] = -grbuf[0];
+        si[0] = grbuf[17];
+        for (i = 0; i < 4; i++)
+        {
+            si[8 - 2*i] =   grbuf[4*i + 1] - grbuf[4*i + 2];
+            co[1 + 2*i] =   grbuf[4*i + 1] + grbuf[4*i + 2];
+            si[7 - 2*i] =   grbuf[4*i + 4] - grbuf[4*i + 3];
+            co[2 + 2*i] = -(grbuf[4*i + 3] + grbuf[4*i + 4]);
+        }
+        ma_dr_mp3_L3_dct3_9(co);
+        ma_dr_mp3_L3_dct3_9(si);
+        si[1] = -si[1];
+        si[3] = -si[3];
+        si[5] = -si[5];
+        si[7] = -si[7];
+        i = 0;
+#if MA_DR_MP3_HAVE_SIMD
+        if (ma_dr_mp3_have_simd()) for (; i < 8; i += 4)
+        {
+            ma_dr_mp3_f4 vovl = MA_DR_MP3_VLD(overlap + i);
+            ma_dr_mp3_f4 vc = MA_DR_MP3_VLD(co + i);
+            ma_dr_mp3_f4 vs = MA_DR_MP3_VLD(si + i);
+            ma_dr_mp3_f4 vr0 = MA_DR_MP3_VLD(g_twid9 + i);
+            ma_dr_mp3_f4 vr1 = MA_DR_MP3_VLD(g_twid9 + 9 + i);
+            ma_dr_mp3_f4 vw0 = MA_DR_MP3_VLD(window + i);
+            ma_dr_mp3_f4 vw1 = MA_DR_MP3_VLD(window + 9 + i);
+            ma_dr_mp3_f4 vsum = MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vc, vr1), MA_DR_MP3_VMUL(vs, vr0));
+            MA_DR_MP3_VSTORE(overlap + i, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vc, vr0), MA_DR_MP3_VMUL(vs, vr1)));
+            MA_DR_MP3_VSTORE(grbuf + i, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vovl, vw0), MA_DR_MP3_VMUL(vsum, vw1)));
+            vsum = MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vovl, vw1), MA_DR_MP3_VMUL(vsum, vw0));
+            MA_DR_MP3_VSTORE(grbuf + 14 - i, MA_DR_MP3_VREV(vsum));
+        }
+#endif
+        for (; i < 9; i++)
+        {
+            float ovl  = overlap[i];
+            float sum  = co[i]*g_twid9[9 + i] + si[i]*g_twid9[0 + i];
+            overlap[i] = co[i]*g_twid9[0 + i] - si[i]*g_twid9[9 + i];
+            grbuf[i]      = ovl*window[0 + i] - sum*window[9 + i];
+            grbuf[17 - i] = ovl*window[9 + i] + sum*window[0 + i];
+        }
+    }
+}
+static void ma_dr_mp3_L3_idct3(float x0, float x1, float x2, float *dst)
+{
+    float m1 = x1*0.86602540f;
+    float a1 = x0 - x2*0.5f;
+    dst[1] = x0 + x2;
+    dst[0] = a1 + m1;
+    dst[2] = a1 - m1;
+}
+static void ma_dr_mp3_L3_imdct12(float *x, float *dst, float *overlap)
+{
+    static const float g_twid3[6] = { 0.79335334f,0.92387953f,0.99144486f, 0.60876143f,0.38268343f,0.13052619f };
+    float co[3], si[3];
+    int i;
+    ma_dr_mp3_L3_idct3(-x[0], x[6] + x[3], x[12] + x[9], co);
+    ma_dr_mp3_L3_idct3(x[15], x[12] - x[9], x[6] - x[3], si);
+    si[1] = -si[1];
+    for (i = 0; i < 3; i++)
+    {
+        float ovl  = overlap[i];
+        float sum  = co[i]*g_twid3[3 + i] + si[i]*g_twid3[0 + i];
+        overlap[i] = co[i]*g_twid3[0 + i] - si[i]*g_twid3[3 + i];
+        dst[i]     = ovl*g_twid3[2 - i] - sum*g_twid3[5 - i];
+        dst[5 - i] = ovl*g_twid3[5 - i] + sum*g_twid3[2 - i];
+    }
+}
+static void ma_dr_mp3_L3_imdct_short(float *grbuf, float *overlap, int nbands)
+{
+    for (;nbands > 0; nbands--, overlap += 9, grbuf += 18)
+    {
+        float tmp[18];
+        MA_DR_MP3_COPY_MEMORY(tmp, grbuf, sizeof(tmp));
+        MA_DR_MP3_COPY_MEMORY(grbuf, overlap, 6*sizeof(float));
+        ma_dr_mp3_L3_imdct12(tmp, grbuf + 6, overlap + 6);
+        ma_dr_mp3_L3_imdct12(tmp + 1, grbuf + 12, overlap + 6);
+        ma_dr_mp3_L3_imdct12(tmp + 2, overlap, overlap + 6);
+    }
+}
+static void ma_dr_mp3_L3_change_sign(float *grbuf)
+{
+    int b, i;
+    for (b = 0, grbuf += 18; b < 32; b += 2, grbuf += 36)
+        for (i = 1; i < 18; i += 2)
+            grbuf[i] = -grbuf[i];
+}
+static void ma_dr_mp3_L3_imdct_gr(float *grbuf, float *overlap, unsigned block_type, unsigned n_long_bands)
+{
+    static const float g_mdct_window[2][18] = {
+        { 0.99904822f,0.99144486f,0.97629601f,0.95371695f,0.92387953f,0.88701083f,0.84339145f,0.79335334f,0.73727734f,0.04361938f,0.13052619f,0.21643961f,0.30070580f,0.38268343f,0.46174861f,0.53729961f,0.60876143f,0.67559021f },
+        { 1,1,1,1,1,1,0.99144486f,0.92387953f,0.79335334f,0,0,0,0,0,0,0.13052619f,0.38268343f,0.60876143f }
+    };
+    if (n_long_bands)
+    {
+        ma_dr_mp3_L3_imdct36(grbuf, overlap, g_mdct_window[0], n_long_bands);
+        grbuf += 18*n_long_bands;
+        overlap += 9*n_long_bands;
+    }
+    if (block_type == MA_DR_MP3_SHORT_BLOCK_TYPE)
+        ma_dr_mp3_L3_imdct_short(grbuf, overlap, 32 - n_long_bands);
+    else
+        ma_dr_mp3_L3_imdct36(grbuf, overlap, g_mdct_window[block_type == MA_DR_MP3_STOP_BLOCK_TYPE], 32 - n_long_bands);
+}
+static void ma_dr_mp3_L3_save_reservoir(ma_dr_mp3dec *h, ma_dr_mp3dec_scratch *s)
+{
+    int pos = (s->bs.pos + 7)/8u;
+    int remains = s->bs.limit/8u - pos;
+    if (remains > MA_DR_MP3_MAX_BITRESERVOIR_BYTES)
+    {
+        pos += remains - MA_DR_MP3_MAX_BITRESERVOIR_BYTES;
+        remains = MA_DR_MP3_MAX_BITRESERVOIR_BYTES;
+    }
+    if (remains > 0)
+    {
+        MA_DR_MP3_MOVE_MEMORY(h->reserv_buf, s->maindata + pos, remains);
+    }
+    h->reserv = remains;
+}
+static int ma_dr_mp3_L3_restore_reservoir(ma_dr_mp3dec *h, ma_dr_mp3_bs *bs, ma_dr_mp3dec_scratch *s, int main_data_begin)
+{
+    int frame_bytes = (bs->limit - bs->pos)/8;
+    int bytes_have = MA_DR_MP3_MIN(h->reserv, main_data_begin);
+    MA_DR_MP3_COPY_MEMORY(s->maindata, h->reserv_buf + MA_DR_MP3_MAX(0, h->reserv - main_data_begin), MA_DR_MP3_MIN(h->reserv, main_data_begin));
+    MA_DR_MP3_COPY_MEMORY(s->maindata + bytes_have, bs->buf + bs->pos/8, frame_bytes);
+    ma_dr_mp3_bs_init(&s->bs, s->maindata, bytes_have + frame_bytes);
+    return h->reserv >= main_data_begin;
+}
+static void ma_dr_mp3_L3_decode(ma_dr_mp3dec *h, ma_dr_mp3dec_scratch *s, ma_dr_mp3_L3_gr_info *gr_info, int nch)
+{
+    int ch;
+    for (ch = 0; ch < nch; ch++)
+    {
+        int layer3gr_limit = s->bs.pos + gr_info[ch].part_23_length;
+        ma_dr_mp3_L3_decode_scalefactors(h->header, s->ist_pos[ch], &s->bs, gr_info + ch, s->scf, ch);
+        ma_dr_mp3_L3_huffman(s->grbuf[ch], &s->bs, gr_info + ch, s->scf, layer3gr_limit);
+    }
+    if (MA_DR_MP3_HDR_TEST_I_STEREO(h->header))
+    {
+        ma_dr_mp3_L3_intensity_stereo(s->grbuf[0], s->ist_pos[1], gr_info, h->header);
+    } else if (MA_DR_MP3_HDR_IS_MS_STEREO(h->header))
+    {
+        ma_dr_mp3_L3_midside_stereo(s->grbuf[0], 576);
+    }
+    for (ch = 0; ch < nch; ch++, gr_info++)
+    {
+        int aa_bands = 31;
+        int n_long_bands = (gr_info->mixed_block_flag ? 2 : 0) << (int)(MA_DR_MP3_HDR_GET_MY_SAMPLE_RATE(h->header) == 2);
+        if (gr_info->n_short_sfb)
+        {
+            aa_bands = n_long_bands - 1;
+            ma_dr_mp3_L3_reorder(s->grbuf[ch] + n_long_bands*18, s->syn[0], gr_info->sfbtab + gr_info->n_long_sfb);
+        }
+        ma_dr_mp3_L3_antialias(s->grbuf[ch], aa_bands);
+        ma_dr_mp3_L3_imdct_gr(s->grbuf[ch], h->mdct_overlap[ch], gr_info->block_type, n_long_bands);
+        ma_dr_mp3_L3_change_sign(s->grbuf[ch]);
+    }
+}
+static void ma_dr_mp3d_DCT_II(float *grbuf, int n)
+{
+    static const float g_sec[24] = {
+        10.19000816f,0.50060302f,0.50241929f,3.40760851f,0.50547093f,0.52249861f,2.05778098f,0.51544732f,0.56694406f,1.48416460f,0.53104258f,0.64682180f,1.16943991f,0.55310392f,0.78815460f,0.97256821f,0.58293498f,1.06067765f,0.83934963f,0.62250412f,1.72244716f,0.74453628f,0.67480832f,5.10114861f
+    };
+    int i, k = 0;
+#if MA_DR_MP3_HAVE_SIMD
+    if (ma_dr_mp3_have_simd()) for (; k < n; k += 4)
+    {
+        ma_dr_mp3_f4 t[4][8], *x;
+        float *y = grbuf + k;
+        for (x = t[0], i = 0; i < 8; i++, x++)
+        {
+            ma_dr_mp3_f4 x0 = MA_DR_MP3_VLD(&y[i*18]);
+            ma_dr_mp3_f4 x1 = MA_DR_MP3_VLD(&y[(15 - i)*18]);
+            ma_dr_mp3_f4 x2 = MA_DR_MP3_VLD(&y[(16 + i)*18]);
+            ma_dr_mp3_f4 x3 = MA_DR_MP3_VLD(&y[(31 - i)*18]);
+            ma_dr_mp3_f4 t0 = MA_DR_MP3_VADD(x0, x3);
+            ma_dr_mp3_f4 t1 = MA_DR_MP3_VADD(x1, x2);
+            ma_dr_mp3_f4 t2 = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x1, x2), g_sec[3*i + 0]);
+            ma_dr_mp3_f4 t3 = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x0, x3), g_sec[3*i + 1]);
+            x[0] = MA_DR_MP3_VADD(t0, t1);
+            x[8] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(t0, t1), g_sec[3*i + 2]);
+            x[16] = MA_DR_MP3_VADD(t3, t2);
+            x[24] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(t3, t2), g_sec[3*i + 2]);
+        }
+        for (x = t[0], i = 0; i < 4; i++, x += 8)
+        {
+            ma_dr_mp3_f4 x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4], x5 = x[5], x6 = x[6], x7 = x[7], xt;
+            xt = MA_DR_MP3_VSUB(x0, x7); x0 = MA_DR_MP3_VADD(x0, x7);
+            x7 = MA_DR_MP3_VSUB(x1, x6); x1 = MA_DR_MP3_VADD(x1, x6);
+            x6 = MA_DR_MP3_VSUB(x2, x5); x2 = MA_DR_MP3_VADD(x2, x5);
+            x5 = MA_DR_MP3_VSUB(x3, x4); x3 = MA_DR_MP3_VADD(x3, x4);
+            x4 = MA_DR_MP3_VSUB(x0, x3); x0 = MA_DR_MP3_VADD(x0, x3);
+            x3 = MA_DR_MP3_VSUB(x1, x2); x1 = MA_DR_MP3_VADD(x1, x2);
+            x[0] = MA_DR_MP3_VADD(x0, x1);
+            x[4] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x0, x1), 0.70710677f);
+            x5 = MA_DR_MP3_VADD(x5, x6);
+            x6 = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(x6, x7), 0.70710677f);
+            x7 = MA_DR_MP3_VADD(x7, xt);
+            x3 = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(x3, x4), 0.70710677f);
+            x5 = MA_DR_MP3_VSUB(x5, MA_DR_MP3_VMUL_S(x7, 0.198912367f));
+            x7 = MA_DR_MP3_VADD(x7, MA_DR_MP3_VMUL_S(x5, 0.382683432f));
+            x5 = MA_DR_MP3_VSUB(x5, MA_DR_MP3_VMUL_S(x7, 0.198912367f));
+            x0 = MA_DR_MP3_VSUB(xt, x6); xt = MA_DR_MP3_VADD(xt, x6);
+            x[1] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(xt, x7), 0.50979561f);
+            x[2] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(x4, x3), 0.54119611f);
+            x[3] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x0, x5), 0.60134488f);
+            x[5] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(x0, x5), 0.89997619f);
+            x[6] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x4, x3), 1.30656302f);
+            x[7] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(xt, x7), 2.56291556f);
+        }
+        if (k > n - 3)
+        {
+#if MA_DR_MP3_HAVE_SSE
+#define MA_DR_MP3_VSAVE2(i, v) _mm_storel_pi((__m64 *)(void*)&y[i*18], v)
+#else
+#define MA_DR_MP3_VSAVE2(i, v) vst1_f32((float32_t *)&y[(i)*18],  vget_low_f32(v))
+#endif
+            for (i = 0; i < 7; i++, y += 4*18)
+            {
+                ma_dr_mp3_f4 s = MA_DR_MP3_VADD(t[3][i], t[3][i + 1]);
+                MA_DR_MP3_VSAVE2(0, t[0][i]);
+                MA_DR_MP3_VSAVE2(1, MA_DR_MP3_VADD(t[2][i], s));
+                MA_DR_MP3_VSAVE2(2, MA_DR_MP3_VADD(t[1][i], t[1][i + 1]));
+                MA_DR_MP3_VSAVE2(3, MA_DR_MP3_VADD(t[2][1 + i], s));
+            }
+            MA_DR_MP3_VSAVE2(0, t[0][7]);
+            MA_DR_MP3_VSAVE2(1, MA_DR_MP3_VADD(t[2][7], t[3][7]));
+            MA_DR_MP3_VSAVE2(2, t[1][7]);
+            MA_DR_MP3_VSAVE2(3, t[3][7]);
+        } else
+        {
+#define MA_DR_MP3_VSAVE4(i, v) MA_DR_MP3_VSTORE(&y[(i)*18], v)
+            for (i = 0; i < 7; i++, y += 4*18)
+            {
+                ma_dr_mp3_f4 s = MA_DR_MP3_VADD(t[3][i], t[3][i + 1]);
+                MA_DR_MP3_VSAVE4(0, t[0][i]);
+                MA_DR_MP3_VSAVE4(1, MA_DR_MP3_VADD(t[2][i], s));
+                MA_DR_MP3_VSAVE4(2, MA_DR_MP3_VADD(t[1][i], t[1][i + 1]));
+                MA_DR_MP3_VSAVE4(3, MA_DR_MP3_VADD(t[2][1 + i], s));
+            }
+            MA_DR_MP3_VSAVE4(0, t[0][7]);
+            MA_DR_MP3_VSAVE4(1, MA_DR_MP3_VADD(t[2][7], t[3][7]));
+            MA_DR_MP3_VSAVE4(2, t[1][7]);
+            MA_DR_MP3_VSAVE4(3, t[3][7]);
+        }
+    } else
+#endif
+#ifdef MA_DR_MP3_ONLY_SIMD
+    {}
+#else
+    for (; k < n; k++)
+    {
+        float t[4][8], *x, *y = grbuf + k;
+        for (x = t[0], i = 0; i < 8; i++, x++)
+        {
+            float x0 = y[i*18];
+            float x1 = y[(15 - i)*18];
+            float x2 = y[(16 + i)*18];
+            float x3 = y[(31 - i)*18];
+            float t0 = x0 + x3;
+            float t1 = x1 + x2;
+            float t2 = (x1 - x2)*g_sec[3*i + 0];
+            float t3 = (x0 - x3)*g_sec[3*i + 1];
+            x[0] = t0 + t1;
+            x[8] = (t0 - t1)*g_sec[3*i + 2];
+            x[16] = t3 + t2;
+            x[24] = (t3 - t2)*g_sec[3*i + 2];
+        }
+        for (x = t[0], i = 0; i < 4; i++, x += 8)
+        {
+            float x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4], x5 = x[5], x6 = x[6], x7 = x[7], xt;
+            xt = x0 - x7; x0 += x7;
+            x7 = x1 - x6; x1 += x6;
+            x6 = x2 - x5; x2 += x5;
+            x5 = x3 - x4; x3 += x4;
+            x4 = x0 - x3; x0 += x3;
+            x3 = x1 - x2; x1 += x2;
+            x[0] = x0 + x1;
+            x[4] = (x0 - x1)*0.70710677f;
+            x5 =  x5 + x6;
+            x6 = (x6 + x7)*0.70710677f;
+            x7 =  x7 + xt;
+            x3 = (x3 + x4)*0.70710677f;
+            x5 -= x7*0.198912367f;
+            x7 += x5*0.382683432f;
+            x5 -= x7*0.198912367f;
+            x0 = xt - x6; xt += x6;
+            x[1] = (xt + x7)*0.50979561f;
+            x[2] = (x4 + x3)*0.54119611f;
+            x[3] = (x0 - x5)*0.60134488f;
+            x[5] = (x0 + x5)*0.89997619f;
+            x[6] = (x4 - x3)*1.30656302f;
+            x[7] = (xt - x7)*2.56291556f;
+        }
+        for (i = 0; i < 7; i++, y += 4*18)
+        {
+            y[0*18] = t[0][i];
+            y[1*18] = t[2][i] + t[3][i] + t[3][i + 1];
+            y[2*18] = t[1][i] + t[1][i + 1];
+            y[3*18] = t[2][i + 1] + t[3][i] + t[3][i + 1];
+        }
+        y[0*18] = t[0][7];
+        y[1*18] = t[2][7] + t[3][7];
+        y[2*18] = t[1][7];
+        y[3*18] = t[3][7];
+    }
+#endif
+}
+#ifndef MA_DR_MP3_FLOAT_OUTPUT
+typedef ma_int16 ma_dr_mp3d_sample_t;
+static ma_int16 ma_dr_mp3d_scale_pcm(float sample)
+{
+    ma_int16 s;
+#if MA_DR_MP3_HAVE_ARMV6
+    ma_int32 s32 = (ma_int32)(sample + .5f);
+    s32 -= (s32 < 0);
+    s = (ma_int16)ma_dr_mp3_clip_int16_arm(s32);
+#else
+    if (sample >=  32766.5f) return (ma_int16) 32767;
+    if (sample <= -32767.5f) return (ma_int16)-32768;
+    s = (ma_int16)(sample + .5f);
+    s -= (s < 0);
+#endif
+    return s;
+}
+#else
+typedef float ma_dr_mp3d_sample_t;
+static float ma_dr_mp3d_scale_pcm(float sample)
+{
+    return sample*(1.f/32768.f);
+}
+#endif
+static void ma_dr_mp3d_synth_pair(ma_dr_mp3d_sample_t *pcm, int nch, const float *z)
+{
+    float a;
+    a  = (z[14*64] - z[    0]) * 29;
+    a += (z[ 1*64] + z[13*64]) * 213;
+    a += (z[12*64] - z[ 2*64]) * 459;
+    a += (z[ 3*64] + z[11*64]) * 2037;
+    a += (z[10*64] - z[ 4*64]) * 5153;
+    a += (z[ 5*64] + z[ 9*64]) * 6574;
+    a += (z[ 8*64] - z[ 6*64]) * 37489;
+    a +=  z[ 7*64]             * 75038;
+    pcm[0] = ma_dr_mp3d_scale_pcm(a);
+    z += 2;
+    a  = z[14*64] * 104;
+    a += z[12*64] * 1567;
+    a += z[10*64] * 9727;
+    a += z[ 8*64] * 64019;
+    a += z[ 6*64] * -9975;
+    a += z[ 4*64] * -45;
+    a += z[ 2*64] * 146;
+    a += z[ 0*64] * -5;
+    pcm[16*nch] = ma_dr_mp3d_scale_pcm(a);
+}
+static void ma_dr_mp3d_synth(float *xl, ma_dr_mp3d_sample_t *dstl, int nch, float *lins)
+{
+    int i;
+    float *xr = xl + 576*(nch - 1);
+    ma_dr_mp3d_sample_t *dstr = dstl + (nch - 1);
+    static const float g_win[] = {
+        -1,26,-31,208,218,401,-519,2063,2000,4788,-5517,7134,5959,35640,-39336,74992,
+        -1,24,-35,202,222,347,-581,2080,1952,4425,-5879,7640,5288,33791,-41176,74856,
+        -1,21,-38,196,225,294,-645,2087,1893,4063,-6237,8092,4561,31947,-43006,74630,
+        -1,19,-41,190,227,244,-711,2085,1822,3705,-6589,8492,3776,30112,-44821,74313,
+        -1,17,-45,183,228,197,-779,2075,1739,3351,-6935,8840,2935,28289,-46617,73908,
+        -1,16,-49,176,228,153,-848,2057,1644,3004,-7271,9139,2037,26482,-48390,73415,
+        -2,14,-53,169,227,111,-919,2032,1535,2663,-7597,9389,1082,24694,-50137,72835,
+        -2,13,-58,161,224,72,-991,2001,1414,2330,-7910,9592,70,22929,-51853,72169,
+        -2,11,-63,154,221,36,-1064,1962,1280,2006,-8209,9750,-998,21189,-53534,71420,
+        -2,10,-68,147,215,2,-1137,1919,1131,1692,-8491,9863,-2122,19478,-55178,70590,
+        -3,9,-73,139,208,-29,-1210,1870,970,1388,-8755,9935,-3300,17799,-56778,69679,
+        -3,8,-79,132,200,-57,-1283,1817,794,1095,-8998,9966,-4533,16155,-58333,68692,
+        -4,7,-85,125,189,-83,-1356,1759,605,814,-9219,9959,-5818,14548,-59838,67629,
+        -4,7,-91,117,177,-106,-1428,1698,402,545,-9416,9916,-7154,12980,-61289,66494,
+        -5,6,-97,111,163,-127,-1498,1634,185,288,-9585,9838,-8540,11455,-62684,65290
+    };
+    float *zlin = lins + 15*64;
+    const float *w = g_win;
+    zlin[4*15]     = xl[18*16];
+    zlin[4*15 + 1] = xr[18*16];
+    zlin[4*15 + 2] = xl[0];
+    zlin[4*15 + 3] = xr[0];
+    zlin[4*31]     = xl[1 + 18*16];
+    zlin[4*31 + 1] = xr[1 + 18*16];
+    zlin[4*31 + 2] = xl[1];
+    zlin[4*31 + 3] = xr[1];
+    ma_dr_mp3d_synth_pair(dstr, nch, lins + 4*15 + 1);
+    ma_dr_mp3d_synth_pair(dstr + 32*nch, nch, lins + 4*15 + 64 + 1);
+    ma_dr_mp3d_synth_pair(dstl, nch, lins + 4*15);
+    ma_dr_mp3d_synth_pair(dstl + 32*nch, nch, lins + 4*15 + 64);
+#if MA_DR_MP3_HAVE_SIMD
+    if (ma_dr_mp3_have_simd()) for (i = 14; i >= 0; i--)
+    {
+#define MA_DR_MP3_VLOAD(k) ma_dr_mp3_f4 w0 = MA_DR_MP3_VSET(*w++); ma_dr_mp3_f4 w1 = MA_DR_MP3_VSET(*w++); ma_dr_mp3_f4 vz = MA_DR_MP3_VLD(&zlin[4*i - 64*k]); ma_dr_mp3_f4 vy = MA_DR_MP3_VLD(&zlin[4*i - 64*(15 - k)]);
+#define MA_DR_MP3_V0(k) { MA_DR_MP3_VLOAD(k) b =               MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vz, w1), MA_DR_MP3_VMUL(vy, w0)) ; a =               MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vz, w0), MA_DR_MP3_VMUL(vy, w1));  }
+#define MA_DR_MP3_V1(k) { MA_DR_MP3_VLOAD(k) b = MA_DR_MP3_VADD(b, MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vz, w1), MA_DR_MP3_VMUL(vy, w0))); a = MA_DR_MP3_VADD(a, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vz, w0), MA_DR_MP3_VMUL(vy, w1))); }
+#define MA_DR_MP3_V2(k) { MA_DR_MP3_VLOAD(k) b = MA_DR_MP3_VADD(b, MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vz, w1), MA_DR_MP3_VMUL(vy, w0))); a = MA_DR_MP3_VADD(a, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vy, w1), MA_DR_MP3_VMUL(vz, w0))); }
+        ma_dr_mp3_f4 a, b;
+        zlin[4*i]     = xl[18*(31 - i)];
+        zlin[4*i + 1] = xr[18*(31 - i)];
+        zlin[4*i + 2] = xl[1 + 18*(31 - i)];
+        zlin[4*i + 3] = xr[1 + 18*(31 - i)];
+        zlin[4*i + 64] = xl[1 + 18*(1 + i)];
+        zlin[4*i + 64 + 1] = xr[1 + 18*(1 + i)];
+        zlin[4*i - 64 + 2] = xl[18*(1 + i)];
+        zlin[4*i - 64 + 3] = xr[18*(1 + i)];
+        MA_DR_MP3_V0(0) MA_DR_MP3_V2(1) MA_DR_MP3_V1(2) MA_DR_MP3_V2(3) MA_DR_MP3_V1(4) MA_DR_MP3_V2(5) MA_DR_MP3_V1(6) MA_DR_MP3_V2(7)
+        {
+#ifndef MA_DR_MP3_FLOAT_OUTPUT
+#if MA_DR_MP3_HAVE_SSE
+            static const ma_dr_mp3_f4 g_max = { 32767.0f, 32767.0f, 32767.0f, 32767.0f };
+            static const ma_dr_mp3_f4 g_min = { -32768.0f, -32768.0f, -32768.0f, -32768.0f };
+            __m128i pcm8 = _mm_packs_epi32(_mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, g_max), g_min)),
+                                           _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, g_max), g_min)));
+            dstr[(15 - i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 1);
+            dstr[(17 + i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 5);
+            dstl[(15 - i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 0);
+            dstl[(17 + i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 4);
+            dstr[(47 - i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 3);
+            dstr[(49 + i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 7);
+            dstl[(47 - i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 2);
+            dstl[(49 + i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 6);
+#else
+            int16x4_t pcma, pcmb;
+            a = MA_DR_MP3_VADD(a, MA_DR_MP3_VSET(0.5f));
+            b = MA_DR_MP3_VADD(b, MA_DR_MP3_VSET(0.5f));
+            pcma = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(a), vreinterpretq_s32_u32(vcltq_f32(a, MA_DR_MP3_VSET(0)))));
+            pcmb = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(b), vreinterpretq_s32_u32(vcltq_f32(b, MA_DR_MP3_VSET(0)))));
+            vst1_lane_s16(dstr + (15 - i)*nch, pcma, 1);
+            vst1_lane_s16(dstr + (17 + i)*nch, pcmb, 1);
+            vst1_lane_s16(dstl + (15 - i)*nch, pcma, 0);
+            vst1_lane_s16(dstl + (17 + i)*nch, pcmb, 0);
+            vst1_lane_s16(dstr + (47 - i)*nch, pcma, 3);
+            vst1_lane_s16(dstr + (49 + i)*nch, pcmb, 3);
+            vst1_lane_s16(dstl + (47 - i)*nch, pcma, 2);
+            vst1_lane_s16(dstl + (49 + i)*nch, pcmb, 2);
+#endif
+#else
+        #if MA_DR_MP3_HAVE_SSE
+            static const ma_dr_mp3_f4 g_scale = { 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f };
+        #else
+            const ma_dr_mp3_f4 g_scale = vdupq_n_f32(1.0f/32768.0f);
+        #endif
+            a = MA_DR_MP3_VMUL(a, g_scale);
+            b = MA_DR_MP3_VMUL(b, g_scale);
+#if MA_DR_MP3_HAVE_SSE
+            _mm_store_ss(dstr + (15 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1)));
+            _mm_store_ss(dstr + (17 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(1, 1, 1, 1)));
+            _mm_store_ss(dstl + (15 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(0, 0, 0, 0)));
+            _mm_store_ss(dstl + (17 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 0, 0, 0)));
+            _mm_store_ss(dstr + (47 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 3, 3, 3)));
+            _mm_store_ss(dstr + (49 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 3, 3, 3)));
+            _mm_store_ss(dstl + (47 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(2, 2, 2, 2)));
+            _mm_store_ss(dstl + (49 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(2, 2, 2, 2)));
+#else
+            vst1q_lane_f32(dstr + (15 - i)*nch, a, 1);
+            vst1q_lane_f32(dstr + (17 + i)*nch, b, 1);
+            vst1q_lane_f32(dstl + (15 - i)*nch, a, 0);
+            vst1q_lane_f32(dstl + (17 + i)*nch, b, 0);
+            vst1q_lane_f32(dstr + (47 - i)*nch, a, 3);
+            vst1q_lane_f32(dstr + (49 + i)*nch, b, 3);
+            vst1q_lane_f32(dstl + (47 - i)*nch, a, 2);
+            vst1q_lane_f32(dstl + (49 + i)*nch, b, 2);
+#endif
+#endif
+        }
+    } else
+#endif
+#ifdef MA_DR_MP3_ONLY_SIMD
+    {}
+#else
+    for (i = 14; i >= 0; i--)
+    {
+#define MA_DR_MP3_LOAD(k) float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - k*64]; float *vy = &zlin[4*i - (15 - k)*64];
+#define MA_DR_MP3_S0(k) { int j; MA_DR_MP3_LOAD(k); for (j = 0; j < 4; j++) b[j]  = vz[j]*w1 + vy[j]*w0, a[j]  = vz[j]*w0 - vy[j]*w1; }
+#define MA_DR_MP3_S1(k) { int j; MA_DR_MP3_LOAD(k); for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vz[j]*w0 - vy[j]*w1; }
+#define MA_DR_MP3_S2(k) { int j; MA_DR_MP3_LOAD(k); for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vy[j]*w1 - vz[j]*w0; }
+        float a[4], b[4];
+        zlin[4*i]     = xl[18*(31 - i)];
+        zlin[4*i + 1] = xr[18*(31 - i)];
+        zlin[4*i + 2] = xl[1 + 18*(31 - i)];
+        zlin[4*i + 3] = xr[1 + 18*(31 - i)];
+        zlin[4*(i + 16)]   = xl[1 + 18*(1 + i)];
+        zlin[4*(i + 16) + 1] = xr[1 + 18*(1 + i)];
+        zlin[4*(i - 16) + 2] = xl[18*(1 + i)];
+        zlin[4*(i - 16) + 3] = xr[18*(1 + i)];
+        MA_DR_MP3_S0(0) MA_DR_MP3_S2(1) MA_DR_MP3_S1(2) MA_DR_MP3_S2(3) MA_DR_MP3_S1(4) MA_DR_MP3_S2(5) MA_DR_MP3_S1(6) MA_DR_MP3_S2(7)
+        dstr[(15 - i)*nch] = ma_dr_mp3d_scale_pcm(a[1]);
+        dstr[(17 + i)*nch] = ma_dr_mp3d_scale_pcm(b[1]);
+        dstl[(15 - i)*nch] = ma_dr_mp3d_scale_pcm(a[0]);
+        dstl[(17 + i)*nch] = ma_dr_mp3d_scale_pcm(b[0]);
+        dstr[(47 - i)*nch] = ma_dr_mp3d_scale_pcm(a[3]);
+        dstr[(49 + i)*nch] = ma_dr_mp3d_scale_pcm(b[3]);
+        dstl[(47 - i)*nch] = ma_dr_mp3d_scale_pcm(a[2]);
+        dstl[(49 + i)*nch] = ma_dr_mp3d_scale_pcm(b[2]);
+    }
+#endif
+}
+static void ma_dr_mp3d_synth_granule(float *qmf_state, float *grbuf, int nbands, int nch, ma_dr_mp3d_sample_t *pcm, float *lins)
+{
+    int i;
+    for (i = 0; i < nch; i++)
+    {
+        ma_dr_mp3d_DCT_II(grbuf + 576*i, nbands);
+    }
+    MA_DR_MP3_COPY_MEMORY(lins, qmf_state, sizeof(float)*15*64);
+    for (i = 0; i < nbands; i += 2)
+    {
+        ma_dr_mp3d_synth(grbuf + i, pcm + 32*nch*i, nch, lins + i*64);
+    }
+#ifndef MA_DR_MP3_NONSTANDARD_BUT_LOGICAL
+    if (nch == 1)
+    {
+        for (i = 0; i < 15*64; i += 2)
+        {
+            qmf_state[i] = lins[nbands*64 + i];
+        }
+    } else
+#endif
+    {
+        MA_DR_MP3_COPY_MEMORY(qmf_state, lins + nbands*64, sizeof(float)*15*64);
+    }
+}
+static int ma_dr_mp3d_match_frame(const ma_uint8 *hdr, int mp3_bytes, int frame_bytes)
+{
+    int i, nmatch;
+    for (i = 0, nmatch = 0; nmatch < MA_DR_MP3_MAX_FRAME_SYNC_MATCHES; nmatch++)
+    {
+        i += ma_dr_mp3_hdr_frame_bytes(hdr + i, frame_bytes) + ma_dr_mp3_hdr_padding(hdr + i);
+        if (i + MA_DR_MP3_HDR_SIZE > mp3_bytes)
+            return nmatch > 0;
+        if (!ma_dr_mp3_hdr_compare(hdr, hdr + i))
+            return 0;
+    }
+    return 1;
+}
+static int ma_dr_mp3d_find_frame(const ma_uint8 *mp3, int mp3_bytes, int *free_format_bytes, int *ptr_frame_bytes)
+{
+    int i, k;
+    for (i = 0; i < mp3_bytes - MA_DR_MP3_HDR_SIZE; i++, mp3++)
+    {
+        if (ma_dr_mp3_hdr_valid(mp3))
+        {
+            int frame_bytes = ma_dr_mp3_hdr_frame_bytes(mp3, *free_format_bytes);
+            int frame_and_padding = frame_bytes + ma_dr_mp3_hdr_padding(mp3);
+            for (k = MA_DR_MP3_HDR_SIZE; !frame_bytes && k < MA_DR_MP3_MAX_FREE_FORMAT_FRAME_SIZE && i + 2*k < mp3_bytes - MA_DR_MP3_HDR_SIZE; k++)
+            {
+                if (ma_dr_mp3_hdr_compare(mp3, mp3 + k))
+                {
+                    int fb = k - ma_dr_mp3_hdr_padding(mp3);
+                    int nextfb = fb + ma_dr_mp3_hdr_padding(mp3 + k);
+                    if (i + k + nextfb + MA_DR_MP3_HDR_SIZE > mp3_bytes || !ma_dr_mp3_hdr_compare(mp3, mp3 + k + nextfb))
+                        continue;
+                    frame_and_padding = k;
+                    frame_bytes = fb;
+                    *free_format_bytes = fb;
+                }
+            }
+            if ((frame_bytes && i + frame_and_padding <= mp3_bytes &&
+                ma_dr_mp3d_match_frame(mp3, mp3_bytes - i, frame_bytes)) ||
+                (!i && frame_and_padding == mp3_bytes))
+            {
+                *ptr_frame_bytes = frame_and_padding;
+                return i;
+            }
+            *free_format_bytes = 0;
+        }
+    }
+    *ptr_frame_bytes = 0;
+    return mp3_bytes;
+}
+MA_API void ma_dr_mp3dec_init(ma_dr_mp3dec *dec)
+{
+    dec->header[0] = 0;
+}
+MA_API int ma_dr_mp3dec_decode_frame(ma_dr_mp3dec *dec, const ma_uint8 *mp3, int mp3_bytes, void *pcm, ma_dr_mp3dec_frame_info *info)
+{
+    int i = 0, igr, frame_size = 0, success = 1;
+    const ma_uint8 *hdr;
+    ma_dr_mp3_bs bs_frame[1];
+    ma_dr_mp3dec_scratch scratch;
+    if (mp3_bytes > 4 && dec->header[0] == 0xff && ma_dr_mp3_hdr_compare(dec->header, mp3))
+    {
+        frame_size = ma_dr_mp3_hdr_frame_bytes(mp3, dec->free_format_bytes) + ma_dr_mp3_hdr_padding(mp3);
+        if (frame_size != mp3_bytes && (frame_size + MA_DR_MP3_HDR_SIZE > mp3_bytes || !ma_dr_mp3_hdr_compare(mp3, mp3 + frame_size)))
+        {
+            frame_size = 0;
+        }
+    }
+    if (!frame_size)
+    {
+        MA_DR_MP3_ZERO_MEMORY(dec, sizeof(ma_dr_mp3dec));
+        i = ma_dr_mp3d_find_frame(mp3, mp3_bytes, &dec->free_format_bytes, &frame_size);
+        if (!frame_size || i + frame_size > mp3_bytes)
+        {
+            info->frame_bytes = i;
+            return 0;
+        }
+    }
+    hdr = mp3 + i;
+    MA_DR_MP3_COPY_MEMORY(dec->header, hdr, MA_DR_MP3_HDR_SIZE);
+    info->frame_bytes = i + frame_size;
+    info->channels = MA_DR_MP3_HDR_IS_MONO(hdr) ? 1 : 2;
+    info->sample_rate = ma_dr_mp3_hdr_sample_rate_hz(hdr);
+    info->layer = 4 - MA_DR_MP3_HDR_GET_LAYER(hdr);
+    info->bitrate_kbps = ma_dr_mp3_hdr_bitrate_kbps(hdr);
+    ma_dr_mp3_bs_init(bs_frame, hdr + MA_DR_MP3_HDR_SIZE, frame_size - MA_DR_MP3_HDR_SIZE);
+    if (MA_DR_MP3_HDR_IS_CRC(hdr))
+    {
+        ma_dr_mp3_bs_get_bits(bs_frame, 16);
+    }
+    if (info->layer == 3)
+    {
+        int main_data_begin = ma_dr_mp3_L3_read_side_info(bs_frame, scratch.gr_info, hdr);
+        if (main_data_begin < 0 || bs_frame->pos > bs_frame->limit)
+        {
+            ma_dr_mp3dec_init(dec);
+            return 0;
+        }
+        success = ma_dr_mp3_L3_restore_reservoir(dec, bs_frame, &scratch, main_data_begin);
+        if (success && pcm != NULL)
+        {
+            for (igr = 0; igr < (MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 2 : 1); igr++, pcm = MA_DR_MP3_OFFSET_PTR(pcm, sizeof(ma_dr_mp3d_sample_t)*576*info->channels))
+            {
+                MA_DR_MP3_ZERO_MEMORY(scratch.grbuf[0], 576*2*sizeof(float));
+                ma_dr_mp3_L3_decode(dec, &scratch, scratch.gr_info + igr*info->channels, info->channels);
+                ma_dr_mp3d_synth_granule(dec->qmf_state, scratch.grbuf[0], 18, info->channels, (ma_dr_mp3d_sample_t*)pcm, scratch.syn[0]);
+            }
+        }
+        ma_dr_mp3_L3_save_reservoir(dec, &scratch);
+    } else
+    {
+#ifdef MA_DR_MP3_ONLY_MP3
+        return 0;
+#else
+        ma_dr_mp3_L12_scale_info sci[1];
+        if (pcm == NULL) {
+            return ma_dr_mp3_hdr_frame_samples(hdr);
+        }
+        ma_dr_mp3_L12_read_scale_info(hdr, bs_frame, sci);
+        MA_DR_MP3_ZERO_MEMORY(scratch.grbuf[0], 576*2*sizeof(float));
+        for (i = 0, igr = 0; igr < 3; igr++)
+        {
+            if (12 == (i += ma_dr_mp3_L12_dequantize_granule(scratch.grbuf[0] + i, bs_frame, sci, info->layer | 1)))
+            {
+                i = 0;
+                ma_dr_mp3_L12_apply_scf_384(sci, sci->scf + igr, scratch.grbuf[0]);
+                ma_dr_mp3d_synth_granule(dec->qmf_state, scratch.grbuf[0], 12, info->channels, (ma_dr_mp3d_sample_t*)pcm, scratch.syn[0]);
+                MA_DR_MP3_ZERO_MEMORY(scratch.grbuf[0], 576*2*sizeof(float));
+                pcm = MA_DR_MP3_OFFSET_PTR(pcm, sizeof(ma_dr_mp3d_sample_t)*384*info->channels);
+            }
+            if (bs_frame->pos > bs_frame->limit)
+            {
+                ma_dr_mp3dec_init(dec);
+                return 0;
+            }
+        }
+#endif
+    }
+    return success*ma_dr_mp3_hdr_frame_samples(dec->header);
+}
+MA_API void ma_dr_mp3dec_f32_to_s16(const float *in, ma_int16 *out, size_t num_samples)
+{
+    size_t i = 0;
+#if MA_DR_MP3_HAVE_SIMD
+    size_t aligned_count = num_samples & ~7;
+    for(; i < aligned_count; i+=8)
+    {
+        ma_dr_mp3_f4 scale = MA_DR_MP3_VSET(32768.0f);
+        ma_dr_mp3_f4 a = MA_DR_MP3_VMUL(MA_DR_MP3_VLD(&in[i  ]), scale);
+        ma_dr_mp3_f4 b = MA_DR_MP3_VMUL(MA_DR_MP3_VLD(&in[i+4]), scale);
+#if MA_DR_MP3_HAVE_SSE
+        ma_dr_mp3_f4 s16max = MA_DR_MP3_VSET( 32767.0f);
+        ma_dr_mp3_f4 s16min = MA_DR_MP3_VSET(-32768.0f);
+        __m128i pcm8 = _mm_packs_epi32(_mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, s16max), s16min)),
+                                        _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, s16max), s16min)));
+        out[i  ] = (ma_int16)_mm_extract_epi16(pcm8, 0);
+        out[i+1] = (ma_int16)_mm_extract_epi16(pcm8, 1);
+        out[i+2] = (ma_int16)_mm_extract_epi16(pcm8, 2);
+        out[i+3] = (ma_int16)_mm_extract_epi16(pcm8, 3);
+        out[i+4] = (ma_int16)_mm_extract_epi16(pcm8, 4);
+        out[i+5] = (ma_int16)_mm_extract_epi16(pcm8, 5);
+        out[i+6] = (ma_int16)_mm_extract_epi16(pcm8, 6);
+        out[i+7] = (ma_int16)_mm_extract_epi16(pcm8, 7);
+#else
+        int16x4_t pcma, pcmb;
+        a = MA_DR_MP3_VADD(a, MA_DR_MP3_VSET(0.5f));
+        b = MA_DR_MP3_VADD(b, MA_DR_MP3_VSET(0.5f));
+        pcma = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(a), vreinterpretq_s32_u32(vcltq_f32(a, MA_DR_MP3_VSET(0)))));
+        pcmb = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(b), vreinterpretq_s32_u32(vcltq_f32(b, MA_DR_MP3_VSET(0)))));
+        vst1_lane_s16(out+i  , pcma, 0);
+        vst1_lane_s16(out+i+1, pcma, 1);
+        vst1_lane_s16(out+i+2, pcma, 2);
+        vst1_lane_s16(out+i+3, pcma, 3);
+        vst1_lane_s16(out+i+4, pcmb, 0);
+        vst1_lane_s16(out+i+5, pcmb, 1);
+        vst1_lane_s16(out+i+6, pcmb, 2);
+        vst1_lane_s16(out+i+7, pcmb, 3);
+#endif
+    }
+#endif
+    for(; i < num_samples; i++)
+    {
+        float sample = in[i] * 32768.0f;
+        if (sample >=  32766.5f)
+            out[i] = (ma_int16) 32767;
+        else if (sample <= -32767.5f)
+            out[i] = (ma_int16)-32768;
+        else
+        {
+            short s = (ma_int16)(sample + .5f);
+            s -= (s < 0);
+            out[i] = s;
+        }
+    }
+}
+#ifndef MA_DR_MP3_SEEK_LEADING_MP3_FRAMES
+#define MA_DR_MP3_SEEK_LEADING_MP3_FRAMES   2
+#endif
+#define MA_DR_MP3_MIN_DATA_CHUNK_SIZE   16384
+#ifndef MA_DR_MP3_DATA_CHUNK_SIZE
+#define MA_DR_MP3_DATA_CHUNK_SIZE  (MA_DR_MP3_MIN_DATA_CHUNK_SIZE*4)
+#endif
+#define MA_DR_MP3_COUNTOF(x)        (sizeof(x) / sizeof(x[0]))
+#define MA_DR_MP3_CLAMP(x, lo, hi)  (MA_DR_MP3_MAX(lo, MA_DR_MP3_MIN(x, hi)))
+#ifndef MA_DR_MP3_PI_D
+#define MA_DR_MP3_PI_D    3.14159265358979323846264
+#endif
+#define MA_DR_MP3_DEFAULT_RESAMPLER_LPF_ORDER   2
+static MA_INLINE float ma_dr_mp3_mix_f32(float x, float y, float a)
+{
+    return x*(1-a) + y*a;
+}
+static MA_INLINE float ma_dr_mp3_mix_f32_fast(float x, float y, float a)
+{
+    float r0 = (y - x);
+    float r1 = r0*a;
+    return x + r1;
+}
+static MA_INLINE ma_uint32 ma_dr_mp3_gcf_u32(ma_uint32 a, ma_uint32 b)
+{
+    for (;;) {
+        if (b == 0) {
+            break;
+        } else {
+            ma_uint32 t = a;
+            a = b;
+            b = t % a;
+        }
+    }
+    return a;
+}
+static void* ma_dr_mp3__malloc_default(size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_MP3_MALLOC(sz);
+}
+static void* ma_dr_mp3__realloc_default(void* p, size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_MP3_REALLOC(p, sz);
+}
+static void ma_dr_mp3__free_default(void* p, void* pUserData)
+{
+    (void)pUserData;
+    MA_DR_MP3_FREE(p);
+}
+static void* ma_dr_mp3__malloc_from_callbacks(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onMalloc != NULL) {
+        return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData);
+    }
+    return NULL;
+}
+static void* ma_dr_mp3__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) {
+        void* p2;
+        p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData);
+        if (p2 == NULL) {
+            return NULL;
+        }
+        if (p != NULL) {
+            MA_DR_MP3_COPY_MEMORY(p2, p, szOld);
+            pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+        }
+        return p2;
+    }
+    return NULL;
+}
+static void ma_dr_mp3__free_from_callbacks(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (p == NULL || pAllocationCallbacks == NULL) {
+        return;
+    }
+    if (pAllocationCallbacks->onFree != NULL) {
+        pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+    }
+}
+static ma_allocation_callbacks ma_dr_mp3_copy_allocation_callbacks_or_defaults(const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        return *pAllocationCallbacks;
+    } else {
+        ma_allocation_callbacks allocationCallbacks;
+        allocationCallbacks.pUserData = NULL;
+        allocationCallbacks.onMalloc  = ma_dr_mp3__malloc_default;
+        allocationCallbacks.onRealloc = ma_dr_mp3__realloc_default;
+        allocationCallbacks.onFree    = ma_dr_mp3__free_default;
+        return allocationCallbacks;
+    }
+}
+static size_t ma_dr_mp3__on_read(ma_dr_mp3* pMP3, void* pBufferOut, size_t bytesToRead)
+{
+    size_t bytesRead;
+    MA_DR_MP3_ASSERT(pMP3         != NULL);
+    MA_DR_MP3_ASSERT(pMP3->onRead != NULL);
+    if (bytesToRead == 0) {
+        return 0;
+    }
+    bytesRead = pMP3->onRead(pMP3->pUserData, pBufferOut, bytesToRead);
+    pMP3->streamCursor += bytesRead;
+    return bytesRead;
+}
+static size_t ma_dr_mp3__on_read_clamped(ma_dr_mp3* pMP3, void* pBufferOut, size_t bytesToRead)
+{
+    MA_DR_MP3_ASSERT(pMP3         != NULL);
+    MA_DR_MP3_ASSERT(pMP3->onRead != NULL);
+    if (pMP3->streamLength == MA_UINT64_MAX) {
+        return ma_dr_mp3__on_read(pMP3, pBufferOut, bytesToRead);
+    } else {
+        ma_uint64 bytesRemaining;
+        bytesRemaining = (pMP3->streamLength - pMP3->streamCursor);
+        if (bytesToRead >         bytesRemaining) {
+            bytesToRead = (size_t)bytesRemaining;
+        }
+        return ma_dr_mp3__on_read(pMP3, pBufferOut, bytesToRead);
+    }
+}
+static ma_bool32 ma_dr_mp3__on_seek(ma_dr_mp3* pMP3, int offset, ma_dr_mp3_seek_origin origin)
+{
+    MA_DR_MP3_ASSERT(offset >= 0);
+    MA_DR_MP3_ASSERT(origin == MA_DR_MP3_SEEK_SET || origin == MA_DR_MP3_SEEK_CUR);
+    if (!pMP3->onSeek(pMP3->pUserData, offset, origin)) {
+        return MA_FALSE;
+    }
+    if (origin == MA_DR_MP3_SEEK_SET) {
+        pMP3->streamCursor = (ma_uint64)offset;
+    } else{
+        pMP3->streamCursor += offset;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_mp3__on_seek_64(ma_dr_mp3* pMP3, ma_uint64 offset, ma_dr_mp3_seek_origin origin)
+{
+    if (offset <= 0x7FFFFFFF) {
+        return ma_dr_mp3__on_seek(pMP3, (int)offset, origin);
+    }
+    if (!ma_dr_mp3__on_seek(pMP3, 0x7FFFFFFF, MA_DR_MP3_SEEK_SET)) {
+        return MA_FALSE;
+    }
+    offset -= 0x7FFFFFFF;
+    while (offset > 0) {
+        if (offset <= 0x7FFFFFFF) {
+            if (!ma_dr_mp3__on_seek(pMP3, (int)offset, MA_DR_MP3_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+            offset = 0;
+        } else {
+            if (!ma_dr_mp3__on_seek(pMP3, 0x7FFFFFFF, MA_DR_MP3_SEEK_CUR)) {
+                return MA_FALSE;
+            }
+            offset -= 0x7FFFFFFF;
+        }
+    }
+    return MA_TRUE;
+}
+static void ma_dr_mp3__on_meta(ma_dr_mp3* pMP3, ma_dr_mp3_metadata_type type, const void* pRawData, size_t rawDataSize)
+{
+    if (pMP3->onMeta) {
+        ma_dr_mp3_metadata metadata;
+        MA_DR_MP3_ZERO_OBJECT(&metadata);
+        metadata.type        = type;
+        metadata.pRawData    = pRawData;
+        metadata.rawDataSize = rawDataSize;
+        pMP3->onMeta(pMP3->pUserDataMeta, &metadata);
+    }
+}
+static ma_uint32 ma_dr_mp3_decode_next_frame_ex__callbacks(ma_dr_mp3* pMP3, ma_dr_mp3d_sample_t* pPCMFrames, ma_dr_mp3dec_frame_info* pMP3FrameInfo, const ma_uint8** ppMP3FrameData)
+{
+    ma_uint32 pcmFramesRead = 0;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->onRead != NULL);
+    if (pMP3->atEnd) {
+        return 0;
+    }
+    for (;;) {
+        ma_dr_mp3dec_frame_info info;
+        if (pMP3->dataSize < MA_DR_MP3_MIN_DATA_CHUNK_SIZE) {
+            size_t bytesRead;
+            if (pMP3->pData != NULL) {
+                MA_DR_MP3_MOVE_MEMORY(pMP3->pData, pMP3->pData + pMP3->dataConsumed, pMP3->dataSize);
+            }
+            pMP3->dataConsumed = 0;
+            if (pMP3->dataCapacity < MA_DR_MP3_DATA_CHUNK_SIZE) {
+                ma_uint8* pNewData;
+                size_t newDataCap;
+                newDataCap = MA_DR_MP3_DATA_CHUNK_SIZE;
+                pNewData = (ma_uint8*)ma_dr_mp3__realloc_from_callbacks(pMP3->pData, newDataCap, pMP3->dataCapacity, &pMP3->allocationCallbacks);
+                if (pNewData == NULL) {
+                    return 0;
+                }
+                pMP3->pData = pNewData;
+                pMP3->dataCapacity = newDataCap;
+            }
+            bytesRead = ma_dr_mp3__on_read_clamped(pMP3, pMP3->pData + pMP3->dataSize, (pMP3->dataCapacity - pMP3->dataSize));
+            if (bytesRead == 0) {
+                if (pMP3->dataSize == 0) {
+                    pMP3->atEnd = MA_TRUE;
+                    return 0;
+                }
+            }
+            pMP3->dataSize += bytesRead;
+        }
+        if (pMP3->dataSize > INT_MAX) {
+            pMP3->atEnd = MA_TRUE;
+            return 0;
+        }
+        MA_DR_MP3_ASSERT(pMP3->pData != NULL);
+        MA_DR_MP3_ASSERT(pMP3->dataCapacity > 0);
+        if (pMP3->pData == NULL) {
+            return 0;
+        }
+        pcmFramesRead = ma_dr_mp3dec_decode_frame(&pMP3->decoder, pMP3->pData + pMP3->dataConsumed, (int)pMP3->dataSize, pPCMFrames, &info);
+        pMP3->dataConsumed += (size_t)info.frame_bytes;
+        pMP3->dataSize     -= (size_t)info.frame_bytes;
+        if (pcmFramesRead > 0) {
+            pcmFramesRead = ma_dr_mp3_hdr_frame_samples(pMP3->decoder.header);
+            pMP3->pcmFramesConsumedInMP3Frame = 0;
+            pMP3->pcmFramesRemainingInMP3Frame = pcmFramesRead;
+            pMP3->mp3FrameChannels = info.channels;
+            pMP3->mp3FrameSampleRate = info.sample_rate;
+            if (pMP3FrameInfo != NULL) {
+                *pMP3FrameInfo = info;
+            }
+            if (ppMP3FrameData != NULL) {
+                *ppMP3FrameData = pMP3->pData + pMP3->dataConsumed - (size_t)info.frame_bytes;
+            }
+            break;
+        } else if (info.frame_bytes == 0) {
+            size_t bytesRead;
+            MA_DR_MP3_MOVE_MEMORY(pMP3->pData, pMP3->pData + pMP3->dataConsumed, pMP3->dataSize);
+            pMP3->dataConsumed = 0;
+            if (pMP3->dataCapacity == pMP3->dataSize) {
+                ma_uint8* pNewData;
+                size_t newDataCap;
+                newDataCap = pMP3->dataCapacity + MA_DR_MP3_DATA_CHUNK_SIZE;
+                pNewData = (ma_uint8*)ma_dr_mp3__realloc_from_callbacks(pMP3->pData, newDataCap, pMP3->dataCapacity, &pMP3->allocationCallbacks);
+                if (pNewData == NULL) {
+                    return 0;
+                }
+                pMP3->pData = pNewData;
+                pMP3->dataCapacity = newDataCap;
+            }
+            bytesRead = ma_dr_mp3__on_read_clamped(pMP3, pMP3->pData + pMP3->dataSize, (pMP3->dataCapacity - pMP3->dataSize));
+            if (bytesRead == 0) {
+                pMP3->atEnd = MA_TRUE;
+                return 0;
+            }
+            pMP3->dataSize += bytesRead;
+        }
+    };
+    return pcmFramesRead;
+}
+static ma_uint32 ma_dr_mp3_decode_next_frame_ex__memory(ma_dr_mp3* pMP3, ma_dr_mp3d_sample_t* pPCMFrames, ma_dr_mp3dec_frame_info* pMP3FrameInfo, const ma_uint8** ppMP3FrameData)
+{
+    ma_uint32 pcmFramesRead = 0;
+    ma_dr_mp3dec_frame_info info;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->memory.pData != NULL);
+    if (pMP3->atEnd) {
+        return 0;
+    }
+    for (;;) {
+        pcmFramesRead = ma_dr_mp3dec_decode_frame(&pMP3->decoder, pMP3->memory.pData + pMP3->memory.currentReadPos, (int)(pMP3->memory.dataSize - pMP3->memory.currentReadPos), pPCMFrames, &info);
+        if (pcmFramesRead > 0) {
+            pcmFramesRead = ma_dr_mp3_hdr_frame_samples(pMP3->decoder.header);
+            pMP3->pcmFramesConsumedInMP3Frame  = 0;
+            pMP3->pcmFramesRemainingInMP3Frame = pcmFramesRead;
+            pMP3->mp3FrameChannels             = info.channels;
+            pMP3->mp3FrameSampleRate           = info.sample_rate;
+            if (pMP3FrameInfo != NULL) {
+                *pMP3FrameInfo = info;
+            }
+            if (ppMP3FrameData != NULL) {
+                *ppMP3FrameData = pMP3->memory.pData + pMP3->memory.currentReadPos;
+            }
+            break;
+        } else if (info.frame_bytes > 0) {
+            pMP3->memory.currentReadPos += (size_t)info.frame_bytes;
+            pMP3->streamCursor          += (size_t)info.frame_bytes;
+        } else {
+            break;
+        }
+    }
+    pMP3->memory.currentReadPos += (size_t)info.frame_bytes;
+    pMP3->streamCursor          += (size_t)info.frame_bytes;
+    return pcmFramesRead;
+}
+static ma_uint32 ma_dr_mp3_decode_next_frame_ex(ma_dr_mp3* pMP3, ma_dr_mp3d_sample_t* pPCMFrames, ma_dr_mp3dec_frame_info* pMP3FrameInfo, const ma_uint8** ppMP3FrameData)
+{
+    if (pMP3->memory.pData != NULL && pMP3->memory.dataSize > 0) {
+        return ma_dr_mp3_decode_next_frame_ex__memory(pMP3, pPCMFrames, pMP3FrameInfo, ppMP3FrameData);
+    } else {
+        return ma_dr_mp3_decode_next_frame_ex__callbacks(pMP3, pPCMFrames, pMP3FrameInfo, ppMP3FrameData);
+    }
+}
+static ma_uint32 ma_dr_mp3_decode_next_frame(ma_dr_mp3* pMP3)
+{
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    return ma_dr_mp3_decode_next_frame_ex(pMP3, (ma_dr_mp3d_sample_t*)pMP3->pcmFrames, NULL, NULL);
+}
+#if 0
+static ma_uint32 ma_dr_mp3_seek_next_frame(ma_dr_mp3* pMP3)
+{
+    ma_uint32 pcmFrameCount;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    pcmFrameCount = ma_dr_mp3_decode_next_frame_ex(pMP3, NULL, NULL, NULL);
+    if (pcmFrameCount == 0) {
+        return 0;
+    }
+    pMP3->currentPCMFrame             += pcmFrameCount;
+    pMP3->pcmFramesConsumedInMP3Frame  = pcmFrameCount;
+    pMP3->pcmFramesRemainingInMP3Frame = 0;
+    return pcmFrameCount;
+}
+#endif
+static ma_bool32 ma_dr_mp3_init_internal(ma_dr_mp3* pMP3, ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, ma_dr_mp3_tell_proc onTell, ma_dr_mp3_meta_proc onMeta, void* pUserData, void* pUserDataMeta, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3dec_frame_info firstFrameInfo;
+    const ma_uint8* pFirstFrameData;
+    ma_uint32 firstFramePCMFrameCount;
+    ma_uint32 detectedMP3FrameCount = 0xFFFFFFFF;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(onRead != NULL);
+    ma_dr_mp3dec_init(&pMP3->decoder);
+    pMP3->onRead = onRead;
+    pMP3->onSeek = onSeek;
+    pMP3->onMeta = onMeta;
+    pMP3->pUserData = pUserData;
+    pMP3->pUserDataMeta = pUserDataMeta;
+    pMP3->allocationCallbacks = ma_dr_mp3_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
+    if (pMP3->allocationCallbacks.onFree == NULL || (pMP3->allocationCallbacks.onMalloc == NULL && pMP3->allocationCallbacks.onRealloc == NULL)) {
+        return MA_FALSE;
+    }
+    pMP3->streamCursor       = 0;
+    pMP3->streamLength       = MA_UINT64_MAX;
+    pMP3->streamStartOffset  = 0;
+    pMP3->delayInPCMFrames   = 0;
+    pMP3->paddingInPCMFrames = 0;
+    pMP3->totalPCMFrameCount = MA_UINT64_MAX;
+    #if 1
+    if (onSeek != NULL && onTell != NULL) {
+        if (onSeek(pUserData, 0, MA_DR_MP3_SEEK_END)) {
+            ma_int64 streamLen;
+            int streamEndOffset = 0;
+            if (onTell(pUserData, &streamLen)) {
+                if (streamLen > 128) {
+                    char id3[3];
+                    if (onSeek(pUserData, streamEndOffset - 128, MA_DR_MP3_SEEK_END)) {
+                        if (onRead(pUserData, id3, 3) == 3 && id3[0] == 'T' && id3[1] == 'A' && id3[2] == 'G') {
+                            streamEndOffset -= 128;
+                            streamLen       -= 128;
+                            if (onMeta != NULL) {
+                                ma_uint8 tag[128];
+                                tag[0] = 'T'; tag[1] = 'A'; tag[2] = 'G';
+                                if (onRead(pUserData, tag + 3, 125) == 125) {
+                                    ma_dr_mp3__on_meta(pMP3, MA_DR_MP3_METADATA_TYPE_ID3V1, tag, 128);
+                                }
+                            }
+                        } else {
+                        }
+                    } else {
+                    }
+                } else {
+                }
+                if (streamLen > 32) {
+                    char ape[32];
+                    if (onSeek(pUserData, streamEndOffset - 32, MA_DR_MP3_SEEK_END)) {
+                        if (onRead(pUserData, ape, 32) == 32 && ape[0] == 'A' && ape[1] == 'P' && ape[2] == 'E' && ape[3] == 'T' && ape[4] == 'A' && ape[5] == 'G' && ape[6] == 'E' && ape[7] == 'X') {
+                            ma_uint32 tagSize =
+                                ((ma_uint32)ape[24] << 0)  |
+                                ((ma_uint32)ape[25] << 8)  |
+                                ((ma_uint32)ape[26] << 16) |
+                                ((ma_uint32)ape[27] << 24);
+                            streamEndOffset -= 32 + tagSize;
+                            streamLen       -= 32 + tagSize;
+                            if (onMeta != NULL) {
+                                if (onSeek(pUserData, streamEndOffset, MA_DR_MP3_SEEK_END)) {
+                                    size_t apeTagSize = (size_t)tagSize + 32;
+                                    ma_uint8* pTagData = (ma_uint8*)ma_dr_mp3_malloc(apeTagSize, pAllocationCallbacks);
+                                    if (pTagData != NULL) {
+                                        if (onRead(pUserData, pTagData, apeTagSize) == apeTagSize) {
+                                            ma_dr_mp3__on_meta(pMP3, MA_DR_MP3_METADATA_TYPE_APE, pTagData, apeTagSize);
+                                        }
+                                        ma_dr_mp3_free(pTagData, pAllocationCallbacks);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                }
+                if (!onSeek(pUserData, 0, MA_DR_MP3_SEEK_SET)) {
+                    return MA_FALSE;
+                }
+                pMP3->streamLength = (ma_uint64)streamLen;
+                if (pMP3->memory.pData != NULL) {
+                    pMP3->memory.dataSize = (size_t)pMP3->streamLength;
+                }
+            } else {
+                if (!onSeek(pUserData, 0, MA_DR_MP3_SEEK_SET)) {
+                    return MA_FALSE;
+                }
+            }
+        } else {
+        }
+    } else {
+    }
+    #endif
+    #if 1
+    {
+        char header[10];
+        if (onRead(pUserData, header, 10) == 10) {
+            if (header[0] == 'I' && header[1] == 'D' && header[2] == '3') {
+                ma_uint32 tagSize =
+                    (((ma_uint32)header[6] & 0x7F) << 21) |
+                    (((ma_uint32)header[7] & 0x7F) << 14) |
+                    (((ma_uint32)header[8] & 0x7F) << 7)  |
+                    (((ma_uint32)header[9] & 0x7F) << 0);
+                if (header[5] & 0x10) {
+                    tagSize += 10;
+                }
+                if (onMeta != NULL) {
+                    size_t tagSizeWithHeader = 10 + tagSize;
+                    ma_uint8* pTagData = (ma_uint8*)ma_dr_mp3_malloc(tagSizeWithHeader, pAllocationCallbacks);
+                    if (pTagData != NULL) {
+                        MA_DR_MP3_COPY_MEMORY(pTagData, header, 10);
+                        if (onRead(pUserData, pTagData + 10, tagSize) == tagSize) {
+                            ma_dr_mp3__on_meta(pMP3, MA_DR_MP3_METADATA_TYPE_ID3V2, pTagData, tagSizeWithHeader);
+                        }
+                        ma_dr_mp3_free(pTagData, pAllocationCallbacks);
+                    }
+                } else {
+                    if (onSeek != NULL) {
+                        if (!onSeek(pUserData, tagSize, MA_DR_MP3_SEEK_CUR)) {
+                            return MA_FALSE;
+                        }
+                    } else {
+                        char discard[1024];
+                        while (tagSize > 0) {
+                            size_t bytesToRead = tagSize;
+                            if (bytesToRead > sizeof(discard)) {
+                                bytesToRead = sizeof(discard);
+                            }
+                            if (onRead(pUserData, discard, bytesToRead) != bytesToRead) {
+                                return MA_FALSE;
+                            }
+                            tagSize -= (ma_uint32)bytesToRead;
+                        }
+                    }
+                }
+                pMP3->streamStartOffset += 10 + tagSize;
+                pMP3->streamCursor = pMP3->streamStartOffset;
+            } else {
+                if (onSeek != NULL) {
+                    if (!onSeek(pUserData, 0, MA_DR_MP3_SEEK_SET)) {
+                        return MA_FALSE;
+                    }
+                } else {
+                }
+            }
+        } else {
+            return MA_FALSE;
+        }
+    }
+    #endif
+    firstFramePCMFrameCount = ma_dr_mp3_decode_next_frame_ex(pMP3, (ma_dr_mp3d_sample_t*)pMP3->pcmFrames, &firstFrameInfo, &pFirstFrameData);
+    if (firstFramePCMFrameCount > 0) {
+        MA_DR_MP3_ASSERT(pFirstFrameData != NULL);
+        #if 1
+        MA_DR_MP3_ASSERT(firstFrameInfo.frame_bytes > 0);
+        {
+            ma_dr_mp3_bs bs;
+            ma_dr_mp3_L3_gr_info grInfo[4];
+            const ma_uint8* pTagData = pFirstFrameData;
+            ma_dr_mp3_bs_init(&bs, pFirstFrameData + MA_DR_MP3_HDR_SIZE, firstFrameInfo.frame_bytes - MA_DR_MP3_HDR_SIZE);
+            if (MA_DR_MP3_HDR_IS_CRC(pFirstFrameData)) {
+                ma_dr_mp3_bs_get_bits(&bs, 16);
+            }
+            if (ma_dr_mp3_L3_read_side_info(&bs, grInfo, pFirstFrameData) >= 0) {
+                ma_bool32 isXing = MA_FALSE;
+                ma_bool32 isInfo = MA_FALSE;
+                const ma_uint8* pTagDataBeg;
+                pTagDataBeg = pFirstFrameData + MA_DR_MP3_HDR_SIZE + (bs.pos/8);
+                pTagData    = pTagDataBeg;
+                isXing = (pTagData[0] == 'X' && pTagData[1] == 'i' && pTagData[2] == 'n' && pTagData[3] == 'g');
+                isInfo = (pTagData[0] == 'I' && pTagData[1] == 'n' && pTagData[2] == 'f' && pTagData[3] == 'o');
+                if (isXing || isInfo) {
+                    ma_uint32 bytes = 0;
+                    ma_uint32 flags = pTagData[7];
+                    pTagData += 8;
+                    if (flags & 0x01) {
+                        detectedMP3FrameCount = (ma_uint32)pTagData[0] << 24 | (ma_uint32)pTagData[1] << 16 | (ma_uint32)pTagData[2] << 8 | (ma_uint32)pTagData[3];
+                        pTagData += 4;
+                    }
+                    if (flags & 0x02) {
+                        bytes  = (ma_uint32)pTagData[0] << 24 | (ma_uint32)pTagData[1] << 16 | (ma_uint32)pTagData[2] << 8 | (ma_uint32)pTagData[3];
+                        (void)bytes;
+                        pTagData += 4;
+                    }
+                    if (flags & 0x04) {
+                        pTagData += 100;
+                    }
+                    if (flags & 0x08) {
+                        pTagData += 4;
+                    }
+                    if (pTagData[0]) {
+                        pTagData += 21;
+                        if (pTagData - pFirstFrameData + 14 < firstFrameInfo.frame_bytes) {
+                            int delayInPCMFrames;
+                            int paddingInPCMFrames;
+                            delayInPCMFrames   = (( (ma_uint32)pTagData[0]        << 4) | ((ma_uint32)pTagData[1] >> 4)) + (528 + 1);
+                            paddingInPCMFrames = ((((ma_uint32)pTagData[1] & 0xF) << 8) | ((ma_uint32)pTagData[2]     )) - (528 + 1);
+                            if (paddingInPCMFrames < 0) {
+                                paddingInPCMFrames = 0;
+                            }
+                            pMP3->delayInPCMFrames   = (ma_uint32)delayInPCMFrames;
+                            pMP3->paddingInPCMFrames = (ma_uint32)paddingInPCMFrames;
+                        }
+                    }
+                    if (isXing) {
+                        pMP3->isVBR = MA_TRUE;
+                    } else if (isInfo) {
+                        pMP3->isCBR = MA_TRUE;
+                    }
+                    if (onMeta != NULL) {
+                        ma_dr_mp3_metadata_type metadataType = isXing ? MA_DR_MP3_METADATA_TYPE_XING : MA_DR_MP3_METADATA_TYPE_VBRI;
+                        size_t tagDataSize;
+                        tagDataSize  = (size_t)firstFrameInfo.frame_bytes;
+                        tagDataSize -= (size_t)(pTagDataBeg - pFirstFrameData);
+                        ma_dr_mp3__on_meta(pMP3, metadataType, pTagDataBeg, tagDataSize);
+                    }
+                    pMP3->pcmFramesRemainingInMP3Frame = 0;
+                    pMP3->streamStartOffset += (ma_uint32)(firstFrameInfo.frame_bytes);
+                    pMP3->streamCursor = pMP3->streamStartOffset;
+                    ma_dr_mp3dec_init(&pMP3->decoder);
+                }
+            } else {
+            }
+        }
+        #endif
+    } else {
+        ma_dr_mp3__free_from_callbacks(pMP3->pData, &pMP3->allocationCallbacks);
+        return MA_FALSE;
+    }
+    if (detectedMP3FrameCount != 0xFFFFFFFF) {
+        pMP3->totalPCMFrameCount = detectedMP3FrameCount * firstFramePCMFrameCount;
+    }
+    pMP3->channels   = pMP3->mp3FrameChannels;
+    pMP3->sampleRate = pMP3->mp3FrameSampleRate;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_init(ma_dr_mp3* pMP3, ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, ma_dr_mp3_tell_proc onTell, ma_dr_mp3_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pMP3 == NULL || onRead == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_MP3_ZERO_OBJECT(pMP3);
+    return ma_dr_mp3_init_internal(pMP3, onRead, onSeek, onTell, onMeta, pUserData, pUserData, pAllocationCallbacks);
+}
+static size_t ma_dr_mp3__on_read_memory(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_dr_mp3* pMP3 = (ma_dr_mp3*)pUserData;
+    size_t bytesRemaining;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->memory.dataSize >= pMP3->memory.currentReadPos);
+    bytesRemaining = pMP3->memory.dataSize - pMP3->memory.currentReadPos;
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+    if (bytesToRead > 0) {
+        MA_DR_MP3_COPY_MEMORY(pBufferOut, pMP3->memory.pData + pMP3->memory.currentReadPos, bytesToRead);
+        pMP3->memory.currentReadPos += bytesToRead;
+    }
+    return bytesToRead;
+}
+static ma_bool32 ma_dr_mp3__on_seek_memory(void* pUserData, int byteOffset, ma_dr_mp3_seek_origin origin)
+{
+    ma_dr_mp3* pMP3 = (ma_dr_mp3*)pUserData;
+    ma_int64 newCursor;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    newCursor = pMP3->memory.currentReadPos;
+    if (origin == MA_DR_MP3_SEEK_SET) {
+        newCursor = 0;
+    } else if (origin == MA_DR_MP3_SEEK_CUR) {
+        newCursor = (ma_int64)pMP3->memory.currentReadPos;
+    } else if (origin == MA_DR_MP3_SEEK_END) {
+        newCursor = (ma_int64)pMP3->memory.dataSize;
+    } else {
+        MA_DR_MP3_ASSERT(!"Invalid seek origin");
+        return MA_FALSE;
+    }
+    newCursor += byteOffset;
+    if (newCursor < 0) {
+        return MA_FALSE;
+    }
+    if ((size_t)newCursor > pMP3->memory.dataSize) {
+        return MA_FALSE;
+    }
+    pMP3->memory.currentReadPos = (size_t)newCursor;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_mp3__on_tell_memory(void* pUserData, ma_int64* pCursor)
+{
+    ma_dr_mp3* pMP3 = (ma_dr_mp3*)pUserData;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pCursor != NULL);
+    *pCursor = (ma_int64)pMP3->memory.currentReadPos;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_init_memory_with_metadata(ma_dr_mp3* pMP3, const void* pData, size_t dataSize, ma_dr_mp3_meta_proc onMeta, void* pUserDataMeta, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 result;
+    if (pMP3 == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_MP3_ZERO_OBJECT(pMP3);
+    if (pData == NULL || dataSize == 0) {
+        return MA_FALSE;
+    }
+    pMP3->memory.pData = (const ma_uint8*)pData;
+    pMP3->memory.dataSize = dataSize;
+    pMP3->memory.currentReadPos = 0;
+    result = ma_dr_mp3_init_internal(pMP3, ma_dr_mp3__on_read_memory, ma_dr_mp3__on_seek_memory, ma_dr_mp3__on_tell_memory, onMeta, pMP3, pUserDataMeta, pAllocationCallbacks);
+    if (result == MA_FALSE) {
+        return MA_FALSE;
+    }
+    if (pMP3->streamLength <= (ma_uint64)MA_SIZE_MAX) {
+        pMP3->memory.dataSize = (size_t)pMP3->streamLength;
+    }
+    if (pMP3->streamStartOffset > (ma_uint64)MA_SIZE_MAX) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_init_memory(ma_dr_mp3* pMP3, const void* pData, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_mp3_init_memory_with_metadata(pMP3, pData, dataSize, NULL, NULL, pAllocationCallbacks);
+}
+#ifndef MA_DR_MP3_NO_STDIO
+#include <stdio.h>
+#include <wchar.h>
+static size_t ma_dr_mp3__on_read_stdio(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    return fread(pBufferOut, 1, bytesToRead, (FILE*)pUserData);
+}
+static ma_bool32 ma_dr_mp3__on_seek_stdio(void* pUserData, int offset, ma_dr_mp3_seek_origin origin)
+{
+    int whence = SEEK_SET;
+    if (origin == MA_DR_MP3_SEEK_CUR) {
+        whence = SEEK_CUR;
+    } else if (origin == MA_DR_MP3_SEEK_END) {
+        whence = SEEK_END;
+    }
+    return fseek((FILE*)pUserData, offset, whence) == 0;
+}
+static ma_bool32 ma_dr_mp3__on_tell_stdio(void* pUserData, ma_int64* pCursor)
+{
+    FILE* pFileStdio = (FILE*)pUserData;
+    ma_int64 result;
+    MA_DR_MP3_ASSERT(pFileStdio != NULL);
+    MA_DR_MP3_ASSERT(pCursor    != NULL);
+#if defined(_WIN32) && !defined(NXDK)
+    #if defined(_MSC_VER) && _MSC_VER > 1200
+        result = _ftelli64(pFileStdio);
+    #else
+        result = ftell(pFileStdio);
+    #endif
+#else
+    result = ftell(pFileStdio);
+#endif
+    *pCursor = result;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_init_file_with_metadata(ma_dr_mp3* pMP3, const char* pFilePath, ma_dr_mp3_meta_proc onMeta, void* pUserDataMeta, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 result;
+    FILE* pFile;
+    if (pMP3 == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_MP3_ZERO_OBJECT(pMP3);
+    if (ma_fopen(&pFile, pFilePath, "rb") != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    result = ma_dr_mp3_init_internal(pMP3, ma_dr_mp3__on_read_stdio, ma_dr_mp3__on_seek_stdio, ma_dr_mp3__on_tell_stdio, onMeta, (void*)pFile, pUserDataMeta, pAllocationCallbacks);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_init_file_with_metadata_w(ma_dr_mp3* pMP3, const wchar_t* pFilePath, ma_dr_mp3_meta_proc onMeta, void* pUserDataMeta, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 result;
+    FILE* pFile;
+    if (pMP3 == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_MP3_ZERO_OBJECT(pMP3);
+    if (ma_wfopen(&pFile, pFilePath, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    result = ma_dr_mp3_init_internal(pMP3, ma_dr_mp3__on_read_stdio, ma_dr_mp3__on_seek_stdio, ma_dr_mp3__on_tell_stdio, onMeta, (void*)pFile, pUserDataMeta, pAllocationCallbacks);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_init_file(ma_dr_mp3* pMP3, const char* pFilePath, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_mp3_init_file_with_metadata(pMP3, pFilePath, NULL, NULL, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_mp3_init_file_w(ma_dr_mp3* pMP3, const wchar_t* pFilePath, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_mp3_init_file_with_metadata_w(pMP3, pFilePath, NULL, NULL, pAllocationCallbacks);
+}
+#endif
+MA_API void ma_dr_mp3_uninit(ma_dr_mp3* pMP3)
+{
+    if (pMP3 == NULL) {
+        return;
+    }
+#ifndef MA_DR_MP3_NO_STDIO
+    if (pMP3->onRead == ma_dr_mp3__on_read_stdio) {
+        FILE* pFile = (FILE*)pMP3->pUserData;
+        if (pFile != NULL) {
+            fclose(pFile);
+            pMP3->pUserData = NULL;
+        }
+    }
+#endif
+    ma_dr_mp3__free_from_callbacks(pMP3->pData, &pMP3->allocationCallbacks);
+}
+#if defined(MA_DR_MP3_FLOAT_OUTPUT)
+static void ma_dr_mp3_f32_to_s16(ma_int16* dst, const float* src, ma_uint64 sampleCount)
+{
+    ma_uint64 i;
+    ma_uint64 i4;
+    ma_uint64 sampleCount4;
+    i = 0;
+    sampleCount4 = sampleCount >> 2;
+    for (i4 = 0; i4 < sampleCount4; i4 += 1) {
+        float x0 = src[i+0];
+        float x1 = src[i+1];
+        float x2 = src[i+2];
+        float x3 = src[i+3];
+        x0 = ((x0 < -1) ? -1 : ((x0 > 1) ? 1 : x0));
+        x1 = ((x1 < -1) ? -1 : ((x1 > 1) ? 1 : x1));
+        x2 = ((x2 < -1) ? -1 : ((x2 > 1) ? 1 : x2));
+        x3 = ((x3 < -1) ? -1 : ((x3 > 1) ? 1 : x3));
+        x0 = x0 * 32767.0f;
+        x1 = x1 * 32767.0f;
+        x2 = x2 * 32767.0f;
+        x3 = x3 * 32767.0f;
+        dst[i+0] = (ma_int16)x0;
+        dst[i+1] = (ma_int16)x1;
+        dst[i+2] = (ma_int16)x2;
+        dst[i+3] = (ma_int16)x3;
+        i += 4;
+    }
+    for (; i < sampleCount; i += 1) {
+        float x = src[i];
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
+        x = x * 32767.0f;
+        dst[i] = (ma_int16)x;
+    }
+}
+#endif
+#if !defined(MA_DR_MP3_FLOAT_OUTPUT)
+static void ma_dr_mp3_s16_to_f32(float* dst, const ma_int16* src, ma_uint64 sampleCount)
+{
+    ma_uint64 i;
+    for (i = 0; i < sampleCount; i += 1) {
+        float x = (float)src[i];
+        x = x * 0.000030517578125f;
+        dst[i] = x;
+    }
+}
+#endif
+static ma_uint64 ma_dr_mp3_read_pcm_frames_raw(ma_dr_mp3* pMP3, ma_uint64 framesToRead, void* pBufferOut)
+{
+    ma_uint64 totalFramesRead = 0;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->onRead != NULL);
+    while (framesToRead > 0) {
+        ma_uint32 framesToConsume;
+        if (pMP3->currentPCMFrame < pMP3->delayInPCMFrames) {
+            ma_uint32 framesToSkip = (ma_uint32)MA_DR_MP3_MIN(pMP3->pcmFramesRemainingInMP3Frame, pMP3->delayInPCMFrames - pMP3->currentPCMFrame);
+            pMP3->currentPCMFrame              += framesToSkip;
+            pMP3->pcmFramesConsumedInMP3Frame  += framesToSkip;
+            pMP3->pcmFramesRemainingInMP3Frame -= framesToSkip;
+        }
+        framesToConsume = (ma_uint32)MA_DR_MP3_MIN(pMP3->pcmFramesRemainingInMP3Frame, framesToRead);
+        if (pMP3->totalPCMFrameCount != MA_UINT64_MAX && pMP3->totalPCMFrameCount > pMP3->paddingInPCMFrames) {
+            if (pMP3->currentPCMFrame < (pMP3->totalPCMFrameCount - pMP3->paddingInPCMFrames)) {
+                ma_uint64 framesRemainigToPadding = (pMP3->totalPCMFrameCount - pMP3->paddingInPCMFrames) - pMP3->currentPCMFrame;
+                if (framesToConsume >               framesRemainigToPadding) {
+                    framesToConsume = (ma_uint32)framesRemainigToPadding;
+                }
+            } else {
+                break;
+            }
+        }
+        if (pBufferOut != NULL) {
+            #if defined(MA_DR_MP3_FLOAT_OUTPUT)
+            {
+                float* pFramesOutF32 = (float*)MA_DR_MP3_OFFSET_PTR(pBufferOut,          sizeof(float) * totalFramesRead                   * pMP3->channels);
+                float* pFramesInF32  = (float*)MA_DR_MP3_OFFSET_PTR(&pMP3->pcmFrames[0], sizeof(float) * pMP3->pcmFramesConsumedInMP3Frame * pMP3->mp3FrameChannels);
+                MA_DR_MP3_COPY_MEMORY(pFramesOutF32, pFramesInF32, sizeof(float) * framesToConsume * pMP3->channels);
+            }
+            #else
+            {
+                ma_int16* pFramesOutS16 = (ma_int16*)MA_DR_MP3_OFFSET_PTR(pBufferOut,          sizeof(ma_int16) * totalFramesRead                   * pMP3->channels);
+                ma_int16* pFramesInS16  = (ma_int16*)MA_DR_MP3_OFFSET_PTR(&pMP3->pcmFrames[0], sizeof(ma_int16) * pMP3->pcmFramesConsumedInMP3Frame * pMP3->mp3FrameChannels);
+                MA_DR_MP3_COPY_MEMORY(pFramesOutS16, pFramesInS16, sizeof(ma_int16) * framesToConsume * pMP3->channels);
+            }
+            #endif
+        }
+        pMP3->currentPCMFrame              += framesToConsume;
+        pMP3->pcmFramesConsumedInMP3Frame  += framesToConsume;
+        pMP3->pcmFramesRemainingInMP3Frame -= framesToConsume;
+        totalFramesRead                    += framesToConsume;
+        framesToRead                       -= framesToConsume;
+        if (framesToRead == 0) {
+            break;
+        }
+        if (pMP3->totalPCMFrameCount != MA_UINT64_MAX && pMP3->totalPCMFrameCount > pMP3->paddingInPCMFrames && pMP3->currentPCMFrame >= (pMP3->totalPCMFrameCount - pMP3->paddingInPCMFrames)) {
+            break;
+        }
+        MA_DR_MP3_ASSERT(pMP3->pcmFramesRemainingInMP3Frame == 0);
+        if (ma_dr_mp3_decode_next_frame(pMP3) == 0) {
+            break;
+        }
+    }
+    return totalFramesRead;
+}
+MA_API ma_uint64 ma_dr_mp3_read_pcm_frames_f32(ma_dr_mp3* pMP3, ma_uint64 framesToRead, float* pBufferOut)
+{
+    if (pMP3 == NULL || pMP3->onRead == NULL) {
+        return 0;
+    }
+#if defined(MA_DR_MP3_FLOAT_OUTPUT)
+    return ma_dr_mp3_read_pcm_frames_raw(pMP3, framesToRead, pBufferOut);
+#else
+    {
+        ma_int16 pTempS16[8192];
+        ma_uint64 totalPCMFramesRead = 0;
+        while (totalPCMFramesRead < framesToRead) {
+            ma_uint64 framesJustRead;
+            ma_uint64 framesRemaining = framesToRead - totalPCMFramesRead;
+            ma_uint64 framesToReadNow = MA_DR_MP3_COUNTOF(pTempS16) / pMP3->channels;
+            if (framesToReadNow > framesRemaining) {
+                framesToReadNow = framesRemaining;
+            }
+            framesJustRead = ma_dr_mp3_read_pcm_frames_raw(pMP3, framesToReadNow, pTempS16);
+            if (framesJustRead == 0) {
+                break;
+            }
+            ma_dr_mp3_s16_to_f32((float*)MA_DR_MP3_OFFSET_PTR(pBufferOut, sizeof(float) * totalPCMFramesRead * pMP3->channels), pTempS16, framesJustRead * pMP3->channels);
+            totalPCMFramesRead += framesJustRead;
+        }
+        return totalPCMFramesRead;
+    }
+#endif
+}
+MA_API ma_uint64 ma_dr_mp3_read_pcm_frames_s16(ma_dr_mp3* pMP3, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    if (pMP3 == NULL || pMP3->onRead == NULL) {
+        return 0;
+    }
+#if !defined(MA_DR_MP3_FLOAT_OUTPUT)
+    return ma_dr_mp3_read_pcm_frames_raw(pMP3, framesToRead, pBufferOut);
+#else
+    {
+        float pTempF32[4096];
+        ma_uint64 totalPCMFramesRead = 0;
+        while (totalPCMFramesRead < framesToRead) {
+            ma_uint64 framesJustRead;
+            ma_uint64 framesRemaining = framesToRead - totalPCMFramesRead;
+            ma_uint64 framesToReadNow = MA_DR_MP3_COUNTOF(pTempF32) / pMP3->channels;
+            if (framesToReadNow > framesRemaining) {
+                framesToReadNow = framesRemaining;
+            }
+            framesJustRead = ma_dr_mp3_read_pcm_frames_raw(pMP3, framesToReadNow, pTempF32);
+            if (framesJustRead == 0) {
+                break;
+            }
+            ma_dr_mp3_f32_to_s16((ma_int16*)MA_DR_MP3_OFFSET_PTR(pBufferOut, sizeof(ma_int16) * totalPCMFramesRead * pMP3->channels), pTempF32, framesJustRead * pMP3->channels);
+            totalPCMFramesRead += framesJustRead;
+        }
+        return totalPCMFramesRead;
+    }
+#endif
+}
+static void ma_dr_mp3_reset(ma_dr_mp3* pMP3)
+{
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    pMP3->pcmFramesConsumedInMP3Frame = 0;
+    pMP3->pcmFramesRemainingInMP3Frame = 0;
+    pMP3->currentPCMFrame = 0;
+    pMP3->dataSize = 0;
+    pMP3->atEnd = MA_FALSE;
+    ma_dr_mp3dec_init(&pMP3->decoder);
+}
+static ma_bool32 ma_dr_mp3_seek_to_start_of_stream(ma_dr_mp3* pMP3)
+{
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->onSeek != NULL);
+    if (!ma_dr_mp3__on_seek_64(pMP3, pMP3->streamStartOffset, MA_DR_MP3_SEEK_SET)) {
+        return MA_FALSE;
+    }
+    ma_dr_mp3_reset(pMP3);
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_mp3_seek_forward_by_pcm_frames__brute_force(ma_dr_mp3* pMP3, ma_uint64 frameOffset)
+{
+    ma_uint64 framesRead;
+#if defined(MA_DR_MP3_FLOAT_OUTPUT)
+    framesRead = ma_dr_mp3_read_pcm_frames_f32(pMP3, frameOffset, NULL);
+#else
+    framesRead = ma_dr_mp3_read_pcm_frames_s16(pMP3, frameOffset, NULL);
+#endif
+    if (framesRead != frameOffset) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_mp3_seek_to_pcm_frame__brute_force(ma_dr_mp3* pMP3, ma_uint64 frameIndex)
+{
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    if (frameIndex == pMP3->currentPCMFrame) {
+        return MA_TRUE;
+    }
+    if (frameIndex < pMP3->currentPCMFrame) {
+        if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+            return MA_FALSE;
+        }
+    }
+    MA_DR_MP3_ASSERT(frameIndex >= pMP3->currentPCMFrame);
+    return ma_dr_mp3_seek_forward_by_pcm_frames__brute_force(pMP3, (frameIndex - pMP3->currentPCMFrame));
+}
+static ma_bool32 ma_dr_mp3_find_closest_seek_point(ma_dr_mp3* pMP3, ma_uint64 frameIndex, ma_uint32* pSeekPointIndex)
+{
+    ma_uint32 iSeekPoint;
+    MA_DR_MP3_ASSERT(pSeekPointIndex != NULL);
+    *pSeekPointIndex = 0;
+    if (frameIndex < pMP3->pSeekPoints[0].pcmFrameIndex) {
+        return MA_FALSE;
+    }
+    for (iSeekPoint = 0; iSeekPoint < pMP3->seekPointCount; ++iSeekPoint) {
+        if (pMP3->pSeekPoints[iSeekPoint].pcmFrameIndex > frameIndex) {
+            break;
+        }
+        *pSeekPointIndex = iSeekPoint;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_mp3_seek_to_pcm_frame__seek_table(ma_dr_mp3* pMP3, ma_uint64 frameIndex)
+{
+    ma_dr_mp3_seek_point seekPoint;
+    ma_uint32 priorSeekPointIndex;
+    ma_uint16 iMP3Frame;
+    ma_uint64 leftoverFrames;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->pSeekPoints != NULL);
+    MA_DR_MP3_ASSERT(pMP3->seekPointCount > 0);
+    if (ma_dr_mp3_find_closest_seek_point(pMP3, frameIndex, &priorSeekPointIndex)) {
+        seekPoint = pMP3->pSeekPoints[priorSeekPointIndex];
+    } else {
+        seekPoint.seekPosInBytes     = 0;
+        seekPoint.pcmFrameIndex      = 0;
+        seekPoint.mp3FramesToDiscard = 0;
+        seekPoint.pcmFramesToDiscard = 0;
+    }
+    if (!ma_dr_mp3__on_seek_64(pMP3, seekPoint.seekPosInBytes, MA_DR_MP3_SEEK_SET)) {
+        return MA_FALSE;
+    }
+    ma_dr_mp3_reset(pMP3);
+    for (iMP3Frame = 0; iMP3Frame < seekPoint.mp3FramesToDiscard; ++iMP3Frame) {
+        ma_uint32 pcmFramesRead;
+        ma_dr_mp3d_sample_t* pPCMFrames;
+        pPCMFrames = NULL;
+        if (iMP3Frame == seekPoint.mp3FramesToDiscard-1) {
+            pPCMFrames = (ma_dr_mp3d_sample_t*)pMP3->pcmFrames;
+        }
+        pcmFramesRead = ma_dr_mp3_decode_next_frame_ex(pMP3, pPCMFrames, NULL, NULL);
+        if (pcmFramesRead == 0) {
+            return MA_FALSE;
+        }
+    }
+    pMP3->currentPCMFrame = seekPoint.pcmFrameIndex - seekPoint.pcmFramesToDiscard;
+    leftoverFrames = frameIndex - pMP3->currentPCMFrame;
+    return ma_dr_mp3_seek_forward_by_pcm_frames__brute_force(pMP3, leftoverFrames);
+}
+MA_API ma_bool32 ma_dr_mp3_seek_to_pcm_frame(ma_dr_mp3* pMP3, ma_uint64 frameIndex)
+{
+    if (pMP3 == NULL || pMP3->onSeek == NULL) {
+        return MA_FALSE;
+    }
+    if (frameIndex == 0) {
+        return ma_dr_mp3_seek_to_start_of_stream(pMP3);
+    }
+    if (pMP3->pSeekPoints != NULL && pMP3->seekPointCount > 0) {
+        return ma_dr_mp3_seek_to_pcm_frame__seek_table(pMP3, frameIndex);
+    } else {
+        return ma_dr_mp3_seek_to_pcm_frame__brute_force(pMP3, frameIndex);
+    }
+}
+MA_API ma_bool32 ma_dr_mp3_get_mp3_and_pcm_frame_count(ma_dr_mp3* pMP3, ma_uint64* pMP3FrameCount, ma_uint64* pPCMFrameCount)
+{
+    ma_uint64 currentPCMFrame;
+    ma_uint64 totalPCMFrameCount;
+    ma_uint64 totalMP3FrameCount;
+    if (pMP3 == NULL) {
+        return MA_FALSE;
+    }
+    if (pMP3->onSeek == NULL) {
+        return MA_FALSE;
+    }
+    currentPCMFrame = pMP3->currentPCMFrame;
+    if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+        return MA_FALSE;
+    }
+    totalPCMFrameCount = 0;
+    totalMP3FrameCount = 0;
+    for (;;) {
+        ma_uint32 pcmFramesInCurrentMP3Frame;
+        pcmFramesInCurrentMP3Frame = ma_dr_mp3_decode_next_frame_ex(pMP3, NULL, NULL, NULL);
+        if (pcmFramesInCurrentMP3Frame == 0) {
+            break;
+        }
+        totalPCMFrameCount += pcmFramesInCurrentMP3Frame;
+        totalMP3FrameCount += 1;
+    }
+    if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_mp3_seek_to_pcm_frame(pMP3, currentPCMFrame)) {
+        return MA_FALSE;
+    }
+    if (pMP3FrameCount != NULL) {
+        *pMP3FrameCount = totalMP3FrameCount;
+    }
+    if (pPCMFrameCount != NULL) {
+        *pPCMFrameCount = totalPCMFrameCount;
+    }
+    return MA_TRUE;
+}
+MA_API ma_uint64 ma_dr_mp3_get_pcm_frame_count(ma_dr_mp3* pMP3)
+{
+    ma_uint64 totalPCMFrameCount;
+    if (pMP3 == NULL) {
+        return 0;
+    }
+    if (pMP3->totalPCMFrameCount != MA_UINT64_MAX) {
+        totalPCMFrameCount = pMP3->totalPCMFrameCount;
+        if (totalPCMFrameCount >= pMP3->delayInPCMFrames) {
+            totalPCMFrameCount -= pMP3->delayInPCMFrames;
+        } else {
+        }
+        if (totalPCMFrameCount >= pMP3->paddingInPCMFrames) {
+            totalPCMFrameCount -= pMP3->paddingInPCMFrames;
+        } else {
+        }
+        return totalPCMFrameCount;
+    } else {
+        if (!ma_dr_mp3_get_mp3_and_pcm_frame_count(pMP3, NULL, &totalPCMFrameCount)) {
+            return 0;
+        }
+        return totalPCMFrameCount;
+    }
+}
+MA_API ma_uint64 ma_dr_mp3_get_mp3_frame_count(ma_dr_mp3* pMP3)
+{
+    ma_uint64 totalMP3FrameCount;
+    if (!ma_dr_mp3_get_mp3_and_pcm_frame_count(pMP3, &totalMP3FrameCount, NULL)) {
+        return 0;
+    }
+    return totalMP3FrameCount;
+}
+static void ma_dr_mp3__accumulate_running_pcm_frame_count(ma_dr_mp3* pMP3, ma_uint32 pcmFrameCountIn, ma_uint64* pRunningPCMFrameCount, float* pRunningPCMFrameCountFractionalPart)
+{
+    float srcRatio;
+    float pcmFrameCountOutF;
+    ma_uint32 pcmFrameCountOut;
+    srcRatio = (float)pMP3->mp3FrameSampleRate / (float)pMP3->sampleRate;
+    MA_DR_MP3_ASSERT(srcRatio > 0);
+    pcmFrameCountOutF = *pRunningPCMFrameCountFractionalPart + (pcmFrameCountIn / srcRatio);
+    pcmFrameCountOut  = (ma_uint32)pcmFrameCountOutF;
+    *pRunningPCMFrameCountFractionalPart = pcmFrameCountOutF - pcmFrameCountOut;
+    *pRunningPCMFrameCount += pcmFrameCountOut;
+}
+typedef struct
+{
+    ma_uint64 bytePos;
+    ma_uint64 pcmFrameIndex;
+} ma_dr_mp3__seeking_mp3_frame_info;
+MA_API ma_bool32 ma_dr_mp3_calculate_seek_points(ma_dr_mp3* pMP3, ma_uint32* pSeekPointCount, ma_dr_mp3_seek_point* pSeekPoints)
+{
+    ma_uint32 seekPointCount;
+    ma_uint64 currentPCMFrame;
+    ma_uint64 totalMP3FrameCount;
+    ma_uint64 totalPCMFrameCount;
+    if (pMP3 == NULL || pSeekPointCount == NULL || pSeekPoints == NULL) {
+        return MA_FALSE;
+    }
+    seekPointCount = *pSeekPointCount;
+    if (seekPointCount == 0) {
+        return MA_FALSE;
+    }
+    currentPCMFrame = pMP3->currentPCMFrame;
+    if (!ma_dr_mp3_get_mp3_and_pcm_frame_count(pMP3, &totalMP3FrameCount, &totalPCMFrameCount)) {
+        return MA_FALSE;
+    }
+    if (totalMP3FrameCount < MA_DR_MP3_SEEK_LEADING_MP3_FRAMES+1) {
+        seekPointCount = 1;
+        pSeekPoints[0].seekPosInBytes     = 0;
+        pSeekPoints[0].pcmFrameIndex      = 0;
+        pSeekPoints[0].mp3FramesToDiscard = 0;
+        pSeekPoints[0].pcmFramesToDiscard = 0;
+    } else {
+        ma_uint64 pcmFramesBetweenSeekPoints;
+        ma_dr_mp3__seeking_mp3_frame_info mp3FrameInfo[MA_DR_MP3_SEEK_LEADING_MP3_FRAMES+1];
+        ma_uint64 runningPCMFrameCount = 0;
+        float runningPCMFrameCountFractionalPart = 0;
+        ma_uint64 nextTargetPCMFrame;
+        ma_uint32 iMP3Frame;
+        ma_uint32 iSeekPoint;
+        if (seekPointCount > totalMP3FrameCount-1) {
+            seekPointCount = (ma_uint32)totalMP3FrameCount-1;
+        }
+        pcmFramesBetweenSeekPoints = totalPCMFrameCount / (seekPointCount+1);
+        if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+            return MA_FALSE;
+        }
+        for (iMP3Frame = 0; iMP3Frame < MA_DR_MP3_SEEK_LEADING_MP3_FRAMES+1; ++iMP3Frame) {
+            ma_uint32 pcmFramesInCurrentMP3FrameIn;
+            MA_DR_MP3_ASSERT(pMP3->streamCursor >= pMP3->dataSize);
+            mp3FrameInfo[iMP3Frame].bytePos       = pMP3->streamCursor - pMP3->dataSize;
+            mp3FrameInfo[iMP3Frame].pcmFrameIndex = runningPCMFrameCount;
+            pcmFramesInCurrentMP3FrameIn = ma_dr_mp3_decode_next_frame_ex(pMP3, NULL, NULL, NULL);
+            if (pcmFramesInCurrentMP3FrameIn == 0) {
+                return MA_FALSE;
+            }
+            ma_dr_mp3__accumulate_running_pcm_frame_count(pMP3, pcmFramesInCurrentMP3FrameIn, &runningPCMFrameCount, &runningPCMFrameCountFractionalPart);
+        }
+        nextTargetPCMFrame = 0;
+        for (iSeekPoint = 0; iSeekPoint < seekPointCount; ++iSeekPoint) {
+            nextTargetPCMFrame += pcmFramesBetweenSeekPoints;
+            for (;;) {
+                if (nextTargetPCMFrame < runningPCMFrameCount) {
+                    pSeekPoints[iSeekPoint].seekPosInBytes     = mp3FrameInfo[0].bytePos;
+                    pSeekPoints[iSeekPoint].pcmFrameIndex      = nextTargetPCMFrame;
+                    pSeekPoints[iSeekPoint].mp3FramesToDiscard = MA_DR_MP3_SEEK_LEADING_MP3_FRAMES;
+                    pSeekPoints[iSeekPoint].pcmFramesToDiscard = (ma_uint16)(nextTargetPCMFrame - mp3FrameInfo[MA_DR_MP3_SEEK_LEADING_MP3_FRAMES-1].pcmFrameIndex);
+                    break;
+                } else {
+                    size_t i;
+                    ma_uint32 pcmFramesInCurrentMP3FrameIn;
+                    for (i = 0; i < MA_DR_MP3_COUNTOF(mp3FrameInfo)-1; ++i) {
+                        mp3FrameInfo[i] = mp3FrameInfo[i+1];
+                    }
+                    mp3FrameInfo[MA_DR_MP3_COUNTOF(mp3FrameInfo)-1].bytePos       = pMP3->streamCursor - pMP3->dataSize;
+                    mp3FrameInfo[MA_DR_MP3_COUNTOF(mp3FrameInfo)-1].pcmFrameIndex = runningPCMFrameCount;
+                    pcmFramesInCurrentMP3FrameIn = ma_dr_mp3_decode_next_frame_ex(pMP3, NULL, NULL, NULL);
+                    if (pcmFramesInCurrentMP3FrameIn == 0) {
+                        pSeekPoints[iSeekPoint].seekPosInBytes     = mp3FrameInfo[0].bytePos;
+                        pSeekPoints[iSeekPoint].pcmFrameIndex      = nextTargetPCMFrame;
+                        pSeekPoints[iSeekPoint].mp3FramesToDiscard = MA_DR_MP3_SEEK_LEADING_MP3_FRAMES;
+                        pSeekPoints[iSeekPoint].pcmFramesToDiscard = (ma_uint16)(nextTargetPCMFrame - mp3FrameInfo[MA_DR_MP3_SEEK_LEADING_MP3_FRAMES-1].pcmFrameIndex);
+                        break;
+                    }
+                    ma_dr_mp3__accumulate_running_pcm_frame_count(pMP3, pcmFramesInCurrentMP3FrameIn, &runningPCMFrameCount, &runningPCMFrameCountFractionalPart);
+                }
+            }
+        }
+        if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_mp3_seek_to_pcm_frame(pMP3, currentPCMFrame)) {
+            return MA_FALSE;
+        }
+    }
+    *pSeekPointCount = seekPointCount;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_bind_seek_table(ma_dr_mp3* pMP3, ma_uint32 seekPointCount, ma_dr_mp3_seek_point* pSeekPoints)
+{
+    if (pMP3 == NULL) {
+        return MA_FALSE;
+    }
+    if (seekPointCount == 0 || pSeekPoints == NULL) {
+        pMP3->seekPointCount = 0;
+        pMP3->pSeekPoints = NULL;
+    } else {
+        pMP3->seekPointCount = seekPointCount;
+        pMP3->pSeekPoints = pSeekPoints;
+    }
+    return MA_TRUE;
+}
+static float* ma_dr_mp3__full_read_and_close_f32(ma_dr_mp3* pMP3, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount)
+{
+    ma_uint64 totalFramesRead = 0;
+    ma_uint64 framesCapacity = 0;
+    float* pFrames = NULL;
+    float temp[4096];
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    for (;;) {
+        ma_uint64 framesToReadRightNow = MA_DR_MP3_COUNTOF(temp) / pMP3->channels;
+        ma_uint64 framesJustRead = ma_dr_mp3_read_pcm_frames_f32(pMP3, framesToReadRightNow, temp);
+        if (framesJustRead == 0) {
+            break;
+        }
+        if (framesCapacity < totalFramesRead + framesJustRead) {
+            ma_uint64 oldFramesBufferSize;
+            ma_uint64 newFramesBufferSize;
+            ma_uint64 newFramesCap;
+            float* pNewFrames;
+            newFramesCap = framesCapacity * 2;
+            if (newFramesCap < totalFramesRead + framesJustRead) {
+                newFramesCap = totalFramesRead + framesJustRead;
+            }
+            oldFramesBufferSize = framesCapacity * pMP3->channels * sizeof(float);
+            newFramesBufferSize = newFramesCap   * pMP3->channels * sizeof(float);
+            if (newFramesBufferSize > (ma_uint64)MA_SIZE_MAX) {
+                break;
+            }
+            pNewFrames = (float*)ma_dr_mp3__realloc_from_callbacks(pFrames, (size_t)newFramesBufferSize, (size_t)oldFramesBufferSize, &pMP3->allocationCallbacks);
+            if (pNewFrames == NULL) {
+                ma_dr_mp3__free_from_callbacks(pFrames, &pMP3->allocationCallbacks);
+                break;
+            }
+            pFrames = pNewFrames;
+            framesCapacity = newFramesCap;
+        }
+        MA_DR_MP3_COPY_MEMORY(pFrames + totalFramesRead*pMP3->channels, temp, (size_t)(framesJustRead*pMP3->channels*sizeof(float)));
+        totalFramesRead += framesJustRead;
+        if (framesJustRead != framesToReadRightNow) {
+            break;
+        }
+    }
+    if (pConfig != NULL) {
+        pConfig->channels   = pMP3->channels;
+        pConfig->sampleRate = pMP3->sampleRate;
+    }
+    ma_dr_mp3_uninit(pMP3);
+    if (pTotalFrameCount) {
+        *pTotalFrameCount = totalFramesRead;
+    }
+    return pFrames;
+}
+static ma_int16* ma_dr_mp3__full_read_and_close_s16(ma_dr_mp3* pMP3, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount)
+{
+    ma_uint64 totalFramesRead = 0;
+    ma_uint64 framesCapacity = 0;
+    ma_int16* pFrames = NULL;
+    ma_int16 temp[4096];
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    for (;;) {
+        ma_uint64 framesToReadRightNow = MA_DR_MP3_COUNTOF(temp) / pMP3->channels;
+        ma_uint64 framesJustRead = ma_dr_mp3_read_pcm_frames_s16(pMP3, framesToReadRightNow, temp);
+        if (framesJustRead == 0) {
+            break;
+        }
+        if (framesCapacity < totalFramesRead + framesJustRead) {
+            ma_uint64 newFramesBufferSize;
+            ma_uint64 oldFramesBufferSize;
+            ma_uint64 newFramesCap;
+            ma_int16* pNewFrames;
+            newFramesCap = framesCapacity * 2;
+            if (newFramesCap < totalFramesRead + framesJustRead) {
+                newFramesCap = totalFramesRead + framesJustRead;
+            }
+            oldFramesBufferSize = framesCapacity * pMP3->channels * sizeof(ma_int16);
+            newFramesBufferSize = newFramesCap   * pMP3->channels * sizeof(ma_int16);
+            if (newFramesBufferSize > (ma_uint64)MA_SIZE_MAX) {
+                break;
+            }
+            pNewFrames = (ma_int16*)ma_dr_mp3__realloc_from_callbacks(pFrames, (size_t)newFramesBufferSize, (size_t)oldFramesBufferSize, &pMP3->allocationCallbacks);
+            if (pNewFrames == NULL) {
+                ma_dr_mp3__free_from_callbacks(pFrames, &pMP3->allocationCallbacks);
+                break;
+            }
+            pFrames = pNewFrames;
+            framesCapacity = newFramesCap;
+        }
+        MA_DR_MP3_COPY_MEMORY(pFrames + totalFramesRead*pMP3->channels, temp, (size_t)(framesJustRead*pMP3->channels*sizeof(ma_int16)));
+        totalFramesRead += framesJustRead;
+        if (framesJustRead != framesToReadRightNow) {
+            break;
+        }
+    }
+    if (pConfig != NULL) {
+        pConfig->channels   = pMP3->channels;
+        pConfig->sampleRate = pMP3->sampleRate;
+    }
+    ma_dr_mp3_uninit(pMP3);
+    if (pTotalFrameCount) {
+        *pTotalFrameCount = totalFramesRead;
+    }
+    return pFrames;
+}
+MA_API float* ma_dr_mp3_open_and_read_pcm_frames_f32(ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, ma_dr_mp3_tell_proc onTell, void* pUserData, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init(&mp3, onRead, onSeek, onTell, NULL, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_f32(&mp3, pConfig, pTotalFrameCount);
+}
+MA_API ma_int16* ma_dr_mp3_open_and_read_pcm_frames_s16(ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, ma_dr_mp3_tell_proc onTell, void* pUserData, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init(&mp3, onRead, onSeek, onTell, NULL, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_s16(&mp3, pConfig, pTotalFrameCount);
+}
+MA_API float* ma_dr_mp3_open_memory_and_read_pcm_frames_f32(const void* pData, size_t dataSize, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init_memory(&mp3, pData, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_f32(&mp3, pConfig, pTotalFrameCount);
+}
+MA_API ma_int16* ma_dr_mp3_open_memory_and_read_pcm_frames_s16(const void* pData, size_t dataSize, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init_memory(&mp3, pData, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_s16(&mp3, pConfig, pTotalFrameCount);
+}
+#ifndef MA_DR_MP3_NO_STDIO
+MA_API float* ma_dr_mp3_open_file_and_read_pcm_frames_f32(const char* filePath, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init_file(&mp3, filePath, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_f32(&mp3, pConfig, pTotalFrameCount);
+}
+MA_API ma_int16* ma_dr_mp3_open_file_and_read_pcm_frames_s16(const char* filePath, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init_file(&mp3, filePath, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_s16(&mp3, pConfig, pTotalFrameCount);
+}
+#endif
+MA_API void* ma_dr_mp3_malloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        return ma_dr_mp3__malloc_from_callbacks(sz, pAllocationCallbacks);
+    } else {
+        return ma_dr_mp3__malloc_default(sz, NULL);
+    }
+}
+MA_API void ma_dr_mp3_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        ma_dr_mp3__free_from_callbacks(p, pAllocationCallbacks);
+    } else {
+        ma_dr_mp3__free_default(p, NULL);
+    }
+}
+#endif
+/* dr_mp3_c end */
+#endif  /* MA_DR_MP3_IMPLEMENTATION */
+#endif  /* MA_NO_MP3 */
+
+
+/* End globally disabled warnings. */
+#if defined(_MSC_VER)
+    #pragma warning(pop)
+#endif
+
+#endif  /* miniaudio_c */
+#endif  /* MINIAUDIO_IMPLEMENTATION */
+
+
+/*
+This software is available as a choice of the following licenses. Choose
+whichever you prefer.
+
+===============================================================================
+ALTERNATIVE 1 - Public Domain (www.unlicense.org)
+===============================================================================
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>
+
+===============================================================================
+ALTERNATIVE 2 - MIT No Attribution
+===============================================================================
+Copyright 2025 David Reid
+
+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.
+
+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/src/Infrastructure/GalNet.Media.Miniaudio/native/stb_vorbis.c b/src/Infrastructure/GalNet.Media.Miniaudio/native/stb_vorbis.c
new file mode 100644
index 00000000..3e5c2504
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/native/stb_vorbis.c
@@ -0,0 +1,5584 @@
+// Ogg Vorbis audio decoder - v1.22 - public domain
+// http://nothings.org/stb_vorbis/
+//
+// Original version written by Sean Barrett in 2007.
+//
+// Originally sponsored by RAD Game Tools. Seeking implementation
+// sponsored by Phillip Bennefall, Marc Andersen, Aaron Baker,
+// Elias Software, Aras Pranckevicius, and Sean Barrett.
+//
+// LICENSE
+//
+//   See end of file for license information.
+//
+// Limitations:
+//
+//   - floor 0 not supported (used in old ogg vorbis files pre-2004)
+//   - lossless sample-truncation at beginning ignored
+//   - cannot concatenate multiple vorbis streams
+//   - sample positions are 32-bit, limiting seekable 192Khz
+//       files to around 6 hours (Ogg supports 64-bit)
+//
+// Feature contributors:
+//    Dougall Johnson (sample-exact seeking)
+//
+// Bugfix/warning contributors:
+//    Terje Mathisen     Niklas Frykholm     Andy Hill
+//    Casey Muratori     John Bolton         Gargaj
+//    Laurent Gomila     Marc LeBlanc        Ronny Chevalier
+//    Bernhard Wodo      Evan Balster        github:alxprd
+//    Tom Beaumont       Ingo Leitgeb        Nicolas Guillemot
+//    Phillip Bennefall  Rohit               Thiago Goulart
+//    github:manxorist   Saga Musix          github:infatum
+//    Timur Gagiev       Maxwell Koo         Peter Waller
+//    github:audinowho   Dougall Johnson     David Reid
+//    github:Clownacy    Pedro J. Estebanez  Remi Verschelde
+//    AnthoFoxo          github:morlat       Gabriel Ravier
+//
+// Partial history:
+//    1.22    - 2021-07-11 - various small fixes
+//    1.21    - 2021-07-02 - fix bug for files with no comments
+//    1.20    - 2020-07-11 - several small fixes
+//    1.19    - 2020-02-05 - warnings
+//    1.18    - 2020-02-02 - fix seek bugs; parse header comments; misc warnings etc.
+//    1.17    - 2019-07-08 - fix CVE-2019-13217..CVE-2019-13223 (by ForAllSecure)
+//    1.16    - 2019-03-04 - fix warnings
+//    1.15    - 2019-02-07 - explicit failure if Ogg Skeleton data is found
+//    1.14    - 2018-02-11 - delete bogus dealloca usage
+//    1.13    - 2018-01-29 - fix truncation of last frame (hopefully)
+//    1.12    - 2017-11-21 - limit residue begin/end to blocksize/2 to avoid large temp allocs in bad/corrupt files
+//    1.11    - 2017-07-23 - fix MinGW compilation
+//    1.10    - 2017-03-03 - more robust seeking; fix negative ilog(); clear error in open_memory
+//    1.09    - 2016-04-04 - back out 'truncation of last frame' fix from previous version
+//    1.08    - 2016-04-02 - warnings; setup memory leaks; truncation of last frame
+//    1.07    - 2015-01-16 - fixes for crashes on invalid files; warning fixes; const
+//    1.06    - 2015-08-31 - full, correct support for seeking API (Dougall Johnson)
+//                           some crash fixes when out of memory or with corrupt files
+//                           fix some inappropriately signed shifts
+//    1.05    - 2015-04-19 - don't define __forceinline if it's redundant
+//    1.04    - 2014-08-27 - fix missing const-correct case in API
+//    1.03    - 2014-08-07 - warning fixes
+//    1.02    - 2014-07-09 - declare qsort comparison as explicitly _cdecl in Windows
+//    1.01    - 2014-06-18 - fix stb_vorbis_get_samples_float (interleaved was correct)
+//    1.0     - 2014-05-26 - fix memory leaks; fix warnings; fix bugs in >2-channel;
+//                           (API change) report sample rate for decode-full-file funcs
+//
+// See end of file for full version history.
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  HEADER BEGINS HERE
+//
+
+#ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H
+#define STB_VORBIS_INCLUDE_STB_VORBIS_H
+
+#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)
+#define STB_VORBIS_NO_STDIO 1
+#endif
+
+#ifndef STB_VORBIS_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////   THREAD SAFETY
+
+// Individual stb_vorbis* handles are not thread-safe; you cannot decode from
+// them from multiple threads at the same time. However, you can have multiple
+// stb_vorbis* handles and decode from them independently in multiple thrads.
+
+
+///////////   MEMORY ALLOCATION
+
+// normally stb_vorbis uses malloc() to allocate memory at startup,
+// and alloca() to allocate temporary memory during a frame on the
+// stack. (Memory consumption will depend on the amount of setup
+// data in the file and how you set the compile flags for speed
+// vs. size. In my test files the maximal-size usage is ~150KB.)
+//
+// You can modify the wrapper functions in the source (setup_malloc,
+// setup_temp_malloc, temp_malloc) to change this behavior, or you
+// can use a simpler allocation model: you pass in a buffer from
+// which stb_vorbis will allocate _all_ its memory (including the
+// temp memory). "open" may fail with a VORBIS_outofmem if you
+// do not pass in enough data; there is no way to determine how
+// much you do need except to succeed (at which point you can
+// query get_info to find the exact amount required. yes I know
+// this is lame).
+//
+// If you pass in a non-NULL buffer of the type below, allocation
+// will occur from it as described above. Otherwise just pass NULL
+// to use malloc()/alloca()
+
+typedef struct
+{
+   char *alloc_buffer;
+   int   alloc_buffer_length_in_bytes;
+} stb_vorbis_alloc;
+
+
+///////////   FUNCTIONS USEABLE WITH ALL INPUT MODES
+
+typedef struct stb_vorbis stb_vorbis;
+
+typedef struct
+{
+   unsigned int sample_rate;
+   int channels;
+
+   unsigned int setup_memory_required;
+   unsigned int setup_temp_memory_required;
+   unsigned int temp_memory_required;
+
+   int max_frame_size;
+} stb_vorbis_info;
+
+typedef struct
+{
+   char *vendor;
+
+   int comment_list_length;
+   char **comment_list;
+} stb_vorbis_comment;
+
+// get general information about the file
+extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f);
+
+// get ogg comments
+extern stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f);
+
+// get the last error detected (clears it, too)
+extern int stb_vorbis_get_error(stb_vorbis *f);
+
+// close an ogg vorbis file and free all memory in use
+extern void stb_vorbis_close(stb_vorbis *f);
+
+// this function returns the offset (in samples) from the beginning of the
+// file that will be returned by the next decode, if it is known, or -1
+// otherwise. after a flush_pushdata() call, this may take a while before
+// it becomes valid again.
+// NOT WORKING YET after a seek with PULLDATA API
+extern int stb_vorbis_get_sample_offset(stb_vorbis *f);
+
+// returns the current seek point within the file, or offset from the beginning
+// of the memory buffer. In pushdata mode it returns 0.
+extern unsigned int stb_vorbis_get_file_offset(stb_vorbis *f);
+
+///////////   PUSHDATA API
+
+#ifndef STB_VORBIS_NO_PUSHDATA_API
+
+// this API allows you to get blocks of data from any source and hand
+// them to stb_vorbis. you have to buffer them; stb_vorbis will tell
+// you how much it used, and you have to give it the rest next time;
+// and stb_vorbis may not have enough data to work with and you will
+// need to give it the same data again PLUS more. Note that the Vorbis
+// specification does not bound the size of an individual frame.
+
+extern stb_vorbis *stb_vorbis_open_pushdata(
+         const unsigned char * datablock, int datablock_length_in_bytes,
+         int *datablock_memory_consumed_in_bytes,
+         int *error,
+         const stb_vorbis_alloc *alloc_buffer);
+// create a vorbis decoder by passing in the initial data block containing
+//    the ogg&vorbis headers (you don't need to do parse them, just provide
+//    the first N bytes of the file--you're told if it's not enough, see below)
+// on success, returns an stb_vorbis *, does not set error, returns the amount of
+//    data parsed/consumed on this call in *datablock_memory_consumed_in_bytes;
+// on failure, returns NULL on error and sets *error, does not change *datablock_memory_consumed
+// if returns NULL and *error is VORBIS_need_more_data, then the input block was
+//       incomplete and you need to pass in a larger block from the start of the file
+
+extern int stb_vorbis_decode_frame_pushdata(
+         stb_vorbis *f,
+         const unsigned char *datablock, int datablock_length_in_bytes,
+         int *channels,             // place to write number of float * buffers
+         float ***output,           // place to write float ** array of float * buffers
+         int *samples               // place to write number of output samples
+     );
+// decode a frame of audio sample data if possible from the passed-in data block
+//
+// return value: number of bytes we used from datablock
+//
+// possible cases:
+//     0 bytes used, 0 samples output (need more data)
+//     N bytes used, 0 samples output (resynching the stream, keep going)
+//     N bytes used, M samples output (one frame of data)
+// note that after opening a file, you will ALWAYS get one N-bytes,0-sample
+// frame, because Vorbis always "discards" the first frame.
+//
+// Note that on resynch, stb_vorbis will rarely consume all of the buffer,
+// instead only datablock_length_in_bytes-3 or less. This is because it wants
+// to avoid missing parts of a page header if they cross a datablock boundary,
+// without writing state-machiney code to record a partial detection.
+//
+// The number of channels returned are stored in *channels (which can be
+// NULL--it is always the same as the number of channels reported by
+// get_info). *output will contain an array of float* buffers, one per
+// channel. In other words, (*output)[0][0] contains the first sample from
+// the first channel, and (*output)[1][0] contains the first sample from
+// the second channel.
+//
+// *output points into stb_vorbis's internal output buffer storage; these
+// buffers are owned by stb_vorbis and application code should not free
+// them or modify their contents. They are transient and will be overwritten
+// once you ask for more data to get decoded, so be sure to grab any data
+// you need before then.
+
+extern void stb_vorbis_flush_pushdata(stb_vorbis *f);
+// inform stb_vorbis that your next datablock will not be contiguous with
+// previous ones (e.g. you've seeked in the data); future attempts to decode
+// frames will cause stb_vorbis to resynchronize (as noted above), and
+// once it sees a valid Ogg page (typically 4-8KB, as large as 64KB), it
+// will begin decoding the _next_ frame.
+//
+// if you want to seek using pushdata, you need to seek in your file, then
+// call stb_vorbis_flush_pushdata(), then start calling decoding, then once
+// decoding is returning you data, call stb_vorbis_get_sample_offset, and
+// if you don't like the result, seek your file again and repeat.
+#endif
+
+
+//////////   PULLING INPUT API
+
+#ifndef STB_VORBIS_NO_PULLDATA_API
+// This API assumes stb_vorbis is allowed to pull data from a source--
+// either a block of memory containing the _entire_ vorbis stream, or a
+// FILE * that you or it create, or possibly some other reading mechanism
+// if you go modify the source to replace the FILE * case with some kind
+// of callback to your code. (But if you don't support seeking, you may
+// just want to go ahead and use pushdata.)
+
+#if !defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION)
+extern int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output);
+#endif
+#if !defined(STB_VORBIS_NO_INTEGER_CONVERSION)
+extern int stb_vorbis_decode_memory(const unsigned char *mem, int len, int *channels, int *sample_rate, short **output);
+#endif
+// decode an entire file and output the data interleaved into a malloc()ed
+// buffer stored in *output. The return value is the number of samples
+// decoded, or -1 if the file could not be opened or was not an ogg vorbis file.
+// When you're done with it, just free() the pointer returned in *output.
+
+extern stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len,
+                                  int *error, const stb_vorbis_alloc *alloc_buffer);
+// create an ogg vorbis decoder from an ogg vorbis stream in memory (note
+// this must be the entire stream!). on failure, returns NULL and sets *error
+
+#ifndef STB_VORBIS_NO_STDIO
+extern stb_vorbis * stb_vorbis_open_filename(const char *filename,
+                                  int *error, const stb_vorbis_alloc *alloc_buffer);
+// create an ogg vorbis decoder from a filename via fopen(). on failure,
+// returns NULL and sets *error (possibly to VORBIS_file_open_failure).
+
+extern stb_vorbis * stb_vorbis_open_file(FILE *f, int close_handle_on_close,
+                                  int *error, const stb_vorbis_alloc *alloc_buffer);
+// create an ogg vorbis decoder from an open FILE *, looking for a stream at
+// the _current_ seek point (ftell). on failure, returns NULL and sets *error.
+// note that stb_vorbis must "own" this stream; if you seek it in between
+// calls to stb_vorbis, it will become confused. Moreover, if you attempt to
+// perform stb_vorbis_seek_*() operations on this file, it will assume it
+// owns the _entire_ rest of the file after the start point. Use the next
+// function, stb_vorbis_open_file_section(), to limit it.
+
+extern stb_vorbis * stb_vorbis_open_file_section(FILE *f, int close_handle_on_close,
+                int *error, const stb_vorbis_alloc *alloc_buffer, unsigned int len);
+// create an ogg vorbis decoder from an open FILE *, looking for a stream at
+// the _current_ seek point (ftell); the stream will be of length 'len' bytes.
+// on failure, returns NULL and sets *error. note that stb_vorbis must "own"
+// this stream; if you seek it in between calls to stb_vorbis, it will become
+// confused.
+#endif
+
+extern int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number);
+extern int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number);
+// these functions seek in the Vorbis file to (approximately) 'sample_number'.
+// after calling seek_frame(), the next call to get_frame_*() will include
+// the specified sample. after calling stb_vorbis_seek(), the next call to
+// stb_vorbis_get_samples_* will start with the specified sample. If you
+// do not need to seek to EXACTLY the target sample when using get_samples_*,
+// you can also use seek_frame().
+
+extern int stb_vorbis_seek_start(stb_vorbis *f);
+// this function is equivalent to stb_vorbis_seek(f,0)
+
+extern unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f);
+extern float        stb_vorbis_stream_length_in_seconds(stb_vorbis *f);
+// these functions return the total length of the vorbis stream
+
+extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output);
+// decode the next frame and return the number of samples. the number of
+// channels returned are stored in *channels (which can be NULL--it is always
+// the same as the number of channels reported by get_info). *output will
+// contain an array of float* buffers, one per channel. These outputs will
+// be overwritten on the next call to stb_vorbis_get_frame_*.
+//
+// You generally should not intermix calls to stb_vorbis_get_frame_*()
+// and stb_vorbis_get_samples_*(), since the latter calls the former.
+
+#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
+extern int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts);
+extern int stb_vorbis_get_frame_short            (stb_vorbis *f, int num_c, short **buffer, int num_samples);
+#endif
+// decode the next frame and return the number of *samples* per channel.
+// Note that for interleaved data, you pass in the number of shorts (the
+// size of your array), but the return value is the number of samples per
+// channel, not the total number of samples.
+//
+// The data is coerced to the number of channels you request according to the
+// channel coercion rules (see below). You must pass in the size of your
+// buffer(s) so that stb_vorbis will not overwrite the end of the buffer.
+// The maximum buffer size needed can be gotten from get_info(); however,
+// the Vorbis I specification implies an absolute maximum of 4096 samples
+// per channel.
+
+// Channel coercion rules:
+//    Let M be the number of channels requested, and N the number of channels present,
+//    and Cn be the nth channel; let stereo L be the sum of all L and center channels,
+//    and stereo R be the sum of all R and center channels (channel assignment from the
+//    vorbis spec).
+//        M    N       output
+//        1    k      sum(Ck) for all k
+//        2    *      stereo L, stereo R
+//        k    l      k > l, the first l channels, then 0s
+//        k    l      k <= l, the first k channels
+//    Note that this is not _good_ surround etc. mixing at all! It's just so
+//    you get something useful.
+
+extern int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats);
+extern int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples);
+// gets num_samples samples, not necessarily on a frame boundary--this requires
+// buffering so you have to supply the buffers. DOES NOT APPLY THE COERCION RULES.
+// Returns the number of samples stored per channel; it may be less than requested
+// at the end of the file. If there are no more samples in the file, returns 0.
+
+#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
+extern int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts);
+extern int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int num_samples);
+#endif
+// gets num_samples samples, not necessarily on a frame boundary--this requires
+// buffering so you have to supply the buffers. Applies the coercion rules above
+// to produce 'channels' channels. Returns the number of samples stored per channel;
+// it may be less than requested at the end of the file. If there are no more
+// samples in the file, returns 0.
+
+#endif
+
+////////   ERROR CODES
+
+enum STBVorbisError
+{
+   VORBIS__no_error,
+
+   VORBIS_need_more_data=1,             // not a real error
+
+   VORBIS_invalid_api_mixing,           // can't mix API modes
+   VORBIS_outofmem,                     // not enough memory
+   VORBIS_feature_not_supported,        // uses floor 0
+   VORBIS_too_many_channels,            // STB_VORBIS_MAX_CHANNELS is too small
+   VORBIS_file_open_failure,            // fopen() failed
+   VORBIS_seek_without_length,          // can't seek in unknown-length file
+
+   VORBIS_unexpected_eof=10,            // file is truncated?
+   VORBIS_seek_invalid,                 // seek past EOF
+
+   // decoding errors (corrupt/invalid stream) -- you probably
+   // don't care about the exact details of these
+
+   // vorbis errors:
+   VORBIS_invalid_setup=20,
+   VORBIS_invalid_stream,
+
+   // ogg errors:
+   VORBIS_missing_capture_pattern=30,
+   VORBIS_invalid_stream_structure_version,
+   VORBIS_continued_packet_flag_invalid,
+   VORBIS_incorrect_stream_serial_number,
+   VORBIS_invalid_first_page,
+   VORBIS_bad_packet_type,
+   VORBIS_cant_find_last_page,
+   VORBIS_seek_failed,
+   VORBIS_ogg_skeleton_not_supported
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // STB_VORBIS_INCLUDE_STB_VORBIS_H
+//
+//  HEADER ENDS HERE
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef STB_VORBIS_HEADER_ONLY
+
+// global configuration settings (e.g. set these in the project/makefile),
+// or just set them in this file at the top (although ideally the first few
+// should be visible when the header file is compiled too, although it's not
+// crucial)
+
+// STB_VORBIS_NO_PUSHDATA_API
+//     does not compile the code for the various stb_vorbis_*_pushdata()
+//     functions
+// #define STB_VORBIS_NO_PUSHDATA_API
+
+// STB_VORBIS_NO_PULLDATA_API
+//     does not compile the code for the non-pushdata APIs
+// #define STB_VORBIS_NO_PULLDATA_API
+
+// STB_VORBIS_NO_STDIO
+//     does not compile the code for the APIs that use FILE *s internally
+//     or externally (implied by STB_VORBIS_NO_PULLDATA_API)
+// #define STB_VORBIS_NO_STDIO
+
+// STB_VORBIS_NO_INTEGER_CONVERSION
+//     does not compile the code for converting audio sample data from
+//     float to integer (implied by STB_VORBIS_NO_PULLDATA_API)
+// #define STB_VORBIS_NO_INTEGER_CONVERSION
+
+// STB_VORBIS_NO_FAST_SCALED_FLOAT
+//      does not use a fast float-to-int trick to accelerate float-to-int on
+//      most platforms which requires endianness be defined correctly.
+//#define STB_VORBIS_NO_FAST_SCALED_FLOAT
+
+
+// STB_VORBIS_MAX_CHANNELS [number]
+//     globally define this to the maximum number of channels you need.
+//     The spec does not put a restriction on channels except that
+//     the count is stored in a byte, so 255 is the hard limit.
+//     Reducing this saves about 16 bytes per value, so using 16 saves
+//     (255-16)*16 or around 4KB. Plus anything other memory usage
+//     I forgot to account for. Can probably go as low as 8 (7.1 audio),
+//     6 (5.1 audio), or 2 (stereo only).
+#ifndef STB_VORBIS_MAX_CHANNELS
+#define STB_VORBIS_MAX_CHANNELS    16  // enough for anyone?
+#endif
+
+// STB_VORBIS_PUSHDATA_CRC_COUNT [number]
+//     after a flush_pushdata(), stb_vorbis begins scanning for the
+//     next valid page, without backtracking. when it finds something
+//     that looks like a page, it streams through it and verifies its
+//     CRC32. Should that validation fail, it keeps scanning. But it's
+//     possible that _while_ streaming through to check the CRC32 of
+//     one candidate page, it sees another candidate page. This #define
+//     determines how many "overlapping" candidate pages it can search
+//     at once. Note that "real" pages are typically ~4KB to ~8KB, whereas
+//     garbage pages could be as big as 64KB, but probably average ~16KB.
+//     So don't hose ourselves by scanning an apparent 64KB page and
+//     missing a ton of real ones in the interim; so minimum of 2
+#ifndef STB_VORBIS_PUSHDATA_CRC_COUNT
+#define STB_VORBIS_PUSHDATA_CRC_COUNT  4
+#endif
+
+// STB_VORBIS_FAST_HUFFMAN_LENGTH [number]
+//     sets the log size of the huffman-acceleration table.  Maximum
+//     supported value is 24. with larger numbers, more decodings are O(1),
+//     but the table size is larger so worse cache missing, so you'll have
+//     to probe (and try multiple ogg vorbis files) to find the sweet spot.
+#ifndef STB_VORBIS_FAST_HUFFMAN_LENGTH
+#define STB_VORBIS_FAST_HUFFMAN_LENGTH   10
+#endif
+
+// STB_VORBIS_FAST_BINARY_LENGTH [number]
+//     sets the log size of the binary-search acceleration table. this
+//     is used in similar fashion to the fast-huffman size to set initial
+//     parameters for the binary search
+
+// STB_VORBIS_FAST_HUFFMAN_INT
+//     The fast huffman tables are much more efficient if they can be
+//     stored as 16-bit results instead of 32-bit results. This restricts
+//     the codebooks to having only 65535 possible outcomes, though.
+//     (At least, accelerated by the huffman table.)
+#ifndef STB_VORBIS_FAST_HUFFMAN_INT
+#define STB_VORBIS_FAST_HUFFMAN_SHORT
+#endif
+
+// STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH
+//     If the 'fast huffman' search doesn't succeed, then stb_vorbis falls
+//     back on binary searching for the correct one. This requires storing
+//     extra tables with the huffman codes in sorted order. Defining this
+//     symbol trades off space for speed by forcing a linear search in the
+//     non-fast case, except for "sparse" codebooks.
+// #define STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH
+
+// STB_VORBIS_DIVIDES_IN_RESIDUE
+//     stb_vorbis precomputes the result of the scalar residue decoding
+//     that would otherwise require a divide per chunk. you can trade off
+//     space for time by defining this symbol.
+// #define STB_VORBIS_DIVIDES_IN_RESIDUE
+
+// STB_VORBIS_DIVIDES_IN_CODEBOOK
+//     vorbis VQ codebooks can be encoded two ways: with every case explicitly
+//     stored, or with all elements being chosen from a small range of values,
+//     and all values possible in all elements. By default, stb_vorbis expands
+//     this latter kind out to look like the former kind for ease of decoding,
+//     because otherwise an integer divide-per-vector-element is required to
+//     unpack the index. If you define STB_VORBIS_DIVIDES_IN_CODEBOOK, you can
+//     trade off storage for speed.
+//#define STB_VORBIS_DIVIDES_IN_CODEBOOK
+
+#ifdef STB_VORBIS_CODEBOOK_SHORTS
+#error "STB_VORBIS_CODEBOOK_SHORTS is no longer supported as it produced incorrect results for some input formats"
+#endif
+
+// STB_VORBIS_DIVIDE_TABLE
+//     this replaces small integer divides in the floor decode loop with
+//     table lookups. made less than 1% difference, so disabled by default.
+
+// STB_VORBIS_NO_INLINE_DECODE
+//     disables the inlining of the scalar codebook fast-huffman decode.
+//     might save a little codespace; useful for debugging
+// #define STB_VORBIS_NO_INLINE_DECODE
+
+// STB_VORBIS_NO_DEFER_FLOOR
+//     Normally we only decode the floor without synthesizing the actual
+//     full curve. We can instead synthesize the curve immediately. This
+//     requires more memory and is very likely slower, so I don't think
+//     you'd ever want to do it except for debugging.
+// #define STB_VORBIS_NO_DEFER_FLOOR
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef STB_VORBIS_NO_PULLDATA_API
+   #define STB_VORBIS_NO_INTEGER_CONVERSION
+   #define STB_VORBIS_NO_STDIO
+#endif
+
+#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)
+   #define STB_VORBIS_NO_STDIO 1
+#endif
+
+#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
+#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT
+
+   // only need endianness for fast-float-to-int, which we don't
+   // use for pushdata
+
+   #ifndef STB_VORBIS_BIG_ENDIAN
+     #define STB_VORBIS_ENDIAN  0
+   #else
+     #define STB_VORBIS_ENDIAN  1
+   #endif
+
+#endif
+#endif
+
+
+#ifndef STB_VORBIS_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STB_VORBIS_NO_CRT
+   #include <stdlib.h>
+   #include <string.h>
+   #include <assert.h>
+   #include <math.h>
+
+   // find definition of alloca if it's not in stdlib.h:
+   #if defined(_MSC_VER) || defined(__MINGW32__)
+      #include <malloc.h>
+   #endif
+   #if defined(__linux__) || defined(__linux) || defined(__sun__) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__)
+      #include <alloca.h>
+   #endif
+#else // STB_VORBIS_NO_CRT
+   #define NULL 0
+   #define malloc(s)   0
+   #define free(s)     ((void) 0)
+   #define realloc(s)  0
+#endif // STB_VORBIS_NO_CRT
+
+#include <limits.h>
+
+#ifdef __MINGW32__
+   // eff you mingw:
+   //     "fixed":
+   //         http://sourceforge.net/p/mingw-w64/mailman/message/32882927/
+   //     "no that broke the build, reverted, who cares about C":
+   //         http://sourceforge.net/p/mingw-w64/mailman/message/32890381/
+   #ifdef __forceinline
+   #undef __forceinline
+   #endif
+   #define __forceinline
+   #ifndef alloca
+   #define alloca __builtin_alloca
+   #endif
+#elif !defined(_MSC_VER)
+   #if __GNUC__
+      #define __forceinline inline
+   #else
+      #define __forceinline
+   #endif
+#endif
+
+#if STB_VORBIS_MAX_CHANNELS > 256
+#error "Value of STB_VORBIS_MAX_CHANNELS outside of allowed range"
+#endif
+
+#if STB_VORBIS_FAST_HUFFMAN_LENGTH > 24
+#error "Value of STB_VORBIS_FAST_HUFFMAN_LENGTH outside of allowed range"
+#endif
+
+
+#if 0
+#include <crtdbg.h>
+#define CHECK(f)   _CrtIsValidHeapPointer(f->channel_buffers[1])
+#else
+#define CHECK(f)   ((void) 0)
+#endif
+
+#define MAX_BLOCKSIZE_LOG  13   // from specification
+#define MAX_BLOCKSIZE      (1 << MAX_BLOCKSIZE_LOG)
+
+
+typedef unsigned char  uint8;
+typedef   signed char   int8;
+typedef unsigned short uint16;
+typedef   signed short  int16;
+typedef unsigned int   uint32;
+typedef   signed int    int32;
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
+typedef float codetype;
+
+#ifdef _MSC_VER
+#define STBV_NOTUSED(v)  (void)(v)
+#else
+#define STBV_NOTUSED(v)  (void)sizeof(v)
+#endif
+
+// @NOTE
+//
+// Some arrays below are tagged "//varies", which means it's actually
+// a variable-sized piece of data, but rather than malloc I assume it's
+// small enough it's better to just allocate it all together with the
+// main thing
+//
+// Most of the variables are specified with the smallest size I could pack
+// them into. It might give better performance to make them all full-sized
+// integers. It should be safe to freely rearrange the structures or change
+// the sizes larger--nothing relies on silently truncating etc., nor the
+// order of variables.
+
+#define FAST_HUFFMAN_TABLE_SIZE   (1 << STB_VORBIS_FAST_HUFFMAN_LENGTH)
+#define FAST_HUFFMAN_TABLE_MASK   (FAST_HUFFMAN_TABLE_SIZE - 1)
+
+typedef struct
+{
+   int dimensions, entries;
+   uint8 *codeword_lengths;
+   float  minimum_value;
+   float  delta_value;
+   uint8  value_bits;
+   uint8  lookup_type;
+   uint8  sequence_p;
+   uint8  sparse;
+   uint32 lookup_values;
+   codetype *multiplicands;
+   uint32 *codewords;
+   #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT
+    int16  fast_huffman[FAST_HUFFMAN_TABLE_SIZE];
+   #else
+    int32  fast_huffman[FAST_HUFFMAN_TABLE_SIZE];
+   #endif
+   uint32 *sorted_codewords;
+   int    *sorted_values;
+   int     sorted_entries;
+} Codebook;
+
+typedef struct
+{
+   uint8 order;
+   uint16 rate;
+   uint16 bark_map_size;
+   uint8 amplitude_bits;
+   uint8 amplitude_offset;
+   uint8 number_of_books;
+   uint8 book_list[16]; // varies
+} Floor0;
+
+typedef struct
+{
+   uint8 partitions;
+   uint8 partition_class_list[32]; // varies
+   uint8 class_dimensions[16]; // varies
+   uint8 class_subclasses[16]; // varies
+   uint8 class_masterbooks[16]; // varies
+   int16 subclass_books[16][8]; // varies
+   uint16 Xlist[31*8+2]; // varies
+   uint8 sorted_order[31*8+2];
+   uint8 neighbors[31*8+2][2];
+   uint8 floor1_multiplier;
+   uint8 rangebits;
+   int values;
+} Floor1;
+
+typedef union
+{
+   Floor0 floor0;
+   Floor1 floor1;
+} Floor;
+
+typedef struct
+{
+   uint32 begin, end;
+   uint32 part_size;
+   uint8 classifications;
+   uint8 classbook;
+   uint8 **classdata;
+   int16 (*residue_books)[8];
+} Residue;
+
+typedef struct
+{
+   uint8 magnitude;
+   uint8 angle;
+   uint8 mux;
+} MappingChannel;
+
+typedef struct
+{
+   uint16 coupling_steps;
+   MappingChannel *chan;
+   uint8  submaps;
+   uint8  submap_floor[15]; // varies
+   uint8  submap_residue[15]; // varies
+} Mapping;
+
+typedef struct
+{
+   uint8 blockflag;
+   uint8 mapping;
+   uint16 windowtype;
+   uint16 transformtype;
+} Mode;
+
+typedef struct
+{
+   uint32  goal_crc;    // expected crc if match
+   int     bytes_left;  // bytes left in packet
+   uint32  crc_so_far;  // running crc
+   int     bytes_done;  // bytes processed in _current_ chunk
+   uint32  sample_loc;  // granule pos encoded in page
+} CRCscan;
+
+typedef struct
+{
+   uint32 page_start, page_end;
+   uint32 last_decoded_sample;
+} ProbedPage;
+
+struct stb_vorbis
+{
+  // user-accessible info
+   unsigned int sample_rate;
+   int channels;
+
+   unsigned int setup_memory_required;
+   unsigned int temp_memory_required;
+   unsigned int setup_temp_memory_required;
+
+   char *vendor;
+   int comment_list_length;
+   char **comment_list;
+
+  // input config
+#ifndef STB_VORBIS_NO_STDIO
+   FILE *f;
+   uint32 f_start;
+   int close_on_free;
+#endif
+
+   uint8 *stream;
+   uint8 *stream_start;
+   uint8 *stream_end;
+
+   uint32 stream_len;
+
+   uint8  push_mode;
+
+   // the page to seek to when seeking to start, may be zero
+   uint32 first_audio_page_offset;
+
+   // p_first is the page on which the first audio packet ends
+   // (but not necessarily the page on which it starts)
+   ProbedPage p_first, p_last;
+
+  // memory management
+   stb_vorbis_alloc alloc;
+   int setup_offset;
+   int temp_offset;
+
+  // run-time results
+   int eof;
+   enum STBVorbisError error;
+
+  // user-useful data
+
+  // header info
+   int blocksize[2];
+   int blocksize_0, blocksize_1;
+   int codebook_count;
+   Codebook *codebooks;
+   int floor_count;
+   uint16 floor_types[64]; // varies
+   Floor *floor_config;
+   int residue_count;
+   uint16 residue_types[64]; // varies
+   Residue *residue_config;
+   int mapping_count;
+   Mapping *mapping;
+   int mode_count;
+   Mode mode_config[64];  // varies
+
+   uint32 total_samples;
+
+  // decode buffer
+   float *channel_buffers[STB_VORBIS_MAX_CHANNELS];
+   float *outputs        [STB_VORBIS_MAX_CHANNELS];
+
+   float *previous_window[STB_VORBIS_MAX_CHANNELS];
+   int previous_length;
+
+   #ifndef STB_VORBIS_NO_DEFER_FLOOR
+   int16 *finalY[STB_VORBIS_MAX_CHANNELS];
+   #else
+   float *floor_buffers[STB_VORBIS_MAX_CHANNELS];
+   #endif
+
+   uint32 current_loc; // sample location of next frame to decode
+   int    current_loc_valid;
+
+  // per-blocksize precomputed data
+
+   // twiddle factors
+   float *A[2],*B[2],*C[2];
+   float *window[2];
+   uint16 *bit_reverse[2];
+
+  // current page/packet/segment streaming info
+   uint32 serial; // stream serial number for verification
+   int last_page;
+   int segment_count;
+   uint8 segments[255];
+   uint8 page_flag;
+   uint8 bytes_in_seg;
+   uint8 first_decode;
+   int next_seg;
+   int last_seg;  // flag that we're on the last segment
+   int last_seg_which; // what was the segment number of the last seg?
+   uint32 acc;
+   int valid_bits;
+   int packet_bytes;
+   int end_seg_with_known_loc;
+   uint32 known_loc_for_packet;
+   int discard_samples_deferred;
+   uint32 samples_output;
+
+  // push mode scanning
+   int page_crc_tests; // only in push_mode: number of tests active; -1 if not searching
+#ifndef STB_VORBIS_NO_PUSHDATA_API
+   CRCscan scan[STB_VORBIS_PUSHDATA_CRC_COUNT];
+#endif
+
+  // sample-access
+   int channel_buffer_start;
+   int channel_buffer_end;
+};
+
+#if defined(STB_VORBIS_NO_PUSHDATA_API)
+   #define IS_PUSH_MODE(f)   FALSE
+#elif defined(STB_VORBIS_NO_PULLDATA_API)
+   #define IS_PUSH_MODE(f)   TRUE
+#else
+   #define IS_PUSH_MODE(f)   ((f)->push_mode)
+#endif
+
+typedef struct stb_vorbis vorb;
+
+static int error(vorb *f, enum STBVorbisError e)
+{
+   f->error = e;
+   if (!f->eof && e != VORBIS_need_more_data) {
+      f->error=e; // breakpoint for debugging
+   }
+   return 0;
+}
+
+
+// these functions are used for allocating temporary memory
+// while decoding. if you can afford the stack space, use
+// alloca(); otherwise, provide a temp buffer and it will
+// allocate out of those.
+
+#define array_size_required(count,size)  (count*(sizeof(void *)+(size)))
+
+#define temp_alloc(f,size)              (f->alloc.alloc_buffer ? setup_temp_malloc(f,size) : alloca(size))
+#define temp_free(f,p)                  (void)0
+#define temp_alloc_save(f)              ((f)->temp_offset)
+#define temp_alloc_restore(f,p)         ((f)->temp_offset = (p))
+
+#define temp_block_array(f,count,size)  make_block_array(temp_alloc(f,array_size_required(count,size)), count, size)
+
+// given a sufficiently large block of memory, make an array of pointers to subblocks of it
+static void *make_block_array(void *mem, int count, int size)
+{
+   int i;
+   void ** p = (void **) mem;
+   char *q = (char *) (p + count);
+   for (i=0; i < count; ++i) {
+      p[i] = q;
+      q += size;
+   }
+   return p;
+}
+
+static void *setup_malloc(vorb *f, int sz)
+{
+   sz = (sz+7) & ~7; // round up to nearest 8 for alignment of future allocs.
+   f->setup_memory_required += sz;
+   if (f->alloc.alloc_buffer) {
+      void *p = (char *) f->alloc.alloc_buffer + f->setup_offset;
+      if (f->setup_offset + sz > f->temp_offset) return NULL;
+      f->setup_offset += sz;
+      return p;
+   }
+   return sz ? malloc(sz) : NULL;
+}
+
+static void setup_free(vorb *f, void *p)
+{
+   if (f->alloc.alloc_buffer) return; // do nothing; setup mem is a stack
+   free(p);
+}
+
+static void *setup_temp_malloc(vorb *f, int sz)
+{
+   sz = (sz+7) & ~7; // round up to nearest 8 for alignment of future allocs.
+   if (f->alloc.alloc_buffer) {
+      if (f->temp_offset - sz < f->setup_offset) return NULL;
+      f->temp_offset -= sz;
+      return (char *) f->alloc.alloc_buffer + f->temp_offset;
+   }
+   return malloc(sz);
+}
+
+static void setup_temp_free(vorb *f, void *p, int sz)
+{
+   if (f->alloc.alloc_buffer) {
+      f->temp_offset += (sz+7)&~7;
+      return;
+   }
+   free(p);
+}
+
+#define CRC32_POLY    0x04c11db7   // from spec
+
+static uint32 crc_table[256];
+static void crc32_init(void)
+{
+   int i,j;
+   uint32 s;
+   for(i=0; i < 256; i++) {
+      for (s=(uint32) i << 24, j=0; j < 8; ++j)
+         s = (s << 1) ^ (s >= (1U<<31) ? CRC32_POLY : 0);
+      crc_table[i] = s;
+   }
+}
+
+static __forceinline uint32 crc32_update(uint32 crc, uint8 byte)
+{
+   return (crc << 8) ^ crc_table[byte ^ (crc >> 24)];
+}
+
+
+// used in setup, and for huffman that doesn't go fast path
+static unsigned int bit_reverse(unsigned int n)
+{
+  n = ((n & 0xAAAAAAAA) >>  1) | ((n & 0x55555555) << 1);
+  n = ((n & 0xCCCCCCCC) >>  2) | ((n & 0x33333333) << 2);
+  n = ((n & 0xF0F0F0F0) >>  4) | ((n & 0x0F0F0F0F) << 4);
+  n = ((n & 0xFF00FF00) >>  8) | ((n & 0x00FF00FF) << 8);
+  return (n >> 16) | (n << 16);
+}
+
+static float square(float x)
+{
+   return x*x;
+}
+
+// this is a weird definition of log2() for which log2(1) = 1, log2(2) = 2, log2(4) = 3
+// as required by the specification. fast(?) implementation from stb.h
+// @OPTIMIZE: called multiple times per-packet with "constants"; move to setup
+static int ilog(int32 n)
+{
+   static signed char log2_4[16] = { 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4 };
+
+   if (n < 0) return 0; // signed n returns 0
+
+   // 2 compares if n < 16, 3 compares otherwise (4 if signed or n > 1<<29)
+   if (n < (1 << 14))
+        if (n < (1 <<  4))            return  0 + log2_4[n      ];
+        else if (n < (1 <<  9))       return  5 + log2_4[n >>  5];
+             else                     return 10 + log2_4[n >> 10];
+   else if (n < (1 << 24))
+             if (n < (1 << 19))       return 15 + log2_4[n >> 15];
+             else                     return 20 + log2_4[n >> 20];
+        else if (n < (1 << 29))       return 25 + log2_4[n >> 25];
+             else                     return 30 + log2_4[n >> 30];
+}
+
+#ifndef M_PI
+  #define M_PI  3.14159265358979323846264f  // from CRC
+#endif
+
+// code length assigned to a value with no huffman encoding
+#define NO_CODE   255
+
+/////////////////////// LEAF SETUP FUNCTIONS //////////////////////////
+//
+// these functions are only called at setup, and only a few times
+// per file
+
+static float float32_unpack(uint32 x)
+{
+   // from the specification
+   uint32 mantissa = x & 0x1fffff;
+   uint32 sign = x & 0x80000000;
+   uint32 exp = (x & 0x7fe00000) >> 21;
+   double res = sign ? -(double)mantissa : (double)mantissa;
+   return (float) ldexp((float)res, (int)exp-788);
+}
+
+
+// zlib & jpeg huffman tables assume that the output symbols
+// can either be arbitrarily arranged, or have monotonically
+// increasing frequencies--they rely on the lengths being sorted;
+// this makes for a very simple generation algorithm.
+// vorbis allows a huffman table with non-sorted lengths. This
+// requires a more sophisticated construction, since symbols in
+// order do not map to huffman codes "in order".
+static void add_entry(Codebook *c, uint32 huff_code, int symbol, int count, int len, uint32 *values)
+{
+   if (!c->sparse) {
+      c->codewords      [symbol] = huff_code;
+   } else {
+      c->codewords       [count] = huff_code;
+      c->codeword_lengths[count] = len;
+      values             [count] = symbol;
+   }
+}
+
+static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)
+{
+   int i,k,m=0;
+   uint32 available[32];
+
+   memset(available, 0, sizeof(available));
+   // find the first entry
+   for (k=0; k < n; ++k) if (len[k] < NO_CODE) break;
+   if (k == n) { assert(c->sorted_entries == 0); return TRUE; }
+   assert(len[k] < 32); // no error return required, code reading lens checks this
+   // add to the list
+   add_entry(c, 0, k, m++, len[k], values);
+   // add all available leaves
+   for (i=1; i <= len[k]; ++i)
+      available[i] = 1U << (32-i);
+   // note that the above code treats the first case specially,
+   // but it's really the same as the following code, so they
+   // could probably be combined (except the initial code is 0,
+   // and I use 0 in available[] to mean 'empty')
+   for (i=k+1; i < n; ++i) {
+      uint32 res;
+      int z = len[i], y;
+      if (z == NO_CODE) continue;
+      assert(z < 32); // no error return required, code reading lens checks this
+      // find lowest available leaf (should always be earliest,
+      // which is what the specification calls for)
+      // note that this property, and the fact we can never have
+      // more than one free leaf at a given level, isn't totally
+      // trivial to prove, but it seems true and the assert never
+      // fires, so!
+      while (z > 0 && !available[z]) --z;
+      if (z == 0) { return FALSE; }
+      res = available[z];
+      available[z] = 0;
+      add_entry(c, bit_reverse(res), i, m++, len[i], values);
+      // propagate availability up the tree
+      if (z != len[i]) {
+         for (y=len[i]; y > z; --y) {
+            assert(available[y] == 0);
+            available[y] = res + (1 << (32-y));
+         }
+      }
+   }
+   return TRUE;
+}
+
+// accelerated huffman table allows fast O(1) match of all symbols
+// of length <= STB_VORBIS_FAST_HUFFMAN_LENGTH
+static void compute_accelerated_huffman(Codebook *c)
+{
+   int i, len;
+   for (i=0; i < FAST_HUFFMAN_TABLE_SIZE; ++i)
+      c->fast_huffman[i] = -1;
+
+   len = c->sparse ? c->sorted_entries : c->entries;
+   #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT
+   if (len > 32767) len = 32767; // largest possible value we can encode!
+   #endif
+   for (i=0; i < len; ++i) {
+      if (c->codeword_lengths[i] <= STB_VORBIS_FAST_HUFFMAN_LENGTH) {
+         uint32 z = c->sparse ? bit_reverse(c->sorted_codewords[i]) : c->codewords[i];
+         // set table entries for all bit combinations in the higher bits
+         while (z < FAST_HUFFMAN_TABLE_SIZE) {
+             c->fast_huffman[z] = i;
+             z += 1 << c->codeword_lengths[i];
+         }
+      }
+   }
+}
+
+#ifdef _MSC_VER
+#define STBV_CDECL __cdecl
+#else
+#define STBV_CDECL
+#endif
+
+static int STBV_CDECL uint32_compare(const void *p, const void *q)
+{
+   uint32 x = * (uint32 *) p;
+   uint32 y = * (uint32 *) q;
+   return x < y ? -1 : x > y;
+}
+
+static int include_in_sort(Codebook *c, uint8 len)
+{
+   if (c->sparse) { assert(len != NO_CODE); return TRUE; }
+   if (len == NO_CODE) return FALSE;
+   if (len > STB_VORBIS_FAST_HUFFMAN_LENGTH) return TRUE;
+   return FALSE;
+}
+
+// if the fast table above doesn't work, we want to binary
+// search them... need to reverse the bits
+static void compute_sorted_huffman(Codebook *c, uint8 *lengths, uint32 *values)
+{
+   int i, len;
+   // build a list of all the entries
+   // OPTIMIZATION: don't include the short ones, since they'll be caught by FAST_HUFFMAN.
+   // this is kind of a frivolous optimization--I don't see any performance improvement,
+   // but it's like 4 extra lines of code, so.
+   if (!c->sparse) {
+      int k = 0;
+      for (i=0; i < c->entries; ++i)
+         if (include_in_sort(c, lengths[i]))
+            c->sorted_codewords[k++] = bit_reverse(c->codewords[i]);
+      assert(k == c->sorted_entries);
+   } else {
+      for (i=0; i < c->sorted_entries; ++i)
+         c->sorted_codewords[i] = bit_reverse(c->codewords[i]);
+   }
+
+   qsort(c->sorted_codewords, c->sorted_entries, sizeof(c->sorted_codewords[0]), uint32_compare);
+   c->sorted_codewords[c->sorted_entries] = 0xffffffff;
+
+   len = c->sparse ? c->sorted_entries : c->entries;
+   // now we need to indicate how they correspond; we could either
+   //   #1: sort a different data structure that says who they correspond to
+   //   #2: for each sorted entry, search the original list to find who corresponds
+   //   #3: for each original entry, find the sorted entry
+   // #1 requires extra storage, #2 is slow, #3 can use binary search!
+   for (i=0; i < len; ++i) {
+      int huff_len = c->sparse ? lengths[values[i]] : lengths[i];
+      if (include_in_sort(c,huff_len)) {
+         uint32 code = bit_reverse(c->codewords[i]);
+         int x=0, n=c->sorted_entries;
+         while (n > 1) {
+            // invariant: sc[x] <= code < sc[x+n]
+            int m = x + (n >> 1);
+            if (c->sorted_codewords[m] <= code) {
+               x = m;
+               n -= (n>>1);
+            } else {
+               n >>= 1;
+            }
+         }
+         assert(c->sorted_codewords[x] == code);
+         if (c->sparse) {
+            c->sorted_values[x] = values[i];
+            c->codeword_lengths[x] = huff_len;
+         } else {
+            c->sorted_values[x] = i;
+         }
+      }
+   }
+}
+
+// only run while parsing the header (3 times)
+static int vorbis_validate(uint8 *data)
+{
+   static uint8 vorbis[6] = { 'v', 'o', 'r', 'b', 'i', 's' };
+   return memcmp(data, vorbis, 6) == 0;
+}
+
+// called from setup only, once per code book
+// (formula implied by specification)
+static int lookup1_values(int entries, int dim)
+{
+   int r = (int) floor(exp((float) log((float) entries) / dim));
+   if ((int) floor(pow((float) r+1, dim)) <= entries)   // (int) cast for MinGW warning;
+      ++r;                                              // floor() to avoid _ftol() when non-CRT
+   if (pow((float) r+1, dim) <= entries)
+      return -1;
+   if ((int) floor(pow((float) r, dim)) > entries)
+      return -1;
+   return r;
+}
+
+// called twice per file
+static void compute_twiddle_factors(int n, float *A, float *B, float *C)
+{
+   int n4 = n >> 2, n8 = n >> 3;
+   int k,k2;
+
+   for (k=k2=0; k < n4; ++k,k2+=2) {
+      A[k2  ] = (float)  cos(4*k*M_PI/n);
+      A[k2+1] = (float) -sin(4*k*M_PI/n);
+      B[k2  ] = (float)  cos((k2+1)*M_PI/n/2) * 0.5f;
+      B[k2+1] = (float)  sin((k2+1)*M_PI/n/2) * 0.5f;
+   }
+   for (k=k2=0; k < n8; ++k,k2+=2) {
+      C[k2  ] = (float)  cos(2*(k2+1)*M_PI/n);
+      C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n);
+   }
+}
+
+static void compute_window(int n, float *window)
+{
+   int n2 = n >> 1, i;
+   for (i=0; i < n2; ++i)
+      window[i] = (float) sin(0.5 * M_PI * square((float) sin((i - 0 + 0.5) / n2 * 0.5 * M_PI)));
+}
+
+static void compute_bitreverse(int n, uint16 *rev)
+{
+   int ld = ilog(n) - 1; // ilog is off-by-one from normal definitions
+   int i, n8 = n >> 3;
+   for (i=0; i < n8; ++i)
+      rev[i] = (bit_reverse(i) >> (32-ld+3)) << 2;
+}
+
+static int init_blocksize(vorb *f, int b, int n)
+{
+   int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3;
+   f->A[b] = (float *) setup_malloc(f, sizeof(float) * n2);
+   f->B[b] = (float *) setup_malloc(f, sizeof(float) * n2);
+   f->C[b] = (float *) setup_malloc(f, sizeof(float) * n4);
+   if (!f->A[b] || !f->B[b] || !f->C[b]) return error(f, VORBIS_outofmem);
+   compute_twiddle_factors(n, f->A[b], f->B[b], f->C[b]);
+   f->window[b] = (float *) setup_malloc(f, sizeof(float) * n2);
+   if (!f->window[b]) return error(f, VORBIS_outofmem);
+   compute_window(n, f->window[b]);
+   f->bit_reverse[b] = (uint16 *) setup_malloc(f, sizeof(uint16) * n8);
+   if (!f->bit_reverse[b]) return error(f, VORBIS_outofmem);
+   compute_bitreverse(n, f->bit_reverse[b]);
+   return TRUE;
+}
+
+static void neighbors(uint16 *x, int n, int *plow, int *phigh)
+{
+   int low = -1;
+   int high = 65536;
+   int i;
+   for (i=0; i < n; ++i) {
+      if (x[i] > low  && x[i] < x[n]) { *plow  = i; low = x[i]; }
+      if (x[i] < high && x[i] > x[n]) { *phigh = i; high = x[i]; }
+   }
+}
+
+// this has been repurposed so y is now the original index instead of y
+typedef struct
+{
+   uint16 x,id;
+} stbv__floor_ordering;
+
+static int STBV_CDECL point_compare(const void *p, const void *q)
+{
+   stbv__floor_ordering *a = (stbv__floor_ordering *) p;
+   stbv__floor_ordering *b = (stbv__floor_ordering *) q;
+   return a->x < b->x ? -1 : a->x > b->x;
+}
+
+//
+/////////////////////// END LEAF SETUP FUNCTIONS //////////////////////////
+
+
+#if defined(STB_VORBIS_NO_STDIO)
+   #define USE_MEMORY(z)    TRUE
+#else
+   #define USE_MEMORY(z)    ((z)->stream)
+#endif
+
+static uint8 get8(vorb *z)
+{
+   if (USE_MEMORY(z)) {
+      if (z->stream >= z->stream_end) { z->eof = TRUE; return 0; }
+      return *z->stream++;
+   }
+
+   #ifndef STB_VORBIS_NO_STDIO
+   {
+   int c = fgetc(z->f);
+   if (c == EOF) { z->eof = TRUE; return 0; }
+   return c;
+   }
+   #endif
+}
+
+static uint32 get32(vorb *f)
+{
+   uint32 x;
+   x = get8(f);
+   x += get8(f) << 8;
+   x += get8(f) << 16;
+   x += (uint32) get8(f) << 24;
+   return x;
+}
+
+static int getn(vorb *z, uint8 *data, int n)
+{
+   if (USE_MEMORY(z)) {
+      if (z->stream+n > z->stream_end) { z->eof = 1; return 0; }
+      memcpy(data, z->stream, n);
+      z->stream += n;
+      return 1;
+   }
+
+   #ifndef STB_VORBIS_NO_STDIO
+   if (fread(data, n, 1, z->f) == 1)
+      return 1;
+   else {
+      z->eof = 1;
+      return 0;
+   }
+   #endif
+}
+
+static void skip(vorb *z, int n)
+{
+   if (USE_MEMORY(z)) {
+      z->stream += n;
+      if (z->stream >= z->stream_end) z->eof = 1;
+      return;
+   }
+   #ifndef STB_VORBIS_NO_STDIO
+   {
+      long x = ftell(z->f);
+      fseek(z->f, x+n, SEEK_SET);
+   }
+   #endif
+}
+
+static int set_file_offset(stb_vorbis *f, unsigned int loc)
+{
+   #ifndef STB_VORBIS_NO_PUSHDATA_API
+   if (f->push_mode) return 0;
+   #endif
+   f->eof = 0;
+   if (USE_MEMORY(f)) {
+      if (f->stream_start + loc >= f->stream_end || f->stream_start + loc < f->stream_start) {
+         f->stream = f->stream_end;
+         f->eof = 1;
+         return 0;
+      } else {
+         f->stream = f->stream_start + loc;
+         return 1;
+      }
+   }
+   #ifndef STB_VORBIS_NO_STDIO
+   if (loc + f->f_start < loc || loc >= 0x80000000) {
+      loc = 0x7fffffff;
+      f->eof = 1;
+   } else {
+      loc += f->f_start;
+   }
+   if (!fseek(f->f, loc, SEEK_SET))
+      return 1;
+   f->eof = 1;
+   fseek(f->f, f->f_start, SEEK_END);
+   return 0;
+   #endif
+}
+
+
+static uint8 ogg_page_header[4] = { 0x4f, 0x67, 0x67, 0x53 };
+
+static int capture_pattern(vorb *f)
+{
+   if (0x4f != get8(f)) return FALSE;
+   if (0x67 != get8(f)) return FALSE;
+   if (0x67 != get8(f)) return FALSE;
+   if (0x53 != get8(f)) return FALSE;
+   return TRUE;
+}
+
+#define PAGEFLAG_continued_packet   1
+#define PAGEFLAG_first_page         2
+#define PAGEFLAG_last_page          4
+
+static int start_page_no_capturepattern(vorb *f)
+{
+   uint32 loc0,loc1,n;
+   if (f->first_decode && !IS_PUSH_MODE(f)) {
+      f->p_first.page_start = stb_vorbis_get_file_offset(f) - 4;
+   }
+   // stream structure version
+   if (0 != get8(f)) return error(f, VORBIS_invalid_stream_structure_version);
+   // header flag
+   f->page_flag = get8(f);
+   // absolute granule position
+   loc0 = get32(f);
+   loc1 = get32(f);
+   // @TODO: validate loc0,loc1 as valid positions?
+   // stream serial number -- vorbis doesn't interleave, so discard
+   get32(f);
+   //if (f->serial != get32(f)) return error(f, VORBIS_incorrect_stream_serial_number);
+   // page sequence number
+   n = get32(f);
+   f->last_page = n;
+   // CRC32
+   get32(f);
+   // page_segments
+   f->segment_count = get8(f);
+   if (!getn(f, f->segments, f->segment_count))
+      return error(f, VORBIS_unexpected_eof);
+   // assume we _don't_ know any the sample position of any segments
+   f->end_seg_with_known_loc = -2;
+   if (loc0 != ~0U || loc1 != ~0U) {
+      int i;
+      // determine which packet is the last one that will complete
+      for (i=f->segment_count-1; i >= 0; --i)
+         if (f->segments[i] < 255)
+            break;
+      // 'i' is now the index of the _last_ segment of a packet that ends
+      if (i >= 0) {
+         f->end_seg_with_known_loc = i;
+         f->known_loc_for_packet   = loc0;
+      }
+   }
+   if (f->first_decode) {
+      int i,len;
+      len = 0;
+      for (i=0; i < f->segment_count; ++i)
+         len += f->segments[i];
+      len += 27 + f->segment_count;
+      f->p_first.page_end = f->p_first.page_start + len;
+      f->p_first.last_decoded_sample = loc0;
+   }
+   f->next_seg = 0;
+   return TRUE;
+}
+
+static int start_page(vorb *f)
+{
+   if (!capture_pattern(f)) return error(f, VORBIS_missing_capture_pattern);
+   return start_page_no_capturepattern(f);
+}
+
+static int start_packet(vorb *f)
+{
+   while (f->next_seg == -1) {
+      if (!start_page(f)) return FALSE;
+      if (f->page_flag & PAGEFLAG_continued_packet)
+         return error(f, VORBIS_continued_packet_flag_invalid);
+   }
+   f->last_seg = FALSE;
+   f->valid_bits = 0;
+   f->packet_bytes = 0;
+   f->bytes_in_seg = 0;
+   // f->next_seg is now valid
+   return TRUE;
+}
+
+static int maybe_start_packet(vorb *f)
+{
+   if (f->next_seg == -1) {
+      int x = get8(f);
+      if (f->eof) return FALSE; // EOF at page boundary is not an error!
+      if (0x4f != x      ) return error(f, VORBIS_missing_capture_pattern);
+      if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern);
+      if (0x67 != get8(f)) return error(f, VORBIS_missing_capture_pattern);
+      if (0x53 != get8(f)) return error(f, VORBIS_missing_capture_pattern);
+      if (!start_page_no_capturepattern(f)) return FALSE;
+      if (f->page_flag & PAGEFLAG_continued_packet) {
+         // set up enough state that we can read this packet if we want,
+         // e.g. during recovery
+         f->last_seg = FALSE;
+         f->bytes_in_seg = 0;
+         return error(f, VORBIS_continued_packet_flag_invalid);
+      }
+   }
+   return start_packet(f);
+}
+
+static int next_segment(vorb *f)
+{
+   int len;
+   if (f->last_seg) return 0;
+   if (f->next_seg == -1) {
+      f->last_seg_which = f->segment_count-1; // in case start_page fails
+      if (!start_page(f)) { f->last_seg = 1; return 0; }
+      if (!(f->page_flag & PAGEFLAG_continued_packet)) return error(f, VORBIS_continued_packet_flag_invalid);
+   }
+   len = f->segments[f->next_seg++];
+   if (len < 255) {
+      f->last_seg = TRUE;
+      f->last_seg_which = f->next_seg-1;
+   }
+   if (f->next_seg >= f->segment_count)
+      f->next_seg = -1;
+   assert(f->bytes_in_seg == 0);
+   f->bytes_in_seg = len;
+   return len;
+}
+
+#define EOP    (-1)
+#define INVALID_BITS  (-1)
+
+static int get8_packet_raw(vorb *f)
+{
+   if (!f->bytes_in_seg) {  // CLANG!
+      if (f->last_seg) return EOP;
+      else if (!next_segment(f)) return EOP;
+   }
+   assert(f->bytes_in_seg > 0);
+   --f->bytes_in_seg;
+   ++f->packet_bytes;
+   return get8(f);
+}
+
+static int get8_packet(vorb *f)
+{
+   int x = get8_packet_raw(f);
+   f->valid_bits = 0;
+   return x;
+}
+
+static int get32_packet(vorb *f)
+{
+   uint32 x;
+   x = get8_packet(f);
+   x += get8_packet(f) << 8;
+   x += get8_packet(f) << 16;
+   x += (uint32) get8_packet(f) << 24;
+   return x;
+}
+
+static void flush_packet(vorb *f)
+{
+   while (get8_packet_raw(f) != EOP);
+}
+
+// @OPTIMIZE: this is the secondary bit decoder, so it's probably not as important
+// as the huffman decoder?
+static uint32 get_bits(vorb *f, int n)
+{
+   uint32 z;
+
+   if (f->valid_bits < 0) return 0;
+   if (f->valid_bits < n) {
+      if (n > 24) {
+         // the accumulator technique below would not work correctly in this case
+         z = get_bits(f, 24);
+         z += get_bits(f, n-24) << 24;
+         return z;
+      }
+      if (f->valid_bits == 0) f->acc = 0;
+      while (f->valid_bits < n) {
+         int z = get8_packet_raw(f);
+         if (z == EOP) {
+            f->valid_bits = INVALID_BITS;
+            return 0;
+         }
+         f->acc += z << f->valid_bits;
+         f->valid_bits += 8;
+      }
+   }
+
+   assert(f->valid_bits >= n);
+   z = f->acc & ((1 << n)-1);
+   f->acc >>= n;
+   f->valid_bits -= n;
+   return z;
+}
+
+// @OPTIMIZE: primary accumulator for huffman
+// expand the buffer to as many bits as possible without reading off end of packet
+// it might be nice to allow f->valid_bits and f->acc to be stored in registers,
+// e.g. cache them locally and decode locally
+static __forceinline void prep_huffman(vorb *f)
+{
+   if (f->valid_bits <= 24) {
+      if (f->valid_bits == 0) f->acc = 0;
+      do {
+         int z;
+         if (f->last_seg && !f->bytes_in_seg) return;
+         z = get8_packet_raw(f);
+         if (z == EOP) return;
+         f->acc += (unsigned) z << f->valid_bits;
+         f->valid_bits += 8;
+      } while (f->valid_bits <= 24);
+   }
+}
+
+enum
+{
+   VORBIS_packet_id = 1,
+   VORBIS_packet_comment = 3,
+   VORBIS_packet_setup = 5
+};
+
+static int codebook_decode_scalar_raw(vorb *f, Codebook *c)
+{
+   int i;
+   prep_huffman(f);
+
+   if (c->codewords == NULL && c->sorted_codewords == NULL)
+      return -1;
+
+   // cases to use binary search: sorted_codewords && !c->codewords
+   //                             sorted_codewords && c->entries > 8
+   if (c->entries > 8 ? c->sorted_codewords!=NULL : !c->codewords) {
+      // binary search
+      uint32 code = bit_reverse(f->acc);
+      int x=0, n=c->sorted_entries, len;
+
+      while (n > 1) {
+         // invariant: sc[x] <= code < sc[x+n]
+         int m = x + (n >> 1);
+         if (c->sorted_codewords[m] <= code) {
+            x = m;
+            n -= (n>>1);
+         } else {
+            n >>= 1;
+         }
+      }
+      // x is now the sorted index
+      if (!c->sparse) x = c->sorted_values[x];
+      // x is now sorted index if sparse, or symbol otherwise
+      len = c->codeword_lengths[x];
+      if (f->valid_bits >= len) {
+         f->acc >>= len;
+         f->valid_bits -= len;
+         return x;
+      }
+
+      f->valid_bits = 0;
+      return -1;
+   }
+
+   // if small, linear search
+   assert(!c->sparse);
+   for (i=0; i < c->entries; ++i) {
+      if (c->codeword_lengths[i] == NO_CODE) continue;
+      if (c->codewords[i] == (f->acc & ((1 << c->codeword_lengths[i])-1))) {
+         if (f->valid_bits >= c->codeword_lengths[i]) {
+            f->acc >>= c->codeword_lengths[i];
+            f->valid_bits -= c->codeword_lengths[i];
+            return i;
+         }
+         f->valid_bits = 0;
+         return -1;
+      }
+   }
+
+   error(f, VORBIS_invalid_stream);
+   f->valid_bits = 0;
+   return -1;
+}
+
+#ifndef STB_VORBIS_NO_INLINE_DECODE
+
+#define DECODE_RAW(var, f,c)                                  \
+   if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH)        \
+      prep_huffman(f);                                        \
+   var = f->acc & FAST_HUFFMAN_TABLE_MASK;                    \
+   var = c->fast_huffman[var];                                \
+   if (var >= 0) {                                            \
+      int n = c->codeword_lengths[var];                       \
+      f->acc >>= n;                                           \
+      f->valid_bits -= n;                                     \
+      if (f->valid_bits < 0) { f->valid_bits = 0; var = -1; } \
+   } else {                                                   \
+      var = codebook_decode_scalar_raw(f,c);                  \
+   }
+
+#else
+
+static int codebook_decode_scalar(vorb *f, Codebook *c)
+{
+   int i;
+   if (f->valid_bits < STB_VORBIS_FAST_HUFFMAN_LENGTH)
+      prep_huffman(f);
+   // fast huffman table lookup
+   i = f->acc & FAST_HUFFMAN_TABLE_MASK;
+   i = c->fast_huffman[i];
+   if (i >= 0) {
+      f->acc >>= c->codeword_lengths[i];
+      f->valid_bits -= c->codeword_lengths[i];
+      if (f->valid_bits < 0) { f->valid_bits = 0; return -1; }
+      return i;
+   }
+   return codebook_decode_scalar_raw(f,c);
+}
+
+#define DECODE_RAW(var,f,c)    var = codebook_decode_scalar(f,c);
+
+#endif
+
+#define DECODE(var,f,c)                                       \
+   DECODE_RAW(var,f,c)                                        \
+   if (c->sparse) var = c->sorted_values[var];
+
+#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
+  #define DECODE_VQ(var,f,c)   DECODE_RAW(var,f,c)
+#else
+  #define DECODE_VQ(var,f,c)   DECODE(var,f,c)
+#endif
+
+
+
+
+
+
+// CODEBOOK_ELEMENT_FAST is an optimization for the CODEBOOK_FLOATS case
+// where we avoid one addition
+#define CODEBOOK_ELEMENT(c,off)          (c->multiplicands[off])
+#define CODEBOOK_ELEMENT_FAST(c,off)     (c->multiplicands[off])
+#define CODEBOOK_ELEMENT_BASE(c)         (0)
+
+static int codebook_decode_start(vorb *f, Codebook *c)
+{
+   int z = -1;
+
+   // type 0 is only legal in a scalar context
+   if (c->lookup_type == 0)
+      error(f, VORBIS_invalid_stream);
+   else {
+      DECODE_VQ(z,f,c);
+      if (c->sparse) assert(z < c->sorted_entries);
+      if (z < 0) {  // check for EOP
+         if (!f->bytes_in_seg)
+            if (f->last_seg)
+               return z;
+         error(f, VORBIS_invalid_stream);
+      }
+   }
+   return z;
+}
+
+static int codebook_decode(vorb *f, Codebook *c, float *output, int len)
+{
+   int i,z = codebook_decode_start(f,c);
+   if (z < 0) return FALSE;
+   if (len > c->dimensions) len = c->dimensions;
+
+#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
+   if (c->lookup_type == 1) {
+      float last = CODEBOOK_ELEMENT_BASE(c);
+      int div = 1;
+      for (i=0; i < len; ++i) {
+         int off = (z / div) % c->lookup_values;
+         float val = CODEBOOK_ELEMENT_FAST(c,off) + last;
+         output[i] += val;
+         if (c->sequence_p) last = val + c->minimum_value;
+         div *= c->lookup_values;
+      }
+      return TRUE;
+   }
+#endif
+
+   z *= c->dimensions;
+   if (c->sequence_p) {
+      float last = CODEBOOK_ELEMENT_BASE(c);
+      for (i=0; i < len; ++i) {
+         float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+         output[i] += val;
+         last = val + c->minimum_value;
+      }
+   } else {
+      float last = CODEBOOK_ELEMENT_BASE(c);
+      for (i=0; i < len; ++i) {
+         output[i] += CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+      }
+   }
+
+   return TRUE;
+}
+
+static int codebook_decode_step(vorb *f, Codebook *c, float *output, int len, int step)
+{
+   int i,z = codebook_decode_start(f,c);
+   float last = CODEBOOK_ELEMENT_BASE(c);
+   if (z < 0) return FALSE;
+   if (len > c->dimensions) len = c->dimensions;
+
+#ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
+   if (c->lookup_type == 1) {
+      int div = 1;
+      for (i=0; i < len; ++i) {
+         int off = (z / div) % c->lookup_values;
+         float val = CODEBOOK_ELEMENT_FAST(c,off) + last;
+         output[i*step] += val;
+         if (c->sequence_p) last = val;
+         div *= c->lookup_values;
+      }
+      return TRUE;
+   }
+#endif
+
+   z *= c->dimensions;
+   for (i=0; i < len; ++i) {
+      float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+      output[i*step] += val;
+      if (c->sequence_p) last = val;
+   }
+
+   return TRUE;
+}
+
+static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **outputs, int ch, int *c_inter_p, int *p_inter_p, int len, int total_decode)
+{
+   int c_inter = *c_inter_p;
+   int p_inter = *p_inter_p;
+   int i,z, effective = c->dimensions;
+
+   // type 0 is only legal in a scalar context
+   if (c->lookup_type == 0)   return error(f, VORBIS_invalid_stream);
+
+   while (total_decode > 0) {
+      float last = CODEBOOK_ELEMENT_BASE(c);
+      DECODE_VQ(z,f,c);
+      #ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
+      assert(!c->sparse || z < c->sorted_entries);
+      #endif
+      if (z < 0) {
+         if (!f->bytes_in_seg)
+            if (f->last_seg) return FALSE;
+         return error(f, VORBIS_invalid_stream);
+      }
+
+      // if this will take us off the end of the buffers, stop short!
+      // we check by computing the length of the virtual interleaved
+      // buffer (len*ch), our current offset within it (p_inter*ch)+(c_inter),
+      // and the length we'll be using (effective)
+      if (c_inter + p_inter*ch + effective > len * ch) {
+         effective = len*ch - (p_inter*ch - c_inter);
+      }
+
+   #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
+      if (c->lookup_type == 1) {
+         int div = 1;
+         for (i=0; i < effective; ++i) {
+            int off = (z / div) % c->lookup_values;
+            float val = CODEBOOK_ELEMENT_FAST(c,off) + last;
+            if (outputs[c_inter])
+               outputs[c_inter][p_inter] += val;
+            if (++c_inter == ch) { c_inter = 0; ++p_inter; }
+            if (c->sequence_p) last = val;
+            div *= c->lookup_values;
+         }
+      } else
+   #endif
+      {
+         z *= c->dimensions;
+         if (c->sequence_p) {
+            for (i=0; i < effective; ++i) {
+               float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+               if (outputs[c_inter])
+                  outputs[c_inter][p_inter] += val;
+               if (++c_inter == ch) { c_inter = 0; ++p_inter; }
+               last = val;
+            }
+         } else {
+            for (i=0; i < effective; ++i) {
+               float val = CODEBOOK_ELEMENT_FAST(c,z+i) + last;
+               if (outputs[c_inter])
+                  outputs[c_inter][p_inter] += val;
+               if (++c_inter == ch) { c_inter = 0; ++p_inter; }
+            }
+         }
+      }
+
+      total_decode -= effective;
+   }
+   *c_inter_p = c_inter;
+   *p_inter_p = p_inter;
+   return TRUE;
+}
+
+static int predict_point(int x, int x0, int x1, int y0, int y1)
+{
+   int dy = y1 - y0;
+   int adx = x1 - x0;
+   // @OPTIMIZE: force int division to round in the right direction... is this necessary on x86?
+   int err = abs(dy) * (x - x0);
+   int off = err / adx;
+   return dy < 0 ? y0 - off : y0 + off;
+}
+
+// the following table is block-copied from the specification
+static float inverse_db_table[256] =
+{
+  1.0649863e-07f, 1.1341951e-07f, 1.2079015e-07f, 1.2863978e-07f,
+  1.3699951e-07f, 1.4590251e-07f, 1.5538408e-07f, 1.6548181e-07f,
+  1.7623575e-07f, 1.8768855e-07f, 1.9988561e-07f, 2.1287530e-07f,
+  2.2670913e-07f, 2.4144197e-07f, 2.5713223e-07f, 2.7384213e-07f,
+  2.9163793e-07f, 3.1059021e-07f, 3.3077411e-07f, 3.5226968e-07f,
+  3.7516214e-07f, 3.9954229e-07f, 4.2550680e-07f, 4.5315863e-07f,
+  4.8260743e-07f, 5.1396998e-07f, 5.4737065e-07f, 5.8294187e-07f,
+  6.2082472e-07f, 6.6116941e-07f, 7.0413592e-07f, 7.4989464e-07f,
+  7.9862701e-07f, 8.5052630e-07f, 9.0579828e-07f, 9.6466216e-07f,
+  1.0273513e-06f, 1.0941144e-06f, 1.1652161e-06f, 1.2409384e-06f,
+  1.3215816e-06f, 1.4074654e-06f, 1.4989305e-06f, 1.5963394e-06f,
+  1.7000785e-06f, 1.8105592e-06f, 1.9282195e-06f, 2.0535261e-06f,
+  2.1869758e-06f, 2.3290978e-06f, 2.4804557e-06f, 2.6416497e-06f,
+  2.8133190e-06f, 2.9961443e-06f, 3.1908506e-06f, 3.3982101e-06f,
+  3.6190449e-06f, 3.8542308e-06f, 4.1047004e-06f, 4.3714470e-06f,
+  4.6555282e-06f, 4.9580707e-06f, 5.2802740e-06f, 5.6234160e-06f,
+  5.9888572e-06f, 6.3780469e-06f, 6.7925283e-06f, 7.2339451e-06f,
+  7.7040476e-06f, 8.2047000e-06f, 8.7378876e-06f, 9.3057248e-06f,
+  9.9104632e-06f, 1.0554501e-05f, 1.1240392e-05f, 1.1970856e-05f,
+  1.2748789e-05f, 1.3577278e-05f, 1.4459606e-05f, 1.5399272e-05f,
+  1.6400004e-05f, 1.7465768e-05f, 1.8600792e-05f, 1.9809576e-05f,
+  2.1096914e-05f, 2.2467911e-05f, 2.3928002e-05f, 2.5482978e-05f,
+  2.7139006e-05f, 2.8902651e-05f, 3.0780908e-05f, 3.2781225e-05f,
+  3.4911534e-05f, 3.7180282e-05f, 3.9596466e-05f, 4.2169667e-05f,
+  4.4910090e-05f, 4.7828601e-05f, 5.0936773e-05f, 5.4246931e-05f,
+  5.7772202e-05f, 6.1526565e-05f, 6.5524908e-05f, 6.9783085e-05f,
+  7.4317983e-05f, 7.9147585e-05f, 8.4291040e-05f, 8.9768747e-05f,
+  9.5602426e-05f, 0.00010181521f, 0.00010843174f, 0.00011547824f,
+  0.00012298267f, 0.00013097477f, 0.00013948625f, 0.00014855085f,
+  0.00015820453f, 0.00016848555f, 0.00017943469f, 0.00019109536f,
+  0.00020351382f, 0.00021673929f, 0.00023082423f, 0.00024582449f,
+  0.00026179955f, 0.00027881276f, 0.00029693158f, 0.00031622787f,
+  0.00033677814f, 0.00035866388f, 0.00038197188f, 0.00040679456f,
+  0.00043323036f, 0.00046138411f, 0.00049136745f, 0.00052329927f,
+  0.00055730621f, 0.00059352311f, 0.00063209358f, 0.00067317058f,
+  0.00071691700f, 0.00076350630f, 0.00081312324f, 0.00086596457f,
+  0.00092223983f, 0.00098217216f, 0.0010459992f,  0.0011139742f,
+  0.0011863665f,  0.0012634633f,  0.0013455702f,  0.0014330129f,
+  0.0015261382f,  0.0016253153f,  0.0017309374f,  0.0018434235f,
+  0.0019632195f,  0.0020908006f,  0.0022266726f,  0.0023713743f,
+  0.0025254795f,  0.0026895994f,  0.0028643847f,  0.0030505286f,
+  0.0032487691f,  0.0034598925f,  0.0036847358f,  0.0039241906f,
+  0.0041792066f,  0.0044507950f,  0.0047400328f,  0.0050480668f,
+  0.0053761186f,  0.0057254891f,  0.0060975636f,  0.0064938176f,
+  0.0069158225f,  0.0073652516f,  0.0078438871f,  0.0083536271f,
+  0.0088964928f,  0.009474637f,   0.010090352f,   0.010746080f,
+  0.011444421f,   0.012188144f,   0.012980198f,   0.013823725f,
+  0.014722068f,   0.015678791f,   0.016697687f,   0.017782797f,
+  0.018938423f,   0.020169149f,   0.021479854f,   0.022875735f,
+  0.024362330f,   0.025945531f,   0.027631618f,   0.029427276f,
+  0.031339626f,   0.033376252f,   0.035545228f,   0.037855157f,
+  0.040315199f,   0.042935108f,   0.045725273f,   0.048696758f,
+  0.051861348f,   0.055231591f,   0.058820850f,   0.062643361f,
+  0.066714279f,   0.071049749f,   0.075666962f,   0.080584227f,
+  0.085821044f,   0.091398179f,   0.097337747f,   0.10366330f,
+  0.11039993f,    0.11757434f,    0.12521498f,    0.13335215f,
+  0.14201813f,    0.15124727f,    0.16107617f,    0.17154380f,
+  0.18269168f,    0.19456402f,    0.20720788f,    0.22067342f,
+  0.23501402f,    0.25028656f,    0.26655159f,    0.28387361f,
+  0.30232132f,    0.32196786f,    0.34289114f,    0.36517414f,
+  0.38890521f,    0.41417847f,    0.44109412f,    0.46975890f,
+  0.50028648f,    0.53279791f,    0.56742212f,    0.60429640f,
+  0.64356699f,    0.68538959f,    0.72993007f,    0.77736504f,
+  0.82788260f,    0.88168307f,    0.9389798f,     1.0f
+};
+
+
+// @OPTIMIZE: if you want to replace this bresenham line-drawing routine,
+// note that you must produce bit-identical output to decode correctly;
+// this specific sequence of operations is specified in the spec (it's
+// drawing integer-quantized frequency-space lines that the encoder
+// expects to be exactly the same)
+//     ... also, isn't the whole point of Bresenham's algorithm to NOT
+// have to divide in the setup? sigh.
+#ifndef STB_VORBIS_NO_DEFER_FLOOR
+#define LINE_OP(a,b)   a *= b
+#else
+#define LINE_OP(a,b)   a = b
+#endif
+
+#ifdef STB_VORBIS_DIVIDE_TABLE
+#define DIVTAB_NUMER   32
+#define DIVTAB_DENOM   64
+int8 integer_divide_table[DIVTAB_NUMER][DIVTAB_DENOM]; // 2KB
+#endif
+
+static __forceinline void draw_line(float *output, int x0, int y0, int x1, int y1, int n)
+{
+   int dy = y1 - y0;
+   int adx = x1 - x0;
+   int ady = abs(dy);
+   int base;
+   int x=x0,y=y0;
+   int err = 0;
+   int sy;
+
+#ifdef STB_VORBIS_DIVIDE_TABLE
+   if (adx < DIVTAB_DENOM && ady < DIVTAB_NUMER) {
+      if (dy < 0) {
+         base = -integer_divide_table[ady][adx];
+         sy = base-1;
+      } else {
+         base =  integer_divide_table[ady][adx];
+         sy = base+1;
+      }
+   } else {
+      base = dy / adx;
+      if (dy < 0)
+         sy = base - 1;
+      else
+         sy = base+1;
+   }
+#else
+   base = dy / adx;
+   if (dy < 0)
+      sy = base - 1;
+   else
+      sy = base+1;
+#endif
+   ady -= abs(base) * adx;
+   if (x1 > n) x1 = n;
+   if (x < x1) {
+      LINE_OP(output[x], inverse_db_table[y&255]);
+      for (++x; x < x1; ++x) {
+         err += ady;
+         if (err >= adx) {
+            err -= adx;
+            y += sy;
+         } else
+            y += base;
+         LINE_OP(output[x], inverse_db_table[y&255]);
+      }
+   }
+}
+
+static int residue_decode(vorb *f, Codebook *book, float *target, int offset, int n, int rtype)
+{
+   int k;
+   if (rtype == 0) {
+      int step = n / book->dimensions;
+      for (k=0; k < step; ++k)
+         if (!codebook_decode_step(f, book, target+offset+k, n-offset-k, step))
+            return FALSE;
+   } else {
+      for (k=0; k < n; ) {
+         if (!codebook_decode(f, book, target+offset, n-k))
+            return FALSE;
+         k += book->dimensions;
+         offset += book->dimensions;
+      }
+   }
+   return TRUE;
+}
+
+// n is 1/2 of the blocksize --
+// specification: "Correct per-vector decode length is [n]/2"
+static void decode_residue(vorb *f, float *residue_buffers[], int ch, int n, int rn, uint8 *do_not_decode)
+{
+   int i,j,pass;
+   Residue *r = f->residue_config + rn;
+   int rtype = f->residue_types[rn];
+   int c = r->classbook;
+   int classwords = f->codebooks[c].dimensions;
+   unsigned int actual_size = rtype == 2 ? n*2 : n;
+   unsigned int limit_r_begin = (r->begin < actual_size ? r->begin : actual_size);
+   unsigned int limit_r_end   = (r->end   < actual_size ? r->end   : actual_size);
+   int n_read = limit_r_end - limit_r_begin;
+   int part_read = n_read / r->part_size;
+   int temp_alloc_point = temp_alloc_save(f);
+   #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+   uint8 ***part_classdata = (uint8 ***) temp_block_array(f,f->channels, part_read * sizeof(**part_classdata));
+   #else
+   int **classifications = (int **) temp_block_array(f,f->channels, part_read * sizeof(**classifications));
+   #endif
+
+   CHECK(f);
+
+   for (i=0; i < ch; ++i)
+      if (!do_not_decode[i])
+         memset(residue_buffers[i], 0, sizeof(float) * n);
+
+   if (rtype == 2 && ch != 1) {
+      for (j=0; j < ch; ++j)
+         if (!do_not_decode[j])
+            break;
+      if (j == ch)
+         goto done;
+
+      for (pass=0; pass < 8; ++pass) {
+         int pcount = 0, class_set = 0;
+         if (ch == 2) {
+            while (pcount < part_read) {
+               int z = r->begin + pcount*r->part_size;
+               int c_inter = (z & 1), p_inter = z>>1;
+               if (pass == 0) {
+                  Codebook *c = f->codebooks+r->classbook;
+                  int q;
+                  DECODE(q,f,c);
+                  if (q == EOP) goto done;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  part_classdata[0][class_set] = r->classdata[q];
+                  #else
+                  for (i=classwords-1; i >= 0; --i) {
+                     classifications[0][i+pcount] = q % r->classifications;
+                     q /= r->classifications;
+                  }
+                  #endif
+               }
+               for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
+                  int z = r->begin + pcount*r->part_size;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  int c = part_classdata[0][class_set][i];
+                  #else
+                  int c = classifications[0][pcount];
+                  #endif
+                  int b = r->residue_books[c][pass];
+                  if (b >= 0) {
+                     Codebook *book = f->codebooks + b;
+                     #ifdef STB_VORBIS_DIVIDES_IN_CODEBOOK
+                     if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size))
+                        goto done;
+                     #else
+                     // saves 1%
+                     if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size))
+                        goto done;
+                     #endif
+                  } else {
+                     z += r->part_size;
+                     c_inter = z & 1;
+                     p_inter = z >> 1;
+                  }
+               }
+               #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+               ++class_set;
+               #endif
+            }
+         } else if (ch > 2) {
+            while (pcount < part_read) {
+               int z = r->begin + pcount*r->part_size;
+               int c_inter = z % ch, p_inter = z/ch;
+               if (pass == 0) {
+                  Codebook *c = f->codebooks+r->classbook;
+                  int q;
+                  DECODE(q,f,c);
+                  if (q == EOP) goto done;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  part_classdata[0][class_set] = r->classdata[q];
+                  #else
+                  for (i=classwords-1; i >= 0; --i) {
+                     classifications[0][i+pcount] = q % r->classifications;
+                     q /= r->classifications;
+                  }
+                  #endif
+               }
+               for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
+                  int z = r->begin + pcount*r->part_size;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  int c = part_classdata[0][class_set][i];
+                  #else
+                  int c = classifications[0][pcount];
+                  #endif
+                  int b = r->residue_books[c][pass];
+                  if (b >= 0) {
+                     Codebook *book = f->codebooks + b;
+                     if (!codebook_decode_deinterleave_repeat(f, book, residue_buffers, ch, &c_inter, &p_inter, n, r->part_size))
+                        goto done;
+                  } else {
+                     z += r->part_size;
+                     c_inter = z % ch;
+                     p_inter = z / ch;
+                  }
+               }
+               #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+               ++class_set;
+               #endif
+            }
+         }
+      }
+      goto done;
+   }
+   CHECK(f);
+
+   for (pass=0; pass < 8; ++pass) {
+      int pcount = 0, class_set=0;
+      while (pcount < part_read) {
+         if (pass == 0) {
+            for (j=0; j < ch; ++j) {
+               if (!do_not_decode[j]) {
+                  Codebook *c = f->codebooks+r->classbook;
+                  int temp;
+                  DECODE(temp,f,c);
+                  if (temp == EOP) goto done;
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  part_classdata[j][class_set] = r->classdata[temp];
+                  #else
+                  for (i=classwords-1; i >= 0; --i) {
+                     classifications[j][i+pcount] = temp % r->classifications;
+                     temp /= r->classifications;
+                  }
+                  #endif
+               }
+            }
+         }
+         for (i=0; i < classwords && pcount < part_read; ++i, ++pcount) {
+            for (j=0; j < ch; ++j) {
+               if (!do_not_decode[j]) {
+                  #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+                  int c = part_classdata[j][class_set][i];
+                  #else
+                  int c = classifications[j][pcount];
+                  #endif
+                  int b = r->residue_books[c][pass];
+                  if (b >= 0) {
+                     float *target = residue_buffers[j];
+                     int offset = r->begin + pcount * r->part_size;
+                     int n = r->part_size;
+                     Codebook *book = f->codebooks + b;
+                     if (!residue_decode(f, book, target, offset, n, rtype))
+                        goto done;
+                  }
+               }
+            }
+         }
+         #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+         ++class_set;
+         #endif
+      }
+   }
+  done:
+   CHECK(f);
+   #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+   temp_free(f,part_classdata);
+   #else
+   temp_free(f,classifications);
+   #endif
+   temp_alloc_restore(f,temp_alloc_point);
+}
+
+
+#if 0
+// slow way for debugging
+void inverse_mdct_slow(float *buffer, int n)
+{
+   int i,j;
+   int n2 = n >> 1;
+   float *x = (float *) malloc(sizeof(*x) * n2);
+   memcpy(x, buffer, sizeof(*x) * n2);
+   for (i=0; i < n; ++i) {
+      float acc = 0;
+      for (j=0; j < n2; ++j)
+         // formula from paper:
+         //acc += n/4.0f * x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1));
+         // formula from wikipedia
+         //acc += 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5));
+         // these are equivalent, except the formula from the paper inverts the multiplier!
+         // however, what actually works is NO MULTIPLIER!?!
+         //acc += 64 * 2.0f / n2 * x[j] * (float) cos(M_PI/n2 * (i + 0.5 + n2/2)*(j + 0.5));
+         acc += x[j] * (float) cos(M_PI / 2 / n * (2 * i + 1 + n/2.0)*(2*j+1));
+      buffer[i] = acc;
+   }
+   free(x);
+}
+#elif 0
+// same as above, but just barely able to run in real time on modern machines
+void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype)
+{
+   float mcos[16384];
+   int i,j;
+   int n2 = n >> 1, nmask = (n << 2) -1;
+   float *x = (float *) malloc(sizeof(*x) * n2);
+   memcpy(x, buffer, sizeof(*x) * n2);
+   for (i=0; i < 4*n; ++i)
+      mcos[i] = (float) cos(M_PI / 2 * i / n);
+
+   for (i=0; i < n; ++i) {
+      float acc = 0;
+      for (j=0; j < n2; ++j)
+         acc += x[j] * mcos[(2 * i + 1 + n2)*(2*j+1) & nmask];
+      buffer[i] = acc;
+   }
+   free(x);
+}
+#elif 0
+// transform to use a slow dct-iv; this is STILL basically trivial,
+// but only requires half as many ops
+void dct_iv_slow(float *buffer, int n)
+{
+   float mcos[16384];
+   float x[2048];
+   int i,j;
+   int n2 = n >> 1, nmask = (n << 3) - 1;
+   memcpy(x, buffer, sizeof(*x) * n);
+   for (i=0; i < 8*n; ++i)
+      mcos[i] = (float) cos(M_PI / 4 * i / n);
+   for (i=0; i < n; ++i) {
+      float acc = 0;
+      for (j=0; j < n; ++j)
+         acc += x[j] * mcos[((2 * i + 1)*(2*j+1)) & nmask];
+      buffer[i] = acc;
+   }
+}
+
+void inverse_mdct_slow(float *buffer, int n, vorb *f, int blocktype)
+{
+   int i, n4 = n >> 2, n2 = n >> 1, n3_4 = n - n4;
+   float temp[4096];
+
+   memcpy(temp, buffer, n2 * sizeof(float));
+   dct_iv_slow(temp, n2);  // returns -c'-d, a-b'
+
+   for (i=0; i < n4  ; ++i) buffer[i] = temp[i+n4];            // a-b'
+   for (   ; i < n3_4; ++i) buffer[i] = -temp[n3_4 - i - 1];   // b-a', c+d'
+   for (   ; i < n   ; ++i) buffer[i] = -temp[i - n3_4];       // c'+d
+}
+#endif
+
+#ifndef LIBVORBIS_MDCT
+#define LIBVORBIS_MDCT 0
+#endif
+
+#if LIBVORBIS_MDCT
+// directly call the vorbis MDCT using an interface documented
+// by Jeff Roberts... useful for performance comparison
+typedef struct
+{
+  int n;
+  int log2n;
+
+  float *trig;
+  int   *bitrev;
+
+  float scale;
+} mdct_lookup;
+
+extern void mdct_init(mdct_lookup *lookup, int n);
+extern void mdct_clear(mdct_lookup *l);
+extern void mdct_backward(mdct_lookup *init, float *in, float *out);
+
+mdct_lookup M1,M2;
+
+void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)
+{
+   mdct_lookup *M;
+   if (M1.n == n) M = &M1;
+   else if (M2.n == n) M = &M2;
+   else if (M1.n == 0) { mdct_init(&M1, n); M = &M1; }
+   else {
+      if (M2.n) __asm int 3;
+      mdct_init(&M2, n);
+      M = &M2;
+   }
+
+   mdct_backward(M, buffer, buffer);
+}
+#endif
+
+
+// the following were split out into separate functions while optimizing;
+// they could be pushed back up but eh. __forceinline showed no change;
+// they're probably already being inlined.
+static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A)
+{
+   float *ee0 = e + i_off;
+   float *ee2 = ee0 + k_off;
+   int i;
+
+   assert((n & 3) == 0);
+   for (i=(n>>2); i > 0; --i) {
+      float k00_20, k01_21;
+      k00_20  = ee0[ 0] - ee2[ 0];
+      k01_21  = ee0[-1] - ee2[-1];
+      ee0[ 0] += ee2[ 0];//ee0[ 0] = ee0[ 0] + ee2[ 0];
+      ee0[-1] += ee2[-1];//ee0[-1] = ee0[-1] + ee2[-1];
+      ee2[ 0] = k00_20 * A[0] - k01_21 * A[1];
+      ee2[-1] = k01_21 * A[0] + k00_20 * A[1];
+      A += 8;
+
+      k00_20  = ee0[-2] - ee2[-2];
+      k01_21  = ee0[-3] - ee2[-3];
+      ee0[-2] += ee2[-2];//ee0[-2] = ee0[-2] + ee2[-2];
+      ee0[-3] += ee2[-3];//ee0[-3] = ee0[-3] + ee2[-3];
+      ee2[-2] = k00_20 * A[0] - k01_21 * A[1];
+      ee2[-3] = k01_21 * A[0] + k00_20 * A[1];
+      A += 8;
+
+      k00_20  = ee0[-4] - ee2[-4];
+      k01_21  = ee0[-5] - ee2[-5];
+      ee0[-4] += ee2[-4];//ee0[-4] = ee0[-4] + ee2[-4];
+      ee0[-5] += ee2[-5];//ee0[-5] = ee0[-5] + ee2[-5];
+      ee2[-4] = k00_20 * A[0] - k01_21 * A[1];
+      ee2[-5] = k01_21 * A[0] + k00_20 * A[1];
+      A += 8;
+
+      k00_20  = ee0[-6] - ee2[-6];
+      k01_21  = ee0[-7] - ee2[-7];
+      ee0[-6] += ee2[-6];//ee0[-6] = ee0[-6] + ee2[-6];
+      ee0[-7] += ee2[-7];//ee0[-7] = ee0[-7] + ee2[-7];
+      ee2[-6] = k00_20 * A[0] - k01_21 * A[1];
+      ee2[-7] = k01_21 * A[0] + k00_20 * A[1];
+      A += 8;
+      ee0 -= 8;
+      ee2 -= 8;
+   }
+}
+
+static void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A, int k1)
+{
+   int i;
+   float k00_20, k01_21;
+
+   float *e0 = e + d0;
+   float *e2 = e0 + k_off;
+
+   for (i=lim >> 2; i > 0; --i) {
+      k00_20 = e0[-0] - e2[-0];
+      k01_21 = e0[-1] - e2[-1];
+      e0[-0] += e2[-0];//e0[-0] = e0[-0] + e2[-0];
+      e0[-1] += e2[-1];//e0[-1] = e0[-1] + e2[-1];
+      e2[-0] = (k00_20)*A[0] - (k01_21) * A[1];
+      e2[-1] = (k01_21)*A[0] + (k00_20) * A[1];
+
+      A += k1;
+
+      k00_20 = e0[-2] - e2[-2];
+      k01_21 = e0[-3] - e2[-3];
+      e0[-2] += e2[-2];//e0[-2] = e0[-2] + e2[-2];
+      e0[-3] += e2[-3];//e0[-3] = e0[-3] + e2[-3];
+      e2[-2] = (k00_20)*A[0] - (k01_21) * A[1];
+      e2[-3] = (k01_21)*A[0] + (k00_20) * A[1];
+
+      A += k1;
+
+      k00_20 = e0[-4] - e2[-4];
+      k01_21 = e0[-5] - e2[-5];
+      e0[-4] += e2[-4];//e0[-4] = e0[-4] + e2[-4];
+      e0[-5] += e2[-5];//e0[-5] = e0[-5] + e2[-5];
+      e2[-4] = (k00_20)*A[0] - (k01_21) * A[1];
+      e2[-5] = (k01_21)*A[0] + (k00_20) * A[1];
+
+      A += k1;
+
+      k00_20 = e0[-6] - e2[-6];
+      k01_21 = e0[-7] - e2[-7];
+      e0[-6] += e2[-6];//e0[-6] = e0[-6] + e2[-6];
+      e0[-7] += e2[-7];//e0[-7] = e0[-7] + e2[-7];
+      e2[-6] = (k00_20)*A[0] - (k01_21) * A[1];
+      e2[-7] = (k01_21)*A[0] + (k00_20) * A[1];
+
+      e0 -= 8;
+      e2 -= 8;
+
+      A += k1;
+   }
+}
+
+static void imdct_step3_inner_s_loop(int n, float *e, int i_off, int k_off, float *A, int a_off, int k0)
+{
+   int i;
+   float A0 = A[0];
+   float A1 = A[0+1];
+   float A2 = A[0+a_off];
+   float A3 = A[0+a_off+1];
+   float A4 = A[0+a_off*2+0];
+   float A5 = A[0+a_off*2+1];
+   float A6 = A[0+a_off*3+0];
+   float A7 = A[0+a_off*3+1];
+
+   float k00,k11;
+
+   float *ee0 = e  +i_off;
+   float *ee2 = ee0+k_off;
+
+   for (i=n; i > 0; --i) {
+      k00     = ee0[ 0] - ee2[ 0];
+      k11     = ee0[-1] - ee2[-1];
+      ee0[ 0] =  ee0[ 0] + ee2[ 0];
+      ee0[-1] =  ee0[-1] + ee2[-1];
+      ee2[ 0] = (k00) * A0 - (k11) * A1;
+      ee2[-1] = (k11) * A0 + (k00) * A1;
+
+      k00     = ee0[-2] - ee2[-2];
+      k11     = ee0[-3] - ee2[-3];
+      ee0[-2] =  ee0[-2] + ee2[-2];
+      ee0[-3] =  ee0[-3] + ee2[-3];
+      ee2[-2] = (k00) * A2 - (k11) * A3;
+      ee2[-3] = (k11) * A2 + (k00) * A3;
+
+      k00     = ee0[-4] - ee2[-4];
+      k11     = ee0[-5] - ee2[-5];
+      ee0[-4] =  ee0[-4] + ee2[-4];
+      ee0[-5] =  ee0[-5] + ee2[-5];
+      ee2[-4] = (k00) * A4 - (k11) * A5;
+      ee2[-5] = (k11) * A4 + (k00) * A5;
+
+      k00     = ee0[-6] - ee2[-6];
+      k11     = ee0[-7] - ee2[-7];
+      ee0[-6] =  ee0[-6] + ee2[-6];
+      ee0[-7] =  ee0[-7] + ee2[-7];
+      ee2[-6] = (k00) * A6 - (k11) * A7;
+      ee2[-7] = (k11) * A6 + (k00) * A7;
+
+      ee0 -= k0;
+      ee2 -= k0;
+   }
+}
+
+static __forceinline void iter_54(float *z)
+{
+   float k00,k11,k22,k33;
+   float y0,y1,y2,y3;
+
+   k00  = z[ 0] - z[-4];
+   y0   = z[ 0] + z[-4];
+   y2   = z[-2] + z[-6];
+   k22  = z[-2] - z[-6];
+
+   z[-0] = y0 + y2;      // z0 + z4 + z2 + z6
+   z[-2] = y0 - y2;      // z0 + z4 - z2 - z6
+
+   // done with y0,y2
+
+   k33  = z[-3] - z[-7];
+
+   z[-4] = k00 + k33;    // z0 - z4 + z3 - z7
+   z[-6] = k00 - k33;    // z0 - z4 - z3 + z7
+
+   // done with k33
+
+   k11  = z[-1] - z[-5];
+   y1   = z[-1] + z[-5];
+   y3   = z[-3] + z[-7];
+
+   z[-1] = y1 + y3;      // z1 + z5 + z3 + z7
+   z[-3] = y1 - y3;      // z1 + z5 - z3 - z7
+   z[-5] = k11 - k22;    // z1 - z5 + z2 - z6
+   z[-7] = k11 + k22;    // z1 - z5 - z2 + z6
+}
+
+static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A, int base_n)
+{
+   int a_off = base_n >> 3;
+   float A2 = A[0+a_off];
+   float *z = e + i_off;
+   float *base = z - 16 * n;
+
+   while (z > base) {
+      float k00,k11;
+      float l00,l11;
+
+      k00    = z[-0] - z[ -8];
+      k11    = z[-1] - z[ -9];
+      l00    = z[-2] - z[-10];
+      l11    = z[-3] - z[-11];
+      z[ -0] = z[-0] + z[ -8];
+      z[ -1] = z[-1] + z[ -9];
+      z[ -2] = z[-2] + z[-10];
+      z[ -3] = z[-3] + z[-11];
+      z[ -8] = k00;
+      z[ -9] = k11;
+      z[-10] = (l00+l11) * A2;
+      z[-11] = (l11-l00) * A2;
+
+      k00    = z[ -4] - z[-12];
+      k11    = z[ -5] - z[-13];
+      l00    = z[ -6] - z[-14];
+      l11    = z[ -7] - z[-15];
+      z[ -4] = z[ -4] + z[-12];
+      z[ -5] = z[ -5] + z[-13];
+      z[ -6] = z[ -6] + z[-14];
+      z[ -7] = z[ -7] + z[-15];
+      z[-12] = k11;
+      z[-13] = -k00;
+      z[-14] = (l11-l00) * A2;
+      z[-15] = (l00+l11) * -A2;
+
+      iter_54(z);
+      iter_54(z-8);
+      z -= 16;
+   }
+}
+
+static void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)
+{
+   int n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l;
+   int ld;
+   // @OPTIMIZE: reduce register pressure by using fewer variables?
+   int save_point = temp_alloc_save(f);
+   float *buf2 = (float *) temp_alloc(f, n2 * sizeof(*buf2));
+   float *u=NULL,*v=NULL;
+   // twiddle factors
+   float *A = f->A[blocktype];
+
+   // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio"
+   // See notes about bugs in that paper in less-optimal implementation 'inverse_mdct_old' after this function.
+
+   // kernel from paper
+
+
+   // merged:
+   //   copy and reflect spectral data
+   //   step 0
+
+   // note that it turns out that the items added together during
+   // this step are, in fact, being added to themselves (as reflected
+   // by step 0). inexplicable inefficiency! this became obvious
+   // once I combined the passes.
+
+   // so there's a missing 'times 2' here (for adding X to itself).
+   // this propagates through linearly to the end, where the numbers
+   // are 1/2 too small, and need to be compensated for.
+
+   {
+      float *d,*e, *AA, *e_stop;
+      d = &buf2[n2-2];
+      AA = A;
+      e = &buffer[0];
+      e_stop = &buffer[n2];
+      while (e != e_stop) {
+         d[1] = (e[0] * AA[0] - e[2]*AA[1]);
+         d[0] = (e[0] * AA[1] + e[2]*AA[0]);
+         d -= 2;
+         AA += 2;
+         e += 4;
+      }
+
+      e = &buffer[n2-3];
+      while (d >= buf2) {
+         d[1] = (-e[2] * AA[0] - -e[0]*AA[1]);
+         d[0] = (-e[2] * AA[1] + -e[0]*AA[0]);
+         d -= 2;
+         AA += 2;
+         e -= 4;
+      }
+   }
+
+   // now we use symbolic names for these, so that we can
+   // possibly swap their meaning as we change which operations
+   // are in place
+
+   u = buffer;
+   v = buf2;
+
+   // step 2    (paper output is w, now u)
+   // this could be in place, but the data ends up in the wrong
+   // place... _somebody_'s got to swap it, so this is nominated
+   {
+      float *AA = &A[n2-8];
+      float *d0,*d1, *e0, *e1;
+
+      e0 = &v[n4];
+      e1 = &v[0];
+
+      d0 = &u[n4];
+      d1 = &u[0];
+
+      while (AA >= A) {
+         float v40_20, v41_21;
+
+         v41_21 = e0[1] - e1[1];
+         v40_20 = e0[0] - e1[0];
+         d0[1]  = e0[1] + e1[1];
+         d0[0]  = e0[0] + e1[0];
+         d1[1]  = v41_21*AA[4] - v40_20*AA[5];
+         d1[0]  = v40_20*AA[4] + v41_21*AA[5];
+
+         v41_21 = e0[3] - e1[3];
+         v40_20 = e0[2] - e1[2];
+         d0[3]  = e0[3] + e1[3];
+         d0[2]  = e0[2] + e1[2];
+         d1[3]  = v41_21*AA[0] - v40_20*AA[1];
+         d1[2]  = v40_20*AA[0] + v41_21*AA[1];
+
+         AA -= 8;
+
+         d0 += 4;
+         d1 += 4;
+         e0 += 4;
+         e1 += 4;
+      }
+   }
+
+   // step 3
+   ld = ilog(n) - 1; // ilog is off-by-one from normal definitions
+
+   // optimized step 3:
+
+   // the original step3 loop can be nested r inside s or s inside r;
+   // it's written originally as s inside r, but this is dumb when r
+   // iterates many times, and s few. So I have two copies of it and
+   // switch between them halfway.
+
+   // this is iteration 0 of step 3
+   imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*0, -(n >> 3), A);
+   imdct_step3_iter0_loop(n >> 4, u, n2-1-n4*1, -(n >> 3), A);
+
+   // this is iteration 1 of step 3
+   imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*0, -(n >> 4), A, 16);
+   imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*1, -(n >> 4), A, 16);
+   imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*2, -(n >> 4), A, 16);
+   imdct_step3_inner_r_loop(n >> 5, u, n2-1 - n8*3, -(n >> 4), A, 16);
+
+   l=2;
+   for (; l < (ld-3)>>1; ++l) {
+      int k0 = n >> (l+2), k0_2 = k0>>1;
+      int lim = 1 << (l+1);
+      int i;
+      for (i=0; i < lim; ++i)
+         imdct_step3_inner_r_loop(n >> (l+4), u, n2-1 - k0*i, -k0_2, A, 1 << (l+3));
+   }
+
+   for (; l < ld-6; ++l) {
+      int k0 = n >> (l+2), k1 = 1 << (l+3), k0_2 = k0>>1;
+      int rlim = n >> (l+6), r;
+      int lim = 1 << (l+1);
+      int i_off;
+      float *A0 = A;
+      i_off = n2-1;
+      for (r=rlim; r > 0; --r) {
+         imdct_step3_inner_s_loop(lim, u, i_off, -k0_2, A0, k1, k0);
+         A0 += k1*4;
+         i_off -= 8;
+      }
+   }
+
+   // iterations with count:
+   //   ld-6,-5,-4 all interleaved together
+   //       the big win comes from getting rid of needless flops
+   //         due to the constants on pass 5 & 4 being all 1 and 0;
+   //       combining them to be simultaneous to improve cache made little difference
+   imdct_step3_inner_s_loop_ld654(n >> 5, u, n2-1, A, n);
+
+   // output is u
+
+   // step 4, 5, and 6
+   // cannot be in-place because of step 5
+   {
+      uint16 *bitrev = f->bit_reverse[blocktype];
+      // weirdly, I'd have thought reading sequentially and writing
+      // erratically would have been better than vice-versa, but in
+      // fact that's not what my testing showed. (That is, with
+      // j = bitreverse(i), do you read i and write j, or read j and write i.)
+
+      float *d0 = &v[n4-4];
+      float *d1 = &v[n2-4];
+      while (d0 >= v) {
+         int k4;
+
+         k4 = bitrev[0];
+         d1[3] = u[k4+0];
+         d1[2] = u[k4+1];
+         d0[3] = u[k4+2];
+         d0[2] = u[k4+3];
+
+         k4 = bitrev[1];
+         d1[1] = u[k4+0];
+         d1[0] = u[k4+1];
+         d0[1] = u[k4+2];
+         d0[0] = u[k4+3];
+
+         d0 -= 4;
+         d1 -= 4;
+         bitrev += 2;
+      }
+   }
+   // (paper output is u, now v)
+
+
+   // data must be in buf2
+   assert(v == buf2);
+
+   // step 7   (paper output is v, now v)
+   // this is now in place
+   {
+      float *C = f->C[blocktype];
+      float *d, *e;
+
+      d = v;
+      e = v + n2 - 4;
+
+      while (d < e) {
+         float a02,a11,b0,b1,b2,b3;
+
+         a02 = d[0] - e[2];
+         a11 = d[1] + e[3];
+
+         b0 = C[1]*a02 + C[0]*a11;
+         b1 = C[1]*a11 - C[0]*a02;
+
+         b2 = d[0] + e[ 2];
+         b3 = d[1] - e[ 3];
+
+         d[0] = b2 + b0;
+         d[1] = b3 + b1;
+         e[2] = b2 - b0;
+         e[3] = b1 - b3;
+
+         a02 = d[2] - e[0];
+         a11 = d[3] + e[1];
+
+         b0 = C[3]*a02 + C[2]*a11;
+         b1 = C[3]*a11 - C[2]*a02;
+
+         b2 = d[2] + e[ 0];
+         b3 = d[3] - e[ 1];
+
+         d[2] = b2 + b0;
+         d[3] = b3 + b1;
+         e[0] = b2 - b0;
+         e[1] = b1 - b3;
+
+         C += 4;
+         d += 4;
+         e -= 4;
+      }
+   }
+
+   // data must be in buf2
+
+
+   // step 8+decode   (paper output is X, now buffer)
+   // this generates pairs of data a la 8 and pushes them directly through
+   // the decode kernel (pushing rather than pulling) to avoid having
+   // to make another pass later
+
+   // this cannot POSSIBLY be in place, so we refer to the buffers directly
+
+   {
+      float *d0,*d1,*d2,*d3;
+
+      float *B = f->B[blocktype] + n2 - 8;
+      float *e = buf2 + n2 - 8;
+      d0 = &buffer[0];
+      d1 = &buffer[n2-4];
+      d2 = &buffer[n2];
+      d3 = &buffer[n-4];
+      while (e >= v) {
+         float p0,p1,p2,p3;
+
+         p3 =  e[6]*B[7] - e[7]*B[6];
+         p2 = -e[6]*B[6] - e[7]*B[7];
+
+         d0[0] =   p3;
+         d1[3] = - p3;
+         d2[0] =   p2;
+         d3[3] =   p2;
+
+         p1 =  e[4]*B[5] - e[5]*B[4];
+         p0 = -e[4]*B[4] - e[5]*B[5];
+
+         d0[1] =   p1;
+         d1[2] = - p1;
+         d2[1] =   p0;
+         d3[2] =   p0;
+
+         p3 =  e[2]*B[3] - e[3]*B[2];
+         p2 = -e[2]*B[2] - e[3]*B[3];
+
+         d0[2] =   p3;
+         d1[1] = - p3;
+         d2[2] =   p2;
+         d3[1] =   p2;
+
+         p1 =  e[0]*B[1] - e[1]*B[0];
+         p0 = -e[0]*B[0] - e[1]*B[1];
+
+         d0[3] =   p1;
+         d1[0] = - p1;
+         d2[3] =   p0;
+         d3[0] =   p0;
+
+         B -= 8;
+         e -= 8;
+         d0 += 4;
+         d2 += 4;
+         d1 -= 4;
+         d3 -= 4;
+      }
+   }
+
+   temp_free(f,buf2);
+   temp_alloc_restore(f,save_point);
+}
+
+#if 0
+// this is the original version of the above code, if you want to optimize it from scratch
+void inverse_mdct_naive(float *buffer, int n)
+{
+   float s;
+   float A[1 << 12], B[1 << 12], C[1 << 11];
+   int i,k,k2,k4, n2 = n >> 1, n4 = n >> 2, n8 = n >> 3, l;
+   int n3_4 = n - n4, ld;
+   // how can they claim this only uses N words?!
+   // oh, because they're only used sparsely, whoops
+   float u[1 << 13], X[1 << 13], v[1 << 13], w[1 << 13];
+   // set up twiddle factors
+
+   for (k=k2=0; k < n4; ++k,k2+=2) {
+      A[k2  ] = (float)  cos(4*k*M_PI/n);
+      A[k2+1] = (float) -sin(4*k*M_PI/n);
+      B[k2  ] = (float)  cos((k2+1)*M_PI/n/2);
+      B[k2+1] = (float)  sin((k2+1)*M_PI/n/2);
+   }
+   for (k=k2=0; k < n8; ++k,k2+=2) {
+      C[k2  ] = (float)  cos(2*(k2+1)*M_PI/n);
+      C[k2+1] = (float) -sin(2*(k2+1)*M_PI/n);
+   }
+
+   // IMDCT algorithm from "The use of multirate filter banks for coding of high quality digital audio"
+   // Note there are bugs in that pseudocode, presumably due to them attempting
+   // to rename the arrays nicely rather than representing the way their actual
+   // implementation bounces buffers back and forth. As a result, even in the
+   // "some formulars corrected" version, a direct implementation fails. These
+   // are noted below as "paper bug".
+
+   // copy and reflect spectral data
+   for (k=0; k < n2; ++k) u[k] = buffer[k];
+   for (   ; k < n ; ++k) u[k] = -buffer[n - k - 1];
+   // kernel from paper
+   // step 1
+   for (k=k2=k4=0; k < n4; k+=1, k2+=2, k4+=4) {
+      v[n-k4-1] = (u[k4] - u[n-k4-1]) * A[k2]   - (u[k4+2] - u[n-k4-3])*A[k2+1];
+      v[n-k4-3] = (u[k4] - u[n-k4-1]) * A[k2+1] + (u[k4+2] - u[n-k4-3])*A[k2];
+   }
+   // step 2
+   for (k=k4=0; k < n8; k+=1, k4+=4) {
+      w[n2+3+k4] = v[n2+3+k4] + v[k4+3];
+      w[n2+1+k4] = v[n2+1+k4] + v[k4+1];
+      w[k4+3]    = (v[n2+3+k4] - v[k4+3])*A[n2-4-k4] - (v[n2+1+k4]-v[k4+1])*A[n2-3-k4];
+      w[k4+1]    = (v[n2+1+k4] - v[k4+1])*A[n2-4-k4] + (v[n2+3+k4]-v[k4+3])*A[n2-3-k4];
+   }
+   // step 3
+   ld = ilog(n) - 1; // ilog is off-by-one from normal definitions
+   for (l=0; l < ld-3; ++l) {
+      int k0 = n >> (l+2), k1 = 1 << (l+3);
+      int rlim = n >> (l+4), r4, r;
+      int s2lim = 1 << (l+2), s2;
+      for (r=r4=0; r < rlim; r4+=4,++r) {
+         for (s2=0; s2 < s2lim; s2+=2) {
+            u[n-1-k0*s2-r4] = w[n-1-k0*s2-r4] + w[n-1-k0*(s2+1)-r4];
+            u[n-3-k0*s2-r4] = w[n-3-k0*s2-r4] + w[n-3-k0*(s2+1)-r4];
+            u[n-1-k0*(s2+1)-r4] = (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1]
+                                - (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1+1];
+            u[n-3-k0*(s2+1)-r4] = (w[n-3-k0*s2-r4] - w[n-3-k0*(s2+1)-r4]) * A[r*k1]
+                                + (w[n-1-k0*s2-r4] - w[n-1-k0*(s2+1)-r4]) * A[r*k1+1];
+         }
+      }
+      if (l+1 < ld-3) {
+         // paper bug: ping-ponging of u&w here is omitted
+         memcpy(w, u, sizeof(u));
+      }
+   }
+
+   // step 4
+   for (i=0; i < n8; ++i) {
+      int j = bit_reverse(i) >> (32-ld+3);
+      assert(j < n8);
+      if (i == j) {
+         // paper bug: original code probably swapped in place; if copying,
+         //            need to directly copy in this case
+         int i8 = i << 3;
+         v[i8+1] = u[i8+1];
+         v[i8+3] = u[i8+3];
+         v[i8+5] = u[i8+5];
+         v[i8+7] = u[i8+7];
+      } else if (i < j) {
+         int i8 = i << 3, j8 = j << 3;
+         v[j8+1] = u[i8+1], v[i8+1] = u[j8 + 1];
+         v[j8+3] = u[i8+3], v[i8+3] = u[j8 + 3];
+         v[j8+5] = u[i8+5], v[i8+5] = u[j8 + 5];
+         v[j8+7] = u[i8+7], v[i8+7] = u[j8 + 7];
+      }
+   }
+   // step 5
+   for (k=0; k < n2; ++k) {
+      w[k] = v[k*2+1];
+   }
+   // step 6
+   for (k=k2=k4=0; k < n8; ++k, k2 += 2, k4 += 4) {
+      u[n-1-k2] = w[k4];
+      u[n-2-k2] = w[k4+1];
+      u[n3_4 - 1 - k2] = w[k4+2];
+      u[n3_4 - 2 - k2] = w[k4+3];
+   }
+   // step 7
+   for (k=k2=0; k < n8; ++k, k2 += 2) {
+      v[n2 + k2 ] = ( u[n2 + k2] + u[n-2-k2] + C[k2+1]*(u[n2+k2]-u[n-2-k2]) + C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2;
+      v[n-2 - k2] = ( u[n2 + k2] + u[n-2-k2] - C[k2+1]*(u[n2+k2]-u[n-2-k2]) - C[k2]*(u[n2+k2+1]+u[n-2-k2+1]))/2;
+      v[n2+1+ k2] = ( u[n2+1+k2] - u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2;
+      v[n-1 - k2] = (-u[n2+1+k2] + u[n-1-k2] + C[k2+1]*(u[n2+1+k2]+u[n-1-k2]) - C[k2]*(u[n2+k2]-u[n-2-k2]))/2;
+   }
+   // step 8
+   for (k=k2=0; k < n4; ++k,k2 += 2) {
+      X[k]      = v[k2+n2]*B[k2  ] + v[k2+1+n2]*B[k2+1];
+      X[n2-1-k] = v[k2+n2]*B[k2+1] - v[k2+1+n2]*B[k2  ];
+   }
+
+   // decode kernel to output
+   // determined the following value experimentally
+   // (by first figuring out what made inverse_mdct_slow work); then matching that here
+   // (probably vorbis encoder premultiplies by n or n/2, to save it on the decoder?)
+   s = 0.5; // theoretically would be n4
+
+   // [[[ note! the s value of 0.5 is compensated for by the B[] in the current code,
+   //     so it needs to use the "old" B values to behave correctly, or else
+   //     set s to 1.0 ]]]
+   for (i=0; i < n4  ; ++i) buffer[i] = s * X[i+n4];
+   for (   ; i < n3_4; ++i) buffer[i] = -s * X[n3_4 - i - 1];
+   for (   ; i < n   ; ++i) buffer[i] = -s * X[i - n3_4];
+}
+#endif
+
+static float *get_window(vorb *f, int len)
+{
+   len <<= 1;
+   if (len == f->blocksize_0) return f->window[0];
+   if (len == f->blocksize_1) return f->window[1];
+   return NULL;
+}
+
+#ifndef STB_VORBIS_NO_DEFER_FLOOR
+typedef int16 YTYPE;
+#else
+typedef int YTYPE;
+#endif
+static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *finalY, uint8 *step2_flag)
+{
+   int n2 = n >> 1;
+   int s = map->chan[i].mux, floor;
+   floor = map->submap_floor[s];
+   if (f->floor_types[floor] == 0) {
+      return error(f, VORBIS_invalid_stream);
+   } else {
+      Floor1 *g = &f->floor_config[floor].floor1;
+      int j,q;
+      int lx = 0, ly = finalY[0] * g->floor1_multiplier;
+      for (q=1; q < g->values; ++q) {
+         j = g->sorted_order[q];
+         #ifndef STB_VORBIS_NO_DEFER_FLOOR
+         STBV_NOTUSED(step2_flag);
+         if (finalY[j] >= 0)
+         #else
+         if (step2_flag[j])
+         #endif
+         {
+            int hy = finalY[j] * g->floor1_multiplier;
+            int hx = g->Xlist[j];
+            if (lx != hx)
+               draw_line(target, lx,ly, hx,hy, n2);
+            CHECK(f);
+            lx = hx, ly = hy;
+         }
+      }
+      if (lx < n2) {
+         // optimization of: draw_line(target, lx,ly, n,ly, n2);
+         for (j=lx; j < n2; ++j)
+            LINE_OP(target[j], inverse_db_table[ly]);
+         CHECK(f);
+      }
+   }
+   return TRUE;
+}
+
+// The meaning of "left" and "right"
+//
+// For a given frame:
+//     we compute samples from 0..n
+//     window_center is n/2
+//     we'll window and mix the samples from left_start to left_end with data from the previous frame
+//     all of the samples from left_end to right_start can be output without mixing; however,
+//        this interval is 0-length except when transitioning between short and long frames
+//     all of the samples from right_start to right_end need to be mixed with the next frame,
+//        which we don't have, so those get saved in a buffer
+//     frame N's right_end-right_start, the number of samples to mix with the next frame,
+//        has to be the same as frame N+1's left_end-left_start (which they are by
+//        construction)
+
+static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)
+{
+   Mode *m;
+   int i, n, prev, next, window_center;
+   f->channel_buffer_start = f->channel_buffer_end = 0;
+
+  retry:
+   if (f->eof) return FALSE;
+   if (!maybe_start_packet(f))
+      return FALSE;
+   // check packet type
+   if (get_bits(f,1) != 0) {
+      if (IS_PUSH_MODE(f))
+         return error(f,VORBIS_bad_packet_type);
+      while (EOP != get8_packet(f));
+      goto retry;
+   }
+
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+
+   i = get_bits(f, ilog(f->mode_count-1));
+   if (i == EOP) return FALSE;
+   if (i >= f->mode_count) return FALSE;
+   *mode = i;
+   m = f->mode_config + i;
+   if (m->blockflag) {
+      n = f->blocksize_1;
+      prev = get_bits(f,1);
+      next = get_bits(f,1);
+   } else {
+      prev = next = 0;
+      n = f->blocksize_0;
+   }
+
+// WINDOWING
+
+   window_center = n >> 1;
+   if (m->blockflag && !prev) {
+      *p_left_start = (n - f->blocksize_0) >> 2;
+      *p_left_end   = (n + f->blocksize_0) >> 2;
+   } else {
+      *p_left_start = 0;
+      *p_left_end   = window_center;
+   }
+   if (m->blockflag && !next) {
+      *p_right_start = (n*3 - f->blocksize_0) >> 2;
+      *p_right_end   = (n*3 + f->blocksize_0) >> 2;
+   } else {
+      *p_right_start = window_center;
+      *p_right_end   = n;
+   }
+
+   return TRUE;
+}
+
+static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start, int left_end, int right_start, int right_end, int *p_left)
+{
+   Mapping *map;
+   int i,j,k,n,n2;
+   int zero_channel[256];
+   int really_zero_channel[256];
+
+// WINDOWING
+
+   STBV_NOTUSED(left_end);
+   n = f->blocksize[m->blockflag];
+   map = &f->mapping[m->mapping];
+
+// FLOORS
+   n2 = n >> 1;
+
+   CHECK(f);
+
+   for (i=0; i < f->channels; ++i) {
+      int s = map->chan[i].mux, floor;
+      zero_channel[i] = FALSE;
+      floor = map->submap_floor[s];
+      if (f->floor_types[floor] == 0) {
+         return error(f, VORBIS_invalid_stream);
+      } else {
+         Floor1 *g = &f->floor_config[floor].floor1;
+         if (get_bits(f, 1)) {
+            short *finalY;
+            uint8 step2_flag[256];
+            static int range_list[4] = { 256, 128, 86, 64 };
+            int range = range_list[g->floor1_multiplier-1];
+            int offset = 2;
+            finalY = f->finalY[i];
+            finalY[0] = get_bits(f, ilog(range)-1);
+            finalY[1] = get_bits(f, ilog(range)-1);
+            for (j=0; j < g->partitions; ++j) {
+               int pclass = g->partition_class_list[j];
+               int cdim = g->class_dimensions[pclass];
+               int cbits = g->class_subclasses[pclass];
+               int csub = (1 << cbits)-1;
+               int cval = 0;
+               if (cbits) {
+                  Codebook *c = f->codebooks + g->class_masterbooks[pclass];
+                  DECODE(cval,f,c);
+               }
+               for (k=0; k < cdim; ++k) {
+                  int book = g->subclass_books[pclass][cval & csub];
+                  cval = cval >> cbits;
+                  if (book >= 0) {
+                     int temp;
+                     Codebook *c = f->codebooks + book;
+                     DECODE(temp,f,c);
+                     finalY[offset++] = temp;
+                  } else
+                     finalY[offset++] = 0;
+               }
+            }
+            if (f->valid_bits == INVALID_BITS) goto error; // behavior according to spec
+            step2_flag[0] = step2_flag[1] = 1;
+            for (j=2; j < g->values; ++j) {
+               int low, high, pred, highroom, lowroom, room, val;
+               low = g->neighbors[j][0];
+               high = g->neighbors[j][1];
+               //neighbors(g->Xlist, j, &low, &high);
+               pred = predict_point(g->Xlist[j], g->Xlist[low], g->Xlist[high], finalY[low], finalY[high]);
+               val = finalY[j];
+               highroom = range - pred;
+               lowroom = pred;
+               if (highroom < lowroom)
+                  room = highroom * 2;
+               else
+                  room = lowroom * 2;
+               if (val) {
+                  step2_flag[low] = step2_flag[high] = 1;
+                  step2_flag[j] = 1;
+                  if (val >= room)
+                     if (highroom > lowroom)
+                        finalY[j] = val - lowroom + pred;
+                     else
+                        finalY[j] = pred - val + highroom - 1;
+                  else
+                     if (val & 1)
+                        finalY[j] = pred - ((val+1)>>1);
+                     else
+                        finalY[j] = pred + (val>>1);
+               } else {
+                  step2_flag[j] = 0;
+                  finalY[j] = pred;
+               }
+            }
+
+#ifdef STB_VORBIS_NO_DEFER_FLOOR
+            do_floor(f, map, i, n, f->floor_buffers[i], finalY, step2_flag);
+#else
+            // defer final floor computation until _after_ residue
+            for (j=0; j < g->values; ++j) {
+               if (!step2_flag[j])
+                  finalY[j] = -1;
+            }
+#endif
+         } else {
+           error:
+            zero_channel[i] = TRUE;
+         }
+         // So we just defer everything else to later
+
+         // at this point we've decoded the floor into buffer
+      }
+   }
+   CHECK(f);
+   // at this point we've decoded all floors
+
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+
+   // re-enable coupled channels if necessary
+   memcpy(really_zero_channel, zero_channel, sizeof(really_zero_channel[0]) * f->channels);
+   for (i=0; i < map->coupling_steps; ++i)
+      if (!zero_channel[map->chan[i].magnitude] || !zero_channel[map->chan[i].angle]) {
+         zero_channel[map->chan[i].magnitude] = zero_channel[map->chan[i].angle] = FALSE;
+      }
+
+   CHECK(f);
+// RESIDUE DECODE
+   for (i=0; i < map->submaps; ++i) {
+      float *residue_buffers[STB_VORBIS_MAX_CHANNELS];
+      int r;
+      uint8 do_not_decode[256];
+      int ch = 0;
+      for (j=0; j < f->channels; ++j) {
+         if (map->chan[j].mux == i) {
+            if (zero_channel[j]) {
+               do_not_decode[ch] = TRUE;
+               residue_buffers[ch] = NULL;
+            } else {
+               do_not_decode[ch] = FALSE;
+               residue_buffers[ch] = f->channel_buffers[j];
+            }
+            ++ch;
+         }
+      }
+      r = map->submap_residue[i];
+      decode_residue(f, residue_buffers, ch, n2, r, do_not_decode);
+   }
+
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+   CHECK(f);
+
+// INVERSE COUPLING
+   for (i = map->coupling_steps-1; i >= 0; --i) {
+      int n2 = n >> 1;
+      float *m = f->channel_buffers[map->chan[i].magnitude];
+      float *a = f->channel_buffers[map->chan[i].angle    ];
+      for (j=0; j < n2; ++j) {
+         float a2,m2;
+         if (m[j] > 0)
+            if (a[j] > 0)
+               m2 = m[j], a2 = m[j] - a[j];
+            else
+               a2 = m[j], m2 = m[j] + a[j];
+         else
+            if (a[j] > 0)
+               m2 = m[j], a2 = m[j] + a[j];
+            else
+               a2 = m[j], m2 = m[j] - a[j];
+         m[j] = m2;
+         a[j] = a2;
+      }
+   }
+   CHECK(f);
+
+   // finish decoding the floors
+#ifndef STB_VORBIS_NO_DEFER_FLOOR
+   for (i=0; i < f->channels; ++i) {
+      if (really_zero_channel[i]) {
+         memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2);
+      } else {
+         do_floor(f, map, i, n, f->channel_buffers[i], f->finalY[i], NULL);
+      }
+   }
+#else
+   for (i=0; i < f->channels; ++i) {
+      if (really_zero_channel[i]) {
+         memset(f->channel_buffers[i], 0, sizeof(*f->channel_buffers[i]) * n2);
+      } else {
+         for (j=0; j < n2; ++j)
+            f->channel_buffers[i][j] *= f->floor_buffers[i][j];
+      }
+   }
+#endif
+
+// INVERSE MDCT
+   CHECK(f);
+   for (i=0; i < f->channels; ++i)
+      inverse_mdct(f->channel_buffers[i], n, f, m->blockflag);
+   CHECK(f);
+
+   // this shouldn't be necessary, unless we exited on an error
+   // and want to flush to get to the next packet
+   flush_packet(f);
+
+   if (f->first_decode) {
+      // assume we start so first non-discarded sample is sample 0
+      // this isn't to spec, but spec would require us to read ahead
+      // and decode the size of all current frames--could be done,
+      // but presumably it's not a commonly used feature
+      f->current_loc = 0u - n2; // start of first frame is positioned for discard (NB this is an intentional unsigned overflow/wrap-around)
+      // we might have to discard samples "from" the next frame too,
+      // if we're lapping a large block then a small at the start?
+      f->discard_samples_deferred = n - right_end;
+      f->current_loc_valid = TRUE;
+      f->first_decode = FALSE;
+   } else if (f->discard_samples_deferred) {
+      if (f->discard_samples_deferred >= right_start - left_start) {
+         f->discard_samples_deferred -= (right_start - left_start);
+         left_start = right_start;
+         *p_left = left_start;
+      } else {
+         left_start += f->discard_samples_deferred;
+         *p_left = left_start;
+         f->discard_samples_deferred = 0;
+      }
+   } else if (f->previous_length == 0 && f->current_loc_valid) {
+      // we're recovering from a seek... that means we're going to discard
+      // the samples from this packet even though we know our position from
+      // the last page header, so we need to update the position based on
+      // the discarded samples here
+      // but wait, the code below is going to add this in itself even
+      // on a discard, so we don't need to do it here...
+   }
+
+   // check if we have ogg information about the sample # for this packet
+   if (f->last_seg_which == f->end_seg_with_known_loc) {
+      // if we have a valid current loc, and this is final:
+      if (f->current_loc_valid && (f->page_flag & PAGEFLAG_last_page)) {
+         uint32 current_end = f->known_loc_for_packet;
+         // then let's infer the size of the (probably) short final frame
+         if (current_end < f->current_loc + (right_end-left_start)) {
+            if (current_end < f->current_loc) {
+               // negative truncation, that's impossible!
+               *len = 0;
+            } else {
+               *len = current_end - f->current_loc;
+            }
+            *len += left_start; // this doesn't seem right, but has no ill effect on my test files
+            if (*len > right_end) *len = right_end; // this should never happen
+            f->current_loc += *len;
+            return TRUE;
+         }
+      }
+      // otherwise, just set our sample loc
+      // guess that the ogg granule pos refers to the _middle_ of the
+      // last frame?
+      // set f->current_loc to the position of left_start
+      f->current_loc = f->known_loc_for_packet - (n2-left_start);
+      f->current_loc_valid = TRUE;
+   }
+   if (f->current_loc_valid)
+      f->current_loc += (right_start - left_start);
+
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+   *len = right_end;  // ignore samples after the window goes to 0
+   CHECK(f);
+
+   return TRUE;
+}
+
+static int vorbis_decode_packet(vorb *f, int *len, int *p_left, int *p_right)
+{
+   int mode, left_end, right_end;
+   if (!vorbis_decode_initial(f, p_left, &left_end, p_right, &right_end, &mode)) return 0;
+   return vorbis_decode_packet_rest(f, len, f->mode_config + mode, *p_left, left_end, *p_right, right_end, p_left);
+}
+
+static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right)
+{
+   int prev,i,j;
+   // we use right&left (the start of the right- and left-window sin()-regions)
+   // to determine how much to return, rather than inferring from the rules
+   // (same result, clearer code); 'left' indicates where our sin() window
+   // starts, therefore where the previous window's right edge starts, and
+   // therefore where to start mixing from the previous buffer. 'right'
+   // indicates where our sin() ending-window starts, therefore that's where
+   // we start saving, and where our returned-data ends.
+
+   // mixin from previous window
+   if (f->previous_length) {
+      int i,j, n = f->previous_length;
+      float *w = get_window(f, n);
+      if (w == NULL) return 0;
+      for (i=0; i < f->channels; ++i) {
+         for (j=0; j < n; ++j)
+            f->channel_buffers[i][left+j] =
+               f->channel_buffers[i][left+j]*w[    j] +
+               f->previous_window[i][     j]*w[n-1-j];
+      }
+   }
+
+   prev = f->previous_length;
+
+   // last half of this data becomes previous window
+   f->previous_length = len - right;
+
+   // @OPTIMIZE: could avoid this copy by double-buffering the
+   // output (flipping previous_window with channel_buffers), but
+   // then previous_window would have to be 2x as large, and
+   // channel_buffers couldn't be temp mem (although they're NOT
+   // currently temp mem, they could be (unless we want to level
+   // performance by spreading out the computation))
+   for (i=0; i < f->channels; ++i)
+      for (j=0; right+j < len; ++j)
+         f->previous_window[i][j] = f->channel_buffers[i][right+j];
+
+   if (!prev)
+      // there was no previous packet, so this data isn't valid...
+      // this isn't entirely true, only the would-have-overlapped data
+      // isn't valid, but this seems to be what the spec requires
+      return 0;
+
+   // truncate a short frame
+   if (len < right) right = len;
+
+   f->samples_output += right-left;
+
+   return right - left;
+}
+
+static int vorbis_pump_first_frame(stb_vorbis *f)
+{
+   int len, right, left, res;
+   res = vorbis_decode_packet(f, &len, &left, &right);
+   if (res)
+      vorbis_finish_frame(f, len, left, right);
+   return res;
+}
+
+#ifndef STB_VORBIS_NO_PUSHDATA_API
+static int is_whole_packet_present(stb_vorbis *f)
+{
+   // make sure that we have the packet available before continuing...
+   // this requires a full ogg parse, but we know we can fetch from f->stream
+
+   // instead of coding this out explicitly, we could save the current read state,
+   // read the next packet with get8() until end-of-packet, check f->eof, then
+   // reset the state? but that would be slower, esp. since we'd have over 256 bytes
+   // of state to restore (primarily the page segment table)
+
+   int s = f->next_seg, first = TRUE;
+   uint8 *p = f->stream;
+
+   if (s != -1) { // if we're not starting the packet with a 'continue on next page' flag
+      for (; s < f->segment_count; ++s) {
+         p += f->segments[s];
+         if (f->segments[s] < 255)               // stop at first short segment
+            break;
+      }
+      // either this continues, or it ends it...
+      if (s == f->segment_count)
+         s = -1; // set 'crosses page' flag
+      if (p > f->stream_end)                     return error(f, VORBIS_need_more_data);
+      first = FALSE;
+   }
+   for (; s == -1;) {
+      uint8 *q;
+      int n;
+
+      // check that we have the page header ready
+      if (p + 26 >= f->stream_end)               return error(f, VORBIS_need_more_data);
+      // validate the page
+      if (memcmp(p, ogg_page_header, 4))         return error(f, VORBIS_invalid_stream);
+      if (p[4] != 0)                             return error(f, VORBIS_invalid_stream);
+      if (first) { // the first segment must NOT have 'continued_packet', later ones MUST
+         if (f->previous_length)
+            if ((p[5] & PAGEFLAG_continued_packet))  return error(f, VORBIS_invalid_stream);
+         // if no previous length, we're resynching, so we can come in on a continued-packet,
+         // which we'll just drop
+      } else {
+         if (!(p[5] & PAGEFLAG_continued_packet)) return error(f, VORBIS_invalid_stream);
+      }
+      n = p[26]; // segment counts
+      q = p+27;  // q points to segment table
+      p = q + n; // advance past header
+      // make sure we've read the segment table
+      if (p > f->stream_end)                     return error(f, VORBIS_need_more_data);
+      for (s=0; s < n; ++s) {
+         p += q[s];
+         if (q[s] < 255)
+            break;
+      }
+      if (s == n)
+         s = -1; // set 'crosses page' flag
+      if (p > f->stream_end)                     return error(f, VORBIS_need_more_data);
+      first = FALSE;
+   }
+   return TRUE;
+}
+#endif // !STB_VORBIS_NO_PUSHDATA_API
+
+static int start_decoder(vorb *f)
+{
+   uint8 header[6], x,y;
+   int len,i,j,k, max_submaps = 0;
+   int longest_floorlist=0;
+
+   // first page, first packet
+   f->first_decode = TRUE;
+
+   if (!start_page(f))                              return FALSE;
+   // validate page flag
+   if (!(f->page_flag & PAGEFLAG_first_page))       return error(f, VORBIS_invalid_first_page);
+   if (f->page_flag & PAGEFLAG_last_page)           return error(f, VORBIS_invalid_first_page);
+   if (f->page_flag & PAGEFLAG_continued_packet)    return error(f, VORBIS_invalid_first_page);
+   // check for expected packet length
+   if (f->segment_count != 1)                       return error(f, VORBIS_invalid_first_page);
+   if (f->segments[0] != 30) {
+      // check for the Ogg skeleton fishead identifying header to refine our error
+      if (f->segments[0] == 64 &&
+          getn(f, header, 6) &&
+          header[0] == 'f' &&
+          header[1] == 'i' &&
+          header[2] == 's' &&
+          header[3] == 'h' &&
+          header[4] == 'e' &&
+          header[5] == 'a' &&
+          get8(f)   == 'd' &&
+          get8(f)   == '\0')                        return error(f, VORBIS_ogg_skeleton_not_supported);
+      else
+                                                    return error(f, VORBIS_invalid_first_page);
+   }
+
+   // read packet
+   // check packet header
+   if (get8(f) != VORBIS_packet_id)                 return error(f, VORBIS_invalid_first_page);
+   if (!getn(f, header, 6))                         return error(f, VORBIS_unexpected_eof);
+   if (!vorbis_validate(header))                    return error(f, VORBIS_invalid_first_page);
+   // vorbis_version
+   if (get32(f) != 0)                               return error(f, VORBIS_invalid_first_page);
+   f->channels = get8(f); if (!f->channels)         return error(f, VORBIS_invalid_first_page);
+   if (f->channels > STB_VORBIS_MAX_CHANNELS)       return error(f, VORBIS_too_many_channels);
+   f->sample_rate = get32(f); if (!f->sample_rate)  return error(f, VORBIS_invalid_first_page);
+   get32(f); // bitrate_maximum
+   get32(f); // bitrate_nominal
+   get32(f); // bitrate_minimum
+   x = get8(f);
+   {
+      int log0,log1;
+      log0 = x & 15;
+      log1 = x >> 4;
+      f->blocksize_0 = 1 << log0;
+      f->blocksize_1 = 1 << log1;
+      if (log0 < 6 || log0 > 13)                       return error(f, VORBIS_invalid_setup);
+      if (log1 < 6 || log1 > 13)                       return error(f, VORBIS_invalid_setup);
+      if (log0 > log1)                                 return error(f, VORBIS_invalid_setup);
+   }
+
+   // framing_flag
+   x = get8(f);
+   if (!(x & 1))                                    return error(f, VORBIS_invalid_first_page);
+
+   // second packet!
+   if (!start_page(f))                              return FALSE;
+
+   if (!start_packet(f))                            return FALSE;
+
+   if (!next_segment(f))                            return FALSE;
+
+   if (get8_packet(f) != VORBIS_packet_comment)            return error(f, VORBIS_invalid_setup);
+   for (i=0; i < 6; ++i) header[i] = get8_packet(f);
+   if (!vorbis_validate(header))                    return error(f, VORBIS_invalid_setup);
+   //file vendor
+   len = get32_packet(f);
+   f->vendor = (char*)setup_malloc(f, sizeof(char) * (len+1));
+   if (f->vendor == NULL)                           return error(f, VORBIS_outofmem);
+   for(i=0; i < len; ++i) {
+      f->vendor[i] = get8_packet(f);
+   }
+   f->vendor[len] = (char)'\0';
+   //user comments
+   f->comment_list_length = get32_packet(f);
+   f->comment_list = NULL;
+   if (f->comment_list_length > 0)
+   {
+      f->comment_list = (char**) setup_malloc(f, sizeof(char*) * (f->comment_list_length));
+      if (f->comment_list == NULL)                  return error(f, VORBIS_outofmem);
+   }
+
+   for(i=0; i < f->comment_list_length; ++i) {
+      len = get32_packet(f);
+      f->comment_list[i] = (char*)setup_malloc(f, sizeof(char) * (len+1));
+      if (f->comment_list[i] == NULL)               return error(f, VORBIS_outofmem);
+
+      for(j=0; j < len; ++j) {
+         f->comment_list[i][j] = get8_packet(f);
+      }
+      f->comment_list[i][len] = (char)'\0';
+   }
+
+   // framing_flag
+   x = get8_packet(f);
+   if (!(x & 1))                                    return error(f, VORBIS_invalid_setup);
+
+
+   skip(f, f->bytes_in_seg);
+   f->bytes_in_seg = 0;
+
+   do {
+      len = next_segment(f);
+      skip(f, len);
+      f->bytes_in_seg = 0;
+   } while (len);
+
+   // third packet!
+   if (!start_packet(f))                            return FALSE;
+
+   #ifndef STB_VORBIS_NO_PUSHDATA_API
+   if (IS_PUSH_MODE(f)) {
+      if (!is_whole_packet_present(f)) {
+         // convert error in ogg header to write type
+         if (f->error == VORBIS_invalid_stream)
+            f->error = VORBIS_invalid_setup;
+         return FALSE;
+      }
+   }
+   #endif
+
+   crc32_init(); // always init it, to avoid multithread race conditions
+
+   if (get8_packet(f) != VORBIS_packet_setup)       return error(f, VORBIS_invalid_setup);
+   for (i=0; i < 6; ++i) header[i] = get8_packet(f);
+   if (!vorbis_validate(header))                    return error(f, VORBIS_invalid_setup);
+
+   // codebooks
+
+   f->codebook_count = get_bits(f,8) + 1;
+   f->codebooks = (Codebook *) setup_malloc(f, sizeof(*f->codebooks) * f->codebook_count);
+   if (f->codebooks == NULL)                        return error(f, VORBIS_outofmem);
+   memset(f->codebooks, 0, sizeof(*f->codebooks) * f->codebook_count);
+   for (i=0; i < f->codebook_count; ++i) {
+      uint32 *values;
+      int ordered, sorted_count;
+      int total=0;
+      uint8 *lengths;
+      Codebook *c = f->codebooks+i;
+      CHECK(f);
+      x = get_bits(f, 8); if (x != 0x42)            return error(f, VORBIS_invalid_setup);
+      x = get_bits(f, 8); if (x != 0x43)            return error(f, VORBIS_invalid_setup);
+      x = get_bits(f, 8); if (x != 0x56)            return error(f, VORBIS_invalid_setup);
+      x = get_bits(f, 8);
+      c->dimensions = (get_bits(f, 8)<<8) + x;
+      x = get_bits(f, 8);
+      y = get_bits(f, 8);
+      c->entries = (get_bits(f, 8)<<16) + (y<<8) + x;
+      ordered = get_bits(f,1);
+      c->sparse = ordered ? 0 : get_bits(f,1);
+
+      if (c->dimensions == 0 && c->entries != 0)    return error(f, VORBIS_invalid_setup);
+
+      if (c->sparse)
+         lengths = (uint8 *) setup_temp_malloc(f, c->entries);
+      else
+         lengths = c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries);
+
+      if (!lengths) return error(f, VORBIS_outofmem);
+
+      if (ordered) {
+         int current_entry = 0;
+         int current_length = get_bits(f,5) + 1;
+         while (current_entry < c->entries) {
+            int limit = c->entries - current_entry;
+            int n = get_bits(f, ilog(limit));
+            if (current_length >= 32) return error(f, VORBIS_invalid_setup);
+            if (current_entry + n > (int) c->entries) { return error(f, VORBIS_invalid_setup); }
+            memset(lengths + current_entry, current_length, n);
+            current_entry += n;
+            ++current_length;
+         }
+      } else {
+         for (j=0; j < c->entries; ++j) {
+            int present = c->sparse ? get_bits(f,1) : 1;
+            if (present) {
+               lengths[j] = get_bits(f, 5) + 1;
+               ++total;
+               if (lengths[j] == 32)
+                  return error(f, VORBIS_invalid_setup);
+            } else {
+               lengths[j] = NO_CODE;
+            }
+         }
+      }
+
+      if (c->sparse && total >= c->entries >> 2) {
+         // convert sparse items to non-sparse!
+         if (c->entries > (int) f->setup_temp_memory_required)
+            f->setup_temp_memory_required = c->entries;
+
+         c->codeword_lengths = (uint8 *) setup_malloc(f, c->entries);
+         if (c->codeword_lengths == NULL) return error(f, VORBIS_outofmem);
+         memcpy(c->codeword_lengths, lengths, c->entries);
+         setup_temp_free(f, lengths, c->entries); // note this is only safe if there have been no intervening temp mallocs!
+         lengths = c->codeword_lengths;
+         c->sparse = 0;
+      }
+
+      // compute the size of the sorted tables
+      if (c->sparse) {
+         sorted_count = total;
+      } else {
+         sorted_count = 0;
+         #ifndef STB_VORBIS_NO_HUFFMAN_BINARY_SEARCH
+         for (j=0; j < c->entries; ++j)
+            if (lengths[j] > STB_VORBIS_FAST_HUFFMAN_LENGTH && lengths[j] != NO_CODE)
+               ++sorted_count;
+         #endif
+      }
+
+      c->sorted_entries = sorted_count;
+      values = NULL;
+
+      CHECK(f);
+      if (!c->sparse) {
+         c->codewords = (uint32 *) setup_malloc(f, sizeof(c->codewords[0]) * c->entries);
+         if (!c->codewords)                  return error(f, VORBIS_outofmem);
+      } else {
+         unsigned int size;
+         if (c->sorted_entries) {
+            c->codeword_lengths = (uint8 *) setup_malloc(f, c->sorted_entries);
+            if (!c->codeword_lengths)           return error(f, VORBIS_outofmem);
+            c->codewords = (uint32 *) setup_temp_malloc(f, sizeof(*c->codewords) * c->sorted_entries);
+            if (!c->codewords)                  return error(f, VORBIS_outofmem);
+            values = (uint32 *) setup_temp_malloc(f, sizeof(*values) * c->sorted_entries);
+            if (!values)                        return error(f, VORBIS_outofmem);
+         }
+         size = c->entries + (sizeof(*c->codewords) + sizeof(*values)) * c->sorted_entries;
+         if (size > f->setup_temp_memory_required)
+            f->setup_temp_memory_required = size;
+      }
+
+      if (!compute_codewords(c, lengths, c->entries, values)) {
+         if (c->sparse) setup_temp_free(f, values, 0);
+         return error(f, VORBIS_invalid_setup);
+      }
+
+      if (c->sorted_entries) {
+         // allocate an extra slot for sentinels
+         c->sorted_codewords = (uint32 *) setup_malloc(f, sizeof(*c->sorted_codewords) * (c->sorted_entries+1));
+         if (c->sorted_codewords == NULL) return error(f, VORBIS_outofmem);
+         // allocate an extra slot at the front so that c->sorted_values[-1] is defined
+         // so that we can catch that case without an extra if
+         c->sorted_values    = ( int   *) setup_malloc(f, sizeof(*c->sorted_values   ) * (c->sorted_entries+1));
+         if (c->sorted_values == NULL) return error(f, VORBIS_outofmem);
+         ++c->sorted_values;
+         c->sorted_values[-1] = -1;
+         compute_sorted_huffman(c, lengths, values);
+      }
+
+      if (c->sparse) {
+         setup_temp_free(f, values, sizeof(*values)*c->sorted_entries);
+         setup_temp_free(f, c->codewords, sizeof(*c->codewords)*c->sorted_entries);
+         setup_temp_free(f, lengths, c->entries);
+         c->codewords = NULL;
+      }
+
+      compute_accelerated_huffman(c);
+
+      CHECK(f);
+      c->lookup_type = get_bits(f, 4);
+      if (c->lookup_type > 2) return error(f, VORBIS_invalid_setup);
+      if (c->lookup_type > 0) {
+         uint16 *mults;
+         c->minimum_value = float32_unpack(get_bits(f, 32));
+         c->delta_value = float32_unpack(get_bits(f, 32));
+         c->value_bits = get_bits(f, 4)+1;
+         c->sequence_p = get_bits(f,1);
+         if (c->lookup_type == 1) {
+            int values = lookup1_values(c->entries, c->dimensions);
+            if (values < 0) return error(f, VORBIS_invalid_setup);
+            c->lookup_values = (uint32) values;
+         } else {
+            c->lookup_values = c->entries * c->dimensions;
+         }
+         if (c->lookup_values == 0) return error(f, VORBIS_invalid_setup);
+         mults = (uint16 *) setup_temp_malloc(f, sizeof(mults[0]) * c->lookup_values);
+         if (mults == NULL) return error(f, VORBIS_outofmem);
+         for (j=0; j < (int) c->lookup_values; ++j) {
+            int q = get_bits(f, c->value_bits);
+            if (q == EOP) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_invalid_setup); }
+            mults[j] = q;
+         }
+
+#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
+         if (c->lookup_type == 1) {
+            int len, sparse = c->sparse;
+            float last=0;
+            // pre-expand the lookup1-style multiplicands, to avoid a divide in the inner loop
+            if (sparse) {
+               if (c->sorted_entries == 0) goto skip;
+               c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->sorted_entries * c->dimensions);
+            } else
+               c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->entries        * c->dimensions);
+            if (c->multiplicands == NULL) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); }
+            len = sparse ? c->sorted_entries : c->entries;
+            for (j=0; j < len; ++j) {
+               unsigned int z = sparse ? c->sorted_values[j] : j;
+               unsigned int div=1;
+               for (k=0; k < c->dimensions; ++k) {
+                  int off = (z / div) % c->lookup_values;
+                  float val = mults[off]*c->delta_value + c->minimum_value + last;
+                  c->multiplicands[j*c->dimensions + k] = val;
+                  if (c->sequence_p)
+                     last = val;
+                  if (k+1 < c->dimensions) {
+                     if (div > UINT_MAX / (unsigned int) c->lookup_values) {
+                        setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values);
+                        return error(f, VORBIS_invalid_setup);
+                     }
+                     div *= c->lookup_values;
+                  }
+               }
+            }
+            c->lookup_type = 2;
+         }
+         else
+#endif
+         {
+            float last=0;
+            CHECK(f);
+            c->multiplicands = (codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->lookup_values);
+            if (c->multiplicands == NULL) { setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); }
+            for (j=0; j < (int) c->lookup_values; ++j) {
+               float val = mults[j] * c->delta_value + c->minimum_value + last;
+               c->multiplicands[j] = val;
+               if (c->sequence_p)
+                  last = val;
+            }
+         }
+#ifndef STB_VORBIS_DIVIDES_IN_CODEBOOK
+        skip:;
+#endif
+         setup_temp_free(f, mults, sizeof(mults[0])*c->lookup_values);
+
+         CHECK(f);
+      }
+      CHECK(f);
+   }
+
+   // time domain transfers (notused)
+
+   x = get_bits(f, 6) + 1;
+   for (i=0; i < x; ++i) {
+      uint32 z = get_bits(f, 16);
+      if (z != 0) return error(f, VORBIS_invalid_setup);
+   }
+
+   // Floors
+   f->floor_count = get_bits(f, 6)+1;
+   f->floor_config = (Floor *)  setup_malloc(f, f->floor_count * sizeof(*f->floor_config));
+   if (f->floor_config == NULL) return error(f, VORBIS_outofmem);
+   for (i=0; i < f->floor_count; ++i) {
+      f->floor_types[i] = get_bits(f, 16);
+      if (f->floor_types[i] > 1) return error(f, VORBIS_invalid_setup);
+      if (f->floor_types[i] == 0) {
+         Floor0 *g = &f->floor_config[i].floor0;
+         g->order = get_bits(f,8);
+         g->rate = get_bits(f,16);
+         g->bark_map_size = get_bits(f,16);
+         g->amplitude_bits = get_bits(f,6);
+         g->amplitude_offset = get_bits(f,8);
+         g->number_of_books = get_bits(f,4) + 1;
+         for (j=0; j < g->number_of_books; ++j)
+            g->book_list[j] = get_bits(f,8);
+         return error(f, VORBIS_feature_not_supported);
+      } else {
+         stbv__floor_ordering p[31*8+2];
+         Floor1 *g = &f->floor_config[i].floor1;
+         int max_class = -1;
+         g->partitions = get_bits(f, 5);
+         for (j=0; j < g->partitions; ++j) {
+            g->partition_class_list[j] = get_bits(f, 4);
+            if (g->partition_class_list[j] > max_class)
+               max_class = g->partition_class_list[j];
+         }
+         for (j=0; j <= max_class; ++j) {
+            g->class_dimensions[j] = get_bits(f, 3)+1;
+            g->class_subclasses[j] = get_bits(f, 2);
+            if (g->class_subclasses[j]) {
+               g->class_masterbooks[j] = get_bits(f, 8);
+               if (g->class_masterbooks[j] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
+            }
+            for (k=0; k < 1 << g->class_subclasses[j]; ++k) {
+               g->subclass_books[j][k] = (int16)get_bits(f,8)-1;
+               if (g->subclass_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
+            }
+         }
+         g->floor1_multiplier = get_bits(f,2)+1;
+         g->rangebits = get_bits(f,4);
+         g->Xlist[0] = 0;
+         g->Xlist[1] = 1 << g->rangebits;
+         g->values = 2;
+         for (j=0; j < g->partitions; ++j) {
+            int c = g->partition_class_list[j];
+            for (k=0; k < g->class_dimensions[c]; ++k) {
+               g->Xlist[g->values] = get_bits(f, g->rangebits);
+               ++g->values;
+            }
+         }
+         // precompute the sorting
+         for (j=0; j < g->values; ++j) {
+            p[j].x = g->Xlist[j];
+            p[j].id = j;
+         }
+         qsort(p, g->values, sizeof(p[0]), point_compare);
+         for (j=0; j < g->values-1; ++j)
+            if (p[j].x == p[j+1].x)
+               return error(f, VORBIS_invalid_setup);
+         for (j=0; j < g->values; ++j)
+            g->sorted_order[j] = (uint8) p[j].id;
+         // precompute the neighbors
+         for (j=2; j < g->values; ++j) {
+            int low = 0,hi = 0;
+            neighbors(g->Xlist, j, &low,&hi);
+            g->neighbors[j][0] = low;
+            g->neighbors[j][1] = hi;
+         }
+
+         if (g->values > longest_floorlist)
+            longest_floorlist = g->values;
+      }
+   }
+
+   // Residue
+   f->residue_count = get_bits(f, 6)+1;
+   f->residue_config = (Residue *) setup_malloc(f, f->residue_count * sizeof(f->residue_config[0]));
+   if (f->residue_config == NULL) return error(f, VORBIS_outofmem);
+   memset(f->residue_config, 0, f->residue_count * sizeof(f->residue_config[0]));
+   for (i=0; i < f->residue_count; ++i) {
+      uint8 residue_cascade[64];
+      Residue *r = f->residue_config+i;
+      f->residue_types[i] = get_bits(f, 16);
+      if (f->residue_types[i] > 2) return error(f, VORBIS_invalid_setup);
+      r->begin = get_bits(f, 24);
+      r->end = get_bits(f, 24);
+      if (r->end < r->begin) return error(f, VORBIS_invalid_setup);
+      r->part_size = get_bits(f,24)+1;
+      r->classifications = get_bits(f,6)+1;
+      r->classbook = get_bits(f,8);
+      if (r->classbook >= f->codebook_count) return error(f, VORBIS_invalid_setup);
+      for (j=0; j < r->classifications; ++j) {
+         uint8 high_bits=0;
+         uint8 low_bits=get_bits(f,3);
+         if (get_bits(f,1))
+            high_bits = get_bits(f,5);
+         residue_cascade[j] = high_bits*8 + low_bits;
+      }
+      r->residue_books = (short (*)[8]) setup_malloc(f, sizeof(r->residue_books[0]) * r->classifications);
+      if (r->residue_books == NULL) return error(f, VORBIS_outofmem);
+      for (j=0; j < r->classifications; ++j) {
+         for (k=0; k < 8; ++k) {
+            if (residue_cascade[j] & (1 << k)) {
+               r->residue_books[j][k] = get_bits(f, 8);
+               if (r->residue_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
+            } else {
+               r->residue_books[j][k] = -1;
+            }
+         }
+      }
+      // precompute the classifications[] array to avoid inner-loop mod/divide
+      // call it 'classdata' since we already have r->classifications
+      r->classdata = (uint8 **) setup_malloc(f, sizeof(*r->classdata) * f->codebooks[r->classbook].entries);
+      if (!r->classdata) return error(f, VORBIS_outofmem);
+      memset(r->classdata, 0, sizeof(*r->classdata) * f->codebooks[r->classbook].entries);
+      for (j=0; j < f->codebooks[r->classbook].entries; ++j) {
+         int classwords = f->codebooks[r->classbook].dimensions;
+         int temp = j;
+         r->classdata[j] = (uint8 *) setup_malloc(f, sizeof(r->classdata[j][0]) * classwords);
+         if (r->classdata[j] == NULL) return error(f, VORBIS_outofmem);
+         for (k=classwords-1; k >= 0; --k) {
+            r->classdata[j][k] = temp % r->classifications;
+            temp /= r->classifications;
+         }
+      }
+   }
+
+   f->mapping_count = get_bits(f,6)+1;
+   f->mapping = (Mapping *) setup_malloc(f, f->mapping_count * sizeof(*f->mapping));
+   if (f->mapping == NULL) return error(f, VORBIS_outofmem);
+   memset(f->mapping, 0, f->mapping_count * sizeof(*f->mapping));
+   for (i=0; i < f->mapping_count; ++i) {
+      Mapping *m = f->mapping + i;
+      int mapping_type = get_bits(f,16);
+      if (mapping_type != 0) return error(f, VORBIS_invalid_setup);
+      m->chan = (MappingChannel *) setup_malloc(f, f->channels * sizeof(*m->chan));
+      if (m->chan == NULL) return error(f, VORBIS_outofmem);
+      if (get_bits(f,1))
+         m->submaps = get_bits(f,4)+1;
+      else
+         m->submaps = 1;
+      if (m->submaps > max_submaps)
+         max_submaps = m->submaps;
+      if (get_bits(f,1)) {
+         m->coupling_steps = get_bits(f,8)+1;
+         if (m->coupling_steps > f->channels) return error(f, VORBIS_invalid_setup);
+         for (k=0; k < m->coupling_steps; ++k) {
+            m->chan[k].magnitude = get_bits(f, ilog(f->channels-1));
+            m->chan[k].angle = get_bits(f, ilog(f->channels-1));
+            if (m->chan[k].magnitude >= f->channels)        return error(f, VORBIS_invalid_setup);
+            if (m->chan[k].angle     >= f->channels)        return error(f, VORBIS_invalid_setup);
+            if (m->chan[k].magnitude == m->chan[k].angle)   return error(f, VORBIS_invalid_setup);
+         }
+      } else
+         m->coupling_steps = 0;
+
+      // reserved field
+      if (get_bits(f,2)) return error(f, VORBIS_invalid_setup);
+      if (m->submaps > 1) {
+         for (j=0; j < f->channels; ++j) {
+            m->chan[j].mux = get_bits(f, 4);
+            if (m->chan[j].mux >= m->submaps)                return error(f, VORBIS_invalid_setup);
+         }
+      } else
+         // @SPECIFICATION: this case is missing from the spec
+         for (j=0; j < f->channels; ++j)
+            m->chan[j].mux = 0;
+
+      for (j=0; j < m->submaps; ++j) {
+         get_bits(f,8); // discard
+         m->submap_floor[j] = get_bits(f,8);
+         m->submap_residue[j] = get_bits(f,8);
+         if (m->submap_floor[j] >= f->floor_count)      return error(f, VORBIS_invalid_setup);
+         if (m->submap_residue[j] >= f->residue_count)  return error(f, VORBIS_invalid_setup);
+      }
+   }
+
+   // Modes
+   f->mode_count = get_bits(f, 6)+1;
+   for (i=0; i < f->mode_count; ++i) {
+      Mode *m = f->mode_config+i;
+      m->blockflag = get_bits(f,1);
+      m->windowtype = get_bits(f,16);
+      m->transformtype = get_bits(f,16);
+      m->mapping = get_bits(f,8);
+      if (m->windowtype != 0)                 return error(f, VORBIS_invalid_setup);
+      if (m->transformtype != 0)              return error(f, VORBIS_invalid_setup);
+      if (m->mapping >= f->mapping_count)     return error(f, VORBIS_invalid_setup);
+   }
+
+   flush_packet(f);
+
+   f->previous_length = 0;
+
+   for (i=0; i < f->channels; ++i) {
+      f->channel_buffers[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1);
+      f->previous_window[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2);
+      f->finalY[i]          = (int16 *) setup_malloc(f, sizeof(int16) * longest_floorlist);
+      if (f->channel_buffers[i] == NULL || f->previous_window[i] == NULL || f->finalY[i] == NULL) return error(f, VORBIS_outofmem);
+      memset(f->channel_buffers[i], 0, sizeof(float) * f->blocksize_1);
+      #ifdef STB_VORBIS_NO_DEFER_FLOOR
+      f->floor_buffers[i]   = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2);
+      if (f->floor_buffers[i] == NULL) return error(f, VORBIS_outofmem);
+      #endif
+   }
+
+   if (!init_blocksize(f, 0, f->blocksize_0)) return FALSE;
+   if (!init_blocksize(f, 1, f->blocksize_1)) return FALSE;
+   f->blocksize[0] = f->blocksize_0;
+   f->blocksize[1] = f->blocksize_1;
+
+#ifdef STB_VORBIS_DIVIDE_TABLE
+   if (integer_divide_table[1][1]==0)
+      for (i=0; i < DIVTAB_NUMER; ++i)
+         for (j=1; j < DIVTAB_DENOM; ++j)
+            integer_divide_table[i][j] = i / j;
+#endif
+
+   // compute how much temporary memory is needed
+
+   // 1.
+   {
+      uint32 imdct_mem = (f->blocksize_1 * sizeof(float) >> 1);
+      uint32 classify_mem;
+      int i,max_part_read=0;
+      for (i=0; i < f->residue_count; ++i) {
+         Residue *r = f->residue_config + i;
+         unsigned int actual_size = f->blocksize_1 / 2;
+         unsigned int limit_r_begin = r->begin < actual_size ? r->begin : actual_size;
+         unsigned int limit_r_end   = r->end   < actual_size ? r->end   : actual_size;
+         int n_read = limit_r_end - limit_r_begin;
+         int part_read = n_read / r->part_size;
+         if (part_read > max_part_read)
+            max_part_read = part_read;
+      }
+      #ifndef STB_VORBIS_DIVIDES_IN_RESIDUE
+      classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(uint8 *));
+      #else
+      classify_mem = f->channels * (sizeof(void*) + max_part_read * sizeof(int *));
+      #endif
+
+      // maximum reasonable partition size is f->blocksize_1
+
+      f->temp_memory_required = classify_mem;
+      if (imdct_mem > f->temp_memory_required)
+         f->temp_memory_required = imdct_mem;
+   }
+
+
+   if (f->alloc.alloc_buffer) {
+      assert(f->temp_offset == f->alloc.alloc_buffer_length_in_bytes);
+      // check if there's enough temp memory so we don't error later
+      if (f->setup_offset + sizeof(*f) + f->temp_memory_required > (unsigned) f->temp_offset)
+         return error(f, VORBIS_outofmem);
+   }
+
+   // @TODO: stb_vorbis_seek_start expects first_audio_page_offset to point to a page
+   // without PAGEFLAG_continued_packet, so this either points to the first page, or
+   // the page after the end of the headers. It might be cleaner to point to a page
+   // in the middle of the headers, when that's the page where the first audio packet
+   // starts, but we'd have to also correctly skip the end of any continued packet in
+   // stb_vorbis_seek_start.
+   if (f->next_seg == -1) {
+      f->first_audio_page_offset = stb_vorbis_get_file_offset(f);
+   } else {
+      f->first_audio_page_offset = 0;
+   }
+
+   return TRUE;
+}
+
+static void vorbis_deinit(stb_vorbis *p)
+{
+   int i,j;
+
+   setup_free(p, p->vendor);
+   for (i=0; i < p->comment_list_length; ++i) {
+      setup_free(p, p->comment_list[i]);
+   }
+   setup_free(p, p->comment_list);
+
+   if (p->residue_config) {
+      for (i=0; i < p->residue_count; ++i) {
+         Residue *r = p->residue_config+i;
+         if (r->classdata) {
+            for (j=0; j < p->codebooks[r->classbook].entries; ++j)
+               setup_free(p, r->classdata[j]);
+            setup_free(p, r->classdata);
+         }
+         setup_free(p, r->residue_books);
+      }
+   }
+
+   if (p->codebooks) {
+      CHECK(p);
+      for (i=0; i < p->codebook_count; ++i) {
+         Codebook *c = p->codebooks + i;
+         setup_free(p, c->codeword_lengths);
+         setup_free(p, c->multiplicands);
+         setup_free(p, c->codewords);
+         setup_free(p, c->sorted_codewords);
+         // c->sorted_values[-1] is the first entry in the array
+         setup_free(p, c->sorted_values ? c->sorted_values-1 : NULL);
+      }
+      setup_free(p, p->codebooks);
+   }
+   setup_free(p, p->floor_config);
+   setup_free(p, p->residue_config);
+   if (p->mapping) {
+      for (i=0; i < p->mapping_count; ++i)
+         setup_free(p, p->mapping[i].chan);
+      setup_free(p, p->mapping);
+   }
+   CHECK(p);
+   for (i=0; i < p->channels && i < STB_VORBIS_MAX_CHANNELS; ++i) {
+      setup_free(p, p->channel_buffers[i]);
+      setup_free(p, p->previous_window[i]);
+      #ifdef STB_VORBIS_NO_DEFER_FLOOR
+      setup_free(p, p->floor_buffers[i]);
+      #endif
+      setup_free(p, p->finalY[i]);
+   }
+   for (i=0; i < 2; ++i) {
+      setup_free(p, p->A[i]);
+      setup_free(p, p->B[i]);
+      setup_free(p, p->C[i]);
+      setup_free(p, p->window[i]);
+      setup_free(p, p->bit_reverse[i]);
+   }
+   #ifndef STB_VORBIS_NO_STDIO
+   if (p->close_on_free) fclose(p->f);
+   #endif
+}
+
+void stb_vorbis_close(stb_vorbis *p)
+{
+   if (p == NULL) return;
+   vorbis_deinit(p);
+   setup_free(p,p);
+}
+
+static void vorbis_init(stb_vorbis *p, const stb_vorbis_alloc *z)
+{
+   memset(p, 0, sizeof(*p)); // NULL out all malloc'd pointers to start
+   if (z) {
+      p->alloc = *z;
+      p->alloc.alloc_buffer_length_in_bytes &= ~7;
+      p->temp_offset = p->alloc.alloc_buffer_length_in_bytes;
+   }
+   p->eof = 0;
+   p->error = VORBIS__no_error;
+   p->stream = NULL;
+   p->codebooks = NULL;
+   p->page_crc_tests = -1;
+   #ifndef STB_VORBIS_NO_STDIO
+   p->close_on_free = FALSE;
+   p->f = NULL;
+   #endif
+}
+
+int stb_vorbis_get_sample_offset(stb_vorbis *f)
+{
+   if (f->current_loc_valid)
+      return f->current_loc;
+   else
+      return -1;
+}
+
+stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f)
+{
+   stb_vorbis_info d;
+   d.channels = f->channels;
+   d.sample_rate = f->sample_rate;
+   d.setup_memory_required = f->setup_memory_required;
+   d.setup_temp_memory_required = f->setup_temp_memory_required;
+   d.temp_memory_required = f->temp_memory_required;
+   d.max_frame_size = f->blocksize_1 >> 1;
+   return d;
+}
+
+stb_vorbis_comment stb_vorbis_get_comment(stb_vorbis *f)
+{
+   stb_vorbis_comment d;
+   d.vendor = f->vendor;
+   d.comment_list_length = f->comment_list_length;
+   d.comment_list = f->comment_list;
+   return d;
+}
+
+int stb_vorbis_get_error(stb_vorbis *f)
+{
+   int e = f->error;
+   f->error = VORBIS__no_error;
+   return e;
+}
+
+static stb_vorbis * vorbis_alloc(stb_vorbis *f)
+{
+   stb_vorbis *p = (stb_vorbis *) setup_malloc(f, sizeof(*p));
+   return p;
+}
+
+#ifndef STB_VORBIS_NO_PUSHDATA_API
+
+void stb_vorbis_flush_pushdata(stb_vorbis *f)
+{
+   f->previous_length = 0;
+   f->page_crc_tests  = 0;
+   f->discard_samples_deferred = 0;
+   f->current_loc_valid = FALSE;
+   f->first_decode = FALSE;
+   f->samples_output = 0;
+   f->channel_buffer_start = 0;
+   f->channel_buffer_end = 0;
+}
+
+static int vorbis_search_for_page_pushdata(vorb *f, uint8 *data, int data_len)
+{
+   int i,n;
+   for (i=0; i < f->page_crc_tests; ++i)
+      f->scan[i].bytes_done = 0;
+
+   // if we have room for more scans, search for them first, because
+   // they may cause us to stop early if their header is incomplete
+   if (f->page_crc_tests < STB_VORBIS_PUSHDATA_CRC_COUNT) {
+      if (data_len < 4) return 0;
+      data_len -= 3; // need to look for 4-byte sequence, so don't miss
+                     // one that straddles a boundary
+      for (i=0; i < data_len; ++i) {
+         if (data[i] == 0x4f) {
+            if (0==memcmp(data+i, ogg_page_header, 4)) {
+               int j,len;
+               uint32 crc;
+               // make sure we have the whole page header
+               if (i+26 >= data_len || i+27+data[i+26] >= data_len) {
+                  // only read up to this page start, so hopefully we'll
+                  // have the whole page header start next time
+                  data_len = i;
+                  break;
+               }
+               // ok, we have it all; compute the length of the page
+               len = 27 + data[i+26];
+               for (j=0; j < data[i+26]; ++j)
+                  len += data[i+27+j];
+               // scan everything up to the embedded crc (which we must 0)
+               crc = 0;
+               for (j=0; j < 22; ++j)
+                  crc = crc32_update(crc, data[i+j]);
+               // now process 4 0-bytes
+               for (   ; j < 26; ++j)
+                  crc = crc32_update(crc, 0);
+               // len is the total number of bytes we need to scan
+               n = f->page_crc_tests++;
+               f->scan[n].bytes_left = len-j;
+               f->scan[n].crc_so_far = crc;
+               f->scan[n].goal_crc = data[i+22] + (data[i+23] << 8) + (data[i+24]<<16) + (data[i+25]<<24);
+               // if the last frame on a page is continued to the next, then
+               // we can't recover the sample_loc immediately
+               if (data[i+27+data[i+26]-1] == 255)
+                  f->scan[n].sample_loc = ~0;
+               else
+                  f->scan[n].sample_loc = data[i+6] + (data[i+7] << 8) + (data[i+ 8]<<16) + (data[i+ 9]<<24);
+               f->scan[n].bytes_done = i+j;
+               if (f->page_crc_tests == STB_VORBIS_PUSHDATA_CRC_COUNT)
+                  break;
+               // keep going if we still have room for more
+            }
+         }
+      }
+   }
+
+   for (i=0; i < f->page_crc_tests;) {
+      uint32 crc;
+      int j;
+      int n = f->scan[i].bytes_done;
+      int m = f->scan[i].bytes_left;
+      if (m > data_len - n) m = data_len - n;
+      // m is the bytes to scan in the current chunk
+      crc = f->scan[i].crc_so_far;
+      for (j=0; j < m; ++j)
+         crc = crc32_update(crc, data[n+j]);
+      f->scan[i].bytes_left -= m;
+      f->scan[i].crc_so_far = crc;
+      if (f->scan[i].bytes_left == 0) {
+         // does it match?
+         if (f->scan[i].crc_so_far == f->scan[i].goal_crc) {
+            // Houston, we have page
+            data_len = n+m; // consumption amount is wherever that scan ended
+            f->page_crc_tests = -1; // drop out of page scan mode
+            f->previous_length = 0; // decode-but-don't-output one frame
+            f->next_seg = -1;       // start a new page
+            f->current_loc = f->scan[i].sample_loc; // set the current sample location
+                                    // to the amount we'd have decoded had we decoded this page
+            f->current_loc_valid = f->current_loc != ~0U;
+            return data_len;
+         }
+         // delete entry
+         f->scan[i] = f->scan[--f->page_crc_tests];
+      } else {
+         ++i;
+      }
+   }
+
+   return data_len;
+}
+
+// return value: number of bytes we used
+int stb_vorbis_decode_frame_pushdata(
+         stb_vorbis *f,                   // the file we're decoding
+         const uint8 *data, int data_len, // the memory available for decoding
+         int *channels,                   // place to write number of float * buffers
+         float ***output,                 // place to write float ** array of float * buffers
+         int *samples                     // place to write number of output samples
+     )
+{
+   int i;
+   int len,right,left;
+
+   if (!IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
+
+   if (f->page_crc_tests >= 0) {
+      *samples = 0;
+      return vorbis_search_for_page_pushdata(f, (uint8 *) data, data_len);
+   }
+
+   f->stream     = (uint8 *) data;
+   f->stream_end = (uint8 *) data + data_len;
+   f->error      = VORBIS__no_error;
+
+   // check that we have the entire packet in memory
+   if (!is_whole_packet_present(f)) {
+      *samples = 0;
+      return 0;
+   }
+
+   if (!vorbis_decode_packet(f, &len, &left, &right)) {
+      // save the actual error we encountered
+      enum STBVorbisError error = f->error;
+      if (error == VORBIS_bad_packet_type) {
+         // flush and resynch
+         f->error = VORBIS__no_error;
+         while (get8_packet(f) != EOP)
+            if (f->eof) break;
+         *samples = 0;
+         return (int) (f->stream - data);
+      }
+      if (error == VORBIS_continued_packet_flag_invalid) {
+         if (f->previous_length == 0) {
+            // we may be resynching, in which case it's ok to hit one
+            // of these; just discard the packet
+            f->error = VORBIS__no_error;
+            while (get8_packet(f) != EOP)
+               if (f->eof) break;
+            *samples = 0;
+            return (int) (f->stream - data);
+         }
+      }
+      // if we get an error while parsing, what to do?
+      // well, it DEFINITELY won't work to continue from where we are!
+      stb_vorbis_flush_pushdata(f);
+      // restore the error that actually made us bail
+      f->error = error;
+      *samples = 0;
+      return 1;
+   }
+
+   // success!
+   len = vorbis_finish_frame(f, len, left, right);
+   for (i=0; i < f->channels; ++i)
+      f->outputs[i] = f->channel_buffers[i] + left;
+
+   if (channels) *channels = f->channels;
+   *samples = len;
+   *output = f->outputs;
+   return (int) (f->stream - data);
+}
+
+stb_vorbis *stb_vorbis_open_pushdata(
+         const unsigned char *data, int data_len, // the memory available for decoding
+         int *data_used,              // only defined if result is not NULL
+         int *error, const stb_vorbis_alloc *alloc)
+{
+   stb_vorbis *f, p;
+   vorbis_init(&p, alloc);
+   p.stream     = (uint8 *) data;
+   p.stream_end = (uint8 *) data + data_len;
+   p.push_mode  = TRUE;
+   if (!start_decoder(&p)) {
+      if (p.eof)
+         *error = VORBIS_need_more_data;
+      else
+         *error = p.error;
+      vorbis_deinit(&p);
+      return NULL;
+   }
+   f = vorbis_alloc(&p);
+   if (f) {
+      *f = p;
+      *data_used = (int) (f->stream - data);
+      *error = 0;
+      return f;
+   } else {
+      vorbis_deinit(&p);
+      return NULL;
+   }
+}
+#endif // STB_VORBIS_NO_PUSHDATA_API
+
+unsigned int stb_vorbis_get_file_offset(stb_vorbis *f)
+{
+   #ifndef STB_VORBIS_NO_PUSHDATA_API
+   if (f->push_mode) return 0;
+   #endif
+   if (USE_MEMORY(f)) return (unsigned int) (f->stream - f->stream_start);
+   #ifndef STB_VORBIS_NO_STDIO
+   return (unsigned int) (ftell(f->f) - f->f_start);
+   #endif
+}
+
+#ifndef STB_VORBIS_NO_PULLDATA_API
+//
+// DATA-PULLING API
+//
+
+static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last)
+{
+   for(;;) {
+      int n;
+      if (f->eof) return 0;
+      n = get8(f);
+      if (n == 0x4f) { // page header candidate
+         unsigned int retry_loc = stb_vorbis_get_file_offset(f);
+         int i;
+         // check if we're off the end of a file_section stream
+         if (retry_loc - 25 > f->stream_len)
+            return 0;
+         // check the rest of the header
+         for (i=1; i < 4; ++i)
+            if (get8(f) != ogg_page_header[i])
+               break;
+         if (f->eof) return 0;
+         if (i == 4) {
+            uint8 header[27];
+            uint32 i, crc, goal, len;
+            for (i=0; i < 4; ++i)
+               header[i] = ogg_page_header[i];
+            for (; i < 27; ++i)
+               header[i] = get8(f);
+            if (f->eof) return 0;
+            if (header[4] != 0) goto invalid;
+            goal = header[22] + (header[23] << 8) + (header[24]<<16) + ((uint32)header[25]<<24);
+            for (i=22; i < 26; ++i)
+               header[i] = 0;
+            crc = 0;
+            for (i=0; i < 27; ++i)
+               crc = crc32_update(crc, header[i]);
+            len = 0;
+            for (i=0; i < header[26]; ++i) {
+               int s = get8(f);
+               crc = crc32_update(crc, s);
+               len += s;
+            }
+            if (len && f->eof) return 0;
+            for (i=0; i < len; ++i)
+               crc = crc32_update(crc, get8(f));
+            // finished parsing probable page
+            if (crc == goal) {
+               // we could now check that it's either got the last
+               // page flag set, OR it's followed by the capture
+               // pattern, but I guess TECHNICALLY you could have
+               // a file with garbage between each ogg page and recover
+               // from it automatically? So even though that paranoia
+               // might decrease the chance of an invalid decode by
+               // another 2^32, not worth it since it would hose those
+               // invalid-but-useful files?
+               if (end)
+                  *end = stb_vorbis_get_file_offset(f);
+               if (last) {
+                  if (header[5] & 0x04)
+                     *last = 1;
+                  else
+                     *last = 0;
+               }
+               set_file_offset(f, retry_loc-1);
+               return 1;
+            }
+         }
+        invalid:
+         // not a valid page, so rewind and look for next one
+         set_file_offset(f, retry_loc);
+      }
+   }
+}
+
+
+#define SAMPLE_unknown  0xffffffff
+
+// seeking is implemented with a binary search, which narrows down the range to
+// 64K, before using a linear search (because finding the synchronization
+// pattern can be expensive, and the chance we'd find the end page again is
+// relatively high for small ranges)
+//
+// two initial interpolation-style probes are used at the start of the search
+// to try to bound either side of the binary search sensibly, while still
+// working in O(log n) time if they fail.
+
+static int get_seek_page_info(stb_vorbis *f, ProbedPage *z)
+{
+   uint8 header[27], lacing[255];
+   int i,len;
+
+   // record where the page starts
+   z->page_start = stb_vorbis_get_file_offset(f);
+
+   // parse the header
+   getn(f, header, 27);
+   if (header[0] != 'O' || header[1] != 'g' || header[2] != 'g' || header[3] != 'S')
+      return 0;
+   getn(f, lacing, header[26]);
+
+   // determine the length of the payload
+   len = 0;
+   for (i=0; i < header[26]; ++i)
+      len += lacing[i];
+
+   // this implies where the page ends
+   z->page_end = z->page_start + 27 + header[26] + len;
+
+   // read the last-decoded sample out of the data
+   z->last_decoded_sample = header[6] + (header[7] << 8) + (header[8] << 16) + (header[9] << 24);
+
+   // restore file state to where we were
+   set_file_offset(f, z->page_start);
+   return 1;
+}
+
+// rarely used function to seek back to the preceding page while finding the
+// start of a packet
+static int go_to_page_before(stb_vorbis *f, unsigned int limit_offset)
+{
+   unsigned int previous_safe, end;
+
+   // now we want to seek back 64K from the limit
+   if (limit_offset >= 65536 && limit_offset-65536 >= f->first_audio_page_offset)
+      previous_safe = limit_offset - 65536;
+   else
+      previous_safe = f->first_audio_page_offset;
+
+   set_file_offset(f, previous_safe);
+
+   while (vorbis_find_page(f, &end, NULL)) {
+      if (end >= limit_offset && stb_vorbis_get_file_offset(f) < limit_offset)
+         return 1;
+      set_file_offset(f, end);
+   }
+
+   return 0;
+}
+
+// implements the search logic for finding a page and starting decoding. if
+// the function succeeds, current_loc_valid will be true and current_loc will
+// be less than or equal to the provided sample number (the closer the
+// better).
+static int seek_to_sample_coarse(stb_vorbis *f, uint32 sample_number)
+{
+   ProbedPage left, right, mid;
+   int i, start_seg_with_known_loc, end_pos, page_start;
+   uint32 delta, stream_length, padding, last_sample_limit;
+   double offset = 0.0, bytes_per_sample = 0.0;
+   int probe = 0;
+
+   // find the last page and validate the target sample
+   stream_length = stb_vorbis_stream_length_in_samples(f);
+   if (stream_length == 0)            return error(f, VORBIS_seek_without_length);
+   if (sample_number > stream_length) return error(f, VORBIS_seek_invalid);
+
+   // this is the maximum difference between the window-center (which is the
+   // actual granule position value), and the right-start (which the spec
+   // indicates should be the granule position (give or take one)).
+   padding = ((f->blocksize_1 - f->blocksize_0) >> 2);
+   if (sample_number < padding)
+      last_sample_limit = 0;
+   else
+      last_sample_limit = sample_number - padding;
+
+   left = f->p_first;
+   while (left.last_decoded_sample == ~0U) {
+      // (untested) the first page does not have a 'last_decoded_sample'
+      set_file_offset(f, left.page_end);
+      if (!get_seek_page_info(f, &left)) goto error;
+   }
+
+   right = f->p_last;
+   assert(right.last_decoded_sample != ~0U);
+
+   // starting from the start is handled differently
+   if (last_sample_limit <= left.last_decoded_sample) {
+      if (stb_vorbis_seek_start(f)) {
+         if (f->current_loc > sample_number)
+            return error(f, VORBIS_seek_failed);
+         return 1;
+      }
+      return 0;
+   }
+
+   while (left.page_end != right.page_start) {
+      assert(left.page_end < right.page_start);
+      // search range in bytes
+      delta = right.page_start - left.page_end;
+      if (delta <= 65536) {
+         // there's only 64K left to search - handle it linearly
+         set_file_offset(f, left.page_end);
+      } else {
+         if (probe < 2) {
+            if (probe == 0) {
+               // first probe (interpolate)
+               double data_bytes = right.page_end - left.page_start;
+               bytes_per_sample = data_bytes / right.last_decoded_sample;
+               offset = left.page_start + bytes_per_sample * (last_sample_limit - left.last_decoded_sample);
+            } else {
+               // second probe (try to bound the other side)
+               double error = ((double) last_sample_limit - mid.last_decoded_sample) * bytes_per_sample;
+               if (error >= 0 && error <  8000) error =  8000;
+               if (error <  0 && error > -8000) error = -8000;
+               offset += error * 2;
+            }
+
+            // ensure the offset is valid
+            if (offset < left.page_end)
+               offset = left.page_end;
+            if (offset > right.page_start - 65536)
+               offset = right.page_start - 65536;
+
+            set_file_offset(f, (unsigned int) offset);
+         } else {
+            // binary search for large ranges (offset by 32K to ensure
+            // we don't hit the right page)
+            set_file_offset(f, left.page_end + (delta / 2) - 32768);
+         }
+
+         if (!vorbis_find_page(f, NULL, NULL)) goto error;
+      }
+
+      for (;;) {
+         if (!get_seek_page_info(f, &mid)) goto error;
+         if (mid.last_decoded_sample != ~0U) break;
+         // (untested) no frames end on this page
+         set_file_offset(f, mid.page_end);
+         assert(mid.page_start < right.page_start);
+      }
+
+      // if we've just found the last page again then we're in a tricky file,
+      // and we're close enough (if it wasn't an interpolation probe).
+      if (mid.page_start == right.page_start) {
+         if (probe >= 2 || delta <= 65536)
+            break;
+      } else {
+         if (last_sample_limit < mid.last_decoded_sample)
+            right = mid;
+         else
+            left = mid;
+      }
+
+      ++probe;
+   }
+
+   // seek back to start of the last packet
+   page_start = left.page_start;
+   set_file_offset(f, page_start);
+   if (!start_page(f)) return error(f, VORBIS_seek_failed);
+   end_pos = f->end_seg_with_known_loc;
+   assert(end_pos >= 0);
+
+   for (;;) {
+      for (i = end_pos; i > 0; --i)
+         if (f->segments[i-1] != 255)
+            break;
+
+      start_seg_with_known_loc = i;
+
+      if (start_seg_with_known_loc > 0 || !(f->page_flag & PAGEFLAG_continued_packet))
+         break;
+
+      // (untested) the final packet begins on an earlier page
+      if (!go_to_page_before(f, page_start))
+         goto error;
+
+      page_start = stb_vorbis_get_file_offset(f);
+      if (!start_page(f)) goto error;
+      end_pos = f->segment_count - 1;
+   }
+
+   // prepare to start decoding
+   f->current_loc_valid = FALSE;
+   f->last_seg = FALSE;
+   f->valid_bits = 0;
+   f->packet_bytes = 0;
+   f->bytes_in_seg = 0;
+   f->previous_length = 0;
+   f->next_seg = start_seg_with_known_loc;
+
+   for (i = 0; i < start_seg_with_known_loc; i++)
+      skip(f, f->segments[i]);
+
+   // start decoding (optimizable - this frame is generally discarded)
+   if (!vorbis_pump_first_frame(f))
+      return 0;
+   if (f->current_loc > sample_number)
+      return error(f, VORBIS_seek_failed);
+   return 1;
+
+error:
+   // try to restore the file to a valid state
+   stb_vorbis_seek_start(f);
+   return error(f, VORBIS_seek_failed);
+}
+
+// the same as vorbis_decode_initial, but without advancing
+static int peek_decode_initial(vorb *f, int *p_left_start, int *p_left_end, int *p_right_start, int *p_right_end, int *mode)
+{
+   int bits_read, bytes_read;
+
+   if (!vorbis_decode_initial(f, p_left_start, p_left_end, p_right_start, p_right_end, mode))
+      return 0;
+
+   // either 1 or 2 bytes were read, figure out which so we can rewind
+   bits_read = 1 + ilog(f->mode_count-1);
+   if (f->mode_config[*mode].blockflag)
+      bits_read += 2;
+   bytes_read = (bits_read + 7) / 8;
+
+   f->bytes_in_seg += bytes_read;
+   f->packet_bytes -= bytes_read;
+   skip(f, -bytes_read);
+   if (f->next_seg == -1)
+      f->next_seg = f->segment_count - 1;
+   else
+      f->next_seg--;
+   f->valid_bits = 0;
+
+   return 1;
+}
+
+int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number)
+{
+   uint32 max_frame_samples;
+
+   if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
+
+   // fast page-level search
+   if (!seek_to_sample_coarse(f, sample_number))
+      return 0;
+
+   assert(f->current_loc_valid);
+   assert(f->current_loc <= sample_number);
+
+   // linear search for the relevant packet
+   max_frame_samples = (f->blocksize_1*3 - f->blocksize_0) >> 2;
+   while (f->current_loc < sample_number) {
+      int left_start, left_end, right_start, right_end, mode, frame_samples;
+      if (!peek_decode_initial(f, &left_start, &left_end, &right_start, &right_end, &mode))
+         return error(f, VORBIS_seek_failed);
+      // calculate the number of samples returned by the next frame
+      frame_samples = right_start - left_start;
+      if (f->current_loc + frame_samples > sample_number) {
+         return 1; // the next frame will contain the sample
+      } else if (f->current_loc + frame_samples + max_frame_samples > sample_number) {
+         // there's a chance the frame after this could contain the sample
+         vorbis_pump_first_frame(f);
+      } else {
+         // this frame is too early to be relevant
+         f->current_loc += frame_samples;
+         f->previous_length = 0;
+         maybe_start_packet(f);
+         flush_packet(f);
+      }
+   }
+   // the next frame should start with the sample
+   if (f->current_loc != sample_number) return error(f, VORBIS_seek_failed);
+   return 1;
+}
+
+int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)
+{
+   if (!stb_vorbis_seek_frame(f, sample_number))
+      return 0;
+
+   if (sample_number != f->current_loc) {
+      int n;
+      uint32 frame_start = f->current_loc;
+      stb_vorbis_get_frame_float(f, &n, NULL);
+      assert(sample_number > frame_start);
+      assert(f->channel_buffer_start + (int) (sample_number-frame_start) <= f->channel_buffer_end);
+      f->channel_buffer_start += (sample_number - frame_start);
+   }
+
+   return 1;
+}
+
+int stb_vorbis_seek_start(stb_vorbis *f)
+{
+   if (IS_PUSH_MODE(f)) { return error(f, VORBIS_invalid_api_mixing); }
+   set_file_offset(f, f->first_audio_page_offset);
+   f->previous_length = 0;
+   f->first_decode = TRUE;
+   f->next_seg = -1;
+   return vorbis_pump_first_frame(f);
+}
+
+unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)
+{
+   unsigned int restore_offset, previous_safe;
+   unsigned int end, last_page_loc;
+
+   if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
+   if (!f->total_samples) {
+      unsigned int last;
+      uint32 lo,hi;
+      char header[6];
+
+      // first, store the current decode position so we can restore it
+      restore_offset = stb_vorbis_get_file_offset(f);
+
+      // now we want to seek back 64K from the end (the last page must
+      // be at most a little less than 64K, but let's allow a little slop)
+      if (f->stream_len >= 65536 && f->stream_len-65536 >= f->first_audio_page_offset)
+         previous_safe = f->stream_len - 65536;
+      else
+         previous_safe = f->first_audio_page_offset;
+
+      set_file_offset(f, previous_safe);
+      // previous_safe is now our candidate 'earliest known place that seeking
+      // to will lead to the final page'
+
+      if (!vorbis_find_page(f, &end, &last)) {
+         // if we can't find a page, we're hosed!
+         f->error = VORBIS_cant_find_last_page;
+         f->total_samples = 0xffffffff;
+         goto done;
+      }
+
+      // check if there are more pages
+      last_page_loc = stb_vorbis_get_file_offset(f);
+
+      // stop when the last_page flag is set, not when we reach eof;
+      // this allows us to stop short of a 'file_section' end without
+      // explicitly checking the length of the section
+      while (!last) {
+         set_file_offset(f, end);
+         if (!vorbis_find_page(f, &end, &last)) {
+            // the last page we found didn't have the 'last page' flag
+            // set. whoops!
+            break;
+         }
+         //previous_safe = last_page_loc+1; // NOTE: not used after this point, but note for debugging
+         last_page_loc = stb_vorbis_get_file_offset(f);
+      }
+
+      set_file_offset(f, last_page_loc);
+
+      // parse the header
+      getn(f, (unsigned char *)header, 6);
+      // extract the absolute granule position
+      lo = get32(f);
+      hi = get32(f);
+      if (lo == 0xffffffff && hi == 0xffffffff) {
+         f->error = VORBIS_cant_find_last_page;
+         f->total_samples = SAMPLE_unknown;
+         goto done;
+      }
+      if (hi)
+         lo = 0xfffffffe; // saturate
+      f->total_samples = lo;
+
+      f->p_last.page_start = last_page_loc;
+      f->p_last.page_end   = end;
+      f->p_last.last_decoded_sample = lo;
+
+     done:
+      set_file_offset(f, restore_offset);
+   }
+   return f->total_samples == SAMPLE_unknown ? 0 : f->total_samples;
+}
+
+float stb_vorbis_stream_length_in_seconds(stb_vorbis *f)
+{
+   return stb_vorbis_stream_length_in_samples(f) / (float) f->sample_rate;
+}
+
+
+
+int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output)
+{
+   int len, right,left,i;
+   if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
+
+   if (!vorbis_decode_packet(f, &len, &left, &right)) {
+      f->channel_buffer_start = f->channel_buffer_end = 0;
+      return 0;
+   }
+
+   len = vorbis_finish_frame(f, len, left, right);
+   for (i=0; i < f->channels; ++i)
+      f->outputs[i] = f->channel_buffers[i] + left;
+
+   f->channel_buffer_start = left;
+   f->channel_buffer_end   = left+len;
+
+   if (channels) *channels = f->channels;
+   if (output)   *output = f->outputs;
+   return len;
+}
+
+#ifndef STB_VORBIS_NO_STDIO
+
+stb_vorbis * stb_vorbis_open_file_section(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc, unsigned int length)
+{
+   stb_vorbis *f, p;
+   vorbis_init(&p, alloc);
+   p.f = file;
+   p.f_start = (uint32) ftell(file);
+   p.stream_len   = length;
+   p.close_on_free = close_on_free;
+   if (start_decoder(&p)) {
+      f = vorbis_alloc(&p);
+      if (f) {
+         *f = p;
+         vorbis_pump_first_frame(f);
+         return f;
+      }
+   }
+   if (error) *error = p.error;
+   vorbis_deinit(&p);
+   return NULL;
+}
+
+stb_vorbis * stb_vorbis_open_file(FILE *file, int close_on_free, int *error, const stb_vorbis_alloc *alloc)
+{
+   unsigned int len, start;
+   start = (unsigned int) ftell(file);
+   fseek(file, 0, SEEK_END);
+   len = (unsigned int) (ftell(file) - start);
+   fseek(file, start, SEEK_SET);
+   return stb_vorbis_open_file_section(file, close_on_free, error, alloc, len);
+}
+
+stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const stb_vorbis_alloc *alloc)
+{
+   FILE *f;
+#if defined(_WIN32) && defined(__STDC_WANT_SECURE_LIB__)
+   if (0 != fopen_s(&f, filename, "rb"))
+      f = NULL;
+#else
+   f = fopen(filename, "rb");
+#endif
+   if (f)
+      return stb_vorbis_open_file(f, TRUE, error, alloc);
+   if (error) *error = VORBIS_file_open_failure;
+   return NULL;
+}
+#endif // STB_VORBIS_NO_STDIO
+
+stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc)
+{
+   stb_vorbis *f, p;
+   if (!data) {
+      if (error) *error = VORBIS_unexpected_eof;
+      return NULL;
+   }
+   vorbis_init(&p, alloc);
+   p.stream = (uint8 *) data;
+   p.stream_end = (uint8 *) data + len;
+   p.stream_start = (uint8 *) p.stream;
+   p.stream_len = len;
+   p.push_mode = FALSE;
+   if (start_decoder(&p)) {
+      f = vorbis_alloc(&p);
+      if (f) {
+         *f = p;
+         vorbis_pump_first_frame(f);
+         if (error) *error = VORBIS__no_error;
+         return f;
+      }
+   }
+   if (error) *error = p.error;
+   vorbis_deinit(&p);
+   return NULL;
+}
+
+#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
+#define PLAYBACK_MONO     1
+#define PLAYBACK_LEFT     2
+#define PLAYBACK_RIGHT    4
+
+#define L  (PLAYBACK_LEFT  | PLAYBACK_MONO)
+#define C  (PLAYBACK_LEFT  | PLAYBACK_RIGHT | PLAYBACK_MONO)
+#define R  (PLAYBACK_RIGHT | PLAYBACK_MONO)
+
+static int8 channel_position[7][6] =
+{
+   { 0 },
+   { C },
+   { L, R },
+   { L, C, R },
+   { L, R, L, R },
+   { L, C, R, L, R },
+   { L, C, R, L, R, C },
+};
+
+
+#ifndef STB_VORBIS_NO_FAST_SCALED_FLOAT
+   typedef union {
+      float f;
+      int i;
+   } float_conv;
+   typedef char stb_vorbis_float_size_test[sizeof(float)==4 && sizeof(int) == 4];
+   #define FASTDEF(x) float_conv x
+   // add (1<<23) to convert to int, then divide by 2^SHIFT, then add 0.5/2^SHIFT to round
+   #define MAGIC(SHIFT) (1.5f * (1 << (23-SHIFT)) + 0.5f/(1 << SHIFT))
+   #define ADDEND(SHIFT) (((150-SHIFT) << 23) + (1 << 22))
+   #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) (temp.f = (x) + MAGIC(s), temp.i - ADDEND(s))
+   #define check_endianness()
+#else
+   #define FAST_SCALED_FLOAT_TO_INT(temp,x,s) ((int) ((x) * (1 << (s))))
+   #define check_endianness()
+   #define FASTDEF(x)
+#endif
+
+static void copy_samples(short *dest, float *src, int len)
+{
+   int i;
+   check_endianness();
+   for (i=0; i < len; ++i) {
+      FASTDEF(temp);
+      int v = FAST_SCALED_FLOAT_TO_INT(temp, src[i],15);
+      if ((unsigned int) (v + 32768) > 65535)
+         v = v < 0 ? -32768 : 32767;
+      dest[i] = v;
+   }
+}
+
+static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len)
+{
+   #define STB_BUFFER_SIZE  32
+   float buffer[STB_BUFFER_SIZE];
+   int i,j,o,n = STB_BUFFER_SIZE;
+   check_endianness();
+   for (o = 0; o < len; o += STB_BUFFER_SIZE) {
+      memset(buffer, 0, sizeof(buffer));
+      if (o + n > len) n = len - o;
+      for (j=0; j < num_c; ++j) {
+         if (channel_position[num_c][j] & mask) {
+            for (i=0; i < n; ++i)
+               buffer[i] += data[j][d_offset+o+i];
+         }
+      }
+      for (i=0; i < n; ++i) {
+         FASTDEF(temp);
+         int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15);
+         if ((unsigned int) (v + 32768) > 65535)
+            v = v < 0 ? -32768 : 32767;
+         output[o+i] = v;
+      }
+   }
+   #undef STB_BUFFER_SIZE
+}
+
+static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len)
+{
+   #define STB_BUFFER_SIZE  32
+   float buffer[STB_BUFFER_SIZE];
+   int i,j,o,n = STB_BUFFER_SIZE >> 1;
+   // o is the offset in the source data
+   check_endianness();
+   for (o = 0; o < len; o += STB_BUFFER_SIZE >> 1) {
+      // o2 is the offset in the output data
+      int o2 = o << 1;
+      memset(buffer, 0, sizeof(buffer));
+      if (o + n > len) n = len - o;
+      for (j=0; j < num_c; ++j) {
+         int m = channel_position[num_c][j] & (PLAYBACK_LEFT | PLAYBACK_RIGHT);
+         if (m == (PLAYBACK_LEFT | PLAYBACK_RIGHT)) {
+            for (i=0; i < n; ++i) {
+               buffer[i*2+0] += data[j][d_offset+o+i];
+               buffer[i*2+1] += data[j][d_offset+o+i];
+            }
+         } else if (m == PLAYBACK_LEFT) {
+            for (i=0; i < n; ++i) {
+               buffer[i*2+0] += data[j][d_offset+o+i];
+            }
+         } else if (m == PLAYBACK_RIGHT) {
+            for (i=0; i < n; ++i) {
+               buffer[i*2+1] += data[j][d_offset+o+i];
+            }
+         }
+      }
+      for (i=0; i < (n<<1); ++i) {
+         FASTDEF(temp);
+         int v = FAST_SCALED_FLOAT_TO_INT(temp,buffer[i],15);
+         if ((unsigned int) (v + 32768) > 65535)
+            v = v < 0 ? -32768 : 32767;
+         output[o2+i] = v;
+      }
+   }
+   #undef STB_BUFFER_SIZE
+}
+
+static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples)
+{
+   int i;
+   if (buf_c != data_c && buf_c <= 2 && data_c <= 6) {
+      static int channel_selector[3][2] = { {0}, {PLAYBACK_MONO}, {PLAYBACK_LEFT, PLAYBACK_RIGHT} };
+      for (i=0; i < buf_c; ++i)
+         compute_samples(channel_selector[buf_c][i], buffer[i]+b_offset, data_c, data, d_offset, samples);
+   } else {
+      int limit = buf_c < data_c ? buf_c : data_c;
+      for (i=0; i < limit; ++i)
+         copy_samples(buffer[i]+b_offset, data[i]+d_offset, samples);
+      for (   ; i < buf_c; ++i)
+         memset(buffer[i]+b_offset, 0, sizeof(short) * samples);
+   }
+}
+
+int stb_vorbis_get_frame_short(stb_vorbis *f, int num_c, short **buffer, int num_samples)
+{
+   float **output = NULL;
+   int len = stb_vorbis_get_frame_float(f, NULL, &output);
+   if (len > num_samples) len = num_samples;
+   if (len)
+      convert_samples_short(num_c, buffer, 0, f->channels, output, 0, len);
+   return len;
+}
+
+static void convert_channels_short_interleaved(int buf_c, short *buffer, int data_c, float **data, int d_offset, int len)
+{
+   int i;
+   check_endianness();
+   if (buf_c != data_c && buf_c <= 2 && data_c <= 6) {
+      assert(buf_c == 2);
+      for (i=0; i < buf_c; ++i)
+         compute_stereo_samples(buffer, data_c, data, d_offset, len);
+   } else {
+      int limit = buf_c < data_c ? buf_c : data_c;
+      int j;
+      for (j=0; j < len; ++j) {
+         for (i=0; i < limit; ++i) {
+            FASTDEF(temp);
+            float f = data[i][d_offset+j];
+            int v = FAST_SCALED_FLOAT_TO_INT(temp, f,15);//data[i][d_offset+j],15);
+            if ((unsigned int) (v + 32768) > 65535)
+               v = v < 0 ? -32768 : 32767;
+            *buffer++ = v;
+         }
+         for (   ; i < buf_c; ++i)
+            *buffer++ = 0;
+      }
+   }
+}
+
+int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts)
+{
+   float **output;
+   int len;
+   if (num_c == 1) return stb_vorbis_get_frame_short(f,num_c,&buffer, num_shorts);
+   len = stb_vorbis_get_frame_float(f, NULL, &output);
+   if (len) {
+      if (len*num_c > num_shorts) len = num_shorts / num_c;
+      convert_channels_short_interleaved(num_c, buffer, f->channels, output, 0, len);
+   }
+   return len;
+}
+
+int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts)
+{
+   float **outputs;
+   int len = num_shorts / channels;
+   int n=0;
+   while (n < len) {
+      int k = f->channel_buffer_end - f->channel_buffer_start;
+      if (n+k >= len) k = len - n;
+      if (k)
+         convert_channels_short_interleaved(channels, buffer, f->channels, f->channel_buffers, f->channel_buffer_start, k);
+      buffer += k*channels;
+      n += k;
+      f->channel_buffer_start += k;
+      if (n == len) break;
+      if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break;
+   }
+   return n;
+}
+
+int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int len)
+{
+   float **outputs;
+   int n=0;
+   while (n < len) {
+      int k = f->channel_buffer_end - f->channel_buffer_start;
+      if (n+k >= len) k = len - n;
+      if (k)
+         convert_samples_short(channels, buffer, n, f->channels, f->channel_buffers, f->channel_buffer_start, k);
+      n += k;
+      f->channel_buffer_start += k;
+      if (n == len) break;
+      if (!stb_vorbis_get_frame_float(f, NULL, &outputs)) break;
+   }
+   return n;
+}
+
+#ifndef STB_VORBIS_NO_STDIO
+int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output)
+{
+   int data_len, offset, total, limit, error;
+   short *data;
+   stb_vorbis *v = stb_vorbis_open_filename(filename, &error, NULL);
+   if (v == NULL) return -1;
+   limit = v->channels * 4096;
+   *channels = v->channels;
+   if (sample_rate)
+      *sample_rate = v->sample_rate;
+   offset = data_len = 0;
+   total = limit;
+   data = (short *) malloc(total * sizeof(*data));
+   if (data == NULL) {
+      stb_vorbis_close(v);
+      return -2;
+   }
+   for (;;) {
+      int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset);
+      if (n == 0) break;
+      data_len += n;
+      offset += n * v->channels;
+      if (offset + limit > total) {
+         short *data2;
+         total *= 2;
+         data2 = (short *) realloc(data, total * sizeof(*data));
+         if (data2 == NULL) {
+            free(data);
+            stb_vorbis_close(v);
+            return -2;
+         }
+         data = data2;
+      }
+   }
+   *output = data;
+   stb_vorbis_close(v);
+   return data_len;
+}
+#endif // NO_STDIO
+
+int stb_vorbis_decode_memory(const uint8 *mem, int len, int *channels, int *sample_rate, short **output)
+{
+   int data_len, offset, total, limit, error;
+   short *data;
+   stb_vorbis *v = stb_vorbis_open_memory(mem, len, &error, NULL);
+   if (v == NULL) return -1;
+   limit = v->channels * 4096;
+   *channels = v->channels;
+   if (sample_rate)
+      *sample_rate = v->sample_rate;
+   offset = data_len = 0;
+   total = limit;
+   data = (short *) malloc(total * sizeof(*data));
+   if (data == NULL) {
+      stb_vorbis_close(v);
+      return -2;
+   }
+   for (;;) {
+      int n = stb_vorbis_get_frame_short_interleaved(v, v->channels, data+offset, total-offset);
+      if (n == 0) break;
+      data_len += n;
+      offset += n * v->channels;
+      if (offset + limit > total) {
+         short *data2;
+         total *= 2;
+         data2 = (short *) realloc(data, total * sizeof(*data));
+         if (data2 == NULL) {
+            free(data);
+            stb_vorbis_close(v);
+            return -2;
+         }
+         data = data2;
+      }
+   }
+   *output = data;
+   stb_vorbis_close(v);
+   return data_len;
+}
+#endif // STB_VORBIS_NO_INTEGER_CONVERSION
+
+int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats)
+{
+   float **outputs;
+   int len = num_floats / channels;
+   int n=0;
+   int z = f->channels;
+   if (z > channels) z = channels;
+   while (n < len) {
+      int i,j;
+      int k = f->channel_buffer_end - f->channel_buffer_start;
+      if (n+k >= len) k = len - n;
+      for (j=0; j < k; ++j) {
+         for (i=0; i < z; ++i)
+            *buffer++ = f->channel_buffers[i][f->channel_buffer_start+j];
+         for (   ; i < channels; ++i)
+            *buffer++ = 0;
+      }
+      n += k;
+      f->channel_buffer_start += k;
+      if (n == len)
+         break;
+      if (!stb_vorbis_get_frame_float(f, NULL, &outputs))
+         break;
+   }
+   return n;
+}
+
+int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples)
+{
+   float **outputs;
+   int n=0;
+   int z = f->channels;
+   if (z > channels) z = channels;
+   while (n < num_samples) {
+      int i;
+      int k = f->channel_buffer_end - f->channel_buffer_start;
+      if (n+k >= num_samples) k = num_samples - n;
+      if (k) {
+         for (i=0; i < z; ++i)
+            memcpy(buffer[i]+n, f->channel_buffers[i]+f->channel_buffer_start, sizeof(float)*k);
+         for (   ; i < channels; ++i)
+            memset(buffer[i]+n, 0, sizeof(float) * k);
+      }
+      n += k;
+      f->channel_buffer_start += k;
+      if (n == num_samples)
+         break;
+      if (!stb_vorbis_get_frame_float(f, NULL, &outputs))
+         break;
+   }
+   return n;
+}
+#endif // STB_VORBIS_NO_PULLDATA_API
+
+/* Version history
+    1.17    - 2019-07-08 - fix CVE-2019-13217, -13218, -13219, -13220, -13221, -13222, -13223
+                           found with Mayhem by ForAllSecure
+    1.16    - 2019-03-04 - fix warnings
+    1.15    - 2019-02-07 - explicit failure if Ogg Skeleton data is found
+    1.14    - 2018-02-11 - delete bogus dealloca usage
+    1.13    - 2018-01-29 - fix truncation of last frame (hopefully)
+    1.12    - 2017-11-21 - limit residue begin/end to blocksize/2 to avoid large temp allocs in bad/corrupt files
+    1.11    - 2017-07-23 - fix MinGW compilation
+    1.10    - 2017-03-03 - more robust seeking; fix negative ilog(); clear error in open_memory
+    1.09    - 2016-04-04 - back out 'avoid discarding last frame' fix from previous version
+    1.08    - 2016-04-02 - fixed multiple warnings; fix setup memory leaks;
+                           avoid discarding last frame of audio data
+    1.07    - 2015-01-16 - fixed some warnings, fix mingw, const-correct API
+                           some more crash fixes when out of memory or with corrupt files
+    1.06    - 2015-08-31 - full, correct support for seeking API (Dougall Johnson)
+                           some crash fixes when out of memory or with corrupt files
+    1.05    - 2015-04-19 - don't define __forceinline if it's redundant
+    1.04    - 2014-08-27 - fix missing const-correct case in API
+    1.03    - 2014-08-07 - Warning fixes
+    1.02    - 2014-07-09 - Declare qsort compare function _cdecl on windows
+    1.01    - 2014-06-18 - fix stb_vorbis_get_samples_float
+    1.0     - 2014-05-26 - fix memory leaks; fix warnings; fix bugs in multichannel
+                           (API change) report sample rate for decode-full-file funcs
+    0.99996 - bracket #include <malloc.h> for macintosh compilation by Laurent Gomila
+    0.99995 - use union instead of pointer-cast for fast-float-to-int to avoid alias-optimization problem
+    0.99994 - change fast-float-to-int to work in single-precision FPU mode, remove endian-dependence
+    0.99993 - remove assert that fired on legal files with empty tables
+    0.99992 - rewind-to-start
+    0.99991 - bugfix to stb_vorbis_get_samples_short by Bernhard Wodo
+    0.9999 - (should have been 0.99990) fix no-CRT support, compiling as C++
+    0.9998 - add a full-decode function with a memory source
+    0.9997 - fix a bug in the read-from-FILE case in 0.9996 addition
+    0.9996 - query length of vorbis stream in samples/seconds
+    0.9995 - bugfix to another optimization that only happened in certain files
+    0.9994 - bugfix to one of the optimizations that caused significant (but inaudible?) errors
+    0.9993 - performance improvements; runs in 99% to 104% of time of reference implementation
+    0.9992 - performance improvement of IMDCT; now performs close to reference implementation
+    0.9991 - performance improvement of IMDCT
+    0.999 - (should have been 0.9990) performance improvement of IMDCT
+    0.998 - no-CRT support from Casey Muratori
+    0.997 - bugfixes for bugs found by Terje Mathisen
+    0.996 - bugfix: fast-huffman decode initialized incorrectly for sparse codebooks; fixing gives 10% speedup - found by Terje Mathisen
+    0.995 - bugfix: fix to 'effective' overrun detection - found by Terje Mathisen
+    0.994 - bugfix: garbage decode on final VQ symbol of a non-multiple - found by Terje Mathisen
+    0.993 - bugfix: pushdata API required 1 extra byte for empty page (failed to consume final page if empty) - found by Terje Mathisen
+    0.992 - fixes for MinGW warning
+    0.991 - turn fast-float-conversion on by default
+    0.990 - fix push-mode seek recovery if you seek into the headers
+    0.98b - fix to bad release of 0.98
+    0.98 - fix push-mode seek recovery; robustify float-to-int and support non-fast mode
+    0.97 - builds under c++ (typecasting, don't use 'class' keyword)
+    0.96 - somehow MY 0.95 was right, but the web one was wrong, so here's my 0.95 rereleased as 0.96, fixes a typo in the clamping code
+    0.95 - clamping code for 16-bit functions
+    0.94 - not publically released
+    0.93 - fixed all-zero-floor case (was decoding garbage)
+    0.92 - fixed a memory leak
+    0.91 - conditional compiles to omit parts of the API and the infrastructure to support them: STB_VORBIS_NO_PULLDATA_API, STB_VORBIS_NO_PUSHDATA_API, STB_VORBIS_NO_STDIO, STB_VORBIS_NO_INTEGER_CONVERSION
+    0.90 - first public release
+*/
+
+#endif // STB_VORBIS_HEADER_ONLY
+
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+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.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+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 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/src/Infrastructure/GalNet.Media.Miniaudio/packages.lock.WindowsReadyToRun.json b/src/Infrastructure/GalNet.Media.Miniaudio/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..c65a5d8e
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,24 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Infrastructure/GalNet.Media.Miniaudio/packages.lock.json b/src/Infrastructure/GalNet.Media.Miniaudio/packages.lock.json
new file mode 100644
index 00000000..55af1eae
--- /dev/null
+++ b/src/Infrastructure/GalNet.Media.Miniaudio/packages.lock.json
@@ -0,0 +1,23 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/CompiledStoryAssetProvider.cs b/src/Infrastructure/GalNet.Storage.FileSystem/CompiledStoryAssetProvider.cs
new file mode 100644
index 00000000..43c71a9d
--- /dev/null
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/CompiledStoryAssetProvider.cs
@@ -0,0 +1,45 @@
+using System.Collections.Frozen;
+using GalNet.Assets;
+using GalNet.Core.Assets;
+
+namespace GalNet.Storage.FileSystem;
+
+/// <summary>Adapts development build output to the same reserved story IDs as installed PAKs.</summary>
+public sealed class CompiledStoryAssetProvider : IAssetProvider
+{
+    private readonly string _root;
+    private readonly Lazy<FrozenDictionary<string, IGameFile>> _snapshot;
+    public CompiledStoryAssetProvider(string root)
+    {
+        _root = Path.GetFullPath(root);
+        _snapshot = new(() => CompiledStoryResources.Create(File.ReadAllBytes(Path.Combine(_root, "Graph", "graph.json")), id =>
+        {
+            var path = FileSystemPaths.ResolveRelativeFile(_root, "Graph/groups/" + id + ".galgroup");
+            return File.Exists(path) ? File.ReadAllBytes(path) : null;
+        }).ToFrozenDictionary(file => file.Id, StringComparer.OrdinalIgnoreCase));
+    }
+    public string Name => "CompiledStory(" + _root + ")";
+    public bool Exists(string archiveName) => File.Exists(Path.Combine(_root, "Graph", "graph.json"));
+    public IArchive OpenArchive(string archiveName) => new StoryArchive(archiveName, _snapshot.Value);
+    public Task<IArchive> OpenArchiveAsync(string archiveName, CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        return Task.FromResult(OpenArchive(archiveName));
+    }
+
+    private sealed class StoryArchive(string name, FrozenDictionary<string, IGameFile> files) : IArchive
+    {
+        private bool _disposed;
+        public string Name => name;
+        public IEnumerable<string> AssetIds => files.Keys;
+        public bool Contains(string assetId) => files.ContainsKey(assetId.Trim());
+        public IGameFile? GetAsset(string assetId)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            return files.GetValueOrDefault(assetId.Trim());
+        }
+        public IGameFile? GetAssetByPath(string path) => files.Values.FirstOrDefault(file =>
+            string.Equals(file.Path, path.Replace('\\', '/'), StringComparison.OrdinalIgnoreCase));
+        public void Dispose() => _disposed = true;
+    }
+}
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/FileGameProgressService.cs b/src/Infrastructure/GalNet.Storage.FileSystem/FileGameProgressService.cs
index 6b0b1312..30bcb464 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/FileGameProgressService.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/FileGameProgressService.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GalNet.Core.Serialization;
 using GalNet.Runtime.Progress;
 
 namespace GalNet.Storage.FileSystem;
@@ -6,6 +7,7 @@ namespace GalNet.Storage.FileSystem;
 /// <summary>Batches in-memory read progress, periodically flushes it and drains writes on shutdown.</summary>
 public sealed class FileGameProgressService : IGameProgressService, IDisposable, IAsyncDisposable
 {
+    private static readonly JsonSerializerOptions JsonOptions = JsonMetadata.CreateOptions(resolver: StorageJsonContext.Default);
     private readonly string _path;
     private readonly object _sync = new();
     private readonly SemaphoreSlim _writeGate = new(1, 1);
@@ -24,7 +26,7 @@ public FileGameProgressService(string profileDirectory, TimeSpan? flushInterval
             throw new ArgumentOutOfRangeException(nameof(flushInterval));
         _path = Path.Combine(profileDirectory, "progress.json");
         var data = File.Exists(_path)
-            ? JsonSerializer.Deserialize<ProgressData>(File.ReadAllText(_path))
+            ? JsonCodec.Deserialize<ProgressData>(File.ReadAllText(_path), JsonOptions)
                 ?? throw new InvalidDataException("Read progress document is empty.")
             : new() { Version = 2 };
         if (data.Version != 2) throw new InvalidDataException($"Unsupported read progress version '{data.Version}'.");
@@ -57,14 +59,10 @@ public async Task FlushAsync(CancellationToken cancellationToken = default)
                 data = new ProgressData
                 {
                     Version = 2,
-                    ReadEntries = _index.Snapshot().Select(entry => JsonSerializer.Serialize(new[] { entry.GroupId, entry.EntryId })).ToHashSet()
+                    ReadEntries = _index.Snapshot().Select(entry => JsonCodec.Serialize(new[] { entry.GroupId, entry.EntryId })).ToHashSet()
                 };
             }
-            Directory.CreateDirectory(Path.GetDirectoryName(_path)!);
-            var temporaryPath = _path + ".tmp";
-            await File.WriteAllTextAsync(temporaryPath, JsonSerializer.Serialize(data), cancellationToken).ConfigureAwait(false);
-            cancellationToken.ThrowIfCancellationRequested();
-            File.Move(temporaryPath, _path, overwrite: true);
+            await FileReplacement.WriteTextAsync(_path, JsonCodec.Serialize(data, JsonOptions), cancellationToken).ConfigureAwait(false);
             lock (_sync) { _flushedRevision = revision; _lastError = null; }
         }
         catch (Exception error)
@@ -127,12 +125,12 @@ private async Task DisposeCoreAsync()
 
     private static ReadEntryId ParseKey(string key)
     {
-        var parts = JsonSerializer.Deserialize<string[]>(key);
+        var parts = JsonCodec.Deserialize<string[]>(key);
         return parts is { Length: 2 } && parts[0] is not null && parts[1] is not null
             ? new(parts[0], parts[1]) : throw new InvalidDataException("Invalid read progress identity.");
     }
 
-    private sealed class ProgressData
+    internal sealed class ProgressData
     {
         public int Version { get; set; }
         public HashSet<string> ReadEntries { get; set; } = [];
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/FilePlayerSession.cs b/src/Infrastructure/GalNet.Storage.FileSystem/FilePlayerSession.cs
index 515912c4..28014ab6 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/FilePlayerSession.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/FilePlayerSession.cs
@@ -1,6 +1,6 @@
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.GameHost;
-using GalNet.Runtime.Gallery;
+using GalNet.GameHost.Gallery;
 using GalNet.Runtime.Variables;
 
 namespace GalNet.Storage.FileSystem;
@@ -9,9 +9,9 @@ namespace GalNet.Storage.FileSystem;
 public static class FilePlayerSession
 {
     public static async Task<PlayerSession> OpenAsync(string profileDirectory, GalleryCatalog gallery,
-        CancellationToken cancellationToken = default)
+        int maxSlots = 60, CancellationToken cancellationToken = default)
     {
-        var saves = new FileSaveService(profileDirectory);
+        var saves = new FileSaveService(profileDirectory, maxSlots);
         PlayerVariableService? variables = null;
         FileGameProgressService? progress = null;
         try
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/FilePlayerVariableStore.cs b/src/Infrastructure/GalNet.Storage.FileSystem/FilePlayerVariableStore.cs
index 6d397285..ef747f91 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/FilePlayerVariableStore.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/FilePlayerVariableStore.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GalNet.Core.Serialization;
 using GalNet.Runtime.Persistence;
 using GalVariable = GalNet.Core.Variable.Variable;
 
@@ -20,7 +21,7 @@ public async Task<IReadOnlyDictionary<string, GalVariable>> LoadAsync(Cancellati
         {
             if (!File.Exists(_path)) return new Dictionary<string, GalVariable>(StringComparer.Ordinal);
             var json = await File.ReadAllTextAsync(_path, ct);
-            var stored = JsonSerializer.Deserialize<Dictionary<string, GalVariable>>(json) ?? [];
+            var stored = JsonCodec.Deserialize<Dictionary<string, GalVariable>>(json) ?? [];
             return stored.ToDictionary(pair => pair.Key, pair => Clone(pair.Key, pair.Value), StringComparer.Ordinal);
         }
         catch (JsonException)
@@ -35,11 +36,8 @@ public async Task SaveAsync(IReadOnlyDictionary<string, GalVariable> variables,
         await _gate.WaitAsync(ct);
         try
         {
-            Directory.CreateDirectory(Path.GetDirectoryName(_path)!);
             var copy = variables.ToDictionary(pair => pair.Key, pair => Clone(pair.Key, pair.Value), StringComparer.Ordinal);
-            var temporaryPath = _path + ".tmp";
-            await File.WriteAllTextAsync(temporaryPath, JsonSerializer.Serialize(copy), ct);
-            File.Move(temporaryPath, _path, true);
+            await FileReplacement.WriteTextAsync(_path, JsonCodec.Serialize(copy), ct).ConfigureAwait(false);
         }
         finally { _gate.Release(); }
     }
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/FileReplacement.cs b/src/Infrastructure/GalNet.Storage.FileSystem/FileReplacement.cs
new file mode 100644
index 00000000..1f6acaec
--- /dev/null
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/FileReplacement.cs
@@ -0,0 +1,25 @@
+namespace GalNet.Storage.FileSystem;
+
+/// <summary>Replaces one file through a unique sibling temporary file; callers own serialization and synchronization.</summary>
+internal static class FileReplacement
+{
+    public static async Task WriteTextAsync(string path, string text, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        path = Path.GetFullPath(path);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        var temporary = path + ".write-" + Guid.NewGuid().ToString("N") + ".tmp";
+        try
+        {
+            await File.WriteAllTextAsync(temporary, text, cancellationToken).ConfigureAwait(false);
+            cancellationToken.ThrowIfCancellationRequested();
+            File.Move(temporary, path, overwrite: true);
+        }
+        catch (Exception writeError)
+        {
+            try { File.Delete(temporary); }
+            catch (Exception cleanupError) { throw new AggregateException(writeError, cleanupError); }
+            throw;
+        }
+    }
+}
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/FileSaveService.cs b/src/Infrastructure/GalNet.Storage.FileSystem/FileSaveService.cs
index d848b8db..879818de 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/FileSaveService.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/FileSaveService.cs
@@ -1,13 +1,15 @@
 using System.Text.Json;
 using GalNet.Core.Runtime;
+using GalNet.Core.Serialization;
 using GalNet.Runtime.Persistence;
 
 namespace GalNet.Storage.FileSystem;
 
 /// <summary>File-backed slot and quick-save store.</summary>
-public sealed class FileSaveService : ISaveService, IDisposable
+public sealed class FileSaveService : ISaveService, ISaveSlotNamingService, ISaveSlotInfoSource, IDisposable
 {
     private const int FormatVersion = GameSnapshot.CurrentFormatVersion;
+    private static readonly JsonSerializerOptions JsonOptions = JsonMetadata.CreateOptions(resolver: StorageJsonContext.Default);
     private readonly string _root;
     private readonly SemaphoreSlim _gate = new(1, 1);
 
@@ -28,6 +30,33 @@ public async Task<IReadOnlyList<SaveSlotInfo>> ListSlotsAsync(CancellationToken
 
     public Task SaveAsync(int slot, SaveRequest request, CancellationToken ct = default) => WriteAsync(slot, false, request, ct);
 
+    public Task<SaveSlotInfo> GetSlotInfoAsync(int slot, CancellationToken ct = default)
+    {
+        if (slot < 0 || slot >= MaxSlots) throw new ArgumentOutOfRangeException(nameof(slot));
+        ct.ThrowIfCancellationRequested();
+        return GetInfoAsync(slot, false, ct);
+    }
+
+    public async Task RenameAsync(int slot, string name, CancellationToken ct = default)
+    {
+        if (slot < 0 || slot >= MaxSlots) throw new ArgumentOutOfRangeException(nameof(slot));
+        ArgumentNullException.ThrowIfNull(name);
+        var normalized = name.Trim();
+        if (normalized.Length > 120 || normalized.Any(char.IsControl))
+            throw new ArgumentException("Save names must contain at most 120 characters and no control characters.", nameof(name));
+        await _gate.WaitAsync(ct);
+        try
+        {
+            var path = GetPath(slot, false);
+            var stored = JsonCodec.Deserialize<StoredSave>(await File.ReadAllTextAsync(path, ct), JsonOptions);
+            if (stored?.Version != FormatVersion || stored.Snapshot is null)
+                throw new InvalidDataException("Only valid saves can be renamed.");
+            stored.Description = normalized.Length == 0 ? null : normalized;
+            await FileReplacement.WriteTextAsync(path, JsonCodec.Serialize(stored, JsonOptions), ct).ConfigureAwait(false);
+        }
+        finally { _gate.Release(); }
+    }
+
     public async Task<GameSnapshot?> LoadAsync(int slot, CancellationToken ct = default)
     {
         ct.ThrowIfCancellationRequested();
@@ -79,13 +108,13 @@ private async Task WriteAsync(int slot, bool quick, SaveRequest request, Cancell
         await _gate.WaitAsync(ct);
         try
         {
-            Directory.CreateDirectory(_root);
             var payload = new StoredSave { Version = FormatVersion, Timestamp = DateTimeOffset.UtcNow, Description = request.Description, Snapshot = request.Snapshot };
             var path = GetPath(slot, quick);
-            var temp = path + ".tmp";
-            await File.WriteAllTextAsync(temp, JsonSerializer.Serialize(payload), ct);
-            File.Move(temp, path, true);
-            if (request.PreviewImage is { Length: > 0 }) await File.WriteAllBytesAsync(GetPreviewPath(slot, quick), request.PreviewImage, ct);
+            var json = await Task.Run(() => JsonCodec.Serialize(payload, JsonOptions), ct).ConfigureAwait(false);
+            await FileReplacement.WriteTextAsync(path, json, ct).ConfigureAwait(false);
+            var previewPath = GetPreviewPath(slot, quick);
+            if (request.PreviewImage is { Length: > 0 }) await File.WriteAllBytesAsync(previewPath, request.PreviewImage, ct);
+            else if (File.Exists(previewPath)) File.Delete(previewPath);
         }
         finally { _gate.Release(); }
     }
@@ -96,8 +125,8 @@ private async Task<SaveSlotInfo> GetInfoAsync(int slot, bool quick, Cancellation
         if (!File.Exists(path)) return new SaveSlotInfo { SlotIndex = slot, IsQuickSave = quick };
         try
         {
-            var json = await File.ReadAllTextAsync(path, ct);
-            var stored = JsonSerializer.Deserialize<StoredSave>(json);
+            var json = await File.ReadAllTextAsync(path, ct).ConfigureAwait(false);
+            var stored = JsonCodec.Deserialize<StoredSave>(json, JsonOptions);
             if (stored?.Version != FormatVersion || stored.Snapshot is null) throw new InvalidDataException();
             var preview = GetPreviewPath(slot, quick);
             return new SaveSlotInfo { SlotIndex = slot, IsQuickSave = quick, Timestamp = stored.Timestamp.LocalDateTime, Description = stored.Description, PreviewImage = File.Exists(preview) ? preview : null };
@@ -111,7 +140,7 @@ private async Task<SaveSlotInfo> GetInfoAsync(int slot, bool quick, Cancellation
         if (!File.Exists(path)) return null;
         try
         {
-            var stored = JsonSerializer.Deserialize<StoredSave>(await File.ReadAllTextAsync(path, ct));
+            var stored = JsonCodec.Deserialize<StoredSave>(await File.ReadAllTextAsync(path, ct), JsonOptions);
             return stored?.Version == FormatVersion ? stored.Snapshot : null;
         }
         catch (OperationCanceledException) { throw; }
@@ -133,7 +162,7 @@ public void Dispose()
         GC.SuppressFinalize(this);
     }
 
-    private sealed class StoredSave
+    internal sealed class StoredSave
     {
         public int Version { get; set; }
         public DateTimeOffset Timestamp { get; set; }
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/GalNet.Storage.FileSystem.csproj b/src/Infrastructure/GalNet.Storage.FileSystem/GalNet.Storage.FileSystem.csproj
index 7801b936..7dc6ac7c 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/GalNet.Storage.FileSystem.csproj
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/GalNet.Storage.FileSystem.csproj
@@ -13,4 +13,5 @@
     <ProjectReference Include="..\..\Shared\GalNet.Assets\GalNet.Assets.csproj" />
   </ItemGroup>
 
+  <ItemGroup><ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/GalleryFileLoader.cs b/src/Infrastructure/GalNet.Storage.FileSystem/GalleryFileLoader.cs
index ace7a683..303dc874 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/GalleryFileLoader.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/GalleryFileLoader.cs
@@ -1,15 +1,16 @@
 using System.Text.Json;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Storage.FileSystem;
 
 /// <summary>Loads generated Gallery content and verifies its type snapshot against the composed registry.</summary>
 public static class GalleryFileLoader
 {
-    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
+    private static readonly JsonSerializerOptions JsonOptions = GalNet.Contracts.Builtins.BuiltinJson.CreateOptions(new(JsonSerializerDefaults.Web)
     {
         PropertyNameCaseInsensitive = true
-    };
+    });
 
     public static GalleryCatalog LoadGenerated(string path, IGalleryTypeCatalog expectedTypes)
     {
@@ -27,7 +28,7 @@ public static GalleryCatalog LoadGeneratedJson(string json, IGalleryTypeCatalog
         ArgumentNullException.ThrowIfNull(expectedTypes);
         try
         {
-            var configuration = JsonSerializer.Deserialize<GalleryConfiguration>(json, JsonOptions)
+            var configuration = JsonCodec.Deserialize<GalleryConfiguration>(json, JsonOptions)
                 ?? throw new InvalidDataException($"The Gallery file '{sourceName}' is empty.");
             var catalog = GalleryCatalog.Create(configuration);
             if (catalog.Types.Count != expectedTypes.Types.Count || catalog.Types.Any(type =>
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/GalpakInstaller.cs b/src/Infrastructure/GalNet.Storage.FileSystem/GalpakInstaller.cs
index 25698fa3..1932591e 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/GalpakInstaller.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/GalpakInstaller.cs
@@ -1,6 +1,7 @@
 using System.IO.Compression;
 using System.Security.Cryptography;
 using System.Text.Json;
+using GalNet.Assets;
 using GalNet.Core.Serialization;
 
 namespace GalNet.Storage.FileSystem;
@@ -8,7 +9,6 @@ namespace GalNet.Storage.FileSystem;
 /// <summary>Verifies and installs a distributable <c>.galpak</c> beside its ZIP container.</summary>
 public static class GalpakInstaller
 {
-    private const int CurrentManifestVersion = 1;
     private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web) { PropertyNameCaseInsensitive = true };
 
     public static async Task<string> InstallAsync(string packagePath, string? installationDirectory = null, CancellationToken ct = default)
@@ -19,21 +19,40 @@ public static async Task<string> InstallAsync(string packagePath, string? instal
             throw new ArgumentException("A .galpak package is required.", nameof(packagePath));
         if (!File.Exists(sourcePath)) throw new FileNotFoundException("Game package was not found.", sourcePath);
 
-        var targetDirectory = installationDirectory is null
-            ? Path.Combine(Path.GetDirectoryName(sourcePath)!, Path.GetFileNameWithoutExtension(sourcePath))
-            : Path.GetFullPath(installationDirectory);
-
         using var source = File.OpenRead(sourcePath);
         using var zip = new ZipArchive(source, ZipArchiveMode.Read, leaveOpen: false);
-        var manifestEntry = FindManifestEntry(zip);
-        var manifest = await ReadManifestAsync(manifestEntry, ct);
-        ValidateManifest(manifest, zip);
+        var manifestEntry = zip.GetEntry("pak/" + PackedGameDocuments.GameFileName) ?? FindManifestEntry(zip);
+        PackedGamePackage? packed = null;
+        byte[]? gameBytes = null;
+        if (manifestEntry.FullName == "pak/" + PackedGameDocuments.GameFileName)
+        {
+            await using var input = manifestEntry.Open();
+            using var buffer = new MemoryStream();
+            await input.CopyToAsync(buffer, ct);
+            gameBytes = buffer.ToArray();
+            packed = PackedGameDocuments.ReadGame(gameBytes);
+        }
+        var manifest = packed?.Installation ?? await ReadManifestAsync(manifestEntry, ct);
+        var prefix = manifest.Version switch
+        {
+            1 when !manifestEntry.FullName.Contains('/', StringComparison.Ordinal) => "",
+            2 when manifestEntry.FullName.StartsWith("pak/", StringComparison.Ordinal)
+                && !manifestEntry.FullName[4..].Contains('/', StringComparison.Ordinal) => "pak/",
+            3 when packed is not null => "pak/",
+            _ => throw new InvalidDataException($"Unsupported .galpak version or layout '{manifest.Version}'.")
+        };
+        ValidateManifest(manifest, zip, manifestEntry.FullName, prefix);
+        var targetDirectory = installationDirectory is null
+            ? Path.Combine(Path.GetDirectoryName(sourcePath)!, manifest.Version >= 2 ? "pak" : Path.GetFileNameWithoutExtension(sourcePath))
+            : Path.GetFullPath(installationDirectory);
 
         if (Directory.Exists(targetDirectory))
         {
-            if (await MatchesInstalledPackageAsync(targetDirectory, manifest, ct))
+            if (await MatchesInstalledPackageAsync(targetDirectory, manifest, ct)
+                && (gameBytes is null || (File.Exists(Path.Combine(targetDirectory, PackedGameDocuments.GameFileName))
+                    && (await File.ReadAllBytesAsync(Path.Combine(targetDirectory, PackedGameDocuments.GameFileName), ct)).AsSpan().SequenceEqual(gameBytes))))
             {
-                EnsureExternalDirectory(targetDirectory);
+                EnsureDirectories(targetDirectory, packed);
                 return targetDirectory;
             }
             throw new InvalidOperationException($"Installation directory '{targetDirectory}' already contains a different package. Choose a new directory or remove it explicitly.");
@@ -47,19 +66,19 @@ public static async Task<string> InstallAsync(string packagePath, string? instal
             foreach (var package in manifest.Files.OrderBy(entry => entry.Path, StringComparer.Ordinal))
             {
                 ct.ThrowIfCancellationRequested();
-                var sourceEntry = zip.GetEntry(package.Path) ?? throw new InvalidDataException($"Package is missing '{package.Path}'.");
+                var sourceEntry = zip.GetEntry(prefix + package.Path) ?? throw new InvalidDataException($"Package is missing '{prefix}{package.Path}'.");
                 var destinationPath = GetSafeDestination(stagingDirectory, package.Path);
                 Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
                 await CopyAndVerifyAsync(sourceEntry, destinationPath, package, ct);
             }
 
-            var installedManifest = GetSafeDestination(stagingDirectory, manifestEntry.FullName);
+            var installedManifest = GetSafeDestination(stagingDirectory, manifestEntry.FullName[prefix.Length..]);
             Directory.CreateDirectory(Path.GetDirectoryName(installedManifest)!);
             await using (var manifestSource = manifestEntry.Open())
             await using (var manifestDestination = File.Create(installedManifest))
                 await manifestSource.CopyToAsync(manifestDestination, ct);
 
-            EnsureExternalDirectory(stagingDirectory);
+            EnsureDirectories(stagingDirectory, packed);
             Directory.Move(stagingDirectory, targetDirectory);
             return targetDirectory;
         }
@@ -70,6 +89,12 @@ public static async Task<string> InstallAsync(string packagePath, string? instal
         }
     }
 
+    private static void EnsureDirectories(string root, PackedGamePackage? packed)
+    {
+        if (packed is null) EnsureExternalDirectory(root);
+        else InstalledGameDescriptor.EnsureExtensionDirectories(root, packed.Manifest.BuildId);
+    }
+
     private static void EnsureExternalDirectory(string root)
     {
         foreach (var directory in new[] { Path.Combine(root, "I18n"), Path.Combine(root, "I18n", "External") })
@@ -83,39 +108,55 @@ private static void EnsureExternalDirectory(string root)
     private static ZipArchiveEntry FindManifestEntry(ZipArchive zip)
     {
         var manifests = zip.Entries
-            .Where(entry => entry.FullName.EndsWith(".galnet", StringComparison.OrdinalIgnoreCase) && !entry.FullName.Contains('/', StringComparison.Ordinal))
+            .Where(entry => entry.FullName.EndsWith(".galnet", StringComparison.OrdinalIgnoreCase))
             .ToArray();
         return manifests.Length == 1
             ? manifests[0]
-            : throw new InvalidDataException("A .galpak must contain exactly one root .galnet manifest.");
+            : throw new InvalidDataException("A .galpak must contain exactly one .galnet manifest in its content root.");
     }
 
     private static async Task<GalpakManifest> ReadManifestAsync(ZipArchiveEntry entry, CancellationToken ct)
     {
         await using var stream = entry.Open();
-        var manifest = await JsonSerializer.DeserializeAsync<GalpakManifest>(stream, JsonOptions, ct);
+        var manifest = await JsonCodec.DeserializeAsync<GalpakManifest>(stream, JsonOptions, ct);
         return manifest ?? throw new InvalidDataException("Package manifest is empty.");
     }
 
-    private static void ValidateManifest(GalpakManifest manifest, ZipArchive zip)
+    private static void ValidateManifest(GalpakManifest manifest, ZipArchive zip, string manifestPath, string prefix)
     {
-        if (manifest.Version != CurrentManifestVersion) throw new InvalidDataException($"Unsupported .galpak version '{manifest.Version}'.");
         if (manifest.Files is not { Count: > 0 }) throw new InvalidDataException("Package manifest has no payloads.");
 
+        var archivePaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var entry in zip.Entries)
+        {
+            if (!archivePaths.Add(entry.FullName)) throw new InvalidDataException($"Duplicate ZIP entry '{entry.FullName}'.");
+            if (!entry.FullName.StartsWith(prefix, StringComparison.Ordinal))
+                throw new InvalidDataException("All package entries must be inside the declared content root.");
+            if (entry.FullName.EndsWith('/'))
+            {
+                if (entry.FullName != prefix) ValidateRelativePath(entry.FullName[prefix.Length..].TrimEnd('/'));
+            }
+            else ValidateRelativePath(entry.FullName[prefix.Length..]);
+        }
+
         var paths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
         foreach (var package in manifest.Files)
         {
             if (package.Size < 0 || string.IsNullOrWhiteSpace(package.Sha256) || package.Sha256.Length != 64 || !package.Sha256.All(char.IsAsciiHexDigit))
                 throw new InvalidDataException($"Package manifest entry '{package.Path}' has an invalid checksum or size.");
             ValidateRelativePath(package.Path);
-            if (package.Path.StartsWith("I18n/External/", StringComparison.OrdinalIgnoreCase))
+            if (prefix + package.Path == manifestPath) throw new InvalidDataException("The package index cannot include itself.");
+            if (package.Path.StartsWith(manifest.Version >= 3 ? "I18n/" : "I18n/External/", StringComparison.OrdinalIgnoreCase))
                 throw new InvalidDataException("I18n/External is reserved for player-installed translations, not package payloads.");
             if (package.Path.EndsWith(".galnet", StringComparison.OrdinalIgnoreCase))
                 throw new InvalidDataException("The package manifest cannot also be a payload file.");
             if (!paths.Add(package.Path)) throw new InvalidDataException($"Package manifest repeats '{package.Path}'.");
-            var zipEntry = zip.GetEntry(package.Path) ?? throw new InvalidDataException($"Package is missing '{package.Path}'.");
+            var zipEntry = zip.GetEntry(prefix + package.Path) ?? throw new InvalidDataException($"Package is missing '{prefix}{package.Path}'.");
             if (zipEntry.Length != package.Size) throw new InvalidDataException($"Package entry '{package.Path}' size does not match its manifest.");
         }
+        if (prefix.Length > 0 && zip.Entries.Any(entry => !entry.FullName.EndsWith('/')
+            && entry.FullName != manifestPath && !paths.Contains(entry.FullName[prefix.Length..])))
+            throw new InvalidDataException("Package contains an undeclared payload.");
     }
 
     private static async Task<bool> MatchesInstalledPackageAsync(string directory, GalpakManifest manifest, CancellationToken ct)
@@ -151,19 +192,7 @@ private static async Task CopyAndVerifyAsync(ZipArchiveEntry source, string dest
             throw new InvalidDataException($"Package entry '{package.Path}' checksum does not match its manifest.");
     }
 
-    private static string GetSafeDestination(string root, string relativePath)
-    {
-        ValidateRelativePath(relativePath);
-        var rootPath = Path.GetFullPath(root).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar) + Path.DirectorySeparatorChar;
-        var destination = Path.GetFullPath(Path.Combine(rootPath, relativePath.Replace('/', Path.DirectorySeparatorChar)));
-        if (!destination.StartsWith(rootPath, StringComparison.OrdinalIgnoreCase))
-            throw new InvalidDataException($"Package entry '{relativePath}' escapes its installation directory.");
-        return destination;
-    }
+    private static string GetSafeDestination(string root, string relativePath) => FileSystemPaths.ResolveRelativeFile(root, relativePath);
 
-    private static void ValidateRelativePath(string path)
-    {
-        if (string.IsNullOrWhiteSpace(path) || Path.IsPathRooted(path) || path.Contains('\\') || path.Split('/').Any(part => part is "" or "." or ".."))
-            throw new InvalidDataException($"Package entry path '{path}' is not a safe relative ZIP path.");
-    }
+    private static void ValidateRelativePath(string path) => FileSystemPaths.ValidateRelativeFile(path);
 }
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/GameGraphContentLoader.cs b/src/Infrastructure/GalNet.Storage.FileSystem/GameGraphContentLoader.cs
index eef2c5f6..72bb536a 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/GameGraphContentLoader.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/GameGraphContentLoader.cs
@@ -1,19 +1,44 @@
+using System.Text;
+using GalNet.Core.Assets;
 using GalNet.Core.Graph;
+using GalNet.Core.Serialization;
 using GalNet.Runtime.Loader;
 
 namespace GalNet.Storage.FileSystem;
 
 internal static class GameGraphContentLoader
 {
-    public static Graph Load(string rootDirectory, string graphRelativePath, string groupsRelativeDirectory, CancellationToken cancellationToken)
+    public static async Task<Graph> LoadResourcesAsync(IAssetManager assets, string graphId, CancellationToken cancellationToken,
+        IReadOnlySet<string>? installedStories = null, IReadOnlySet<string>? declaredStories = null)
     {
-        var graph = GraphLoader.LoadFromJson(File.ReadAllText(Path.Combine(rootDirectory, graphRelativePath)));
+        var graphFile = await assets.GetFileAsync(graphId, cancellationToken);
+        if (graphFile?.TypeId != "graph") throw new InvalidDataException("Required graph resource is missing or has the wrong type.");
+        var graph = GraphLoader.LoadFromJson(Encoding.UTF8.GetString(await graphFile.ReadAllBytesAsync(cancellationToken)));
+        if (graph.Id != graphFile.Id) throw new InvalidDataException("Graph resource identity does not match its payload.");
         foreach (var group in graph.Nodes.OfType<Group>())
         {
-            cancellationToken.ThrowIfCancellationRequested();
-            var path = Path.Combine(rootDirectory, groupsRelativeDirectory, $"{group.Id}.galgroup");
-            if (File.Exists(path)) GalgroupLoader.LoadIntoGroupFromContent(group, File.ReadAllText(path));
+            if (group.StoryPackage.Length > 0 && installedStories is not null)
+            {
+                if (declaredStories?.Contains(group.StoryPackage) != true) throw new InvalidDataException($"Graph references undeclared story package '{group.StoryPackage}'.");
+                if (!installedStories.Contains(group.StoryPackage)) { group.IsAvailable = false; continue; }
+            }
+            var file = await assets.GetFileAsync(group.ResourceId, cancellationToken);
+            if (file?.TypeId != "group") throw new InvalidDataException($"Required group resource '{group.ResourceId}' is missing or has the wrong type.");
+            GalgroupLoader.LoadIntoGroupFromContent(group, Encoding.UTF8.GetString(await file.ReadAllBytesAsync(cancellationToken)));
+        }
+        var groups = graph.Nodes.OfType<Group>().ToDictionary(group => group.Id, StringComparer.Ordinal);
+        foreach (var group in groups.Values.Where(group => !group.IsAvailable))
+        {
+            var visited = new HashSet<string>(StringComparer.Ordinal);
+            var current = group;
+            while (current.Entries.Count == 0)
+            {
+                if (!visited.Add(current.Id)) throw new InvalidDataException("Skipping absent story packages creates an empty-group cycle.");
+                var next = graph.Edges.FirstOrDefault(edge => edge.FromNodeId == current.Id && edge.FromOutlet == 0)?.ToNodeId;
+                if (next is null || !groups.TryGetValue(next, out current!)) break;
+            }
         }
         return graph;
     }
+
 }
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/GameInstallation.cs b/src/Infrastructure/GalNet.Storage.FileSystem/GameInstallation.cs
index 3bb86b9c..7cf16994 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/GameInstallation.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/GameInstallation.cs
@@ -1,13 +1,14 @@
 using GalNet.Assets.Provider;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
-using GalNet.Runtime.Content;
+using GalNet.GameHost.Content;
 
 namespace GalNet.Storage.FileSystem;
 
 /// <summary>Resolved game input: a development directory or a verified installed package directory.</summary>
 public sealed class GameInstallation
 {
+    private readonly Dictionary<IResourceTypeCatalog, Lazy<InstalledPackageSet>> _packageSets = new(ReferenceEqualityComparer.Instance);
     private GameInstallation(string rootDirectory, bool isPackaged)
     {
         RootDirectory = rootDirectory;
@@ -30,28 +31,37 @@ public static async Task<GameInstallation> OpenAsync(string path, CancellationTo
         }
 
         if (!Directory.Exists(fullPath)) throw new DirectoryNotFoundException($"Game directory was not found: {fullPath}");
-        return new GameInstallation(fullPath, Directory.EnumerateFiles(fullPath, "*.galnet", SearchOption.TopDirectoryOnly).Any());
+        return new GameInstallation(fullPath, File.Exists(Path.Combine(fullPath, GalNet.Assets.PackedGameDocuments.GameFileName))
+            || Directory.EnumerateFiles(fullPath, "*.galnet", SearchOption.TopDirectoryOnly).Any());
     }
 
-    public IGameContentProvider CreateContentProvider(IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes) => IsPackaged
-        ? new InstalledGameContentProvider(RootDirectory, resourceTypes, galleryTypes)
-        : new ProjectGameContentProvider(RootDirectory, resourceTypes, galleryTypes);
+    public IGameContentProvider CreateContentProvider(IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes, GameContentLoadOptions? options = null) => IsPackaged
+        ? new InstalledGameContentProvider(RootDirectory, resourceTypes, galleryTypes, options, () => Packages(resourceTypes))
+        : new ProjectGameContentProvider(RootDirectory, resourceTypes, galleryTypes, options);
 
-    /// <summary>Returns every resource PAK in descending relative-path priority, or the source directory.</summary>
+    /// <summary>Returns the session's verified base/story PAK selection, or development resources.</summary>
     public IReadOnlyList<IAssetProvider> CreateAssetProviders(IResourceTypeCatalog resourceTypes)
     {
         ArgumentNullException.ThrowIfNull(resourceTypes);
         var assetsDirectory = Path.Combine(RootDirectory, "Assets");
-        if (!IsPackaged) return [new LocalFileProvider(assetsDirectory, resourceTypes, optional: true)];
+        if (!IsPackaged) return [new CompiledStoryAssetProvider(RootDirectory), new LocalFileProvider(assetsDirectory, resourceTypes, optional: true)];
 
-        var providers = new List<IAssetProvider>();
-        var resourcePaksDirectory = Path.Combine(assetsDirectory, "Paks");
-        if (Directory.Exists(resourcePaksDirectory))
+        return Packages(resourceTypes).CreateProviders();
+    }
+
+    internal static IReadOnlyList<IAssetProvider> CreateInstalledAssetProviders(string rootDirectory, IResourceTypeCatalog resourceTypes)
+    {
+        return InstalledPackageSet.Load(rootDirectory, resourceTypes).CreateProviders();
+    }
+
+    private InstalledPackageSet Packages(IResourceTypeCatalog types)
+    {
+        Lazy<InstalledPackageSet> value;
+        lock (_packageSets)
         {
-            foreach (var pakPath in Directory.EnumerateFiles(resourcePaksDirectory, "*.pak", SearchOption.AllDirectories)
-                         .OrderByDescending(path => Path.GetRelativePath(resourcePaksDirectory, path), StringComparer.OrdinalIgnoreCase))
-                providers.Add(new PakFileProvider(pakPath, "assets", resourceTypes));
+            if (!_packageSets.TryGetValue(types, out value!))
+                _packageSets.Add(types, value = new(() => InstalledPackageSet.Load(RootDirectory, types)));
         }
-        return providers;
+        return value.Value;
     }
 }
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/GameLocalizationLoader.cs b/src/Infrastructure/GalNet.Storage.FileSystem/GameLocalizationLoader.cs
index a3a737cf..ef27bb00 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/GameLocalizationLoader.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/GameLocalizationLoader.cs
@@ -1,10 +1,11 @@
 using System.Globalization;
 using System.Text.Json;
+using GalNet.Assets;
 using GalNet.Core.Entry;
 using GalNet.Core.Graph;
 using GalNet.Core.I18n;
-using GalNet.Core.Settings;
-using GalNet.Runtime.Content;
+using GalNet.Core.Serialization;
+using GalNet.GameHost.Content;
 
 namespace GalNet.Storage.FileSystem;
 
@@ -13,7 +14,7 @@ public static class GameLocalizationLoader
 {
     private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);
 
-    public static GameLocalizationContent Load(string gameDirectory, Graph graph, ProjectSettings settings,
+    public static GameLocalizationContent Load(string gameDirectory, Graph graph, string? defaultCulture = null,
         CancellationToken cancellationToken = default)
     {
         var root = Path.Combine(Path.GetFullPath(gameDirectory), "I18n");
@@ -26,7 +27,7 @@ public static GameLocalizationContent Load(string gameDirectory, Graph graph, Pr
             RejectLink(charactersPath);
             try
             {
-                var definitions = JsonSerializer.Deserialize<List<CharacterDefinition>>(File.ReadAllText(charactersPath), JsonOptions)
+                var definitions = JsonCodec.Deserialize<List<CharacterDefinition>>(File.ReadAllText(charactersPath), JsonOptions)
                     ?? throw new InvalidDataException("Character catalog must be a JSON array.");
                 characters = new CharacterCatalog(definitions);
             }
@@ -55,11 +56,9 @@ public static GameLocalizationContent Load(string gameDirectory, Graph graph, Pr
                 var json = File.ReadAllText(path);
                 try
                 {
-                    using var document = JsonDocument.Parse(json);
-                    var keys = new HashSet<string>(StringComparer.Ordinal);
-                    ReadKeys(document.RootElement, "", keys);
-                    if (string.Equals(culture.Name, settings.TargetLocale.Code, StringComparison.OrdinalIgnoreCase))
-                        defaultKeys.UnionWith(keys);
+                    var text = new GameLocalizationSource(culture.Name, relative, json).ReadText();
+                    if (string.Equals(culture.Name, defaultCulture, StringComparison.OrdinalIgnoreCase))
+                        defaultKeys.UnionWith(text.Keys);
                 }
                 catch (JsonException error)
                 {
@@ -69,11 +68,12 @@ public static GameLocalizationContent Load(string gameDirectory, Graph graph, Pr
             }
         }
 
-        ValidateRequiredKeys(graph, characters, defaultKeys, settings.TargetLocale.Code);
+        if (defaultCulture is not null) ValidateRequiredKeys(graph, characters, defaultKeys, defaultCulture);
         var diagnostics = new List<GameLocalizationDiagnostic>();
         var externalSources = LoadExternal(Path.Combine(root, "External"), diagnostics, cancellationToken);
         return new GameLocalizationContent
         {
+            DefaultCulture = defaultCulture ?? "en-US",
             Characters = characters,
             Sources = sources.AsReadOnly(),
             ExternalSources = externalSources,
@@ -81,8 +81,42 @@ public static GameLocalizationContent Load(string gameDirectory, Graph graph, Pr
         };
     }
 
+    internal static GameLocalizationContent LoadPacked(string directory, Graph graph, PackedDocumentSet documents,
+        PackedDocumentSet languages, string? defaultCulture, CancellationToken cancellationToken)
+    {
+        var definitions = JsonCodec.Deserialize<List<CharacterDefinition>>(documents.GetText("characters.json"), JsonOptions)
+            ?? throw new InvalidDataException("Packed character catalog must be an array.");
+        var characters = new CharacterCatalog(definitions);
+        var sources = new List<GameLocalizationSource>();
+        var cultures = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var defaultKeys = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var path in languages.Documents.Keys.Order(StringComparer.Ordinal))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (!path.StartsWith("texts/", StringComparison.Ordinal) || !path.EndsWith(".json", StringComparison.Ordinal)
+                || path.Split('/').Length != 2) throw new InvalidDataException("Invalid packed language entry.");
+            var culture = CultureInfo.GetCultureInfo(path[6..^5]);
+            if (culture.Name.Length == 0 || !cultures.Add(culture.Name)) throw new InvalidDataException("Duplicate or invalid packed culture.");
+            var source = new GameLocalizationSource(culture.Name, path, languages.GetText(path));
+            var text = source.ReadText();
+            if (string.Equals(culture.Name, defaultCulture, StringComparison.OrdinalIgnoreCase)) defaultKeys.UnionWith(text.Keys);
+            sources.Add(source);
+        }
+        if (defaultCulture is not null) ValidateRequiredKeys(graph, characters, defaultKeys, defaultCulture);
+        var diagnostics = new List<GameLocalizationDiagnostic>();
+        var external = LoadExternal(Path.Combine(directory, "I18n"), diagnostics, cancellationToken, "I18n");
+        return new GameLocalizationContent
+        {
+            DefaultCulture = defaultCulture ?? "en-US",
+            Characters = characters,
+            Sources = sources.AsReadOnly(),
+            ExternalSources = external,
+            Diagnostics = diagnostics.AsReadOnly()
+        };
+    }
+
     private static IReadOnlyList<GameLocalizationSource> LoadExternal(string root,
-        List<GameLocalizationDiagnostic> diagnostics, CancellationToken cancellationToken)
+        List<GameLocalizationDiagnostic> diagnostics, CancellationToken cancellationToken, string sourcePrefix = "External")
     {
         var sources = new List<GameLocalizationSource>();
         if (!Directory.Exists(root)) return sources;
@@ -100,36 +134,22 @@ private static IReadOnlyList<GameLocalizationSource> LoadExternal(string root,
                     if (!relative.Contains('/')) throw new InvalidDataException("External JSON must be below a culture directory.");
                     var culture = CultureInfo.GetCultureInfo(relative.Split('/')[0]);
                     var json = File.ReadAllText(path);
-                    using var document = JsonDocument.Parse(json);
-                    ReadKeys(document.RootElement, "", new(StringComparer.Ordinal));
-                    sources.Add(new(culture.Name, $"External/{relative}", json));
+                    _ = new GameLocalizationSource(culture.Name, relative, json).ReadText();
+                    sources.Add(new(culture.Name, $"{sourcePrefix}/{relative}", json));
                 }
                 catch (Exception error) when (error is IOException or InvalidDataException or UnauthorizedAccessException or JsonException or ArgumentException)
                 {
-                    diagnostics.Add(new($"External/{relative}", error.Message));
+                    diagnostics.Add(new($"{sourcePrefix}/{relative}", error.Message));
                 }
             }
         }
         catch (Exception error) when (error is IOException or InvalidDataException or UnauthorizedAccessException)
         {
-            diagnostics.Add(new("External", error.Message));
+            diagnostics.Add(new(sourcePrefix, error.Message));
         }
         return sources.AsReadOnly();
     }
 
-    private static void ReadKeys(JsonElement element, string prefix, HashSet<string> keys)
-    {
-        if (element.ValueKind != JsonValueKind.Object) throw new InvalidDataException("Localization documents must contain JSON objects with string leaves.");
-        foreach (var property in element.EnumerateObject())
-        {
-            if (string.IsNullOrWhiteSpace(property.Name)) throw new InvalidDataException("Localization keys cannot be empty.");
-            var key = prefix.Length == 0 ? property.Name : $"{prefix}.{property.Name}";
-            if (property.Value.ValueKind == JsonValueKind.Object) ReadKeys(property.Value, key, keys);
-            else if (property.Value.ValueKind == JsonValueKind.String) keys.Add(key);
-            else throw new InvalidDataException($"Localization key '{key}' must have a string value.");
-        }
-    }
-
     private static void ValidateRequiredKeys(Graph graph, CharacterCatalog characters, HashSet<string> defaultKeys, string defaultCulture)
     {
         foreach (var character in characters.Characters) Require(character.DisplayNameKey);
@@ -138,7 +158,7 @@ private static void ValidateRequiredKeys(Graph graph, CharacterCatalog character
             {
                 if (entry.Type is not ("dialogue.text" or "nvl.append")) continue;
                 if (entry.Type == "dialogue.text" && entry.Arguments.TryGetProperty("speaker", out var speaker)
-                    && !string.IsNullOrEmpty(speaker.GetString())) characters.GetRequired(speaker.GetString()!);
+                    && !string.IsNullOrWhiteSpace(speaker.GetString())) characters.GetRequired(speaker.GetString()!);
                 Require(entry.Arguments.TryGetProperty("content", out var content) ? content.GetString() ?? "" : "");
             }
         foreach (var branch in graph.Nodes.OfType<Branch>().Where(branch => branch.BranchType == BranchType.Choice))
@@ -146,7 +166,8 @@ private static void ValidateRequiredKeys(Graph graph, CharacterCatalog character
 
         void Require(string key)
         {
-            if (string.IsNullOrWhiteSpace(key) || !defaultKeys.Contains(key))
+            if (string.IsNullOrWhiteSpace(key)) return;
+            if (!defaultKeys.Contains(key))
                 throw new InvalidDataException($"Default language '{defaultCulture}' is missing required localization key '{key}'.");
         }
     }
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/GameProjectConfigurationLoader.cs b/src/Infrastructure/GalNet.Storage.FileSystem/GameProjectConfigurationLoader.cs
new file mode 100644
index 00000000..0ac44c03
--- /dev/null
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/GameProjectConfigurationLoader.cs
@@ -0,0 +1,30 @@
+using System.Text.Json;
+using GalNet.Core.Configuration;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Storage.FileSystem;
+
+internal static class GameProjectConfigurationLoader
+{
+    public static ProjectConfiguration Load(string directory, ProjectConfigurationSchema? schema = null)
+    {
+        var path = Path.Combine(directory, "settings.json");
+        if (!File.Exists(path)) return new ProjectConfiguration();
+        return LoadJson(File.ReadAllText(path), schema, path);
+    }
+
+    internal static ProjectConfiguration LoadJson(string json, ProjectConfigurationSchema? schema, string sourceName)
+    {
+        try
+        {
+            var settings = JsonCodec.Deserialize<ProjectConfiguration>(json)
+                ?? throw new InvalidDataException("Project settings must be a JSON object.");
+            schema?.Validate(settings);
+            return settings;
+        }
+        catch (JsonException error)
+        {
+            throw new InvalidDataException($"Invalid project settings in '{sourceName}'.", error);
+        }
+    }
+}
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/GameProjectSettingsLoader.cs b/src/Infrastructure/GalNet.Storage.FileSystem/GameProjectSettingsLoader.cs
deleted file mode 100644
index 327468a2..00000000
--- a/src/Infrastructure/GalNet.Storage.FileSystem/GameProjectSettingsLoader.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using GalNet.Core.Settings;
-
-namespace GalNet.Storage.FileSystem;
-
-internal static class GameProjectSettingsLoader
-{
-    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
-    {
-        Converters = { new JsonStringEnumConverter() }
-    };
-
-    public static ProjectSettings Load(string directory)
-    {
-        var path = Path.Combine(directory, "settings.json");
-        if (!File.Exists(path)) return new ProjectSettings();
-        try
-        {
-            return JsonSerializer.Deserialize<ProjectSettings>(File.ReadAllText(path), JsonOptions)
-                ?? throw new InvalidDataException("Project settings must be a JSON object.");
-        }
-        catch (JsonException error)
-        {
-            throw new InvalidDataException($"Invalid project settings in '{path}'.", error);
-        }
-    }
-}
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/GameResourceScope.cs b/src/Infrastructure/GalNet.Storage.FileSystem/GameResourceScope.cs
index 5aad9d9e..c32eebfe 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/GameResourceScope.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/GameResourceScope.cs
@@ -1,7 +1,7 @@
 using GalNet.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
-using GalNet.Runtime.Content;
+using GalNet.GameHost.Content;
 
 namespace GalNet.Storage.FileSystem;
 
@@ -22,10 +22,10 @@ private GameResourceScope(string directory, GameContent content, AssetManager as
 
     public static async Task<GameResourceScope> OpenAsync(string directory,
         IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes,
-        CancellationToken cancellationToken = default)
+        GameContentLoadOptions? options = null, CancellationToken cancellationToken = default)
     {
         var installation = await GameInstallation.OpenAsync(directory, cancellationToken);
-        var content = await installation.CreateContentProvider(resourceTypes, galleryTypes).LoadAsync(cancellationToken);
+        var content = await installation.CreateContentProvider(resourceTypes, galleryTypes, options).LoadAsync(cancellationToken);
         var assets = new AssetManager(installation.CreateAssetProviders(resourceTypes));
         try { return new GameResourceScope(installation.RootDirectory, content, assets); }
         catch { assets.Dispose(); throw; }
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/InstalledGameContentProvider.cs b/src/Infrastructure/GalNet.Storage.FileSystem/InstalledGameContentProvider.cs
index 57e52cd0..dbaa8ade 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/InstalledGameContentProvider.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/InstalledGameContentProvider.cs
@@ -1,6 +1,7 @@
+using GalNet.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
-using GalNet.Runtime.Content;
+using GalNet.GameHost.Content;
 
 namespace GalNet.Storage.FileSystem;
 
@@ -8,22 +9,40 @@ namespace GalNet.Storage.FileSystem;
 public sealed class InstalledGameContentProvider : IGameContentProvider
 {
     private readonly string _directory;
+    private readonly GameContentLoadOptions _options;
     private readonly IGalleryTypeCatalog _galleryTypes;
+    private readonly IResourceTypeCatalog _resourceTypes;
+    private readonly Func<InstalledPackageSet>? _packages;
 
-    public InstalledGameContentProvider(string directory, IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes)
+    public InstalledGameContentProvider(string directory, IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes, GameContentLoadOptions? options = null)
     {
         _directory = Path.GetFullPath(directory);
+        _options = options ?? new();
         ArgumentNullException.ThrowIfNull(resourceTypes);
+        _resourceTypes = resourceTypes;
         _galleryTypes = galleryTypes ?? throw new ArgumentNullException(nameof(galleryTypes));
     }
 
-    public Task<GameContent> LoadAsync(CancellationToken cancellationToken = default) => Task.Run(() =>
+    internal InstalledGameContentProvider(string directory, IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes,
+        GameContentLoadOptions? options, Func<InstalledPackageSet> packages) : this(directory, resourceTypes, galleryTypes, options) => _packages = packages;
+
+    public Task<GameContent> LoadAsync(CancellationToken cancellationToken = default) => Task.Run(async () =>
     {
         cancellationToken.ThrowIfCancellationRequested();
-        var graph = GameGraphContentLoader.Load(_directory, Path.Combine("Graph", "graph.json"), Path.Combine("Graph", "groups"), cancellationToken);
-        var gallery = GalleryFileLoader.LoadGenerated(Path.Combine(_directory, "gallery.json"), _galleryTypes);
-        var settings = GameProjectSettingsLoader.Load(_directory);
-        var localization = GameLocalizationLoader.Load(_directory, graph, settings, cancellationToken);
-        return new GameContent { Graph = graph, Gallery = gallery, Settings = settings, Localization = localization };
+        var packages = _packages?.Invoke() ?? InstalledPackageSet.Load(_directory, _resourceTypes);
+        using var assets = new AssetManager(packages.CreateProviders());
+        var graph = await GameGraphContentLoader.LoadResourcesAsync(assets, packages.Manifest.GraphId, cancellationToken,
+            packages.InstalledStories, packages.Manifest.Stories.Select(story => story.PackageId).ToHashSet(StringComparer.Ordinal));
+        graph.ContentBuildId = packages.Manifest.BuildId;
+        graph.InstalledStoryPackages = packages.InstalledStories.Order(StringComparer.Ordinal).ToArray();
+        var documents = packages.GamePackage?.Documents;
+        var gallery = documents is null ? GalleryFileLoader.LoadGenerated(Path.Combine(_directory, "gallery.json"), _galleryTypes)
+            : GalleryFileLoader.LoadGeneratedJson(documents.GetText("gallery.json"), _galleryTypes, "game.pak/gallery.json");
+        var settings = documents is null ? GameProjectConfigurationLoader.Load(_directory, _options.Configurations)
+            : GameProjectConfigurationLoader.LoadJson(documents.GetText("settings.json"), _options.Configurations, "game.pak/settings.json");
+        var culture = _options.SelectDefaultCulture?.Invoke(settings);
+        var localization = documents is null ? GameLocalizationLoader.Load(_directory, graph, culture, cancellationToken)
+            : GameLocalizationLoader.LoadPacked(_directory, graph, documents, packages.Localization!, culture, cancellationToken);
+        return new GameContent { Graph = graph, Gallery = gallery, Configuration = settings, Localization = localization };
     }, cancellationToken);
 }
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/InstalledGameDescriptor.cs b/src/Infrastructure/GalNet.Storage.FileSystem/InstalledGameDescriptor.cs
new file mode 100644
index 00000000..91ea7901
--- /dev/null
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/InstalledGameDescriptor.cs
@@ -0,0 +1,28 @@
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Storage.FileSystem;
+
+/// <summary>Reads a content identity from its fixed packed entry, with legacy directory compatibility.</summary>
+public static class InstalledGameDescriptor
+{
+    public static GameContentManifest Read(string directory)
+    {
+        var packed = Path.Combine(directory, PackedGameDocuments.GameFileName);
+        if (File.Exists(packed)) return PackedGameDocuments.ReadGame(File.ReadAllBytes(packed)).Manifest;
+        return JsonCodec.Deserialize<GameContentManifest>(File.ReadAllText(Path.Combine(directory, GameContentManifest.FileName)),
+            new JsonSerializerOptions(JsonSerializerDefaults.Web) { AllowDuplicateProperties = false })
+            ?? throw new InvalidDataException("Missing content descriptor.");
+    }
+
+    internal static void EnsureExtensionDirectories(string directory, string buildId)
+    {
+        foreach (var relative in PackedGameDocuments.ExtensionDirectories(buildId))
+        {
+            var path = FileSystemPaths.ResolveRelativeFile(directory, relative);
+            FileSystemPaths.RequireNoLinks(path, "Extension directories cannot be symbolic links.");
+            Directory.CreateDirectory(path);
+        }
+    }
+}
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/InstalledPackageSet.cs b/src/Infrastructure/GalNet.Storage.FileSystem/InstalledPackageSet.cs
new file mode 100644
index 00000000..17ad79e5
--- /dev/null
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/InstalledPackageSet.cs
@@ -0,0 +1,180 @@
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Assets.Provider;
+using GalNet.Core.Assets;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Storage.FileSystem;
+
+/// <summary>A validated immutable package selection. Providers verify those same bytes on each later open.</summary>
+internal sealed class InstalledPackageSet
+{
+    private sealed record Pak(string Path, string Hash, string PackageId, IReadOnlyList<IGameFile> Index);
+    private readonly List<Pak> _paks = [];
+    private readonly List<ResourceOverrideSource> _overrides = [];
+    private readonly IResourceTypeCatalog _types;
+    public GameContentManifest Manifest { get; }
+    public PackedGamePackage? GamePackage { get; private init; }
+    public PackedDocumentSet? Localization { get; private set; }
+    public HashSet<string> InstalledStories { get; } = new(StringComparer.Ordinal);
+    private InstalledPackageSet(GameContentManifest manifest, IResourceTypeCatalog types) { Manifest = manifest; _types = types; }
+    public IReadOnlyList<IAssetProvider> CreateProviders() => [new ResourceOverlayProvider(_paks.SelectMany(pak =>
+        pak.Index.Select(file => new ResourceFileSource(file, new PakFileProvider(pak.Path, "assets", _types, expectedSha256: pak.Hash)))).ToArray(), _overrides, _types)];
+
+    public static InstalledPackageSet Load(string root, IResourceTypeCatalog types)
+    {
+        var packedPath = Path.Combine(root, PackedGameDocuments.GameFileName);
+        var packed = File.Exists(packedPath) ? PackedGameDocuments.ReadGame(File.ReadAllBytes(packedPath)) : null;
+        var path = Path.Combine(root, GameContentManifest.FileName);
+        if (packed is null && !File.Exists(path)) throw new InvalidDataException("Installed content requires game.pak or a legacy content.json. Re-export the game.");
+        var manifest = packed?.Manifest ?? JsonCodec.Deserialize<GameContentManifest>(File.ReadAllText(path), new JsonSerializerOptions(JsonSerializerDefaults.Web)
+        { AllowDuplicateProperties = false, UnmappedMemberHandling = System.Text.Json.Serialization.JsonUnmappedMemberHandling.Disallow })
+            ?? throw new InvalidDataException("Missing content manifest.");
+        if (manifest.Version != (packed is null ? 2 : 3) || manifest.GraphId != StoryResourceIds.Graph || string.IsNullOrWhiteSpace(manifest.ProjectId)
+            || !Hash(manifest.BuildId) || manifest.BasePaks is not { Count: > 0 } || manifest.Stories is null)
+            throw new InvalidDataException("Unsupported or incomplete content manifest.");
+        var result = new InstalledPackageSet(manifest, types) { GamePackage = packed };
+        if (packed is not null)
+        {
+            var expected = manifest.LocalizationPak!;
+            var bytes = File.ReadAllBytes(Path.Combine(root, PackedGameDocuments.LocalizationFileName));
+            if (bytes.LongLength != expected.Size || CryptoHelper.HashSHA256(bytes) != expected.Sha256)
+                throw new InvalidDataException("Packed localization failed integrity verification.");
+            result.Localization = PackedGameDocuments.Read(bytes);
+            if (result.Localization.Descriptor.ProjectId != manifest.ProjectId || result.Localization.Descriptor.BuildId != manifest.BuildId)
+                throw new InvalidDataException("Packed localization belongs to another content build.");
+        }
+        var filePaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        for (var index = 0; index < manifest.BasePaks.Count; index++)
+        {
+            var expected = manifest.BasePaks[index];
+            if (expected?.Path is null || !expected.Path.StartsWith("Assets/Paks/", StringComparison.Ordinal) || !filePaths.Add(expected.Path))
+                throw new InvalidDataException("Invalid or duplicate base PAK path.");
+            result._paks.Add(result.Read(FileSystemPaths.ResolveRelativeFile(root, expected.Path), expected, "base", "", index, manifest.BasePaks.Count));
+        }
+        var definitions = new Dictionary<string, StoryPackageManifest>(StringComparer.Ordinal);
+        foreach (var story in manifest.Stories)
+        {
+            if (story is null || string.IsNullOrWhiteSpace(story.PackageId) || story.Parts is not { Count: > 0 } || !definitions.TryAdd(story.PackageId, story))
+                throw new InvalidDataException("Invalid story package definition.");
+            foreach (var part in story.Parts)
+                if (part?.Path is null || !part.Path.StartsWith("StoryPatches/" + manifest.BuildId + "/", StringComparison.Ordinal)
+                    || !filePaths.Add(part.Path) || !Hash(part.Sha256) || part.Size < 0)
+                    throw new InvalidDataException("Invalid story part descriptor.");
+        }
+        var installed = new Dictionary<(string Package, int Index), Pak>();
+        var hashes = new HashSet<string>(StringComparer.Ordinal);
+        var roots = new[] { Path.Combine(root, "StoryPatches", manifest.BuildId),
+            Path.Combine(Path.GetDirectoryName(Path.GetFullPath(root)) ?? root, "StoryPatches", manifest.BuildId) }.Distinct(StringComparer.OrdinalIgnoreCase);
+        foreach (var directory in roots.Where(Directory.Exists))
+        {
+            if ((File.GetAttributes(directory) & FileAttributes.ReparsePoint) != 0) throw new InvalidDataException("Story package directories cannot be links.");
+            foreach (var candidate in Directory.EnumerateFiles(directory, "*.pak").Order(StringComparer.Ordinal))
+            {
+                var bytes = File.ReadAllBytes(candidate);
+                var hash = CryptoHelper.HashSHA256(bytes);
+                if (!hashes.Add(hash)) continue;
+                using var archive = Archive.Deserialize("assets", bytes, types);
+                var control = archive.Descriptor;
+                if (control.Kind != "story" || !definitions.TryGetValue(control.PackageId, out var definition)
+                    || control.PartIndex >= definition.Parts.Count)
+                    throw new InvalidDataException("Unrecognized story PAK in the current build's package directory.");
+                var pak = result.Read(candidate, definition.Parts[control.PartIndex], "story", control.PackageId,
+                    control.PartIndex, definition.Parts.Count, bytes);
+                if (!installed.TryAdd((control.PackageId, control.PartIndex), pak)) throw new InvalidDataException("Conflicting story package parts.");
+            }
+        }
+        foreach (var story in manifest.Stories)
+        {
+            var own = installed.Where(pair => pair.Key.Package == story.PackageId).OrderBy(pair => pair.Key.Index).Select(pair => pair.Value).ToArray();
+            if (own.Length == 0) continue;
+            if (own.Length != story.Parts.Count) throw new InvalidDataException($"Story package '{story.PackageId}' is only partially installed.");
+            result.InstalledStories.Add(story.PackageId);
+            result._paks.AddRange(own);
+        }
+        result.ValidateDependencies();
+        result.LoadOverrides(root);
+        return result;
+    }
+
+    private void LoadOverrides(string root)
+    {
+        var hashes = new HashSet<string>(StringComparer.Ordinal);
+        var directories = new[] { Path.Combine(root, "ResourcePatches"),
+            Path.Combine(Path.GetDirectoryName(Path.GetFullPath(root)) ?? root, "ResourcePatches") }.Distinct(StringComparer.OrdinalIgnoreCase);
+        foreach (var directory in directories.Where(Directory.Exists))
+        {
+            if ((File.GetAttributes(directory) & FileAttributes.ReparsePoint) != 0) throw new InvalidDataException("Resource patch directory cannot be a link.");
+            foreach (var path in Directory.EnumerateFiles(directory, "*.pak").Order(StringComparer.Ordinal))
+            {
+                var bytes = File.ReadAllBytes(path);
+                var hash = CryptoHelper.HashSHA256(bytes);
+                if (!hashes.Add(hash)) continue;
+                using var archive = Archive.Deserialize("assets", bytes, _types);
+                var descriptor = archive.Descriptor;
+                if (descriptor.Kind != "override" || descriptor.ProjectId != Manifest.ProjectId || descriptor.BuildId.Length != 0)
+                    throw new InvalidDataException("Resource override PAK has the wrong kind/project or binds a base build.");
+                foreach (var id in archive.AssetIds) _ = archive.GetAsset(id)!.ReadAllBytes();
+                var files = archive.MetadataIndex.Select(entry => (IGameFile)new IndexFile(entry)).ToArray();
+                if (files.Any(file => file.TypeId is "graph" or "group")) throw new InvalidDataException("Resource overrides cannot carry graph/group resources.");
+                _ = AssetDependencyCollector.Collect(files, files.Select(file => file.Id), _types, declaredComplete: files.Select(file => file.Id));
+                var provider = new PakFileProvider(path, "assets", _types, expectedSha256: hash);
+                _overrides.Add(new(descriptor, hash, files.Select(file => new ResourceFileSource(file, provider)).ToArray()));
+            }
+        }
+        // Resolve once during preparation, so invalid mappings cannot be swallowed as a presentation fallback.
+        _ = CreateProviders();
+    }
+
+    private Pak Read(string path, GalpakFileEntry expected, string kind, string packageId, int index, int count, byte[]? bytes = null)
+    {
+        if (!Hash(expected.Sha256) || expected.Size < 0) throw new InvalidDataException("Invalid PAK checksum descriptor.");
+        if (!File.Exists(path)) throw new InvalidDataException($"Required PAK '{expected.Path}' is missing.");
+        bytes ??= File.ReadAllBytes(path);
+        if (bytes.LongLength != expected.Size || CryptoHelper.HashSHA256(bytes) != expected.Sha256)
+            throw new InvalidDataException($"PAK '{expected.Path}' failed integrity verification.");
+        using var archive = Archive.Deserialize("assets", bytes, _types);
+        var control = archive.Descriptor;
+        if (control.Kind != kind || control.ProjectId != Manifest.ProjectId || control.BuildId != Manifest.BuildId
+            || control.PackageId != packageId || control.PartIndex != index || control.PartCount != count)
+            throw new InvalidDataException($"PAK '{expected.Path}' does not belong to the declared content build or part set.");
+        return new(path, expected.Sha256, packageId, archive.MetadataIndex.Select(entry => (IGameFile)new IndexFile(entry)).ToArray());
+    }
+
+    private void ValidateDependencies()
+    {
+        var all = new Dictionary<string, IGameFile>(StringComparer.OrdinalIgnoreCase);
+        var codec = new AssetMetaCodec(_types);
+        foreach (var file in _paks.SelectMany(pak => pak.Index))
+        {
+            if (all.TryGetValue(file.Id, out var previous))
+            {
+                if (previous.Hash != file.Hash || previous.Length != file.Length || codec.Serialize(previous.Metadata) != codec.Serialize(file.Metadata))
+                    throw new InvalidDataException($"Story/base packages contain different versions of resource '{file.Id}'.");
+            }
+            else all.Add(file.Id, file);
+        }
+        var baseline = _paks.Where(pak => pak.PackageId.Length == 0).SelectMany(pak => pak.Index).DistinctBy(file => file.Id, StringComparer.OrdinalIgnoreCase).ToArray();
+        _ = AssetDependencyCollector.Collect(baseline, baseline.Select(file => file.Id), _types, declaredComplete: baseline.Select(file => file.Id));
+        foreach (var package in InstalledStories)
+        {
+            var own = _paks.Where(pak => pak.PackageId == package).SelectMany(pak => pak.Index).ToArray();
+            var available = baseline.Concat(own).DistinctBy(file => file.Id, StringComparer.OrdinalIgnoreCase).ToArray();
+            _ = AssetDependencyCollector.Collect(available, own.Select(file => file.Id), _types, package, available.Select(file => file.Id));
+        }
+    }
+
+    private static bool Hash(string value) => value is { Length: 64 } && value.All(c => c is >= '0' and <= '9' or >= 'a' and <= 'f');
+    private sealed class IndexFile(PakAssetIndexEntry entry) : IGameFile
+    {
+        public string Id => entry.Id;
+        public string Path => entry.Path;
+        public string TypeId => entry.TypeId;
+        public AssetMeta Metadata => entry.Metadata;
+        public long Length => entry.Length;
+        public string? Hash => entry.Hash;
+        public Stream OpenRead() => throw new InvalidOperationException("This is a metadata-only dependency index.");
+        public byte[] ReadAllBytes() => throw new InvalidOperationException("This is a metadata-only dependency index.");
+        public Task<byte[]> ReadAllBytesAsync(CancellationToken ct = default) => throw new InvalidOperationException("This is a metadata-only dependency index.");
+    }
+}
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/ProjectGameContentProvider.cs b/src/Infrastructure/GalNet.Storage.FileSystem/ProjectGameContentProvider.cs
index 6deb760a..c0e2e4cc 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/ProjectGameContentProvider.cs
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/ProjectGameContentProvider.cs
@@ -1,7 +1,8 @@
+using GalNet.Assets;
 using GalNet.Assets.Provider;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
-using GalNet.Runtime.Content;
+using GalNet.GameHost.Content;
 
 namespace GalNet.Storage.FileSystem;
 
@@ -9,27 +10,30 @@ namespace GalNet.Storage.FileSystem;
 public sealed class ProjectGameContentProvider : IGameContentProvider
 {
     private readonly string _directory;
+    private readonly GameContentLoadOptions _options;
     private readonly IResourceTypeCatalog _resourceTypes;
     private readonly IGalleryTypeCatalog _galleryTypes;
 
-    public ProjectGameContentProvider(string directory, IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes)
+    public ProjectGameContentProvider(string directory, IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes, GameContentLoadOptions? options = null)
     {
         _directory = Path.GetFullPath(directory);
+        _options = options ?? new();
         _resourceTypes = resourceTypes ?? throw new ArgumentNullException(nameof(resourceTypes));
         _galleryTypes = galleryTypes ?? throw new ArgumentNullException(nameof(galleryTypes));
     }
 
-    public Task<GameContent> LoadAsync(CancellationToken cancellationToken = default) => Task.Run(() =>
+    public Task<GameContent> LoadAsync(CancellationToken cancellationToken = default) => Task.Run(async () =>
     {
         cancellationToken.ThrowIfCancellationRequested();
-        var graph = GameGraphContentLoader.Load(_directory, Path.Combine("Graph", "graph.json"), Path.Combine("Graph", "groups"), cancellationToken);
+        using var storyAssets = new AssetManager([new CompiledStoryAssetProvider(_directory)]);
+        var graph = await GameGraphContentLoader.LoadResourcesAsync(storyAssets, StoryResourceIds.Graph, cancellationToken);
         var assetsDirectory = Path.Combine(_directory, "Assets");
         using var assets = new LocalFileProvider(assetsDirectory, _resourceTypes, optional: true);
         using var archive = assets.OpenArchive("assets");
         var gallery = new GalleryCatalogCompiler(_resourceTypes, _galleryTypes)
             .Compile(archive.AssetIds.Select(id => archive.GetAsset(id)!.Metadata));
-        var settings = GameProjectSettingsLoader.Load(_directory);
-        var localization = GameLocalizationLoader.Load(_directory, graph, settings, cancellationToken);
-        return new GameContent { Graph = graph, AssetRoot = assetsDirectory, Gallery = gallery, Settings = settings, Localization = localization };
+        var settings = GameProjectConfigurationLoader.Load(_directory, _options.Configurations);
+        var localization = GameLocalizationLoader.Load(_directory, graph, _options.SelectDefaultCulture?.Invoke(settings), cancellationToken);
+        return new GameContent { Graph = graph, Gallery = gallery, Configuration = settings, Localization = localization };
     }, cancellationToken);
 }
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/StorageJsonContext.cs b/src/Infrastructure/GalNet.Storage.FileSystem/StorageJsonContext.cs
new file mode 100644
index 00000000..a21583e3
--- /dev/null
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/StorageJsonContext.cs
@@ -0,0 +1,8 @@
+using System.Text.Json.Serialization;
+
+namespace GalNet.Storage.FileSystem;
+
+[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata)]
+[JsonSerializable(typeof(FileSaveService.StoredSave))]
+[JsonSerializable(typeof(FileGameProgressService.ProgressData))]
+internal sealed partial class StorageJsonContext : JsonSerializerContext;
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/packages.lock.WindowsReadyToRun.json b/src/Infrastructure/GalNet.Storage.FileSystem/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..35fef03e
--- /dev/null
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,68 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Serilog": {
+        "type": "CentralTransitive",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Infrastructure/GalNet.Storage.FileSystem/packages.lock.json b/src/Infrastructure/GalNet.Storage.FileSystem/packages.lock.json
index 1647d3ba..7d30f201 100644
--- a/src/Infrastructure/GalNet.Storage.FileSystem/packages.lock.json
+++ b/src/Infrastructure/GalNet.Storage.FileSystem/packages.lock.json
@@ -8,6 +8,13 @@
         "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
       },
       "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
         "type": "Project",
         "dependencies": {
           "GalNet.Core": "[1.0.0, )"
@@ -19,6 +26,7 @@
       "galnet.gamehost": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
@@ -27,6 +35,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -35,7 +44,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/src/Launcher/GalNet.Launcher.Android/Application.cs b/src/Launcher/GalNet.Launcher.Android/Application.cs
deleted file mode 100644
index 79ca3180..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Application.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using Android.App;
-using Android.Runtime;
-using Avalonia;
-using Avalonia.Android;
-
-namespace GalNet.Launcher.Android
-{
-    [Application]
-    public class Application : AvaloniaAndroidApplication<App>
-    {
-        protected Application(nint javaReference, JniHandleOwnership transfer) : base(javaReference, transfer)
-        {
-        }
-
-        protected override AppBuilder CustomizeAppBuilder(AppBuilder builder)
-        {
-            return base.CustomizeAppBuilder(builder)
-            .WithInterFont();
-        }
-    }
-}
diff --git a/src/Launcher/GalNet.Launcher.Android/GalNet.Launcher.Android.csproj b/src/Launcher/GalNet.Launcher.Android/GalNet.Launcher.Android.csproj
deleted file mode 100644
index 0e7be3f7..00000000
--- a/src/Launcher/GalNet.Launcher.Android/GalNet.Launcher.Android.csproj
+++ /dev/null
@@ -1,28 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net10.0-android</TargetFramework>
-    <SupportedOSPlatformVersion>23</SupportedOSPlatformVersion>
-    <Nullable>enable</Nullable>
-    <ApplicationId>com.CompanyName.GalNet.Launcher</ApplicationId>
-    <ApplicationVersion>1</ApplicationVersion>
-    <ApplicationDisplayVersion>1.0</ApplicationDisplayVersion>
-    <AndroidPackageFormat>apk</AndroidPackageFormat>
-    <AndroidEnableProfiledAot>false</AndroidEnableProfiledAot>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <AndroidResource Include="Icon.png">
-      <Link>Resources\drawable\Icon.png</Link>
-    </AndroidResource>
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Avalonia.Android" />
-    <PackageReference Include="Xamarin.AndroidX.Core.SplashScreen" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\GalNet.Launcher\GalNet.Launcher.csproj" />
-  </ItemGroup>
-</Project>
diff --git a/src/Launcher/GalNet.Launcher.Android/Icon.png b/src/Launcher/GalNet.Launcher.Android/Icon.png
deleted file mode 100644
index 3c398459..00000000
Binary files a/src/Launcher/GalNet.Launcher.Android/Icon.png and /dev/null differ
diff --git a/src/Launcher/GalNet.Launcher.Android/MainActivity.cs b/src/Launcher/GalNet.Launcher.Android/MainActivity.cs
deleted file mode 100644
index 817a739e..00000000
--- a/src/Launcher/GalNet.Launcher.Android/MainActivity.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-using Android.App;
-using Android.Content.PM;
-using Avalonia;
-using Avalonia.Android;
-
-namespace GalNet.Launcher.Android;
-
-[Activity(
-    Label = "GalNet.Launcher.Android",
-    Theme = "@style/MyTheme.NoActionBar",
-    Icon = "@drawable/icon",
-    MainLauncher = true,
-    ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize | ConfigChanges.UiMode)]
-public class MainActivity : AvaloniaMainActivity
-{
-}
diff --git a/src/Launcher/GalNet.Launcher.Android/Properties/AndroidManifest.xml b/src/Launcher/GalNet.Launcher.Android/Properties/AndroidManifest.xml
deleted file mode 100644
index 33080016..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Properties/AndroidManifest.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:installLocation="auto">
-	<uses-permission android:name="android.permission.INTERNET" />
-	<application android:label="GalNet.Launcher" android:icon="@drawable/Icon" />
-</manifest>
diff --git a/src/Launcher/GalNet.Launcher.Android/Resources/AboutResources.txt b/src/Launcher/GalNet.Launcher.Android/Resources/AboutResources.txt
deleted file mode 100644
index c2bca974..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Resources/AboutResources.txt
+++ /dev/null
@@ -1,44 +0,0 @@
-Images, layout descriptions, binary blobs and string dictionaries can be included 
-in your application as resource files.  Various Android APIs are designed to 
-operate on the resource IDs instead of dealing with images, strings or binary blobs 
-directly.
-
-For example, a sample Android app that contains a user interface layout (main.axml),
-an internationalization string table (strings.xml) and some icons (drawable-XXX/icon.png) 
-would keep its resources in the "Resources" directory of the application:
-
-Resources/
-    drawable/
-        icon.png
-
-    layout/
-        main.axml
-
-    values/
-        strings.xml
-
-In order to get the build system to recognize Android resources, set the build action to
-"AndroidResource".  The native Android APIs do not operate directly with filenames, but 
-instead operate on resource IDs.  When you compile an Android application that uses resources, 
-the build system will package the resources for distribution and generate a class called "R" 
-(this is an Android convention) that contains the tokens for each one of the resources 
-included. For example, for the above Resources layout, this is what the R class would expose:
-
-public class R {
-    public class drawable {
-        public const int icon = 0x123;
-    }
-
-    public class layout {
-        public const int main = 0x456;
-    }
-
-    public class strings {
-        public const int first_string = 0xabc;
-        public const int second_string = 0xbcd;
-    }
-}
-
-You would then use R.drawable.icon to reference the drawable/icon.png file, or R.layout.main 
-to reference the layout/main.axml file, or R.strings.first_string to reference the first 
-string in the dictionary file values/strings.xml.
\ No newline at end of file
diff --git a/src/Launcher/GalNet.Launcher.Android/Resources/drawable-night-v31/avalonia_anim.xml b/src/Launcher/GalNet.Launcher.Android/Resources/drawable-night-v31/avalonia_anim.xml
deleted file mode 100644
index dde4b5a7..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Resources/drawable-night-v31/avalonia_anim.xml
+++ /dev/null
@@ -1,66 +0,0 @@
-<animated-vector
-  xmlns:android="http://schemas.android.com/apk/res/android"
-  xmlns:aapt="http://schemas.android.com/aapt">
-  <aapt:attr name="android:drawable">
-    <vector
-      android:name="vector"
-      android:width="128dp"
-      android:height="128dp"
-      android:viewportWidth="128"
-      android:viewportHeight="128">
-      <group
-        android:name="wrapper"
-        android:translateX="21"
-        android:translateY="21">
-        <group android:name="group">
-          <path
-            android:name="path"
-            android:pathData="M 74.853 85.823 L 75.368 85.823 C 80.735 85.823 85.144 81.803 85.761 76.602 L 85.836 41.76 C 85.225 18.593 66.254 0 42.939 0 C 19.24 0 0.028 19.212 0.028 42.912 C 0.028 66.357 18.831 85.418 42.18 85.823 L 74.853 85.823 Z"
-            android:strokeWidth="1"/>
-          <path
-            android:name="path_1"
-            android:pathData="M 43.059 14.614 C 29.551 14.614 18.256 24.082 15.445 36.743 C 18.136 37.498 20.109 39.968 20.109 42.899 C 20.109 45.831 18.136 48.301 15.445 49.055 C 18.256 61.716 29.551 71.184 43.059 71.184 C 47.975 71.184 52.599 69.93 56.628 67.723 L 56.628 70.993 L 71.344 70.993 L 71.344 44.072 C 71.357 43.714 71.344 43.26 71.344 42.899 C 71.344 27.278 58.68 14.614 43.059 14.614 Z M 29.51 42.899 C 29.51 35.416 35.576 29.35 43.059 29.35 C 50.541 29.35 56.607 35.416 56.607 42.899 C 56.607 50.382 50.541 56.448 43.059 56.448 C 35.576 56.448 29.51 50.382 29.51 42.899 Z"
-            android:strokeWidth="1"
-            android:fillType="evenOdd"/>
-          <path
-            android:name="path_2"
-            android:pathData="M 18.105 42.88 C 18.105 45.38 16.078 47.407 13.579 47.407 C 11.079 47.407 9.052 45.38 9.052 42.88 C 9.052 40.381 11.079 38.354 13.579 38.354 C 16.078 38.354 18.105 40.381 18.105 42.88 Z"
-            android:strokeWidth="1"/>
-        </group>
-      </group>
-    </vector>
-  </aapt:attr>
-  <target android:name="path">
-    <aapt:attr name="android:animation">
-      <objectAnimator
-        android:propertyName="fillColor"
-        android:duration="1000"
-        android:valueFrom="#00ffffff"
-        android:valueTo="#161c2d"
-        android:valueType="colorType"
-        android:interpolator="@android:interpolator/fast_out_slow_in"/>
-    </aapt:attr>
-  </target>
-  <target android:name="path_1">
-    <aapt:attr name="android:animation">
-      <objectAnimator
-        android:propertyName="fillColor"
-        android:duration="1000"
-        android:valueFrom="#00ffffff"
-        android:valueTo="#f9f9fb"
-        android:valueType="colorType"
-        android:interpolator="@android:interpolator/fast_out_slow_in"/>
-    </aapt:attr>
-  </target>
-  <target android:name="path_2">
-    <aapt:attr name="android:animation">
-      <objectAnimator
-        android:propertyName="fillColor"
-        android:duration="1000"
-        android:valueFrom="#00ffffff"
-        android:valueTo="#f9f9fb"
-        android:valueType="colorType"
-        android:interpolator="@android:interpolator/fast_out_slow_in"/>
-    </aapt:attr>
-  </target>
-</animated-vector>
diff --git a/src/Launcher/GalNet.Launcher.Android/Resources/drawable-v31/avalonia_anim.xml b/src/Launcher/GalNet.Launcher.Android/Resources/drawable-v31/avalonia_anim.xml
deleted file mode 100644
index 94f27d9e..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Resources/drawable-v31/avalonia_anim.xml
+++ /dev/null
@@ -1,71 +0,0 @@
-<animated-vector
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:aapt="http://schemas.android.com/aapt">
-    <aapt:attr name="android:drawable">
-        <vector
-            android:name="vector"
-            android:width="128dp"
-            android:height="128dp"
-            android:viewportWidth="128"
-            android:viewportHeight="128">
-            <group
-                android:name="wrapper"
-                android:translateX="21"
-                android:translateY="21">
-                <group android:name="group">
-                    <path
-                        android:name="path"
-                        android:pathData="M 74.853 85.823 L 75.368 85.823 C 80.735 85.823 85.144 81.803 85.761 76.602 L 85.836 41.76 C 85.225 18.593 66.254 0 42.939 0 C 19.24 0 0.028 19.212 0.028 42.912 C 0.028 66.357 18.831 85.418 42.18 85.823 L 74.853 85.823 Z"
-                        android:fillColor="#00ffffff"
-                        android:strokeWidth="1"/>
-                    <path
-                        android:name="path_1"
-                        android:pathData="M 43.059 14.614 C 29.551 14.614 18.256 24.082 15.445 36.743 C 18.136 37.498 20.109 39.968 20.109 42.899 C 20.109 45.831 18.136 48.301 15.445 49.055 C 18.256 61.716 29.551 71.184 43.059 71.184 C 47.975 71.184 52.599 69.93 56.628 67.723 L 56.628 70.993 L 71.344 70.993 L 71.344 44.072 C 71.357 43.714 71.344 43.26 71.344 42.899 C 71.344 27.278 58.68 14.614 43.059 14.614 Z M 29.51 42.899 C 29.51 35.416 35.576 29.35 43.059 29.35 C 50.541 29.35 56.607 35.416 56.607 42.899 C 56.607 50.382 50.541 56.448 43.059 56.448 C 35.576 56.448 29.51 50.382 29.51 42.899 Z"
-                        android:fillColor="#00ffffff"
-                        android:strokeWidth="1"
-                        android:fillType="evenOdd"/>
-                    <path
-                        android:name="path_2"
-                        android:pathData="M 18.105 42.88 C 18.105 45.38 16.078 47.407 13.579 47.407 C 11.079 47.407 9.052 45.38 9.052 42.88 C 9.052 40.381 11.079 38.354 13.579 38.354 C 16.078 38.354 18.105 40.381 18.105 42.88 Z"
-                        android:fillColor="#00ffffff"
-                        android:strokeWidth="1"/>
-                </group>
-            </group>
-        </vector>
-    </aapt:attr>
-    <target android:name="path_2">
-        <aapt:attr name="android:animation">
-            <objectAnimator
-                android:propertyName="fillColor"
-                android:startOffset="100"
-                android:duration="900"
-                android:valueFrom="#00ffffff"
-                android:valueTo="#161c2d"
-                android:valueType="colorType"
-                android:interpolator="@android:interpolator/fast_out_slow_in"/>
-        </aapt:attr>
-    </target>
-    <target android:name="path">
-        <aapt:attr name="android:animation">
-            <objectAnimator
-                android:propertyName="fillColor"
-                android:duration="500"
-                android:valueFrom="#00ffffff"
-                android:valueTo="#f9f9fb"
-                android:valueType="colorType"
-                android:interpolator="@android:interpolator/fast_out_slow_in"/>
-        </aapt:attr>
-    </target>
-    <target android:name="path_1">
-        <aapt:attr name="android:animation">
-            <objectAnimator
-                android:propertyName="fillColor"
-                android:startOffset="100"
-                android:duration="900"
-                android:valueFrom="#00ffffff"
-                android:valueTo="#161c2d"
-                android:valueType="colorType"
-                android:interpolator="@android:interpolator/fast_out_slow_in"/>
-        </aapt:attr>
-    </target>
-</animated-vector>
diff --git a/src/Launcher/GalNet.Launcher.Android/Resources/drawable/splash_screen.xml b/src/Launcher/GalNet.Launcher.Android/Resources/drawable/splash_screen.xml
deleted file mode 100644
index 2e920b4b..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Resources/drawable/splash_screen.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
-
-  <item>
-    <color android:color="@color/splash_background"/>
-  </item>
-
-  <item android:drawable="@drawable/icon"
-        android:width="120dp"
-        android:height="120dp"
-        android:gravity="center" />
-
-</layer-list>
diff --git a/src/Launcher/GalNet.Launcher.Android/Resources/values-night/colors.xml b/src/Launcher/GalNet.Launcher.Android/Resources/values-night/colors.xml
deleted file mode 100644
index 3d47b6fc..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Resources/values-night/colors.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-  <color name="splash_background">#212121</color>
-</resources>
diff --git a/src/Launcher/GalNet.Launcher.Android/Resources/values-v31/styles.xml b/src/Launcher/GalNet.Launcher.Android/Resources/values-v31/styles.xml
deleted file mode 100644
index d5ecec43..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Resources/values-v31/styles.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<resources>
-
-  <style name="MyTheme">
-  </style>
-
-  <style name="MyTheme.NoActionBar" parent="@style/Theme.AppCompat.NoActionBar">
-    <item name="android:windowActionBar">false</item>
-    <item name="android:windowBackground">@null</item>
-    <item name="android:windowNoTitle">true</item>
-    <item name="android:windowSplashScreenBackground">@color/splash_background</item>
-    <item name="android:windowSplashScreenAnimatedIcon">@drawable/avalonia_anim</item>
-    <item name="android:windowSplashScreenAnimationDuration">1000</item>
-    <item name="postSplashScreenTheme">@style/MyTheme.Main</item>
-
-  </style>
-  <style name="MyTheme.Main"
-         parent ="MyTheme.NoActionBar">
-    <item name="android:windowIsTranslucent">true</item>
-  </style>
-</resources>
diff --git a/src/Launcher/GalNet.Launcher.Android/Resources/values/colors.xml b/src/Launcher/GalNet.Launcher.Android/Resources/values/colors.xml
deleted file mode 100644
index 59279d5d..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Resources/values/colors.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-  <color name="splash_background">#FFFFFF</color>
-</resources>
diff --git a/src/Launcher/GalNet.Launcher.Android/Resources/values/styles.xml b/src/Launcher/GalNet.Launcher.Android/Resources/values/styles.xml
deleted file mode 100644
index 6e534de2..00000000
--- a/src/Launcher/GalNet.Launcher.Android/Resources/values/styles.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<resources>
-
-  <style name="MyTheme">
-  </style>
-
-  <style name="MyTheme.NoActionBar" parent="@style/Theme.AppCompat.DayNight.NoActionBar">
-    <item name="android:windowActionBar">false</item>
-    <item name="android:windowBackground">@drawable/splash_screen</item>
-    <item name="android:windowNoTitle">true</item>
-  </style>
-</resources>
diff --git a/src/Launcher/GalNet.Launcher.Android/packages.lock.json b/src/Launcher/GalNet.Launcher.Android/packages.lock.json
deleted file mode 100644
index 0466e248..00000000
--- a/src/Launcher/GalNet.Launcher.Android/packages.lock.json
+++ /dev/null
@@ -1,929 +0,0 @@
-{
-  "version": 2,
-  "dependencies": {
-    "net10.0-android36.0": {
-      "Avalonia.Android": {
-        "type": "Direct",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "O0syg5V3N+mmgxe6uGwbe0inFDhA3ERMF9MLC0ALRvBy5BurH1/aLdvnX9ubeu/x8sxHPIf2znUaS/F3C8EFpw==",
-        "dependencies": {
-          "Avalonia": "12.0.5",
-          "Avalonia.HarfBuzz": "12.0.5",
-          "Avalonia.Skia": "12.0.5",
-          "Xamarin.AndroidX.AppCompat": "1.7.1.3",
-          "Xamarin.AndroidX.Window": "1.5.1.2"
-        }
-      },
-      "Microsoft.NET.ILLink.Tasks": {
-        "type": "Direct",
-        "requested": "[10.0.12, )",
-        "resolved": "10.0.12",
-        "contentHash": "xi+BDjFpW+Sb+MHFHaH6Y/gV9I8BluFwRXc1QyCdoZbIK26eNiBeFuMTe/FMwc33G1wdHCyDg7CVTmb8OdQrMQ=="
-      },
-      "Xamarin.AndroidX.Core.SplashScreen": {
-        "type": "Direct",
-        "requested": "[1.0.1.15, )",
-        "resolved": "1.0.1.15",
-        "contentHash": "lIrwgrscmgm3lAa6orpTPb27MoUeg5RdgUSshSga3wdAS503pK8OWQ8l+7QzTM4/mypop8RpHg0LHNv9y0WX4Q==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.3",
-          "Xamarin.Kotlin.StdLib": "2.0.21.3"
-        }
-      },
-      "Antlr4.Runtime.Standard": {
-        "type": "Transitive",
-        "resolved": "4.13.1",
-        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
-      },
-      "Avalonia.BuildServices": {
-        "type": "Transitive",
-        "resolved": "11.3.2",
-        "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
-      },
-      "Avalonia.HarfBuzz": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "jR8i/fgrmAKEp0T3iLqfKCoEDJV9ODVzN+8bofM2guEr05eaXbx6iXZxcjh0nDK4UbK0akYDgBfAgyHoatqGjg==",
-        "dependencies": {
-          "Avalonia": "12.0.5",
-          "HarfBuzzSharp": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3"
-        }
-      },
-      "Avalonia.Remote.Protocol": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
-      },
-      "HarfBuzzSharp": {
-        "type": "Transitive",
-        "resolved": "8.3.1.3",
-        "contentHash": "NGZ2+ZVNPM+NdHB/asW0/ykWngyHWwcqjrbN2nDeH1B/aptPGlCUl8wkQ2cSJxw5fdWgdmIPmNuTPWpLwNVXWg==",
-        "dependencies": {
-          "HarfBuzzSharp.NativeAssets.Android": "8.3.1.3"
-        }
-      },
-      "HarfBuzzSharp.NativeAssets.Android": {
-        "type": "Transitive",
-        "resolved": "8.3.1.3",
-        "contentHash": "Yte9/yYql8ngAjo7YgHlXSinLJcJXIRBM9gegVXpJ2SVYT1i2O/wMA+H3jmYiYiTQxHpHKi4exZUcMzry171MA=="
-      },
-      "HarfBuzzSharp.NativeAssets.Linux": {
-        "type": "Transitive",
-        "resolved": "8.3.1.3",
-        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
-      },
-      "HarfBuzzSharp.NativeAssets.WebAssembly": {
-        "type": "Transitive",
-        "resolved": "8.3.1.3",
-        "contentHash": "w2QfdNm9Uz/sUa0B5D+OnVQhyq3G/fBq6ibQMdWBlQqqwh0g0/5j3RFvYqZAmRZ5+RzvjVe8o8SFFnWYUSkuxA=="
-      },
-      "MicroCom.Runtime": {
-        "type": "Transitive",
-        "resolved": "0.11.4",
-        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
-      },
-      "Microsoft.Extensions.Logging.Abstractions": {
-        "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
-        }
-      },
-      "Microsoft.IO.RecyclableMemoryStream": {
-        "type": "Transitive",
-        "resolved": "3.0.1",
-        "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g=="
-      },
-      "SkiaSharp": {
-        "type": "Transitive",
-        "resolved": "3.119.4",
-        "contentHash": "53NOSUZ1Us+91Sm0uCkIivh/k7jOowRErZT2sIWwPFN9mLUvdxnE6rS4sWo4255+Rd2MWUSF+j0NMZHD6Cke+Q==",
-        "dependencies": {
-          "SkiaSharp.NativeAssets.Android": "3.119.4"
-        }
-      },
-      "SkiaSharp.NativeAssets.Android": {
-        "type": "Transitive",
-        "resolved": "3.119.4",
-        "contentHash": "qfjNh5hZBZxpOIM1aeDByj2qNbcK2JZG5Y7YyGSeliaYnf1N/hVfsswIPUa+qzcMqS9Q0VCGk85zQLvwVXtrvQ=="
-      },
-      "SkiaSharp.NativeAssets.Linux": {
-        "type": "Transitive",
-        "resolved": "3.119.4",
-        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
-      },
-      "SkiaSharp.NativeAssets.WebAssembly": {
-        "type": "Transitive",
-        "resolved": "3.119.4",
-        "contentHash": "S1HOxtBbD4bYDtA2e9WH5TX+lxqRrTPvKjrjttRhxnHNNu7YY8VFo/LeCP7tNqoTA6PV+8vsvNbmRUEC2ip8RQ=="
-      },
-      "Xamarin.AndroidX.Activity": {
-        "type": "Transitive",
-        "resolved": "1.12.4.1",
-        "contentHash": "XvPeFfCBOL/l7GDuM9EwpoooB163TSiztwx/nKaH4ghDn4EBVL6zBQc2S7R4uTWEjOARCyOtsqIaN2bc9NjBBQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Core.Core.Ktx": "1.17.0.2",
-          "Xamarin.AndroidX.Core.ViewTree": "1.0.0.5",
-          "Xamarin.AndroidX.Lifecycle.Common": "2.10.0.2",
-          "Xamarin.AndroidX.Lifecycle.Runtime": "2.10.0.2",
-          "Xamarin.AndroidX.Lifecycle.ViewModel": "2.10.0.2",
-          "Xamarin.AndroidX.Lifecycle.ViewModelSavedState": "2.10.0.2",
-          "Xamarin.AndroidX.NavigationEvent": "1.0.2.1",
-          "Xamarin.AndroidX.ProfileInstaller.ProfileInstaller": "1.4.1.7",
-          "Xamarin.AndroidX.SavedState": "1.4.0.2",
-          "Xamarin.AndroidX.Tracing.Tracing": "1.3.0.3",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.Annotation": {
-        "type": "Transitive",
-        "resolved": "1.9.1.7",
-        "contentHash": "o77RbvsTeE48+KMfg3Y5pLL1R0OgHb29aqphPLcnTusB7wCoOM0s/vsh6JsxusV+CAD5UPZB4qB45tTQ5jg8mQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Annotation.Experimental": {
-        "type": "Transitive",
-        "resolved": "1.5.1.3",
-        "contentHash": "U1ewvEEGaB2s4L2E3ijnBx1I7JjZI1H9tiTIc99x5NCXtcxvZoRDoJRsOsffLAck8IpfiXVsNuMT3Dj3Yafe6Q==",
-        "dependencies": {
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Annotation.Jvm": {
-        "type": "Transitive",
-        "resolved": "1.9.1.7",
-        "contentHash": "mnpIIJq38C63y9Pg1LZxQgY7U5PiDHAepy8xldVJL8UPNigBSEXB3oOh0UDAsfqtDldfv0lH8ADcAq3plQRhhg==",
-        "dependencies": {
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.AppCompat": {
-        "type": "Transitive",
-        "resolved": "1.7.1.3",
-        "contentHash": "Sx7IB41pP1H6jJbuM8bxnUpppyjAGmpOh5SxuiL71+33lENESl7uWZ/aymmRMwgNMh6OSwhdTj5A0J1PLUvsAA==",
-        "dependencies": {
-          "Xamarin.AndroidX.Activity": "1.12.4.1",
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.AppCompat.AppCompatResources": "[1.7.1.3, 1.7.2)",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.AndroidX.Core.Core.Ktx": "1.17.0.2",
-          "Xamarin.AndroidX.CursorAdapter": "1.0.0.36",
-          "Xamarin.AndroidX.DrawerLayout": "1.2.0.20",
-          "Xamarin.AndroidX.Emoji2": "1.6.0.2",
-          "Xamarin.AndroidX.Emoji2.ViewsHelper": "1.6.0.2",
-          "Xamarin.AndroidX.Fragment": "1.8.9.2",
-          "Xamarin.AndroidX.Lifecycle.Runtime": "2.10.0.2",
-          "Xamarin.AndroidX.Lifecycle.ViewModel": "2.10.0.2",
-          "Xamarin.AndroidX.ProfileInstaller.ProfileInstaller": "1.4.1.7",
-          "Xamarin.AndroidX.ResourceInspection.Annotation": "1.0.1.24",
-          "Xamarin.AndroidX.SavedState": "1.4.0.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.AppCompat.AppCompatResources": {
-        "type": "Transitive",
-        "resolved": "1.7.1.3",
-        "contentHash": "2wPEdyIN/Xh1wcOowZ3jAMBX7RrRNtBA8mzwmec6eOB+MXj/ANTx+CISJQJBlXzsif8vvZz81dPJ80OAPmeV2Q==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.AndroidX.VectorDrawable": "1.2.0.10",
-          "Xamarin.AndroidX.VectorDrawable.Animated": "1.2.0.10"
-        }
-      },
-      "Xamarin.AndroidX.Arch.Core.Common": {
-        "type": "Transitive",
-        "resolved": "2.2.0.20",
-        "contentHash": "CJ4jsgchHOAXM1mSWEyc7WhRPxVLbSYQiV56K79VpKsTLmUGQrjXvZxjB5REyEG1yaUrlAlZ1QMNPtXLDJ+ijQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7"
-        }
-      },
-      "Xamarin.AndroidX.Arch.Core.Runtime": {
-        "type": "Transitive",
-        "resolved": "2.2.0.20",
-        "contentHash": "j+EaKYaCFOLZhknLWKVVDKOTz0v6HIk1BNu3FtGv5uECTD2NQv46/bNnVrxkf9ji9XMFhklq1aBTbXM+JAjRcA==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Arch.Core.Common": "[2.2.0.20, 2.2.1)"
-        }
-      },
-      "Xamarin.AndroidX.Collection": {
-        "type": "Transitive",
-        "resolved": "1.5.0.5",
-        "contentHash": "7WADsWiPLDB0FE2eaxlAS0q9rz/R9ONaktZvIIFSIwKDJNa6TD1zYBhBFYYlwOdPKhv8tSNcisw04Yf8At06pw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Collection.Jvm": "1.5.0.5",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Collection.Jvm": {
-        "type": "Transitive",
-        "resolved": "1.5.0.5",
-        "contentHash": "r1V8niIXewad1V5f856rp993k0uM2kUTRhGEG2svVxfoEAVcQxsxkp/1yqVVKxKGvwX3LOm9zMhN4BMQzf57QA==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Compose.Runtime.Annotation": {
-        "type": "Transitive",
-        "resolved": "1.10.4.1",
-        "contentHash": "GiMCWfs1EEKa8deibZ1YpGrP++eAnAS1QqX8Z1Bgjufxj8E3fbEs7XwcKnCdl/1g+nvpdunjXp+NjcnJeLOyAg==",
-        "dependencies": {
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Compose.Runtime.Annotation.Android": {
-        "type": "Transitive",
-        "resolved": "1.10.4.1",
-        "contentHash": "kSP1q3RaExDHuZ3W3pdWR4T3WAZYzGhRv8HK+wFpqeiU1ts/TJ3ZyFDI0AQRl587Af6dl5aki0pn10lD8l6XMg==",
-        "dependencies": {
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Concurrent.Futures": {
-        "type": "Transitive",
-        "resolved": "1.3.0.3",
-        "contentHash": "I2BZFcrd/c/zsCwv8BZt4j77jz7Bpb0/dkI537i/nb98uIk+Ka60WPtQpAcoiqQzhwIVijVBckzODh0ciTUJkg==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.Google.Guava.ListenableFuture": "1.0.0.31",
-          "Xamarin.JSpecify": "1.0.0.6"
-        }
-      },
-      "Xamarin.AndroidX.Core": {
-        "type": "Transitive",
-        "resolved": "1.17.0.2",
-        "contentHash": "W5QTwF99C4wP+OIpTXLJZYPunKdf0huPAhTdxpOSU0ps5mvJst9v2TVi5JZOCM5IXOl/mcGe8uFaG59ARPw1lA==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Annotation.Experimental": "1.5.1.3",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Concurrent.Futures": "1.3.0.3",
-          "Xamarin.AndroidX.Core.ViewTree": "1.0.0.5",
-          "Xamarin.AndroidX.Interpolator": "1.0.0.36",
-          "Xamarin.AndroidX.Lifecycle.Common": "2.10.0.2",
-          "Xamarin.AndroidX.Lifecycle.Runtime": "2.10.0.2",
-          "Xamarin.AndroidX.Tracing.Tracing": "1.3.0.3",
-          "Xamarin.AndroidX.VersionedParcelable": "1.2.1.5",
-          "Xamarin.Google.Guava.ListenableFuture": "1.0.0.31",
-          "Xamarin.JSpecify": "1.0.0.6",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.Core.Core.Ktx": {
-        "type": "Transitive",
-        "resolved": "1.17.0.2",
-        "contentHash": "SY7p2ulFYcyjqdJENh3GAXrUhGE3N/KoIMrzlFi5/34QpMmCS2ejsCuo3cj1MRfR9iQkjj3XwGYk29oF83KTvw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Core.ViewTree": {
-        "type": "Transitive",
-        "resolved": "1.0.0.5",
-        "contentHash": "7pEcGvCKXBa1AS+NPcvF4DjB4ZPtAzPIi9T3HEmisMKmY7jxfLLD0qPnpTQpznFn6Xt5axoKKF88/5H+ZZ+z2A==",
-        "dependencies": {
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.CursorAdapter": {
-        "type": "Transitive",
-        "resolved": "1.0.0.36",
-        "contentHash": "WKPYhD+48bJt3Xcr/0Hikv7xIjw3s0LOlkunz4n6kCtV3aLbNtwGemkqulKV/AkpNmYdFARWzz8ngV5RG4lP5Q==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7"
-        }
-      },
-      "Xamarin.AndroidX.CustomView": {
-        "type": "Transitive",
-        "resolved": "1.2.0.3",
-        "contentHash": "ekAHgOWMZdX6tP7TDIOveOq2W48oTVkUotOBokxZU739vwi+r3c9svx2K3bWKWszCBqCXWxtdxup18D55UlEXQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.JSpecify": "1.0.0.6"
-        }
-      },
-      "Xamarin.AndroidX.DrawerLayout": {
-        "type": "Transitive",
-        "resolved": "1.2.0.20",
-        "contentHash": "KelXwjsaO1fnJ2r6efBZAcYNvzvHtqt2M50Cu8+AnJvmnrp6avNxASHaYDk7Wnm0pqQuPQccX+UlVxBJPHW7oQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.AndroidX.CustomView": "1.2.0.3"
-        }
-      },
-      "Xamarin.AndroidX.Emoji2": {
-        "type": "Transitive",
-        "resolved": "1.6.0.2",
-        "contentHash": "4QKAApr9H9jUKnDacMkJnZUAfxf8WtVRCvZhlOApaLFNdlfJhV3GiBDQg9LyNKjY2+3fP4f6K0acnmyt7AlRhQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.AndroidX.Lifecycle.Process": "2.10.0.2",
-          "Xamarin.AndroidX.Startup.StartupRuntime": "1.2.0.7",
-          "Xamarin.JSpecify": "1.0.0.6"
-        }
-      },
-      "Xamarin.AndroidX.Emoji2.ViewsHelper": {
-        "type": "Transitive",
-        "resolved": "1.6.0.2",
-        "contentHash": "A2QPgZ+dlSid44LKiQgWD2Ev82w92dDQuopgDc6eZkGZitMD/Wm72gIwdasIiUckk4vmSJeFNTmK0q0ofYoqEw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.AndroidX.Emoji2": "[1.6.0.2, 1.6.1)",
-          "Xamarin.JSpecify": "1.0.0.6"
-        }
-      },
-      "Xamarin.AndroidX.Fragment": {
-        "type": "Transitive",
-        "resolved": "1.8.9.2",
-        "contentHash": "i8fyLoxNhQ+J5chDFeIPpAPkRFevAqLqt/t+J+Wex67DsrPiJYTjeuJ+p5GX9c2qRWyYtDorb9WwpOL4/tMwxg==",
-        "dependencies": {
-          "Xamarin.AndroidX.Activity": "1.12.4.1",
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Annotation.Experimental": "1.5.1.3",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core.Core.Ktx": "1.17.0.2",
-          "Xamarin.AndroidX.Lifecycle.LiveData.Core": "2.10.0.2",
-          "Xamarin.AndroidX.Lifecycle.Runtime": "2.10.0.2",
-          "Xamarin.AndroidX.Lifecycle.ViewModel": "2.10.0.2",
-          "Xamarin.AndroidX.Lifecycle.ViewModelSavedState": "2.10.0.2",
-          "Xamarin.AndroidX.Loader": "1.1.0.36",
-          "Xamarin.AndroidX.ProfileInstaller.ProfileInstaller": "1.4.1.7",
-          "Xamarin.AndroidX.SavedState": "1.4.0.2",
-          "Xamarin.AndroidX.ViewPager": "1.1.0.6",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Interpolator": {
-        "type": "Transitive",
-        "resolved": "1.0.0.36",
-        "contentHash": "eDykH8nqVeiFNk7P3epX7nGgl6DcWQo5XB5rLuEUSMybjo97SlGwdSElMA0Dn2H1us51yMQVcKmsqh4dXzUaCA==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.Common": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "ksfAj0Rp6vYUC4qEKKaskUQ2mqfiHgNddnnvz/F34a+mzpcKoSkdSzW6dqI/ZADIzLHsUKPi9lJ4Mt2QPTp82g==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Lifecycle.Common.Jvm": "2.10.0.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.Common.Jvm": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "Ut/Dzg3/T2yFWfSZLa4IkDh0RNOs8iqusAdvdRB5ZrSQgQfPF7BbkpfREd1n+JmFNE8/j1oO6s5N64vYIY9nEw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.JSpecify": "1.0.0.6",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.LiveData.Core": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "4V6+6FbIzIhSVjLSrWXnz7WkGqJvjgXYSqKlI2d8fkCGkAoxcjsBqCqFoxS3uTnNHdpmmRP37y2XxsjM44Vm7w==",
-        "dependencies": {
-          "Xamarin.AndroidX.Arch.Core.Common": "2.2.0.20",
-          "Xamarin.AndroidX.Arch.Core.Runtime": "2.2.0.20",
-          "Xamarin.AndroidX.Lifecycle.Common": "[2.10.0.2, 2.10.1)",
-          "Xamarin.JSpecify": "1.0.0.6",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.Process": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "hmlTAohFRnBhf86TeayiVeyE0CKUOoAELRP2hv3d36vPdxpAVrP+v9Lr104AKZUVoY7jsVuO9akAgUANY2aqRA==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Lifecycle.Runtime": "[2.10.0.2, 2.10.1)",
-          "Xamarin.AndroidX.Startup.StartupRuntime": "1.2.0.7",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.Runtime": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "V/Ab8a1jULOsIYTakUH1fxfznrr5BMa1wE1Bscq34hvq0Xd+pWdrf95bbO870H62lryRGMaS/Np6XQ/NnGgn2w==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Lifecycle.Common": "[2.10.0.2, 2.10.1)",
-          "Xamarin.AndroidX.Lifecycle.Runtime.Android": "2.10.0.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.Runtime.Android": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "bXducXU2t/Tp7NfZjyBFaPFMNY/tFYogxvq8Q9EqZsws9Eu/DvwWzsUs1WnrfOc8Dh505CaM+dRjtpGHD2/BcQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.AndroidX.Arch.Core.Common": "2.2.0.20",
-          "Xamarin.AndroidX.Arch.Core.Runtime": "2.2.0.20",
-          "Xamarin.AndroidX.Core.ViewTree": "1.0.0.5",
-          "Xamarin.AndroidX.Lifecycle.Common.Jvm": "[2.10.0.2, 2.10.1)",
-          "Xamarin.AndroidX.ProfileInstaller.ProfileInstaller": "1.4.1.7",
-          "Xamarin.JSpecify": "1.0.0.6",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Android": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.ViewModel": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "kc9DGem8or9Olsa/xKDruV7a41GVPhao951Tq3zpdH5MxIqimdW6IRmi6Ieqq5TtEuSQJQQpkzf6tcdGQbVlNg==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Lifecycle.ViewModel.Android": "2.10.0.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.ViewModel.Android": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "cCu5OlCXfg4WnpCGSldOgV6eKfH+Aly+MpJKtJORMLeKpNGncEDsH5Ob9dxYJN2CcLIhpYVlEITKwZ2hU+UUyQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.AndroidX.Core.ViewTree": "1.0.0.5",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Android": "1.10.2.3",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.ViewModelSavedState": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "FW3rckNEnS3Dx7Dig5+ONjBkwYAv69p+JfsGZG/mQhETcNdeZl60SBmBRrwiqhv8AoWObq53gsHt7P3O87Qhzw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Lifecycle.Common": "[2.10.0.2, 2.10.1)",
-          "Xamarin.AndroidX.Lifecycle.ViewModel": "[2.10.0.2, 2.10.1)",
-          "Xamarin.AndroidX.Lifecycle.ViewModelSavedState.Android": "2.10.0.2",
-          "Xamarin.AndroidX.SavedState": "1.4.0.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3",
-          "Xamarin.KotlinX.Serialization.Core": "1.10.0.1"
-        }
-      },
-      "Xamarin.AndroidX.Lifecycle.ViewModelSavedState.Android": {
-        "type": "Transitive",
-        "resolved": "2.10.0.2",
-        "contentHash": "7lyx2t/ltqbC03jPZP3Ufsg0PqeD8yfmlqrq59lF5c/dJz3Y5JeICq8n+aY5T0c+WHzia4AdZ2gPJJ3Rk/l7EQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.AndroidX.Core.Core.Ktx": "1.17.0.2",
-          "Xamarin.AndroidX.Lifecycle.Common.Jvm": "[2.10.0.2, 2.10.1)",
-          "Xamarin.AndroidX.Lifecycle.LiveData.Core": "[2.10.0.2, 2.10.1)",
-          "Xamarin.AndroidX.Lifecycle.ViewModel.Android": "[2.10.0.2, 2.10.1)",
-          "Xamarin.AndroidX.SavedState.SavedState.Android": "1.4.0.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Android": "1.10.2.3",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3",
-          "Xamarin.KotlinX.Serialization.Core.Jvm": "1.10.0.1"
-        }
-      },
-      "Xamarin.AndroidX.Loader": {
-        "type": "Transitive",
-        "resolved": "1.1.0.36",
-        "contentHash": "QwX56hQ4xC2XMU+Pba8DOnLvq+B/zDHkqlRReEf2qm62O97RX9lRxET64Rc/4ssJEEornDD9KMpn2aNftxEIMA==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.AndroidX.Lifecycle.LiveData.Core": "2.10.0.2",
-          "Xamarin.AndroidX.Lifecycle.ViewModel": "2.10.0.2"
-        }
-      },
-      "Xamarin.AndroidX.NavigationEvent": {
-        "type": "Transitive",
-        "resolved": "1.0.2.1",
-        "contentHash": "39yEKeQBzL3GiSHlewvmKFMwT5o5RdodoTTAKDWRz6pmKwXG+OOrUB31IhSjUTAs7n70SZ/9KXDzgmIaPVBsBQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Compose.Runtime.Annotation": "1.10.4.1",
-          "Xamarin.AndroidX.NavigationEvent.Android": "1.0.2.1",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.NavigationEvent.Android": {
-        "type": "Transitive",
-        "resolved": "1.0.2.1",
-        "contentHash": "Zm4qWQY03CuvFWFQjGFkB6mCg2Ycuqmhd+vpitKyMm7bd/DJf9KK6ox3Kh9/MdI8pSiYcXr6fpjLoXM51jCGOw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.AndroidX.Compose.Runtime.Annotation.Android": "1.10.4.1",
-          "Xamarin.AndroidX.Core.ViewTree": "1.0.0.5",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Android": "1.10.2.3",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.ProfileInstaller.ProfileInstaller": {
-        "type": "Transitive",
-        "resolved": "1.4.1.7",
-        "contentHash": "Xw4x6ZA4dSC5Fe49fbm5YJRblhAAANbcONidZHncznImuJZ0XJngQhbjvDFNI/UipP3OD41SOSpGHIweRJYagQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Concurrent.Futures": "1.3.0.3",
-          "Xamarin.AndroidX.Startup.StartupRuntime": "1.2.0.7",
-          "Xamarin.Google.Guava.ListenableFuture": "1.0.0.31"
-        }
-      },
-      "Xamarin.AndroidX.ResourceInspection.Annotation": {
-        "type": "Transitive",
-        "resolved": "1.0.1.24",
-        "contentHash": "jJKNvyHyMP7BbLw3eI4SatY7hbu1Qb+Y9xQ/p6AEExDOchTKRpg1mTEV9rp57OvgRek7QgPNLwgyMxT5O3mZIw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7"
-        }
-      },
-      "Xamarin.AndroidX.SavedState": {
-        "type": "Transitive",
-        "resolved": "1.4.0.2",
-        "contentHash": "5auFgyvy2HRKz7w7w5W3zKZ49CoW30yhOjprqS2IGy5lPvLG4J2ZunO88cUjQWPu7xsXcEq74cpw2wzMnvUY/A==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Lifecycle.Common": "2.10.0.2",
-          "Xamarin.AndroidX.SavedState.SavedState.Android": "1.4.0.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3",
-          "Xamarin.KotlinX.Serialization.Core": "1.10.0.1"
-        }
-      },
-      "Xamarin.AndroidX.SavedState.SavedState.Android": {
-        "type": "Transitive",
-        "resolved": "1.4.0.2",
-        "contentHash": "tka3EwzK3asA5aTOt213TNNOVCJR3Q1qd1GWdSWYwNerhyEl31nKjW4lOWagjwyG8ai8dJtZVapXZ0+NMkoIwg==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.AndroidX.Core.Core.Ktx": "1.17.0.2",
-          "Xamarin.AndroidX.Core.ViewTree": "1.0.0.5",
-          "Xamarin.AndroidX.Lifecycle.Common.Jvm": "2.10.0.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core": "1.10.2.3",
-          "Xamarin.KotlinX.Serialization.Core.Jvm": "1.10.0.1"
-        }
-      },
-      "Xamarin.AndroidX.Startup.StartupRuntime": {
-        "type": "Transitive",
-        "resolved": "1.2.0.7",
-        "contentHash": "i3ZYBjKcaXahM64NK7+rHGImEK0dmAt8YjBw2mfdLOkmhMApC6TXVTEq58lLA2UdhuOCbAJTBdxdq7E6GQXbDw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Tracing.Tracing": "1.3.0.3"
-        }
-      },
-      "Xamarin.AndroidX.Tracing.Tracing": {
-        "type": "Transitive",
-        "resolved": "1.3.0.3",
-        "contentHash": "RiUQWISFX42hjv4gS0LgFkDOJbVJOAOE1eITV0epUQk5hQJI6E0MUYAHtXEplg39lbp/bqHfOST/E8IbE1/n5w==",
-        "dependencies": {
-          "Xamarin.AndroidX.Tracing.Tracing.Android": "1.3.0.3",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Tracing.Tracing.Android": {
-        "type": "Transitive",
-        "resolved": "1.3.0.3",
-        "contentHash": "xxh4wt+VMEjO6PTEo0XLwyVaDyVTS4nPdM4qMVI2sxC8ozSAPtpZEmUzeaUgaHbX7zgZEmUO/Tv+ZCQWOjLMmQ==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.VectorDrawable": {
-        "type": "Transitive",
-        "resolved": "1.2.0.10",
-        "contentHash": "ZRoUx2Qbu3pEBSvKmGlvHOXmIMqaCr0LQxhs24dJwmHVkwTi22l11T4ejtTbo2Gp75e5KI2tvHmh5FpO1bHnFA==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core": "1.17.0.2"
-        }
-      },
-      "Xamarin.AndroidX.VectorDrawable.Animated": {
-        "type": "Transitive",
-        "resolved": "1.2.0.10",
-        "contentHash": "h9iGCtft2L2em5SRSSpOh1p49fhsaR43UvXt54qRhXeR5lXdnF2LBwH1rxv4E7TPdR9AfMKzki+B8mjrMZWh4w==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.AndroidX.Interpolator": "1.0.0.36",
-          "Xamarin.AndroidX.VectorDrawable": "1.2.0.10"
-        }
-      },
-      "Xamarin.AndroidX.VersionedParcelable": {
-        "type": "Transitive",
-        "resolved": "1.2.1.5",
-        "contentHash": "ToYJpFhA6l9wAGD53XnwNIxcQEeKC4vojlULGXuizzwkOYYgfpIvqT9YJoxGJqYJSg/WpFdXJhUey2HtXioMHg==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.JSpecify": "1.0.0.6"
-        }
-      },
-      "Xamarin.AndroidX.ViewPager": {
-        "type": "Transitive",
-        "resolved": "1.1.0.6",
-        "contentHash": "RCN1PymyCFY/7VSnZNOdOErU6OgEQg5n0dAOy8qxQKjoaA3m39JEo9wUATrXi3PwITBbCDMlxn4a/c13ZDa0Bw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.AndroidX.CustomView": "1.2.0.3"
-        }
-      },
-      "Xamarin.AndroidX.Window": {
-        "type": "Transitive",
-        "resolved": "1.5.1.2",
-        "contentHash": "7f1EmaLM3xQFPbNKirCYRxTWW0EWDxWSORHvMVnmlGetBwt4iue8KjJ0mqw5Veq2tv1Q8SBrlT+jHqTXNxvvcA==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Collection": "1.5.0.5",
-          "Xamarin.AndroidX.Core": "1.17.0.2",
-          "Xamarin.AndroidX.Window.WindowCore": "[1.5.1.2, 1.5.2)",
-          "Xamarin.JSpecify": "1.0.0.6",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Android": "1.10.2.3"
-        }
-      },
-      "Xamarin.AndroidX.Window.WindowCore": {
-        "type": "Transitive",
-        "resolved": "1.5.1.2",
-        "contentHash": "mpO/kUUF/l3sipJM9yyNyHk7UpJ83wjNl2BMkMEuy29fVka1sb7avjAZPOuYICFIJE2gW9W/wvAoWclLLwVBXw==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation": "1.9.1.7",
-          "Xamarin.AndroidX.Window.WindowCore.Jvm": "1.5.1.2",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.AndroidX.Window.WindowCore.Jvm": {
-        "type": "Transitive",
-        "resolved": "1.5.1.2",
-        "contentHash": "ovPEz7SEdYUlA7wiwToLJLmJ7YkVEfoI9ZOAiKOO3HnqjaoC3PIzzCP9ybJGLF3FaHpfFwm6LTXEU+llaQSGbg==",
-        "dependencies": {
-          "Xamarin.AndroidX.Annotation.Jvm": "1.9.1.7",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.Google.Guava.ListenableFuture": {
-        "type": "Transitive",
-        "resolved": "1.0.0.31",
-        "contentHash": "V5w2z1+O1hGVexBvWOS+PemiVDU1wWx9EuK8J6+xqn7GgB1OPRe2GSeU3xexeNgrKF1+X64R0Vuv9bYoPDfIiA=="
-      },
-      "Xamarin.Jetbrains.Annotations": {
-        "type": "Transitive",
-        "resolved": "26.1.0.1",
-        "contentHash": "GQk+C9cG/ss7q3I73ewWEK6cSI7oXk5x6Z/LCe/m2Pf47SwLX5DYlsadIbSAJvxkRzeatm/SPd6SKU8kWQ1enA=="
-      },
-      "Xamarin.JSpecify": {
-        "type": "Transitive",
-        "resolved": "1.0.0.6",
-        "contentHash": "LilLB52Pijbp+5tSsLCT/POAjsTcALD95roNJvQAZWtp7qDem/pny2oZsgUVQ143kQIpMkZ2EETVeL4nI1Kwww=="
-      },
-      "Xamarin.Kotlin.StdLib": {
-        "type": "Transitive",
-        "resolved": "2.3.10.1",
-        "contentHash": "FJ2Yjvz/jHBXdQuF5KHDL27gacZ0WTBssABiopSBWE6ODa6jJiweld/3TqyhPUB9OEOgHiOAGUhlL98XLzdftw==",
-        "dependencies": {
-          "Xamarin.Jetbrains.Annotations": "26.1.0.1"
-        }
-      },
-      "Xamarin.KotlinX.Coroutines.Android": {
-        "type": "Transitive",
-        "resolved": "1.10.2.3",
-        "contentHash": "me/1VhRcYj46E/vn36vdgUZ11uGH69u/2JG6q+5i8kSL+3Tb10MN9HqTj4r6S4oloLP8QNhZ4yz/vIi6amk5qA==",
-        "dependencies": {
-          "Xamarin.Kotlin.StdLib": "2.3.10.1",
-          "Xamarin.KotlinX.Coroutines.Core.Jvm": "1.10.2.3"
-        }
-      },
-      "Xamarin.KotlinX.Coroutines.Core": {
-        "type": "Transitive",
-        "resolved": "1.10.2.3",
-        "contentHash": "nUFTp3liDGGgQHrPPoDxIOmgPE1qGqdbPLVapldo54Inn79fyhYQZ05z8cM7mPgC1a6AMqQcxca33zVeijD+tQ==",
-        "dependencies": {
-          "Xamarin.KotlinX.Coroutines.Core.Jvm": "1.10.2.3"
-        }
-      },
-      "Xamarin.KotlinX.Coroutines.Core.Jvm": {
-        "type": "Transitive",
-        "resolved": "1.10.2.3",
-        "contentHash": "7JxlouNHPQXVEHJpZcb6FXum/XYGepJuhujcs7dBO3sVaeQHSiDevDzZUOcKVnGyzOWfypyt4MLfAqteSzqdsg==",
-        "dependencies": {
-          "Xamarin.Jetbrains.Annotations": "26.1.0.1",
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "Xamarin.KotlinX.Serialization.Core": {
-        "type": "Transitive",
-        "resolved": "1.10.0.1",
-        "contentHash": "tw1jX3l3XgbK0sTU2KVCt/o4OOLtrZwF69A46W6DhVZyQgrW252bn7sC8+9RIb2/k0hGSIJvEA0kYXCFbfkj1g==",
-        "dependencies": {
-          "Xamarin.KotlinX.Serialization.Core.Jvm": "1.10.0.1"
-        }
-      },
-      "Xamarin.KotlinX.Serialization.Core.Jvm": {
-        "type": "Transitive",
-        "resolved": "1.10.0.1",
-        "contentHash": "kefEHOomdFnoJCE9WDKuJJLFKcqh1wLgmFWXAtGZ7+XiNOCJJDyqsj9J9gwmh/FSqsjm9e7dKWHnUJkwN50bUA==",
-        "dependencies": {
-          "Xamarin.Kotlin.StdLib": "2.3.10.1"
-        }
-      },
-      "galnet.assets": {
-        "type": "Project",
-        "dependencies": {
-          "GalNet.Core": "[1.0.0, )"
-        }
-      },
-      "galnet.core": {
-        "type": "Project"
-      },
-      "galnet.launcher": {
-        "type": "Project",
-        "dependencies": {
-          "Avalonia": "[12.0.5, )",
-          "Avalonia.Fonts.Inter": "[12.0.5, )",
-          "Avalonia.Themes.Fluent": "[12.0.5, )",
-          "AvaloniaUI.DiagnosticsSupport": "[2.2.3, )",
-          "CommunityToolkit.Mvvm": "[8.4.1, )",
-          "GalNet.Assets": "[1.0.0, )",
-          "GalNet.Core": "[1.0.0, )",
-          "GalNet.Runtime": "[1.0.0, )"
-        }
-      },
-      "galnet.presentation.abstractions": {
-        "type": "Project",
-        "dependencies": {
-          "GalNet.Core": "[1.0.0, )"
-        }
-      },
-      "galnet.runtime": {
-        "type": "Project",
-        "dependencies": {
-          "CoreCLR-NCalc": "[3.1.253, )",
-          "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
-          "Serilog": "[4.2.0, )"
-        }
-      },
-      "Avalonia": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
-        "dependencies": {
-          "Avalonia.BuildServices": "11.3.2",
-          "Avalonia.Remote.Protocol": "12.0.5",
-          "MicroCom.Runtime": "0.11.4"
-        }
-      },
-      "Avalonia.Fonts.Inter": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
-      "Avalonia.Skia": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "cSLTpvzsm5JpUA1tQvuht3qN6oiy1PNRgbrp1g7jCSzAFf+OKZecSne+KT1apBQUkevciaHxwtAxLolPGD9izg==",
-        "dependencies": {
-          "Avalonia": "12.0.5",
-          "HarfBuzzSharp": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3",
-          "SkiaSharp": "3.119.4",
-          "SkiaSharp.NativeAssets.Linux": "3.119.4",
-          "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
-        }
-      },
-      "Avalonia.Themes.Fluent": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
-      "AvaloniaUI.DiagnosticsSupport": {
-        "type": "CentralTransitive",
-        "requested": "[2.2.3, )",
-        "resolved": "2.2.3",
-        "contentHash": "kQCInYusi2c9tjd9hV05Lln6Csbo07kiC672M3G7dsalDBe2j+pOk3We2nzdyy5ptQYy/9gQiC8ZaHhb6u/5Kw==",
-        "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
-          "Microsoft.IO.RecyclableMemoryStream": "3.0.1"
-        }
-      },
-      "CommunityToolkit.Mvvm": {
-        "type": "CentralTransitive",
-        "requested": "[8.4.1, )",
-        "resolved": "8.4.1",
-        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
-      },
-      "CoreCLR-NCalc": {
-        "type": "CentralTransitive",
-        "requested": "[3.1.253, )",
-        "resolved": "3.1.253",
-        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
-        "dependencies": {
-          "Antlr4.Runtime.Standard": "4.13.1"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection.Abstractions": {
-        "type": "CentralTransitive",
-        "requested": "[10.0.0, )",
-        "resolved": "8.0.0",
-        "contentHash": "cjWrLkJXK0rs4zofsK4bSdg+jhDLTaxrkXu4gS6Y7MAlCvRyNNgwY/lJi5RDlQOnSZweHqoyvgvbdvQsRIW+hg=="
-      },
-      "Serilog": {
-        "type": "CentralTransitive",
-        "requested": "[4.2.0, )",
-        "resolved": "4.2.0",
-        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
-      }
-    },
-    "net10.0-android36.0/android-arm64": {
-      "HarfBuzzSharp.NativeAssets.Android": {
-        "type": "Transitive",
-        "resolved": "8.3.1.3",
-        "contentHash": "Yte9/yYql8ngAjo7YgHlXSinLJcJXIRBM9gegVXpJ2SVYT1i2O/wMA+H3jmYiYiTQxHpHKi4exZUcMzry171MA=="
-      },
-      "HarfBuzzSharp.NativeAssets.Linux": {
-        "type": "Transitive",
-        "resolved": "8.3.1.3",
-        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
-      },
-      "SkiaSharp.NativeAssets.Android": {
-        "type": "Transitive",
-        "resolved": "3.119.4",
-        "contentHash": "qfjNh5hZBZxpOIM1aeDByj2qNbcK2JZG5Y7YyGSeliaYnf1N/hVfsswIPUa+qzcMqS9Q0VCGk85zQLvwVXtrvQ=="
-      },
-      "SkiaSharp.NativeAssets.Linux": {
-        "type": "Transitive",
-        "resolved": "3.119.4",
-        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
-      }
-    },
-    "net10.0-android36.0/android-x64": {
-      "HarfBuzzSharp.NativeAssets.Android": {
-        "type": "Transitive",
-        "resolved": "8.3.1.3",
-        "contentHash": "Yte9/yYql8ngAjo7YgHlXSinLJcJXIRBM9gegVXpJ2SVYT1i2O/wMA+H3jmYiYiTQxHpHKi4exZUcMzry171MA=="
-      },
-      "HarfBuzzSharp.NativeAssets.Linux": {
-        "type": "Transitive",
-        "resolved": "8.3.1.3",
-        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
-      },
-      "SkiaSharp.NativeAssets.Android": {
-        "type": "Transitive",
-        "resolved": "3.119.4",
-        "contentHash": "qfjNh5hZBZxpOIM1aeDByj2qNbcK2JZG5Y7YyGSeliaYnf1N/hVfsswIPUa+qzcMqS9Q0VCGk85zQLvwVXtrvQ=="
-      },
-      "SkiaSharp.NativeAssets.Linux": {
-        "type": "Transitive",
-        "resolved": "3.119.4",
-        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/Launcher/GalNet.Launcher.Browser/GalNet.Launcher.Browser.csproj b/src/Launcher/GalNet.Launcher.Browser/GalNet.Launcher.Browser.csproj
deleted file mode 100644
index 8cb2f29a..00000000
--- a/src/Launcher/GalNet.Launcher.Browser/GalNet.Launcher.Browser.csproj
+++ /dev/null
@@ -1,16 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk.WebAssembly">
-  <PropertyGroup>
-    <TargetFramework>net10.0-browser</TargetFramework>
-    <OutputType>Exe</OutputType>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Avalonia.Browser" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\GalNet.Launcher\GalNet.Launcher.csproj" />
-  </ItemGroup>
-</Project>
diff --git a/src/Launcher/GalNet.Launcher.Browser/Program.cs b/src/Launcher/GalNet.Launcher.Browser/Program.cs
deleted file mode 100644
index a9c22365..00000000
--- a/src/Launcher/GalNet.Launcher.Browser/Program.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using System.Threading.Tasks;
-using Avalonia;
-using Avalonia.Browser;
-
-namespace GalNet.Launcher.Browser;
-
-internal sealed partial class Program
-{
-    private static Task Main(string[] args) => BuildAvaloniaApp()
-        .WithInterFont()
-#if DEBUG
-        .WithDeveloperTools()
-#endif
-        .StartBrowserAppAsync("out");
-
-    public static AppBuilder BuildAvaloniaApp()
-        => AppBuilder.Configure<App>();
-}
diff --git a/src/Launcher/GalNet.Launcher.Browser/Properties/AssemblyInfo.cs b/src/Launcher/GalNet.Launcher.Browser/Properties/AssemblyInfo.cs
deleted file mode 100644
index c4039b7b..00000000
--- a/src/Launcher/GalNet.Launcher.Browser/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1 +0,0 @@
-[assembly: System.Runtime.Versioning.SupportedOSPlatform("browser")]
diff --git a/src/Launcher/GalNet.Launcher.Browser/Properties/launchSettings.json b/src/Launcher/GalNet.Launcher.Browser/Properties/launchSettings.json
deleted file mode 100644
index ed60cfcf..00000000
--- a/src/Launcher/GalNet.Launcher.Browser/Properties/launchSettings.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-    "profiles": {
-    "GalNet.Launcher.Browser": {
-        "commandName": "Project",
-        "launchBrowser": true,
-        "environmentVariables": {
-          "ASPNETCORE_ENVIRONMENT": "Development"
-        },
-        "applicationUrl": "https://localhost:7169;http://localhost:5235",
-        "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}"
-      }
-    }
-}
diff --git a/src/Launcher/GalNet.Launcher.Browser/runtimeconfig.template.json b/src/Launcher/GalNet.Launcher.Browser/runtimeconfig.template.json
deleted file mode 100644
index b96a9432..00000000
--- a/src/Launcher/GalNet.Launcher.Browser/runtimeconfig.template.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "wasmHostProperties": {
-        "perHostConfig": [
-            {
-                "name": "browser",
-                "host": "browser"
-            }
-        ]
-    }
-}
\ No newline at end of file
diff --git a/src/Launcher/GalNet.Launcher.Browser/wwwroot/app.css b/src/Launcher/GalNet.Launcher.Browser/wwwroot/app.css
deleted file mode 100644
index 1d6f754a..00000000
--- a/src/Launcher/GalNet.Launcher.Browser/wwwroot/app.css
+++ /dev/null
@@ -1,58 +0,0 @@
-/* HTML styles for the splash screen */
-.avalonia-splash {
-    position: absolute;
-    height: 100%;
-    width: 100%;
-    background: white;
-    font-family: 'Outfit', sans-serif;
-    justify-content: center;
-    align-items: center;
-    display: flex;
-    pointer-events: none;
-}
-
-/* Light theme styles */
-@media (prefers-color-scheme: light) {
-    .avalonia-splash {
-        background: white;
-    }
-
-    .avalonia-splash h2 {
-        color: #1b2a4e;
-    }
-
-    .avalonia-splash a {
-        color: #0D6EFD;
-    }
-}
-
-@media (prefers-color-scheme: dark) {
-    .avalonia-splash {
-        background: #1b2a4e;
-    }
-
-    .avalonia-splash h2 {
-        color: white;
-    }
-
-    .avalonia-splash a {
-        color: white;
-    }
-}
-
-.avalonia-splash h2 {
-    font-weight: 400;
-    font-size: 1.5rem;
-}
-
-.avalonia-splash a {
-    text-decoration: none;
-    font-size: 2.5rem;
-    display: block;   
-}
-
-.avalonia-splash.splash-close {
-    transition: opacity 200ms, display 200ms;
-    display: none;
-    opacity: 0;
-}
diff --git a/src/Launcher/GalNet.Launcher.Browser/wwwroot/favicon.ico b/src/Launcher/GalNet.Launcher.Browser/wwwroot/favicon.ico
deleted file mode 100644
index f7da8bb5..00000000
Binary files a/src/Launcher/GalNet.Launcher.Browser/wwwroot/favicon.ico and /dev/null differ
diff --git a/src/Launcher/GalNet.Launcher.Browser/wwwroot/index.html b/src/Launcher/GalNet.Launcher.Browser/wwwroot/index.html
deleted file mode 100644
index ef7a4aa6..00000000
--- a/src/Launcher/GalNet.Launcher.Browser/wwwroot/index.html
+++ /dev/null
@@ -1,36 +0,0 @@
-<!DOCTYPE html>
-<html>
-
-<head>
-    <title>GalNet.Launcher.Browser</title>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <link rel="stylesheet" href="./app.css" />
-</head>
-
-<body style="margin: 0; overflow: hidden">
-<div id="out">
-    <div class="avalonia-splash">
-        <h2>
-            Powered by
-            <a href="https://www.avaloniaui.net/" target="_blank">
-                <svg width="266" height="52" viewBox="0 0 266 52" fill="none" xmlns="http://www.w3.org/2000/svg">
-                    <path d="M55.8592 47.3941C54.9035 47.3941 54.1184 47.1723 53.504 46.7285C52.9237 46.2848 52.5483 45.6875 52.3776 44.9365C52.2411 44.1856 52.3947 43.3493 52.8384 42.4277L65.9456 13.7045C66.4917 12.544 67.1403 11.7077 67.8912 11.1957C68.6421 10.6496 69.5125 10.3765 70.5024 10.3765C71.4923 10.3765 72.3627 10.6496 73.1136 11.1957C73.8645 11.7077 74.496 12.544 75.008 13.7045L88.2176 42.4277C88.6613 43.3493 88.8149 44.2027 88.6784 44.9877C88.576 45.7387 88.2347 46.336 87.6544 46.7797C87.0741 47.1893 86.3232 47.3941 85.4016 47.3941C84.2411 47.3941 83.3365 47.1211 82.688 46.5749C82.0736 46.0288 81.5275 45.1755 81.0496 44.0149L78.9279 39.0997H62.0415L59.9552 44.0149C59.4432 45.2096 58.8971 46.08 58.3168 46.6261C57.7707 47.1381 56.9515 47.3941 55.8592 47.3941ZM70.4 19.2853L64.6844 32.9045H76.2627L70.5024 19.2853H70.4Z" fill="currentColor"/>
-                    <path d="M101.869 47.3941C100.879 47.3941 100.009 47.1381 99.258 46.6261C98.5071 46.08 97.9096 45.2779 97.4659 44.2197L89.7348 26.4021C89.3593 25.5147 89.2228 24.6955 89.3252 23.9445C89.4276 23.1595 89.786 22.5451 90.4004 22.1013C91.0489 21.6235 91.9364 21.3845 93.0628 21.3845C93.9844 21.3845 94.7353 21.6064 95.3156 22.0501C95.8959 22.4597 96.4079 23.2619 96.8516 24.4565L102.018 37.95L107.552 24.4053C108.03 23.2448 108.559 22.4597 109.14 22.0501C109.72 21.6064 110.522 21.3845 111.546 21.3845C112.433 21.3845 113.133 21.6235 113.645 22.1013C114.191 22.5451 114.516 23.1424 114.618 23.8933C114.755 24.6443 114.618 25.4635 114.208 26.3509L106.324 44.2197C105.88 45.312 105.283 46.1141 104.532 46.6261C103.815 47.1381 102.927 47.3941 101.869 47.3941Z" fill="currentColor"/>
-                    <path d="M126.569 47.4965C124.726 47.4965 123.07 47.1381 121.602 46.4213C120.135 45.7045 118.991 44.7317 118.172 43.5029C117.353 42.2741 116.943 40.8917 116.943 39.3557C116.943 37.5125 117.421 36.0619 118.377 35.0037C119.333 33.9115 120.886 33.1435 123.036 32.6997C125.186 32.2219 128.037 31.9829 131.586 31.9829H133.43V35.9765H131.638C129.897 35.9765 128.48 36.0789 127.388 36.2837C126.33 36.4544 125.562 36.7616 125.084 37.2053C124.64 37.6491 124.418 38.2635 124.418 39.0485C124.418 40.0043 124.743 40.7893 125.391 41.4037C126.074 42.0181 127.047 42.3253 128.31 42.3253C129.299 42.3253 130.17 42.1035 130.921 41.6597C131.706 41.1819 132.32 40.5504 132.764 39.7653C133.208 38.9461 133.43 38.0245 133.43 37.0005V31.1125C133.43 29.6107 133.088 28.5525 132.406 27.9381C131.723 27.2896 130.562 26.9653 128.924 26.9653C128.002 26.9653 126.995 27.0848 125.903 27.3237C124.845 27.5285 123.667 27.8869 122.37 28.3989C121.619 28.7403 120.954 28.8256 120.374 28.6549C119.793 28.4501 119.35 28.1088 119.042 27.6309C118.735 27.1189 118.582 26.5728 118.582 25.9925C118.582 25.3781 118.752 24.7979 119.094 24.2517C119.435 23.6715 119.998 23.2448 120.783 22.9717C122.387 22.3232 123.889 21.8795 125.289 21.6405C126.722 21.4016 128.037 21.2821 129.231 21.2821C131.859 21.2821 134.01 21.6747 135.682 22.4597C137.389 23.2107 138.669 24.3883 139.522 25.9925C140.376 27.5627 140.802 29.5936 140.802 32.0853V43.4517C140.802 44.7147 140.495 45.6875 139.881 46.3701C139.266 47.0528 138.379 47.3941 137.218 47.3941C136.058 47.3941 135.153 47.0528 134.505 46.3701C133.89 45.6875 133.583 44.7147 133.583 43.4517L133.594 43.15C133.594 43.15 133.293 44.032 132.61 44.8853C131.962 45.7045 131.126 46.3531 130.102 46.8309C129.078 47.2747 127.9 47.4965 126.569 47.4965Z" fill="currentColor"/>
-                    <path d="M155.632 47.4965C152.594 47.4965 150.324 46.6603 148.822 44.9877C147.321 43.2811 146.57 40.7552 146.57 37.4101V14.3189C146.57 13.0219 146.894 12.0491 147.542 11.4005C148.225 10.7179 149.198 10.3765 150.461 10.3765C151.69 10.3765 152.628 10.7179 153.277 11.4005C153.959 12.0491 154.301 13.0219 154.301 14.3189V37.1029C154.301 38.5024 154.591 39.5435 155.171 40.2261C155.786 40.8747 156.588 41.1989 157.578 41.1989C157.851 41.1989 158.107 41.1819 158.346 41.1477C158.585 41.1136 158.841 41.0965 159.114 41.0965C159.66 41.0283 160.035 41.1989 160.24 41.6085C160.479 41.984 160.598 42.752 160.598 43.9125C160.598 44.9365 160.394 45.7216 159.984 46.2677C159.574 46.7797 158.943 47.1211 158.09 47.2917C157.748 47.3259 157.356 47.36 156.912 47.3941C156.468 47.4624 156.042 47.4965 155.632 47.4965Z" fill="currentColor"/>
-                    <path d="M175.453 47.4965C172.756 47.4965 170.401 46.9675 168.387 45.9093C166.407 44.8512 164.871 43.3323 163.779 41.3525C162.687 39.3728 162.141 37.0347 162.141 34.3381C162.141 32.3243 162.448 30.5152 163.062 28.9109C163.677 27.3067 164.564 25.9413 165.725 24.8149C166.919 23.6544 168.336 22.784 169.974 22.2037C171.613 21.5893 173.439 21.2821 175.453 21.2821C178.149 21.2821 180.487 21.8112 182.467 22.8693C184.481 23.9275 186.034 25.4293 187.126 27.3749C188.253 29.3205 188.816 31.6416 188.816 34.3381C188.816 36.3861 188.492 38.2123 187.843 39.8165C187.229 41.4208 186.341 42.8032 185.181 43.9637C184.02 45.1243 182.604 46.0117 180.931 46.6261C179.293 47.2064 177.467 47.4965 175.453 47.4965ZM175.453 41.7109C176.579 41.7109 177.552 41.4379 178.371 40.8917C179.19 40.3456 179.839 39.5435 180.317 38.4853C180.795 37.3931 181.034 36.0107 181.034 34.3381C181.034 31.8464 180.522 30.0203 179.498 28.8597C178.474 27.6651 177.125 27.0677 175.453 27.0677C174.361 27.0677 173.388 27.3237 172.534 27.8357C171.715 28.3477 171.067 29.1499 170.589 30.2421C170.145 31.3003 169.923 32.6656 169.923 34.3381C169.923 36.8299 170.435 38.6901 171.459 39.9189C172.483 41.1136 173.814 41.7109 175.453 41.7109Z" fill="currentColor"/>
-                    <path d="M197.411 47.3941C196.148 47.3941 195.175 47.0528 194.492 46.3701C193.844 45.6875 193.52 44.7147 193.52 43.4517V25.2757C193.52 24.0128 193.844 23.0571 194.492 22.4085C195.175 21.7259 196.114 21.3845 197.308 21.3845C198.537 21.3845 199.476 21.7259 200.124 22.4085C200.773 23.0571 201.112 24.1871 201.112 25.45C201.141 25.3955 202.48 23.552 204.016 22.6645C205.586 21.7429 207.361 21.2821 209.34 21.2821C211.354 21.2821 213.01 21.6747 214.307 22.4597C215.604 23.2107 216.577 24.3712 217.225 25.9413C217.874 27.4773 218.198 29.44 218.198 31.8293V43.4517C218.198 44.7147 217.857 45.6875 217.174 46.3701C216.525 47.0528 215.57 47.3941 214.307 47.3941C213.078 47.3941 212.122 47.0528 211.44 46.3701C210.791 45.6875 210.467 44.7147 210.467 43.4517V32.1877C210.467 30.4469 210.143 29.2011 209.494 28.4501C208.88 27.6651 207.924 27.2725 206.627 27.2725C204.988 27.2725 203.674 27.7845 202.684 28.8085C201.729 29.8325 201.251 31.1979 201.251 32.9045V43.4517C201.251 46.08 199.971 47.3941 197.411 47.3941Z" fill="currentColor"/>
-                    <path d="M227.861 47.3429C226.598 47.3429 225.625 46.9845 224.942 46.2677C224.294 45.5168 223.97 44.4757 223.97 43.1445V25.6341C223.97 24.2688 224.294 23.2277 224.942 22.5109C225.625 21.76 226.598 21.3845 227.861 21.3845C229.09 21.3845 230.028 21.76 230.677 22.5109C231.359 23.2277 231.701 24.2688 231.701 25.6341V43.1445C231.701 44.4757 231.377 45.5168 230.728 46.2677C230.079 46.9845 229.124 47.3429 227.861 47.3429ZM227.861 17.1861C226.427 17.1861 225.318 16.8619 224.533 16.2133C223.782 15.5307 223.406 14.5749 223.406 13.3461C223.406 12.0832 223.782 11.1275 224.533 10.4789C225.318 9.79629 226.427 9.45496 227.861 9.45496C229.294 9.45496 230.387 9.79629 231.138 10.4789C231.889 11.1275 232.264 12.0832 232.264 13.3461C232.264 14.5749 231.889 15.5307 231.138 16.2133C230.387 16.8619 229.294 17.1861 227.861 17.1861Z" fill="currentColor"/>
-                    <path d="M246.169 47.4965C244.326 47.4965 242.67 47.1381 241.202 46.4213C239.735 45.7045 238.591 44.7317 237.772 43.5029C236.953 42.2741 236.543 40.8917 236.543 39.3557C236.543 37.5125 237.021 36.0619 237.977 35.0037C238.933 33.9115 240.486 33.1435 242.636 32.6997C244.786 32.2219 247.637 31.9829 251.186 31.9829H253.03V35.9765H251.238C249.497 35.9765 248.08 36.0789 246.988 36.2837C245.93 36.4544 245.162 36.7616 244.684 37.2053C244.24 37.6491 244.018 38.2635 244.018 39.0485C244.018 40.0043 244.343 40.7893 244.991 41.4037C245.674 42.0181 246.647 42.3253 247.91 42.3253C248.899 42.3253 249.77 42.1035 250.521 41.6597C251.306 41.1819 251.92 40.5504 252.364 39.7653C252.808 38.9461 253.03 38.0245 253.03 37.0005V31.1125C253.03 29.6107 252.688 28.5525 252.006 27.9381C251.323 27.2896 250.162 26.9653 248.524 26.9653C247.602 26.9653 246.595 27.0848 245.503 27.3237C244.445 27.5285 243.267 27.8869 241.97 28.3989C241.219 28.7403 240.554 28.8256 239.974 28.6549C239.393 28.4501 238.95 28.1088 238.642 27.6309C238.335 27.1189 238.182 26.5728 238.182 25.9925C238.182 25.3781 238.352 24.7979 238.694 24.2517C239.035 23.6715 239.598 23.2448 240.383 22.9717C241.987 22.3232 243.489 21.8795 244.889 21.6405C246.322 21.4016 247.637 21.2821 248.831 21.2821C251.459 21.2821 253.61 21.6747 255.282 22.4597C256.989 23.2107 258.269 24.3883 259.122 25.9925C259.976 27.5627 260.402 29.5936 260.402 32.0853V43.4517C260.402 44.7147 260.095 45.6875 259.481 46.3701C258.866 47.0528 257.979 47.3941 256.818 47.3941C255.658 47.3941 254.753 47.0528 254.105 46.3701C253.49 45.6875 253.183 44.7147 253.183 43.4517V43.1789C253.183 43.3144 252.893 44.032 252.21 44.8853C251.562 45.7045 250.726 46.3531 249.702 46.8309C248.678 47.2747 247.5 47.4965 246.169 47.4965Z" fill="currentColor"/>
-                    <path d="M22.3444 20.9916C18.7895 20.9916 15.9077 24.0073 15.9077 27.7274C15.9077 31.4475 18.7895 34.4632 22.3444 34.4632C25.8993 34.4632 28.7811 31.4475 28.7811 27.7274C28.7811 24.0073 25.8993 20.9916 22.3444 20.9916Z" fill="currentColor"/>
-                    <path fill-rule="evenodd" clip-rule="evenodd" d="M37.6937 49.0667H21.9271C10.8346 48.8653 1.90173 39.3893 1.90173 27.7333C1.90173 15.9513 11.0289 6.40002 22.2878 6.40002C33.3638 6.40002 42.3768 15.6435 42.6667 27.161L42.6314 44.4824C42.338 47.0679 40.2434 49.0667 37.6937 49.0667ZM9.22617 24.667C10.5612 18.3725 15.9275 13.6656 22.3444 13.6656C29.7657 13.6656 35.7818 19.9613 35.7818 27.7274C35.7818 27.7857 35.7825 27.8488 35.7831 27.9136C35.7846 28.0483 35.7861 28.1901 35.7818 28.3103V41.6939H28.7907V40.0685C26.877 41.1655 24.6803 41.7892 22.3444 41.7892C15.9275 41.7892 10.5612 37.0823 9.22617 30.7878C10.5043 30.4129 11.4416 29.1847 11.4416 27.7274C11.4416 26.2701 10.5043 25.0419 9.22617 24.667ZM8.33937 29.9683C9.52696 29.9683 10.4897 28.9609 10.4897 27.7181C10.4897 26.4753 9.52696 25.4678 8.33937 25.4678C7.15178 25.4678 6.18904 26.4753 6.18904 27.7181C6.18904 28.9609 7.15178 29.9683 8.33937 29.9683Z" fill="currentColor"/>
-                </svg>
-            </a>
-        </h2>
-    </div>
-</div>
-<script type='module' src="./main.js"></script>
-</body>
-
-</html>
diff --git a/src/Launcher/GalNet.Launcher.Browser/wwwroot/main.js b/src/Launcher/GalNet.Launcher.Browser/wwwroot/main.js
deleted file mode 100644
index bf1555e4..00000000
--- a/src/Launcher/GalNet.Launcher.Browser/wwwroot/main.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import { dotnet } from './_framework/dotnet.js'
-
-const is_browser = typeof window != "undefined";
-if (!is_browser) throw new Error(`Expected to be running in a browser`);
-
-const dotnetRuntime = await dotnet
-    .withDiagnosticTracing(false)
-    .withApplicationArgumentsFromQuery()
-    .create();
-
-const config = dotnetRuntime.getConfig();
-
-await dotnetRuntime.runMain(config.mainAssemblyName, [globalThis.location.href]);
diff --git a/src/Launcher/GalNet.Launcher.Desktop/GalNet.Launcher.Desktop.csproj b/src/Launcher/GalNet.Launcher.Desktop/GalNet.Launcher.Desktop.csproj
deleted file mode 100644
index 87d6ee1a..00000000
--- a/src/Launcher/GalNet.Launcher.Desktop/GalNet.Launcher.Desktop.csproj
+++ /dev/null
@@ -1,25 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <!--If you are willing to use platform-specific APIs, use conditional compilation.
-    See https://docs.avaloniaui.net/docs/guides/platforms/platform-specific-code/dotnet for more details.-->
-    <TargetFramework>net10.0</TargetFramework>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <ApplicationManifest>app.manifest</ApplicationManifest>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Avalonia.Desktop" />
-    <PackageReference Include="AvaloniaUI.DiagnosticsSupport" >
-      <IncludeAssets Condition="'$(Configuration)' != 'Debug'">None</IncludeAssets>
-      <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
-    </PackageReference>
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\GalNet.Launcher\GalNet.Launcher.csproj" />
-  </ItemGroup>
-</Project>
diff --git a/src/Launcher/GalNet.Launcher.Desktop/Program.cs b/src/Launcher/GalNet.Launcher.Desktop/Program.cs
deleted file mode 100644
index be6603f7..00000000
--- a/src/Launcher/GalNet.Launcher.Desktop/Program.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-using Avalonia;
-
-namespace GalNet.Launcher.Desktop;
-
-sealed class Program
-{
-    // Initialization code. Don't use any Avalonia, third-party APIs or any
-    // SynchronizationContext-reliant code before AppMain is called: things aren't initialized
-    // yet and stuff might break.
-    [STAThread]
-    public static void Main(string[] args) => BuildAvaloniaApp()
-        .StartWithClassicDesktopLifetime(args);
-
-    // Avalonia configuration, don't remove; also used by visual designer.
-    public static AppBuilder BuildAvaloniaApp()
-        => AppBuilder.Configure<App>()
-            .UsePlatformDetect()
-#if DEBUG
-            .WithDeveloperTools()
-#endif
-            .WithInterFont()
-            .LogToTrace();
-}
diff --git a/src/Launcher/GalNet.Launcher.Desktop/app.manifest b/src/Launcher/GalNet.Launcher.Desktop/app.manifest
deleted file mode 100644
index d0995d9a..00000000
--- a/src/Launcher/GalNet.Launcher.Desktop/app.manifest
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
-  <!-- This manifest is used on Windows only.
-       Don't remove it as it might cause problems with window transparency and embedded controls.
-       For more details visit https://learn.microsoft.com/en-us/windows/win32/sbscs/application-manifests -->
-  <assemblyIdentity version="1.0.0.0" name="GalNet.Launcher.Desktop"/>
-
-  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
-    <application>
-      <!-- A list of the Windows versions that this application has been tested on
-           and is designed to work with. Uncomment the appropriate elements
-           and Windows will automatically select the most compatible environment. -->
-
-      <!-- Windows 10 -->
-      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
-    </application>
-  </compatibility>
-</assembly>
diff --git a/src/Launcher/GalNet.Launcher.iOS/AppDelegate.cs b/src/Launcher/GalNet.Launcher.iOS/AppDelegate.cs
deleted file mode 100644
index b3c0d63b..00000000
--- a/src/Launcher/GalNet.Launcher.iOS/AppDelegate.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using Avalonia;
-using Avalonia.Controls;
-using Avalonia.iOS;
-using Avalonia.Media;
-using Foundation;
-using UIKit;
-
-namespace GalNet.Launcher.iOS;
-
-// The UIApplicationDelegate for the application. This class is responsible for launching the 
-// User Interface of the application, as well as listening (and optionally responding) to 
-// application events from iOS.
-[Register("AppDelegate")]
-#pragma warning disable CA1711 // Identifiers should not have incorrect suffix
-public partial class AppDelegate : AvaloniaAppDelegate<App>
-#pragma warning restore CA1711 // Identifiers should not have incorrect suffix
-{
-    protected override AppBuilder CustomizeAppBuilder(AppBuilder builder)
-    {
-        return base.CustomizeAppBuilder(builder)
-            .WithInterFont();
-    }
-}
diff --git a/src/Launcher/GalNet.Launcher.iOS/Entitlements.plist b/src/Launcher/GalNet.Launcher.iOS/Entitlements.plist
deleted file mode 100644
index 0c67376e..00000000
--- a/src/Launcher/GalNet.Launcher.iOS/Entitlements.plist
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict/>
-</plist>
diff --git a/src/Launcher/GalNet.Launcher.iOS/GalNet.Launcher.iOS.csproj b/src/Launcher/GalNet.Launcher.iOS/GalNet.Launcher.iOS.csproj
deleted file mode 100644
index 77cc7ae5..00000000
--- a/src/Launcher/GalNet.Launcher.iOS/GalNet.Launcher.iOS.csproj
+++ /dev/null
@@ -1,16 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net10.0-ios</TargetFramework>
-    <SupportedOSPlatformVersion>13.0</SupportedOSPlatformVersion>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Avalonia.iOS" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\GalNet.Launcher\GalNet.Launcher.csproj" />
-  </ItemGroup>
-</Project>
diff --git a/src/Launcher/GalNet.Launcher.iOS/Info.plist b/src/Launcher/GalNet.Launcher.iOS/Info.plist
deleted file mode 100644
index 11352d56..00000000
--- a/src/Launcher/GalNet.Launcher.iOS/Info.plist
+++ /dev/null
@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDisplayName</key>
-	<string>GalNet.Launcher</string>
-	<key>CFBundleIdentifier</key>
-	<string>companyName.GalNet.Launcher</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-	<key>LSRequiresIPhoneOS</key>
-	<true/>
-	<key>MinimumOSVersion</key>
-	<string>13.0</string>
-	<key>UIDeviceFamily</key>
-	<array>
-		<integer>1</integer>
-		<integer>2</integer>
-	</array>
-	<key>UILaunchStoryboardName</key>
-	<string>LaunchScreen</string>
-	<key>UIRequiredDeviceCapabilities</key>
-	<array>
-		<string>armv7</string>
-	</array>
-	<key>UISupportedInterfaceOrientations</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationPortraitUpsideDown</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-	<key>UISupportedInterfaceOrientations~ipad</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationPortraitUpsideDown</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-</dict>
-</plist>
diff --git a/src/Launcher/GalNet.Launcher.iOS/Main.cs b/src/Launcher/GalNet.Launcher.iOS/Main.cs
deleted file mode 100644
index 60cfc5e9..00000000
--- a/src/Launcher/GalNet.Launcher.iOS/Main.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using UIKit;
-
-namespace GalNet.Launcher.iOS;
-
-public class Application
-{
-    // This is the main entry point of the application.
-    static void Main(string[] args)
-    {
-        // if you want to use a different Application Delegate class from "AppDelegate"
-        // you can specify it here.
-        UIApplication.Main(args, null, typeof(AppDelegate));
-    }
-}
diff --git a/src/Launcher/GalNet.Launcher.iOS/Resources/LaunchScreen.xib b/src/Launcher/GalNet.Launcher.iOS/Resources/LaunchScreen.xib
deleted file mode 100644
index cda5a651..00000000
--- a/src/Launcher/GalNet.Launcher.iOS/Resources/LaunchScreen.xib
+++ /dev/null
@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.XIB" version="3.0" toolsVersion="6214" systemVersion="14A314h" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES">
-	<dependencies>
-		<plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="6207" />
-		<capability name="Constraints with non-1.0 multipliers" minToolsVersion="5.1" />
-	</dependencies>
-	<objects>
-		<placeholder placeholderIdentifier="IBFilesOwner" id="-1" userLabel="File's Owner" />
-		<placeholder placeholderIdentifier="IBFirstResponder" id="-2" customClass="UIResponder" />
-		<view contentMode="scaleToFill" id="iN0-l3-epB">
-			<rect key="frame" x="0.0" y="0.0" width="480" height="480" />
-			<autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES" />
-			<subviews>
-				<label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="  Copyright (c) 2022 " textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines"
-					minimumFontSize="9" translatesAutoresizingMaskIntoConstraints="NO" id="8ie-xW-0ye">
-					<rect key="frame" x="20" y="439" width="441" height="21" />
-					<fontDescription key="fontDescription" type="system" pointSize="17" />
-					<color key="textColor" cocoaTouchSystemColor="darkTextColor" />
-					<nil key="highlightedColor" />
-				</label>
-				<label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="GalNet.Launcher" textAlignment="center" lineBreakMode="middleTruncation" baselineAdjustment="alignBaselines"
-					minimumFontSize="18" translatesAutoresizingMaskIntoConstraints="NO" id="kId-c2-rCX">
-					<rect key="frame" x="20" y="140" width="441" height="43" />
-					<fontDescription key="fontDescription" type="boldSystem" pointSize="36" />
-					<color key="textColor" cocoaTouchSystemColor="darkTextColor" />
-					<nil key="highlightedColor" />
-				</label>
-			</subviews>
-			<color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite" />
-			<constraints>
-				<constraint firstItem="kId-c2-rCX" firstAttribute="centerY" secondItem="iN0-l3-epB" secondAttribute="bottom" multiplier="1/3" constant="1" id="5cJ-9S-tgC" />
-				<constraint firstAttribute="centerX" secondItem="kId-c2-rCX" secondAttribute="centerX" id="Koa-jz-hwk" />
-				<constraint firstAttribute="bottom" secondItem="8ie-xW-0ye" secondAttribute="bottom" constant="20" id="Kzo-t9-V3l" />
-				<constraint firstItem="8ie-xW-0ye" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" constant="20" symbolic="YES" id="MfP-vx-nX0" />
-				<constraint firstAttribute="centerX" secondItem="8ie-xW-0ye" secondAttribute="centerX" id="ZEH-qu-HZ9" />
-				<constraint firstItem="kId-c2-rCX" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" constant="20" symbolic="YES" id="fvb-Df-36g" />
-			</constraints>
-			<nil key="simulatedStatusBarMetrics" />
-			<freeformSimulatedSizeMetrics key="simulatedDestinationMetrics" />
-			<point key="canvasLocation" x="548" y="455" />
-		</view>
-	</objects>
-</document>
diff --git a/src/Launcher/GalNet.Launcher.slnx b/src/Launcher/GalNet.Launcher.slnx
deleted file mode 100644
index e5d53cd7..00000000
--- a/src/Launcher/GalNet.Launcher.slnx
+++ /dev/null
@@ -1,11 +0,0 @@
-<Solution>
-  <Project Path="GalNet.Launcher.Android/GalNet.Launcher.Android.csproj">
-    <Deploy />
-  </Project>
-  <Project Path="GalNet.Launcher.Browser/GalNet.Launcher.Browser.csproj" />
-  <Project Path="GalNet.Launcher.Desktop/GalNet.Launcher.Desktop.csproj" />
-  <Project Path="GalNet.Launcher.iOS/GalNet.Launcher.iOS.csproj">
-    <Deploy />
-  </Project>
-  <Project Path="GalNet.Launcher/GalNet.Launcher.csproj" />
-</Solution>
diff --git a/src/Launcher/GalNet.Launcher/App.axaml b/src/Launcher/GalNet.Launcher/App.axaml
deleted file mode 100644
index c1d37089..00000000
--- a/src/Launcher/GalNet.Launcher/App.axaml
+++ /dev/null
@@ -1,15 +0,0 @@
-<Application xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:local="using:GalNet.Launcher"
-             x:Class="GalNet.Launcher.App"
-             RequestedThemeVariant="Default">
-             <!-- "Default" ThemeVariant follows system theme variant. "Dark" or "Light" are other available options. -->
-
-    <Application.DataTemplates>
-        <local:ViewLocator/>
-    </Application.DataTemplates>    
-
-    <Application.Styles>
-        <FluentTheme />
-    </Application.Styles>
-</Application>
\ No newline at end of file
diff --git a/src/Launcher/GalNet.Launcher/App.axaml.cs b/src/Launcher/GalNet.Launcher/App.axaml.cs
deleted file mode 100644
index 0d376a80..00000000
--- a/src/Launcher/GalNet.Launcher/App.axaml.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using System.Linq;
-using Avalonia;
-using Avalonia.Controls.ApplicationLifetimes;
-using Avalonia.Data.Core;
-using Avalonia.Data.Core.Plugins;
-using Avalonia.Markup.Xaml;
-using GalNet.Launcher.ViewModels;
-using GalNet.Launcher.Views;
-
-namespace GalNet.Launcher;
-
-public partial class App : Application
-{
-    public override void Initialize()
-    {
-        AvaloniaXamlLoader.Load(this);
-    }
-
-    public override void OnFrameworkInitializationCompleted()
-    {
-        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
-        {
-            desktop.MainWindow = new MainWindow
-            {
-                DataContext = new MainViewModel()
-            };
-        }
-        else if (ApplicationLifetime is IActivityApplicationLifetime singleViewFactoryApplicationLifetime)
-        {
-            singleViewFactoryApplicationLifetime.MainViewFactory = () => new MainView { DataContext = new MainViewModel() };
-        }
-        else if (ApplicationLifetime is ISingleViewApplicationLifetime singleViewPlatform)
-        {
-            singleViewPlatform.MainView = new MainView
-            {
-                DataContext = new MainViewModel()
-            };
-        }
-
-        base.OnFrameworkInitializationCompleted();
-    }
-}
diff --git a/src/Launcher/GalNet.Launcher/Assets/Icon.png b/src/Launcher/GalNet.Launcher/Assets/Icon.png
deleted file mode 100644
index 3c398459..00000000
Binary files a/src/Launcher/GalNet.Launcher/Assets/Icon.png and /dev/null differ
diff --git a/src/Launcher/GalNet.Launcher/Assets/avalonia-logo.ico b/src/Launcher/GalNet.Launcher/Assets/avalonia-logo.ico
deleted file mode 100644
index f7da8bb5..00000000
Binary files a/src/Launcher/GalNet.Launcher/Assets/avalonia-logo.ico and /dev/null differ
diff --git a/src/Launcher/GalNet.Launcher/GalNet.Launcher.csproj b/src/Launcher/GalNet.Launcher/GalNet.Launcher.csproj
deleted file mode 100644
index 20b2cbf9..00000000
--- a/src/Launcher/GalNet.Launcher/GalNet.Launcher.csproj
+++ /dev/null
@@ -1,29 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
-    <Nullable>enable</Nullable>
-    <LangVersion>latest</LangVersion>
-    <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
-  </PropertyGroup>
-  
-  <ItemGroup>
-    <AvaloniaResource Include="Assets\**" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Avalonia" />
-    <PackageReference Include="Avalonia.Themes.Fluent" />
-    <PackageReference Include="Avalonia.Fonts.Inter" />
-    <PackageReference Include="AvaloniaUI.DiagnosticsSupport">
-      <IncludeAssets Condition="'$(Configuration)' != 'Debug'">None</IncludeAssets>
-      <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="CommunityToolkit.Mvvm" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\Shared\GalNet.Assets\GalNet.Assets.csproj" />
-    <ProjectReference Include="..\..\Shared\GalNet.Core\GalNet.Core.csproj" />
-    <ProjectReference Include="..\..\Shared\GalNet.Runtime\GalNet.Runtime.csproj" />
-  </ItemGroup>
-</Project>
diff --git a/src/Launcher/GalNet.Launcher/ViewLocator.cs b/src/Launcher/GalNet.Launcher/ViewLocator.cs
deleted file mode 100644
index 12797d13..00000000
--- a/src/Launcher/GalNet.Launcher/ViewLocator.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using System.Diagnostics.CodeAnalysis;
-using Avalonia.Controls.Templates;
-using GalNet.Launcher.ViewModels;
-using AvaloniaControl = Avalonia.Controls.Control;
-using AvaloniaTextBlock = Avalonia.Controls.TextBlock;
-
-namespace GalNet.Launcher;
-
-/// <summary>
-/// Given a view model, returns the corresponding view if possible.
-/// </summary>
-[RequiresUnreferencedCode(
-    "Default implementation of ViewLocator involves reflection which may be trimmed away.",
-    Url = "https://docs.avaloniaui.net/docs/concepts/view-locator")]
-public class ViewLocator : IDataTemplate
-{
-    public AvaloniaControl? Build(object? param)
-    {
-        if (param is null)
-            return null;
-
-        var name = param.GetType().FullName!.Replace("ViewModel", "View", StringComparison.Ordinal);
-        var type = Type.GetType(name);
-
-        if (type != null)
-        {
-            return (AvaloniaControl)Activator.CreateInstance(type)!;
-        }
-
-        return new AvaloniaTextBlock { Text = "Not Found: " + name };
-    }
-
-    public bool Match(object? data)
-    {
-        return data is ViewModelBase;
-    }
-}
diff --git a/src/Launcher/GalNet.Launcher/ViewModels/MainViewModel.cs b/src/Launcher/GalNet.Launcher/ViewModels/MainViewModel.cs
deleted file mode 100644
index b72f1364..00000000
--- a/src/Launcher/GalNet.Launcher/ViewModels/MainViewModel.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-using CommunityToolkit.Mvvm.ComponentModel;
-
-namespace GalNet.Launcher.ViewModels;
-
-public partial class MainViewModel : ViewModelBase
-{
-    [ObservableProperty]
-    private string _greeting = "Welcome to Avalonia!";
-}
diff --git a/src/Launcher/GalNet.Launcher/ViewModels/ViewModelBase.cs b/src/Launcher/GalNet.Launcher/ViewModels/ViewModelBase.cs
deleted file mode 100644
index 02296593..00000000
--- a/src/Launcher/GalNet.Launcher/ViewModels/ViewModelBase.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-using CommunityToolkit.Mvvm.ComponentModel;
-
-namespace GalNet.Launcher.ViewModels;
-
-public abstract class ViewModelBase : ObservableObject
-{
-}
diff --git a/src/Launcher/GalNet.Launcher/Views/MainView.axaml b/src/Launcher/GalNet.Launcher/Views/MainView.axaml
deleted file mode 100644
index 7cda0ade..00000000
--- a/src/Launcher/GalNet.Launcher/Views/MainView.axaml
+++ /dev/null
@@ -1,16 +0,0 @@
-<UserControl xmlns="https://github.com/avaloniaui"
-                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-                xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-                xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-                xmlns:vm="using:GalNet.Launcher.ViewModels"
-                mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
-                x:Class="GalNet.Launcher.Views.MainView"
-                x:DataType="vm:MainViewModel">
-    <Design.DataContext>
-        <!-- This only sets the DataContext for the previewer in an IDE,
-to set the actual DataContext for runtime, set the DataContext property in code (look at App.axaml.cs) -->
-        <vm:MainViewModel />
-    </Design.DataContext>
-
-    <TextBlock Text="{Binding Greeting}" HorizontalAlignment="Center" VerticalAlignment="Center"/>
-</UserControl>
diff --git a/src/Launcher/GalNet.Launcher/Views/MainView.axaml.cs b/src/Launcher/GalNet.Launcher/Views/MainView.axaml.cs
deleted file mode 100644
index c55d191b..00000000
--- a/src/Launcher/GalNet.Launcher/Views/MainView.axaml.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-
-using Avalonia;
-using Avalonia.Controls;
-
-namespace GalNet.Launcher.Views;
-
-public partial class MainView : UserControl
-{
-    public MainView()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/Launcher/GalNet.Launcher/Views/MainWindow.axaml b/src/Launcher/GalNet.Launcher/Views/MainWindow.axaml
deleted file mode 100644
index f53490ac..00000000
--- a/src/Launcher/GalNet.Launcher/Views/MainWindow.axaml
+++ /dev/null
@@ -1,12 +0,0 @@
-<Window xmlns="https://github.com/avaloniaui"
-        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        xmlns:vm="using:GalNet.Launcher.ViewModels"
-        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-        xmlns:views="using:GalNet.Launcher.Views"
-        mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
-        x:Class="GalNet.Launcher.Views.MainWindow"
-        Icon="/Assets/avalonia-logo.ico"
-        Title="GalNet.Launcher">
-        <views:MainView />
-</Window>
diff --git a/src/Launcher/GalNet.Launcher/Views/MainWindow.axaml.cs b/src/Launcher/GalNet.Launcher/Views/MainWindow.axaml.cs
deleted file mode 100644
index b460b3e4..00000000
--- a/src/Launcher/GalNet.Launcher/Views/MainWindow.axaml.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using Avalonia.Controls;
-
-namespace GalNet.Launcher.Views;
-
-public partial class MainWindow : Window
-{
-    public MainWindow()
-    {
-        InitializeComponent();
-    }
-}
diff --git a/src/Launcher/GalNet.Launcher/packages.lock.json b/src/Launcher/GalNet.Launcher/packages.lock.json
deleted file mode 100644
index 95b7a3ca..00000000
--- a/src/Launcher/GalNet.Launcher/packages.lock.json
+++ /dev/null
@@ -1,130 +0,0 @@
-{
-  "version": 2,
-  "dependencies": {
-    "net10.0": {
-      "Avalonia": {
-        "type": "Direct",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
-        "dependencies": {
-          "Avalonia.BuildServices": "11.3.2",
-          "Avalonia.Remote.Protocol": "12.0.5",
-          "MicroCom.Runtime": "0.11.4"
-        }
-      },
-      "Avalonia.Fonts.Inter": {
-        "type": "Direct",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
-      "Avalonia.Themes.Fluent": {
-        "type": "Direct",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
-      "AvaloniaUI.DiagnosticsSupport": {
-        "type": "Direct",
-        "requested": "[2.2.3, )",
-        "resolved": "2.2.3",
-        "contentHash": "kQCInYusi2c9tjd9hV05Lln6Csbo07kiC672M3G7dsalDBe2j+pOk3We2nzdyy5ptQYy/9gQiC8ZaHhb6u/5Kw==",
-        "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
-          "Microsoft.IO.RecyclableMemoryStream": "3.0.1"
-        }
-      },
-      "CommunityToolkit.Mvvm": {
-        "type": "Direct",
-        "requested": "[8.4.1, )",
-        "resolved": "8.4.1",
-        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
-      },
-      "Antlr4.Runtime.Standard": {
-        "type": "Transitive",
-        "resolved": "4.13.1",
-        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
-      },
-      "Avalonia.BuildServices": {
-        "type": "Transitive",
-        "resolved": "11.3.2",
-        "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
-      },
-      "Avalonia.Remote.Protocol": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
-      },
-      "MicroCom.Runtime": {
-        "type": "Transitive",
-        "resolved": "0.11.4",
-        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
-      },
-      "Microsoft.Extensions.Logging.Abstractions": {
-        "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
-        "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
-        }
-      },
-      "Microsoft.IO.RecyclableMemoryStream": {
-        "type": "Transitive",
-        "resolved": "3.0.1",
-        "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g=="
-      },
-      "galnet.assets": {
-        "type": "Project",
-        "dependencies": {
-          "GalNet.Core": "[1.0.0, )"
-        }
-      },
-      "galnet.core": {
-        "type": "Project"
-      },
-      "galnet.presentation.abstractions": {
-        "type": "Project",
-        "dependencies": {
-          "GalNet.Core": "[1.0.0, )"
-        }
-      },
-      "galnet.runtime": {
-        "type": "Project",
-        "dependencies": {
-          "CoreCLR-NCalc": "[3.1.253, )",
-          "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
-          "Serilog": "[4.2.0, )"
-        }
-      },
-      "CoreCLR-NCalc": {
-        "type": "CentralTransitive",
-        "requested": "[3.1.253, )",
-        "resolved": "3.1.253",
-        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
-        "dependencies": {
-          "Antlr4.Runtime.Standard": "4.13.1"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection.Abstractions": {
-        "type": "CentralTransitive",
-        "requested": "[10.0.0, )",
-        "resolved": "8.0.0",
-        "contentHash": "cjWrLkJXK0rs4zofsK4bSdg+jhDLTaxrkXu4gS6Y7MAlCvRyNNgwY/lJi5RDlQOnSZweHqoyvgvbdvQsRIW+hg=="
-      },
-      "Serilog": {
-        "type": "CentralTransitive",
-        "requested": "[4.2.0, )",
-        "resolved": "4.2.0",
-        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/Presentation/GalNet.Avalonia.Controls/DialoguePresenter.cs b/src/Presentation/GalNet.Avalonia.Controls/DialoguePresenter.cs
index 9ebe3173..170af615 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/DialoguePresenter.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/DialoguePresenter.cs
@@ -6,6 +6,14 @@ namespace GalNet.Game.Controls;
 /// <summary>Templatable ADV dialogue surface with a named typewriter part.</summary>
 public class DialoguePresenter : TemplatedControl
 {
+    public static readonly StyledProperty<bool> CanReplayVoiceProperty = AvaloniaProperty.Register<DialoguePresenter, bool>(nameof(CanReplayVoice));
+    public static readonly StyledProperty<System.Windows.Input.ICommand?> ReplayVoiceCommandProperty = AvaloniaProperty.Register<DialoguePresenter, System.Windows.Input.ICommand?>(nameof(ReplayVoiceCommand));
+    public static readonly StyledProperty<string> ReplayIconProperty = AvaloniaProperty.Register<DialoguePresenter, string>(nameof(ReplayIcon), "🔊");
+    public static readonly StyledProperty<string> ReplayLabelProperty = AvaloniaProperty.Register<DialoguePresenter, string>(nameof(ReplayLabel), "Replay voice");
+    public bool CanReplayVoice { get => GetValue(CanReplayVoiceProperty); set => SetValue(CanReplayVoiceProperty, value); }
+    public System.Windows.Input.ICommand? ReplayVoiceCommand { get => GetValue(ReplayVoiceCommandProperty); set => SetValue(ReplayVoiceCommandProperty, value); }
+    public string ReplayIcon { get => GetValue(ReplayIconProperty); set => SetValue(ReplayIconProperty, value); }
+    public string ReplayLabel { get => GetValue(ReplayLabelProperty); set => SetValue(ReplayLabelProperty, value); }
     public static readonly StyledProperty<string?> SpeakerProperty =
         AvaloniaProperty.Register<DialoguePresenter, string?>(nameof(Speaker));
 
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/DefaultFieldEditors.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/DefaultFieldEditors.cs
index 72ea6bab..3cd69a51 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Forms/DefaultFieldEditors.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/DefaultFieldEditors.cs
@@ -56,7 +56,7 @@ public static FieldEditorLease CreateToggle(FieldEditorContext context)
     {
         Require(context, typeof(bool));
         if (context.EffectiveValue is { } json && ValueValidation.Validate(context.Field.Value, json) is not null) return CreateJson(context);
-        var control = new CheckBox { IsThreeState = context.Field.Value.AllowNull };
+        var control = new CheckBox { IsThreeState = context.Field.Value.AllowNull, VerticalAlignment = global::Avalonia.Layout.VerticalAlignment.Center, VerticalContentAlignment = global::Avalonia.Layout.VerticalAlignment.Center };
         return Bind(control, context,
             () => control.IsChecked = (bool?)context.ReadValue(),
             change =>
@@ -95,7 +95,7 @@ public static FieldEditorLease CreateSlider(FieldEditorContext context)
         var maximum = max.GetDouble();
         var type = Nullable.GetUnderlyingType(value.ValueType) ?? value.ValueType;
         var integer = type != typeof(float) && type != typeof(double);
-        if (!double.IsFinite(minimum) || !double.IsFinite(maximum) ||
+        if (!double.IsFinite(minimum) || !double.IsFinite(maximum) || minimum > maximum ||
             integer && (minimum < -9007199254740991d || maximum > 9007199254740991d))
             throw new NotSupportedException("Slider bounds cannot be represented exactly; use the numeric text editor.");
         var step = context.Field.Editor?.Step ?? (integer ? 1 : .01);
@@ -127,7 +127,7 @@ private static void Require(FieldEditorContext context, params Type[] types)
         if (!types.Contains(type)) throw new NotSupportedException($"Editor does not support '{type.Name}'.");
     }
 
-    private static FieldEditorLease Bind(Control control, FieldEditorContext context, Action update,
+    internal static FieldEditorLease Bind(Control control, FieldEditorContext context, Action update,
         Action<AvaloniaPropertyChangedEventArgs> edit, bool commitText = false)
     {
         var syncing = false;
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/DtoEditorContext.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/DtoEditorContext.cs
index 8bb819b9..7e814cbf 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Forms/DtoEditorContext.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/DtoEditorContext.cs
@@ -87,6 +87,8 @@ private sealed class ScopedBinding(DtoEditorContext owner, IFieldBinding source)
         public bool CanReset => source.CanReset;
         public object? Label => source.Label;
         public object? HostContext => source.HostContext;
+        public IReadOnlyList<string>? PropertySegments => source.PropertySegments;
+        public bool IsLabelLiteral => source.IsLabelLiteral;
         public IReadOnlyList<FieldEditorOption>? Options => source.Options;
         public bool SupportsPreview => !owner._disposed && source is IFieldPreviewBinding { SupportsPreview: true };
         public ValueIssue? Preview(FieldValue value) => !IsEnabled ? new("dto.obsolete", "DTO editor is unavailable.") : source is IFieldPreviewBinding preview ? preview.Preview(value) : new("dto.preview", "Preview is unavailable.");
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/EditorRegistry.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/EditorRegistry.cs
index f84bd7ef..6cd9a810 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Forms/EditorRegistry.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/EditorRegistry.cs
@@ -19,6 +19,7 @@ public sealed class EditorRegistry
     /// <summary>Host policy: optional non-string text inputs may be cleared without authoring null.</summary>
     public bool EmptyInputClearsOptionalFields { get; init; }
     public Func<ValueDescriptor, JsonElement, FieldCopy>? CopyValue { get; init; }
+    public Func<FieldDescriptor, ValueIssue, string>? FormatIssue { get; init; }
     private readonly Dictionary<string, FieldEditorFactory> _factories = new(StringComparer.Ordinal);
     private readonly Dictionary<FieldValueSemantic, FieldEditorFactory> _semantics = [];
     public void RegisterSemantic(FieldValueSemantic semantic, FieldEditorFactory factory)
@@ -103,19 +104,23 @@ public FieldEditorFactory Resolve(FieldDescriptor field, Type? dtoType = null)
         var type = Nullable.GetUnderlyingType(field.Value.ValueType) ?? field.Value.ValueType;
         if (_typeFactories.TryGetValue(type, out var custom)) return custom;
         var id = field.Editor?.EditorId;
+        if (id is null && field.Value.Structure is not null && StructuredFieldEditor.Supports(field.Value)) id = "structure";
         if (id is null)
-            id = field.Value.TryGetConstraint("enum", out _) || field.Value.TryGetConstraint("options", out _)
+            id = field.Value.TryGetConstraint("enum", out _)
                 ? ValueEditorIds.Choice : _defaults.TryGetValue(type, out var mapped) ? mapped
-                    : type.IsEnum ? ValueEditorIds.Choice : StructuredFieldEditor.Supports(type) ? "structure" : ValueEditorIds.Json;
+                    : type.IsEnum ? ValueEditorIds.Choice : StructuredFieldEditor.Supports(field.Value) ? "structure" : ValueEditorIds.Json;
         return _factories.TryGetValue(id, out var factory) ? factory
             : throw new NotSupportedException($"Editor '{id}' for field '{field.Id}' is not registered.");
     }
 
-    public static EditorRegistry CreateDefault(bool emptyInputClearsOptionalFields = false, Func<ValueDescriptor, JsonElement, FieldCopy>? copyValue = null)
+    public static EditorRegistry CreateDefault(bool emptyInputClearsOptionalFields = false, Func<ValueDescriptor, JsonElement, FieldCopy>? copyValue = null,
+        Func<FieldDescriptor, ValueIssue, string>? formatIssue = null)
     {
-        var registry = new EditorRegistry { EmptyInputClearsOptionalFields = emptyInputClearsOptionalFields, CopyValue = copyValue };
+        var registry = new EditorRegistry { EmptyInputClearsOptionalFields = emptyInputClearsOptionalFields, CopyValue = copyValue, FormatIssue = formatIssue };
         registry.Register(ValueEditorIds.Text, DefaultFieldEditors.CreateText);
         registry.Register(ValueEditorIds.Numeric, DefaultFieldEditors.CreateNumeric);
+        registry.Register(ValueEditorIds.NumericText, DefaultFieldEditors.CreateNumeric);
+        registry.Register(ValueEditorIds.NumericUpDown, NumericFieldEditors.CreateUpDown);
         registry.Register(ValueEditorIds.Slider, DefaultFieldEditors.CreateSlider);
         registry.Register(ValueEditorIds.Toggle, DefaultFieldEditors.CreateToggle);
         registry.Register(ValueEditorIds.Choice, DefaultFieldEditors.CreateChoice);
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldBinding.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldBinding.cs
index 27601ac9..40822e01 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldBinding.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldBinding.cs
@@ -29,8 +29,11 @@ public interface IFieldBinding
     bool IsVisible => true;
     bool CanReset => true;
     object? Label => null;
+    bool IsLabelLiteral => false;
     /// <summary>Optional host metadata, forwarded by scoped decorators without exposing their source binding.</summary>
     object? HostContext => null;
+    /// <summary>Wire segments relative to the root author field, when backed by a shared property view.</summary>
+    IReadOnlyList<string>? PropertySegments => null;
     IReadOnlyList<FieldEditorOption>? Options => null;
 }
 
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorContext.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorContext.cs
index 59d1786a..4f211510 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorContext.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorContext.cs
@@ -4,6 +4,7 @@
 using System.Text.Json;
 using Avalonia.Threading;
 using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Game.Controls.Forms;
 
@@ -36,6 +37,9 @@ public FieldEditorContext(FieldDescriptor field, IFieldBinding binding, EditorRe
 
     public FieldDescriptor Field { get; }
     public object? HostContext => _binding.HostContext;
+    internal bool AllowsChildReset => _binding.CanReset;
+    internal object? LabelOverride => _binding.IsLabelLiteral ? _binding.Label : null;
+    public IReadOnlyList<string>? PropertySegments => _binding.PropertySegments;
     public EditorRegistry? Registry { get; }
     internal int Depth { get; }
     public bool CanOmit => !Field.IsRequired || Field.DefaultValue is not null;
@@ -43,7 +47,7 @@ public FieldEditorContext(FieldDescriptor field, IFieldBinding binding, EditorRe
     public bool HasDefault => Field.DefaultValue is not null;
     public bool CanReset => _binding.CanReset && (HasDefault || CanOmit);
     public Task<bool> OmitAsync() => CommitAsync(default);
-    public Task<bool> SetNullAsync() => CommitAsync(new(JsonSerializer.SerializeToElement<object?>(null)));
+    public Task<bool> SetNullAsync() => CommitAsync(new(JsonCodec.SerializeToElement<object?>(null)));
     public Task<bool> ResetDefaultAsync() => Field.DefaultValue is { } value ? CommitAsync(new(value)) : Task.FromResult(false);
     public Task<bool> ResetAsync() => !CanReset ? Task.FromResult(false) : HasDefault ? ResetDefaultAsync() : OmitAsync();
     public void RevertDraft() { if (_disposed) return; _dirty = false; _pending = null; Issue = null; _draftVersion++; Refresh(); }
@@ -54,6 +58,7 @@ public FieldEditorContext(FieldDescriptor field, IFieldBinding binding, EditorRe
     public object Label => _binding.Label ?? Field.LabelKey ?? Field.Id;
     public IReadOnlyList<FieldEditorOption> Options { get; private set; } = [];
     public ValueIssue? Issue { get; private set; }
+    public string? IssueMessage => Issue is { } issue ? Registry?.FormatIssue?.Invoke(Field, issue) ?? issue.Message : null;
     public bool IsSubmitting => _submitting;
     public bool HasDraft => _dirty;
     public bool IsEnabled => !_disposed && !_submitting && _binding.IsEnabled;
@@ -68,7 +73,7 @@ public string Text
             _dirty = true;
             _draftVersion++;
             _ = ParseText(out var issue);
-            Issue = issue;
+            Issue = !_jsonText && ValueCodec.IsIncompleteEditorNumber(Field.Value, value) ? null : issue;
             Notify();
         }
     }
@@ -187,7 +192,7 @@ private FieldValue ParseText(out ValueIssue? issue)
         }
         try
         {
-            var json = _jsonText ? JsonSerializer.Deserialize<JsonElement>(Text) : ValueCodec.ParseEditorText(Field.Value, Text);
+            var json = _jsonText ? JsonCodec.Deserialize<JsonElement>(Text) : ValueCodec.ParseEditorText(Field.Value, Text);
             issue = ValueValidation.Validate(Field.Value, json);
             return new(json);
         }
@@ -229,10 +234,9 @@ private ReadOnlyCollection<FieldEditorOption> ReadOptions()
         }
         IEnumerable<JsonElement> values = [];
         if (Field.Value.TryGetConstraint("enum", out var choices)) values = choices.EnumerateArray();
-        else if (Field.Value.TryGetConstraint("options", out choices))
-            values = choices.EnumerateArray().Select(choice => ValueCodec.FromEditorText(Field.Value, choice.GetString()!));
         else if ((Nullable.GetUnderlyingType(Field.Value.ValueType) ?? Field.Value.ValueType) is { IsEnum: true } type)
-            values = Enum.GetValues(type).Cast<object>().Select(value => ValueCodec.Serialize(Field.Value, value));
+            values = Enum.GetValuesAsUnderlyingType(type).Cast<object>()
+                .Select(value => ValueCodec.Serialize(Field.Value, Enum.ToObject(type, value)));
         return Array.AsReadOnly(values.Select((value, index) => new FieldEditorOption(index.ToString(CultureInfo.InvariantCulture),
             value.ValueKind == JsonValueKind.String ? value.GetString()! : value.GetRawText(), value)).ToArray());
     }
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorLease.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorLease.cs
index f7ed283b..a8c49fd5 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorLease.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorLease.cs
@@ -7,5 +7,6 @@ public sealed class FieldEditorLease(Control control, Action? release = null) :
 {
     private Action? _release = release;
     public Control Control { get; } = control ?? throw new ArgumentNullException(nameof(control));
+    public GalNet.Core.Parameters.ValueIssue? Diagnostic { get; init; }
     public void Dispose() => Interlocked.Exchange(ref _release, null)?.Invoke();
 }
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorRow.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorRow.cs
index 2d164359..c3dbb16a 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorRow.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/FieldEditorRow.cs
@@ -23,7 +23,7 @@ public sealed class FieldEditorRow : Grid
     public IFieldBinding? Binding { get => GetValue(BindingProperty); set => SetValue(BindingProperty, value); }
     public bool ShowLabel { get => GetValue(ShowLabelProperty); set => SetValue(ShowLabelProperty, value); }
     private readonly ContentControl _label = new() { Name = "FieldLabel", VerticalAlignment = VerticalAlignment.Top, Margin = new(0, 6, 0, 0) };
-    private readonly ContentControl _editor = new() { HorizontalContentAlignment = HorizontalAlignment.Stretch, VerticalAlignment = VerticalAlignment.Top };
+    private readonly ContentControl _editor = new() { Name = "FieldEditor", HorizontalContentAlignment = HorizontalAlignment.Stretch, VerticalAlignment = VerticalAlignment.Top };
     private readonly FieldEditorActions _actions = new() { Simplified = true, VerticalAlignment = VerticalAlignment.Top };
     private readonly TextBlock _issue = new() { TextWrapping = global::Avalonia.Media.TextWrapping.Wrap };
     private FieldEditorContext? _owned, _active;
@@ -43,7 +43,7 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
         base.OnPropertyChanged(change);
         if (_label is null) return;
         if (change.Property == LabelProperty) _label.Content = Label;
-        if (change.Property == EditorProperty) _editor.Content = Editor;
+        if (change.Property == EditorProperty) { _editor.Content = Editor; Layout(_narrow); }
         if (change.Property == ContextProperty || change.Property == FieldProperty || change.Property == BindingProperty) { if (_mounted) Connect(); }
         if (change.Property == ShowLabelProperty) Layout(_narrow);
     }
@@ -62,20 +62,21 @@ private void Disconnect()
     private void Changed(object? sender, PropertyChangedEventArgs args) => Refresh();
     private void Refresh()
     {
-        _issue.Text = _active?.Issue?.Message; _issue.IsVisible = !string.IsNullOrEmpty(_issue.Text);
+        _issue.Text = _active?.IssueMessage; _issue.IsVisible = !string.IsNullOrEmpty(_issue.Text);
         IsVisible = _active?.IsVisible ?? true;
         _editor.IsEnabled = _active?.IsEnabled ?? true;
     }
     private void Layout(bool narrow)
     {
         _narrow = narrow;
-        _label.IsVisible = ShowLabel;
-        ColumnDefinitions = new(narrow || !ShowLabel ? "*,Auto" : "130,*,Auto");
-        RowDefinitions = new(narrow && ShowLabel ? "Auto,Auto,Auto" : "Auto,Auto");
+        var showLabel = ShowLabel && Editor is not StructuredFieldEditor;
+        _label.IsVisible = showLabel;
+        ColumnDefinitions = new(narrow || !showLabel ? "*,Auto" : "130,*,Auto");
+        RowDefinitions = new(narrow && showLabel ? "Auto,Auto,Auto" : "Auto,Auto");
         SetRow(_label, 0); SetColumn(_label, 0);
-        SetRow(_editor, narrow && ShowLabel ? 1 : 0); SetColumn(_editor, narrow || !ShowLabel ? 0 : 1);
-        SetRow(_actions, 0); SetColumn(_actions, narrow || !ShowLabel ? 1 : 2);
-        SetRow(_issue, narrow && ShowLabel ? 2 : 1); SetColumn(_issue, narrow || !ShowLabel ? 0 : 1);
+        SetRow(_editor, narrow && showLabel ? 1 : 0); SetColumn(_editor, narrow || !showLabel ? 0 : 1);
+        SetRow(_actions, 0); SetColumn(_actions, narrow || !showLabel ? 1 : 2);
+        SetRow(_issue, narrow && showLabel ? 2 : 1); SetColumn(_issue, narrow || !showLabel ? 0 : 1);
         _label.Margin = new(0, narrow ? 0 : 6, 0, 0);
     }
 }
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/NumericFieldEditors.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/NumericFieldEditors.cs
new file mode 100644
index 00000000..c9aaec2f
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/NumericFieldEditors.cs
@@ -0,0 +1,149 @@
+using System.Globalization;
+using System.Text.Json;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.VisualTree;
+using GalNet.Core.Parameters;
+
+namespace GalNet.Game.Controls.Forms;
+
+/// <summary>Optional numeric controls. Author text remains the source of truth, independent of UI numeric values.</summary>
+public static class NumericFieldEditors
+{
+    public static FieldEditorLease CreateUpDown(FieldEditorContext context)
+    {
+        var type = Nullable.GetUnderlyingType(context.Field.Value.ValueType) ?? context.Field.Value.ValueType;
+        if (!DefaultFieldEditors.NumericTypes.Contains(type)) throw new NotSupportedException("A numeric field is required.");
+        // Never funnel high precision values through a UI decimal/double conversion.
+        if (type == typeof(long) || type == typeof(ulong) || type == typeof(decimal) || context.Field.Value.IsStringEncoded ||
+            context.EffectiveValue is { ValueKind: JsonValueKind.String })
+            return DefaultFieldEditors.CreateNumeric(context);
+        if (context.EffectiveValue is { ValueKind: JsonValueKind.Number } current && !current.TryGetDecimal(out _))
+        {
+            var exact = DefaultFieldEditors.CreateNumeric(context);
+            return new(exact.Control, exact.Dispose) { Diagnostic = new("editor.numericFallback", "This value exceeds the step control's decimal range.") };
+        }
+        var fractional = type == typeof(float) || type == typeof(double);
+        var step = context.Field.Editor?.Step ?? (fractional ? .1 : 1);
+        if (!double.IsFinite(step) || step <= 0 || !fractional && step != Math.Truncate(step) || step > (double)decimal.MaxValue)
+            return ExactFallback(context, "The step must be positive, finite and compatible with the numeric type.");
+        if (!decimal.TryParse(step.ToString("R", CultureInfo.InvariantCulture), NumberStyles.Float, CultureInfo.InvariantCulture, out var increment) || increment <= 0)
+            return ExactFallback(context, "The step cannot be represented by the step control.");
+        var control = new DraftNumericUpDown { Increment = increment, NumberFormat = CultureInfo.InvariantCulture.NumberFormat };
+        void Spin(bool increase)
+        {
+            if (!context.IsEnabled || context.IsSubmitting || context.DraftState?.CanCommit == false) return;
+            try
+            {
+                var json = context.Text.Length == 0 ? context.EffectiveValue : ValueCodec.ParseEditorText(context.Field.Value, context.Text);
+                if (json is { } value && ValueValidation.Validate(context.Field.Value, value) is { } issue) { context.ReportIssue(issue); return; }
+                var current = json is { ValueKind: JsonValueKind.Number } number ? number.GetDecimal() : 0;
+                var next = checked(current + (increase ? control.Increment : -control.Increment));
+                if (context.Field.Value.TryGetConstraint("minimum", out var min) && min.TryGetDecimal(out var minimum)) next = Math.Max(minimum, next);
+                if (context.Field.Value.TryGetConstraint("maximum", out var max) && max.TryGetDecimal(out var maximum)) next = Math.Min(maximum, next);
+                context.Text = next.ToString(CultureInfo.InvariantCulture);
+                _ = context.CommitTextAsync();
+            }
+            catch (Exception error) when (error is JsonException or ArgumentException or OverflowException or FormatException)
+            { context.ReportIssue(new("value.spin", "This value cannot be adjusted with the step buttons. Enter an exact number instead.")); }
+        }
+        control.StepRequested = Spin;
+        control.TextEdited = text => context.Text = text;
+        var lease = DefaultFieldEditors.Bind(control, context, () => control.SetDraftText(context.Text), _ => { }, commitText: true);
+        return new(control, () => { control.ReleaseEditor(); lease.Dispose(); });
+    }
+
+    private static FieldEditorLease ExactFallback(FieldEditorContext context, string reason)
+    {
+        var exact = DefaultFieldEditors.CreateNumeric(context);
+        return new(exact.Control, exact.Dispose) { Diagnostic = new("editor.numericFallback", reason) };
+    }
+
+    /// <summary>Editor path with exact typed input beside the bounded coarse adjustment.</summary>
+    public static FieldEditorLease CreateSliderWithInput(FieldEditorContext context)
+    {
+        if (context.EffectiveValue is { } value && ValueValidation.Validate(context.Field.Value, value) is not null)
+            return CreateUpDown(context);
+        FieldEditorLease sliderLease;
+        try { sliderLease = DefaultFieldEditors.CreateSlider(context); }
+        catch (Exception error) when (error is NotSupportedException or ArgumentException or OverflowException or InvalidOperationException)
+        {
+            var input = DefaultFieldEditors.CreateNumeric(context);
+            return new(input.Control, input.Dispose) { Diagnostic = new("editor.numericFallback", error.Message) };
+        }
+        var slider = (Slider)sliderLease.Control;
+        var number = CreateUpDown(context);
+        var panel = new Grid { ColumnDefinitions = new("*,140"), ColumnSpacing = 8 };
+        panel.Children.Add(slider); Grid.SetColumn(number.Control, 1); panel.Children.Add(number.Control);
+        return new(panel, () => { sliderLease.Dispose(); number.Dispose(); });
+    }
+
+    // Native NumericUpDown normally reparses/reformats on every edit and on blur. Keep the
+    // native spinner/template/keyboard behavior, but let the field contract own text and commits.
+    private sealed class DraftNumericUpDown : NumericUpDown
+    {
+        private TextBox? _input;
+        private ButtonSpinner? _spinner;
+        private string _draftText = "";
+        private bool _syncing;
+        protected override Type StyleKeyOverride => typeof(NumericUpDown);
+        public Action<bool>? StepRequested { get; set; }
+        public Action<string>? TextEdited { get; set; }
+        public DraftNumericUpDown() => AddHandler(KeyDownEvent, StepKey, RoutingStrategies.Tunnel);
+        public void SetDraftText(string text)
+        {
+            _syncing = true;
+            try { _draftText = text; Text = text; if (_input is not null && _input.Text != text) _input.Text = text; }
+            finally { _syncing = false; }
+        }
+        protected override void OnTextChanged(string? oldValue, string? newValue) { }
+        protected override void OnValueChanged(decimal? oldValue, decimal? newValue) { }
+        protected override void OnLostFocus(FocusChangedEventArgs e) { }
+        protected override void OnKeyDown(KeyEventArgs e) { }
+        private void StepKey(object? sender, KeyEventArgs e)
+        {
+            if (!IsEnabled || IsReadOnly || !AllowSpin || e.Key is not (Key.Up or Key.Down) || e.KeyModifiers != KeyModifiers.None) return;
+            StepRequested?.Invoke(e.Key == Key.Up); e.Handled = true;
+        }
+        protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
+        {
+            if (!IsEnabled || IsReadOnly || !AllowSpin || _input?.IsFocused != true || e.Delta.Y == 0) return;
+            StepRequested?.Invoke(e.Delta.Y > 0); e.Handled = true;
+        }
+        protected override void OnSpin(SpinEventArgs e)
+        {
+            if (IsEnabled && !IsReadOnly && AllowSpin) StepRequested?.Invoke(e.Direction == SpinDirection.Increase);
+            e.Handled = true;
+        }
+        protected override void OnGotFocus(FocusChangedEventArgs e) { if (ReferenceEquals(e.Source, this)) _input?.Focus(); }
+        protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+        {
+            // Deliberately own the template parts instead of attaching NumericUpDown's eager
+            // Value parser: its initial/null conversions must not create author drafts.
+            DisconnectParts();
+            _input = e.NameScope.Find<TextBox>("PART_TextBox");
+            _spinner = e.NameScope.Find<ButtonSpinner>("PART_Spinner");
+            SetDraftText(_draftText);
+            if (_input is not null) _input.PropertyChanged += Edited;
+            if (_spinner is not null)
+            {
+                _spinner.ValidSpinDirection = ValidSpinDirections.Increase | ValidSpinDirections.Decrease;
+                _spinner.Spin += Spin;
+                _spinner.ApplyTemplate();
+                foreach (var button in _spinner.GetVisualDescendants().OfType<RepeatButton>()) { button.Delay = 250; button.Interval = 30; }
+            }
+        }
+        private void Edited(object? sender, Avalonia.AvaloniaPropertyChangedEventArgs e)
+        { if (!_syncing && e.Property == TextBox.TextProperty && _input is not null) TextEdited?.Invoke(_input.Text ?? ""); }
+        private void Spin(object? sender, SpinEventArgs e) => OnSpin(e);
+        private void DisconnectParts()
+        {
+            if (_input is not null) _input.PropertyChanged -= Edited;
+            if (_spinner is not null) _spinner.Spin -= Spin;
+            _input = null; _spinner = null;
+        }
+        public void ReleaseEditor() { DisconnectParts(); StepRequested = null; TextEdited = null; RemoveHandler(KeyDownEvent, StepKey); }
+    }
+}
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/PropertyFieldBinding.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/PropertyFieldBinding.cs
new file mode 100644
index 00000000..7ac8e574
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/PropertyFieldBinding.cs
@@ -0,0 +1,34 @@
+using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Game.Controls.Forms;
+
+/// <summary>One child property, backed by the parent's current JSON and author transaction.</summary>
+public sealed class PropertyFieldBinding(FieldEditorContext parent, FieldDescriptor memberField, string segment,
+    Func<bool> available, Func<FieldValue, CancellationToken, Task<ValueIssue?>> submit, ValueStructureResolver? resolver = null) : IFieldBinding
+{
+    public FieldDraftState? Draft => parent.DraftState?.Child?.Invoke(memberField, segment);
+    public object? HostContext => parent.HostContext;
+    public IReadOnlyList<string>? PropertySegments => [.. parent.PropertySegments ?? [], segment];
+    public bool CanReset => parent.AllowsChildReset;
+    public bool IsEnabled => available() && parent.IsEnabled;
+    public bool IsVisible => parent.IsVisible;
+    public FieldValue Read()
+    {
+        using var document = new ValueDocument(parent.Field, parent.EffectiveValue, resolver);
+        var property = document.FindProperty([segment]);
+        return property is not null ? new(property.Value) : document.Root.Issue is not null
+            ? new(JsonCodec.SerializeToElement("?")) : default;
+    }
+    public event EventHandler? Changed;
+    public void Refresh() => Changed?.Invoke(this, EventArgs.Empty);
+    public async Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        if (!IsEnabled) return new("structure.obsolete", "The property binding is no longer available.");
+        using var document = new ValueDocument(parent.Field, parent.Value.Json, resolver);
+        var patch = document.Patch([segment], value.Json, cancellationToken);
+        if (patch.Issue is not null) return patch.Issue;
+        return await submit(new(patch.Value), cancellationToken);
+    }
+}
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/SchemaForm.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/SchemaForm.cs
index 4f2e4fe4..777e3c4f 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Forms/SchemaForm.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/SchemaForm.cs
@@ -10,6 +10,7 @@ namespace GalNet.Game.Controls.Forms;
 public sealed record FieldEditorItem(FieldEditorContext Context, Control Control)
 {
     public bool IsJsonFallback => Equals(Control.Tag, "schema.json");
+    public bool ShowSeparateLabel { get; init; } = true;
 }
 
 /// <summary>Owns editors while mounted. Schema, registry, binding and visual theme are supplied by the host.</summary>
@@ -91,10 +92,12 @@ public void RefreshEditors()
                         lease = DefaultFieldEditors.CreateJson(context);
                     }
                     _owned[^1] = (context, lease);
+                    if (lease.Diagnostic is { } diagnostic) errors.Add(diagnostic with { Path = field.Id, Message = Registry!.FormatIssue?.Invoke(field, diagnostic) ?? diagnostic.Message });
                     if (!controls.Add(lease.Control) || lease.Control.Parent is not null || lease.Control.GetVisualParent() is not null)
                         throw new InvalidOperationException("Editor factories must return fresh, unparented controls.");
                 }
-                SetAndRaise(EditorsProperty, ref _editors, Array.AsReadOnly(_owned.Select(editor => new FieldEditorItem(editor.Context, editor.Lease!.Control)).ToArray()));
+                SetAndRaise(EditorsProperty, ref _editors, Array.AsReadOnly(_owned.Select(editor => new FieldEditorItem(editor.Context, editor.Lease!.Control)
+                { ShowSeparateLabel = ShowLabels && editor.Lease!.Control is not StructuredFieldEditor }).ToArray()));
             }
         }
         catch (Exception exception)
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Forms/StructuredFieldEditor.cs b/src/Presentation/GalNet.Avalonia.Controls/Forms/StructuredFieldEditor.cs
index b0fb0992..9e49e54f 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Forms/StructuredFieldEditor.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Forms/StructuredFieldEditor.cs
@@ -1,10 +1,9 @@
 using System.ComponentModel;
-using System.Reflection;
 using System.Text.Json;
-using System.Text.Json.Serialization;
 using Avalonia;
 using Avalonia.Controls;
 using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Game.Controls.Forms;
 
@@ -33,6 +32,9 @@ public sealed class StructuredFieldEditor : Expander, IDisposable
     public FieldEditorContext Context { get; }
     private readonly Type _type;
     private readonly Type? _element;
+    private readonly ResolvedValueStructure _shape;
+    private readonly ValueStructureResolver _resolver = new();
+    private bool IsMap => _shape.Kind == ValueStructureKind.Map;
     private readonly List<ChildBinding> _bindings = [];
     private readonly List<(Button Button, string Kind)> _buttons = [];
     private CancellationTokenSource _version = new();
@@ -44,24 +46,41 @@ public sealed class StructuredFieldEditor : Expander, IDisposable
     private Button? _jsonButton;
     private bool _disposed;
     private int _generation;
-    private static Type? ElementType(Type type) => type.IsArray && type.GetArrayRank() == 1 ? type.GetElementType()
-        : type.IsGenericType && type.GetGenericTypeDefinition() is var definition && (definition == typeof(List<>) || definition == typeof(IList<>) || definition == typeof(IReadOnlyList<>) || definition == typeof(IEnumerable<>)) ? type.GetGenericArguments()[0] : null;
-    internal static bool Supports(Type type) => ElementType(type) is not null || typeof(IFieldDto).IsAssignableFrom(type) && type.GetProperty("Schema", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy) is not null;
+    internal static bool Supports(Type type) => Supports(new ValueDescriptor(type));
+    internal static bool Supports(ValueDescriptor descriptor)
+    {
+        using var resolver = new ValueStructureResolver();
+        return resolver.Resolve(new("structure", descriptor)).Kind is ValueStructureKind.Object or ValueStructureKind.Sequence or ValueStructureKind.Map;
+    }
     internal static FieldEditorLease Create(FieldEditorContext context)
     {
-        var type = Nullable.GetUnderlyingType(context.Field.Value.ValueType) ?? context.Field.Value.ValueType;
-        if (context.Field.Value.IsStringEncoded || type.GetCustomAttribute<JsonConverterAttribute>() is not null || context.Field.Value.JsonOptions.Converters.Any(converter => converter.CanConvert(type)))
-            return DefaultFieldEditors.CreateJson(context);
+        if (!Supports(context.Field.Value)) return DefaultFieldEditors.CreateJson(context);
         var editor = new StructuredFieldEditor(context); return new(editor, editor.Dispose);
     }
     private StructuredFieldEditor(FieldEditorContext context)
     {
-        Context = context; _type = Nullable.GetUnderlyingType(context.Field.Value.ValueType) ?? context.Field.Value.ValueType; _element = ElementType(_type);
+        Context = context; DataContext = context;
+        _type = Nullable.GetUnderlyingType(context.Field.Value.ValueType) ?? context.Field.Value.ValueType;
+        using var document = new ValueDocument(context.Field, null, _resolver);
+        _shape = document.Root.Structure;
+        _element = _shape.Kind == ValueStructureKind.Sequence ? _shape.Element!.Value.ValueType : null;
         _snapshot = Current; Header = _type.Name; IsEnabled = context.IsEnabled; IsVisible = context.IsVisible;
         Classes.Add("structured-field");
         context.PropertyChanged += Changed;
     }
     private JsonElement? Current => Context.Value.Json ?? Context.Field.DefaultValue;
+    public static readonly StyledProperty<string?> TitleTextProperty = AvaloniaProperty.Register<StructuredFieldEditor, string?>(nameof(TitleText));
+    public string? TitleText { get => GetValue(TitleTextProperty); set => SetValue(TitleTextProperty, value); }
+    public static readonly StyledProperty<string> KeyTextProperty = AvaloniaProperty.Register<StructuredFieldEditor, string>(nameof(KeyText), "Key");
+    public string KeyText { get => GetValue(KeyTextProperty); set => SetValue(KeyTextProperty, value); }
+    public static readonly StyledProperty<string> DuplicateKeyTextProperty = AvaloniaProperty.Register<StructuredFieldEditor, string>(nameof(DuplicateKeyText), "A key with this name already exists.");
+    public string DuplicateKeyText { get => GetValue(DuplicateKeyTextProperty); set => SetValue(DuplicateKeyTextProperty, value); }
+    public static readonly StyledProperty<double> ChildIndentProperty = AvaloniaProperty.Register<StructuredFieldEditor, double>(nameof(ChildIndent), 12);
+    public double ChildIndent { get => GetValue(ChildIndentProperty); set => SetValue(ChildIndentProperty, value); }
+    public static readonly StyledProperty<double> ItemSpacingProperty = AvaloniaProperty.Register<StructuredFieldEditor, double>(nameof(ItemSpacing), 6);
+    public double ItemSpacing { get => GetValue(ItemSpacingProperty); set => SetValue(ItemSpacingProperty, value); }
+    private JsonElement? DecodedCurrent { get { using var doc = new ValueDocument(Context.Field, Current, _resolver); return doc.Root.Content; } }
+
     protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
     {
         base.OnPropertyChanged(change);
@@ -69,10 +88,10 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
         if (change.Property == IsExpandedProperty) { if (IsExpanded) Build(); else Release(); }
         else if (change.Property == ExpandByDefaultProperty && ExpandByDefault)
         {
-            try { if (_element is null && Members(Context.Field.Value, _type).Count <= 6) IsExpanded = true; }
-            catch (Exception error) when (error is ArgumentException or InvalidOperationException or NotSupportedException or TargetInvocationException) { }
+            try { if (_shape.Kind == ValueStructureKind.Object && _shape.Members.Count <= 6) IsExpanded = true; }
+            catch (Exception error) when (error is ArgumentException or InvalidOperationException or NotSupportedException) { }
         }
-        else if (change.Property == ObjectTextProperty || change.Property == ListTextProperty || change.Property == RepairTextProperty)
+        else if (change.Property == ObjectTextProperty || change.Property == ListTextProperty || change.Property == RepairTextProperty || change.Property == TitleTextProperty)
         {
             if (IsExpanded) SetHeader(_jsonMode || _fallback is not null ? "JSON" : HeaderText());
             else Header = HeaderText();
@@ -91,22 +110,25 @@ private void Changed(object? sender, PropertyChangedEventArgs args)
         _snapshot = current?.Clone();
         if (!IsExpanded) return;
         if (_fallback is not null || Context.IsSubmitting && !Equal(_submitted, current)
-            || _element is not null && !(_elementCommit && Equal(_submitted, current))
-            || _element is null && current is { ValueKind: not (JsonValueKind.Object or JsonValueKind.Null) }) Build();
+            || (_element is not null || IsMap) && !(_elementCommit && Equal(_submitted, current))
+            || _element is null && DecodedCurrent is { ValueKind: not (JsonValueKind.Object or JsonValueKind.Null) }) Build();
         else foreach (var binding in _bindings.ToArray()) binding.Refresh();
     }
     private void Build()
     {
         Release(); if (_disposed || !IsExpanded) return;
-        var value = Current;
+        var value = DecodedCurrent;
         var kind = _element is null ? JsonValueKind.Object : JsonValueKind.Array;
-        if (_jsonMode || value is { ValueKind: not JsonValueKind.Null } provided && provided.ValueKind != kind || _element is not null && value is { ValueKind: JsonValueKind.Array } array && array.GetArrayLength() > 200)
+        if (_jsonMode || value is { ValueKind: not JsonValueKind.Null } provided && provided.ValueKind != kind || value is { ValueKind: JsonValueKind.Array } array && array.GetArrayLength() > 200 || IsMap && value is { ValueKind: JsonValueKind.Object } map && map.EnumerateObject().Take(201).Count() > 200)
         { BuildJson(); return; }
         try
         {
-            if (_element is null) BuildObject(); else BuildArray();
+            using var snapshot = new ValueDocument(Context.Field, Current, _resolver);
+            if (snapshot.Root.Issue is not null) { BuildJson(); return; }
+            if (IsMap) BuildMap(); else if (_element is null) BuildObject(); else BuildArray();
+            if (Content is Control child) child.Margin = new(ChildIndent, ItemSpacing, 0, 0);
         }
-        catch (Exception error) when (error is ArgumentException or InvalidOperationException or NotSupportedException or TargetInvocationException)
+        catch (Exception error) when (error is ArgumentException or InvalidOperationException or NotSupportedException)
         { Release(); BuildJson(); ToolTip.SetTip(this, error.InnerException?.Message ?? error.Message); }
     }
     private void BuildJson()
@@ -125,22 +147,12 @@ private void SetHeader(string text)
         };
         panel.Children.Add(button); Header = panel;
     }
-    private string HeaderText() => _element is null ? ObjectText ?? _type.Name : (ListText ?? _type.Name) + " · " + ArrayValues().Count;
+    private string HeaderText() => (Context.LabelOverride?.ToString() ?? TitleText ?? Context.Label.ToString() ?? Context.Field.Id) + (_element is not null ? " · " + ArrayValues().Count : IsMap ? " · " + MapValues().Count : "");
     private sealed record Member(FieldDescriptor Field, string Wire);
     private static IReadOnlyList<Member> Members(ValueDescriptor descriptor, Type type)
     {
-        var schema = (IReadOnlyList<FieldDescriptor>)type.GetProperty("Schema", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)!.GetValue(null)!;
-        var properties = descriptor.JsonOptions.GetTypeInfo(type).Properties;
-        return schema.Select(field =>
-        {
-            var member = type.GetProperties().Single(property => property.GetCustomAttribute<FieldAttribute>() is not null &&
-                (property.GetCustomAttribute<JsonPropertyNameAttribute>()?.Name ?? JsonNamingPolicy.CamelCase.ConvertName(property.Name)) == field.Id);
-            var wire = properties.Single(property => property.AttributeProvider is MemberInfo info && info.Name == member.Name).Name;
-            var options = new JsonSerializerOptions(descriptor.JsonOptions);
-            foreach (var converter in field.Value.JsonOptions.Converters.Reverse()) options.Converters.Insert(0, converter);
-            var child = new FieldDescriptor(field.Id, new(field.Value.ValueType, field.Value.AllowNull, field.Value.Constraints, options), field.IsRequired, field.DefaultValue, field.Editor, field.LabelKey, field.DescriptionKey, field.Semantic);
-            return new Member(child, wire);
-        }).ToArray();
+        using var document = new ValueDocument(new("structure", descriptor), null);
+        return document.Root.Structure.Members.Select(member => new Member(member.Field, member.WireName)).ToArray();
     }
     private void BuildObject()
     {
@@ -149,13 +161,13 @@ private void BuildObject()
         var map = members.ToDictionary(member => member.Field.Id, member => member.Wire, StringComparer.Ordinal);
         var bindings = fields.ToDictionary(field => field.Id, field => Bind(field, map[field.Id], null), StringComparer.Ordinal);
         var generation = _generation;
-        var item = new DtoEditorItem(Context.Field.Id, _type, fields, field => bindings[field.Id], (patch, token) => CommitObject(patch.ToDictionary(pair => map[pair.Key], pair => pair.Value), generation, token));
+        var item = new DtoEditorItem(Context.Field.Id, Context.Field.Value.Structure?.SchemaType ?? _type, fields, field => bindings[field.Id], (patch, token) => CommitObject(patch.ToDictionary(pair => map[pair.Key], pair => pair.Value), generation, token));
         Content = new DtoEditorHost { Depth = Context.Depth + 1, Item = item, Registry = Context.Registry };
     }
     private void BuildArray()
     {
         var values = ArrayValues(); SetHeader(HeaderText());
-        var panel = new StackPanel { Spacing = 6 };
+        var panel = new StackPanel { Spacing = ItemSpacing };
         var generation = _generation;
         for (var index = 0; index < values.Count; index++)
         {
@@ -170,19 +182,74 @@ private void BuildArray()
             {
                 if (!Available(generation)) return;
                 var items = ArrayValues();
-                using var copy = Context.Registry?.CopyValue?.Invoke(new(_element!, jsonOptions: Context.Field.Value.JsonOptions), items[position]) ?? new FieldCopy(items[position]);
-                items.Insert(position + 1, copy.Value);
-                await Submit(JsonSerializer.SerializeToElement(items), generation, CancellationToken.None);
+                var element = _shape.Element!;
+                var wrapped = element.Semantic != FieldValueSemantic.None;
+                var descriptor = wrapped ? new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Object([element])) : element.Value;
+                var source = wrapped ? JsonCodec.SerializeToElement(new Dictionary<string, JsonElement> { [element.Id] = items[position] }) : items[position];
+                using var copy = Context.Registry?.CopyValue?.Invoke(descriptor, source) ?? new FieldCopy(source);
+                items.Insert(position + 1, wrapped ? copy.Value.GetProperty(element.Id) : copy.Value);
+                await Submit(JsonCodec.SerializeToElement(items.ToArray()), generation, CancellationToken.None);
             }).IsEnabled = values.Count < 200;
             row.Children.Add(buttons);
-            var descriptor = new FieldDescriptor("element", new(_element!, jsonOptions: Context.Field.Value.JsonOptions), isRequired: true);
+            var descriptor = new FieldDescriptor(_shape.Element!.Id, _shape.Element.Value, isRequired: true, editor: _shape.Element.Editor, labelKey: _shape.Element.LabelKey, semantic: _shape.Element.Semantic, resourceTypeId: _shape.Element.ResourceTypeId);
             var binding = Bind(descriptor, null, position);
             row.Children.Add(new SchemaForm { ShowLabels = false, Depth = Context.Depth + 1, Schema = [descriptor], Registry = Context.Registry, Binding = _ => binding });
             panel.Children.Add(row);
         }
-        AddButton(panel, "add", () => ChangeArray(generation, list => list.Add(InitialValue(new(_element!, jsonOptions: Context.Field.Value.JsonOptions))))).IsEnabled = values.Count < 200;
+        AddButton(panel, "add", () => ChangeArray(generation, list => list.Add(InitialValue(_shape.Element!.Value)))).IsEnabled = values.Count < 200;
         Content = panel;
     }
+    private Dictionary<string, JsonElement> MapValues() => DecodedCurrent is { ValueKind: JsonValueKind.Object } map
+        ? map.EnumerateObject().ToDictionary(property => property.Name, property => property.Value.Clone(), StringComparer.Ordinal) : new(StringComparer.Ordinal);
+    private void BuildMap()
+    {
+        var values = MapValues(); SetHeader(HeaderText());
+        var panel = new StackPanel { Spacing = ItemSpacing }; var generation = _generation;
+        foreach (var pair in values)
+        {
+            var original = pair.Key;
+            var row = new StackPanel { Spacing = ItemSpacing };
+            var keys = new StackPanel { Orientation = global::Avalonia.Layout.Orientation.Horizontal, Spacing = ItemSpacing };
+            var key = new TextBox { Name = "MapKey", Text = original, Watermark = KeyText, MinWidth = 120 };
+            async Task Rename()
+            {
+                if (!Available(generation) || key.Text == original) return;
+                var candidate = MapValues(); var renamed = key.Text ?? "";
+                if (candidate.ContainsKey(renamed)) { Context.ReportIssue(new("structure.keyDuplicate", DuplicateKeyText)); return; }
+                if (!candidate.ContainsKey(original)) return;
+                var ordered = candidate.Select(item => new KeyValuePair<string, JsonElement>(item.Key == original ? renamed : item.Key, item.Value)).ToDictionary();
+                await Submit(JsonCodec.SerializeToElement(ordered), generation, CancellationToken.None);
+            }
+            key.KeyDown += async (_, args) =>
+            {
+                if (args.Key == global::Avalonia.Input.Key.Enter) { args.Handled = true; await Rename(); }
+                else if (args.Key == global::Avalonia.Input.Key.Escape) { key.Text = original; args.Handled = true; }
+            };
+            key.LostFocus += async (_, _) => await Rename();
+            keys.Children.Add(key);
+            AddButton(keys, "remove", async () =>
+            {
+                if (!Available(generation)) return;
+                var candidate = MapValues(); candidate.Remove(original);
+                await Submit(JsonCodec.SerializeToElement(candidate), generation, CancellationToken.None);
+            });
+            row.Children.Add(keys);
+            var descriptor = _shape.Element!;
+            row.Children.Add(new SchemaForm { Depth = Context.Depth + 1, ShowLabels = false, Schema = [descriptor], Registry = Context.Registry, Binding = _ => Bind(descriptor, original, null) });
+            panel.Children.Add(row);
+        }
+        var additions = new StackPanel { Orientation = global::Avalonia.Layout.Orientation.Horizontal, Spacing = ItemSpacing };
+        var input = new TextBox { Name = "MapNewKey", Watermark = KeyText, MinWidth = 120 }; additions.Children.Add(input);
+        AddButton(additions, "add", async () =>
+        {
+            if (!Available(generation)) return;
+            var candidate = MapValues(); var key = input.Text ?? "";
+            if (candidate.ContainsKey(key)) { Context.ReportIssue(new("structure.keyDuplicate", DuplicateKeyText)); return; }
+            candidate.Add(key, InitialValue(_shape.Element!.Value));
+            await Submit(JsonCodec.SerializeToElement(candidate), generation, CancellationToken.None);
+        }).IsEnabled = values.Count < 200;
+        panel.Children.Add(additions); Content = panel;
+    }
     private Button AddButton(Panel panel, string kind, Func<Task> action)
     {
         var button = new Button { Name = kind }; _buttons.Add((button, kind));
@@ -191,30 +258,40 @@ private Button AddButton(Panel panel, string kind, Func<Task> action)
     }
     private void RefreshButtonText()
     { foreach (var (button, kind) in _buttons) button.Content = kind switch { "add" => AddText, "remove" => RemoveText, "up" => UpText, "copy" => CopyText, _ => DownText }; }
-    private List<JsonElement> ArrayValues() => Current is { ValueKind: JsonValueKind.Array } array ? array.EnumerateArray().Select(item => item.Clone()).ToList() : [];
+    private List<JsonElement> ArrayValues() => DecodedCurrent is { ValueKind: JsonValueKind.Array } array ? array.EnumerateArray().Select(item => item.Clone()).ToList() : [];
     private static JsonElement InitialValue(ValueDescriptor descriptor, int depth = 0)
     {
         var type = Nullable.GetUnderlyingType(descriptor.ValueType) ?? descriptor.ValueType;
-        if (depth >= 8) return JsonSerializer.SerializeToElement<object?>(null);
-        if (ElementType(type) is not null) return JsonSerializer.SerializeToElement(Array.Empty<object>());
-        if (typeof(IFieldDto).IsAssignableFrom(type))
-            return JsonSerializer.SerializeToElement(Members(descriptor, type).Where(member => member.Field.DefaultValue is not null || member.Field.IsRequired)
+        if (depth >= 8) return JsonCodec.SerializeToElement<object?>(null);
+        using var document = new ValueDocument(new("initial", descriptor), null);
+        var shape = document.Root.Structure;
+        if (shape.Kind == ValueStructureKind.Sequence) return JsonCodec.SerializeToElement(Array.Empty<JsonElement>());
+        if (shape.Kind == ValueStructureKind.Map) return JsonCodec.SerializeToElement(new Dictionary<string, JsonElement>());
+        if (shape.Kind == ValueStructureKind.Object)
+            return JsonCodec.SerializeToElement(Members(descriptor, type).Where(member => member.Field.DefaultValue is not null || member.Field.IsRequired)
                 .ToDictionary(member => member.Wire, member => member.Field.DefaultValue ?? InitialValue(member.Field.Value, depth + 1)));
-        return JsonSerializer.SerializeToElement(type == typeof(string) ? "" : type.IsEnum ? Enum.GetValues(type).GetValue(0) : type.IsValueType ? Activator.CreateInstance(type) : null, descriptor.ValueType, descriptor.JsonOptions);
+        return JsonCodec.SerializeToElement(type == typeof(string) ? "" : type.IsEnum ? Enum.ToObject(type, Enum.GetValuesAsUnderlyingType(type).GetValue(0)!) : type.IsValueType ? Activator.CreateInstance(type) : null, descriptor.ValueType, descriptor.JsonOptions);
     }
     private ChildBinding Bind(FieldDescriptor field, string? wire, int? index)
     { var binding = new ChildBinding(this, field, wire, index, _generation); _bindings.Add(binding); return binding; }
     private async Task<ValueIssue?> CommitObject(IReadOnlyDictionary<string, FieldValue> patch, int generation, CancellationToken token)
     {
         if (!Available(generation)) return Obsolete();
-        var values = Current is { ValueKind: JsonValueKind.Object } json ? json.EnumerateObject().ToDictionary(property => property.Name, property => property.Value.Clone(), StringComparer.Ordinal) : new Dictionary<string, JsonElement>(StringComparer.Ordinal);
-        foreach (var (key, value) in patch) { if (value.Json is { } provided) values[key] = provided; else values.Remove(key); }
-        return await Submit(JsonSerializer.SerializeToElement(values), generation, token);
+        var candidate = Context.Value.Json;
+        foreach (var (key, value) in patch)
+        {
+            using var document = new ValueDocument(Context.Field, candidate, _resolver);
+            var changed = document.Patch([key], value.Json, token);
+            if (changed.Issue is not null) return changed.Issue;
+            candidate = changed.Value;
+        }
+        return candidate is { } result ? await Submit(result, generation, token, elementCommit: IsMap) : Obsolete();
     }
+
     private async Task ChangeArray(int generation, Action<List<JsonElement>> edit)
     {
         if (!Available(generation)) return;
-        var values = ArrayValues(); edit(values); await Submit(JsonSerializer.SerializeToElement(values), generation, CancellationToken.None);
+        var values = ArrayValues(); edit(values); await Submit(JsonCodec.SerializeToElement(values.ToArray()), generation, CancellationToken.None);
     }
     private Task Move(int index, int offset, int generation) => ChangeArray(generation, values => { var item = values[index]; values.RemoveAt(index); values.Insert(index + offset, item); });
     private bool Available(int generation) => !_disposed && IsExpanded && generation == _generation && Context.IsEnabled;
@@ -222,6 +299,8 @@ private async Task ChangeArray(int generation, Action<List<JsonElement>> edit)
     private async Task<ValueIssue?> Submit(JsonElement json, int generation, CancellationToken token, bool elementCommit = false)
     {
         if (!Available(generation)) return Obsolete();
+        if (_shape.AllowsJsonString && Context.Value.Json is { ValueKind: JsonValueKind.String } && json.ValueKind != JsonValueKind.String)
+            json = JsonCodec.SerializeToElement(json.GetRawText());
         using var linked = CancellationTokenSource.CreateLinkedTokenSource(token, _version.Token);
         _submitted = json.Clone(); _elementCommit = elementCommit;
         try { return await Context.CommitAsync(new(json), linked.Token) ? null : Context.Issue ?? Obsolete(); }
@@ -232,13 +311,17 @@ private sealed class ChildBinding(StructuredFieldEditor owner, FieldDescriptor f
         public FieldDraftState? Draft => GetDraft();
         private FieldDraftState? GetDraft() => owner.Context.DraftState?.Child?.Invoke(field, wire ?? index!.Value.ToString(System.Globalization.CultureInfo.InvariantCulture));
         public object? HostContext => owner.Context.HostContext;
+        public IReadOnlyList<string>? PropertySegments => [.. owner.Context.PropertySegments ?? [], wire ?? index!.Value.ToString(System.Globalization.CultureInfo.InvariantCulture)];
+        public object? Label => index is { } position ? "#" + (position + 1) : owner.IsMap ? wire : null;
+        public bool IsLabelLiteral => index is not null || owner.IsMap;
+        public bool CanReset => owner.Context.AllowsChildReset;
+        public bool IsVisible => owner.Context.IsVisible;
         public bool IsEnabled => owner.Available(generation);
         public FieldValue Read()
         {
-            var value = owner.Current;
-            if (wire is not null && value is { ValueKind: JsonValueKind.Object } obj && obj.TryGetProperty(wire, out var member)) return new(member);
-            if (index is { } position && value is { ValueKind: JsonValueKind.Array } array && position < array.GetArrayLength()) return new(array[position]);
-            return default;
+            using var document = new ValueDocument(owner.Context.Field, owner.Current, owner._resolver);
+            var property = document.FindProperty([wire ?? index!.Value.ToString(System.Globalization.CultureInfo.InvariantCulture)]);
+            return new(property?.Value);
         }
         public event EventHandler? Changed;
         public void Refresh() => Changed?.Invoke(this, EventArgs.Empty);
@@ -250,7 +333,7 @@ public FieldValue Read()
             if (wire is not null) return owner.CommitObject(new Dictionary<string, FieldValue> { [wire] = value }, generation, token);
             if (value.Json is not { } element) return Task.FromResult<ValueIssue?>(new("structure.element", "Array elements cannot be omitted; remove the element instead.", field.Id));
             var values = owner.ArrayValues(); values[index!.Value] = element;
-            return owner.Submit(JsonSerializer.SerializeToElement(values), generation, token, elementCommit: true);
+            return owner.Submit(JsonCodec.SerializeToElement(values.ToArray()), generation, token, elementCommit: true);
         }
     }
     private void Release()
@@ -261,6 +344,6 @@ private void Release()
     }
     public void Dispose()
     {
-        if (_disposed) return; _disposed = true; Context.PropertyChanged -= Changed; Release(); _version.Dispose();
+        if (_disposed) return; _disposed = true; Context.PropertyChanged -= Changed; Release(); _version.Dispose(); _resolver.Dispose();
     }
 }
diff --git a/src/Presentation/GalNet.Avalonia.Controls/GalNet.Avalonia.Controls.csproj b/src/Presentation/GalNet.Avalonia.Controls/GalNet.Avalonia.Controls.csproj
index 31722af8..faf7a3d9 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/GalNet.Avalonia.Controls.csproj
+++ b/src/Presentation/GalNet.Avalonia.Controls/GalNet.Avalonia.Controls.csproj
@@ -11,4 +11,5 @@
     <ProjectReference Include="..\..\Shared\GalNet.Core\GalNet.Core.csproj" />
   </ItemGroup>
 
+  <ItemGroup><ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Presentation/GalNet.Avalonia.Controls/NvlPresenter.cs b/src/Presentation/GalNet.Avalonia.Controls/NvlPresenter.cs
index 569f5fe4..744ea46a 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/NvlPresenter.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/NvlPresenter.cs
@@ -10,6 +10,7 @@ public sealed class NvlPresenter : TemplatedControl
     private StackPanel? _lines;
     private ScrollViewer? _scrollViewer;
     private NvlLinePresenter? _latestLine;
+    public bool NextLineWasRead { get; set; }
 
     /// <summary>Adds a line and completes after its rich text/typewriter presentation finishes.</summary>
     public Task AppendAsync(string text, double charactersPerSecond, CancellationToken cancellationToken = default)
@@ -21,6 +22,7 @@ public Task AppendAsync(string text, double charactersPerSecond, CancellationTok
             Text = text,
             CharactersPerSecond = charactersPerSecond
         };
+        ReadTextStyle.SetWasRead(line, NextLineWasRead);
         lines.Children.Add(line);
         _latestLine = line;
         line.ApplyTemplate();
diff --git a/src/Presentation/GalNet.Avalonia.Controls/ReadTextStyle.cs b/src/Presentation/GalNet.Avalonia.Controls/ReadTextStyle.cs
new file mode 100644
index 00000000..37297026
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.Controls/ReadTextStyle.cs
@@ -0,0 +1,18 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media;
+
+namespace GalNet.Game.Controls;
+
+/// <summary>Inherited defaults for previously read typewriter text. Explicit rich-text colors win.</summary>
+public sealed class ReadTextStyle : AvaloniaObject
+{
+    public static readonly AttachedProperty<IBrush?> ForegroundProperty =
+        AvaloniaProperty.RegisterAttached<ReadTextStyle, Control, IBrush?>("Foreground", inherits: true);
+    public static readonly AttachedProperty<bool> WasReadProperty =
+        AvaloniaProperty.RegisterAttached<ReadTextStyle, Control, bool>("WasRead", inherits: true);
+    public static IBrush? GetForeground(Control control) => control.GetValue(ForegroundProperty);
+    public static void SetForeground(Control control, IBrush? value) => control.SetValue(ForegroundProperty, value);
+    public static bool GetWasRead(Control control) => control.GetValue(WasReadProperty);
+    public static void SetWasRead(Control control, bool value) => control.SetValue(WasReadProperty, value);
+}
diff --git a/src/Presentation/GalNet.Avalonia.Controls/SaveSlotCard.cs b/src/Presentation/GalNet.Avalonia.Controls/SaveSlotCard.cs
index c736ba1e..0dcffc0d 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/SaveSlotCard.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/SaveSlotCard.cs
@@ -1,7 +1,12 @@
 using System.Windows.Input;
 using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Interactivity;
 using Avalonia.Media;
+using Avalonia.VisualTree;
 
 namespace GalNet.Game.Controls;
 
@@ -24,6 +29,14 @@ public class SaveSlotCard : TemplatedControl
         AvaloniaProperty.Register<SaveSlotCard, ICommand?>(nameof(Command));
     public static readonly StyledProperty<object?> CommandParameterProperty =
         AvaloniaProperty.Register<SaveSlotCard, object?>(nameof(CommandParameter));
+    public static readonly StyledProperty<ICommand?> RenameCommandProperty =
+        AvaloniaProperty.Register<SaveSlotCard, ICommand?>(nameof(RenameCommand));
+    public static readonly StyledProperty<bool> CanRenameProperty =
+        AvaloniaProperty.Register<SaveSlotCard, bool>(nameof(CanRename));
+    public static readonly StyledProperty<string?> RenameErrorProperty =
+        AvaloniaProperty.Register<SaveSlotCard, string?>(nameof(RenameError));
+    private TextBox? _name;
+    private Button? _activate;
 
     public int SlotIndex { get => GetValue(SlotIndexProperty); set => SetValue(SlotIndexProperty, value); }
     public string? Timestamp { get => GetValue(TimestampProperty); set => SetValue(TimestampProperty, value); }
@@ -33,4 +46,33 @@ public class SaveSlotCard : TemplatedControl
     public bool IsCorrupt { get => GetValue(IsCorruptProperty); set => SetValue(IsCorruptProperty, value); }
     public ICommand? Command { get => GetValue(CommandProperty); set => SetValue(CommandProperty, value); }
     public object? CommandParameter { get => GetValue(CommandParameterProperty); set => SetValue(CommandParameterProperty, value); }
+    public ICommand? RenameCommand { get => GetValue(RenameCommandProperty); set => SetValue(RenameCommandProperty, value); }
+    public bool CanRename { get => GetValue(CanRenameProperty); set => SetValue(CanRenameProperty, value); }
+    public string? RenameError { get => GetValue(RenameErrorProperty); set => SetValue(RenameErrorProperty, value); }
+
+    protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+    {
+        if (_name is not null) { _name.LostFocus -= OnNameLostFocus; _name.KeyDown -= OnNameKeyDown; }
+        base.OnApplyTemplate(e);
+        _name = e.NameScope.Find<TextBox>("PART_Name");
+        _activate = e.NameScope.Find<Button>("PART_Activate");
+        if (_name is not null) { _name.LostFocus += OnNameLostFocus; _name.KeyDown += OnNameKeyDown; }
+    }
+
+    private void OnNameLostFocus(object? sender, RoutedEventArgs e) => CommitName();
+    private void OnNameKeyDown(object? sender, KeyEventArgs e)
+    {
+        if (e.Key is not (Key.Enter or Key.Escape)) return;
+        if (_name?.GetVisualDescendants().OfType<TextPresenter>().Any(presenter => !string.IsNullOrEmpty(presenter.PreeditText)) == true) return;
+        e.Handled = true;
+        if (e.Key == Key.Escape && _name is not null) _name.Text = Description;
+        else CommitName();
+        _activate?.Focus();
+    }
+    private void CommitName()
+    {
+        var name = _name?.Text ?? "";
+        if (CanRename && (name != Description || RenameError is not null) && RenameCommand?.CanExecute(name) == true)
+            RenameCommand.Execute(name);
+    }
 }
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Styles/Generic.axaml b/src/Presentation/GalNet.Avalonia.Controls/Styles/Generic.axaml
index f972ad06..89f9ebd5 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Styles/Generic.axaml
+++ b/src/Presentation/GalNet.Avalonia.Controls/Styles/Generic.axaml
@@ -1,5 +1,5 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Styles xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="using:GalNet.Game.Controls">
+<?xml version="1.0" encoding="utf-8"?>
+<Styles xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="using:GalNet.Game.Controls" xmlns:conv="using:Avalonia.Data.Converters">
   <Styles.Resources>
     <ResourceDictionary>
       <ResourceDictionary.MergedDictionaries>
@@ -12,6 +12,7 @@
               <StackPanel Spacing="8">
                 <TextBlock Text="{TemplateBinding Speaker}" FontWeight="SemiBold" FontSize="{DynamicResource GalNet.Theme.SpeakerFontSize}" Foreground="{DynamicResource GalNet.Brush.Primary}" />
                 <local:TypewriterTextBlock Name="PART_Typewriter" SourceText="{TemplateBinding Text}" CharactersPerSecond="{TemplateBinding CharactersPerSecond}" FontSize="{DynamicResource GalNet.Theme.DialogueFontSize}" Foreground="{DynamicResource GalNet.Brush.TextPrimary}" />
+                <Button HorizontalAlignment="Right" Content="{TemplateBinding ReplayIcon}" IsVisible="{TemplateBinding CanReplayVoice}" Command="{TemplateBinding ReplayVoiceCommand}" ToolTip.Tip="{TemplateBinding ReplayLabel}" AutomationProperties.Name="{TemplateBinding ReplayLabel}" />
               </StackPanel>
             </Border>
           </ControlTemplate>
@@ -66,26 +67,49 @@
       <ControlTheme x:Key="{x:Type local:SaveSlotCard}" TargetType="local:SaveSlotCard">
         <Setter Property="Template">
           <ControlTemplate>
-            <Button HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Command="{TemplateBinding Command}" CommandParameter="{TemplateBinding CommandParameter}" Padding="0" Background="Transparent" BorderBrush="Transparent" BorderThickness="0" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch">
-              <Border MinHeight="{DynamicResource GalNet.Theme.SaveMinHeight}" Padding="16" Background="{DynamicResource GalNet.Brush.Surface}" BorderBrush="{DynamicResource GalNet.Brush.Border}" BorderThickness="1" CornerRadius="{DynamicResource GalNet.Theme.CornerRadius}">
-                <Grid RowDefinitions="*,Auto" RowSpacing="12">
-                  <StackPanel Spacing="4" VerticalAlignment="Top">
-                    <TextBlock FontWeight="SemiBold" FontSize="16" Foreground="{DynamicResource GalNet.Brush.TextPrimary}">
-                      <Run Text="Slot " />
-                      <Run Text="{TemplateBinding SlotIndex}" />
-                    </TextBlock>
-                    <TextBlock Text="{TemplateBinding Description}" TextWrapping="Wrap" Opacity="0.75" />
-                  </StackPanel>
-                  <StackPanel Grid.Row="1" Spacing="2">
-                    <TextBlock Text="{TemplateBinding Timestamp}" FontSize="12" Opacity="0.74" />
-                    <TextBlock Text="Empty" IsVisible="{TemplateBinding IsEmpty}" FontSize="12" Opacity="0.56" />
-                    <TextBlock Text="Corrupt save" IsVisible="{TemplateBinding IsCorrupt}" FontSize="12" Foreground="{DynamicResource GalNet.Brush.Error}" />
+            <Border Name="PART_Frame" Height="210" Background="{DynamicResource GalNet.Brush.Surface}"
+                    BorderBrush="{DynamicResource GalNet.Brush.Border}" BorderThickness="1"
+                    CornerRadius="{DynamicResource GalNet.Theme.CornerRadius}" ClipToBounds="True">
+              <Grid>
+                <Image Name="PART_Preview" Source="{TemplateBinding Preview}" Stretch="UniformToFill" />
+                <Button Name="PART_Activate" Command="{TemplateBinding Command}" CommandParameter="{TemplateBinding CommandParameter}"
+                        Background="Transparent" BorderThickness="0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"
+                        AutomationProperties.Name="{TemplateBinding Description}">
+                  <Button.Template><ControlTemplate><Border Background="Transparent" /></ControlTemplate></Button.Template>
+                </Button>
+                <Grid VerticalAlignment="Bottom" MinHeight="84">
+                  <Border Background="{DynamicResource GalNet.Brush.SaveCaption}" IsHitTestVisible="False" />
+                  <StackPanel Spacing="4" Margin="16,12">
+                    <TextBox Name="PART_Name" Text="{TemplateBinding Description, Mode=OneWay}"
+                             IsReadOnly="{Binding !CanRename, RelativeSource={RelativeSource TemplatedParent}}"
+                             Focusable="{TemplateBinding CanRename}" IsHitTestVisible="{TemplateBinding CanRename}" MaxLength="120" AcceptsReturn="False"
+                             Background="Transparent" BorderThickness="0" Padding="0" MinHeight="26"
+                             FontSize="17" FontWeight="SemiBold" Foreground="{DynamicResource GalNet.Brush.TextPrimary}"
+                             ToolTip.Tip="{TemplateBinding RenameError}">
+                      <TextBox.Template>
+                        <ControlTemplate TargetType="TextBox">
+                          <ScrollViewer Name="PART_ScrollViewer" HorizontalScrollBarVisibility="Hidden" VerticalScrollBarVisibility="Disabled">
+                            <TextPresenter Name="PART_TextPresenter" Text="{TemplateBinding Text, Mode=TwoWay}"
+                                           CaretBrush="{DynamicResource GalNet.Brush.TextPrimary}"
+                                           SelectionBrush="{DynamicResource GalNet.Brush.Selection}"
+                                           SelectionForegroundBrush="{DynamicResource GalNet.Brush.TextPrimary}" />
+                          </ScrollViewer>
+                        </ControlTemplate>
+                      </TextBox.Template>
+                    </TextBox>
+                    <TextBlock Text="{TemplateBinding Timestamp}" FontSize="12" Foreground="{DynamicResource GalNet.Brush.TextSecondary}" IsHitTestVisible="False" />
+                    <TextBlock Text="{TemplateBinding RenameError}" IsVisible="{Binding RenameError, RelativeSource={RelativeSource TemplatedParent}, Converter={x:Static conv:StringConverters.IsNotNullOrEmpty}}" FontSize="12" Foreground="{DynamicResource GalNet.Brush.Error}" TextWrapping="Wrap" IsHitTestVisible="False" />
                   </StackPanel>
                 </Grid>
-              </Border>
-            </Button>
+                <Border Name="PART_Highlight" Background="{DynamicResource GalNet.Brush.Selection}" Opacity="0" IsHitTestVisible="False" />
+              </Grid>
+            </Border>
           </ControlTemplate>
         </Setter>
+        <Style Selector="^:pointerover /template/ Border#PART_Frame"><Setter Property="BorderBrush" Value="{DynamicResource GalNet.Brush.PrimaryHover}" /></Style>
+        <Style Selector="^:pointerover /template/ Border#PART_Highlight"><Setter Property="Opacity" Value="0.18" /></Style>
+        <Style Selector="^:focus-within /template/ Border#PART_Frame"><Setter Property="BorderBrush" Value="{DynamicResource GalNet.Brush.Focus}" /></Style>
+        <Style Selector="^:focus-within /template/ Border#PART_Highlight"><Setter Property="Opacity" Value="0.3" /></Style>
       </ControlTheme>
       <ControlTheme x:Key="{x:Type local:NvlPresenter}" TargetType="local:NvlPresenter">
         <Setter Property="Template">
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Styles/Resources.axaml b/src/Presentation/GalNet.Avalonia.Controls/Styles/Resources.axaml
index e1960c3d..0e95b0e3 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Styles/Resources.axaml
+++ b/src/Presentation/GalNet.Avalonia.Controls/Styles/Resources.axaml
@@ -11,6 +11,7 @@
   <SolidColorBrush x:Key="GalNet.Brush.Surface" Color="#242A33" />
   <SolidColorBrush x:Key="GalNet.Brush.SurfaceRaised" Color="#303946" />
   <SolidColorBrush x:Key="GalNet.Brush.Overlay" Color="#D9242A33" />
+  <SolidColorBrush x:Key="GalNet.Brush.SaveCaption" Color="#D9242A33" />
   <SolidColorBrush x:Key="GalNet.Brush.TextPrimary" Color="#F1F3F5" />
   <SolidColorBrush x:Key="GalNet.Brush.TextSecondary" Color="#B8C0CB" />
   <SolidColorBrush x:Key="GalNet.Brush.TextDisabled" Color="#727E8E" />
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Styles/SchemaForm.axaml b/src/Presentation/GalNet.Avalonia.Controls/Styles/SchemaForm.axaml
index 741d64c6..eca9606e 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Styles/SchemaForm.axaml
+++ b/src/Presentation/GalNet.Avalonia.Controls/Styles/SchemaForm.axaml
@@ -9,7 +9,7 @@
               <ItemsControl.ItemTemplate>
                 <DataTemplate>
                   <StackPanel IsVisible="{Binding Context.IsVisible}">
-                    <ContentControl Content="{Binding Context.Label}" />
+                    <ContentControl Content="{Binding Context.Label}" IsVisible="{Binding ShowSeparateLabel}" />
                     <ContentControl Content="{Binding Control}" />
                     <TextBlock Text="JSON" IsVisible="{Binding IsJsonFallback}" Opacity="0.65" />
                     <forms:FieldEditorActions Context="{Binding Context}" />
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCanvas.Curves.cs b/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCanvas.Curves.cs
index d9635641..e017ec68 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCanvas.Curves.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCanvas.Curves.cs
@@ -2,7 +2,7 @@
 using Avalonia;
 using Avalonia.Input;
 using Avalonia.Media;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Game.Controls.Timeline;
 
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCanvasModel.cs b/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCanvasModel.cs
index 4a736ab9..eee1f9df 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCanvasModel.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCanvasModel.cs
@@ -1,5 +1,5 @@
 using System.ComponentModel;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Game.Controls.Timeline;
 
diff --git a/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCurveViewport.cs b/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCurveViewport.cs
index 6bcad495..3fb765be 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCurveViewport.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/Timeline/TimelineCurveViewport.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Game.Controls.Timeline;
 
diff --git a/src/Presentation/GalNet.Avalonia.Controls/TypewriterTextBlock.cs b/src/Presentation/GalNet.Avalonia.Controls/TypewriterTextBlock.cs
index 0c2fbd7e..4ceaa0da 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/TypewriterTextBlock.cs
+++ b/src/Presentation/GalNet.Avalonia.Controls/TypewriterTextBlock.cs
@@ -29,11 +29,14 @@ public sealed class TypewriterTextBlock : TextBlock
     private bool _skipRequested;
     private bool _instantMode;
     private readonly object _skipGate = new();
+    private readonly List<Run> _defaultColorRuns = [];
 
     static TypewriterTextBlock()
     {
         SourceTextProperty.Changed.AddClassHandler<TypewriterTextBlock>((control, _) => control.Restart());
         CharactersPerSecondProperty.Changed.AddClassHandler<TypewriterTextBlock>((control, _) => control.Restart());
+        ReadTextStyle.ForegroundProperty.Changed.AddClassHandler<TypewriterTextBlock>((control, _) => control.RefreshReadColor());
+        ReadTextStyle.WasReadProperty.Changed.AddClassHandler<TypewriterTextBlock>((control, _) => control.RefreshReadColor());
     }
 
     /// <summary>Raw game text, including <c>\d</c> and <c>\n</c> directives.</summary>
@@ -80,6 +83,7 @@ public Task StartAsync(CancellationToken cancellationToken = default)
         IsRunning = true;
         IsCompleted = false;
         Text = null;
+        _defaultColorRuns.Clear();
         (Inlines ?? throw new InvalidOperationException("TextBlock did not provide an inline collection.")).Clear();
         _ = RenderAsync(SourceText, _completion, _skipSignal, _runCancellation.Token);
         return _completion.Task;
@@ -128,6 +132,11 @@ private async Task RenderAsync(
                         };
                         if (token.Color is { } color && Color.TryParse(color, out var parsed))
                             run.Foreground = new SolidColorBrush(parsed);
+                        else
+                        {
+                            _defaultColorRuns.Add(run);
+                            ApplyReadColor(run);
+                        }
                         inlines.Add(run);
                         foreach (var character in token.Text)
                         {
@@ -192,4 +201,14 @@ private async Task DelayOrSkipAsync(TimeSpan duration, TaskCompletionSource skip
         await Task.WhenAny(Task.Delay(duration, cancellationToken), signal);
         cancellationToken.ThrowIfCancellationRequested();
     }
+
+    private void RefreshReadColor()
+    {
+        foreach (var run in _defaultColorRuns) ApplyReadColor(run);
+    }
+    private void ApplyReadColor(Run run)
+    {
+        if (ReadTextStyle.GetWasRead(this) && ReadTextStyle.GetForeground(this) is { } brush) run.Foreground = brush;
+        else run.ClearValue(TextElement.ForegroundProperty);
+    }
 }
diff --git a/src/Presentation/GalNet.Avalonia.Controls/packages.lock.WindowsReadyToRun.json b/src/Presentation/GalNet.Avalonia.Controls/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..6d96a79e
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.Controls/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,43 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
+        "dependencies": {
+          "Avalonia.BuildServices": "11.3.2",
+          "Avalonia.Remote.Protocol": "12.0.5",
+          "MicroCom.Runtime": "0.11.4"
+        }
+      },
+      "Avalonia.BuildServices": {
+        "type": "Transitive",
+        "resolved": "11.3.2",
+        "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
+      },
+      "Avalonia.Remote.Protocol": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Presentation/GalNet.Avalonia.Controls/packages.lock.json b/src/Presentation/GalNet.Avalonia.Controls/packages.lock.json
index 5310c6c8..66d260fb 100644
--- a/src/Presentation/GalNet.Avalonia.Controls/packages.lock.json
+++ b/src/Presentation/GalNet.Avalonia.Controls/packages.lock.json
@@ -28,6 +28,12 @@
         "resolved": "0.11.4",
         "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
       },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.core": {
         "type": "Project"
       }
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameHostOptions.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameHostOptions.cs
index b8a0131c..a3f0f3e4 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameHostOptions.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameHostOptions.cs
@@ -1,23 +1,30 @@
 using GalNet.Assets.Variants;
 using GalNet.Avalonia.GameView.Page;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
-using GalNet.Core.Scene;
+using GalNet.Core.Configuration;
+using GalNet.GameHost.Content;
 using GalNet.Presentation.Abstractions.View;
-using GalNet.Runtime.Content;
 
 namespace GalNet.Avalonia.GameHost;
 
 /// <summary>Project policies supplied to the default Avalonia player composition.</summary>
 public sealed class AvaloniaGameHostOptions
 {
+    public GameContentLoadOptions Content { get; init; } = new();
+    public Func<ProjectConfiguration, AvaloniaProjectOptions> SelectProjectOptions { get; init; } = _ => new();
     public AvaloniaGamePresentationOptions Presentation { get; init; } = new();
+    public bool ShowTrackAudioControls { get; init; }
     public string GameTitle { get; init; } = "GalNet";
     public string NoGameMessage { get; init; } = "Select a game directory to start.";
     public required Func<(IResourceTypeCatalog Resources, IGalleryTypeCatalog Gallery)> CreateContentCatalogs { get; init; }
     public required Action<GameRegistration, AvaloniaGamePresentation, GamePage, GameContent> ConfigureExecution { get; init; }
-    /// <summary>Optional borrowed runtime binding. Disposed before the run; no debugger dependency is required.</summary>
-    public Func<GalNet.Runtime.Engine.GameEngine, IDisposable>? AttachDebugRun { get; init; }
+    /// <summary>Project binding attached after preparation and released after the engine stops.</summary>
+    public Func<GalNet.Runtime.Engine.GameEngine, IDisposable>? AttachRun { get; init; }
+    /// <summary>Profile services attached after onboarding/settings; released before player storage.</summary>
+    public Func<AvaloniaPlayerContext, IDisposable>? AttachPlayer { get; init; }
     public Action<IAssetManager> ConfigureDecoders { get; init; } = assets =>
     {
         assets.RegisterDecoder<GalNet.Rendering.Scene.SceneTexture>("sprite", new GalNet.Rendering.Scene.SceneTextureAssetDecoder());
@@ -28,3 +35,14 @@ public sealed class AvaloniaGameHostOptions
     public Func<IAssetManager, CancellationToken, Task<EffectProgramResource[]>> SelectEffectPrograms { get; init; } =
         async (assets, token) => (await assets.GetFilesAsync("effect-program", token)).Select(file => new EffectProgramResource(file.Id)).ToArray();
 }
+
+/// <summary>Values consumed by the default player, projected once by the project's composition root.</summary>
+public sealed record AvaloniaProjectOptions
+{
+    public int SaveSlotCount { get; init; } = 60;
+    public string DefaultCulture { get; init; } = "en-US";
+    public AudioConfiguration Audio { get; init; } = AudioConfiguration.Empty;
+}
+
+/// <summary>Borrowed profile resources for project services. The session retains ownership.</summary>
+public sealed record AvaloniaPlayerContext(GalNet.GameHost.PlayerSession Player, GameContent Content, string ProfileDirectory);
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGamePresentation.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGamePresentation.cs
index 76e381e7..48969461 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGamePresentation.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGamePresentation.cs
@@ -4,11 +4,12 @@
 using GalNet.Avalonia.GameView.Presentation;
 using GalNet.Avalonia.GameView.Services;
 using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
+using GalNet.Core.Execution;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
-using GalNet.Core.Variants;
-using GalNet.Presentation.Abstractions.Audio;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
@@ -32,11 +33,13 @@ private AvaloniaGamePresentation() { }
     public AvaloniaGamePresenters Presenters { get; private set; } = null!;
     public AvaloniaEffectRuntime Effects { get; private set; } = null!;
     public IAudioPlaybackHost Audio { get; private set; } = null!;
-    public AvaloniaVideoPresenter Video { get; private set; } = null!;
+    public IVideoPresenter Video { get; private set; } = null!;
     public CompositeGameView View { get; private set; } = null!;
     public BuiltinAudioModule AudioModule { get; private set; } = null!;
     public StateRestoreSession Restorer { get; private set; } = null!;
     public ImageVariantsCatalog ImageVariants { get; private set; } = ImageVariantsCatalog.Empty;
+    public GalNet.GameHost.DialogueHistoryJournal History { get; } = new();
+    public GalNet.GameHost.DialogueVoiceReplay VoiceReplay { get; private set; } = null!;
 
     public static async Task<AvaloniaGamePresentation> CreateAsync(
         GamePageViewModel gameplay, GamePage page, IAssetManager assets,
@@ -44,7 +47,8 @@ public static async Task<AvaloniaGamePresentation> CreateAsync(
         IReadOnlyList<EffectProgramResource> effectPrograms, IAssetFileMaterializer files,
         Action<GameRegistration, AvaloniaGamePresentation> configure,
         IEnumerable<string> requiredInstructions,
-        AvaloniaGamePresentationOptions? options = null, LibVLC? sharedLibVlc = null, CancellationToken cancellationToken = default)
+        AvaloniaGamePresentationOptions? options = null, LibVLC? sharedLibVlc = null,
+        AudioConfiguration? audioConfiguration = null, CancellationToken cancellationToken = default)
     {
         options ??= new AvaloniaGamePresentationOptions();
         var presentation = new AvaloniaGamePresentation();
@@ -60,13 +64,16 @@ public static async Task<AvaloniaGamePresentation> CreateAsync(
             GameLog.Logger.Information(
                 "Preloaded {UsableEffectProgramCount}/{EffectProgramCount} effect programs in {ElapsedMilliseconds} ms",
                 preload.UsableProgramCount, preload.RequestedProgramCount, preload.Cache.TotalLoadTime.TotalMilliseconds);
-            presentation.Effects = new AvaloniaEffectRuntime(gameplay, presentation._programs);
-            presentation.Audio = options.CreateAudioHost(assets, files, sharedLibVlc);
-            presentation.AudioModule = new BuiltinAudioModule(presentation.Audio);
-            presentation.Video = new AvaloniaVideoPresenter(assets, gameplay, files: files,
-                sharedLibVlc: sharedLibVlc);
+            presentation.Effects = new AvaloniaEffectRuntime(gameplay, presentation._programs, assets);
+            presentation.Audio = options.CreateAudioHost(assets, files);
+            presentation.VoiceReplay = new(presentation.Audio);
+            presentation.AudioModule = new BuiltinAudioModule(presentation.Audio, configuration: audioConfiguration);
+            presentation.Video = options.CreateVideoPresenter is { } createVideo
+                ? createVideo(assets, gameplay, files) ?? throw new InvalidOperationException("The video presenter factory returned null.")
+                : new AvaloniaVideoPresenter(assets, gameplay, files: files, sharedLibVlc: sharedLibVlc);
             using var registration = new GameRegistration();
             configure(registration, presentation);
+            registration.RegisterImplementation(GalNet.GameHost.DialogueHistoryJournal.CreateModule());
             presentation.View = registration.BuildView();
             presentation.View.RequireInstructions(requiredInstructions);
             presentation.Restorer = new StateRestoreSession(presentation.View);
@@ -92,7 +99,7 @@ public async Task BeginCatchUpAsync(CancellationToken cancellationToken)
         await Restorer.SuspendAsync(cancellationToken);
     }
 
-    public async Task EndCatchUpAsync(IGameRuntime runtime, CancellationToken cancellationToken)
+    public async Task EndCatchUpAsync(IGameContext runtime, CancellationToken cancellationToken)
     {
         await AvaloniaUiDispatcher.Instance.InvokeAsync(() =>
         {
@@ -109,10 +116,12 @@ await AvaloniaUiDispatcher.Instance.InvokeAsync(() =>
     private async Task DisposeCoreAsync()
     {
         var cleanup = new GalNet.GameHost.ResourceCleanup();
+        await cleanup.RunAsync(() => VoiceReplay?.DisposeAsync() ?? ValueTask.CompletedTask);
         // Implementations borrow platform ports, so release the view first.
         await cleanup.RunAsync(() => Restorer?.DisposeAsync() ?? ValueTask.CompletedTask);
         await cleanup.RunAsync(() => View?.DisposeAsync() ?? ValueTask.CompletedTask);
-        await cleanup.RunAsync(() => Video?.DisposeAsync() ?? ValueTask.CompletedTask);
+        if (Video is IAsyncDisposable asyncVideo) await cleanup.RunAsync(asyncVideo.DisposeAsync);
+        else cleanup.Run(() => (Video as IDisposable)?.Dispose());
         if (Audio is IAsyncDisposable asyncAudio) await cleanup.RunAsync(asyncAudio.DisposeAsync);
         else cleanup.Run(() => Audio?.Dispose());
         cleanup.Run(() =>
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGamePresentationOptions.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGamePresentationOptions.cs
index 02280eda..55be4cae 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGamePresentationOptions.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGamePresentationOptions.cs
@@ -1,9 +1,10 @@
 using GalNet.Avalonia.GameView.Presentation;
+using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Contracts.Builtins.Audio;
 using GalNet.Core.Assets;
-using GalNet.Media.LibVlc;
-using GalNet.Presentation.Abstractions.Audio;
+using GalNet.Media.Miniaudio;
+using GalNet.Presentation.Abstractions.View;
 using GalNet.Rendering.Scene;
-using LibVLCSharp.Shared;
 
 namespace GalNet.Avalonia.GameHost;
 
@@ -12,6 +13,8 @@ public sealed class AvaloniaGamePresentationOptions
 {
     public Func<IReadOnlyDictionary<string, AssetHandle<SceneTexture>>, IGamePageLayerFactory> CreateLayers { get; init; } =
         textures => new DefaultGameLayerFactory(textures);
-    public Func<IAssetManager, IAssetFileMaterializer, LibVLC?, IAudioPlaybackHost> CreateAudioHost { get; init; } =
-        (assets, files, shared) => new LibVlcAudioPlaybackHost(assets, files: files, sharedLibVlc: shared);
+    public Func<IAssetManager, IAssetFileMaterializer, IAudioPlaybackHost> CreateAudioHost { get; init; } =
+        (assets, files) => new MiniaudioAudioPlaybackHost(files);
+    /// <summary>When omitted, uses the default LibVLC pixel presenter. A custom presenter owns its platform resources.</summary>
+    public Func<IAssetManager, GamePageViewModel, IAssetFileMaterializer, IVideoPresenter>? CreateVideoPresenter { get; init; }
 }
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameResources.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameResources.cs
index de6e6871..08c1b1ca 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameResources.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameResources.cs
@@ -1,5 +1,5 @@
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Assets;
-using GalNet.Core.Scene;
 using GalNet.Rendering.Scene;
 
 namespace GalNet.Avalonia.GameHost;
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameRun.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameRun.cs
index 950ecf1d..d7a7c822 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameRun.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameRun.cs
@@ -1,8 +1,8 @@
+using GalNet.Avalonia.GameHost.Settings;
 using GalNet.Avalonia.GameView.Page;
 using GalNet.Avalonia.GameView.ViewModels;
 using GalNet.Core.Runtime;
 using GalNet.Core.Services;
-using GalNet.Core.Settings;
 using GalNet.GameHost;
 using GalNet.Runtime.Engine;
 using GalNet.Runtime.Logging;
@@ -13,47 +13,57 @@
 namespace GalNet.Avalonia.GameHost;
 
 /// <summary>Default page binding and run ownership; the engine owns execution and terminal states.</summary>
-internal sealed class AvaloniaGameRun : IGameRun
+internal sealed class AvaloniaGameRun : IGameRun, IParameterizedGameRun
 {
     private readonly GamePageViewModel _gameplay;
     private readonly GameRun _run;
     private GameEngine _engine => _run.Engine;
     private readonly AvaloniaGamePresentation _presentation;
-    private readonly AvaloniaPlayerSettingsService _playerSettings;
+    private readonly IAvaloniaPlayerSettings _playerSettings;
     private readonly Func<bool, string?, Task> _updateStateAsync;
     private readonly Func<Task> _runCompletedAsync;
     private readonly Func<Task> _resetPresentationAsync;
     private readonly Func<Action, Task> _onUiAsync;
     private readonly Func<Task> _flushPlayerVariables;
     private Task _stateUpdate = Task.CompletedTask;
+    private Task _settingsUpdate = Task.CompletedTask;
     private bool _disposed;
-    private IDisposable? _debugBinding;
+    private IDisposable? _runBinding;
+    private readonly Func<GameEngine, IDisposable>? _attachRun;
+    private DialogueHistoryDispatcher _history = null!;
 
     private AvaloniaGameRun(
-        GamePageViewModel gameplay, GameRun run, AvaloniaGamePresentation presentation, AvaloniaPlayerSettingsService playerSettings,
+        GamePageViewModel gameplay, GameRun run, AvaloniaGamePresentation presentation, IAvaloniaPlayerSettings playerSettings,
         Func<bool, string?, Task> updateStateAsync, Func<Task> runCompletedAsync,
-        Func<Task> resetPresentationAsync, Func<Action, Task> onUiAsync, Func<Task> flushPlayerVariables)
+        Func<Task> resetPresentationAsync, Func<Action, Task> onUiAsync, Func<Task> flushPlayerVariables, Func<GameEngine, IDisposable>? attachRun)
     {
+        _attachRun = attachRun;
         _gameplay = gameplay;
         _run = run;
         _presentation = presentation;
         _playerSettings = playerSettings;
-        _playerSettings.SettingsChanged += OnPlayerSettingsChanged;
-        OnPlayerSettingsChanged(playerSettings.RuntimeSettings);
         _updateStateAsync = updateStateAsync;
         _runCompletedAsync = runCompletedAsync;
         _resetPresentationAsync = resetPresentationAsync;
         _onUiAsync = onUiAsync;
         _flushPlayerVariables = flushPlayerVariables;
+        OnPlayerSettingsChanged();
+        _playerSettings.SettingsChanged += OnPlayerSettingsChanged;
         _gameplay.AdvanceRequested += OnAdvanceRequested;
         _gameplay.BindPlayback(_engine);
         _engine.StateChanged += OnEngineStateChanged;
+        _gameplay.GetHistoryLines = () => { _history.FlushCompleted(); return _presentation.History.Lines; };
+        _gameplay.PlayVoiceAsync = PlayVoiceAsync;
+        _gameplay.StopVoiceReplayRequested += OnStopVoiceReplay;
+        _presentation.VoiceReplay.Changed += OnVoiceReplayChanged;
+        _presentation.VoiceReplay.Failed += OnVoiceReplayFailed;
+        _presentation.History.Changed += OnHistoryChanged;
     }
 
     public static async Task<AvaloniaGameRun> CreateAsync(
         GamePageViewModel gameplay, GamePage page, GameResourceScope resources, AvaloniaGameResources visuals,
-        PlayerSession saveSession, AvaloniaPlayerSettingsService playerSettings, ITextResolver textResolver, AvaloniaGameHostOptions options,
-        LibVLC? sharedLibVlc, Func<bool, string?, Task> updateStateAsync,
+        PlayerSession saveSession, IAvaloniaPlayerSettings playerSettings, ITextResolver textResolver, AvaloniaGameHostOptions options,
+        GalNet.Contracts.Builtins.Audio.AudioConfiguration audioConfiguration, LibVLC? sharedLibVlc, Func<bool, string?, Task> updateStateAsync,
         Func<Task> runCompletedAsync, Func<Task> resetPresentationAsync,
         Func<Action, Task> onUiAsync, CancellationToken cancellationToken)
     {
@@ -61,20 +71,24 @@ public static async Task<AvaloniaGameRun> CreateAsync(
             visuals.PreloadedTextures, visuals.EffectPrograms, resources.MediaFiles,
             (registration, presentation) => options.ConfigureExecution(registration, presentation, page, resources.Content),
             resources.Content.Graph.Nodes.OfType<GalNet.Core.Graph.Group>()
-                .SelectMany(group => group.Entries).Select(entry => entry.Type), options.Presentation, sharedLibVlc, cancellationToken);
+                .SelectMany(group => group.Entries).Select(entry => entry.Type), options.Presentation, sharedLibVlc,
+            audioConfiguration: audioConfiguration, cancellationToken: cancellationToken);
         GameRun? run = null;
         AvaloniaGameRun? adapter = null;
         try
         {
-            var settings = new SettingsContainer();
-            settings.Set(resources.Content.Settings);
-            settings.Set(saveSession.Settings);
-            var runtime = new GameRuntime(textResolver, resources.Content.Graph.RootNodeId, settings, saveSession.Variables);
-            run = new GameRun(resources.Content.Graph, runtime, presentation.View,
-                saveSession.Progress, presentation.Presenters.ChoicePresenter, presentation, presentation.Restorer);
+            var runtime = new GameRuntime(textResolver, resources.Content.Graph.RootNodeId, saveSession.Variables,
+                saveDefaults: resources.Content.Graph.SaveVariables, playerDefaults: resources.Content.Graph.PlayerVariables);
+            var history = new DialogueHistoryDispatcher(presentation.View, presentation.History, saveSession.Progress, resources.Content.Localization.Characters);
+            run = new GameRun(resources.Content.Graph, runtime, history,
+                saveSession.Progress, presentation.Presenters.ChoicePresenter, presentation, presentation.Restorer,
+                playbackOptions: playerSettings.PlaybackOptions);
             adapter = new AvaloniaGameRun(gameplay, run, presentation, playerSettings,
-                updateStateAsync, runCompletedAsync, resetPresentationAsync, onUiAsync, () => saveSession.Variables.FlushPlayerVariablesAsync());
-            adapter._debugBinding = options.AttachDebugRun?.Invoke(run.Engine);
+                updateStateAsync, runCompletedAsync, resetPresentationAsync, onUiAsync, () => saveSession.Variables.FlushPlayerVariablesAsync(), options.AttachRun);
+            adapter._history = history;
+            history.SuppressRecording = () => run.Engine.IsDebugReplaying;
+            history.TextStarting += adapter.OnTextStarting;
+            history.StoryContinuing += adapter.OnStoryContinuing;
             return adapter;
         }
         catch (Exception error)
@@ -96,10 +110,27 @@ public static async Task<AvaloniaGameRun> CreateAsync(
         }
     }
 
-    public GameSnapshot CreateSaveData() => _run.CreateSaveData();
+    public GameSnapshot CreateSaveData()
+    {
+        _history.FlushCompleted();
+        return _presentation.History.Attach(_run.CreateSaveData());
+    }
+    public Task InitializeSaveVariablesAsync(IReadOnlyDictionary<string, object> variables, CancellationToken cancellationToken) =>
+        _run.InitializeSaveVariablesAsync(variables, cancellationToken);
+    public Task ValidateSnapshotAsync(GameSnapshot snapshot, CancellationToken cancellationToken)
+    {
+        snapshot = DialogueHistoryJournal.PrepareSnapshot(snapshot);
+        DialogueHistoryJournal.Validate(snapshot);
+        return _run.ValidateSnapshotAsync(snapshot, cancellationToken);
+    }
 
-    public Task PrepareAsync(GameSnapshot? snapshot, CancellationToken cancellationToken) =>
-        _run.PrepareAsync(snapshot, cancellationToken);
+    public async Task PrepareAsync(GameSnapshot? snapshot, CancellationToken cancellationToken)
+    {
+        if (snapshot is not null) snapshot = DialogueHistoryJournal.PrepareSnapshot(snapshot);
+        _presentation.History.Restore(snapshot);
+        await _run.PrepareAsync(snapshot, cancellationToken);
+        _runBinding = _attachRun?.Invoke(_engine);
+    }
 
     public async Task StartPreparedAsync(CancellationToken cancellationToken)
     {
@@ -111,25 +142,44 @@ public async Task StartPreparedAsync(CancellationToken cancellationToken)
 
     public async Task StopAsync()
     {
-        await _run.StopAsync();
-        _presentation.Presenters.CompleteInitialPresentation();
-        await _stateUpdate;
-        await _flushPlayerVariables();
+        OnStopVoiceReplay();
+        var cleanup = new ResourceCleanup();
+        await cleanup.RunAsync(() => new(_settingsUpdate));
+        await cleanup.RunAsync(() => new(_run.StopAsync()));
+        var binding = _runBinding;
+        _runBinding = null;
+        await cleanup.RunAsync(() => ResourceCleanup.DisposeAsync(binding));
+        cleanup.Run(_presentation.Presenters.CompleteInitialPresentation);
+        await cleanup.RunAsync(() => new(_stateUpdate));
+        await cleanup.RunAsync(() => new(_flushPlayerVariables()));
+        cleanup.ThrowIfFailed();
     }
 
     public async ValueTask DisposeAsync()
     {
         if (_disposed) return;
         _disposed = true;
+        OnStopVoiceReplay();
+        _history.TextStarting -= OnTextStarting;
+        _history.StoryContinuing -= OnStoryContinuing;
+        _gameplay.StopVoiceReplayRequested -= OnStopVoiceReplay;
+        _presentation.VoiceReplay.Changed -= OnVoiceReplayChanged;
+        _presentation.VoiceReplay.Failed -= OnVoiceReplayFailed;
+        _presentation.History.Changed -= OnHistoryChanged;
+        _gameplay.GetHistoryLines = null;
+        _gameplay.PlayVoiceAsync = null;
+        await _onUiAsync(_gameplay.ResetDialogueHistory);
         _playerSettings.SettingsChanged -= OnPlayerSettingsChanged;
         var cleanup = new ResourceCleanup();
         cleanup.Run(() => _gameplay.BindPlayback(null));
         _gameplay.AdvanceRequested -= OnAdvanceRequested;
         _engine.StateChanged -= OnEngineStateChanged;
         cleanup.Run(_presentation.Presenters.CompleteInitialPresentation);
+        await cleanup.RunAsync(() => new(_settingsUpdate));
         await cleanup.RunAsync(() => _run.DisposeAsync());
         await cleanup.RunAsync(() => new(_flushPlayerVariables()));
-        cleanup.Run(() => _debugBinding?.Dispose());
+        await cleanup.RunAsync(() => ResourceCleanup.DisposeAsync(_runBinding));
+        _runBinding = null;
         await cleanup.RunAsync(() => new(_presentation.Restorer.SuspendAsync(CancellationToken.None)));
         await cleanup.RunAsync(() => new(_stateUpdate));
         await cleanup.RunAsync(() => new(_resetPresentationAsync()));
@@ -152,8 +202,54 @@ await _onUiAsync(() =>
         catch (Exception error) { GameLog.Logger.Debug(error, "Opening presentation did not become interactive"); }
     }
 
-    private void OnAdvanceRequested() => _ = AdvanceAsync();
-    private void OnPlayerSettingsChanged(GameSettings settings) => _presentation.AudioModule.ApplyPlayerSettings(settings);
+    private void OnAdvanceRequested() { OnStopVoiceReplay(); _ = AdvanceAsync(); }
+
+    private GalNet.Primitives.Builtins.Audio.AudioPlaybackTicket? _originalVoice;
+    private void OnStopVoiceReplay() => _presentation.VoiceReplay.Stop();
+    private void OnStoryContinuing()
+    {
+        if (_disposed) return;
+        OnStopVoiceReplay();
+        _ = _onUiAsync(() => { if (!_disposed) _gameplay.CloseHistoryCommand.Execute(null); });
+    }
+    private void OnVoiceReplayChanged() => _ = _onUiAsync(() => { if (!_disposed) _gameplay.IsVoiceReplaying = _presentation.VoiceReplay.IsPlaying; });
+    private void OnVoiceReplayFailed(Exception error) => _ = _onUiAsync(() => { if (!_disposed) _gameplay.StatusMessage = error.Message; });
+    private void OnHistoryChanged() => _ = _onUiAsync(() =>
+    {
+        if (!_disposed && _gameplay.IsHistoryOpen) _gameplay.HistoryLines = _presentation.History.Lines;
+    });
+    private Task PlayVoiceAsync(GalNet.Presentation.Abstractions.Application.DialogueVoice voice)
+    {
+        _originalVoice?.Stop();
+        return _presentation.VoiceReplay.PlayAsync(voice);
+    }
+    private void OnTextStarting(GalNet.Presentation.Abstractions.Application.DialogueHistoryLine line, GalNet.Primitives.Builtins.Audio.AudioPlaybackTicket? ticket)
+    {
+        if (_disposed) return;
+        _originalVoice = ticket;
+        _presentation.Presenters.SetReadingContext(line.WasRead);
+        _ = _onUiAsync(() => { if (!_disposed) _gameplay.SetCurrentDialogue(line, ticket?.IsCompleted != false); });
+        if (ticket is not null) _ = CompleteVoiceAsync(line, ticket.Completion);
+    }
+    private async Task CompleteVoiceAsync(GalNet.Presentation.Abstractions.Application.DialogueHistoryLine line, Task completion)
+    {
+        await completion;
+        await _onUiAsync(() => { if (!_disposed) _gameplay.CompleteDialogueVoice(line); });
+    }
+    private void OnPlayerSettingsChanged()
+    {
+        _presentation.AudioModule.ApplyMix(_playerSettings.AudioMix);
+        _gameplay.TextSpeed = _playerSettings.TextSpeed;
+        _settingsUpdate = ApplyPlaybackOptionsAsync(_settingsUpdate);
+    }
+
+    private async Task ApplyPlaybackOptionsAsync(Task previous)
+    {
+        await previous;
+        if (_disposed) return;
+        try { await _engine.UpdatePlaybackOptionsAsync(_playerSettings.PlaybackOptions); }
+        catch (Exception error) { GameLog.Logger.Error(error, "Player playback settings failed"); }
+    }
 
     private async Task AdvanceAsync()
     {
@@ -161,8 +257,11 @@ private async Task AdvanceAsync()
         catch (Exception error) { GameLog.Logger.Error(error, "Player advance failed"); }
     }
 
-    private void OnEngineStateChanged(GameEngineStateChange change) =>
+    private void OnEngineStateChanged(GameEngineStateChange change)
+    {
+        if (change.State != GameEngineState.Running) OnStopVoiceReplay();
         _stateUpdate = ApplyStateAsync(_stateUpdate, change);
+    }
 
     private async Task ApplyStateAsync(Task previous, GameEngineStateChange change)
     {
@@ -179,6 +278,8 @@ private async Task ApplyStateAsync(Task previous, GameEngineStateChange change)
                 _ => null
             };
             GameLog.Logger.Information("Game engine state changed to {State}", change.State);
+            // Restore/Seek temporarily prepares the engine without ending the active host run.
+            if (change.State == GameEngineState.Ready) return;
             if (change.Error is { } error)
             {
                 _presentation.Presenters.FailInitialPresentation(error);
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameSession.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameSession.cs
index 83653c2c..f87cf049 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameSession.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaGameSession.cs
@@ -1,10 +1,13 @@
 using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
 using CommunityToolkit.Mvvm.ComponentModel;
+using GalNet.Avalonia.GameHost.Settings;
 using GalNet.Avalonia.GameView.Page;
 using GalNet.Avalonia.GameView.Presentation;
 using GalNet.Avalonia.GameView.Services;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Runtime;
 using GalNet.GameHost;
 using GalNet.Media.LibVlc;
@@ -14,29 +17,31 @@
 namespace GalNet.Avalonia.GameHost;
 
 /// <summary>Default Avalonia session adapter. Neutral GameSession owns command coordination.</summary>
-public partial class AvaloniaGameSession : ObservableObject, IGameSessionService, IPreparedGameSessionService, IFirstEmptySlotSession, IGameGallerySession, IAsyncDisposable
+public partial class AvaloniaGameSession : ObservableObject, ISavePreviewSource, IGameSessionService, IPreparedGameSessionService, IParameterizedGameSessionService, IFirstEmptySlotSession, ISaveSlotNamingSession, IGameGallerySession, IAsyncDisposable
 {
     private readonly AvaloniaGameHostOptions _options;
     private readonly GamePageViewModel _gameplay;
     private readonly GamePage _page;
-    private readonly AvaloniaPlayerSettingsService _settings;
+    private readonly IAvaloniaPlayerSettings _settings;
     private readonly IPlayerLocalization _localization;
-    private readonly AvaloniaPlayerStartup _startup;
+    private readonly IPlayerStartup _startup;
     private readonly LibVlcRuntime _mediaRuntime;
-    private readonly ObservableCollection<GameSaveSlot> _saveSlots = [];
+    private readonly SaveSlotCollection _saveSlots = [];
     private readonly ReadOnlyObservableCollection<GameSaveSlot> _readOnlySaveSlots;
     private GameResourceScope? _resources;
+    private AvaloniaProjectOptions _projectOptions = new();
     private AvaloniaGameResources? _visualResources;
     private PlayerSession? _saveSession;
     private IGalleryResourceResolver? _galleryResources;
     private readonly GameSession _session;
+    private IDisposable? _playerBinding;
     private readonly SemaphoreSlim _initialization = new(1, 1);
     private bool _disposed;
     private readonly object _disposeGate = new();
     private Task? _disposeTask;
 
-    public AvaloniaGameSession(AvaloniaGameHostOptions options, GamePageViewModel gameplay, GamePage page, AvaloniaPlayerSettingsService settings,
-        IPlayerLocalization localization, AvaloniaPlayerStartup startup, LibVlcRuntime mediaRuntime)
+    public AvaloniaGameSession(AvaloniaGameHostOptions options, GamePageViewModel gameplay, GamePage page, IAvaloniaPlayerSettings settings,
+        IPlayerLocalization localization, IPlayerStartup startup, LibVlcRuntime mediaRuntime)
     {
         _options = options;
         GameTitle = options.GameTitle;
@@ -87,17 +92,20 @@ private async Task<bool> InitializeGameResourcesAsync(string? gameDirectory, str
         {
             var catalogs = _options.CreateContentCatalogs();
             var resources = await GameResourceScope.OpenAsync(gameDirectory,
-                catalogs.Resources, catalogs.Gallery, cancellationToken);
+                catalogs.Resources, catalogs.Gallery, _options.Content, cancellationToken);
+            AvaloniaProjectOptions projectOptions;
             profileDirectory ??= Path.Combine(resources.GameDirectory, ".galnet");
             PlayerSession? saveSession = null;
             AvaloniaGameResources? visuals = null;
             IGalleryResourceResolver? galleryResources = null;
             try
             {
+                projectOptions = _options.SelectProjectOptions(resources.Content.Configuration);
                 _options.ConfigureDecoders(resources.Assets);
                 visuals = await AvaloniaGameResources.CreateAsync(resources.Assets,
                     _options.SelectTexturePreloads, _options.SelectEffectPrograms, cancellationToken);
-                saveSession = await FilePlayerSession.OpenAsync(profileDirectory, resources.Content.Gallery, cancellationToken);
+                saveSession = await FilePlayerSession.OpenAsync(profileDirectory, resources.Content.Gallery,
+                    projectOptions.SaveSlotCount, cancellationToken);
                 galleryResources = await AssetGalleryResourceResolver.CreateAsync(resources.Assets,
                     resources.Content.Gallery, cancellationToken, resources.MediaFiles);
             }
@@ -113,6 +121,7 @@ private async Task<bool> InitializeGameResourcesAsync(string? gameDirectory, str
             }
 
             _resources = resources;
+            _projectOptions = projectOptions;
             _visualResources = visuals;
             _saveSession = saveSession;
             _galleryResources = galleryResources;
@@ -133,11 +142,13 @@ private async Task<bool> InitializeGameResourcesAsync(string? gameDirectory, str
 
             await RefreshSlotsAsync(cancellationToken);
             if (!await _startup.InitializeAsync(saveSession.Variables,
-                    resources.Content.Settings.TargetLocale.Code, selectLanguage, cancellationToken))
+                    projectOptions.DefaultCulture, selectLanguage, cancellationToken))
                 throw new OperationCanceledException("Language selection was cancelled.", cancellationToken);
-            await _settings.AttachAsync(saveSession.Variables, saveSession.Settings, cancellationToken);
+            await _settings.AttachAsync(saveSession.Variables,
+                projectOptions.Audio, _options.ShowTrackAudioControls, cancellationToken);
             await _settings.RestoreDisplayAsync(cancellationToken);
 
+            _playerBinding = _options.AttachPlayer?.Invoke(new(saveSession, resources.Content, profileDirectory));
             IsReady = true;
             StatusMessage = $"Loaded game data: {resources.GameDirectory}";
             _gameplay.StatusMessage = "Ready";
@@ -160,6 +171,15 @@ public async Task StartNewGameAsync(CancellationToken cancellationToken = defaul
         await BeginPreparedGameAsync(cancellationToken);
     }
 
+    public async Task StartNewGameAsync(IReadOnlyDictionary<string, object> initialSaveVariables, CancellationToken cancellationToken = default)
+    {
+        await PrepareNewGameAsync(initialSaveVariables, cancellationToken);
+        await BeginPreparedGameAsync(cancellationToken);
+    }
+
+    public Task PrepareNewGameAsync(IReadOnlyDictionary<string, object> initialSaveVariables, CancellationToken cancellationToken = default) =>
+        _session.PrepareNewAsync(initialSaveVariables, cancellationToken);
+
     public async Task ContinueAsync(CancellationToken cancellationToken = default)
     {
         await PrepareContinueAsync(cancellationToken);
@@ -184,40 +204,71 @@ public Task ClearPlayerStateAsync(CancellationToken cancellationToken = default)
             var saveSession = _saveSession;
             await _settings.FlushAsync();
             if (saveSession is not null) await saveSession.ClearAsync(token);
-            await OnUiAsync(() =>
+            await AvaloniaUiDispatcher.Instance.InvokeAsync(async () =>
             {
-                _gameplay.TextSpeed = saveSession?.Settings.TextSpeed ?? _gameplay.TextSpeed;
+                if (saveSession is not null)
+                    await _settings.AttachAsync(saveSession.Variables,
+                        _projectOptions.Audio,
+                        _options.ShowTrackAudioControls, token);
+                _gameplay.TextSpeed = _settings.TextSpeed;
                 _gameplay.IsNvlMode = false;
                 _gameplay.IsUiHidden = false;
                 _gameplay.StatusMessage = "Player state cleared. Restarting...";
             });
         }, cancellationToken);
 
+    public Func<byte[]?>? CaptureSavePreview { get; set; }
+
+    public bool CanRenameSlots => _saveSession?.CanRenameSlots == true;
+
+    public async Task<string> RenameSlotAsync(int slotIndex, string name, CancellationToken cancellationToken = default)
+    {
+        await _initialization.WaitAsync(cancellationToken);
+        try
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            var player = _saveSession ?? throw new InvalidOperationException("The player session is not initialized.");
+            await player.RenameSlotAsync(slotIndex, name, cancellationToken);
+            var displayName = string.IsNullOrWhiteSpace(name) ? $"{_localization.GetString("SaveSlots.Slot").Value} {slotIndex + 1:D2}" : name.Trim();
+            await OnUiAsync(() =>
+            {
+                var index = _saveSlots.ToList().FindIndex(slot => slot.SlotIndex == slotIndex);
+                if (index >= 0) _saveSlots[index] = _saveSlots[index] with { Description = displayName };
+            });
+            return displayName;
+        }
+        finally { _initialization.Release(); }
+    }
+
     public async Task SaveAsync(int slotIndex, CancellationToken cancellationToken = default)
     {
+        var preview = CaptureSavePreview?.Invoke();
         await _session.WithSnapshotAsync(async (snapshot, token) =>
         {
-            await _saveSession!.SaveAsync(slotIndex, snapshot, token);
-            await RefreshSlotsAsync(token);
+            await _saveSession!.SaveAsync(slotIndex, snapshot, preview, token);
+            await RefreshSlotAsync(slotIndex, token);
             await OnUiAsync(() => _gameplay.StatusMessage = $"Saved to slot {slotIndex}.");
             return true;
         }, cancellationToken);
     }
 
-    public Task<int?> SaveFirstEmptyAsync(CancellationToken cancellationToken = default) =>
-        _session.WithSnapshotAsync(async (snapshot, token) =>
+    public Task<int?> SaveFirstEmptyAsync(CancellationToken cancellationToken = default)
+    {
+        var preview = CaptureSavePreview?.Invoke();
+        return _session.WithSnapshotAsync(async (snapshot, token) =>
         {
             if (!IsPlaying || _saveSession is null)
                 throw new InvalidOperationException("No active game is available to save.");
             await _settings.FlushAsync();
-            var slot = await _saveSession.SaveFirstEmptyAsync(snapshot, token);
+            var slot = await _saveSession.SaveFirstEmptyAsync(snapshot, preview, token);
             if (slot is not null)
             {
-                await RefreshSlotsAsync(token);
+                await RefreshSlotAsync(slot.Value, token);
                 await OnUiAsync(() => _gameplay.StatusMessage = $"Saved to slot {slot.Value + 1}.");
             }
             return slot;
         }, cancellationToken);
+    }
 
     public async Task LoadAsync(int slotIndex, CancellationToken cancellationToken = default)
     {
@@ -245,6 +296,8 @@ private async Task DisposeCoreAsync()
             _gameplay.InteractionObserved -= OnInteractionObserved;
             await cleanup.RunAsync(() => _session.DisposeAsync());
             await cleanup.RunAsync(() => new(_settings.FlushAsync()));
+            await cleanup.RunAsync(() => ResourceCleanup.DisposeAsync(_playerBinding));
+            _playerBinding = null;
             var saves = _saveSession;
             _saveSession = null;
             GalleryResources = null;
@@ -286,6 +339,7 @@ private async Task<IGameRun> CreateRunAsync(CancellationToken cancellationToken)
             _settings,
             _localization,
             _options,
+            _projectOptions.Audio,
             _mediaRuntime.Instance,
             UpdateRunnerStateAsync,
             () => RefreshSlotsAsync(CancellationToken.None),
@@ -298,22 +352,62 @@ protected async Task RefreshSlotsAsync(CancellationToken cancellationToken)
     {
         if (_saveSession is null) return;
         var slots = await _saveSession.ListSlotsAsync(cancellationToken);
+        var previews = new Dictionary<int, byte[]>();
+        foreach (var slot in slots)
+        {
+            if (slot.PreviewImage is not { } path) continue;
+            try { previews[slot.SlotIndex] = await File.ReadAllBytesAsync(path, cancellationToken); }
+            catch (IOException) { }
+            catch (UnauthorizedAccessException) { }
+        }
         await OnUiAsync(() =>
         {
-            _saveSlots.Clear();
-            foreach (var slot in slots)
-            {
-                _saveSlots.Add(new GameSaveSlot(
-                    slot.SlotIndex,
-                    slot.Timestamp,
-                    slot.IsCorrupt ? "Corrupt save" : slot.Timestamp == default ? "Empty" : "Saved game",
-                    slot.Timestamp == default && !slot.IsCorrupt,
-                    slot.IsCorrupt));
-            }
+            _saveSlots.ReplaceAll(slots.Select(slot => CreateSlot(slot, previews.GetValueOrDefault(slot.SlotIndex))));
             CanContinue = _saveSlots.Any(slot => !slot.IsEmpty && !slot.IsCorrupt);
         });
     }
 
+    private GameSaveSlot CreateSlot(GalNet.Runtime.Persistence.SaveSlotInfo slot, byte[]? preview) => new(
+        slot.SlotIndex, slot.Timestamp,
+        slot.IsCorrupt ? _localization.GetString("SaveSlots.Corrupt").Value
+            : slot.Timestamp == default ? _localization.GetString("SaveSlots.Empty").Value
+            : string.IsNullOrWhiteSpace(slot.Description) ? $"{_localization.GetString("SaveSlots.Slot").Value} {slot.SlotIndex + 1:D2}" : slot.Description,
+        slot.Timestamp == default && !slot.IsCorrupt, slot.IsCorrupt)
+    { PreviewImage = preview };
+
+    private async Task RefreshSlotAsync(int slotIndex, CancellationToken cancellationToken)
+    {
+        var slot = await _saveSession!.GetSlotInfoAsync(slotIndex, cancellationToken);
+        if (slot is null) return;
+        byte[]? preview = null;
+        if (slot.PreviewImage is { } path)
+        {
+            try { preview = await File.ReadAllBytesAsync(path, cancellationToken); }
+            catch (IOException) { }
+            catch (UnauthorizedAccessException) { }
+        }
+        await OnUiAsync(() =>
+        {
+            var index = _saveSlots.ToList().FindIndex(item => item.SlotIndex == slotIndex);
+            if (index >= 0) _saveSlots[index] = CreateSlot(slot, preview);
+            else _saveSlots.Add(CreateSlot(slot, preview));
+            CanContinue = _saveSlots.Any(item => !item.IsEmpty && !item.IsCorrupt);
+        });
+    }
+
+    private sealed class SaveSlotCollection : ObservableCollection<GameSaveSlot>
+    {
+        public void ReplaceAll(IEnumerable<GameSaveSlot> slots)
+        {
+            var next = slots.ToArray();
+            Items.Clear();
+            foreach (var slot in next) Items.Add(slot);
+            OnPropertyChanged(new PropertyChangedEventArgs(nameof(Count)));
+            OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+        }
+    }
+
     /// <summary>Runs a project-specific save action under the same command gate as normal saves and run replacement.</summary>
     protected Task<T> WithSnapshotAsync<T>(Func<GameSnapshot, PlayerSession, CancellationToken, Task<T>> action,
         CancellationToken cancellationToken = default) =>
diff --git a/src/Samples/GalNet.Sample.Avalonia/Services/SampleLocalizationService.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerLocalization.cs
similarity index 51%
rename from src/Samples/GalNet.Sample.Avalonia/Services/SampleLocalizationService.cs
rename to src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerLocalization.cs
index fed6e74e..1e19af2a 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Services/SampleLocalizationService.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerLocalization.cs
@@ -1,19 +1,19 @@
+using System.Globalization;
 using DynamicLocalization.Core;
 using DynamicLocalization.Core.Providers;
 using GalNet.Core.Services;
-using GalNet.Runtime.Content;
-using GalNet.Sample.Localization;
+using GalNet.GameHost.Content;
+using GalNet.Runtime.I18n;
 
-namespace GalNet.Sample.Avalonia.Services;
+namespace GalNet.Avalonia.GameHost;
 
-/// <summary>Owns the official demo's observable LocalizedString values for the Sample lifetime.</summary>
-public sealed class SampleLocalizationService(CultureService cultureService,
-    IEnumerable<ILocalizationProvider>? bootstrapProviders = null) : IDisposable, GalNet.Avalonia.GameHost.IPlayerLocalization
+/// <summary>Owns observable localized strings and the replaceable game text provider.</summary>
+public sealed class AvaloniaPlayerLocalization(CultureService cultureService,
+    IEnumerable<ILocalizationProvider>? bootstrapProviders = null) : IDisposable, IPlayerLocalization
 {
     private readonly Dictionary<string, LocalizedString> _strings = new(StringComparer.Ordinal);
-    private GameLocalizationProvider? _gameProvider;
+    private TextProvider? _gameProvider;
     private readonly ILocalizationProvider[] _bootstrapProviders = bootstrapProviders?.ToArray() ?? [];
-    public static SampleLocalizationService? Current { get; private set; }
 
     public CultureService CultureService { get; } = cultureService;
 
@@ -21,7 +21,10 @@ public sealed class SampleLocalizationService(CultureService cultureService,
 
     public void AttachGame(GameContent content, IEnumerable<GameLocalizationSource>? additionalSources = null)
     {
-        var provider = new GameLocalizationProvider(content, () => CultureService.CurrentCulture, _bootstrapProviders, additionalSources);
+        var sources = _bootstrapProviders.SelectMany(provider => provider.GetAvailableCultures().Select(culture =>
+            new LocalizedTextSource(culture, key => provider.TryGetString(key, culture, out var value) ? value : null)));
+        var provider = new TextProvider(content.Localization.CreateResolver(
+            () => CultureService.CurrentCulture, sources, additionalSources));
         foreach (var bootstrap in _bootstrapProviders) CultureService.UnregisterProvider(bootstrap.Name);
         if (_gameProvider is not null) CultureService.UnregisterProvider(_gameProvider.Name);
         _gameProvider = provider;
@@ -48,18 +51,21 @@ public void Dispose()
         _gameProvider = null;
         foreach (var text in _strings.Values) text.Dispose();
         _strings.Clear();
-        if (ReferenceEquals(Current, this))
-        {
-            Current = null;
+        if (GalNet.Avalonia.GameView.MarkupExtensions.PlayerTextExtension.Resolve?.Target == this)
             GalNet.Avalonia.GameView.MarkupExtensions.PlayerTextExtension.Resolve = null;
-        }
     }
 
-    public static SampleLocalizationService Create(CultureService cultureService,
-        IEnumerable<ILocalizationProvider>? bootstrapProviders = null)
+    private sealed class TextProvider(GameTextResolver resolver) : ILocalizationProvider
     {
-        var service = new SampleLocalizationService(cultureService, bootstrapProviders);
-        Current = service;
-        return service;
+        public string Name => "GalNet.Game";
+        public IEnumerable<CultureInfo> GetAvailableCultures() => resolver.AvailableCultures;
+        public string GetString(string key, CultureInfo culture) => resolver.GetString(key, culture);
+        public bool TryGetString(string key, CultureInfo culture, out string? value) => resolver.TryGetString(key, culture, out value);
+        public string Resolve(string key) => resolver.Resolve(key);
+        public Task ReloadAsync(CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return Task.CompletedTask;
+        }
     }
 }
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerSettingsService.Audio.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerSettingsService.Audio.cs
new file mode 100644
index 00000000..a4fc3e8f
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerSettingsService.Audio.cs
@@ -0,0 +1,37 @@
+using System.Collections.ObjectModel;
+using GalNet.Avalonia.GameView.Settings;
+using GalNet.Contracts.Builtins.Audio;
+
+namespace GalNet.Avalonia.GameHost;
+
+public sealed partial class AvaloniaPlayerSettingsService
+{
+    private readonly ObservableCollection<SettingCategory> _categories;
+    private readonly IReadOnlyList<SettingItem> _baseAudioItems;
+    private readonly int _audioRestoreStart;
+    private static readonly AudioMixLevel NeutralMix = new();
+
+    private void ConfigureAudio(AudioConfiguration configuration, bool showTracks)
+    {
+        _restoreValues.RemoveRange(_audioRestoreStart, _restoreValues.Count - _audioRestoreStart);
+        var items = _baseAudioItems.ToList();
+        foreach (var group in configuration.Buses) AddLevel(false, group.Id, group.Name, true);
+        foreach (var track in configuration.Tracks) AddLevel(true, track.Id, track.Name, showTracks);
+        var index = _categories.IndexOf(_categories.Single(category => category.Id == "audio"));
+        _categories[index] = new SettingCategory("audio", "Settings.Audio", items, _localization.GetString("Settings.Audio"));
+        _coordinator.Attach(Categories);
+
+        void AddLevel(bool isTrack, string id, string name, bool visible)
+        {
+            var prefix = $"audio.{(isTrack ? "track" : "group")}.{Uri.EscapeDataString(id)}";
+            var labelKey = string.IsNullOrWhiteSpace(name) ? id : name;
+            var mute = Boolean(prefix + ".muted", "Settings.Muted", false,
+                () => Level().Muted, value => Levels()[id] = Level() with { Muted = value });
+            var gain = Number(prefix + ".gain", labelKey, 1, 1, .01,
+                () => Level().Gain, value => Levels()[id] = Level() with { Gain = (float)value }, NumericEditorKind.Slider, livePreview: true, inlineToggle: mute);
+            if (visible) { items.Add(gain); items.Add(mute); }
+            Dictionary<string, AudioMixLevel> Levels() => isTrack ? RuntimeSettings.Tracks : RuntimeSettings.Buses;
+            AudioMixLevel Level() => Levels().GetValueOrDefault(id) ?? NeutralMix;
+        }
+    }
+}
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerSettingsService.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerSettingsService.cs
index 67b406af..4093ab2c 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerSettingsService.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerSettingsService.cs
@@ -1,11 +1,11 @@
 using Avalonia.Threading;
 using DynamicLocalization.Core;
+using GalNet.Avalonia.GameHost.Settings;
 using GalNet.Avalonia.GameView.Input;
 using GalNet.Avalonia.GameView.Presentation;
 using GalNet.Avalonia.GameView.Services;
 using GalNet.Avalonia.GameView.Settings;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Settings;
 using GalNet.Core.Variable;
 using GalNet.Game.Controls.Forms;
 using GalNet.GameHost;
@@ -15,7 +15,7 @@
 namespace GalNet.Avalonia.GameHost;
 
 /// <summary>Applies preferences and persists them through the session's player variables.</summary>
-public sealed class AvaloniaPlayerSettingsService : IPlayerSettingsService, IDisposable
+public sealed partial class AvaloniaPlayerSettingsService : IAvaloniaPlayerSettings, IDisposable
 {
     public const string LocaleVariable = PlayerPreferences.LocaleVariable;
     public const string TextSpeedVariable = PlayerPreferences.TextSpeedVariable;
@@ -36,7 +36,14 @@ public sealed class AvaloniaPlayerSettingsService : IPlayerSettingsService, IDis
     private long _liveSaveRevision;
     private readonly List<Action<IReadOnlyDictionary<string, GalNet.Core.Variable.Variable>>> _restoreValues = [];
     public GameSettings RuntimeSettings { get; private set; } = new();
-    public event Action<GameSettings>? SettingsChanged;
+    public GalNet.Core.Execution.PlaybackOptions PlaybackOptions => RuntimeSettings.ToPlaybackOptions();
+    public GalNet.Contracts.Builtins.Audio.AudioMixOptions AudioMix => RuntimeSettings.ToAudioMixOptions();
+    public double TextSpeed => RuntimeSettings.TextSpeed;
+    public event Action? SettingsChanged;
+
+    Task IAvaloniaPlayerSettings.AttachAsync(PlayerVariableService variables,
+        GalNet.Contracts.Builtins.Audio.AudioConfiguration audio, bool showTracks, CancellationToken cancellationToken) =>
+        AttachAsync(variables, new GameSettings(), audio, showTracks, cancellationToken);
     public PlayerInputSettings Input { get; } = new();
     private readonly CustomSetting<PlayerInputConfiguration> _inputSetting;
     private readonly AvaloniaGamepadInput _gamepadInput;
@@ -47,6 +54,7 @@ public AvaloniaPlayerSettingsService(IPlayerLocalization localization, GamePageV
         _localization = localization;
         _gameplay = gameplay;
         gameplay.Input = Input;
+        Input.OpenHistoryAsync = () => { gameplay.OpenHistoryCommand.Execute(null); return Task.CompletedTask; };
         _gamepadInput = new AvaloniaGamepadInput(Input);
         _inputSetting = new CustomSetting<PlayerInputConfiguration>("inputBindings", "Settings.Operation", PlayerInputSettings.Defaults(),
             () => Input.Configuration, (value, _) =>
@@ -84,13 +92,29 @@ public AvaloniaPlayerSettingsService(IPlayerLocalization localization, GamePageV
                 await _displayMode.TrySetValueAsync(_display.Mode == PlayerDisplayMode.Window
                     ? PlayerDisplayMode.BorderlessFullscreen : PlayerDisplayMode.Window);
         };
-        Categories = Array.AsReadOnly(new[]
+        var masterMute = Boolean("masterMuted", "Settings.MasterMuted", false, () => RuntimeSettings.MasterMuted, value => RuntimeSettings.MasterMuted = value);
+        var readColorEnabled = Boolean("enableReadTextColor", "Settings.EnableReadTextColor", false,
+            () => RuntimeSettings.EnableReadTextColor, value => { RuntimeSettings.EnableReadTextColor = value; ApplyReadTextColor(); });
+        const string readColorVariable = "player.galnet.settings.readTextColor";
+        var readColor = new CustomSetting<string>("readTextColor", "Settings.ReadTextColor", "#A8B8C8",
+            () => RuntimeSettings.ReadTextColor,
+            (value, token) => ApplyRuntimeSettingAsync(readColorVariable, () => { RuntimeSettings.ReadTextColor = value; ApplyReadTextColor(); }, value, token),
+            context => ReadTextColorEditor.Create(context.Setting, readColorEnabled, _localization), _localization.GetString("Settings.ReadTextColor"))
+        { InlineToggle = readColorEnabled, Validator = value => global::Avalonia.Media.Color.TryParse(value, out _) ? null : "Settings.InvalidColor" };
+        _restoreValues.Add(stored =>
+        {
+            RuntimeSettings.ReadTextColor = stored.TryGetValue(readColorVariable, out var color) && color.Type == VariableType.String &&
+                global::Avalonia.Media.Color.TryParse(color.AsString(), out _) ? color.AsString() : "#A8B8C8";
+            ApplyReadTextColor();
+        });
+        _categories = new System.Collections.ObjectModel.ObservableCollection<SettingCategory>(new[]
         {
             new SettingCategory("game", "Settings.Game",
             [
                 _language,
                 Number("textSpeed", "Settings.TextSpeed", 30, 120, 1, () => RuntimeSettings.TextSpeed,
                     value => { RuntimeSettings.TextSpeed = (float)value; gameplay.TextSpeed = value; }, NumericEditorKind.Slider),
+                readColor, readColorEnabled,
                 Boolean("quickReadOnly", "Settings.QuickReadOnly", true, () => RuntimeSettings.QuickReadOnly, value => RuntimeSettings.QuickReadOnly = value),
                 Milliseconds("quickInterval", "Settings.QuickInterval", 50, 5000, 10, () => RuntimeSettings.QuickAdvanceIntervalMilliseconds, value => RuntimeSettings.QuickAdvanceIntervalMilliseconds = value),
                 Milliseconds("autoInterval", "Settings.AutoInterval", 2000, 30000, 100, () => RuntimeSettings.AutoAdvanceIntervalMilliseconds, value => RuntimeSettings.AutoAdvanceIntervalMilliseconds = value)
@@ -99,23 +123,19 @@ await _displayMode.TrySetValueAsync(_display.Mode == PlayerDisplayMode.Window
             new SettingCategory("graphics", "Settings.Graphics", [_displayMode, _windowSize], localization.GetString("Settings.Graphics")),
             new SettingCategory("audio", "Settings.Audio",
             [
-                Number("masterVolume", "Settings.MasterVolume", 1, 1, .01, () => RuntimeSettings.MasterVolume, value => RuntimeSettings.MasterVolume = (float)value, NumericEditorKind.Slider, livePreview: true),
-                Boolean("masterMuted", "Settings.MasterMuted", false, () => RuntimeSettings.MasterMuted, value => RuntimeSettings.MasterMuted = value),
-                Number("bgmVolume", "Settings.BgmVolume", 1, 1, .01, () => RuntimeSettings.BgmVolume, value => RuntimeSettings.BgmVolume = (float)value, NumericEditorKind.Slider, livePreview: true),
-                Boolean("bgmMuted", "Settings.BgmMuted", false, () => RuntimeSettings.BgmMuted, value => RuntimeSettings.BgmMuted = value),
-                Number("sfxVolume", "Settings.SfxVolume", 1, 1, .01, () => RuntimeSettings.SfxVolume, value => RuntimeSettings.SfxVolume = (float)value, NumericEditorKind.Slider, livePreview: true),
-                Boolean("sfxMuted", "Settings.SfxMuted", false, () => RuntimeSettings.SfxMuted, value => RuntimeSettings.SfxMuted = value),
-                Number("voiceVolume", "Settings.VoiceVolume", 1, 1, .01, () => RuntimeSettings.VoiceVolume, value => RuntimeSettings.VoiceVolume = (float)value, NumericEditorKind.Slider, livePreview: true),
-                Boolean("voiceMuted", "Settings.VoiceMuted", false, () => RuntimeSettings.VoiceMuted, value => RuntimeSettings.VoiceMuted = value)
+                Number("masterVolume", "Settings.MasterVolume", 1, 1, .01, () => RuntimeSettings.MasterVolume, value => RuntimeSettings.MasterVolume = (float)value, NumericEditorKind.Slider, livePreview: true, inlineToggle: masterMute),
+                masterMute
             ], localization.GetString("Settings.Audio"))
         });
         _coordinator = new SettingsCoordinator { SaveAsync = token => _variables?.FlushPlayerVariablesAsync(token) ?? Task.CompletedTask };
         _coordinator.Attach(Categories);
+        _baseAudioItems = Categories.Last().Items;
+        _audioRestoreStart = _restoreValues.Count;
         localization.CultureService.CultureChanged += OnCultureChanged;
         _display.Changed += OnDisplayChanged;
     }
 
-    public IReadOnlyList<SettingCategory> Categories { get; }
+    public IReadOnlyList<SettingCategory> Categories => _categories;
     public EditorRegistry Editors { get; }
     public Task FlushAsync() => AvaloniaUiDispatcher.Instance.InvokeAsync(FlushOnUiAsync);
 
@@ -162,14 +182,18 @@ private void OnDisplayChanged()
         _coordinator.RefreshAvailability();
     }
 
-    public async Task AttachAsync(PlayerVariableService variables, GameSettings runtimeSettings, CancellationToken cancellationToken = default)
+    public async Task AttachAsync(PlayerVariableService variables, GameSettings runtimeSettings,
+        GalNet.Contracts.Builtins.Audio.AudioConfiguration? audioConfiguration = null, bool showTrackControls = false,
+        CancellationToken cancellationToken = default)
     {
+        await FlushAsync();
         _variables = variables;
         _preferences = new PlayerPreferences(variables);
         RuntimeSettings = runtimeSettings;
         _restoring = true;
         try
         {
+            ConfigureAudio(audioConfiguration ?? GalNet.Contracts.Builtins.Audio.AudioConfiguration.Empty, showTrackControls);
             var stored = variables.GetSnapshot(VariableScope.Player);
             Input.Restore(stored.TryGetValue("player.galnet.input.bindings", out var bindings) && bindings.Type == VariableType.String ? bindings.AsString() : null);
             var languages = Languages();
@@ -188,7 +212,7 @@ public async Task AttachAsync(PlayerVariableService variables, GameSettings runt
     }
 
     private DoubleSetting Number(string id, string key, double defaultValue, double maximum, double step,
-        Func<double> read, Action<double> write, NumericEditorKind editor = NumericEditorKind.NumericUpDown, bool livePreview = false)
+        Func<double> read, Action<double> write, NumericEditorKind editor = NumericEditorKind.NumericUpDown, bool livePreview = false, BoolSetting? inlineToggle = null)
     {
         var variable = "player.galnet.settings." + id;
         _restoreValues.Add(_ => write(_preferences!.Number(variable, defaultValue, maximum)));
@@ -196,6 +220,7 @@ private DoubleSetting Number(string id, string key, double defaultValue, double
             (value, token) => ApplyRuntimeSettingAsync(variable, () => write(value), (float)value, token), _localization.GetString(key))
         {
             EditorKind = editor,
+            InlineToggle = inlineToggle,
             LivePreview = livePreview ? value => PreviewRuntimeSetting(variable, () => write(value), (float)value) : null
         };
     }
@@ -223,7 +248,7 @@ private void FlushAudioPreview()
         _audioPreviewTimer.Stop();
         if (!_audioPreviewPending) return;
         _audioPreviewPending = false;
-        try { SettingsChanged?.Invoke(RuntimeSettings); }
+        try { SettingsChanged?.Invoke(); }
         catch (Exception exception) { GameLog.Logger.Error(exception, "Live audio settings preview failed"); }
     }
 
@@ -262,11 +287,15 @@ private BoolSetting Boolean(string id, string key, bool defaultValue, Func<bool>
             (value, token) => ApplyRuntimeSettingAsync(variable, () => write(value), value, token), _localization.GetString(key));
     }
 
+    private void ApplyReadTextColor() => _gameplay.ReadTextBrush = RuntimeSettings.EnableReadTextColor &&
+        global::Avalonia.Media.Color.TryParse(RuntimeSettings.ReadTextColor, out var color)
+            ? new global::Avalonia.Media.SolidColorBrush(color) : null;
+
     private async Task ApplyRuntimeSettingAsync(string variable, Action apply, object storedValue, CancellationToken cancellationToken)
     {
         apply();
-        SettingsChanged?.Invoke(RuntimeSettings);
-        await _gameplay.RefreshPlaybackSettingsAsync(cancellationToken);
+        SettingsChanged?.Invoke();
+        await _gameplay.UpdatePlaybackOptionsAsync(RuntimeSettings.ToPlaybackOptions(), cancellationToken);
         Store(variable, storedValue);
     }
 
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerStartup.cs b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerStartup.cs
index d75da665..1b7de011 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerStartup.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/AvaloniaPlayerStartup.cs
@@ -4,7 +4,7 @@
 namespace GalNet.Avalonia.GameHost;
 
 /// <summary>Connects the default player localization adapter to neutral onboarding.</summary>
-public sealed class AvaloniaPlayerStartup(IPlayerLocalization localization)
+public sealed class AvaloniaPlayerStartup(IPlayerLocalization localization) : IPlayerStartup
 {
     public const string LaunchCountVariable = PlayerStartup.LaunchCountVariable;
     public async Task<bool> InitializeAsync(PlayerVariableService variables, string defaultCulture,
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/DialogueHistoryDispatcher.cs b/src/Presentation/GalNet.Avalonia.GameHost/DialogueHistoryDispatcher.cs
new file mode 100644
index 00000000..77b4fcbe
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.GameHost/DialogueHistoryDispatcher.cs
@@ -0,0 +1,134 @@
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Entry;
+using GalNet.Core.Execution;
+using GalNet.Core.I18n;
+using GalNet.Core.Parameters;
+using GalNet.Core.Primitives;
+using GalNet.Core.Runtime;
+using GalNet.GameHost;
+using GalNet.Presentation.Abstractions.Application;
+using GalNet.Primitives.Builtins;
+using GalNet.Primitives.Builtins.Audio;
+using GalNet.Runtime.Progress;
+
+namespace GalNet.Avalonia.GameHost;
+
+/// <summary>Host observation of actual built-in dialogue invocations; borrows the underlying dispatcher.</summary>
+public sealed class DialogueHistoryDispatcher(IPrimitiveDispatcher inner, DialogueHistoryJournal journal,
+    IGameProgressService progress, CharacterCatalog characters) : IPrimitiveDispatcher
+{
+    private readonly object _gate = new();
+    private GameState? _state;
+    private PendingText? _pending;
+    private CandidateVoice? _voice;
+    public Func<bool> SuppressRecording { get; set; } = () => false;
+    public event Action<DialogueHistoryLine, AudioPlaybackTicket?>? TextStarting;
+    public event Action? StoryContinuing;
+    public StateCatalog StateCatalog => inner.StateCatalog;
+    public bool RequiresStateRestore => inner.RequiresStateRestore;
+    public IReadOnlyCollection<EntryDefinition> Primitives => inner.Primitives;
+    public bool TryGetEntry(string primitiveType, out EntryDefinition? entry) => inner.TryGetEntry(primitiveType, out entry);
+    public bool CanExecute(string primitiveType) => inner.CanExecute(primitiveType);
+    public void ValidateState(IGameContext runtime, GameState state) => inner.ValidateState(runtime, state);
+    public void OnInstructionSkipped(PrimitiveEntry entry, IGameContext runtime)
+    {
+        lock (_gate) _voice = null;
+        inner.OnInstructionSkipped(entry, runtime);
+    }
+    public void OnPlaybackContinuing()
+    {
+        StoryContinuing?.Invoke();
+        inner.OnPlaybackContinuing();
+    }
+    public void OnCheckpointCreating(IGameContext runtime)
+    {
+        FlushCompleted();
+        inner.OnCheckpointCreating(runtime);
+    }
+
+    public PrimitiveInstance Dispatch(PrimitiveEntry entry, IGameContext runtime, CancellationToken cancellationToken,
+        PrimitiveInvocationMode mode = PrimitiveInvocationMode.Normal)
+    {
+        lock (_gate)
+        {
+            runtime.State.Configure(StateCatalog);
+            if (!ReferenceEquals(_state, runtime.State))
+            {
+                _state = runtime.State; _pending = null; _voice = null;
+                journal.Rewind(_state);
+            }
+            FlushCompleted();
+            StoryContinuing?.Invoke();
+            DialogueHistoryLine? line = null;
+            AudioPlaybackTicket? original = null;
+            var sourceId = SourceId(entry.StableId);
+            inner.TryGetEntry(entry.Type, out var entryDefinition);
+            var isText = entry.Type == BuiltinEntryIds.Text && entryDefinition?.FieldDataType == typeof(DialogueTextOptions) ||
+                entry.Type == BuiltinEntryIds.AppendNvl && entryDefinition?.FieldDataType == typeof(NvlAppendOptions);
+            if (isText)
+            {
+                var arguments = entry.Arguments;
+                var text = arguments.TryGetProperty("content", out var content) ? runtime.TextResolver.Resolve(content.GetString() ?? "") : "";
+                var speaker = "";
+                if (entry.Type == BuiltinEntryIds.Text && arguments.TryGetProperty("speaker", out var speakerValue) &&
+                    speakerValue.GetString() is { } characterId && !string.IsNullOrWhiteSpace(characterId))
+                    speaker = runtime.TextResolver.Resolve(characters.GetRequired(characterId).DisplayNameKey);
+                var voice = _voice is { } candidate && candidate.GroupId == runtime.CurrentNodeId && candidate.SourceId == sourceId &&
+                    candidate.TargetId == entry.StableId && sourceId is not null ? candidate : null;
+                line = new(runtime.CurrentNodeId, entry.StableId, speaker, text, progress.IsRead(runtime.CurrentNodeId, entry.StableId), voice?.Voice);
+                original = voice?.Ticket;
+                _voice = null;
+                TextStarting?.Invoke(line, original);
+            }
+            else _voice = null;
+
+            var instance = inner.Dispatch(entry, runtime, cancellationToken, mode);
+            if (entry.Type == BuiltinEntryIds.PlayAudio && sourceId is not null && entryDefinition?.FieldDataType == typeof(AudioPlayOptions))
+            {
+                var (_, options) = PrimitiveArgumentHelper.NormalizeFields<AudioPlayOptions>(entryDefinition.DynamicParameters, entry.Arguments);
+                var primitiveIndex = int.Parse(entry.StableId.AsSpan(entry.StableId.LastIndexOf('#') + 1), System.Globalization.CultureInfo.InvariantCulture);
+                var target = sourceId + "#" + (primitiveIndex + 1).ToString(System.Globalization.CultureInfo.InvariantCulture);
+                if (!string.IsNullOrWhiteSpace(options.Asset) && !string.IsNullOrWhiteSpace(options.TrackId))
+                    _voice = new(runtime.CurrentNodeId, sourceId, target, new(options.Asset, options.TrackId, options.Gain),
+                        (instance as AudioPlaybackPrimitiveInstance)?.Ticket);
+            }
+            if (line is not null && !SuppressRecording())
+            {
+                var pending = new PendingText(runtime.State, line, instance, mode == PrimitiveInvocationMode.CatchUp, cancellationToken);
+                _pending = pending;
+                FlushCompleted();
+                _ = ObserveAsync(pending);
+            }
+            return instance;
+        }
+    }
+
+    public void FlushCompleted()
+    {
+        lock (_gate)
+        {
+            if (_pending is not { } pending || pending.Token.IsCancellationRequested || !ReferenceEquals(pending.State, _state)) return;
+            if (!pending.CatchUp && pending.Instance is not IAdvanceWaitInstance { IsTextPresented: true }) return;
+            _pending = null;
+            journal.Append(pending.State, pending.Line);
+        }
+    }
+
+    private async Task ObserveAsync(PendingText pending)
+    {
+        try { await pending.Instance.PresentationCompletion.ConfigureAwait(false); }
+        catch (Exception) { return; }
+        lock (_gate) { if (ReferenceEquals(_pending, pending)) FlushCompleted(); }
+    }
+
+    private static string? SourceId(string id)
+    {
+        var separator = id.LastIndexOf('#');
+        return separator > 0 && int.TryParse(id.AsSpan(separator + 1), out var index) && index > 0 ? id[..separator] : null;
+    }
+
+    public void Dispose() { lock (_gate) { _pending = null; _voice = null; } }
+    public ValueTask DisposeAsync() { Dispose(); return ValueTask.CompletedTask; }
+    private sealed record CandidateVoice(string GroupId, string SourceId, string TargetId, DialogueVoice Voice, AudioPlaybackTicket? Ticket);
+    private sealed record PendingText(GameState State, DialogueHistoryLine Line, PrimitiveInstance Instance, bool CatchUp, CancellationToken Token);
+}
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/GalNet.Avalonia.GameHost.csproj b/src/Presentation/GalNet.Avalonia.GameHost/GalNet.Avalonia.GameHost.csproj
index 46cb8e41..010dbd43 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/GalNet.Avalonia.GameHost.csproj
+++ b/src/Presentation/GalNet.Avalonia.GameHost/GalNet.Avalonia.GameHost.csproj
@@ -3,7 +3,9 @@
   <ItemGroup>
     <ProjectReference Include="../../Infrastructure/GalNet.Storage.FileSystem/GalNet.Storage.FileSystem.csproj" />
     <ProjectReference Include="../../Infrastructure/GalNet.Media.LibVlc/GalNet.Media.LibVlc.csproj" />
+    <ProjectReference Include="../../Infrastructure/GalNet.Media.Miniaudio/GalNet.Media.Miniaudio.csproj" />
     <PackageReference Include="DynamicLocalization.Core" />
+    <PackageReference Include="Avalonia.Controls.ColorPicker" />
     <ProjectReference Include="../../Shared/GalNet.GameHost/GalNet.GameHost.csproj" />
     <ProjectReference Include="../GalNet.Avalonia.Controls/GalNet.Avalonia.Controls.csproj" />
     <ProjectReference Include="../GalNet.Avalonia.GameView/GalNet.Avalonia.GameView.csproj" />
@@ -14,4 +16,5 @@
     <ProjectReference Include="../../Shared/GalNet.Core/GalNet.Core.csproj" />
     <ProjectReference Include="../GalNet.Avalonia.Rendering/GalNet.Avalonia.Rendering.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/IAvaloniaPlayerSettings.cs b/src/Presentation/GalNet.Avalonia.GameHost/IAvaloniaPlayerSettings.cs
new file mode 100644
index 00000000..cecbebb1
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.GameHost/IAvaloniaPlayerSettings.cs
@@ -0,0 +1,27 @@
+using GalNet.Avalonia.GameView.Services;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Execution;
+using GalNet.Runtime.Variables;
+
+namespace GalNet.Avalonia.GameHost;
+
+/// <summary>Projects own their preference model and UI; the default host consumes these module inputs.</summary>
+public interface IAvaloniaPlayerSettings : IPlayerSettingsService
+{
+    PlaybackOptions PlaybackOptions { get; }
+    AudioMixOptions AudioMix { get; }
+    double TextSpeed { get; }
+    event Action? SettingsChanged;
+    Task AttachAsync(PlayerVariableService variables, AudioConfiguration audio, bool showTracks,
+        CancellationToken cancellationToken = default);
+    Task FlushAsync();
+    void BindWindow(global::Avalonia.Controls.Window? window) { }
+    Task RestoreDisplayAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
+}
+
+/// <summary>Optional project onboarding, independent of the default language-selection implementation.</summary>
+public interface IPlayerStartup
+{
+    Task<bool> InitializeAsync(PlayerVariableService variables, string defaultCulture,
+        Func<string, CancellationToken, Task<string?>> selectLanguage, CancellationToken cancellationToken = default);
+}
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/IPlayerLocalization.cs b/src/Presentation/GalNet.Avalonia.GameHost/IPlayerLocalization.cs
index 1f8e1a11..388b42b7 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/IPlayerLocalization.cs
+++ b/src/Presentation/GalNet.Avalonia.GameHost/IPlayerLocalization.cs
@@ -1,6 +1,6 @@
 using DynamicLocalization.Core;
 using GalNet.Core.Services;
-using GalNet.Runtime.Content;
+using GalNet.GameHost.Content;
 
 namespace GalNet.Avalonia.GameHost;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/ReadTextColorEditor.cs b/src/Presentation/GalNet.Avalonia.GameHost/ReadTextColorEditor.cs
new file mode 100644
index 00000000..385b60b7
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.GameHost/ReadTextColorEditor.cs
@@ -0,0 +1,79 @@
+using System.ComponentModel;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Data;
+using Avalonia.Layout;
+using Avalonia.Markup.Xaml.Styling;
+using Avalonia.Media;
+using GalNet.Avalonia.GameView.Settings;
+using GalNet.Game.Controls.Forms;
+
+namespace GalNet.Avalonia.GameHost;
+
+internal static class ReadTextColorEditor
+{
+    public static FieldEditorLease Create(SettingItem<string> colorSetting, BoolSetting enabled, IPlayerLocalization localization)
+    {
+        var panel = new StackPanel { Name = "ReadTextColorEditor", Orientation = Orientation.Horizontal, Spacing = 16 };
+        var check = new CheckBox { Name = "EnableReadTextColor" };
+        check.Bind(ContentControl.ContentProperty, new Binding("Value") { Source = localization.GetString("Settings.EnableReadTextColor") });
+        var swatch = new Border { Width = 28, Height = 20, BorderBrush = Brushes.Gray, BorderThickness = new(1) };
+        var button = new Button { Name = "ReadTextColorPicker", Content = swatch };
+        button.Bind(ToolTip.TipProperty, new Binding("Value") { Source = localization.GetString("Settings.ReadTextColor") });
+        var picker = new ColorView { IsAlphaEnabled = false, IsAlphaVisible = false };
+        picker.Styles.Add(new StyleInclude(new Uri("avares://GalNet.Avalonia.GameHost/"))
+        { Source = new Uri("avares://Avalonia.Controls.ColorPicker/Themes/Fluent/Fluent.xaml") });
+        var apply = new Button();
+        apply.Bind(ContentControl.ContentProperty, new Binding("Value") { Source = localization.GetString("Common.Confirm") });
+        var cancel = new Button();
+        cancel.Bind(ContentControl.ContentProperty, new Binding("Value") { Source = localization.GetString("Common.Cancel") });
+        var flyout = new Flyout
+        {
+            Content = new StackPanel
+            {
+                Spacing = 12,
+                Children =
+        { picker, new StackPanel { Orientation = Orientation.Horizontal, HorizontalAlignment = HorizontalAlignment.Right, Spacing = 8, Children = { cancel, apply } } }
+            }
+        };
+        button.Flyout = flyout;
+        panel.Children.Add(check); panel.Children.Add(button);
+        var refreshing = false;
+        var disposed = false;
+        void Refresh()
+        {
+            if (disposed) return;
+            refreshing = true;
+            check.IsChecked = enabled.Value;
+            check.IsEnabled = enabled.IsEnabled;
+            button.IsVisible = enabled.Value;
+            if (!enabled.Value) flyout.Hide();
+            button.IsEnabled = colorSetting.IsEnabled;
+            swatch.Background = Color.TryParse(colorSetting.Value, out var color) ? new SolidColorBrush(color) : Brushes.Transparent;
+            refreshing = false;
+        }
+        async void Toggle(object? sender, global::Avalonia.AvaloniaPropertyChangedEventArgs args)
+        {
+            if (!refreshing && args.Property == ToggleButton.IsCheckedProperty)
+            { await enabled.TrySetValueAsync(check.IsChecked == true); Refresh(); }
+        }
+        void Changed(object? sender, PropertyChangedEventArgs args) => Refresh();
+        check.PropertyChanged += Toggle;
+        enabled.PropertyChanged += Changed; colorSetting.PropertyChanged += Changed;
+        flyout.Opened += (_, _) => picker.Color = Color.TryParse(colorSetting.Value, out var color) ? color : Color.Parse("#A8B8C8");
+        apply.Click += async (_, _) =>
+        {
+            if (disposed || !enabled.Value || !colorSetting.IsEnabled) return;
+            var color = picker.Color;
+            if (await colorSetting.TrySetValueAsync($"#{color.R:X2}{color.G:X2}{color.B:X2}")) flyout.Hide();
+        };
+        cancel.Click += (_, _) => flyout.Hide();
+        Refresh();
+        return new FieldEditorLease(panel, () =>
+        {
+            disposed = true; flyout.Hide();
+            check.PropertyChanged -= Toggle;
+            enabled.PropertyChanged -= Changed; colorSetting.PropertyChanged -= Changed;
+        });
+    }
+}
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/Settings/GameSettings.cs b/src/Presentation/GalNet.Avalonia.GameHost/Settings/GameSettings.cs
new file mode 100644
index 00000000..b3d97b80
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.GameHost/Settings/GameSettings.cs
@@ -0,0 +1,46 @@
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Execution;
+
+namespace GalNet.Avalonia.GameHost.Settings;
+
+/// <summary>
+/// Default Avalonia host preferences, projected to the individual runtime modules.
+/// Projects may use their own model; the engine and PlayerSession do not depend on this type.
+/// </summary>
+public sealed class GameSettings
+{
+
+    /// <summary>文本显示速度（字符/秒，0 = 即时）</summary>
+    public float TextSpeed { get; set; } = 30f;
+    public bool EnableReadTextColor { get; set; }
+    public string ReadTextColor { get; set; } = "#A8B8C8";
+
+    /// <summary>自动推进间隔（整数毫秒）</summary>
+    public int AutoAdvanceIntervalMilliseconds { get; set; } = 2000;
+
+    /// <summary>Delay used by quick mode between reading units, in integer milliseconds.</summary>
+    public int QuickAdvanceIntervalMilliseconds { get; set; } = 50;
+
+    /// <summary>Quick mode stops before text not read before this visit.</summary>
+    public bool QuickReadOnly { get; set; } = true;
+
+    public float MasterVolume { get; set; } = 1f;
+    public bool MasterMuted { get; set; }
+    public Dictionary<string, AudioMixLevel> Buses { get; } = new(StringComparer.Ordinal);
+    public Dictionary<string, AudioMixLevel> Tracks { get; } = new(StringComparer.Ordinal);
+
+    public PlaybackOptions ToPlaybackOptions() => new()
+    {
+        AutoAdvanceIntervalMilliseconds = AutoAdvanceIntervalMilliseconds,
+        QuickAdvanceIntervalMilliseconds = QuickAdvanceIntervalMilliseconds,
+        QuickReadOnly = QuickReadOnly
+    };
+
+    public AudioMixOptions ToAudioMixOptions() => new()
+    {
+        MasterGain = MasterVolume,
+        MasterMuted = MasterMuted,
+        Buses = Buses,
+        Tracks = Tracks
+    };
+}
diff --git a/src/Launcher/GalNet.Launcher.Desktop/packages.lock.json b/src/Presentation/GalNet.Avalonia.GameHost/packages.lock.WindowsReadyToRun.json
similarity index 55%
rename from src/Launcher/GalNet.Launcher.Desktop/packages.lock.json
rename to src/Presentation/GalNet.Avalonia.GameHost/packages.lock.WindowsReadyToRun.json
index 7f1f3373..99ddfede 100644
--- a/src/Launcher/GalNet.Launcher.Desktop/packages.lock.json
+++ b/src/Presentation/GalNet.Avalonia.GameHost/packages.lock.WindowsReadyToRun.json
@@ -2,28 +2,24 @@
   "version": 2,
   "dependencies": {
     "net10.0": {
-      "Avalonia.Desktop": {
+      "Avalonia.Controls.ColorPicker": {
         "type": "Direct",
         "requested": "[12.0.5, )",
         "resolved": "12.0.5",
-        "contentHash": "L4bTMshYrhjSKu09Q60OHN1+Lfr9z7JsyRL6rfj3iQfjWm+5gsTl2viz5gyzDUgc/U5A7gf57e1spEX+nE/7zg==",
+        "contentHash": "EmYXjNZq5wevvvvbLTNvnDBnZfQ6YuFBPOwDc6IXMFFIFLY4WAfpi3Dr94/qmt55shDcMceogaUiNy0yyLf5NQ==",
         "dependencies": {
           "Avalonia": "12.0.5",
-          "Avalonia.HarfBuzz": "12.0.5",
-          "Avalonia.Native": "12.0.5",
-          "Avalonia.Skia": "12.0.5",
-          "Avalonia.Win32": "12.0.5",
-          "Avalonia.X11": "12.0.5"
+          "Avalonia.Remote.Protocol": "12.0.5"
         }
       },
-      "AvaloniaUI.DiagnosticsSupport": {
+      "DynamicLocalization.Core": {
         "type": "Direct",
-        "requested": "[2.2.3, )",
-        "resolved": "2.2.3",
-        "contentHash": "kQCInYusi2c9tjd9hV05Lln6Csbo07kiC672M3G7dsalDBe2j+pOk3We2nzdyy5ptQYy/9gQiC8ZaHhb6u/5Kw==",
+        "requested": "[2.1.2, )",
+        "resolved": "2.1.2",
+        "contentHash": "UdDvJeBnNoif/bi73CBDi7GiOhGUB9EkKl3v0JTNdVcPhCqWY+Jy9qr4IqNS9bQ5Xwn6uTYimYLDqGNxEEDjqw==",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
-          "Microsoft.IO.RecyclableMemoryStream": "3.0.1"
+          "System.Text.Json": "[6.0.10, 10.0.0)",
+          "YamlDotNet": "[11.0.1, 19.0.0)"
         }
       },
       "Antlr4.Runtime.Standard": {
@@ -31,77 +27,16 @@
         "resolved": "4.13.1",
         "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
       },
-      "Avalonia.Angle.Windows.Natives": {
-        "type": "Transitive",
-        "resolved": "2.1.27548.20260419",
-        "contentHash": "l17nI3XVDN3oMnpjf2pnmJg0YTwK4m6NLsn/itAjDMdObTFxN77D5F1M9sRMSfViSY3KKcse1ROczwgoWLJsnA=="
-      },
       "Avalonia.BuildServices": {
         "type": "Transitive",
         "resolved": "11.3.2",
         "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
       },
-      "Avalonia.FreeDesktop": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "51IiLrfyJdMtmVTiXiEi1q1nXS5KAMYvFNeovlwKSuTgY/agBevnfBTY+DnKnIjZMdXWWKVGJJh7MldMkPc14w==",
-        "dependencies": {
-          "Avalonia": "12.0.5",
-          "Tmds.DBus.Protocol": "0.92.0"
-        }
-      },
-      "Avalonia.FreeDesktop.AtSpi": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "IrsjB1QpzXwgdnkpG6ejGxSaHp0sRrq3rZlrzRyhwEGllAxcOeUuQpq8/OrO3OUJLxXtxlsM4ku17v+7q7xGKQ==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
-      "Avalonia.HarfBuzz": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "jR8i/fgrmAKEp0T3iLqfKCoEDJV9ODVzN+8bofM2guEr05eaXbx6iXZxcjh0nDK4UbK0akYDgBfAgyHoatqGjg==",
-        "dependencies": {
-          "Avalonia": "12.0.5",
-          "HarfBuzzSharp": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3"
-        }
-      },
-      "Avalonia.Native": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "m6qn0UGMI/b4cFfJ8id8sPYLotc7szhZdexPCKY+kIvGlx6Ln0VjNejRMiJDZ4S91q6nbKJL/YmfPd8UruTNjQ==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
       "Avalonia.Remote.Protocol": {
         "type": "Transitive",
         "resolved": "12.0.5",
         "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
       },
-      "Avalonia.Win32": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "ZY1ZLXQdQqlz9GUZGXK+73kTFgKzygPbGk/gHfROUWLr2aBh1kOA1KY5xB7/cSSY+egDr+IGSjsQbgS8eSu9Tg==",
-        "dependencies": {
-          "Avalonia": "12.0.5",
-          "Avalonia.Angle.Windows.Natives": "2.1.27548.20260419"
-        }
-      },
-      "Avalonia.X11": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "6OyZa5ehNbzd7JWiVbGdjuzdsgy2Rgibtwczmh7hKnePxLmOqeSL+hQ6vHanSx246TpSBKDPvjqwW7NuQrmAJg==",
-        "dependencies": {
-          "Avalonia": "12.0.5",
-          "Avalonia.FreeDesktop": "12.0.5",
-          "Avalonia.FreeDesktop.AtSpi": "12.0.5",
-          "Avalonia.Skia": "12.0.5"
-        }
-      },
       "HarfBuzzSharp": {
         "type": "Transitive",
         "resolved": "8.3.1.3",
@@ -131,23 +66,23 @@
         "resolved": "8.3.1.3",
         "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
       },
-      "MicroCom.Runtime": {
-        "type": "Transitive",
-        "resolved": "0.11.4",
-        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
-      },
-      "Microsoft.Extensions.Logging.Abstractions": {
+      "Irihi.Avalonia.Shared": {
         "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
+        "resolved": "0.4.0",
+        "contentHash": "T6+jezCUjisJNz6zkNcNLVNI2ttWznbyQnW6MS9L45EXhePqRCIxB3xV/5L8gFAJ83JrhiCIokMOxRWdq9/1Zg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
+          "Avalonia": "12.0.0"
         }
       },
-      "Microsoft.IO.RecyclableMemoryStream": {
+      "Irihi.Avalonia.Shared.Contracts": {
         "type": "Transitive",
-        "resolved": "3.0.1",
-        "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g=="
+        "resolved": "0.4.0",
+        "contentHash": "Du8DY2YqlSmCmywqZtuOhgwLkgklMeE1ajZ4Dd/iqVz6HmAKptjVTqA1oloZX5ihqsdKRiNuUGCdYPe1rekf2Q=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
       },
       "SkiaSharp": {
         "type": "Transitive",
@@ -178,48 +113,135 @@
         "resolved": "3.119.4",
         "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
       },
-      "Tmds.DBus.Protocol": {
+      "System.Text.Json": {
+        "type": "Transitive",
+        "resolved": "6.0.10",
+        "contentHash": "NSB0kDipxn2ychp88NXWfFRFlmi1bst/xynOutbnpEfRCT9JZkZ7KOmF/I/hNKo2dILiMGnqblm+j1sggdLB9g=="
+      },
+      "YamlDotNet": {
         "type": "Transitive",
-        "resolved": "0.92.0",
-        "contentHash": "h7IMakm0PF2jxiagoysoAjrzzLQ0UBdnSXQL5kb17YW0Fvyo12Tg96A99QkzwktWRrd7H+Uw9EzjasNLUfGYlA=="
+        "resolved": "11.0.1",
+        "contentHash": "UvICfSN4gJfAmOsuY/go0hb5SFfr3ZYCXb7jg66yT7kh+wSJEt7tUiwuoCNMpt8ScEXLDwXttpFoWKWeirYU1A=="
       },
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
-      "galnet.core": {
-        "type": "Project"
+      "galnet.avalonia.controls": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
       },
-      "galnet.launcher": {
+      "galnet.avalonia.gameview": {
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
-          "Avalonia.Fonts.Inter": "[12.0.5, )",
-          "Avalonia.Themes.Fluent": "[12.0.5, )",
-          "AvaloniaUI.DiagnosticsSupport": "[2.2.3, )",
           "CommunityToolkit.Mvvm": "[8.4.1, )",
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "Irihi.Ursa": "[2.1.0, )",
+          "LibVLCSharp": "[3.10.0, )",
+          "LibVLCSharp.Avalonia": "[3.10.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.avalonia.rendering": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
         }
       },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.media.libvlc": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "LibVLCSharp": "[3.10.0, )"
+        }
+      },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
+      "galnet.primitives.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
       "galnet.runtime": {
         "type": "Project",
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
+      "galnet.storage.filesystem": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
       "Avalonia": {
         "type": "CentralTransitive",
         "requested": "[12.0.5, )",
@@ -231,15 +253,6 @@
           "MicroCom.Runtime": "0.11.4"
         }
       },
-      "Avalonia.Fonts.Inter": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
       "Avalonia.Skia": {
         "type": "CentralTransitive",
         "requested": "[12.0.5, )",
@@ -255,15 +268,6 @@
           "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
         }
       },
-      "Avalonia.Themes.Fluent": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
       "CommunityToolkit.Mvvm": {
         "type": "CentralTransitive",
         "requested": "[8.4.1, )",
@@ -279,11 +283,38 @@
           "Antlr4.Runtime.Standard": "4.13.1"
         }
       },
+      "Irihi.Ursa": {
+        "type": "CentralTransitive",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "G2wAmenCgMZkBOqs5MYRtlurhU2tAKKmcNJzjjaA9Mj5v3YIivuv7wyNpIpgYZ602sOZhFtQwYrCaLVUhn9Htw==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Avalonia.Shared": "0.4.0",
+          "Irihi.Avalonia.Shared.Contracts": "0.4.0"
+        }
+      },
+      "LibVLCSharp": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
+      },
+      "LibVLCSharp.Avalonia": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "juoBLjh37+07kWDblbHLaWTQx1HsXOIJHU7aeH5/95xjN6dXfZMVE8ltg8NyaNL6vr2B4QgR3EiRBsEa+fPvlQ==",
+        "dependencies": {
+          "Avalonia": "11.3.13",
+          "LibVLCSharp": "3.10.0"
+        }
+      },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "CentralTransitive",
         "requested": "[10.0.0, )",
-        "resolved": "8.0.0",
-        "contentHash": "cjWrLkJXK0rs4zofsK4bSdg+jhDLTaxrkXu4gS6Y7MAlCvRyNNgwY/lJi5RDlQOnSZweHqoyvgvbdvQsRIW+hg=="
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
       },
       "Serilog": {
         "type": "CentralTransitive",
@@ -291,6 +322,38 @@
         "resolved": "4.2.0",
         "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
       }
+    },
+    "net10.0/win-x64": {
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      }
     }
   }
 }
\ No newline at end of file
diff --git a/src/Presentation/GalNet.Avalonia.GameHost/packages.lock.json b/src/Presentation/GalNet.Avalonia.GameHost/packages.lock.json
index dfa96339..dbba22ec 100644
--- a/src/Presentation/GalNet.Avalonia.GameHost/packages.lock.json
+++ b/src/Presentation/GalNet.Avalonia.GameHost/packages.lock.json
@@ -2,6 +2,16 @@
   "version": 2,
   "dependencies": {
     "net10.0": {
+      "Avalonia.Controls.ColorPicker": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "EmYXjNZq5wevvvvbLTNvnDBnZfQ6YuFBPOwDc6IXMFFIFLY4WAfpi3Dr94/qmt55shDcMceogaUiNy0yyLf5NQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Remote.Protocol": "12.0.5"
+        }
+      },
       "DynamicLocalization.Core": {
         "type": "Direct",
         "requested": "[2.1.2, )",
@@ -116,6 +126,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -123,6 +134,7 @@
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -134,6 +146,7 @@
           "GalNet.Assets": "[1.0.0, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Irihi.Ursa": "[2.1.0, )",
@@ -148,6 +161,7 @@
         "dependencies": {
           "Avalonia": "[12.0.5, )",
           "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -163,23 +177,41 @@
       "galnet.gamehost": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
         }
       },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.media.libvlc": {
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "LibVLCSharp": "[3.10.0, )"
         }
       },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -197,7 +229,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
@@ -205,6 +236,7 @@
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Composition/AvaloniaGameViewServiceCollectionExtensions.cs b/src/Presentation/GalNet.Avalonia.GameView/Composition/AvaloniaGameViewServiceCollectionExtensions.cs
index 8430f69f..90805a1a 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Composition/AvaloniaGameViewServiceCollectionExtensions.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Composition/AvaloniaGameViewServiceCollectionExtensions.cs
@@ -61,31 +61,31 @@ public static IServiceCollection AddAvaloniaGameViewPages(
         }
         services.AddSingleton(viewRegistry);
         services.AddSingleton(galleryPages.Build());
-        services.AddScoped<GameNavigationTransitionCoordinator>();
-        services.AddScoped<IGameNavigationTransitionCoordinator>(provider =>
+        services.TryAddScoped<GameNavigationTransitionCoordinator>();
+        services.TryAddScoped<IGameNavigationTransitionCoordinator>(provider =>
             provider.GetRequiredService<GameNavigationTransitionCoordinator>());
-        services.AddScoped<IGameNavigationService, GameNavigationService>();
-        services.AddScoped<IPlayerSettingsService, DefaultPlayerSettingsService>();
-        services.AddScoped<GalleryNavigationService>();
-        services.AddScoped<GameLaunchFlow>();
-        services.AddScoped<IPageViewFactory, PageViewFactory>();
-        services.AddScoped<IGameScreenshotService, AvaloniaGameScreenshotService>();
-        services.AddScoped<GalleryMediaService>();
-        services.AddScoped<GameShellViewModel>();
-        services.AddScoped<TitlePageViewModel>();
-        services.AddScoped<GamePageViewModel>();
-        services.AddScoped<SaveSlotsPageViewModel>();
-        services.AddScoped<SettingsPageViewModel>();
-        services.AddScoped<GalleryPageViewModel>();
-        services.AddScoped<CgGalleryImagePageViewModel>();
-        services.AddScoped<VideoGalleryPlayerPageViewModel>();
-        services.AddScoped<MissingGalleryPageViewModel>();
-        services.AddScoped<AboutPageViewModel>();
-        services.AddScoped<LoadingPageViewModel>();
-        services.AddScoped<GameShell>();
+        services.TryAddScoped<IGameNavigationService, GameNavigationService>();
+        services.TryAddScoped<IPlayerSettingsService, DefaultPlayerSettingsService>();
+        services.TryAddScoped<GalleryNavigationService>();
+        services.TryAddScoped<GameLaunchFlow>();
+        services.TryAddScoped<IPageViewFactory, PageViewFactory>();
+        services.TryAddScoped<IGameScreenshotService, AvaloniaGameScreenshotService>();
+        services.TryAddScoped<GalleryMediaService>();
+        services.TryAddScoped<GameShellViewModel>();
+        services.TryAddScoped<TitlePageViewModel>();
+        services.TryAddScoped<GamePageViewModel>();
+        services.TryAddScoped<SaveSlotsPageViewModel>();
+        services.TryAddScoped<SettingsPageViewModel>();
+        services.TryAddScoped<GalleryPageViewModel>();
+        services.TryAddScoped<CgGalleryImagePageViewModel>();
+        services.TryAddScoped<VideoGalleryPlayerPageViewModel>();
+        services.TryAddScoped<MissingGalleryPageViewModel>();
+        services.TryAddScoped<AboutPageViewModel>();
+        services.TryAddScoped<LoadingPageViewModel>();
+        services.TryAddScoped<GameShell>();
 
-        if (gamePageType == typeof(GamePage)) services.AddScoped<GamePage>();
-        else services.AddScoped<GamePage>(provider => (GamePage)provider.GetRequiredService(gamePageType));
+        if (gamePageType == typeof(GamePage)) services.TryAddScoped<GamePage>();
+        else services.TryAddScoped<GamePage>(provider => (GamePage)provider.GetRequiredService(gamePageType));
         return services;
     }
 }
diff --git a/src/Presentation/GalNet.Avalonia.GameView/GalNet.Avalonia.GameView.csproj b/src/Presentation/GalNet.Avalonia.GameView/GalNet.Avalonia.GameView.csproj
index bf707091..d12e5de8 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/GalNet.Avalonia.GameView.csproj
+++ b/src/Presentation/GalNet.Avalonia.GameView/GalNet.Avalonia.GameView.csproj
@@ -23,4 +23,5 @@
   <ItemGroup>
     <EmbeddedResource Include="Assets\MissingLayer.png" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Input/GameActionDispatcher.cs b/src/Presentation/GalNet.Avalonia.GameView/Input/GameActionDispatcher.cs
index a3318c1d..664f8245 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Input/GameActionDispatcher.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Input/GameActionDispatcher.cs
@@ -13,7 +13,7 @@ public sealed class GameActionDispatcher(
     private bool _busy;
 
     public bool CanReceive => session.IsPlaying && !settings.IsCapturing && !_busy &&
-        activeGame() is { IsChoiceVisible: false, IsSkipConfirmationOpen: false };
+        activeGame() is { IsChoiceVisible: false, IsSkipConfirmationOpen: false, IsHistoryOpen: false };
 
     public async Task DispatchAsync(string action)
     {
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputJsonContext.cs b/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputJsonContext.cs
new file mode 100644
index 00000000..d0557ce6
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputJsonContext.cs
@@ -0,0 +1,8 @@
+using System.Text.Json.Serialization;
+
+namespace GalNet.Avalonia.GameView.Input;
+
+// Preserve the existing PascalCase properties and numeric device values on disk.
+[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata)]
+[JsonSerializable(typeof(PlayerInputConfiguration))]
+internal sealed partial class PlayerInputJsonContext : JsonSerializerContext;
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputRouter.cs b/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputRouter.cs
index 422b348b..f4625f90 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputRouter.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputRouter.cs
@@ -39,8 +39,9 @@ public PlayerInputRouter(Control root, PlayerInputSettings settings, Func<GamePa
     }
     private async void Gamepad(IReadOnlySet<string> buttons)
     {
+        if (!_root.IsEffectivelyEnabled || !_root.IsEffectivelyVisible) { ResetInput(); return; }
         if (_settings.IsCapturing) { _gamepadDraft = null; _gamepadPeak = 0; StopNavigationRepeat(); return; }
-        var navigation = _activeGame() is null or { IsChoiceVisible: true } or { IsSkipConfirmationOpen: true };
+        var navigation = _activeGame() is null or { IsChoiceVisible: true } or { IsSkipConfirmationOpen: true } or { IsHistoryOpen: true };
         if (navigation && buttons.Count == 1 && buttons.First() is "Up" or "Down" or "Left" or "Right")
         {
             var direction = buttons.First();
@@ -71,7 +72,7 @@ private async void Gamepad(IReadOnlySet<string> buttons)
         _gamepadPeak = 0;
         if (gesture is null) return;
         var game = _activeGame();
-        if (game is null || game.IsChoiceVisible || game.IsSkipConfirmationOpen)
+        if (game is null || game.IsChoiceVisible || game.IsSkipConfirmationOpen || game.IsHistoryOpen)
         { Navigate(gesture); return; }
         var action = _settings.Resolve(PlayerInputDevice.Gamepad, gesture);
         if (action != "hold.quick" && action is not null) await DispatchAsync(action);
@@ -80,7 +81,7 @@ private async void Gamepad(IReadOnlySet<string> buttons)
     private void NavigationRepeat(object? sender, EventArgs e)
     {
         _navigationRepeat.Interval = TimeSpan.FromMilliseconds(100);
-        if (_navigationDirection is { } direction && !_settings.IsCapturing) Navigate(direction);
+        if (_root.IsEffectivelyEnabled && _root.IsEffectivelyVisible && _navigationDirection is { } direction && !_settings.IsCapturing) Navigate(direction);
     }
     private void CloseChoice(bool commit)
     {
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputSettings.cs b/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputSettings.cs
index 169a5523..975c3c15 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputSettings.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Input/PlayerInputSettings.cs
@@ -52,7 +52,7 @@ public void ObserveGamepad(IReadOnlySet<string> buttons)
     public string? ConflictActionKey { get; private set; }
     public void ReportError(string? key) { ErrorKey = key; Changed?.Invoke(); }
     public event Action? Changed;
-    /// <summary>Optional future page extension; no handler means the history action is unavailable.</summary>
+    /// <summary>History page callback; no handler means the history action is unavailable.</summary>
     public Func<Task>? OpenHistoryAsync { get; set; }
     public Func<Task>? ToggleFullscreenAsync { get; set; }
     public bool IsActionAvailable(string id) => id != "open.history" || OpenHistoryAsync is not null;
@@ -127,13 +127,20 @@ public void Apply(PlayerInputConfiguration configuration)
         Changed?.Invoke();
         OnPropertyChanged(nameof(EastConfirms));
     }
-    public string Serialize() => JsonSerializer.Serialize(_configuration);
+    public string Serialize() => JsonSerializer.Serialize(_configuration, PlayerInputJsonContext.Default.PlayerInputConfiguration);
     public void Restore(string? json)
     {
         try
         {
-            var parsed = json is null ? null : JsonSerializer.Deserialize<PlayerInputConfiguration>(json);
-            Apply(parsed is not null && Validate(parsed) is null ? parsed : Defaults());
+            var parsed = json is null ? null : JsonSerializer.Deserialize(json, PlayerInputJsonContext.Default.PlayerInputConfiguration);
+            var restored = parsed is not null && Validate(parsed) is null ? parsed : Defaults();
+            // Older preferences had no default history binding. Preserve explicit unbinding and conflicts.
+            if (!restored.Bindings.ContainsKey("open.history"))
+            {
+                var occupied = restored.Bindings.Values.SelectMany(bindings => bindings).ToHashSet();
+                restored.Bindings["open.history"] = Defaults().Bindings["open.history"].Where(binding => !occupied.Contains(binding)).ToArray();
+            }
+            Apply(restored);
         }
         catch (JsonException) { Apply(Defaults()); }
     }
@@ -171,13 +178,14 @@ private static PlayerInputConfiguration Copy(PlayerInputConfiguration value) =>
         ["hold.quick"] = [new(PlayerInputDevice.KeyboardMouse, "Control"), new(PlayerInputDevice.Gamepad, "West")],
         ["toggle.quick"] = [new(PlayerInputDevice.KeyboardMouse, "Tab")],
         ["toggle.auto"] = [new(PlayerInputDevice.KeyboardMouse, "A")],
-        ["toggle.ui"] = [new(PlayerInputDevice.KeyboardMouse, "H"), new(PlayerInputDevice.KeyboardMouse, "MouseMiddle"), new(PlayerInputDevice.Gamepad, "North"), new(PlayerInputDevice.Touch, "TwoFingerTap")],
+        ["toggle.ui"] = [new(PlayerInputDevice.KeyboardMouse, "H"), new(PlayerInputDevice.KeyboardMouse, "MouseRight"), new(PlayerInputDevice.Gamepad, "North"), new(PlayerInputDevice.Touch, "TwoFingerTap")],
         ["save.first-empty"] = [new(PlayerInputDevice.KeyboardMouse, "Control+S")],
         ["open.save"] = [new(PlayerInputDevice.KeyboardMouse, "F5")],
         ["open.load"] = [new(PlayerInputDevice.KeyboardMouse, "Control+L")],
         ["open.settings"] = [new(PlayerInputDevice.KeyboardMouse, "F1"), new(PlayerInputDevice.Gamepad, "Start")],
         ["screenshot"] = [new(PlayerInputDevice.KeyboardMouse, "F12")],
-        ["toggle.fullscreen"] = [new(PlayerInputDevice.KeyboardMouse, "Alt+Enter")]
+        ["toggle.fullscreen"] = [new(PlayerInputDevice.KeyboardMouse, "Alt+Enter")],
+        ["open.history"] = [new(PlayerInputDevice.KeyboardMouse, "WheelUp")]
     });
     public void Dispose() { CancelGamepad(); _edits.Dispose(); }
 }
diff --git a/src/Presentation/GalNet.Avalonia.GameView/MarkupExtensions/PlayerTextBlock.cs b/src/Presentation/GalNet.Avalonia.GameView/MarkupExtensions/PlayerTextBlock.cs
index 7f2872c0..2a426e14 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/MarkupExtensions/PlayerTextBlock.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/MarkupExtensions/PlayerTextBlock.cs
@@ -9,13 +9,16 @@ public sealed class PlayerTextBlock : TextBlock
 {
     public static readonly StyledProperty<string?> KeyProperty =
         AvaloniaProperty.Register<PlayerTextBlock, string?>(nameof(Key));
+    public static readonly StyledProperty<string?> FallbackProperty =
+        AvaloniaProperty.Register<PlayerTextBlock, string?>(nameof(Fallback));
     private IDisposable? _binding;
     public string? Key { get => GetValue(KeyProperty); set => SetValue(KeyProperty, value); }
+    public string? Fallback { get => GetValue(FallbackProperty); set => SetValue(FallbackProperty, value); }
 
     protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
     {
         base.OnPropertyChanged(change);
-        if (change.Property == KeyProperty) UpdateText();
+        if (change.Property == KeyProperty || change.Property == FallbackProperty) UpdateText();
     }
 
     protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
@@ -36,7 +39,7 @@ private void UpdateText()
         _binding?.Dispose();
         _binding = null;
         IsVisible = !string.IsNullOrWhiteSpace(Key);
-        Text = Key;
+        Text = Fallback ?? Key;
         if (IsVisible && PlayerTextExtension.Resolve is { } resolve)
             _binding = this.Bind(TextProperty, new ReflectionBinding("Value") { Source = resolve(Key!), Mode = BindingMode.OneWay });
     }
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Navigation/GalleryPageNavigation.cs b/src/Presentation/GalNet.Avalonia.GameView/Navigation/GalleryPageNavigation.cs
index ab592111..95dd177e 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Navigation/GalleryPageNavigation.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Navigation/GalleryPageNavigation.cs
@@ -1,6 +1,6 @@
 using Avalonia.Controls;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace GalNet.Avalonia.GameView.Navigation;
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Page/DialogueHistoryOverlay.axaml b/src/Presentation/GalNet.Avalonia.GameView/Page/DialogueHistoryOverlay.axaml
new file mode 100644
index 00000000..38e03be7
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.GameView/Page/DialogueHistoryOverlay.axaml
@@ -0,0 +1,41 @@
+<UserControl xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:text="using:GalNet.Avalonia.GameView.MarkupExtensions" xmlns:controls="using:GalNet.Game.Controls"
+             xmlns:page="using:GalNet.Avalonia.GameView.Page"
+             x:Class="GalNet.Avalonia.GameView.Page.DialogueHistoryOverlay" x:CompileBindings="False"
+             IsVisible="{Binding IsHistoryOpen}" page:GamePage.IsPlayerInteraction="True">
+  <Border Background="{DynamicResource GalNet.Brush.Background}" Padding="32">
+    <Grid RowDefinitions="Auto,*,Auto" RowSpacing="20" MaxWidth="1080">
+      <Grid ColumnDefinitions="*,Auto">
+        <TextBlock Text="{text:PlayerText History.Title, History}" FontSize="30" FontWeight="SemiBold" />
+        <Button Name="CloseHistory" Grid.Column="1" Content="{text:PlayerText Common.Back, Back}" Command="{Binding CloseHistoryCommand}" />
+      </Grid>
+      <ItemsControl Name="HistoryList" Grid.Row="1" ItemsSource="{Binding HistoryLines}">
+        <ItemsControl.Template>
+          <ControlTemplate>
+            <ScrollViewer HorizontalScrollBarVisibility="Disabled" VerticalScrollBarVisibility="Auto">
+              <ItemsPresenter Name="PART_ItemsPresenter" ItemsPanel="{TemplateBinding ItemsPanel}" />
+            </ScrollViewer>
+          </ControlTemplate>
+        </ItemsControl.Template>
+        <ItemsControl.ItemsPanel><ItemsPanelTemplate><VirtualizingStackPanel /></ItemsPanelTemplate></ItemsControl.ItemsPanel>
+        <ItemsControl.ItemTemplate>
+          <DataTemplate>
+            <Border Padding="12,16" BorderBrush="{DynamicResource GalNet.Brush.Divider}" BorderThickness="0,0,0,1">
+              <Grid ColumnDefinitions="*,Auto" ColumnSpacing="20">
+                <StackPanel Spacing="8">
+                  <TextBlock Text="{Binding Speaker}" FontWeight="SemiBold" Foreground="{DynamicResource GalNet.Brush.Primary}" />
+                  <controls:TypewriterTextBlock SourceText="{Binding Text}" CharactersPerSecond="0" FontSize="21"
+                       TextWrapping="Wrap" controls:ReadTextStyle.WasRead="{Binding WasRead}" />
+                </StackPanel>
+                <Button Grid.Column="1" Content="🔊" IsVisible="{Binding HasVoice}" VerticalAlignment="Top"
+                        Command="{Binding $parent[UserControl].DataContext.ReplayHistoryVoiceCommand}" CommandParameter="{Binding}"
+                        ToolTip.Tip="{text:PlayerText History.ReplayVoice, 'Replay voice'}" AutomationProperties.Name="{text:PlayerText History.ReplayVoice, 'Replay voice'}" />
+              </Grid>
+            </Border>
+          </DataTemplate>
+        </ItemsControl.ItemTemplate>
+      </ItemsControl>
+      <TextBlock Grid.Row="2" Text="{text:PlayerText History.Empty, 'No dialogue yet.'}" IsVisible="{Binding IsHistoryEmpty}" Foreground="{DynamicResource GalNet.Brush.TextSecondary}" />
+    </Grid>
+  </Border>
+</UserControl>
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Page/DialogueHistoryOverlay.axaml.cs b/src/Presentation/GalNet.Avalonia.GameView/Page/DialogueHistoryOverlay.axaml.cs
new file mode 100644
index 00000000..067ea99d
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.GameView/Page/DialogueHistoryOverlay.axaml.cs
@@ -0,0 +1,23 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Threading;
+using GalNet.Avalonia.GameView.ViewModels;
+
+namespace GalNet.Avalonia.GameView.Page;
+
+public partial class DialogueHistoryOverlay : UserControl
+{
+    public DialogueHistoryOverlay() => InitializeComponent();
+
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+        if (change.Property == IsVisibleProperty && IsVisible)
+            Dispatcher.UIThread.Post(() =>
+            {
+                if (!IsVisible || DataContext is not GamePageViewModel game) return;
+                CloseHistory.Focus();
+                if (game.HistoryLines.Count > 0) HistoryList.ScrollIntoView(game.HistoryLines[^1]);
+            }, DispatcherPriority.Loaded);
+    }
+}
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Page/GamePage.cs b/src/Presentation/GalNet.Avalonia.GameView/Page/GamePage.cs
index 6f5276c1..ce799922 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Page/GamePage.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Page/GamePage.cs
@@ -1,3 +1,4 @@
+using System.Linq.Expressions;
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Presenters;
@@ -26,6 +27,8 @@ public class GamePage : TemplatedControl
         AvaloniaProperty.RegisterDirect<GamePage, NvlPresenter>(nameof(Nvl), page => page.Nvl);
     public static readonly DirectProperty<GamePage, ChoiceList> ChoiceProperty =
         AvaloniaProperty.RegisterDirect<GamePage, ChoiceList>(nameof(Choice), page => page.Choice);
+    public static readonly DirectProperty<GamePage, Control> HistoryProperty =
+        AvaloniaProperty.RegisterDirect<GamePage, Control>(nameof(History), page => page.History);
 
     /// <summary>Marks custom interactive regions that must not advance the story.</summary>
     public static readonly AttachedProperty<bool> IsPlayerInteractionProperty =
@@ -40,20 +43,34 @@ public class GamePage : TemplatedControl
     public DialoguePresenter Dialogue { get; } = new();
     public NvlPresenter Nvl { get; } = new();
     public ChoiceList Choice { get; } = new();
+    public Control History { get; } = new DialogueHistoryOverlay();
 
     public GamePage()
     {
         Scene = new Grid { ClipToBounds = true, Children = { SceneHost } };
-        BindContent(SceneHost, SceneLayerHost.ItemsSourceProperty, nameof(GamePageViewModel.Layers));
-        BindContent(SceneHost, SceneLayerHost.EffectsSourceProperty, nameof(GamePageViewModel.TextureEffects));
-        BindContent(SceneHost, SceneLayerHost.RenderablesSourceProperty, nameof(GamePageViewModel.SceneRenderables));
-        BindContent(Dialogue, IsVisibleProperty, nameof(GamePageViewModel.IsDialogueOverlayVisible));
-        BindContent(Nvl, IsVisibleProperty, nameof(GamePageViewModel.IsNvlOverlayVisible));
-        BindContent(Choice, IsVisibleProperty, nameof(GamePageViewModel.IsChoiceOverlayVisible));
-        BindContent(Choice, ItemsControl.ItemsSourceProperty, nameof(GamePageViewModel.Choices));
-        BindContent(Choice, ChoiceList.SelectionCommandProperty, nameof(GamePageViewModel.CompleteChoiceCommand));
+        BindContent(SceneHost, SceneLayerHost.ItemsSourceProperty, page => ((GamePageViewModel)page.DataContext!).Layers);
+        BindContent(SceneHost, SceneLayerHost.EffectsSourceProperty, page => ((GamePageViewModel)page.DataContext!).TextureEffects);
+        BindContent(SceneHost, SceneLayerHost.RenderablesSourceProperty, page => ((GamePageViewModel)page.DataContext!).SceneRenderables);
+        BindContent(Dialogue, IsVisibleProperty, page => ((GamePageViewModel)page.DataContext!).IsDialogueOverlayVisible);
+        BindContent(Dialogue, ReadTextStyle.ForegroundProperty, page => ((GamePageViewModel)page.DataContext!).ReadTextBrush);
+        BindContent(Nvl, ReadTextStyle.ForegroundProperty, page => ((GamePageViewModel)page.DataContext!).ReadTextBrush);
+        BindContent(History, ReadTextStyle.ForegroundProperty, page => ((GamePageViewModel)page.DataContext!).ReadTextBrush);
+        BindContent(Dialogue, DialoguePresenter.CanReplayVoiceProperty, page => ((GamePageViewModel)page.DataContext!).CanReplayDialogue);
+        BindContent(Dialogue, DialoguePresenter.ReplayVoiceCommandProperty, page => ((GamePageViewModel)page.DataContext!).ReplayDialogueCommand);
+        BindContent(Dialogue, DialoguePresenter.ReplayIconProperty, page => ((GamePageViewModel)page.DataContext!).ReplayIcon);
+        if (MarkupExtensions.PlayerTextExtension.CreateBinding("History.ReplayVoice", "Replay voice") is ReflectionBinding replayLabel)
+            Dialogue.Bind(DialoguePresenter.ReplayLabelProperty, replayLabel);
+        BindContent(Nvl, IsVisibleProperty, page => ((GamePageViewModel)page.DataContext!).IsNvlOverlayVisible);
+        BindContent(Choice, IsVisibleProperty, page => ((GamePageViewModel)page.DataContext!).IsChoiceOverlayVisible);
+        BindContent(Choice, ItemsControl.ItemsSourceProperty, page => ((GamePageViewModel)page.DataContext!).Choices);
+        BindContent(Choice, ChoiceList.SelectionCommandProperty, page => ((GamePageViewModel)page.DataContext!).CompleteChoiceCommand);
         AddHandler(PointerPressedEvent, OnPagePointerPressed, RoutingStrategies.Tunnel);
-        AddHandler(KeyDownEvent, (_, _) => (DataContext as GamePageViewModel)?.ClearPlaybackPointer(), RoutingStrategies.Tunnel);
+        AddHandler(KeyDownEvent, (_, args) =>
+        {
+            if (DataContext is not GamePageViewModel game) return;
+            game.ClearPlaybackPointer();
+            if (game.IsHistoryOpen && args.Key == Key.Escape) { game.CloseHistoryCommand.Execute(null); args.Handled = true; }
+        }, RoutingStrategies.Tunnel);
     }
 
     public static bool GetIsPlayerInteraction(Control control) => control.GetValue(IsPlayerInteractionProperty);
@@ -76,6 +93,8 @@ protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
         RequirePresenter(e, "PART_Dialogue", Dialogue);
         RequirePresenter(e, "PART_Nvl", Nvl);
         RequirePresenter(e, "PART_Choice", Choice);
+        if (e.NameScope.Find<ContentPresenter>("PART_History") is { } history && !ReferenceEquals(history.Content, History))
+            throw new InvalidOperationException("PART_History must present the owned History content.");
     }
 
     private static void RequirePresenter(TemplateAppliedEventArgs e, string name, Control content)
@@ -86,8 +105,8 @@ private static void RequirePresenter(TemplateAppliedEventArgs e, string name, Co
             throw new InvalidOperationException($"GamePage {name} must present the corresponding owned content using TemplateBinding.");
     }
 
-    private void BindContent(AvaloniaObject target, AvaloniaProperty property, string path) =>
-        target.Bind(property, new ReflectionBinding($"DataContext.{path}") { Source = this });
+    private void BindContent<T>(AvaloniaObject target, AvaloniaProperty property, Expression<Func<GamePage, T>> path) =>
+        target.Bind(property, CompiledBinding.Create(path, source: this));
 
     private void OnPagePointerPressed(object? sender, PointerPressedEventArgs eventArgs)
     {
@@ -100,7 +119,7 @@ private void OnPagePointerPressed(object? sender, PointerPressedEventArgs eventA
         var toggle = (eventArgs.Source as Visual)?.GetSelfAndVisualAncestors().OfType<Control>()
             .Select(GetPlaybackToggle).FirstOrDefault(mode => mode is not null);
         viewModel.CancelPlaybackFromPointer(toggle);
-        if (viewModel.IsSkipConfirmationOpen || IsPlayerControl(eventArgs.Source)) return;
+        if (viewModel.IsSkipConfirmationOpen || viewModel.IsHistoryOpen || IsPlayerControl(eventArgs.Source)) return;
 
         viewModel.ObserveAdvancePointerPressed();
         if (viewModel.AdvanceCommand.CanExecute(null))
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Page/GameShell.axaml.cs b/src/Presentation/GalNet.Avalonia.GameView/Page/GameShell.axaml.cs
index edcf6ebb..644c2c0c 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Page/GameShell.axaml.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Page/GameShell.axaml.cs
@@ -29,6 +29,7 @@ public partial class GameShell : UserControl, IDisposable
     private bool _hadActiveRun;
     private bool _returningToTitle;
     private bool _disposed;
+    private byte[]? _savePreview;
     private readonly GalNet.Avalonia.GameView.Input.PlayerInputRouter? _inputRouter;
     private readonly GalNet.Avalonia.GameView.Input.TouchInputRecognizer? _touchInput;
     private readonly GalNet.Avalonia.GameView.Input.PlayerInputSettings? _inputSettings;
@@ -48,6 +49,7 @@ public GameShell(
         _views = views;
         _screenshots = screenshots;
         _session = session;
+        if (session is ISavePreviewSource previewSource) previewSource.CaptureSavePreview = CaptureSavePreview;
         _navigation = navigation;
         _transitions = transitions;
         _inputSettings = settings.Input;
@@ -62,12 +64,17 @@ public GameShell(
         if (settings.Input is { } input)
         {
             _inputRouter = new(this, input, () => _viewModel.CurrentViewModel as GamePageViewModel, session, GoBack);
-            _touchInput = new(this, input, () => _viewModel.CurrentViewModel is GamePageViewModel { IsChoiceVisible: false, IsSkipConfirmationOpen: false }, _inputRouter.DispatchAsync);
+            _touchInput = new(this, input, () => _viewModel.CurrentViewModel is GamePageViewModel { IsChoiceVisible: false, IsSkipConfirmationOpen: false, IsHistoryOpen: false }, _inputRouter.DispatchAsync);
         }
     }
 
     private void GoBack()
     {
+        if (_viewModel.CurrentViewModel is GamePageViewModel { IsHistoryOpen: true } game)
+        {
+            game.CloseHistoryCommand.Execute(null);
+            return;
+        }
         if (_viewModel.CurrentViewModel is BackNavigablePageViewModel page)
         {
             if (page.BackCommand.CanExecute(null)) page.BackCommand.Execute(null);
@@ -78,6 +85,7 @@ private void GoBack()
     public void Dispose()
     {
         _disposed = true;
+        if (_session is ISavePreviewSource previewSource) previewSource.CaptureSavePreview = null;
         _pageBackInput.Dispose();
         _inputRouter?.Dispose();
         _touchInput?.Dispose();
@@ -155,6 +163,8 @@ await OnUiAsync(() =>
                 return;
             }
 
+            if (PageHost.Content is GamePage page && _viewModel.CurrentViewModel is SaveSlotsPageViewModel)
+                _savePreview = TryCaptureScene(page);
             targetContent = contentFactory();
             if (targetContent is Visual targetVisual &&
                 targetVisual.GetVisualParent() is ContentPresenter previousPresenter)
@@ -274,7 +284,10 @@ private async void OnScreenshotRequested()
         await _screenshots.CaptureAsync(new GameScreenshotRequest(
             _session.GameTitle,
             owner,
-            includeUi => Task.FromResult(includeUi ? CapturePng(this) : page.CaptureScenePng())));
+            includeUi => CaptureScreenshotAsync(page, includeUi, null))
+        {
+            CapturePreviewPngAsync = includeUi => CaptureScreenshotAsync(page, includeUi, new PixelSize(720, 405))
+        });
     }
 
     private async void OnReturnToTitleRequested()
@@ -290,14 +303,22 @@ private async void OnReturnToTitleRequested()
         finally { _returningToTitle = false; }
     }
 
-    private static byte[] CapturePng(Control target)
+    private byte[]? CaptureSavePreview() => PageHost.Content is GamePage page ? TryCaptureScene(page) : _savePreview;
+
+    private static byte[]? TryCaptureScene(GamePage page)
     {
-        var width = Math.Max(1, (int)Math.Ceiling(target.Bounds.Width));
-        var height = Math.Max(1, (int)Math.Ceiling(target.Bounds.Height));
-        using var bitmap = new RenderTargetBitmap(new PixelSize(width, height));
-        bitmap.Render(target);
-        using var stream = new MemoryStream();
-        bitmap.Save(stream);
-        return stream.ToArray();
+        try { return page.SceneHost.CapturePng(new PixelSize(480, 270)); }
+        catch (Exception error) { Log.Logger.Warning(error, "Unable to capture save preview"); return null; }
+    }
+
+    private async Task<byte[]> CaptureScreenshotAsync(GamePage page, bool includeUi, PixelSize? maximumSize)
+    {
+        using var bitmap = page.SceneHost.CaptureControl(includeUi ? this : page.Scene, maximumSize);
+        return await Task.Run(() =>
+        {
+            using var stream = new MemoryStream();
+            bitmap.Save(stream);
+            return stream.ToArray();
+        });
     }
 }
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Page/ScreenshotDialog.cs b/src/Presentation/GalNet.Avalonia.GameView/Page/ScreenshotDialog.cs
index 59112478..9e3ee2cd 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Page/ScreenshotDialog.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Page/ScreenshotDialog.cs
@@ -102,7 +102,7 @@ private async void OnBrowseClicked(object? sender, global::Avalonia.Interactivit
 
         var folders = await topLevel.StorageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
         {
-            Title = "Choose screenshot folder",
+            Title = ScreenshotDialogViewModel.Text("Screenshot.ChooseFolder", "Choose folder…"),
             AllowMultiple = false
         });
         if (ReferenceEquals(_viewModel, viewModel) && folders.Count > 0)
@@ -126,8 +126,13 @@ private async void OnSaveClicked(object? sender, global::Avalonia.Interactivity.
         viewModel.DirectoryPath = DirectoryBox.Text?.Trim() ?? string.Empty;
         viewModel.FileName = FileNameBox.Text?.Trim() ?? string.Empty;
         viewModel.IncludeUi = IncludeUiBox.IsChecked == true;
-        await viewModel.SaveAsync();
-        if (ReferenceEquals(_viewModel, viewModel)) ErrorBlock.Text = viewModel.Error;
+        SaveButton.IsEnabled = false;
+        try
+        {
+            await viewModel.SaveAsync();
+            if (ReferenceEquals(_viewModel, viewModel)) ErrorBlock.Text = viewModel.Error;
+        }
+        finally { SaveButton.IsEnabled = true; }
     }
 
     private async Task RefreshPreviewAsync(ScreenshotDialogViewModel viewModel)
@@ -148,7 +153,7 @@ private async Task RefreshPreviewAsync(ScreenshotDialogViewModel viewModel)
         catch (Exception exception)
         {
             if (!ReferenceEquals(_viewModel, viewModel) || version != _previewVersion) return;
-            ErrorBlock.Text = $"Could not capture screenshot: {exception.Message}";
+            ErrorBlock.Text = $"{ScreenshotDialogViewModel.Text("Screenshot.CaptureFailed", "Could not capture screenshot.")} {exception.Message}";
         }
     }
 }
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaAnimationPresenter.cs b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaAnimationPresenter.cs
index b0ddc53c..a2f595a2 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaAnimationPresenter.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaAnimationPresenter.cs
@@ -1,6 +1,6 @@
 using System.Diagnostics;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Avalonia.GameView.Presentation;
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaDialoguePresenter.cs b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaDialoguePresenter.cs
index 03d3b2ea..459c3d51 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaDialoguePresenter.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaDialoguePresenter.cs
@@ -1,5 +1,6 @@
 using GalNet.Avalonia.GameView.Page;
 using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Core.Execution;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Avalonia.GameView.Presentation;
@@ -10,7 +11,9 @@ public sealed class AvaloniaDialoguePresenter : IDialoguePresenter, INvlPresente
     private readonly GamePageViewModel _state;
     private readonly GamePage _page;
     private readonly IAvaloniaUiDispatcher _dispatcher;
-    private readonly List<string> _nvlHistory = [];
+    private readonly List<(string Text, bool WasRead)> _nvlHistory = [];
+    private bool _wasRead;
+    private bool _dialogueWasRead;
     private bool _catchUp;
     private bool _dialogueVisible;
     private bool _nvlVisible;
@@ -27,6 +30,8 @@ public AvaloniaDialoguePresenter(GamePageViewModel state, GamePage page, IAvalon
 
     public Task InitialPresentationReady => _initialPresentationReady.Task;
 
+    public void SetReadingContext(bool wasRead) => _dispatcher.Dispatch(() => _wasRead = wasRead);
+
     public void CompleteInitialPresentation() => _initialPresentationReady.TrySetResult();
     public void FailInitialPresentation(Exception exception) => _initialPresentationReady.TrySetException(exception);
     public void ShowDialogue() => _dispatcher.Dispatch(() => { _dialogueVisible = true; if (!_catchUp) _state.IsDialogueVisible = true; });
@@ -39,7 +44,8 @@ public Task AppendNvlTextAsync(string text, CancellationToken cancellationToken)
         _dispatcher.InvokeAsync(() =>
         {
             _page.EnsureLayout();
-            _nvlHistory.Add(text);
+            _nvlHistory.Add((text, _wasRead));
+            _page.Nvl.NextLineWasRead = _wasRead;
             return RenderNvlParagraphAsync(text, immediately: false, cancellationToken);
         });
     public void SkipNvlText() => _dispatcher.Dispatch(_page.Nvl.SkipText);
@@ -48,7 +54,8 @@ public Task AppendNvlTextImmediatelyAsync(string text, CancellationToken cancell
         _dispatcher.InvokeAsync(() =>
         {
             _page.EnsureLayout();
-            _nvlHistory.Add(text);
+            _nvlHistory.Add((text, _wasRead));
+            _page.Nvl.NextLineWasRead = _wasRead;
             return RenderNvlParagraphAsync(text, immediately: true, cancellationToken);
         });
 
@@ -61,6 +68,7 @@ private Task PresentDialogueAsync(string speaker, string text, bool immediately,
             _page.EnsureLayout();
             _speaker = speaker;
             _text = text;
+            _dialogueWasRead = _wasRead;
             _dialogueVisible = true;
             _state.IsDialogueVisible = true;
             return RenderDialogueAsync(speaker, text, immediately, cancellationToken);
@@ -103,10 +111,11 @@ public void RecordDialogue(string speaker, string text) => _dispatcher.Dispatch(
     {
         _speaker = speaker;
         _text = text;
+        _dialogueWasRead = _wasRead;
         _dialogueVisible = true;
     });
 
-    public void RecordNvlParagraph(string text) => _dispatcher.Dispatch(() => _nvlHistory.Add(text));
+    public void RecordNvlParagraph(string text) => _dispatcher.Dispatch(() => _nvlHistory.Add((text, _wasRead)));
 
     public Task BeginCatchUpAsync() => _dispatcher.InvokeAsync(() =>
     {
@@ -122,7 +131,10 @@ public Task EndCatchUpAsync(CancellationToken cancellationToken) => _dispatcher.
         _page.EnsureLayout();
         _page.Nvl.Clear();
         foreach (var paragraph in _nvlHistory)
-            await RenderNvlParagraphAsync(paragraph, immediately: true, cancellationToken);
+        {
+            _page.Nvl.NextLineWasRead = paragraph.WasRead;
+            await RenderNvlParagraphAsync(paragraph.Text, immediately: true, cancellationToken);
+        }
         if (_text is not null)
             await RenderDialogueAsync(_speaker, _text, immediately: true, cancellationToken);
         _state.IsDialogueVisible = _dialogueVisible;
@@ -134,6 +146,7 @@ public Task EndCatchUpAsync(CancellationToken cancellationToken) => _dispatcher.
     private Task RenderDialogueAsync(string speaker, string text, bool immediately, CancellationToken cancellationToken)
     {
         _page.Dialogue.Speaker = speaker;
+        GalNet.Game.Controls.ReadTextStyle.SetWasRead(_page.Dialogue, _dialogueWasRead);
         _page.Dialogue.Text = text;
         _page.Dialogue.CharactersPerSecond = immediately ? 0 : _state.TextSpeed;
         var completion = _page.Dialogue.StartAsync(cancellationToken);
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaEffectRuntime.cs b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaEffectRuntime.cs
index eeea9e42..c4203bf5 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaEffectRuntime.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaEffectRuntime.cs
@@ -1,6 +1,9 @@
+using System.Collections.Concurrent;
+using System.Text.Json;
 using Avalonia.Threading;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Assets;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Rendering.Scene;
 
@@ -9,6 +12,9 @@ namespace GalNet.Avalonia.GameView.Presentation;
 /// <summary>Owns active texture effects. The renderer owns their pixels.</summary>
 public sealed class AvaloniaEffectRuntime : IDisposable, IEffectPresenter
 {
+    private readonly IAssetManager? _assets;
+    private bool _disposed;
+    private readonly ConcurrentDictionary<string, long> _preparations = new(StringComparer.Ordinal);
     private readonly Dictionary<string, ITextureEffectFactory> _textureFactories;
     private readonly Dictionary<string, ITextureEffectFactory> _programFactories = new(StringComparer.Ordinal);
     private readonly SkiaShaderEffectProgramResolver? _programs;
@@ -18,64 +24,88 @@ public sealed class AvaloniaEffectRuntime : IDisposable, IEffectPresenter
     private long _nextTextureEffectInsertionOrder;
     public IEffectCatalog Catalog { get; }
 
-    public AvaloniaEffectRuntime(GamePageViewModel page, SkiaShaderEffectProgramResolver? programs = null)
+    public AvaloniaEffectRuntime(GamePageViewModel page, SkiaShaderEffectProgramResolver? programs = null, IAssetManager? assets = null)
     {
         _page = page;
         _textureFactories = DiscoverTextureFactories().ToDictionary(factory => factory.Definition.Id, StringComparer.OrdinalIgnoreCase);
         _programs = programs;
+        _assets = assets;
         Catalog = new EffectCatalog(_textureFactories.Values.Select(factory => factory.Definition));
     }
 
     public static IEffectCatalog CreateDefaultCatalog() => new EffectCatalog(DiscoverTextureFactories().Select(factory => factory.Definition));
-    public static IEnumerable<ITextureEffectFactory> DiscoverTextureFactories() => typeof(SceneLayerHost).Assembly
-        .GetTypes().Where(type => !type.IsAbstract && typeof(ITextureEffectFactory).IsAssignableFrom(type) && type.GetConstructor(Type.EmptyTypes) is not null)
-        .Select(type => (ITextureEffectFactory)Activator.CreateInstance(type)!);
+    // Built-in effects are project shader resources, resolved explicitly by
+    // GetProgramFactoryAsync. There are no parameterless renderer factories.
+    // Keep this public entry point without scanning/rooting the renderer assembly.
+    public static IEnumerable<ITextureEffectFactory> DiscoverTextureFactories() => [];
 
     public async Task StartEffectAsync(EffectRequest request, CancellationToken cancellationToken)
     {
+        ObjectDisposedException.ThrowIf(_disposed, this);
         if (string.IsNullOrWhiteSpace(request.InstanceId)) return;
+        var generation = _preparations.AddOrUpdate(request.InstanceId, 1, static (_, value) => value + 1);
         if (!string.IsNullOrWhiteSpace(request.ProgramResource))
         {
+            ShaderTextureBindings? textures = null;
             try
             {
                 var stage = string.IsNullOrWhiteSpace(request.TargetHandleId) ? EffectStage.ScenePost : EffectStage.Layer;
                 var factory = await GetProgramFactoryAsync(request.ProgramResource, stage, cancellationToken);
-                await UiDispatcher.InvokeAsync(() => StartTextureEffect(request, factory));
+                textures = await LoadTexturesAsync(request, cancellationToken);
+                await UiDispatcher.InvokeAsync(() =>
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    if (_disposed || _preparations.GetValueOrDefault(request.InstanceId) != generation) return;
+                    StartTextureEffect(request, factory, textures);
+                    textures = null; // The published instance now owns the leases.
+                });
             }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
             catch (Exception error)
             {
                 if (_reportedProgramFailures.Add(request.ProgramResource))
                     System.Diagnostics.Trace.TraceWarning("Shader program '{0}' could not be applied; using identity rendering. {1}", request.ProgramResource, error.Message);
             }
+            finally { textures?.Dispose(); }
             return;
         }
         foreach (var diagnostic in Catalog.Validate(request.Id, request.TargetHandleId, request.Parameters))
             System.Diagnostics.Trace.TraceWarning("Effect diagnostic: {0}", diagnostic);
         if (_textureFactories.TryGetValue(request.Id, out var textureFactory))
         {
-            await UiDispatcher.InvokeAsync(() => StartTextureEffect(request, textureFactory));
+            await UiDispatcher.InvokeAsync(() =>
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                if (!_disposed && _preparations.GetValueOrDefault(request.InstanceId) == generation) StartTextureEffect(request, textureFactory);
+            });
             return;
         }
     }
 
-    public Task StopEffectAsync(string instanceId, CancellationToken cancellationToken) =>
-        UiDispatcher.InvokeAsync(() => StopTextureEffect(instanceId));
+    public Task StopEffectAsync(string instanceId, CancellationToken cancellationToken)
+    {
+        _preparations.AddOrUpdate(instanceId, 1, static (_, value) => value + 1);
+        return UiDispatcher.InvokeAsync(() => StopTextureEffect(instanceId));
+    }
 
     public void Clear()
     {
+        foreach (var id in _preparations.Keys) _preparations.AddOrUpdate(id, 1, static (_, value) => value + 1);
         foreach (var id in _textureInstances.Keys.ToArray()) StopTextureEffect(id);
     }
 
     public void Dispose()
     {
+        if (_disposed) return;
+        _disposed = true;
         Clear();
         _programs?.Dispose();
     }
 
-    private void StartTextureEffect(EffectRequest request, ITextureEffectFactory factory)
+    private void StartTextureEffect(EffectRequest request, ITextureEffectFactory factory, ShaderTextureBindings? textures = null)
     {
         StopTextureEffect(request.InstanceId);
-        var instance = new SceneEffectInstance(request.InstanceId, factory, request.TargetHandleId, request.Order, request.Parameters, Interlocked.Increment(ref _nextTextureEffectInsertionOrder));
+        var instance = new SceneEffectInstance(request.InstanceId, factory, request.TargetHandleId, request.Order, request.Parameters, Interlocked.Increment(ref _nextTextureEffectInsertionOrder), textures);
         _textureInstances.Add(instance.InstanceId, instance);
         _page.TextureEffects.Add(instance);
         foreach (var property in factory.Definition.AnimatableProperties)
@@ -94,6 +124,31 @@ private void StartTextureEffect(EffectRequest request, ITextureEffectFactory fac
         }
     }
 
+    private async Task<ShaderTextureBindings> LoadTexturesAsync(EffectRequest request, CancellationToken cancellationToken)
+    {
+        var bindings = new ShaderTextureBindings();
+        try
+        {
+            if (!_programs!.TryGetDescriptor(new EffectProgramResource(request.ProgramResource), out var descriptor))
+                throw new InvalidOperationException("Shader metadata is unavailable.");
+            using var parameters = JsonDocument.Parse(string.IsNullOrWhiteSpace(request.Parameters) ? "{}" : request.Parameters);
+            foreach (var parameter in descriptor.Parameters.Where(parameter => parameter.Kind == ShaderEffectParameterKind.Texture))
+            {
+                var id = parameters.RootElement.TryGetProperty(parameter.Name, out var value) && value.ValueKind == JsonValueKind.String ? value.GetString() : null;
+                if (string.IsNullOrWhiteSpace(id))
+                {
+                    if (parameter.Required) throw new InvalidDataException($"Shader texture '{parameter.Name}' is required.");
+                    continue;
+                }
+                var lease = _assets is null ? null : await _assets.AcquireAsync<SceneTexture>(id, cancellationToken);
+                if (lease is null) throw new InvalidDataException($"Shader texture '{id}' could not be loaded.");
+                bindings.Add(parameter.Name, lease);
+            }
+            return bindings;
+        }
+        catch { bindings.Dispose(); throw; }
+    }
+
     private async Task<ITextureEffectFactory> GetProgramFactoryAsync(string resource, EffectStage stage, CancellationToken cancellationToken)
     {
         var key = $"{stage}:{resource}";
@@ -110,6 +165,7 @@ private void StopTextureEffect(string instanceId)
         if (!_textureInstances.Remove(instanceId, out var instance)) return;
         _page.UnregisterEffectAnimations(instanceId);
         _page.TextureEffects.Remove(instance);
+        instance.Dispose();
     }
 
     private sealed class UiDispatcher
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaGamePresenters.cs b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaGamePresenters.cs
index 00ab180b..cffa4bf5 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaGamePresenters.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaGamePresenters.cs
@@ -1,5 +1,6 @@
 using GalNet.Avalonia.GameView.Page;
 using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Core.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Rendering.Scene;
 
@@ -42,6 +43,7 @@ public AvaloniaGamePresenters(
     public IAnimationPresenter AnimationPresenter { get; }
     public IParticlePresenter ParticlePresenter { get; }
     public Task InitialPresentationReady => _dialogue.InitialPresentationReady;
+    public void SetReadingContext(bool wasRead) => _dialogue.SetReadingContext(wasRead);
 
     public void CompleteInitialPresentation() => _dialogue.CompleteInitialPresentation();
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaLayerPresenter.cs b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaLayerPresenter.cs
index a09ff3a8..e84d117f 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaLayerPresenter.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Presentation/AvaloniaLayerPresenter.cs
@@ -1,5 +1,5 @@
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Rendering.Scene;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Services/AssetGalleryResourceResolver.cs b/src/Presentation/GalNet.Avalonia.GameView/Services/AssetGalleryResourceResolver.cs
index da98923f..c1e653cc 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Services/AssetGalleryResourceResolver.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Services/AssetGalleryResourceResolver.cs
@@ -1,6 +1,6 @@
 using GalNet.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
 
 namespace GalNet.Avalonia.GameView.Services;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Services/AvaloniaGameScreenshotService.cs b/src/Presentation/GalNet.Avalonia.GameView/Services/AvaloniaGameScreenshotService.cs
index 23662985..b0ee0bc3 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Services/AvaloniaGameScreenshotService.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Services/AvaloniaGameScreenshotService.cs
@@ -21,13 +21,13 @@ public async Task CaptureAsync(GameScreenshotRequest request, CancellationToken
         var viewModel = new ScreenshotDialogViewModel(
             directory,
             fileName,
-            request.CapturePngAsync,
+            request.CapturePreviewPngAsync ?? request.CapturePngAsync,
             async (targetDirectory, targetFileName, includeUi) =>
             {
                 try
                 {
                     if (string.IsNullOrWhiteSpace(targetFileName))
-                        return "Enter a file name.";
+                        return ScreenshotDialogViewModel.Text("Screenshot.FileNameRequired", "Enter a file name.");
 
                     if (!targetFileName.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
                         targetFileName += ".png";
@@ -40,7 +40,7 @@ public async Task CaptureAsync(GameScreenshotRequest request, CancellationToken
                 }
                 catch (Exception exception)
                 {
-                    return $"Could not save screenshot: {exception.Message}";
+                    return $"{ScreenshotDialogViewModel.Text("Screenshot.SaveFailed", "Could not save screenshot.")} {exception.Message}";
                 }
             });
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Services/GalleryMediaService.cs b/src/Presentation/GalNet.Avalonia.GameView/Services/GalleryMediaService.cs
index 851fa96f..8bcc94f2 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Services/GalleryMediaService.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Services/GalleryMediaService.cs
@@ -1,5 +1,5 @@
 using Avalonia.Media.Imaging;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using LibVLCSharp.Shared;
 using LibVlcMedia = LibVLCSharp.Shared.Media;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Services/IGameScreenshotService.cs b/src/Presentation/GalNet.Avalonia.GameView/Services/IGameScreenshotService.cs
index 097557ae..dcea2c9c 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Services/IGameScreenshotService.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Services/IGameScreenshotService.cs
@@ -14,4 +14,13 @@ public interface IGameScreenshotService
 public sealed record GameScreenshotRequest(
     string GameTitle,
     TopLevel? Owner,
-    Func<bool, Task<byte[]>> CapturePngAsync);
+    Func<bool, Task<byte[]>> CapturePngAsync)
+{
+    public Func<bool, Task<byte[]>>? CapturePreviewPngAsync { get; init; }
+}
+
+/// <summary>Optional host integration for capturing the scene associated with a save.</summary>
+public interface ISavePreviewSource
+{
+    Func<byte[]?>? CaptureSavePreview { get; set; }
+}
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Services/ScreenshotDialogViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/Services/ScreenshotDialogViewModel.cs
index b8d507c6..0e3e356b 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Services/ScreenshotDialogViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Services/ScreenshotDialogViewModel.cs
@@ -1,3 +1,4 @@
+using GalNet.Avalonia.GameView.MarkupExtensions;
 using Irihi.Avalonia.Shared.Contracts;
 
 namespace GalNet.Avalonia.GameView.Services;
@@ -6,6 +7,7 @@ public sealed class ScreenshotDialogViewModel : IDialogContext
 {
     private readonly Func<bool, Task<byte[]>> _capture;
     private readonly Func<string, string, bool, Task<string?>> _save;
+    private readonly Dictionary<bool, Task<byte[]>> _previews = [];
 
     public ScreenshotDialogViewModel(
         string directoryPath,
@@ -25,7 +27,12 @@ public ScreenshotDialogViewModel(
     public string? Error { get; private set; }
     public event EventHandler<object?>? RequestClose;
 
-    public Task<byte[]> CapturePreviewAsync() => _capture(IncludeUi);
+    public Task<byte[]> CapturePreviewAsync()
+    {
+        var includeUi = IncludeUi;
+        if (_previews.TryGetValue(includeUi, out var cached) && !cached.IsFaulted && !cached.IsCanceled) return cached;
+        return _previews[includeUi] = _capture(includeUi);
+    }
 
     public async Task SaveAsync()
     {
@@ -35,4 +42,5 @@ public async Task SaveAsync()
 
     public void Cancel() => RequestClose?.Invoke(this, false);
     public void Close() => Cancel();
+    internal static string Text(string key, string fallback) => PlayerTextExtension.Resolve?.Invoke(key)?.ToString() ?? fallback;
 }
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Settings/NumericSettings.cs b/src/Presentation/GalNet.Avalonia.GameView/Settings/NumericSettings.cs
index dff57005..92ed9ae1 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Settings/NumericSettings.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Settings/NumericSettings.cs
@@ -1,5 +1,5 @@
-using System.Text.Json;
 using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Avalonia.GameView.Settings;
 
@@ -9,7 +9,8 @@ public IntSetting(string id, string nameKey, int defaultValue, int minimum, int
         Func<int> read, Func<int, CancellationToken, Task> apply, object? label = null, Func<int>? forcedValue = null)
         : base(id, nameKey, defaultValue, read, apply, label, forcedValue)
     {
-        ValueContract = new(typeof(int), constraints: JsonSerializer.SerializeToElement(new { minimum, maximum }));
+        ValueContract = new(typeof(int), constraints: JsonCodec.SerializeToElement(new Dictionary<string, int>
+        { ["minimum"] = minimum, ["maximum"] = maximum }));
         if (ValueValidation.ValidateValue(ValueContract, defaultValue) is not null || step <= 0)
             throw new ArgumentException("Invalid integer setting bounds/default/step.");
         Minimum = minimum; Maximum = maximum; Step = step;
@@ -33,7 +34,8 @@ public DoubleSetting(string id, string nameKey, double defaultValue, double mini
     {
         if (!double.IsFinite(minimum) || !double.IsFinite(maximum) || !double.IsFinite(step) || step <= 0)
             throw new ArgumentException("Invalid numeric setting bounds/default/step.");
-        ValueContract = new(typeof(double), constraints: JsonSerializer.SerializeToElement(new { minimum, maximum }));
+        ValueContract = new(typeof(double), constraints: JsonCodec.SerializeToElement(new Dictionary<string, double>
+        { ["minimum"] = minimum, ["maximum"] = maximum }));
         if (ValueValidation.ValidateValue(ValueContract, defaultValue) is not null)
             throw new ArgumentException("Invalid numeric setting default.");
         Minimum = minimum; Maximum = maximum; Step = step;
diff --git a/src/Presentation/GalNet.Avalonia.GameView/Settings/SettingItem.cs b/src/Presentation/GalNet.Avalonia.GameView/Settings/SettingItem.cs
index 8592f8e4..97c55010 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/Settings/SettingItem.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/Settings/SettingItem.cs
@@ -23,6 +23,7 @@ public SettingCategory(string id, string nameKey, IEnumerable<SettingItem> items
     public string NameKey { get; }
     public object Label { get; }
     public IReadOnlyList<SettingItem> Items { get; }
+    public IReadOnlyList<SettingItem> DisplayItems => Items.Where(item => !Items.Any(parent => ReferenceEquals(parent.InlineToggle, item))).ToArray();
 }
 
 public abstract class SettingItem : ObservableObject
@@ -42,6 +43,7 @@ protected SettingItem(string id, string nameKey, object? label = null)
     public string NameKey { get; }
     public object Label { get; }
     public string? DescriptionKey { get; init; }
+    public BoolSetting? InlineToggle { get; init; }
     public bool IsFullWidth { get; init; }
     public int EditorColumn => IsFullWidth ? 0 : 1;
     public int EditorColumnSpan => IsFullWidth ? 2 : 1;
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/AudioGalleryPageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/AudioGalleryPageViewModel.cs
index 611fd8c9..b4e532f0 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/AudioGalleryPageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/AudioGalleryPageViewModel.cs
@@ -5,7 +5,7 @@
 using CommunityToolkit.Mvvm.Input;
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Services;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/CgGalleryImagePageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/CgGalleryImagePageViewModel.cs
index 12c9fe09..593d54e4 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/CgGalleryImagePageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/CgGalleryImagePageViewModel.cs
@@ -3,7 +3,7 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Services;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/CgGalleryPageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/CgGalleryPageViewModel.cs
index 196588b1..69b05718 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/CgGalleryPageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/CgGalleryPageViewModel.cs
@@ -1,6 +1,6 @@
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Services;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryEntryViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryEntryViewModel.cs
index db8f2d53..bdce600f 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryEntryViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryEntryViewModel.cs
@@ -1,7 +1,7 @@
 using System.Globalization;
 using Avalonia.Media.Imaging;
 using CommunityToolkit.Mvvm.ComponentModel;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryPageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryPageViewModel.cs
index 57c970bc..08e6c5d0 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryPageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryPageViewModel.cs
@@ -2,7 +2,7 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using GalNet.Avalonia.GameView.Navigation;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryVisualPageViewModelBase.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryVisualPageViewModelBase.cs
index 7a810d91..8cb5ca15 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryVisualPageViewModelBase.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GalleryVisualPageViewModelBase.cs
@@ -1,7 +1,7 @@
 using System.Collections.ObjectModel;
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Services;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.History.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.History.cs
new file mode 100644
index 00000000..755f0f1f
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.History.cs
@@ -0,0 +1,89 @@
+using Avalonia.Media;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GalNet.Presentation.Abstractions.Application;
+
+namespace GalNet.Avalonia.GameView.ViewModels;
+
+public partial class GamePageViewModel
+{
+    [ObservableProperty] private bool _isHistoryOpen;
+    [ObservableProperty] private IReadOnlyList<DialogueHistoryLine> _historyLines = [];
+    [ObservableProperty] private bool _canReplayDialogue;
+    [ObservableProperty] private bool _isVoiceReplaying;
+    [ObservableProperty] private IBrush? _readTextBrush;
+    private DialogueHistoryLine? _currentDialogue;
+    private Func<IReadOnlyList<DialogueHistoryLine>>? _getHistoryLines;
+    public Func<IReadOnlyList<DialogueHistoryLine>>? GetHistoryLines
+    {
+        get => _getHistoryLines;
+        set { _getHistoryLines = value; OnPropertyChanged(nameof(HasHistory)); }
+    }
+    public Func<DialogueVoice, Task>? PlayVoiceAsync { get; set; }
+    public event Action? StopVoiceReplayRequested;
+    public bool HasHistory => GetHistoryLines is not null;
+    public bool IsHistoryEmpty => HistoryLines.Count == 0;
+    public string ReplayIcon => IsVoiceReplaying ? "■" : "🔊";
+
+    public void SetCurrentDialogue(DialogueHistoryLine line, bool voiceFinished)
+    {
+        _currentDialogue = line;
+        CanReplayDialogue = line.Voice is not null && voiceFinished;
+    }
+    public void CompleteDialogueVoice(DialogueHistoryLine line)
+    {
+        if (ReferenceEquals(line, _currentDialogue)) CanReplayDialogue = line.Voice is not null;
+    }
+
+    public void NotifyStoryContinuing() => StopVoiceReplayRequested?.Invoke();
+
+    [RelayCommand]
+    private void OpenHistory()
+    {
+        if (!HasHistory || IsHistoryOpen || IsSkipConfirmationOpen) return;
+        CancelPlayback();
+        HistoryLines = GetHistoryLines!();
+        IsHistoryOpen = true;
+    }
+
+    [RelayCommand]
+    private void CloseHistory()
+    {
+        if (!IsHistoryOpen) return;
+        IsHistoryOpen = false;
+        StopVoiceReplayRequested?.Invoke();
+    }
+
+    [RelayCommand]
+    private Task ReplayDialogueAsync() => CanReplayDialogue && _currentDialogue is { } line ? ReplayHistoryVoiceAsync(line) : Task.CompletedTask;
+
+    [RelayCommand]
+    private async Task ReplayHistoryVoiceAsync(DialogueHistoryLine line)
+    {
+        CancelPlayback();
+        if (IsVoiceReplaying)
+        {
+            StopVoiceReplayRequested?.Invoke();
+            // A repeated click on the current dialogue toggles playback off.
+            if (ReferenceEquals(line, _replayingLine)) { _replayingLine = null; return; }
+        }
+        if (line.Voice is not { } voice || PlayVoiceAsync is null) return;
+        _replayingLine = line;
+        try { await PlayVoiceAsync(voice); }
+        catch (Exception error) { StatusMessage = error.Message; }
+    }
+    private DialogueHistoryLine? _replayingLine;
+
+    public void ResetDialogueHistory()
+    {
+        CloseHistory();
+        StopVoiceReplayRequested?.Invoke();
+        HistoryLines = [];
+        _currentDialogue = null;
+        _replayingLine = null;
+        CanReplayDialogue = false;
+        IsVoiceReplaying = false;
+    }
+    partial void OnIsVoiceReplayingChanged(bool value) => OnPropertyChanged(nameof(ReplayIcon));
+    partial void OnHistoryLinesChanged(IReadOnlyList<DialogueHistoryLine> value) => OnPropertyChanged(nameof(IsHistoryEmpty));
+}
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.Playback.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.Playback.cs
index bcf1ec6f..c22601e2 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.Playback.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.Playback.cs
@@ -1,15 +1,21 @@
 using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
+using GalNet.Core.Execution;
 using GalNet.Core.Primitives;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
-public sealed partial class GamePageViewModel
+public partial class GamePageViewModel
 {
     public GalNet.Avalonia.GameView.Input.PlayerInputSettings? Input { get; set; }
-    public Task SetQuickHeldAsync(bool held) => RequestModeAsync(held ? PlaybackMode.Quick : PlaybackMode.Manual);
+    public Task SetQuickHeldAsync(bool held)
+    {
+        if (IsHistoryOpen) return Task.CompletedTask;
+        if (held) NotifyStoryContinuing();
+        return RequestModeAsync(held ? PlaybackMode.Quick : PlaybackMode.Manual);
+    }
     private IPlayerPlaybackController? _playback;
     private Task _playbackRequests = Task.CompletedTask;
     private PlaybackMode? _pointerToggle;
@@ -52,7 +58,8 @@ public void CancelPlayback()
     [RelayCommand] private Task ToggleAutoAsync() => ToggleAsync(PlaybackMode.Auto);
     private Task ToggleAsync(PlaybackMode target)
     {
-        if (IsSkipConfirmationOpen) return Task.CompletedTask;
+        if (IsSkipConfirmationOpen || IsHistoryOpen) return Task.CompletedTask;
+        NotifyStoryContinuing();
         var selected = _pointerToggle == target ? _pointerWasSelected : PlaybackMode == target;
         _pointerToggle = null;
         return RequestModeAsync(selected ? PlaybackMode.Manual : target);
@@ -86,6 +93,8 @@ private async Task ApplyModeAsync(Task previous, IPlayerPlaybackController? cont
     [RelayCommand]
     private void RequestSkip()
     {
+        if (IsHistoryOpen) return;
+        NotifyStoryContinuing();
         CancelPlayback();
         if (_playback is not null) IsSkipConfirmationOpen = true;
     }
@@ -94,6 +103,7 @@ private void RequestSkip()
     private async Task ConfirmSkipAsync(CancellationToken cancellationToken)
     {
         if (!IsSkipConfirmationOpen) return;
+        NotifyStoryContinuing();
         var controller = _playback;
         IsSkipConfirmationOpen = false;
         await _playbackRequests;
@@ -103,8 +113,8 @@ private async Task ConfirmSkipAsync(CancellationToken cancellationToken)
         catch (Exception error) { ReportPlaybackFailure(controller, error); }
     }
 
-    public Task RefreshPlaybackSettingsAsync(CancellationToken cancellationToken = default) =>
-        _playback?.RefreshPlaybackSettingsAsync(cancellationToken) ?? Task.CompletedTask;
+    public Task UpdatePlaybackOptionsAsync(PlaybackOptions options, CancellationToken cancellationToken = default) =>
+        _playback?.UpdatePlaybackOptionsAsync(options, cancellationToken) ?? Task.CompletedTask;
     private void ReportPlaybackFailure(IPlayerPlaybackController? controller, Exception error)
     {
         if (!ReferenceEquals(controller, _playback)) return;
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.cs
index 13e179aa..c3f74b90 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GamePageViewModel.cs
@@ -3,14 +3,14 @@
 using Avalonia.Media;
 using CommunityToolkit.Mvvm.Input;
 using GalNet.Avalonia.GameView.Navigation;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Game.Controls;
 using GalNet.Rendering.Scene;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
 /// <summary>Platform UI state shared by the editor preview and the official Avalonia sample.</summary>
-public sealed partial class GamePageViewModel : PageViewModelBase
+public partial class GamePageViewModel : PageViewModelBase
 {
     private readonly IGameNavigationService _navigation;
     private TaskCompletionSource? _advanceWaiter;
@@ -48,7 +48,8 @@ public sealed partial class GamePageViewModel : PageViewModelBase
     [RelayCommand]
     private void Advance()
     {
-        if (IsSkipConfirmationOpen) return;
+        if (IsSkipConfirmationOpen || IsHistoryOpen) return;
+        NotifyStoryContinuing();
         if (IsUiHidden)
         {
             InteractionObserved?.Invoke("advance.restore-ui");
@@ -70,7 +71,7 @@ private Task OpenLoadSlotsAsync(CancellationToken cancellationToken) =>
 
     [RelayCommand] private void ToggleNvlMode() => IsNvlMode = !IsNvlMode;
     [RelayCommand] private void OpenSettings() => _navigation.Navigate<SettingsPageViewModel>();
-    [RelayCommand] private void ReturnToTitle() => ReturnToTitleRequested?.Invoke();
+    [RelayCommand] private void ReturnToTitle() { CloseHistory(); NotifyStoryContinuing(); ReturnToTitleRequested?.Invoke(); }
     [RelayCommand] private void RequestScreenshot() => ScreenshotRequested?.Invoke();
     [RelayCommand] private void HideUi() => IsUiHidden = true;
     [RelayCommand] private void ReturnToGame() => _navigation.GoBack();
@@ -119,6 +120,8 @@ public Task<int> WaitForChoiceAsync(IEnumerable<string> options, CancellationTok
     [RelayCommand]
     private void CompleteChoice(int selectedIndex)
     {
+        if (IsHistoryOpen) return;
+        NotifyStoryContinuing();
         InteractionObserved?.Invoke($"choice.selected:{selectedIndex}");
         _choiceWaiter?.TrySetResult(selectedIndex);
     }
@@ -158,6 +161,7 @@ public void HideLayer(string id)
     /// <summary>Removes all host-owned visuals before a new game session is constructed.</summary>
     public void ResetScenePresentation()
     {
+        ResetDialogueHistory();
         ResetSceneVisuals();
         IsDialogueVisible = false;
         IsNvlMode = false;
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GameSaveSlotRowViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GameSaveSlotRowViewModel.cs
index 69b51d14..b4e0c38c 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GameSaveSlotRowViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GameSaveSlotRowViewModel.cs
@@ -1,13 +1,23 @@
+using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
+using GalNet.Avalonia.GameView.MarkupExtensions;
 using GalNet.Avalonia.GameView.Services;
+using Serilog;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
-public sealed class GameSaveSlotRowViewModel
+public sealed class GameSaveSlotRowViewModel : ObservableObject, IDisposable
 {
+    public global::Avalonia.Media.Imaging.Bitmap? Preview { get; }
     public int SlotIndex { get; }
     public string Timestamp { get; }
-    public string Description { get; }
+    private string _description;
+    public string Description { get => _description; private set => SetProperty(ref _description, value); }
+    private string? _renameError;
+    public string? RenameError { get => _renameError; private set => SetProperty(ref _renameError, value); }
+    private readonly bool _canRename;
+    public bool CanRename => _canRename && !RenameCommand.IsRunning;
+    public IAsyncRelayCommand<string> RenameCommand { get; }
     public bool IsEmpty { get; }
     public bool IsCorrupt { get; }
     public bool IsSaveMode { get; }
@@ -15,14 +25,48 @@ public sealed class GameSaveSlotRowViewModel
     public IAsyncRelayCommand LoadCommand { get; }
 
     public GameSaveSlotRowViewModel(GameSaveSlot slot, bool isSaveMode, Func<int, Task> save, Func<int, Task> load)
+        : this(slot, isSaveMode, save, load, null) { }
+
+    public GameSaveSlotRowViewModel(GameSaveSlot slot, bool isSaveMode, Func<int, Task> save, Func<int, Task> load, Func<int, string, Task<string>>? rename)
     {
+        if (slot.PreviewImage is { Length: > 0 } bytes)
+        {
+            try { using var stream = new MemoryStream(bytes); Preview = global::Avalonia.Media.Imaging.Bitmap.DecodeToWidth(stream, 480); }
+            catch (Exception) { /* A damaged preview must not make the save unusable. */ }
+        }
         SlotIndex = slot.SlotIndex;
         Timestamp = slot.DisplayTimestamp;
-        Description = slot.Description;
+        _description = slot.Description;
         IsEmpty = slot.IsEmpty;
         IsCorrupt = slot.IsCorrupt;
         IsSaveMode = isSaveMode;
-        SaveCommand = new AsyncRelayCommand(() => save(SlotIndex));
-        LoadCommand = new AsyncRelayCommand(() => load(SlotIndex), () => !IsEmpty && !IsCorrupt);
+        _canRename = rename is not null && !IsEmpty && !IsCorrupt;
+        RenameCommand = new AsyncRelayCommand<string>(async name =>
+        {
+            try
+            {
+                RenameError = null;
+                Description = await rename!(SlotIndex, name ?? "");
+            }
+            catch (Exception exception)
+            {
+                Log.Error(exception, "Failed to rename save slot {SlotIndex}", SlotIndex);
+                RenameError = PlayerTextExtension.Resolve?.Invoke("SaveSlots.RenameFailed")?.ToString() ?? "Could not save the name. Try again.";
+            }
+        }, _ => _canRename);
+        RenameCommand.PropertyChanged += OnRenameStateChanged;
+        SaveCommand = new AsyncRelayCommand(async () => { await FinishRenameAsync(); if (RenameError is null) await save(SlotIndex); });
+        LoadCommand = new AsyncRelayCommand(async () => { await FinishRenameAsync(); if (RenameError is null) await load(SlotIndex); }, () => !IsEmpty && !IsCorrupt);
+    }
+    private Task FinishRenameAsync() => RenameCommand.ExecutionTask ?? Task.CompletedTask;
+    private void OnRenameStateChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(RenameCommand.IsRunning)) OnPropertyChanged(nameof(CanRename));
+    }
+    internal void UpdateDescription(string description) => Description = description;
+    public void Dispose()
+    {
+        RenameCommand.PropertyChanged -= OnRenameStateChanged;
+        Preview?.Dispose();
     }
 }
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GameShellViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GameShellViewModel.cs
index 8d490ed0..30ef5de0 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GameShellViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/GameShellViewModel.cs
@@ -4,7 +4,7 @@
 namespace GalNet.Avalonia.GameView.ViewModels;
 
 /// <summary>Scope-owned navigation host for the default game pages.</summary>
-public sealed class GameShellViewModel : ObservableObject, IDisposable
+public class GameShellViewModel : ObservableObject, IDisposable
 {
     private readonly IGameNavigationService _navigation;
 
@@ -16,7 +16,7 @@ public GameShellViewModel(IGameNavigationService navigation)
 
     public PageViewModelBase? CurrentViewModel => _navigation.CurrentViewModel;
 
-    public void Dispose() => _navigation.CurrentViewModelChanged -= OnCurrentViewModelChanged;
+    public virtual void Dispose() => _navigation.CurrentViewModelChanged -= OnCurrentViewModelChanged;
 
     private void OnCurrentViewModelChanged(object? sender, EventArgs e) => OnPropertyChanged(nameof(CurrentViewModel));
 }
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/MissingGalleryPageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/MissingGalleryPageViewModel.cs
index 073b764a..50de38c8 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/MissingGalleryPageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/MissingGalleryPageViewModel.cs
@@ -1,6 +1,6 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using GalNet.Avalonia.GameView.Navigation;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/SaveSlotsPageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/SaveSlotsPageViewModel.cs
index bc0adb38..9fe1612a 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/SaveSlotsPageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/SaveSlotsPageViewModel.cs
@@ -18,6 +18,7 @@ public sealed partial class SaveSlotsPageViewModel : BackNavigablePageViewModel,
     public ObservableCollection<GameSaveSlotRowViewModel> Slots { get; } = [];
     [CommunityToolkit.Mvvm.ComponentModel.ObservableProperty] private SaveSlotsMode _mode;
     public string Heading => Mode == SaveSlotsMode.Save ? "Save game" : "Load game";
+    public string HeadingKey => Mode == SaveSlotsMode.Save ? "SaveSlots.SaveTitle" : "SaveSlots.LoadTitle";
     public bool IsSaveMode => Mode == SaveSlotsMode.Save;
 
     public SaveSlotsPageViewModel(
@@ -59,23 +60,47 @@ public Task ActivateAsync(SaveSlotsMode mode, CancellationToken cancellationToke
     {
         Mode = mode;
         OnPropertyChanged(nameof(Heading));
+        OnPropertyChanged(nameof(HeadingKey));
         OnPropertyChanged(nameof(IsSaveMode));
         RebuildRows();
         return Task.CompletedTask;
     }
 
-    public void Dispose() => ((INotifyCollectionChanged)_session.SaveSlots).CollectionChanged -= OnSlotsChanged;
-    private void OnSlotsChanged(object? sender, NotifyCollectionChangedEventArgs e) => RebuildRows();
+    public void Dispose()
+    {
+        ((INotifyCollectionChanged)_session.SaveSlots).CollectionChanged -= OnSlotsChanged;
+        foreach (var row in Slots) row.Dispose();
+        Slots.Clear();
+    }
+    private void OnSlotsChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        if (e.Action == NotifyCollectionChangedAction.Replace && e.NewStartingIndex >= 0 && e.NewItems is { Count: 1 }
+            && e.NewItems[0] is GameSaveSlot replacement && e.NewStartingIndex < Slots.Count)
+        {
+            if (e.OldItems?[0] is GameSaveSlot previous && replacement with { Description = previous.Description } == previous)
+                Slots[e.NewStartingIndex].UpdateDescription(replacement.Description);
+            else
+            {
+                var old = Slots[e.NewStartingIndex];
+                Slots[e.NewStartingIndex] = CreateRow(replacement);
+                old.Dispose();
+            }
+            return;
+        }
+        RebuildRows();
+    }
+    private GameSaveSlotRowViewModel CreateRow(GameSaveSlot slot) => new(
+        slot, Mode == SaveSlotsMode.Save, SaveSlotAsync,
+        slotIndex => LoadSlotAsync(slotIndex, CancellationToken.None),
+        _session is ISaveSlotNamingSession { CanRenameSlots: true } naming
+            ? (slotIndex, name) => naming.RenameSlotAsync(slotIndex, name) : null);
     private void RebuildRows()
     {
+        foreach (var row in Slots) row.Dispose();
         Slots.Clear();
         foreach (var slot in _session.SaveSlots)
         {
-            var row = new GameSaveSlotRowViewModel(
-                slot,
-                Mode == SaveSlotsMode.Save,
-                SaveSlotAsync,
-                slotIndex => LoadSlotAsync(slotIndex, CancellationToken.None));
+            var row = CreateRow(slot);
             if (Mode == SaveSlotsMode.Save)
                 row.LoadCommand.NotifyCanExecuteChanged();
             Slots.Add(row);
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/SettingsPageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/SettingsPageViewModel.cs
index 7a2ab54c..f5898ec9 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/SettingsPageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/SettingsPageViewModel.cs
@@ -5,7 +5,7 @@
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
-public sealed partial class SettingsPageViewModel(IGameNavigationService navigation,
+public partial class SettingsPageViewModel(IGameNavigationService navigation,
     IPlayerSettingsService settings)
     : BackNavigablePageViewModel(navigation)
 {
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/TitlePageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/TitlePageViewModel.cs
index 10a6a87c..2e09bd72 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/TitlePageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/TitlePageViewModel.cs
@@ -3,12 +3,12 @@
 using CommunityToolkit.Mvvm.Input;
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Services;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using Serilog;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
-public sealed partial class TitlePageViewModel : PageViewModelBase, IDisposable
+public partial class TitlePageViewModel : PageViewModelBase, IDisposable
 {
     private readonly IGameSessionService _session;
     private readonly IGameNavigationService _navigation;
@@ -41,7 +41,7 @@ public TitlePageViewModel(
     [ObservableProperty] private bool _isLoading;
 
     [RelayCommand]
-    private async Task StartNewGameAsync(CancellationToken cancellationToken)
+    protected virtual async Task StartNewGameAsync(CancellationToken cancellationToken)
     {
         if (!CanStartNewGame) return;
         IsLoading = true;
@@ -56,7 +56,7 @@ private async Task StartNewGameAsync(CancellationToken cancellationToken)
     }
 
     [RelayCommand]
-    private async Task ContinueAsync(CancellationToken cancellationToken)
+    protected virtual async Task ContinueAsync(CancellationToken cancellationToken)
     {
         if (!CanContinueGame) return;
         IsLoading = true;
@@ -70,6 +70,17 @@ private async Task ContinueAsync(CancellationToken cancellationToken)
         finally { IsLoading = false; }
     }
 
+    [RelayCommand]
+    protected virtual async Task StartNewGameWithVariablesAsync(IReadOnlyDictionary<string, object> variables, CancellationToken cancellationToken)
+    {
+        if (!CanStartNewGame) return;
+        if (_session is not IParameterizedGameSessionService configured)
+            throw new NotSupportedException("This session does not accept new game variables.");
+        IsLoading = true;
+        try { await LaunchGameAsync(token => configured.PrepareNewGameAsync(variables, token), cancellationToken); }
+        finally { IsLoading = false; }
+    }
+
     private Task LaunchGameAsync(Func<CancellationToken, Task> prepare, CancellationToken cancellationToken)
     {
         Func<CancellationToken, Task>? begin = null;
@@ -80,12 +91,12 @@ private Task LaunchGameAsync(Func<CancellationToken, Task> prepare, Cancellation
     }
 
     [RelayCommand]
-    private Task OpenLoadSlotsAsync(CancellationToken cancellationToken) =>
+    protected virtual Task OpenLoadSlotsAsync(CancellationToken cancellationToken) =>
         _navigation.NavigateAsync<SaveSlotsPageViewModel, SaveSlotsMode>(SaveSlotsMode.Load, cancellationToken);
 
-    [RelayCommand] private void OpenSettings() => _navigation.Navigate<SettingsPageViewModel>();
+    [RelayCommand] protected virtual void OpenSettings() => _navigation.Navigate<SettingsPageViewModel>();
     [RelayCommand]
-    private async Task OpenGalleryAsync(CancellationToken cancellationToken)
+    protected virtual async Task OpenGalleryAsync(CancellationToken cancellationToken)
     {
         var types = GetGalleryTypes();
         if (types.Count == 0) return;
@@ -96,9 +107,11 @@ private async Task OpenGalleryAsync(CancellationToken cancellationToken)
         }
         await _navigation.NavigateAsync<GalleryPageViewModel, IReadOnlyList<GalleryTypeData>>(types, cancellationToken);
     }
-    [RelayCommand] private void OpenAbout() => _navigation.Navigate<AboutPageViewModel>();
+    public Action? ExitRequested { get; set; }
+    [RelayCommand] protected virtual void Exit() => ExitRequested?.Invoke();
+    [RelayCommand] protected virtual void OpenAbout() => _navigation.Navigate<AboutPageViewModel>();
 
-    public void Dispose() => _session.PropertyChanged -= OnSessionPropertyChanged;
+    public virtual void Dispose() => _session.PropertyChanged -= OnSessionPropertyChanged;
 
     private void OnSessionPropertyChanged(object? sender, PropertyChangedEventArgs e)
     {
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/VideoGalleryPageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/VideoGalleryPageViewModel.cs
index 2c9ba73e..d77bb652 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/VideoGalleryPageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/VideoGalleryPageViewModel.cs
@@ -1,6 +1,6 @@
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Services;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
 
diff --git a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/VideoGalleryPlayerPageViewModel.cs b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/VideoGalleryPlayerPageViewModel.cs
index 419f8fd7..b72dd920 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/ViewModels/VideoGalleryPlayerPageViewModel.cs
+++ b/src/Presentation/GalNet.Avalonia.GameView/ViewModels/VideoGalleryPlayerPageViewModel.cs
@@ -2,7 +2,7 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Services;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using LibVLCSharp.Shared;
 
 namespace GalNet.Avalonia.GameView.ViewModels;
diff --git a/src/Launcher/GalNet.Launcher.iOS/packages.lock.json b/src/Presentation/GalNet.Avalonia.GameView/packages.lock.WindowsReadyToRun.json
similarity index 54%
rename from src/Launcher/GalNet.Launcher.iOS/packages.lock.json
rename to src/Presentation/GalNet.Avalonia.GameView/packages.lock.WindowsReadyToRun.json
index a0f2c0e4..bd01fbf7 100644
--- a/src/Launcher/GalNet.Launcher.iOS/packages.lock.json
+++ b/src/Presentation/GalNet.Avalonia.GameView/packages.lock.WindowsReadyToRun.json
@@ -1,45 +1,68 @@
 {
   "version": 2,
   "dependencies": {
-    "net10.0-ios27.0": {
-      "Avalonia.iOS": {
+    "net10.0": {
+      "Avalonia": {
         "type": "Direct",
         "requested": "[12.0.5, )",
         "resolved": "12.0.5",
-        "contentHash": "W1g0MLNM2iEICKM25OrdMrrQUq1zZ/4h6ZPJmqgHS+vId72qxmrlz3immldJPxv2mVMkqg/Rz7f0UZ4dWy733g==",
+        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
         "dependencies": {
-          "Avalonia": "12.0.5",
-          "Avalonia.HarfBuzz": "12.0.5",
-          "Avalonia.Skia": "12.0.5"
+          "Avalonia.BuildServices": "11.3.2",
+          "Avalonia.Remote.Protocol": "12.0.5",
+          "MicroCom.Runtime": "0.11.4"
         }
       },
-      "Microsoft.NET.ILLink.Tasks": {
+      "CommunityToolkit.Mvvm": {
+        "type": "Direct",
+        "requested": "[8.4.1, )",
+        "resolved": "8.4.1",
+        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
+      },
+      "Irihi.Ursa": {
         "type": "Direct",
-        "requested": "[10.0.12, )",
-        "resolved": "10.0.12",
-        "contentHash": "xi+BDjFpW+Sb+MHFHaH6Y/gV9I8BluFwRXc1QyCdoZbIK26eNiBeFuMTe/FMwc33G1wdHCyDg7CVTmb8OdQrMQ=="
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "G2wAmenCgMZkBOqs5MYRtlurhU2tAKKmcNJzjjaA9Mj5v3YIivuv7wyNpIpgYZ602sOZhFtQwYrCaLVUhn9Htw==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Avalonia.Shared": "0.4.0",
+          "Irihi.Avalonia.Shared.Contracts": "0.4.0"
+        }
       },
-      "Antlr4.Runtime.Standard": {
-        "type": "Transitive",
-        "resolved": "4.13.1",
-        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      "LibVLCSharp": {
+        "type": "Direct",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
+      },
+      "LibVLCSharp.Avalonia": {
+        "type": "Direct",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "juoBLjh37+07kWDblbHLaWTQx1HsXOIJHU7aeH5/95xjN6dXfZMVE8ltg8NyaNL6vr2B4QgR3EiRBsEa+fPvlQ==",
+        "dependencies": {
+          "Avalonia": "11.3.13",
+          "LibVLCSharp": "3.10.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "Direct",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      },
+      "Serilog": {
+        "type": "Direct",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
       },
       "Avalonia.BuildServices": {
         "type": "Transitive",
         "resolved": "11.3.2",
         "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
       },
-      "Avalonia.HarfBuzz": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "jR8i/fgrmAKEp0T3iLqfKCoEDJV9ODVzN+8bofM2guEr05eaXbx6iXZxcjh0nDK4UbK0akYDgBfAgyHoatqGjg==",
-        "dependencies": {
-          "Avalonia": "12.0.5",
-          "HarfBuzzSharp": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3"
-        }
-      },
       "Avalonia.Remote.Protocol": {
         "type": "Transitive",
         "resolved": "12.0.5",
@@ -50,120 +73,115 @@
         "resolved": "8.3.1.3",
         "contentHash": "NGZ2+ZVNPM+NdHB/asW0/ykWngyHWwcqjrbN2nDeH1B/aptPGlCUl8wkQ2cSJxw5fdWgdmIPmNuTPWpLwNVXWg==",
         "dependencies": {
-          "HarfBuzzSharp.NativeAssets.iOS": "8.3.1.3"
+          "HarfBuzzSharp.NativeAssets.Win32": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.macOS": "8.3.1.3"
         }
       },
-      "HarfBuzzSharp.NativeAssets.iOS": {
+      "HarfBuzzSharp.NativeAssets.Linux": {
         "type": "Transitive",
         "resolved": "8.3.1.3",
-        "contentHash": "Qc81kED8LkoY4NrkIemcpezOviUNKo+Ehf1DPRVm4gFCKoPznw+GnZC0jHoRaJvc53hybXwsvwH9iFMA32bPtQ=="
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
       },
-      "HarfBuzzSharp.NativeAssets.Linux": {
+      "HarfBuzzSharp.NativeAssets.macOS": {
         "type": "Transitive",
         "resolved": "8.3.1.3",
-        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
       },
       "HarfBuzzSharp.NativeAssets.WebAssembly": {
         "type": "Transitive",
         "resolved": "8.3.1.3",
         "contentHash": "w2QfdNm9Uz/sUa0B5D+OnVQhyq3G/fBq6ibQMdWBlQqqwh0g0/5j3RFvYqZAmRZ5+RzvjVe8o8SFFnWYUSkuxA=="
       },
-      "MicroCom.Runtime": {
+      "HarfBuzzSharp.NativeAssets.Win32": {
         "type": "Transitive",
-        "resolved": "0.11.4",
-        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
       },
-      "Microsoft.Extensions.Logging.Abstractions": {
+      "Irihi.Avalonia.Shared": {
         "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
+        "resolved": "0.4.0",
+        "contentHash": "T6+jezCUjisJNz6zkNcNLVNI2ttWznbyQnW6MS9L45EXhePqRCIxB3xV/5L8gFAJ83JrhiCIokMOxRWdq9/1Zg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
+          "Avalonia": "12.0.0"
         }
       },
-      "Microsoft.IO.RecyclableMemoryStream": {
+      "Irihi.Avalonia.Shared.Contracts": {
         "type": "Transitive",
-        "resolved": "3.0.1",
-        "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g=="
+        "resolved": "0.4.0",
+        "contentHash": "Du8DY2YqlSmCmywqZtuOhgwLkgklMeE1ajZ4Dd/iqVz6HmAKptjVTqA1oloZX5ihqsdKRiNuUGCdYPe1rekf2Q=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
       },
       "SkiaSharp": {
         "type": "Transitive",
         "resolved": "3.119.4",
         "contentHash": "53NOSUZ1Us+91Sm0uCkIivh/k7jOowRErZT2sIWwPFN9mLUvdxnE6rS4sWo4255+Rd2MWUSF+j0NMZHD6Cke+Q==",
         "dependencies": {
-          "SkiaSharp.NativeAssets.iOS": "3.119.4"
+          "SkiaSharp.NativeAssets.Win32": "3.119.4",
+          "SkiaSharp.NativeAssets.macOS": "3.119.4"
         }
       },
-      "SkiaSharp.NativeAssets.iOS": {
+      "SkiaSharp.NativeAssets.Linux": {
         "type": "Transitive",
         "resolved": "3.119.4",
-        "contentHash": "ObEOu9MVakx4mrNiCJ+T8tp36qb3CM+fpRSqlQ7EZdl4ZndZBUlLNOBEsHje98I6SEILTEZQU3Rn8l5w+dYJdw=="
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
       },
-      "SkiaSharp.NativeAssets.Linux": {
+      "SkiaSharp.NativeAssets.macOS": {
         "type": "Transitive",
         "resolved": "3.119.4",
-        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
       },
       "SkiaSharp.NativeAssets.WebAssembly": {
         "type": "Transitive",
         "resolved": "3.119.4",
         "contentHash": "S1HOxtBbD4bYDtA2e9WH5TX+lxqRrTPvKjrjttRhxnHNNu7YY8VFo/LeCP7tNqoTA6PV+8vsvNbmRUEC2ip8RQ=="
       },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      },
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
-      "galnet.core": {
-        "type": "Project"
-      },
-      "galnet.launcher": {
+      "galnet.avalonia.controls": {
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
-          "Avalonia.Fonts.Inter": "[12.0.5, )",
-          "Avalonia.Themes.Fluent": "[12.0.5, )",
-          "AvaloniaUI.DiagnosticsSupport": "[2.2.3, )",
-          "CommunityToolkit.Mvvm": "[8.4.1, )",
-          "GalNet.Assets": "[1.0.0, )",
-          "GalNet.Core": "[1.0.0, )",
-          "GalNet.Runtime": "[1.0.0, )"
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
         }
       },
-      "galnet.presentation.abstractions": {
+      "galnet.avalonia.rendering": {
         "type": "Project",
         "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
-      "galnet.runtime": {
+      "galnet.contracts.builtins": {
         "type": "Project",
         "dependencies": {
-          "CoreCLR-NCalc": "[3.1.253, )",
-          "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
-          "Serilog": "[4.2.0, )"
+          "GalNet.Core": "[1.0.0, )"
         }
       },
-      "Avalonia": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
-        "dependencies": {
-          "Avalonia.BuildServices": "11.3.2",
-          "Avalonia.Remote.Protocol": "12.0.5",
-          "MicroCom.Runtime": "0.11.4"
-        }
+      "galnet.core": {
+        "type": "Project"
       },
-      "Avalonia.Fonts.Inter": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
+      "galnet.presentation.abstractions": {
+        "type": "Project",
         "dependencies": {
-          "Avalonia": "12.0.5"
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
         }
       },
       "Avalonia.Skia": {
@@ -180,74 +198,38 @@
           "SkiaSharp.NativeAssets.Linux": "3.119.4",
           "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
         }
-      },
-      "Avalonia.Themes.Fluent": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
-      "AvaloniaUI.DiagnosticsSupport": {
-        "type": "CentralTransitive",
-        "requested": "[2.2.3, )",
-        "resolved": "2.2.3",
-        "contentHash": "kQCInYusi2c9tjd9hV05Lln6Csbo07kiC672M3G7dsalDBe2j+pOk3We2nzdyy5ptQYy/9gQiC8ZaHhb6u/5Kw==",
-        "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
-          "Microsoft.IO.RecyclableMemoryStream": "3.0.1"
-        }
-      },
-      "CommunityToolkit.Mvvm": {
-        "type": "CentralTransitive",
-        "requested": "[8.4.1, )",
-        "resolved": "8.4.1",
-        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
-      },
-      "CoreCLR-NCalc": {
-        "type": "CentralTransitive",
-        "requested": "[3.1.253, )",
-        "resolved": "3.1.253",
-        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
-        "dependencies": {
-          "Antlr4.Runtime.Standard": "4.13.1"
-        }
-      },
-      "Microsoft.Extensions.DependencyInjection.Abstractions": {
-        "type": "CentralTransitive",
-        "requested": "[10.0.0, )",
-        "resolved": "8.0.0",
-        "contentHash": "cjWrLkJXK0rs4zofsK4bSdg+jhDLTaxrkXu4gS6Y7MAlCvRyNNgwY/lJi5RDlQOnSZweHqoyvgvbdvQsRIW+hg=="
-      },
-      "Serilog": {
-        "type": "CentralTransitive",
-        "requested": "[4.2.0, )",
-        "resolved": "4.2.0",
-        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
       }
     },
-    "net10.0-ios27.0/iossimulator-x64": {
-      "HarfBuzzSharp.NativeAssets.iOS": {
+    "net10.0/win-x64": {
+      "HarfBuzzSharp.NativeAssets.Linux": {
         "type": "Transitive",
         "resolved": "8.3.1.3",
-        "contentHash": "Qc81kED8LkoY4NrkIemcpezOviUNKo+Ehf1DPRVm4gFCKoPznw+GnZC0jHoRaJvc53hybXwsvwH9iFMA32bPtQ=="
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
       },
-      "HarfBuzzSharp.NativeAssets.Linux": {
+      "HarfBuzzSharp.NativeAssets.macOS": {
         "type": "Transitive",
         "resolved": "8.3.1.3",
-        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
       },
-      "SkiaSharp.NativeAssets.iOS": {
+      "HarfBuzzSharp.NativeAssets.Win32": {
         "type": "Transitive",
-        "resolved": "3.119.4",
-        "contentHash": "ObEOu9MVakx4mrNiCJ+T8tp36qb3CM+fpRSqlQ7EZdl4ZndZBUlLNOBEsHje98I6SEILTEZQU3Rn8l5w+dYJdw=="
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
       },
       "SkiaSharp.NativeAssets.Linux": {
         "type": "Transitive",
         "resolved": "3.119.4",
         "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
       }
     }
   }
diff --git a/src/Presentation/GalNet.Avalonia.GameView/packages.lock.json b/src/Presentation/GalNet.Avalonia.GameView/packages.lock.json
index 5deaefd2..3a19ff79 100644
--- a/src/Presentation/GalNet.Avalonia.GameView/packages.lock.json
+++ b/src/Presentation/GalNet.Avalonia.GameView/packages.lock.json
@@ -147,6 +147,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -154,6 +155,7 @@
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -162,6 +164,13 @@
         "dependencies": {
           "Avalonia": "[12.0.5, )",
           "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -171,6 +180,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/GalNet.Avalonia.Rendering.csproj b/src/Presentation/GalNet.Avalonia.Rendering/GalNet.Avalonia.Rendering.csproj
index 66f174e2..f0930ad6 100644
--- a/src/Presentation/GalNet.Avalonia.Rendering/GalNet.Avalonia.Rendering.csproj
+++ b/src/Presentation/GalNet.Avalonia.Rendering/GalNet.Avalonia.Rendering.csproj
@@ -9,4 +9,5 @@
     <PackageReference Include="Avalonia.Skia" />
     <ProjectReference Include="..\..\Shared\GalNet.Core\GalNet.Core.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/Scene/ParticleEmitter.cs b/src/Presentation/GalNet.Avalonia.Rendering/Scene/ParticleEmitter.cs
index 22da3802..231f2ef7 100644
--- a/src/Presentation/GalNet.Avalonia.Rendering/Scene/ParticleEmitter.cs
+++ b/src/Presentation/GalNet.Avalonia.Rendering/Scene/ParticleEmitter.cs
@@ -1,7 +1,7 @@
 using System.ComponentModel;
 using System.Globalization;
 using System.Runtime.CompilerServices;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using SkiaSharp;
 
 namespace GalNet.Rendering.Scene;
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneEffects.cs b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneEffects.cs
index 7361409e..f0f8a296 100644
--- a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneEffects.cs
+++ b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneEffects.cs
@@ -1,7 +1,7 @@
 using System.ComponentModel;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using SkiaSharp;
 
 namespace GalNet.Rendering.Scene;
@@ -27,11 +27,11 @@ public interface ITextureEffectFactory
 }
 
 /// <summary>Live renderer-owned state for a texture effect instance.</summary>
-public sealed class SceneEffectInstance : INotifyPropertyChanged
+public sealed class SceneEffectInstance : INotifyPropertyChanged, IDisposable
 {
     private readonly Dictionary<string, float> _animatedValues = new(StringComparer.Ordinal);
     private readonly Lazy<IReadOnlyDictionary<string, JsonElement>> _staticValues;
-    public SceneEffectInstance(string instanceId, ITextureEffectFactory factory, string targetHandleId, int order, string parameters, long insertionOrder = 0)
+    public SceneEffectInstance(string instanceId, ITextureEffectFactory factory, string targetHandleId, int order, string parameters, long insertionOrder = 0, ShaderTextureBindings? textures = null)
     {
         InstanceId = instanceId;
         Factory = factory;
@@ -40,6 +40,7 @@ public SceneEffectInstance(string instanceId, ITextureEffectFactory factory, str
         Order = order;
         Parameters = parameters;
         InsertionOrder = insertionOrder;
+        Textures = textures;
         _staticValues = new Lazy<IReadOnlyDictionary<string, JsonElement>>(ParseStaticValues, LazyThreadSafetyMode.ExecutionAndPublication);
     }
     public string InstanceId { get; }
@@ -50,6 +51,10 @@ public SceneEffectInstance(string instanceId, ITextureEffectFactory factory, str
     public int Order { get; }
     public long InsertionOrder { get; }
     public string Parameters { get; }
+    public ShaderTextureBindings? Textures { get; }
+    // Draw-local context, refreshed from the current render entry on both CPU and GPU paths.
+    internal float LayerZ { get; set; }
+    public void Dispose() => Textures?.Dispose();
     public event PropertyChangedEventHandler? PropertyChanged;
     public void SetAnimatedValue(string name, float value)
     {
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneLayerHost.cs b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneLayerHost.cs
index 3160b3a5..86ffb8fe 100644
--- a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneLayerHost.cs
+++ b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneLayerHost.cs
@@ -4,6 +4,7 @@
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Media;
+using Avalonia.Media.Imaging;
 using Avalonia.Rendering.SceneGraph;
 using Avalonia.Skia;
 using Avalonia.Threading;
@@ -35,6 +36,7 @@ public sealed class SceneLayerHost : Control
     private long _nextInsertionOrder;
     private bool _frameInvalidationPending;
     private SceneRenderPlan _renderPlan = SceneRenderPlan.Empty;
+    private PixelSize? _capturePixelSize;
 
     static SceneLayerHost()
     {
@@ -60,6 +62,37 @@ public byte[] CapturePng()
         return data.ToArray();
     }
 
+    /// <summary>Small scene preview; the regular screenshot entry keeps its original resolution.</summary>
+    public byte[] CapturePng(PixelSize maximumSize)
+    {
+        using var scene = SceneRenderPipeline.Render(_renderPlan, EffectsSource ?? [], null, Bounds.Size, Fit(Bounds.Size, maximumSize), CreateRenderOptions());
+        using var image = SKImage.FromBitmap(scene);
+        using var data = image.Encode(SKEncodedImageFormat.Png, 100);
+        return data.ToArray();
+    }
+
+    /// <summary>Captures a control containing this scene, bounding both its pixels and scene effect passes.</summary>
+    public RenderTargetBitmap CaptureControl(Control target, PixelSize? maximumSize = null)
+    {
+        Dispatcher.UIThread.VerifyAccess();
+        var pixels = Fit(target.Bounds.Size, maximumSize);
+        var scale = pixels.Width / Math.Max(1, target.Bounds.Width);
+        var bitmap = new RenderTargetBitmap(pixels, new Vector(96 * scale, 96 * scale));
+        var previous = _capturePixelSize;
+        _capturePixelSize = maximumSize is { } maximum ? Fit(Bounds.Size, maximum) : null;
+        try { bitmap.Render(target); return bitmap; }
+        catch { bitmap.Dispose(); throw; }
+        finally { _capturePixelSize = previous; }
+    }
+
+    private static PixelSize Fit(Size size, PixelSize? maximum)
+    {
+        var width = Math.Max(1, (int)Math.Ceiling(size.Width));
+        var height = Math.Max(1, (int)Math.Ceiling(size.Height));
+        var scale = maximum is { } bound ? Math.Min(1, Math.Min((double)Math.Max(1, bound.Width) / width, (double)Math.Max(1, bound.Height) / height)) : 1;
+        return new PixelSize(Math.Max(1, (int)Math.Round(width * scale)), Math.Max(1, (int)Math.Round(height * scale)));
+    }
+
     public override void Render(DrawingContext context)
     {
         base.Render(context);
@@ -67,7 +100,7 @@ public override void Render(DrawingContext context)
         AdvanceRenderables();
         // The operation receives Avalonia's live Skia canvas. Do not encode a PNG or create an
         // Avalonia Bitmap here: animation must be a texture draw, not a per-frame image round trip.
-        context.Custom(new SkiaSceneDrawOperation(Bounds, _renderPlan, EffectsSource?.ToArray() ?? [], null, CreateRenderOptions()));
+        context.Custom(new SkiaSceneDrawOperation(Bounds, _renderPlan, EffectsSource?.ToArray() ?? [], null, CreateRenderOptions(), _capturePixelSize));
     }
 
     private void ResetLayers()
@@ -198,7 +231,7 @@ internal sealed class SkiaSceneDrawOperation(
     SceneRenderPlan plan,
     IReadOnlyList<SceneEffectInstance> effects,
     IReadOnlyList<ISceneRenderable>? renderables,
-    SceneRenderOptions renderOptions) : ICustomDrawOperation
+    SceneRenderOptions renderOptions, PixelSize? capturePixelSize = null) : ICustomDrawOperation
 {
     private static int _missingSkiaReported;
     private static int _gpuActiveReported;
@@ -219,7 +252,7 @@ public void Render(ImmediateDrawingContext context)
         lease.SkCanvas.Save();
         lease.SkCanvas.ClipRect(new SKRect((float)Bounds.X, (float)Bounds.Y, (float)Bounds.Right, (float)Bounds.Bottom));
         lease.SkCanvas.Translate((float)Bounds.X, (float)Bounds.Y);
-        if (SceneRenderPipeline.TryRenderGpu(lease.SkCanvas, lease.GrContext, plan, effects, renderables, Bounds.Size, renderOptions))
+        if (capturePixelSize is null && SceneRenderPipeline.TryRenderGpu(lease.SkCanvas, lease.GrContext, plan, effects, renderables, Bounds.Size, renderOptions))
         {
             if (Interlocked.Exchange(ref _gpuActiveReported, 1) == 0)
                 System.Diagnostics.Trace.TraceInformation("Scene pipeline is using GPU textures and shader passes.");
@@ -228,8 +261,10 @@ public void Render(ImmediateDrawingContext context)
         {
             if (Interlocked.Exchange(ref _cpuFallbackReported, 1) == 0)
                 System.Diagnostics.Trace.TraceWarning("Scene pipeline has no GPU texture path; using the slower CPU snapshot fallback.");
-            using var scene = SceneRenderPipeline.Render(plan, effects, renderables, Bounds.Size, renderOptions);
-            lease.SkCanvas.DrawBitmap(scene, 0, 0);
+            using var scene = capturePixelSize is { } pixels
+                ? SceneRenderPipeline.Render(plan, effects, renderables, Bounds.Size, pixels, renderOptions)
+                : SceneRenderPipeline.Render(plan, effects, renderables, Bounds.Size, renderOptions);
+            lease.SkCanvas.DrawBitmap(scene, new SKRect(0, 0, (float)Bounds.Width, (float)Bounds.Height));
         }
         lease.SkCanvas.Restore();
     }
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneLayerItem.cs b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneLayerItem.cs
index 11d000ee..1ba892c6 100644
--- a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneLayerItem.cs
+++ b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneLayerItem.cs
@@ -1,6 +1,6 @@
 using System.ComponentModel;
 using System.Runtime.CompilerServices;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Rendering.Scene;
 
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneRenderPipeline.cs b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneRenderPipeline.cs
index 0f4419ea..2dc968ae 100644
--- a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneRenderPipeline.cs
+++ b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SceneRenderPipeline.cs
@@ -1,6 +1,6 @@
 using Avalonia;
 using Avalonia.Media;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using SkiaSharp;
 
 namespace GalNet.Rendering.Scene;
@@ -60,10 +60,18 @@ public static bool TryRenderGpu(SKCanvas destination, GRContext? gpuContext, Sce
     }
 
     public static SKBitmap Render(SceneRenderPlan plan, IEnumerable<SceneEffectInstance> effects, IEnumerable<ISceneRenderable>? renderables, Size logicalSize, SceneRenderOptions? options = null)
+        => Render(plan, effects, renderables, logicalSize,
+            new PixelSize(Math.Max(1, (int)Math.Ceiling(logicalSize.Width)), Math.Max(1, (int)Math.Ceiling(logicalSize.Height))), options);
+
+    /// <summary>Renders a bounded snapshot while preserving logical layer coordinates and native image sizes.</summary>
+    public static SKBitmap Render(SceneRenderPlan plan, IEnumerable<SceneEffectInstance> effects, IEnumerable<ISceneRenderable>? renderables,
+        Size logicalSize, PixelSize pixelSize, SceneRenderOptions? options = null)
     {
         using var budget = new SceneRenderBudgetGuard(options, isGpu: false);
-        var width = Math.Max(1, (int)Math.Ceiling(logicalSize.Width));
-        var height = Math.Max(1, (int)Math.Ceiling(logicalSize.Height));
+        var width = Math.Max(1, pixelSize.Width);
+        var height = Math.Max(1, pixelSize.Height);
+        var logicalWidth = Math.Max(1, (int)Math.Ceiling(logicalSize.Width));
+        var logicalHeight = Math.Max(1, (int)Math.Ceiling(logicalSize.Height));
         var scene = NewBitmap(width, height);
         using var sceneCanvas = new SKCanvas(scene);
         sceneCanvas.Clear(SKColors.Black);
@@ -73,7 +81,7 @@ public static SKBitmap Render(SceneRenderPlan plan, IEnumerable<SceneEffectInsta
         {
             if (entry.Renderable is not ILayerEffectTarget target)
             {
-                entry.Renderable.Render(new SceneRenderContext(sceneCanvas, new SKSize(width, height), false));
+                RenderEntry(sceneCanvas, entry.Renderable);
                 continue;
             }
             var layerEffects = effectPlan.GetLayer(target.EffectTargetHandleId);
@@ -81,13 +89,13 @@ public static SKBitmap Render(SceneRenderPlan plan, IEnumerable<SceneEffectInsta
             {
                 // An empty texture-to-texture chain is an identity pass. Keep the fixed logical
                 // pipeline, but do not allocate a full-scene intermediate just to copy it.
-                entry.Renderable.Render(new SceneRenderContext(sceneCanvas, new SKSize(width, height), false));
+                RenderEntry(sceneCanvas, entry.Renderable);
                 continue;
             }
 
             using var layer = NewBitmap(width, height);
-            using (var layerCanvas = new SKCanvas(layer)) entry.Renderable.Render(new SceneRenderContext(layerCanvas, new SKSize(width, height), false));
-            using var output = ApplyEffects(layer, layerEffects, budget);
+            using (var layerCanvas = new SKCanvas(layer)) RenderEntry(layerCanvas, entry.Renderable);
+            using var output = ApplyEffects(layer, layerEffects, budget, (float)entry.Renderable.Z);
             sceneCanvas.DrawBitmap(output ?? layer, 0, 0);
         }
 
@@ -97,13 +105,25 @@ public static SKBitmap Render(SceneRenderPlan plan, IEnumerable<SceneEffectInsta
         if (result is null) return scene;
         scene.Dispose();
         return result;
+
+        void RenderEntry(SKCanvas canvas, ISceneRenderable renderable)
+        {
+            canvas.Save();
+            try
+            {
+                canvas.Scale((float)width / logicalWidth, (float)height / logicalHeight);
+                renderable.Render(new SceneRenderContext(canvas, new SKSize(logicalWidth, logicalHeight), false));
+            }
+            finally { canvas.Restore(); }
+        }
     }
 
-    private static SKBitmap? ApplyEffects(SKBitmap source, IEnumerable<SceneEffectInstance> effects, SceneRenderBudgetGuard budget)
+    private static SKBitmap? ApplyEffects(SKBitmap source, IEnumerable<SceneEffectInstance> effects, SceneRenderBudgetGuard budget, float layerZ = 0)
     {
         SKBitmap? current = null;
         foreach (var effect in effects)
         {
+            effect.LayerZ = layerZ;
             if (!budget.TryAcquireEffectPass(effect, source.Width, source.Height)) continue;
             var next = NewBitmap(source.Width, source.Height);
             using (var canvas = new SKCanvas(next))
@@ -143,7 +163,7 @@ private static void RenderEntriesGpu(SKCanvas canvas, GRContext gpuContext, Scen
             entry.Renderable.Render(new SceneRenderContext(layerSurface.Canvas, new SKSize(width, height), true));
             layerSurface.Flush();
             using var input = layerSurface.Snapshot();
-            using var output = ApplyGpuEffects(gpuContext, input, layerEffects, width, height, budget);
+            using var output = ApplyGpuEffects(gpuContext, input, layerEffects, width, height, budget, (float)entry.Renderable.Z);
             canvas.DrawImage(output ?? input, 0, 0);
         }
 
@@ -156,11 +176,12 @@ private static IEnumerable<SceneRenderEntry> OrderedEntries(SceneRenderPlan plan
             .OrderBy(entry => entry.Order).ThenBy(entry => entry.InsertionOrder);
     }
 
-    private static SKImage? ApplyGpuEffects(GRContext gpuContext, SKImage source, IEnumerable<SceneEffectInstance> effects, int width, int height, SceneRenderBudgetGuard budget)
+    private static SKImage? ApplyGpuEffects(GRContext gpuContext, SKImage source, IEnumerable<SceneEffectInstance> effects, int width, int height, SceneRenderBudgetGuard budget, float layerZ = 0)
     {
         SKImage? current = null;
         foreach (var effect in effects)
         {
+            effect.LayerZ = layerZ;
             if (!budget.TryAcquireEffectPass(effect, width, height)) continue;
             using var nextSurface = NewGpuSurface(gpuContext, width, height)
                 ?? throw new InvalidOperationException("Unable to allocate a GPU effect surface.");
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/Scene/ShaderTextureBindings.cs b/src/Presentation/GalNet.Avalonia.Rendering/Scene/ShaderTextureBindings.cs
new file mode 100644
index 00000000..1b2d315a
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.Rendering/Scene/ShaderTextureBindings.cs
@@ -0,0 +1,16 @@
+using GalNet.Core.Assets;
+
+namespace GalNet.Rendering.Scene;
+
+/// <summary>One effect's acquired texture leases, released on stop, replacement or failed preparation.</summary>
+public sealed class ShaderTextureBindings : IDisposable
+{
+    private readonly Dictionary<string, AssetHandle<SceneTexture>> _leases = new(StringComparer.Ordinal);
+    public void Add(string parameter, AssetHandle<SceneTexture> lease) => _leases.Add(parameter, lease);
+    public SceneTexture? Get(string parameter) => _leases.GetValueOrDefault(parameter)?.Value;
+    public void Dispose()
+    {
+        foreach (var lease in _leases.Values) lease.Dispose();
+        _leases.Clear();
+    }
+}
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SkiaShaderEffectPrograms.cs b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SkiaShaderEffectPrograms.cs
index 2c190360..c8d4e514 100644
--- a/src/Presentation/GalNet.Avalonia.Rendering/Scene/SkiaShaderEffectPrograms.cs
+++ b/src/Presentation/GalNet.Avalonia.Rendering/Scene/SkiaShaderEffectPrograms.cs
@@ -1,6 +1,6 @@
 using System.Diagnostics;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Assets;
-using GalNet.Core.Scene;
 using SkiaSharp;
 
 namespace GalNet.Rendering.Scene;
@@ -63,6 +63,8 @@ private static void ValidateBindings(SKRuntimeEffect effect, ShaderEffectDescrip
 
         foreach (var parameter in descriptor.Parameters)
         {
+            if (parameter.Uniform == "layerZ")
+                diagnostics.Add("Shader uniform 'layerZ' is reserved for the current render layer Z and cannot be an author parameter.");
             var exists = parameter.Kind == ShaderEffectParameterKind.Texture
                 ? children.Contains(parameter.Uniform)
                 : uniforms.Contains(parameter.Uniform);
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/Scene/TextureEffects.cs b/src/Presentation/GalNet.Avalonia.Rendering/Scene/TextureEffects.cs
index a1f55230..b9020229 100644
--- a/src/Presentation/GalNet.Avalonia.Rendering/Scene/TextureEffects.cs
+++ b/src/Presentation/GalNet.Avalonia.Rendering/Scene/TextureEffects.cs
@@ -1,6 +1,6 @@
 using System.Globalization;
 using System.Text.Json;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using SkiaSharp;
 
 namespace GalNet.Rendering.Scene;
@@ -39,11 +39,28 @@ private void DrawShader(SKCanvas target, SKShader input, int width, int height,
         using var uniforms = new SKRuntimeEffectUniforms(_effect!);
         using var children = new SKRuntimeEffectChildren(_effect!);
         if (uniforms.Contains("size")) uniforms.Add("size", new SKSize(width, height));
+        if (uniforms.Contains("layerZ")) uniforms.Add("layerZ", instance.LayerZ);
         children.Add(_descriptor.SourceInput, input);
-        foreach (var parameter in _descriptor.Parameters) BindParameter(uniforms, parameter, instance);
-        using var shader = _effect!.ToShader(uniforms, children);
-        using var paint = new SKPaint { Shader = shader, IsAntialias = false };
-        target.DrawRect(0, 0, width, height, paint);
+        var textureShaders = new List<SKShader>();
+        try
+        {
+            foreach (var parameter in _descriptor.Parameters)
+            {
+                if (parameter.Kind != ShaderEffectParameterKind.Texture) { BindParameter(uniforms, parameter, instance); continue; }
+                var image = instance.Textures?.Get(parameter.Name)?.SkImage;
+                if (image is null && parameter.Required)
+                    throw new InvalidOperationException($"Required shader texture '{parameter.Name}' is unavailable.");
+                var texture = image is null ? SKShader.CreateColor(SKColors.Transparent) :
+                    image.ToShader(SKShaderTileMode.Clamp, SKShaderTileMode.Clamp,
+                        SKMatrix.CreateScale((float)width / image.Width, (float)height / image.Height));
+                textureShaders.Add(texture);
+                children.Add(parameter.Uniform, texture);
+            }
+            using var shader = _effect!.ToShader(uniforms, children);
+            using var paint = new SKPaint { Shader = shader, IsAntialias = false };
+            target.DrawRect(0, 0, width, height, paint);
+        }
+        finally { foreach (var texture in textureShaders) texture.Dispose(); }
     }
 
     private static void BindParameter(SKRuntimeEffectUniforms uniforms, ShaderEffectParameterDescriptor parameter, SceneEffectInstance instance)
@@ -76,6 +93,9 @@ private static void BindParameter(SKRuntimeEffectUniforms uniforms, ShaderEffect
             case ShaderEffectParameterKind.Vector2:
                 uniforms.Add(parameter.Uniform, ReadVector(instance, parameter, 2));
                 break;
+            case ShaderEffectParameterKind.Vector3:
+                uniforms.Add(parameter.Uniform, ReadVector(instance, parameter, 3));
+                break;
             case ShaderEffectParameterKind.Vector4:
                 uniforms.Add(parameter.Uniform, ReadVector(instance, parameter, 4));
                 break;
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/packages.lock.WindowsReadyToRun.json b/src/Presentation/GalNet.Avalonia.Rendering/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..658d33c7
--- /dev/null
+++ b/src/Presentation/GalNet.Avalonia.Rendering/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,147 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
+        "dependencies": {
+          "Avalonia.BuildServices": "11.3.2",
+          "Avalonia.Remote.Protocol": "12.0.5",
+          "MicroCom.Runtime": "0.11.4"
+        }
+      },
+      "Avalonia.Skia": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "cSLTpvzsm5JpUA1tQvuht3qN6oiy1PNRgbrp1g7jCSzAFf+OKZecSne+KT1apBQUkevciaHxwtAxLolPGD9izg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3",
+          "SkiaSharp": "3.119.4",
+          "SkiaSharp.NativeAssets.Linux": "3.119.4",
+          "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
+        }
+      },
+      "Avalonia.BuildServices": {
+        "type": "Transitive",
+        "resolved": "11.3.2",
+        "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
+      },
+      "Avalonia.Remote.Protocol": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
+      },
+      "HarfBuzzSharp": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "NGZ2+ZVNPM+NdHB/asW0/ykWngyHWwcqjrbN2nDeH1B/aptPGlCUl8wkQ2cSJxw5fdWgdmIPmNuTPWpLwNVXWg==",
+        "dependencies": {
+          "HarfBuzzSharp.NativeAssets.Win32": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.macOS": "8.3.1.3"
+        }
+      },
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "w2QfdNm9Uz/sUa0B5D+OnVQhyq3G/fBq6ibQMdWBlQqqwh0g0/5j3RFvYqZAmRZ5+RzvjVe8o8SFFnWYUSkuxA=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
+      },
+      "SkiaSharp": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "53NOSUZ1Us+91Sm0uCkIivh/k7jOowRErZT2sIWwPFN9mLUvdxnE6rS4sWo4255+Rd2MWUSF+j0NMZHD6Cke+Q==",
+        "dependencies": {
+          "SkiaSharp.NativeAssets.Win32": "3.119.4",
+          "SkiaSharp.NativeAssets.macOS": "3.119.4"
+        }
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "S1HOxtBbD4bYDtA2e9WH5TX+lxqRrTPvKjrjttRhxnHNNu7YY8VFo/LeCP7tNqoTA6PV+8vsvNbmRUEC2ip8RQ=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/Presentation/GalNet.Avalonia.Rendering/packages.lock.json b/src/Presentation/GalNet.Avalonia.Rendering/packages.lock.json
index f794bfc3..8ad624bc 100644
--- a/src/Presentation/GalNet.Avalonia.Rendering/packages.lock.json
+++ b/src/Presentation/GalNet.Avalonia.Rendering/packages.lock.json
@@ -101,6 +101,12 @@
         "resolved": "3.119.4",
         "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
       },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.core": {
         "type": "Project"
       }
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Base/TitleMenu.axaml b/src/Presentation/GalNet.Avalonia.Themes/Base/TitleMenu.axaml
index 62b8e9a7..5e21c802 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Base/TitleMenu.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Base/TitleMenu.axaml
@@ -11,5 +11,6 @@
     <Button Classes="player-menu" Content="{text:PlayerText Settings.Title, Settings}" Command="{Binding OpenSettingsCommand}" IsEnabled="{Binding IsNavigationEnabled}" />
     <Button Classes="player-menu" Content="{text:PlayerText Title.Gallery, Gallery}" Command="{Binding OpenGalleryCommand}" IsEnabled="{Binding CanOpenGallery}" IsVisible="{Binding HasGallery}" />
     <Button Classes="player-menu" Content="{text:PlayerText Title.About, About}" Command="{Binding OpenAboutCommand}" IsEnabled="{Binding IsNavigationEnabled}" />
+    <Button Classes="player-menu" Content="{text:PlayerText Title.Exit, Exit}" Command="{Binding ExitCommand}" IsEnabled="{Binding IsNavigationEnabled}" />
   </StackPanel>
 </UserControl>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Common/GameToolbar.axaml b/src/Presentation/GalNet.Avalonia.Themes/Common/GameToolbar.axaml
index 815c0f37..331ee378 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Common/GameToolbar.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Common/GameToolbar.axaml
@@ -54,6 +54,7 @@
     <ToggleButton Classes="player-link" Margin="4" Content="{text:PlayerText Playback.Auto, Auto}"
                   IsChecked="{Binding IsAutoMode, Mode=OneWay}" Command="{Binding ToggleAutoCommand}" page:GamePage.PlaybackToggle="Auto" />
     <Button Classes="player-link" Margin="4" Content="{text:PlayerText Playback.Skip, Skip}" Command="{Binding RequestSkipCommand}" />
+    <Button Classes="player-link" Margin="4" Content="{text:PlayerText History.Title, History}" Command="{Binding OpenHistoryCommand}" IsVisible="{Binding HasHistory}" />
     <Button Classes="player-link" Margin="4" Content="{text:PlayerText Common.Save, Save}" Command="{Binding OpenSaveSlotsCommand}" />
     <Button Classes="player-link" Margin="4" Content="{text:PlayerText Title.Load, Load}" Command="{Binding OpenLoadSlotsCommand}" />
     <Button Classes="player-link" Margin="4" Content="{text:PlayerText Settings.Title, Settings}" Command="{Binding OpenSettingsCommand}" />
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Common/SettingsCategories.axaml b/src/Presentation/GalNet.Avalonia.Themes/Common/SettingsCategories.axaml
index 11453e81..acf47704 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Common/SettingsCategories.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Common/SettingsCategories.axaml
@@ -1,8 +1,25 @@
 <UserControl xmlns="https://github.com/avaloniaui" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:forms="using:GalNet.Game.Controls.Forms" xmlns:settings="using:GalNet.Avalonia.GameView.Settings"
              xmlns:text="using:GalNet.Avalonia.GameView.MarkupExtensions"
-             xmlns:common="using:GalNet.Avalonia.Themes.Common"
+             xmlns:common="using:GalNet.Avalonia.Themes.Common" xmlns:conv="using:Avalonia.Data.Converters"
              x:Class="GalNet.Avalonia.Themes.Common.SettingsCategories" x:CompileBindings="False">
+  <UserControl.Resources>
+    <DataTemplate x:Key="MuteEditor" DataType="settings:BoolSetting">
+      <StackPanel Spacing="3" IsVisible="{Binding IsVisible}">
+        <ToggleButton Classes="player-mute" IsChecked="{Binding Value, Mode=TwoWay}" IsEnabled="{Binding IsEnabled}"
+                      ToolTip.Tip="{Binding Label}" AutomationProperties.Name="{Binding Label}">
+          <Viewbox Width="22" Height="22">
+            <Canvas Width="24" Height="24">
+              <Path Classes="speaker" Data="M 3,9 L 7,9 L 12,5 L 12,19 L 7,15 L 3,15 Z" Stroke="{Binding $parent[ToggleButton].Foreground}" StrokeThickness="1.6" StrokeJoin="Round" />
+              <Path Classes="sound-waves" Data="M 16,8 C 19,10 19,14 16,16 M 19,5 C 24,9 24,15 19,19" Stroke="{Binding $parent[ToggleButton].Foreground}" StrokeThickness="1.6" StrokeLineCap="Round" />
+              <Path Classes="mute-slash" Data="M 3,3 L 21,21" Stroke="{Binding $parent[ToggleButton].Foreground}" StrokeThickness="2" StrokeLineCap="Round" />
+            </Canvas>
+          </Viewbox>
+        </ToggleButton>
+        <text:PlayerTextBlock Key="{Binding ErrorKey}" Foreground="{DynamicResource GalNet.Brush.Error}" TextWrapping="Wrap" />
+      </StackPanel>
+    </DataTemplate>
+  </UserControl.Resources>
   <TabControl x:Name="CategoryTabs" ItemsSource="{Binding VisibleCategories, RelativeSource={RelativeSource AncestorType=UserControl}}">
     <TabControl.ItemTemplate>
       <DataTemplate DataType="settings:SettingCategory"><ContentControl Content="{Binding Label}" /></DataTemplate>
@@ -10,7 +27,7 @@
     <TabControl.ContentTemplate>
       <DataTemplate DataType="settings:SettingCategory">
         <ScrollViewer HorizontalScrollBarVisibility="Disabled">
-          <ItemsControl ItemsSource="{Binding Items}" Margin="0,20,0,0">
+          <ItemsControl ItemsSource="{Binding DisplayItems}" Margin="0,20,0,0">
             <ItemsControl.ItemTemplate>
               <DataTemplate DataType="settings:SettingItem">
                 <Grid ColumnDefinitions="180,*" ColumnSpacing="22" Margin="0,0,0,24" IsVisible="{Binding IsVisible}">
@@ -19,7 +36,7 @@
                     <text:PlayerTextBlock Key="{Binding DescriptionKey}" TextWrapping="Wrap" Opacity="0.64" />
                   </StackPanel>
                   <StackPanel Grid.Column="{Binding EditorColumn}" Grid.ColumnSpan="{Binding EditorColumnSpan}" Spacing="4">
-                    <ContentControl Content="{Binding}" IsEnabled="{Binding IsEnabled}">
+                    <ContentControl Content="{Binding}" IsEnabled="{Binding IsEnabled}" VerticalAlignment="Center">
                       <ContentControl.DataTemplates>
                         <DataTemplate DataType="settings:ActionSetting"><Button Content="{Binding Label}" Command="{Binding ExecuteCommand}" /></DataTemplate>
                         <DataTemplate DataType="settings:ICustomSetting"><settings:CustomSettingEditor /></DataTemplate>
@@ -33,9 +50,12 @@
                                     <ItemsControl.ItemTemplate>
                                       <DataTemplate>
                                         <StackPanel Spacing="4">
-                                          <ContentControl Content="{Binding Control}" />
+                                          <Grid ColumnDefinitions="*,Auto" ColumnSpacing="14">
+                                            <ContentControl Content="{Binding Control}" VerticalAlignment="Center" />
+                                            <ContentControl Grid.Column="1" Content="{Binding DataContext.InlineToggle, RelativeSource={RelativeSource AncestorType={x:Type forms:DtoEditorHost}}}" ContentTemplate="{StaticResource MuteEditor}" VerticalAlignment="Center" />
+                                          </Grid>
                                           <text:PlayerTextBlock Key="{Binding Context.Field.Editor.UnitKey}" Opacity="0.64" />
-                                          <TextBlock Text="{Binding Context.Issue.Message}" TextWrapping="Wrap" />
+                                          <TextBlock Text="{Binding Context.Issue.Message}" IsVisible="{Binding Context.Issue.Message, Converter={x:Static conv:StringConverters.IsNotNullOrEmpty}}" TextWrapping="Wrap" />
                                         </StackPanel>
                                       </DataTemplate>
                                     </ItemsControl.ItemTemplate>
@@ -61,4 +81,25 @@
       </DataTemplate>
     </TabControl.ContentTemplate>
   </TabControl>
+  <UserControl.Styles>
+    <Style Selector="CheckBox"><Setter Property="HorizontalAlignment" Value="Left" /></Style>
+    <Style Selector="ToggleButton.player-mute">
+      <Setter Property="Width" Value="40" /><Setter Property="Height" Value="40" />
+      <Setter Property="Padding" Value="8" /><Setter Property="CornerRadius" Value="{DynamicResource GalNet.Theme.CornerRadius}" />
+      <Setter Property="Background" Value="Transparent" /><Setter Property="BorderThickness" Value="0" />
+      <Setter Property="Foreground" Value="{DynamicResource GalNet.Brush.TextSecondary}" />
+      <Setter Property="Template"><ControlTemplate>
+        <Border Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" CornerRadius="{TemplateBinding CornerRadius}" Padding="{TemplateBinding Padding}">
+          <ContentPresenter Content="{TemplateBinding Content}" HorizontalAlignment="Center" VerticalAlignment="Center" />
+        </Border>
+      </ControlTemplate></Setter>
+    </Style>
+    <Style Selector="ToggleButton.player-mute:checked"><Setter Property="Foreground" Value="{DynamicResource GalNet.Brush.Primary}" /><Setter Property="Background" Value="{DynamicResource GalNet.Brush.Selection}" /></Style>
+    <Style Selector="ToggleButton.player-mute:pointerover"><Setter Property="Background" Value="{DynamicResource GalNet.Brush.SurfaceRaised}" /><Setter Property="Foreground" Value="{DynamicResource GalNet.Brush.TextPrimary}" /></Style>
+    <Style Selector="ToggleButton.player-mute:focus-visible"><Setter Property="BorderThickness" Value="1" /><Setter Property="BorderBrush" Value="{DynamicResource GalNet.Brush.Focus}" /></Style>
+    <Style Selector="ToggleButton.player-mute:disabled"><Setter Property="Opacity" Value="0.45" /></Style>
+    <Style Selector="ToggleButton.player-mute Path.mute-slash"><Setter Property="IsVisible" Value="False" /></Style>
+    <Style Selector="ToggleButton.player-mute:checked Path.mute-slash"><Setter Property="IsVisible" Value="True" /></Style>
+    <Style Selector="ToggleButton.player-mute:checked Path.sound-waves"><Setter Property="IsVisible" Value="False" /></Style>
+  </UserControl.Styles>
 </UserControl>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Common/Styles.axaml b/src/Presentation/GalNet.Avalonia.Themes/Common/Styles.axaml
index e6c0c2cb..50c00674 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Common/Styles.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Common/Styles.axaml
@@ -36,6 +36,47 @@
       <x:Double x:Key="GalNet.Theme.HeadingSize">32</x:Double>
       <x:Double x:Key="GalNet.Theme.TitleSize">48</x:Double>
       <x:Int32 x:Key="GalNet.Theme.SaveColumns">4</x:Int32>
+      <!-- Fluent control resources also reach popup roots and focus/pressed template parts. -->
+      <SolidColorBrush x:Key="ComboBoxForeground" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxBackground" Color="{DynamicResource GalNet.Palette.SurfaceColor}" />
+      <SolidColorBrush x:Key="ComboBoxBorderBrush" Color="{DynamicResource GalNet.Palette.BorderColor}" />
+      <SolidColorBrush x:Key="ComboBoxBackgroundPointerOver" Color="{DynamicResource GalNet.Palette.SurfaceRaisedColor}" />
+      <SolidColorBrush x:Key="ComboBoxBorderBrushPointerOver" Color="{DynamicResource GalNet.Palette.PrimaryHoverColor}" />
+      <SolidColorBrush x:Key="ComboBoxBackgroundPressed" Color="{DynamicResource GalNet.Palette.SurfaceRaisedColor}" />
+      <SolidColorBrush x:Key="ComboBoxBorderBrushPressed" Color="{DynamicResource GalNet.Palette.FocusColor}" />
+      <SolidColorBrush x:Key="ComboBoxForegroundFocused" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxForegroundFocusedPressed" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxBackgroundUnfocused" Color="{DynamicResource GalNet.Palette.SurfaceColor}" />
+      <SolidColorBrush x:Key="ComboBoxBackgroundBorderBrushUnfocused" Color="{DynamicResource GalNet.Palette.BorderColor}" />
+      <SolidColorBrush x:Key="ComboBoxBackgroundBorderBrushFocused" Color="{DynamicResource GalNet.Palette.FocusColor}" />
+      <SolidColorBrush x:Key="ComboBoxPlaceHolderForeground" Color="{DynamicResource GalNet.Palette.TextSecondaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxPlaceHolderForegroundFocusedPressed" Color="{DynamicResource GalNet.Palette.TextSecondaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxDropDownGlyphForeground" Color="{DynamicResource GalNet.Palette.TextSecondaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxDropDownGlyphForegroundFocused" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxDropDownGlyphForegroundFocusedPressed" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxDropDownBackground" Color="{DynamicResource GalNet.Palette.SurfaceColor}" />
+      <SolidColorBrush x:Key="ComboBoxDropDownBorderBrush" Color="{DynamicResource GalNet.Palette.BorderColor}" />
+      <SolidColorBrush x:Key="ComboBoxBackgroundDisabled" Color="{DynamicResource GalNet.Palette.SurfaceRaisedColor}" />
+      <SolidColorBrush x:Key="ComboBoxBorderBrushDisabled" Color="{DynamicResource GalNet.Palette.DividerColor}" />
+      <SolidColorBrush x:Key="ComboBoxForegroundDisabled" Color="{DynamicResource GalNet.Palette.TextDisabledColor}" />
+      <SolidColorBrush x:Key="ComboBoxDropDownGlyphForegroundDisabled" Color="{DynamicResource GalNet.Palette.TextDisabledColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemForeground" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemForegroundPointerOver" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemForegroundSelected" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemForegroundSelectedPointerOver" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemForegroundPressed" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemForegroundSelectedPressed" Color="{DynamicResource GalNet.Palette.OnPrimaryColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemForegroundDisabled" Color="{DynamicResource GalNet.Palette.TextDisabledColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemForegroundSelectedDisabled" Color="{DynamicResource GalNet.Palette.TextDisabledColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemBackgroundPointerOver" Color="{DynamicResource GalNet.Palette.SurfaceRaisedColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemBackgroundPressed" Color="{DynamicResource GalNet.Palette.SurfaceRaisedColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemBackgroundSelected" Color="{DynamicResource GalNet.Palette.SelectionColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemBackgroundSelectedPointerOver" Color="{DynamicResource GalNet.Palette.SelectionColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemBackgroundSelectedPressed" Color="{DynamicResource GalNet.Palette.PrimaryPressedColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemBackgroundSelectedDisabled" Color="{DynamicResource GalNet.Palette.SurfaceRaisedColor}" />
+      <SolidColorBrush x:Key="ComboBoxItemBackground" Color="Transparent" />
+      <Thickness x:Key="ComboBoxItemThemePadding">12,9</Thickness>
+      <Thickness x:Key="ComboBoxDropdownBorderPadding">6</Thickness>
     </ResourceDictionary>
   </Styles.Resources>
   <StyleInclude Source="avares://GalNet.Avalonia.Controls/Styles/Generic.axaml" />
@@ -89,6 +130,24 @@
   <Style Selector=".galnet-player CheckBox">
     <Setter Property="Foreground" Value="{DynamicResource GalNet.Brush.TextPrimary}" />
   </Style>
+  <Style Selector=".galnet-player ComboBox">
+    <Setter Property="MinHeight" Value="42" />
+    <Setter Property="Padding" Value="12,8,8,8" />
+    <Setter Property="CornerRadius" Value="{DynamicResource GalNet.Theme.CornerRadius}" />
+  </Style>
+  <Style Selector=".galnet-player ComboBox:disabled">
+    <Setter Property="Background" Value="{DynamicResource GalNet.Brush.SurfaceRaised}" />
+    <Setter Property="Foreground" Value="{DynamicResource GalNet.Brush.TextDisabled}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource GalNet.Brush.Divider}" />
+  </Style>
+  <Style Selector=".galnet-player ComboBox /template/ Border#PopupBorder">
+    <Setter Property="CornerRadius" Value="{DynamicResource GalNet.Theme.CornerRadius}" />
+    <Setter Property="BoxShadow" Value="0 8 24 0 #26000000" />
+  </Style>
+  <Style Selector=".galnet-player ComboBoxItem">
+    <Setter Property="CornerRadius" Value="4" />
+    <Setter Property="MinHeight" Value="38" />
+  </Style>
   <Style Selector=".galnet-player ProgressBar">
     <Setter Property="Foreground" Value="{DynamicResource GalNet.Brush.Primary}" />
     <Setter Property="Background" Value="{DynamicResource GalNet.Brush.SurfaceRaised}" />
diff --git a/src/Presentation/GalNet.Avalonia.Themes/GalNet.Avalonia.Themes.csproj b/src/Presentation/GalNet.Avalonia.Themes/GalNet.Avalonia.Themes.csproj
index 2065cb93..a5d6d6eb 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/GalNet.Avalonia.Themes.csproj
+++ b/src/Presentation/GalNet.Avalonia.Themes/GalNet.Avalonia.Themes.csproj
@@ -7,4 +7,5 @@
     <ProjectReference Include="..\GalNet.Avalonia.Controls\GalNet.Avalonia.Controls.csproj" />
     <ProjectReference Include="..\GalNet.Avalonia.GameView\GalNet.Avalonia.GameView.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicGalleryPage.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicGalleryPage.axaml
index 93d8c272..46d48cfe 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicGalleryPage.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicGalleryPage.axaml
@@ -4,7 +4,7 @@
              xmlns:text="using:GalNet.Avalonia.GameView.MarkupExtensions"
              xmlns:local="using:GalNet.Avalonia.GameView.Page"
              xmlns:vm="using:GalNet.Avalonia.GameView.ViewModels"
-             xmlns:gallery="using:GalNet.Core.Gallery"
+             xmlns:gallery="using:GalNet.Contracts.Builtins.Gallery"
              x:Class="GalNet.Avalonia.Themes.Layouts.Classic.ClassicGalleryPage"
              x:DataType="vm:GalleryPageViewModel">
   <Grid Background="{DynamicResource GalNet.Brush.Background}">
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicSaveSlotsPage.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicSaveSlotsPage.axaml
index 95e0a0c5..82eafad9 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicSaveSlotsPage.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicSaveSlotsPage.axaml
@@ -13,7 +13,7 @@
       <Grid RowDefinitions="Auto,Auto,*">
         <Grid ColumnDefinitions="*,Auto" x:Name="PageHeader" MinHeight="{DynamicResource GalNet.Theme.PageHeaderMinHeight}" ColumnSpacing="24">
           <StackPanel Spacing="3">
-            <TextBlock Text="{Binding Heading}" FontSize="{DynamicResource GalNet.Theme.HeadingSize}" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" VerticalAlignment="Center" />
+            <text:PlayerTextBlock Key="{Binding HeadingKey}" Fallback="{Binding Heading}" FontSize="{DynamicResource GalNet.Theme.HeadingSize}" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" VerticalAlignment="Center" />
             <TextBlock Text="{text:PlayerText SaveSlots.Choose, 'Choose a slot'}" Opacity="0.64" />
           </StackPanel>
           <Button Grid.Column="1" Classes="player-back" Content="{text:PlayerText Common.Back, 'Back'}" Command="{Binding BackCommand}" VerticalAlignment="Center" x:Name="PageBackButton" />
@@ -30,8 +30,8 @@
               <ItemsControl.ItemTemplate>
                 <DataTemplate x:DataType="vm:GameSaveSlotRowViewModel">
                   <Panel Margin="7">
-                    <controls:SaveSlotCard SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" Command="{Binding LoadCommand}" IsVisible="{Binding !IsSaveMode}" />
-                    <controls:SaveSlotCard SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" Command="{Binding SaveCommand}" IsVisible="{Binding IsSaveMode}" />
+                    <controls:SaveSlotCard Preview="{Binding Preview}" SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" CanRename="{Binding CanRename}" RenameCommand="{Binding RenameCommand}" RenameError="{Binding RenameError}" Command="{Binding LoadCommand}" IsVisible="{Binding !IsSaveMode}" />
+                    <controls:SaveSlotCard Preview="{Binding Preview}" SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" CanRename="{Binding CanRename}" RenameCommand="{Binding RenameCommand}" RenameError="{Binding RenameError}" Command="{Binding SaveCommand}" IsVisible="{Binding IsSaveMode}" />
                   </Panel>
                 </DataTemplate>
               </ItemsControl.ItemTemplate>
@@ -42,4 +42,4 @@
       </Grid>
     </Border>
   </Grid>
-</UserControl>
\ No newline at end of file
+</UserControl>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicScreenshotDialog.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicScreenshotDialog.axaml
index 5c04af36..6d7af255 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicScreenshotDialog.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicScreenshotDialog.axaml
@@ -43,7 +43,7 @@
       <StackPanel Grid.Row="4"
                   Spacing="4">
         <CheckBox Name="IncludeUiBox"
-                  Content="{text:PlayerText Screenshot.IncludeUi, 'Include player UI'}" />
+                  Content="{text:PlayerText Screenshot.IncludeUi, 'Include dialogue and controls'}" />
         <TextBlock Name="ErrorBlock"
                    Foreground="{DynamicResource GalNet.Brush.Error}"
                    TextWrapping="Wrap" />
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicTitlePage.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicTitlePage.axaml
index 142bc2ea..68c6046c 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicTitlePage.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/ClassicTitlePage.axaml
@@ -11,7 +11,8 @@
     </Grid>
     <Grid Margin="80,64" ColumnDefinitions="440,*" RowDefinitions="Auto,*">
       <StackPanel Grid.ColumnSpan="2" Spacing="12">
-        <TextBlock Text="{Binding GameTitle}" FontSize="{DynamicResource GalNet.Theme.TitleSize}" FontWeight="Bold" TextWrapping="Wrap" />
+        <TextBlock Text="{Binding GameTitle}" Foreground="{DynamicResource GalNet.Brush.TextPrimary}"
+                   FontSize="{DynamicResource GalNet.Theme.TitleSize}" FontWeight="Bold" TextWrapping="Wrap" />
         <TextBlock Text="{Binding StatusMessage}" Foreground="{DynamicResource GalNet.Brush.TextSecondary}" TextWrapping="Wrap" MaxWidth="840" HorizontalAlignment="Left" />
       </StackPanel>
       <ScrollViewer Grid.Row="1" VerticalAlignment="Bottom" HorizontalScrollBarVisibility="Disabled" Margin="0,32,0,0">
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/Resources.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/Resources.axaml
index 3c705fd5..1a1117a6 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/Resources.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Classic/Resources.axaml
@@ -23,6 +23,7 @@
               <ContentPresenter Name="PART_Dialogue" Content="{TemplateBinding Dialogue}" Margin="64,0,64,70" HorizontalAlignment="Stretch" VerticalAlignment="Bottom" HorizontalContentAlignment="Stretch" ZIndex="13" />
               <ContentPresenter Name="PART_Choice" Content="{TemplateBinding Choice}" Width="620" HorizontalAlignment="Center" VerticalAlignment="Center" ZIndex="50" />
               <common:GameToolbar HorizontalAlignment="Center" VerticalAlignment="Bottom" Margin="20" ZIndex="40" />
+              <ContentPresenter Name="PART_History" Content="{TemplateBinding History}" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch" ZIndex="100" />
             </Grid>
       </ControlTemplate>
     </Setter>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalGalleryPage.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalGalleryPage.axaml
index f8e2093b..c4bba209 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalGalleryPage.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalGalleryPage.axaml
@@ -4,7 +4,7 @@
              xmlns:text="using:GalNet.Avalonia.GameView.MarkupExtensions"
              xmlns:local="using:GalNet.Avalonia.GameView.Page"
              xmlns:vm="using:GalNet.Avalonia.GameView.ViewModels"
-             xmlns:gallery="using:GalNet.Core.Gallery"
+             xmlns:gallery="using:GalNet.Contracts.Builtins.Gallery"
              x:Class="GalNet.Avalonia.Themes.Layouts.Minimal.MinimalGalleryPage"
              x:DataType="vm:GalleryPageViewModel">
   <Grid Background="{DynamicResource GalNet.Brush.Background}">
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalSaveSlotsPage.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalSaveSlotsPage.axaml
index 7c5019f8..17d3bfba 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalSaveSlotsPage.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalSaveSlotsPage.axaml
@@ -13,7 +13,7 @@
       <Grid ColumnDefinitions="200,*" ColumnSpacing="36">
         <Grid x:Name="PageHeader" RowDefinitions="Auto,*,Auto">
           <StackPanel Spacing="3">
-            <TextBlock Text="{Binding Heading}" FontSize="{DynamicResource GalNet.Theme.HeadingSize}" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" VerticalAlignment="Center" />
+            <text:PlayerTextBlock Key="{Binding HeadingKey}" Fallback="{Binding Heading}" FontSize="{DynamicResource GalNet.Theme.HeadingSize}" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" VerticalAlignment="Center" />
             <TextBlock Text="{text:PlayerText SaveSlots.Choose, 'Choose a slot'}" Opacity="0.64" />
           </StackPanel>
           <Button Classes="player-back" Content="{text:PlayerText Common.Back, 'Back'}" Command="{Binding BackCommand}" VerticalAlignment="Bottom" x:Name="PageBackButton" Grid.Row="2" HorizontalAlignment="Stretch" />
@@ -29,8 +29,8 @@
               <ItemsControl.ItemTemplate>
                 <DataTemplate x:DataType="vm:GameSaveSlotRowViewModel">
                   <Panel Margin="7">
-                    <controls:SaveSlotCard SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" Command="{Binding LoadCommand}" IsVisible="{Binding !IsSaveMode}" />
-                    <controls:SaveSlotCard SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" Command="{Binding SaveCommand}" IsVisible="{Binding IsSaveMode}" />
+                    <controls:SaveSlotCard Preview="{Binding Preview}" SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" CanRename="{Binding CanRename}" RenameCommand="{Binding RenameCommand}" RenameError="{Binding RenameError}" Command="{Binding LoadCommand}" IsVisible="{Binding !IsSaveMode}" />
+                    <controls:SaveSlotCard Preview="{Binding Preview}" SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" CanRename="{Binding CanRename}" RenameCommand="{Binding RenameCommand}" RenameError="{Binding RenameError}" Command="{Binding SaveCommand}" IsVisible="{Binding IsSaveMode}" />
                   </Panel>
                 </DataTemplate>
               </ItemsControl.ItemTemplate>
@@ -41,4 +41,4 @@
       </Grid>
     </Border>
   </Grid>
-</UserControl>
\ No newline at end of file
+</UserControl>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalScreenshotDialog.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalScreenshotDialog.axaml
index 41217e29..39d9ee34 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalScreenshotDialog.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalScreenshotDialog.axaml
@@ -43,7 +43,7 @@
       <StackPanel Grid.Row="4"
                   Spacing="4">
         <CheckBox Name="IncludeUiBox"
-                  Content="{text:PlayerText Screenshot.IncludeUi, 'Include player UI'}" />
+                  Content="{text:PlayerText Screenshot.IncludeUi, 'Include dialogue and controls'}" />
         <TextBlock Name="ErrorBlock"
                    Foreground="{DynamicResource GalNet.Brush.Error}"
                    TextWrapping="Wrap" />
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalTitlePage.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalTitlePage.axaml
index cffc239f..f47dc094 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalTitlePage.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/MinimalTitlePage.axaml
@@ -8,7 +8,8 @@
    <Grid Margin="64" ColumnDefinitions="*,380" ColumnSpacing="64">
     <StackPanel VerticalAlignment="Center" Spacing="24">
       <Border Width="56" Height="4" Background="{DynamicResource GalNet.Brush.Primary}" HorizontalAlignment="Left" />
-      <TextBlock Text="{Binding GameTitle}" FontSize="{DynamicResource GalNet.Theme.TitleSize}" FontWeight="SemiBold" TextWrapping="Wrap" />
+      <TextBlock Text="{Binding GameTitle}" Foreground="{DynamicResource GalNet.Brush.TextPrimary}"
+                 FontSize="{DynamicResource GalNet.Theme.TitleSize}" FontWeight="SemiBold" TextWrapping="Wrap" />
       <TextBlock Text="{Binding StatusMessage}" Foreground="{DynamicResource GalNet.Brush.TextSecondary}" TextWrapping="Wrap" />
     </StackPanel>
     <Border Grid.Column="1" BorderBrush="{DynamicResource GalNet.Brush.Divider}" BorderThickness="1,0,0,0" Padding="32,0,0,0">
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/Resources.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/Resources.axaml
index 81d2afed..33acbe1b 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/Resources.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Minimal/Resources.axaml
@@ -26,6 +26,7 @@
             <controls:TypewriterTextBlock Name="PART_Typewriter" SourceText="{TemplateBinding Text}"
                                          CharactersPerSecond="{TemplateBinding CharactersPerSecond}"
                                          Foreground="{DynamicResource GalNet.Brush.TextPrimary}" FontSize="{DynamicResource GalNet.Theme.DialogueFontSize}" />
+            <Button HorizontalAlignment="Right" Content="{TemplateBinding ReplayIcon}" IsVisible="{TemplateBinding CanReplayVoice}" Command="{TemplateBinding ReplayVoiceCommand}" ToolTip.Tip="{TemplateBinding ReplayLabel}" AutomationProperties.Name="{TemplateBinding ReplayLabel}" />
           </StackPanel>
         </Border>
       </ControlTemplate>
@@ -41,6 +42,7 @@
               <ContentPresenter Name="PART_Nvl" Content="{TemplateBinding Nvl}" Width="780" MaxHeight="580" HorizontalAlignment="Center" VerticalAlignment="Center" ZIndex="12" />
               <ContentPresenter Name="PART_Dialogue" Content="{TemplateBinding Dialogue}" Width="620" Margin="32" HorizontalAlignment="Right" VerticalAlignment="Bottom" HorizontalContentAlignment="Stretch" ZIndex="13" />
               <ContentPresenter Name="PART_Choice" Content="{TemplateBinding Choice}" Width="520" Margin="32" HorizontalAlignment="Left" VerticalAlignment="Center" ZIndex="50" />
+              <ContentPresenter Name="PART_History" Content="{TemplateBinding History}" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch" ZIndex="100" />
             </Grid>
       </ControlTemplate>
     </Setter>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperGalleryPage.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperGalleryPage.axaml
index bc1939c2..3a64e070 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperGalleryPage.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperGalleryPage.axaml
@@ -4,7 +4,7 @@
              xmlns:text="using:GalNet.Avalonia.GameView.MarkupExtensions"
              xmlns:local="using:GalNet.Avalonia.GameView.Page"
              xmlns:vm="using:GalNet.Avalonia.GameView.ViewModels"
-             xmlns:gallery="using:GalNet.Core.Gallery"
+             xmlns:gallery="using:GalNet.Contracts.Builtins.Gallery"
              x:Class="GalNet.Avalonia.Themes.Layouts.Paper.PaperGalleryPage"
              x:DataType="vm:GalleryPageViewModel">
   <Grid Background="{DynamicResource GalNet.Brush.Background}">
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperSaveSlotsPage.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperSaveSlotsPage.axaml
index 7bf9afce..bc0cfd82 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperSaveSlotsPage.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperSaveSlotsPage.axaml
@@ -13,7 +13,7 @@
       <Grid RowDefinitions="Auto,Auto,*">
         <Grid ColumnDefinitions="140,*,140" x:Name="PageHeader" MinHeight="{DynamicResource GalNet.Theme.PageHeaderMinHeight}" ColumnSpacing="24">
           <StackPanel Spacing="3" Grid.Column="1" HorizontalAlignment="Center">
-            <TextBlock Text="{Binding Heading}" FontSize="{DynamicResource GalNet.Theme.HeadingSize}" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" VerticalAlignment="Center" />
+            <text:PlayerTextBlock Key="{Binding HeadingKey}" Fallback="{Binding Heading}" FontSize="{DynamicResource GalNet.Theme.HeadingSize}" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" VerticalAlignment="Center" />
             <TextBlock Text="{text:PlayerText SaveSlots.Choose, 'Choose a slot'}" Opacity="0.64" />
           </StackPanel>
           <Button Grid.Column="0" Classes="player-back" Content="{text:PlayerText Common.Back, 'Back'}" Command="{Binding BackCommand}" VerticalAlignment="Center" x:Name="PageBackButton" />
@@ -30,8 +30,8 @@
               <ItemsControl.ItemTemplate>
                 <DataTemplate x:DataType="vm:GameSaveSlotRowViewModel">
                   <Panel Margin="7">
-                    <controls:SaveSlotCard SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" Command="{Binding LoadCommand}" IsVisible="{Binding !IsSaveMode}" />
-                    <controls:SaveSlotCard SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" Command="{Binding SaveCommand}" IsVisible="{Binding IsSaveMode}" />
+                    <controls:SaveSlotCard Preview="{Binding Preview}" SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" CanRename="{Binding CanRename}" RenameCommand="{Binding RenameCommand}" RenameError="{Binding RenameError}" Command="{Binding LoadCommand}" IsVisible="{Binding !IsSaveMode}" />
+                    <controls:SaveSlotCard Preview="{Binding Preview}" SlotIndex="{Binding SlotIndex}" Timestamp="{Binding Timestamp}" Description="{Binding Description}" IsEmpty="{Binding IsEmpty}" IsCorrupt="{Binding IsCorrupt}" CanRename="{Binding CanRename}" RenameCommand="{Binding RenameCommand}" RenameError="{Binding RenameError}" Command="{Binding SaveCommand}" IsVisible="{Binding IsSaveMode}" />
                   </Panel>
                 </DataTemplate>
               </ItemsControl.ItemTemplate>
@@ -42,4 +42,4 @@
       </Grid>
     </Border>
   </Grid>
-</UserControl>
\ No newline at end of file
+</UserControl>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperScreenshotDialog.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperScreenshotDialog.axaml
index 88584947..88cb9e56 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperScreenshotDialog.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperScreenshotDialog.axaml
@@ -43,7 +43,7 @@
       <StackPanel Grid.Row="4"
                   Spacing="4">
         <CheckBox Name="IncludeUiBox"
-                  Content="{text:PlayerText Screenshot.IncludeUi, 'Include player UI'}" />
+                  Content="{text:PlayerText Screenshot.IncludeUi, 'Include dialogue and controls'}" />
         <TextBlock Name="ErrorBlock"
                    Foreground="{DynamicResource GalNet.Brush.Error}"
                    TextWrapping="Wrap" />
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperTitlePage.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperTitlePage.axaml
index 05f601ad..463be1b9 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperTitlePage.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/PaperTitlePage.axaml
@@ -22,7 +22,8 @@
             BorderThickness="0">
       <Grid ColumnDefinitions="*,360" ColumnSpacing="56">
         <StackPanel VerticalAlignment="Center" Spacing="24">
-          <TextBlock Text="{Binding GameTitle}" FontSize="{DynamicResource GalNet.Theme.TitleSize}" TextWrapping="Wrap" />
+          <TextBlock Text="{Binding GameTitle}" Foreground="{DynamicResource GalNet.Brush.TextPrimary}"
+                     FontSize="{DynamicResource GalNet.Theme.TitleSize}" TextWrapping="Wrap" />
           <Border Height="1" Background="{DynamicResource GalNet.Brush.Primary}" />
           <TextBlock Text="{Binding StatusMessage}" Foreground="{DynamicResource GalNet.Brush.TextSecondary}" TextWrapping="Wrap" />
         </StackPanel>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/Resources.axaml b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/Resources.axaml
index 2782434b..417c0417 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/Resources.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Layouts/Paper/Resources.axaml
@@ -27,6 +27,7 @@
             <controls:TypewriterTextBlock Name="PART_Typewriter" SourceText="{TemplateBinding Text}"
                                          CharactersPerSecond="{TemplateBinding CharactersPerSecond}"
                                          Foreground="{DynamicResource GalNet.Brush.TextPrimary}" FontSize="{DynamicResource GalNet.Theme.DialogueFontSize}" />
+            <Button HorizontalAlignment="Right" Content="{TemplateBinding ReplayIcon}" IsVisible="{TemplateBinding CanReplayVoice}" Command="{TemplateBinding ReplayVoiceCommand}" ToolTip.Tip="{TemplateBinding ReplayLabel}" AutomationProperties.Name="{TemplateBinding ReplayLabel}" />
           </StackPanel>
         </Border>
       </ControlTemplate>
@@ -63,6 +64,7 @@
               <ContentPresenter Name="PART_Nvl" Content="{TemplateBinding Nvl}" Grid.ColumnSpan="2" Width="900" MaxHeight="580" HorizontalAlignment="Center" VerticalAlignment="Center" ZIndex="12" />
               <common:GameToolbar Grid.Row="1" Grid.ColumnSpan="2" HorizontalAlignment="Center" Margin="0,20,0,0" />
              </Grid>
+              <ContentPresenter Name="PART_History" Content="{TemplateBinding History}" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch" ZIndex="100" />
             </Grid>
       </ControlTemplate>
     </Setter>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Palettes/Mono.axaml b/src/Presentation/GalNet.Avalonia.Themes/Palettes/Mono.axaml
index 0c1674b4..6d44cbec 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Palettes/Mono.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Palettes/Mono.axaml
@@ -14,6 +14,7 @@
   <SolidColorBrush x:Key="GalNet.Brush.OnSecondary" Color="{DynamicResource GalNet.Palette.OnSecondaryColor}" />
   <StaticResource x:Key="GalNet.Palette.BackgroundColor" ResourceKey="GalNet.Color.Neutral.50" />
   <SolidColorBrush x:Key="GalNet.Brush.Background" Color="{DynamicResource GalNet.Palette.BackgroundColor}" />
+  <SolidColorBrush x:Key="GalNet.Brush.SaveCaption" Color="{DynamicResource GalNet.Palette.BackgroundColor}" Opacity="0.86" />
   <Color x:Key="GalNet.Palette.SurfaceColor">#FFFFFF</Color>
   <SolidColorBrush x:Key="GalNet.Brush.Surface" Color="{DynamicResource GalNet.Palette.SurfaceColor}" />
   <StaticResource x:Key="GalNet.Palette.SurfaceRaisedColor" ResourceKey="GalNet.Color.Neutral.100" />
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Palettes/Ocean.axaml b/src/Presentation/GalNet.Avalonia.Themes/Palettes/Ocean.axaml
index 1ea3a879..c4c6fc43 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Palettes/Ocean.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Palettes/Ocean.axaml
@@ -14,6 +14,7 @@
   <SolidColorBrush x:Key="GalNet.Brush.OnSecondary" Color="{DynamicResource GalNet.Palette.OnSecondaryColor}" />
   <StaticResource x:Key="GalNet.Palette.BackgroundColor" ResourceKey="GalNet.Color.Neutral.950" />
   <SolidColorBrush x:Key="GalNet.Brush.Background" Color="{DynamicResource GalNet.Palette.BackgroundColor}" />
+  <SolidColorBrush x:Key="GalNet.Brush.SaveCaption" Color="{DynamicResource GalNet.Palette.BackgroundColor}" Opacity="0.86" />
   <StaticResource x:Key="GalNet.Palette.SurfaceColor" ResourceKey="GalNet.Color.Neutral.900" />
   <SolidColorBrush x:Key="GalNet.Brush.Surface" Color="{DynamicResource GalNet.Palette.SurfaceColor}" />
   <StaticResource x:Key="GalNet.Palette.SurfaceRaisedColor" ResourceKey="GalNet.Color.Neutral.800" />
diff --git a/src/Presentation/GalNet.Avalonia.Themes/Palettes/Rose.axaml b/src/Presentation/GalNet.Avalonia.Themes/Palettes/Rose.axaml
index d9f78c41..354df542 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/Palettes/Rose.axaml
+++ b/src/Presentation/GalNet.Avalonia.Themes/Palettes/Rose.axaml
@@ -14,6 +14,7 @@
   <SolidColorBrush x:Key="GalNet.Brush.OnSecondary" Color="{DynamicResource GalNet.Palette.OnSecondaryColor}" />
   <Color x:Key="GalNet.Palette.BackgroundColor">#1A141C</Color>
   <SolidColorBrush x:Key="GalNet.Brush.Background" Color="{DynamicResource GalNet.Palette.BackgroundColor}" />
+  <SolidColorBrush x:Key="GalNet.Brush.SaveCaption" Color="{DynamicResource GalNet.Palette.BackgroundColor}" Opacity="0.86" />
   <Color x:Key="GalNet.Palette.SurfaceColor">#2D222E</Color>
   <SolidColorBrush x:Key="GalNet.Brush.Surface" Color="{DynamicResource GalNet.Palette.SurfaceColor}" />
   <Color x:Key="GalNet.Palette.SurfaceRaisedColor">#3D2B3A</Color>
diff --git a/src/Presentation/GalNet.Avalonia.Themes/README.md b/src/Presentation/GalNet.Avalonia.Themes/README.md
index 366e0307..e5c65714 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/README.md
+++ b/src/Presentation/GalNet.Avalonia.Themes/README.md
@@ -119,3 +119,5 @@ GameThemeTests 覆盖九种组合的页面加载、Skia headless 渲染、配色
 三套布局分别提供 ScreenshotDialog 派生 View，共享基类在 GameView；主题只维护布局。XAML 加载后调用 InitializeDialog，需提供具名控件 Preview(Image)、DirectoryBox/TextBox、FileNameBox/TextBox、IncludeUiBox(CheckBox)、BrowseButton/CancelButton/SaveButton(Button)、ErrorBlock(TextBlock)。缺少控件会明确报错。宿主可注册 `views.Register<ScreenshotDialogViewModel, MyScreenshotDialog>()` 覆盖单个对话框。
 
 对话框每次通过 DI 构造独立实例，并由截图服务释放；普通页面保持 Scoped。通用玩家样式与工具栏位于 Common，GameView 的 Page 目录仅保留 GameShell 导航宿主、GamePage 行为控件和 ScreenshotDialog 行为基类。
+
+宿主可通过 `GameScreenshotRequest.CapturePreviewPngAsync` 提供小图预览，正式保存仍使用 `CapturePngAsync`；不提供新回调的宿主保持原路径。GameShell 预览上限为 720×405，同一弹窗分别缓存包含界面/仅场景两种结果，正式导出保持原分辨率。自定义场景捕获应同时缩小场景效果中间纹理，而非仅在最终 Image 上缩放。完整契约见 [control.md](../../../docs/spec/control.md#截图对话框契约)。
diff --git a/src/Launcher/GalNet.Launcher.Browser/packages.lock.json b/src/Presentation/GalNet.Avalonia.Themes/packages.lock.WindowsReadyToRun.json
similarity index 69%
rename from src/Launcher/GalNet.Launcher.Browser/packages.lock.json
rename to src/Presentation/GalNet.Avalonia.Themes/packages.lock.WindowsReadyToRun.json
index a205c56c..b7499bc7 100644
--- a/src/Launcher/GalNet.Launcher.Browser/packages.lock.json
+++ b/src/Presentation/GalNet.Avalonia.Themes/packages.lock.WindowsReadyToRun.json
@@ -1,53 +1,21 @@
 {
   "version": 2,
   "dependencies": {
-    "net10.0-browser1.0": {
-      "Avalonia.Browser": {
+    "net10.0": {
+      "Avalonia.Themes.Fluent": {
         "type": "Direct",
         "requested": "[12.0.5, )",
         "resolved": "12.0.5",
-        "contentHash": "A8+DTuLTB7/m9QUjIUAnCsdsg4qZ9UkcSQdWMMq/3+ph6dJgqY4a1KVIkXwBN4Ud5wv1RrvHdIXl75vui4xzfA==",
+        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
         "dependencies": {
-          "Avalonia": "12.0.5",
-          "Avalonia.HarfBuzz": "12.0.5",
-          "Avalonia.Skia": "12.0.5",
-          "HarfBuzzSharp": "8.3.1.3",
-          "SkiaSharp": "3.119.4"
+          "Avalonia": "12.0.5"
         }
       },
-      "Microsoft.NET.ILLink.Tasks": {
-        "type": "Direct",
-        "requested": "[10.0.12, )",
-        "resolved": "10.0.12",
-        "contentHash": "xi+BDjFpW+Sb+MHFHaH6Y/gV9I8BluFwRXc1QyCdoZbIK26eNiBeFuMTe/FMwc33G1wdHCyDg7CVTmb8OdQrMQ=="
-      },
-      "Microsoft.NET.Sdk.WebAssembly.Pack": {
-        "type": "Direct",
-        "requested": "[10.0.12, )",
-        "resolved": "10.0.12",
-        "contentHash": "u1XrZ7IAKh4XfqSaU/MsVfi5pz7RgPNn5hZaw5750YulFaSLLc0kFsVxH9jaHxGbdBWWrkovnVA4J9emtrq8tg=="
-      },
-      "Antlr4.Runtime.Standard": {
-        "type": "Transitive",
-        "resolved": "4.13.1",
-        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
-      },
       "Avalonia.BuildServices": {
         "type": "Transitive",
         "resolved": "11.3.2",
         "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
       },
-      "Avalonia.HarfBuzz": {
-        "type": "Transitive",
-        "resolved": "12.0.5",
-        "contentHash": "jR8i/fgrmAKEp0T3iLqfKCoEDJV9ODVzN+8bofM2guEr05eaXbx6iXZxcjh0nDK4UbK0akYDgBfAgyHoatqGjg==",
-        "dependencies": {
-          "Avalonia": "12.0.5",
-          "HarfBuzzSharp": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
-          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3"
-        }
-      },
       "Avalonia.Remote.Protocol": {
         "type": "Transitive",
         "resolved": "12.0.5",
@@ -82,23 +50,23 @@
         "resolved": "8.3.1.3",
         "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
       },
-      "MicroCom.Runtime": {
-        "type": "Transitive",
-        "resolved": "0.11.4",
-        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
-      },
-      "Microsoft.Extensions.Logging.Abstractions": {
+      "Irihi.Avalonia.Shared": {
         "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
+        "resolved": "0.4.0",
+        "contentHash": "T6+jezCUjisJNz6zkNcNLVNI2ttWznbyQnW6MS9L45EXhePqRCIxB3xV/5L8gFAJ83JrhiCIokMOxRWdq9/1Zg==",
         "dependencies": {
-          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
+          "Avalonia": "12.0.0"
         }
       },
-      "Microsoft.IO.RecyclableMemoryStream": {
+      "Irihi.Avalonia.Shared.Contracts": {
         "type": "Transitive",
-        "resolved": "3.0.1",
-        "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g=="
+        "resolved": "0.4.0",
+        "contentHash": "Du8DY2YqlSmCmywqZtuOhgwLkgklMeE1ajZ4Dd/iqVz6HmAKptjVTqA1oloZX5ihqsdKRiNuUGCdYPe1rekf2Q=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
       },
       "SkiaSharp": {
         "type": "Transitive",
@@ -132,38 +100,59 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
-      "galnet.core": {
-        "type": "Project"
+      "galnet.avalonia.controls": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
       },
-      "galnet.launcher": {
+      "galnet.avalonia.gameview": {
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
-          "Avalonia.Fonts.Inter": "[12.0.5, )",
-          "Avalonia.Themes.Fluent": "[12.0.5, )",
-          "AvaloniaUI.DiagnosticsSupport": "[2.2.3, )",
           "CommunityToolkit.Mvvm": "[8.4.1, )",
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Runtime": "[1.0.0, )"
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "Irihi.Ursa": "[2.1.0, )",
+          "LibVLCSharp": "[3.10.0, )",
+          "LibVLCSharp.Avalonia": "[3.10.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )",
+          "Serilog": "[4.2.0, )"
         }
       },
-      "galnet.presentation.abstractions": {
+      "galnet.avalonia.rendering": {
         "type": "Project",
         "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
-      "galnet.runtime": {
+      "galnet.contracts.builtins": {
         "type": "Project",
         "dependencies": {
-          "CoreCLR-NCalc": "[3.1.253, )",
-          "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
-          "Serilog": "[4.2.0, )"
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
         }
       },
       "Avalonia": {
@@ -177,15 +166,6 @@
           "MicroCom.Runtime": "0.11.4"
         }
       },
-      "Avalonia.Fonts.Inter": {
-        "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
-      },
       "Avalonia.Skia": {
         "type": "CentralTransitive",
         "requested": "[12.0.5, )",
@@ -201,45 +181,44 @@
           "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
         }
       },
-      "Avalonia.Themes.Fluent": {
+      "CommunityToolkit.Mvvm": {
         "type": "CentralTransitive",
-        "requested": "[12.0.5, )",
-        "resolved": "12.0.5",
-        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
-        "dependencies": {
-          "Avalonia": "12.0.5"
-        }
+        "requested": "[8.4.1, )",
+        "resolved": "8.4.1",
+        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
       },
-      "AvaloniaUI.DiagnosticsSupport": {
+      "Irihi.Ursa": {
         "type": "CentralTransitive",
-        "requested": "[2.2.3, )",
-        "resolved": "2.2.3",
-        "contentHash": "kQCInYusi2c9tjd9hV05Lln6Csbo07kiC672M3G7dsalDBe2j+pOk3We2nzdyy5ptQYy/9gQiC8ZaHhb6u/5Kw==",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "G2wAmenCgMZkBOqs5MYRtlurhU2tAKKmcNJzjjaA9Mj5v3YIivuv7wyNpIpgYZ602sOZhFtQwYrCaLVUhn9Htw==",
         "dependencies": {
-          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
-          "Microsoft.IO.RecyclableMemoryStream": "3.0.1"
+          "Avalonia": "12.0.2",
+          "Irihi.Avalonia.Shared": "0.4.0",
+          "Irihi.Avalonia.Shared.Contracts": "0.4.0"
         }
       },
-      "CommunityToolkit.Mvvm": {
+      "LibVLCSharp": {
         "type": "CentralTransitive",
-        "requested": "[8.4.1, )",
-        "resolved": "8.4.1",
-        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
       },
-      "CoreCLR-NCalc": {
+      "LibVLCSharp.Avalonia": {
         "type": "CentralTransitive",
-        "requested": "[3.1.253, )",
-        "resolved": "3.1.253",
-        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "juoBLjh37+07kWDblbHLaWTQx1HsXOIJHU7aeH5/95xjN6dXfZMVE8ltg8NyaNL6vr2B4QgR3EiRBsEa+fPvlQ==",
         "dependencies": {
-          "Antlr4.Runtime.Standard": "4.13.1"
+          "Avalonia": "11.3.13",
+          "LibVLCSharp": "3.10.0"
         }
       },
       "Microsoft.Extensions.DependencyInjection.Abstractions": {
         "type": "CentralTransitive",
         "requested": "[10.0.0, )",
-        "resolved": "8.0.0",
-        "contentHash": "cjWrLkJXK0rs4zofsK4bSdg+jhDLTaxrkXu4gS6Y7MAlCvRyNNgwY/lJi5RDlQOnSZweHqoyvgvbdvQsRIW+hg=="
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
       },
       "Serilog": {
         "type": "CentralTransitive",
@@ -248,7 +227,7 @@
         "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
       }
     },
-    "net10.0-browser1.0/browser-wasm": {
+    "net10.0/win-x64": {
       "HarfBuzzSharp.NativeAssets.Linux": {
         "type": "Transitive",
         "resolved": "8.3.1.3",
diff --git a/src/Presentation/GalNet.Avalonia.Themes/packages.lock.json b/src/Presentation/GalNet.Avalonia.Themes/packages.lock.json
index 7b6fb30c..bb2da0e5 100644
--- a/src/Presentation/GalNet.Avalonia.Themes/packages.lock.json
+++ b/src/Presentation/GalNet.Avalonia.Themes/packages.lock.json
@@ -100,6 +100,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -107,6 +108,7 @@
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -118,6 +120,7 @@
           "GalNet.Assets": "[1.0.0, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Irihi.Ursa": "[2.1.0, )",
@@ -132,6 +135,13 @@
         "dependencies": {
           "Avalonia": "[12.0.5, )",
           "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -141,6 +151,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
diff --git a/src/Samples/GalNet.Sample.Avalonia/App.axaml.cs b/src/Samples/GalNet.Sample.Avalonia/App.axaml.cs
index 277d541a..4cd0bb21 100644
--- a/src/Samples/GalNet.Sample.Avalonia/App.axaml.cs
+++ b/src/Samples/GalNet.Sample.Avalonia/App.axaml.cs
@@ -1,6 +1,7 @@
 using Avalonia;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Markup.Xaml;
+using GalNet.Avalonia.GameHost;
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Services;
 using GalNet.Avalonia.GameView.ViewModels;
@@ -20,46 +21,81 @@ public partial class App : Application
 
     public override void Initialize()
     {
+#if BENCHMARK
+        using var measurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Sample.Xaml");
+#endif
         AvaloniaXamlLoader.Load(this);
     }
 
     public override void OnFrameworkInitializationCompleted()
     {
+#if BENCHMARK
+        using var frameworkMeasurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Sample.FrameworkInitialization");
+#endif
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
             var services = new ServiceCollection();
+#if BENCHMARK
+            using (GalNet.Diagnostics.CpuProfiler.Shared.Measure("Sample.RegisterServices"))
+#endif
             SampleCustomization.ConfigureServices(services);
 
+#if BENCHMARK
+            using (GalNet.Diagnostics.CpuProfiler.Shared.Measure("Sample.BuildServiceProvider"))
+#endif
             _rootServices = services.BuildServiceProvider();
             _gameScope = _rootServices.CreateAsyncScope();
             var scopedServices = _gameScope.Value.ServiceProvider;
-            var localization = scopedServices.GetRequiredService<SampleLocalizationService>();
+            var localization = scopedServices.GetRequiredService<IPlayerLocalization>();
             GalNet.Avalonia.GameView.MarkupExtensions.PlayerTextExtension.Resolve = localization.GetString;
 
             scopedServices.GetRequiredService<IGameNavigationService>().ResetTo<TitlePageViewModel>(NavigationTransition.None);
 
-            var mainWindow = scopedServices.GetRequiredService<MainWindow>();
+            MainWindow mainWindow;
+#if BENCHMARK
+            using (GalNet.Diagnostics.CpuProfiler.Shared.Measure("Sample.CreateMainWindow"))
+#endif
+            mainWindow = scopedServices.GetRequiredService<MainWindow>();
             desktop.MainWindow = mainWindow;
+            scopedServices.GetRequiredService<TitlePageViewModel>().ExitRequested = mainWindow.Close;
             var startupCancellation = new CancellationTokenSource();
             mainWindow.Opened += async (_, _) =>
             {
                 try
                 {
+#if BENCHMARK
+                    using var startupMeasurement = GalNet.Diagnostics.CpuProfiler.Shared.Measure("Sample.InitializeSession");
+#endif
                     var session = scopedServices.GetRequiredService<SampleGameSessionService>();
                     var ready = await session.InitializeAsync(LaunchOptions, mainWindow.SelectLanguageAsync, startupCancellation.Token);
+#if GALNET_GAME_DEBUG
                     if (ready && LaunchOptions.DebugInvitation is { } invitation)
                         await scopedServices.GetRequiredService<Debug.SampleExternalDebug>().ConnectAsync(invitation, startupCancellation.Token);
+#endif
                     if (!startupCancellation.IsCancellationRequested)
                         mainWindow.CompleteStartup(ready ? null : session.StatusMessage);
+#if BENCHMARK
+                    startupMeasurement.Dispose();
+                    global::Avalonia.Threading.Dispatcher.UIThread.Post(() =>
+                    {
+                        if (GalNet.Diagnostics.StartupBenchmark.Complete(ready)) mainWindow.Close();
+                    }, global::Avalonia.Threading.DispatcherPriority.Background);
+#endif
                 }
                 catch (OperationCanceledException)
                 {
+#if BENCHMARK
+                    GalNet.Diagnostics.StartupBenchmark.Complete(false);
+#endif
                     if (!startupCancellation.IsCancellationRequested) mainWindow.Close();
                 }
                 catch (Exception error)
                 {
                     GameLog.Logger.Error(error, "Startup flow failed");
                     if (!startupCancellation.IsCancellationRequested) mainWindow.CompleteStartup(error.Message);
+#if BENCHMARK
+                    if (GalNet.Diagnostics.StartupBenchmark.Complete(false)) mainWindow.Close();
+#endif
                 }
             };
             var closingInProgress = false;
@@ -72,6 +108,14 @@ public override void OnFrameworkInitializationCompleted()
                 if (closingInProgress) return;
 
                 closingInProgress = true;
+#if !BENCHMARK
+                var confirmed = SampleApplicationRestarter.IsRestarting || await mainWindow.ConfirmExitAsync();
+                if (!confirmed)
+                {
+                    closingInProgress = false;
+                    return;
+                }
+#endif
                 var shutdown = System.Diagnostics.Stopwatch.StartNew();
                 GameLog.Logger.Information("Game host shutdown started");
                 startupCancellation.Cancel();
diff --git a/src/Samples/GalNet.Sample.Avalonia/Debug/SampleDebugSnapshotFactory.cs b/src/Samples/GalNet.Sample.Avalonia/Debug/SampleDebugSnapshotFactory.cs
index b78d6876..1df7f54d 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Debug/SampleDebugSnapshotFactory.cs
+++ b/src/Samples/GalNet.Sample.Avalonia/Debug/SampleDebugSnapshotFactory.cs
@@ -1,5 +1,5 @@
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Core.Variable;
 using GalVariable = GalNet.Core.Variable.Variable;
 
@@ -14,6 +14,8 @@ public static GameSnapshot Create(GameSnapshot source, SampleDebugSaveKind kind)
         return new GameSnapshot
         {
             Version = source.Version,
+            ContentBuildId = source.ContentBuildId,
+            StoryPackages = source.StoryPackages.ToArray(),
             NodeId = source.NodeId,
             EntryIndex = kind == SampleDebugSaveKind.GalGroupStart ? 0 : source.EntryIndex,
             Variables = source.Variables.ToDictionary(pair => pair.Key, pair => CloneVariable(pair.Value)),
diff --git a/src/Samples/GalNet.Sample.Avalonia/GalNet.Sample.Avalonia.csproj b/src/Samples/GalNet.Sample.Avalonia/GalNet.Sample.Avalonia.csproj
index b91334e0..4072af7d 100644
--- a/src/Samples/GalNet.Sample.Avalonia/GalNet.Sample.Avalonia.csproj
+++ b/src/Samples/GalNet.Sample.Avalonia/GalNet.Sample.Avalonia.csproj
@@ -1,4 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <EnableGameDebugging Condition="'$(EnableGameDebugging)' == '' And '$(Configuration)' == 'Debug'">true</EnableGameDebugging>
+    <EnableGameDebugging Condition="'$(EnableGameDebugging)' == ''">false</EnableGameDebugging>
+    <EnableLaunchArguments Condition="'$(EnableLaunchArguments)' == ''">$(EnableGameDebugging)</EnableLaunchArguments>
+    <NuGetLockFilePath Condition="'$(EnableGameDebugging)' != 'true' And '$(PublishProfile)' != 'WindowsReadyToRun'">$(MSBuildProjectDirectory)/packages.lock.NoGameDebugging.json</NuGetLockFilePath>
+    <DefineConstants Condition="'$(EnableGameDebugging)' == 'true'">$(DefineConstants);GALNET_GAME_DEBUG</DefineConstants>
+    <DefineConstants Condition="'$(EnableLaunchArguments)' == 'true'">$(DefineConstants);GALNET_LAUNCH_ARGS</DefineConstants>
+    <NuGetLockFilePath Condition="'$(EnableGameDebugging)' == 'true' And '$(PublishProfile)' == 'WindowsReadyToRun'">$(MSBuildProjectDirectory)/packages.lock.WindowsReadyToRun.Debugging.json</NuGetLockFilePath>
+    <CopyOutputSymbolsToPublishDirectory Condition="'$(EnableGameDebugging)' != 'true'">false</CopyOutputSymbolsToPublishDirectory>
+  </PropertyGroup>
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
     <TargetFramework>net10.0</TargetFramework>
@@ -9,7 +19,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <ProjectReference Include="../../Shared/GalNet.Debugging/GalNet.Debugging.csproj" />
+    <ProjectReference Include="../../Shared/GalNet.Debugging/GalNet.Debugging.csproj" Condition="'$(EnableGameDebugging)' == 'true'" />
     <ProjectReference Include="../../Infrastructure/GalNet.Media.LibVlc/GalNet.Media.LibVlc.csproj" />
     <ProjectReference Include="../../Shared/GalNet.GameHost/GalNet.GameHost.csproj" />
     <ProjectReference Include="../../Presentation/GalNet.Avalonia.GameHost/GalNet.Avalonia.GameHost.csproj" />
@@ -17,7 +27,6 @@
     <Folder Include="Models\" />
     <AvaloniaResource Include="Assets\**" />
     <EmbeddedResource Include="Localization\*.json" />
-    <Compile Include="..\Shared\GameLocalizationProvider.cs" Link="Localization\GameLocalizationProvider.cs" />
     <Folder Include="ViewModels\" />
     <Compile Update="Views\LanguageSelectionView.axaml.cs">
       <DependentUpon>LanguageSelectionView.axaml</DependentUpon>
@@ -30,8 +39,8 @@
     <PackageReference Include="Avalonia.Themes.Fluent" />
     <PackageReference Include="Avalonia.Fonts.Inter" />
     <PackageReference Include="AvaloniaUI.DiagnosticsSupport">
-      <IncludeAssets Condition="'$(Configuration)' != 'Debug'">None</IncludeAssets>
-      <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
+      <IncludeAssets Condition="'$(EnableGameDebugging)' != 'true'">None</IncludeAssets>
+      <PrivateAssets Condition="'$(EnableGameDebugging)' != 'true'">All</PrivateAssets>
     </PackageReference>
     <PackageReference Include="CommunityToolkit.Mvvm" />
     <PackageReference Include="DynamicLocalization.Core" />
@@ -57,4 +66,22 @@
     <ProjectReference Include="..\..\Shared\GalNet.Runtime\GalNet.Runtime.csproj" />
     <ProjectReference Include="..\..\Infrastructure\GalNet.Storage.FileSystem\GalNet.Storage.FileSystem.csproj" />
   </ItemGroup>
+  <ItemGroup Condition="'$(Benchmark)' == 'true'">
+    <ProjectReference Include="../../Shared/GalNet.Diagnostics/GalNet.Diagnostics.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(EnableGameDebugging)' != 'true'">
+    <Compile Remove="Debug/**/*.cs;Services/SampleDebug*.cs;Services/SampleGameSessionService.Debug.cs;Views/Debug*.cs;Views/MainWindow.Debug.cs" />
+    <AvaloniaResource Remove="Views/Debug*.axaml" />
+    <AvaloniaXaml Remove="Views/Debug*.axaml" />
+  </ItemGroup>
+  <!-- The SDK property alone does not exclude referenced-project and native-package PDBs. -->
+  <Target Name="ValidateSampleLaunchCapabilities" BeforeTargets="CoreCompile">
+    <Error Condition="'$(EnableGameDebugging)' == 'true' And '$(EnableLaunchArguments)' != 'true'" Text="Game debugging requires EnableLaunchArguments=true." />
+  </Target>
+  <Target Name="ExcludePlayerPublishSymbols" AfterTargets="ComputeFilesToPublish" Condition="'$(CopyOutputSymbolsToPublishDirectory)' == 'false'">
+    <ItemGroup>
+      <ResolvedFileToPublish Remove="@(ResolvedFileToPublish)" Condition="'%(ResolvedFileToPublish.Extension)' == '.pdb'" />
+    </ItemGroup>
+  </Target>
 </Project>
diff --git a/src/Samples/GalNet.Sample.Avalonia/GameLaunchOptions.cs b/src/Samples/GalNet.Sample.Avalonia/GameLaunchOptions.cs
index 8295e051..43b88fdf 100644
--- a/src/Samples/GalNet.Sample.Avalonia/GameLaunchOptions.cs
+++ b/src/Samples/GalNet.Sample.Avalonia/GameLaunchOptions.cs
@@ -1,47 +1,111 @@
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Storage.FileSystem;
+#if GALNET_GAME_DEBUG
 using GalNet.Debugging;
+#endif
 
 namespace GalNet.Sample.Avalonia;
 
 internal sealed record GameLaunchOptions(string? GameDirectory, string? ProfileDirectory)
 {
+#if GALNET_GAME_DEBUG
     public DebugInvitation? DebugInvitation { get; init; }
-    public string LogDirectory =>
-        Path.Combine(
-            ProfileDirectory
-            ?? (GameDirectory is null
-                ? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "GalNet", "Sample")
-                : Path.Combine(GameDirectory, ".galnet")),
-            "logs");
+#endif
+    public string LogDirectory => Path.Combine(ProfileDirectory
+        ?? GetDefaultProfileDirectory(GameDirectory ?? Path.Combine(GetApplicationDirectory(AppContext.BaseDirectory), "pak")), "logs");
 
     public static GameLaunchOptions Parse(string[] args)
+        => Parse(args, GetApplicationDirectory(AppContext.BaseDirectory));
+
+    internal static string GetApplicationDirectory(string assemblyDirectory)
+    {
+        var directory = new DirectoryInfo(Path.GetFullPath(assemblyDirectory));
+        return directory.Name.Equals("lib", StringComparison.OrdinalIgnoreCase) && directory.Parent is not null
+            && (File.Exists(Path.Combine(directory.Parent.FullName, "GalNet.Sample.Avalonia.exe"))
+                || File.Exists(Path.Combine(directory.Parent.FullName, "GalNet.Sample.Avalonia")))
+            ? directory.Parent.FullName : directory.FullName;
+    }
+
+    internal static string GetDefaultProfileDirectory(string gameDirectory)
+    {
+        var identity = "directory:" + Path.GetFullPath(gameDirectory);
+        try
+        {
+            if (File.Exists(Path.Combine(gameDirectory, PackedGameDocuments.GameFileName)))
+                identity = "project:" + InstalledGameDescriptor.Read(gameDirectory).ProjectId;
+            else
+            {
+                var descriptor = Path.Combine(gameDirectory, "content.json");
+                if (File.Exists(descriptor))
+                {
+                    using var json = JsonDocument.Parse(File.ReadAllBytes(descriptor));
+                    if (json.RootElement.ValueKind == JsonValueKind.Object
+                        && json.RootElement.TryGetProperty("projectId", out var id)
+                        && id.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(id.GetString()))
+                        identity = "project:" + id.GetString();
+                }
+            }
+        }
+        catch (Exception error) when (error is IOException or InvalidDataException or UnauthorizedAccessException or JsonException)
+        {
+            // Content loading reports the original error in the startup window.
+        }
+        var projectKey = Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(identity)));
+        return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "GalNet", projectKey);
+    }
+
+    internal static GameLaunchOptions Parse(string[] args, string applicationDirectory)
     {
-        string? gameDirectory = null;
+        var gameDirectory = Path.Combine(Path.GetFullPath(applicationDirectory), "pak");
         string? profileDirectory = null;
+#if GALNET_LAUNCH_ARGS
+        var hasGameArgument = false;
+#if GALNET_GAME_DEBUG
         var debug = new Dictionary<string, string>(StringComparer.Ordinal);
+#endif
 
         for (var index = 0; index < args.Length; index++)
         {
             if (args[index].StartsWith("--debug-", StringComparison.Ordinal))
             {
+#if GALNET_GAME_DEBUG
                 var key = args[index];
                 if (index + 1 >= args.Length) throw new ArgumentException($"Missing value for '{key}'.");
                 debug.Add(key, args[++index]);
                 continue;
+#else
+                throw new ArgumentException("This application was built without game debugging support.");
+#endif
             }
-            if (args[index] == "--profile" && index + 1 < args.Length)
+            if (args[index] == "--profile")
             {
+                if (index + 1 >= args.Length || args[index + 1].StartsWith('-'))
+                    throw new ArgumentException("Missing value for '--profile'.");
                 profileDirectory = Path.GetFullPath(args[++index]);
                 continue;
             }
 
-            if (!args[index].StartsWith('-') && gameDirectory is null)
+            if (!args[index].StartsWith('-') && !hasGameArgument)
+            {
                 gameDirectory = Path.GetFullPath(args[index]);
+                hasGameArgument = true;
+                continue;
+            }
+            throw new ArgumentException($"Unknown launch argument '{args[index]}'.");
         }
+#else
+        if (args.Length > 0) throw new ArgumentException("This player was built without launch argument support.");
+#endif
+        profileDirectory ??= GetDefaultProfileDirectory(gameDirectory);
 
+#if GALNET_GAME_DEBUG
         DebugInvitation? invitation = null;
         if (debug.Count > 0)
         {
-            if (gameDirectory is null || !debug.TryGetValue("--debug-port", out var portText) || !int.TryParse(portText, out var port) || port is <= 0 or > 65535 ||
+            if (!debug.TryGetValue("--debug-port", out var portText) || !int.TryParse(portText, out var port) || port is <= 0 or > 65535 ||
                 !debug.TryGetValue("--debug-token", out var token) || !debug.TryGetValue("--debug-session", out var session) || !debug.TryGetValue("--debug-project", out var project))
                 throw new ArgumentException("Debug launch requires a content directory, port, token, session and project identity.");
             string? fingerprint = null;
@@ -54,5 +118,8 @@ public static GameLaunchOptions Parse(string[] args)
             invitation = new(port, token, session, new(project, DebugContentIdentity.Compute(gameDirectory), fingerprint));
         }
         return new GameLaunchOptions(gameDirectory, profileDirectory) { DebugInvitation = invitation };
+#else
+        return new GameLaunchOptions(gameDirectory, profileDirectory);
+#endif
     }
 }
diff --git a/src/Samples/GalNet.Sample.Avalonia/Localization/en-US.json b/src/Samples/GalNet.Sample.Avalonia/Localization/en-US.json
index a1a2eeb5..e63c65ea 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Localization/en-US.json
+++ b/src/Samples/GalNet.Sample.Avalonia/Localization/en-US.json
@@ -1,4 +1,7 @@
 {
+  "Title.Exit": "Exit",
+  "Exit.Title": "Exit game",
+  "Exit.Message": "Are you sure you want to exit?",
   "Settings.Operation": "Controls",
   "Input.Advance": "Advance",
   "Input.HoldQuick": "Hold to fast-forward",
@@ -99,10 +102,19 @@
   "Screenshot.Folder": "Folder",
   "Screenshot.ChooseFolder": "Choose folder…",
   "Screenshot.FileName": "File name",
-  "Screenshot.IncludeUi": "Include player UI",
+  "Screenshot.IncludeUi": "Include dialogue and controls",
+  "Screenshot.CaptureFailed": "Could not capture screenshot.",
+  "Screenshot.SaveFailed": "Could not save screenshot.",
+  "Screenshot.FileNameRequired": "Enter a file name.",
+  "SaveSlots.SaveTitle": "Save game",
+  "SaveSlots.LoadTitle": "Load game",
   "Common.Cancel": "Cancel",
   "SaveSlots.Choose": "Choose a slot",
-  "SaveSlots.Hint": "Saves are managed by the current game host.",
+  "SaveSlots.Hint": "Click a save name to edit it. Press Enter or click elsewhere to save.",
+  "SaveSlots.Slot": "Save",
+  "SaveSlots.Empty": "Empty slot",
+  "SaveSlots.Corrupt": "Corrupt save",
+  "SaveSlots.RenameFailed": "Could not save the name. Try again.",
   "About.Description": "This default player shell is fully replaceable by a game client without changing its runtime or game data.",
   "Title.NewGame": "New Game",
   "Title.Continue": "Continue",
@@ -119,5 +131,12 @@
   "Debug.OpenLogDirectory": "Open log directory",
   "DebugLog.Title": "Debug log",
   "DebugLog.Clear": "Clear log",
-  "DebugLog.OpenDirectory": "Open log directory"
+  "DebugLog.OpenDirectory": "Open log directory",
+  "Settings.Muted": "Muted",
+  "History.Title": "History",
+  "History.ReplayVoice": "Replay voice",
+  "History.Empty": "No dialogue yet.",
+  "Settings.ReadTextColor": "Read text color",
+  "Settings.EnableReadTextColor": "Enable",
+  "Settings.InvalidColor": "Choose a valid color."
 }
diff --git a/src/Samples/GalNet.Sample.Avalonia/Localization/zh-CN.json b/src/Samples/GalNet.Sample.Avalonia/Localization/zh-CN.json
index be6e34b8..40bd9fc6 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Localization/zh-CN.json
+++ b/src/Samples/GalNet.Sample.Avalonia/Localization/zh-CN.json
@@ -1,12 +1,15 @@
 {
+  "Title.Exit": "退出",
+  "Exit.Title": "退出游戏",
+  "Exit.Message": "确定要退出游戏吗？",
   "Settings.Operation": "操作",
-  "Input.Advance": "下一步",
-  "Input.HoldQuick": "按住快速",
-  "Input.Quick": "切换快速",
+  "Input.Advance": "推进剧情",
+  "Input.HoldQuick": "按住快进",
+  "Input.Quick": "切换快进",
   "Input.Auto": "自动播放",
   "Input.Skip": "跳过已读",
   "Input.HideUi": "显示 / 隐藏界面",
-  "Input.Save": "存入首个空槽",
+  "Input.Save": "保存至空存档槽",
   "Input.OpenSave": "打开存档页",
   "Input.Load": "打开读档页",
   "Input.Settings": "打开设置",
@@ -75,20 +78,20 @@
   "Settings.SfxMuted": "音效静音",
   "Settings.VoiceVolume": "语音音量",
   "Settings.VoiceMuted": "语音静音",
-  "Playback.Quick": "快速",
+  "Playback.Quick": "快进",
   "Playback.Auto": "自动",
   "Playback.Skip": "跳过",
   "Playback.SkipTitle": "跳过已读剧情？",
   "Playback.SkipMessage": "沿当前剧情继续，直到未读文本或下一个选项。",
   "Playback.Failed": "无法切换播放，请查看游戏日志了解详情。",
   "Common.Confirm": "确认",
-  "Settings.Description": "播放偏好",
+  "Settings.Description": "游戏偏好",
   "Settings.Language": "语言",
-  "Settings.TextSpeed": "文字速度",
-  "Settings.Hint": "设置为当前游戏保存。界面立即切换，剧情文本从下一条起生效。",
+  "Settings.TextSpeed": "文字显示速度",
+  "Settings.Hint": "偏好会自动保存。界面语言立即切换，剧情文本从下一条开始使用新语言。",
   "Common.Back": "返回",
   "Common.Save": "保存",
-  "Common.Title": "标题",
+  "Common.Title": "返回标题画面",
   "Common.Screenshot": "截图",
   "Common.HideUi": "隐藏界面",
   "Gallery.Locked": "未解锁",
@@ -96,13 +99,22 @@
   "Gallery.Description": "已解锁的回忆与作品",
   "Gallery.Unavailable": "鉴赏页面不可用",
   "Screenshot.Title": "保存截图",
-  "Screenshot.Folder": "文件夹",
+  "Screenshot.Folder": "保存位置",
   "Screenshot.ChooseFolder": "选择文件夹…",
   "Screenshot.FileName": "文件名",
-  "Screenshot.IncludeUi": "包含播放器界面",
+  "Screenshot.IncludeUi": "包含对话框和操作栏",
+  "Screenshot.CaptureFailed": "无法生成截图预览。",
+  "Screenshot.SaveFailed": "截图保存失败。",
+  "Screenshot.FileNameRequired": "请输入图片名称。",
+  "SaveSlots.SaveTitle": "保存进度",
+  "SaveSlots.LoadTitle": "读取存档",
   "Common.Cancel": "取消",
   "SaveSlots.Choose": "选择存档槽",
-  "SaveSlots.Hint": "存档由当前游戏宿主管理。",
+  "SaveSlots.Hint": "点击存档名称即可编辑，按 Enter 或点击其他位置保存。",
+  "SaveSlots.Slot": "存档",
+  "SaveSlots.Empty": "空存档槽",
+  "SaveSlots.Corrupt": "存档已损坏",
+  "SaveSlots.RenameFailed": "名称保存失败，请重试。",
   "About.Description": "游戏客户端可以替换默认播放器界面，无需更改运行时或游戏数据。",
   "Title.NewGame": "开始游戏",
   "Title.Continue": "继续游戏",
@@ -119,5 +131,12 @@
   "Debug.OpenLogDirectory": "打开日志目录",
   "DebugLog.Title": "调试日志",
   "DebugLog.Clear": "清空日志",
-  "DebugLog.OpenDirectory": "打开日志目录"
+  "DebugLog.OpenDirectory": "打开日志目录",
+  "Settings.Muted": "静音",
+  "History.Title": "历史",
+  "History.ReplayVoice": "重播语音",
+  "History.Empty": "暂无历史文本。",
+  "Settings.ReadTextColor": "已读文本颜色",
+  "Settings.EnableReadTextColor": "启用",
+  "Settings.InvalidColor": "请选择有效颜色。"
 }
diff --git a/src/Samples/GalNet.Sample.Avalonia/Program.cs b/src/Samples/GalNet.Sample.Avalonia/Program.cs
index dd45a2a9..bcd28a77 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Program.cs
+++ b/src/Samples/GalNet.Sample.Avalonia/Program.cs
@@ -2,7 +2,9 @@
 using Avalonia;
 using GalNet.Avalonia.Themes;
 using GalNet.Runtime.Logging;
+#if GALNET_GAME_DEBUG
 using GalNet.Sample.Avalonia.Debug;
+#endif
 using Serilog;
 
 namespace GalNet.Sample.Avalonia;
@@ -12,12 +14,19 @@ sealed class Program
     [STAThread]
     public static void Main(string[] args)
     {
+#if BENCHMARK
+        GalNet.Diagnostics.StartupBenchmark.Start();
+#endif
         try
         {
             var launchOptions = GameLaunchOptions.Parse(args);
             Directory.CreateDirectory(launchOptions.LogDirectory);
             Log.Logger = new LoggerConfiguration()
+#if GALNET_GAME_DEBUG
                 .MinimumLevel.Debug()
+#else
+                .MinimumLevel.Information()
+#endif
                 .Enrich.WithProperty("LogChannel", "Game")
                 .WriteTo.Console(
                     formatProvider: CultureInfo.InvariantCulture,
@@ -29,7 +38,9 @@ public static void Main(string[] args)
                     retainedFileCountLimit: 14,
                     shared: true,
                     outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} {Level:u3} {LogChannel}] {Message:lj}{NewLine}{Exception}")
+#if GALNET_GAME_DEBUG
                 .WriteTo.Sink(SampleDebugLogStore.Shared)
+#endif
                 .CreateLogger();
 
             try
@@ -49,10 +60,16 @@ public static void Main(string[] args)
             {
                 GameLog.Logger.Information("Avalonia sample stopped");
                 Log.CloseAndFlush();
+#if BENCHMARK
+                if (GalNet.Diagnostics.StartupBenchmark.Failed) Environment.ExitCode = 1;
+#endif
             }
         }
         catch (Exception exception)
         {
+#if BENCHMARK
+            GalNet.Diagnostics.StartupBenchmark.Complete(false);
+#endif
             Console.Error.WriteLine(exception);
             Environment.ExitCode = 1;
         }
@@ -62,7 +79,7 @@ public static void Main(string[] args)
     public static AppBuilder BuildAvaloniaApp()
         => AppBuilder.Configure<App>()
             .UsePlatformDetect()
-#if DEBUG
+#if GALNET_GAME_DEBUG
             .WithDeveloperTools()
 #endif
             .WithInterFont()
diff --git a/src/Samples/GalNet.Sample.Avalonia/Properties/PublishProfiles/WindowsReadyToRun.pubxml b/src/Samples/GalNet.Sample.Avalonia/Properties/PublishProfiles/WindowsReadyToRun.pubxml
new file mode 100644
index 00000000..c7276fff
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Avalonia/Properties/PublishProfiles/WindowsReadyToRun.pubxml
@@ -0,0 +1,10 @@
+<Project>
+  <PropertyGroup>
+    <Configuration>Release</Configuration>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <SelfContained>false</SelfContained>
+    <PublishReadyToRun>true</PublishReadyToRun>
+    <PublishSingleFile>false</PublishSingleFile>
+    <PublishTrimmed>false</PublishTrimmed>
+  </PropertyGroup>
+</Project>
diff --git a/src/Samples/GalNet.Sample.Avalonia/SampleCustomization.cs b/src/Samples/GalNet.Sample.Avalonia/SampleCustomization.cs
index e1ea7a61..78280c66 100644
--- a/src/Samples/GalNet.Sample.Avalonia/SampleCustomization.cs
+++ b/src/Samples/GalNet.Sample.Avalonia/SampleCustomization.cs
@@ -1,22 +1,27 @@
+using GalNet.Contracts.Builtins.Assets;
 using DynamicLocalization.Core;
 using DynamicLocalization.Core.Providers;
 using GalNet.Avalonia.GameHost;
 using GalNet.Avalonia.GameView.Composition;
 using GalNet.Avalonia.GameView.Page;
+using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Presentation;
 using GalNet.Avalonia.GameView.Services;
 using GalNet.Avalonia.GameView.ViewModels;
 using GalNet.Avalonia.Themes;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Contracts.Builtins;
 using GalNet.Game.Controls.Forms;
 using GalNet.Media.LibVlc;
-using GalNet.Presentation.Abstractions.Audio;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
 using GalNet.Project.Contracts;
-using GalNet.Runtime.Content;
+using GalNet.GameHost.Content;
+#if GALNET_GAME_DEBUG
 using GalNet.Sample.Avalonia.Debug;
+#endif
 using GalNet.Sample.Avalonia.Presentation;
 using GalNet.Sample.Avalonia.Services;
 using GalNet.Sample.Avalonia.ViewModels;
@@ -28,29 +33,33 @@ namespace GalNet.Sample.Avalonia;
 /// <summary>Project choices. The host owns services and resources; modules borrow platform ports.</summary>
 internal static class SampleCustomization
 {
-    internal static IGameLayoutTheme PlayerTheme { get; } = new ClassicTheme(GamePalette.Mono);
+    internal static GamePalette PlayerPalette { get; } = GamePalette.Mono;
+    internal static IGameLayoutTheme PlayerTheme { get; } = new ClassicTheme(PlayerPalette);
 
-    internal static void ConfigureServices(IServiceCollection services, bool enableDebug = true)
+    internal static void ConfigureServices(IServiceCollection services, bool enableDebug = true, Action<IPageViewRegistryBuilder>? configureViews = null)
     {
-        services.AddAvaloniaGameViewPages(theme: PlayerTheme)
+        services.AddAvaloniaGameViewPages(theme: PlayerTheme, configureViews: configureViews)
             .AddSingleton(_ => CreateLocalizationService())
-            .AddSingleton<IPlayerLocalization>(provider => provider.GetRequiredService<SampleLocalizationService>())
+            .AddSingleton<IPlayerLocalization>(provider => provider.GetRequiredService<AvaloniaPlayerLocalization>())
             .AddSingleton<LibVlcRuntime>()
             .AddScoped(provider => new AvaloniaPlayerSettingsService(provider.GetRequiredService<IPlayerLocalization>(),
                 provider.GetRequiredService<GamePageViewModel>(), editors: CreateFieldEditors()))
-            .AddScoped<AvaloniaPlayerStartup>()
+            .AddScoped<IPlayerStartup, AvaloniaPlayerStartup>()
             .AddScoped<LanguageSelectionViewModel>()
-            .AddScoped<IPlayerSettingsService>(provider => provider.GetRequiredService<AvaloniaPlayerSettingsService>())
+            .AddScoped<IAvaloniaPlayerSettings>(provider => provider.GetRequiredService<AvaloniaPlayerSettingsService>())
+            .AddScoped<IPlayerSettingsService>(provider => provider.GetRequiredService<IAvaloniaPlayerSettings>())
             .AddScoped<SampleGameSessionService>()
             .AddScoped<IGameSessionService>(provider => provider.GetRequiredService<SampleGameSessionService>())
             .AddTransient<MainWindow>();
+#if GALNET_GAME_DEBUG
         if (enableDebug) services.AddSampleDebug();
         if (enableDebug) services.AddScoped<SampleExternalDebug>();
+#endif
     }
 
     internal static EditorRegistry CreateFieldEditors() => EditorRegistry.CreateDefault().Freeze();
 
-    internal static SampleLocalizationService CreateLocalizationService()
+    internal static AvaloniaPlayerLocalization CreateLocalizationService()
     {
         var cultureService = new CultureService();
         var provider = new JsonLocalizationProvider();
@@ -62,8 +71,7 @@ internal static SampleLocalizationService CreateLocalizationService()
         });
         cultureService.RegisterProvider(provider);
         cultureService.SetCulture("en-US");
-        LocalizationService.Initialize(cultureService);
-        return SampleLocalizationService.Create(cultureService, [provider]);
+        return new AvaloniaPlayerLocalization(cultureService, [provider]);
     }
 
     internal static (IResourceTypeCatalog Resources, IGalleryTypeCatalog Gallery) CreateContentCatalogs()
@@ -72,12 +80,27 @@ internal static (IResourceTypeCatalog Resources, IGalleryTypeCatalog Gallery) Cr
         return (resources, BuiltinGalleryTypes.CreateCatalog(resources));
     }
 
-    internal static AvaloniaGameHostOptions CreateHostOptions(Func<GalNet.Runtime.Engine.GameEngine, IDisposable>? attachDebugRun = null) => new()
+    internal static AvaloniaGameHostOptions CreateHostOptions(Func<GalNet.Runtime.Engine.GameEngine, IDisposable>? attachRun = null) => new()
     {
         GameTitle = "GalNet Avalonia Sample",
         NoGameMessage = "Usage: GalNet.Sample.Avalonia <game-data-directory> [--profile <directory>]",
         CreateContentCatalogs = CreateContentCatalogs,
-        AttachDebugRun = attachDebugRun,
+        AttachRun = attachRun,
+        Content = new GameContentLoadOptions
+        {
+            Configurations = ProjectSchemas.Configurations,
+            SelectDefaultCulture = configuration => configuration.ReadDefaultOptions().TargetLocale.Code
+        },
+        SelectProjectOptions = configuration =>
+        {
+            var options = configuration.ReadDefaultOptions();
+            return new()
+            {
+                SaveSlotCount = options.SaveSlotCount,
+                DefaultCulture = options.TargetLocale.Code,
+                Audio = new(options.AudioTracks, options.AudioBuses)
+            };
+        },
         ConfigureExecution = (registration, presentation, page, content) => ConfigureExecution(registration,
             presentation.Presenters, page, content, presentation.Effects, presentation.Audio,
             presentation.Video, presentation.AudioModule, presentation.ImageVariants)
@@ -86,7 +109,7 @@ internal static (IResourceTypeCatalog Resources, IGalleryTypeCatalog Gallery) Cr
     internal static void ConfigureExecution(
         GameRegistration registration, AvaloniaGamePresenters presenters, GamePage page,
         GameContent content, AvaloniaEffectRuntime? effects, IAudioPlaybackHost? audio,
-        AvaloniaVideoPresenter? video, BuiltinAudioModule? audioModule, GalNet.Core.Variants.ImageVariantsCatalog? imageVariants = null)
+        IVideoPresenter? video, BuiltinAudioModule? audioModule, GalNet.Contracts.Builtins.Variants.ImageVariantsCatalog? imageVariants = null)
     {
         registration.UseCatalog(ProjectSchemas.CreateCatalog());
         registration.AddBuiltinImplementations(registration.BuildCatalog(),
diff --git a/src/Samples/GalNet.Sample.Avalonia/Services/SampleApplicationRestarter.cs b/src/Samples/GalNet.Sample.Avalonia/Services/SampleApplicationRestarter.cs
index 51cb698b..3cf18fe3 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Services/SampleApplicationRestarter.cs
+++ b/src/Samples/GalNet.Sample.Avalonia/Services/SampleApplicationRestarter.cs
@@ -7,6 +7,8 @@ namespace GalNet.Sample.Avalonia.Services;
 /// <summary>Restarts the Sample with the exact host command and launch arguments it received.</summary>
 internal static class SampleApplicationRestarter
 {
+    public static bool IsRestarting { get; private set; }
+
     public static void Restart()
     {
         if (Application.Current?.ApplicationLifetime is not IClassicDesktopStyleApplicationLifetime desktop)
@@ -27,6 +29,7 @@ public static void Restart()
         if (Process.Start(startInfo) is null)
             throw new InvalidOperationException("Unable to start the replacement Sample process.");
 
+        IsRestarting = true;
         desktop.Shutdown();
     }
 }
diff --git a/src/Samples/GalNet.Sample.Avalonia/Services/SampleGameSessionService.Debug.cs b/src/Samples/GalNet.Sample.Avalonia/Services/SampleGameSessionService.Debug.cs
new file mode 100644
index 00000000..8df4074d
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Avalonia/Services/SampleGameSessionService.Debug.cs
@@ -0,0 +1,27 @@
+using GalNet.Runtime.Logging;
+using GalNet.Sample.Avalonia.Debug;
+
+namespace GalNet.Sample.Avalonia.Services;
+
+internal sealed partial class SampleGameSessionService
+{
+    internal Task<SampleDebugSaveResult> SaveDebugSnapshotAsync(SampleDebugSaveKind kind,
+        bool overwriteWhenAllVisibleSlotsAreOccupied, CancellationToken cancellationToken = default) =>
+        WithSnapshotAsync(async (currentSnapshot, saves, token) =>
+        {
+            var slots = await saves.ListSlotsAsync(token);
+            var firstEmptySlot = slots.Where(slot => slot.Timestamp == default && !slot.IsCorrupt)
+                .OrderBy(slot => slot.SlotIndex).FirstOrDefault();
+            if (firstEmptySlot is null && !overwriteWhenAllVisibleSlotsAreOccupied)
+                return SampleDebugSaveResult.RequiresOverwrite();
+            var targetSlot = firstEmptySlot?.SlotIndex
+                ?? slots.OrderBy(slot => slot.SlotIndex).FirstOrDefault()?.SlotIndex
+                ?? throw new InvalidOperationException("没有可用的存档槽。");
+            var snapshot = SampleDebugSnapshotFactory.Create(currentSnapshot, kind);
+            await saves.SaveAsync(targetSlot, snapshot, token);
+            await RefreshSlotsAsync(token);
+            await SetGameplayStatusAsync($"Debug saved to slot {targetSlot}.");
+            GameLog.Logger.Information("Created {DebugSaveKind} debug save in slot {SlotIndex}", kind, targetSlot);
+            return SampleDebugSaveResult.Saved(targetSlot);
+        }, cancellationToken);
+}
diff --git a/src/Samples/GalNet.Sample.Avalonia/Services/SampleGameSessionService.cs b/src/Samples/GalNet.Sample.Avalonia/Services/SampleGameSessionService.cs
index 1b52f70a..221a19bc 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Services/SampleGameSessionService.cs
+++ b/src/Samples/GalNet.Sample.Avalonia/Services/SampleGameSessionService.cs
@@ -2,40 +2,27 @@
 using GalNet.Avalonia.GameView.Page;
 using GalNet.Avalonia.GameView.ViewModels;
 using GalNet.Media.LibVlc;
-using GalNet.Runtime.Logging;
-using GalNet.Sample.Avalonia.Debug;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace GalNet.Sample.Avalonia.Services;
 
 /// <summary>Project launch arguments and debug-only save policies.</summary>
-internal sealed class SampleGameSessionService(
-    GamePageViewModel gameplay, GamePage page, AvaloniaPlayerSettingsService settings,
-    SampleLocalizationService localization, AvaloniaPlayerStartup startup, LibVlcRuntime mediaRuntime, IServiceProvider services)
-    : AvaloniaGameSession(SampleCustomization.CreateHostOptions(App.LaunchOptions.DebugInvitation is null ? null :
-        engine => services.GetRequiredService<SampleExternalDebug>().Attach(engine)), gameplay, page, settings, localization, startup, mediaRuntime)
+internal sealed partial class SampleGameSessionService(
+    GamePageViewModel gameplay, GamePage page, IAvaloniaPlayerSettings settings,
+    IPlayerLocalization localization, IPlayerStartup startup, LibVlcRuntime mediaRuntime, IServiceProvider services)
+    : AvaloniaGameSession(CreateOptions(services), gameplay, page, settings, localization, startup, mediaRuntime)
 {
     public Task<bool> InitializeAsync(GameLaunchOptions options,
         Func<string, CancellationToken, Task<string?>> selectLanguage, CancellationToken cancellationToken = default) =>
         InitializeAsync(options.GameDirectory, options.ProfileDirectory, selectLanguage, cancellationToken);
 
-    internal Task<SampleDebugSaveResult> SaveDebugSnapshotAsync(SampleDebugSaveKind kind,
-        bool overwriteWhenAllVisibleSlotsAreOccupied, CancellationToken cancellationToken = default) =>
-        WithSnapshotAsync(async (currentSnapshot, saves, token) =>
-        {
-            var slots = await saves.ListSlotsAsync(token);
-            var firstEmptySlot = slots.Where(slot => slot.Timestamp == default && !slot.IsCorrupt)
-                .OrderBy(slot => slot.SlotIndex).FirstOrDefault();
-            if (firstEmptySlot is null && !overwriteWhenAllVisibleSlotsAreOccupied)
-                return SampleDebugSaveResult.RequiresOverwrite();
-            var targetSlot = firstEmptySlot?.SlotIndex
-                ?? slots.OrderBy(slot => slot.SlotIndex).FirstOrDefault()?.SlotIndex
-                ?? throw new InvalidOperationException("没有可用的存档槽。");
-            var snapshot = SampleDebugSnapshotFactory.Create(currentSnapshot, kind);
-            await saves.SaveAsync(targetSlot, snapshot, token);
-            await RefreshSlotsAsync(token);
-            await SetGameplayStatusAsync($"Debug saved to slot {targetSlot}.");
-            GameLog.Logger.Information("Created {DebugSaveKind} debug save in slot {SlotIndex}", kind, targetSlot);
-            return SampleDebugSaveResult.Saved(targetSlot);
-        }, cancellationToken);
+    private static AvaloniaGameHostOptions CreateOptions(IServiceProvider services)
+    {
+#if GALNET_GAME_DEBUG
+        return SampleCustomization.CreateHostOptions(App.LaunchOptions.DebugInvitation is null ? null :
+            engine => services.GetRequiredService<GalNet.Sample.Avalonia.Debug.SampleExternalDebug>().Attach(engine));
+#else
+        return SampleCustomization.CreateHostOptions();
+#endif
+    }
 }
diff --git a/src/Samples/GalNet.Sample.Avalonia/ViewModels/LanguageSelectionViewModel.cs b/src/Samples/GalNet.Sample.Avalonia/ViewModels/LanguageSelectionViewModel.cs
index 78ff82de..89ac5eda 100644
--- a/src/Samples/GalNet.Sample.Avalonia/ViewModels/LanguageSelectionViewModel.cs
+++ b/src/Samples/GalNet.Sample.Avalonia/ViewModels/LanguageSelectionViewModel.cs
@@ -1,12 +1,13 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
+using GalNet.Avalonia.GameHost;
 using GalNet.Avalonia.GameView.Services;
 using GalNet.Sample.Avalonia.Services;
 
 namespace GalNet.Sample.Avalonia.ViewModels;
 
 /// <summary>Owns the first-run selection; language sources must be loaded before choosing.</summary>
-public sealed partial class LanguageSelectionViewModel(SampleLocalizationService localization) : ObservableObject
+public sealed partial class LanguageSelectionViewModel(IPlayerLocalization localization) : ObservableObject
 {
     private TaskCompletionSource<string?>? _selection;
 
@@ -43,6 +44,11 @@ public sealed partial class LanguageSelectionViewModel(SampleLocalizationService
         }
     }
 
+    partial void OnSelectedLanguageChanged(SettingOption? value)
+    {
+        if (value is not null) localization.ApplyCulture(value.Value);
+    }
+
     private bool CanConfirm() => _selection is { Task.IsCompleted: false } && SelectedLanguage is not null;
 
     [RelayCommand(CanExecute = nameof(CanConfirm))]
@@ -52,6 +58,4 @@ private void Confirm()
             _selection!.TrySetResult(SelectedLanguage!.Value);
     }
 
-    [RelayCommand]
-    private void Cancel() => _selection?.TrySetResult(null);
 }
diff --git a/src/Samples/GalNet.Sample.Avalonia/Views/DebugMenuView.axaml b/src/Samples/GalNet.Sample.Avalonia/Views/DebugMenuView.axaml
new file mode 100644
index 00000000..43972b44
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Avalonia/Views/DebugMenuView.axaml
@@ -0,0 +1,19 @@
+<Menu xmlns="https://github.com/avaloniaui"
+      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+      xmlns:debug="using:GalNet.Sample.Avalonia.Debug"
+      xmlns:loc="clr-namespace:GalNet.Avalonia.GameView.MarkupExtensions;assembly=GalNet.Avalonia.GameView"
+      x:Class="GalNet.Sample.Avalonia.Views.DebugMenuView"
+      x:DataType="debug:SampleDebugViewModel">
+  <MenuItem Header="{loc:Localize Debug.Menu}" Foreground="{DynamicResource GalNet.Brush.TextPrimary}">
+    <MenuItem Header="{loc:Localize Debug.ClearPlayerState}" Command="{Binding ClearPlayerStateCommand}" />
+    <MenuItem Header="{loc:Localize Debug.ReloadGameResources}" Command="{Binding ReloadGameResourcesCommand}" />
+    <Separator />
+    <MenuItem Header="{loc:Localize Debug.Save}">
+      <MenuItem Header="{loc:Localize Debug.SaveProgressOnly}" Command="{Binding SaveProgressOnlyCommand}" />
+      <MenuItem Header="{loc:Localize Debug.SaveGalgroup}" Command="{Binding SaveGalGroupStartCommand}" />
+    </MenuItem>
+    <Separator />
+    <MenuItem Header="{loc:Localize Debug.ShowLog}" Command="{Binding ShowLogCommand}" />
+    <MenuItem Header="{loc:Localize Debug.OpenLogDirectory}" Command="{Binding OpenLogDirectoryCommand}" />
+  </MenuItem>
+</Menu>
diff --git a/src/Samples/GalNet.Sample.Avalonia/Views/DebugMenuView.axaml.cs b/src/Samples/GalNet.Sample.Avalonia/Views/DebugMenuView.axaml.cs
new file mode 100644
index 00000000..b4c82095
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Avalonia/Views/DebugMenuView.axaml.cs
@@ -0,0 +1,10 @@
+using Avalonia.Controls;
+
+namespace GalNet.Sample.Avalonia.Views;
+
+public partial class DebugMenuView : Menu
+{
+    protected override Type StyleKeyOverride => typeof(Menu);
+
+    public DebugMenuView() => InitializeComponent();
+}
diff --git a/src/Samples/GalNet.Sample.Avalonia/Views/LanguageSelectionView.axaml b/src/Samples/GalNet.Sample.Avalonia/Views/LanguageSelectionView.axaml
index ed0b62a0..0ad5c535 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Views/LanguageSelectionView.axaml
+++ b/src/Samples/GalNet.Sample.Avalonia/Views/LanguageSelectionView.axaml
@@ -18,7 +18,6 @@
       </ComboBox.ItemTemplate>
     </ComboBox>
     <StackPanel Orientation="Horizontal" Spacing="12" HorizontalAlignment="Right">
-      <Button x:Name="CancelButton" Content="{loc:Localize Common.Cancel}" Command="{Binding CancelCommand}" />
       <Button x:Name="ConfirmButton" Content="{loc:Localize Onboarding.Confirm}" Command="{Binding ConfirmCommand}" />
     </StackPanel>
   </StackPanel>
diff --git a/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.Debug.cs b/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.Debug.cs
new file mode 100644
index 00000000..20e4e847
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.Debug.cs
@@ -0,0 +1,86 @@
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using GalNet.Sample.Avalonia.Debug;
+using Microsoft.Extensions.DependencyInjection;
+using Ursa.Controls;
+
+namespace GalNet.Sample.Avalonia.Views;
+
+public partial class MainWindow
+{
+    private IServiceProvider _services = null!;
+    private SampleDebugLogStore? _debugLogStore;
+    private SampleDebugViewModel? _debugViewModel;
+    private DebugLogWindow? _debugLogWindow;
+    private DebugMenuView _debugMenu = null!;
+
+    partial void InitializeDebug(IServiceProvider services)
+    {
+        _services = services;
+        _debugLogStore = services.GetService<SampleDebugLogStore>();
+        _debugViewModel = services.GetService<SampleDebugViewModel>();
+        _debugMenu = new DebugMenuView();
+        LeftContent = _debugMenu;
+        _debugMenu.IsVisible = false;
+        _debugMenu.DataContext = _debugViewModel;
+        if (_debugViewModel is not null)
+        {
+            _debugViewModel.LogRequested += OnLogRequested;
+            _debugViewModel.ConfirmationRequested += ConfirmAsync;
+            _debugViewModel.NotificationRequested += NotifyAsync;
+        }
+        AddHandler(KeyDownEvent, OnKeyDown, RoutingStrategies.Tunnel);
+    }
+
+    partial void CompleteDebugStartup(string? error) =>
+        _debugMenu.IsVisible = error is null && _debugLogStore is not null && _debugViewModel is not null;
+
+    private void OnKeyDown(object? sender, KeyEventArgs e)
+    {
+        if (_debugLogStore is null || e.Key != Key.L || e.KeyModifiers != KeyModifiers.None)
+            return;
+
+        e.Handled = true;
+        _debugViewModel?.ShowLogCommand.Execute(null);
+    }
+
+    private void OnLogRequested() => _ = ShowDebugLogAsync();
+
+    private async Task<bool> ConfirmAsync(SampleDebugPrompt prompt) =>
+        await MessageBox.ShowAsync(this, prompt.Message, prompt.Title, button: MessageBoxButton.OKCancel) == MessageBoxResult.OK;
+
+    private Task<MessageBoxResult> NotifyAsync(SampleDebugNotification notification) =>
+        MessageBox.ShowAsync(this, notification.Message, notification.Title, button: MessageBoxButton.OK);
+
+    private Task ShowDebugLogAsync()
+    {
+        if (_debugLogStore is null)
+            return Task.CompletedTask;
+
+        if (_debugLogWindow is { IsVisible: true })
+        {
+            _debugLogWindow.Activate();
+            return Task.CompletedTask;
+        }
+
+        var window = _services.GetRequiredService<DebugLogWindow>();
+        _debugLogWindow = window;
+        window.Closed += (_, _) =>
+        {
+            if (ReferenceEquals(_debugLogWindow, window))
+                _debugLogWindow = null;
+        };
+        window.Show(this);
+        return Task.CompletedTask;
+    }
+
+    partial void DetachDebugBindings()
+    {
+        if (_debugViewModel is null)
+            return;
+
+        _debugViewModel.LogRequested -= OnLogRequested;
+        _debugViewModel.ConfirmationRequested -= ConfirmAsync;
+        _debugViewModel.NotificationRequested -= NotifyAsync;
+    }
+}
diff --git a/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.axaml b/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.axaml
index cc8c4175..55d8f880 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.axaml
+++ b/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.axaml
@@ -1,37 +1,69 @@
 <ursa:UrsaWindow xmlns="https://github.com/avaloniaui"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:controls="using:GalNet.Game.Controls"
-        xmlns:debug="using:GalNet.Sample.Avalonia.Debug"
         xmlns:loc="clr-namespace:GalNet.Avalonia.GameView.MarkupExtensions;assembly=GalNet.Avalonia.GameView"
         xmlns:views="using:GalNet.Sample.Avalonia.Views"
         xmlns:ursa="https://irihi.tech/ursa"
         x:Class="GalNet.Sample.Avalonia.Views.MainWindow"
         Width="1280" Height="720" MinWidth="800" MinHeight="500"
-        Background="Black"
+        Classes="galnet-player"
+        Background="{DynamicResource GalNet.Brush.Background}"
+        Foreground="{DynamicResource GalNet.Brush.TextPrimary}"
         Icon="/Assets/avalonia-logo.ico"
         Title="{loc:Localize App.Title}">
-  <ursa:UrsaWindow.LeftContent>
-    <Menu x:Name="DebugMenu" IsVisible="False" x:DataType="debug:SampleDebugViewModel">
-      <MenuItem Header="{loc:Localize Debug.Menu}">
-        <MenuItem Header="{loc:Localize Debug.ClearPlayerState}" Command="{Binding ClearPlayerStateCommand}" />
-        <MenuItem Header="{loc:Localize Debug.ReloadGameResources}" Command="{Binding ReloadGameResourcesCommand}" />
-        <Separator />
-        <MenuItem Header="{loc:Localize Debug.Save}">
-          <MenuItem Header="{loc:Localize Debug.SaveProgressOnly}" Command="{Binding SaveProgressOnlyCommand}" />
-          <MenuItem Header="{loc:Localize Debug.SaveGalgroup}" Command="{Binding SaveGalGroupStartCommand}" />
-        </MenuItem>
-        <Separator />
-        <MenuItem Header="{loc:Localize Debug.ShowLog}" Command="{Binding ShowLogCommand}" />
-        <MenuItem Header="{loc:Localize Debug.OpenLogDirectory}" Command="{Binding OpenLogDirectoryCommand}" />
-      </MenuItem>
-    </Menu>
-  </ursa:UrsaWindow.LeftContent>
+
   <Grid x:Name="PlayerRoot" Classes="galnet-player" Background="{DynamicResource GalNet.Brush.Background}">
-    <controls:GameCanvasHost x:Name="GameCanvas" IsVisible="False"
-                             DesignWidth="1920"
-                             DesignHeight="1080" />
-    <views:LanguageSelectionView x:Name="LanguageSelection" IsVisible="False" />
-    <TextBlock x:Name="StartupStatus" HorizontalAlignment="Center" VerticalAlignment="Center"
-               Foreground="{DynamicResource GalNet.Brush.TextPrimary}" Text="{loc:Localize Onboarding.Loading}" TextWrapping="Wrap" MaxWidth="600" />
+    <Grid x:Name="PlayerContent">
+      <controls:GameCanvasHost x:Name="GameCanvas" IsVisible="False"
+                               DesignWidth="1920"
+                               DesignHeight="1080" />
+      <views:LanguageSelectionView x:Name="LanguageSelection" IsVisible="False" />
+      <TextBlock x:Name="StartupStatus" HorizontalAlignment="Center" VerticalAlignment="Center"
+                 Foreground="{DynamicResource GalNet.Brush.TextPrimary}" Text="{loc:Localize Onboarding.Loading}" TextWrapping="Wrap" MaxWidth="600" />
+    </Grid>
+    <Grid x:Name="ExitConfirmation" IsVisible="False" Background="#66000000" KeyboardNavigation.TabNavigation="Cycle">
+      <Border Width="360" Margin="24" Padding="24" HorizontalAlignment="Center" VerticalAlignment="Center"
+              CornerRadius="6" Background="{DynamicResource GalNet.Brush.Surface}"
+              BorderBrush="{DynamicResource GalNet.Brush.Border}" BorderThickness="1" BoxShadow="0 8 24 0 #26000000">
+        <StackPanel Spacing="24">
+          <StackPanel Spacing="8">
+            <TextBlock Text="{loc:Localize Exit.Title}" FontSize="18" FontWeight="SemiBold" />
+            <TextBlock Text="{loc:Localize Exit.Message}" FontSize="14" LineHeight="22"
+                       Foreground="{DynamicResource GalNet.Brush.TextSecondary}" TextWrapping="Wrap" />
+          </StackPanel>
+          <Grid ColumnDefinitions="Auto,Auto" ColumnSpacing="8" HorizontalAlignment="Right">
+            <Button x:Name="CancelExitButton" Content="{loc:Localize Common.Cancel}" Click="OnCancelExit"
+                    FontSize="14" FontWeight="Normal" MinWidth="80" MinHeight="34" Padding="16,6" CornerRadius="4" HorizontalContentAlignment="Center" />
+            <Button x:Name="ConfirmExitButton" Grid.Column="1" Classes="player-primary" Content="{loc:Localize Title.Exit}" Click="OnConfirmExit"
+                    FontSize="14" FontWeight="Normal" MinWidth="80" MinHeight="34" Padding="16,6" CornerRadius="4" HorizontalContentAlignment="Center"
+                    Background="{DynamicResource GalNet.Brush.Primary}" Foreground="{DynamicResource GalNet.Brush.OnPrimary}" BorderBrush="{DynamicResource GalNet.Brush.Primary}" />
+          </Grid>
+        </StackPanel>
+      </Border>
+    </Grid>
   </Grid>
+  <ursa:UrsaWindow.Resources>
+    <!-- Caption buttons live in WindowDrawnDecorations, outside the content template. -->
+    <SolidColorBrush x:Key="CaptionButtonForeground" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+    <SolidColorBrush x:Key="CaptionButtonPointeroverForeground" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+    <SolidColorBrush x:Key="CaptionButtonPointeroverBackground" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" Opacity="0.08" />
+    <SolidColorBrush x:Key="CaptionButtonPressedBackground" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" Opacity="0.14" />
+    <SolidColorBrush x:Key="CaptionButtonPressedForeground" Color="{DynamicResource GalNet.Palette.TextPrimaryColor}" />
+    <SolidColorBrush x:Key="CaptionButtonCloseForeground" Color="White" />
+    <SolidColorBrush x:Key="CaptionButtonClosePointeroverBackground" Color="#C42B1C" />
+    <SolidColorBrush x:Key="CaptionButtonClosePressedBackground" Color="#A4261B" />
+    <SolidColorBrush x:Key="TitleBarBackground" Color="{DynamicResource GalNet.Palette.BackgroundColor}" />
+    <SolidColorBrush x:Key="WindowBackground" Color="{DynamicResource GalNet.Palette.BackgroundColor}" />
+  </ursa:UrsaWindow.Resources>
+  <ursa:UrsaWindow.Styles>
+    <Style Selector="Button.player-primary">
+      <Setter Property="Background" Value="{DynamicResource GalNet.Brush.Primary}" />
+      <Setter Property="Foreground" Value="{DynamicResource GalNet.Brush.OnPrimary}" />
+      <Setter Property="BorderBrush" Value="{DynamicResource GalNet.Brush.Primary}" />
+    </Style>
+    <Style Selector="Button.player-primary:pointerover /template/ ContentPresenter">
+      <Setter Property="Background" Value="{DynamicResource GalNet.Brush.PrimaryHover}" />
+      <Setter Property="Foreground" Value="{DynamicResource GalNet.Brush.OnPrimary}" />
+    </Style>
+  </ursa:UrsaWindow.Styles>
 </ursa:UrsaWindow>
diff --git a/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.axaml.cs b/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.axaml.cs
index 6f40ee9e..9b7b874c 100644
--- a/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.axaml.cs
+++ b/src/Samples/GalNet.Sample.Avalonia/Views/MainWindow.axaml.cs
@@ -3,8 +3,6 @@
 using Avalonia.Interactivity;
 using GalNet.Avalonia.GameHost;
 using GalNet.Avalonia.GameView.Page;
-using GalNet.Sample.Avalonia.Debug;
-using GalNet.Sample.Avalonia.Services;
 using GalNet.Sample.Avalonia.ViewModels;
 using Microsoft.Extensions.DependencyInjection;
 using Ursa.Controls;
@@ -13,36 +11,55 @@ namespace GalNet.Sample.Avalonia.Views;
 
 public partial class MainWindow : UrsaWindow
 {
-    private readonly IServiceProvider _services;
-    private readonly AvaloniaPlayerSettingsService _settings;
+    private readonly IAvaloniaPlayerSettings _settings;
     private bool _bindingsDetached;
-    private readonly SampleDebugLogStore? _debugLogStore;
-    private readonly SampleDebugViewModel? _debugViewModel;
     private readonly LanguageSelectionViewModel _languageSelectionViewModel;
-    private DebugLogWindow? _debugLogWindow;
+    private TaskCompletionSource<bool>? _exitConfirmation;
+    private IInputElement? _exitPreviousFocus;
 
     public MainWindow(GameShell shell, IServiceProvider services)
     {
-        _services = services;
-        _debugLogStore = services.GetService<SampleDebugLogStore>();
-        _debugViewModel = services.GetService<SampleDebugViewModel>();
         _languageSelectionViewModel = services.GetRequiredService<LanguageSelectionViewModel>();
         InitializeComponent();
-        _settings = services.GetRequiredService<AvaloniaPlayerSettingsService>();
+        _settings = services.GetRequiredService<IAvaloniaPlayerSettings>();
         _settings.BindWindow(this);
+        Resources.MergedDictionaries.Add(SampleCustomization.PlayerPalette.CreateResources());
         PlayerRoot.Styles.Add(SampleCustomization.PlayerTheme.CreateStyles());
         LanguageSelection.DataContext = _languageSelectionViewModel;
         GameCanvas.GameContent = shell;
-        DebugMenu.IsVisible = false;
-        DebugMenu.DataContext = _debugViewModel;
-        if (_debugViewModel is not null)
-        {
-            _debugViewModel.LogRequested += OnLogRequested;
-            _debugViewModel.ConfirmationRequested += ConfirmAsync;
-            _debugViewModel.NotificationRequested += NotifyAsync;
-        }
-        AddHandler(KeyDownEvent, OnKeyDown, RoutingStrategies.Tunnel);
+        InitializeDebug(services);
         Closed += OnClosed;
+        AddHandler(KeyDownEvent, OnExitKeyDown, RoutingStrategies.Tunnel);
+    }
+
+    public Task<bool> ConfirmExitAsync()
+    {
+        if (_exitConfirmation is not null) return _exitConfirmation.Task;
+        _exitConfirmation = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        _exitPreviousFocus = FocusManager?.GetFocusedElement();
+        PlayerContent.IsEnabled = false;
+        ExitConfirmation.IsVisible = true;
+        CancelExitButton.Focus();
+        return _exitConfirmation.Task;
+    }
+
+    private void OnCancelExit(object? sender, RoutedEventArgs e) => CompleteExitConfirmation(false);
+    private void OnConfirmExit(object? sender, RoutedEventArgs e) => CompleteExitConfirmation(true);
+    private void OnExitKeyDown(object? sender, KeyEventArgs e)
+    {
+        if (_exitConfirmation is null || e.Key != Key.Escape) return;
+        e.Handled = true;
+        CompleteExitConfirmation(false);
+    }
+    private void CompleteExitConfirmation(bool confirmed)
+    {
+        var completion = _exitConfirmation;
+        _exitConfirmation = null;
+        ExitConfirmation.IsVisible = false;
+        PlayerContent.IsEnabled = true;
+        _exitPreviousFocus?.Focus();
+        _exitPreviousFocus = null;
+        completion?.TrySetResult(confirmed);
     }
 
     public async Task<string?> SelectLanguageAsync(string preferred, CancellationToken cancellationToken)
@@ -58,59 +75,20 @@ public void CompleteStartup(string? error = null)
         StartupStatus.IsVisible = error is not null;
         if (error is not null) StartupStatus.Text = error;
         GameCanvas.IsVisible = error is null;
-        DebugMenu.IsVisible = error is null && _debugLogStore is not null && _debugViewModel is not null;
-    }
-
-    private void OnKeyDown(object? sender, KeyEventArgs e)
-    {
-        if (_debugLogStore is null || e.Key != Key.L || e.KeyModifiers != KeyModifiers.None)
-            return;
-
-        e.Handled = true;
-        _debugViewModel?.ShowLogCommand.Execute(null);
-    }
-
-    private void OnLogRequested() => _ = ShowDebugLogAsync();
-
-    private async Task<bool> ConfirmAsync(SampleDebugPrompt prompt) =>
-        await MessageBox.ShowAsync(this, prompt.Message, prompt.Title, button: MessageBoxButton.OKCancel) == MessageBoxResult.OK;
-
-    private Task<MessageBoxResult> NotifyAsync(SampleDebugNotification notification) =>
-        MessageBox.ShowAsync(this, notification.Message, notification.Title, button: MessageBoxButton.OK);
-
-    private Task ShowDebugLogAsync()
-    {
-        if (_debugLogStore is null)
-            return Task.CompletedTask;
-
-        if (_debugLogWindow is { IsVisible: true })
-        {
-            _debugLogWindow.Activate();
-            return Task.CompletedTask;
-        }
-
-        var window = _services.GetRequiredService<DebugLogWindow>();
-        _debugLogWindow = window;
-        window.Closed += (_, _) =>
-        {
-            if (ReferenceEquals(_debugLogWindow, window))
-                _debugLogWindow = null;
-        };
-        window.Show(this);
-        return Task.CompletedTask;
+        CompleteDebugStartup(error);
     }
 
     private void OnClosed(object? sender, EventArgs e)
     {
+        CompleteExitConfirmation(false);
         DetachHostBindings();
-        if (_debugViewModel is null)
-            return;
-
-        _debugViewModel.LogRequested -= OnLogRequested;
-        _debugViewModel.ConfirmationRequested -= ConfirmAsync;
-        _debugViewModel.NotificationRequested -= NotifyAsync;
+        DetachDebugBindings();
     }
 
+    partial void InitializeDebug(IServiceProvider services);
+    partial void CompleteDebugStartup(string? error);
+    partial void DetachDebugBindings();
+
     internal void DetachHostBindings()
     {
         if (_bindingsDetached) return;
diff --git a/src/Samples/GalNet.Sample.Avalonia/packages.lock.NoGameDebugging.json b/src/Samples/GalNet.Sample.Avalonia/packages.lock.NoGameDebugging.json
new file mode 100644
index 00000000..c842afac
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Avalonia/packages.lock.NoGameDebugging.json
@@ -0,0 +1,538 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
+        "dependencies": {
+          "Avalonia.BuildServices": "11.3.2",
+          "Avalonia.Remote.Protocol": "12.0.5",
+          "MicroCom.Runtime": "0.11.4"
+        }
+      },
+      "Avalonia.Desktop": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "L4bTMshYrhjSKu09Q60OHN1+Lfr9z7JsyRL6rfj3iQfjWm+5gsTl2viz5gyzDUgc/U5A7gf57e1spEX+nE/7zg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.HarfBuzz": "12.0.5",
+          "Avalonia.Native": "12.0.5",
+          "Avalonia.Skia": "12.0.5",
+          "Avalonia.Win32": "12.0.5",
+          "Avalonia.X11": "12.0.5"
+        }
+      },
+      "Avalonia.Fonts.Inter": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Themes.Fluent": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "AvaloniaUI.DiagnosticsSupport": {
+        "type": "Direct",
+        "requested": "[2.2.3, )",
+        "resolved": "2.2.3",
+        "contentHash": "kQCInYusi2c9tjd9hV05Lln6Csbo07kiC672M3G7dsalDBe2j+pOk3We2nzdyy5ptQYy/9gQiC8ZaHhb6u/5Kw==",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
+          "Microsoft.IO.RecyclableMemoryStream": "3.0.1"
+        }
+      },
+      "CommunityToolkit.Mvvm": {
+        "type": "Direct",
+        "requested": "[8.4.1, )",
+        "resolved": "8.4.1",
+        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
+      },
+      "DynamicLocalization.Core": {
+        "type": "Direct",
+        "requested": "[2.1.2, )",
+        "resolved": "2.1.2",
+        "contentHash": "UdDvJeBnNoif/bi73CBDi7GiOhGUB9EkKl3v0JTNdVcPhCqWY+Jy9qr4IqNS9bQ5Xwn6uTYimYLDqGNxEEDjqw==",
+        "dependencies": {
+          "System.Text.Json": "[6.0.10, 10.0.0)",
+          "YamlDotNet": "[11.0.1, 19.0.0)"
+        }
+      },
+      "Irihi.Ursa": {
+        "type": "Direct",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "G2wAmenCgMZkBOqs5MYRtlurhU2tAKKmcNJzjjaA9Mj5v3YIivuv7wyNpIpgYZ602sOZhFtQwYrCaLVUhn9Htw==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Avalonia.Shared": "0.4.0",
+          "Irihi.Avalonia.Shared.Contracts": "0.4.0"
+        }
+      },
+      "Irihi.Ursa.Themes.Semi": {
+        "type": "Direct",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "vz7iA6YcAqJ9Z34CXGtapsROERLjZ7vD1CqblO7V5NWQyrJ5igbAYSuFFWnZnPVFKkyKM/c43oGmcWjiDBLoHA==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Ursa": "2.1.0",
+          "Semi.Avalonia": "12.0.1"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "Direct",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "f0RBabswJq+gRu5a+hWIobrLWiUYPKMhCD9WO3sYBAdSy3FFH14LMvLVFZc2kPSCimBLxSuitUhsd6tb0TAY6A==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0"
+        }
+      },
+      "Semi.Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.1, )",
+        "resolved": "12.0.1",
+        "contentHash": "WAjB/Clu8eD+AjLbCUV/fNwHdCk5iSwLoFyWG7UeBBbr8zP7GWQHDqr4EcDgY9vbTpynYFoOql72FCHxOPHjPA==",
+        "dependencies": {
+          "Avalonia": "12.0.1",
+          "Irihi.Avalonia.Shared": "0.4.0"
+        }
+      },
+      "Serilog": {
+        "type": "Direct",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      },
+      "Serilog.Sinks.Console": {
+        "type": "Direct",
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "fQGWqVMClCP2yEyTXPIinSr5c+CBGUvBybPxjAGcf7ctDhadFhrQw03Mv8rJ07/wR5PDfFjewf2LimvXCDzpbA==",
+        "dependencies": {
+          "Serilog": "4.0.0"
+        }
+      },
+      "Serilog.Sinks.File": {
+        "type": "Direct",
+        "requested": "[7.0.0, )",
+        "resolved": "7.0.0",
+        "contentHash": "fKL7mXv7qaiNBUC71ssvn/dU0k9t0o45+qm2XgKAlSt19xF+ijjxyA3R6HmCgfKEKwfcfkwWjayuQtRueZFkYw==",
+        "dependencies": {
+          "Serilog": "4.2.0"
+        }
+      },
+      "VideoLAN.LibVLC.Windows": {
+        "type": "Direct",
+        "requested": "[3.0.23.1, )",
+        "resolved": "3.0.23.1",
+        "contentHash": "yTGNrzj+Q/t72VNKK0d64jZ+8BGu5Vcp2nxpZ2ll350LkRWKSwqShGpZWcVxXVP8TiMbeGML09+Jzz3hNsIcqA=="
+      },
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "Avalonia.Angle.Windows.Natives": {
+        "type": "Transitive",
+        "resolved": "2.1.27548.20260419",
+        "contentHash": "l17nI3XVDN3oMnpjf2pnmJg0YTwK4m6NLsn/itAjDMdObTFxN77D5F1M9sRMSfViSY3KKcse1ROczwgoWLJsnA=="
+      },
+      "Avalonia.BuildServices": {
+        "type": "Transitive",
+        "resolved": "11.3.2",
+        "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
+      },
+      "Avalonia.FreeDesktop": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "51IiLrfyJdMtmVTiXiEi1q1nXS5KAMYvFNeovlwKSuTgY/agBevnfBTY+DnKnIjZMdXWWKVGJJh7MldMkPc14w==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Tmds.DBus.Protocol": "0.92.0"
+        }
+      },
+      "Avalonia.FreeDesktop.AtSpi": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "IrsjB1QpzXwgdnkpG6ejGxSaHp0sRrq3rZlrzRyhwEGllAxcOeUuQpq8/OrO3OUJLxXtxlsM4ku17v+7q7xGKQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.HarfBuzz": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "jR8i/fgrmAKEp0T3iLqfKCoEDJV9ODVzN+8bofM2guEr05eaXbx6iXZxcjh0nDK4UbK0akYDgBfAgyHoatqGjg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3"
+        }
+      },
+      "Avalonia.Native": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "m6qn0UGMI/b4cFfJ8id8sPYLotc7szhZdexPCKY+kIvGlx6Ln0VjNejRMiJDZ4S91q6nbKJL/YmfPd8UruTNjQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Remote.Protocol": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
+      },
+      "Avalonia.Win32": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "ZY1ZLXQdQqlz9GUZGXK+73kTFgKzygPbGk/gHfROUWLr2aBh1kOA1KY5xB7/cSSY+egDr+IGSjsQbgS8eSu9Tg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Angle.Windows.Natives": "2.1.27548.20260419"
+        }
+      },
+      "Avalonia.X11": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "6OyZa5ehNbzd7JWiVbGdjuzdsgy2Rgibtwczmh7hKnePxLmOqeSL+hQ6vHanSx246TpSBKDPvjqwW7NuQrmAJg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.FreeDesktop": "12.0.5",
+          "Avalonia.FreeDesktop.AtSpi": "12.0.5",
+          "Avalonia.Skia": "12.0.5"
+        }
+      },
+      "HarfBuzzSharp": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "NGZ2+ZVNPM+NdHB/asW0/ykWngyHWwcqjrbN2nDeH1B/aptPGlCUl8wkQ2cSJxw5fdWgdmIPmNuTPWpLwNVXWg==",
+        "dependencies": {
+          "HarfBuzzSharp.NativeAssets.Win32": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.macOS": "8.3.1.3"
+        }
+      },
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "w2QfdNm9Uz/sUa0B5D+OnVQhyq3G/fBq6ibQMdWBlQqqwh0g0/5j3RFvYqZAmRZ5+RzvjVe8o8SFFnWYUSkuxA=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "Irihi.Avalonia.Shared": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "T6+jezCUjisJNz6zkNcNLVNI2ttWznbyQnW6MS9L45EXhePqRCIxB3xV/5L8gFAJ83JrhiCIokMOxRWdq9/1Zg==",
+        "dependencies": {
+          "Avalonia": "12.0.0"
+        }
+      },
+      "Irihi.Avalonia.Shared.Contracts": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "Du8DY2YqlSmCmywqZtuOhgwLkgklMeE1ajZ4Dd/iqVz6HmAKptjVTqA1oloZX5ihqsdKRiNuUGCdYPe1rekf2Q=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.IO.RecyclableMemoryStream": {
+        "type": "Transitive",
+        "resolved": "3.0.1",
+        "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g=="
+      },
+      "SkiaSharp": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "53NOSUZ1Us+91Sm0uCkIivh/k7jOowRErZT2sIWwPFN9mLUvdxnE6rS4sWo4255+Rd2MWUSF+j0NMZHD6Cke+Q==",
+        "dependencies": {
+          "SkiaSharp.NativeAssets.Win32": "3.119.4",
+          "SkiaSharp.NativeAssets.macOS": "3.119.4"
+        }
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "S1HOxtBbD4bYDtA2e9WH5TX+lxqRrTPvKjrjttRhxnHNNu7YY8VFo/LeCP7tNqoTA6PV+8vsvNbmRUEC2ip8RQ=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      },
+      "System.Text.Json": {
+        "type": "Transitive",
+        "resolved": "6.0.10",
+        "contentHash": "NSB0kDipxn2ychp88NXWfFRFlmi1bst/xynOutbnpEfRCT9JZkZ7KOmF/I/hNKo2dILiMGnqblm+j1sggdLB9g=="
+      },
+      "Tmds.DBus.Protocol": {
+        "type": "Transitive",
+        "resolved": "0.92.0",
+        "contentHash": "h7IMakm0PF2jxiagoysoAjrzzLQ0UBdnSXQL5kb17YW0Fvyo12Tg96A99QkzwktWRrd7H+Uw9EzjasNLUfGYlA=="
+      },
+      "YamlDotNet": {
+        "type": "Transitive",
+        "resolved": "11.0.1",
+        "contentHash": "UvICfSN4gJfAmOsuY/go0hb5SFfr3ZYCXb7jg66yT7kh+wSJEt7tUiwuoCNMpt8ScEXLDwXttpFoWKWeirYU1A=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.controls": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia.Controls.ColorPicker": "[12.0.5, )",
+          "DynamicLocalization.Core": "[2.1.2, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Media.LibVlc": "[1.0.0, )",
+          "GalNet.Media.Miniaudio": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Primitives.Builtins": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )",
+          "GalNet.Storage.FileSystem": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.gameview": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "CommunityToolkit.Mvvm": "[8.4.1, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "Irihi.Ursa": "[2.1.0, )",
+          "LibVLCSharp": "[3.10.0, )",
+          "LibVLCSharp.Avalonia": "[3.10.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.avalonia.rendering": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.themes": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia.Themes.Fluent": "[12.0.5, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.media.libvlc": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "LibVLCSharp": "[3.10.0, )"
+        }
+      },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.primitives.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "GalNet.Project.Contracts": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.storage.filesystem": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "Avalonia.Controls.ColorPicker": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "EmYXjNZq5wevvvvbLTNvnDBnZfQ6YuFBPOwDc6IXMFFIFLY4WAfpi3Dr94/qmt55shDcMceogaUiNy0yyLf5NQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Remote.Protocol": "12.0.5"
+        }
+      },
+      "Avalonia.Skia": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "cSLTpvzsm5JpUA1tQvuht3qN6oiy1PNRgbrp1g7jCSzAFf+OKZecSne+KT1apBQUkevciaHxwtAxLolPGD9izg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3",
+          "SkiaSharp": "3.119.4",
+          "SkiaSharp.NativeAssets.Linux": "3.119.4",
+          "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "LibVLCSharp": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
+      },
+      "LibVLCSharp.Avalonia": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "juoBLjh37+07kWDblbHLaWTQx1HsXOIJHU7aeH5/95xjN6dXfZMVE8ltg8NyaNL6vr2B4QgR3EiRBsEa+fPvlQ==",
+        "dependencies": {
+          "Avalonia": "11.3.13",
+          "LibVLCSharp": "3.10.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/Samples/GalNet.Sample.Avalonia/packages.lock.WindowsReadyToRun.Debugging.json b/src/Samples/GalNet.Sample.Avalonia/packages.lock.WindowsReadyToRun.Debugging.json
new file mode 100644
index 00000000..1889f966
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Avalonia/packages.lock.WindowsReadyToRun.Debugging.json
@@ -0,0 +1,589 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
+        "dependencies": {
+          "Avalonia.BuildServices": "11.3.2",
+          "Avalonia.Remote.Protocol": "12.0.5",
+          "MicroCom.Runtime": "0.11.4"
+        }
+      },
+      "Avalonia.Desktop": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "L4bTMshYrhjSKu09Q60OHN1+Lfr9z7JsyRL6rfj3iQfjWm+5gsTl2viz5gyzDUgc/U5A7gf57e1spEX+nE/7zg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.HarfBuzz": "12.0.5",
+          "Avalonia.Native": "12.0.5",
+          "Avalonia.Skia": "12.0.5",
+          "Avalonia.Win32": "12.0.5",
+          "Avalonia.X11": "12.0.5"
+        }
+      },
+      "Avalonia.Fonts.Inter": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Themes.Fluent": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "AvaloniaUI.DiagnosticsSupport": {
+        "type": "Direct",
+        "requested": "[2.2.3, )",
+        "resolved": "2.2.3",
+        "contentHash": "kQCInYusi2c9tjd9hV05Lln6Csbo07kiC672M3G7dsalDBe2j+pOk3We2nzdyy5ptQYy/9gQiC8ZaHhb6u/5Kw==",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
+          "Microsoft.IO.RecyclableMemoryStream": "3.0.1"
+        }
+      },
+      "CommunityToolkit.Mvvm": {
+        "type": "Direct",
+        "requested": "[8.4.1, )",
+        "resolved": "8.4.1",
+        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
+      },
+      "DynamicLocalization.Core": {
+        "type": "Direct",
+        "requested": "[2.1.2, )",
+        "resolved": "2.1.2",
+        "contentHash": "UdDvJeBnNoif/bi73CBDi7GiOhGUB9EkKl3v0JTNdVcPhCqWY+Jy9qr4IqNS9bQ5Xwn6uTYimYLDqGNxEEDjqw==",
+        "dependencies": {
+          "System.Text.Json": "[6.0.10, 10.0.0)",
+          "YamlDotNet": "[11.0.1, 19.0.0)"
+        }
+      },
+      "Irihi.Ursa": {
+        "type": "Direct",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "G2wAmenCgMZkBOqs5MYRtlurhU2tAKKmcNJzjjaA9Mj5v3YIivuv7wyNpIpgYZ602sOZhFtQwYrCaLVUhn9Htw==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Avalonia.Shared": "0.4.0",
+          "Irihi.Avalonia.Shared.Contracts": "0.4.0"
+        }
+      },
+      "Irihi.Ursa.Themes.Semi": {
+        "type": "Direct",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "vz7iA6YcAqJ9Z34CXGtapsROERLjZ7vD1CqblO7V5NWQyrJ5igbAYSuFFWnZnPVFKkyKM/c43oGmcWjiDBLoHA==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Ursa": "2.1.0",
+          "Semi.Avalonia": "12.0.1"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "Direct",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "f0RBabswJq+gRu5a+hWIobrLWiUYPKMhCD9WO3sYBAdSy3FFH14LMvLVFZc2kPSCimBLxSuitUhsd6tb0TAY6A==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0"
+        }
+      },
+      "Semi.Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.1, )",
+        "resolved": "12.0.1",
+        "contentHash": "WAjB/Clu8eD+AjLbCUV/fNwHdCk5iSwLoFyWG7UeBBbr8zP7GWQHDqr4EcDgY9vbTpynYFoOql72FCHxOPHjPA==",
+        "dependencies": {
+          "Avalonia": "12.0.1",
+          "Irihi.Avalonia.Shared": "0.4.0"
+        }
+      },
+      "Serilog": {
+        "type": "Direct",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      },
+      "Serilog.Sinks.Console": {
+        "type": "Direct",
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "fQGWqVMClCP2yEyTXPIinSr5c+CBGUvBybPxjAGcf7ctDhadFhrQw03Mv8rJ07/wR5PDfFjewf2LimvXCDzpbA==",
+        "dependencies": {
+          "Serilog": "4.0.0"
+        }
+      },
+      "Serilog.Sinks.File": {
+        "type": "Direct",
+        "requested": "[7.0.0, )",
+        "resolved": "7.0.0",
+        "contentHash": "fKL7mXv7qaiNBUC71ssvn/dU0k9t0o45+qm2XgKAlSt19xF+ijjxyA3R6HmCgfKEKwfcfkwWjayuQtRueZFkYw==",
+        "dependencies": {
+          "Serilog": "4.2.0"
+        }
+      },
+      "VideoLAN.LibVLC.Windows": {
+        "type": "Direct",
+        "requested": "[3.0.23.1, )",
+        "resolved": "3.0.23.1",
+        "contentHash": "yTGNrzj+Q/t72VNKK0d64jZ+8BGu5Vcp2nxpZ2ll350LkRWKSwqShGpZWcVxXVP8TiMbeGML09+Jzz3hNsIcqA=="
+      },
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "Avalonia.Angle.Windows.Natives": {
+        "type": "Transitive",
+        "resolved": "2.1.27548.20260419",
+        "contentHash": "l17nI3XVDN3oMnpjf2pnmJg0YTwK4m6NLsn/itAjDMdObTFxN77D5F1M9sRMSfViSY3KKcse1ROczwgoWLJsnA=="
+      },
+      "Avalonia.BuildServices": {
+        "type": "Transitive",
+        "resolved": "11.3.2",
+        "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
+      },
+      "Avalonia.FreeDesktop": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "51IiLrfyJdMtmVTiXiEi1q1nXS5KAMYvFNeovlwKSuTgY/agBevnfBTY+DnKnIjZMdXWWKVGJJh7MldMkPc14w==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Tmds.DBus.Protocol": "0.92.0"
+        }
+      },
+      "Avalonia.FreeDesktop.AtSpi": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "IrsjB1QpzXwgdnkpG6ejGxSaHp0sRrq3rZlrzRyhwEGllAxcOeUuQpq8/OrO3OUJLxXtxlsM4ku17v+7q7xGKQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.HarfBuzz": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "jR8i/fgrmAKEp0T3iLqfKCoEDJV9ODVzN+8bofM2guEr05eaXbx6iXZxcjh0nDK4UbK0akYDgBfAgyHoatqGjg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3"
+        }
+      },
+      "Avalonia.Native": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "m6qn0UGMI/b4cFfJ8id8sPYLotc7szhZdexPCKY+kIvGlx6Ln0VjNejRMiJDZ4S91q6nbKJL/YmfPd8UruTNjQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Remote.Protocol": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
+      },
+      "Avalonia.Win32": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "ZY1ZLXQdQqlz9GUZGXK+73kTFgKzygPbGk/gHfROUWLr2aBh1kOA1KY5xB7/cSSY+egDr+IGSjsQbgS8eSu9Tg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Angle.Windows.Natives": "2.1.27548.20260419"
+        }
+      },
+      "Avalonia.X11": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "6OyZa5ehNbzd7JWiVbGdjuzdsgy2Rgibtwczmh7hKnePxLmOqeSL+hQ6vHanSx246TpSBKDPvjqwW7NuQrmAJg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.FreeDesktop": "12.0.5",
+          "Avalonia.FreeDesktop.AtSpi": "12.0.5",
+          "Avalonia.Skia": "12.0.5"
+        }
+      },
+      "HarfBuzzSharp": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "NGZ2+ZVNPM+NdHB/asW0/ykWngyHWwcqjrbN2nDeH1B/aptPGlCUl8wkQ2cSJxw5fdWgdmIPmNuTPWpLwNVXWg==",
+        "dependencies": {
+          "HarfBuzzSharp.NativeAssets.Win32": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.macOS": "8.3.1.3"
+        }
+      },
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "w2QfdNm9Uz/sUa0B5D+OnVQhyq3G/fBq6ibQMdWBlQqqwh0g0/5j3RFvYqZAmRZ5+RzvjVe8o8SFFnWYUSkuxA=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "Irihi.Avalonia.Shared": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "T6+jezCUjisJNz6zkNcNLVNI2ttWznbyQnW6MS9L45EXhePqRCIxB3xV/5L8gFAJ83JrhiCIokMOxRWdq9/1Zg==",
+        "dependencies": {
+          "Avalonia": "12.0.0"
+        }
+      },
+      "Irihi.Avalonia.Shared.Contracts": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "Du8DY2YqlSmCmywqZtuOhgwLkgklMeE1ajZ4Dd/iqVz6HmAKptjVTqA1oloZX5ihqsdKRiNuUGCdYPe1rekf2Q=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.IO.RecyclableMemoryStream": {
+        "type": "Transitive",
+        "resolved": "3.0.1",
+        "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g=="
+      },
+      "SkiaSharp": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "53NOSUZ1Us+91Sm0uCkIivh/k7jOowRErZT2sIWwPFN9mLUvdxnE6rS4sWo4255+Rd2MWUSF+j0NMZHD6Cke+Q==",
+        "dependencies": {
+          "SkiaSharp.NativeAssets.Win32": "3.119.4",
+          "SkiaSharp.NativeAssets.macOS": "3.119.4"
+        }
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "S1HOxtBbD4bYDtA2e9WH5TX+lxqRrTPvKjrjttRhxnHNNu7YY8VFo/LeCP7tNqoTA6PV+8vsvNbmRUEC2ip8RQ=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      },
+      "System.Text.Json": {
+        "type": "Transitive",
+        "resolved": "6.0.10",
+        "contentHash": "NSB0kDipxn2ychp88NXWfFRFlmi1bst/xynOutbnpEfRCT9JZkZ7KOmF/I/hNKo2dILiMGnqblm+j1sggdLB9g=="
+      },
+      "Tmds.DBus.Protocol": {
+        "type": "Transitive",
+        "resolved": "0.92.0",
+        "contentHash": "h7IMakm0PF2jxiagoysoAjrzzLQ0UBdnSXQL5kb17YW0Fvyo12Tg96A99QkzwktWRrd7H+Uw9EzjasNLUfGYlA=="
+      },
+      "YamlDotNet": {
+        "type": "Transitive",
+        "resolved": "11.0.1",
+        "contentHash": "UvICfSN4gJfAmOsuY/go0hb5SFfr3ZYCXb7jg66yT7kh+wSJEt7tUiwuoCNMpt8ScEXLDwXttpFoWKWeirYU1A=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.controls": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia.Controls.ColorPicker": "[12.0.5, )",
+          "DynamicLocalization.Core": "[2.1.2, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Media.LibVlc": "[1.0.0, )",
+          "GalNet.Media.Miniaudio": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Primitives.Builtins": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )",
+          "GalNet.Storage.FileSystem": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.gameview": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "CommunityToolkit.Mvvm": "[8.4.1, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "Irihi.Ursa": "[2.1.0, )",
+          "LibVLCSharp": "[3.10.0, )",
+          "LibVLCSharp.Avalonia": "[3.10.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.avalonia.rendering": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.themes": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia.Themes.Fluent": "[12.0.5, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.debugging": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.media.libvlc": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "LibVLCSharp": "[3.10.0, )"
+        }
+      },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.primitives.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "GalNet.Project.Contracts": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.storage.filesystem": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "Avalonia.Controls.ColorPicker": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "EmYXjNZq5wevvvvbLTNvnDBnZfQ6YuFBPOwDc6IXMFFIFLY4WAfpi3Dr94/qmt55shDcMceogaUiNy0yyLf5NQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Remote.Protocol": "12.0.5"
+        }
+      },
+      "Avalonia.Skia": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "cSLTpvzsm5JpUA1tQvuht3qN6oiy1PNRgbrp1g7jCSzAFf+OKZecSne+KT1apBQUkevciaHxwtAxLolPGD9izg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3",
+          "SkiaSharp": "3.119.4",
+          "SkiaSharp.NativeAssets.Linux": "3.119.4",
+          "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "LibVLCSharp": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
+      },
+      "LibVLCSharp.Avalonia": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "juoBLjh37+07kWDblbHLaWTQx1HsXOIJHU7aeH5/95xjN6dXfZMVE8ltg8NyaNL6vr2B4QgR3EiRBsEa+fPvlQ==",
+        "dependencies": {
+          "Avalonia": "11.3.13",
+          "LibVLCSharp": "3.10.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      }
+    },
+    "net10.0/win-x64": {
+      "Avalonia.Angle.Windows.Natives": {
+        "type": "Transitive",
+        "resolved": "2.1.27548.20260419",
+        "contentHash": "l17nI3XVDN3oMnpjf2pnmJg0YTwK4m6NLsn/itAjDMdObTFxN77D5F1M9sRMSfViSY3KKcse1ROczwgoWLJsnA=="
+      },
+      "Avalonia.Native": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "m6qn0UGMI/b4cFfJ8id8sPYLotc7szhZdexPCKY+kIvGlx6Ln0VjNejRMiJDZ4S91q6nbKJL/YmfPd8UruTNjQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/Samples/GalNet.Sample.Avalonia/packages.lock.WindowsReadyToRun.json b/src/Samples/GalNet.Sample.Avalonia/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..41a38004
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Avalonia/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,583 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
+        "dependencies": {
+          "Avalonia.BuildServices": "11.3.2",
+          "Avalonia.Remote.Protocol": "12.0.5",
+          "MicroCom.Runtime": "0.11.4"
+        }
+      },
+      "Avalonia.Desktop": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "L4bTMshYrhjSKu09Q60OHN1+Lfr9z7JsyRL6rfj3iQfjWm+5gsTl2viz5gyzDUgc/U5A7gf57e1spEX+nE/7zg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.HarfBuzz": "12.0.5",
+          "Avalonia.Native": "12.0.5",
+          "Avalonia.Skia": "12.0.5",
+          "Avalonia.Win32": "12.0.5",
+          "Avalonia.X11": "12.0.5"
+        }
+      },
+      "Avalonia.Fonts.Inter": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Themes.Fluent": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "AvaloniaUI.DiagnosticsSupport": {
+        "type": "Direct",
+        "requested": "[2.2.3, )",
+        "resolved": "2.2.3",
+        "contentHash": "kQCInYusi2c9tjd9hV05Lln6Csbo07kiC672M3G7dsalDBe2j+pOk3We2nzdyy5ptQYy/9gQiC8ZaHhb6u/5Kw==",
+        "dependencies": {
+          "Microsoft.Extensions.Logging.Abstractions": "8.0.0",
+          "Microsoft.IO.RecyclableMemoryStream": "3.0.1"
+        }
+      },
+      "CommunityToolkit.Mvvm": {
+        "type": "Direct",
+        "requested": "[8.4.1, )",
+        "resolved": "8.4.1",
+        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
+      },
+      "DynamicLocalization.Core": {
+        "type": "Direct",
+        "requested": "[2.1.2, )",
+        "resolved": "2.1.2",
+        "contentHash": "UdDvJeBnNoif/bi73CBDi7GiOhGUB9EkKl3v0JTNdVcPhCqWY+Jy9qr4IqNS9bQ5Xwn6uTYimYLDqGNxEEDjqw==",
+        "dependencies": {
+          "System.Text.Json": "[6.0.10, 10.0.0)",
+          "YamlDotNet": "[11.0.1, 19.0.0)"
+        }
+      },
+      "Irihi.Ursa": {
+        "type": "Direct",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "G2wAmenCgMZkBOqs5MYRtlurhU2tAKKmcNJzjjaA9Mj5v3YIivuv7wyNpIpgYZ602sOZhFtQwYrCaLVUhn9Htw==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Avalonia.Shared": "0.4.0",
+          "Irihi.Avalonia.Shared.Contracts": "0.4.0"
+        }
+      },
+      "Irihi.Ursa.Themes.Semi": {
+        "type": "Direct",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "vz7iA6YcAqJ9Z34CXGtapsROERLjZ7vD1CqblO7V5NWQyrJ5igbAYSuFFWnZnPVFKkyKM/c43oGmcWjiDBLoHA==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Ursa": "2.1.0",
+          "Semi.Avalonia": "12.0.1"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "Direct",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "f0RBabswJq+gRu5a+hWIobrLWiUYPKMhCD9WO3sYBAdSy3FFH14LMvLVFZc2kPSCimBLxSuitUhsd6tb0TAY6A==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0"
+        }
+      },
+      "Semi.Avalonia": {
+        "type": "Direct",
+        "requested": "[12.0.1, )",
+        "resolved": "12.0.1",
+        "contentHash": "WAjB/Clu8eD+AjLbCUV/fNwHdCk5iSwLoFyWG7UeBBbr8zP7GWQHDqr4EcDgY9vbTpynYFoOql72FCHxOPHjPA==",
+        "dependencies": {
+          "Avalonia": "12.0.1",
+          "Irihi.Avalonia.Shared": "0.4.0"
+        }
+      },
+      "Serilog": {
+        "type": "Direct",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      },
+      "Serilog.Sinks.Console": {
+        "type": "Direct",
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "fQGWqVMClCP2yEyTXPIinSr5c+CBGUvBybPxjAGcf7ctDhadFhrQw03Mv8rJ07/wR5PDfFjewf2LimvXCDzpbA==",
+        "dependencies": {
+          "Serilog": "4.0.0"
+        }
+      },
+      "Serilog.Sinks.File": {
+        "type": "Direct",
+        "requested": "[7.0.0, )",
+        "resolved": "7.0.0",
+        "contentHash": "fKL7mXv7qaiNBUC71ssvn/dU0k9t0o45+qm2XgKAlSt19xF+ijjxyA3R6HmCgfKEKwfcfkwWjayuQtRueZFkYw==",
+        "dependencies": {
+          "Serilog": "4.2.0"
+        }
+      },
+      "VideoLAN.LibVLC.Windows": {
+        "type": "Direct",
+        "requested": "[3.0.23.1, )",
+        "resolved": "3.0.23.1",
+        "contentHash": "yTGNrzj+Q/t72VNKK0d64jZ+8BGu5Vcp2nxpZ2ll350LkRWKSwqShGpZWcVxXVP8TiMbeGML09+Jzz3hNsIcqA=="
+      },
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "Avalonia.Angle.Windows.Natives": {
+        "type": "Transitive",
+        "resolved": "2.1.27548.20260419",
+        "contentHash": "l17nI3XVDN3oMnpjf2pnmJg0YTwK4m6NLsn/itAjDMdObTFxN77D5F1M9sRMSfViSY3KKcse1ROczwgoWLJsnA=="
+      },
+      "Avalonia.BuildServices": {
+        "type": "Transitive",
+        "resolved": "11.3.2",
+        "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
+      },
+      "Avalonia.FreeDesktop": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "51IiLrfyJdMtmVTiXiEi1q1nXS5KAMYvFNeovlwKSuTgY/agBevnfBTY+DnKnIjZMdXWWKVGJJh7MldMkPc14w==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Tmds.DBus.Protocol": "0.92.0"
+        }
+      },
+      "Avalonia.FreeDesktop.AtSpi": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "IrsjB1QpzXwgdnkpG6ejGxSaHp0sRrq3rZlrzRyhwEGllAxcOeUuQpq8/OrO3OUJLxXtxlsM4ku17v+7q7xGKQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.HarfBuzz": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "jR8i/fgrmAKEp0T3iLqfKCoEDJV9ODVzN+8bofM2guEr05eaXbx6iXZxcjh0nDK4UbK0akYDgBfAgyHoatqGjg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3"
+        }
+      },
+      "Avalonia.Native": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "m6qn0UGMI/b4cFfJ8id8sPYLotc7szhZdexPCKY+kIvGlx6Ln0VjNejRMiJDZ4S91q6nbKJL/YmfPd8UruTNjQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Remote.Protocol": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
+      },
+      "Avalonia.Win32": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "ZY1ZLXQdQqlz9GUZGXK+73kTFgKzygPbGk/gHfROUWLr2aBh1kOA1KY5xB7/cSSY+egDr+IGSjsQbgS8eSu9Tg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Angle.Windows.Natives": "2.1.27548.20260419"
+        }
+      },
+      "Avalonia.X11": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "6OyZa5ehNbzd7JWiVbGdjuzdsgy2Rgibtwczmh7hKnePxLmOqeSL+hQ6vHanSx246TpSBKDPvjqwW7NuQrmAJg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.FreeDesktop": "12.0.5",
+          "Avalonia.FreeDesktop.AtSpi": "12.0.5",
+          "Avalonia.Skia": "12.0.5"
+        }
+      },
+      "HarfBuzzSharp": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "NGZ2+ZVNPM+NdHB/asW0/ykWngyHWwcqjrbN2nDeH1B/aptPGlCUl8wkQ2cSJxw5fdWgdmIPmNuTPWpLwNVXWg==",
+        "dependencies": {
+          "HarfBuzzSharp.NativeAssets.Win32": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.macOS": "8.3.1.3"
+        }
+      },
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "w2QfdNm9Uz/sUa0B5D+OnVQhyq3G/fBq6ibQMdWBlQqqwh0g0/5j3RFvYqZAmRZ5+RzvjVe8o8SFFnWYUSkuxA=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "Irihi.Avalonia.Shared": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "T6+jezCUjisJNz6zkNcNLVNI2ttWznbyQnW6MS9L45EXhePqRCIxB3xV/5L8gFAJ83JrhiCIokMOxRWdq9/1Zg==",
+        "dependencies": {
+          "Avalonia": "12.0.0"
+        }
+      },
+      "Irihi.Avalonia.Shared.Contracts": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "Du8DY2YqlSmCmywqZtuOhgwLkgklMeE1ajZ4Dd/iqVz6HmAKptjVTqA1oloZX5ihqsdKRiNuUGCdYPe1rekf2Q=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
+      },
+      "Microsoft.Extensions.Logging.Abstractions": {
+        "type": "Transitive",
+        "resolved": "8.0.0",
+        "contentHash": "arDBqTgFCyS0EvRV7O3MZturChstm50OJ0y9bDJvAcmEPJm0FFpFyjU/JLYyStNGGey081DvnQYlncNX5SJJGA==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0"
+        }
+      },
+      "Microsoft.IO.RecyclableMemoryStream": {
+        "type": "Transitive",
+        "resolved": "3.0.1",
+        "contentHash": "s/s20YTVY9r9TPfTrN5g8zPF1YhwxyqO6PxUkrYTGI2B+OGPe9AdajWZrLhFqXIvqIW23fnUE4+ztrUWNU1+9g=="
+      },
+      "SkiaSharp": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "53NOSUZ1Us+91Sm0uCkIivh/k7jOowRErZT2sIWwPFN9mLUvdxnE6rS4sWo4255+Rd2MWUSF+j0NMZHD6Cke+Q==",
+        "dependencies": {
+          "SkiaSharp.NativeAssets.Win32": "3.119.4",
+          "SkiaSharp.NativeAssets.macOS": "3.119.4"
+        }
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "S1HOxtBbD4bYDtA2e9WH5TX+lxqRrTPvKjrjttRhxnHNNu7YY8VFo/LeCP7tNqoTA6PV+8vsvNbmRUEC2ip8RQ=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      },
+      "System.Text.Json": {
+        "type": "Transitive",
+        "resolved": "6.0.10",
+        "contentHash": "NSB0kDipxn2ychp88NXWfFRFlmi1bst/xynOutbnpEfRCT9JZkZ7KOmF/I/hNKo2dILiMGnqblm+j1sggdLB9g=="
+      },
+      "Tmds.DBus.Protocol": {
+        "type": "Transitive",
+        "resolved": "0.92.0",
+        "contentHash": "h7IMakm0PF2jxiagoysoAjrzzLQ0UBdnSXQL5kb17YW0Fvyo12Tg96A99QkzwktWRrd7H+Uw9EzjasNLUfGYlA=="
+      },
+      "YamlDotNet": {
+        "type": "Transitive",
+        "resolved": "11.0.1",
+        "contentHash": "UvICfSN4gJfAmOsuY/go0hb5SFfr3ZYCXb7jg66yT7kh+wSJEt7tUiwuoCNMpt8ScEXLDwXttpFoWKWeirYU1A=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.controls": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia.Controls.ColorPicker": "[12.0.5, )",
+          "DynamicLocalization.Core": "[2.1.2, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Media.LibVlc": "[1.0.0, )",
+          "GalNet.Media.Miniaudio": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Primitives.Builtins": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )",
+          "GalNet.Storage.FileSystem": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.gameview": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "CommunityToolkit.Mvvm": "[8.4.1, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "Irihi.Ursa": "[2.1.0, )",
+          "LibVLCSharp": "[3.10.0, )",
+          "LibVLCSharp.Avalonia": "[3.10.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.avalonia.rendering": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.themes": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia.Themes.Fluent": "[12.0.5, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.media.libvlc": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "LibVLCSharp": "[3.10.0, )"
+        }
+      },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.primitives.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "GalNet.Project.Contracts": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.storage.filesystem": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "Avalonia.Controls.ColorPicker": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "EmYXjNZq5wevvvvbLTNvnDBnZfQ6YuFBPOwDc6IXMFFIFLY4WAfpi3Dr94/qmt55shDcMceogaUiNy0yyLf5NQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Remote.Protocol": "12.0.5"
+        }
+      },
+      "Avalonia.Skia": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "cSLTpvzsm5JpUA1tQvuht3qN6oiy1PNRgbrp1g7jCSzAFf+OKZecSne+KT1apBQUkevciaHxwtAxLolPGD9izg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3",
+          "SkiaSharp": "3.119.4",
+          "SkiaSharp.NativeAssets.Linux": "3.119.4",
+          "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "LibVLCSharp": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
+      },
+      "LibVLCSharp.Avalonia": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "juoBLjh37+07kWDblbHLaWTQx1HsXOIJHU7aeH5/95xjN6dXfZMVE8ltg8NyaNL6vr2B4QgR3EiRBsEa+fPvlQ==",
+        "dependencies": {
+          "Avalonia": "11.3.13",
+          "LibVLCSharp": "3.10.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      }
+    },
+    "net10.0/win-x64": {
+      "Avalonia.Angle.Windows.Natives": {
+        "type": "Transitive",
+        "resolved": "2.1.27548.20260419",
+        "contentHash": "l17nI3XVDN3oMnpjf2pnmJg0YTwK4m6NLsn/itAjDMdObTFxN77D5F1M9sRMSfViSY3KKcse1ROczwgoWLJsnA=="
+      },
+      "Avalonia.Native": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "m6qn0UGMI/b4cFfJ8id8sPYLotc7szhZdexPCKY+kIvGlx6Ln0VjNejRMiJDZ4S91q6nbKJL/YmfPd8UruTNjQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/Samples/GalNet.Sample.Avalonia/packages.lock.json b/src/Samples/GalNet.Sample.Avalonia/packages.lock.json
index 60063307..d3da94d9 100644
--- a/src/Samples/GalNet.Sample.Avalonia/packages.lock.json
+++ b/src/Samples/GalNet.Sample.Avalonia/packages.lock.json
@@ -325,6 +325,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -332,20 +333,24 @@
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
       "galnet.avalonia.gamehost": {
         "type": "Project",
         "dependencies": {
+          "Avalonia.Controls.ColorPicker": "[12.0.5, )",
           "DynamicLocalization.Core": "[2.1.2, )",
           "GalNet.Assets": "[1.0.0, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.GameView": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Media.LibVlc": "[1.0.0, )",
+          "GalNet.Media.Miniaudio": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Primitives.Builtins": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )",
@@ -360,6 +365,7 @@
           "GalNet.Assets": "[1.0.0, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Irihi.Ursa": "[2.1.0, )",
@@ -374,6 +380,7 @@
         "dependencies": {
           "Avalonia": "[12.0.5, )",
           "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -382,7 +389,8 @@
         "dependencies": {
           "Avalonia.Themes.Fluent": "[12.0.5, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
-          "GalNet.Avalonia.GameView": "[1.0.0, )"
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )"
         }
       },
       "galnet.contracts.builtins": {
@@ -403,23 +411,41 @@
       "galnet.gamehost": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
         }
       },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.media.libvlc": {
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "LibVLCSharp": "[3.10.0, )"
         }
       },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -444,7 +470,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
@@ -452,11 +477,22 @@
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
         }
       },
+      "Avalonia.Controls.ColorPicker": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "EmYXjNZq5wevvvvbLTNvnDBnZfQ6YuFBPOwDc6IXMFFIFLY4WAfpi3Dr94/qmt55shDcMceogaUiNy0yyLf5NQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Remote.Protocol": "12.0.5"
+        }
+      },
       "Avalonia.Skia": {
         "type": "CentralTransitive",
         "requested": "[12.0.5, )",
diff --git a/src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj b/src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj
index 729e507a..375cf87e 100644
--- a/src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj
+++ b/src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj
@@ -5,7 +5,7 @@
     <EnableDynamicLoading>true</EnableDynamicLoading>
   </PropertyGroup>
   <ItemGroup>
-    <ProjectReference Include="../../Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" GlobalPropertiesToRemove="OutputPath;OutDir" />
+    <ProjectReference Include="../../Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" GlobalPropertiesToRemove="OutputPath;OutDir;PublishAot;SelfContained;RuntimeIdentifier" />
     <ProjectReference Include="../../Shared/GalNet.Core/GalNet.Core.csproj" />
     <ProjectReference Include="../../Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" />
   </ItemGroup>
diff --git a/src/Samples/GalNet.Sample.Contracts/ProjectSchemas.cs b/src/Samples/GalNet.Sample.Contracts/ProjectSchemas.cs
index 944d3ead..13597ad5 100644
--- a/src/Samples/GalNet.Sample.Contracts/ProjectSchemas.cs
+++ b/src/Samples/GalNet.Sample.Contracts/ProjectSchemas.cs
@@ -1,4 +1,5 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
 
 namespace GalNet.Project.Contracts;
@@ -6,6 +7,7 @@ namespace GalNet.Project.Contracts;
 /// <summary>Single source of authoring contracts shared by the sample game and tools.</summary>
 public static class ProjectSchemas
 {
+    public static ProjectConfigurationSchema Configurations { get; } = DefaultProjectConfiguration.Schema;
     public static IEntryCatalog CreateCatalog() => new TargetProfileEntryCatalog(Modules);
 
     public static IReadOnlyList<IEntryModule> Modules { get; } = Array.AsReadOnly(
diff --git a/src/Samples/GalNet.Sample.Contracts/README.md b/src/Samples/GalNet.Sample.Contracts/README.md
index a4cde885..6d1e65d1 100644
--- a/src/Samples/GalNet.Sample.Contracts/README.md
+++ b/src/Samples/GalNet.Sample.Contracts/README.md
@@ -5,7 +5,7 @@
 从仓库根目录部署到内容项目：
 
 ```powershell
-./scripts/build-project-contracts.ps1 -ContractsProject ./src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj -ProjectDirectory <内容项目目录>
+./scripts/contracts/build-project-contracts.ps1 -ContractsProject ./src/Samples/GalNet.Sample.Contracts/GalNet.Sample.Contracts.csproj -ProjectDirectory <内容项目目录>
 ```
 
 脚本先完成独立构建，再替换内容项目的 `Contracts` 目录及依赖，发布失败则恢复旧目录。游戏发布仍走正常程序集依赖；不要把工具契约目录当作资源或额外打包进 galpak。
diff --git a/src/Samples/GalNet.Sample.Contracts/ScreenshotSchema.cs b/src/Samples/GalNet.Sample.Contracts/ScreenshotSchema.cs
index 740e3428..d208bab3 100644
--- a/src/Samples/GalNet.Sample.Contracts/ScreenshotSchema.cs
+++ b/src/Samples/GalNet.Sample.Contracts/ScreenshotSchema.cs
@@ -22,7 +22,7 @@ public static class ScreenshotSchema
 
     public static void ValidateFileName(string? name)
     {
-        FileNameParameter.Validate(JsonSerializer.SerializeToElement(name));
+        FileNameParameter.Validate(GalNet.Core.Serialization.JsonCodec.SerializeToElement(name));
 
         if (string.IsNullOrWhiteSpace(name) || name.Any(character => char.IsControl(character) || "<>:\"/\\|?*".Contains(character)) ||
             name.Trim() != name || !name.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
diff --git a/src/Samples/GalNet.Sample.Contracts/packages.lock.WindowsReadyToRun.json b/src/Samples/GalNet.Sample.Contracts/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..9fb490d8
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Contracts/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,17 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Samples/GalNet.Sample.Headless/Acceptance/AotAcceptance.cs b/src/Samples/GalNet.Sample.Headless/Acceptance/AotAcceptance.cs
new file mode 100644
index 00000000..6d25604d
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Headless/Acceptance/AotAcceptance.cs
@@ -0,0 +1,58 @@
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using GalNet.Core.Graph;
+using GalNet.Core.Runtime;
+using GalNet.Core.Serialization;
+using GalNet.Runtime.Engine;
+using GalNet.Runtime.Loader;
+using GalNet.Runtime.Runtime;
+using GalNet.Runtime.SaveLoad;
+
+namespace GalNet.Sample.Headless.Acceptance;
+
+internal static class AotAcceptance
+{
+    public static async Task<int> RunAsync(string[] args)
+    {
+        if (JsonSerializer.IsReflectionEnabledByDefault) throw new InvalidOperationException("The acceptance host must disable reflection JSON.");
+        if (args.Contains("--expect-aot") && RuntimeFeature.IsDynamicCodeSupported) throw new InvalidOperationException("The acceptance host is not running as NativeAOT.");
+
+        var graph = GraphLoader.LoadFromJson("""{"name":"AOT 验收","rootNodeId":"main","nodes":[{"id":"main","type":"Group"}],"edges":[]}""");
+        var group = (Group)graph.Nodes.Single();
+        GalgroupLoader.LoadIntoGroupFromContent(group, """{"version":3,"kind":"Compiled","entries":[{"id":"one","typeId":"project.increment","arguments":{}}]}""");
+        var stateOptions = JsonMetadata.CreateOptions(GameState.JsonOptions, SmokeJsonContext.Default);
+        var states = new StateCatalogBuilder();
+        states.Register<SmokeState>("project.counter", value => value.Id, jsonTypeInfo: JsonMetadata.GetTypeInfo<SmokeState[]>(stateOptions));
+        var runtime = new GameRuntime(null, group.Id);
+        runtime.SetVariable("save.count", 0);
+        runtime.State.Configure(states.Build());
+        runtime.State.Table<SmokeState>().Add(new() { Id = "counter" });
+        await using var engine = new GameEngine(graph, runtime, new SmokeDispatcher(states.Build()));
+        var saved = SaveManager.Serialize(engine.CreateSaveData());
+        var snapshot = SaveManager.Deserialize(saved) ?? throw new InvalidDataException("Snapshot decoding failed.");
+        await engine.AdvanceAsync();
+        Check(engine.State == GameEngineState.Completed && runtime.GetVariable("save.count")!.AsInt() == 1, "story execution");
+        Check(runtime.State.Table<SmokeState>().Get("counter").Count == 1, "custom state execution");
+        await engine.RestoreFromAsync(snapshot);
+        Check(runtime.State.Table<SmokeState>().Get("counter").Count == 0, "custom state restoration");
+        await engine.AdvanceAsync();
+        Check(runtime.GetVariable("save.count")!.AsInt() == 1, "restored execution");
+        Check(runtime.EvaluateCondition("[save.count] == 1 && '文本' == '文本'"), "interpreted expressions");
+        await SmokeBackends.VerifyAsync(snapshot);
+        try
+        {
+            _ = JsonCodec.SerializeToElement(new MissingMetadata());
+            throw new InvalidOperationException("Unregistered metadata unexpectedly succeeded.");
+        }
+        catch (NotSupportedException error) when (error.Message.Contains("No JSON metadata", StringComparison.Ordinal)) { }
+        Console.WriteLine($"AOT_ACCEPTANCE_OK dynamicCode={RuntimeFeature.IsDynamicCodeSupported} reflectionJson={JsonSerializer.IsReflectionEnabledByDefault}");
+        return 0;
+
+    }
+
+    private static void Check(bool condition, string operation)
+    {
+        if (!condition) throw new InvalidOperationException($"AOT acceptance failed: {operation}.");
+    }
+
+}
diff --git a/src/Samples/GalNet.Sample.Headless/Acceptance/SmokeBackends.cs b/src/Samples/GalNet.Sample.Headless/Acceptance/SmokeBackends.cs
new file mode 100644
index 00000000..c6e78841
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Headless/Acceptance/SmokeBackends.cs
@@ -0,0 +1,97 @@
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Assets.Provider;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+using GalNet.Core.Graph;
+using GalNet.Core.Parameters;
+using GalNet.Core.Runtime;
+using GalNet.Core.Serialization;
+using GalNet.Presentation.Abstractions.Execution;
+using GalNet.Presentation.Abstractions.View;
+using GalNet.Primitives.Builtins;
+using GalNet.Runtime.Engine;
+using GalNet.Runtime.Loader;
+using GalNet.Runtime.Persistence;
+using GalNet.Storage.FileSystem;
+
+namespace GalNet.Sample.Headless.Acceptance;
+
+internal static class SmokeBackends
+{
+    public static async Task VerifyAsync(GameSnapshot snapshot)
+    {
+        var options = new SmokeOptions { Count = 4, Child = new() { Text = "嵌套", Next = new() { Text = "递归" } } };
+        var fields = ValueCodec.SerializeFields(options);
+        var decoded = ValueCodec.DeserializeFields<SmokeOptions>(SmokeOptions.Schema, fields);
+        Check(decoded.Count == 4 && decoded.Child?.Next?.Text == "递归", "generated field codecs");
+        Check(decoded.Enabled == true && decoded.Mode == SmokeMode.First && fields.GetProperty("enabled").ValueKind == JsonValueKind.String,
+            "nullable field converters and enum choices");
+        using (var structures = new ValueStructureResolver())
+        {
+            var resolved = structures.Resolve(SmokeOptions.Schema.Single(field => field.Id == "child"));
+            Check(resolved.Kind == ValueStructureKind.Object && resolved.Members.Any(member => member.WireName == "Text"), "generated lazy nested schemas");
+        }
+        var section = new ConfigurationSection<SmokeSettings>("project.settings", SmokeSettings.Schema, jsonResolver: SmokeJsonContext.Default);
+        var configuration = new ProjectConfiguration();
+        configuration.Set(section, new() { Count = 5 });
+        var configCopy = JsonCodec.Deserialize<ProjectConfiguration>(JsonCodec.Serialize(configuration))!;
+        Check(configCopy.Read(section).Count == 5, "custom configuration");
+        try { configCopy.Set(section, new() { Count = -1 }); throw new InvalidOperationException("Invalid configuration was accepted."); }
+        catch (InvalidDataException) { }
+        var defaults = new DefaultProjectOptions().ToConfiguration();
+        Check(JsonCodec.Deserialize<ProjectConfiguration>(JsonCodec.Serialize(defaults))!.ReadDefaultOptions().SaveSlotCount > 0, "default configuration");
+
+        var catalog = new ResourceTypeCatalogBuilder().Add<SmokeMeta>("project-data", SmokeJsonContext.Default, ".custom").Build();
+        var codec = new AssetMetaCodec(catalog);
+        var meta = (SmokeMeta)codec.Deserialize("""{"id":"custom","type":"project-data","path":"data.custom","label":"资源","future":true}""");
+        Check(((SmokeMeta)codec.Deserialize(codec.Serialize(meta))).Label == "资源" && meta.ExtensionData!["future"].GetBoolean(), "custom metadata");
+        meta.SetGallery([new GalleryAnnotation { Id = 1, TypeId = "images", ExtensionData = new() { ["future"] = JsonCodec.SerializeToElement(true) } }]);
+        Check(meta.ReadGallery().Single().ExtensionData!["future"].GetBoolean(), "gallery annotation extension data");
+        var bytes = Archive.Serialize("assets", [new GameFile(meta.Id, meta.Path, meta.TypeId, meta, [1, 2, 3])], catalog);
+        var provider = new PakStreamProvider(new Dictionary<string, Func<Stream>> { ["assets"] = () => new MemoryStream(bytes) }, catalog);
+        using var assets = new AssetManager([provider]);
+        using (var handle = await assets.AcquireAsync<byte[]>(meta.Id)) Check(handle!.Value.SequenceEqual(new byte[] { 1, 2, 3 }), "packaged resources");
+        using (var registration = new GameRegistration())
+        {
+            await using var view = registration.AddBuiltins().BuildView();
+            var state = new GameState(view.StateCatalog);
+            state.Table<Layer>().Add(new() { Id = "layer", AssetId = "sprite" });
+            var restored = GameState.Restore(view.StateCatalog, state.Capture());
+            Check(restored.Table<Layer>().Get("layer").AssetId == "sprite", "builtin state registration");
+            var graph = GraphLoader.LoadFromJson("""{"rootNodeId":"main","nodes":[{"id":"main","type":"Group"}],"edges":[]}""");
+            GalgroupLoader.LoadIntoGroupFromContent((Group)graph.Nodes.Single(),
+                """{"version":3,"kind":"Compiled","entries":[{"id":"color","typeId":"layer.showColor","arguments":{"handleId":"color","color":"#FFFFFF"}}]}""");
+            await using var engine = new GameEngine(graph, view);
+            await engine.AdvanceAsync();
+            Check(engine.State == GameEngineState.Completed && engine.Runtime.State.Table<Layer>().Get("color").Color == "#FFFFFF", "builtin generated dispatch");
+        }
+
+        var root = Path.Combine(Path.GetTempPath(), "GalNet-Aot-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(root);
+        try
+        {
+            using var saves = new FileSaveService(root);
+            await saves.SaveAsync(0, new SaveRequest { Snapshot = snapshot });
+            Check((await saves.LoadAsync(0))?.States.Count == snapshot.States.Count, "file save/load");
+            Check(!(await saves.ListSlotsAsync())[0].IsCorrupt, "file save metadata");
+            using var store = new FilePlayerVariableStore(root);
+            var variables = snapshot.Variables.ToDictionary(pair => pair.Key, pair => pair.Value);
+            await store.SaveAsync(variables);
+            Check((await store.LoadAsync()).Count == variables.Count, "player variable store");
+            await using (var progress = new FileGameProgressService(root)) { progress.MarkRead("main", "one"); await progress.FlushAsync(); }
+            await using var reopened = new FileGameProgressService(root);
+            Check(reopened.IsRead("main", "one"), "read progress persistence");
+        }
+        finally { Directory.Delete(root, true); }
+    }
+
+    private static void Check(bool condition, string operation)
+    {
+        if (!condition) throw new InvalidOperationException($"AOT acceptance failed: {operation}.");
+    }
+}
diff --git a/src/Samples/GalNet.Sample.Headless/Acceptance/SmokeContracts.cs b/src/Samples/GalNet.Sample.Headless/Acceptance/SmokeContracts.cs
new file mode 100644
index 00000000..317c25f8
--- /dev/null
+++ b/src/Samples/GalNet.Sample.Headless/Acceptance/SmokeContracts.cs
@@ -0,0 +1,74 @@
+using System.Text.Json.Serialization;
+using GalNet.Core.Assets;
+using GalNet.Core.Entry;
+using GalNet.Core.Execution;
+using GalNet.Core.Parameters;
+using GalNet.Core.Primitives;
+using GalNet.Core.Runtime;
+
+[assembly: FieldSchemaJsonContext(typeof(GalNet.Sample.Headless.Acceptance.SmokeJsonContext))]
+
+namespace GalNet.Sample.Headless.Acceptance;
+
+public sealed class SmokeState
+{
+    public string Id { get; set; } = "";
+    public int Count { get; set; }
+}
+
+internal sealed class MissingMetadata;
+
+[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata, UseStringEnumConverter = true)]
+[JsonSerializable(typeof(SmokeState[]))]
+[JsonSerializable(typeof(SmokeOptions))]
+[JsonSerializable(typeof(SmokeSettings))]
+[JsonSerializable(typeof(SmokeMeta))]
+internal sealed partial class SmokeJsonContext : JsonSerializerContext;
+
+[GenerateFieldSchema]
+public partial class SmokeOptions
+{
+    [Field(0)] public int Count { get; set; } = 2;
+    [Field(1)] public SmokeChild? Child { get; set; }
+    [Field(2), JsonConverter(typeof(StringBooleanValueConverter))] public bool? Enabled { get; set; } = true;
+    [Field(3), JsonConverter(typeof(StringEnumValueConverter<SmokeMode>))] public SmokeMode? Mode { get; set; } = SmokeMode.First;
+}
+
+public enum SmokeMode { First, Second }
+
+[GenerateFieldSchema]
+public partial class SmokeChild
+{
+    [Field(0)] public string Text { get; set; } = "";
+    [Field(1)] public SmokeChild? Next { get; set; }
+}
+
+[GenerateFieldSchema]
+public partial class SmokeSettings
+{
+    [Field(0, Minimum = 0)] public int Count { get; set; } = 3;
+}
+
+public sealed class SmokeMeta : AssetMeta
+{
+    public string Label { get; set; } = "";
+}
+
+internal sealed class SmokeDispatcher(StateCatalog catalog) : IPrimitiveDispatcher
+{
+    public StateCatalog StateCatalog => catalog;
+    public IReadOnlyCollection<EntryDefinition> Primitives => [];
+    public bool CanExecute(string primitiveType) => primitiveType == "project.increment";
+    public bool TryGetEntry(string primitiveType, out EntryDefinition? entry) { entry = null; return false; }
+    public PrimitiveInstance Dispatch(PrimitiveEntry entry, IGameContext runtime, CancellationToken cancellationToken,
+        PrimitiveInvocationMode mode = PrimitiveInvocationMode.Normal)
+    {
+        var instance = new ImmediatePrimitiveInstance(() =>
+        {
+            runtime.State.Update(() => runtime.State.Table<SmokeState>().Get("counter").Count++);
+            runtime.SetVariable("save.count", runtime.GetVariable("save.count")!.AsInt() + 1);
+        }, batchId: entry.BatchId);
+        instance.Dispatch(mode);
+        return instance;
+    }
+}
diff --git a/src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj b/src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj
index d37d414d..93461bb1 100644
--- a/src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj
+++ b/src/Samples/GalNet.Sample.Headless/GalNet.Sample.Headless.csproj
@@ -12,8 +12,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="DynamicLocalization.Core" />
-    <Compile Include="..\Shared\GameLocalizationProvider.cs" Link="Localization\GameLocalizationProvider.cs" />
+    <ProjectReference Include="../../Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj"
+                      OutputItemType="Analyzer" ReferenceOutputAssembly="false"
+                      GlobalPropertiesToRemove="TargetFramework;RuntimeIdentifier;SelfContained;PublishAot" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Samples/GalNet.Sample.Headless/HeadlessConsolePresentation.cs b/src/Samples/GalNet.Sample.Headless/HeadlessConsolePresentation.cs
index b3c5b51c..03c131bc 100644
--- a/src/Samples/GalNet.Sample.Headless/HeadlessConsolePresentation.cs
+++ b/src/Samples/GalNet.Sample.Headless/HeadlessConsolePresentation.cs
@@ -1,5 +1,5 @@
-using GalNet.Core.Scene;
-using GalNet.Core.Settings;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Execution;
 using GalNet.Core.Text;
 using GalNet.Presentation.Abstractions.View;
 
@@ -8,13 +8,15 @@ namespace GalNet.Sample.Headless;
 /// <summary>Basic interactive console adapters used by the official sample player.</summary>
 internal sealed class ConsolePresentation : IDialoguePresenter, INvlPresenter, IChoicePresenter, ILayerPresenter, IAnimationPresenter, IEffectPresenter
 {
-    private readonly GameSettings _settings;
+    private readonly float _textSpeed;
     private volatile bool _skipCurrentTypewriter;
     private volatile bool _instantTypewriter;
     private int _advancePromptActive;
 
-    public ConsolePresentation(GameSettings settings) => _settings = settings;
+    public ConsolePresentation(float textSpeed = 30f) => _textSpeed = textSpeed;
 
+    private readonly TaskCompletionSource<Exception> _inputFailure = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    public Task<Exception> InputFailure => _inputFailure.Task;
     public event Action? AdvanceRequested;
 
     public void ShowLayer(LayerRenderRequest request) =>
@@ -81,8 +83,8 @@ public async Task StartTypewriter(string widgetInstanceId, string speaker, strin
                         {
                             ct.ThrowIfCancellationRequested();
                             Console.Write(character);
-                            if (!_skipCurrentTypewriter && !_instantTypewriter && _settings.TextSpeed > 0)
-                                await Task.Delay(TimeSpan.FromSeconds(1d / _settings.TextSpeed), ct);
+                            if (!_skipCurrentTypewriter && !_instantTypewriter && _textSpeed > 0)
+                                await Task.Delay(TimeSpan.FromSeconds(1d / _textSpeed), ct);
                         }
                         break;
                     case RichTypewriterTokenKind.LineBreak:
@@ -117,7 +119,7 @@ public static async Task<int> WaitForChoiceAsync(string widgetInstanceId, string
         while (true)
         {
             Console.Write("  Select: ");
-            var input = await Task.Run(Console.ReadLine, ct);
+            var input = await Task.Run(Console.ReadLine).WaitAsync(ct);
             if (input is null)
                 throw new EndOfStreamException("Console input closed while waiting for a choice.");
             if (int.TryParse(input, out var selected) && selected >= 1 && selected <= options.Length) return selected - 1;
@@ -158,11 +160,12 @@ private async Task RequestAdvanceAsync(CancellationToken cancellationToken)
         try
         {
             Console.Write("  >> ");
-            if (await Task.Run(Console.ReadLine, cancellationToken) is null)
+            if (await Task.Run(Console.ReadLine).WaitAsync(cancellationToken) is null)
                 throw new EndOfStreamException("Console input closed while waiting to advance.");
             AdvanceRequested?.Invoke();
         }
         catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { }
+        catch (Exception error) { _inputFailure.TrySetResult(error); }
         finally
         {
             Interlocked.Exchange(ref _advancePromptActive, 0);
diff --git a/src/Samples/GalNet.Sample.Headless/Program.cs b/src/Samples/GalNet.Sample.Headless/Program.cs
index c8ec98dc..690be143 100644
--- a/src/Samples/GalNet.Sample.Headless/Program.cs
+++ b/src/Samples/GalNet.Sample.Headless/Program.cs
@@ -1,18 +1,23 @@
+using System.Globalization;
 using GalNet.Assets;
 using GalNet.Assets.Variants;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
-using GalNet.Core.Settings;
 using GalNet.GameHost;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
+using GalNet.Runtime.Engine;
 using GalNet.Runtime.Persistence;
 using GalNet.Runtime.Runtime;
 using GalNet.Runtime.Variables;
 using GalNet.Sample.Headless;
-using GalNet.Sample.Localization;
 using GalNet.Storage.FileSystem;
 
+if (args.Contains("--aot-self-test"))
+    return await GalNet.Sample.Headless.Acceptance.AotAcceptance.RunAsync(args);
+
 if (!HeadlessOptions.TryParse(args, out var options, out var error))
 {
     Console.Error.WriteLine(error);
@@ -25,38 +30,41 @@
     var installation = await GameInstallation.OpenAsync(options!.GameDirectory);
     var resourceTypes = BuiltinResourceTypes.CreateCatalog();
     var galleryTypes = BuiltinGalleryTypes.CreateCatalog(resourceTypes);
-    var content = await installation.CreateContentProvider(resourceTypes, galleryTypes).LoadAsync();
+    var content = await installation.CreateContentProvider(resourceTypes, galleryTypes, new()
+    {
+        Configurations = GalNet.Project.Contracts.ProjectSchemas.Configurations,
+        SelectDefaultCulture = configuration => configuration.ReadDefaultOptions().TargetLocale.Code
+    }).LoadAsync();
     using var assets = new AssetManager(installation.CreateAssetProviders(resourceTypes));
     assets.RegisterImageVariantsDecoder();
     var imageVariants = await assets.LoadImageVariantsCatalogAsync();
     foreach (var diagnostic in content.Localization.Diagnostics)
         Console.Error.WriteLine($"Skipped localization source '{diagnostic.RelativePath}': {diagnostic.Message}");
-    var textResolver = new GameLocalizationProvider(content, () => content.Settings.TargetLocale.ToCultureInfo());
-    var settings = new SettingsContainer();
-    settings.Set(content.Settings);
-    settings.Set(new GameSettings());
+    var culture = CultureInfo.GetCultureInfo(content.Localization.DefaultCulture);
+    var textResolver = content.Localization.CreateResolver(() => culture);
 
-    var saves = new FileSaveService(options.ProfileDirectory);
-    var variables = await PlayerVariableService.CreateAsync(new FilePlayerVariableStore(options.ProfileDirectory));
-    variables.ConfigureSystemVariables(GalleryUnlockVariable.CreateDefinitions(content.Gallery));
-    await using var progress = new FileGameProgressService(options.ProfileDirectory);
+    using var player = await FilePlayerSession.OpenAsync(options.ProfileDirectory, content.Gallery,
+        content.Configuration.ReadDefaultOptions().SaveSlotCount);
+    var variables = player.Variables;
+    var progress = player.Progress;
 
-    var presentation = new ConsolePresentation(settings.Get<GameSettings>());
+    var presentation = new ConsolePresentation();
     using var registration = new GameRegistration();
     registration.UseCatalog(GalNet.Project.Contracts.ProjectSchemas.CreateCatalog());
     await using var view = registration.AddBuiltinImplementations(registration.BuildCatalog(),
         presentation, presentation, presentation, presentation, content.Gallery, nvlPresenter: presentation,
-        characters: content.Localization.Characters, imageVariants: imageVariants).BuildView();
+        characters: content.Localization.Characters, imageVariants: imageVariants, audioConfiguration: new GalNet.Contracts.Builtins.Audio.AudioConfiguration(content.Configuration.ReadDefaultOptions().AudioTracks, content.Configuration.ReadDefaultOptions().AudioBuses)).BuildView();
     view.RequireInstructions(content.Graph.Nodes.OfType<GalNet.Core.Graph.Group>().SelectMany(group => group.Entries).Select(entry => entry.Type));
 
-    var runtime = new GameRuntime(textResolver, content.Graph.RootNodeId, settings, variables);
+    var runtime = new GameRuntime(textResolver, content.Graph.RootNodeId, variables,
+        saveDefaults: content.Graph.SaveVariables, playerDefaults: content.Graph.PlayerVariables);
     await using var run = new GameRun(content.Graph, runtime, view, progress, presentation);
     var engine = run.Engine;
 
     GalNet.Core.Runtime.GameSnapshot? initialSnapshot = null;
     if (options.LoadSlot is { } loadSlot)
     {
-        var snapshot = await saves.LoadAsync(loadSlot)
+        var snapshot = await player.LoadAsync(loadSlot, CancellationToken.None)
             ?? throw new InvalidOperationException($"Save slot {loadSlot} is empty or invalid.");
         initialSnapshot = snapshot;
         Console.WriteLine($"[Save] loaded slot {loadSlot}");
@@ -65,8 +73,13 @@
     Task latestCheckpointSave = Task.CompletedTask;
     if (options.SaveSlot is { } saveSlot)
     {
-        if (saveSlot >= saves.MaxSlots) throw new InvalidDataException($"Save slot must be below {saves.MaxSlots}.");
-        engine.CheckpointCreated += snapshot => latestCheckpointSave = saves.SaveAsync(saveSlot, new SaveRequest { Snapshot = snapshot });
+        if (saveSlot >= content.Configuration.ReadDefaultOptions().SaveSlotCount) throw new InvalidDataException($"Save slot must be below {content.Configuration.ReadDefaultOptions().SaveSlotCount}.");
+        engine.CheckpointCreated += snapshot => latestCheckpointSave = SaveCheckpointAsync(latestCheckpointSave, snapshot);
+        async Task SaveCheckpointAsync(Task previous, GalNet.Core.Runtime.GameSnapshot snapshot)
+        {
+            await previous;
+            await player.SaveAsync(saveSlot, snapshot, CancellationToken.None);
+        }
     }
 
     var advanceFailure = new TaskCompletionSource<Exception>(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -79,21 +92,29 @@ async Task AdvanceAsync()
         catch (Exception exception) { advanceFailure.TrySetResult(exception); }
     }
 
-    await run.PrepareAsync(initialSnapshot);
-    await run.StartPreparedAsync();
-    while (engine.IsRunning)
+    var terminal = new TaskCompletionSource<GameEngineStateChange>(TaskCreationOptions.RunContinuationsAsynchronously);
+    engine.StateChanged += change =>
+    {
+        if (change.State is GameEngineState.Completed or GameEngineState.Faulted or GameEngineState.Stopped)
+            terminal.TrySetResult(change);
+    };
+    try
     {
-        var completed = await Task.WhenAny(Task.Delay(25), advanceFailure.Task);
-        if (completed == advanceFailure.Task)
-            throw await advanceFailure.Task;
+        await run.PrepareAsync(initialSnapshot);
+        await run.StartPreparedAsync();
+        var completed = await Task.WhenAny(terminal.Task, presentation.InputFailure, advanceFailure.Task);
+        if (completed == presentation.InputFailure) throw await presentation.InputFailure;
+        if (completed == advanceFailure.Task) throw await advanceFailure.Task;
+        var state = await terminal.Task;
+        if (state.Error is { } failure) throw failure;
+        if (state.State == GameEngineState.Stopped) throw new OperationCanceledException();
     }
-    await latestAdvance;
-    await latestCheckpointSave;
+    finally { await Task.WhenAll(latestAdvance, latestCheckpointSave); }
 
     if (options.SaveSlot is { } finalSaveSlot)
     {
         await progress.FlushAsync();
-        await saves.SaveAsync(finalSaveSlot, new SaveRequest { Snapshot = engine.CreateSaveData() });
+        await player.SaveAsync(finalSaveSlot, engine.CreateSaveData(), CancellationToken.None);
         Console.WriteLine($"[Save] wrote slot {finalSaveSlot}");
     }
 
diff --git a/src/Samples/GalNet.Sample.Headless/packages.lock.json b/src/Samples/GalNet.Sample.Headless/packages.lock.json
index 5ce51c8e..eaa42e9c 100644
--- a/src/Samples/GalNet.Sample.Headless/packages.lock.json
+++ b/src/Samples/GalNet.Sample.Headless/packages.lock.json
@@ -2,34 +2,15 @@
   "version": 2,
   "dependencies": {
     "net10.0": {
-      "DynamicLocalization.Core": {
-        "type": "Direct",
-        "requested": "[2.1.2, )",
-        "resolved": "2.1.2",
-        "contentHash": "UdDvJeBnNoif/bi73CBDi7GiOhGUB9EkKl3v0JTNdVcPhCqWY+Jy9qr4IqNS9bQ5Xwn6uTYimYLDqGNxEEDjqw==",
-        "dependencies": {
-          "System.Text.Json": "[6.0.10, 10.0.0)",
-          "YamlDotNet": "[11.0.1, 19.0.0)"
-        }
-      },
       "Antlr4.Runtime.Standard": {
         "type": "Transitive",
         "resolved": "4.13.1",
         "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
       },
-      "System.Text.Json": {
-        "type": "Transitive",
-        "resolved": "6.0.10",
-        "contentHash": "NSB0kDipxn2ychp88NXWfFRFlmi1bst/xynOutbnpEfRCT9JZkZ7KOmF/I/hNKo2dILiMGnqblm+j1sggdLB9g=="
-      },
-      "YamlDotNet": {
-        "type": "Transitive",
-        "resolved": "11.0.1",
-        "contentHash": "UvICfSN4gJfAmOsuY/go0hb5SFfr3ZYCXb7jg66yT7kh+wSJEt7tUiwuoCNMpt8ScEXLDwXttpFoWKWeirYU1A=="
-      },
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -45,6 +26,7 @@
       "galnet.gamehost": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
@@ -53,6 +35,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -77,7 +60,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
@@ -85,6 +67,7 @@
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
diff --git a/src/Samples/Shared/GameLocalizationProvider.cs b/src/Samples/Shared/GameLocalizationProvider.cs
deleted file mode 100644
index 1cd98a52..00000000
--- a/src/Samples/Shared/GameLocalizationProvider.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-using System.Globalization;
-using DynamicLocalization.Core.Providers;
-using GalNet.Core.Services;
-using GalNet.Runtime.Content;
-using GalNet.Runtime.I18n;
-
-namespace GalNet.Sample.Localization;
-
-/// <summary>Adapts DynamicLocalization JSON providers to the Runtime-owned lookup policy.</summary>
-public sealed class GameLocalizationProvider : ITextResolver, ILocalizationProvider
-{
-    private readonly GameTextResolver _resolver;
-
-    public GameLocalizationProvider(GameContent content, Func<CultureInfo> currentCulture,
-        IEnumerable<ILocalizationProvider>? bootstrapProviders = null,
-        IEnumerable<GameLocalizationSource>? additionalSources = null)
-    {
-        var sources = new List<LocalizedTextSource>();
-        foreach (var provider in bootstrapProviders ?? [])
-            foreach (var culture in provider.GetAvailableCultures())
-                sources.Add(Adapt(provider, culture));
-
-        foreach (var source in content.Localization.Sources.Concat(content.Localization.ExternalSources).Concat(additionalSources ?? []))
-        {
-            // LoadJsonString replaces a culture's dictionary, so each file needs its own provider.
-            var provider = new JsonLocalizationProvider();
-            provider.LoadJsonString(source.Json, source.Culture);
-            sources.Add(Adapt(provider, CultureInfo.GetCultureInfo(source.Culture)));
-        }
-        _resolver = new GameTextResolver(sources, content.Settings.TargetLocale.ToCultureInfo(), currentCulture);
-    }
-
-    public string Name => "Sample.Game";
-    public IEnumerable<CultureInfo> GetAvailableCultures() => _resolver.AvailableCultures;
-    public string Resolve(string key) => _resolver.Resolve(key);
-    public string GetString(string key, CultureInfo culture) => _resolver.GetString(key, culture);
-    public bool TryGetString(string key, CultureInfo culture, out string? value) => _resolver.TryGetString(key, culture, out value);
-
-    private static LocalizedTextSource Adapt(ILocalizationProvider provider, CultureInfo culture) =>
-        new(culture, key => provider.TryGetString(key, culture, out var value) ? value : null);
-
-    // Sources are snapshots of loaded content. A new content session supplies a new resolver.
-    public Task ReloadAsync(CancellationToken cancellationToken = default)
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return Task.CompletedTask;
-    }
-}
diff --git a/src/Shared/GalNet.Assets/Archive.cs b/src/Shared/GalNet.Assets/Archive.cs
index 28214766..6d532f8f 100644
--- a/src/Shared/GalNet.Assets/Archive.cs
+++ b/src/Shared/GalNet.Assets/Archive.cs
@@ -1,81 +1,61 @@
-using System.Buffers.Binary;
 using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Assets.Variants;
 using GalNet.Core.Assets;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Assets;
 
-/// <summary>
-/// .pak 归档实现 —— 可寻址资源文件集合。
-///
-/// 二进制格式：
-///   [Magic   ] 4 bytes   "GPAK"
-///   [Ver     ] 4 bytes   int32
-///   [Count   ] 4 bytes   int32
-///   ── Entry Table ──
-///   [IdLen   ] 4 bytes   int32
-///   [Id      ] IdLen     UTF-8
-///   [PathLen ] 4 bytes   int32
-///   [Path    ] PathLen   UTF-8
-///   [TypeLen ] 4 bytes   int32
-///   [TypeId  ] TypeLen   UTF-8
-///   [MetaLen ] 4 bytes   int32
-///   [Meta    ] MetaLen   UTF-8 canonical registered metadata JSON
-///   [Offset  ] 8 bytes   int64   数据段起始偏移
-///   [OrigLen ] 8 bytes   int64   原始大小(未压缩)
-///   [StoredLen] 8 bytes  int64   存储大小(压缩后)
-///   [Compress] 4 bytes   int32   CompressionMode
-///   [Hash    ] 32 bytes  SHA256  (十六进制解码后)
-///   ── Data Section ──
-///   [Block 1]  StoredLen bytes
-///   [Block 2]  StoredLen bytes
-///   ...
-/// </summary>
-public sealed class Archive : IArchive
+/// <summary>GPAK v3: magic/version, length-prefixed control JSON, entry count/table and data blocks.</summary>
+public sealed class Archive : IPakArchive
 {
-    private const string Magic = "GPAK";
-    private const int CurrentVersion = 2;
-
-    private readonly string _name;
-    private readonly Dictionary<string, EntryDescriptor> _entries = new();
-    private readonly Dictionary<string, string> _pathToId = new();
+    public const int CurrentVersion = 3;
+    private static readonly UTF8Encoding Utf8 = new(false, true);
+    private static readonly JsonSerializerOptions ControlOptions = JsonMetadata.CreateOptions(new(JsonSerializerDefaults.Web)
+    {
+        AllowDuplicateProperties = false,
+        PropertyNameCaseInsensitive = false,
+        UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow
+    });
+    private readonly Dictionary<string, EntryDescriptor> _entries;
+    private readonly Dictionary<string, string> _pathToId;
     private readonly byte[] _dataSection;
+    private readonly PakDescriptor _descriptor;
     private bool _disposed;
 
     private Archive(string name, byte[] dataSection, Dictionary<string, EntryDescriptor> entries,
-        Dictionary<string, string> pathToId)
+        Dictionary<string, string> pathToId, PakDescriptor descriptor)
     {
-        _name = name;
+        Name = name;
         _dataSection = dataSection;
         _entries = entries;
         _pathToId = pathToId;
+        _descriptor = descriptor;
     }
 
-    public string Name => _name;
+    public string Name { get; }
+    public PakDescriptor Descriptor => _descriptor with { Mappings = new(_descriptor.Mappings, StringComparer.OrdinalIgnoreCase) };
     public IEnumerable<string> AssetIds => _entries.Keys;
-
-    public bool Contains(string assetId) => _entries.ContainsKey(assetId);
+    public IReadOnlyList<PakAssetIndexEntry> MetadataIndex => _entries.Values.Select(entry => new PakAssetIndexEntry(
+        entry.Metadata.Id, entry.Metadata.Path, entry.Metadata.TypeId, entry.Metadata, entry.OriginalLength, entry.Hash)).ToArray();
+    public bool Contains(string assetId) => _entries.ContainsKey(assetId.Trim());
 
     public IGameFile? GetAsset(string assetId)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
-
-        if (!_entries.TryGetValue(assetId, out var desc))
-            return null;
-
-        var raw = new ReadOnlySpan<byte>(_dataSection, (int)desc.Offset, (int)desc.StoredLength).ToArray();
-        var data = desc.Compression != CompressionMode.None
-            ? CompressionHelper.Decompress(raw, desc.Compression)
-            : raw;
-
-        return new GameFile(assetId, desc.Path, desc.TypeId, desc.Metadata, data, desc.Hash);
+        if (!_entries.TryGetValue(assetId.Trim(), out var entry)) return null;
+        var raw = _dataSection.AsSpan((int)entry.Offset, (int)entry.StoredLength).ToArray();
+        var data = entry.Compression == CompressionMode.None ? raw : CompressionHelper.Decompress(raw, entry.Compression);
+        if (data.LongLength != entry.OriginalLength || CryptoHelper.HashSHA256(data) != entry.Hash)
+            throw new InvalidDataException($"PAK resource '{assetId}' failed size/hash verification.");
+        var file = new GameFile(entry.Metadata.Id, entry.Metadata.Path, entry.Metadata.TypeId, entry.Metadata, data, entry.Hash);
+        ValidateCompiledDependencies(file);
+        return file;
     }
 
-    public IGameFile? GetAssetByPath(string path)
-    {
-        if (_pathToId.TryGetValue(AssetPathHelper.Normalize(path), out var id))
-            return GetAsset(id);
-        return null;
-    }
+    public IGameFile? GetAssetByPath(string path) =>
+        _pathToId.TryGetValue(AssetPathHelper.Normalize(path), out var id) ? GetAsset(id) : null;
 
     public void Dispose()
     {
@@ -84,215 +64,157 @@ public void Dispose()
         _pathToId.Clear();
     }
 
-    // ── 序列化/反序列化 ──
-
-    /// <summary>将二进制数据反序列化为 Archive。</summary>
-    public static Archive Deserialize(string name, byte[] pakData, IResourceTypeCatalog? resourceTypes = null)
+    public static Archive Deserialize(string name, byte[] pakData, IResourceTypeCatalog resourceTypes)
     {
-        var metaCodec = new AssetMetaCodec(resourceTypes ?? BuiltinResourceTypes.CreateCatalog());
-        var span = new ReadOnlySpan<byte>(pakData);
-        var offset = 0;
-
-        // Magic
-        if (Encoding.UTF8.GetString(span[offset..(offset + 4)]) != Magic)
-            throw new InvalidDataException("Invalid .pak magic number");
-        offset += 4;
-
-        // Version
-        var version = BinaryPrimitives.ReadInt32LittleEndian(span[offset..]);
-        offset += 4;
-        if (version != CurrentVersion)
-            throw new InvalidDataException($"Unsupported .pak version: {version}");
-
-        // Entry count
-        var count = BinaryPrimitives.ReadInt32LittleEndian(span[offset..]);
-        offset += 4;
-
-        var entries = new Dictionary<string, EntryDescriptor>(count);
-        var pathToId = new Dictionary<string, string>(count);
-
-        for (var i = 0; i < count; i++)
+        try
         {
-            var idLen = BinaryPrimitives.ReadInt32LittleEndian(span[offset..]);
-            offset += 4;
-            var id = Encoding.UTF8.GetString(span[offset..(offset + idLen)]);
-            offset += idLen;
-
-            var pathLen = BinaryPrimitives.ReadInt32LittleEndian(span[offset..]);
-            offset += 4;
-            var path = Encoding.UTF8.GetString(span[offset..(offset + pathLen)]);
-            offset += pathLen;
-
-            var typeLength = BinaryPrimitives.ReadInt32LittleEndian(span[offset..]);
-            offset += 4;
-            var typeId = Encoding.UTF8.GetString(span[offset..(offset + typeLength)]);
-            offset += typeLength;
-
-            var metadataLength = BinaryPrimitives.ReadInt32LittleEndian(span[offset..]);
-            offset += 4;
-            var metadataJson = Encoding.UTF8.GetString(span[offset..(offset + metadataLength)]);
-            offset += metadataLength;
-            var metadata = metaCodec.Deserialize(metadataJson);
-            if (!string.Equals(id, metadata.Id, StringComparison.Ordinal)
-                || !string.Equals(path, metadata.Path, StringComparison.Ordinal)
-                || !string.Equals(typeId, metadata.TypeId, StringComparison.OrdinalIgnoreCase))
-                throw new InvalidDataException("Pak entry identity does not match its typed metadata.");
-
-            var dataOffset = BinaryPrimitives.ReadInt64LittleEndian(span[offset..]);
-            offset += 8;
-            var origLen = BinaryPrimitives.ReadInt64LittleEndian(span[offset..]);
-            offset += 8;
-            var storedLen = BinaryPrimitives.ReadInt64LittleEndian(span[offset..]);
-            offset += 8;
-
-            var compress = (CompressionMode)BinaryPrimitives.ReadInt32LittleEndian(span[offset..]);
-            offset += 4;
-
-            var hashBytes = span[offset..(offset + 64)]; // 64 hex chars = 32 bytes
-            var hash = Encoding.UTF8.GetString(hashBytes).TrimEnd('\0');
-            offset += 64;
-
-            entries[id] = new EntryDescriptor
+            using var stream = new MemoryStream(pakData, writable: false);
+            using var reader = new BinaryReader(stream, Utf8);
+            if (!ReadExact(reader, 4).AsSpan().SequenceEqual("GPAK"u8)) throw new InvalidDataException("Invalid .pak magic number.");
+            var version = reader.ReadInt32();
+            if (version != CurrentVersion) throw new InvalidDataException($"Unsupported .pak version: {version}.");
+            var descriptor = JsonCodec.Deserialize<PakDescriptor>(ReadString(reader), ControlOptions)
+                ?? throw new InvalidDataException("Missing PAK control descriptor.");
+            descriptor.Validate();
+            descriptor = descriptor with { Mappings = new(descriptor.Mappings, StringComparer.OrdinalIgnoreCase) };
+            var count = reader.ReadInt32();
+            if (count < 0 || count > (stream.Length - stream.Position) / 108)
+                throw new InvalidDataException("Invalid PAK entry count.");
+            var codec = new AssetMetaCodec(resourceTypes);
+            var entries = new Dictionary<string, EntryDescriptor>(StringComparer.OrdinalIgnoreCase);
+            var paths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            for (var i = 0; i < count; i++)
             {
-                Path = path,
-                TypeId = typeId,
-                Metadata = metadata,
-                Offset = dataOffset,
-                OriginalLength = origLen,
-                StoredLength = storedLen,
-                Compression = compress,
-                Hash = hash,
-            };
-
-            pathToId[AssetPathHelper.Normalize(path)] = id;
+                var id = ReadString(reader);
+                var path = ReadString(reader);
+                var type = ReadString(reader);
+                var metadata = codec.Deserialize(ReadString(reader));
+                if (id != metadata.Id || path != metadata.Path || type != metadata.TypeId)
+                    throw new InvalidDataException("PAK entry identity does not match its typed metadata.");
+                var entry = new EntryDescriptor(metadata, reader.ReadInt64(), reader.ReadInt64(), reader.ReadInt64(),
+                    (CompressionMode)reader.ReadInt32(), Utf8.GetString(ReadExact(reader, 64)));
+                if (!Enum.IsDefined(entry.Compression) || entry.Offset < 0 || entry.OriginalLength < 0
+                    || entry.OriginalLength > int.MaxValue || entry.StoredLength < 0 || entry.StoredLength > int.MaxValue
+                    || entry.Hash.Length != 64 || entry.Hash.Any(c => c is not (>= '0' and <= '9' or >= 'a' and <= 'f')))
+                    throw new InvalidDataException("Invalid PAK entry lengths, compression or SHA-256.");
+                if (!entries.TryAdd(id, entry) || !paths.TryAdd(AssetPathHelper.Normalize(path), id))
+                    throw new InvalidDataException("Duplicate PAK resource ID or logical path.");
+            }
+            var data = pakData[(int)stream.Position..];
+            long position = 0;
+            foreach (var entry in entries.Values)
+            {
+                if (entry.Offset != position || entry.StoredLength > data.LongLength - position)
+                    throw new InvalidDataException("Invalid PAK data block range.");
+                position += entry.StoredLength;
+            }
+            if (position != data.LongLength) throw new InvalidDataException("Unexpected PAK trailing bytes.");
+            ValidateTargets(descriptor, entries.Keys);
+            var archive = new Archive(name, data, entries, paths, descriptor);
+            foreach (var id in entries.Where(pair => pair.Value.Metadata.TypeId == ImageVariantsCodec.ResourceType).Select(pair => pair.Key))
+                archive.GetAsset(id);
+            return archive;
+        }
+        catch (Exception exception) when (exception is EndOfStreamException or JsonException or DecoderFallbackException or ArgumentException or OverflowException)
+        {
+            throw new InvalidDataException("Malformed PAK archive.", exception);
         }
-
-        // Data section starts at offset
-        var dataSection = pakData[offset..];
-
-        return new Archive(name, dataSection, entries, pathToId);
     }
 
-    /// <summary>将 Archive 序列化为二进制数据（.pak 格式）。</summary>
     public static byte[] Serialize(string name, IReadOnlyList<IGameFile> files,
-        CompressionMode compression = CompressionMode.Brotli, IResourceTypeCatalog? resourceTypes = null)
+        IResourceTypeCatalog resourceTypes, CompressionMode compression = CompressionMode.Brotli, PakDescriptor? descriptor = null)
     {
-        var metaCodec = new AssetMetaCodec(resourceTypes ?? BuiltinResourceTypes.CreateCatalog());
-        // Build entry descriptors (compress if needed)
-        var entryList = new List<(IGameFile file, byte[] storedData, CompressionMode actualCompression, string hash, byte[] typeBytes, byte[] metadataBytes)>();
-        foreach (var file in files)
+        ArgumentNullException.ThrowIfNull(files);
+        if (!Enum.IsDefined(compression)) throw new ArgumentOutOfRangeException(nameof(compression));
+        descriptor ??= new();
+        descriptor.Validate();
+        descriptor = descriptor with
         {
-            var data = file.ReadAllBytes();
-            var hash = string.IsNullOrEmpty(file.Hash)
-                ? CryptoHelper.HashSHA256(data)
-                : file.Hash;
-            var useCompression = compression != CompressionMode.None && data.Length > 256;
-            var stored = useCompression ? CompressionHelper.Compress(data, compression) : data;
-            var typeBytes = Encoding.UTF8.GetBytes(file.TypeId);
-            var metadataBytes = Encoding.UTF8.GetBytes(metaCodec.Serialize(file.Metadata));
-            entryList.Add((file, stored, useCompression ? compression : CompressionMode.None, hash, typeBytes, metadataBytes));
-        }
-
-        // Calculate sizes
-        var headerSize = 4 + 4 + 4; // magic + version + count
-        foreach (var (file, storedData, _, _, typeBytes, metadataBytes) in entryList)
+            Mappings = descriptor.Mappings.OrderBy(pair => pair.Key, StringComparer.Ordinal)
+            .ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.OrdinalIgnoreCase)
+        };
+        var codec = new AssetMetaCodec(resourceTypes);
+        var entries = new List<(EntryDescriptor Entry, byte[] Data)>();
+        var ids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var paths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var file in files.OrderBy(file => file.Id, StringComparer.Ordinal))
         {
-            headerSize += 4 + Encoding.UTF8.GetByteCount(file.Id); // id
-            headerSize += 4 + Encoding.UTF8.GetByteCount(file.Path); // path
-            headerSize += 4 + typeBytes.Length + 4 + metadataBytes.Length + 8 + 8 + 8 + 4 + 64;
+            if (string.IsNullOrWhiteSpace(file.Id) || file.Id != file.Id.Trim()
+                || string.IsNullOrWhiteSpace(file.Path) || file.Path != file.Path.Trim().Replace('\\', '/'))
+                throw new InvalidDataException("PAK resources require canonical, non-empty identity and path.");
+            if (file.Id != file.Metadata.Id || file.Path != file.Metadata.Path || file.TypeId != file.Metadata.TypeId)
+                throw new InvalidDataException("PAK entry identity does not match its typed metadata.");
+            if (!ids.Add(file.Id) || !paths.Add(AssetPathHelper.Normalize(file.Path)))
+                throw new InvalidDataException("Duplicate PAK resource ID or logical path.");
+            var bytes = file.ReadAllBytes();
+            if (bytes.LongLength != file.Length) throw new InvalidDataException("Resource size changed while preparing PAK.");
+            ValidateCompiledDependencies(new GameFile(file.Id, file.Path, file.TypeId, file.Metadata, bytes));
+            var actualCompression = compression != CompressionMode.None && bytes.Length > 256 ? compression : CompressionMode.None;
+            var stored = actualCompression == CompressionMode.None ? bytes : CompressionHelper.Compress(bytes, actualCompression);
+            entries.Add((new(file.Metadata, 0, bytes.Length, stored.Length, actualCompression, CryptoHelper.HashSHA256(bytes)), stored));
         }
-
-        var pakSize = headerSize;
-        foreach (var (_, storedData, _, _, _, _) in entryList)
-            pakSize += storedData.Length;
-
-        var pak = new byte[pakSize];
-        var span = new Span<byte>(pak);
-        var pos = 0;
-
-        // Magic
-        Encoding.UTF8.GetBytes(Magic, span[pos..(pos + 4)]);
-        pos += 4;
-
-        // Version
-        BinaryPrimitives.WriteInt32LittleEndian(span[pos..], CurrentVersion);
-        pos += 4;
-
-        // Entry count
-        BinaryPrimitives.WriteInt32LittleEndian(span[pos..], entryList.Count);
-        pos += 4;
-
-        // Entry table
-        var dataRelativeOffset = 0L;
-        foreach (var (file, storedData, actualCompression, hash, typeBytes, metadataBytes) in entryList)
+        ValidateTargets(descriptor, ids);
+        using var stream = new MemoryStream();
+        using var writer = new BinaryWriter(stream, Utf8, leaveOpen: true);
+        writer.Write("GPAK"u8);
+        writer.Write(CurrentVersion);
+        WriteString(writer, JsonCodec.Serialize(descriptor, ControlOptions));
+        writer.Write(entries.Count);
+        long offset = 0;
+        foreach (var (entry, stored) in entries)
         {
-            // Id
-            var idBytes = Encoding.UTF8.GetBytes(file.Id);
-            BinaryPrimitives.WriteInt32LittleEndian(span[pos..], idBytes.Length);
-            pos += 4;
-            idBytes.CopyTo(span[pos..]);
-            pos += idBytes.Length;
-
-            // Path
-            var pathBytes = Encoding.UTF8.GetBytes(file.Path);
-            BinaryPrimitives.WriteInt32LittleEndian(span[pos..], pathBytes.Length);
-            pos += 4;
-            pathBytes.CopyTo(span[pos..]);
-            pos += pathBytes.Length;
-
-            BinaryPrimitives.WriteInt32LittleEndian(span[pos..], typeBytes.Length);
-            pos += 4;
-            typeBytes.CopyTo(span[pos..]);
-            pos += typeBytes.Length;
-
-            BinaryPrimitives.WriteInt32LittleEndian(span[pos..], metadataBytes.Length);
-            pos += 4;
-            metadataBytes.CopyTo(span[pos..]);
-            pos += metadataBytes.Length;
-
-            // Offset (relative to data section start)
-            BinaryPrimitives.WriteInt64LittleEndian(span[pos..], dataRelativeOffset);
-            pos += 8;
-
-            // Original length
-            BinaryPrimitives.WriteInt64LittleEndian(span[pos..], file.Length);
-            pos += 8;
-
-            // Stored length
-            BinaryPrimitives.WriteInt64LittleEndian(span[pos..], storedData.Length);
-            pos += 8;
-
-            // Compression
-            BinaryPrimitives.WriteInt32LittleEndian(span[pos..], (int)actualCompression);
-            pos += 4;
-
-            // Hash (64 hex chars)
-            var hashBytes = Encoding.UTF8.GetBytes(hash.PadRight(64, '\0')[..64]);
-            hashBytes.CopyTo(span[pos..]);
-            pos += 64;
-
-            dataRelativeOffset += storedData.Length;
+            WriteString(writer, entry.Metadata.Id);
+            WriteString(writer, entry.Metadata.Path);
+            WriteString(writer, entry.Metadata.TypeId);
+            WriteString(writer, codec.Serialize(entry.Metadata));
+            writer.Write(offset);
+            writer.Write(entry.OriginalLength);
+            writer.Write(entry.StoredLength);
+            writer.Write((int)entry.Compression);
+            writer.Write(Utf8.GetBytes(entry.Hash));
+            offset += stored.Length;
         }
+        foreach (var (_, stored) in entries) writer.Write(stored);
+        writer.Flush();
+        return stream.ToArray();
+    }
 
-        // Data section
-        foreach (var (_, storedData, _, _, _, _) in entryList)
-        {
-            storedData.CopyTo(span[pos..]);
-            pos += storedData.Length;
-        }
+    private static void ValidateCompiledDependencies(GameFile file)
+    {
+        if (file.TypeId != ImageVariantsCodec.ResourceType) return;
+        var definition = ImageVariantsCodec.Decode(file.ReadAllBytes());
+        var expected = definition.Variants.Select(variant => variant.AssetId.Trim()).ToHashSet(StringComparer.OrdinalIgnoreCase);
+        if (file.Metadata is not IAssetDependencies source) throw new InvalidDataException("Compiled image variants require dependency metadata.");
+        var info = source.GetDependencies();
+        if (!info.Complete || info.Direct.Any(item => item is null || string.IsNullOrWhiteSpace(item.AssetId)
+                || item.ExpectedTypeId != "sprite" || item.RequiredStoryPackage is not null)
+            || !expected.SetEquals(info.Direct.Select(item => item.AssetId.Trim())))
+            throw new InvalidDataException("Compiled image variants dependencies do not match their payload.");
+    }
 
-        return pak;
+    private static void ValidateTargets(PakDescriptor descriptor, IEnumerable<string> ids)
+    {
+        var available = ids.ToHashSet(StringComparer.OrdinalIgnoreCase);
+        if (descriptor.Mappings.Values.Any(id => !available.Contains(id)))
+            throw new InvalidDataException("Override mapping targets must be carried by their PAK.");
     }
 
-    private struct EntryDescriptor
+    private static string ReadString(BinaryReader reader) => Utf8.GetString(ReadExact(reader, reader.ReadInt32()));
+    private static byte[] ReadExact(BinaryReader reader, int count)
     {
-        public string Path;
-        public string TypeId;
-        public AssetMeta Metadata;
-        public long Offset;
-        public long OriginalLength;
-        public long StoredLength;
-        public CompressionMode Compression;
-        public string Hash;
+        if (count < 0 || count > reader.BaseStream.Length - reader.BaseStream.Position)
+            throw new InvalidDataException("Invalid PAK field length.");
+        var bytes = reader.ReadBytes(count);
+        if (bytes.Length != count) throw new InvalidDataException("Truncated PAK field.");
+        return bytes;
     }
+    private static void WriteString(BinaryWriter writer, string value)
+    {
+        var bytes = Utf8.GetBytes(value);
+        writer.Write(bytes.Length);
+        writer.Write(bytes);
+    }
+
+    private sealed record EntryDescriptor(AssetMeta Metadata, long Offset, long OriginalLength, long StoredLength,
+        CompressionMode Compression, string Hash);
 }
diff --git a/src/Shared/GalNet.Assets/AssetDependencyCollector.cs b/src/Shared/GalNet.Assets/AssetDependencyCollector.cs
new file mode 100644
index 00000000..728e95af
--- /dev/null
+++ b/src/Shared/GalNet.Assets/AssetDependencyCollector.cs
@@ -0,0 +1,55 @@
+using GalNet.Core.Assets;
+
+namespace GalNet.Assets;
+
+public sealed record AssetDependencyClosure(IReadOnlyList<IGameFile> Files, IReadOnlyList<string> IncompleteAssetIds)
+{
+    public bool Complete => IncompleteAssetIds.Count == 0;
+}
+
+/// <summary>Computes references without choosing archive ownership or acquiring decoded assets.</summary>
+public static class AssetDependencyCollector
+{
+    public static AssetDependencyClosure Collect(IEnumerable<IGameFile> available, IEnumerable<string> roots,
+        IResourceTypeCatalog types, string? storyPackage = null, IEnumerable<string>? declaredComplete = null,
+        CancellationToken cancellationToken = default)
+    {
+        var files = new Dictionary<string, IGameFile>(StringComparer.OrdinalIgnoreCase);
+        foreach (var file in available)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (string.IsNullOrWhiteSpace(file.Id) || !files.TryAdd(file.Id.Trim(), file))
+                throw new InvalidDataException($"Duplicate or empty resource ID '{file.Id}'.");
+        }
+        var completeDeclarations = (declaredComplete ?? []).ToHashSet(StringComparer.OrdinalIgnoreCase);
+        var selected = new Dictionary<string, IGameFile>(StringComparer.OrdinalIgnoreCase);
+        var incomplete = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var pending = new Queue<(string Id, string? Type, string Source)>(roots.Select(id => (id, (string?)null, "build root")));
+        while (pending.TryDequeue(out var reference))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (string.IsNullOrWhiteSpace(reference.Id) || !files.TryGetValue(reference.Id.Trim(), out var file))
+                throw new InvalidDataException($"Resource '{reference.Source}' references missing asset '{reference.Id}'.");
+            if (reference.Type is not null && !StringComparer.Ordinal.Equals(file.TypeId, types.NormalizeTypeId(reference.Type)))
+                throw new InvalidDataException($"Resource '{reference.Source}' expects '{reference.Id}' to have type '{reference.Type}', got '{file.TypeId}'.");
+            if (!selected.TryAdd(file.Id.Trim(), file)) continue;
+            var registration = types.Get(file.TypeId);
+            var info = file.Metadata is IAssetDependencies dependencies
+                ? dependencies.GetDependencies()
+                : new AssetDependencyInfo([], registration.HasNoDependencies);
+            if (!info.Complete && !completeDeclarations.Contains(file.Id)) incomplete.Add(file.Id);
+            foreach (var dependency in info.Direct)
+            {
+                if (dependency is null) throw new InvalidDataException($"Resource '{file.Id}' has a null dependency.");
+                if (dependency.RequiredStoryPackage is { Length: > 0 } required)
+                {
+                    if (file.TypeId != "graph" || dependency.ExpectedTypeId != "group")
+                        throw new InvalidDataException("Only graph-to-group references may have optional story package references.");
+                    if (!StringComparer.Ordinal.Equals(required, storyPackage)) continue;
+                }
+                pending.Enqueue((dependency.AssetId, dependency.ExpectedTypeId, file.Id));
+            }
+        }
+        return new(selected.Values.OrderBy(file => file.Id, StringComparer.Ordinal).ToArray(), incomplete.Order(StringComparer.Ordinal).ToArray());
+    }
+}
diff --git a/src/Shared/GalNet.Assets/AssetFileMaterializer.cs b/src/Shared/GalNet.Assets/AssetFileMaterializer.cs
index abea819e..3a04c310 100644
--- a/src/Shared/GalNet.Assets/AssetFileMaterializer.cs
+++ b/src/Shared/GalNet.Assets/AssetFileMaterializer.cs
@@ -3,13 +3,14 @@
 namespace GalNet.Assets;
 
 /// <summary>Materializes acquired bytes once while any consumer retains a file lease.</summary>
-public sealed class AssetFileMaterializer(IAssetManager assets) : IAssetFileMaterializer
+public sealed class AssetFileMaterializer(IAssetManager assets, string? cacheDirectory = null) : IAssetFileMaterializer
 {
     private readonly object _gate = new();
     private readonly SemaphoreSlim _loadGate = new(1, 1);
     private readonly CancellationTokenSource _shutdown = new();
     private readonly Dictionary<string, Entry> _entries = new(StringComparer.OrdinalIgnoreCase);
-    private readonly string _directory = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "GalNet", "Media", Guid.NewGuid().ToString("N"));
+    private readonly string _directory = System.IO.Path.Combine(
+        System.IO.Path.GetFullPath(cacheDirectory ?? System.IO.Path.GetTempPath()), "GalNet", "Media", Guid.NewGuid().ToString("N"));
     private bool _disposed;
     private bool _drained;
     private Task? _disposeTask;
diff --git a/src/Shared/GalNet.Assets/AssetsJsonContext.cs b/src/Shared/GalNet.Assets/AssetsJsonContext.cs
new file mode 100644
index 00000000..3f74a512
--- /dev/null
+++ b/src/Shared/GalNet.Assets/AssetsJsonContext.cs
@@ -0,0 +1,10 @@
+using System.Text.Json.Serialization;
+using GalNet.Assets.Variants;
+using GalNet.Contracts.Builtins.Variants;
+
+namespace GalNet.Assets;
+
+[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata)]
+[JsonSerializable(typeof(ImageVariantsSource))]
+[JsonSerializable(typeof(ImageVariantsCodec.Payload))]
+internal sealed partial class AssetsJsonContext : JsonSerializerContext;
diff --git a/src/Shared/GalNet.Assets/CompiledStoryResources.cs b/src/Shared/GalNet.Assets/CompiledStoryResources.cs
new file mode 100644
index 00000000..126950c3
--- /dev/null
+++ b/src/Shared/GalNet.Assets/CompiledStoryResources.cs
@@ -0,0 +1,59 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using GalNet.Core.Assets;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Assets;
+
+/// <summary>Owns the effective story bytes shared by development providers and publication.</summary>
+public static class CompiledStoryResources
+{
+    private static readonly JsonSerializerOptions Options = new(JsonSerializerDefaults.Web);
+
+    public static IReadOnlyList<IGameFile> Create(byte[] graphBytes, Func<string, byte[]?> readGroup,
+        Func<string, CompiledGroupDocument, AssetDependencyInfo>? analyzeGroup = null, CancellationToken cancellationToken = default)
+    {
+        var graph = JsonNode.Parse(graphBytes)?.AsObject() ?? throw new InvalidDataException("Missing compiled graph.");
+        graph["id"] = StoryResourceIds.Graph;
+        var files = new List<IGameFile>();
+        var references = new List<AssetDependency>();
+        if (graph["nodes"] is not JsonArray nodes) throw new InvalidDataException("Compiled graph requires a node array.");
+        foreach (var node in nodes.OfType<JsonObject>())
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (node["type"]?.GetValue<string>() is not ("Group" or "Entry")) continue;
+            var id = node["id"]!.GetValue<string>();
+            var resourceId = StoryResourceIds.Group(id);
+            var package = node["storyPackage"]?.GetValue<string>() ?? "";
+            node["resourceId"] = resourceId;
+            var bytes = readGroup(id)
+                ?? (node["type"]!.GetValue<string>() == "Entry" ? JsonCodec.SerializeToUtf8Bytes(new CompiledGroupDocument(), Options)
+                    : throw new InvalidDataException($"Compiled group '{id}' is missing. Build the project first."));
+            var document = JsonCodec.Deserialize<CompiledGroupDocument>(bytes, Options)
+                ?? throw new InvalidDataException($"Compiled group '{id}' is invalid.");
+            if (document.Kind != GroupDocumentKind.Compiled || document.Version != CompiledGroupDocument.CurrentVersion)
+                throw new InvalidDataException($"Group '{id}' is not compiled for this runtime.");
+            var dependencies = analyzeGroup?.Invoke(id, document) ?? new AssetDependencyInfo([], document.Entries.Count == 0);
+            var meta = new DependentAssetMeta
+            {
+                Id = resourceId,
+                TypeId = "group",
+                Path = "Story/groups/" + Uri.EscapeDataString(id) + ".galgroup",
+                Dependencies = dependencies.Direct.ToList(),
+                DependenciesComplete = dependencies.Complete
+            };
+            files.Add(new GameFile(meta.Id, meta.Path, meta.TypeId, meta, bytes));
+            references.Add(new(resourceId, "group", package.Length == 0 ? null : package));
+        }
+        var graphMeta = new DependentAssetMeta
+        {
+            Id = StoryResourceIds.Graph,
+            TypeId = "graph",
+            Path = "Story/main.galgraph",
+            DependenciesComplete = true,
+            Dependencies = references
+        };
+        files.Add(new GameFile(graphMeta.Id, graphMeta.Path, graphMeta.TypeId, graphMeta, JsonCodec.SerializeToUtf8Bytes(graph, Options)));
+        return files;
+    }
+}
diff --git a/src/Shared/GalNet.Assets/ContentPackagePlanner.cs b/src/Shared/GalNet.Assets/ContentPackagePlanner.cs
new file mode 100644
index 00000000..57c9b68a
--- /dev/null
+++ b/src/Shared/GalNet.Assets/ContentPackagePlanner.cs
@@ -0,0 +1,67 @@
+using GalNet.Core.Assets;
+
+namespace GalNet.Assets;
+
+public sealed record PlannedPak(string PackageId, int PartIndex, int PartCount, IReadOnlyList<IGameFile> Files);
+public sealed record ContentPackagePlan(IReadOnlyList<PlannedPak> Paks, IReadOnlyList<IGameFile> Unused);
+
+/// <summary>Base closure first; optional story closures only subtract the base set, never one another.</summary>
+public static class ContentPackagePlanner
+{
+    public static ContentPackagePlan Plan(IReadOnlyList<IGameFile> available, IEnumerable<string> extraRoots,
+        IResourceTypeCatalog types, long maxBytes, IEnumerable<string>? declaredComplete = null, CancellationToken ct = default)
+    {
+        ArgumentOutOfRangeException.ThrowIfLessThan(maxBytes, 1);
+        var graph = available.Single(file => file.Id == StoryResourceIds.Graph);
+        var graphDependencies = ((IAssetDependencies)graph.Metadata).GetDependencies();
+        var packages = graphDependencies.Direct.Where(reference => !string.IsNullOrEmpty(reference.RequiredStoryPackage))
+            .GroupBy(reference => reference.RequiredStoryPackage!, StringComparer.Ordinal).OrderBy(group => group.Key, StringComparer.Ordinal).ToArray();
+        var names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var package in packages)
+            if (package.Key.Length > 128 || package.Key != package.Key.Trim() || package.Key.Any(char.IsControl) || !names.Add(package.Key))
+                throw new InvalidDataException($"Invalid or case-ambiguous story package '{package.Key}'. Names must be trimmed and at most 128 characters.");
+        var complete = (declaredComplete ?? []).ToArray();
+        var baseline = Collect(extraRoots.Prepend(StoryResourceIds.Graph), null);
+        var baseIds = baseline.Select(file => file.Id).ToHashSet(StringComparer.OrdinalIgnoreCase);
+        if (packages.SelectMany(package => package).Any(reference => baseIds.Contains(reference.AssetId)))
+            throw new InvalidDataException("Base content cannot require an optional story group.");
+        var result = new List<PlannedPak>();
+        var used = new HashSet<string>(baseIds, StringComparer.OrdinalIgnoreCase);
+        Split("", baseline);
+        foreach (var package in packages)
+        {
+            var closure = Collect(package.Select(reference => reference.AssetId), package.Key);
+            var otherGroups = packages.Where(other => other.Key != package.Key).SelectMany(other => other).Select(item => item.AssetId).ToHashSet(StringComparer.OrdinalIgnoreCase);
+            if (closure.Any(file => otherGroups.Contains(file.Id))) throw new InvalidDataException($"Story '{package.Key}' requires another optional story's group.");
+            var own = closure.Where(file => !baseIds.Contains(file.Id)).ToArray();
+            used.UnionWith(own.Select(file => file.Id));
+            Split(package.Key, own);
+        }
+        return new(result, available.Where(file => !used.Contains(file.Id)).OrderBy(file => file.Id, StringComparer.Ordinal).ToArray());
+
+        IReadOnlyList<IGameFile> Collect(IEnumerable<string> roots, string? package)
+        {
+            var closure = AssetDependencyCollector.Collect(available, roots, types, package, complete, ct);
+            if (!closure.Complete) throw new InvalidDataException("Resource dependencies are incomplete: "
+                + string.Join(", ", closure.IncompleteAssetIds) + ". Declare additional roots and explicitly confirm their coverage in galnet.packaging.");
+            return closure.Files;
+        }
+        void Split(string package, IReadOnlyList<IGameFile> files)
+        {
+            var parts = new List<List<IGameFile>>();
+            var current = new List<IGameFile>();
+            long size = 0;
+            foreach (var file in files.OrderBy(file => file.Id, StringComparer.Ordinal))
+            {
+                ct.ThrowIfCancellationRequested();
+                if (current.Count > 0 && file.Length > maxBytes - size)
+                { parts.Add(current); current = []; size = 0; }
+                current.Add(file);
+                size = checked(size + file.Length);
+            }
+            if (current.Count != 0) parts.Add(current);
+            for (var index = 0; index < parts.Count; index++) result.Add(new(package, index, parts.Count, parts[index]));
+        }
+    }
+
+}
diff --git a/src/Shared/GalNet.Assets/FileSystemPaths.cs b/src/Shared/GalNet.Assets/FileSystemPaths.cs
new file mode 100644
index 00000000..76c116bf
--- /dev/null
+++ b/src/Shared/GalNet.Assets/FileSystemPaths.cs
@@ -0,0 +1,42 @@
+namespace GalNet.Assets;
+
+/// <summary>Physical filesystem checks shared by authoring, local assets and package I/O.</summary>
+public static class FileSystemPaths
+{
+    public static bool IsSameOrChild(string path, string parent)
+    {
+        var relative = Path.GetRelativePath(parent, path);
+        return !Path.IsPathRooted(relative) && relative != ".." &&
+            !relative.StartsWith(".." + Path.DirectorySeparatorChar, StringComparison.Ordinal);
+    }
+
+    /// <summary>Requires a slash-separated relative file name, without dot or empty segments.</summary>
+    public static void ValidateRelativeFile(string path)
+    {
+        if (string.IsNullOrWhiteSpace(path) || Path.IsPathRooted(path) || path.Contains('\\') ||
+            path.Split('/').Any(part => part is "" or "." or ".."))
+            throw new InvalidDataException($"Path '{path}' is not a safe relative file path.");
+    }
+
+    public static string ResolveRelativeFile(string root, string relative)
+    {
+        ValidateRelativeFile(relative);
+        var destination = Path.GetFullPath(Path.Combine(root, relative.Replace('/', Path.DirectorySeparatorChar)));
+        if (!IsSameOrChild(destination, root))
+            throw new InvalidDataException($"Path '{relative}' escapes its destination directory.");
+        return destination;
+    }
+
+    /// <summary>Checks an existing path or its existing ancestors; does not create or resolve links.</summary>
+    public static void RequireNoLinks(string path, string message)
+    {
+        var fullPath = Path.GetFullPath(path);
+        var current = Path.GetPathRoot(fullPath)!;
+        foreach (var component in fullPath[current.Length..].Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries))
+        {
+            current = Path.Combine(current, component);
+            if ((File.Exists(current) || Directory.Exists(current)) && (File.GetAttributes(current) & FileAttributes.ReparsePoint) != 0)
+                throw new InvalidDataException(message);
+        }
+    }
+}
diff --git a/src/Shared/GalNet.Assets/GalNet.Assets.csproj b/src/Shared/GalNet.Assets/GalNet.Assets.csproj
index 530a2fe0..ee15f310 100644
--- a/src/Shared/GalNet.Assets/GalNet.Assets.csproj
+++ b/src/Shared/GalNet.Assets/GalNet.Assets.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <TargetFramework>net10.0</TargetFramework>
@@ -10,4 +10,5 @@
       <ProjectReference Include="..\GalNet.Core\GalNet.Core.csproj" />
     </ItemGroup>
 
+  <ItemGroup><ProjectReference Include="../GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Shared/GalNet.Assets/PackedGameDocuments.cs b/src/Shared/GalNet.Assets/PackedGameDocuments.cs
new file mode 100644
index 00000000..46201adb
--- /dev/null
+++ b/src/Shared/GalNet.Assets/PackedGameDocuments.cs
@@ -0,0 +1,99 @@
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Core.Assets;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Assets;
+
+/// <summary>Internal documents use GPAK with a fixed catalog, separate from game resource overrides.</summary>
+public static class PackedGameDocuments
+{
+    public const string GameFileName = "game.pak";
+    public const string LocalizationFileName = "localization.pak";
+    public const string InstallationPath = "installation.json";
+    private const string DocumentType = "document";
+    private const string IdPrefix = "galnet:document:";
+    private static readonly IResourceTypeCatalog Types = new ResourceTypeCatalogBuilder()
+        .Add<AssetMeta>(DocumentType).WithoutDependencies(DocumentType).Build();
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
+    {
+        AllowDuplicateProperties = false,
+        UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow
+    };
+
+    public static byte[] Build(string projectId, string buildId, IEnumerable<KeyValuePair<string, byte[]>> documents)
+    {
+        var files = documents.Select(pair =>
+        {
+            FileSystemPaths.ValidateRelativeFile(pair.Key);
+            var metadata = new AssetMeta { Id = IdPrefix + pair.Key, Path = pair.Key, TypeId = DocumentType };
+            return (IGameFile)new GameFile(metadata.Id, metadata.Path, DocumentType, metadata, pair.Value);
+        }).ToArray();
+        return PakBuilder.Build("documents", files, Types, descriptor: new() { ProjectId = projectId, BuildId = buildId });
+    }
+
+    public static PackedDocumentSet Read(byte[] bytes)
+    {
+        using var archive = Archive.Deserialize("documents", bytes, Types);
+        var descriptor = archive.Descriptor;
+        if (descriptor.Kind != "base" || descriptor.PartIndex != 0 || descriptor.PartCount != 1
+            || string.IsNullOrWhiteSpace(descriptor.ProjectId) || !IsHash(descriptor.BuildId))
+            throw new InvalidDataException("Invalid internal document package identity.");
+        var documents = new Dictionary<string, byte[]>(StringComparer.Ordinal);
+        foreach (var entry in archive.MetadataIndex)
+        {
+            FileSystemPaths.ValidateRelativeFile(entry.Path);
+            if (entry.Id != IdPrefix + entry.Path || entry.TypeId != DocumentType)
+                throw new InvalidDataException("Invalid internal document identity.");
+            documents.Add(entry.Path, archive.GetAsset(entry.Id)!.ReadAllBytes());
+        }
+        return new(descriptor, documents);
+    }
+
+    public static PackedGamePackage ReadGame(byte[] bytes)
+    {
+        var documents = Read(bytes);
+        var manifest = JsonCodec.Deserialize<GameContentManifest>(documents.GetText(GameContentManifest.FileName), JsonOptions)
+            ?? throw new InvalidDataException("Missing packed content descriptor.");
+        if (manifest.Version != 3 || string.IsNullOrWhiteSpace(manifest.ProjectId) || !IsHash(manifest.BuildId)
+            || manifest.ProjectId != documents.Descriptor.ProjectId || manifest.BuildId != documents.Descriptor.BuildId
+            || manifest.BasePaks is not { Count: > 0 } || manifest.Stories is null
+            || manifest.BasePaks.Any(file => file?.Path is null || !file.Path.StartsWith("Assets/Paks/", StringComparison.Ordinal))
+            || manifest.LocalizationPak is not { Path: LocalizationFileName } language || !ValidFile(language))
+            throw new InvalidDataException("Invalid packed content descriptor.");
+        var index = JsonCodec.Deserialize<GalpakManifest>(documents.GetText(InstallationPath), JsonOptions)
+            ?? throw new InvalidDataException("Missing packed installation index.");
+        var expected = manifest.BasePaks.Append(language).ToArray();
+        if (index.Version != 3 || index.ProjectId != manifest.ProjectId || index.Files is null
+            || expected.Any(file => !ValidFile(file)) || expected.Select(file => file.Path).Distinct(StringComparer.OrdinalIgnoreCase).Count() != expected.Length
+            || index.Files.Count != expected.Length || index.Files.Distinct().Count() != expected.Length
+            || expected.Any(file => !index.Files.Contains(file)))
+            throw new InvalidDataException("Packed installation index differs from content descriptor.");
+        foreach (var required in new[] { "settings.json", "gallery.json", "characters.json", "packaging-layout.json" })
+            _ = documents.GetText(required);
+        if (documents.Documents.Count != 6) throw new InvalidDataException("Unexpected internal game document.");
+        return new(documents, manifest, index);
+    }
+
+    public static IEnumerable<string> ExtensionDirectories(string buildId)
+    {
+        if (!IsHash(buildId)) throw new InvalidDataException("Invalid content build identity.");
+        return ["I18n", "ResourcePatches", "StoryPatches", "StoryPatches/" + buildId];
+    }
+
+    private static bool ValidFile(GalpakFileEntry? file) => file is not null && file.Size >= 0 && IsHash(file.Sha256);
+    private static bool IsHash(string? value) => value is { Length: 64 } && value.All(c => c is >= '0' and <= '9' or >= 'a' and <= 'f');
+}
+
+public sealed record PackedDocumentSet(PakDescriptor Descriptor, IReadOnlyDictionary<string, byte[]> Documents)
+{
+    public string GetText(string path)
+    {
+        if (!Documents.TryGetValue(path, out var bytes)) throw new InvalidDataException($"Packed document '{path}' was not found.");
+        try { return new UTF8Encoding(false, true).GetString(bytes); }
+        catch (DecoderFallbackException error) { throw new InvalidDataException($"Packed document '{path}' is not UTF-8.", error); }
+    }
+}
+
+public sealed record PackedGamePackage(PackedDocumentSet Documents, GameContentManifest Manifest, GalpakManifest Installation);
diff --git a/src/Shared/GalNet.Assets/PakBuilder.cs b/src/Shared/GalNet.Assets/PakBuilder.cs
index b32c3c77..2364af54 100644
--- a/src/Shared/GalNet.Assets/PakBuilder.cs
+++ b/src/Shared/GalNet.Assets/PakBuilder.cs
@@ -16,18 +16,18 @@ public static class PakBuilder
     /// <param name="compression">压缩模式（默认 Brotli）</param>
     /// <returns>.pak 文件字节数组</returns>
     public static byte[] Build(string archiveName, IReadOnlyList<IGameFile> files,
-        CompressionMode compression = CompressionMode.Brotli, IResourceTypeCatalog? resourceTypes = null)
+        IResourceTypeCatalog resourceTypes, CompressionMode compression = CompressionMode.Brotli, PakDescriptor? descriptor = null)
     {
-        return Archive.Serialize(archiveName, files, compression, resourceTypes);
+        return Archive.Serialize(archiveName, files, resourceTypes, compression, descriptor);
     }
 
     /// <summary>
     /// 将一组资源文件打包并写入磁盘。
     /// </summary>
     public static void BuildToFile(string pakPath, IReadOnlyList<IGameFile> files,
-        CompressionMode compression = CompressionMode.Brotli, IResourceTypeCatalog? resourceTypes = null)
+        IResourceTypeCatalog resourceTypes, CompressionMode compression = CompressionMode.Brotli, PakDescriptor? descriptor = null)
     {
-        var data = Build(Path.GetFileNameWithoutExtension(pakPath), files, compression, resourceTypes);
+        var data = Build(Path.GetFileNameWithoutExtension(pakPath), files, resourceTypes, compression, descriptor);
         File.WriteAllBytes(pakPath, data);
     }
 }
diff --git a/src/Shared/GalNet.Assets/Provider/LocalFileProvider.cs b/src/Shared/GalNet.Assets/Provider/LocalFileProvider.cs
index fa3754ce..442e866d 100644
--- a/src/Shared/GalNet.Assets/Provider/LocalFileProvider.cs
+++ b/src/Shared/GalNet.Assets/Provider/LocalFileProvider.cs
@@ -31,11 +31,11 @@ public sealed class LocalFileProvider : IAssetProvider, IDisposable
     /// </summary>
     /// <param name="assetsRoot">Assets 目录的绝对路径</param>
     /// <param name="optional">若目录不存在是否静默返回空归档</param>
-    public LocalFileProvider(string assetsRoot, IResourceTypeCatalog? resourceTypes = null, bool optional = false)
+    public LocalFileProvider(string assetsRoot, IResourceTypeCatalog resourceTypes, bool optional = false)
     {
         _assetsRoot = Path.TrimEndingDirectorySeparator(Path.GetFullPath(assetsRoot));
         _optional = optional;
-        _resourceTypes = resourceTypes ?? BuiltinResourceTypes.CreateCatalog();
+        _resourceTypes = resourceTypes ?? throw new ArgumentNullException(nameof(resourceTypes));
     }
 
     public string Name => $"LocalFile({_assetsRoot})";
@@ -130,9 +130,7 @@ public async Task<IArchive> OpenArchiveAsync(string archiveName, CancellationTok
 
     private Task<ScanResult> ScanAsync(int version) => Task.Run(() =>
     {
-        for (var ancestor = new DirectoryInfo(_assetsRoot); ancestor is not null; ancestor = ancestor.Parent)
-            if (ancestor.Exists && (ancestor.Attributes & FileAttributes.ReparsePoint) != 0)
-                throw new InvalidDataException("Assets root must not traverse a directory link.");
+        FileSystemPaths.RequireNoLinks(_assetsRoot, "Assets root must not traverse a directory link.");
         var files = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         var directories = new List<string>();
         var pending = new Stack<string>();
diff --git a/src/Shared/GalNet.Assets/Provider/PakFileProvider.cs b/src/Shared/GalNet.Assets/Provider/PakFileProvider.cs
index 35cbe212..14d0884c 100644
--- a/src/Shared/GalNet.Assets/Provider/PakFileProvider.cs
+++ b/src/Shared/GalNet.Assets/Provider/PakFileProvider.cs
@@ -12,16 +12,17 @@ public sealed class PakFileProvider : IAssetProvider
     private readonly string? _archiveName;
     private readonly bool _optional;
     private readonly IResourceTypeCatalog _resourceTypes;
+    private readonly string? _expectedSha256;
 
-    public PakFileProvider(string pakDirectory, IResourceTypeCatalog? resourceTypes = null, bool optional = false)
+    public PakFileProvider(string pakDirectory, IResourceTypeCatalog resourceTypes, bool optional = false)
     {
         _pakDirectory = pakDirectory.Replace('\\', '/').TrimEnd('/');
         _optional = optional;
-        _resourceTypes = resourceTypes ?? BuiltinResourceTypes.CreateCatalog();
+        _resourceTypes = resourceTypes ?? throw new ArgumentNullException(nameof(resourceTypes));
     }
 
     /// <summary>Maps one explicitly named archive to a PAK file, for example a patch PAK.</summary>
-    public PakFileProvider(string pakPath, string archiveName, IResourceTypeCatalog? resourceTypes = null, bool optional = false)
+    public PakFileProvider(string pakPath, string archiveName, IResourceTypeCatalog resourceTypes, bool optional = false, string? expectedSha256 = null)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(pakPath);
         ArgumentException.ThrowIfNullOrWhiteSpace(archiveName);
@@ -29,7 +30,8 @@ public PakFileProvider(string pakPath, string archiveName, IResourceTypeCatalog?
         _pakPath = Path.GetFullPath(pakPath);
         _archiveName = NormalizeArchiveName(archiveName);
         _optional = optional;
-        _resourceTypes = resourceTypes ?? BuiltinResourceTypes.CreateCatalog();
+        _resourceTypes = resourceTypes ?? throw new ArgumentNullException(nameof(resourceTypes));
+        _expectedSha256 = expectedSha256;
     }
 
     public string Name => $"PakFile({_pakPath ?? _pakDirectory})";
@@ -49,6 +51,7 @@ public IArchive OpenArchive(string archiveName)
         }
 
         var data = File.ReadAllBytes(path);
+        Verify(data);
         return Archive.Deserialize(archiveName, data, _resourceTypes);
     }
 
@@ -62,6 +65,7 @@ public async Task<IArchive> OpenArchiveAsync(string archiveName, CancellationTok
         }
 
         var data = await File.ReadAllBytesAsync(path, ct);
+        Verify(data);
         return Archive.Deserialize(archiveName, data, _resourceTypes);
     }
 
@@ -79,6 +83,12 @@ private bool TryGetPakPath(string archiveName, out string path)
         return true;
     }
 
+    private void Verify(byte[] bytes)
+    {
+        if (_expectedSha256 is not null && CryptoHelper.HashSHA256(bytes) != _expectedSha256)
+            throw new InvalidDataException("PAK content changed after the content session was prepared.");
+    }
+
     private static string NormalizeArchiveName(string archiveName) =>
         archiveName.EndsWith(".pak", StringComparison.OrdinalIgnoreCase) ? archiveName[..^4] : archiveName;
 
diff --git a/src/Shared/GalNet.Assets/Provider/PakStreamProvider.cs b/src/Shared/GalNet.Assets/Provider/PakStreamProvider.cs
new file mode 100644
index 00000000..ebf61500
--- /dev/null
+++ b/src/Shared/GalNet.Assets/Provider/PakStreamProvider.cs
@@ -0,0 +1,62 @@
+using GalNet.Core.Assets;
+
+namespace GalNet.Assets.Provider;
+
+/// <summary>Opens PAKs from a host-supplied manifest, including packaged, non-seekable resources.</summary>
+public sealed class PakStreamProvider : IAssetProvider
+{
+    private readonly Dictionary<string, Func<Stream>> _archives = new(StringComparer.OrdinalIgnoreCase);
+    private readonly IResourceTypeCatalog _resourceTypes;
+
+    /// <param name="archives">Each factory transfers a fresh readable stream to the provider on every call.</param>
+    /// <param name="resourceTypes">The same frozen catalog used to build the PAKs.</param>
+    public PakStreamProvider(IReadOnlyDictionary<string, Func<Stream>> archives, IResourceTypeCatalog resourceTypes)
+    {
+        ArgumentNullException.ThrowIfNull(archives);
+        _resourceTypes = resourceTypes ?? throw new ArgumentNullException(nameof(resourceTypes));
+        foreach (var (name, open) in archives)
+        {
+            ArgumentNullException.ThrowIfNull(open);
+            if (!_archives.TryAdd(NormalizeName(name), open))
+                throw new ArgumentException($"Duplicate PAK archive name '{name}'.", nameof(archives));
+        }
+    }
+
+    public string Name => "PakStream";
+
+    /// <summary>Checks the explicit manifest; does not open a stream or enumerate storage.</summary>
+    public bool Exists(string archiveName) => _archives.ContainsKey(NormalizeName(archiveName));
+
+    public IArchive OpenArchive(string archiveName)
+    {
+        using var stream = Open(archiveName);
+        using var data = new MemoryStream();
+        stream.CopyTo(data);
+        return Archive.Deserialize(archiveName, data.ToArray(), _resourceTypes);
+    }
+
+    public async Task<IArchive> OpenArchiveAsync(string archiveName, CancellationToken ct = default)
+    {
+        ct.ThrowIfCancellationRequested();
+        await using var stream = Open(archiveName);
+        using var data = new MemoryStream();
+        await stream.CopyToAsync(data, ct).ConfigureAwait(false);
+        ct.ThrowIfCancellationRequested();
+        return Archive.Deserialize(archiveName, data.ToArray(), _resourceTypes);
+    }
+
+    private Stream Open(string archiveName)
+    {
+        if (!_archives.TryGetValue(NormalizeName(archiveName), out var open))
+            throw new FileNotFoundException($"PAK archive '{archiveName}' is not in the resource manifest.");
+        return open() ?? throw new InvalidDataException($"PAK stream factory for '{archiveName}' returned null.");
+    }
+
+    private static string NormalizeName(string name)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(name);
+        var normalized = name.EndsWith(".pak", StringComparison.OrdinalIgnoreCase) ? name[..^4] : name;
+        ArgumentException.ThrowIfNullOrWhiteSpace(normalized);
+        return normalized;
+    }
+}
diff --git a/src/Shared/GalNet.Assets/Provider/ResourceOverlayProvider.cs b/src/Shared/GalNet.Assets/Provider/ResourceOverlayProvider.cs
new file mode 100644
index 00000000..c1710349
--- /dev/null
+++ b/src/Shared/GalNet.Assets/Provider/ResourceOverlayProvider.cs
@@ -0,0 +1,105 @@
+using GalNet.Core.Assets;
+
+namespace GalNet.Assets.Provider;
+
+public sealed record ResourceFileSource(IGameFile Index, IAssetProvider Provider);
+public sealed record ResourceOverrideSource(PakDescriptor Descriptor, string Sha256, IReadOnlyList<ResourceFileSource> Files);
+
+/// <summary>A frozen logical resource view. Mapped files retain the original ID/path; source PAKs remain explicit.</summary>
+public sealed class ResourceOverlayProvider : IAssetProvider
+{
+    private readonly Dictionary<string, IGameFile> _files;
+    public string Name => "ResourceOverlay";
+
+    public ResourceOverlayProvider(IReadOnlyList<ResourceFileSource> baseline, IReadOnlyList<ResourceOverrideSource> overrides,
+        IResourceTypeCatalog types)
+    {
+        var codec = new AssetMetaCodec(types);
+        var originals = baseline.GroupBy(item => item.Index.Id, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(group => group.Key, group => group.First(), StringComparer.OrdinalIgnoreCase);
+        _files = originals.ToDictionary(pair => pair.Key, pair => (IGameFile)new SourceFile(pair.Value), StringComparer.OrdinalIgnoreCase);
+        var selected = new Dictionary<string, (ResourceOverrideSource Pack, ResourceFileSource Target)>(StringComparer.OrdinalIgnoreCase);
+        foreach (var patch in overrides.DistinctBy(patch => patch.Sha256, StringComparer.Ordinal)
+                     .OrderByDescending(patch => patch.Descriptor.Priority).ThenByDescending(patch => patch.Sha256, StringComparer.Ordinal))
+        {
+            patch.Descriptor.Validate();
+            if (patch.Descriptor.Kind != "override") throw new InvalidDataException("Only override PAKs contribute resource mappings.");
+            var targets = patch.Files.ToDictionary(item => item.Index.Id, StringComparer.OrdinalIgnoreCase);
+            foreach (var (source, target) in patch.Descriptor.Mappings)
+            {
+                if (!targets.TryGetValue(target, out var replacement)) throw new InvalidDataException("Override mapping target is not carried by its PAK.");
+                if (!originals.TryGetValue(source, out var original)) continue; // An absent story remains absent.
+                ResourceOverrideBuilder.ValidateCompatibility(new SourceFile(original), new SourceFile(replacement));
+                selected.TryAdd(source, (patch, replacement));
+            }
+        }
+        foreach (var (source, selection) in selected)
+        {
+            var original = originals[source].Index;
+            var metadata = codec.Deserialize(codec.Serialize(selection.Target.Index.Metadata), selection.Target.Index.Path);
+            metadata.Id = original.Id;
+            metadata.Path = original.Path;
+            _files[source] = new SourceFile(selection.Target, original.Id, original.Path, metadata);
+        }
+        // Only active packages' carried dependencies are made addressable. Existing IDs never change implicitly.
+        foreach (var patch in selected.Values.Select(value => value.Pack).DistinctBy(patch => patch.Sha256))
+        {
+            foreach (var file in patch.Files)
+            {
+                if (file.Index.TypeId is "graph" or "group") throw new InvalidDataException("Overrides cannot carry story resources.");
+                if (file.Index.Metadata is not IAssetDependencies dependencies) continue;
+                foreach (var dependency in dependencies.GetDependencies().Direct)
+                {
+                    var carried = patch.Files.FirstOrDefault(item => StringComparer.OrdinalIgnoreCase.Equals(item.Index.Id, dependency.AssetId))
+                        ?? throw new InvalidDataException("Override dependency must be carried by the same PAK.");
+                    if (_files.TryGetValue(carried.Index.Id, out var existing))
+                    {
+                        // Explicit mappings are independent requests; baseline data must otherwise agree.
+                        var comparison = originals.TryGetValue(carried.Index.Id, out var original) ? original.Index : existing;
+                        if (comparison.Hash != carried.Index.Hash || comparison.Length != carried.Index.Length
+                            || codec.Serialize(comparison.Metadata) != codec.Serialize(carried.Index.Metadata))
+                            throw new InvalidDataException($"Carried dependency '{carried.Index.Id}' conflicts with another source. Assign the changed author resource a new ID.");
+                    }
+                    else _files.Add(carried.Index.Id, new SourceFile(carried));
+                }
+            }
+            foreach (var carried in patch.Files)
+                _files.TryAdd(carried.Index.Id, new SourceFile(carried));
+        }
+    }
+
+    public bool Exists(string archiveName) => archiveName is "assets" or "assets.pak";
+    public IArchive OpenArchive(string archiveName) => Exists(archiveName) ? new View(_files) : throw new FileNotFoundException(archiveName);
+    public Task<IArchive> OpenArchiveAsync(string archiveName, CancellationToken ct = default)
+    { ct.ThrowIfCancellationRequested(); return Task.FromResult(OpenArchive(archiveName)); }
+    private sealed class View(Dictionary<string, IGameFile> files) : IArchive
+    {
+        public string Name => "assets";
+        public IEnumerable<string> AssetIds => files.Keys;
+        public bool Contains(string id) => files.ContainsKey(id.Trim());
+        public IGameFile? GetAsset(string id) => files.GetValueOrDefault(id.Trim());
+        public IGameFile? GetAssetByPath(string path) => files.Values.FirstOrDefault(file => StringComparer.OrdinalIgnoreCase.Equals(file.Path, AssetPathHelper.Normalize(path)));
+        public void Dispose() { }
+    }
+    private sealed class SourceFile(ResourceFileSource source, string? id = null, string? path = null, AssetMeta? metadata = null) : IGameFile, IAssetOverrideFile
+    {
+        public bool IsResourceOverride => id is not null;
+        public string Id => id ?? source.Index.Id;
+        public string Path => path ?? source.Index.Path;
+        public string TypeId => source.Index.TypeId;
+        public AssetMeta Metadata => metadata ?? source.Index.Metadata;
+        public long Length => source.Index.Length;
+        public string? Hash => source.Index.Hash;
+        public Stream OpenRead() => new MemoryStream(ReadAllBytes(), writable: false);
+        public byte[] ReadAllBytes()
+        {
+            using var archive = source.Provider.OpenArchive("assets");
+            return (archive.GetAsset(source.Index.Id) ?? throw new InvalidDataException("Prepared resource disappeared.")).ReadAllBytes();
+        }
+        public async Task<byte[]> ReadAllBytesAsync(CancellationToken ct = default)
+        {
+            using var archive = await source.Provider.OpenArchiveAsync("assets", ct);
+            return await (archive.GetAsset(source.Index.Id) ?? throw new InvalidDataException("Prepared resource disappeared.")).ReadAllBytesAsync(ct);
+        }
+    }
+}
diff --git a/src/Shared/GalNet.Assets/ResourceOverrideBuilder.cs b/src/Shared/GalNet.Assets/ResourceOverrideBuilder.cs
new file mode 100644
index 00000000..4a60afa7
--- /dev/null
+++ b/src/Shared/GalNet.Assets/ResourceOverrideBuilder.cs
@@ -0,0 +1,50 @@
+using GalNet.Assets.Variants;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+
+namespace GalNet.Assets;
+
+public static class ResourceOverrideBuilder
+{
+    public static byte[] Build(string projectId, ResourceOverrideDefinition definition, IReadOnlyList<IGameFile> available,
+        IResourceTypeCatalog types, CancellationToken ct = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(projectId);
+        ArgumentNullException.ThrowIfNull(definition);
+        var control = new PakDescriptor
+        {
+            Kind = "override",
+            ProjectId = projectId,
+            PackageId = definition.Id,
+            Priority = definition.Priority,
+            Mappings = definition.Mappings.OrderBy(pair => pair.Key, StringComparer.Ordinal)
+                .ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.OrdinalIgnoreCase)
+        };
+        control.Validate();
+        if (control.Mappings.Count == 0) throw new InvalidDataException("A resource override must contain at least one mapping.");
+        var files = available.ToDictionary(file => file.Id, StringComparer.OrdinalIgnoreCase);
+        foreach (var (source, target) in control.Mappings)
+        {
+            if (!files.TryGetValue(source, out var original) || !files.TryGetValue(target, out var replacement))
+                throw new InvalidDataException($"Override '{source}' → '{target}' requires both author resources.");
+            ValidateCompatibility(original, replacement);
+        }
+        var closure = AssetDependencyCollector.Collect(available, control.Mappings.Values.Concat(definition.IncludeResources), types,
+            declaredComplete: definition.DeclaredCompleteResources, cancellationToken: ct);
+        if (!closure.Complete) throw new InvalidDataException("Override dependencies are incomplete: " + string.Join(", ", closure.IncompleteAssetIds));
+        if (closure.Files.Any(file => file.TypeId is "graph" or "group")) throw new InvalidDataException("Resource overrides cannot carry graph/group resources.");
+        return PakBuilder.Build("assets", closure.Files, types, descriptor: control);
+    }
+
+    public static void ValidateCompatibility(IGameFile original, IGameFile replacement)
+    {
+        if (original.TypeId is "graph" or "group" || replacement.TypeId != original.TypeId)
+            throw new InvalidDataException($"Resource override '{original.Id}' has an incompatible resource type.");
+        if (original.TypeId != "image-variants") return;
+        var before = ImageVariantsCodec.Decode(original.ReadAllBytes());
+        var after = ImageVariantsCodec.Decode(replacement.ReadAllBytes());
+        if (!before.Dimensions.Select(d => d.Key).SequenceEqual(after.Dimensions.Select(d => d.Key), StringComparer.Ordinal)
+            || before.Variants.Any(variant => !after.Variants.Any(target => target.Key == variant.Key)))
+            throw new InvalidDataException($"Replacement atlas '{replacement.Id}' must preserve dimension keys and original variant keys.");
+    }
+}
diff --git a/src/Shared/GalNet.Assets/Variants/ImageVariantsCatalogLoader.cs b/src/Shared/GalNet.Assets/Variants/ImageVariantsCatalogLoader.cs
index 59d917f7..7ccc1294 100644
--- a/src/Shared/GalNet.Assets/Variants/ImageVariantsCatalogLoader.cs
+++ b/src/Shared/GalNet.Assets/Variants/ImageVariantsCatalogLoader.cs
@@ -1,5 +1,5 @@
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
-using GalNet.Core.Variants;
 
 namespace GalNet.Assets.Variants;
 
@@ -22,6 +22,7 @@ public static async Task<ImageVariantsCatalog> LoadImageVariantsCatalogAsync(thi
             definitions.Add(file.Id, handle.Value);
         }
         ct.ThrowIfCancellationRequested();
-        return new ImageVariantsCatalog(definitions);
+        return new ImageVariantsCatalog(definitions, files.Where(file => file.TypeId == ImageVariantsCodec.ResourceType
+            && file is IAssetOverrideFile { IsResourceOverride: true }).Select(file => file.Id));
     }
 }
diff --git a/src/Shared/GalNet.Assets/Variants/ImageVariantsCodec.cs b/src/Shared/GalNet.Assets/Variants/ImageVariantsCodec.cs
index c13727d8..6aebe68b 100644
--- a/src/Shared/GalNet.Assets/Variants/ImageVariantsCodec.cs
+++ b/src/Shared/GalNet.Assets/Variants/ImageVariantsCodec.cs
@@ -1,7 +1,8 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
-using GalNet.Core.Variants;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Assets.Variants;
 
@@ -9,23 +10,23 @@ namespace GalNet.Assets.Variants;
 public static class ImageVariantsCodec
 {
     public const string ResourceType = "image-variants";
-    private static readonly JsonSerializerOptions Options = new(JsonSerializerDefaults.Web)
+    private static readonly JsonSerializerOptions Options = JsonMetadata.CreateOptions(new(JsonSerializerDefaults.Web)
     {
         UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow,
+        AllowDuplicateProperties = false,
         PropertyNameCaseInsensitive = false
-    };
+    }, AssetsJsonContext.Default);
 
     public static ImageVariantsSource ReadSource(ReadOnlyMemory<byte> data)
     {
-        RejectDuplicateProperties(data);
-        return JsonSerializer.Deserialize<ImageVariantsSource>(data.Span, Options)
+        return JsonCodec.Deserialize<ImageVariantsSource>(data.Span, Options)
             ?? throw new InvalidDataException("Image variants source must be an object.");
     }
 
     public static byte[] Encode(ImageVariantsDefinition definition)
     {
         ArgumentNullException.ThrowIfNull(definition);
-        return JsonSerializer.SerializeToUtf8Bytes(new Payload
+        return JsonCodec.SerializeToUtf8Bytes(new Payload
         {
             Kind = "image-variants",
             Version = 1,
@@ -37,12 +38,14 @@ public static byte[] Encode(ImageVariantsDefinition definition)
 
     public static ImageVariantsDefinition Decode(ReadOnlyMemory<byte> data)
     {
-        RejectDuplicateProperties(data);
-        var payload = JsonSerializer.Deserialize<Payload>(data.Span, Options);
+        var payload = JsonCodec.Deserialize<Payload>(data.Span, Options);
         if (payload is not { Kind: "image-variants", Version: 1, Dimensions: not null, Variants: not null })
             throw new InvalidDataException("Unsupported compiled image variants payload.");
         if (payload.Variants.Any(item => item is null || string.IsNullOrEmpty(item.Key)))
             throw new InvalidDataException("Compiled variants require exact keys.");
+        // Compiled payloads contain the full inferred structure; only author sources infer missing names.
+        if (payload.Dimensions.Count != payload.Variants.Select(item => item.Key.Split('_').Length).DefaultIfEmpty(0).Max())
+            throw new InvalidDataException("Compiled dimensions must match the variant positions.");
         var result = ImageVariantsBuilder.Build(new ImageVariantsSource
         {
             Folder = ".",
@@ -55,27 +58,7 @@ public static ImageVariantsDefinition Decode(ReadOnlyMemory<byte> data)
     internal static ImageVariantsDefinition RequireDefinition(ImageVariantsBuildResult result) => result.Definition
         ?? throw new InvalidDataException(string.Join("; ", result.Diagnostics.Select(item => $"{item.Path} [{item.Code}]: {item.Message}")));
 
-    private static void RejectDuplicateProperties(ReadOnlyMemory<byte> data)
-    {
-        using var document = JsonDocument.Parse(data);
-        Check(document.RootElement);
-        static void Check(JsonElement element)
-        {
-            if (element.ValueKind == JsonValueKind.Object)
-            {
-                var names = new HashSet<string>(StringComparer.Ordinal);
-                foreach (var property in element.EnumerateObject())
-                {
-                    if (!names.Add(property.Name)) throw new InvalidDataException($"Duplicate image variants property '{property.Name}'.");
-                    Check(property.Value);
-                }
-            }
-            else if (element.ValueKind == JsonValueKind.Array)
-                foreach (var item in element.EnumerateArray()) Check(item);
-        }
-    }
-
-    private sealed class Payload
+    internal sealed class Payload
     {
         public string Kind { get; set; } = "";
         public int Version { get; set; }
@@ -84,7 +67,7 @@ private sealed class Payload
         public List<Variant>? Variants { get; set; }
     }
 
-    private sealed class Variant
+    internal sealed class Variant
     {
         public string Key { get; set; } = "";
         public string AssetId { get; set; } = "";
diff --git a/src/Shared/GalNet.Assets/Variants/LocalAssetCompiler.cs b/src/Shared/GalNet.Assets/Variants/LocalAssetCompiler.cs
index ecfb49e1..e786a7ce 100644
--- a/src/Shared/GalNet.Assets/Variants/LocalAssetCompiler.cs
+++ b/src/Shared/GalNet.Assets/Variants/LocalAssetCompiler.cs
@@ -1,5 +1,5 @@
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
-using GalNet.Core.Variants;
 
 namespace GalNet.Assets.Variants;
 
@@ -54,7 +54,14 @@ public static async Task<IReadOnlyList<IGameFile>> CompileAsync(IReadOnlyDiction
                     facts.Add(new ImageVariantFile(path[(path.LastIndexOf('/') + 1)..], asset.Id, asset.TypeId));
                 }
                 var definition = ImageVariantsCodec.RequireDefinition(ImageVariantsBuilder.Build(source, facts));
-                assets[original.Path] = new GameFile(original.Id, original.Path, original.TypeId, original.Metadata, ImageVariantsCodec.Encode(definition));
+                var metadata = codec.Deserialize(codec.Serialize(original.Metadata));
+                if (metadata is not DependentAssetMeta dependent)
+                    throw new InvalidDataException("Image variants metadata must expose compiled dependencies.");
+                dependent.Dependencies = definition.Variants.Select(variant => variant.AssetId)
+                    .Distinct(StringComparer.OrdinalIgnoreCase).Order(StringComparer.Ordinal)
+                    .Select(id => new AssetDependency(id, "sprite")).ToList();
+                dependent.DependenciesComplete = true;
+                assets[original.Path] = new GameFile(original.Id, original.Path, original.TypeId, dependent, ImageVariantsCodec.Encode(definition));
             }
             catch (Exception exception) when (exception is IOException or InvalidDataException or UnauthorizedAccessException or ArgumentException or System.Text.Json.JsonException)
             {
diff --git a/src/Shared/GalNet.Assets/packages.lock.WindowsReadyToRun.json b/src/Shared/GalNet.Assets/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..9fb490d8
--- /dev/null
+++ b/src/Shared/GalNet.Assets/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,17 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Shared/GalNet.Assets/packages.lock.json b/src/Shared/GalNet.Assets/packages.lock.json
index e1926ffa..af322323 100644
--- a/src/Shared/GalNet.Assets/packages.lock.json
+++ b/src/Shared/GalNet.Assets/packages.lock.json
@@ -2,6 +2,12 @@
   "version": 2,
   "dependencies": {
     "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.core": {
         "type": "Project"
       }
diff --git a/src/Shared/GalNet.Contracts.Builtins/Assets/BuiltinResourceTypes.cs b/src/Shared/GalNet.Contracts.Builtins/Assets/BuiltinResourceTypes.cs
new file mode 100644
index 00000000..69d2b711
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Assets/BuiltinResourceTypes.cs
@@ -0,0 +1,20 @@
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Core.Assets;
+
+namespace GalNet.Contracts.Builtins.Assets;
+
+public static class BuiltinResourceTypes
+{
+    public static IResourceTypeCatalog CreateCatalog() => new ResourceTypeCatalogBuilder()
+        .Add<SpriteAssetMeta>("sprite", BuiltinJson.Resolver, ".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif", ".avif")
+        .Add<DependentAssetMeta>("image-variants", ".variants")
+        .Add<DependentAssetMeta>("graph", ".galgraph")
+        .Add<DependentAssetMeta>("group", ".galgroup")
+        .Add<AssetMeta>("audio", ".mp3", ".wav", ".ogg", ".flac")
+        .Add<AssetMeta>("video", ".mp4", ".webm", ".mkv")
+        .Add<AssetMeta>("font", ".ttf", ".otf", ".woff", ".woff2")
+        .Add<AssetMeta>("effect-program", ".sksl")
+        .Add<AssetMeta>("data")
+        .WithoutDependencies("sprite", "audio", "video", "font", "effect-program")
+        .DefaultType("data").Build();
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/Assets/SpriteAssetMeta.cs b/src/Shared/GalNet.Contracts.Builtins/Assets/SpriteAssetMeta.cs
new file mode 100644
index 00000000..ee577405
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Assets/SpriteAssetMeta.cs
@@ -0,0 +1,10 @@
+using GalNet.Core.Assets;
+
+namespace GalNet.Contracts.Builtins.Assets;
+
+public sealed class SpriteAssetMeta : AssetMeta
+{
+    [System.Text.Json.Serialization.JsonPropertyName("filter")]
+    [System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
+    public string? Filter { get; set; }
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/Audio/AudioConfiguration.cs b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioConfiguration.cs
new file mode 100644
index 00000000..b9dbe3c7
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioConfiguration.cs
@@ -0,0 +1,54 @@
+using System.Text.Json.Serialization;
+
+namespace GalNet.Contracts.Builtins.Audio;
+
+public sealed record AudioBusDefinition
+{
+    public AudioBusDefinition() { }
+
+    [JsonConstructor]
+    public AudioBusDefinition(string id, string name = "", float defaultGain = 1f)
+    {
+        Id = id; Name = name; DefaultGain = defaultGain;
+    }
+
+    public string Id { get; init; } = "";
+    public string Name { get; init; } = "";
+    public float DefaultGain { get; init; } = 1f;
+}
+
+/// <summary>Validated, owned audio declarations. Empty configurations and ungrouped tracks are valid.</summary>
+public sealed class AudioConfiguration
+{
+    public static AudioConfiguration Empty { get; } = new();
+    private readonly Dictionary<string, AudioTrackDefinition> _tracks;
+    public IReadOnlyList<AudioBusDefinition> Buses { get; }
+    public IReadOnlyList<AudioTrackDefinition> Tracks { get; }
+
+    public AudioConfiguration(IEnumerable<AudioTrackDefinition>? tracks = null, IEnumerable<AudioBusDefinition>? buses = null)
+    {
+        var groupArray = (buses ?? []).ToArray();
+        var busIds = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var group in groupArray)
+            if (group is null || string.IsNullOrWhiteSpace(group.Id) || !busIds.Add(group.Id) || !float.IsFinite(group.DefaultGain) || group.DefaultGain < 0)
+                throw new InvalidDataException("Audio groups require unique, nonempty IDs.");
+
+        var trackArray = (tracks ?? []).ToArray();
+        _tracks = new(StringComparer.Ordinal);
+        foreach (var track in trackArray)
+        {
+            if (track is null || string.IsNullOrWhiteSpace(track.Id) || !_tracks.TryAdd(track.Id, track))
+                throw new InvalidDataException("Audio tracks require unique, nonempty IDs.");
+            if (track.BusId is not null && !busIds.Contains(track.BusId))
+                throw new InvalidDataException($"Audio track '{track.Id}' references unknown bus '{track.BusId}'.");
+            if (!float.IsFinite(track.DefaultGain) || track.DefaultGain < 0 || track.MaxVoices < 1 || track.MaxQueuedItems < 0 ||
+                !Enum.IsDefined(track.OverflowPolicy) || !Enum.IsDefined(track.QueueOverflowPolicy) || !Enum.IsDefined(track.PlaybackOrder) || !Enum.IsDefined(track.Repeat))
+                throw new InvalidDataException($"Audio track '{track.Id}' has invalid gain, capacity, or overflow policy.");
+        }
+        Buses = Array.AsReadOnly(groupArray);
+        Tracks = Array.AsReadOnly(trackArray);
+    }
+
+    public bool TryGetTrack(string id, out AudioTrackDefinition track) => _tracks.TryGetValue(id, out track!);
+    public bool HasTarget(SEffectScope scope, string id) => scope == SEffectScope.Track ? _tracks.ContainsKey(id) : scope == SEffectScope.Bus && Buses.Any(bus => bus.Id == id);
+}
diff --git a/src/Shared/GalNet.Core/Audio/AudioContracts.cs b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioContracts.cs
similarity index 57%
rename from src/Shared/GalNet.Core/Audio/AudioContracts.cs
rename to src/Shared/GalNet.Contracts.Builtins/Audio/AudioContracts.cs
index bf229790..24b5e100 100644
--- a/src/Shared/GalNet.Core/Audio/AudioContracts.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioContracts.cs
@@ -1,6 +1,6 @@
 using System.Text.Json;
 
-namespace GalNet.Core.Audio;
+namespace GalNet.Contracts.Builtins.Audio;
 
 public enum AudioPlacement
 {
@@ -11,6 +11,12 @@ public enum AudioPlacement
     ReplaceIfDifferent
 }
 
+public enum AudioCompletion
+{
+    Discard,
+    RequeueTail
+}
+
 public enum AudioBackendAction
 {
     Start,
@@ -19,7 +25,11 @@ public enum AudioBackendAction
     Resume,
     SetGain,
     ApplySEffect,
-    StopSEffect
+    StopSEffect,
+    Configure,
+    SetMix,
+    ResetMixer,
+    SetLevel
 }
 
 public enum AudioBackendEventKind
@@ -32,12 +42,13 @@ public enum AudioBackendEventKind
 public sealed record AudioBackendCapabilities(
     bool SupportsConcurrentVoices = false,
     bool SupportsFade = false,
-    bool SupportsTrackSEffects = false)
+    bool SupportsTrackSEffects = false,
+    bool SupportsMixer = false)
 {
     public static AudioBackendCapabilities None { get; } = new();
 }
 
-/// <summary>A voice-level request. Queue ownership always remains in AudioRuntime.</summary>
+/// <summary>A voice or mixer command. TrackId identifies the scoped target for target-level actions; queue ownership remains in AudioRuntime.</summary>
 public sealed record AudioBackendRequest(
     AudioBackendAction Action,
     string TrackId,
@@ -48,7 +59,12 @@ public sealed record AudioBackendRequest(
     float FadeSeconds = 0f,
     string? SEffectId = null,
     string? SEffectInstanceId = null,
-    JsonElement? SEffectParameters = null);
+    JsonElement? SEffectParameters = null,
+    SEffectScope Scope = SEffectScope.Track,
+    AudioConfiguration? Configuration = null,
+    AudioMixOptions? Mix = null,
+    float FadeOutSeconds = 0,
+    bool Muted = false);
 
 public sealed record AudioBackendEvent(
     AudioBackendEventKind Kind,
@@ -62,12 +78,16 @@ public sealed record AudioPlayRequest(
     string AssetId,
     AudioPlacement Placement,
     float Gain = 1f,
-    float FadeInSeconds = 0f);
+    float FadeInSeconds = 0f,
+    int LoopCount = 1,
+    AudioCompletion Completion = AudioCompletion.Discard,
+    float FadeOutSeconds = 0f);
 
-public sealed record AudioStopRequest(string TrackId, bool ClearQueue, float FadeOutSeconds = 0f);
+public sealed record AudioStopRequest(string TrackId, bool ClearQueue, float? FadeOutSeconds = null);
 
 public sealed record AudioSEffectRequest(
-    string TrackId,
+    string TargetId,
     string InstanceId,
     string SEffectId,
-    JsonElement Parameters);
+    JsonElement Parameters,
+    SEffectScope Scope = SEffectScope.Track);
diff --git a/src/Shared/GalNet.Contracts.Builtins/Audio/AudioMixOptions.cs b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioMixOptions.cs
new file mode 100644
index 00000000..c023add1
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioMixOptions.cs
@@ -0,0 +1,40 @@
+using System.Collections.ObjectModel;
+
+namespace GalNet.Contracts.Builtins.Audio;
+
+public sealed record AudioMixLevel(float Gain = 1f, bool Muted = false);
+
+/// <summary>Host-projected mixer values. Audio never reads a player preference model.</summary>
+public sealed record AudioMixOptions
+{
+    public float MasterGain { get; init; } = 1f;
+    public bool MasterMuted { get; init; }
+    public IReadOnlyDictionary<string, AudioMixLevel> Buses { get; init; } = ReadOnlyDictionary<string, AudioMixLevel>.Empty;
+    public IReadOnlyDictionary<string, AudioMixLevel> Tracks { get; init; } = ReadOnlyDictionary<string, AudioMixLevel>.Empty;
+
+    public AudioMixOptions Snapshot()
+    {
+        ValidateGain(MasterGain);
+        return this with { Buses = CopyLevels(Buses), Tracks = CopyLevels(Tracks) };
+    }
+
+    private static IReadOnlyDictionary<string, AudioMixLevel> CopyLevels(IReadOnlyDictionary<string, AudioMixLevel> values)
+    {
+        ArgumentNullException.ThrowIfNull(values);
+        var groups = new Dictionary<string, AudioMixLevel>(StringComparer.Ordinal);
+        foreach (var (id, level) in values)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(id);
+            ArgumentNullException.ThrowIfNull(level);
+            ValidateGain(level.Gain);
+            groups.Add(id, level);
+        }
+        return new ReadOnlyDictionary<string, AudioMixLevel>(groups);
+    }
+
+    private static void ValidateGain(float gain)
+    {
+        if (!float.IsFinite(gain) || gain < 0 || gain > 1)
+            throw new ArgumentOutOfRangeException(nameof(gain), "Mixer gain must be finite and between zero and one.");
+    }
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/Audio/AudioState.cs b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioState.cs
new file mode 100644
index 00000000..c83c552c
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioState.cs
@@ -0,0 +1,33 @@
+using System.Text.Json;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Contracts.Builtins.Audio;
+
+/// <summary>Only logical playback data; backend IDs and tickets are deliberately separate.</summary>
+public sealed class AudioItemState
+{
+    public string Id { get; init; } = Guid.NewGuid().ToString("N");
+    public int CompletedIterations { get; set; }
+    public AudioPlayRequest Request { get; set; } = new("", "", AudioPlacement.Enqueue);
+}
+
+public sealed class AudioTrackState
+{
+    public string Id { get; init; } = "";
+    public bool Paused { get; set; }
+    public uint RandomState { get; set; } = 0x9e3779b9;
+    public List<AudioItemState> Active { get; init; } = [];
+    public List<AudioItemState> Pending { get; init; } = [];
+}
+
+public sealed record AudioSEffectState(string TargetId, string InstanceId, string SEffectId, JsonElement Parameters, SEffectScope Scope = SEffectScope.Track)
+{
+    // JSON array encoding preserves the existing track-local identity without separator collisions.
+    public static string Key(string trackId, string instanceId) => JsonCodec.Serialize(new[] { trackId, instanceId });
+    public string Key() => Scope == SEffectScope.Track ? Key(TargetId, InstanceId) : JsonCodec.Serialize(new[] { "bus", TargetId, InstanceId });
+}
+
+public sealed record AudioChannelState(string TargetId, SEffectScope Scope, float Gain = 1, bool Muted = false)
+{
+    public string Key() => JsonCodec.Serialize(new[] { Scope.ToString(), TargetId });
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/Audio/AudioTrackDefinition.cs b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioTrackDefinition.cs
new file mode 100644
index 00000000..b1b48635
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Audio/AudioTrackDefinition.cs
@@ -0,0 +1,50 @@
+using System.Text.Json.Serialization;
+
+namespace GalNet.Contracts.Builtins.Audio;
+
+public enum AudioOverflowPolicy
+{
+    DropNewest,
+    StopOldest
+}
+
+public enum AudioQueueOverflowPolicy
+{
+    DropNewest,
+    DropOldest
+}
+
+public enum AudioPlaybackOrder { Sequential, Random }
+public enum AudioTrackRepeat { None, One, All }
+
+/// <summary>Author-configured logical route, independent from backend players.</summary>
+public sealed record AudioTrackDefinition
+{
+    public AudioTrackDefinition() { }
+
+    // Source-generated JSON binds init-only members through constructor metadata.
+    // Explicit optional defaults prevent omitted fields from replacing CLR initializers with zero.
+    [JsonConstructor]
+    public AudioTrackDefinition(string id, string name = "", string? busId = null,
+        AudioPlaybackOrder playbackOrder = AudioPlaybackOrder.Sequential, AudioTrackRepeat repeat = AudioTrackRepeat.None,
+        bool preserveDuringCatchUp = false, float defaultGain = 1f, int maxVoices = 1, int maxQueuedItems = 0,
+        AudioOverflowPolicy overflowPolicy = AudioOverflowPolicy.DropNewest,
+        AudioQueueOverflowPolicy queueOverflowPolicy = AudioQueueOverflowPolicy.DropNewest)
+    {
+        Id = id; Name = name; BusId = busId; PlaybackOrder = playbackOrder; Repeat = repeat;
+        PreserveDuringCatchUp = preserveDuringCatchUp; DefaultGain = defaultGain; MaxVoices = maxVoices;
+        MaxQueuedItems = maxQueuedItems; OverflowPolicy = overflowPolicy; QueueOverflowPolicy = queueOverflowPolicy;
+    }
+
+    public string Id { get; init; } = "";
+    public string Name { get; init; } = "";
+    public string? BusId { get; init; }
+    public AudioPlaybackOrder PlaybackOrder { get; init; }
+    public AudioTrackRepeat Repeat { get; init; }
+    public bool PreserveDuringCatchUp { get; init; }
+    public float DefaultGain { get; init; } = 1f;
+    public int MaxVoices { get; init; } = 1;
+    public int MaxQueuedItems { get; init; }
+    public AudioOverflowPolicy OverflowPolicy { get; init; } = AudioOverflowPolicy.DropNewest;
+    public AudioQueueOverflowPolicy QueueOverflowPolicy { get; init; } = AudioQueueOverflowPolicy.DropNewest;
+}
diff --git a/src/Shared/GalNet.Presentation.Abstractions/Audio/IAudioPlaybackHost.cs b/src/Shared/GalNet.Contracts.Builtins/Audio/IAudioPlaybackHost.cs
similarity index 62%
rename from src/Shared/GalNet.Presentation.Abstractions/Audio/IAudioPlaybackHost.cs
rename to src/Shared/GalNet.Contracts.Builtins/Audio/IAudioPlaybackHost.cs
index 549ac082..5408e774 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/Audio/IAudioPlaybackHost.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Audio/IAudioPlaybackHost.cs
@@ -1,8 +1,6 @@
-using GalNet.Core.Audio;
+namespace GalNet.Contracts.Builtins.Audio;
 
-namespace GalNet.Presentation.Abstractions.Audio;
-
-/// <summary>Platform playback boundary. Hosts execute voice commands but never own queues.</summary>
+/// <summary>Playback and target-mixer boundary. Hosts execute voice/graph commands but never own queues.</summary>
 public interface IAudioPlaybackHost : IDisposable
 {
     AudioBackendCapabilities Capabilities { get; }
diff --git a/src/Shared/GalNet.Contracts.Builtins/Audio/SEffectCatalog.cs b/src/Shared/GalNet.Contracts.Builtins/Audio/SEffectCatalog.cs
new file mode 100644
index 00000000..c68a53f3
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Audio/SEffectCatalog.cs
@@ -0,0 +1,74 @@
+using System.Collections.Frozen;
+using System.Text.Json;
+using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Contracts.Builtins.Audio;
+
+/// <summary>The attachment targets supported by an audio effect descriptor.</summary>
+public enum SEffectScope { Track, Bus }
+
+/// <summary>Metadata for one numeric parameter accepted by a sound effect.</summary>
+public sealed record SEffectParameterDefinition(
+    string Name,
+    bool Required = false,
+    float? Minimum = null,
+    float? Maximum = null,
+    float? DefaultValue = null)
+{
+    public FieldDescriptor Field => new(Name, ParameterValidation.Field(Name, typeof(float), Required, Minimum, Maximum).Value,
+        Required, defaultValue: DefaultValue is { } value ? JsonCodec.SerializeToElement(value) : null);
+}
+
+/// <summary>Platform-neutral authoring metadata for one named audio effect.</summary>
+public sealed record SEffectDefinition(
+    string Id,
+    IReadOnlySet<SEffectScope> SupportedScopes,
+    IReadOnlyList<SEffectParameterDefinition> Parameters)
+{
+    public JsonElement DefaultParameters => JsonCodec.SerializeToElement(Parameters.Where(parameter => parameter.DefaultValue is not null)
+        .ToDictionary(parameter => parameter.Name, parameter => parameter.DefaultValue!.Value));
+}
+
+public interface ISEffectCatalog
+{
+    IReadOnlyList<SEffectDefinition> Definitions { get; }
+    bool TryGet(string id, out SEffectDefinition definition);
+    IReadOnlyList<string> Validate(string id, SEffectScope scope, JsonElement parameters);
+}
+
+/// <summary>Immutable effect metadata registry supplied by the active playback host.</summary>
+public sealed class SEffectCatalog : ISEffectCatalog
+{
+    private readonly IReadOnlyDictionary<string, SEffectDefinition> _byId;
+    private readonly Dictionary<string, IReadOnlyDictionary<string, FieldDescriptor>> _fields;
+
+    public SEffectCatalog(IEnumerable<SEffectDefinition> definitions)
+    {
+        _byId = definitions.Select(definition => definition with
+        { SupportedScopes = definition.SupportedScopes.ToFrozenSet(), Parameters = Array.AsReadOnly(definition.Parameters.ToArray()) })
+            .ToDictionary(definition => definition.Id, StringComparer.OrdinalIgnoreCase);
+        _fields = _byId.Values.ToDictionary(definition => definition.Id,
+            definition => (IReadOnlyDictionary<string, FieldDescriptor>)definition.Parameters.ToDictionary(parameter => parameter.Name,
+                parameter => parameter.Field, StringComparer.Ordinal),
+            StringComparer.OrdinalIgnoreCase);
+        Definitions = _byId.Values.OrderBy(definition => definition.Id, StringComparer.OrdinalIgnoreCase).ToArray();
+    }
+
+    public static SEffectCatalog Empty { get; } = new([]);
+    public static SEffectCatalog Builtins { get; } = new([
+        new("seffect.gain", Scopes(), [new("gain", Required: true, Minimum: 0, Maximum: 1, DefaultValue: SEffectDefaults.Gain)]),
+        new("seffect.lowPass", Scopes(), [new("cutoffHz", Required: true, Minimum: 20, Maximum: 20_000, DefaultValue: SEffectDefaults.LowPassCutoff), new("q", Minimum: .1f, Maximum: 10, DefaultValue: SEffectDefaults.Q)]),
+        new("seffect.highPass", Scopes(), [new("cutoffHz", Required: true, Minimum: 20, Maximum: 20_000, DefaultValue: SEffectDefaults.HighPassCutoff), new("q", Minimum: .1f, Maximum: 10, DefaultValue: SEffectDefaults.Q)]),
+        new("seffect.reverb", Scopes(), [new("roomSize", Minimum: 0, Maximum: 1, DefaultValue: SEffectDefaults.RoomSize), new("decaySeconds", Minimum: .1f, Maximum: 20, DefaultValue: SEffectDefaults.DecaySeconds), new("damping", Minimum: 0, Maximum: 1, DefaultValue: SEffectDefaults.Damping), new("mix", Minimum: 0, Maximum: 1, DefaultValue: SEffectDefaults.Mix)])]);
+    private static HashSet<SEffectScope> Scopes() => [SEffectScope.Track, SEffectScope.Bus];
+    public IReadOnlyList<SEffectDefinition> Definitions { get; }
+    public bool TryGet(string id, out SEffectDefinition definition) => _byId.TryGetValue(id, out definition!);
+
+    public IReadOnlyList<string> Validate(string id, SEffectScope scope, JsonElement parameters)
+    {
+        if (!TryGet(id, out var definition)) return [$"Unsupported SEffect '{id}'."];
+        if (!definition.SupportedScopes.Contains(scope)) return [$"SEffect '{id}' does not support {scope} scope."];
+        return ParameterValidation.Validate("SEffect", id, parameters, _fields[definition.Id]);
+    }
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/Audio/SEffectParameters.cs b/src/Shared/GalNet.Contracts.Builtins/Audio/SEffectParameters.cs
new file mode 100644
index 00000000..9346872a
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Audio/SEffectParameters.cs
@@ -0,0 +1,30 @@
+using System.Text.Json;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Contracts.Builtins.Audio;
+
+public static class SEffectParameters
+{
+    /// <summary>Numeric effect patches replace explicit fields and preserve all other values.</summary>
+    public static JsonElement Merge(JsonElement current, JsonElement patch)
+    {
+        if (current.ValueKind != JsonValueKind.Object || patch.ValueKind != JsonValueKind.Object)
+            throw new InvalidDataException("Audio effect parameters must be an object.");
+        var values = new Dictionary<string, JsonElement>(StringComparer.Ordinal);
+        foreach (var item in current.EnumerateObject())
+            if (!values.TryAdd(item.Name, item.Value)) throw new InvalidDataException("Duplicate audio effect parameter.");
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var item in patch.EnumerateObject())
+        {
+            if (!seen.Add(item.Name)) throw new InvalidDataException("Duplicate audio effect parameter.");
+            values[item.Name] = item.Value;
+        }
+        return JsonCodec.SerializeToElement(values);
+    }
+}
+
+public static class SEffectDefaults
+{
+    public const float LowPassCutoff = 20_000, HighPassCutoff = 20, Q = .7071068f, Gain = 1;
+    public const float RoomSize = .5f, DecaySeconds = 1.5f, Damping = .4f, Mix = .25f;
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/BuiltinArgumentValidation.cs b/src/Shared/GalNet.Contracts.Builtins/BuiltinArgumentValidation.cs
index b199583a..819f3d46 100644
--- a/src/Shared/GalNet.Contracts.Builtins/BuiltinArgumentValidation.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/BuiltinArgumentValidation.cs
@@ -1,26 +1,31 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
-using GalNet.Core.Scene;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Contracts.Builtins;
 
 /// <summary>Portable semantic checks shared by compilation and every implementation of built-in contracts.</summary>
 internal static class BuiltinArgumentValidation
 {
-    private static readonly JsonSerializerOptions JsonOptions = new()
+    private static readonly JsonSerializerOptions JsonOptions = BuiltinJson.CreateOptions(new()
     {
         PropertyNameCaseInsensitive = true,
-        Converters = { new JsonStringEnumConverter() }
-    };
+    }, stringEnums: true);
 
     public static void Validate(string type, JsonElement arguments)
     {
         switch (type)
         {
+            case BuiltinEntryIds.StopAudioSEffect:
+                if (arguments.TryGetProperty("all", out var all) && all.ValueKind == JsonValueKind.True &&
+                    arguments.TryGetProperty("instanceId", out var instance) && instance.ValueKind == JsonValueKind.String && !string.IsNullOrEmpty(instance.GetString()))
+                    throw new ArgumentException("Stopping all audio effects cannot specify an instance.");
+                break;
             case BuiltinEntryIds.PlayVideo:
                 RequireText(type, arguments, "asset", "handleId");
-                var points = arguments.GetProperty("skipPoints").Deserialize<double[]>(JsonOptions)
+                var points = JsonCodec.Deserialize<double[]>(arguments.GetProperty("skipPoints"), JsonOptions)
                     ?? throw new InvalidDataException("video.play skipPoints must be an array.");
                 if (points.Any(point => !double.IsFinite(point) || point < 0) ||
                     points.Zip(points.Skip(1), (left, right) => right > left).Any(valid => !valid))
@@ -29,7 +34,7 @@ public static void Validate(string type, JsonElement arguments)
             case BuiltinEntryIds.PlayTimeline:
                 if (!arguments.TryGetProperty("timeline", out var value) || value.ValueKind != JsonValueKind.Object)
                     throw new InvalidDataException("timeline.play requires a timeline object.");
-                ValidateTimeline(value.Deserialize<TimelineDefinition>(JsonOptions)!);
+                ValidateTimeline(JsonCodec.Deserialize<TimelineDefinition>(value, JsonOptions)!);
                 break;
             case BuiltinEntryIds.PlayParticleEmitter:
             case BuiltinEntryIds.BurstParticles:
@@ -78,8 +83,12 @@ internal static void ValidateTimelineStructure(TimelineDefinition timeline)
         }
         foreach (var item in timeline.Events)
         {
-            if (item is null || item.Parameters is null || item.Frame < 0 || item.Frame > timeline.DurationFrames)
+            if (item is null || item.Parameters is null || item.Frame < 0 || item.Frame > timeline.DurationFrames || !Enum.IsDefined(item.Execution))
                 throw new InvalidDataException("Animation events must be inside the timeline duration.");
+            if (item.Execution == TimelineEventExecution.Once && item.Frame != 0 ||
+                item.Execution == TimelineEventExecution.OnCompletion && (item.Frame != timeline.DurationFrames ||
+                    item.Type is not (BuiltinEntryIds.HideLayer or BuiltinEntryIds.StopEffect or BuiltinEntryIds.StopParticleEmitter)))
+                throw new InvalidDataException("Playback setup must be at frame zero; completion events must be terminal cleanup operations.");
         }
     }
 }
diff --git a/src/Shared/GalNet.Contracts.Builtins/BuiltinAudioDefaults.cs b/src/Shared/GalNet.Contracts.Builtins/BuiltinAudioDefaults.cs
new file mode 100644
index 00000000..d8230eaf
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/BuiltinAudioDefaults.cs
@@ -0,0 +1,19 @@
+using GalNet.Contracts.Builtins.Audio;
+
+namespace GalNet.Contracts.Builtins;
+
+/// <summary>Optional three-group example selected explicitly by default project templates and samples.</summary>
+public static class BuiltinAudioDefaults
+{
+    public static AudioConfiguration Create() => new(
+    [
+        new() { Id = "bgm", Name = "Settings.BgmVolume", BusId = "bgm", PreserveDuringCatchUp = true, DefaultGain = .8f, MaxVoices = 1, MaxQueuedItems = 64, OverflowPolicy = AudioOverflowPolicy.StopOldest },
+        new() { Id = "sfx", Name = "Settings.SfxVolume", BusId = "sfx", MaxVoices = 8 },
+        new() { Id = "vocal", Name = "Settings.VoiceVolume", BusId = "vocal", MaxVoices = 1, MaxQueuedItems = 64, OverflowPolicy = AudioOverflowPolicy.StopOldest }
+    ],
+    [
+        new() { Id = "bgm", Name = "Settings.BgmVolume" },
+        new() { Id = "sfx", Name = "Settings.SfxVolume" },
+        new() { Id = "vocal", Name = "Settings.VoiceVolume" }
+    ]);
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/BuiltinEntryIds.cs b/src/Shared/GalNet.Contracts.Builtins/BuiltinEntryIds.cs
index 2bb29913..d67ccf19 100644
--- a/src/Shared/GalNet.Contracts.Builtins/BuiltinEntryIds.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/BuiltinEntryIds.cs
@@ -3,6 +3,7 @@ namespace GalNet.Contracts.Builtins;
 /// <summary>Stable wire identities for the explicitly registered built-in entries.</summary>
 public static class BuiltinEntryIds
 {
+    public const string UpdateAudioSEffect = "audio.seffect.update";
     public const string Animate = "animation.animate";
     public const string PlayTimeline = "timeline.play";
     public const string StopAnimation = "animation.stop";
@@ -30,6 +31,7 @@ public static class BuiltinEntryIds
     public const string ClearAudio = "audio.clear";
     public const string EnqueueAudio = "audio.enqueue";
     public const string ApplyAudioSEffect = "audio.seffect.apply";
+    public const string SetAudioLevel = "audio.mix.set";
     public const string StopAudioSEffect = "audio.seffect.stop";
     public const string PlayVideo = "video.play";
     public const string StopVideo = "video.stop";
@@ -46,6 +48,12 @@ public static class BuiltinEntryIds
     public const string BlackFadeTransition = "transition.fadeBlack";
     public const string WhiteFadeTransition = "transition.fadeWhite";
     public const string ColorFadeTransition = "transition.fadeColor";
+    public const string RevealTransition = "transition.reveal";
+    public const string BlurTransition = "transition.blur";
+    public const string MotionPreset = "preset.motion";
+    public const string ShakePreset = "preset.shake";
+    public const string SpeedLinesPreset = "preset.speedLines";
+    public const string ImpactPreset = "preset.impact";
     public const string TextVoice = "dialogue.textVoice";
     public const string AppendVoiceNvl = "nvl.appendVoice";
 }
diff --git a/src/Shared/GalNet.Contracts.Builtins/BuiltinJsonContext.cs b/src/Shared/GalNet.Contracts.Builtins/BuiltinJsonContext.cs
new file mode 100644
index 00000000..51145347
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/BuiltinJsonContext.cs
@@ -0,0 +1,79 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+using GalNet.Core.Parameters;
+using GalNet.Core.Runtime;
+using GalNet.Core.Serialization;
+
+[assembly: FieldSchemaJsonContext(typeof(GalNet.Contracts.Builtins.BuiltinJsonContext))]
+
+namespace GalNet.Contracts.Builtins;
+
+[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata, UseStringEnumConverter = true)]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.AnimationOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.AnimationStopOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Assets.SpriteAssetMeta))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Audio.AudioChannelState[]))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Audio.AudioSEffectState[]))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Audio.AudioTrackState[]))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.AudioLevelOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.AudioPlayOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.AudioSEffectOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.AudioSEffectStopOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.AudioSEffectUpdateOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.AudioStopOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.AudioTrackOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.BlindsOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.BlurTransitionOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.ColorFadeOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.ColorFieldOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.CrossFadeOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.CustomInvokeOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.DefaultProjectOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.DialogueTextOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.EffectApplyOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Gallery.GalleryAnnotation[]))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Gallery.GalleryConfiguration))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.GalleryUnlockOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.ImpactPresetOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.InstanceIdOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.LayerColorOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.LayerHandleOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.LayerMoveOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.LayerReplaceOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.LayerShowOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.MotionPresetOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.NvlAppendOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.NvlVoiceOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.ParticleBurstOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.ParticlePlayOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.RevealTransitionOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Scene.EffectInstance[]))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Scene.Layer[]))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Scene.LoopAnimationState[]))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Scene.ParticleEmitterInstance[]))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Scene.TimelineDefinition))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.ShakePresetOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.SlideOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.SpeedLinesPresetOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.TextVoiceOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.TimelineOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.VariableSetOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.Variants.ImageVariantsSource))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.VariantsSelectOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.VariantsShowOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.VideoPlayOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.VideoStopOptions))]
+[JsonSerializable(typeof(global::GalNet.Contracts.Builtins.WaitOptions))]
+[JsonSerializable(typeof(global::System.Collections.Generic.Dictionary<string, string>))]
+[JsonSerializable(typeof(global::System.Collections.Generic.List<GalNet.Core.I18n.I18nLocale>))]
+internal sealed partial class BuiltinJsonContext : JsonSerializerContext;
+
+public static class BuiltinJson
+{
+    private static readonly JsonSerializerOptions StateOptions = CreateOptions(GameState.JsonOptions);
+    public static IJsonTypeInfoResolver Resolver => BuiltinJsonContext.Default;
+    public static JsonSerializerOptions CreateOptions(JsonSerializerOptions? template = null, bool stringEnums = false) =>
+        JsonMetadata.CreateOptions(template, Resolver, stringEnums);
+    public static JsonTypeInfo<T[]> StateTypeInfo<T>() => JsonMetadata.GetTypeInfo<T[]>(StateOptions);
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/BuiltinSchemas.cs b/src/Shared/GalNet.Contracts.Builtins/BuiltinSchemas.cs
index cddb70b0..ad1e8e57 100644
--- a/src/Shared/GalNet.Contracts.Builtins/BuiltinSchemas.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/BuiltinSchemas.cs
@@ -57,6 +57,12 @@ public static IReadOnlyList<IEntryModule> CreateAllModules() => Array.AsReadOnly
         DefaultPrimitiveEntryBase.ForDto<AnimationOptions>(BuiltinEntryIds.Animate),
         DefaultPrimitiveEntryBase.ForDto<TimelineOptions>(BuiltinEntryIds.PlayTimeline, arguments => BuiltinArgumentValidation.Validate(BuiltinEntryIds.PlayTimeline, arguments), validatePartialArguments: static _ => { }),
         DefaultPrimitiveEntryBase.ForDto<AnimationStopOptions>(BuiltinEntryIds.StopAnimation)
+    ], compositeEntries:
+    [
+        DefaultCompositeEntryBase.ForDto<MotionPresetOptions>(BuiltinEntryIds.MotionPreset, VisualPresetCompiler.Motion, category: "Preset"),
+        DefaultCompositeEntryBase.ForDto<ShakePresetOptions>(BuiltinEntryIds.ShakePreset, VisualPresetCompiler.Shake, category: "Preset"),
+        DefaultCompositeEntryBase.ForDto<SpeedLinesPresetOptions>(BuiltinEntryIds.SpeedLinesPreset, VisualPresetCompiler.SpeedLines, category: "Preset"),
+        DefaultCompositeEntryBase.ForDto<ImpactPresetOptions>(BuiltinEntryIds.ImpactPreset, VisualPresetCompiler.Impact, category: "Preset")
     ]);
 
     public static IEntryModule CreateAudioModule() => new DefaultEntryModule("audio",
@@ -69,7 +75,9 @@ public static IReadOnlyList<IEntryModule> CreateAllModules() => Array.AsReadOnly
         DefaultPrimitiveEntryBase.ForDto<AudioTrackOptions>(BuiltinEntryIds.ClearAudio),
         DefaultPrimitiveEntryBase.ForDto<AudioPlayOptions>(BuiltinEntryIds.EnqueueAudio),
         DefaultPrimitiveEntryBase.ForDto<AudioSEffectOptions>(BuiltinEntryIds.ApplyAudioSEffect),
-        DefaultPrimitiveEntryBase.ForDto<AudioSEffectStopOptions>(BuiltinEntryIds.StopAudioSEffect)
+        DefaultPrimitiveEntryBase.ForDto<AudioSEffectUpdateOptions>(BuiltinEntryIds.UpdateAudioSEffect),
+        DefaultPrimitiveEntryBase.ForDto<AudioLevelOptions>(BuiltinEntryIds.SetAudioLevel),
+        DefaultPrimitiveEntryBase.ForDto<AudioSEffectStopOptions>(BuiltinEntryIds.StopAudioSEffect, arguments => BuiltinArgumentValidation.Validate(BuiltinEntryIds.StopAudioSEffect, arguments))
     ]);
 
     public static IEntryModule CreateVideoModule() => new DefaultEntryModule("video",
diff --git a/src/Shared/GalNet.Contracts.Builtins/DefaultProjectConfiguration.cs b/src/Shared/GalNet.Contracts.Builtins/DefaultProjectConfiguration.cs
new file mode 100644
index 00000000..8d4b1aae
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/DefaultProjectConfiguration.cs
@@ -0,0 +1,38 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Configuration;
+using GalNet.Core.I18n;
+using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Contracts.Builtins;
+
+/// <summary>Optional default host authoring model, selected by templates and sample composition.</summary>
+public static class DefaultProjectConfiguration
+{
+    private static readonly JsonSerializerOptions JsonOptions = BuiltinJson.CreateOptions(new(JsonSerializerDefaults.Web)
+    { PropertyNameCaseInsensitive = false }, stringEnums: true);
+    public static ConfigurationSection<DefaultProjectOptions> Section { get; } = new("galnet.project",
+    [
+        Field("targetLocale", typeof(I18nLocale)), Field("availableLocales", typeof(List<I18nLocale>)),
+        Field("defaultWidth", typeof(int), minimum: 1), Field("defaultHeight", typeof(int), minimum: 1),
+        Field("saveSlotCount", typeof(int), minimum: 0),
+        Field("audioBuses", typeof(List<AudioBusDefinition>)), Field("audioTracks", typeof(List<AudioTrackDefinition>)),
+        Field("defaultVisualPrograms", typeof(Dictionary<string, string>))
+    ], value => _ = new AudioConfiguration(value.AudioTracks, value.AudioBuses), version: 2, jsonResolver: BuiltinJson.Resolver);
+    public static ProjectConfigurationSchema Schema { get; } = new([Section, ContentPackagingOptions.Section, ResourceOverrideOptions.Section]);
+
+    public static DefaultProjectOptions ReadDefaultOptions(this ProjectConfiguration configuration) => configuration.Read(Section);
+    public static ProjectConfiguration ToConfiguration(this DefaultProjectOptions value)
+    {
+        var configuration = new ProjectConfiguration();
+        configuration.Set(Section, value);
+        return configuration;
+    }
+
+    private static FieldDescriptor Field(string id, Type type, int? minimum = null) => new(id,
+        new ValueDescriptor(type, allowNull: false,
+            constraints: minimum is { } bound ? JsonCodec.SerializeToElement(new Dictionary<string, int> { ["minimum"] = bound }) : null,
+            jsonOptions: JsonOptions), editor: new EditorHints(EditorId: type == typeof(int) ? ValueEditorIds.Numeric : ValueEditorIds.Json));
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/DefaultProjectOptions.cs b/src/Shared/GalNet.Contracts.Builtins/DefaultProjectOptions.cs
new file mode 100644
index 00000000..31455d14
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/DefaultProjectOptions.cs
@@ -0,0 +1,22 @@
+using GalNet.Core.I18n;
+
+namespace GalNet.Contracts.Builtins;
+
+public sealed class DefaultProjectOptions
+{
+    public I18nLocale TargetLocale { get; set; } = I18nLocale.ZhCn;
+
+    public List<I18nLocale> AvailableLocales { get; set; } = [I18nLocale.ZhCn];
+
+    public int SaveSlotCount { get; set; } = 60;
+
+    public List<GalNet.Contracts.Builtins.Audio.AudioBusDefinition> AudioBuses { get; set; } = [];
+    public List<GalNet.Contracts.Builtins.Audio.AudioTrackDefinition> AudioTracks { get; set; } = [];
+
+    /// <summary>Authoring defaults only. Saved entries retain their explicit program resource IDs.</summary>
+    public Dictionary<string, string> DefaultVisualPrograms { get; set; } = new(StringComparer.Ordinal);
+
+    public int DefaultWidth { get; set; } = 1920;
+
+    public int DefaultHeight { get; set; } = 1080;
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/BuiltinTransitionEntries.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/BuiltinTransitionEntries.cs
index c24c2c4b..c16e602e 100644
--- a/src/Shared/GalNet.Contracts.Builtins/Entry/BuiltinTransitionEntries.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/BuiltinTransitionEntries.cs
@@ -6,6 +6,8 @@ internal static class BuiltinTransitionEntries
 {
     public static IReadOnlyList<CompositeEntryBase> Definitions { get; } =
     [
+        DefaultCompositeEntryBase.ForDto<RevealTransitionOptions>(BuiltinEntryIds.RevealTransition, VisualPresetCompiler.Reveal, category: "Transition"),
+        DefaultCompositeEntryBase.ForDto<BlurTransitionOptions>(BuiltinEntryIds.BlurTransition, VisualPresetCompiler.Blur, category: "Transition"),
         DefaultCompositeEntryBase.ForDto<CrossFadeOptions>(BuiltinEntryIds.CrossFadeTransition, CrossFadeTransition.Compile, category: "Transition"),
         DefaultCompositeEntryBase.ForDto<SlideOptions>(BuiltinEntryIds.SlideTransition, SlideTransition.Compile, category: "Transition"),
         DefaultCompositeEntryBase.ForDto<BlindsOptions>(BuiltinEntryIds.BlindsTransition, BlindsTransition.Compile, category: "Transition"),
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/ComplexPrimitiveOptions.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/ComplexPrimitiveOptions.cs
index 98445f68..929550cc 100644
--- a/src/Shared/GalNet.Contracts.Builtins/Entry/ComplexPrimitiveOptions.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/ComplexPrimitiveOptions.cs
@@ -1,8 +1,8 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
-using GalNet.Core.Audio;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Parameters;
-using GalNet.Core.Scene;
 
 namespace GalNet.Contracts.Builtins;
 
@@ -10,9 +10,9 @@ namespace GalNet.Contracts.Builtins;
 public partial class LayerShowOptions
 {
     [Common, Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? HandleId { get; set; }
-    [Common, Field(1, AllowNull = true, EditorId = "entry.imageasset")] public string? AssetId { get; set; }
-    [Field(2, EditorId = ValueEditorIds.Json)] public JsonElement Flipbook { get; set; }
-    [Field(3, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Transform { get; set; }
+    [Common, Field(1, AllowNull = true, EditorId = "entry.imageasset", ResourceTypeId = "sprite")] public string? AssetId { get; set; }
+    [Field(2, EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.FlipbookDefinition), StructureIgnoresCase = true, StructureUsesFieldIds = true)] public JsonElement Flipbook { get; set; }
+    [Field(3, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement Transform { get; set; }
     [Field(4, EditorId = ValueEditorIds.Numeric)] public float Z { get; set; } = 0;
     [Field(5, EditorId = ValueEditorIds.Numeric)] public float Opacity { get; set; } = 1;
     [Field(6, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<LayerDisplayMode>))]
@@ -24,7 +24,7 @@ public partial class LayerColorOptions
 {
     [Common, Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? HandleId { get; set; }
     [Common, Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? Color { get; set; }
-    [Field(2, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Transform { get; set; }
+    [Field(2, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement Transform { get; set; }
     [Field(3, EditorId = ValueEditorIds.Numeric)] public float Z { get; set; } = 1000;
     [Field(4, EditorId = ValueEditorIds.Numeric)] public float Opacity { get; set; } = 1;
 }
@@ -33,7 +33,7 @@ public partial class LayerColorOptions
 public partial class LayerMoveOptions
 {
     [Common, Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? HandleId { get; set; }
-    [Field(1, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Transform { get; set; }
+    [Field(1, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement Transform { get; set; }
     [Field(2, EditorId = ValueEditorIds.Numeric)] public float Z { get; set; } = 0;
     [Common, Field(3, Minimum = 0, EditorId = ValueEditorIds.Numeric)] public float Duration { get; set; } = 0.5f;
 }
@@ -43,7 +43,7 @@ public partial class AnimationOptions
 {
     [Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? PlaybackHandleId { get; set; }
     [Common, Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? HandleId { get; set; }
-    [Field(2, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(AnimationPropertyValueConverter))]
+    [Field(2, AllowNull = true, EditorId = ValueEditorIds.Choice)]
     [Common]
     public string? Property { get; set; }
     [Common, Field(3, EditorId = ValueEditorIds.Numeric)] public float From { get; set; }
@@ -62,17 +62,6 @@ public partial class AnimationOptions
     public AnimationBlendMode? BlendMode { get; set; } = AnimationBlendMode.Replace;
 }
 
-public sealed class AnimationPropertyValueConverter : JsonConverter<string>, IStringValueEncoding
-{
-    public IReadOnlyList<string> Choices { get; } = Array.AsReadOnly(Layer.AnimationProperties
-        .Concat(ParticleEmitterInstance.AnimationProperties)
-        // Shader effect properties come from program metadata, so the compiler cannot enumerate
-        // them here. Keep the common Shadertoy time property authorable.
-        .Select(property => property.Name).Append("time").Distinct(StringComparer.Ordinal).ToArray());
-    public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => reader.GetString();
-    public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options) => writer.WriteStringValue(value);
-}
-
 [GenerateFieldSchema]
 public partial class TimelineOptions
 {
@@ -83,36 +72,56 @@ public partial class TimelineOptions
 [GenerateFieldSchema]
 public partial class AudioPlayOptions
 {
-    [Common, Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? TrackId { get; set; } = "bgm";
-    [Common, Field(1, AllowNull = true, EditorId = "entry.audioasset")] public string? Asset { get; set; }
+    public AudioPlayOptions() => TrackId = "";
+    [Common, Field(0, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)] public string TrackId { get; set; }
+    [Common, Field(1, AllowNull = true, EditorId = "entry.audioasset", ResourceTypeId = "audio")] public string? Asset { get; set; }
     [Field(2, EditorId = ValueEditorIds.Numeric)] public float Gain { get; set; } = 1;
     [Field(3, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(AudioPlacementValueConverter))]
     public AudioPlacement? Placement { get; set; } = AudioPlacement.Enqueue;
     [Field(4, Minimum = 0, EditorId = ValueEditorIds.Numeric)] public float FadeIn { get; set; } = 0;
     [Field(5, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringBooleanValueConverter))]
     public bool? AutoBlocking { get; set; } = false;
+    [Field(6, Minimum = 0, EditorId = ValueEditorIds.Numeric)] public int LoopCount { get; set; } = 1;
+    [Field(7, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(AudioCompletionValueConverter))]
+    public AudioCompletion Completion { get; set; } = AudioCompletion.Discard;
+    [Field(8, Minimum = 0, EditorId = ValueEditorIds.Numeric)] public float FadeOut { get; set; } = 0;
 }
 
 public sealed class AudioPlacementValueConverter() : StringEnumValueConverter<AudioPlacement>(JsonNamingPolicy.CamelCase);
+public sealed class AudioCompletionValueConverter() : StringEnumValueConverter<AudioCompletion>(JsonNamingPolicy.CamelCase);
 
 [GenerateFieldSchema]
 public partial class AudioSEffectOptions
 {
-    [Common, Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? TrackId { get; set; } = "bgm";
-    [Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? InstanceId { get; set; }
-    [Field(2, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? Id { get; set; }
-    [Field(3, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Parameters { get; set; }
+    public AudioSEffectOptions() => TargetId = "";
+    [Common, Field(1, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)] public string TargetId { get; set; }
+    [Field(4, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? InstanceId { get; set; }
+    [Common, Field(2, AllowNull = true, EditorId = ValueEditorIds.Choice)] public string? Id { get; set; }
+    [Common, Field(3, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Parameters { get; set; }
+    [Common, Field(0, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(AudioTargetScopeValueConverter))] public SEffectScope Scope { get; set; } = SEffectScope.Track;
+}
+
+public sealed class AudioTargetScopeValueConverter() : StringEnumValueConverter<SEffectScope>(JsonNamingPolicy.CamelCase);
+
+[GenerateFieldSchema]
+public partial class AudioLevelOptions
+{
+    public AudioLevelOptions() => TargetId = "";
+    [Common, Field(0, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)] public string TargetId { get; set; }
+    [Field(1, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(AudioTargetScopeValueConverter))] public SEffectScope Scope { get; set; } = SEffectScope.Track;
+    [Field(2, Minimum = 0, Maximum = 1, EditorId = ValueEditorIds.Slider, Step = .01)] public float Gain { get; set; } = 1;
+    [Field(3, EditorId = ValueEditorIds.Choice)] public bool Muted { get; set; }
 }
 
 [GenerateFieldSchema]
 public partial class VideoPlayOptions
 {
-    [Common, Field(0, AllowNull = true, EditorId = "entry.videoasset")] public string? Asset { get; set; }
+    [Common, Field(0, AllowNull = true, EditorId = "entry.videoasset", ResourceTypeId = "video")] public string? Asset { get; set; }
     [Common, Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? HandleId { get; set; } = "video";
     [Field(2, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringBooleanValueConverter))]
     public bool? Blocking { get; set; } = true;
     [Field(3, DefaultJson = "[]", EditorId = ValueEditorIds.Json)] public JsonElement SkipPoints { get; set; }
-    [Field(4, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Transform { get; set; }
+    [Field(4, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement Transform { get; set; }
     [Field(5, EditorId = ValueEditorIds.Numeric)] public float Z { get; set; } = 0;
     [Field(6, EditorId = ValueEditorIds.Numeric)] public float Opacity { get; set; } = 1;
     [Field(7, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<LayerDisplayMode>))]
@@ -122,7 +131,7 @@ public partial class VideoPlayOptions
 [GenerateFieldSchema]
 public partial class EffectApplyOptions
 {
-    [Common, Field(0, AllowNull = true, EditorId = "entry.effectprogramasset")] public string? Program { get; set; } = "";
+    [Common, Field(0, AllowNull = true, EditorId = "entry.effectprogramasset", ResourceTypeId = "effect-program")] public string? Program { get; set; } = "";
     [Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? Id { get; set; } = "";
     [Field(2, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? InstanceId { get; set; }
     [Common, Field(3, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? TargetHandleId { get; set; } = "";
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/CompositeOptions.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/CompositeOptions.cs
index 9706584c..1ced5f98 100644
--- a/src/Shared/GalNet.Contracts.Builtins/Entry/CompositeOptions.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/CompositeOptions.cs
@@ -1,18 +1,17 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Parameters;
-using GalNet.Core.Scene;
 
 namespace GalNet.Contracts.Builtins;
 
-[GenerateFieldSchema]
-public partial class CrossFadeOptions
+public abstract class CrossFadeOptionsBase
 {
     [Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? PlaybackHandleId { get; set; }
     [Common, Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? OldHandleId { get; set; }
     [Field(2, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? NewHandleId { get; set; }
-    [Common, Field(3, AllowNull = true, EditorId = "entry.imageasset")] public string? AssetId { get; set; }
-    [Field(4, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Transform { get; set; }
+    [Common, Field(3, AllowNull = true, EditorId = "entry.imageasset", ResourceTypeId = "sprite")] public string? AssetId { get; set; }
+    [Field(4, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement Transform { get; set; }
     [Field(5, EditorId = ValueEditorIds.Numeric)] public float Z { get; set; } = 0;
     [Field(6, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<LayerDisplayMode>))]
     public LayerDisplayMode? DisplayMode { get; set; } = LayerDisplayMode.Fill;
@@ -21,6 +20,9 @@ public partial class CrossFadeOptions
     [Field(9, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? BatchId { get; set; }
 }
 
+[GenerateFieldSchema]
+public partial class CrossFadeOptions : CrossFadeOptionsBase;
+
 public enum SlideDirection { Left, Right, Up, Down }
 public enum BlindsOrientation { Vertical, Horizontal }
 
@@ -30,8 +32,8 @@ public partial class SlideOptions
     [Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? PlaybackHandleId { get; set; }
     [Common, Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? FromLayerHandleId { get; set; }
     [Common, Field(2, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? ToLayerHandleId { get; set; }
-    [Common, Field(3, AllowNull = true, EditorId = "entry.imageasset")] public string? ToAssetId { get; set; }
-    [Field(4, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement ToTransform { get; set; }
+    [Common, Field(3, AllowNull = true, EditorId = "entry.imageasset", ResourceTypeId = "sprite")] public string? ToAssetId { get; set; }
+    [Field(4, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement ToTransform { get; set; }
     [Field(5, EditorId = ValueEditorIds.Numeric)] public float ToZ { get; set; } = 0;
     [Field(6, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<LayerDisplayMode>))]
     public LayerDisplayMode? ToDisplayMode { get; set; } = LayerDisplayMode.Fill;
@@ -49,9 +51,9 @@ public partial class BlindsOptions
     [Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? PlaybackHandleId { get; set; }
     [Common, Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? OldHandleId { get; set; }
     [Field(2, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? NewHandleId { get; set; }
-    [Common, Field(3, AllowNull = true, EditorId = "entry.imageasset")] public string? AssetId { get; set; }
-    [Common, Field(4, AllowNull = true, EditorId = "entry.effectprogramasset")] public string? MaskProgram { get; set; }
-    [Field(5, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Transform { get; set; }
+    [Common, Field(3, AllowNull = true, EditorId = "entry.imageasset", ResourceTypeId = "sprite")] public string? AssetId { get; set; }
+    [Common, Field(4, AllowNull = true, EditorId = "entry.effectprogramasset", ResourceTypeId = "effect-program")] public string? MaskProgram { get; set; }
+    [Field(5, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement Transform { get; set; }
     [Field(6, EditorId = ValueEditorIds.Numeric)] public float Z { get; set; } = 0;
     [Field(7, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<LayerDisplayMode>))]
     public LayerDisplayMode? DisplayMode { get; set; } = LayerDisplayMode.Fill;
@@ -68,8 +70,8 @@ public abstract class ColorFieldOptionsBase
     [Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? PlaybackHandleId { get; set; }
     [Common, Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? FromLayerHandleId { get; set; }
     [Common, Field(2, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? ToLayerHandleId { get; set; }
-    [Common, Field(3, AllowNull = true, EditorId = "entry.imageasset")] public string? ToAssetId { get; set; }
-    [Field(4, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement ToTransform { get; set; }
+    [Common, Field(3, AllowNull = true, EditorId = "entry.imageasset", ResourceTypeId = "sprite")] public string? ToAssetId { get; set; }
+    [Field(4, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement ToTransform { get; set; }
     [Field(5, EditorId = ValueEditorIds.Numeric)] public float ToZ { get; set; } = 0;
     [Field(6, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<LayerDisplayMode>))]
     public LayerDisplayMode? ToDisplayMode { get; set; } = LayerDisplayMode.Fill;
@@ -92,18 +94,20 @@ public partial class ColorFadeOptions : ColorFieldOptionsBase
 [GenerateFieldSchema]
 public partial class TextVoiceOptions
 {
+    public TextVoiceOptions() => TrackId = "";
     [Common, Field(0, AllowNull = true, EditorId = "entry.autocomplete"), CharacterReference] public string? Speaker { get; set; }
     [Common, Field(1, AllowNull = true, EditorId = "entry.multilinetext"), LocalizedText] public string? Content { get; set; }
-    [Common, Field(2, AllowNull = true, EditorId = "entry.audioasset")] public string? Asset { get; set; }
+    [Common, Field(2, AllowNull = true, EditorId = "entry.audioasset", ResourceTypeId = "audio")] public string? Asset { get; set; }
     [Field(3, EditorId = ValueEditorIds.Numeric)] public float Gain { get; set; } = 1;
-    [Common, Field(4, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? TrackId { get; set; } = "vocal";
+    [Common, Field(4, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)] public string TrackId { get; set; }
 }
 
 [GenerateFieldSchema]
 public partial class NvlVoiceOptions
 {
+    public NvlVoiceOptions() => TrackId = "";
     [Common, Field(0, AllowNull = true, EditorId = "entry.multilinetext"), LocalizedText] public string? Content { get; set; }
-    [Common, Field(1, AllowNull = true, EditorId = "entry.audioasset")] public string? Asset { get; set; }
+    [Common, Field(1, AllowNull = true, EditorId = "entry.audioasset", ResourceTypeId = "audio")] public string? Asset { get; set; }
     [Field(2, EditorId = ValueEditorIds.Numeric)] public float Gain { get; set; } = 1;
-    [Common, Field(3, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? TrackId { get; set; } = "vocal";
+    [Common, Field(3, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)] public string TrackId { get; set; }
 }
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/PrimitiveOptions.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/PrimitiveOptions.cs
index e158999e..af8d2abc 100644
--- a/src/Shared/GalNet.Contracts.Builtins/Entry/PrimitiveOptions.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/PrimitiveOptions.cs
@@ -6,8 +6,9 @@ namespace GalNet.Contracts.Builtins;
 [GenerateFieldSchema]
 public partial class AudioTrackOptions
 {
-    [Common, Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)]
-    public string? TrackId { get; set; } = "bgm";
+    public AudioTrackOptions() => TrackId = "";
+    [Common, Field(0, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)]
+    public string TrackId { get; set; }
 }
 
 [GenerateFieldSchema]
@@ -20,10 +21,11 @@ public partial class WaitOptions
 [GenerateFieldSchema]
 public partial class AudioStopOptions
 {
-    [Common, Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)]
-    public string? TrackId { get; set; } = "bgm";
+    public AudioStopOptions() => TrackId = "";
+    [Common, Field(0, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)]
+    public string TrackId { get; set; }
     [Field(1, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringBooleanValueConverter))]
     public bool? ClearQueue { get; set; } = true;
-    [Field(2, Minimum = 0, EditorId = ValueEditorIds.Numeric)]
-    public float FadeOut { get; set; } = 0;
+    [Field(2, AllowNull = true, Minimum = 0, EditorId = ValueEditorIds.Numeric)]
+    public float? FadeOut { get; set; }
 }
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/SimplePrimitiveOptions.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/SimplePrimitiveOptions.cs
index 63d66eae..f53c94c9 100644
--- a/src/Shared/GalNet.Contracts.Builtins/Entry/SimplePrimitiveOptions.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/SimplePrimitiveOptions.cs
@@ -1,6 +1,7 @@
+using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Parameters;
-using GalNet.Core.Scene;
 
 namespace GalNet.Contracts.Builtins;
 
@@ -37,7 +38,7 @@ public partial class LayerReplaceOptions
     [Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)]
     [Common]
     public string? HandleId { get; set; }
-    [Field(1, AllowNull = true, EditorId = "entry.imageasset")]
+    [Field(1, AllowNull = true, EditorId = "entry.imageasset", ResourceTypeId = "sprite")]
     [Common]
     public string? AssetId { get; set; }
 }
@@ -52,11 +53,24 @@ public partial class InstanceIdOptions
 [GenerateFieldSchema]
 public partial class AudioSEffectStopOptions
 {
-    [Field(0, AllowNull = true, EditorId = ValueEditorIds.Text)]
+    public AudioSEffectStopOptions() => TargetId = "";
+    [Field(1, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)]
     [Common]
-    public string? TrackId { get; set; } = "bgm";
-    [Field(1, AllowNull = true, EditorId = ValueEditorIds.Text)]
+    public string TargetId { get; set; }
+    [Common, Field(2, AllowNull = true, EditorId = ValueEditorIds.Choice)]
     public string? InstanceId { get; set; }
+    [Common, Field(0, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(AudioTargetScopeValueConverter))] public GalNet.Contracts.Builtins.Audio.SEffectScope Scope { get; set; } = GalNet.Contracts.Builtins.Audio.SEffectScope.Track;
+    [Field(3, EditorId = ValueEditorIds.Choice)] public bool All { get; set; }
+}
+
+[GenerateFieldSchema]
+public partial class AudioSEffectUpdateOptions
+{
+    [Common, Field(0, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(AudioTargetScopeValueConverter))]
+    public GalNet.Contracts.Builtins.Audio.SEffectScope Scope { get; set; } = GalNet.Contracts.Builtins.Audio.SEffectScope.Track;
+    [Common, Field(1, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)] public string TargetId { get; set; } = "";
+    [Common, Field(2, AllowNull = true, EditorId = ValueEditorIds.Text)] public string? InstanceId { get; set; }
+    [Common, Field(3, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Parameters { get; set; }
 }
 
 [GenerateFieldSchema]
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/TransitionEntries.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/TransitionEntries.cs
index 70d4fef0..67e7bc2e 100644
--- a/src/Shared/GalNet.Contracts.Builtins/Entry/TransitionEntries.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/TransitionEntries.cs
@@ -1,19 +1,19 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
-using GalNet.Core.Scene;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Contracts.Builtins;
 
 internal static class TransitionEntrySupport
 {
-    public static readonly JsonSerializerOptions TimelineJsonOptions = new()
+    public static readonly JsonSerializerOptions TimelineJsonOptions = BuiltinJson.CreateOptions(new()
     {
         PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-        Converters = { new JsonStringEnumConverter() }
-    };
-    private static readonly JsonSerializerOptions TransformJsonOptions = new() { PropertyNameCaseInsensitive = true };
+    }, stringEnums: true);
+    private static readonly JsonSerializerOptions TransformJsonOptions = BuiltinJson.CreateOptions(new() { PropertyNameCaseInsensitive = true });
 
     public static string Require(string? value, string name, string type) =>
         !string.IsNullOrWhiteSpace(value) ? value : throw new InvalidDataException($"Transition '{type}' requires '{name}'.");
@@ -36,8 +36,8 @@ public static LayerTransform Transform(JsonElement value, string name, string ty
         try
         {
             var transform = value.ValueKind == JsonValueKind.String
-                ? JsonSerializer.Deserialize<LayerTransform>(value.GetString()!, TransformJsonOptions)
-                : value.Deserialize<LayerTransform>(TransformJsonOptions);
+                ? JsonCodec.Deserialize<LayerTransform>(value.GetString()!, TransformJsonOptions)
+                : JsonCodec.Deserialize<LayerTransform>(value, TransformJsonOptions);
             return transform is { ScaleX: > 0, ScaleY: > 0 } ? transform : throw new InvalidDataException();
         }
         catch (JsonException exception) { throw new InvalidDataException($"Transition '{type}' has invalid transform '{name}'.", exception); }
@@ -47,7 +47,7 @@ public static PrimitiveEntry TimelineEntry(EntryCompileContext context, Timeline
     {
         return new PrimitiveEntry(
             BuiltinEntryIds.PlayTimeline,
-            ValueCodec.SerializeFields(new TimelineOptions { Timeline = JsonSerializer.SerializeToElement(timeline, TimelineJsonOptions) }, omitNullValues: true))
+            ValueCodec.SerializeFields(new TimelineOptions { Timeline = JsonCodec.SerializeToElement(timeline, TimelineJsonOptions) }, omitNullValues: true))
         {
             Condition = context.Condition,
             BatchId = batchId
@@ -89,13 +89,13 @@ public static IReadOnlyList<PrimitiveEntry> Compile(EntryCompileContext context,
     {
         Frame = 0,
         Type = BuiltinEntryIds.ShowLayer,
-        Parameters = new Dictionary<string, JsonElement>(StringComparer.Ordinal) { ["handleId"] = JsonSerializer.SerializeToElement(handle), ["assetId"] = JsonSerializer.SerializeToElement(asset), ["transform"] = transform, ["z"] = JsonSerializer.SerializeToElement(z), ["opacity"] = JsonSerializer.SerializeToElement(opacity), ["displayMode"] = JsonSerializer.SerializeToElement(displayMode.ToString()) }
+        Parameters = new Dictionary<string, JsonElement>(StringComparer.Ordinal) { ["handleId"] = JsonCodec.SerializeToElement(handle), ["assetId"] = JsonCodec.SerializeToElement(asset), ["transform"] = transform, ["z"] = JsonCodec.SerializeToElement(z), ["opacity"] = JsonCodec.SerializeToElement(opacity), ["displayMode"] = JsonCodec.SerializeToElement(displayMode.ToString()) }
     };
     internal static TimelineEventDefinition HideLayer(string handle, int frame) => new()
     {
         Frame = frame,
         Type = BuiltinEntryIds.HideLayer,
-        Parameters = new Dictionary<string, JsonElement>(StringComparer.Ordinal) { ["handleId"] = JsonSerializer.SerializeToElement(handle) }
+        Parameters = new Dictionary<string, JsonElement>(StringComparer.Ordinal) { ["handleId"] = JsonCodec.SerializeToElement(handle) }
     };
 }
 
@@ -125,7 +125,7 @@ public static IReadOnlyList<PrimitiveEntry> Compile(EntryCompileContext context,
             Blocking = true,
             Skippable = true,
             Tracks = [Track(oldHandle, property, 0, -incomingX - incomingY, frames, AnimationBlendMode.Additive), Track(newHandle, property, incomingX != 0 ? initial.X : initial.Y, incomingX != 0 ? destination.X : destination.Y, frames, AnimationBlendMode.Replace)],
-            Events = [CrossFadeTransition.ShowLayer(newHandle, TransitionEntrySupport.Require(options.ToAssetId, "toAssetId", BuiltinEntryIds.SlideTransition), JsonSerializer.SerializeToElement(initial, TransitionEntrySupport.TimelineJsonOptions), options.ToZ, 1, TransitionEntrySupport.DisplayMode(options.ToDisplayMode)), CrossFadeTransition.HideLayer(oldHandle, frames)]
+            Events = [CrossFadeTransition.ShowLayer(newHandle, TransitionEntrySupport.Require(options.ToAssetId, "toAssetId", BuiltinEntryIds.SlideTransition), JsonCodec.SerializeToElement(initial, TransitionEntrySupport.TimelineJsonOptions), options.ToZ, 1, TransitionEntrySupport.DisplayMode(options.ToDisplayMode)), CrossFadeTransition.HideLayer(oldHandle, frames)]
         };
         return [TransitionEntrySupport.TimelineEntry(context, timeline, TransitionEntrySupport.NullIfWhiteSpace(options.BatchId))];
     }
@@ -157,7 +157,7 @@ public static IReadOnlyList<PrimitiveEntry> Compile(EntryCompileContext context,
         if (!string.Equals(orientation, "Vertical", StringComparison.OrdinalIgnoreCase) && !string.Equals(orientation, "Horizontal", StringComparison.OrdinalIgnoreCase))
             throw new InvalidDataException($"Transition '{BuiltinEntryIds.BlindsTransition}' has an unknown orientation.");
         var mask = $"{context.SourceEntryId}:blinds-mask";
-        var maskParameters = JsonSerializer.SerializeToElement(new { bladeCount, orientation }, TransitionEntrySupport.TimelineJsonOptions);
+        var maskParameters = JsonCodec.SerializeToElement(new { bladeCount, orientation }, TransitionEntrySupport.TimelineJsonOptions);
         var timeline = new TimelineDefinition
         {
             PlaybackHandleId = playback,
@@ -191,9 +191,9 @@ public static IReadOnlyList<PrimitiveEntry> Compile(EntryCompileContext context,
         Type = BuiltinEntryIds.ApplyEffect,
         Parameters = new Dictionary<string, JsonElement>(StringComparer.Ordinal)
         {
-            ["program"] = JsonSerializer.SerializeToElement(program),
-            ["instanceId"] = JsonSerializer.SerializeToElement(instanceId),
-            ["targetHandleId"] = JsonSerializer.SerializeToElement(targetHandleId),
+            ["program"] = JsonCodec.SerializeToElement(program),
+            ["instanceId"] = JsonCodec.SerializeToElement(instanceId),
+            ["targetHandleId"] = JsonCodec.SerializeToElement(targetHandleId),
             ["parameters"] = parameters
         }
     };
@@ -204,7 +204,7 @@ public static IReadOnlyList<PrimitiveEntry> Compile(EntryCompileContext context,
         Type = BuiltinEntryIds.StopEffect,
         Parameters = new Dictionary<string, JsonElement>(StringComparer.Ordinal)
         {
-            ["instanceId"] = JsonSerializer.SerializeToElement(instanceId)
+            ["instanceId"] = JsonCodec.SerializeToElement(instanceId)
         }
     };
 }
@@ -235,10 +235,10 @@ public static IReadOnlyList<PrimitiveEntry> Compile(EntryCompileContext context,
             Skippable = true,
             Tracks = [new TimelineTrackDefinition { HandleId = overlay, Property = "opacity", Keys = keys }],
             Events = [new() { Frame = 0, Type = BuiltinEntryIds.ShowColorLayer, Parameters = new Dictionary<string, JsonElement>(StringComparer.Ordinal)
-            { ["handleId"] = JsonSerializer.SerializeToElement(overlay), ["color"] = JsonSerializer.SerializeToElement(color), ["transform"] = JsonSerializer.SerializeToElement(new { }), ["z"] = JsonSerializer.SerializeToElement(options.OverlayZ), ["opacity"] = JsonSerializer.SerializeToElement(0f) } },
+            { ["handleId"] = JsonCodec.SerializeToElement(overlay), ["color"] = JsonCodec.SerializeToElement(color), ["transform"] = JsonCodec.SerializeToElement(new { }), ["z"] = JsonCodec.SerializeToElement(options.OverlayZ), ["opacity"] = JsonCodec.SerializeToElement(0f) } },
             CrossFadeTransition.HideLayer(oldHandle, swapFrame),
             new() { Frame = swapFrame, Type = BuiltinEntryIds.ShowLayer, Parameters = new Dictionary<string, JsonElement>(StringComparer.Ordinal)
-            { ["handleId"] = JsonSerializer.SerializeToElement(newHandle), ["assetId"] = JsonSerializer.SerializeToElement(TransitionEntrySupport.Require(options.ToAssetId, "toAssetId", type)), ["transform"] = TransitionEntrySupport.Json(options.ToTransform, "toTransform", type), ["z"] = JsonSerializer.SerializeToElement(options.ToZ), ["opacity"] = JsonSerializer.SerializeToElement(1f), ["displayMode"] = JsonSerializer.SerializeToElement(TransitionEntrySupport.DisplayMode(options.ToDisplayMode).ToString()) } },
+            { ["handleId"] = JsonCodec.SerializeToElement(newHandle), ["assetId"] = JsonCodec.SerializeToElement(TransitionEntrySupport.Require(options.ToAssetId, "toAssetId", type)), ["transform"] = TransitionEntrySupport.Json(options.ToTransform, "toTransform", type), ["z"] = JsonCodec.SerializeToElement(options.ToZ), ["opacity"] = JsonCodec.SerializeToElement(1f), ["displayMode"] = JsonCodec.SerializeToElement(TransitionEntrySupport.DisplayMode(options.ToDisplayMode).ToString()) } },
             CrossFadeTransition.HideLayer(overlay, duration)]
         };
         return [TransitionEntrySupport.TimelineEntry(context, timeline, TransitionEntrySupport.NullIfWhiteSpace(options.BatchId))];
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/VariantsOptions.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/VariantsOptions.cs
index 1848cb46..c71adf79 100644
--- a/src/Shared/GalNet.Contracts.Builtins/Entry/VariantsOptions.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/VariantsOptions.cs
@@ -1,7 +1,8 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Parameters;
-using GalNet.Core.Scene;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Contracts.Builtins;
 
@@ -9,11 +10,11 @@ namespace GalNet.Contracts.Builtins;
 public partial class VariantsShowOptions
 {
     [Common, Field(0, Required = true, EditorId = ValueEditorIds.Text)] public string HandleId { get; set; } = "";
-    [Common, Field(1, Required = true, EditorId = "entry.variantsasset")] public string AssetId { get; set; } = "";
+    [Common, Field(1, Required = true, EditorId = "entry.variantsasset", ResourceTypeId = "image-variants")] public string AssetId { get; set; } = "";
     [Field(2, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Selection { get; set; }
-    [Field(3, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Transform { get; set; }
+    [Field(3, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement Transform { get; set; }
     [Field(4, EditorId = ValueEditorIds.Numeric)] public float Z { get; set; } = 0;
-    [Field(5, Minimum = 0, Maximum = 1, EditorId = ValueEditorIds.Numeric)] public float Opacity { get; set; } = 1;
+    [Field(5, Minimum = 0, Maximum = 1, EditorId = ValueEditorIds.Slider, Step = .01)] public float Opacity { get; set; } = 1;
     [Field(6, AllowNull = true, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<LayerDisplayMode>))]
     public LayerDisplayMode? DisplayMode { get; set; } = LayerDisplayMode.Native;
 }
@@ -48,10 +49,10 @@ internal static void Show(JsonElement arguments)
 
     public static LayerTransform ReadTransform(JsonElement value)
     {
-        var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true, AllowDuplicateProperties = false };
+        var options = BuiltinJson.CreateOptions(new() { PropertyNameCaseInsensitive = true, AllowDuplicateProperties = false });
         var transform = value.ValueKind == JsonValueKind.String
-            ? JsonSerializer.Deserialize<LayerTransform>(value.GetString()!, options)
-            : value.Deserialize<LayerTransform>(options);
+            ? JsonCodec.Deserialize<LayerTransform>(value.GetString()!, options)
+            : JsonCodec.Deserialize<LayerTransform>(value, options);
         if (transform is null || !float.IsFinite(transform.X) || !float.IsFinite(transform.Y) || !float.IsFinite(transform.RotationDegrees)
             || !float.IsFinite(transform.ScaleX) || !float.IsFinite(transform.ScaleY) || transform.ScaleX < .001f || transform.ScaleY < .001f)
             throw new InvalidDataException("Variant transform requires finite values and positive scale.");
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/VisualPresetCompiler.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/VisualPresetCompiler.cs
new file mode 100644
index 00000000..291ff16a
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/VisualPresetCompiler.cs
@@ -0,0 +1,229 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Entry;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Contracts.Builtins;
+
+/// <summary>Pure composition. Shader locators are always supplied by the author entry.</summary>
+internal static class VisualPresetCompiler
+{
+    private static JsonElement Json<T>(T value) => JsonCodec.SerializeToElement(value, TransitionEntrySupport.TimelineJsonOptions);
+    private static string Require(string? value, string name) => TransitionEntrySupport.Require(value, name, "visual preset");
+    private static TimelineEventDefinition Event(int frame, string type, object parameters) => new()
+    {
+        Frame = frame,
+        Type = type,
+        Parameters = Json(parameters).EnumerateObject().ToDictionary(p => p.Name, p => p.Value.Clone(), StringComparer.Ordinal)
+    };
+    private static TimelineTrackDefinition Track(string handle, string property, int frames, float from, float to, AnimationBlendMode blend = AnimationBlendMode.Replace) => new()
+    {
+        HandleId = handle,
+        Property = property,
+        BlendMode = blend,
+        Keys = [new() { Frame = 0, Value = from }, new() { Frame = frames, Value = to }]
+    };
+    private static TimelineDefinition Clip(VisualClipOptions options)
+    {
+        Require(options.PlaybackHandleId, "playbackHandleId");
+        if (options.DurationFrames is < 2 or > 36000 || options.FrameRate is < 1 or > 240) throw new InvalidDataException("Invalid visual clip duration or frame rate.");
+        return new() { PlaybackHandleId = options.PlaybackHandleId, DurationFrames = options.DurationFrames, FrameRate = options.FrameRate, Blocking = options.Blocking, Skippable = options.Skippable };
+    }
+    private static TimelineDefinition Transition(CrossFadeOptionsBase options)
+    {
+        Require(options.PlaybackHandleId, "playbackHandleId");
+        Require(options.OldHandleId, "oldHandleId");
+        Require(options.NewHandleId, "newHandleId");
+        Require(options.AssetId, "assetId");
+        if (options.OldHandleId == options.NewHandleId) throw new InvalidDataException("Outgoing and incoming layer handles must differ.");
+        if (options.OldHandleId!.StartsWith(options.PlaybackHandleId + "/visual/", StringComparison.Ordinal) || options.NewHandleId!.StartsWith(options.PlaybackHandleId + "/visual/", StringComparison.Ordinal))
+            throw new InvalidDataException("Layer handles cannot use the playback's reserved /visual/ namespace.");
+        if (options.DurationFrames is < 2 or > 36000 || options.FrameRate is < 1 or > 240 || !float.IsFinite(options.Z)) throw new InvalidDataException("Invalid transition duration, frame rate or Z.");
+        _ = TransitionEntrySupport.Transform(options.Transform, "transform", "visual transition");
+        var timeline = new TimelineDefinition { PlaybackHandleId = options.PlaybackHandleId!, DurationFrames = options.DurationFrames, FrameRate = options.FrameRate, Blocking = true, Skippable = true };
+        timeline.Events.Add(CrossFadeTransition.ShowLayer(options.NewHandleId!, options.AssetId!, options.Transform, options.Z, 1, TransitionEntrySupport.DisplayMode(options.DisplayMode)));
+        return timeline;
+    }
+    private static IReadOnlyList<PrimitiveEntry> Finish(EntryCompileContext context, TimelineDefinition timeline, string? batch)
+    {
+        TimelineEventCapabilities.ValidateStructure(timeline);
+        foreach (var item in timeline.Events) TimelineEventCapabilities.NormalizeEvent(item);
+        return [TransitionEntrySupport.TimelineEntry(context, timeline, TransitionEntrySupport.NullIfWhiteSpace(batch))];
+    }
+    private static string Id(TimelineDefinition timeline, string suffix) => timeline.PlaybackHandleId + "/visual/" + suffix;
+    private static TimelineEventDefinition Apply(int frame, string id, string handle, string program, object parameters, int order = 0) =>
+        Event(frame, BuiltinEntryIds.ApplyEffect, new { program = Require(program, "program"), instanceId = id, targetHandleId = handle, order, parameters });
+    private static TimelineEventDefinition Stop(int frame, string id) => Event(frame, BuiltinEntryIds.StopEffect, new { instanceId = id });
+
+    public static IReadOnlyList<PrimitiveEntry> Reveal(EntryCompileContext context, RevealTransitionOptions options)
+    {
+        var timeline = Transition(options);
+        var id = Id(timeline, "reveal");
+        object parameters;
+        if (options.Mode == RevealMode.Mask)
+            parameters = new { progress = 0, softness = options.Softness, mask = Require(options.MaskAsset, "maskAsset") };
+        else
+        {
+            if (options.Center.ValueKind != JsonValueKind.Array || options.Center.GetArrayLength() != 2 ||
+                options.Center.EnumerateArray().Any(c => !c.TryGetSingle(out var f) || !float.IsFinite(f) || f < 0 || f > 1))
+                throw new InvalidDataException("Reveal center requires two normalized coordinates.");
+            parameters = new { progress = 0, softness = options.Softness, mode = options.Mode.ToString(), angle = options.Angle, count = options.Count, center = options.Center };
+        }
+        timeline.Events.Add(Apply(0, id, options.NewHandleId!, options.Program, parameters));
+        timeline.Tracks.Add(Track(id, "progress", timeline.DurationFrames, 0, 1));
+        timeline.Events.Add(Stop(timeline.DurationFrames, id));
+        timeline.Events.Add(CrossFadeTransition.HideLayer(options.OldHandleId!, timeline.DurationFrames));
+        return Finish(context, timeline, options.BatchId);
+    }
+
+    public static IReadOnlyList<PrimitiveEntry> Blur(EntryCompileContext context, BlurTransitionOptions options)
+    {
+        var timeline = Transition(options);
+        timeline.Tracks.Add(Track(options.OldHandleId!, "opacity", timeline.DurationFrames, 1, 0));
+        timeline.Tracks.Add(Track(options.NewHandleId!, "opacity", timeline.DurationFrames, 0, 1));
+        // The incoming layer must already be transparent when frame-zero events dispatch.
+        timeline.Events[0].Parameters["opacity"] = Json(0f);
+        foreach (var incoming in new[] { false, true })
+            for (var axis = 0; axis < 2; axis++)
+            {
+                var id = Id(timeline, (incoming ? "new" : "old") + "-blur-" + axis);
+                var handle = incoming ? options.NewHandleId! : options.OldHandleId!;
+                timeline.Events.Add(Apply(0, id, handle, options.BlurProgram, new { radius = incoming ? options.Radius : 0, direction = axis == 0 ? new[] { 1, 0 } : new[] { 0, 1 } }, axis));
+                timeline.Tracks.Add(Track(id, "radius", timeline.DurationFrames, incoming ? options.Radius : 0, incoming ? 0 : options.Radius));
+                timeline.Events.Add(Stop(timeline.DurationFrames, id));
+            }
+        timeline.Events.Add(CrossFadeTransition.HideLayer(options.OldHandleId!, timeline.DurationFrames));
+        return Finish(context, timeline, options.BatchId);
+    }
+
+    public static IReadOnlyList<PrimitiveEntry> Motion(EntryCompileContext context, MotionPresetOptions options)
+    {
+        var timeline = Clip(options);
+        var handle = Require(options.HandleId, "handleId");
+        var frames = timeline.DurationFrames;
+        var transform = TransitionEntrySupport.Transform(options.Transform, "transform", "motion");
+        var angle = options.Angle * MathF.PI / 180f;
+        var x = MathF.Cos(angle) * options.Distance;
+        var y = MathF.Sin(angle) * options.Distance;
+        void Add(string property, float from, float to) => timeline.Tracks.Add(Track(handle, property, frames, from, to));
+        switch (options.Motion)
+        {
+            case MotionPreset.FadeIn: Add("opacity", 0, 1); break;
+            case MotionPreset.FadeOut: Add("opacity", 1, 0); break;
+            case MotionPreset.SlideIn:
+                Add("opacity", 0, 1);
+                Add("transform.x", transform.X - x, transform.X);
+                Add("transform.y", transform.Y - y, transform.Y);
+                break;
+            case MotionPreset.SlideOut:
+                Add("opacity", 1, 0);
+                Add("transform.x", transform.X, transform.X + x);
+                Add("transform.y", transform.Y, transform.Y + y);
+                break;
+            case MotionPreset.PopIn:
+                Add("opacity", 0, 1);
+                foreach (var (property, value) in new[] { ("transform.scaleX", transform.ScaleX), ("transform.scaleY", transform.ScaleY) })
+                {
+                    var track = Track(handle, property, frames, value * .8f, value);
+                    track.Keys.Insert(1, new() { Frame = frames / 2, Value = value * 1.08f });
+                    timeline.Tracks.Add(track);
+                }
+                break;
+            case MotionPreset.Jump: timeline.Tracks.Add(Pulse(handle, "transform.y", frames, -options.Distance)); break;
+            case MotionPreset.Nod: timeline.Tracks.Add(Pulse(handle, "transform.rotationDegrees", frames, options.RotationDegrees)); break;
+            case MotionPreset.ShakeHead:
+                AddShake(timeline, handle, options.Distance, 2, 0); break;
+            case MotionPreset.Push:
+                Add("transform.x", transform.X, transform.X + x + (transform.X - options.AnchorX) * (options.Scale - 1));
+                Add("transform.y", transform.Y, transform.Y + y + (transform.Y - options.AnchorY) * (options.Scale - 1));
+                Add("transform.scaleX", transform.ScaleX, transform.ScaleX * options.Scale);
+                Add("transform.scaleY", transform.ScaleY, transform.ScaleY * options.Scale);
+                break;
+            default: throw new InvalidDataException("Unknown motion preset.");
+        }
+        return Finish(context, timeline, options.BatchId);
+    }
+    private static TimelineTrackDefinition Pulse(string handle, string property, int frames, float peak)
+    {
+        var track = Track(handle, property, frames, 0, 0, AnimationBlendMode.Additive);
+        track.Keys.Insert(1, new() { Frame = frames / 2, Value = peak });
+        return track;
+    }
+    private static void AddShake(TimelineDefinition timeline, string handle, float amplitude, int cycles, float angle, bool sustained = false)
+    {
+        var samples = Math.Min(timeline.DurationFrames, cycles * 4);
+        var radians = angle * MathF.PI / 180;
+        foreach (var (property, axis) in new[] { ("transform.x", MathF.Cos(radians)), ("transform.y", MathF.Sin(radians)) })
+        {
+            var track = new TimelineTrackDefinition { HandleId = handle, Property = property, BlendMode = AnimationBlendMode.Additive };
+            for (var i = 0; i <= samples; i++)
+            {
+                var t = (float)i / samples;
+                track.Keys.Add(new() { Frame = (int)MathF.Round(t * timeline.DurationFrames), Value = i == 0 || i == samples ? 0 : amplitude * axis * (sustained ? 1 : 1 - t) * MathF.Sin(i * MathF.PI * .5f) });
+            }
+            timeline.Tracks.Add(track);
+        }
+    }
+    public static IReadOnlyList<PrimitiveEntry> Shake(EntryCompileContext context, ShakePresetOptions options)
+    {
+        var timeline = Clip(options);
+        Sustain(timeline, options.PlaybackMode);
+        AddShake(timeline, Require(options.HandleId, "handleId"), options.Amplitude, options.Cycles, options.Angle, options.PlaybackMode == VisualPlaybackMode.UntilStopped);
+        return Finish(context, timeline, options.BatchId);
+    }
+    private static void Sustain(TimelineDefinition timeline, VisualPlaybackMode mode)
+    {
+        if (!Enum.IsDefined(mode)) throw new InvalidDataException("Unknown visual playback mode.");
+        if (mode != VisualPlaybackMode.UntilStopped) return;
+        timeline.LoopMode = AnimationLoopMode.Loop;
+        timeline.Blocking = false;
+        timeline.Skippable = false;
+    }
+    private static void AddLines(TimelineDefinition timeline, SpeedLinesPresetOptionsBase options)
+    {
+        if (options.Parameters.ValueKind != JsonValueKind.Object) throw new InvalidDataException("Speed line parameters must be an object.");
+        var layer = Id(timeline, "lines");
+        var effect = Id(timeline, "lines-effect");
+        var parameters = options.Parameters.EnumerateObject().ToDictionary(p => p.Name, p => p.Value.Clone(), StringComparer.Ordinal);
+        parameters["time"] = Json(0f); parameters["speed"] = Json(options.Speed); parameters["flicker"] = Json(options.Flicker);
+        timeline.Events.Add(Event(0, BuiltinEntryIds.ShowColorLayer, new { handleId = layer, color = "#00000000", z = options.Z, opacity = 1 }));
+        timeline.Events.Add(Apply(0, effect, layer, options.Program, parameters));
+        timeline.Tracks.Add(Track(effect, "time", timeline.DurationFrames, 0, (float)timeline.DurationFrames / timeline.FrameRate));
+        var opacity = Track(layer, "opacity", timeline.DurationFrames, 0, 0);
+        opacity.Keys.Insert(1, new() { Frame = timeline.DurationFrames / 2, Value = 1 });
+        timeline.Tracks.Add(opacity);
+        timeline.Events.Add(Stop(timeline.DurationFrames, effect));
+        timeline.Events.Add(CrossFadeTransition.HideLayer(layer, timeline.DurationFrames));
+    }
+    public static IReadOnlyList<PrimitiveEntry> SpeedLines(EntryCompileContext context, SpeedLinesPresetOptions options)
+    {
+        var timeline = Clip(options);
+        Sustain(timeline, options.PlaybackMode);
+        AddLines(timeline, options);
+        if (options.PlaybackMode == VisualPlaybackMode.UntilStopped)
+        {
+            timeline.Tracks.RemoveAll(track => track.Property == "opacity");
+            foreach (var item in timeline.Events)
+                item.Execution = item.Frame == 0 ? TimelineEventExecution.Once : TimelineEventExecution.OnCompletion;
+        }
+        return Finish(context, timeline, options.BatchId);
+    }
+    public static IReadOnlyList<PrimitiveEntry> Impact(EntryCompileContext context, ImpactPresetOptions options)
+    {
+        var timeline = Clip(options);
+        var handle = Require(options.HandleId, "handleId");
+        if (handle.StartsWith(options.PlaybackHandleId + "/visual/", StringComparison.Ordinal))
+            throw new InvalidDataException("Impact target cannot use the playback's reserved /visual/ namespace.");
+        AddShake(timeline, handle, options.Amplitude, options.Cycles, options.Angle);
+        foreach (var property in new[] { "transform.scaleX", "transform.scaleY" })
+            timeline.Tracks.Add(Pulse(handle, property, timeline.DurationFrames, .08f));
+        AddLines(timeline, options);
+        var flash = Id(timeline, "flash");
+        timeline.Events.Add(Event(0, BuiltinEntryIds.ShowColorLayer, new { handleId = flash, color = "#FFFFFF", z = options.Z + 1, opacity = options.FlashOpacity }));
+        var flashTrack = Track(flash, "opacity", timeline.DurationFrames, options.FlashOpacity, 0);
+        flashTrack.Keys.Insert(1, new() { Frame = timeline.DurationFrames / 2, Value = 0 });
+        timeline.Tracks.Add(flashTrack);
+        timeline.Events.Add(CrossFadeTransition.HideLayer(flash, timeline.DurationFrames));
+        return Finish(context, timeline, options.BatchId);
+    }
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/VisualPresetOptions.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/VisualPresetOptions.cs
new file mode 100644
index 00000000..40bb8c36
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/VisualPresetOptions.cs
@@ -0,0 +1,87 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Core.Parameters;
+
+namespace GalNet.Contracts.Builtins;
+
+public enum RevealMode { Wipe, Radial, Noise, Blinds, Mask }
+public enum MotionPreset { FadeIn, FadeOut, SlideIn, SlideOut, PopIn, Jump, Nod, ShakeHead, Push }
+public enum VisualPlaybackMode { Timed, UntilStopped }
+
+[GenerateFieldSchema]
+public partial class RevealTransitionOptions : CrossFadeOptionsBase
+{
+    [Common, Field(10, Required = true, AllowNull = false, EditorId = "entry.effectprogramasset", ResourceTypeId = "effect-program")] public string Program { get; set; } = "";
+    [Field(11, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<RevealMode>))] public RevealMode Mode { get; set; }
+    [Field(12, Minimum = 0.001, Maximum = 1)] public float Softness { get; set; } = .05f;
+    [Field(13)] public float Angle { get; set; }
+    [Field(14, DefaultJson = "[0.5,0.5]", EditorId = ValueEditorIds.Json)] public JsonElement Center { get; set; }
+    [Field(15, Minimum = 1, Maximum = 256)] public float Count { get; set; } = 12;
+    [Field(16, AllowNull = true, EditorId = "entry.imageasset", ResourceTypeId = "sprite")] public string? MaskAsset { get; set; }
+}
+
+[GenerateFieldSchema]
+public partial class BlurTransitionOptions : CrossFadeOptionsBase
+{
+    [Common, Field(10, Required = true, AllowNull = false, EditorId = "entry.effectprogramasset", ResourceTypeId = "effect-program")] public string BlurProgram { get; set; } = "";
+    [Field(11, Minimum = 0, Maximum = 64)] public float Radius { get; set; } = 24;
+}
+
+public abstract class VisualClipOptions
+{
+    [Field(0, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)] public string PlaybackHandleId { get; set; } = "";
+    [Field(1, Minimum = 1, Maximum = 240)] public int FrameRate { get; set; } = 60;
+    [Common, Field(2, Minimum = 2, Maximum = 36000)] public int DurationFrames { get; set; } = 36;
+    [Common, Field(3)] public bool Blocking { get; set; } = true;
+    [Field(4)] public bool Skippable { get; set; } = true;
+    [Field(5, AllowNull = true)] public string? BatchId { get; set; }
+}
+
+[GenerateFieldSchema]
+public partial class MotionPresetOptions : VisualClipOptions
+{
+    [Common, Field(6, Required = true, AllowNull = false)] public string HandleId { get; set; } = "";
+    [Common, Field(7, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<MotionPreset>))] public MotionPreset Motion { get; set; }
+    [Field(8, DefaultJson = "{}", EditorId = ValueEditorIds.Json, StructureType = typeof(GalNet.Contracts.Builtins.Scene.LayerTransform), StructureAllowsJsonString = true, StructureIgnoresCase = true)] public JsonElement Transform { get; set; }
+    [Field(9, Minimum = 0, Maximum = 100000)] public float Distance { get; set; } = 120;
+    [Field(10)] public float Angle { get; set; }
+    [Field(11, Minimum = 0.01, Maximum = 100)] public float Scale { get; set; } = 1.15f;
+    [Field(12)] public float AnchorX { get; set; }
+    [Field(13)] public float AnchorY { get; set; }
+    [Field(14, Minimum = -180, Maximum = 180)] public float RotationDegrees { get; set; } = 8;
+}
+
+[GenerateFieldSchema]
+public partial class ShakePresetOptions : VisualClipOptions
+{
+    [Common, Field(10, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<VisualPlaybackMode>))] public VisualPlaybackMode PlaybackMode { get; set; }
+    [Common, Field(6, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)] public string HandleId { get; set; } = "";
+    [Field(7, Minimum = 0, Maximum = 10000)] public float Amplitude { get; set; } = 16;
+    [Field(8, Minimum = 1, Maximum = 30)] public int Cycles { get; set; } = 4;
+    [Field(9)] public float Angle { get; set; }
+}
+
+public abstract class SpeedLinesPresetOptionsBase : VisualClipOptions
+{
+    [Common, Field(6, Required = true, AllowNull = false, EditorId = "entry.effectprogramasset", ResourceTypeId = "effect-program")] public string Program { get; set; } = "";
+    [Field(7, DefaultJson = "{}", EditorId = ValueEditorIds.Json)] public JsonElement Parameters { get; set; }
+    [Field(8)] public float Z { get; set; } = 900;
+    [Field(9, Minimum = -20, Maximum = 20)] public float Speed { get; set; } = 2;
+    [Field(10, Minimum = 0, Maximum = 1)] public float Flicker { get; set; } = .3f;
+}
+
+[GenerateFieldSchema]
+public partial class SpeedLinesPresetOptions : SpeedLinesPresetOptionsBase
+{
+    [Common, Field(11, EditorId = ValueEditorIds.Choice), JsonConverter(typeof(StringEnumValueConverter<VisualPlaybackMode>))] public VisualPlaybackMode PlaybackMode { get; set; }
+}
+
+[GenerateFieldSchema]
+public partial class ImpactPresetOptions : SpeedLinesPresetOptionsBase
+{
+    [Common, Field(11, Required = true, AllowNull = false, EditorId = ValueEditorIds.Text)] public string HandleId { get; set; } = "";
+    [Field(12, Minimum = 0, Maximum = 10000)] public float Amplitude { get; set; } = 16;
+    [Field(13, Minimum = 1, Maximum = 30)] public int Cycles { get; set; } = 4;
+    [Field(14)] public float Angle { get; set; }
+    [Field(15, Minimum = 0, Maximum = 1)] public float FlashOpacity { get; set; } = .7f;
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/Entry/VoiceTextEntries.cs b/src/Shared/GalNet.Contracts.Builtins/Entry/VoiceTextEntries.cs
index 3f26a206..980732bf 100644
--- a/src/Shared/GalNet.Contracts.Builtins/Entry/VoiceTextEntries.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Entry/VoiceTextEntries.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Audio;
+using GalNet.Contracts.Builtins.Audio;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
 
@@ -18,11 +18,11 @@ public static IReadOnlyList<PrimitiveEntry> Nvl(EntryCompileContext context, Nvl
         new PrimitiveEntry(BuiltinEntryIds.AppendNvl, ValueCodec.SerializeFields(new NvlAppendOptions
         { Content = options.Content ?? "" })) { Condition = context.Condition }
     ];
-    private static PrimitiveEntry Audio(EntryCompileContext context, string? asset, string? track, float gain, string type)
+    private static PrimitiveEntry Audio(EntryCompileContext context, string? asset, string track, float gain, string type)
     {
         if (string.IsNullOrWhiteSpace(asset)) throw new InvalidDataException($"'{type}' requires 'asset'.");
         return new(BuiltinEntryIds.PlayAudio, ValueCodec.SerializeFields(new AudioPlayOptions
-        { TrackId = track ?? "", Asset = asset, Gain = gain, Placement = AudioPlacement.ReplaceIfDifferent, AutoBlocking = true }))
+        { TrackId = track, Asset = asset, Gain = gain, Placement = AudioPlacement.ReplaceIfDifferent, AutoBlocking = true }))
         { Condition = context.Condition };
     }
 }
diff --git a/src/Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj b/src/Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj
index c5ac18ab..10823e58 100644
--- a/src/Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj
+++ b/src/Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj
@@ -3,7 +3,7 @@
     <TargetFramework>net10.0</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
-    <ProjectReference Include="../../Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" GlobalPropertiesToRemove="OutputPath;OutDir" />
+    <ProjectReference Include="../../Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" GlobalPropertiesToRemove="OutputPath;OutDir;PublishAot;SelfContained;RuntimeIdentifier" />
     <ProjectReference Include="..\GalNet.Core\GalNet.Core.csproj" />
   </ItemGroup>
 </Project>
diff --git a/src/Shared/GalNet.Core/Gallery/BuiltinGalleryTypes.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/BuiltinGalleryTypes.cs
similarity index 90%
rename from src/Shared/GalNet.Core/Gallery/BuiltinGalleryTypes.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/BuiltinGalleryTypes.cs
index 6e40c6b0..c614b6a6 100644
--- a/src/Shared/GalNet.Core/Gallery/BuiltinGalleryTypes.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/BuiltinGalleryTypes.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 /// <summary>Creates the default Gallery type registrations offered by GalNet authoring hosts.</summary>
 public static class BuiltinGalleryTypes
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryAnnotation.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryAnnotation.cs
similarity index 69%
rename from src/Shared/GalNet.Core/Gallery/GalleryAnnotation.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryAnnotation.cs
index 6334f45c..62fb4ca1 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryAnnotation.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryAnnotation.cs
@@ -1,8 +1,9 @@
 using System.Text.Json.Serialization;
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 public sealed record GalleryAnnotation
 {
+    [JsonExtensionData] public Dictionary<string, System.Text.Json.JsonElement>? ExtensionData { get; set; }
     [JsonPropertyName("id")] public int Id { get; init; }
     [JsonPropertyName("typeId")] public string TypeId { get; init; } = "";
     [JsonPropertyName("title")]
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryCatalog.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryCatalog.cs
similarity index 98%
rename from src/Shared/GalNet.Core/Gallery/GalleryCatalog.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryCatalog.cs
index e9e1c127..0b6dac78 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryCatalog.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryCatalog.cs
@@ -1,7 +1,7 @@
 using System.Collections.Frozen;
 using System.Collections.ObjectModel;
 
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 public sealed class GalleryCatalog
 {
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryCatalogCompiler.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryCatalogCompiler.cs
similarity index 95%
rename from src/Shared/GalNet.Core/Gallery/GalleryCatalogCompiler.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryCatalogCompiler.cs
index e8768191..70d151d3 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryCatalogCompiler.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryCatalogCompiler.cs
@@ -1,5 +1,5 @@
 using GalNet.Core.Assets;
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 public sealed class GalleryCatalogCompiler(IResourceTypeCatalog resourceTypes, IGalleryTypeCatalog galleryTypes)
 {
@@ -15,7 +15,7 @@ public GalleryCatalog Compile(IEnumerable<AssetMeta> metadata)
             if (!resource.MetaDtoType.IsInstanceOfType(meta)) throw new InvalidDataException($"Asset '{meta.Path}' declares '{meta.TypeId}' but has metadata DTO '{meta.GetType().Name}'.");
             if (!assetsById.TryAdd(meta.Id, meta.Path))
                 throw new InvalidDataException($"Asset ID '{meta.Id}' is declared by both '{assetsById[meta.Id]}' and '{meta.Path}'.");
-            foreach (var annotation in meta.Gallery ?? [])
+            foreach (var annotation in meta.ReadGallery())
             {
                 if (annotation.Id <= 0) throw new InvalidDataException($"Gallery annotation in '{meta.Path}' must have a positive ID.");
                 var galleryType = galleryTypes.Get(annotation.TypeId);
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryConfiguration.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryConfiguration.cs
similarity index 91%
rename from src/Shared/GalNet.Core/Gallery/GalleryConfiguration.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryConfiguration.cs
index c71545e7..09467f07 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryConfiguration.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryConfiguration.cs
@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 /// <summary>Serializable Gallery content stored in <c>gallery.json</c>.</summary>
 public sealed class GalleryConfiguration
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryItem.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryItem.cs
similarity index 92%
rename from src/Shared/GalNet.Core/Gallery/GalleryItem.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryItem.cs
index 56e979a3..68ded289 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryItem.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryItem.cs
@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 /// <summary>A stable resource entry exposed through Gallery.</summary>
 public sealed record GalleryItem
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryItemData.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryItemData.cs
similarity index 78%
rename from src/Shared/GalNet.Core/Gallery/GalleryItemData.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryItemData.cs
index 77cb16d6..0c4f59e4 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryItemData.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryItemData.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 /// <summary>One Gallery item projected with its current Player unlock state.</summary>
 public sealed record GalleryItemData(GalleryItem Item, bool IsUnlocked);
diff --git a/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryMetadata.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryMetadata.cs
new file mode 100644
index 00000000..2c5acc84
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryMetadata.cs
@@ -0,0 +1,24 @@
+using System.Text.Json;
+using GalNet.Core.Assets;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Contracts.Builtins.Gallery;
+
+/// <summary>Optional Gallery annotations over the generic asset metadata envelope.</summary>
+public static class GalleryMetadata
+{
+    private static readonly JsonSerializerOptions JsonOptions = BuiltinJson.CreateOptions(new(JsonSerializerDefaults.Web));
+    public static IReadOnlyList<GalleryAnnotation> ReadGallery(this AssetMeta metadata)
+    {
+        if (metadata.ExtensionData is not { } extensions || !extensions.TryGetValue("gallery", out var json)) return [];
+        try
+        {
+            var items = JsonCodec.Deserialize<GalleryAnnotation[]>(json, JsonOptions) ?? [];
+            if (items.Any(item => item is null)) throw new InvalidDataException($"Invalid Gallery annotation in '{metadata.Path}'.");
+            return items;
+        }
+        catch (JsonException error) { throw new InvalidDataException($"Invalid Gallery annotations in '{metadata.Path}'.", error); }
+    }
+    public static void SetGallery(this AssetMeta metadata, IEnumerable<GalleryAnnotation> values) =>
+        (metadata.ExtensionData ??= new(StringComparer.Ordinal))["gallery"] = JsonCodec.SerializeToElement(values.ToArray(), JsonOptions);
+}
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryTypeCatalog.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryTypeCatalog.cs
similarity index 97%
rename from src/Shared/GalNet.Core/Gallery/GalleryTypeCatalog.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryTypeCatalog.cs
index 6cfd867a..d977c7a9 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryTypeCatalog.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryTypeCatalog.cs
@@ -1,6 +1,6 @@
 using System.Collections.ObjectModel;
 using GalNet.Core.Assets;
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 public interface IGalleryTypeCatalog { IReadOnlyList<GalleryTypeRegistration> Types { get; } GalleryTypeRegistration Get(string typeId); bool TryGet(string typeId, out GalleryTypeRegistration registration); }
 public sealed class GalleryTypeCatalogBuilder
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryTypeData.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryTypeData.cs
similarity index 82%
rename from src/Shared/GalNet.Core/Gallery/GalleryTypeData.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryTypeData.cs
index e254ebc5..9c96f7ba 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryTypeData.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryTypeData.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 /// <summary>One registered Gallery type and the items currently exposed for it.</summary>
 public sealed record GalleryTypeData(
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryTypeRegistration.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryTypeRegistration.cs
similarity index 88%
rename from src/Shared/GalNet.Core/Gallery/GalleryTypeRegistration.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryTypeRegistration.cs
index 841fc587..d7347dcd 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryTypeRegistration.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryTypeRegistration.cs
@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 /// <summary>Associates one Gallery type with the resource type it contains.</summary>
 public sealed record GalleryTypeRegistration
diff --git a/src/Shared/GalNet.Core/Gallery/GalleryUnlockVariable.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryUnlockVariable.cs
similarity index 97%
rename from src/Shared/GalNet.Core/Gallery/GalleryUnlockVariable.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryUnlockVariable.cs
index 1b13b5e6..7eaf2862 100644
--- a/src/Shared/GalNet.Core/Gallery/GalleryUnlockVariable.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/GalleryUnlockVariable.cs
@@ -2,7 +2,7 @@
 using GalNet.Core.Variable;
 using GalVariable = GalNet.Core.Variable.Variable;
 
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 /// <summary>Defines the stable Player-variable contract used by Gallery unlock state.</summary>
 public static class GalleryUnlockVariable
diff --git a/src/Shared/GalNet.Core/Gallery/IGalleryDataSource.cs b/src/Shared/GalNet.Contracts.Builtins/Gallery/IGalleryDataSource.cs
similarity index 80%
rename from src/Shared/GalNet.Core/Gallery/IGalleryDataSource.cs
rename to src/Shared/GalNet.Contracts.Builtins/Gallery/IGalleryDataSource.cs
index 422d0873..45577b00 100644
--- a/src/Shared/GalNet.Core/Gallery/IGalleryDataSource.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Gallery/IGalleryDataSource.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Gallery;
+namespace GalNet.Contracts.Builtins.Gallery;
 
 /// <summary>Platform-independent Gallery projection consumed by host UI implementations.</summary>
 public interface IGalleryDataSource
diff --git a/src/Shared/GalNet.Contracts.Builtins/ParameterValidation.cs b/src/Shared/GalNet.Contracts.Builtins/ParameterValidation.cs
new file mode 100644
index 00000000..32416862
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/ParameterValidation.cs
@@ -0,0 +1,32 @@
+using System.Text.Json;
+using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Contracts.Builtins;
+
+/// <summary>Effect metadata uses the same field/value rules as Entry contracts.</summary>
+internal static class ParameterValidation
+{
+    public static FieldDescriptor Field(string name, Type type, bool required, float? minimum, float? maximum, IReadOnlyList<string>? options = null)
+    {
+        var constraints = new Dictionary<string, object>();
+        if (minimum is { } min) constraints["minimum"] = min;
+        if (maximum is { } max) constraints["maximum"] = max;
+        if (options is { Count: > 0 }) constraints["enum"] = options;
+        return new(name, new ValueDescriptor(type, allowNull: false, constraints: JsonCodec.SerializeToElement(constraints)), required);
+    }
+    public static IReadOnlyList<string> Validate(string kind, string id, JsonElement values, IReadOnlyDictionary<string, FieldDescriptor> fields)
+    {
+        if (values.ValueKind != JsonValueKind.Object) return [$"{kind} '{id}' parameters must be a JSON object."];
+        var diagnostics = new List<string>();
+        foreach (var value in values.EnumerateObject())
+        {
+            if (!fields.TryGetValue(value.Name, out var field)) diagnostics.Add($"{kind} '{id}' does not declare parameter '{value.Name}'.");
+            else if (ValueValidation.Validate(field.Value, value.Value) is { } issue)
+                diagnostics.Add($"{kind} parameter '{value.Name}' {(issue.Message.StartsWith("Value ", StringComparison.Ordinal) ? issue.Message[6..] : issue.Message)}");
+        }
+        foreach (var field in fields.Values)
+            if (field.IsRequired && !values.TryGetProperty(field.Id, out _)) diagnostics.Add($"{kind} '{id}' requires parameter '{field.Id}'.");
+        return diagnostics;
+    }
+}
diff --git a/src/Shared/GalNet.Contracts.Builtins/README.md b/src/Shared/GalNet.Contracts.Builtins/README.md
index c6fccc1b..9c548122 100644
--- a/src/Shared/GalNet.Contracts.Builtins/README.md
+++ b/src/Shared/GalNet.Contracts.Builtins/README.md
@@ -15,7 +15,7 @@ var selected = new TargetProfileEntryCatalog(
 var all = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
 ```
 
-CreateAllModules 只返回 13 个独立模块的只读列表。各组件是 Dialogue、Nvl、Layers、Animations、Audio、Video、Effects、Particles、Flow、Variables、Gallery、Transitions 和 Voice，不存在聚合大模块。
+CreateAllModules 只返回 14 个独立模块的只读列表。各组件是 Dialogue、Nvl、Layers、Animations、Audio、Video、Effects、Particles、Flow、Variables、Gallery、Transitions、Voice 和 Custom，不存在聚合大模块。Animations 包含人物动作、震动、动态集中线和冲击 Composite，Transitions 包含 shader 遮罩与模糊转场；它们使用显式项目 shader 引用并编译为 timeline.play。
 
 选用 Composite 时，也要选用其输出所需的 primitive；编译器验证缺失契约。游戏宿主另行注册执行实现，由 GalNet.Primitives.Builtins 或自己的平台程序集提供。完整 typeId 唯一，模块名/前缀不用于匹配执行实现。
 
diff --git a/src/Shared/GalNet.Core/Scene/AnimatableSceneInstance.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/AnimatableSceneInstance.cs
similarity index 97%
rename from src/Shared/GalNet.Core/Scene/AnimatableSceneInstance.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/AnimatableSceneInstance.cs
index 3b149534..5252b74a 100644
--- a/src/Shared/GalNet.Core/Scene/AnimatableSceneInstance.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/AnimatableSceneInstance.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>The value representation an animation property currently accepts.</summary>
 public enum AnimationValueKind
diff --git a/src/Shared/GalNet.Core/Scene/AnimationCurve.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/AnimationCurve.cs
similarity index 97%
rename from src/Shared/GalNet.Core/Scene/AnimationCurve.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/AnimationCurve.cs
index 147f9220..f3903a10 100644
--- a/src/Shared/GalNet.Core/Scene/AnimationCurve.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/AnimationCurve.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>Named easing curves available to immediate <c>animate</c> entries.</summary>
 public enum BuiltinAnimationCurve
diff --git a/src/Shared/GalNet.Core/Scene/AnimationRequest.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/AnimationRequest.cs
similarity index 94%
rename from src/Shared/GalNet.Core/Scene/AnimationRequest.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/AnimationRequest.cs
index 5de6d632..2c9c91ee 100644
--- a/src/Shared/GalNet.Core/Scene/AnimationRequest.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/AnimationRequest.cs
@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>Controls whether a sampled animation value replaces or offsets the underlying property value.</summary>
 public enum AnimationBlendMode
@@ -61,6 +61,8 @@ public sealed class AnimationPlaybackInstance : ISceneInstance
     /// <summary>Stable playback handle used by stop commands and to prevent duplicate active playbacks.</summary>
     public string Id { get; init; } = "";
     public AnimationLoopMode LoopMode { get; init; }
+    /// <summary>Includes presentation cleanup; stop commands await it before the handle can be reused.</summary>
+    public Task PresentationCompletion { get; set; } = Task.CompletedTask;
 
     /// <summary>Most recent requested stop mode, or <see langword="null"/> while playback may continue.</summary>
     public AnimationStopMode? RequestedStop
diff --git a/src/Shared/GalNet.Contracts.Builtins/Scene/EffectCatalog.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/EffectCatalog.cs
new file mode 100644
index 00000000..94d0bce5
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/EffectCatalog.cs
@@ -0,0 +1,85 @@
+using System.Text.Json;
+using GalNet.Core.Parameters;
+
+namespace GalNet.Contracts.Builtins.Scene;
+
+/// <summary>Fixed slots in the game render pipeline. Every pixel effect consumes and produces the same image stream.</summary>
+public enum EffectStage { Layer, ScenePost }
+
+/// <summary>Editor-facing JSON value kinds for an effect's static start parameters.</summary>
+public enum EffectParameterKind { Text, Integer, Float, Boolean, ImageAsset, Select }
+
+/// <summary>Metadata for one JSON member accepted by an effect factory.</summary>
+public sealed record EffectParameterDefinition(
+    string Name,
+    EffectParameterKind Kind,
+    bool Required = false,
+    float? Minimum = null,
+    float? Maximum = null,
+    IReadOnlyList<string>? Options = null)
+{
+    public FieldDescriptor Field => ParameterValidation.Field(Name, Kind switch
+    { EffectParameterKind.Integer => typeof(int), EffectParameterKind.Float => typeof(float), EffectParameterKind.Boolean => typeof(bool), _ => typeof(string) },
+        Required, Minimum, Maximum, Options);
+}
+
+/// <summary>Platform-neutral authoring metadata emitted by an effect factory.</summary>
+public sealed record EffectDefinition(
+    string Id,
+    EffectStage Stage,
+    IReadOnlyList<EffectParameterDefinition> Parameters,
+    IReadOnlyList<AnimatableProperty> AnimatableProperties);
+
+public interface IEffectCatalog
+{
+    IReadOnlyList<EffectDefinition> Definitions { get; }
+    bool TryGet(string id, out EffectDefinition definition);
+    IReadOnlyList<string> Validate(string id, string targetHandleId, string parameters);
+}
+
+/// <summary>
+/// Immutable effect metadata registry. Validation returns diagnostics instead of throwing so
+/// editor and runtime hosts can decide whether a malformed effect remains executable.
+/// </summary>
+public sealed class EffectCatalog : IEffectCatalog
+{
+    private readonly IReadOnlyDictionary<string, EffectDefinition> _byId;
+    private readonly Dictionary<string, IReadOnlyDictionary<string, FieldDescriptor>> _parametersByEffect;
+
+    public EffectCatalog(IEnumerable<EffectDefinition> definitions)
+    {
+        _byId = definitions.Select(definition => definition with
+        {
+            Parameters = Array.AsReadOnly(definition.Parameters.Select(parameter => parameter with { Options = parameter.Options is { } choices ? Array.AsReadOnly(choices.ToArray()) : null }).ToArray()),
+            AnimatableProperties = Array.AsReadOnly(definition.AnimatableProperties.ToArray())
+        }).ToDictionary(definition => definition.Id, StringComparer.OrdinalIgnoreCase);
+        _parametersByEffect = _byId.Values.ToDictionary(
+            definition => definition.Id,
+            definition => (IReadOnlyDictionary<string, FieldDescriptor>)definition.Parameters.ToDictionary(parameter => parameter.Name,
+                parameter => parameter.Field, StringComparer.Ordinal),
+            StringComparer.OrdinalIgnoreCase);
+        Definitions = _byId.Values.OrderBy(definition => definition.Id, StringComparer.OrdinalIgnoreCase).ToArray();
+    }
+
+    public IReadOnlyList<EffectDefinition> Definitions { get; }
+    public bool TryGet(string id, out EffectDefinition definition) => _byId.TryGetValue(id, out definition!);
+
+    public IReadOnlyList<string> Validate(string id, string targetHandleId, string parameters)
+    {
+        if (!TryGet(id, out var definition)) return [$"Unknown effect '{id}'."];
+        var diagnostics = new List<string>();
+        if (definition.Stage == EffectStage.Layer && string.IsNullOrWhiteSpace(targetHandleId))
+            diagnostics.Add($"Layer effect '{id}' requires targetHandleId.");
+        if (definition.Stage != EffectStage.Layer && !string.IsNullOrWhiteSpace(targetHandleId))
+            diagnostics.Add($"{definition.Stage} effect '{id}' must not target a Layer.");
+
+        JsonDocument document;
+        try { document = JsonDocument.Parse(string.IsNullOrWhiteSpace(parameters) ? "{}" : parameters); }
+        catch (JsonException error) { diagnostics.Add($"Effect parameters are not valid JSON: {error.Message}"); return diagnostics; }
+        using (document)
+        {
+            diagnostics.AddRange(ParameterValidation.Validate("Effect", id, document.RootElement, _parametersByEffect[definition.Id]));
+        }
+        return diagnostics;
+    }
+}
diff --git a/src/Shared/GalNet.Core/Scene/EffectInstance.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/EffectInstance.cs
similarity index 98%
rename from src/Shared/GalNet.Core/Scene/EffectInstance.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/EffectInstance.cs
index 817f6816..0850f85d 100644
--- a/src/Shared/GalNet.Core/Scene/EffectInstance.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/EffectInstance.cs
@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>A live effect target whose numeric parameters can be driven by the common animation system.</summary>
 public sealed class EffectInstance : AnimatableSceneInstance
diff --git a/src/Shared/GalNet.Core/Scene/FlipbookDefinition.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/FlipbookDefinition.cs
similarity index 68%
rename from src/Shared/GalNet.Core/Scene/FlipbookDefinition.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/FlipbookDefinition.cs
index 90dc3cf8..9555497b 100644
--- a/src/Shared/GalNet.Core/Scene/FlipbookDefinition.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/FlipbookDefinition.cs
@@ -1,12 +1,19 @@
-namespace GalNet.Core.Scene;
+using GalNet.Core.Parameters;
+
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>Describes the used frames in a row-major sprite sheet. Frame indices are zero-based.</summary>
-public sealed class FlipbookDefinition
+[GenerateFieldSchema]
+public sealed partial class FlipbookDefinition
 {
+    [Field(0, Minimum = 1, LabelKey = "Form.Flipbook.Columns")]
     public int Columns { get; set; } = 1;
+    [Field(1, Minimum = 1, LabelKey = "Form.Flipbook.Rows")]
     public int Rows { get; set; } = 1;
+    [Field(2, Minimum = 1, LabelKey = "Form.Flipbook.FrameCount")]
     public int FrameCount { get; set; } = 1;
-    public float Index { get; set; }
+    [Field(3, Minimum = 0, LabelKey = "Form.Flipbook.Index")]
+    public float Index { get; set; } = 0f;
 
     public int Capacity => Columns * Rows;
 
diff --git a/src/Shared/GalNet.Core/Scene/ISceneInstance.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/ISceneInstance.cs
similarity index 78%
rename from src/Shared/GalNet.Core/Scene/ISceneInstance.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/ISceneInstance.cs
index 65e46f3e..6a99f844 100644
--- a/src/Shared/GalNet.Core/Scene/ISceneInstance.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/ISceneInstance.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>A currently active scene object addressed by an opaque runtime handle.</summary>
 public interface ISceneInstance
diff --git a/src/Shared/GalNet.Core/Scene/Layer.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/Layer.cs
similarity index 99%
rename from src/Shared/GalNet.Core/Scene/Layer.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/Layer.cs
index afffcc7c..42eba86a 100644
--- a/src/Shared/GalNet.Core/Scene/Layer.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/Layer.cs
@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>
 /// Resource-backed scene instance. Its Id is a stable opaque handle; z values sort front-to-back.
diff --git a/src/Shared/GalNet.Core/Scene/LayerDisplayMode.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/LayerDisplayMode.cs
similarity index 80%
rename from src/Shared/GalNet.Core/Scene/LayerDisplayMode.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/LayerDisplayMode.cs
index 219a71de..0ec3cdc0 100644
--- a/src/Shared/GalNet.Core/Scene/LayerDisplayMode.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/LayerDisplayMode.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>How a layer image is laid out inside the logical game canvas.</summary>
 public enum LayerDisplayMode
diff --git a/src/Shared/GalNet.Contracts.Builtins/Scene/LayerTransform.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/LayerTransform.cs
new file mode 100644
index 00000000..6a36277d
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/LayerTransform.cs
@@ -0,0 +1,28 @@
+using GalNet.Core.Parameters;
+
+namespace GalNet.Contracts.Builtins.Scene;
+
+/// <summary>Center-anchored transform in logical game-canvas pixels and degrees.</summary>
+[GenerateFieldSchema]
+public sealed partial class LayerTransform
+{
+    [Field(0, LabelKey = "Form.Transform.X")]
+    public float X { get; set; } = 0f;
+    [Field(1, LabelKey = "Form.Transform.Y")]
+    public float Y { get; set; } = 0f;
+    [Field(2, LabelKey = "Form.Transform.RotationDegrees")]
+    public float RotationDegrees { get; set; } = 0f;
+    [Field(3, LabelKey = "Form.Transform.ScaleX")]
+    public float ScaleX { get; set; } = 1f;
+    [Field(4, LabelKey = "Form.Transform.ScaleY")]
+    public float ScaleY { get; set; } = 1f;
+
+    public LayerTransform Clone() => new()
+    {
+        X = X,
+        Y = Y,
+        RotationDegrees = RotationDegrees,
+        ScaleX = ScaleX,
+        ScaleY = ScaleY
+    };
+}
diff --git a/src/Shared/GalNet.Core/Scene/LayerVariantsState.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/LayerVariantsState.cs
similarity index 54%
rename from src/Shared/GalNet.Core/Scene/LayerVariantsState.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/LayerVariantsState.cs
index f3bbf4e4..62832318 100644
--- a/src/Shared/GalNet.Core/Scene/LayerVariantsState.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/LayerVariantsState.cs
@@ -1,6 +1,6 @@
-using GalNet.Core.Variants;
+using GalNet.Contracts.Builtins.Variants;
 
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>Persistent selection intent; Layer.AssetId is the actual image.</summary>
 public sealed class LayerVariantsState
@@ -10,13 +10,19 @@ public sealed class LayerVariantsState
     public List<string> ProtectedDimensions { get; set; } = [];
     public string VariantKey { get; set; } = "";
     public ImageVariantResolutionReason Reason { get; set; }
+    /// <summary>The cached display result was produced through an explicit resource override.</summary>
+    [System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingDefault)]
+    public bool UsesResourceOverride { get; set; }
 
-    public static LayerVariantsState From(string assetId, ImageVariantResolution resolution) => new()
+    public static LayerVariantsState From(string assetId, ImageVariantResolution resolution) => From(assetId, resolution, false);
+
+    public static LayerVariantsState From(string assetId, ImageVariantResolution resolution, bool usesResourceOverride) => new()
     {
         AssetId = assetId,
         Request = resolution.Request.ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.Ordinal),
         ProtectedDimensions = resolution.ProtectedDimensions.ToList(),
         VariantKey = resolution.Variant.Key,
-        Reason = resolution.Reason
+        Reason = resolution.Reason,
+        UsesResourceOverride = usesResourceOverride
     };
 }
diff --git a/src/Shared/GalNet.Core/Scene/LoopAnimationState.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/LoopAnimationState.cs
similarity index 87%
rename from src/Shared/GalNet.Core/Scene/LoopAnimationState.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/LoopAnimationState.cs
index 9be78b9b..549ce5f4 100644
--- a/src/Shared/GalNet.Core/Scene/LoopAnimationState.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/LoopAnimationState.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>Typed replay definition, independent from live stop controls and clocks.</summary>
 public sealed class LoopAnimationState
diff --git a/src/Shared/GalNet.Core/Scene/ParticleEmitter.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/ParticleEmitter.cs
similarity index 99%
rename from src/Shared/GalNet.Core/Scene/ParticleEmitter.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/ParticleEmitter.cs
index 8d34e828..fa47abba 100644
--- a/src/Shared/GalNet.Core/Scene/ParticleEmitter.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/ParticleEmitter.cs
@@ -1,7 +1,7 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>Platform-neutral authoring data for a scene particle emitter.</summary>
 public sealed record ParticleEmitterDefinition(
diff --git a/src/Shared/GalNet.Core/Scene/ShaderEffectAnimationProperties.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/ShaderEffectAnimationProperties.cs
similarity index 95%
rename from src/Shared/GalNet.Core/Scene/ShaderEffectAnimationProperties.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/ShaderEffectAnimationProperties.cs
index 88bc0054..30352b3b 100644
--- a/src/Shared/GalNet.Core/Scene/ShaderEffectAnimationProperties.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/ShaderEffectAnimationProperties.cs
@@ -1,6 +1,6 @@
 using System.Globalization;
 
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>Portable scalar animation declarations shared by authoring and rendering.</summary>
 public static class ShaderEffectAnimationProperties
diff --git a/src/Shared/GalNet.Contracts.Builtins/Scene/ShaderEffectFields.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/ShaderEffectFields.cs
new file mode 100644
index 00000000..30443f71
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/ShaderEffectFields.cs
@@ -0,0 +1,69 @@
+using System.Globalization;
+using System.Text.Json;
+using GalNet.Core.Parameters;
+
+namespace GalNet.Contracts.Builtins.Scene;
+
+/// <summary>Shared wire fields for shader forms and read-only property analysis.</summary>
+public static class ShaderEffectFields
+{
+    public static FieldDescriptor Create(ShaderEffectParameterDescriptor parameter)
+    {
+        var type = parameter.Kind switch
+        {
+            ShaderEffectParameterKind.Float => typeof(float),
+            ShaderEffectParameterKind.Integer => typeof(int),
+            ShaderEffectParameterKind.Boolean => typeof(bool),
+            ShaderEffectParameterKind.Vector2 or ShaderEffectParameterKind.Vector3 or ShaderEffectParameterKind.Vector4 => typeof(float[]),
+            _ => typeof(string)
+        };
+        var constraints = new Dictionary<string, object>();
+        if (parameter.Minimum is { } minimum && type != typeof(float[])) constraints["minimum"] = minimum;
+        if (parameter.Maximum is { } maximum && type != typeof(float[])) constraints["maximum"] = maximum;
+        if (parameter.Kind == ShaderEffectParameterKind.Enum && parameter.Options is { Count: > 0 } options)
+            constraints["enum"] = options;
+        if (parameter.Kind is ShaderEffectParameterKind.Vector2 or ShaderEffectParameterKind.Vector3 or ShaderEffectParameterKind.Vector4)
+            constraints["minItems"] = constraints["maxItems"] = parameter.Kind switch
+            {
+                ShaderEffectParameterKind.Vector2 => 2,
+                ShaderEffectParameterKind.Vector3 => 3,
+                _ => 4
+            };
+        var descriptor = new ValueDescriptor(type, allowNull: false, constraints: JsonSerializer.SerializeToElement(constraints));
+        var editor = parameter.Kind switch
+        {
+            ShaderEffectParameterKind.Texture => "entry.imageasset",
+            ShaderEffectParameterKind.Color => "shader.color",
+            ShaderEffectParameterKind.Vector2 => "shader.vector2",
+            ShaderEffectParameterKind.Vector3 => "shader.vector3",
+            ShaderEffectParameterKind.Vector4 => "shader.vector4",
+            ShaderEffectParameterKind.Boolean => ValueEditorIds.Toggle,
+            ShaderEffectParameterKind.Enum => ValueEditorIds.Choice,
+            ShaderEffectParameterKind.Float or ShaderEffectParameterKind.Integer => ValueEditorIds.Numeric,
+            _ => null
+        };
+        var fallback = Default(parameter, descriptor);
+        return new(parameter.Name, descriptor, parameter.Required, fallback, new EditorHints(editor, parameter.Step),
+            resourceTypeId: parameter.Kind == ShaderEffectParameterKind.Texture ? "sprite" : null);
+    }
+
+    private static JsonElement? Default(ShaderEffectParameterDescriptor parameter, ValueDescriptor descriptor)
+    {
+        if (parameter.DefaultValue is not { } text) return null;
+        try
+        {
+            object value = parameter.Kind switch
+            {
+                ShaderEffectParameterKind.Float => float.Parse(text, CultureInfo.InvariantCulture),
+                ShaderEffectParameterKind.Integer => int.Parse(text, CultureInfo.InvariantCulture),
+                ShaderEffectParameterKind.Boolean => bool.Parse(text),
+                ShaderEffectParameterKind.Vector2 or ShaderEffectParameterKind.Vector3 or ShaderEffectParameterKind.Vector4 => JsonSerializer.Deserialize<float[]>(text)!,
+                _ => text
+            };
+            var json = JsonSerializer.SerializeToElement(value, descriptor.ValueType, descriptor.JsonOptions);
+            return ValueValidation.Validate(descriptor, json) is null ? json : null;
+        }
+        catch (Exception error) when (error is JsonException or FormatException or OverflowException or ArgumentException)
+        { return null; }
+    }
+}
diff --git a/src/Shared/GalNet.Core/Scene/ShaderEffectMetadata.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/ShaderEffectMetadata.cs
similarity index 97%
rename from src/Shared/GalNet.Core/Scene/ShaderEffectMetadata.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/ShaderEffectMetadata.cs
index 01338027..5b6fb87c 100644
--- a/src/Shared/GalNet.Core/Scene/ShaderEffectMetadata.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/ShaderEffectMetadata.cs
@@ -2,7 +2,7 @@
 using System.Text.Json;
 using System.Text.RegularExpressions;
 
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>
 /// A platform-neutral reference to an effect program resource. The resource may contain
@@ -21,7 +21,7 @@ public EffectProgramResource(string value)
 }
 
 /// <summary>Value kinds declared by an <c>@param</c> or <c>@texture</c> metadata entry.</summary>
-public enum ShaderEffectParameterKind { Float, Integer, Boolean, Color, Vector2, Vector4, Texture, Enum }
+public enum ShaderEffectParameterKind { Float, Integer, Boolean, Color, Vector2, Vector4, Texture, Enum, Vector3 }
 
 /// <summary>Editor and validation metadata parsed from a shader resource comment block.</summary>
 public sealed record ShaderEffectParameterDescriptor(
@@ -357,6 +357,7 @@ ShaderEffectParameterKind.Float or
             ShaderEffectParameterKind.Integer or
             ShaderEffectParameterKind.Color or
             ShaderEffectParameterKind.Vector2 or
+            ShaderEffectParameterKind.Vector3 or
             ShaderEffectParameterKind.Vector4;
 
         private static string? DefaultValue(ShaderEffectParameterKind kind, string[] options) => kind switch
@@ -365,6 +366,7 @@ ShaderEffectParameterKind.Vector2 or
             ShaderEffectParameterKind.Boolean => "false",
             ShaderEffectParameterKind.Color => "#00000000",
             ShaderEffectParameterKind.Vector2 => "[0,0]",
+            ShaderEffectParameterKind.Vector3 => "[0,0,0]",
             ShaderEffectParameterKind.Vector4 => "[0,0,0,0]",
             ShaderEffectParameterKind.Texture => null,
             ShaderEffectParameterKind.Enum => options.Length > 0 ? options[0] : null,
@@ -377,8 +379,9 @@ ShaderEffectParameterKind.Vector2 or
             "int" or "integer" => ShaderEffectParameterKind.Integer,
             "bool" or "boolean" => ShaderEffectParameterKind.Boolean,
             "color" => ShaderEffectParameterKind.Color,
-            "vec2" or "vector2" => ShaderEffectParameterKind.Vector2,
-            "vec4" or "vector4" => ShaderEffectParameterKind.Vector4,
+            "vec2" or "vector2" or "float2" => ShaderEffectParameterKind.Vector2,
+            "vec3" or "vector3" or "float3" => ShaderEffectParameterKind.Vector3,
+            "vec4" or "vector4" or "float4" => ShaderEffectParameterKind.Vector4,
             "texture" => ShaderEffectParameterKind.Texture,
             "enum" => ShaderEffectParameterKind.Enum,
             _ => null
diff --git a/src/Shared/GalNet.Core/Scene/Timeline.cs b/src/Shared/GalNet.Contracts.Builtins/Scene/Timeline.cs
similarity index 67%
rename from src/Shared/GalNet.Core/Scene/Timeline.cs
rename to src/Shared/GalNet.Contracts.Builtins/Scene/Timeline.cs
index 44675b52..d84916bf 100644
--- a/src/Shared/GalNet.Core/Scene/Timeline.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Scene/Timeline.cs
@@ -1,6 +1,7 @@
 using System.Text.Json;
+using GalNet.Core.Parameters;
 
-namespace GalNet.Core.Scene;
+namespace GalNet.Contracts.Builtins.Scene;
 
 /// <summary>Interpolation used by the segment immediately following a timeline keyframe.</summary>
 public enum AnimationInterpolation
@@ -15,56 +16,67 @@ public enum AnimationInterpolation
 /// A timeline at 60 fps with <c>DurationFrames = 30</c> plays for half a second. A track whose
 /// keys are `(0, 0)` and `(30, 1)` linearly fades its target property from 0 to 1.
 /// </example>
-public sealed class TimelineDefinition
+[GenerateFieldSchema]
+public sealed partial class TimelineDefinition
 {
+    public TimelineDefinition() { Tracks = []; Events = []; }
     /// <summary>Opaque handle for this timeline playback; it must be unique while the timeline is active.</summary>
-    public string PlaybackHandleId { get; set; } = "";
+    [Field(0)] public string PlaybackHandleId { get; set; } = "";
     /// <summary>Timeline sampling frequency in frames per second. Valid authoring values are 1 through 240.</summary>
-    public int FrameRate { get; set; } = 60;
+    [Field(1)] public int FrameRate { get; set; } = 60;
     /// <summary>Inclusive timeline end frame. Tracks must start at frame 0 and may not exceed this value.</summary>
-    public int DurationFrames { get; set; }
-    public bool Blocking { get; set; }
-    public bool Skippable { get; set; }
+    [Field(2)] public int DurationFrames { get; set; }
+    [Field(3)] public bool Blocking { get; set; }
+    [Field(4)] public bool Skippable { get; set; }
     /// <summary>Whether the whole timeline plays once or is restarted after its final frame.</summary>
-    public AnimationLoopMode LoopMode { get; set; }
+    [Field(5)] public AnimationLoopMode LoopMode { get; set; }
     /// <summary>Property tracks sampled in parallel during playback.</summary>
-    public List<TimelineTrackDefinition> Tracks { get; set; } = [];
+    [Field(6)] public List<TimelineTrackDefinition> Tracks { get; set; }
     /// <summary>Entries dispatched at their declared frames without creating a separate engine checkpoint.</summary>
-    public List<TimelineEventDefinition> Events { get; set; } = [];
+    [Field(7)] public List<TimelineEventDefinition> Events { get; set; }
 }
 
 /// <summary>Keyframed values for one property on one active scene instance.</summary>
-public sealed class TimelineTrackDefinition
+[GenerateFieldSchema]
+public sealed partial class TimelineTrackDefinition
 {
-    public string HandleId { get; set; } = "";
-    public string Property { get; set; } = "";
+    public TimelineTrackDefinition() => Keys = [];
+    [Field(0)] public string HandleId { get; set; } = "";
+    [Field(1)] public string Property { get; set; } = "";
     /// <summary>Whether keys are absolute property values or relative offsets from the current Replace value.</summary>
-    public AnimationBlendMode BlendMode { get; set; }
+    [Field(2)] public AnimationBlendMode BlendMode { get; set; }
     /// <summary>Strictly frame-ordered keys; the first key must be at frame 0.</summary>
-    public List<TimelineKeyframeDefinition> Keys { get; set; } = [];
+    [Field(3)] public List<TimelineKeyframeDefinition> Keys { get; set; }
 }
 
 /// <summary>Tangents are values per timeline frame. Interpolation belongs to the segment after this key.</summary>
-public sealed class TimelineKeyframeDefinition
+[GenerateFieldSchema]
+public sealed partial class TimelineKeyframeDefinition
 {
-    public int Frame { get; set; }
-    public float Value { get; set; }
+    [Field(0)] public int Frame { get; set; }
+    [Field(1)] public float Value { get; set; }
     /// <summary>Incoming derivative in value-per-frame units, used only by cubic Hermite interpolation.</summary>
-    public float InTangent { get; set; }
+    [Field(2)] public float InTangent { get; set; }
     /// <summary>Outgoing derivative in value-per-frame units, used only by cubic Hermite interpolation.</summary>
-    public float OutTangent { get; set; }
-    public AnimationInterpolation InterpolationToNext { get; set; } = AnimationInterpolation.Linear;
+    [Field(3)] public float OutTangent { get; set; }
+    [Field(4)] public AnimationInterpolation InterpolationToNext { get; set; } = AnimationInterpolation.Linear;
 }
 
 /// <summary>Entry-like event embedded in a timeline and dispatched when its frame is reached.</summary>
-public sealed class TimelineEventDefinition
+[GenerateFieldSchema]
+public sealed partial class TimelineEventDefinition
 {
-    public int Frame { get; set; }
-    public string Type { get; set; } = "";
+    public TimelineEventDefinition() => Parameters = new(StringComparer.Ordinal);
+    [Field(0)] public int Frame { get; set; }
+    /// <summary>Defaults to each iteration; setup and cleanup can instead belong to the whole playback.</summary>
+    [Field(1)] public TimelineEventExecution Execution { get; set; }
+    [Field(2)] public string Type { get; set; } = "";
     /// <summary>Structured entry parameters preserved until the event is dispatched.</summary>
-    public Dictionary<string, JsonElement> Parameters { get; set; } = new(StringComparer.Ordinal);
+    [Field(3)] public Dictionary<string, JsonElement> Parameters { get; set; }
 }
 
+public enum TimelineEventExecution { EachIteration, Once, OnCompletion }
+
 /// <summary>Terminal timeline outcome plus the terminal outcome recorded for each track.</summary>
 public sealed class TimelinePlayResult
 {
diff --git a/src/Shared/GalNet.Contracts.Builtins/TimelineEventCapabilities.cs b/src/Shared/GalNet.Contracts.Builtins/TimelineEventCapabilities.cs
index dd4f7438..9751be9f 100644
--- a/src/Shared/GalNet.Contracts.Builtins/TimelineEventCapabilities.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/TimelineEventCapabilities.cs
@@ -1,7 +1,8 @@
 using System.Collections.Frozen;
 using System.Text.Json;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
-using GalNet.Core.Scene;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Contracts.Builtins;
 
@@ -27,7 +28,7 @@ public static class TimelineEventCapabilities
     public static JsonElement NormalizeEvent(TimelineEventDefinition item)
     {
         if (item is null || item.Parameters is null || !Supports(item.Type)) throw new InvalidDataException("Unsupported or incomplete Timeline event.");
-        return PrimitiveArgumentHelper.Normalize(Catalog.Value.Get(item.Type).DynamicParameters!, JsonSerializer.SerializeToElement(item.Parameters));
+        return PrimitiveArgumentHelper.Normalize(Catalog.Value.Get(item.Type).DynamicParameters, JsonCodec.SerializeToElement(item.Parameters));
     }
     public static void ValidateStructure(TimelineDefinition timeline) => BuiltinArgumentValidation.ValidateTimelineStructure(timeline);
 }
diff --git a/src/Shared/GalNet.Core/Variants/ImageVariantsBuilder.cs b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsBuilder.cs
similarity index 80%
rename from src/Shared/GalNet.Core/Variants/ImageVariantsBuilder.cs
rename to src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsBuilder.cs
index 037cbba3..490e7f1d 100644
--- a/src/Shared/GalNet.Core/Variants/ImageVariantsBuilder.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsBuilder.cs
@@ -1,6 +1,6 @@
 using System.Globalization;
 
-namespace GalNet.Core.Variants;
+namespace GalNet.Contracts.Builtins.Variants;
 
 /// <summary>Compiles already-enumerated sprite facts; never reads a directory or opens an image.</summary>
 public static class ImageVariantsBuilder
@@ -58,32 +58,29 @@ public static ImageVariantsBuildResult Build(ImageVariantsSource source, IEnumer
 
         var count = variants.Count == 0 ? 0 : variants.Max(item => item.Values.Count);
         var dimensions = new List<ImageVariantDimension>();
-        if (source.Dimensions is null)
-        {
-            for (var position = 0; position < count; position++)
-            {
-                var number = (position + 1).ToString(CultureInfo.InvariantCulture);
-                dimensions.Add(new ImageVariantDimension("d" + number, number, Options(position)));
-            }
-        }
-        else
-        {
-            if (source.Dimensions.Count < count)
-                Error("insufficient-dimensions", "/dimensions", "Dimensions must cover the longest variant name.");
-            var keys = new HashSet<string>(StringComparer.Ordinal);
+        // Author dimensions name positions; files alone determine the active structure.
+        var keys = new HashSet<string>(StringComparer.Ordinal);
+        if (source.Dimensions is not null)
             for (var position = 0; position < source.Dimensions.Count; position++)
             {
                 var item = source.Dimensions[position];
                 var path = $"/dimensions/{position}/key";
                 if (item is null || string.IsNullOrWhiteSpace(item.Key))
-                {
                     Error("invalid-dimension-key", path, "A nonempty dimension key is required.");
-                    continue;
-                }
-                if (!keys.Add(item.Key)) Error("duplicate-dimension-key", path, $"Dimension '{item.Key}' is repeated.");
-                dimensions.Add(new ImageVariantDimension(item.Key,
-                    item.Label ?? (position + 1).ToString(CultureInfo.InvariantCulture), Options(position)));
+                else if (!keys.Add(item.Key))
+                    Error("duplicate-dimension-key", path, $"Dimension '{item.Key}' is repeated.");
+            }
+        for (var position = 0; position < count; position++)
+        {
+            var number = (position + 1).ToString(CultureInfo.InvariantCulture);
+            var item = source.Dimensions is { } configured && position < configured.Count ? configured[position] : null;
+            var key = item?.Key;
+            if (key is null)
+            {
+                key = "d" + number;
+                while (!keys.Add(key)) key += "_";
             }
+            dimensions.Add(new ImageVariantDimension(key, item?.Label ?? number, Options(position)));
         }
 
         return diagnostics.Count > 0
diff --git a/src/Shared/GalNet.Core/Variants/ImageVariantsCatalog.cs b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsCatalog.cs
similarity index 65%
rename from src/Shared/GalNet.Core/Variants/ImageVariantsCatalog.cs
rename to src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsCatalog.cs
index 7433a513..54a85683 100644
--- a/src/Shared/GalNet.Core/Variants/ImageVariantsCatalog.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsCatalog.cs
@@ -1,14 +1,17 @@
 using System.Collections.Frozen;
 
-namespace GalNet.Core.Variants;
+namespace GalNet.Contracts.Builtins.Variants;
 
 /// <summary>One prepared content scope. Definitions are immutable and never resolved through a later scope.</summary>
 public sealed class ImageVariantsCatalog
 {
     private readonly FrozenDictionary<string, ImageVariantsDefinition> _definitions;
+    private readonly FrozenSet<string> _overridden;
     public static ImageVariantsCatalog Empty { get; } = new([]);
 
-    public ImageVariantsCatalog(IEnumerable<KeyValuePair<string, ImageVariantsDefinition>> definitions)
+    public ImageVariantsCatalog(IEnumerable<KeyValuePair<string, ImageVariantsDefinition>> definitions) : this(definitions, null) { }
+
+    public ImageVariantsCatalog(IEnumerable<KeyValuePair<string, ImageVariantsDefinition>> definitions, IEnumerable<string>? overriddenIds)
     {
         ArgumentNullException.ThrowIfNull(definitions);
         var snapshot = new Dictionary<string, ImageVariantsDefinition>(StringComparer.OrdinalIgnoreCase);
@@ -18,8 +21,12 @@ public ImageVariantsCatalog(IEnumerable<KeyValuePair<string, ImageVariantsDefini
                 throw new InvalidDataException("Image variants catalog requires unique nonempty resource IDs and valid definitions.");
         }
         _definitions = snapshot.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);
+        _overridden = (overriddenIds ?? []).Select(id => id.Trim()).ToFrozenSet(StringComparer.OrdinalIgnoreCase);
+        if (_overridden.Any(id => !_definitions.ContainsKey(id))) throw new InvalidDataException("Overridden atlases must belong to this prepared catalog.");
     }
 
+    public bool IsOverridden(string assetId) => _overridden.Contains(assetId.Trim());
+
     public ImageVariantsDefinition Get(string assetId) => _definitions.TryGetValue(assetId.Trim(), out var definition)
         ? definition : throw new InvalidDataException($"Image variants resource '{assetId}' was not prepared for this content scope.");
 }
diff --git a/src/Shared/GalNet.Core/Variants/ImageVariantsDefinition.cs b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsDefinition.cs
similarity index 97%
rename from src/Shared/GalNet.Core/Variants/ImageVariantsDefinition.cs
rename to src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsDefinition.cs
index c1dee349..1274cb32 100644
--- a/src/Shared/GalNet.Core/Variants/ImageVariantsDefinition.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsDefinition.cs
@@ -1,6 +1,6 @@
 using System.Collections.Frozen;
 
-namespace GalNet.Core.Variants;
+namespace GalNet.Contracts.Builtins.Variants;
 
 public sealed class ImageVariantDimension
 {
diff --git a/src/Shared/GalNet.Core/Variants/ImageVariantsResolver.cs b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsResolver.cs
similarity index 99%
rename from src/Shared/GalNet.Core/Variants/ImageVariantsResolver.cs
rename to src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsResolver.cs
index 24e43276..a4071ff0 100644
--- a/src/Shared/GalNet.Core/Variants/ImageVariantsResolver.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsResolver.cs
@@ -1,6 +1,6 @@
 using System.Collections.Frozen;
 
-namespace GalNet.Core.Variants;
+namespace GalNet.Contracts.Builtins.Variants;
 
 public enum ImageVariantResolutionReason
 {
diff --git a/src/Shared/GalNet.Core/Variants/ImageVariantsSource.cs b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsSource.cs
similarity index 97%
rename from src/Shared/GalNet.Core/Variants/ImageVariantsSource.cs
rename to src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsSource.cs
index 8e4397ff..eb4cb90d 100644
--- a/src/Shared/GalNet.Core/Variants/ImageVariantsSource.cs
+++ b/src/Shared/GalNet.Contracts.Builtins/Variants/ImageVariantsSource.cs
@@ -1,6 +1,6 @@
 using System.Text.Json.Serialization;
 
-namespace GalNet.Core.Variants;
+namespace GalNet.Contracts.Builtins.Variants;
 
 /// <summary>Author description; directory enumeration belongs to the host, not Core.</summary>
 public sealed class ImageVariantsSource
diff --git a/src/Shared/GalNet.Contracts.Builtins/packages.lock.WindowsReadyToRun.json b/src/Shared/GalNet.Contracts.Builtins/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..c135c208
--- /dev/null
+++ b/src/Shared/GalNet.Contracts.Builtins/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,11 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Shared/GalNet.Core/Assets/AssetMeta.cs b/src/Shared/GalNet.Core/Assets/AssetMeta.cs
index 7e7bf9fb..a6b852c2 100644
--- a/src/Shared/GalNet.Core/Assets/AssetMeta.cs
+++ b/src/Shared/GalNet.Core/Assets/AssetMeta.cs
@@ -1,5 +1,3 @@
-using GalNet.Core.Gallery;
-
 namespace GalNet.Core.Assets;
 
 /// <summary>Common, portable metadata written beside every asset.</summary>
@@ -19,10 +17,6 @@ public class AssetMeta
     [System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
     public string? Compress { get; set; }
 
-    [System.Text.Json.Serialization.JsonPropertyName("gallery")]
-    [System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
-    public List<GalleryAnnotation>? Gallery { get; set; }
-
     /// <summary>Fields not understood by the current DTO are retained when metadata is rewritten.</summary>
     [System.Text.Json.Serialization.JsonExtensionData]
     public Dictionary<string, System.Text.Json.JsonElement>? ExtensionData { get; set; }
@@ -36,17 +30,3 @@ public class AssetMeta
         _ => CompressionMode.None,
     };
 }
-
-public sealed class SpriteAssetMeta : AssetMeta
-{
-    [System.Text.Json.Serialization.JsonPropertyName("filter")]
-    [System.Text.Json.Serialization.JsonIgnore(Condition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull)]
-    public string? Filter { get; set; }
-}
-
-public sealed class AudioAssetMeta : AssetMeta;
-public sealed class VideoAssetMeta : AssetMeta;
-public sealed class ImageVariantsAssetMeta : AssetMeta;
-public sealed class FontAssetMeta : AssetMeta;
-public sealed class EffectProgramAssetMeta : AssetMeta;
-public sealed class BinaryAssetMeta : AssetMeta;
diff --git a/src/Shared/GalNet.Core/Assets/AssetMetaCodec.cs b/src/Shared/GalNet.Core/Assets/AssetMetaCodec.cs
index a1e299d2..94be9b72 100644
--- a/src/Shared/GalNet.Core/Assets/AssetMetaCodec.cs
+++ b/src/Shared/GalNet.Core/Assets/AssetMetaCodec.cs
@@ -1,11 +1,13 @@
 using System.Text.Json;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Core.Assets;
 
 /// <summary>Two-step metadata codec selected by stable type IDs, never CLR type names.</summary>
 public sealed class AssetMetaCodec(IResourceTypeCatalog resourceTypes, JsonSerializerOptions? options = null)
 {
-    private readonly JsonSerializerOptions _options = options ?? new JsonSerializerOptions(JsonSerializerDefaults.Web);
+    private readonly JsonSerializerOptions _options = JsonMetadata.Prepare(options ?? new JsonSerializerOptions(JsonSerializerDefaults.Web));
+    private readonly System.Collections.Concurrent.ConcurrentDictionary<string, JsonSerializerOptions> _metadataOptions = new(StringComparer.Ordinal);
     public AssetMeta Deserialize(string json, string? pathHint = null)
     {
         JsonDocument document;
@@ -32,7 +34,7 @@ public string Serialize(AssetMeta meta)
         ArgumentNullException.ThrowIfNull(meta);
         var registration = resourceTypes.Get(meta.TypeId);
         if (!registration.MetaDtoType.IsInstanceOfType(meta)) throw new InvalidDataException($"Metadata for '{meta.TypeId}' must use '{registration.MetaDtoType.Name}'.");
-        return JsonSerializer.Serialize(meta, registration.MetaDtoType, _options);
+        return JsonCodec.Serialize(meta, registration.MetaDtoType, Options(registration));
     }
 
     private string ReadTypeId(JsonElement root, string? pathHint)
@@ -41,23 +43,26 @@ private string ReadTypeId(JsonElement root, string? pathHint)
         if (!string.IsNullOrWhiteSpace(declared)) return resourceTypes.NormalizeTypeId(declared);
         var extension = Path.GetExtension(pathHint ?? "");
         if (resourceTypes.TryGetByExtension(extension, out var inferred)) return inferred.TypeId;
-        return "data";
+        return resourceTypes.DefaultTypeId ?? throw new InvalidDataException("Asset metadata requires a type or a catalog-defined default for this extension.");
     }
 
     private AssetMeta DeserializeOrDefault(string json, ResourceTypeRegistration registration, string typeId)
     {
         try
         {
-            return (AssetMeta?)JsonSerializer.Deserialize(json, registration.MetaDtoType, _options)
+            return (AssetMeta?)JsonCodec.Deserialize(json, registration.MetaDtoType, Options(registration))
                 ?? throw new InvalidDataException($"Metadata for '{typeId}' is empty.");
         }
         catch (JsonException)
         {
-            return (AssetMeta)(Activator.CreateInstance(registration.MetaDtoType)
-                ?? throw new InvalidDataException($"Metadata type '{registration.MetaDtoType.Name}' cannot be created."));
+            return registration.Create?.Invoke()
+                ?? throw new InvalidDataException($"Metadata type '{registration.MetaDtoType.Name}' requires a registered creation factory.");
         }
     }
 
+    private JsonSerializerOptions Options(ResourceTypeRegistration registration) =>
+        _metadataOptions.GetOrAdd(registration.TypeId, _ => JsonMetadata.CreateOptions(_options, registration.JsonResolver));
+
     private static string ReadRequiredString(JsonElement root, string name) =>
         ReadOptionalString(root, name) is { Length: > 0 } value
             ? value
diff --git a/src/Shared/GalNet.Core/Assets/BuiltinResourceTypes.cs b/src/Shared/GalNet.Core/Assets/BuiltinResourceTypes.cs
deleted file mode 100644
index 2bda6941..00000000
--- a/src/Shared/GalNet.Core/Assets/BuiltinResourceTypes.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-namespace GalNet.Core.Assets;
-
-public static class BuiltinResourceTypes
-{
-    public static IResourceTypeCatalog CreateCatalog() => new ResourceTypeCatalogBuilder()
-        .Add<SpriteAssetMeta>("sprite", ".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif", ".avif")
-        .Add<ImageVariantsAssetMeta>("image-variants", ".variants")
-        .Add<AudioAssetMeta>("audio", ".mp3", ".wav", ".ogg", ".flac")
-        .Add<VideoAssetMeta>("video", ".mp4", ".webm", ".mkv")
-        .Add<FontAssetMeta>("font", ".ttf", ".otf", ".woff", ".woff2")
-        .Add<EffectProgramAssetMeta>("effect-program", ".sksl")
-        .Add<BinaryAssetMeta>("data")
-        .Build();
-}
diff --git a/src/Shared/GalNet.Core/Assets/IAssetDependencies.cs b/src/Shared/GalNet.Core/Assets/IAssetDependencies.cs
new file mode 100644
index 00000000..4d6bf263
--- /dev/null
+++ b/src/Shared/GalNet.Core/Assets/IAssetDependencies.cs
@@ -0,0 +1,21 @@
+namespace GalNet.Core.Assets;
+
+/// <summary>Direct references from an effective metadata snapshot, never a recursive loader.</summary>
+public interface IAssetDependencies
+{
+    AssetDependencyInfo GetDependencies();
+}
+
+public sealed record AssetDependency(string AssetId, string? ExpectedTypeId = null, string? RequiredStoryPackage = null);
+
+public sealed record AssetDependencyInfo(IReadOnlyList<AssetDependency> Direct, bool Complete);
+
+/// <summary>Metadata for payloads whose compiler supplies their direct references.</summary>
+public class DependentAssetMeta : AssetMeta, IAssetDependencies
+{
+    public List<AssetDependency> Dependencies { get; set; } = [];
+    public bool DependenciesComplete { get; set; }
+
+    public AssetDependencyInfo GetDependencies() => new(
+        (Dependencies ?? throw new InvalidDataException("Dependency metadata cannot contain a null list.")).ToArray(), DependenciesComplete);
+}
diff --git a/src/Shared/GalNet.Core/Assets/IAssetOverrideFile.cs b/src/Shared/GalNet.Core/Assets/IAssetOverrideFile.cs
new file mode 100644
index 00000000..576a233f
--- /dev/null
+++ b/src/Shared/GalNet.Core/Assets/IAssetOverrideFile.cs
@@ -0,0 +1,7 @@
+namespace GalNet.Core.Assets;
+
+/// <summary>Runtime provenance of a logical file explicitly resolved through a resource override.</summary>
+public interface IAssetOverrideFile
+{
+    bool IsResourceOverride { get; }
+}
diff --git a/src/Shared/GalNet.Core/Assets/PakAssetIndexEntry.cs b/src/Shared/GalNet.Core/Assets/PakAssetIndexEntry.cs
new file mode 100644
index 00000000..a007ed4c
--- /dev/null
+++ b/src/Shared/GalNet.Core/Assets/PakAssetIndexEntry.cs
@@ -0,0 +1,4 @@
+namespace GalNet.Core.Assets;
+
+/// <summary>Archive table facts without decoding the resource payload.</summary>
+public sealed record PakAssetIndexEntry(string Id, string Path, string TypeId, AssetMeta Metadata, long Length, string Hash);
diff --git a/src/Shared/GalNet.Core/Assets/PakDescriptor.cs b/src/Shared/GalNet.Core/Assets/PakDescriptor.cs
new file mode 100644
index 00000000..e8d0c349
--- /dev/null
+++ b/src/Shared/GalNet.Core/Assets/PakDescriptor.cs
@@ -0,0 +1,58 @@
+namespace GalNet.Core.Assets;
+
+/// <summary>Archive control data, separate from addressable resource metadata.</summary>
+public sealed record PakDescriptor
+{
+    public string Kind { get; init; } = "base";
+    public string ProjectId { get; init; } = "";
+    public string BuildId { get; init; } = "";
+    public string PackageId { get; init; } = "";
+    public int PartIndex { get; init; }
+    public int PartCount { get; init; } = 1;
+    public int Priority { get; init; }
+    public Dictionary<string, string> Mappings { get; init; } = new(StringComparer.OrdinalIgnoreCase);
+
+    public void Validate()
+    {
+        if (Kind is not ("base" or "story" or "override"))
+            throw new InvalidDataException($"Unsupported PAK kind '{Kind}'.");
+        if (PartCount < 1 || PartIndex < 0 || PartIndex >= PartCount)
+            throw new InvalidDataException("Invalid PAK part index/count.");
+        if (ProjectId is null || BuildId is null || PackageId is null || Mappings is null)
+            throw new InvalidDataException("PAK control fields cannot be null.");
+        if (Kind != "override" && string.IsNullOrWhiteSpace(ProjectId) != string.IsNullOrWhiteSpace(BuildId))
+            throw new InvalidDataException("PAK project and build identities must be supplied together.");
+        if (Kind == "story" && (string.IsNullOrWhiteSpace(ProjectId) || string.IsNullOrWhiteSpace(PackageId)))
+            throw new InvalidDataException("Story PAKs require project, build and package identities.");
+        if (Kind != "override" && (Mappings.Count != 0 || Priority != 0))
+            throw new InvalidDataException("Only override PAKs may contain mappings or priority.");
+        if (Kind == "override" && (string.IsNullOrWhiteSpace(PackageId) || PartCount != 1))
+            throw new InvalidDataException("Override PAKs require a package identity and one part.");
+        if (Kind == "base" && PackageId.Length != 0)
+            throw new InvalidDataException("Base PAKs cannot declare a story/override package identity.");
+        var sources = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var (source, target) in Mappings)
+        {
+            if (string.IsNullOrWhiteSpace(source) || string.IsNullOrWhiteSpace(target)
+                || source != source.Trim() || target != target.Trim() || !sources.Add(source)
+                || StringComparer.OrdinalIgnoreCase.Equals(source, target))
+                throw new InvalidDataException("Override mappings require distinct, non-empty canonical source/target IDs.");
+        }
+        var lookup = new Dictionary<string, string>(Mappings, StringComparer.OrdinalIgnoreCase);
+        foreach (var source in lookup.Keys)
+        {
+            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            var current = source;
+            while (lookup.TryGetValue(current, out var target))
+            {
+                if (!seen.Add(current)) throw new InvalidDataException("Override mappings cannot form a cycle.");
+                current = target;
+            }
+        }
+    }
+}
+
+public interface IPakArchive : IArchive
+{
+    PakDescriptor Descriptor { get; }
+}
diff --git a/src/Shared/GalNet.Core/Assets/ResourceTypeCatalog.cs b/src/Shared/GalNet.Core/Assets/ResourceTypeCatalog.cs
index 0c4598d4..da09ecdb 100644
--- a/src/Shared/GalNet.Core/Assets/ResourceTypeCatalog.cs
+++ b/src/Shared/GalNet.Core/Assets/ResourceTypeCatalog.cs
@@ -1,13 +1,20 @@
 using System.Collections.Frozen;
 using System.Collections.ObjectModel;
+using System.Text.Json.Serialization.Metadata;
 
 namespace GalNet.Core.Assets;
 
-public sealed record ResourceTypeRegistration(string TypeId, Type MetaDtoType, IReadOnlyList<string> Extensions);
+public sealed record ResourceTypeRegistration(string TypeId, Type MetaDtoType, IReadOnlyList<string> Extensions)
+{
+    public IJsonTypeInfoResolver? JsonResolver { get; init; }
+    public Func<AssetMeta>? Create { get; init; }
+    public bool HasNoDependencies { get; init; }
+}
 
 public interface IResourceTypeCatalog
 {
     IReadOnlyList<ResourceTypeRegistration> Types { get; }
+    string? DefaultTypeId { get; }
     ResourceTypeRegistration Get(string typeId);
     bool TryGet(string? typeId, out ResourceTypeRegistration registration);
     bool TryGetByExtension(string? extension, out ResourceTypeRegistration registration);
@@ -16,11 +23,22 @@ public interface IResourceTypeCatalog
 
 public sealed class ResourceTypeCatalogBuilder
 {
-    private readonly Dictionary<string, Type> _registrations = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, (Type Type, IJsonTypeInfoResolver? Resolver, Func<AssetMeta> Create)> _registrations = new(StringComparer.Ordinal);
     private readonly List<(string TypeId, string Extension)> _extensions = [];
+    private string? _defaultTypeId;
+    private readonly HashSet<string> _leafTypes = new(StringComparer.Ordinal);
+    public ResourceTypeCatalogBuilder WithoutDependencies(params string[] typeIds)
+    {
+        foreach (var id in typeIds) _leafTypes.Add(ResourceTypeCatalog.NormalizeTypeIdCore(id));
+        return this;
+    }
+    public ResourceTypeCatalogBuilder DefaultType(string typeId)
+    { _defaultTypeId = ResourceTypeCatalog.NormalizeTypeIdCore(typeId); return this; }
 
-    public ResourceTypeCatalogBuilder Add<TMeta>(string typeId, params string[] extensions) where TMeta : AssetMeta => Add(typeId, typeof(TMeta), false, extensions);
-    public ResourceTypeCatalogBuilder Replace<TMeta>(string typeId, params string[] extensions) where TMeta : AssetMeta => Add(typeId, typeof(TMeta), true, extensions);
+    public ResourceTypeCatalogBuilder Add<TMeta>(string typeId, params string[] extensions) where TMeta : AssetMeta, new() => Add(typeId, typeof(TMeta), false, extensions, null, static () => new TMeta());
+    public ResourceTypeCatalogBuilder Replace<TMeta>(string typeId, params string[] extensions) where TMeta : AssetMeta, new() => Add(typeId, typeof(TMeta), true, extensions, null, static () => new TMeta());
+    public ResourceTypeCatalogBuilder Add<TMeta>(string typeId, IJsonTypeInfoResolver resolver, params string[] extensions) where TMeta : AssetMeta, new() => Add(typeId, typeof(TMeta), false, extensions, resolver, static () => new TMeta());
+    public ResourceTypeCatalogBuilder Replace<TMeta>(string typeId, IJsonTypeInfoResolver resolver, params string[] extensions) where TMeta : AssetMeta, new() => Add(typeId, typeof(TMeta), true, extensions, resolver, static () => new TMeta());
     public ResourceTypeCatalogBuilder AddExtensions(string typeId, params string[] extensions)
     {
         var normalizedType = ResourceTypeCatalog.NormalizeTypeIdCore(typeId);
@@ -30,6 +48,8 @@ public ResourceTypeCatalogBuilder AddExtensions(string typeId, params string[] e
 
     public IResourceTypeCatalog Build()
     {
+        foreach (var id in _leafTypes)
+            if (!_registrations.ContainsKey(id)) throw new InvalidOperationException($"Leaf resource type '{id}' is not registered.");
         var owners = new Dictionary<string, string>(StringComparer.Ordinal);
         var byType = _registrations.Keys.ToDictionary(key => key, _ => new List<string>(), StringComparer.Ordinal);
         foreach (var (typeId, extension) in _extensions)
@@ -39,16 +59,20 @@ public IResourceTypeCatalog Build()
             owners[extension] = typeId;
             if (!values.Contains(extension, StringComparer.Ordinal)) values.Add(extension);
         }
+        if (_defaultTypeId is not null && !_registrations.ContainsKey(_defaultTypeId))
+            throw new InvalidOperationException($"Default resource type '{_defaultTypeId}' must be registered.");
         return new ResourceTypeCatalog(_registrations.OrderBy(pair => pair.Key, StringComparer.Ordinal).Select(pair =>
-            new ResourceTypeRegistration(pair.Key, pair.Value, new ReadOnlyCollection<string>(byType[pair.Key].OrderBy(item => item, StringComparer.Ordinal).ToList()))).ToList());
+            new ResourceTypeRegistration(pair.Key, pair.Value.Type, new ReadOnlyCollection<string>(byType[pair.Key].OrderBy(item => item, StringComparer.Ordinal).ToList()))
+            { JsonResolver = pair.Value.Resolver, Create = pair.Value.Create, HasNoDependencies = _leafTypes.Contains(pair.Key) }).ToList(), _defaultTypeId);
     }
 
-    private ResourceTypeCatalogBuilder Add(string typeId, Type metaType, bool replace, IEnumerable<string> extensions)
+    private ResourceTypeCatalogBuilder Add(string typeId, Type metaType, bool replace, IEnumerable<string> extensions,
+        IJsonTypeInfoResolver? resolver, Func<AssetMeta> create)
     {
         var normalized = ResourceTypeCatalog.NormalizeTypeIdCore(typeId);
-        if (!typeof(AssetMeta).IsAssignableFrom(metaType) || metaType.IsAbstract || metaType.GetConstructor(Type.EmptyTypes) is null) throw new ArgumentException($"'{metaType}' must be a concrete AssetMeta DTO with a parameterless constructor.", nameof(metaType));
         if (_registrations.ContainsKey(normalized) && !replace) throw new InvalidOperationException($"Resource type '{normalized}' is already fully registered. Use Replace explicitly.");
-        _registrations[normalized] = metaType;
+        if (replace) _leafTypes.Remove(normalized);
+        _registrations[normalized] = (metaType, resolver, create);
         return AddExtensions(normalized, extensions.ToArray());
     }
 }
@@ -57,13 +81,15 @@ public sealed class ResourceTypeCatalog : IResourceTypeCatalog
 {
     private readonly FrozenDictionary<string, ResourceTypeRegistration> _byType;
     private readonly FrozenDictionary<string, ResourceTypeRegistration> _byExtension;
-    internal ResourceTypeCatalog(IReadOnlyList<ResourceTypeRegistration> types)
+    internal ResourceTypeCatalog(IReadOnlyList<ResourceTypeRegistration> types, string? defaultTypeId)
     {
+        DefaultTypeId = defaultTypeId;
         Types = new ReadOnlyCollection<ResourceTypeRegistration>(types.ToList());
         _byType = types.ToFrozenDictionary(type => type.TypeId, StringComparer.Ordinal);
         _byExtension = types.SelectMany(type => type.Extensions.Select(extension => (extension, type))).ToFrozenDictionary(pair => pair.extension, pair => pair.type, StringComparer.Ordinal);
     }
     public IReadOnlyList<ResourceTypeRegistration> Types { get; }
+    public string? DefaultTypeId { get; }
     public ResourceTypeRegistration Get(string typeId) => TryGet(typeId, out var result) ? result : throw new KeyNotFoundException($"Resource type '{typeId}' is not registered.");
     public bool TryGet(string? typeId, out ResourceTypeRegistration registration)
     {
diff --git a/src/Shared/GalNet.Core/Assets/StoryResourceIds.cs b/src/Shared/GalNet.Core/Assets/StoryResourceIds.cs
new file mode 100644
index 00000000..d301cd82
--- /dev/null
+++ b/src/Shared/GalNet.Core/Assets/StoryResourceIds.cs
@@ -0,0 +1,12 @@
+namespace GalNet.Core.Assets;
+
+/// <summary>Reserved identities for the one graph and its stable node-owned group resources.</summary>
+public static class StoryResourceIds
+{
+    public const string Graph = "galnet:graph:main";
+    public static string Group(string nodeId)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(nodeId);
+        return "galnet:group:" + nodeId;
+    }
+}
diff --git a/src/Shared/GalNet.Core/Audio/AudioState.cs b/src/Shared/GalNet.Core/Audio/AudioState.cs
deleted file mode 100644
index 41245dee..00000000
--- a/src/Shared/GalNet.Core/Audio/AudioState.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System.Text.Json;
-
-namespace GalNet.Core.Audio;
-
-/// <summary>Only logical playback data; backend IDs and tickets are deliberately separate.</summary>
-public sealed class AudioItemState
-{
-    public string Id { get; init; } = Guid.NewGuid().ToString("N");
-    public AudioPlayRequest Request { get; set; } = new("", "", AudioPlacement.Enqueue);
-}
-
-public sealed class AudioTrackState
-{
-    public string Id { get; init; } = "";
-    public bool Paused { get; set; }
-    public List<AudioItemState> Active { get; init; } = [];
-    public List<AudioItemState> Pending { get; init; } = [];
-}
-
-public sealed record AudioSEffectState(string TrackId, string InstanceId, string SEffectId, JsonElement Parameters)
-{
-    // JSON array encoding preserves the existing track-local identity without separator collisions.
-    public static string Key(string trackId, string instanceId) => JsonSerializer.Serialize(new[] { trackId, instanceId });
-}
diff --git a/src/Shared/GalNet.Core/Audio/AudioTrackDefinition.cs b/src/Shared/GalNet.Core/Audio/AudioTrackDefinition.cs
deleted file mode 100644
index f9a0a75d..00000000
--- a/src/Shared/GalNet.Core/Audio/AudioTrackDefinition.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-namespace GalNet.Core.Audio;
-
-/// <summary>Fixed mixer routes exposed by the first audio feature.</summary>
-public static class AudioBuses
-{
-    public const string Bgm = "bgm";
-    public const string Sfx = "sfx";
-    public const string Vocal = "vocal";
-
-    public static bool IsValid(string? value) => value is Bgm or Sfx or Vocal;
-}
-
-public enum AudioOverflowPolicy
-{
-    DropNewest,
-    StopOldest
-}
-
-public enum AudioQueueOverflowPolicy
-{
-    DropNewest,
-    DropOldest
-}
-
-/// <summary>Author-configured logical route, independent from backend players.</summary>
-public sealed class AudioTrackDefinition
-{
-    public string Id { get; set; } = "";
-    public string Name { get; set; } = "";
-    public string Bus { get; set; } = AudioBuses.Sfx;
-    public float DefaultGain { get; set; } = 1f;
-    public int MaxVoices { get; set; } = 1;
-    public int MaxQueuedItems { get; set; }
-    public AudioOverflowPolicy OverflowPolicy { get; set; } = AudioOverflowPolicy.DropNewest;
-    public AudioQueueOverflowPolicy QueueOverflowPolicy { get; set; } = AudioQueueOverflowPolicy.DropNewest;
-
-    public static List<AudioTrackDefinition> CreateDefaults() =>
-    [
-        new() { Id = AudioBuses.Bgm, Name = "背景音乐", Bus = AudioBuses.Bgm, DefaultGain = .8f, MaxVoices = 1, MaxQueuedItems = 64, OverflowPolicy = AudioOverflowPolicy.StopOldest },
-        new() { Id = AudioBuses.Sfx, Name = "音效", Bus = AudioBuses.Sfx, DefaultGain = 1f, MaxVoices = 8, MaxQueuedItems = 0, OverflowPolicy = AudioOverflowPolicy.DropNewest },
-        new() { Id = AudioBuses.Vocal, Name = "语音", Bus = AudioBuses.Vocal, DefaultGain = 1f, MaxVoices = 1, MaxQueuedItems = 64, OverflowPolicy = AudioOverflowPolicy.StopOldest }
-    ];
-}
diff --git a/src/Shared/GalNet.Core/Audio/SEffectCatalog.cs b/src/Shared/GalNet.Core/Audio/SEffectCatalog.cs
deleted file mode 100644
index bcdf5cae..00000000
--- a/src/Shared/GalNet.Core/Audio/SEffectCatalog.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-using System.Text.Json;
-
-namespace GalNet.Core.Audio;
-
-/// <summary>The attachment targets supported by an audio effect descriptor.</summary>
-public enum SEffectScope { Track, Item }
-
-/// <summary>Metadata for one numeric parameter accepted by a sound effect.</summary>
-public sealed record SEffectParameterDefinition(
-    string Name,
-    bool Required = false,
-    float? Minimum = null,
-    float? Maximum = null);
-
-/// <summary>Platform-neutral authoring metadata for one named audio effect.</summary>
-public sealed record SEffectDefinition(
-    string Id,
-    IReadOnlySet<SEffectScope> SupportedScopes,
-    IReadOnlyList<SEffectParameterDefinition> Parameters);
-
-public interface ISEffectCatalog
-{
-    IReadOnlyList<SEffectDefinition> Definitions { get; }
-    bool TryGet(string id, out SEffectDefinition definition);
-    IReadOnlyList<string> Validate(string id, SEffectScope scope, JsonElement parameters);
-}
-
-/// <summary>Immutable effect metadata registry supplied by the active playback host.</summary>
-public sealed class SEffectCatalog : ISEffectCatalog
-{
-    private readonly IReadOnlyDictionary<string, SEffectDefinition> _byId;
-
-    public SEffectCatalog(IEnumerable<SEffectDefinition> definitions)
-    {
-        _byId = definitions.ToDictionary(definition => definition.Id, StringComparer.OrdinalIgnoreCase);
-        Definitions = _byId.Values.OrderBy(definition => definition.Id, StringComparer.OrdinalIgnoreCase).ToArray();
-    }
-
-    public static SEffectCatalog Empty { get; } = new([]);
-    public static SEffectCatalog Builtins { get; } = new([
-        new("seffect.gain", new HashSet<SEffectScope> { SEffectScope.Track }, [new("gain", Required: true, Minimum: 0, Maximum: 1)]),
-        new("seffect.lowPass", new HashSet<SEffectScope> { SEffectScope.Track },
-            [new("cutoffHz", Required: true, Minimum: 20, Maximum: 20_000), new("attenuationDb", Minimum: -20, Maximum: 0)]),
-        new("seffect.highPass", new HashSet<SEffectScope> { SEffectScope.Track },
-            [new("cutoffHz", Required: true, Minimum: 20, Maximum: 20_000), new("attenuationDb", Minimum: -20, Maximum: 0)])]);
-    public IReadOnlyList<SEffectDefinition> Definitions { get; }
-    public bool TryGet(string id, out SEffectDefinition definition) => _byId.TryGetValue(id, out definition!);
-
-    public IReadOnlyList<string> Validate(string id, SEffectScope scope, JsonElement parameters)
-    {
-        if (!TryGet(id, out var definition)) return [$"Unsupported SEffect '{id}'."];
-        if (!definition.SupportedScopes.Contains(scope)) return [$"SEffect '{id}' does not support {scope} scope."];
-        if (parameters.ValueKind != JsonValueKind.Object) return [$"SEffect '{id}' parameters must be a JSON object."];
-
-        var declared = definition.Parameters.ToDictionary(parameter => parameter.Name, StringComparer.Ordinal);
-        var diagnostics = new List<string>();
-        foreach (var value in parameters.EnumerateObject())
-        {
-            if (!declared.TryGetValue(value.Name, out var parameter))
-            {
-                diagnostics.Add($"SEffect '{id}' does not declare parameter '{value.Name}'.");
-                continue;
-            }
-            if (value.Value.ValueKind != JsonValueKind.Number || !value.Value.TryGetSingle(out var number) || !float.IsFinite(number))
-            {
-                diagnostics.Add($"SEffect parameter '{value.Name}' must be a finite number.");
-                continue;
-            }
-            if (parameter.Minimum is { } minimum && number < minimum || parameter.Maximum is { } maximum && number > maximum)
-                diagnostics.Add($"SEffect parameter '{value.Name}' is outside its supported range.");
-        }
-        foreach (var parameter in definition.Parameters.Where(parameter => parameter.Required && !parameters.TryGetProperty(parameter.Name, out _)))
-            diagnostics.Add($"SEffect '{id}' requires parameter '{parameter.Name}'.");
-        return diagnostics;
-    }
-}
diff --git a/src/Shared/GalNet.Core/Compilation/GalgroupCompiler.cs b/src/Shared/GalNet.Core/Compilation/GalgroupCompiler.cs
index 75cb914e..74c8558c 100644
--- a/src/Shared/GalNet.Core/Compilation/GalgroupCompiler.cs
+++ b/src/Shared/GalNet.Core/Compilation/GalgroupCompiler.cs
@@ -1,9 +1,7 @@
 using System.Text.Json;
-using System.Text.Json.Serialization;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
 using GalNet.Core.Serialization;
 
 namespace GalNet.Core.Compilation;
@@ -11,14 +9,19 @@ namespace GalNet.Core.Compilation;
 /// <summary>Compiles editor-source group documents into Runtime-only primitive documents.</summary>
 public static class GalgroupCompiler
 {
-    private static readonly JsonSerializerOptions JsonOptions = new()
-    {
-        PropertyNameCaseInsensitive = true,
-        Converters = { new JsonStringEnumConverter() }
-    };
-
     /// <summary>Expands every non-primitive entry and returns a deterministic compiled document plus source mapping.</summary>
     public static CompiledGroupResult Compile(GroupDocument source, IEntryCatalog catalog)
+        => CompileCore(source, catalog, null);
+
+    /// <summary>Compiles once while collecting entry-local errors; failed analyses expose no partial output.</summary>
+    public static GroupCompilationAnalysis Analyze(GroupDocument source, IEntryCatalog catalog)
+    {
+        var errors = new List<GroupCompilationIssue>();
+        var result = CompileCore(source, catalog, errors);
+        return new(errors.Count == 0 ? result : null, errors.AsReadOnly());
+    }
+
+    private static CompiledGroupResult CompileCore(GroupDocument source, IEntryCatalog catalog, List<GroupCompilationIssue>? errors)
     {
         ArgumentNullException.ThrowIfNull(catalog);
         if (source.Version != GroupDocument.CurrentVersion) throw new InvalidDataException($"Unsupported .rawgalgroup version '{source.Version}'.");
@@ -30,46 +33,55 @@ public static CompiledGroupResult Compile(GroupDocument source, IEntryCatalog ca
 
         foreach (var (sourceEntry, sourceIndex) in source.Entries.Select((entry, index) => (entry, index)))
         {
-            if (string.IsNullOrWhiteSpace(sourceEntry.Id) || !stableIds.Add(sourceEntry.Id))
-                throw new InvalidDataException($"Source entry #{sourceIndex + 1} must have a unique non-empty id.");
-
-            var entry = CreateEntry(sourceEntry, sourceIndex + 1, catalog);
-            IReadOnlyList<PrimitiveEntry> primitives = entry switch
+            var parametersReady = false;
+            try
             {
-                PrimitiveEntry primitive => [primitive],
-                CompositeEntry composite => composite.Compile(new EntryCompileContext
+                if (string.IsNullOrWhiteSpace(sourceEntry.Id) || !stableIds.Add(sourceEntry.Id))
+                    throw new InvalidDataException($"Source entry #{sourceIndex + 1} must have a unique non-empty id.");
+
+                var entry = CreateEntry(sourceEntry, sourceIndex + 1, catalog);
+                parametersReady = true;
+                IReadOnlyList<PrimitiveEntry> primitives = entry switch
                 {
-                    SourceEntryId = sourceEntry.Id,
-                    Condition = sourceEntry.Condition
-                }),
-                _ => throw new InvalidDataException($"Entry '{sourceEntry.Type}' is neither a primitive nor a composite entry.")
-            };
-
-            var emittedIds = new List<string>(primitives.Count);
-            var readingIndices = primitives.Select((primitive, index) => (primitive, index))
-                .Where(item => catalog.Get(item.primitive.Type).IsReading).Select(item => item.index).ToArray();
-            if (readingIndices.Length > 1)
-                throw new InvalidDataException($"Composite '{sourceEntry.Id}' contains multiple reading boundaries. Split it into separate source entries.");
-            var readingIndex = readingIndices.FirstOrDefault(-1);
-            if (readingIndex >= 0)
-            {
-                if (primitives.Take(readingIndex + 1).Any(primitive => primitive.Condition != primitives[readingIndex].Condition))
-                    throw new InvalidDataException($"Composite '{sourceEntry.Id}' has inconsistent reading-boundary conditions.");
-                primitives[0].ReadingBoundaryId = $"{sourceEntry.Id}#{readingIndex + 1}";
+                    PrimitiveEntry primitive => [primitive],
+                    CompositeEntry composite => composite.Compile(new EntryCompileContext
+                    {
+                        SourceEntryId = sourceEntry.Id,
+                        Condition = sourceEntry.Condition
+                    }),
+                    _ => throw new InvalidDataException($"Entry '{sourceEntry.Type}' is neither a primitive nor a composite entry.")
+                };
+
+                var emittedIds = new List<string>(primitives.Count);
+                var readingIndices = primitives.Select((primitive, index) => (primitive, index))
+                    .Where(item => catalog.Get(item.primitive.Type).IsReading).Select(item => item.index).ToArray();
+                if (readingIndices.Length > 1)
+                    throw new InvalidDataException($"Composite '{sourceEntry.Id}' contains multiple reading boundaries. Split it into separate source entries.");
+                var readingIndex = readingIndices.FirstOrDefault(-1);
+                if (readingIndex >= 0)
+                {
+                    if (primitives.Take(readingIndex + 1).Any(primitive => primitive.Condition != primitives[readingIndex].Condition))
+                        throw new InvalidDataException($"Composite '{sourceEntry.Id}' has inconsistent reading-boundary conditions.");
+                    primitives[0].ReadingBoundaryId = $"{sourceEntry.Id}#{readingIndex + 1}";
+                }
+                for (var emittedIndex = 0; emittedIndex < primitives.Count; emittedIndex++)
+                {
+                    var primitive = primitives[emittedIndex];
+                    primitive.Id = compiled.Entries.Count + 1;
+                    primitive.Condition = CombineConditions(sourceEntry.Condition, primitive.Condition);
+                    var generatedId = $"{sourceEntry.Id}#{emittedIndex + 1}";
+                    if (entry is CompositeEntry)
+                        primitive.SetArguments(PrimitiveArgumentHelper.Normalize(catalog.Get(primitive.Type).DynamicParameters, primitive.Arguments));
+                    compiled.Entries.Add(SerializeEntry(generatedId, primitive));
+                    emittedIds.Add(generatedId);
+                }
+
+                sourceMap.Add(sourceEntry.Id, emittedIds);
             }
-            for (var emittedIndex = 0; emittedIndex < primitives.Count; emittedIndex++)
+            catch (Exception exception) when (errors is not null)
             {
-                var primitive = primitives[emittedIndex];
-                primitive.Id = compiled.Entries.Count + 1;
-                primitive.Condition = CombineConditions(sourceEntry.Condition, primitive.Condition);
-                var generatedId = $"{sourceEntry.Id}#{emittedIndex + 1}";
-                var schema = catalog.Get(primitive.Type);
-                primitive.SetArguments(PrimitiveArgumentHelper.Normalize(schema.DynamicParameters!, primitive.Arguments));
-                compiled.Entries.Add(SerializeEntry(generatedId, primitive));
-                emittedIds.Add(generatedId);
+                errors.Add(new(sourceIndex, !parametersReady, exception.Message));
             }
-
-            sourceMap.Add(sourceEntry.Id, emittedIds);
         }
 
         return new CompiledGroupResult(compiled, sourceMap);
@@ -79,33 +91,25 @@ public static CompiledGroupResult Compile(GroupDocument source, IEntryCatalog ca
     private static Entry.Entry CreateEntry(GroupEntryDocument source, int index, IEntryCatalog catalog)
     {
         if (string.IsNullOrWhiteSpace(source.Type)) throw new InvalidDataException("Source entry type is required.");
-        RejectLegacyLayerTransitionParameters(source);
+
         try
         {
             var definition = catalog.Get(source.Type);
             if (definition.Kind == EntryKind.Primitive)
             {
-                var parameters = definition.DynamicParameters ?? throw new InvalidDataException($"Primitive '{source.Type}' has no dynamic parameter schema.");
-                var rawArguments = JsonSerializer.SerializeToElement(source.Parameters);
+                var parameters = definition.DynamicParameters;
+                var rawArguments = JsonCodec.SerializeToElement(source.Parameters);
                 var (arguments, batchId) = PrimitiveArgumentHelper.NormalizeCompiledArguments(parameters, rawArguments);
-                var primitive = new AuthoringPrimitiveEntry(source.Type)
+                var primitive = new PrimitiveEntry(source.Type, arguments, batchId)
                 {
                     Id = index,
-                    Condition = source.Condition,
-                    BatchId = batchId
+                    Condition = source.Condition
                 };
-                primitive.SetArguments(arguments);
                 return primitive;
             }
 
-            var composite = catalog.Create(
-                source.Type,
-                index,
-                source.Condition,
-                source.Parameters.ToDictionary(pair => pair.Key, pair => ToValue(pair.Value), StringComparer.Ordinal));
-            if (composite is CompositeEntry typedComposite)
-                typedComposite.SetSourceArguments(JsonSerializer.SerializeToElement(source.Parameters));
-            return composite;
+            var normalized = PrimitiveArgumentHelper.Normalize(definition.DynamicParameters, JsonCodec.SerializeToElement(source.Parameters));
+            return catalog.Create(source.Type, index, source.Condition, normalized);
         }
         catch (Exception exception) when (exception is InvalidDataException or JsonException or ArgumentException)
         {
@@ -113,14 +117,6 @@ private static Entry.Entry CreateEntry(GroupEntryDocument source, int index, IEn
         }
     }
 
-    private static void RejectLegacyLayerTransitionParameters(GroupEntryDocument source)
-    {
-        if (source.Type is not ("layer.show" or "layer.hide")) return;
-        var legacy = source.Parameters.Keys.FirstOrDefault(name => name is "transitionId" or "transitionDuration" or "transitionBlocking" or "transitionParameters");
-        if (legacy is not null)
-            throw new InvalidDataException($"'{source.Type}.{legacy}' is no longer supported. Use a transition.* entry, which compiles into Layer and animation primitives.");
-    }
-
     private static PrimitiveEntryDocument SerializeEntry(string generatedId, PrimitiveEntry entry)
     {
         return new PrimitiveEntryDocument
@@ -130,33 +126,10 @@ private static PrimitiveEntryDocument SerializeEntry(string generatedId, Primiti
             BatchId = entry.BatchId,
             ReadingBoundaryId = entry.ReadingBoundaryId,
             Condition = entry.Condition,
-            Arguments = entry.IsGeneric || entry is AuthoringPrimitiveEntry
-                ? entry.Arguments.Clone()
-                : SerializeArguments(entry, catalog: null)
+            Arguments = entry.Arguments.Clone()
         };
     }
 
-    private static JsonElement SerializeArguments(PrimitiveEntry entry, IEntryCatalog? catalog)
-    {
-        if (catalog is null)
-            throw new InvalidOperationException("Only generic primitives may be emitted without a catalog.");
-        var definition = catalog.Get(entry.Type);
-        var arguments = entry.Values.ToDictionary(
-            pair => pair.Key,
-            pair => ValueCodec.FromEditorText((definition.DynamicParameters ?? throw new InvalidDataException($"Entry '{entry.Type}' has no dynamic parameter schema."))[pair.Key].Value, pair.Value),
-            StringComparer.Ordinal);
-        return JsonSerializer.SerializeToElement(arguments);
-    }
-
-    private static string ToValue(JsonElement value) => value.ValueKind switch
-    {
-        JsonValueKind.String => value.GetString() ?? "",
-        JsonValueKind.Number or JsonValueKind.True or JsonValueKind.False => value.GetRawText(),
-        JsonValueKind.Object or JsonValueKind.Array => value.GetRawText(),
-        JsonValueKind.Null => "",
-        _ => throw new InvalidDataException("Entry parameter values cannot be undefined.")
-    };
-
     private static string CombineConditions(string parent, string child)
     {
         if (string.IsNullOrWhiteSpace(parent)) return child;
@@ -169,3 +142,6 @@ private static string CombineConditions(string parent, string child)
 public sealed record CompiledGroupResult(
     CompiledGroupDocument Document,
     IReadOnlyDictionary<string, IReadOnlyList<string>> SourceMap);
+
+public sealed record GroupCompilationIssue(int SourceIndex, bool IsParameterError, string Message);
+public sealed record GroupCompilationAnalysis(CompiledGroupResult? Compilation, IReadOnlyList<GroupCompilationIssue> Issues);
diff --git a/src/Shared/GalNet.Core/Configuration/ConfigurationSection.cs b/src/Shared/GalNet.Core/Configuration/ConfigurationSection.cs
new file mode 100644
index 00000000..c8a6f3fd
--- /dev/null
+++ b/src/Shared/GalNet.Core/Configuration/ConfigurationSection.cs
@@ -0,0 +1,83 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Core.Configuration;
+
+public abstract class ConfigurationSection
+{
+    protected ConfigurationSection(string id, IReadOnlyList<FieldDescriptor> fields, int version)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(id);
+        if (version < 1) throw new ArgumentOutOfRangeException(nameof(version));
+        if (fields.Select(field => field.Id).Distinct(StringComparer.Ordinal).Count() != fields.Count)
+            throw new ArgumentException("Configuration field IDs must be unique.", nameof(fields));
+        Id = id;
+        Version = version;
+        Fields = Array.AsReadOnly(fields.ToArray());
+    }
+
+    public string Id { get; }
+    public int Version { get; }
+    public IReadOnlyList<FieldDescriptor> Fields { get; }
+    public abstract void Validate(ProjectSectionData value);
+    public abstract JsonElement Resolve(ProjectSectionData? value);
+}
+
+public sealed class ConfigurationSection<T>(string id, IReadOnlyList<FieldDescriptor> fields, Action<T>? validate = null, int version = 1,
+    IJsonTypeInfoResolver? jsonResolver = null)
+    : ConfigurationSection(id, fields, version) where T : new()
+{
+    private readonly JsonSerializerOptions _jsonOptions = JsonMetadata.CreateOptions(new(JsonSerializerDefaults.Web)
+    { PropertyNameCaseInsensitive = false }, jsonResolver, stringEnums: true);
+    internal JsonElement Encode(T value) => JsonCodec.SerializeToElement(value, _jsonOptions);
+
+    public T Read(ProjectSectionData? value)
+    {
+        if (value is not null && value.Version != Version) throw new InvalidDataException($"Unsupported configuration version {value.Version} for '{Id}'; expected {Version}.");
+        var data = value?.Data ?? Encode(new T());
+        if (data.ValueKind != JsonValueKind.Object) throw new InvalidDataException($"Configuration section '{Id}' must contain an object.");
+        var normalized = data.EnumerateObject().ToDictionary(property => property.Name, property => property.Value, StringComparer.Ordinal);
+        foreach (var field in Fields)
+        {
+            if (field.DefaultValue is { } fallback && (value is null || !normalized.ContainsKey(field.Id))) normalized[field.Id] = fallback;
+            if (!normalized.TryGetValue(field.Id, out var json))
+            {
+                if (field.IsRequired) throw new InvalidDataException($"Configuration '{Id}' requires '{field.Id}'.");
+                else continue;
+            }
+            if (ValueValidation.Validate(field.Value, json) is { } issue)
+                throw new InvalidDataException($"Configuration '{Id}/{field.Id}': {issue.Message}");
+        }
+        var result = JsonCodec.Deserialize<T>(JsonCodec.SerializeToElement(normalized), _jsonOptions)
+            ?? throw new InvalidDataException($"Configuration '{Id}' cannot be null.");
+        validate?.Invoke(result);
+        return result;
+    }
+
+    public override void Validate(ProjectSectionData value) => _ = Read(value);
+    public override JsonElement Resolve(ProjectSectionData? value) => Encode(Read(value));
+}
+
+/// <summary>Explicit project contract declarations; unknown sections remain opaque author data.</summary>
+public sealed class ProjectConfigurationSchema
+{
+    public static ProjectConfigurationSchema Empty { get; } = new([]);
+    public IReadOnlyList<ConfigurationSection> Sections { get; }
+    public ProjectConfigurationSchema(IEnumerable<ConfigurationSection> sections)
+    {
+        var values = sections.ToArray();
+        if (values.Any(section => section is null) || values.Select(section => section.Id).Distinct(StringComparer.Ordinal).Count() != values.Length)
+            throw new ArgumentException("Configuration section IDs must be nonempty and unique.", nameof(sections));
+        Sections = Array.AsReadOnly(values);
+    }
+
+    public void Validate(ProjectConfiguration configuration)
+    {
+        var stored = configuration.Sections;
+        foreach (var section in Sections)
+            if (stored.TryGetValue(section.Id, out var value)) section.Validate(value);
+    }
+}
diff --git a/src/Shared/GalNet.Core/Configuration/ContentPackagingOptions.cs b/src/Shared/GalNet.Core/Configuration/ContentPackagingOptions.cs
new file mode 100644
index 00000000..faee3903
--- /dev/null
+++ b/src/Shared/GalNet.Core/Configuration/ContentPackagingOptions.cs
@@ -0,0 +1,19 @@
+using GalNet.Core.Parameters;
+
+namespace GalNet.Core.Configuration;
+
+/// <summary>Explicit roots and dynamic-reference declarations used by publication.</summary>
+public sealed class ContentPackagingOptions
+{
+    public long MaxPakBytes { get; set; } = 128 * 1024 * 1024;
+    public List<string> IncludeResources { get; set; } = [];
+    public List<string> DeclaredCompleteResources { get; set; } = [];
+
+    public static ConfigurationSection<ContentPackagingOptions> Section { get; } = new("galnet.packaging",
+    [new("maxPakBytes", new(typeof(long))), new("includeResources", new(typeof(List<string>))),
+        new("declaredCompleteResources", new(typeof(List<string>)))], value =>
+    {
+        if (value.MaxPakBytes < 1 || value.IncludeResources is null || value.DeclaredCompleteResources is null)
+            throw new InvalidDataException("Packaging requires a positive PAK size and non-null resource lists.");
+    });
+}
diff --git a/src/Shared/GalNet.Core/Configuration/ProjectConfiguration.cs b/src/Shared/GalNet.Core/Configuration/ProjectConfiguration.cs
new file mode 100644
index 00000000..bb5ed243
--- /dev/null
+++ b/src/Shared/GalNet.Core/Configuration/ProjectConfiguration.cs
@@ -0,0 +1,105 @@
+using System.Collections.ObjectModel;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Core.Configuration;
+
+public sealed record ProjectSectionData(int Version, JsonElement Data);
+
+/// <summary>Owned author/content data. Defaults are read without mutation; runtime modules receive projected options.</summary>
+[JsonConverter(typeof(ProjectConfigurationJsonConverter))]
+public sealed class ProjectConfiguration
+{
+    public const int CurrentVersion = 1;
+    private Dictionary<string, ProjectSectionData> _sections = new(StringComparer.Ordinal);
+    public IReadOnlyDictionary<string, ProjectSectionData> Sections => new ReadOnlyDictionary<string, ProjectSectionData>(_sections);
+
+    public T Read<T>(ConfigurationSection<T> section) where T : new() =>
+        section.Read(_sections.GetValueOrDefault(section.Id));
+
+    public void Set<T>(ConfigurationSection<T> section, T value) where T : new()
+    {
+        ArgumentNullException.ThrowIfNull(value);
+        var data = section.Encode(value);
+        if (_sections.TryGetValue(section.Id, out var previous))
+        {
+            if (previous.Version != section.Version)
+                throw new InvalidDataException($"Unsupported configuration version {previous.Version} for '{section.Id}'; expected {section.Version}.");
+            // A typed editor owns declared members; retain fields it doesn't understand.
+            var merged = previous.Data.EnumerateObject().ToDictionary(property => property.Name, property => property.Value, StringComparer.Ordinal);
+            foreach (var property in data.EnumerateObject()) merged[property.Name] = property.Value;
+            data = JsonCodec.SerializeToElement(merged);
+        }
+        section.Validate(new(section.Version, data));
+        SetRaw(section.Id, new(section.Version, data));
+    }
+
+    public void SetRaw(string id, ProjectSectionData value)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(id);
+        ArgumentNullException.ThrowIfNull(value);
+        if (value.Version < 1 || value.Data.ValueKind != JsonValueKind.Object)
+            throw new InvalidDataException($"Configuration section '{id}' requires a positive version and object data.");
+        using var document = JsonDocument.Parse(value.Data.GetRawText(), new JsonDocumentOptions { AllowDuplicateProperties = false });
+        _sections[id] = value with { Data = document.RootElement.Clone() };
+    }
+
+    public bool Remove(string id) => _sections.Remove(id);
+    public void Patch(ConfigurationSection section, IReadOnlyDictionary<string, JsonElement> values, IReadOnlyList<string>? remove = null)
+    {
+        var previous = _sections.GetValueOrDefault(section.Id);
+        if (previous is not null && previous.Version != section.Version)
+            throw new InvalidDataException($"Unsupported configuration version {previous.Version} for '{section.Id}'.");
+        var fields = section.Fields.Select(field => field.Id).ToHashSet(StringComparer.Ordinal);
+        if (values.Keys.Concat(remove ?? []).Any(id => !fields.Contains(id)))
+            throw new ArgumentException($"The patch contains undeclared fields in '{section.Id}'.");
+        var candidate = previous?.Data.EnumerateObject().ToDictionary(property => property.Name, property => property.Value, StringComparer.Ordinal) ?? new();
+        foreach (var id in remove ?? []) candidate.Remove(id);
+        foreach (var (id, value) in values) candidate[id] = value;
+        var data = new ProjectSectionData(section.Version, JsonCodec.SerializeToElement(candidate));
+        section.Validate(data);
+        SetRaw(section.Id, data);
+    }
+
+    public ProjectConfiguration Clone()
+    {
+        var clone = new ProjectConfiguration();
+        clone.ReplaceFrom(this);
+        return clone;
+    }
+
+    public void ReplaceFrom(ProjectConfiguration source)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        _sections = source._sections.ToDictionary(pair => pair.Key, pair => pair.Value with { Data = pair.Value.Data.Clone() }, StringComparer.Ordinal);
+    }
+}
+
+public sealed class ProjectConfigurationJsonConverter : JsonConverter<ProjectConfiguration>
+{
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
+    {
+        PropertyNameCaseInsensitive = false,
+        NumberHandling = JsonNumberHandling.Strict,
+        AllowDuplicateProperties = false,
+        RespectRequiredConstructorParameters = true,
+        UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow
+    };
+    internal sealed record Envelope(int Version, IReadOnlyDictionary<string, ProjectSectionData> Sections);
+
+    public override ProjectConfiguration Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var envelope = JsonCodec.Deserialize<Envelope>(ref reader, JsonOptions);
+        if (envelope is not { Version: ProjectConfiguration.CurrentVersion, Sections: not null })
+            throw new JsonException("Project configuration requires version 1 and an object of sections.");
+        var result = new ProjectConfiguration();
+        foreach (var (id, section) in envelope.Sections)
+            result.SetRaw(id, section ?? throw new JsonException($"Invalid configuration section '{id}'."));
+        return result;
+    }
+
+    public override void Write(Utf8JsonWriter writer, ProjectConfiguration value, JsonSerializerOptions options) =>
+        JsonCodec.Serialize(writer, new Envelope(ProjectConfiguration.CurrentVersion,
+            value.Sections.OrderBy(pair => pair.Key, StringComparer.Ordinal).ToDictionary()), JsonOptions);
+}
diff --git a/src/Shared/GalNet.Core/Configuration/ResourceOverrideDefinition.cs b/src/Shared/GalNet.Core/Configuration/ResourceOverrideDefinition.cs
new file mode 100644
index 00000000..6886a409
--- /dev/null
+++ b/src/Shared/GalNet.Core/Configuration/ResourceOverrideDefinition.cs
@@ -0,0 +1,17 @@
+namespace GalNet.Core.Configuration;
+
+/// <summary>Author-owned independent resource replacement package.</summary>
+public sealed class ResourceOverrideDefinition
+{
+    public string Id { get; set; } = "";
+    public string Name { get; set; } = "";
+    public int Priority { get; set; }
+    private Dictionary<string, string> _mappings = new(StringComparer.OrdinalIgnoreCase);
+    public Dictionary<string, string> Mappings
+    {
+        get => _mappings;
+        set => _mappings = value is null ? null! : new(value, StringComparer.OrdinalIgnoreCase);
+    }
+    public List<string> IncludeResources { get; set; } = [];
+    public List<string> DeclaredCompleteResources { get; set; } = [];
+}
diff --git a/src/Shared/GalNet.Core/Configuration/ResourceOverrideOptions.cs b/src/Shared/GalNet.Core/Configuration/ResourceOverrideOptions.cs
new file mode 100644
index 00000000..fdb4f835
--- /dev/null
+++ b/src/Shared/GalNet.Core/Configuration/ResourceOverrideOptions.cs
@@ -0,0 +1,18 @@
+using GalNet.Core.Parameters;
+
+namespace GalNet.Core.Configuration;
+
+public sealed class ResourceOverrideOptions
+{
+    public List<ResourceOverrideDefinition> Packages { get; set; } = [];
+    public List<string> AdditionalOriginals { get; set; } = [];
+    public static ConfigurationSection<ResourceOverrideOptions> Section { get; } = new("galnet.resourceOverrides",
+        [new("packages", new(typeof(List<ResourceOverrideDefinition>))), new("additionalOriginals", new(typeof(List<string>)))], value =>
+        {
+            if (value.Packages is null || value.AdditionalOriginals is null || value.Packages.Any(package => package is null
+                || string.IsNullOrWhiteSpace(package.Id) || string.IsNullOrWhiteSpace(package.Name) || package.Mappings is null
+                || package.IncludeResources is null || package.DeclaredCompleteResources is null)
+                || value.Packages.Select(package => package.Id).Distinct(StringComparer.Ordinal).Count() != value.Packages.Count)
+                throw new InvalidDataException("Resource override definitions require unique IDs, names and non-null resource lists.");
+        });
+}
diff --git a/src/Shared/GalNet.Core/Entry/Entry.cs b/src/Shared/GalNet.Core/Entry/Entry.cs
index ba36c34a..143d89e7 100644
--- a/src/Shared/GalNet.Core/Entry/Entry.cs
+++ b/src/Shared/GalNet.Core/Entry/Entry.cs
@@ -1,184 +1,81 @@
-using System.Collections.ObjectModel;
 using System.Text.Json;
 using GalNet.Core.Primitives;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Core.Entry;
 
-/// <summary>A single graph entry. Persisted values intentionally remain strings.</summary>
+/// <summary>Common instruction identity and owned JSON arguments.</summary>
 public abstract class Entry
 {
-    /// <summary>Identifier assigned by the entry compiler; execution position is tracked separately by the runtime.</summary>
     public int Id { get; set; }
-
-    /// <summary>Expression that must evaluate to <see langword="true"/> before this entry executes.</summary>
     public string Condition { get; set; } = "";
-
-    /// <summary>Serialized parameter values. Concrete entry types interpret the named values.</summary>
-    public Dictionary<string, string> Values { get; } = new(StringComparer.Ordinal);
     public abstract string Type { get; }
-}
-
-/// <summary>
-/// A Runtime-ready primitive invocation. Compiled content always uses this generic
-/// shape; concrete authoring entries may temporarily derive from it while being
-/// expanded by the compiler.
-/// </summary>
-public class PrimitiveEntry : Entry
-{
-    private readonly string? _typeId;
-
-    /// <summary>Creates a generic compiled primitive entry.</summary>
-    public PrimitiveEntry(string typeId, JsonElement arguments, string? batchId = null)
+    public JsonElement Arguments { get; private set; } = JsonCodec.SerializeToElement(new Dictionary<string, object?>());
+    public void SetArguments(JsonElement arguments)
     {
-        if (string.IsNullOrWhiteSpace(typeId))
-            throw new ArgumentException("Primitive type ID is required.", nameof(typeId));
         if (arguments.ValueKind != JsonValueKind.Object)
-            throw new ArgumentException("Primitive arguments must be a JSON object.", nameof(arguments));
-
-        _typeId = typeId;
+            throw new ArgumentException("Entry arguments must be a JSON object.", nameof(arguments));
         Arguments = arguments.Clone();
-        BatchId = NormalizeBatchId(batchId);
     }
+}
 
-    /// <summary>Creates a derived authoring primitive entry.</summary>
-    protected PrimitiveEntry()
+/// <summary>A compiled invocation; authoring entries are distinct types.</summary>
+public sealed class PrimitiveEntry : Entry
+{
+    public PrimitiveEntry(string typeId, JsonElement arguments, string? batchId = null)
     {
-        Arguments = JsonSerializer.SerializeToElement(new Dictionary<string, object?>());
+        ArgumentException.ThrowIfNullOrWhiteSpace(typeId);
+        Type = typeId;
+        SetArguments(arguments);
+        BatchId = NormalizeBatchId(batchId);
     }
-
-    /// <summary>Unparsed JSON arguments preserved from compiled content.</summary>
-    public JsonElement Arguments { get; private set; }
-
-    /// <summary>Optional skip-batch identity scoped to one execution of the containing group.</summary>
+    public override string Type { get; }
     public string? BatchId { get; set; }
     public string StableId { get; set; } = "";
-    /// <summary>Text identity checked before this instruction (including preceding voice commands).</summary>
     public string? ReadingBoundaryId { get; set; }
-
-    /// <summary>Whether this is the generic Runtime form rather than an authoring subtype.</summary>
-    public bool IsGeneric => _typeId is not null;
-
-    public override string Type => _typeId
-        ?? throw new InvalidOperationException("Derived primitive entries must override Type.");
-
-    /// <summary>Replaces arguments when a compiler expands an authoring primitive.</summary>
-    public void SetArguments(JsonElement arguments)
-    {
-        if (arguments.ValueKind != JsonValueKind.Object)
-            throw new ArgumentException("Primitive arguments must be a JSON object.", nameof(arguments));
-        Arguments = arguments.Clone();
-    }
-
-    internal static string? NormalizeBatchId(string? batchId) =>
-        string.IsNullOrWhiteSpace(batchId) ? null : batchId;
+    internal static string? NormalizeBatchId(string? batchId) => string.IsNullOrWhiteSpace(batchId) ? null : batchId;
 }
 
-/// <summary>
-/// Generic authoring representation of a registered primitive. Concrete primitive
-/// schemas live in an outer catalog; Core never needs one CLR type per command.
-/// </summary>
-public sealed class AuthoringPrimitiveEntry : PrimitiveEntry
+/// <summary>A draft primitive containing author JSON; compilation creates a PrimitiveEntry.</summary>
+public sealed class AuthoringPrimitiveEntry(string typeId) : Entry
 {
-    private readonly string _typeId;
-
-    public AuthoringPrimitiveEntry(string typeId)
-    {
-        if (string.IsNullOrWhiteSpace(typeId))
-            throw new ArgumentException("Primitive type ID is required.", nameof(typeId));
-        _typeId = typeId;
-    }
-
-    public override string Type => _typeId;
+    public override string Type { get; } = !string.IsNullOrWhiteSpace(typeId) ? typeId
+        : throw new ArgumentException("Primitive type ID is required.", nameof(typeId));
 }
 
-/// <summary>An editor-facing composite entry expanded into Runtime primitives before execution.</summary>
 public abstract class CompositeEntry : Entry
 {
-    internal virtual void SetSourceArguments(System.Text.Json.JsonElement arguments) { }
-
-    /// <summary>Builds the ordered Runtime primitives represented by this entry.</summary>
     public abstract IReadOnlyList<PrimitiveEntry> Compile(EntryCompileContext context);
 }
 
-/// <summary>Context available while one source entry is expanded into primitives.</summary>
 public sealed class EntryCompileContext
 {
-    /// <summary>Stable identifier of the source entry being compiled.</summary>
     public required string SourceEntryId { get; init; }
-
-    /// <summary>Condition inherited by every emitted primitive.</summary>
     public required string Condition { get; init; }
-
-    /// <summary>Creates a primitive while preserving the source entry condition.</summary>
-    public TPrimitive CreatePrimitive<TPrimitive>() where TPrimitive : PrimitiveEntry, new() =>
-        new() { Condition = Condition };
-}
-
-/// <summary>Editor-facing input kind for a serialized entry parameter.</summary>
-public enum EntryParameterType
-{
-    Text,
-    MultilineText,
-    Integer,
-    Float,
-    Autocomplete,
-    ImageAsset,
-    AudioAsset,
-    VideoAsset,
-    EffectProgramAsset,
-    Select,
-    VariableName,
-    Expression,
-    Json
 }
-
 /// <summary>Schema used to create, validate, and edit one registered entry type.</summary>
-/// <remarks>Defaults are copied into each new entry; options constrain editor choices but are not persisted separately.</remarks>
+/// <remarks>Parameter defaults and constraints are owned by the immutable parameter table.</remarks>
 public sealed class EntryDefinition
 {
-    public EntryDefinition(
-        string type,
-        string category,
-        Func<Entry> factory,
-        IReadOnlyDictionary<string, EntryParameterType> parameters,
-        IReadOnlyDictionary<string, string> defaults,
-        IReadOnlyDictionary<string, IReadOnlyList<string>> options,
-        EntryKind kind,
-        DynamicParameterTable? dynamicParameters = null)
+    public EntryDefinition(string type, string category, Func<Entry> factory, EntryKind kind, DynamicParameterTable parameters)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(type);
         ArgumentException.ThrowIfNullOrWhiteSpace(category);
         ArgumentNullException.ThrowIfNull(factory);
         ArgumentNullException.ThrowIfNull(parameters);
-        ArgumentNullException.ThrowIfNull(defaults);
-        ArgumentNullException.ThrowIfNull(options);
-
         Type = type;
         Category = category;
         Factory = factory;
-        Parameters = Freeze(parameters);
-        Defaults = Freeze(defaults);
-        Options = new ReadOnlyDictionary<string, IReadOnlyList<string>>(options.ToDictionary(
-            pair => pair.Key,
-            pair => (IReadOnlyList<string>)Array.AsReadOnly(pair.Value.ToArray()),
-            StringComparer.Ordinal));
         Kind = kind;
-        DynamicParameters = dynamicParameters;
+        DynamicParameters = parameters;
     }
-
     public string Type { get; }
     public string Category { get; }
     public Func<Entry> Factory { get; }
-    public IReadOnlyDictionary<string, EntryParameterType> Parameters { get; }
-    public IReadOnlyDictionary<string, string> Defaults { get; }
-    public IReadOnlyDictionary<string, IReadOnlyList<string>> Options { get; }
     public EntryKind Kind { get; }
-    public DynamicParameterTable? DynamicParameters { get; }
+    public DynamicParameterTable DynamicParameters { get; }
     public bool IsReading { get; init; }
     public Type? FieldDataType { get; init; }
-
-    private static ReadOnlyDictionary<TKey, TValue> Freeze<TKey, TValue>(IReadOnlyDictionary<TKey, TValue> values)
-        where TKey : notnull => new ReadOnlyDictionary<TKey, TValue>(values.ToDictionary(pair => pair.Key, pair => pair.Value));
 }
 
 /// <summary>
@@ -190,7 +87,7 @@ public interface IEntryCatalog
     IReadOnlyList<EntryDefinition> Definitions { get; }
     bool TryGet(string type, out EntryDefinition definition);
     EntryDefinition Get(string type);
-    Entry Create(string type, int id = 0, string condition = "", IReadOnlyDictionary<string, string>? values = null);
+    Entry Create(string type, int id = 0, string condition = "", JsonElement? arguments = null);
 }
 
 /// <summary>Whether an entry is directly executable or requires compilation first.</summary>
diff --git a/src/Shared/GalNet.Core/Entry/EntryModule.cs b/src/Shared/GalNet.Core/Entry/EntryModule.cs
index 39940ff8..ab54f37d 100644
--- a/src/Shared/GalNet.Core/Entry/EntryModule.cs
+++ b/src/Shared/GalNet.Core/Entry/EntryModule.cs
@@ -25,38 +25,8 @@ protected EntryBase(string name, DynamicParameterTable parameters, string? categ
 
     internal abstract EntryDefinition CreateDefinition();
 
-    protected EntryDefinition BuildDefinition(
-        Func<Entry> factory,
-        EntryKind kind)
-    {
-        var editorParameters = new Dictionary<string, EntryParameterType>(StringComparer.Ordinal);
-        var defaults = new Dictionary<string, string>(StringComparer.Ordinal);
-        var options = new Dictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal);
-        foreach (var parameter in Parameters.Values)
-        {
-            editorParameters.Add(parameter.Name, EntrySchema.GetEditorType(parameter));
-            if (parameter.DefaultValue is { } defaultValue)
-            {
-                var text = ValueCodec.ToEditorText(parameter.Value, defaultValue);
-                if (JsonElement.DeepEquals(defaultValue, ValueCodec.ParseEditorText(parameter.Value, text))) defaults.Add(parameter.Name, text);
-            }
-            if (parameter.TryGetConstraint("options", out var values) && values.ValueKind == JsonValueKind.Array)
-                options.Add(parameter.Name, values.EnumerateArray().Select(value => value.GetString() ?? "").ToArray());
-            else if (parameter.ValueType == typeof(bool))
-                options.Add(parameter.Name, ["true", "false"]);
-        }
-
-        return new EntryDefinition(
-            Name,
-            Category,
-            factory,
-            editorParameters,
-            defaults,
-            options,
-            kind,
-            Parameters)
-        { IsReading = IsReading, FieldDataType = FieldDataType };
-    }
+    protected EntryDefinition BuildDefinition(Func<Entry> factory, EntryKind kind) =>
+        new(Name, Category, factory, kind, Parameters) { IsReading = IsReading, FieldDataType = FieldDataType };
 
     private static string GetDefaultCategory(string name)
     {
@@ -142,15 +112,11 @@ public override CompositeEntry CreateEntry() =>
     private sealed class DtoCompositeEntry<T>(string name, DynamicParameterTable parameters,
         Func<EntryCompileContext, T, IReadOnlyList<PrimitiveEntry>> compile) : CompositeEntry where T : IFieldDto, new()
     {
-        private JsonElement? _sourceArguments;
         public override string Type => name;
-        internal override void SetSourceArguments(JsonElement arguments) => _sourceArguments = arguments.Clone();
         public override IReadOnlyList<PrimitiveEntry> Compile(EntryCompileContext context)
         {
-            var source = _sourceArguments ?? JsonSerializer.SerializeToElement(Values.ToDictionary(pair => pair.Key,
-                pair => ValueCodec.FromEditorText(parameters[pair.Key].Value, pair.Value), StringComparer.Ordinal));
-            var normalized = PrimitiveArgumentHelper.Normalize(parameters, source);
-            return compile(context, ValueCodec.DeserializeFields<T>(parameters.Fields, normalized));
+            var (_, options) = PrimitiveArgumentHelper.NormalizeFields<T>(parameters, Arguments);
+            return compile(context, options);
         }
     }
 }
diff --git a/src/Shared/GalNet.Core/Entry/EntrySchema.cs b/src/Shared/GalNet.Core/Entry/EntrySchema.cs
deleted file mode 100644
index 242f3767..00000000
--- a/src/Shared/GalNet.Core/Entry/EntrySchema.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-using System.Text.Json;
-using GalNet.Core.Parameters;
-using GalNet.Core.Primitives;
-
-namespace GalNet.Core.Entry;
-
-/// <summary>Small immutable helpers used by outer authoring catalogs.</summary>
-public static class EntrySchema
-{
-    public static IReadOnlyDictionary<string, EntryParameterType> Parameters(params (string Name, EntryParameterType Type)[] items) =>
-        new Dictionary<string, EntryParameterType>(items.ToDictionary(x => x.Name, x => x.Type), StringComparer.Ordinal);
-
-    public static IReadOnlyDictionary<string, string> Defaults(params (string Name, string Value)[] items) =>
-        new Dictionary<string, string>(items.ToDictionary(x => x.Name, x => x.Value), StringComparer.Ordinal);
-
-    public static IReadOnlyDictionary<string, IReadOnlyList<string>> Options(params (string Name, string[] Values)[] items) =>
-        new Dictionary<string, IReadOnlyList<string>>(items.ToDictionary(x => x.Name, x => (IReadOnlyList<string>)x.Values), StringComparer.Ordinal);
-
-    public static DynamicParameterTable DynamicParameters(
-        IReadOnlyDictionary<string, EntryParameterType> parameters,
-        IReadOnlyDictionary<string, string>? defaults = null,
-        IReadOnlyDictionary<string, IReadOnlyList<string>>? options = null,
-        Action<JsonElement>? validateArguments = null)
-    {
-        ArgumentNullException.ThrowIfNull(parameters);
-        return new DynamicParameterTable(parameters.Select(pair =>
-        {
-            var constraints = CreateConstraints(options?.GetValueOrDefault(pair.Key));
-            return new DynamicParameterDescriptor(
-                pair.Key,
-                GetValueType(pair.Value),
-                defaultValue: defaults is not null && defaults.TryGetValue(pair.Key, out var value)
-                    ? ValueCodec.FromEditorText(new ValueDescriptor(GetValueType(pair.Value)), value)
-                    : null,
-                constraints: constraints, editor: new EditorHints(GetEditorId(pair.Value)));
-        }), validateArguments);
-    }
-
-    public static EntryParameterType GetEditorType(DynamicParameterDescriptor parameter)
-    {
-        if (parameter.Editor?.EditorId is { } editorId && editorId != ValueEditorIds.Numeric)
-            foreach (var type in Enum.GetValues<EntryParameterType>())
-                if (GetEditorId(type) == editorId) return type;
-        if (parameter.ValueType == typeof(int)) return EntryParameterType.Integer;
-        if (parameter.ValueType == typeof(float) || parameter.ValueType == typeof(double) || parameter.ValueType == typeof(decimal)) return EntryParameterType.Float;
-        if (parameter.ValueType == typeof(JsonElement)) return EntryParameterType.Json;
-        if (parameter.ValueType == typeof(bool)) return EntryParameterType.Select;
-        return EntryParameterType.Text;
-    }
-
-    private static Type GetValueType(EntryParameterType type) => type switch
-    {
-        EntryParameterType.Integer => typeof(int),
-        EntryParameterType.Float => typeof(float),
-        EntryParameterType.Json => typeof(JsonElement),
-        _ => typeof(string)
-    };
-
-    private static JsonElement CreateConstraints(IReadOnlyList<string>? options)
-    {
-        var constraints = new Dictionary<string, object?>();
-        if (options is not null) constraints["options"] = options;
-        return JsonSerializer.SerializeToElement(constraints);
-    }
-
-    private static string GetEditorId(EntryParameterType type) => type switch
-    {
-        EntryParameterType.Integer or EntryParameterType.Float => ValueEditorIds.Numeric,
-        EntryParameterType.Json => ValueEditorIds.Json,
-        EntryParameterType.Select => ValueEditorIds.Choice,
-        EntryParameterType.Text => ValueEditorIds.Text,
-        _ => "entry." + type.ToString().ToLowerInvariant()
-    };
-}
diff --git a/src/Shared/GalNet.Core/Entry/PrimitiveArgumentHelper.cs b/src/Shared/GalNet.Core/Entry/PrimitiveArgumentHelper.cs
index 3aef6a4c..60c4a0a3 100644
--- a/src/Shared/GalNet.Core/Entry/PrimitiveArgumentHelper.cs
+++ b/src/Shared/GalNet.Core/Entry/PrimitiveArgumentHelper.cs
@@ -1,5 +1,7 @@
 using System.Text.Json;
+using GalNet.Core.Parameters;
 using GalNet.Core.Primitives;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Core.Entry;
 
@@ -7,6 +9,17 @@ namespace GalNet.Core.Entry;
 public static class PrimitiveArgumentHelper
 {
     public static JsonElement Normalize(DynamicParameterTable parameters, JsonElement arguments)
+        => NormalizeCore(parameters, arguments, null);
+
+    /// <summary>Validates once and writes decoded fields into a fresh invocation DTO, including independent defaults.</summary>
+    public static (JsonElement Arguments, T Options) NormalizeFields<T>(DynamicParameterTable parameters, JsonElement arguments)
+        where T : IFieldDto, new()
+    {
+        var options = new T();
+        return (NormalizeCore(parameters, arguments, options), options);
+    }
+
+    private static JsonElement NormalizeCore(DynamicParameterTable parameters, JsonElement arguments, IFieldDto? options)
     {
         ArgumentNullException.ThrowIfNull(parameters);
         if (arguments.ValueKind != JsonValueKind.Object)
@@ -17,7 +30,8 @@ public static JsonElement Normalize(DynamicParameterTable parameters, JsonElemen
         {
             if (!parameters.TryGetValue(property.Name, out var parameter))
                 throw new InvalidDataException($"Unknown primitive parameter '{property.Name}'.");
-            Validate(parameter, property.Value);
+            var decoded = Read(parameter, property.Value);
+            options?.WriteField(parameter.Name, decoded);
             normalized.Add(property.Name, property.Value.Clone());
         }
 
@@ -28,14 +42,17 @@ public static JsonElement Normalize(DynamicParameterTable parameters, JsonElemen
             try
             {
                 if (parameter.DefaultValue is { } defaultValue)
+                {
                     normalized.Add(parameter.Name, defaultValue);
+                    if (options is not null) options.WriteField(parameter.Name, Read(parameter, defaultValue));
+                }
                 else if (parameter.IsRequired)
                     throw new ArgumentException($"Primitive requires parameter '{parameter.Name}'.");
             }
             catch (ArgumentException exception) { throw new InvalidDataException(exception.Message, exception); }
         }
 
-        var result = JsonSerializer.SerializeToElement(normalized);
+        var result = JsonCodec.SerializeToElement(normalized);
         parameters.ValidateArguments(result);
         return result;
     }
@@ -60,18 +77,17 @@ public static (JsonElement Arguments, string? BatchId) NormalizeCompiledArgument
             }
             values.Add(property.Name, property.Value.Clone());
         }
-        return (JsonSerializer.SerializeToElement(values), batchId);
+        return (JsonCodec.SerializeToElement(values), batchId);
     }
 
-    private static void Validate(DynamicParameterDescriptor parameter, JsonElement value)
+    private static object? Read(DynamicParameterDescriptor parameter, JsonElement value)
     {
         try
         {
-            parameter.Validate(value);
-        }
-        catch (ArgumentException exception)
-        {
-            throw new InvalidDataException(exception.Message, exception);
+            var decoded = ValueValidation.Read(parameter.Value, value, out var issue);
+            if (issue is not null) throw new InvalidDataException($"Parameter '{parameter.Name}': {issue.Message}");
+            return decoded;
         }
+        catch (ArgumentException exception) { throw new InvalidDataException(exception.Message, exception); }
     }
 }
diff --git a/src/Shared/GalNet.Core/Entry/TargetProfileEntryCatalog.cs b/src/Shared/GalNet.Core/Entry/TargetProfileEntryCatalog.cs
index 06238909..2a5f8680 100644
--- a/src/Shared/GalNet.Core/Entry/TargetProfileEntryCatalog.cs
+++ b/src/Shared/GalNet.Core/Entry/TargetProfileEntryCatalog.cs
@@ -1,3 +1,6 @@
+using System.Text.Json;
+using GalNet.Core.Serialization;
+
 namespace GalNet.Core.Entry;
 
 /// <summary>
@@ -48,18 +51,20 @@ public EntryDefinition Get(string type) => TryGet(type, out var definition)
         ? definition
         : throw new InvalidDataException($"Entry type '{type}' is not enabled by this target profile.");
 
-    public Entry Create(string type, int id = 0, string condition = "", IReadOnlyDictionary<string, string>? values = null)
+    public Entry Create(string type, int id = 0, string condition = "", JsonElement? arguments = null)
     {
         var definition = Get(type);
         var entry = definition.Factory();
         entry.Id = id;
         entry.Condition = condition;
-        foreach (var (name, value) in definition.Defaults)
-            entry.Values[name] = value;
-        if (values is null) return entry;
-
-        foreach (var (name, value) in values)
-            if (definition.Parameters.ContainsKey(name)) entry.Values[name] = value;
+        var values = definition.DynamicParameters.Values.Where(parameter => parameter.DefaultValue.HasValue)
+            .ToDictionary(parameter => parameter.Name, parameter => parameter.DefaultValue!.Value.Clone(), StringComparer.Ordinal);
+        if (arguments is { } provided)
+        {
+            if (provided.ValueKind != JsonValueKind.Object) throw new ArgumentException("Author arguments must be an object.", nameof(arguments));
+            foreach (var property in provided.EnumerateObject()) values[property.Name] = property.Value.Clone();
+        }
+        entry.SetArguments(JsonCodec.SerializeToElement(values));
         return entry;
     }
 
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/ICatchUpPresentation.cs b/src/Shared/GalNet.Core/Execution/ICatchUpPresentation.cs
similarity index 69%
rename from src/Shared/GalNet.Presentation.Abstractions/View/ICatchUpPresentation.cs
rename to src/Shared/GalNet.Core/Execution/ICatchUpPresentation.cs
index 3628ff20..1a1b1546 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/ICatchUpPresentation.cs
+++ b/src/Shared/GalNet.Core/Execution/ICatchUpPresentation.cs
@@ -1,10 +1,10 @@
 using GalNet.Core.Runtime;
 
-namespace GalNet.Presentation.Abstractions.View;
+namespace GalNet.Core.Execution;
 
 /// <summary>Host presentation suspension and final-state synchronization for forward catch-up.</summary>
 public interface ICatchUpPresentation
 {
     Task BeginCatchUpAsync(CancellationToken cancellationToken);
-    Task EndCatchUpAsync(IGameRuntime runtime, CancellationToken cancellationToken);
+    Task EndCatchUpAsync(IGameContext runtime, CancellationToken cancellationToken);
 }
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/IChoicePresenter.cs b/src/Shared/GalNet.Core/Execution/IChoicePresenter.cs
similarity index 82%
rename from src/Shared/GalNet.Presentation.Abstractions/View/IChoicePresenter.cs
rename to src/Shared/GalNet.Core/Execution/IChoicePresenter.cs
index 91eeea5a..50a68615 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/IChoicePresenter.cs
+++ b/src/Shared/GalNet.Core/Execution/IChoicePresenter.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Presentation.Abstractions.View;
+namespace GalNet.Core.Execution;
 
 /// <summary>Presents one already-filtered choice and returns its visible index.</summary>
 public interface IChoicePresenter
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/IPlayerPlaybackController.cs b/src/Shared/GalNet.Core/Execution/IPlayerPlaybackController.cs
similarity index 76%
rename from src/Shared/GalNet.Presentation.Abstractions/View/IPlayerPlaybackController.cs
rename to src/Shared/GalNet.Core/Execution/IPlayerPlaybackController.cs
index 955d848c..8aa94c90 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/IPlayerPlaybackController.cs
+++ b/src/Shared/GalNet.Core/Execution/IPlayerPlaybackController.cs
@@ -1,6 +1,6 @@
 using GalNet.Core.Primitives;
 
-namespace GalNet.Presentation.Abstractions.View;
+namespace GalNet.Core.Execution;
 
 /// <summary>Player commands without a dependency on an engine or UI implementation.</summary>
 public interface IPlayerPlaybackController
@@ -10,5 +10,5 @@ public interface IPlayerPlaybackController
     void CancelPlayback();
     Task SetPlaybackModeAsync(PlaybackMode mode, CancellationToken cancellationToken = default);
     Task SkipToUnreadAsync(CancellationToken cancellationToken = default);
-    Task RefreshPlaybackSettingsAsync(CancellationToken cancellationToken = default);
+    Task UpdatePlaybackOptionsAsync(PlaybackOptions options, CancellationToken cancellationToken = default);
 }
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/IGameView.cs b/src/Shared/GalNet.Core/Execution/IPrimitiveDispatcher.cs
similarity index 53%
rename from src/Shared/GalNet.Presentation.Abstractions/View/IGameView.cs
rename to src/Shared/GalNet.Core/Execution/IPrimitiveDispatcher.cs
index bf783914..de38680e 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/IGameView.cs
+++ b/src/Shared/GalNet.Core/Execution/IPrimitiveDispatcher.cs
@@ -2,23 +2,32 @@
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
 
-namespace GalNet.Presentation.Abstractions.View;
+namespace GalNet.Core.Execution;
 
 /// <summary>Resolves and dispatches one compiled primitive call.</summary>
-public interface IGameView : IDisposable, IAsyncDisposable
+public interface IPrimitiveDispatcher : IDisposable, IAsyncDisposable
 {
     StateCatalog StateCatalog => StateCatalog.Empty;
     bool RequiresStateRestore => false;
-    void ValidateState(IGameRuntime runtime, GameState state) { }
+    void ValidateState(IGameContext runtime, GameState state) { }
     IReadOnlyCollection<EntryDefinition> Primitives { get; }
 
     bool TryGetEntry(string primitiveType, out EntryDefinition? entry);
 
     bool CanExecute(string primitiveType);
 
+    /// <summary>Notifies optional host observers when an instruction's condition excludes its execution.</summary>
+    void OnInstructionSkipped(PrimitiveEntry entry, IGameContext runtime) { }
+
+    /// <summary>Stops transient host interaction before an accepted story advance or playback-mode continuation.</summary>
+    void OnPlaybackContinuing() { }
+
+    /// <summary>Commits completed host observations under the execution gate before capturing persistent state.</summary>
+    void OnCheckpointCreating(IGameContext runtime) { }
+
     PrimitiveInstance Dispatch(
         PrimitiveEntry entry,
-        IGameRuntime runtime,
+        IGameContext runtime,
         CancellationToken cancellationToken,
         PrimitiveInvocationMode mode = PrimitiveInvocationMode.Normal);
 
diff --git a/src/Shared/GalNet.Core/Execution/PlaybackOptions.cs b/src/Shared/GalNet.Core/Execution/PlaybackOptions.cs
new file mode 100644
index 00000000..970e9663
--- /dev/null
+++ b/src/Shared/GalNet.Core/Execution/PlaybackOptions.cs
@@ -0,0 +1,15 @@
+namespace GalNet.Core.Execution;
+
+/// <summary>Immutable scheduling input supplied by the host, independent of its preference model.</summary>
+public sealed record PlaybackOptions
+{
+    public int AutoAdvanceIntervalMilliseconds { get; init; } = 2000;
+    public int QuickAdvanceIntervalMilliseconds { get; init; } = 50;
+    public bool QuickReadOnly { get; init; } = true;
+
+    public void Validate()
+    {
+        ArgumentOutOfRangeException.ThrowIfNegative(AutoAdvanceIntervalMilliseconds);
+        ArgumentOutOfRangeException.ThrowIfNegative(QuickAdvanceIntervalMilliseconds);
+    }
+}
diff --git a/src/Shared/GalNet.Core/Graph/Graph.cs b/src/Shared/GalNet.Core/Graph/Graph.cs
index 2c1ae2a1..956bebe6 100644
--- a/src/Shared/GalNet.Core/Graph/Graph.cs
+++ b/src/Shared/GalNet.Core/Graph/Graph.cs
@@ -19,4 +19,8 @@ public sealed class Graph
 
     /// <summary>所有边</summary>
     public List<Edge> Edges { get; init; } = [];
+    public List<GalNet.Core.Variable.ProjectVariableDefinition> PlayerVariables { get; init; } = [];
+    public List<GalNet.Core.Variable.ProjectVariableDefinition> SaveVariables { get; init; } = [];
+    public string ContentBuildId { get; set; } = "";
+    public IReadOnlyList<string> InstalledStoryPackages { get; set; } = [];
 }
diff --git a/src/Shared/GalNet.Core/Graph/Group.cs b/src/Shared/GalNet.Core/Graph/Group.cs
index aa7ed400..36abf324 100644
--- a/src/Shared/GalNet.Core/Graph/Group.cs
+++ b/src/Shared/GalNet.Core/Graph/Group.cs
@@ -8,6 +8,9 @@ namespace GalNet.Core.Graph;
 public sealed class Group : Node
 {
     public override NodeType NodeType => NodeType.Group;
+    public string ResourceId { get; init; } = "";
+    public string StoryPackage { get; init; } = "";
+    public bool IsAvailable { get; set; } = true;
 
     /// <summary>该组包含的复杂条目列表（开发期编写）</summary>
     public List<EntryModel> Entries { get; init; } = [];
diff --git a/src/Shared/GalNet.Core/Parameters/EditorHints.cs b/src/Shared/GalNet.Core/Parameters/EditorHints.cs
index 6870a4c8..f19f3f64 100644
--- a/src/Shared/GalNet.Core/Parameters/EditorHints.cs
+++ b/src/Shared/GalNet.Core/Parameters/EditorHints.cs
@@ -2,20 +2,14 @@ namespace GalNet.Core.Parameters;
 
 /// <summary>Optional presentation metadata. Step does not restrict legal values.</summary>
 public sealed record EditorHints(string? EditorId = null, double? Step = null,
-    string? Format = null, string? UnitKey = null, bool IsCommon = false)
-{
-    // Previously built project contracts call the original four-argument constructor.
-    public EditorHints(string? EditorId, double? Step, string? Format, string? UnitKey)
-        : this(EditorId, Step, Format, UnitKey, false) { }
-
-    public void Deconstruct(out string? editorId, out double? step, out string? format, out string? unitKey)
-    { editorId = EditorId; step = Step; format = Format; unitKey = UnitKey; }
-}
+    string? Format = null, string? UnitKey = null, bool IsCommon = false);
 
 /// <summary>Shared editor names; hosts may register any other string ID.</summary>
 public static class ValueEditorIds
 {
     public const string Numeric = "numeric";
+    public const string NumericUpDown = "numericupdown";
+    public const string NumericText = "numerictext";
     public const string Slider = "slider";
     public const string Toggle = "toggle";
     public const string Choice = "choice";
diff --git a/src/Shared/GalNet.Core/Parameters/FieldDescriptor.cs b/src/Shared/GalNet.Core/Parameters/FieldDescriptor.cs
index eabdda1a..b2aea36b 100644
--- a/src/Shared/GalNet.Core/Parameters/FieldDescriptor.cs
+++ b/src/Shared/GalNet.Core/Parameters/FieldDescriptor.cs
@@ -5,10 +5,16 @@ namespace GalNet.Core.Parameters;
 /// <summary>Immutable field metadata; consumers own values, labels and commit behavior.</summary>
 public sealed class FieldDescriptor
 {
+    // Preserve the constructor signature used by already compiled project contracts.
+    public FieldDescriptor(string id, ValueDescriptor value, bool isRequired,
+        JsonElement? defaultValue, EditorHints? editor, string? labelKey,
+        string? descriptionKey, FieldValueSemantic semantic)
+        : this(id, value, isRequired, defaultValue, editor, labelKey, descriptionKey, semantic, null) { }
+
     public FieldDescriptor(string id, ValueDescriptor value, bool isRequired = false,
         JsonElement? defaultValue = null, EditorHints? editor = null,
         string? labelKey = null, string? descriptionKey = null,
-        FieldValueSemantic semantic = FieldValueSemantic.None)
+        FieldValueSemantic semantic = FieldValueSemantic.None, string? resourceTypeId = null)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(id);
         ArgumentNullException.ThrowIfNull(value);
@@ -24,6 +30,9 @@ public FieldDescriptor(string id, ValueDescriptor value, bool isRequired = false
         LabelKey = labelKey;
         DescriptionKey = descriptionKey;
         Semantic = semantic;
+        if (resourceTypeId is not null && value.ValueType != typeof(string))
+            throw new ArgumentException("Resource references require a string field.", nameof(resourceTypeId));
+        ResourceTypeId = resourceTypeId;
     }
 
     public string Id { get; }
@@ -34,4 +43,11 @@ public FieldDescriptor(string id, ValueDescriptor value, bool isRequired = false
     public string? LabelKey { get; }
     public string? DescriptionKey { get; }
     public FieldValueSemantic Semantic { get; }
+    public string? ResourceTypeId { get; }
+    public string? MemberName { get; private init; }
+    public string? JsonPropertyName { get; private init; }
+
+    public FieldDescriptor WithMember(string memberName, string? jsonPropertyName = null) =>
+        new(Id, Value, IsRequired, DefaultValue, Editor, LabelKey, DescriptionKey, Semantic, ResourceTypeId)
+        { MemberName = memberName, JsonPropertyName = jsonPropertyName };
 }
diff --git a/src/Shared/GalNet.Core/Parameters/FieldDto.cs b/src/Shared/GalNet.Core/Parameters/FieldDto.cs
index 8ad0fd74..e44e1c2c 100644
--- a/src/Shared/GalNet.Core/Parameters/FieldDto.cs
+++ b/src/Shared/GalNet.Core/Parameters/FieldDto.cs
@@ -3,6 +3,13 @@ namespace GalNet.Core.Parameters;
 [AttributeUsage(AttributeTargets.Class)]
 public sealed class GenerateFieldSchemaAttribute : Attribute;
 
+/// <summary>The assembly's source-generated JSON context used by generated field contracts.</summary>
+[AttributeUsage(AttributeTargets.Assembly)]
+public sealed class FieldSchemaJsonContextAttribute(Type contextType) : Attribute
+{
+    public Type ContextType { get; } = contextType;
+}
+
 /// <summary>Display this field in an author's compact, common-fields view.</summary>
 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
 public sealed class CommonAttribute : Attribute;
@@ -25,6 +32,7 @@ public sealed class FieldAttribute(int order) : Attribute
     public bool Required { get; set; }
     public bool AllowNull { get; set; }
     public string? EditorId { get; set; }
+    public string? ResourceTypeId { get; set; }
     public double Step { get; set; } = double.NaN;
     public string? Format { get; set; }
     public string? UnitKey { get; set; }
@@ -36,6 +44,10 @@ public sealed class FieldAttribute(int order) : Attribute
     public string? ValueFormat { get; set; }
     public string? DefaultJson { get; set; }
     public string[]? Choices { get; set; }
+    public Type? StructureType { get; set; }
+    public bool StructureAllowsJsonString { get; set; }
+    public bool StructureIgnoresCase { get; set; }
+    public bool StructureUsesFieldIds { get; set; }
 }
 
 /// <summary>Generated member access is platform independent. Notification and submission remain host concerns.</summary>
diff --git a/src/Shared/GalNet.Core/Parameters/PropertyPath.cs b/src/Shared/GalNet.Core/Parameters/PropertyPath.cs
new file mode 100644
index 00000000..0005b8f5
--- /dev/null
+++ b/src/Shared/GalNet.Core/Parameters/PropertyPath.cs
@@ -0,0 +1,72 @@
+using System.Collections;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Core.Parameters;
+
+public enum PropertySegmentKind { Member, Index, MapKey, JsonString }
+public readonly record struct PropertySegment(PropertySegmentKind Kind, string Value);
+
+/// <summary>Immutable wire path. Encoding boundaries distinguish a logical child from a JSON string leaf.</summary>
+public sealed class PropertyPath : IReadOnlyList<PropertySegment>
+{
+    private readonly PropertySegment[] _segments;
+    public static PropertyPath Empty { get; } = new([]);
+    private PropertyPath(PropertySegment[] segments) => _segments = segments;
+    public int Count => _segments.Length;
+    public PropertySegment this[int index] => _segments[index];
+    public PropertyPath Member(string name) => Append(new(PropertySegmentKind.Member, name));
+    public PropertyPath MapKey(string key) => Append(new(PropertySegmentKind.MapKey, key));
+    public PropertyPath JsonString() => Append(new(PropertySegmentKind.JsonString, ""));
+    public PropertyPath Index(int index) => index < 0 ? throw new ArgumentOutOfRangeException(nameof(index))
+        : Append(new(PropertySegmentKind.Index, index.ToString(CultureInfo.InvariantCulture)));
+    public PropertyPath Append(PropertySegment segment)
+    {
+        ArgumentNullException.ThrowIfNull(segment.Value);
+        if (!Enum.IsDefined(segment.Kind) || segment.Kind == PropertySegmentKind.Index &&
+            (!int.TryParse(segment.Value, NumberStyles.None, CultureInfo.InvariantCulture, out var index) || index < 0 || segment.Value != index.ToString(CultureInfo.InvariantCulture)))
+            throw new ArgumentException("Invalid property path segment.", nameof(segment));
+        return new([.. _segments, segment]);
+    }
+    public string ToJsonPointer() => Pointer(_segments.TakeWhile(segment => segment.Kind != PropertySegmentKind.JsonString));
+    public string ToLogicalPointer() => Pointer(_segments.Where(segment => segment.Kind != PropertySegmentKind.JsonString));
+    private static string Pointer(IEnumerable<PropertySegment> segments) => string.Concat(segments.Select(segment => "/" + Escape(segment.Value)));
+    public static string Escape(string segment) => segment.Replace("~", "~0", StringComparison.Ordinal).Replace("/", "~1", StringComparison.Ordinal);
+    public static string Unescape(string segment) => segment.Replace("~1", "/", StringComparison.Ordinal).Replace("~0", "~", StringComparison.Ordinal);
+
+    /// <summary>Replace an existing wire location, retaining explicit JSON-string boundaries. The input is never mutated.</summary>
+    public JsonElement Replace(JsonElement source, JsonElement replacement)
+    {
+        if (Count > 64) throw new ArgumentException("The property path is too deep.");
+        JsonNode? Apply(JsonNode? node, int depth)
+        {
+            if (depth == Count) return JsonNode.Parse(replacement.GetRawText());
+            var segment = this[depth];
+            if (segment.Kind == PropertySegmentKind.JsonString)
+            {
+                var decoded = JsonNode.Parse(node!.GetValue<string>(), documentOptions: new() { MaxDepth = 64 });
+                return JsonValue.Create(Apply(decoded, depth + 1)?.ToJsonString() ?? "null");
+            }
+            if (segment.Kind == PropertySegmentKind.Index && node is JsonArray array)
+            {
+                var index = int.Parse(segment.Value, CultureInfo.InvariantCulture);
+                if (index >= array.Count) throw new ArgumentException("The list element no longer exists.");
+                var before = array[index]; var after = Apply(before, depth + 1);
+                if (!ReferenceEquals(before, after)) array[index] = after;
+                return array;
+            }
+            if (segment.Kind is PropertySegmentKind.Member or PropertySegmentKind.MapKey && node is JsonObject obj && obj.ContainsKey(segment.Value))
+            {
+                var before = obj[segment.Value]; var after = Apply(before, depth + 1);
+                if (!ReferenceEquals(before, after)) obj[segment.Value] = after;
+                return obj;
+            }
+            throw new ArgumentException("The wire property no longer exists.");
+        }
+        return JsonCodec.SerializeToElement(Apply(JsonNode.Parse(source.GetRawText()), 0));
+    }
+    public IEnumerator<PropertySegment> GetEnumerator() => ((IEnumerable<PropertySegment>)_segments).GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}
diff --git a/src/Shared/GalNet.Core/Parameters/ValueCodec.cs b/src/Shared/GalNet.Core/Parameters/ValueCodec.cs
index edf4c7a7..df09a90f 100644
--- a/src/Shared/GalNet.Core/Parameters/ValueCodec.cs
+++ b/src/Shared/GalNet.Core/Parameters/ValueCodec.cs
@@ -1,6 +1,7 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Schema;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Core.Parameters;
 
@@ -18,7 +19,7 @@ public static JsonElement SerializeFields(IFieldDto data, bool omitNullValues =
             if (value is JsonElement { ValueKind: JsonValueKind.Undefined } || omitNullValues && value is null) continue;
             values.Add(field.Id, Serialize(field.Value, value));
         }
-        return JsonSerializer.SerializeToElement(values);
+        return JsonCodec.SerializeToElement(values);
     }
 
     public static T DeserializeFields<T>(IReadOnlyList<FieldDescriptor> fields, JsonElement arguments) where T : IFieldDto, new()
@@ -45,7 +46,7 @@ public static JsonElement ParseDefault(ValueDescriptor descriptor, string json)
 
     public static JsonElement Serialize(ValueDescriptor descriptor, object? value)
     {
-        var json = JsonSerializer.SerializeToElement(value, descriptor.ValueType, descriptor.JsonOptions);
+        var json = JsonCodec.SerializeToElement(value, descriptor.ValueType, descriptor.JsonOptions);
         _ = Deserialize(descriptor, json);
         return json;
     }
@@ -59,7 +60,36 @@ public static JsonElement FromEditorText(ValueDescriptor descriptor, string text
 
     /// <summary>Parse a draft without enforcing constraints; validate before committing it.</summary>
     public static JsonElement ParseEditorText(ValueDescriptor descriptor, string text) =>
-        descriptor.IsStringEncoded ? JsonSerializer.SerializeToElement(text) : JsonDocumentValue(text);
+        descriptor.IsStringEncoded ? JsonCodec.SerializeToElement(text) : JsonDocumentValue(NormalizeEditorNumber(descriptor, text));
+
+    private static bool IsFractional(ValueDescriptor descriptor) =>
+        (Nullable.GetUnderlyingType(descriptor.ValueType) ?? descriptor.ValueType) is var type &&
+        (type == typeof(float) || type == typeof(double) || type == typeof(decimal));
+
+    private static string NormalizeEditorNumber(ValueDescriptor descriptor, string text)
+    {
+        if (!IsFractional(descriptor)) return text;
+        var number = text.Trim();
+        if (number.StartsWith('.')) return "0" + number;
+        if (number.StartsWith("-.", StringComparison.Ordinal)) return "-0" + number[1..];
+        return text;
+    }
+
+    /// <summary>Transient numeric prefixes may remain neutral until the user confirms the input.</summary>
+    public static bool IsIncompleteEditorNumber(ValueDescriptor descriptor, string text)
+    {
+        if (descriptor.IsStringEncoded) return false;
+        var type = Nullable.GetUnderlyingType(descriptor.ValueType) ?? descriptor.ValueType;
+        if (!IsFractional(descriptor)) return type.IsPrimitive && type != typeof(bool) && type != typeof(char) && text.Trim() == "-";
+        var number = text.Trim();
+        if (number is "-" or "." or "-.") return true;
+        if (number.EndsWith('.') && double.TryParse(number[..^1], System.Globalization.NumberStyles.AllowLeadingSign,
+                System.Globalization.CultureInfo.InvariantCulture, out var integerPart) && double.IsFinite(integerPart)) return true;
+        var exponent = number.IndexOfAny(['e', 'E']);
+        return exponent > 0 && number[(exponent + 1)..] is "" or "-" or "+" &&
+            double.TryParse(NormalizeEditorNumber(descriptor, number[..exponent]), System.Globalization.NumberStyles.Float,
+                System.Globalization.CultureInfo.InvariantCulture, out var mantissa) && double.IsFinite(mantissa);
+    }
 
     private static JsonElement JsonDocumentValue(string text)
     {
@@ -74,24 +104,17 @@ public static string ToEditorText(ValueDescriptor descriptor, JsonElement value)
     public static JsonElement Describe(ValueDescriptor descriptor, string? referencePrefix = null)
     {
         var schemaOptions = descriptor.JsonOptions.Converters.Any(converter => converter is IStringValueEncoding && converter.CanConvert(typeof(string)))
-            ? JsonSerializerOptions.Default : descriptor.JsonOptions;
-        var exported = schemaOptions.GetJsonSchemaAsNode(descriptor.IsStringEncoded ? typeof(string) : descriptor.ValueType);
+            ? JsonMetadata.Prepare() : descriptor.JsonOptions;
+        var exported = JsonMetadata.GetTypeInfo(descriptor.IsStringEncoded ? typeof(string) : descriptor.ValueType, schemaOptions).GetJsonSchemaAsNode();
         var prefix = referencePrefix ?? "#";
         RebaseReferences(exported, prefix + (descriptor.AllowNull ? "/anyOf/0/allOf/0" : "/allOf/0"));
         // Root rules must not alter the nullability or constraints of recursively referenced child types.
         var schema = new JsonObject { ["allOf"] = new JsonArray(exported), ["not"] = new JsonObject { ["type"] = "null" } };
         if (descriptor.Constraints is { } constraints)
             foreach (var constraint in constraints.EnumerateObject())
-                if (constraint.Name == "options")
-                {
-                    var options = new JsonArray();
-                    foreach (var option in constraint.Value.EnumerateArray())
-                        options.Add(JsonNode.Parse(ParseEditorText(descriptor, option.GetString()!).GetRawText()));
-                    schema["enum"] = options;
-                }
-                else if (constraint.Name is "minimum" or "maximum" or "minLength" or "maxLength" or "minItems" or "maxItems" or "enum")
+                if (constraint.Name is "minimum" or "maximum" or "minLength" or "maxLength" or "minItems" or "maxItems" or "enum")
                     schema[constraint.Name] = JsonNode.Parse(constraint.Value.GetRawText());
-        return JsonSerializer.SerializeToElement(descriptor.AllowNull
+        return JsonCodec.SerializeToElement(descriptor.AllowNull
             ? new JsonObject { ["anyOf"] = new JsonArray(schema, new JsonObject { ["type"] = "null" }) }
             : schema);
     }
diff --git a/src/Shared/GalNet.Core/Parameters/ValueDescriptor.cs b/src/Shared/GalNet.Core/Parameters/ValueDescriptor.cs
index dd2d33f9..39e1f70e 100644
--- a/src/Shared/GalNet.Core/Parameters/ValueDescriptor.cs
+++ b/src/Shared/GalNet.Core/Parameters/ValueDescriptor.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Core.Parameters;
 
@@ -6,7 +7,7 @@ namespace GalNet.Core.Parameters;
 public sealed class ValueDescriptor
 {
     public ValueDescriptor(Type valueType, bool? allowNull = null, JsonElement? constraints = null,
-        JsonSerializerOptions? jsonOptions = null)
+        JsonSerializerOptions? jsonOptions = null, IReadOnlyList<string>? choices = null)
     {
         ArgumentNullException.ThrowIfNull(valueType);
         if (constraints is { ValueKind: not JsonValueKind.Object })
@@ -14,16 +15,16 @@ public ValueDescriptor(Type valueType, bool? allowNull = null, JsonElement? cons
         ValueType = valueType;
         AllowNull = allowNull ?? (valueType == typeof(JsonElement) || !valueType.IsValueType || Nullable.GetUnderlyingType(valueType) is not null);
         Constraints = constraints?.Clone();
-        JsonOptions = jsonOptions is null ? new JsonSerializerOptions() : new JsonSerializerOptions(jsonOptions);
-        JsonOptions.MakeReadOnly(populateMissingResolver: true);
+        JsonOptions = JsonMetadata.Prepare(jsonOptions);
         var encoding = JsonOptions.Converters.FirstOrDefault(converter => converter is IStringValueEncoding &&
             converter.CanConvert(Nullable.GetUnderlyingType(valueType) ?? valueType)) as IStringValueEncoding;
         IsStringEncoded = valueType == typeof(string) || encoding is not null;
-        if (encoding is not null && !TryGetConstraint("options", out _) && !TryGetConstraint("enum", out _))
+        choices ??= TryGetConstraint("enum", out _) ? null : encoding?.Choices;
+        if (choices is not null)
         {
-            var rules = Constraints?.Deserialize<Dictionary<string, JsonElement>>() ?? new();
-            rules["options"] = JsonSerializer.SerializeToElement(encoding.Choices);
-            Constraints = JsonSerializer.SerializeToElement(rules);
+            var rules = Constraints is { } declared ? JsonCodec.Deserialize<Dictionary<string, JsonElement>>(declared) ?? new() : new();
+            rules["enum"] = JsonCodec.SerializeToElement(choices.Select(choice => ValueCodec.ParseEditorText(this, choice)).ToArray());
+            Constraints = JsonCodec.SerializeToElement(rules);
         }
         foreach (var name in new[] { "minLength", "maxLength", "minItems", "maxItems" })
             if (TryGetConstraint(name, out var bound) && (bound.ValueKind != JsonValueKind.Number || !bound.TryGetInt32(out var length) || length < 0))
@@ -31,18 +32,15 @@ public ValueDescriptor(Type valueType, bool? allowNull = null, JsonElement? cons
         foreach (var name in new[] { "minimum", "maximum" })
             if (TryGetConstraint(name, out var bound) && (bound.ValueKind != JsonValueKind.Number || !bound.TryGetDouble(out var number) || !double.IsFinite(number)))
                 throw new ArgumentException($"'{name}' must be a finite number.", nameof(constraints));
-        foreach (var name in new[] { "enum", "options" })
-            if (TryGetConstraint(name, out var choices) && (choices.ValueKind != JsonValueKind.Array ||
-                name == "options" && choices.EnumerateArray().Any(choice => choice.ValueKind != JsonValueKind.String)))
-                throw new ArgumentException($"'{name}' must be an array{(name == "options" ? " of strings" : "")}.", nameof(constraints));
-        if (TryGetConstraint("enum", out _) && TryGetConstraint("options", out _))
-            throw new ArgumentException("Use enum or options, not both.", nameof(constraints));
-        if (TryGetConstraint("options", out var legacyOptions))
-            foreach (var option in legacyOptions.EnumerateArray())
+        if (TryGetConstraint("enum", out var enumValues))
+        {
+            if (enumValues.ValueKind != JsonValueKind.Array) throw new ArgumentException("'enum' must be an array.", nameof(constraints));
+            foreach (var option in enumValues.EnumerateArray())
             {
-                try { _ = JsonSerializer.Deserialize(ValueCodec.ParseEditorText(this, option.GetString()!), ValueType, JsonOptions); }
+                try { _ = JsonCodec.Deserialize(option, ValueType, JsonOptions); }
                 catch (JsonException exception) { throw new ArgumentException("An option is incompatible with the value type.", nameof(constraints), exception); }
             }
+        }
         foreach (var (minimum, maximum) in new[] { ("minimum", "maximum"), ("minLength", "maxLength"), ("minItems", "maxItems") })
             if (TryGetConstraint(minimum, out var lower) && TryGetConstraint(maximum, out var upper) && ValueValidation.CompareNumber(lower, upper) > 0)
                 throw new ArgumentException($"'{minimum}' must not exceed '{maximum}'.", nameof(constraints));
@@ -51,8 +49,24 @@ public ValueDescriptor(Type valueType, bool? allowNull = null, JsonElement? cons
     public Type ValueType { get; }
     public bool AllowNull { get; }
     public JsonElement? Constraints { get; }
-    public JsonSerializerOptions JsonOptions { get; }
+    public JsonSerializerOptions JsonOptions { get; private init; }
     public bool IsStringEncoded { get; }
+    public ValueStructure? Structure { get; private init; }
+    public Func<IReadOnlyList<FieldDescriptor>>? SchemaProvider { get; private init; }
+
+    public ValueDescriptor WithSchemaProvider(Func<IReadOnlyList<FieldDescriptor>> provider) =>
+        new(ValueType, AllowNull, Constraints, JsonOptions) { Structure = Structure, SchemaProvider = provider };
+
+    /// <summary>Describe structured wire data without changing its codec or the existing constructor ABI.</summary>
+    public ValueDescriptor WithStructure(ValueStructure structure)
+    {
+        ArgumentNullException.ThrowIfNull(structure);
+        return new(ValueType, AllowNull, Constraints, JsonOptions) { Structure = structure, SchemaProvider = SchemaProvider, JsonOptions = JsonOptions };
+    }
+
+    public ValueDescriptor WithJsonOptions(JsonSerializerOptions options) =>
+        new(ValueType, AllowNull, Constraints, options) { Structure = Structure, SchemaProvider = SchemaProvider, JsonOptions = JsonMetadata.Prepare(options) };
+
     public bool TryGetConstraint(string name, out JsonElement value)
     {
         if (Constraints is { } constraints && constraints.TryGetProperty(name, out value)) return true;
diff --git a/src/Shared/GalNet.Core/Parameters/ValueDocument.cs b/src/Shared/GalNet.Core/Parameters/ValueDocument.cs
new file mode 100644
index 00000000..f19dc00c
--- /dev/null
+++ b/src/Shared/GalNet.Core/Parameters/ValueDocument.cs
@@ -0,0 +1,247 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Core.Parameters;
+
+public sealed record ValueTraversalOptions(int MaximumDepth = 16, int MaximumNodes = 100_000, bool IncludeMissing = false);
+
+/// <summary>Immutable JSON properties with caller-scoped metadata. Disposal invalidates access, not author data.</summary>
+public sealed class ValueDocument : IDisposable
+{
+    private readonly ValueStructureResolver _resolver;
+    private readonly bool _ownsResolver;
+    private bool _disposed;
+    internal IValueStructureProvider? Provider { get; }
+    internal object? Context { get; }
+    public ValueProperty Root { get; }
+    public ValueDocument(FieldDescriptor root, JsonElement? value, ValueStructureResolver? resolver = null,
+        IValueStructureProvider? provider = null, object? context = null)
+    {
+        ArgumentNullException.ThrowIfNull(root);
+        _ownsResolver = resolver is null; _resolver = resolver ?? new(); Provider = provider; Context = context;
+        Root = new(this, root, value is { ValueKind: not JsonValueKind.Undefined } json ? json.Clone() : null, PropertyPath.Empty);
+    }
+    internal void CheckAccess() => ObjectDisposedException.ThrowIf(_disposed, this);
+    internal ResolvedValueStructure Resolve(ValueProperty property) => _resolver.Resolve(property.Field, property.Value, property.Path, Provider, Context);
+
+    public IEnumerable<ValueProperty> GetIterator(ValueTraversalOptions? options = null, CancellationToken token = default)
+    {
+        options ??= new();
+        if (options.MaximumDepth < 0 || options.MaximumNodes < 1) throw new ArgumentOutOfRangeException(nameof(options));
+        return Iterate(options, token);
+    }
+    private IEnumerable<ValueProperty> Iterate(ValueTraversalOptions options, CancellationToken token)
+    {
+        var stack = new Stack<(IEnumerator<ValueProperty> Items, int Depth)>();
+        stack.Push((new[] { Root }.AsEnumerable().GetEnumerator(), 0));
+        var spent = 0;
+        try
+        {
+            while (stack.TryPeek(out var frame))
+            {
+                CheckAccess(); token.ThrowIfCancellationRequested();
+                if (!frame.Items.MoveNext()) { stack.Pop().Items.Dispose(); continue; }
+                var property = frame.Items.Current;
+                if (++spent > options.MaximumNodes || frame.Depth > options.MaximumDepth)
+                {
+                    yield return property.WithIssue(new("analysis.limit", "Property traversal exceeded its node/depth budget."));
+                    yield break;
+                }
+                yield return property;
+                if (property.Issue is null && property.Value is not null)
+                    stack.Push((property.EnumerateChildren(options.IncludeMissing).GetEnumerator(), frame.Depth + 1));
+            }
+        }
+        finally { while (stack.TryPop(out var frame)) frame.Items.Dispose(); }
+    }
+    /// <summary>Resolve actual member names (and declared field IDs) against a fresh snapshot; never treats a map key as an index.</summary>
+    public ValueProperty? FindProperty(IReadOnlyList<string> segments, int maximumNodes = 100_000, CancellationToken token = default)
+    {
+        CheckAccess();
+        if (segments.Count > 64 || maximumNodes < 1) return null;
+        var current = Root; var spent = 0;
+        foreach (var segment in segments)
+        {
+            token.ThrowIfCancellationRequested();
+            ValueProperty? match = null;
+            foreach (var child in current.EnumerateChildren(includeMissing: true))
+            {
+                if (++spent > maximumNodes) return null;
+                token.ThrowIfCancellationRequested();
+                var comparer = current.Structure.IgnoresCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+                if (!string.Equals(child.Path[^1].Value, segment, comparer) &&
+                    !(current.Structure.Kind == ValueStructureKind.Object && child.Field != current.Structure.AdditionalField
+                        && string.Equals(child.Field.Id, segment, comparer))) continue;
+                if (match is not null || child.Issue?.Code == "field.duplicate") return null;
+                match = child;
+            }
+            if (match is null) return null;
+            current = match;
+        }
+        return current;
+    }
+    public void Dispose() { _disposed = true; if (_ownsResolver) _resolver.Dispose(); }
+
+    /// <summary>Opt-in nested field checks. Partial author edits do not require absent sibling fields.</summary>
+    public IEnumerable<ValueIssue> Validate(bool requireAllFields = false, ValueTraversalOptions? options = null, CancellationToken token = default)
+    {
+        options = (options ?? new()) with { IncludeMissing = requireAllFields };
+        foreach (var property in GetIterator(options, token))
+        {
+            if (property.Issue is { } issue) yield return issue with { Path = property.Path.ToLogicalPointer() };
+            else if (requireAllFields && !property.IsProvided && property.Field.IsRequired && property.Field.DefaultValue is null)
+                yield return new("field.required", "Field must be provided.", property.Path.ToLogicalPointer());
+        }
+    }
+
+    /// <summary>Produce a candidate only; the caller still owns author identity, transactions and business validation.</summary>
+    public ValuePatch Patch(IReadOnlyList<string> segments, JsonElement? replacement, CancellationToken token = default)
+    {
+        CheckAccess();
+        if (segments.Count > 64) return new(null, new("analysis.limit", "The property path is too deep."));
+        var budget = 100_000;
+        try { return PatchCore(Root, segments, 0, replacement, ref budget, token); }
+        catch (Exception error) when (error is ArgumentException or InvalidOperationException or JsonException)
+        { return new(null, new("structure.edit", error.Message)); }
+    }
+    private ValuePatch PatchCore(ValueProperty property, IReadOnlyList<string> segments, int depth, JsonElement? replacement, ref int budget, CancellationToken token)
+    {
+        token.ThrowIfCancellationRequested();
+        if (depth == segments.Count)
+        {
+            if (replacement is { } value && ValueValidation.Validate(property.Field.Value, value) is { } issue) return new(null, issue);
+            if (replacement is null && property.Field.IsRequired && property.Field.DefaultValue is null) return new(null, new("field.required", "Field must be provided."));
+            return new(replacement?.Clone(), null);
+        }
+        if (property.Issue is { } invalid) return new(null, invalid);
+        if (property.Content is { ValueKind: JsonValueKind.Null }) return new(null, new("structure.obsolete", "A null object must be explicitly replaced before editing its members."));
+        var structure = property.Structure;
+        var comparer = structure.IgnoresCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
+        var name = segments[depth]; ValueProperty? selected = null;
+        foreach (var child in property.EnumerateChildren(includeMissing: true))
+        {
+            token.ThrowIfCancellationRequested();
+            if (--budget < 0) return new(null, new("analysis.limit", "Property lookup exceeded its budget."));
+            if (!comparer.Equals(child.Path[^1].Value, name) && !(structure.Kind == ValueStructureKind.Object
+                && child.Field != structure.AdditionalField && comparer.Equals(child.Field.Id, name))) continue;
+            if (selected is not null || child.Issue?.Code is "field.unknown" or "field.duplicate")
+                return new(null, new("structure.ambiguous", "The property name is ambiguous or unknown."));
+            selected = child;
+        }
+        if (selected is null && structure.Kind == ValueStructureKind.Map)
+            selected = new(this, structure.Element!, null, property.Path.MapKey(name));
+        if (selected is null) return new(null, new("structure.obsolete", "The object member or list element is no longer available."));
+        var changed = PatchCore(selected, segments, depth + 1, replacement, ref budget, token);
+        if (changed.Issue is not null) return changed;
+        var node = property.Content is { } content ? JsonNode.Parse(content.GetRawText())! : new JsonObject();
+        var wire = selected.Path[^1].Value;
+        if (node is JsonArray array)
+        {
+            if (changed.Value is not { } element) return new(null, new("structure.element", "Remove an array element with a structural operation."));
+            array[int.Parse(wire, System.Globalization.CultureInfo.InvariantCulture)] = JsonNode.Parse(element.GetRawText());
+        }
+        else if (node is JsonObject obj)
+        {
+            if (changed.Value is { } provided) obj[wire] = JsonNode.Parse(provided.GetRawText()); else obj.Remove(wire);
+        }
+        else return new(null, new("structure.obsolete", "The parent value is not an editable container."));
+        return new(structure.AllowsJsonString && property.Value is { ValueKind: JsonValueKind.String }
+            ? JsonCodec.SerializeToElement(node.ToJsonString()) : JsonCodec.SerializeToElement(node), null);
+    }
+}
+
+public sealed record ValuePatch(JsonElement? Value, ValueIssue? Issue);
+
+public sealed class ValueProperty
+{
+    private readonly ValueDocument _document;
+    private readonly ValueIssue? _issue;
+    private bool _decoded;
+    private JsonElement? _content;
+    private ValueIssue? _decodeIssue;
+    private ResolvedValueStructure? _structure;
+    public FieldDescriptor Field { get; }
+    public JsonElement? Value { get; }
+    public bool IsProvided => Value is not null;
+    public PropertyPath Path { get; }
+    public ResolvedValueStructure Structure { get { _document.CheckAccess(); return _structure ??= _document.Resolve(this); } }
+    public ValueIssue? Issue
+    {
+        get
+        {
+            _document.CheckAccess();
+            if (_issue is not null) return _issue;
+            var content = Content;
+            if (_decodeIssue is not null) return _decodeIssue;
+            if (content is null) return null;
+            if (content.Value.ValueKind == JsonValueKind.Null)
+                return Field.Value.AllowNull ? null : new("value.null", "Value must not be null.");
+            if (Structure.Issue is { } issue)
+                return content.Value.ValueKind is JsonValueKind.Array or JsonValueKind.Object || issue.Code != "field.opaque"
+                    || Field.Value.ValueType != typeof(JsonElement) || Field.Value.Structure?.ResolverId is not null ? issue : null;
+            var expected = Structure.Kind switch { ValueStructureKind.Object or ValueStructureKind.Map => JsonValueKind.Object, ValueStructureKind.Sequence => JsonValueKind.Array, _ => JsonValueKind.Undefined };
+            if (expected != JsonValueKind.Undefined && content.Value.ValueKind != expected)
+                return new(expected == JsonValueKind.Array ? "field.arrayRequired" : "field.objectRequired", expected == JsonValueKind.Array ? "Expected a list." : "Expected an object.");
+            if (Field.Semantic != FieldValueSemantic.None && content.Value.ValueKind != JsonValueKind.String)
+                return new("field.stringRequired", "Localized fields must contain string keys.");
+            if (Structure.Kind == ValueStructureKind.Scalar && Field.Semantic == FieldValueSemantic.None)
+                return ValueValidation.Validate(Field.Value, content.Value);
+            return null;
+        }
+    }
+    internal ValueProperty(ValueDocument document, FieldDescriptor field, JsonElement? value, PropertyPath path, ValueIssue? issue = null)
+    { _document = document; Field = field; Value = value; Path = path; _issue = issue; }
+    internal ValueProperty WithIssue(ValueIssue issue) => new(_document, Field, Value, Path, issue);
+    public JsonElement? Content
+    {
+        get
+        {
+            _document.CheckAccess();
+            if (_decoded) return _content;
+            _decoded = true; _content = Value;
+            if (Structure.AllowsJsonString && Value is { ValueKind: JsonValueKind.String } encoded)
+            {
+                try { using var json = JsonDocument.Parse(encoded.GetString()!, new() { MaxDepth = 64 }); _content = json.RootElement.Clone(); }
+                catch (JsonException error) { _decodeIssue = new("field.objectRequired", error.Message); }
+            }
+            return _content;
+        }
+    }
+    public IEnumerable<ValueProperty> EnumerateChildren(bool includeMissing = false)
+    {
+        _document.CheckAccess();
+        if (Issue is not null || Content is { ValueKind: JsonValueKind.Null }) yield break;
+        var content = Content;
+        var path = Structure.AllowsJsonString && Value is { ValueKind: JsonValueKind.String } ? Path.JsonString() : Path;
+        if (Structure.Kind == ValueStructureKind.Object)
+        {
+            var comparer = Structure.IgnoresCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
+            var seen = new HashSet<string>(comparer);
+            if (content is { ValueKind: JsonValueKind.Object } obj)
+                foreach (var property in obj.EnumerateObject())
+                {
+                    var member = Structure.Members.FirstOrDefault(member => comparer.Equals(member.WireName, property.Name));
+                    var field = member?.Field ?? Structure.AdditionalField;
+                    var issue = !seen.Add(property.Name) ? new ValueIssue("field.duplicate", "Duplicate author property.")
+                        : field is null ? new ValueIssue("field.unknown", "Unknown author field cannot be analyzed.") : null;
+                    yield return new(_document, field ?? UnknownField, property.Value, path.Member(property.Name), issue);
+                }
+            if (includeMissing)
+                foreach (var member in Structure.Members)
+                    if (!seen.Contains(member.WireName)) yield return new(_document, member.Field, null, path.Member(member.WireName));
+        }
+        else if (Structure.Kind == ValueStructureKind.Sequence && content is { ValueKind: JsonValueKind.Array } array)
+        {
+            var index = 0;
+            foreach (var item in array.EnumerateArray()) yield return new(_document, Structure.Element!, item, path.Index(index++));
+        }
+        else if (Structure.Kind == ValueStructureKind.Map && content is { ValueKind: JsonValueKind.Object } map)
+        {
+            var seen = new HashSet<string>(StringComparer.Ordinal);
+            foreach (var member in map.EnumerateObject())
+                yield return new(_document, Structure.Element!, member.Value, path.MapKey(member.Name), seen.Add(member.Name) ? null : new("field.duplicate", "Duplicate map key."));
+        }
+    }
+    private static FieldDescriptor UnknownField { get; } = new("unknown", new(typeof(JsonElement)));
+}
diff --git a/src/Shared/GalNet.Core/Parameters/ValueStructure.cs b/src/Shared/GalNet.Core/Parameters/ValueStructure.cs
new file mode 100644
index 00000000..08a789a5
--- /dev/null
+++ b/src/Shared/GalNet.Core/Parameters/ValueStructure.cs
@@ -0,0 +1,64 @@
+using System.Text.Json;
+
+namespace GalNet.Core.Parameters;
+
+public enum ValueStructureKind { Scalar, Object, Sequence, Map, Opaque }
+
+/// <summary>Lazy structural metadata. Type references do not initialize their child schemas.</summary>
+public sealed class ValueStructure
+{
+    private ValueStructure() { }
+    public Type? SchemaType { get; private init; }
+    public IReadOnlyList<FieldDescriptor>? Fields { get; private init; }
+    public FieldDescriptor? Element { get; private init; }
+    public FieldDescriptor? AdditionalField { get; private init; }
+    public ValueStructureKind? Kind { get; private init; }
+    public bool AllowsJsonString { get; private init; }
+    public bool IgnoresCase { get; private init; }
+    public bool UsesFieldIds { get; private init; }
+    public string? ResolverId { get; private init; }
+
+    public static ValueStructure ForType(Type type, bool allowsJsonString = false, bool ignoresCase = false, bool usesFieldIds = false)
+    {
+        ArgumentNullException.ThrowIfNull(type);
+        return new() { SchemaType = type, AllowsJsonString = allowsJsonString, IgnoresCase = ignoresCase, UsesFieldIds = usesFieldIds };
+    }
+    public static ValueStructure Object(IEnumerable<FieldDescriptor> fields, bool ignoresCase = false)
+    {
+        ArgumentNullException.ThrowIfNull(fields);
+        var members = fields.ToArray();
+        if (members.Select(field => field.Id).Distinct(ignoresCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal).Count() != members.Length)
+            throw new ArgumentException("Object field identities must be unique.", nameof(fields));
+        return new() { Kind = ValueStructureKind.Object, Fields = Array.AsReadOnly(members), IgnoresCase = ignoresCase };
+    }
+    public static ValueStructure Sequence(FieldDescriptor element) => new() { Kind = ValueStructureKind.Sequence, Element = element ?? throw new ArgumentNullException(nameof(element)) };
+    /// <summary>Explicitly declares additional object members and their value contract.</summary>
+    public static ValueStructure OpenObject(IEnumerable<FieldDescriptor> fields, FieldDescriptor additionalField, bool ignoresCase = false)
+    {
+        ArgumentNullException.ThrowIfNull(additionalField);
+        var shape = Object(fields, ignoresCase);
+        return new() { Kind = shape.Kind, Fields = shape.Fields, IgnoresCase = shape.IgnoresCase, AdditionalField = additionalField };
+    }
+    /// <summary>An atomic codec value with no child semantics, including deliberately uninterpreted JSON.</summary>
+    public static ValueStructure Scalar() => new() { Kind = ValueStructureKind.Scalar };
+    public static ValueStructure Map(FieldDescriptor value) => new() { Kind = ValueStructureKind.Map, Element = value ?? throw new ArgumentNullException(nameof(value)) };
+    public static ValueStructure Dynamic(string resolverId)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(resolverId);
+        return new() { ResolverId = resolverId };
+    }
+}
+
+/// <summary>The caller owns the frozen context and its validity; no project or UI services are required.</summary>
+public interface IValueStructureProvider
+{
+    ValueStructure? Resolve(string id, FieldDescriptor field, JsonElement? value, PropertyPath path, object? context);
+}
+
+public sealed record ValueStructureMember(FieldDescriptor Field, string WireName);
+
+public sealed record ResolvedValueStructure(ValueStructureKind Kind, IReadOnlyList<ValueStructureMember> Members,
+    FieldDescriptor? Element = null, bool AllowsJsonString = false, bool IgnoresCase = false, ValueIssue? Issue = null)
+{
+    public FieldDescriptor? AdditionalField { get; init; }
+}
diff --git a/src/Shared/GalNet.Core/Parameters/ValueStructureResolver.cs b/src/Shared/GalNet.Core/Parameters/ValueStructureResolver.cs
new file mode 100644
index 00000000..fa890734
--- /dev/null
+++ b/src/Shared/GalNet.Core/Parameters/ValueStructureResolver.cs
@@ -0,0 +1,130 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+using GalNet.Core.Serialization;
+
+namespace GalNet.Core.Parameters;
+
+/// <summary>Caller-scoped metadata cache. Never constructs a DTO or reads its instance properties.</summary>
+public sealed class ValueStructureResolver : IDisposable
+{
+    private readonly Dictionary<(Type Type, JsonSerializerOptions Options, ValueStructure? Structure), ResolvedValueStructure> _cache = [];
+    private bool _disposed;
+    public ResolvedValueStructure Resolve(FieldDescriptor field, JsonElement? value = null, PropertyPath? path = null,
+        IValueStructureProvider? provider = null, object? context = null)
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+        var descriptor = field.Value;
+        var declaration = descriptor.Structure;
+        if (declaration?.ResolverId is { } id)
+        {
+            declaration = provider?.Resolve(id, field, value, path ?? PropertyPath.Empty, context);
+            if (declaration is null || declaration.ResolverId is not null) return Opaque("Dynamic structure is unavailable.");
+            return ResolveCore(descriptor, declaration);
+        }
+        var key = (descriptor.ValueType, descriptor.JsonOptions, declaration);
+        if (!_cache.TryGetValue(key, out var result)) _cache.Add(key, result = ResolveCore(descriptor, declaration));
+        return result;
+    }
+    private static ResolvedValueStructure Opaque(string message) => new(ValueStructureKind.Opaque, [], Issue: new("field.opaque", message));
+    private static ResolvedValueStructure ResolveCore(ValueDescriptor descriptor, ValueStructure? declaration)
+    {
+        try
+        {
+            if (declaration?.Kind is { } explicitKind)
+                return new(explicitKind, Array.AsReadOnly(declaration.Fields?.Select(field => new ValueStructureMember(Inherit(field, descriptor.JsonOptions), field.Id)).ToArray() ?? []),
+                    declaration.Element is { } elementField ? Inherit(elementField, descriptor.JsonOptions) : null,
+                    declaration.AllowsJsonString, declaration.IgnoresCase)
+                { AdditionalField = declaration.AdditionalField is { } additional ? Inherit(additional, descriptor.JsonOptions) : null };
+            var type = Nullable.GetUnderlyingType(declaration?.SchemaType ?? descriptor.ValueType) ?? declaration?.SchemaType ?? descriptor.ValueType;
+            if (declaration is null && descriptor.IsStringEncoded && IsScalar(type)) return new(ValueStructureKind.Scalar, []);
+            if (declaration is null && type == typeof(JsonElement)) return Opaque("Structured value has no traversable field schema.");
+            var info = JsonMetadata.GetTypeInfo(type, descriptor.JsonOptions);
+            if (info.Kind == JsonTypeInfoKind.None)
+                return declaration?.SchemaType is not null
+                    ? new(ValueStructureKind.Opaque, [], Issue: new("schema.invalid", "The declared structure type does not expose an object or collection contract."))
+                    : IsScalar(type)
+                    ? new(ValueStructureKind.Scalar, []) : Opaque("The value codec does not expose a traversable structure.");
+            var element = ElementType(type);
+            if (info.Kind == JsonTypeInfoKind.Enumerable && element is not null)
+                return new(ValueStructureKind.Sequence, [], Child("element", element, descriptor), AllowsJsonString: declaration?.AllowsJsonString == true);
+            var map = MapType(type);
+            if (info.Kind == JsonTypeInfoKind.Dictionary && map is not null)
+                return new(ValueStructureKind.Map, [], Child("value", map, descriptor), AllowsJsonString: declaration?.AllowsJsonString == true);
+            if (!typeof(IFieldDto).IsAssignableFrom(type) || info.Kind != JsonTypeInfoKind.Object)
+                return Opaque("Structured value has no traversable field schema.");
+            var fields = descriptor.SchemaProvider?.Invoke();
+            if (fields is null && JsonSerializer.IsReflectionEnabledByDefault) fields = ReflectionSchema(type);
+            if (fields is null)
+                return new(ValueStructureKind.Opaque, [], Issue: new("schema.unavailable", "Nested DTO has no readable schema."));
+            var members = fields.Select(field => MapMember(field, type, descriptor.JsonOptions, info, declaration?.UsesFieldIds == true)).ToArray();
+            var comparer = declaration?.IgnoresCase == true || descriptor.JsonOptions.PropertyNameCaseInsensitive ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
+            if (members.Select(member => member.WireName).Distinct(comparer).Count() != members.Length)
+                throw new InvalidOperationException("Schema members have ambiguous wire names.");
+            return new(ValueStructureKind.Object, Array.AsReadOnly(members), AllowsJsonString: declaration?.AllowsJsonString == true,
+                IgnoresCase: comparer == StringComparer.OrdinalIgnoreCase);
+        }
+        catch (Exception error) when (error is ArgumentException or InvalidOperationException or NotSupportedException or TargetInvocationException or TypeInitializationException)
+        { return new(ValueStructureKind.Opaque, [], Issue: new("schema.invalid", error.InnerException?.Message ?? error.Message)); }
+    }
+    private static ValueStructureMember MapMember(FieldDescriptor field, Type type, JsonSerializerOptions parent, JsonTypeInfo info, bool usesFieldIds)
+    {
+        JsonPropertyInfo? wire;
+        if (field.MemberName is { } memberName)
+        {
+            var name = field.JsonPropertyName ?? parent.PropertyNamingPolicy?.ConvertName(memberName) ?? memberName;
+            wire = info.Properties.FirstOrDefault(property => property.Name == name)
+                ?? throw new InvalidOperationException($"Field '{field.Id}' is absent from the wire contract.");
+        }
+        else if (JsonSerializer.IsReflectionEnabledByDefault) wire = ReflectionMember(field, type, info);
+        else wire = info.Properties.FirstOrDefault(property => property.Name == field.Id);
+        return new(Inherit(field, parent), usesFieldIds ? field.Id : wire?.Name ?? field.Id);
+    }
+
+    [RequiresUnreferencedCode("Only used by reflection-enabled desktop hosts for handwritten schemas.")]
+    private static IReadOnlyList<FieldDescriptor>? ReflectionSchema(Type type) =>
+        type.GetProperty("Schema", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)?.GetValue(null) as IReadOnlyList<FieldDescriptor>;
+
+    [RequiresUnreferencedCode("Generated fields carry their CLR and JSON member names directly.")]
+    private static JsonPropertyInfo? ReflectionMember(FieldDescriptor field, Type type, JsonTypeInfo info)
+    {
+        var source = type.GetMembers(BindingFlags.Public | BindingFlags.Instance).FirstOrDefault(member => member is PropertyInfo or FieldInfo
+            && member.GetCustomAttribute<FieldAttribute>() is not null
+            && (member.GetCustomAttribute<JsonPropertyNameAttribute>()?.Name ?? JsonNamingPolicy.CamelCase.ConvertName(member.Name)) == field.Id);
+        var wire = info.Properties.FirstOrDefault(property => property.AttributeProvider is MemberInfo member && member.Name == source?.Name);
+        // Handwritten IFieldDto schemas may describe wire members without Field annotations.
+        wire ??= info.Properties.FirstOrDefault(property => property.Name == field.Id);
+        if (source is not null && wire is null) throw new InvalidOperationException($"Field '{field.Id}' is absent from the wire contract.");
+        return wire;
+    }
+    private static FieldDescriptor Child(string id, Type type, ValueDescriptor parent)
+    {
+        var value = new ValueDescriptor(type, jsonOptions: parent.JsonOptions);
+        if (parent.SchemaProvider is { } schema) value = value.WithSchemaProvider(schema);
+        return new(id, value);
+    }
+    private static FieldDescriptor Inherit(FieldDescriptor field, JsonSerializerOptions parent)
+    {
+        var options = parent;
+        if (field.Value.JsonOptions.Converters.Count > 0 &&
+            !parent.Converters.Take(field.Value.JsonOptions.Converters.Count).SequenceEqual(field.Value.JsonOptions.Converters))
+        {
+            options = new(parent);
+            foreach (var converter in field.Value.JsonOptions.Converters.Reverse()) options.Converters.Insert(0, converter);
+        }
+        var value = field.Value.WithJsonOptions(options);
+        var inherited = new FieldDescriptor(field.Id, value, field.IsRequired, field.DefaultValue, field.Editor, field.LabelKey, field.DescriptionKey, field.Semantic, field.ResourceTypeId);
+        return field.MemberName is { } name ? inherited.WithMember(name, field.JsonPropertyName) : inherited;
+    }
+    public static Type? ElementType(Type type) => type.IsArray && type.GetArrayRank() == 1 ? type.GetElementType()
+        : type.IsGenericType && type.GetGenericTypeDefinition() is var generic &&
+          (generic == typeof(List<>) || generic == typeof(IList<>) || generic == typeof(IReadOnlyList<>) || generic == typeof(IEnumerable<>)) ? type.GetGenericArguments()[0] : null;
+    public static Type? MapType(Type type) => type.IsGenericType && type.GetGenericArguments() is var arguments && arguments.Length == 2 && arguments[0] == typeof(string)
+        && type.GetGenericTypeDefinition() is var generic && (generic == typeof(Dictionary<,>) || generic == typeof(IDictionary<,>) || generic == typeof(IReadOnlyDictionary<,>)) ? arguments[1] : null;
+    private static bool IsScalar(Type type) => type.IsPrimitive || type.IsEnum || type == typeof(string) || type == typeof(decimal)
+        || type == typeof(Guid) || type == typeof(DateTime) || type == typeof(DateTimeOffset) || type == typeof(TimeSpan)
+        || type == typeof(DateOnly) || type == typeof(TimeOnly) || type == typeof(Uri) || type == typeof(Version) || type == typeof(byte[]);
+    public void Dispose() { _disposed = true; _cache.Clear(); }
+}
diff --git a/src/Shared/GalNet.Core/Parameters/ValueValidation.cs b/src/Shared/GalNet.Core/Parameters/ValueValidation.cs
index 3e00300f..1cc8113e 100644
--- a/src/Shared/GalNet.Core/Parameters/ValueValidation.cs
+++ b/src/Shared/GalNet.Core/Parameters/ValueValidation.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Core.Parameters;
 
@@ -13,7 +14,7 @@ public static class ValueValidation
             return new("value.finite", "Value must be finite.");
         try
         {
-            return Validate(descriptor, JsonSerializer.SerializeToElement(value, descriptor.ValueType, descriptor.JsonOptions));
+            return Validate(descriptor, JsonCodec.SerializeToElement(value, descriptor.ValueType, descriptor.JsonOptions));
         }
         catch (Exception exception) when (exception is JsonException or ArgumentException)
         {
@@ -38,7 +39,7 @@ public static class ValueValidation
         if (value.ValueKind == JsonValueKind.Null)
             return descriptor.ValueType == typeof(JsonElement) ? value.Clone() : null;
         object? result;
-        try { result = JsonSerializer.Deserialize(value, descriptor.ValueType, descriptor.JsonOptions); }
+        try { result = JsonCodec.Deserialize(value, descriptor.ValueType, descriptor.JsonOptions); }
         catch (JsonException exception)
         {
             issue = new("value.type", $"Value is not compatible with '{descriptor.ValueType.Name}'.", exception.Path);
@@ -54,8 +55,7 @@ public static class ValueValidation
             issue = new("value.length", "Value is outside its supported length.");
         else if (value.ValueKind == JsonValueKind.Array && OutsideLength(descriptor, "minItems", "maxItems", value.GetArrayLength()))
             issue = new("value.items", "Array is outside its supported length.");
-        else if (descriptor.TryGetConstraint("enum", out var choices) && !choices.EnumerateArray().Any(choice => JsonElement.DeepEquals(choice, value)) ||
-            descriptor.TryGetConstraint("options", out var options) && !options.EnumerateArray().Any(option => JsonElement.DeepEquals(ValueCodec.ParseEditorText(descriptor, option.GetString()!), value)))
+        else if (descriptor.TryGetConstraint("enum", out var choices) && !choices.EnumerateArray().Any(choice => JsonElement.DeepEquals(choice, value)))
             issue = new("value.option", "Value has an unsupported value.");
         return result;
     }
diff --git a/src/Shared/GalNet.Core/Primitives/PrimitiveCreateContext.cs b/src/Shared/GalNet.Core/Primitives/PrimitiveCreateContext.cs
index 9f6e67aa..7522b0e4 100644
--- a/src/Shared/GalNet.Core/Primitives/PrimitiveCreateContext.cs
+++ b/src/Shared/GalNet.Core/Primitives/PrimitiveCreateContext.cs
@@ -10,7 +10,7 @@ public sealed class PrimitiveCreateContext
     public PrimitiveCreateContext(
         EntryDefinition definition,
         PrimitiveEntry entry,
-        IGameRuntime runtime,
+        IGameContext runtime,
         CancellationToken scopeCancellation)
     {
         ArgumentNullException.ThrowIfNull(definition);
@@ -24,9 +24,9 @@ public PrimitiveCreateContext(
 
     public EntryDefinition Definition { get; }
     public PrimitiveEntry Entry { get; }
-    public IGameRuntime Runtime { get; }
+    public IGameContext Runtime { get; }
     public CancellationToken ScopeCancellation { get; }
-    public DynamicParameterTable Parameters => Definition.DynamicParameters!;
+    public DynamicParameterTable Parameters => Definition.DynamicParameters;
     public JsonElement Arguments => Entry.Arguments;
     public string? BatchId => Entry.BatchId;
 }
diff --git a/src/Shared/GalNet.Core/Runtime/GameSnapshot.cs b/src/Shared/GalNet.Core/Runtime/GameSnapshot.cs
index 15ba466a..c417cd5d 100644
--- a/src/Shared/GalNet.Core/Runtime/GameSnapshot.cs
+++ b/src/Shared/GalNet.Core/Runtime/GameSnapshot.cs
@@ -3,7 +3,7 @@ namespace GalNet.Core.Runtime;
 /// <summary>Persisted runtime state needed to resume a game and rebuild its visible scene.</summary>
 public sealed class GameSnapshot
 {
-    public const int CurrentFormatVersion = 4;
+    public const int CurrentFormatVersion = 5;
 
     /// <summary>Persisted save format version. Older formats are intentionally rejected.</summary>
     public int Version { get; init; } = CurrentFormatVersion;
@@ -13,6 +13,8 @@ public sealed class GameSnapshot
 
     /// <summary>Zero-based position of the next entry within <see cref="NodeId"/>.</summary>
     public int EntryIndex { get; init; }
+    public string ContentBuildId { get; init; } = "";
+    public string[] StoryPackages { get; init; } = [];
 
     /// <summary>Save-scoped variable values captured for this snapshot.</summary>
     public Dictionary<string, GalNet.Core.Variable.Variable> Variables { get; init; } = [];
@@ -20,4 +22,7 @@ public sealed class GameSnapshot
     /// <summary>Layer, control, effect, and transition state used to rehydrate the presentation.</summary>
     [System.Text.Json.Serialization.JsonRequired]
     public Dictionary<string, StateSection> States { get; init; } = new(StringComparer.Ordinal);
+
+    /// <summary>Optional host-owned save data. Execution does not interpret or restore these attachments.</summary>
+    public Dictionary<string, System.Text.Json.JsonElement> Attachments { get; init; } = new(StringComparer.Ordinal);
 }
diff --git a/src/Shared/GalNet.Core/Runtime/GameState.cs b/src/Shared/GalNet.Core/Runtime/GameState.cs
index f8d6c9a4..f035d7be 100644
--- a/src/Shared/GalNet.Core/Runtime/GameState.cs
+++ b/src/Shared/GalNet.Core/Runtime/GameState.cs
@@ -1,6 +1,7 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
-using GalNet.Core.Scene;
+using System.Text.Json.Serialization.Metadata;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Core.Runtime;
 
@@ -18,29 +19,33 @@ public sealed class StateCatalog
 public sealed class StateCatalogBuilder
 {
     private readonly List<StateContract> _contracts = [];
-    public void Register<T>(string id, Func<T, string> key, Action<T>? validate = null, int version = 1) where T : class
+    public void Register<T>(string id, Func<T, string> key, Action<T>? validate = null, int version = 1, string? keySpace = null,
+        JsonTypeInfo<T[]>? jsonTypeInfo = null) where T : class
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(id);
         ArgumentNullException.ThrowIfNull(key);
         ArgumentOutOfRangeException.ThrowIfLessThan(version, 1);
         if (_contracts.Any(item => item.Id == id || item.Type == typeof(T)))
             throw new InvalidOperationException($"Duplicate state contract '{id}' / '{typeof(T).Name}'.");
-        _contracts.Add(new StateContract<T>(id, version, key, validate));
+        _contracts.Add(new StateContract<T>(id, version, key, validate, keySpace, jsonTypeInfo));
     }
     public StateCatalog Build() => new(_contracts);
 }
 
-internal abstract class StateContract(string id, int version, Type type)
+internal abstract class StateContract(string id, int version, Type type, string? keySpace)
 {
     public string Id { get; } = id;
     public int Version { get; } = version;
     public Type Type { get; } = type;
+    public string? KeySpace { get; } = keySpace;
     public abstract IStateTable Create(GameState owner, JsonElement? payload);
 }
 
-internal sealed class StateContract<T>(string id, int version, Func<T, string> key, Action<T>? validate)
-    : StateContract(id, version, typeof(T)) where T : class
+internal sealed class StateContract<T>(string id, int version, Func<T, string> key, Action<T>? validate, string? keySpace,
+    JsonTypeInfo<T[]>? jsonTypeInfo)
+    : StateContract(id, version, typeof(T), keySpace) where T : class
 {
+    internal JsonTypeInfo<T[]> JsonTypeInfo => jsonTypeInfo ?? JsonMetadata.GetTypeInfo<T[]>(GameState.JsonOptions);
     public override IStateTable Create(GameState owner, JsonElement? payload)
     {
         var table = new StateTable<T>(owner, this, key, validate);
@@ -48,7 +53,7 @@ public override IStateTable Create(GameState owner, JsonElement? payload)
         {
             if (json.ValueKind != JsonValueKind.Array) throw new InvalidDataException($"State '{Id}' must be an array.");
             T[] values;
-            try { values = json.Deserialize<T[]>(GameState.JsonOptions) ?? throw new InvalidDataException($"Invalid state '{Id}'."); }
+            try { values = JsonSerializer.Deserialize(json, JsonTypeInfo) ?? throw new InvalidDataException($"Invalid state '{Id}'."); }
             catch (JsonException error) { throw new InvalidDataException($"Invalid state '{Id}': {error.Message}", error); }
             foreach (var value in values)
                 table.Add(value);
@@ -70,9 +75,9 @@ public sealed class StateTable<T> : IStateTable where T : class
     private readonly Func<T, string> _key;
     private readonly Action<T>? _validate;
     private readonly Dictionary<string, T> _values = new(StringComparer.Ordinal);
-    private readonly StateContract _contract;
+    private readonly StateContract<T> _contract;
     StateContract IStateTable.Contract => _contract;
-    internal StateTable(GameState owner, StateContract contract, Func<T, string> key, Action<T>? validate)
+    internal StateTable(GameState owner, StateContract<T> contract, Func<T, string> key, Action<T>? validate)
     { _owner = owner; _contract = contract; _key = key; _validate = validate; }
     public IReadOnlyList<T> Values { get { lock (_owner.SyncRoot) return _values.Values.ToArray(); } }
     public bool TryGet(string id, out T value) { lock (_owner.SyncRoot) return _values.TryGetValue(id, out value!); }
@@ -88,7 +93,7 @@ private void Write(T value, bool replace)
             if (string.IsNullOrWhiteSpace(id)) throw new InvalidDataException($"State '{_contract.Id}' has an empty ID.");
             _validate?.Invoke(value);
             if (!replace && _values.ContainsKey(id)) throw new InvalidDataException($"Duplicate state item '{_contract.Id}/{id}'.");
-            _owner.CheckSceneIdentity(value, _values.GetValueOrDefault(id));
+            _owner.CheckIdentity(_contract.KeySpace, id, value, _values.GetValueOrDefault(id));
             _values[id] = value;
         }
     }
@@ -97,7 +102,7 @@ public bool Remove(string id)
         lock (_owner.SyncRoot)
         {
             if (!_values.Remove(id, out var value)) return false;
-            _owner.RemoveSceneIdentity(value);
+            _owner.RemoveIdentity(_contract.KeySpace, id, value);
             return true;
         }
     }
@@ -105,27 +110,26 @@ public void Clear()
     {
         lock (_owner.SyncRoot)
         {
-            foreach (var value in _values.Values) _owner.RemoveSceneIdentity(value);
+            foreach (var (id, value) in _values) _owner.RemoveIdentity(_contract.KeySpace, id, value);
             _values.Clear();
         }
     }
-    JsonElement IStateTable.Encode() => JsonSerializer.SerializeToElement(_values.Values.ToArray(), GameState.JsonOptions);
+    JsonElement IStateTable.Encode() => JsonSerializer.SerializeToElement(_values.Values.ToArray(), _contract.JsonTypeInfo);
 }
 
 /// <summary>Canonical persistent facts for one run. Old run references never resolve through a new state root.</summary>
 public sealed class GameState
 {
-    internal static JsonSerializerOptions JsonOptions { get; } = new()
+    public static JsonSerializerOptions JsonOptions { get; } = JsonMetadata.CreateOptions(new()
     {
         AllowDuplicateProperties = false,
         PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
         IgnoreReadOnlyProperties = true,
         UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow,
-        Converters = { new JsonStringEnumConverter() }
-    };
-    public object SyncRoot { get; } = new();
+    }, stringEnums: true);
+    internal object SyncRoot { get; } = new();
     private readonly Dictionary<Type, IStateTable> _tables = [];
-    private readonly Dictionary<string, ISceneInstance> _scene = new(StringComparer.Ordinal);
+    private readonly Dictionary<(string Space, string Id), object> _identities = new();
     private StateCatalog? _lastCatalog;
     public GameState(StateCatalog? catalog = null) => Configure(catalog ?? StateCatalog.Empty);
     public void Configure(StateCatalog catalog)
@@ -137,7 +141,7 @@ public void Configure(StateCatalog catalog)
             {
                 if (_tables.TryGetValue(contract.Type, out var existing))
                 {
-                    if (existing.Contract.Id != contract.Id || existing.Contract.Version != contract.Version)
+                    if (existing.Contract.Id != contract.Id || existing.Contract.Version != contract.Version || existing.Contract.KeySpace != contract.KeySpace)
                         throw new InvalidOperationException($"Conflicting state contract '{contract.Id}'.");
                     continue;
                 }
@@ -154,6 +158,7 @@ public StateTable<T> Table<T>() where T : class
             : throw new InvalidOperationException($"State type '{typeof(T).Name}' is not registered.");
     }
     public void Update(Action action) { lock (SyncRoot) action(); }
+    public T Update<T>(Func<T> update) { lock (SyncRoot) return update(); }
     public T Read<T>(Func<T> read) { lock (SyncRoot) return read(); }
     public Dictionary<string, StateSection> Capture()
     {
@@ -173,28 +178,28 @@ public static GameState Restore(StateCatalog catalog, IReadOnlyDictionary<string
         }
         return state;
     }
-    internal void CheckSceneIdentity(object value, object? previous)
+    internal void CheckIdentity(string? space, string id, object value, object? previous)
     {
-        if (value is not ISceneInstance scene) return;
-        if (_scene.TryGetValue(scene.Id, out var existing) && !ReferenceEquals(existing, previous))
-            throw new InvalidOperationException($"Scene handle '{scene.Id}' is already in use.");
-        _scene[scene.Id] = scene;
+        if (space is null) return;
+        if (_identities.TryGetValue((space, id), out var existing) && !ReferenceEquals(existing, previous))
+            throw new InvalidOperationException($"State handle '{id}' is already in use in '{space}'.");
+        _identities[(space, id)] = value;
     }
-    internal void RemoveSceneIdentity(object value)
+    internal void RemoveIdentity(string? space, string id, object value)
     {
-        if (value is ISceneInstance scene && _scene.TryGetValue(scene.Id, out var existing) && ReferenceEquals(existing, value))
-            _scene.Remove(scene.Id);
+        if (space is not null && _identities.TryGetValue((space, id), out var existing) && ReferenceEquals(existing, value))
+            _identities.Remove((space, id));
     }
-    public bool TryGetScene<T>(string id, out T value) where T : class, ISceneInstance
+    public bool TryGetIdentity<T>(string space, string id, out T value) where T : class
     {
         lock (SyncRoot)
         {
-            value = _scene.GetValueOrDefault(id) as T ?? null!;
+            value = _identities.GetValueOrDefault((space, id)) as T ?? null!;
             return value is not null;
         }
     }
-    public IReadOnlyList<T> SceneObjects<T>() where T : class, ISceneInstance
+    public IReadOnlyList<T> IdentityObjects<T>(string space) where T : class
     {
-        lock (SyncRoot) return _scene.Values.OfType<T>().ToArray();
+        lock (SyncRoot) return _identities.Where(pair => pair.Key.Space == space).Select(pair => pair.Value).OfType<T>().ToArray();
     }
 }
diff --git a/src/Shared/GalNet.Core/Runtime/IGameContext.cs b/src/Shared/GalNet.Core/Runtime/IGameContext.cs
new file mode 100644
index 00000000..e0ab3b87
--- /dev/null
+++ b/src/Shared/GalNet.Core/Runtime/IGameContext.cs
@@ -0,0 +1,22 @@
+using GalNet.Core.Services;
+using GalNet.Core.Variable;
+using GalVariable = GalNet.Core.Variable.Variable;
+
+namespace GalNet.Core.Runtime;
+
+/// <summary>Gameplay capabilities borrowed by an instruction or presentation, scoped to one run.</summary>
+public interface IGameContext
+{
+    string CurrentNodeId { get; }
+    int EntryIndex { get; }
+    bool IsGameEnded { get; }
+    ITextResolver TextResolver { get; }
+    GameState State { get; }
+    void EndGame();
+    void SetVariable(string name, object value);
+    GalVariable? GetVariable(string name);
+    bool TryGetVariable(string name, out GalVariable variable);
+    IReadOnlyDictionary<string, GalVariable> GetVariables(VariableScope scope);
+    bool EvaluateCondition(string expression);
+    object? EvaluateExpression(string expression);
+}
diff --git a/src/Shared/GalNet.Core/Runtime/IGameRuntime.cs b/src/Shared/GalNet.Core/Runtime/IGameRuntime.cs
deleted file mode 100644
index 3f583c31..00000000
--- a/src/Shared/GalNet.Core/Runtime/IGameRuntime.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-using GalNet.Core.Scene;
-using GalNet.Core.Services;
-using GalNet.Core.Settings;
-using GalNet.Core.Variable;
-
-namespace GalNet.Core.Runtime;
-
-/// <summary>
-/// 游戏运行时状态接口 —— 统一管理游戏当前的位置、变量、场景状态等。
-/// 由 GameRuntime 实现，并通过 PrimitiveCreateContext 提供给每次原语实例。
-///
-/// 设计原则：
-///   - 位置/结束标志仅暴露只读属性，防止 Handler 意外修改控制流。
-///   - 所有控制流变更通过显式方法（JumpTo / EndGame）进行，意图明确。
-/// </summary>
-public interface IGameRuntime
-{
-    // ── 位置（只读）──
-    string CurrentNodeId { get; }
-    int EntryIndex { get; }
-
-    // ── 游戏结束标志（只读）──
-    bool IsGameEnded { get; }
-
-    // ── 核心引用 ──
-    ITextResolver TextResolver { get; }
-
-    // ── 设置 ──
-    SettingsContainer Settings { get; }
-
-    // ── 场景状态 ──
-    GameState State { get; }
-    ISceneInstanceManager SceneInstances { get; }
-
-    // ── 控制流方法 ──
-
-    /// <summary>跳转到指定节点，并重置 EntryIndex。</summary>
-    void JumpTo(string nodeId, int entryIndex = 0);
-
-    /// <summary>直接设置条目索引进度（引擎步进或测试用）。</summary>
-    void SetEntryIndex(int entryIndex);
-
-    /// <summary>标记游戏结束。</summary>
-    void EndGame();
-
-    // ── 变量操作 ──
-    void SetVariable(string name, object value);
-    GalNet.Core.Variable.Variable? GetVariable(string name);
-    bool TryGetVariable(string name, out GalNet.Core.Variable.Variable variable);
-    IReadOnlyDictionary<string, GalNet.Core.Variable.Variable> GetVariables(VariableScope scope);
-    bool EvaluateCondition(string expression);
-    object? EvaluateExpression(string expression);
-
-    // ── 存档快照 ──
-    GameSnapshot CreateSnapshot();
-    void RestoreFrom(GameSnapshot snapshot);
-}
diff --git a/src/Shared/GalNet.Core/Runtime/NewGameVariables.cs b/src/Shared/GalNet.Core/Runtime/NewGameVariables.cs
new file mode 100644
index 00000000..96d6f791
--- /dev/null
+++ b/src/Shared/GalNet.Core/Runtime/NewGameVariables.cs
@@ -0,0 +1,23 @@
+namespace GalNet.Core.Runtime;
+
+/// <summary>Copies and validates one new run's save-only startup parameters.</summary>
+public static class NewGameVariables
+{
+    public static IReadOnlyDictionary<string, object> Capture(IReadOnlyDictionary<string, object> values)
+    {
+        ArgumentNullException.ThrowIfNull(values);
+        var copy = new Dictionary<string, object>(StringComparer.Ordinal);
+        foreach (var (name, value) in values)
+        {
+            if (!name.StartsWith("save.", StringComparison.Ordinal) || string.IsNullOrWhiteSpace(name[5..]))
+                throw new ArgumentException("New game variables require an explicit save. scope.", nameof(values));
+            if (value is not (bool or int or string)
+                && !(value is long integer && integer is >= int.MinValue and <= int.MaxValue)
+                && !(value is float number && float.IsFinite(number))
+                && !(value is double real && float.IsFinite((float)real)))
+                throw new ArgumentException($"Unsupported initial value for '{name}'.", nameof(values));
+            copy.Add(name, value);
+        }
+        return copy;
+    }
+}
diff --git a/src/Shared/GalNet.Core/Runtime/SnapshotCopy.cs b/src/Shared/GalNet.Core/Runtime/SnapshotCopy.cs
index f371fd5a..08cba266 100644
--- a/src/Shared/GalNet.Core/Runtime/SnapshotCopy.cs
+++ b/src/Shared/GalNet.Core/Runtime/SnapshotCopy.cs
@@ -5,14 +5,18 @@ namespace GalNet.Core.Runtime;
 /// <summary>External snapshots own their variables and immutable JSON payloads.</summary>
 public static class SnapshotCopy
 {
-    public static GameSnapshot Clone(GameSnapshot snapshot) => new()
+    public static GameSnapshot Clone(GameSnapshot snapshot) => Clone(snapshot, null, null);
+    public static GameSnapshot Clone(GameSnapshot snapshot, string? contentBuildId, IEnumerable<string>? storyPackages) => new()
     {
         Version = snapshot.Version,
         NodeId = snapshot.NodeId,
         EntryIndex = snapshot.EntryIndex,
+        ContentBuildId = contentBuildId ?? snapshot.ContentBuildId,
+        StoryPackages = (storyPackages ?? snapshot.StoryPackages).ToArray(),
         Variables = snapshot.Variables.ToDictionary(pair => pair.Key, pair => CloneVariable(pair.Value), StringComparer.Ordinal),
         States = snapshot.States.ToDictionary(pair => pair.Key,
-            pair => new StateSection(pair.Value.Version, pair.Value.Payload.Clone()), StringComparer.Ordinal)
+            pair => new StateSection(pair.Value.Version, pair.Value.Payload.Clone()), StringComparer.Ordinal),
+        Attachments = snapshot.Attachments.ToDictionary(pair => pair.Key, pair => pair.Value.Clone(), StringComparer.Ordinal)
     };
     public static GalVariable CloneVariable(GalVariable variable) => variable.Clone();
 }
diff --git a/src/Shared/GalNet.Core/Scene/EffectCatalog.cs b/src/Shared/GalNet.Core/Scene/EffectCatalog.cs
deleted file mode 100644
index 4c1a679a..00000000
--- a/src/Shared/GalNet.Core/Scene/EffectCatalog.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-using System.Text.Json;
-
-namespace GalNet.Core.Scene;
-
-/// <summary>Fixed slots in the game render pipeline. Every pixel effect consumes and produces the same image stream.</summary>
-public enum EffectStage { Layer, ScenePost }
-
-/// <summary>Editor-facing JSON value kinds for an effect's static start parameters.</summary>
-public enum EffectParameterKind { Text, Integer, Float, Boolean, ImageAsset, Select }
-
-/// <summary>Metadata for one JSON member accepted by an effect factory.</summary>
-public sealed record EffectParameterDefinition(
-    string Name,
-    EffectParameterKind Kind,
-    bool Required = false,
-    float? Minimum = null,
-    float? Maximum = null,
-    IReadOnlyList<string>? Options = null);
-
-/// <summary>Platform-neutral authoring metadata emitted by an effect factory.</summary>
-public sealed record EffectDefinition(
-    string Id,
-    EffectStage Stage,
-    IReadOnlyList<EffectParameterDefinition> Parameters,
-    IReadOnlyList<AnimatableProperty> AnimatableProperties);
-
-public interface IEffectCatalog
-{
-    IReadOnlyList<EffectDefinition> Definitions { get; }
-    bool TryGet(string id, out EffectDefinition definition);
-    IReadOnlyList<string> Validate(string id, string targetHandleId, string parameters);
-}
-
-/// <summary>
-/// Immutable effect metadata registry. Validation returns diagnostics instead of throwing so
-/// editor and runtime hosts can decide whether a malformed effect remains executable.
-/// </summary>
-public sealed class EffectCatalog : IEffectCatalog
-{
-    private readonly IReadOnlyDictionary<string, EffectDefinition> _byId;
-    private readonly Dictionary<string, IReadOnlyDictionary<string, EffectParameterDefinition>> _parametersByEffect;
-
-    public EffectCatalog(IEnumerable<EffectDefinition> definitions)
-    {
-        _byId = definitions.ToDictionary(definition => definition.Id, StringComparer.OrdinalIgnoreCase);
-        _parametersByEffect = _byId.Values.ToDictionary(
-            definition => definition.Id,
-            definition => (IReadOnlyDictionary<string, EffectParameterDefinition>)definition.Parameters.ToDictionary(parameter => parameter.Name, StringComparer.Ordinal),
-            StringComparer.OrdinalIgnoreCase);
-        Definitions = _byId.Values.OrderBy(definition => definition.Id, StringComparer.OrdinalIgnoreCase).ToArray();
-    }
-
-    public IReadOnlyList<EffectDefinition> Definitions { get; }
-    public bool TryGet(string id, out EffectDefinition definition) => _byId.TryGetValue(id, out definition!);
-
-    public IReadOnlyList<string> Validate(string id, string targetHandleId, string parameters)
-    {
-        if (!TryGet(id, out var definition)) return [$"Unknown effect '{id}'."];
-        var diagnostics = new List<string>();
-        if (definition.Stage == EffectStage.Layer && string.IsNullOrWhiteSpace(targetHandleId))
-            diagnostics.Add($"Layer effect '{id}' requires targetHandleId.");
-        if (definition.Stage != EffectStage.Layer && !string.IsNullOrWhiteSpace(targetHandleId))
-            diagnostics.Add($"{definition.Stage} effect '{id}' must not target a Layer.");
-
-        JsonDocument document;
-        try { document = JsonDocument.Parse(string.IsNullOrWhiteSpace(parameters) ? "{}" : parameters); }
-        catch (JsonException error) { diagnostics.Add($"Effect parameters are not valid JSON: {error.Message}"); return diagnostics; }
-        using (document)
-        {
-            if (document.RootElement.ValueKind != JsonValueKind.Object)
-            {
-                diagnostics.Add("Effect parameters must be a JSON object.");
-                return diagnostics;
-            }
-
-            var known = _parametersByEffect[definition.Id];
-            foreach (var value in document.RootElement.EnumerateObject())
-            {
-                if (!known.TryGetValue(value.Name, out var parameter))
-                {
-                    diagnostics.Add($"Effect '{id}' does not declare parameter '{value.Name}'.");
-                    continue;
-                }
-                ValidateValue(parameter, value.Value, diagnostics);
-            }
-            foreach (var parameter in definition.Parameters.Where(parameter => parameter.Required && !document.RootElement.TryGetProperty(parameter.Name, out _)))
-                diagnostics.Add($"Effect '{id}' requires parameter '{parameter.Name}'.");
-        }
-        return diagnostics;
-    }
-
-    private static void ValidateValue(EffectParameterDefinition parameter, JsonElement value, List<string> diagnostics)
-    {
-        var expected = parameter.Kind switch
-        {
-            EffectParameterKind.Text or EffectParameterKind.ImageAsset or EffectParameterKind.Select => JsonValueKind.String,
-            EffectParameterKind.Integer or EffectParameterKind.Float => JsonValueKind.Number,
-            EffectParameterKind.Boolean => JsonValueKind.True,
-            _ => JsonValueKind.Undefined
-        };
-        if (parameter.Kind == EffectParameterKind.Boolean)
-        {
-            if (value.ValueKind is JsonValueKind.True or JsonValueKind.False) return;
-            diagnostics.Add($"Effect parameter '{parameter.Name}' must be Boolean.");
-            return;
-        }
-        if (value.ValueKind != expected)
-        {
-            diagnostics.Add($"Effect parameter '{parameter.Name}' must be {parameter.Kind}.");
-            return;
-        }
-        if (parameter.Kind == EffectParameterKind.Integer && !value.TryGetInt32(out _))
-            diagnostics.Add($"Effect parameter '{parameter.Name}' must be an Integer.");
-        if ((parameter.Kind is EffectParameterKind.Integer or EffectParameterKind.Float) && value.TryGetDouble(out var number))
-        {
-            if (!double.IsFinite(number) || parameter.Minimum is { } minimum && number < minimum || parameter.Maximum is { } maximum && number > maximum)
-                diagnostics.Add($"Effect parameter '{parameter.Name}' is outside its supported range.");
-        }
-        if (parameter.Kind == EffectParameterKind.Select && parameter.Options is { Count: > 0 } options && !options.Contains(value.GetString() ?? "", StringComparer.Ordinal))
-            diagnostics.Add($"Effect parameter '{parameter.Name}' has an unsupported value.");
-    }
-}
diff --git a/src/Shared/GalNet.Core/Scene/ISceneInstanceManager.cs b/src/Shared/GalNet.Core/Scene/ISceneInstanceManager.cs
deleted file mode 100644
index 2cc8b1b9..00000000
--- a/src/Shared/GalNet.Core/Scene/ISceneInstanceManager.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-namespace GalNet.Core.Scene;
-
-/// <summary>
-/// Resolves opaque handles to currently active scene instances. A removed handle is immediately invalid.
-/// </summary>
-public interface ISceneInstanceManager
-{
-    IReadOnlyList<TInstance> GetAll<TInstance>() where TInstance : class, ISceneInstance;
-    bool TryGet<TInstance>(string handleId, out TInstance instance) where TInstance : class, ISceneInstance;
-    TInstance GetOrAdd<TInstance>(string handleId, Func<string, TInstance> factory) where TInstance : class, ISceneInstance;
-    /// <summary>Adds a runtime-only instance that must not enter persistent state or saves.</summary>
-    TInstance GetOrAddTransient<TInstance>(string handleId, Func<string, TInstance> factory) where TInstance : class, ISceneInstance;
-    bool Remove<TInstance>(string handleId, out TInstance? instance) where TInstance : class, ISceneInstance;
-}
diff --git a/src/Shared/GalNet.Core/Scene/LayerTransform.cs b/src/Shared/GalNet.Core/Scene/LayerTransform.cs
deleted file mode 100644
index b4abd424..00000000
--- a/src/Shared/GalNet.Core/Scene/LayerTransform.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-namespace GalNet.Core.Scene;
-
-/// <summary>Center-anchored transform in logical game-canvas pixels and degrees.</summary>
-public sealed class LayerTransform
-{
-    public float X { get; set; }
-    public float Y { get; set; }
-    public float RotationDegrees { get; set; }
-    public float ScaleX { get; set; } = 1f;
-    public float ScaleY { get; set; } = 1f;
-
-    public LayerTransform Clone() => new()
-    {
-        X = X,
-        Y = Y,
-        RotationDegrees = RotationDegrees,
-        ScaleX = ScaleX,
-        ScaleY = ScaleY
-    };
-}
diff --git a/src/Shared/GalNet.Core/Serialization/CoreJsonContext.cs b/src/Shared/GalNet.Core/Serialization/CoreJsonContext.cs
new file mode 100644
index 00000000..10d13eb4
--- /dev/null
+++ b/src/Shared/GalNet.Core/Serialization/CoreJsonContext.cs
@@ -0,0 +1,68 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+using GalNet.Core.Runtime;
+
+namespace GalNet.Core.Serialization;
+
+[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata)]
+[JsonSerializable(typeof(bool))]
+[JsonSerializable(typeof(byte))]
+[JsonSerializable(typeof(sbyte))]
+[JsonSerializable(typeof(short))]
+[JsonSerializable(typeof(ushort))]
+[JsonSerializable(typeof(int))]
+[JsonSerializable(typeof(uint))]
+[JsonSerializable(typeof(long))]
+[JsonSerializable(typeof(ulong))]
+[JsonSerializable(typeof(float))]
+[JsonSerializable(typeof(double))]
+[JsonSerializable(typeof(decimal))]
+[JsonSerializable(typeof(char))]
+[JsonSerializable(typeof(string))]
+[JsonSerializable(typeof(bool?))]
+[JsonSerializable(typeof(int?))]
+[JsonSerializable(typeof(float?))]
+[JsonSerializable(typeof(double?))]
+[JsonSerializable(typeof(decimal?))]
+[JsonSerializable(typeof(Guid))]
+[JsonSerializable(typeof(DateTime))]
+[JsonSerializable(typeof(DateTimeOffset))]
+[JsonSerializable(typeof(TimeSpan))]
+[JsonSerializable(typeof(DateOnly))]
+[JsonSerializable(typeof(TimeOnly))]
+[JsonSerializable(typeof(Uri))]
+[JsonSerializable(typeof(Version))]
+[JsonSerializable(typeof(byte[]))]
+[JsonSerializable(typeof(string[]))]
+[JsonSerializable(typeof(double[]))]
+[JsonSerializable(typeof(float[]))]
+[JsonSerializable(typeof(JsonElement))]
+[JsonSerializable(typeof(JsonElement[]))]
+[JsonSerializable(typeof(JsonNode))]
+[JsonSerializable(typeof(JsonObject))]
+[JsonSerializable(typeof(JsonArray))]
+[JsonSerializable(typeof(Dictionary<string, JsonElement>))]
+[JsonSerializable(typeof(Dictionary<string, object>))]
+[JsonSerializable(typeof(Dictionary<string, string>))]
+[JsonSerializable(typeof(Dictionary<string, float>))]
+[JsonSerializable(typeof(Dictionary<string, double>))]
+[JsonSerializable(typeof(Dictionary<string, int>))]
+[JsonSerializable(typeof(Dictionary<string, GalNet.Core.Variable.Variable>))]
+[JsonSerializable(typeof(GameSnapshot))]
+[JsonSerializable(typeof(CompiledGroupDocument))]
+[JsonSerializable(typeof(GroupDocument))]
+[JsonSerializable(typeof(ProjectConfiguration))]
+[JsonSerializable(typeof(ProjectConfigurationJsonConverter.Envelope))]
+[JsonSerializable(typeof(GalpakManifest))]
+[JsonSerializable(typeof(List<GalNet.Core.I18n.CharacterDefinition>))]
+[JsonSerializable(typeof(AssetMeta))]
+[JsonSerializable(typeof(DependentAssetMeta))]
+[JsonSerializable(typeof(PakDescriptor))]
+[JsonSerializable(typeof(GameContentManifest))]
+[JsonSerializable(typeof(ContentPackagingOptions))]
+[JsonSerializable(typeof(ResourceOverrideDefinition))]
+[JsonSerializable(typeof(ResourceOverrideOptions))]
+internal sealed partial class CoreJsonContext : JsonSerializerContext;
diff --git a/src/Shared/GalNet.Core/Serialization/GameContentManifest.cs b/src/Shared/GalNet.Core/Serialization/GameContentManifest.cs
new file mode 100644
index 00000000..ee8e11da
--- /dev/null
+++ b/src/Shared/GalNet.Core/Serialization/GameContentManifest.cs
@@ -0,0 +1,18 @@
+using GalNet.Core.Assets;
+
+namespace GalNet.Core.Serialization;
+
+/// <summary>Bootstrap descriptor for the project's one addressable graph.</summary>
+public sealed record GameContentManifest
+{
+    public const string FileName = "content.json";
+    public int Version { get; init; } = 2;
+    public string GraphId { get; init; } = StoryResourceIds.Graph;
+    public string ProjectId { get; init; } = "";
+    public string BuildId { get; init; } = "";
+    public List<GalpakFileEntry> BasePaks { get; init; } = [];
+    public List<StoryPackageManifest> Stories { get; init; } = [];
+    public GalpakFileEntry? LocalizationPak { get; init; }
+}
+
+public sealed record StoryPackageManifest(string PackageId, List<GalpakFileEntry> Parts);
diff --git a/src/Shared/GalNet.Core/Serialization/GroupDocument.cs b/src/Shared/GalNet.Core/Serialization/GroupDocument.cs
index 60a1e8d7..6db89fdf 100644
--- a/src/Shared/GalNet.Core/Serialization/GroupDocument.cs
+++ b/src/Shared/GalNet.Core/Serialization/GroupDocument.cs
@@ -81,5 +81,5 @@ public sealed class PrimitiveEntryDocument
     public string Condition { get; set; } = "";
 
     [JsonPropertyName("arguments")]
-    public JsonElement Arguments { get; set; } = JsonSerializer.SerializeToElement(new Dictionary<string, object?>());
+    public JsonElement Arguments { get; set; } = JsonCodec.SerializeToElement(new Dictionary<string, object?>());
 }
diff --git a/src/Shared/GalNet.Core/Serialization/JsonMetadata.cs b/src/Shared/GalNet.Core/Serialization/JsonMetadata.cs
new file mode 100644
index 00000000..bfb1ed7b
--- /dev/null
+++ b/src/Shared/GalNet.Core/Serialization/JsonMetadata.cs
@@ -0,0 +1,81 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+
+namespace GalNet.Core.Serialization;
+
+/// <summary>Composes generated metadata per options instance; reflection is only a desktop fallback.</summary>
+public static class JsonMetadata
+{
+    private static readonly ConditionalWeakTable<JsonSerializerOptions, JsonSerializerOptions> Prepared = new();
+    private static readonly JsonSerializerOptions DefaultOptions = CreateOptions();
+
+    public static JsonSerializerOptions Prepare(JsonSerializerOptions? options = null) =>
+        options is null ? DefaultOptions : Prepared.GetValue(options, value => CreateOptions(value));
+
+    public static JsonSerializerOptions CreateOptions(JsonSerializerOptions? template = null, IJsonTypeInfoResolver? resolver = null,
+        bool stringEnums = false)
+    {
+        var options = template is null ? new JsonSerializerOptions() : new(template);
+        var resolvers = new List<IJsonTypeInfoResolver>();
+        if (resolver is not null) resolvers.Add(resolver);
+        if (template?.TypeInfoResolver is { } existing) resolvers.Add(existing);
+        resolvers.Add(CoreJsonContext.Default);
+        if (JsonSerializer.IsReflectionEnabledByDefault) resolvers.Add(ReflectionResolver());
+        if (stringEnums && RuntimeFeature.IsDynamicCodeSupported) options.Converters.Add(ReflectionEnums());
+        options.TypeInfoResolver = JsonTypeInfoResolver.Combine(resolvers.ToArray());
+        options.MakeReadOnly();
+        Prepared.Add(options, options);
+        return options;
+    }
+
+    public static JsonTypeInfo GetTypeInfo(Type type, JsonSerializerOptions? options = null)
+    {
+        try { return Prepare(options).GetTypeInfo(type); }
+        catch (NotSupportedException error)
+        {
+            throw new NotSupportedException($"No JSON metadata is registered for '{type}'. Supply a generated JsonSerializerContext at the contract registration boundary.", error);
+        }
+    }
+
+    public static JsonTypeInfo<T> GetTypeInfo<T>(JsonSerializerOptions? options = null) => (JsonTypeInfo<T>)GetTypeInfo(typeof(T), options);
+
+    [RequiresUnreferencedCode("Reflection fallback is only enabled when JsonSerializer.IsReflectionEnabledByDefault is true.")]
+    private static IJsonTypeInfoResolver ReflectionResolver() => new DefaultJsonTypeInfoResolver();
+
+    [RequiresDynamicCode("Generated contexts provide enum metadata when dynamic code is unavailable.")]
+    private static JsonConverter ReflectionEnums() => new JsonStringEnumConverter();
+}
+
+/// <summary>JSON operations always select explicit metadata, including when reflection is disabled.</summary>
+public static class JsonCodec
+{
+    public static JsonElement SerializeToElement<T>(T value, JsonSerializerOptions? options = null) =>
+        JsonSerializer.SerializeToElement(value, JsonMetadata.GetTypeInfo<T>(options));
+    public static JsonElement SerializeToElement(object? value, Type type, JsonSerializerOptions? options = null) =>
+        JsonSerializer.SerializeToElement(value, JsonMetadata.GetTypeInfo(type, options));
+    public static string Serialize<T>(T value, JsonSerializerOptions? options = null) =>
+        JsonSerializer.Serialize(value, JsonMetadata.GetTypeInfo<T>(options));
+    public static string Serialize(object? value, Type type, JsonSerializerOptions? options = null) =>
+        JsonSerializer.Serialize(value, JsonMetadata.GetTypeInfo(type, options));
+    public static void Serialize<T>(Utf8JsonWriter writer, T value, JsonSerializerOptions? options = null) =>
+        JsonSerializer.Serialize(writer, value, JsonMetadata.GetTypeInfo<T>(options));
+    public static byte[] SerializeToUtf8Bytes<T>(T value, JsonSerializerOptions? options = null) =>
+        JsonSerializer.SerializeToUtf8Bytes(value, JsonMetadata.GetTypeInfo<T>(options));
+    public static T? Deserialize<T>(string json, JsonSerializerOptions? options = null) =>
+        JsonSerializer.Deserialize(json, JsonMetadata.GetTypeInfo<T>(options));
+    public static T? Deserialize<T>(ReadOnlySpan<byte> json, JsonSerializerOptions? options = null) =>
+        JsonSerializer.Deserialize(json, JsonMetadata.GetTypeInfo<T>(options));
+    public static T? Deserialize<T>(JsonElement json, JsonSerializerOptions? options = null) =>
+        JsonSerializer.Deserialize(json, JsonMetadata.GetTypeInfo<T>(options));
+    public static T? Deserialize<T>(ref Utf8JsonReader reader, JsonSerializerOptions? options = null) =>
+        JsonSerializer.Deserialize(ref reader, JsonMetadata.GetTypeInfo<T>(options));
+    public static object? Deserialize(JsonElement json, Type type, JsonSerializerOptions? options = null) =>
+        JsonSerializer.Deserialize(json, JsonMetadata.GetTypeInfo(type, options));
+    public static object? Deserialize(string json, Type type, JsonSerializerOptions? options = null) =>
+        JsonSerializer.Deserialize(json, JsonMetadata.GetTypeInfo(type, options));
+    public static ValueTask<T?> DeserializeAsync<T>(Stream stream, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) =>
+        JsonSerializer.DeserializeAsync(stream, JsonMetadata.GetTypeInfo<T>(options), cancellationToken);
+}
diff --git a/src/Shared/GalNet.Core/Settings/GameSettings.cs b/src/Shared/GalNet.Core/Settings/GameSettings.cs
deleted file mode 100644
index 370dd934..00000000
--- a/src/Shared/GalNet.Core/Settings/GameSettings.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-namespace GalNet.Core.Settings;
-
-/// <summary>
-/// 运行时游戏设置 —— 可被项目设置覆盖的玩家偏好。
-/// 持久化在用户目录下，按游戏隔离。
-/// </summary>
-public sealed class GameSettings : SettingsSection
-{
-    public override string SectionKey => "game";
-
-    /// <summary>文本显示速度（字符/秒，0 = 即时）</summary>
-    public float TextSpeed { get; set; } = 30f;
-
-    /// <summary>自动推进间隔（整数毫秒）</summary>
-    public int AutoAdvanceIntervalMilliseconds { get; set; } = 2000;
-
-    /// <summary>Delay used by quick mode between reading units, in integer milliseconds.</summary>
-    public int QuickAdvanceIntervalMilliseconds { get; set; } = 50;
-
-    /// <summary>Quick mode stops before text not read before this visit.</summary>
-    public bool QuickReadOnly { get; set; } = true;
-
-    /// <summary>BGM 默认音量（0~1）</summary>
-    public float BgmVolume { get; set; } = 1f;
-
-    /// <summary>音效默认音量（0~1）</summary>
-    public float SfxVolume { get; set; } = 1f;
-
-    /// <summary>语音默认音量（0~1）</summary>
-    public float VoiceVolume { get; set; } = 1f;
-
-    public float MasterVolume { get; set; } = 1f;
-    public bool MasterMuted { get; set; }
-    public bool BgmMuted { get; set; }
-    public bool SfxMuted { get; set; }
-    public bool VoiceMuted { get; set; }
-
-    /// <summary>全屏模式</summary>
-    public bool Fullscreen { get; set; } = true;
-}
diff --git a/src/Shared/GalNet.Core/Settings/LauncherSettings.cs b/src/Shared/GalNet.Core/Settings/LauncherSettings.cs
deleted file mode 100644
index 62974476..00000000
--- a/src/Shared/GalNet.Core/Settings/LauncherSettings.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using GalNet.Core.I18n;
-
-namespace GalNet.Core.Settings;
-
-/// <summary>
-/// 启动器全局设置 —— 持久化在启动器配置目录。
-/// </summary>
-public sealed class LauncherSettings : SettingsSection
-{
-    public override string SectionKey => "launcher";
-
-    /// <summary>启动器 UI 语言</summary>
-    public I18nLocale UiLocale { get; set; } = I18nLocale.ZhCn;
-
-    /// <summary>启动器窗口宽度</summary>
-    public int Width { get; set; } = 1280;
-
-    /// <summary>启动器窗口高度</summary>
-    public int Height { get; set; } = 720;
-
-    /// <summary>默认音频输出设备</summary>
-    public string? AudioDevice { get; set; }
-}
diff --git a/src/Shared/GalNet.Core/Settings/ProjectSettings.cs b/src/Shared/GalNet.Core/Settings/ProjectSettings.cs
deleted file mode 100644
index 93eb8e6c..00000000
--- a/src/Shared/GalNet.Core/Settings/ProjectSettings.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using GalNet.Core.I18n;
-using GalNet.Core.Variable;
-
-namespace GalNet.Core.Settings;
-
-public sealed class ProjectSettings : SettingsSection
-{
-    public override string SectionKey => "project";
-
-    public I18nLocale TargetLocale { get; set; } = I18nLocale.ZhCn;
-
-    public List<I18nLocale> AvailableLocales { get; set; } = [I18nLocale.ZhCn];
-
-    public int SaveSlotCount { get; set; } = 60;
-
-    public int SfxChannelCount { get; set; } = 4;
-
-    /// <summary>Author-controlled logical audio routes. Bus CRUD is intentionally not part of this version.</summary>
-    public List<GalNet.Core.Audio.AudioTrackDefinition> AudioTracks { get; set; } = GalNet.Core.Audio.AudioTrackDefinition.CreateDefaults();
-
-    public int DefaultWidth { get; set; } = 1920;
-
-    public int DefaultHeight { get; set; } = 1080;
-
-    public List<ProjectVariableDefinition> PlayerVariables { get; set; } = [];
-
-    public List<ProjectVariableDefinition> SaveVariables { get; set; } = [];
-}
diff --git a/src/Shared/GalNet.Core/Settings/SaveSettings.cs b/src/Shared/GalNet.Core/Settings/SaveSettings.cs
deleted file mode 100644
index 23bcb199..00000000
--- a/src/Shared/GalNet.Core/Settings/SaveSettings.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-namespace GalNet.Core.Settings;
-
-/// <summary>
-/// 存档相关设置 —— 继承项目设置中与存档相关的配置。
-/// </summary>
-public sealed class SaveSettings : SettingsSection
-{
-    public override string SectionKey => "save";
-
-    /// <summary>最大存档槽位数</summary>
-    public int MaxSlots { get; set; } = 60;
-
-    /// <summary>缩略图宽度</summary>
-    public int ThumbnailWidth { get; set; } = 320;
-
-    /// <summary>缩略图高度</summary>
-    public int ThumbnailHeight { get; set; } = 180;
-
-    public static SaveSettings FromProject(ProjectSettings project) => new()
-    {
-        MaxSlots = project.SaveSlotCount
-    };
-}
diff --git a/src/Shared/GalNet.Core/Settings/SettingsContainer.cs b/src/Shared/GalNet.Core/Settings/SettingsContainer.cs
deleted file mode 100644
index aac4a3a9..00000000
--- a/src/Shared/GalNet.Core/Settings/SettingsContainer.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-namespace GalNet.Core.Settings;
-
-/// <summary>
-/// 统一的设置容器 —— 按 SectionKey 存取，持久化到 JSON。
-/// </summary>
-public sealed class SettingsContainer
-{
-    private readonly Dictionary<string, SettingsSection> _sections = new();
-
-    /// <summary>获取指定类型的设置节（若不存在则创建默认实例）</summary>
-    public T Get<T>() where T : SettingsSection, new()
-    {
-        var key = new T().SectionKey;
-        if (_sections.TryGetValue(key, out var section) && section is T typed)
-            return typed;
-
-        var def = new T();
-        _sections[key] = def;
-        return def;
-    }
-
-    /// <summary>设置指定类型的设置节</summary>
-    public void Set<T>(T section) where T : SettingsSection
-    {
-        _sections[section.SectionKey] = section;
-    }
-
-    /// <summary>获取所有设置节</summary>
-    public IReadOnlyList<SettingsSection> GetAll() => _sections.Values.ToList().AsReadOnly();
-}
diff --git a/src/Shared/GalNet.Core/Settings/SettingsSection.cs b/src/Shared/GalNet.Core/Settings/SettingsSection.cs
deleted file mode 100644
index a9d66028..00000000
--- a/src/Shared/GalNet.Core/Settings/SettingsSection.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace GalNet.Core.Settings;
-
-/// <summary>
-/// 设置节抽象基类 —— JSON 可序列化/反序列化的一节设置。
-/// </summary>
-public abstract class SettingsSection
-{
-    /// <summary>节的唯一 Key</summary>
-    public abstract string SectionKey { get; }
-}
diff --git a/src/Shared/GalNet.Core/packages.lock.WindowsReadyToRun.json b/src/Shared/GalNet.Core/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..0f43b377
--- /dev/null
+++ b/src/Shared/GalNet.Core/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,7 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {},
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Shared/GalNet.Debugging/packages.lock.WindowsReadyToRun.json b/src/Shared/GalNet.Debugging/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..0331ad87
--- /dev/null
+++ b/src/Shared/GalNet.Debugging/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,39 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Serilog": {
+        "type": "CentralTransitive",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Shared/GalNet.Debugging/packages.lock.json b/src/Shared/GalNet.Debugging/packages.lock.json
index 3453cca0..3b3ddb6e 100644
--- a/src/Shared/GalNet.Debugging/packages.lock.json
+++ b/src/Shared/GalNet.Debugging/packages.lock.json
@@ -10,18 +10,11 @@
       "galnet.core": {
         "type": "Project"
       },
-      "galnet.presentation.abstractions": {
-        "type": "Project",
-        "dependencies": {
-          "GalNet.Core": "[1.0.0, )"
-        }
-      },
       "galnet.runtime": {
         "type": "Project",
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/src/Shared/GalNet.Diagnostics/CpuProfiler.cs b/src/Shared/GalNet.Diagnostics/CpuProfiler.cs
new file mode 100644
index 00000000..32bf153a
--- /dev/null
+++ b/src/Shared/GalNet.Diagnostics/CpuProfiler.cs
@@ -0,0 +1,119 @@
+#if BENCHMARK
+using System.Diagnostics;
+using System.Text.Json;
+
+namespace GalNet.Diagnostics;
+
+/// <summary>Opt-in, bounded CPU wall-clock events. Has no UI or logging dependency.</summary>
+public sealed class CpuProfiler
+{
+    public static CpuProfiler Shared { get; } = new(emitEventPipe:
+        Environment.GetEnvironmentVariable("GALNET_BENCHMARK_EVENTPIPE") == "1");
+    private readonly object _gate = new();
+    private readonly List<CpuEvent> _events = [];
+    private readonly long _origin = Stopwatch.GetTimestamp();
+    private readonly int _capacity;
+    private readonly bool _emitEventPipe;
+    private bool _recording = true;
+    private int _dropped;
+
+    public CpuProfiler(int capacity = 100_000, bool emitEventPipe = false)
+    {
+        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(capacity);
+        _capacity = capacity;
+        _emitEventPipe = emitEventPipe;
+    }
+
+    public IDisposable Measure(string name, string category = "CPU") =>
+        new Measurement(this, name, category);
+
+    public void Mark(string name, string category = "CPU") =>
+        Add(new(name, category, ElapsedMicroseconds(), null, Environment.CurrentManagedThreadId));
+
+    public void Stop()
+    {
+        lock (_gate) _recording = false;
+    }
+
+    public CpuEvent[] Snapshot()
+    {
+        lock (_gate) return _events.OrderBy(item => item.TimestampMicroseconds).ToArray();
+    }
+
+    public void WriteTrace(Stream destination)
+    {
+        CpuEvent[] snapshot;
+        int dropped;
+        lock (_gate)
+        {
+            snapshot = _events.OrderBy(item => item.TimestampMicroseconds).ToArray();
+            dropped = _dropped;
+        }
+        using var json = new Utf8JsonWriter(destination, new() { Indented = true });
+        json.WriteStartObject();
+        json.WriteString("displayTimeUnit", "ms");
+        json.WriteNumber("droppedEvents", dropped);
+        json.WriteStartArray("traceEvents");
+        foreach (var item in snapshot)
+        {
+            json.WriteStartObject();
+            json.WriteString("name", item.Name);
+            json.WriteString("cat", item.Category);
+            json.WriteString("ph", item.DurationMicroseconds.HasValue ? "X" : "i");
+            json.WriteNumber("ts", item.TimestampMicroseconds);
+            json.WriteNumber("pid", Environment.ProcessId);
+            json.WriteNumber("tid", item.ThreadId);
+            if (item.DurationMicroseconds is { } duration) json.WriteNumber("dur", duration);
+            else json.WriteString("s", "t");
+            json.WriteEndObject();
+        }
+        json.WriteEndArray();
+        json.WriteEndObject();
+    }
+
+    private double ElapsedMicroseconds() =>
+        Stopwatch.GetElapsedTime(_origin).TotalMicroseconds;
+
+    private void Add(CpuEvent item)
+    {
+        lock (_gate)
+        {
+            if (!_recording) return;
+            if (_events.Count < _capacity) _events.Add(item);
+            else
+            {
+                _dropped++;
+                return;
+            }
+        }
+        if (_emitEventPipe) CpuTraceEvents.Log.Emit(item);
+    }
+
+    private sealed class Measurement : IDisposable
+    {
+        private CpuProfiler? _owner;
+        private readonly string _name;
+        private readonly string _category;
+        private readonly double _start;
+        private readonly int _thread = Environment.CurrentManagedThreadId;
+
+        public Measurement(CpuProfiler owner, string name, string category)
+        {
+            _owner = owner;
+            _name = name;
+            _category = category;
+            _start = owner.ElapsedMicroseconds();
+        }
+
+        public void Dispose()
+        {
+            var owner = Interlocked.Exchange(ref _owner, null);
+            if (owner is null) return;
+            owner.Add(new(_name, _category, _start, owner.ElapsedMicroseconds() - _start, _thread));
+        }
+    }
+}
+
+public sealed record CpuEvent(string Name, string Category, double TimestampMicroseconds,
+    double? DurationMicroseconds, int ThreadId);
+#endif
diff --git a/src/Shared/GalNet.Diagnostics/CpuTraceEvents.cs b/src/Shared/GalNet.Diagnostics/CpuTraceEvents.cs
new file mode 100644
index 00000000..ab99ffff
--- /dev/null
+++ b/src/Shared/GalNet.Diagnostics/CpuTraceEvents.cs
@@ -0,0 +1,24 @@
+#if BENCHMARK
+using System.Diagnostics.Tracing;
+
+namespace GalNet.Diagnostics;
+
+/// <summary>Optional EventPipe mirror for correlating CPU phases with runtime stacks.</summary>
+[EventSource(Name = "GalNet-CPU")]
+internal sealed class CpuTraceEvents : EventSource
+{
+    public static CpuTraceEvents Log { get; } = new();
+
+    [NonEvent]
+    internal void Emit(CpuEvent item)
+    {
+        if (IsEnabled()) Record(item.Name, item.Category, item.TimestampMicroseconds,
+            item.DurationMicroseconds ?? -1, item.ThreadId);
+    }
+
+    [Event(1, Level = EventLevel.Informational)]
+    public void Record(string name, string category, double timestampMicroseconds,
+        double durationMicroseconds, int threadId) =>
+        WriteEvent(1, name, category, timestampMicroseconds, durationMicroseconds, threadId);
+}
+#endif
diff --git a/src/Shared/GalNet.Diagnostics/GalNet.Diagnostics.csproj b/src/Shared/GalNet.Diagnostics/GalNet.Diagnostics.csproj
new file mode 100644
index 00000000..555ae434
--- /dev/null
+++ b/src/Shared/GalNet.Diagnostics/GalNet.Diagnostics.csproj
@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+  </PropertyGroup>
+</Project>
diff --git a/src/Shared/GalNet.Diagnostics/StartupBenchmark.cs b/src/Shared/GalNet.Diagnostics/StartupBenchmark.cs
new file mode 100644
index 00000000..444daab2
--- /dev/null
+++ b/src/Shared/GalNet.Diagnostics/StartupBenchmark.cs
@@ -0,0 +1,46 @@
+#if BENCHMARK
+namespace GalNet.Diagnostics;
+
+/// <summary>Environment-driven startup capture shared by desktop hosts.</summary>
+public static class StartupBenchmark
+{
+    private static IDisposable? _startup;
+    private static string? _output;
+    private static int _completed;
+    public static bool Failed { get; private set; }
+
+    public static void Start()
+    {
+        _output = Environment.GetEnvironmentVariable("GALNET_BENCHMARK_OUTPUT");
+        if (string.IsNullOrWhiteSpace(_output)) return;
+        _startup = CpuProfiler.Shared.Measure("Startup.Total", "Startup");
+        CpuProfiler.Shared.Mark("Startup.Main", "Startup");
+    }
+
+    /// <returns>Whether this benchmark process should close its window.</returns>
+    public static bool Complete(bool success = true)
+    {
+        if (_startup is null || Interlocked.Exchange(ref _completed, 1) != 0) return false;
+        Failed = !success;
+        CpuProfiler.Shared.Mark(success ? "Startup.Ready" : "Startup.Failed", "Startup");
+        _startup.Dispose();
+        CpuProfiler.Shared.Stop();
+        try
+        {
+            var path = Path.GetFullPath(_output!);
+            Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+            var temporary = path + ".tmp";
+            using (var stream = File.Create(temporary)) CpuProfiler.Shared.WriteTrace(stream);
+            File.Move(temporary, path, overwrite: true);
+        }
+        catch (Exception failure)
+        {
+            Console.Error.WriteLine($"Startup benchmark export failed: {failure}");
+            Failed = true;
+            Environment.ExitCode = 1;
+        }
+        if (!success) Environment.ExitCode = 1;
+        return Environment.GetEnvironmentVariable("GALNET_BENCHMARK_EXIT") == "1";
+    }
+}
+#endif
diff --git a/src/Shared/GalNet.Diagnostics/packages.lock.json b/src/Shared/GalNet.Diagnostics/packages.lock.json
new file mode 100644
index 00000000..6afd6786
--- /dev/null
+++ b/src/Shared/GalNet.Diagnostics/packages.lock.json
@@ -0,0 +1,6 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Shared/GalNet.GameHost/Content/GameContentLoadOptions.cs b/src/Shared/GalNet.GameHost/Content/GameContentLoadOptions.cs
new file mode 100644
index 00000000..ed47d36c
--- /dev/null
+++ b/src/Shared/GalNet.GameHost/Content/GameContentLoadOptions.cs
@@ -0,0 +1,10 @@
+using GalNet.Core.Configuration;
+
+namespace GalNet.GameHost.Content;
+
+/// <summary>Composition-owned configuration declarations and localization projection.</summary>
+public sealed record GameContentLoadOptions
+{
+    public ProjectConfigurationSchema Configurations { get; init; } = ProjectConfigurationSchema.Empty;
+    public Func<ProjectConfiguration, string?>? SelectDefaultCulture { get; init; }
+}
diff --git a/src/Shared/GalNet.GameHost/Content/GameLocalizationContent.cs b/src/Shared/GalNet.GameHost/Content/GameLocalizationContent.cs
new file mode 100644
index 00000000..5836ac47
--- /dev/null
+++ b/src/Shared/GalNet.GameHost/Content/GameLocalizationContent.cs
@@ -0,0 +1,54 @@
+using System.Globalization;
+using System.Text.Json;
+using GalNet.Core.I18n;
+using GalNet.Runtime.I18n;
+
+namespace GalNet.GameHost.Content;
+
+/// <summary>Host-ready text sources and language-independent character metadata.</summary>
+public sealed class GameLocalizationContent
+{
+    public string DefaultCulture { get; init; } = "en-US";
+    public CharacterCatalog Characters { get; init; } = CharacterCatalog.Empty;
+    public IReadOnlyList<GameLocalizationSource> Sources { get; init; } = [];
+    public IReadOnlyList<GameLocalizationSource> ExternalSources { get; init; } = [];
+    public IReadOnlyList<GameLocalizationDiagnostic> Diagnostics { get; init; } = [];
+
+    public GameTextResolver CreateResolver(Func<CultureInfo> currentCulture,
+        IEnumerable<LocalizedTextSource>? bootstrap = null, IEnumerable<GameLocalizationSource>? additional = null) =>
+        new((bootstrap ?? []).Concat(Sources.Concat(ExternalSources).Concat(additional ?? [])
+            .Select(source => source.ToTextSource())), CultureInfo.GetCultureInfo(DefaultCulture), currentCulture);
+}
+
+/// <summary>One source document; hosts load each document into their localization provider in order.</summary>
+public sealed record GameLocalizationSource(string Culture, string RelativePath, string Json)
+{
+    public LocalizedTextSource ToTextSource()
+    {
+        var text = ReadText();
+        return new(CultureInfo.GetCultureInfo(Culture), key => text.GetValueOrDefault(key));
+    }
+
+    public IReadOnlyDictionary<string, string> ReadText()
+    {
+        using var document = JsonDocument.Parse(Json);
+        var text = new Dictionary<string, string>(StringComparer.Ordinal);
+        Read(document.RootElement, "");
+        return text;
+
+        void Read(JsonElement element, string prefix)
+        {
+            if (element.ValueKind != JsonValueKind.Object) throw new InvalidDataException("Text sources require objects with string leaves.");
+            foreach (var property in element.EnumerateObject())
+            {
+                if (string.IsNullOrWhiteSpace(property.Name)) throw new InvalidDataException("Localization keys cannot be empty.");
+                var key = prefix.Length == 0 ? property.Name : $"{prefix}.{property.Name}";
+                if (property.Value.ValueKind == JsonValueKind.Object) Read(property.Value, key);
+                else if (property.Value.ValueKind == JsonValueKind.String) text[key] = property.Value.GetString()!;
+                else throw new InvalidDataException($"Localization key '{key}' must have a string value.");
+            }
+        }
+    }
+}
+
+public sealed record GameLocalizationDiagnostic(string RelativePath, string Message);
diff --git a/src/Shared/GalNet.Runtime/Content/IGameContentProvider.cs b/src/Shared/GalNet.GameHost/Content/IGameContentProvider.cs
similarity index 71%
rename from src/Shared/GalNet.Runtime/Content/IGameContentProvider.cs
rename to src/Shared/GalNet.GameHost/Content/IGameContentProvider.cs
index 979085ee..baf70f1e 100644
--- a/src/Shared/GalNet.Runtime/Content/IGameContentProvider.cs
+++ b/src/Shared/GalNet.GameHost/Content/IGameContentProvider.cs
@@ -1,8 +1,8 @@
-using GalNet.Core.Gallery;
-using GalNet.Core.Settings;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Core.Configuration;
 using GameGraph = GalNet.Core.Graph.Graph;
 
-namespace GalNet.Runtime.Content;
+namespace GalNet.GameHost.Content;
 
 /// <summary>Host supplied game content, loaded from a package or built in memory.</summary>
 public interface IGameContentProvider
@@ -13,8 +13,7 @@ public interface IGameContentProvider
 public sealed class GameContent
 {
     public required GameGraph Graph { get; init; }
-    public string? AssetRoot { get; init; }
     public GalleryCatalog Gallery { get; init; } = GalleryCatalog.Empty;
-    public ProjectSettings Settings { get; init; } = new();
+    public ProjectConfiguration Configuration { get; init; } = new();
     public GameLocalizationContent Localization { get; init; } = new();
 }
diff --git a/src/Shared/GalNet.GameHost/DialogueHistoryJournal.cs b/src/Shared/GalNet.GameHost/DialogueHistoryJournal.cs
new file mode 100644
index 00000000..33dadafa
--- /dev/null
+++ b/src/Shared/GalNet.GameHost/DialogueHistoryJournal.cs
@@ -0,0 +1,108 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Core.Runtime;
+using GalNet.Presentation.Abstractions.Application;
+using GalNet.Presentation.Abstractions.Execution;
+
+namespace GalNet.GameHost;
+
+public sealed record DialogueHistoryCursor(int Count);
+
+/// <summary>Run-owned completed dialogue visits. Only a small cursor participates in live snapshots.</summary>
+public sealed class DialogueHistoryJournal
+{
+    public const string StateId = "host.dialogue.history";
+    private readonly object _gate = new();
+    private readonly List<DialogueHistoryLine> _lines = [];
+    public event Action? Changed;
+
+    public static IPrimitiveModule CreateModule() => new PrimitiveModule(registry =>
+        registry.State(HistoryJsonContext.Default.DialogueHistoryCursorArray, StateId, _ => "current",
+            validate: cursor => { if (cursor.Count < 0) throw new InvalidDataException("Invalid dialogue history cursor."); }));
+
+    public IReadOnlyList<DialogueHistoryLine> Lines { get { lock (_gate) return _lines.ToArray(); } }
+
+    public void Append(GameState state, DialogueHistoryLine line)
+    {
+        lock (_gate)
+        {
+            _lines.Add(line);
+            state.Table<DialogueHistoryCursor>().Set(new(_lines.Count));
+        }
+        Changed?.Invoke();
+    }
+
+    public GameSnapshot Attach(GameSnapshot snapshot)
+    {
+        var result = SnapshotCopy.Clone(snapshot);
+        lock (_gate)
+        {
+            var count = ReadCount(snapshot);
+            if (count > _lines.Count) throw new InvalidDataException("Dialogue history is behind the saved checkpoint.");
+            result.Attachments[StateId] = JsonSerializer.SerializeToElement(_lines.Take(count).ToArray(), HistoryJsonContext.Default.DialogueHistoryLineArray);
+        }
+        return result;
+    }
+
+    public void Restore(GameSnapshot? snapshot)
+    {
+        var lines = Decode(snapshot);
+        lock (_gate) { _lines.Clear(); _lines.AddRange(lines); }
+        Changed?.Invoke();
+    }
+
+    public static void Validate(GameSnapshot snapshot) => _ = Decode(snapshot);
+
+    /// <summary>Older host saves had no history module. They start an empty journal; other state contracts remain strict.</summary>
+    public static GameSnapshot PrepareSnapshot(GameSnapshot snapshot)
+    {
+        if (snapshot.States.ContainsKey(StateId)) return snapshot;
+        if (snapshot.Attachments.ContainsKey(StateId)) throw new InvalidDataException("Dialogue history has no checkpoint cursor.");
+        var result = SnapshotCopy.Clone(snapshot);
+        result.States.Add(StateId, new(1, JsonSerializer.SerializeToElement(Array.Empty<DialogueHistoryCursor>(), HistoryJsonContext.Default.DialogueHistoryCursorArray)));
+        return result;
+    }
+
+    public void Rewind(GameState state)
+    {
+        lock (_gate)
+        {
+            var cursors = state.Table<DialogueHistoryCursor>().Values;
+            var count = Math.Min(cursors.Count == 0 ? 0 : cursors[0].Count, _lines.Count);
+            if (count < _lines.Count) _lines.RemoveRange(count, _lines.Count - count);
+            state.Table<DialogueHistoryCursor>().Set(new(count));
+        }
+        Changed?.Invoke();
+    }
+
+    private static DialogueHistoryLine[] Decode(GameSnapshot? snapshot)
+    {
+        if (snapshot is null) return [];
+        var count = ReadCount(snapshot);
+        var lines = snapshot.Attachments.TryGetValue(StateId, out var value)
+            ? JsonSerializer.Deserialize(value, HistoryJsonContext.Default.DialogueHistoryLineArray)
+                ?? throw new InvalidDataException("Missing dialogue history data.")
+            : [];
+        if (lines.Length != count || lines.Any(line => line is null || string.IsNullOrWhiteSpace(line.GroupId) ||
+            string.IsNullOrWhiteSpace(line.EntryId) || line.Speaker is null || line.Text is null ||
+            line.Voice is { } voice && (string.IsNullOrWhiteSpace(voice.AssetId) || string.IsNullOrWhiteSpace(voice.TrackId) || !float.IsFinite(voice.Gain) || voice.Gain < 0)))
+            throw new InvalidDataException("Dialogue history does not match its saved checkpoint.");
+        return lines;
+    }
+
+    private static int ReadCount(GameSnapshot snapshot)
+    {
+        if (!snapshot.States.TryGetValue(StateId, out var section)) return 0;
+        if (section.Version != 1) throw new InvalidDataException("Unsupported dialogue history cursor.");
+        var cursors = JsonSerializer.Deserialize(section.Payload, HistoryJsonContext.Default.DialogueHistoryCursorArray)
+            ?? throw new InvalidDataException("Invalid dialogue history cursor.");
+        if (cursors.Length > 1 || cursors.Any(cursor => cursor is null || cursor.Count < 0))
+            throw new InvalidDataException("Invalid dialogue history cursor.");
+        return cursors.FirstOrDefault()?.Count ?? 0;
+    }
+}
+
+[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
+[JsonSerializable(typeof(DialogueHistoryCursor[]))]
+[JsonSerializable(typeof(DialogueHistoryLine[]))]
+internal sealed partial class HistoryJsonContext : JsonSerializerContext;
diff --git a/src/Shared/GalNet.GameHost/DialogueVoiceReplay.cs b/src/Shared/GalNet.GameHost/DialogueVoiceReplay.cs
new file mode 100644
index 00000000..739ab32e
--- /dev/null
+++ b/src/Shared/GalNet.GameHost/DialogueVoiceReplay.cs
@@ -0,0 +1,108 @@
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Presentation.Abstractions.Application;
+
+namespace GalNet.GameHost;
+
+/// <summary>A single transient backend voice, borrowing the running game's track mixer.</summary>
+public sealed class DialogueVoiceReplay : IAsyncDisposable
+{
+    private readonly IAudioPlaybackHost _host;
+    private readonly object _gate = new();
+    private AudioBackendRequest? _current;
+    private Task _operations = Task.CompletedTask;
+    private long _revision;
+    private bool _disposed;
+    private CancellationTokenSource? _starting;
+    public event Action? Changed;
+    public event Action<Exception>? Failed;
+    public bool IsPlaying { get { lock (_gate) return _current is not null; } }
+
+    public DialogueVoiceReplay(IAudioPlaybackHost host)
+    {
+        _host = host;
+        host.EventReceived += OnEvent;
+    }
+
+    public Task PlayAsync(DialogueVoice voice)
+    {
+        lock (_gate)
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+            StopCore();
+            var request = new AudioBackendRequest(AudioBackendAction.Start, voice.TrackId,
+                "dialogue-replay-" + Guid.NewGuid().ToString("N"), ++_revision, voice.AssetId, voice.Gain);
+            _current = request;
+            var cancellation = new CancellationTokenSource();
+            _starting = cancellation;
+            _operations = StartAfterAsync(_operations, request, cancellation);
+            Changed?.Invoke();
+            return _operations;
+        }
+    }
+
+    public void Stop()
+    {
+        lock (_gate) StopCore();
+    }
+
+    private void StopCore()
+    {
+        if (_current is not { } previous) return;
+        _current = null;
+        _revision++;
+        _starting?.Cancel();
+        _operations = StopAfterAsync(_operations, previous);
+        Changed?.Invoke();
+    }
+
+    private async Task StartAfterAsync(Task previous, AudioBackendRequest request, CancellationTokenSource cancellation)
+    {
+        try
+        {
+            await Task.Yield();
+            await previous.ConfigureAwait(false);
+            lock (_gate) { if (!ReferenceEquals(_current, request) || _disposed) return; }
+            await _host.ApplyAsync(request, cancellation.Token).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) when (cancellation.IsCancellationRequested) { }
+        catch (Exception error)
+        {
+            lock (_gate) { if (ReferenceEquals(_current, request)) _current = null; }
+            Changed?.Invoke();
+            Failed?.Invoke(error);
+        }
+        finally
+        {
+            lock (_gate) { if (ReferenceEquals(_starting, cancellation)) _starting = null; }
+            cancellation.Dispose();
+        }
+    }
+
+    private async Task StopAfterAsync(Task previous, AudioBackendRequest request)
+    {
+        await Task.Yield();
+        await previous.ConfigureAwait(false);
+        try { await _host.ApplyAsync(request with { Action = AudioBackendAction.Stop }).ConfigureAwait(false); }
+        catch (Exception error) { Failed?.Invoke(error); }
+    }
+
+    private void OnEvent(AudioBackendEvent value)
+    {
+        lock (_gate)
+        {
+            if (_current is not { } current || value.VoiceId != current.VoiceId || value.Generation != current.Generation ||
+                value.TrackId != current.TrackId || value.Kind is not (AudioBackendEventKind.Ended or AudioBackendEventKind.Failed)) return;
+            _current = null;
+        }
+        Changed?.Invoke();
+        if (value.Kind == AudioBackendEventKind.Failed) Failed?.Invoke(new InvalidOperationException(value.Message ?? "Voice replay failed."));
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        Task operations;
+        lock (_gate) { if (_disposed) return; _disposed = true; StopCore(); operations = _operations; }
+        _host.EventReceived -= OnEvent;
+        await operations.ConfigureAwait(false);
+    }
+}
diff --git a/src/Shared/GalNet.GameHost/GalNet.GameHost.csproj b/src/Shared/GalNet.GameHost/GalNet.GameHost.csproj
index e844acd8..7bef0f0b 100644
--- a/src/Shared/GalNet.GameHost/GalNet.GameHost.csproj
+++ b/src/Shared/GalNet.GameHost/GalNet.GameHost.csproj
@@ -5,4 +5,5 @@
     <ProjectReference Include="../GalNet.Runtime/GalNet.Runtime.csproj" />
     <ProjectReference Include="../GalNet.Presentation.Abstractions/GalNet.Presentation.Abstractions.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Shared/GalNet.Runtime/Gallery/GalleryDataSource.cs b/src/Shared/GalNet.GameHost/Gallery/GalleryDataSource.cs
similarity index 94%
rename from src/Shared/GalNet.Runtime/Gallery/GalleryDataSource.cs
rename to src/Shared/GalNet.GameHost/Gallery/GalleryDataSource.cs
index 5fa6b1b6..6fbfed35 100644
--- a/src/Shared/GalNet.Runtime/Gallery/GalleryDataSource.cs
+++ b/src/Shared/GalNet.GameHost/Gallery/GalleryDataSource.cs
@@ -1,10 +1,10 @@
 using System.Collections.ObjectModel;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Variable;
 using GalNet.Runtime.Variables;
 using GalVariable = GalNet.Core.Variable.Variable;
 
-namespace GalNet.Runtime.Gallery;
+namespace GalNet.GameHost.Gallery;
 
 /// <summary>Merges the immutable Gallery catalog with current Player variables.</summary>
 public sealed class GalleryDataSource(GalleryCatalog catalog, IVariableService variables) : IGalleryDataSource
diff --git a/src/Shared/GalNet.GameHost/GameRun.cs b/src/Shared/GalNet.GameHost/GameRun.cs
index 78c82600..637d65c2 100644
--- a/src/Shared/GalNet.GameHost/GameRun.cs
+++ b/src/Shared/GalNet.GameHost/GameRun.cs
@@ -1,43 +1,55 @@
+using GalNet.Core.Execution;
 using GalNet.Core.Graph;
 using GalNet.Core.Runtime;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Runtime.Engine;
 using GalNet.Runtime.Progress;
+using GalNet.Runtime.Runtime;
 
 namespace GalNet.GameHost;
 
 /// <summary>Default engine lifecycle. The caller owns the view and platform backends; a supplied restore session is borrowed.</summary>
-public sealed class GameRun : IGameRun
+public sealed class GameRun : IGameRun, IParameterizedGameRun
 {
     private readonly StateRestoreSession? _restoration;
     private bool _prepared;
+    private bool _newGame;
     private readonly bool _ownsRestoration;
     private readonly object _disposeGate = new();
     private Task? _disposeTask;
 
-    public GameRun(Graph graph, IGameRuntime runtime, IGameView view,
+    public GameRun(Graph graph, IGameRuntime runtime, IPrimitiveDispatcher view,
         IGameProgressService? progress = null, IChoicePresenter? choices = null,
-        ICatchUpPresentation? catchUp = null, StateRestoreSession? restoration = null)
+        ICatchUpPresentation? catchUp = null, StateRestoreSession? restoration = null, PlaybackOptions? playbackOptions = null)
     {
-        Engine = new GameEngine(graph, runtime, view, progress, choices, catchUp);
+        Engine = new GameEngine(graph, runtime, view, progress, choices, catchUp, playbackOptions);
         _ownsRestoration = restoration is null && view is CompositeGameView;
         _restoration = restoration ?? (view is CompositeGameView composite ? new StateRestoreSession(composite) : null);
     }
 
     public GameEngine Engine { get; }
+    public async Task InitializeSaveVariablesAsync(IReadOnlyDictionary<string, object> variables, CancellationToken cancellationToken)
+    {
+        if (!_prepared || !_newGame) throw new InvalidOperationException("Initial variables require a newly prepared game.");
+        await Engine.SetVariablesAsync(NewGameVariables.Capture(variables), cancellationToken);
+        _newGame = false;
+    }
     public GameSnapshot CreateSaveData() => Engine.CreateSaveData();
+    public Task ValidateSnapshotAsync(GameSnapshot snapshot, CancellationToken cancellationToken) =>
+        Engine.ValidateRestoreAsync(snapshot, cancellationToken);
 
     public async Task PrepareAsync(GameSnapshot? snapshot, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
         if (snapshot is not null)
         {
-            Engine.RestoreFrom(snapshot);
+            await Engine.RestoreFromAsync(snapshot, cancellationToken);
             if (_restoration is not null)
                 await Engine.SynchronizePresentationAsync(_restoration.RestoreAsync, cancellationToken);
         }
         _prepared = true;
+        _newGame = snapshot is null;
     }
 
     public async Task StartPreparedAsync(CancellationToken cancellationToken = default)
diff --git a/src/Shared/GalNet.GameHost/GameSession.cs b/src/Shared/GalNet.GameHost/GameSession.cs
index f748b076..25f4a1ca 100644
--- a/src/Shared/GalNet.GameHost/GameSession.cs
+++ b/src/Shared/GalNet.GameHost/GameSession.cs
@@ -14,16 +14,33 @@ public sealed class GameSession(Func<CancellationToken, Task<IGameRun>> createRu
     public Task PrepareAsync(GameSnapshot? snapshot, CancellationToken cancellationToken = default) =>
         ExecuteAsync(token => PrepareCoreAsync(snapshot, token), cancellationToken);
 
+    public Task PrepareNewAsync(IReadOnlyDictionary<string, object> initialSaveVariables, CancellationToken cancellationToken = default)
+    {
+        var copied = NewGameVariables.Capture(initialSaveVariables);
+        return ExecuteAsync(token => PrepareCoreAsync(null, token, copied), cancellationToken);
+    }
+
     public Task PrepareFromAsync(Func<CancellationToken, Task<GameSnapshot>> load,
         CancellationToken cancellationToken = default) =>
         ExecuteAsync(async token => await PrepareCoreAsync(await load(token), token), cancellationToken);
 
-    private async Task PrepareCoreAsync(GameSnapshot? snapshot, CancellationToken token)
+    private async Task PrepareCoreAsync(GameSnapshot? snapshot, CancellationToken token,
+        IReadOnlyDictionary<string, object>? initialSaveVariables = null)
     {
+        if (snapshot is not null && _run is not null) await _run.ValidateSnapshotAsync(snapshot, token);
         await ReleaseRunAsync();
         var run = await createRun(token);
         _run = run;
-        try { await run.PrepareAsync(snapshot, token); }
+        try
+        {
+            await run.PrepareAsync(snapshot, token);
+            if (initialSaveVariables is { Count: > 0 })
+            {
+                if (run is not IParameterizedGameRun configurable)
+                    throw new NotSupportedException("This game run does not accept initial save variables.");
+                await configurable.InitializeSaveVariablesAsync(initialSaveVariables, token);
+            }
+        }
         catch (Exception error)
         {
             _run = null;
diff --git a/src/Shared/GalNet.GameHost/IGameRun.cs b/src/Shared/GalNet.GameHost/IGameRun.cs
index 726bd99a..137d2fad 100644
--- a/src/Shared/GalNet.GameHost/IGameRun.cs
+++ b/src/Shared/GalNet.GameHost/IGameRun.cs
@@ -5,8 +5,15 @@ namespace GalNet.GameHost;
 /// <summary>One replaceable run. Implementations own the engine and their presentation bindings.</summary>
 public interface IGameRun : IAsyncDisposable
 {
+    Task ValidateSnapshotAsync(GameSnapshot snapshot, CancellationToken cancellationToken);
     Task PrepareAsync(GameSnapshot? snapshot, CancellationToken cancellationToken);
     Task StartPreparedAsync(CancellationToken cancellationToken);
     Task StopAsync();
     GameSnapshot CreateSaveData();
 }
+
+/// <summary>Optional startup initialization, executed after preparation and before the first entry.</summary>
+public interface IParameterizedGameRun
+{
+    Task InitializeSaveVariablesAsync(IReadOnlyDictionary<string, object> variables, CancellationToken cancellationToken);
+}
diff --git a/src/Shared/GalNet.GameHost/PlayerSession.cs b/src/Shared/GalNet.GameHost/PlayerSession.cs
index 2b4d8a4f..82adf33a 100644
--- a/src/Shared/GalNet.GameHost/PlayerSession.cs
+++ b/src/Shared/GalNet.GameHost/PlayerSession.cs
@@ -1,6 +1,5 @@
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Runtime;
-using GalNet.Core.Settings;
 using GalNet.Runtime.Persistence;
 using GalNet.Runtime.Progress;
 using GalNet.Runtime.Variables;
@@ -24,17 +23,20 @@ public PlayerSession(ISaveService saves, PlayerVariableService variables, IGameP
 
     public PlayerVariableService Variables { get; }
     public IGameProgressService Progress { get; }
-    public GameSettings Settings { get; private set; } = new();
     public IGalleryDataSource GalleryDataSource { get; }
 
-    public async Task SaveAsync(int slotIndex, GameSnapshot snapshot, CancellationToken cancellationToken)
+    public Task SaveAsync(int slotIndex, GameSnapshot snapshot, CancellationToken cancellationToken) => SaveAsync(slotIndex, snapshot, null, cancellationToken);
+
+    public async Task SaveAsync(int slotIndex, GameSnapshot snapshot, byte[]? preview, CancellationToken cancellationToken)
     {
         await _writeGate.WaitAsync(cancellationToken);
-        try { await SaveCoreAsync(slotIndex, snapshot, cancellationToken); }
+        try { await SaveCoreAsync(slotIndex, snapshot, preview, cancellationToken); }
         finally { _writeGate.Release(); }
     }
 
-    public async Task<int?> SaveFirstEmptyAsync(GameSnapshot snapshot, CancellationToken cancellationToken)
+    public Task<int?> SaveFirstEmptyAsync(GameSnapshot snapshot, CancellationToken cancellationToken) => SaveFirstEmptyAsync(snapshot, null, cancellationToken);
+
+    public async Task<int?> SaveFirstEmptyAsync(GameSnapshot snapshot, byte[]? preview, CancellationToken cancellationToken)
     {
         await _writeGate.WaitAsync(cancellationToken);
         try
@@ -42,16 +44,27 @@ public async Task SaveAsync(int slotIndex, GameSnapshot snapshot, CancellationTo
             var slots = await _saves.ListSlotsAsync(cancellationToken);
             var empty = slots.Where(slot => slot.Timestamp == default && !slot.IsCorrupt).OrderBy(slot => slot.SlotIndex).FirstOrDefault();
             if (empty is null) return null;
-            await SaveCoreAsync(empty.SlotIndex, snapshot, cancellationToken);
+            await SaveCoreAsync(empty.SlotIndex, snapshot, preview, cancellationToken);
             return empty.SlotIndex;
         }
         finally { _writeGate.Release(); }
     }
 
-    private async Task SaveCoreAsync(int slotIndex, GameSnapshot snapshot, CancellationToken cancellationToken)
+    private async Task SaveCoreAsync(int slotIndex, GameSnapshot snapshot, byte[]? preview, CancellationToken cancellationToken)
     {
         await Progress.FlushAsync(cancellationToken);
-        await _saves.SaveAsync(slotIndex, new SaveRequest { Snapshot = snapshot }, cancellationToken);
+        var previous = await GetSlotInfoAsync(slotIndex, cancellationToken);
+        await _saves.SaveAsync(slotIndex, new SaveRequest { Snapshot = snapshot, PreviewImage = preview, Description = previous?.Description }, cancellationToken);
+    }
+
+    public bool CanRenameSlots => _saves is ISaveSlotNamingService;
+
+    public async Task RenameSlotAsync(int slotIndex, string name, CancellationToken cancellationToken = default)
+    {
+        if (_saves is not ISaveSlotNamingService names) throw new NotSupportedException("This save store does not support slot names.");
+        await _writeGate.WaitAsync(cancellationToken);
+        try { await names.RenameAsync(slotIndex, name, cancellationToken); }
+        finally { _writeGate.Release(); }
     }
 
     public Task<GameSnapshot?> LoadAsync(int slotIndex, CancellationToken cancellationToken) =>
@@ -60,6 +73,10 @@ private async Task SaveCoreAsync(int slotIndex, GameSnapshot snapshot, Cancellat
     public Task<IReadOnlyList<SaveSlotInfo>> ListSlotsAsync(CancellationToken cancellationToken) =>
         _saves.ListSlotsAsync(cancellationToken);
 
+    public async Task<SaveSlotInfo?> GetSlotInfoAsync(int slotIndex, CancellationToken cancellationToken = default) =>
+        _saves is ISaveSlotInfoSource source ? await source.GetSlotInfoAsync(slotIndex, cancellationToken)
+            : (await _saves.ListSlotsAsync(cancellationToken)).FirstOrDefault(slot => slot.SlotIndex == slotIndex);
+
     public async Task<GameSnapshot> LoadLatestAsync(CancellationToken cancellationToken = default)
     {
         var slots = await ListSlotsAsync(cancellationToken);
@@ -75,9 +92,13 @@ await LoadAsync(slotIndex, cancellationToken)
 
     public async Task ClearAsync(CancellationToken cancellationToken)
     {
-        await _clearStorage(cancellationToken);
-        await Variables.ResetPlayerVariablesAsync(cancellationToken);
-        Settings = new GameSettings();
+        await _writeGate.WaitAsync(cancellationToken);
+        try
+        {
+            await _clearStorage(cancellationToken);
+            await Variables.ResetPlayerVariablesAsync(cancellationToken);
+        }
+        finally { _writeGate.Release(); }
     }
 
     public void Dispose()
diff --git a/src/Shared/GalNet.GameHost/ResourceCleanup.cs b/src/Shared/GalNet.GameHost/ResourceCleanup.cs
index 50fa029b..2fcca250 100644
--- a/src/Shared/GalNet.GameHost/ResourceCleanup.cs
+++ b/src/Shared/GalNet.GameHost/ResourceCleanup.cs
@@ -4,6 +4,13 @@ namespace GalNet.GameHost;
 public sealed class ResourceCleanup
 {
     private readonly List<Exception> _errors = [];
+    /// <summary>Prefer asynchronous draining when a borrowed binding supports both disposal contracts.</summary>
+    public static ValueTask DisposeAsync(IDisposable? resource)
+    {
+        if (resource is IAsyncDisposable asynchronous) return asynchronous.DisposeAsync();
+        resource?.Dispose();
+        return ValueTask.CompletedTask;
+    }
     public void Run(Action release)
     {
         try { release(); }
diff --git a/src/Shared/GalNet.GameHost/packages.lock.WindowsReadyToRun.json b/src/Shared/GalNet.GameHost/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..f66ae590
--- /dev/null
+++ b/src/Shared/GalNet.GameHost/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,52 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Serilog": {
+        "type": "CentralTransitive",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Shared/GalNet.GameHost/packages.lock.json b/src/Shared/GalNet.GameHost/packages.lock.json
index 3453cca0..7f4bf12f 100644
--- a/src/Shared/GalNet.GameHost/packages.lock.json
+++ b/src/Shared/GalNet.GameHost/packages.lock.json
@@ -7,12 +7,19 @@
         "resolved": "4.13.1",
         "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
       },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.core": {
         "type": "Project"
       },
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -21,7 +28,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/src/Shared/GalNet.Presentation.Abstractions/Application/DialogueHistoryLine.cs b/src/Shared/GalNet.Presentation.Abstractions/Application/DialogueHistoryLine.cs
new file mode 100644
index 00000000..764fabae
--- /dev/null
+++ b/src/Shared/GalNet.Presentation.Abstractions/Application/DialogueHistoryLine.cs
@@ -0,0 +1,12 @@
+namespace GalNet.Presentation.Abstractions.Application;
+
+/// <summary>Serializable replay intent, independent of an original backend voice.</summary>
+public sealed record DialogueVoice(string AssetId, string TrackId, float Gain = 1f);
+
+/// <summary>One completed visit to a dialogue or NVL entry, in the language the player saw.</summary>
+public sealed record DialogueHistoryLine(string GroupId, string EntryId, string Speaker, string Text,
+    bool WasRead, DialogueVoice? Voice = null)
+{
+    [System.Text.Json.Serialization.JsonIgnore]
+    public bool HasVoice => Voice is not null;
+}
diff --git a/src/Shared/GalNet.Presentation.Abstractions/Application/IGameGallerySession.cs b/src/Shared/GalNet.Presentation.Abstractions/Application/IGameGallerySession.cs
index e3b056d7..a50d7d72 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/Application/IGameGallerySession.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/Application/IGameGallerySession.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GalNet.Presentation.Abstractions.Application;
 
diff --git a/src/Shared/GalNet.Presentation.Abstractions/Application/IGameSessionService.cs b/src/Shared/GalNet.Presentation.Abstractions/Application/IGameSessionService.cs
index 186f801e..fff37ed5 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/Application/IGameSessionService.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/Application/IGameSessionService.cs
@@ -37,14 +37,29 @@ public interface IPreparedGameSessionService
     Task BeginPreparedGameAsync(CancellationToken cancellationToken = default);
 }
 
+/// <summary>Optional chapter/route startup parameters, applied only when creating a new game.</summary>
+public interface IParameterizedGameSessionService : IPreparedGameSessionService
+{
+    Task StartNewGameAsync(IReadOnlyDictionary<string, object> initialSaveVariables, CancellationToken cancellationToken = default);
+    Task PrepareNewGameAsync(IReadOnlyDictionary<string, object> initialSaveVariables, CancellationToken cancellationToken = default);
+}
+
 /// <summary>Optional safe save action; null means every normal slot is occupied.</summary>
 public interface IFirstEmptySlotSession
 {
     Task<int?> SaveFirstEmptyAsync(CancellationToken cancellationToken = default);
 }
 
+/// <summary>Optional save-name editing, available even when no story is running.</summary>
+public interface ISaveSlotNamingSession
+{
+    bool CanRenameSlots { get; }
+    Task<string> RenameSlotAsync(int slotIndex, string name, CancellationToken cancellationToken = default);
+}
+
 /// <summary>Presentation-safe save slot data. The host owns loading, writing and preview bytes.</summary>
 public sealed record GameSaveSlot(int SlotIndex, DateTime Timestamp, string Description, bool IsEmpty, bool IsCorrupt)
 {
+    public byte[]? PreviewImage { get; init; }
     public string DisplayTimestamp => Timestamp == default ? string.Empty : Timestamp.ToString("g", CultureInfo.CurrentCulture);
 }
diff --git a/src/Shared/GalNet.Presentation.Abstractions/Execution/PrimitiveRegistry.cs b/src/Shared/GalNet.Presentation.Abstractions/Execution/PrimitiveRegistry.cs
index 18eb7a69..35014d9b 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/Execution/PrimitiveRegistry.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/Execution/PrimitiveRegistry.cs
@@ -1,3 +1,5 @@
+using System.Text.Json;
+using System.Text.Json.Serialization.Metadata;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
 using GalNet.Core.Primitives;
@@ -14,8 +16,8 @@ public sealed class PrimitiveRegistry
     private Func<string, bool>? _selection;
     private readonly StateCatalogBuilder _states = new();
     private readonly List<StateRestorer> _restorers = [];
-    internal List<Action<IGameRuntime, GameState>> StateValidators { get; } = [];
-    public void ValidateState(Action<IGameRuntime, GameState> validate)
+    internal List<Action<IGameContext, GameState>> StateValidators { get; } = [];
+    public void ValidateState(Action<IGameContext, GameState> validate)
     {
         ObjectDisposedException.ThrowIf(_frozen, this);
         StateValidators.Add(validate);
@@ -39,10 +41,10 @@ internal IReadOnlyList<StateRestorer> BuildRestorers()
         return ordered;
     }
     public void State<T>(string id, Func<T, string> key, Func<StateRestoreContext, Task>? restore = null,
-        Action<T>? validate = null, int version = 1, params string[] after) where T : class
+        Action<T>? validate = null, int version = 1, string? keySpace = null, params string[] after) where T : class
     {
         ObjectDisposedException.ThrowIf(_frozen, this);
-        _states.Register(id, key, validate, version);
+        _states.Register(id, key, validate, version, keySpace);
         if (restore is not null) Restore(id, restore, after);
     }
     public void Restore(string id, Func<StateRestoreContext, Task> restore, params string[] after)
@@ -57,14 +59,44 @@ public void Restore(string id, Func<StateRestoreContext, Task> restore, params s
     internal PrimitiveRegistry(IEntryCatalog catalog) => _catalog = catalog;
     internal void Freeze() => _frozen = true;
 
-    public void Register(string type, Func<PrimitiveCreateContext, PrimitiveInstance> factory) => Add(type, factory, null);
+    public void Register(string type, Func<PrimitiveCreateContext, PrimitiveInstance> factory)
+    {
+        ArgumentNullException.ThrowIfNull(factory);
+        Add(type, context => factory(WithArguments(context,
+            PrimitiveArgumentHelper.Normalize(context.Parameters, context.Arguments))), null);
+    }
+    public void State<T>(JsonTypeInfo<T[]> jsonTypeInfo, string id, Func<T, string> key, Func<StateRestoreContext, Task>? restore = null,
+        Action<T>? validate = null, int version = 1, string? keySpace = null, params string[] after) where T : class
+    {
+        ObjectDisposedException.ThrowIf(_frozen, this);
+        ArgumentNullException.ThrowIfNull(jsonTypeInfo);
+        _states.Register(id, key, validate, version, keySpace, jsonTypeInfo);
+        if (restore is not null) Restore(id, restore, after);
+    }
 
     /// <summary>Checks the DTO contract now and decodes independent Options for each invocation.</summary>
     public void Register<T>(string type, Func<PrimitiveCreateContext, T, PrimitiveInstance> factory)
         where T : IFieldDto, IFieldSchema<T>, new()
     {
         ArgumentNullException.ThrowIfNull(factory);
-        Add(type, context => factory(context, ValueCodec.DeserializeFields<T>(context.Parameters.Fields, context.Arguments)), typeof(T));
+        Add(type, context =>
+        {
+            var (arguments, options) = PrimitiveArgumentHelper.NormalizeFields<T>(context.Parameters, context.Arguments);
+            return factory(WithArguments(context, arguments), options);
+        }, typeof(T));
+    }
+
+    private static PrimitiveCreateContext WithArguments(PrimitiveCreateContext context, JsonElement arguments)
+    {
+        var source = context.Entry;
+        var entry = new PrimitiveEntry(source.Type, arguments, source.BatchId)
+        {
+            Id = source.Id,
+            StableId = source.StableId,
+            ReadingBoundaryId = source.ReadingBoundaryId,
+            Condition = source.Condition
+        };
+        return new(context.Definition, entry, context.Runtime, context.ScopeCancellation);
     }
 
     private void Add(string type, Func<PrimitiveCreateContext, PrimitiveInstance> factory, Type? optionsType)
diff --git a/src/Shared/GalNet.Presentation.Abstractions/Execution/StateRestoreSession.cs b/src/Shared/GalNet.Presentation.Abstractions/Execution/StateRestoreSession.cs
index e762335e..7ddcc98f 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/Execution/StateRestoreSession.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/Execution/StateRestoreSession.cs
@@ -4,9 +4,9 @@
 
 namespace GalNet.Presentation.Abstractions.Execution;
 
-public sealed class StateRestoreContext(IGameRuntime runtime, Action<PrimitiveInstance> track, Action<Func<Task>> own, CancellationToken token)
+public sealed class StateRestoreContext(IGameContext runtime, Action<PrimitiveInstance> track, Action<Func<Task>> own, CancellationToken token)
 {
-    public IGameRuntime Runtime { get; } = runtime;
+    public IGameContext Runtime { get; } = runtime;
     public CancellationToken CancellationToken { get; } = token;
     public void Start(PrimitiveInstance instance) { track(instance); instance.Dispatch(); }
     public void Own(Func<Task> cleanup) => own(cleanup);
@@ -24,7 +24,7 @@ public sealed class StateRestoreSession(CompositeGameView view) : IAsyncDisposab
     private readonly object _disposeSync = new();
     private Task? _disposeTask;
     private volatile bool _disposed;
-    public async Task RestoreAsync(IGameRuntime runtime, CancellationToken cancellationToken = default)
+    public async Task RestoreAsync(IGameContext runtime, CancellationToken cancellationToken = default)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
         await _gate.WaitAsync(cancellationToken).ConfigureAwait(false);
diff --git a/src/Shared/GalNet.Presentation.Abstractions/GalNet.Presentation.Abstractions.csproj b/src/Shared/GalNet.Presentation.Abstractions/GalNet.Presentation.Abstractions.csproj
index b844b227..f7d8ed04 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/GalNet.Presentation.Abstractions.csproj
+++ b/src/Shared/GalNet.Presentation.Abstractions/GalNet.Presentation.Abstractions.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
@@ -9,4 +9,5 @@
   <ItemGroup>
     <ProjectReference Include="..\GalNet.Core\GalNet.Core.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/CompositeGameView.cs b/src/Shared/GalNet.Presentation.Abstractions/View/CompositeGameView.cs
index d7d31acb..3e523fa5 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/CompositeGameView.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/View/CompositeGameView.cs
@@ -1,4 +1,5 @@
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
 using GalNet.Presentation.Abstractions.Execution;
@@ -6,13 +7,13 @@
 namespace GalNet.Presentation.Abstractions.View;
 
 /// <summary>Dispatches validated instructions to independently registered execution modules.</summary>
-public sealed class CompositeGameView : IGameView
+public sealed class CompositeGameView : IPrimitiveDispatcher
 {
     private readonly IEntryCatalog _catalog;
     private readonly IReadOnlyList<IPrimitiveModule> _modules;
     private readonly Dictionary<string, Func<PrimitiveCreateContext, PrimitiveInstance>> _instructions;
     private bool _disposed;
-    private readonly IReadOnlyList<Action<IGameRuntime, GameState>> _stateValidators;
+    private readonly IReadOnlyList<Action<IGameContext, GameState>> _stateValidators;
 
     public CompositeGameView(IEntryCatalog catalog, IEnumerable<IPrimitiveModule> modules)
     {
@@ -34,7 +35,7 @@ public CompositeGameView(IEntryCatalog catalog, IEnumerable<IPrimitiveModule> mo
     public StateCatalog StateCatalog { get; }
     public bool RequiresStateRestore => StateRestorers.Count != 0;
     internal IReadOnlyList<StateRestorer> StateRestorers { get; }
-    public void ValidateState(IGameRuntime runtime, GameState state)
+    public void ValidateState(IGameContext runtime, GameState state)
     {
         foreach (var validate in _stateValidators) validate(runtime, state);
     }
@@ -54,29 +55,20 @@ public void RequireInstructions(IEnumerable<string> typeIds)
         if (missing.Length != 0) throw new InvalidOperationException($"Project contract declares primitives without registered execution implementations: {string.Join(", ", missing)}.");
     }
 
-    public PrimitiveInstance Dispatch(PrimitiveEntry entry, IGameRuntime runtime, CancellationToken cancellationToken,
+    public PrimitiveInstance Dispatch(PrimitiveEntry entry, IGameContext runtime, CancellationToken cancellationToken,
         PrimitiveInvocationMode mode = PrimitiveInvocationMode.Normal)
     {
         ArgumentNullException.ThrowIfNull(entry);
         ArgumentNullException.ThrowIfNull(runtime);
         ObjectDisposedException.ThrowIf(_disposed, this);
-        if (!entry.IsGeneric)
-            throw new InvalidOperationException($"Instruction '{entry.Type}' must be compiled before dispatch.");
         runtime.State.Configure(StateCatalog);
         if (!_instructions.TryGetValue(entry.Type, out var implementation))
             throw new InvalidOperationException($"Instruction '{entry.Type}' has no registered implementation.");
         var definition = _catalog.Get(entry.Type);
-        var normalized = new PrimitiveEntry(entry.Type,
-            PrimitiveArgumentHelper.Normalize(definition.DynamicParameters!, entry.Arguments), entry.BatchId)
-        {
-            Id = entry.Id,
-            StableId = entry.StableId,
-            ReadingBoundaryId = entry.ReadingBoundaryId,
-            Condition = entry.Condition
-        };
-        var instance = implementation(new PrimitiveCreateContext(definition, normalized, runtime, cancellationToken))
+        var instance = implementation(new PrimitiveCreateContext(definition, entry, runtime, cancellationToken))
             ?? throw new InvalidOperationException($"Instruction '{entry.Type}' returned no instance.");
-        if (!string.Equals(instance.BatchId, normalized.BatchId, StringComparison.Ordinal))
+        var expectedBatchId = string.IsNullOrWhiteSpace(entry.BatchId) ? null : entry.BatchId;
+        if (!string.Equals(instance.BatchId, expectedBatchId, StringComparison.Ordinal))
             throw new InvalidOperationException($"Instruction '{entry.Type}' created an instance with a different BatchId.");
         instance.Dispatch(mode);
         return instance;
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/IAnimationPresenter.cs b/src/Shared/GalNet.Presentation.Abstractions/View/IAnimationPresenter.cs
index 67baae0e..dca7a431 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/IAnimationPresenter.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/View/IAnimationPresenter.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Presentation.Abstractions.View;
 
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/ILayerPresenter.cs b/src/Shared/GalNet.Presentation.Abstractions/View/ILayerPresenter.cs
index 9fff8a91..266712ec 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/ILayerPresenter.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/View/ILayerPresenter.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Presentation.Abstractions.View;
 
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/LayerRenderRequest.cs b/src/Shared/GalNet.Presentation.Abstractions/View/LayerRenderRequest.cs
index 999d4fd7..a50115b3 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/LayerRenderRequest.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/View/LayerRenderRequest.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Presentation.Abstractions.View;
 
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/NullGameView.cs b/src/Shared/GalNet.Presentation.Abstractions/View/NullGameView.cs
index e76bc75c..3adc6cb3 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/NullGameView.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/View/NullGameView.cs
@@ -1,11 +1,12 @@
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
 
 namespace GalNet.Presentation.Abstractions.View;
 
 /// <summary>An empty view with no registered contracts or executable instructions.</summary>
-public sealed class NullGameView : IGameView
+public sealed class NullGameView : IPrimitiveDispatcher
 {
     public IReadOnlyCollection<EntryDefinition> Primitives => [];
     public bool CanExecute(string primitiveType) => false;
@@ -14,7 +15,7 @@ public bool TryGetEntry(string primitiveType, out EntryDefinition? entry)
         entry = null;
         return false;
     }
-    public PrimitiveInstance Dispatch(PrimitiveEntry entry, IGameRuntime runtime, CancellationToken cancellationToken,
+    public PrimitiveInstance Dispatch(PrimitiveEntry entry, IGameContext runtime, CancellationToken cancellationToken,
         PrimitiveInvocationMode mode = PrimitiveInvocationMode.Normal) =>
         throw new InvalidOperationException($"Instruction '{entry.Type}' has no registered implementation.");
     public void Dispose() => GC.SuppressFinalize(this);
diff --git a/src/Shared/GalNet.Presentation.Abstractions/View/ParticleEmitterRequest.cs b/src/Shared/GalNet.Presentation.Abstractions/View/ParticleEmitterRequest.cs
index c0335791..1f9a6de3 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/View/ParticleEmitterRequest.cs
+++ b/src/Shared/GalNet.Presentation.Abstractions/View/ParticleEmitterRequest.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GalNet.Presentation.Abstractions.View;
 
diff --git a/src/Shared/GalNet.Presentation.Abstractions/packages.lock.WindowsReadyToRun.json b/src/Shared/GalNet.Presentation.Abstractions/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..9fb490d8
--- /dev/null
+++ b/src/Shared/GalNet.Presentation.Abstractions/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,17 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Shared/GalNet.Presentation.Abstractions/packages.lock.json b/src/Shared/GalNet.Presentation.Abstractions/packages.lock.json
index e1926ffa..af322323 100644
--- a/src/Shared/GalNet.Presentation.Abstractions/packages.lock.json
+++ b/src/Shared/GalNet.Presentation.Abstractions/packages.lock.json
@@ -2,6 +2,12 @@
   "version": 2,
   "dependencies": {
     "net10.0": {
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.core": {
         "type": "Project"
       }
diff --git a/src/Shared/GalNet.Primitives.Builtins/AnimationPrimitiveInstance.cs b/src/Shared/GalNet.Primitives.Builtins/AnimationPrimitiveInstance.cs
index a7f2b466..9e59877c 100644
--- a/src/Shared/GalNet.Primitives.Builtins/AnimationPrimitiveInstance.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/AnimationPrimitiveInstance.cs
@@ -1,7 +1,7 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Runtime.Logging;
 
@@ -11,11 +11,12 @@ public sealed class AnimationPrimitiveInstance : PrimitiveInstance
 {
     private readonly object _gate = new();
     private readonly bool _restoring;
-    private readonly IGameRuntime _runtime;
+    private readonly IGameContext _runtime;
     private readonly IAnimationPresenter? _presenter;
     private readonly AnimationRequest _request;
     private readonly CancellationToken _scopeCancellation;
     private bool _skippable;
+    private bool _skipRequested;
     private AnimationPlaybackInstance? _playback;
     private bool _catchUpDetached;
     private Task _presentationTask = Task.CompletedTask;
@@ -28,7 +29,7 @@ public AnimationPrimitiveInstance(IAnimationPresenter? presenter, PrimitiveCreat
     { }
 
     public AnimationPrimitiveInstance(
-        IGameRuntime runtime,
+        IGameContext runtime,
         IAnimationPresenter? presenter,
         AnimationRequest request,
         string? batchId,
@@ -56,16 +57,20 @@ public override bool IsSkippable
     protected override void OnDispatch()
     {
         if (!_restoring) BuiltinRuntimeActions.ApplyAnimationStableState(_runtime, _request);
-        else _runtime.SceneInstances.GetOrAddTransient(_request.PlaybackHandleId,
+        else _runtime.Scene().GetOrAddTransient(_request.PlaybackHandleId,
+            id => new AnimationPlaybackInstance { Id = id, LoopMode = _request.LoopMode });
+        _playback = _runtime.Scene().GetOrAddTransient(_request.PlaybackHandleId,
             id => new AnimationPlaybackInstance { Id = id, LoopMode = _request.LoopMode });
-        _runtime.SceneInstances.TryGet<AnimationPlaybackInstance>(_request.PlaybackHandleId, out _playback!);
         if (_presenter is null)
         {
+            if (_request.LoopMode == AnimationLoopMode.Once)
+                BuiltinRuntimeActions.StopAnimationState(_runtime, _request.PlaybackHandleId);
             TryComplete();
             return;
         }
 
         _presentationTask = ObservePresentationAsync();
+        _playback.PresentationCompletion = _presentationTask;
     }
 
     protected override void OnSkip()
@@ -75,6 +80,7 @@ protected override void OnSkip()
             if (!_skippable || IsCompleted)
                 return;
             _skippable = false;
+            _skipRequested = true;
         }
 
         _presenter?.CompleteAnimationImmediately(_request.PlaybackHandleId);
@@ -107,7 +113,10 @@ private async Task ObservePresentationAsync()
     {
         try
         {
-            await _presenter!.AnimateAsync(_request, _scopeCancellation).ConfigureAwait(false);
+            var outcome = await _presenter!.AnimateAsync(_request, _scopeCancellation).ConfigureAwait(false);
+            if (outcome != AnimationOutcome.Replaced && !_skipRequested && !_catchUpDetached && !_scopeCancellation.IsCancellationRequested &&
+                _request.LoopMode != AnimationLoopMode.Once && (_playback?.RequestedStop is not null || outcome == AnimationOutcome.Skipped))
+                BuiltinRuntimeActions.ApplyAnimationTerminalValue(_runtime, _request);
         }
         catch (OperationCanceledException) when (_scopeCancellation.IsCancellationRequested)
         { }
@@ -116,7 +125,7 @@ private async Task ObservePresentationAsync()
         {
             _runtime.State.Update(() =>
             {
-                if (!_catchUpDetached && _playback is not null && _runtime.SceneInstances.TryGet<AnimationPlaybackInstance>(_request.PlaybackHandleId, out var current) && ReferenceEquals(current, _playback))
+                if (!_catchUpDetached && _playback is not null && _runtime.Scene().TryGet<AnimationPlaybackInstance>(_request.PlaybackHandleId, out var current) && ReferenceEquals(current, _playback))
                     BuiltinRuntimeActions.StopAnimationState(_runtime, _request.PlaybackHandleId);
             });
             lock (_gate)
diff --git a/src/Shared/GalNet.Primitives.Builtins/Arguments.cs b/src/Shared/GalNet.Primitives.Builtins/Arguments.cs
index 958535de..eca422fb 100644
--- a/src/Shared/GalNet.Primitives.Builtins/Arguments.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Arguments.cs
@@ -1,16 +1,17 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins;
 using GalNet.Core.Primitives;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Primitives.Builtins;
 
 internal static class Arguments
 {
-    internal static readonly JsonSerializerOptions JsonOptions = new()
+    internal static readonly JsonSerializerOptions JsonOptions = BuiltinJson.CreateOptions(new()
     {
         PropertyNameCaseInsensitive = true,
-        Converters = { new JsonStringEnumConverter() }
-    };
+    }, stringEnums: true);
 
     public static string RawJson(JsonElement value, string fallback = "{}") =>
         value.ValueKind is JsonValueKind.Null or JsonValueKind.Undefined ? fallback : value.GetRawText();
@@ -21,8 +22,8 @@ public static string RawJson(JsonElement value, string fallback = "{}") =>
         if (value.ValueKind == JsonValueKind.String)
         {
             var json = value.GetString();
-            return string.IsNullOrWhiteSpace(json) ? default : JsonSerializer.Deserialize<T>(json, JsonOptions);
+            return string.IsNullOrWhiteSpace(json) ? default : JsonCodec.Deserialize<T>(json, JsonOptions);
         }
-        return value.Deserialize<T>(JsonOptions);
+        return JsonCodec.Deserialize<T>(value, JsonOptions);
     }
 }
diff --git a/src/Shared/GalNet.Runtime/Audio/AudioBackendDispatcher.cs b/src/Shared/GalNet.Primitives.Builtins/Audio/AudioBackendDispatcher.cs
similarity index 80%
rename from src/Shared/GalNet.Runtime/Audio/AudioBackendDispatcher.cs
rename to src/Shared/GalNet.Primitives.Builtins/Audio/AudioBackendDispatcher.cs
index 076b27a9..b42c1836 100644
--- a/src/Shared/GalNet.Runtime/Audio/AudioBackendDispatcher.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Audio/AudioBackendDispatcher.cs
@@ -1,7 +1,6 @@
-using GalNet.Core.Audio;
-using GalNet.Presentation.Abstractions.Audio;
+using GalNet.Contracts.Builtins.Audio;
 
-namespace GalNet.Runtime.Audio;
+namespace GalNet.Primitives.Builtins.Audio;
 
 /// <summary>Orders commands per voice, cancels pending starts and drains backend work using the audio runtime's gate.</summary>
 internal sealed class AudioBackendDispatcher(IAudioPlaybackHost? host, object gate, Action<string> report, Action<AudioBackendEvent> terminal)
@@ -12,6 +11,7 @@ internal sealed class AudioBackendDispatcher(IAudioPlaybackHost? host, object ga
     private readonly Action<AudioBackendEvent> _terminal = terminal;
     private readonly Dictionary<string, BackendQueue> _backendQueues = new(StringComparer.Ordinal);
     private readonly List<Task> _pendingRequests = [];
+    private Task _mixerTail = Task.CompletedTask;
 
     public void CompleteVoice(string voiceId)
     {
@@ -51,6 +51,13 @@ public void Enqueue(AudioBackendRequest request)
                 _report($"Audio backend does not support SEffect on '{request.TrackId}'.");
                 return;
             }
+            if (_host.Capabilities.SupportsMixer && request.Action is AudioBackendAction.Configure or AudioBackendAction.SetMix or AudioBackendAction.ResetMixer or AudioBackendAction.SetLevel or AudioBackendAction.ApplySEffect or AudioBackendAction.StopSEffect)
+            {
+                _mixerTail = SendMixerAsync(_mixerTail, request);
+                _pendingRequests.RemoveAll(task => task.IsCompleted);
+                _pendingRequests.Add(_mixerTail);
+                return;
+            }
             if (request.FadeSeconds > 0 && !_host.Capabilities.SupportsFade)
             {
                 _report($"Audio backend does not support fades on '{request.TrackId}'; applying immediately.");
@@ -64,12 +71,18 @@ public void Enqueue(AudioBackendRequest request)
             // Stop invalidates an in-flight asset load immediately; subsequent commands
             // for this voice still run in order after the producer has observed cancellation.
             if (request.Action == AudioBackendAction.Stop) queue.StartCancellation.Cancel();
-            queue.Tail = SendAsync(queue.Tail, queue, request);
+            queue.Tail = SendAsync(Task.WhenAll(queue.Tail, _mixerTail), queue, request);
             _pendingRequests.RemoveAll(task => task.IsCompleted);
             _pendingRequests.Add(queue.Tail);
         }
     }
 
+    private async Task SendMixerAsync(Task previous, AudioBackendRequest request)
+    {
+        try { await previous.ConfigureAwait(false); await _host!.ApplyAsync(request).ConfigureAwait(false); }
+        catch (Exception error) { _report($"Audio mixer request failed: {error.Message}"); }
+    }
+
     private async Task SendAsync(Task previous, BackendQueue queue, AudioBackendRequest request)
     {
         try
diff --git a/src/Shared/GalNet.Runtime/Audio/AudioPlaybackTicket.cs b/src/Shared/GalNet.Primitives.Builtins/Audio/AudioPlaybackTicket.cs
similarity index 93%
rename from src/Shared/GalNet.Runtime/Audio/AudioPlaybackTicket.cs
rename to src/Shared/GalNet.Primitives.Builtins/Audio/AudioPlaybackTicket.cs
index 2f0b691e..7a2d3f2b 100644
--- a/src/Shared/GalNet.Runtime/Audio/AudioPlaybackTicket.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Audio/AudioPlaybackTicket.cs
@@ -1,4 +1,4 @@
-namespace GalNet.Runtime.Audio;
+namespace GalNet.Primitives.Builtins.Audio;
 
 /// <summary>One logical playback, including time spent queued. Continuations never run under the audio lock.</summary>
 public sealed class AudioPlaybackTicket
diff --git a/src/Shared/GalNet.Primitives.Builtins/Audio/AudioRuntime.cs b/src/Shared/GalNet.Primitives.Builtins/Audio/AudioRuntime.cs
new file mode 100644
index 00000000..bc96de55
--- /dev/null
+++ b/src/Shared/GalNet.Primitives.Builtins/Audio/AudioRuntime.cs
@@ -0,0 +1,541 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Runtime;
+
+namespace GalNet.Primitives.Builtins.Audio;
+
+/// <summary>Projects canonical audio state to backend voices. Only tickets and backend identities live here.</summary>
+public sealed class AudioRuntime : IDisposable, IAsyncDisposable
+{
+    private readonly object _gate = new();
+    private readonly IAudioPlaybackHost? _host;
+    private readonly ISEffectCatalog _effects;
+    private readonly AudioBackendDispatcher _dispatcher;
+    private readonly Dictionary<string, TrackBinding> _tracks = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, VoiceBinding> _voices = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, List<AudioPlaybackTicket>> _tickets = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, RetiringVoice> _retiring = new(StringComparer.Ordinal);
+    private GameState _state;
+    private long _nextGeneration;
+    private AudioMixOptions _mix = new();
+    private bool _disposed;
+    private bool _catchUp;
+    private AudioConfiguration? _configuration;
+    private AudioConfiguration? _declarations;
+    public event Action<string>? Diagnostic;
+
+    public AudioRuntime(IAudioPlaybackHost? host = null, ISEffectCatalog? effects = null)
+    {
+        _host = host;
+        _effects = effects ?? host?.SEffects ?? SEffectCatalog.Builtins;
+        var builder = new StateCatalogBuilder();
+        builder.Register<AudioTrackState>("builtin.audio.tracks", value => value.Id, ValidateTrack, jsonTypeInfo: BuiltinJson.StateTypeInfo<AudioTrackState>());
+        builder.Register<AudioSEffectState>("builtin.audio.seffects", value => value.Key(), ValidateEffect, jsonTypeInfo: BuiltinJson.StateTypeInfo<AudioSEffectState>());
+        builder.Register<AudioChannelState>("builtin.audio.channels", value => value.Key(), ValidateChannel, jsonTypeInfo: BuiltinJson.StateTypeInfo<AudioChannelState>());
+        _state = new GameState(builder.Build());
+        _dispatcher = new(host, _gate, Report, OnBackendEvent);
+        if (host is not null) host.EventReceived += OnBackendEvent;
+    }
+
+    public void Bind(GameState state)
+    {
+        lock (_gate)
+        {
+            if (ReferenceEquals(state, _state)) return;
+            StopBindings();
+            _state = state;
+            _tracks.Clear();
+            ResetMixer();
+        }
+    }
+    public async Task SuspendAsync(GameState expected)
+    {
+        lock (_gate)
+        {
+            if (!ReferenceEquals(_state, expected)) return;
+            StopBindings();
+            ResetMixer();
+        }
+        await _dispatcher.DrainAsync().ConfigureAwait(false);
+    }
+    public void Reset(GameState? expected = null)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            if (_disposed || expected is not null && !ReferenceEquals(expected, _state)) return;
+            StopBindings();
+            _state.Table<AudioTrackState>().Clear();
+            _state.Table<AudioSEffectState>().Clear();
+            _state.Table<AudioChannelState>().Clear();
+            ResetMixer();
+            _tracks.Clear();
+            _catchUp = false;
+        });
+    }
+    public void Validate(GameState state, AudioConfiguration configuration)
+    {
+        var identities = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var track in state.Table<AudioTrackState>().Values)
+        {
+            ValidateTrack(track);
+            if (track.Active.Concat(track.Pending).Any(item => !identities.Add(item.Id)))
+                throw new InvalidDataException("Saved audio item identities must be unique across tracks.");
+            if (!configuration.TryGetTrack(track.Id, out var definition))
+                throw new InvalidDataException($"Unknown saved audio track '{track.Id}'.");
+            if (track.Active.Count > definition.MaxVoices || track.Pending.Count > definition.MaxQueuedItems)
+                throw new InvalidDataException($"Saved audio track '{track.Id}' exceeds its configured limits.");
+        }
+        foreach (var effect in state.Table<AudioSEffectState>().Values)
+        {
+            ValidateEffect(effect);
+            if (!configuration.HasTarget(effect.Scope, effect.TargetId)) throw new InvalidDataException("An audio effect references a missing target.");
+        }
+        if (state.Table<AudioSEffectState>().Values.GroupBy(value => (value.Scope, value.TargetId)).Any(group => group.Count() > 64))
+            throw new InvalidDataException("An audio target supports at most 64 active effects.");
+        foreach (var channel in state.Table<AudioChannelState>().Values)
+        {
+            ValidateChannel(channel);
+            if (!configuration.HasTarget(channel.Scope, channel.TargetId)) throw new InvalidDataException("An audio level references a missing target.");
+        }
+    }
+    public static void ValidateChannel(AudioChannelState channel)
+    {
+        if (string.IsNullOrWhiteSpace(channel.TargetId) || channel.Scope is not (SEffectScope.Track or SEffectScope.Bus) || !float.IsFinite(channel.Gain) || channel.Gain < 0 || channel.Gain > 1)
+            throw new InvalidDataException("Invalid audio channel level.");
+    }
+    public static void ValidateTrack(AudioTrackState track)
+    {
+        if (string.IsNullOrWhiteSpace(track.Id) || track.Active is null || track.Pending is null)
+            throw new InvalidDataException("An audio track requires an ID and playback collections.");
+        var ids = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var item in track.Active.Concat(track.Pending))
+            if (item is null || item.Request is null || string.IsNullOrWhiteSpace(item.Id) || !ids.Add(item.Id) || item.Request.TrackId != track.Id ||
+                string.IsNullOrWhiteSpace(item.Request.AssetId) || !float.IsFinite(item.Request.Gain) || item.Request.Gain < 0 ||
+                !float.IsFinite(item.Request.FadeInSeconds) || item.Request.FadeInSeconds < 0 ||
+                !float.IsFinite(item.Request.FadeOutSeconds) || item.Request.FadeOutSeconds < 0 ||
+                !Enum.IsDefined(item.Request.Placement) || !Enum.IsDefined(item.Request.Completion) || item.Request.LoopCount < 0 ||
+                item.CompletedIterations < 0 || item.Request.LoopCount > 0 && item.CompletedIterations >= item.Request.LoopCount ||
+                item.Request.LoopCount == 0 && item.CompletedIterations != 0)
+                throw new InvalidDataException($"Invalid playback item in track '{track.Id}'.");
+    }
+    private void ValidateEffect(AudioSEffectState effect)
+    {
+        if (string.IsNullOrWhiteSpace(effect.TargetId) || string.IsNullOrWhiteSpace(effect.InstanceId)) throw new InvalidDataException("An audio effect requires track and instance IDs.");
+        var diagnostics = _effects.Validate(effect.SEffectId, effect.Scope, effect.Parameters);
+        if (diagnostics.Count > 0) throw new InvalidDataException(string.Join(" ", diagnostics));
+    }
+    public async Task RestoreAsync(GameState state, AudioConfiguration configuration, CancellationToken token)
+    {
+        Validate(state, configuration);
+        Bind(state);
+        lock (_gate) StopBindings();
+        await _dispatcher.DrainAsync().WaitAsync(token).ConfigureAwait(false);
+        lock (_gate) _state.Update(() =>
+        {
+            token.ThrowIfCancellationRequested();
+            if (!ReferenceEquals(_state, state)) throw new OperationCanceledException("The audio run was replaced.", token);
+            ResetMixer();
+            Configure(configuration);
+            foreach (var saved in _state.Table<AudioTrackState>().Values)
+            {
+                var track = GetTrack(configuration, saved.Id)!;
+                foreach (var item in saved.Active.ToArray()) Project(track, item, fade: 0);
+            }
+        });
+    }
+    public void BeginCatchUp()
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            if (_catchUp || _disposed) return;
+            StopBindings();
+            _catchUp = true;
+            ResetMixer();
+            // CatchUp projection is a declared track policy, independent of group names.
+            foreach (var track in _tracks.Values.Where(track => !track.Definition.PreserveDuringCatchUp))
+            { track.State.Active.Clear(); track.State.Pending.Clear(); }
+        });
+    }
+    public void EndCatchUp()
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            if (!_catchUp || _disposed) return;
+            _catchUp = false;
+            if (_declarations is { } configuration) { ResetMixer(); Configure(configuration); }
+            foreach (var track in _tracks.Values)
+                foreach (var item in track.State.Active.ToArray()) Project(track, item, 0);
+        });
+    }
+    public void ApplyMix(AudioMixOptions options)
+    {
+        ArgumentNullException.ThrowIfNull(options);
+        var snapshot = options.Snapshot();
+        lock (_gate) _state.Update(() =>
+        {
+            _mix = snapshot;
+            if (_host?.Capabilities.SupportsMixer == true)
+            {
+                _dispatcher.Enqueue(new(AudioBackendAction.SetMix, "", "", 0, Mix: snapshot));
+                return;
+            }
+            foreach (var track in _tracks.Values)
+                foreach (var item in track.State.Active.ToArray()) SendItem(track, item, AudioBackendAction.SetGain);
+            foreach (var retiring in _retiring.Values.ToArray())
+                _dispatcher.Enqueue(new(AudioBackendAction.SetGain, retiring.Binding.TrackId, retiring.Binding.Id,
+                    retiring.Binding.Generation, Gain: Gain(retiring.Track, retiring.Item)));
+        });
+    }
+    public AudioPlaybackTicket Play(AudioConfiguration configuration, AudioPlayRequest request)
+    {
+        lock (_gate) return _state.Update(() =>
+        {
+            var ticket = new AudioPlaybackTicket(StopTicket);
+            if (request.LoopCount < 0 || !Enum.IsDefined(request.Completion) || !Enum.IsDefined(request.Placement) ||
+                !float.IsFinite(request.Gain) || request.Gain < 0 || !float.IsFinite(request.FadeInSeconds) || request.FadeInSeconds < 0 ||
+                !float.IsFinite(request.FadeOutSeconds) || request.FadeOutSeconds < 0)
+            { Report("Invalid audio playback request."); ticket.Complete(); return ticket; }
+            var track = GetTrack(configuration, request.TrackId);
+            if (track is null || string.IsNullOrWhiteSpace(request.AssetId) || _catchUp && !track.Definition.PreserveDuringCatchUp)
+            { ticket.Complete(); return ticket; }
+            if (request.Placement == AudioPlacement.ReplaceIfDifferent)
+            {
+                var same = track.State.Active.Where(item => item.Request.AssetId == request.AssetId).ToArray();
+                if (same.Length > 0)
+                {
+                    foreach (var item in same)
+                    {
+                        if (item.Request.LoopCount != request.LoopCount) item.CompletedIterations = 0;
+                        item.Request = item.Request with { Gain = request.Gain, LoopCount = request.LoopCount, Completion = request.Completion };
+                        SendItem(track, item, AudioBackendAction.SetGain);
+                    }
+                    if (_host is not null) Tickets(same[0].Id).Add(ticket);
+                    if (_host is null) ticket.Complete();
+                    return ticket;
+                }
+            }
+            var value = new AudioItemState { Request = request };
+            if (_host is not null) Tickets(value.Id).Add(ticket);
+            switch (request.Placement)
+            {
+                case AudioPlacement.Replace:
+                case AudioPlacement.ReplaceAll:
+                case AudioPlacement.ReplaceIfDifferent:
+                    StopActive(track, null);
+                    if (request.Placement == AudioPlacement.ReplaceAll) ClearPending(track);
+                    Start(track, value); break;
+                case AudioPlacement.Next:
+                    if (track.Definition.MaxVoices != 1) { Report("audio.next requires a single-voice track."); Complete(value); break; }
+                    StopActive(track, null); QueueOrStart(track, value, true); Pump(track); break;
+                default: QueueOrStart(track, value, false); break;
+            }
+            if (_host is null) ticket.Complete();
+            return ticket;
+        });
+    }
+    public void Stop(AudioConfiguration configuration, AudioStopRequest request)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            if (request.FadeOutSeconds is { } fade && (!float.IsFinite(fade) || fade < 0)) { Report("Invalid audio fade-out duration."); return; }
+            var track = GetTrack(configuration, request.TrackId); if (track is null) return;
+            foreach (var retiring in _retiring.Values.Where(value => value.Binding.TrackId == request.TrackId).ToArray())
+                _dispatcher.Enqueue(new(AudioBackendAction.Stop, retiring.Binding.TrackId, retiring.Binding.Id,
+                    retiring.Binding.Generation, FadeSeconds: request.FadeOutSeconds ?? retiring.Item.Request.FadeOutSeconds));
+            StopActive(track, request.FadeOutSeconds); if (request.ClearQueue) ClearPending(track);
+        });
+    }
+    public void Pause(AudioConfiguration configuration, string trackId) => SetPaused(configuration, trackId, true);
+    public void Resume(AudioConfiguration configuration, string trackId) => SetPaused(configuration, trackId, false);
+    private void SetPaused(AudioConfiguration configuration, string trackId, bool paused)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            var track = GetTrack(configuration, trackId); if (track is null) return;
+            track.State.Paused = paused;
+            foreach (var item in track.State.Active.ToArray())
+                if (!paused && !_voices.ContainsKey(item.Id)) Project(track, item, 0);
+                else SendItem(track, item, paused ? AudioBackendAction.Pause : AudioBackendAction.Resume);
+            if (!paused) Pump(track);
+        });
+    }
+    public void Next(AudioConfiguration configuration, string trackId)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            var track = GetTrack(configuration, trackId); if (track is null) return;
+            if (track.Definition.MaxVoices != 1) { Report("audio.next requires a single-voice track."); return; }
+            StopActive(track, null); Pump(track);
+        });
+    }
+    public void Clear(AudioConfiguration configuration, string trackId)
+    { lock (_gate) _state.Update(() => { var track = GetTrack(configuration, trackId); if (track is not null) ClearPending(track); }); }
+    public void ApplySEffect(AudioConfiguration configuration, AudioSEffectRequest request)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            Configure(configuration);
+            if (!configuration.HasTarget(request.Scope, request.TargetId)) { Report("Unknown audio effect target."); return; }
+            if (request.Scope == SEffectScope.Bus && _host?.Capabilities.SupportsMixer == false) { Report("Audio backend does not support bus effects."); return; }
+            var track = request.Scope == SEffectScope.Track ? GetTrack(configuration, request.TargetId) : null;
+            var effect = new AudioSEffectState(request.TargetId, request.InstanceId, request.SEffectId, request.Parameters.Clone(), request.Scope);
+            try { ValidateEffect(effect); } catch (InvalidDataException error) { Report(error.Message); return; }
+            var effects = _state.Table<AudioSEffectState>();
+            if (!effects.TryGet(effect.Key(), out _) && effects.Values.Count(value => value.Scope == effect.Scope && value.TargetId == effect.TargetId) >= 64)
+            { Report("An audio target supports at most 64 active effects."); return; }
+            effects.Set(effect);
+            if (_host?.Capabilities.SupportsMixer == true) SendTargetEffect(effect, AudioBackendAction.ApplySEffect);
+            else if (track is not null) foreach (var item in track.State.Active.ToArray()) SendEffect(track, item, effect, AudioBackendAction.ApplySEffect);
+        });
+    }
+    public void UpdateSEffect(AudioConfiguration configuration, string targetId, string instanceId, JsonElement parameters, SEffectScope scope = SEffectScope.Track)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            Configure(configuration);
+            if (!_state.Table<AudioSEffectState>().TryGet(new AudioSEffectState(targetId, instanceId, "", default, scope).Key(), out var effect)) return;
+            try
+            {
+                var merged = SEffectParameters.Merge(effect.Parameters, parameters);
+                var diagnostics = _effects.Validate(effect.SEffectId, scope, merged);
+                if (diagnostics.Count != 0) { Report(string.Join(" ", diagnostics)); return; }
+                ApplySEffect(configuration, new(targetId, instanceId, effect.SEffectId, merged, scope));
+            }
+            catch (InvalidDataException error) { Report(error.Message); }
+        });
+    }
+    public void StopSEffect(AudioConfiguration configuration, string trackId, string instanceId, SEffectScope scope = SEffectScope.Track, bool all = false)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            Configure(configuration);
+            if (all && !string.IsNullOrEmpty(instanceId)) { Report("Stop all effects cannot specify an instance."); return; }
+            if (all)
+            {
+                foreach (var stoppedEffect in _state.Table<AudioSEffectState>().Values.Where(effect => effect.Scope == scope && effect.TargetId == trackId).ToArray())
+                    StopSEffect(configuration, trackId, stoppedEffect.InstanceId, scope);
+                return;
+            }
+            var track = scope == SEffectScope.Track ? GetTrack(configuration, trackId) : null;
+            var table = _state.Table<AudioSEffectState>();
+            var key = new AudioSEffectState(trackId, instanceId, "", default, scope).Key();
+            if (!table.TryGet(key, out var effect)) return;
+            table.Remove(key);
+            if (_host?.Capabilities.SupportsMixer == true) SendTargetEffect(effect, AudioBackendAction.StopSEffect);
+            else if (track is not null) foreach (var item in track.State.Active.ToArray()) SendEffect(track, item, effect, AudioBackendAction.StopSEffect);
+        });
+    }
+    private TrackBinding? GetTrack(AudioConfiguration configuration, string id)
+    {
+        if (_disposed) return null;
+        Configure(configuration);
+        if (_tracks.TryGetValue(id, out var cached)) return cached;
+        var definition = configuration.TryGetTrack(id, out var configured) ? configured : null;
+        if (definition is null)
+        { Report($"Unknown or invalid audio track '{id}'."); return null; }
+        var table = _state.Table<AudioTrackState>();
+        if (!table.TryGet(id, out var data)) { data = new AudioTrackState { Id = id }; table.Add(data); }
+        var track = new TrackBinding(definition, data); _tracks.Add(id, track); return track;
+    }
+    private void QueueOrStart(TrackBinding track, AudioItemState item, bool priority)
+    {
+        if (track.State.Active.Count < track.Definition.MaxVoices) { Start(track, item); return; }
+        if (track.Definition.MaxQueuedItems == 0)
+        {
+            if (track.Definition.OverflowPolicy == AudioOverflowPolicy.DropNewest) { Report("Audio voice limit reached."); Complete(item); return; }
+            StopVoice(track, track.State.Active[0], null); Start(track, item); return;
+        }
+        if (track.State.Pending.Count >= track.Definition.MaxQueuedItems)
+        {
+            if (track.Definition.QueueOverflowPolicy == AudioQueueOverflowPolicy.DropNewest) { Report("Audio queue limit reached."); Complete(item); return; }
+            Complete(track.State.Pending[0]); track.State.Pending.RemoveAt(0);
+        }
+        if (priority) track.State.Pending.Insert(0, item); else track.State.Pending.Add(item);
+    }
+    private void Start(TrackBinding track, AudioItemState item) { track.State.Active.Add(item); Project(track, item, item.Request.FadeInSeconds); }
+    private void Pump(TrackBinding track)
+    {
+        while (!track.State.Paused && track.State.Active.Count < track.Definition.MaxVoices && track.State.Pending.Count > 0)
+        {
+            var index = 0;
+            if (track.Definition.PlaybackOrder == AudioPlaybackOrder.Random)
+            {
+                var seed = track.State.RandomState;
+                seed ^= seed << 13; seed ^= seed >> 17; seed ^= seed << 5;
+                track.State.RandomState = seed == 0 ? 0x9e3779b9 : seed;
+                index = (int)(track.State.RandomState % (uint)track.State.Pending.Count);
+            }
+            var item = track.State.Pending[index]; track.State.Pending.RemoveAt(index); Start(track, item);
+        }
+    }
+    private void Project(TrackBinding track, AudioItemState item, float fade)
+    {
+        if (_catchUp || track.State.Paused || _host is null) return;
+        var generation = ++_nextGeneration;
+        var binding = new VoiceBinding(track.State.Id, $"{track.Definition.Id}:{generation}", generation);
+        _voices[item.Id] = binding;
+        _dispatcher.Enqueue(new(AudioBackendAction.Start, track.Definition.Id, binding.Id, generation, item.Request.AssetId, Gain(track, item), fade, FadeOutSeconds: item.Request.FadeOutSeconds));
+        if (_host.Capabilities.SupportsMixer) return;
+        foreach (var effect in _state.Table<AudioSEffectState>().Values.Where(value => value.Scope == SEffectScope.Track && value.TargetId == track.State.Id))
+            SendEffect(track, item, effect, AudioBackendAction.ApplySEffect);
+    }
+    private void SendItem(TrackBinding track, AudioItemState item, AudioBackendAction action, float fade = 0)
+    {
+        if (!_catchUp && _voices.TryGetValue(item.Id, out var binding))
+            _dispatcher.Enqueue(new(action, track.State.Id, binding.Id, binding.Generation, Gain: Gain(track, item), FadeSeconds: fade));
+    }
+    private void SendEffect(TrackBinding track, AudioItemState item, AudioSEffectState effect, AudioBackendAction action)
+    {
+        if (!_catchUp && _voices.TryGetValue(item.Id, out var binding))
+            _dispatcher.Enqueue(new(action, track.State.Id, binding.Id, binding.Generation, SEffectId: effect.SEffectId,
+                SEffectInstanceId: effect.InstanceId, SEffectParameters: effect.Parameters));
+    }
+    private float Gain(TrackBinding track, AudioItemState item)
+    {
+        if (_host?.Capabilities.SupportsMixer == true) return item.Request.Gain;
+        var group = track.Definition.BusId is { } busId ? _mix.Buses.GetValueOrDefault(busId) : null;
+        _mix.Tracks.TryGetValue(track.Definition.Id, out var trackMix);
+        if (_mix.MasterMuted || group?.Muted == true || trackMix?.Muted == true) return 0;
+        var gain = (double)track.Definition.DefaultGain * item.Request.Gain * (group?.Gain ?? 1f) * (trackMix?.Gain ?? 1f) * _mix.MasterGain;
+        return (float)Math.Clamp(gain, 0, 1);
+    }
+    private void ResetMixer()
+    {
+        _configuration = null;
+        if (_host?.Capabilities.SupportsMixer == true) _dispatcher.Enqueue(new(AudioBackendAction.ResetMixer, "", "", 0));
+    }
+    private void Configure(AudioConfiguration configuration)
+    {
+        _declarations = configuration;
+        if (ReferenceEquals(_configuration, configuration)) return;
+        _configuration = configuration;
+        if (_host?.Capabilities.SupportsMixer != true) return;
+        _dispatcher.Enqueue(new(AudioBackendAction.Configure, "", "", 0, Configuration: configuration));
+        _dispatcher.Enqueue(new(AudioBackendAction.SetMix, "", "", 0, Mix: _mix));
+        foreach (var channel in _state.Table<AudioChannelState>().Values) SendLevel(channel);
+        foreach (var effect in _state.Table<AudioSEffectState>().Values) SendTargetEffect(effect, AudioBackendAction.ApplySEffect);
+    }
+    private void SendTargetEffect(AudioSEffectState effect, AudioBackendAction action)
+    {
+        if (!_catchUp) _dispatcher.Enqueue(new(action, effect.TargetId, "", 0, SEffectId: effect.SEffectId,
+            SEffectInstanceId: effect.InstanceId, SEffectParameters: effect.Parameters, Scope: effect.Scope));
+    }
+    public void SetLevel(AudioConfiguration configuration, AudioChannelState channel)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            Configure(configuration);
+            ValidateChannel(channel);
+            if (!configuration.HasTarget(channel.Scope, channel.TargetId)) { Report("Unknown audio level target."); return; }
+            if (_host?.Capabilities.SupportsMixer == false) { Report("Audio backend does not support target mixer levels."); return; }
+            _state.Table<AudioChannelState>().Set(channel);
+            if (!_catchUp) SendLevel(channel);
+        });
+    }
+    private void SendLevel(AudioChannelState channel) => _dispatcher.Enqueue(new(AudioBackendAction.SetLevel,
+        channel.TargetId, "", 0, Gain: channel.Gain, Muted: channel.Muted, Scope: channel.Scope));
+    private List<AudioPlaybackTicket> Tickets(string id)
+    { if (!_tickets.TryGetValue(id, out var tickets)) _tickets[id] = tickets = []; return tickets; }
+    private void Complete(AudioItemState item)
+    { if (_tickets.Remove(item.Id, out var tickets)) foreach (var ticket in tickets) ticket.Complete(); }
+    private void StopVoice(TrackBinding track, AudioItemState item, float? requestedFade)
+    {
+        var fade = requestedFade ?? item.Request.FadeOutSeconds;
+        track.State.Active.Remove(item);
+        if (_voices.Remove(item.Id, out var binding))
+        {
+            if (fade > 0 && _host?.Capabilities.SupportsFade == true)
+                _retiring[binding.Id] = new(track, item, binding);
+            _dispatcher.Enqueue(new(AudioBackendAction.Stop, binding.TrackId, binding.Id, binding.Generation, FadeSeconds: Math.Max(0, fade)));
+        }
+        Complete(item);
+    }
+    private void StopActive(TrackBinding track, float? fade) { foreach (var item in track.State.Active.ToArray()) StopVoice(track, item, fade); }
+    private void ClearPending(TrackBinding track) { foreach (var item in track.State.Pending) Complete(item); track.State.Pending.Clear(); }
+    private void StopBindings()
+    {
+        var bindings = _voices.Values.Concat(_retiring.Values.Select(value => value.Binding)).ToArray();
+        _voices.Clear();
+        _retiring.Clear();
+        var pendingTickets = _tickets.Values.SelectMany(tickets => tickets).ToArray();
+        _tickets.Clear();
+        // Some hosts report an end synchronously from Stop. Invalidate identities before calling them.
+        foreach (var binding in bindings)
+            _dispatcher.Enqueue(new(AudioBackendAction.Stop, binding.TrackId, binding.Id, binding.Generation));
+        foreach (var ticket in pendingTickets) ticket.Complete();
+    }
+    private void OnBackendEvent(AudioBackendEvent value)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            if (_disposed || value.Kind is not (AudioBackendEventKind.Ended or AudioBackendEventKind.Failed)) return;
+            if (_retiring.TryGetValue(value.VoiceId, out var retiring) && retiring.Binding.TrackId == value.TrackId && retiring.Binding.Generation == value.Generation)
+            { _retiring.Remove(value.VoiceId); _dispatcher.CompleteVoice(value.VoiceId); return; }
+            if (!_tracks.TryGetValue(value.TrackId, out var track)) return;
+            var item = track.State.Active.FirstOrDefault(item => _voices.TryGetValue(item.Id, out var voice) && voice.Id == value.VoiceId && voice.Generation == value.Generation);
+            if (item is null) return;
+            _voices.Remove(item.Id); _dispatcher.CompleteVoice(value.VoiceId);
+            if (value.Kind == AudioBackendEventKind.Ended &&
+                (track.Definition.Repeat == AudioTrackRepeat.One || item.Request.LoopCount == 0 || item.CompletedIterations < item.Request.LoopCount - 1))
+            {
+                if (track.Definition.Repeat != AudioTrackRepeat.One && item.Request.LoopCount > 0) item.CompletedIterations++;
+                Project(track, item, 0);
+                return;
+            }
+            track.State.Active.Remove(item);
+            if (value.Kind == AudioBackendEventKind.Failed) Report(value.Message ?? $"Audio backend failed for '{item.Request.AssetId}'.");
+            if (value.Kind == AudioBackendEventKind.Ended && (item.Request.Completion == AudioCompletion.RequeueTail || track.Definition.Repeat == AudioTrackRepeat.All))
+            {
+                item.CompletedIterations = 0;
+                if (track.State.Pending.Count == 0) Start(track, item);
+                else
+                {
+                    // Free a voice for the existing queue before applying the idle queue budget.
+                    track.State.Pending.Add(item); Pump(track);
+                    if (track.State.Pending.Count > track.Definition.MaxQueuedItems)
+                    {
+                        var index = track.Definition.QueueOverflowPolicy == AudioQueueOverflowPolicy.DropNewest ? track.State.Pending.Count - 1 : 0;
+                        var dropped = track.State.Pending[index]; track.State.Pending.RemoveAt(index); Complete(dropped);
+                        Report("Audio queue limit reached while requeuing completed playback.");
+                    }
+                }
+                return;
+            }
+            Pump(track);
+            Complete(item);
+        });
+    }
+    private void StopTicket(AudioPlaybackTicket ticket)
+    {
+        lock (_gate) _state.Update(() =>
+        {
+            foreach (var track in _tracks.Values)
+            {
+                foreach (var item in track.State.Pending.Where(item => Tickets(item.Id).Contains(ticket)).ToArray())
+                { track.State.Pending.Remove(item); Complete(item); }
+                foreach (var item in track.State.Active.Where(item => Tickets(item.Id).Contains(ticket)).ToArray()) StopVoice(track, item, null);
+                Pump(track);
+            }
+            ticket.Complete();
+        });
+    }
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            if (_disposed) return; _disposed = true;
+            StopBindings(); ResetMixer(); if (_host is not null) _host.EventReceived -= OnBackendEvent;
+        }
+    }
+    public async ValueTask DisposeAsync() { Dispose(); await _dispatcher.DrainAsync().ConfigureAwait(false); }
+    private void Report(string message)
+    {
+        foreach (var handler in Diagnostic?.GetInvocationList() ?? [])
+            try { ((Action<string>)handler)(message); }
+            catch (Exception) { /* Diagnostic observers cannot interrupt backend cleanup. */ }
+    }
+    private sealed record TrackBinding(AudioTrackDefinition Definition, AudioTrackState State);
+    private sealed record RetiringVoice(TrackBinding Track, AudioItemState Item, VoiceBinding Binding);
+    private sealed record VoiceBinding(string TrackId, string Id, long Generation);
+}
diff --git a/src/Shared/GalNet.Primitives.Builtins/AudioPlaybackPrimitiveInstance.cs b/src/Shared/GalNet.Primitives.Builtins/AudioPlaybackPrimitiveInstance.cs
index 4f1c044d..9217f066 100644
--- a/src/Shared/GalNet.Primitives.Builtins/AudioPlaybackPrimitiveInstance.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/AudioPlaybackPrimitiveInstance.cs
@@ -1,5 +1,5 @@
 using GalNet.Core.Primitives;
-using GalNet.Runtime.Audio;
+using GalNet.Primitives.Builtins.Audio;
 
 namespace GalNet.Primitives.Builtins;
 
@@ -11,6 +11,8 @@ public sealed class AudioPlaybackPrimitiveInstance(
     CancellationToken cancellationToken) : PrimitiveInstance(batchId)
 {
     private AudioPlaybackTicket? _ticket;
+    /// <summary>The original logical playback, when this invocation actually started audio.</summary>
+    public AudioPlaybackTicket? Ticket => _ticket;
     public override bool IsBlocking => false;
     public override bool IsSkippable => autoBlocking;
 
diff --git a/src/Shared/GalNet.Primitives.Builtins/BuiltinRegistration.cs b/src/Shared/GalNet.Primitives.Builtins/BuiltinRegistration.cs
index c7ac2bd8..187feef6 100644
--- a/src/Shared/GalNet.Primitives.Builtins/BuiltinRegistration.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/BuiltinRegistration.cs
@@ -1,9 +1,9 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Core.I18n;
-using GalNet.Core.Variants;
-using GalNet.Presentation.Abstractions.Audio;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 
@@ -33,12 +33,13 @@ public static GameRegistration AddBuiltins(
         CharacterCatalog? characters = null,
         BuiltinAudioModule? audioModule = null,
         ImageVariantsCatalog? imageVariants = null,
-        BuiltinCustomActionModule? customActions = null)
+        BuiltinCustomActionModule? customActions = null,
+        AudioConfiguration? audioConfiguration = null)
     {
         registration.AddBuiltinSchemas();
         return registration.AddBuiltinImplementations(registration.BuildCatalog(),
             dialoguePresenter, layerPresenter, animationPresenter, effectPresenter, gallery,
-            particlePresenter, nvlPresenter, audioHost, videoPresenter, characters, audioModule, imageVariants, customActions);
+            particlePresenter, nvlPresenter, audioHost, videoPresenter, characters, audioModule, imageVariants, customActions, audioConfiguration);
     }
 
     /// <summary>Registers logical implementations. Optional presenters select state-only/headless operation.</summary>
@@ -57,14 +58,15 @@ public static GameRegistration AddBuiltinImplementations(
         CharacterCatalog? characters = null,
         BuiltinAudioModule? audioModule = null,
         ImageVariantsCatalog? imageVariants = null,
-        BuiltinCustomActionModule? customActions = null)
+        BuiltinCustomActionModule? customActions = null,
+        AudioConfiguration? audioConfiguration = null)
     {
         ArgumentNullException.ThrowIfNull(catalog);
         IPrimitiveModule[] modules =
         [
             new BuiltinDialogueModule(dialoguePresenter, characters), new BuiltinNvlModule(nvlPresenter),
             new BuiltinLayerModule(layerPresenter, imageVariants), new BuiltinAnimationModule(animationPresenter, layerPresenter, effectPresenter, particlePresenter),
-            audioModule ?? new BuiltinAudioModule(audioHost), new BuiltinVideoModule(videoPresenter),
+            audioModule ?? new BuiltinAudioModule(audioHost, configuration: audioConfiguration), new BuiltinVideoModule(videoPresenter),
             new BuiltinEffectModule(effectPresenter), new BuiltinParticleModule(particlePresenter),
             new BuiltinFlowModule(), new BuiltinVariableModule(), new BuiltinGalleryModule(gallery),
             customActions ?? new BuiltinCustomActionModule()
@@ -86,7 +88,8 @@ private sealed class SelectedBuiltinModule(IPrimitiveModule inner, IEntryCatalog
     public static GameRegistration AddBuiltinFlow(this GameRegistration registration) => registration.RegisterImplementation(new BuiltinFlowModule());
     public static GameRegistration AddBuiltinCustomActions(this GameRegistration registration, BuiltinCustomActionModule? module = null) =>
         registration.RegisterImplementation(module ?? new BuiltinCustomActionModule());
-    public static GameRegistration AddBuiltinAudio(this GameRegistration registration, IAudioPlaybackHost? host = null) => registration.RegisterImplementation(new BuiltinAudioModule(host));
+    public static GameRegistration AddBuiltinAudio(this GameRegistration registration, IAudioPlaybackHost? host = null,
+        AudioConfiguration? configuration = null) => registration.RegisterImplementation(new BuiltinAudioModule(host, configuration: configuration));
     public static GameRegistration AddBuiltinGallery(this GameRegistration registration, GalleryCatalog? gallery = null) => registration.RegisterImplementation(new BuiltinGalleryModule(gallery));
     public static GameRegistration AddBuiltinDialogue(this GameRegistration registration, IDialoguePresenter? presenter = null, CharacterCatalog? characters = null) => registration.RegisterImplementation(new BuiltinDialogueModule(presenter, characters));
     public static GameRegistration AddBuiltinNvl(this GameRegistration registration, INvlPresenter? presenter = null) => registration.RegisterImplementation(new BuiltinNvlModule(presenter));
diff --git a/src/Shared/GalNet.Primitives.Builtins/DialoguePrimitiveInstance.cs b/src/Shared/GalNet.Primitives.Builtins/DialoguePrimitiveInstance.cs
index 4d453b40..8d2f8ffe 100644
--- a/src/Shared/GalNet.Primitives.Builtins/DialoguePrimitiveInstance.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/DialoguePrimitiveInstance.cs
@@ -14,7 +14,7 @@ public sealed class DialoguePrimitiveInstance : TextAdvancePrimitiveInstance
     public DialoguePrimitiveInstance(IDialoguePresenter? presenter, CharacterCatalog characters,
         PrimitiveCreateContext context, DialogueTextOptions options)
         : this(presenter ?? throw new InvalidOperationException("The dialogue module has no presenter."),
-            string.IsNullOrEmpty(options.Speaker) ? "" : context.Runtime.TextResolver.Resolve(characters.GetRequired(options.Speaker).DisplayNameKey),
+            string.IsNullOrWhiteSpace(options.Speaker) ? "" : context.Runtime.TextResolver.Resolve(characters.GetRequired(options.Speaker).DisplayNameKey),
             context.Runtime.TextResolver.Resolve(options.Content ?? ""), context.BatchId, context.ScopeCancellation)
     { }
 
diff --git a/src/Shared/GalNet.Primitives.Builtins/EffectPrimitiveInstance.cs b/src/Shared/GalNet.Primitives.Builtins/EffectPrimitiveInstance.cs
index 9e90b8d4..186c93ce 100644
--- a/src/Shared/GalNet.Primitives.Builtins/EffectPrimitiveInstance.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/EffectPrimitiveInstance.cs
@@ -5,7 +5,7 @@
 
 namespace GalNet.Primitives.Builtins;
 
-public sealed class ApplyEffectPrimitiveInstance(IGameRuntime runtime, IEffectPresenter? presenter,
+public sealed class ApplyEffectPrimitiveInstance(IGameContext runtime, IEffectPresenter? presenter,
     EffectRequest request, string? batchId, CancellationToken scopeCancellation)
     : BuiltinPresentationPrimitiveInstance(batchId, scopeCancellation)
 {
@@ -17,7 +17,7 @@ protected override Task ExecuteAsync(CancellationToken token) =>
         presenter?.StartEffectAsync(request, token) ?? Task.CompletedTask;
 }
 
-public sealed class StopEffectPrimitiveInstance(IGameRuntime runtime, IEffectPresenter? presenter,
+public sealed class StopEffectPrimitiveInstance(IGameContext runtime, IEffectPresenter? presenter,
     string instanceId, string? batchId, CancellationToken scopeCancellation)
     : BuiltinPresentationPrimitiveInstance(batchId, scopeCancellation)
 {
diff --git a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinAnimationModule.cs b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinAnimationModule.cs
index 13a656cb..d035848c 100644
--- a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinAnimationModule.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinAnimationModule.cs
@@ -1,5 +1,5 @@
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 
@@ -15,10 +15,10 @@ public sealed class BuiltinAnimationModule(
         registry.ValidateState((_, state) =>
         {
             foreach (var animation in state.Table<LoopAnimationState>().Values)
-                if (state.SceneObjects<ISceneInstance>().Any(item => item.Id == animation.Id))
+                if (state.IdentityObjects<ISceneInstance>(BuiltinScene.KeySpace).Any(item => item.Id == animation.Id))
                     throw new InvalidDataException($"Animation playback handle '{animation.Id}' conflicts with a scene object.");
         });
-        registry.State<LoopAnimationState>("builtin.animations", value => value.Id, context =>
+        registry.State<LoopAnimationState>(BuiltinJson.StateTypeInfo<LoopAnimationState>(), "builtin.animations", value => value.Id, context =>
         {
             if (animationPresenter is null) return Task.CompletedTask;
             foreach (var state in context.Runtime.State.Table<LoopAnimationState>().Values)
@@ -38,16 +38,24 @@ public sealed class BuiltinAnimationModule(
             new AnimationPrimitiveInstance(animationPresenter, context, options));
         registry.Register<TimelineOptions>(BuiltinEntryIds.PlayTimeline, (context, options) =>
             new TimelinePrimitiveInstance(animationPresenter, layerPresenter, effectPresenter, particlePresenter, context, options));
-        registry.Immediate<AnimationStopOptions>(BuiltinEntryIds.StopAnimation, (context, options) =>
+        registry.Async<AnimationStopOptions>(BuiltinEntryIds.StopAnimation, async (context, options, token) =>
             {
                 var playbackHandleId = options.PlaybackHandleId ?? "";
                 var mode = options.Mode ?? AnimationStopMode.AfterIteration;
-                if (context.Runtime.SceneInstances.TryGet<AnimationPlaybackInstance>(playbackHandleId, out var playback))
+                if (context.Runtime.Scene().TryGet<AnimationPlaybackInstance>(playbackHandleId, out var playback))
                     playback.RequestStop(mode);
-                if (mode == AnimationStopMode.CompleteImmediately)
+                if (mode == AnimationStopMode.CompleteImmediately || playback?.PresentationCompletion.IsCompleted != false)
                 {
                     animationPresenter?.CompleteAnimationImmediately(playbackHandleId);
+                    if (playback is not null)
+                        await playback.PresentationCompletion.WaitAsync(token).ConfigureAwait(false);
+                    // Headless and catch-up playbacks can retain a loop definition without a live presenter.
+                    if (context.Runtime.State.Table<LoopAnimationState>().TryGet(playbackHandleId, out var saved))
+                    {
+                        if (saved.Timeline is { } timeline) BuiltinRuntimeActions.ApplyTimelineTerminalState(context.Runtime, timeline);
+                        else if (saved.Request is { } request) BuiltinRuntimeActions.ApplyAnimationTerminalValue(context.Runtime, request);
+                    }
                     BuiltinRuntimeActions.StopAnimationState(context.Runtime, playbackHandleId);
                 }
-            });
+            }, blocking: true);
     });
diff --git a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinAudioModule.cs b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinAudioModule.cs
index f6f0b20a..9290291a 100644
--- a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinAudioModule.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinAudioModule.cs
@@ -1,11 +1,9 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Audio;
+using GalNet.Contracts.Builtins.Audio;
 using GalNet.Core.Primitives;
-using GalNet.Core.Settings;
-using GalNet.Presentation.Abstractions.Audio;
 using GalNet.Presentation.Abstractions.Execution;
-using GalNet.Runtime.Audio;
+using GalNet.Primitives.Builtins.Audio;
 using GalNet.Runtime.Logging;
 
 namespace GalNet.Primitives.Builtins;
@@ -14,21 +12,22 @@ public sealed class BuiltinAudioModule : PrimitiveModule
 {
     private readonly AudioRuntime _runtime;
     private readonly AudioScope _scope;
-    public void ApplyPlayerSettings(GameSettings settings) => _runtime.ApplyPlayerSettings(settings);
+    public void ApplyMix(AudioMixOptions options) => _runtime.ApplyMix(options);
     public void BeginCatchUp() => _runtime.BeginCatchUp();
     public void EndCatchUp() => _runtime.EndCatchUp();
 
-    public BuiltinAudioModule(IAudioPlaybackHost? host = null, ISEffectCatalog? effects = null) : this(new AudioRuntime(host, effects)) { }
+    public BuiltinAudioModule(IAudioPlaybackHost? host = null, ISEffectCatalog? effects = null,
+        AudioConfiguration? configuration = null) : this(new AudioRuntime(host, effects), configuration ?? AudioConfiguration.Empty) { }
 
-    private BuiltinAudioModule(AudioRuntime runtime) : this(runtime, new AudioScope(runtime)) { }
+    private BuiltinAudioModule(AudioRuntime runtime, AudioConfiguration configuration) : this(runtime, new AudioScope(runtime), configuration) { }
 
-    private BuiltinAudioModule(AudioRuntime runtime, AudioScope scope) : base(registry => RegisterPrimitives(registry, runtime, scope))
+    private BuiltinAudioModule(AudioRuntime runtime, AudioScope scope, AudioConfiguration configuration)
+        : base(registry => RegisterPrimitives(registry, runtime, scope, configuration))
     {
         _runtime = runtime;
         _scope = scope;
         _runtime.Diagnostic += OnDiagnostic;
     }
-
     public override void Dispose()
     {
         _scope.Dispose();
@@ -48,49 +47,51 @@ public override async ValueTask DisposeAsync()
         }
     }
 
-    private static List<AudioTrackDefinition> Tracks(PrimitiveCreateContext context) => context.Runtime.Settings.Get<ProjectSettings>().AudioTracks;
-
-    private static void RegisterPrimitives(PrimitiveRegistry registry, AudioRuntime runtime, AudioScope scope)
+    private static void RegisterPrimitives(PrimitiveRegistry registry, AudioRuntime runtime, AudioScope scope,
+        AudioConfiguration tracks)
     {
-        registry.State<AudioTrackState>("builtin.audio.tracks", value => value.Id, validate: AudioRuntime.ValidateTrack);
-        registry.State<AudioSEffectState>("builtin.audio.seffects", value => AudioSEffectState.Key(value.TrackId, value.InstanceId));
-        registry.ValidateState((game, state) => runtime.Validate(state, game.Settings.Get<ProjectSettings>().AudioTracks));
+        registry.State<AudioTrackState>(BuiltinJson.StateTypeInfo<AudioTrackState>(), "builtin.audio.tracks", value => value.Id, validate: AudioRuntime.ValidateTrack, version: 2);
+        registry.State<AudioSEffectState>(BuiltinJson.StateTypeInfo<AudioSEffectState>(), "builtin.audio.seffects", value => value.Key(), version: 2);
+        registry.State<AudioChannelState>(BuiltinJson.StateTypeInfo<AudioChannelState>(), "builtin.audio.channels", value => value.Key(), validate: AudioRuntime.ValidateChannel);
+        registry.ValidateState((_, state) => runtime.Validate(state, tracks));
         registry.Restore("builtin.audio", async context =>
         {
             scope.Bind(context.Runtime, context.CancellationToken);
             context.Own(() => runtime.SuspendAsync(context.Runtime.State));
-            runtime.ApplyPlayerSettings(context.Runtime.Settings.Get<GameSettings>());
-            await runtime.RestoreAsync(context.Runtime.State, context.Runtime.Settings.Get<ProjectSettings>().AudioTracks,
+            await runtime.RestoreAsync(context.Runtime.State, tracks,
                 context.CancellationToken).ConfigureAwait(false);
         });
-        registry.Register<AudioPlayOptions>(BuiltinEntryIds.PlayAudio, (context, options) => Playback(context, runtime, scope,
+        registry.Register<AudioPlayOptions>(BuiltinEntryIds.PlayAudio, (context, options) => Playback(context, runtime, scope, tracks,
             options, options.Placement ?? AudioPlacement.Enqueue));
         registry.Register<AudioStopOptions>(BuiltinEntryIds.StopAudio, (context, options) => Audio(context, scope, () =>
-            runtime.Stop(Tracks(context), new AudioStopRequest(
-                options.TrackId ?? "", options.ClearQueue ?? true, options.FadeOut))));
-        Track(registry, BuiltinEntryIds.PauseAudio, scope, (context, track) => runtime.Pause(Tracks(context), track));
-        Track(registry, BuiltinEntryIds.ResumeAudio, scope, (context, track) => runtime.Resume(Tracks(context), track));
-        Track(registry, BuiltinEntryIds.NextAudio, scope, (context, track) => runtime.Next(Tracks(context), track));
-        Track(registry, BuiltinEntryIds.ClearAudio, scope, (context, track) => runtime.Clear(Tracks(context), track));
-        registry.Register<AudioPlayOptions>(BuiltinEntryIds.EnqueueAudio, (context, options) => Playback(context, runtime, scope, options, AudioPlacement.Enqueue));
+            runtime.Stop(tracks, new AudioStopRequest(
+                options.TrackId, options.ClearQueue ?? true, options.FadeOut))));
+        Track(registry, BuiltinEntryIds.PauseAudio, scope, (_, track) => runtime.Pause(tracks, track));
+        Track(registry, BuiltinEntryIds.ResumeAudio, scope, (_, track) => runtime.Resume(tracks, track));
+        Track(registry, BuiltinEntryIds.NextAudio, scope, (_, track) => runtime.Next(tracks, track));
+        Track(registry, BuiltinEntryIds.ClearAudio, scope, (_, track) => runtime.Clear(tracks, track));
+        registry.Register<AudioPlayOptions>(BuiltinEntryIds.EnqueueAudio, (context, options) => Playback(context, runtime, scope, tracks, options, AudioPlacement.Enqueue));
         registry.Register<AudioSEffectOptions>(BuiltinEntryIds.ApplyAudioSEffect, (context, options) => Audio(context, scope, () =>
-            runtime.ApplySEffect(Tracks(context), new AudioSEffectRequest(
-                options.TrackId ?? "", options.InstanceId ?? "",
-                options.Id ?? "", Arguments.Json<JsonElement>(options.Parameters)))));
+            runtime.ApplySEffect(tracks, new AudioSEffectRequest(
+                options.TargetId, options.InstanceId ?? "",
+                options.Id ?? "", Arguments.Json<JsonElement>(options.Parameters), options.Scope))));
         registry.Register<AudioSEffectStopOptions>(BuiltinEntryIds.StopAudioSEffect, (context, options) => Audio(context, scope, () =>
-            runtime.StopSEffect(Tracks(context), options.TrackId ?? "", options.InstanceId ?? "")));
+            runtime.StopSEffect(tracks, options.TargetId, options.InstanceId ?? "", options.Scope, options.All)));
+        registry.Register<AudioSEffectUpdateOptions>(BuiltinEntryIds.UpdateAudioSEffect, (context, options) => Audio(context, scope, () =>
+            runtime.UpdateSEffect(tracks, options.TargetId, options.InstanceId ?? "", options.Parameters, options.Scope)));
+        registry.Register<AudioLevelOptions>(BuiltinEntryIds.SetAudioLevel, (context, options) => Audio(context, scope, () =>
+            runtime.SetLevel(tracks, new(options.TargetId, options.Scope, options.Gain, options.Muted))));
     }
 
     private static AudioPlayRequest PlayRequest(AudioPlayOptions options, AudioPlacement placement) => new(
-        options.TrackId ?? "", options.Asset ?? "", placement, options.Gain, options.FadeIn);
+        options.TrackId, options.Asset ?? "", placement, options.Gain, options.FadeIn, options.LoopCount, options.Completion, options.FadeOut);
 
     private static AudioPlaybackPrimitiveInstance Playback(PrimitiveCreateContext context, AudioRuntime runtime,
-        AudioScope scope, AudioPlayOptions options, AudioPlacement placement) => new(() =>
+        AudioScope scope, AudioConfiguration tracks, AudioPlayOptions options, AudioPlacement placement) => new(() =>
         {
             scope.Bind(context.Runtime, context.ScopeCancellation);
             context.ScopeCancellation.ThrowIfCancellationRequested();
-            runtime.ApplyPlayerSettings(context.Runtime.Settings.Get<GameSettings>());
-            return runtime.Play(Tracks(context), PlayRequest(options, placement));
+            return runtime.Play(tracks, PlayRequest(options, placement));
         }, options.AutoBlocking ?? false, context.BatchId, context.ScopeCancellation);
 
     private static void OnDiagnostic(string message) => GameLog.Logger.Warning("Audio: {Diagnostic}", message);
@@ -100,7 +101,7 @@ private sealed class AudioScope(AudioRuntime runtime) : IDisposable
         private CancellationToken _token;
         private GalNet.Core.Runtime.GameState? _boundState;
         private CancellationTokenRegistration _registration;
-        public void Bind(GalNet.Core.Runtime.IGameRuntime game, CancellationToken token)
+        public void Bind(GalNet.Core.Runtime.IGameContext game, CancellationToken token)
         {
             if (_token == token && ReferenceEquals(_boundState, game.State)) return;
             _boundState = game.State;
@@ -118,7 +119,7 @@ private static void Track(PrimitiveRegistry registry, string type, AudioScope sc
         {
             scope.Bind(context.Runtime, context.ScopeCancellation);
             context.ScopeCancellation.ThrowIfCancellationRequested();
-            action(context, options.TrackId ?? "");
+            action(context, options.TrackId);
         });
 
     private static ImmediatePrimitiveInstance Audio(PrimitiveCreateContext context, AudioScope scope, Action action) =>
diff --git a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinEffectModule.cs b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinEffectModule.cs
index 4a89b2fc..25e4c183 100644
--- a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinEffectModule.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinEffectModule.cs
@@ -1,5 +1,5 @@
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 
@@ -8,7 +8,7 @@ namespace GalNet.Primitives.Builtins;
 public sealed class BuiltinEffectModule(IEffectPresenter? presenter = null) : PrimitiveModule(
     registry =>
     {
-        registry.State<EffectInstance>("builtin.effects", value => value.Id, async context =>
+        registry.State<EffectInstance>(BuiltinJson.StateTypeInfo<EffectInstance>(), "builtin.effects", value => value.Id, async context =>
         {
             if (presenter is null) return;
             foreach (var effect in context.Runtime.State.Table<EffectInstance>().Values)
@@ -18,7 +18,7 @@ await presenter.StartEffectAsync(new EffectRequest(effect.EffectId, effect.Id, e
                     effect.Order, effect.Parameters, effect.ProgramResource)
                 { AnimationValues = effect.AnimationValues }, context.CancellationToken).ConfigureAwait(false);
             }
-        }, after: ["builtin.layers"]);
+        }, keySpace: BuiltinScene.KeySpace, after: ["builtin.layers"]);
         registry.Register<EffectApplyOptions>(BuiltinEntryIds.ApplyEffect, (context, options) =>
             new ApplyEffectPrimitiveInstance(presenter, context, options));
         registry.Register<InstanceIdOptions>(BuiltinEntryIds.StopEffect, (context, options) =>
diff --git a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinGalleryModule.cs b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinGalleryModule.cs
index 6a6f466c..2119d845 100644
--- a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinGalleryModule.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinGalleryModule.cs
@@ -1,5 +1,5 @@
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Presentation.Abstractions.Execution;
 
 namespace GalNet.Primitives.Builtins;
diff --git a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinLayerModule.cs b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinLayerModule.cs
index 8e53cd6d..9cdcaed0 100644
--- a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinLayerModule.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinLayerModule.cs
@@ -1,7 +1,7 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
-using GalNet.Core.Variants;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 
@@ -15,7 +15,7 @@ public sealed class BuiltinLayerModule(ILayerPresenter? presenter = null, ImageV
         {
             foreach (var layer in state.Table<Layer>().Values) LayerVariantsRuntime.ValidateContent(layer, variants);
         });
-        registry.State<Layer>("builtin.layers", value => value.Id, context =>
+        registry.State<Layer>(BuiltinJson.StateTypeInfo<Layer>(), "builtin.layers", value => value.Id, context =>
         {
             foreach (var layer in context.Runtime.State.Table<Layer>().Values) LayerVariantsRuntime.ValidateContent(layer, variants);
             if (presenter is null) return Task.CompletedTask;
@@ -25,7 +25,7 @@ public sealed class BuiltinLayerModule(ILayerPresenter? presenter = null, ImageV
                 presenter.ShowLayer(Request(layer));
             }
             return Task.CompletedTask;
-        }, validate: LayerVariantsRuntime.ValidateShape, version: 2);
+        }, validate: LayerVariantsRuntime.ValidateShape, version: 2, keySpace: BuiltinScene.KeySpace);
         registry.Register<VariantsShowOptions>(BuiltinEntryIds.ShowVariants, (context, options) => Immediate(context, presenter,
             target => LayerVariantsRuntime.Show(context, options, variants, target)));
         registry.Register<VariantsSelectOptions>(BuiltinEntryIds.SelectVariants, (context, options) => Immediate(context, presenter,
diff --git a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinParticleModule.cs b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinParticleModule.cs
index d1de4ad3..60ce11d4 100644
--- a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinParticleModule.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinParticleModule.cs
@@ -1,5 +1,5 @@
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 
@@ -8,7 +8,7 @@ namespace GalNet.Primitives.Builtins;
 public sealed class BuiltinParticleModule(IParticlePresenter? presenter = null) : PrimitiveModule(
     registry =>
     {
-        registry.State<ParticleEmitterInstance>("builtin.particles", value => value.Id, async context =>
+        registry.State<ParticleEmitterInstance>(BuiltinJson.StateTypeInfo<ParticleEmitterInstance>(), "builtin.particles", value => value.Id, async context =>
         {
             if (presenter is null) return;
             foreach (var emitter in context.Runtime.State.Table<ParticleEmitterInstance>().Values)
@@ -17,7 +17,7 @@ public sealed class BuiltinParticleModule(IParticlePresenter? presenter = null)
                 await presenter.StartParticleEmitterAsync(new ParticleEmitterRequest(emitter.Id, emitter.Definition, emitter.Z)
                 { AnimationValues = emitter.AnimationValues }, context.CancellationToken).ConfigureAwait(false);
             }
-        });
+        }, keySpace: BuiltinScene.KeySpace);
         registry.Register<ParticlePlayOptions>(BuiltinEntryIds.PlayParticleEmitter, (context, options) =>
             new PlayParticlePrimitiveInstance(presenter, context, options));
         registry.Register<ParticleBurstOptions>(BuiltinEntryIds.BurstParticles, (context, options) =>
diff --git a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinVariableModule.cs b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinVariableModule.cs
index 1bbaef74..233dff6e 100644
--- a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinVariableModule.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinVariableModule.cs
@@ -1,5 +1,6 @@
 using GalNet.Contracts.Builtins;
 using GalNet.Presentation.Abstractions.Execution;
+using GalNet.Runtime.Logging;
 
 namespace GalNet.Primitives.Builtins;
 
@@ -7,6 +8,20 @@ public sealed class BuiltinVariableModule() : PrimitiveModule(
     registry => registry.Immediate<VariableSetOptions>(BuiltinEntryIds.SetVariable, (context, options) =>
             {
                 var target = options.Target;
-                if (!string.IsNullOrWhiteSpace(target))
-                    context.Runtime.SetVariable(target, context.Runtime.EvaluateExpression(options.Expression ?? "") ?? "");
+                if (string.IsNullOrWhiteSpace(target)) return;
+                object? value;
+                try { value = context.Runtime.EvaluateExpression(options.Expression ?? ""); }
+                catch (Exception error) when (error is not OperationCanceledException)
+                {
+                    GameLog.Logger.Warning(error, "{DiagnosticCode} at group {GroupId}, entry {EntryId}: assignment to {Variable} rejected",
+                        "variable.expression.invalid", context.Runtime.CurrentNodeId, context.Entry.StableId, target);
+                    return;
+                }
+                if (value is null)
+                {
+                    GameLog.Logger.Warning("{DiagnosticCode} at group {GroupId}, entry {EntryId}: assignment to {Variable} has no value",
+                        "variable.expression.empty", context.Runtime.CurrentNodeId, context.Entry.StableId, target);
+                    return;
+                }
+                context.Runtime.SetVariable(target, value);
             }));
diff --git a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinVideoModule.cs b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinVideoModule.cs
index 2670ab59..4c8d27ab 100644
--- a/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinVideoModule.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/Modules/BuiltinVideoModule.cs
@@ -1,5 +1,5 @@
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 
@@ -19,8 +19,8 @@ public sealed class BuiltinVideoModule(IVideoPresenter? presenter = null) : Prim
         registry.Immediate<VideoStopOptions>(BuiltinEntryIds.StopVideo, (context, options) =>
             {
                 var handleId = options.HandleId ?? "";
-                if (context.Runtime.SceneInstances.TryGet<Layer>(handleId, out var layer) && layer.IsVideo)
-                    context.Runtime.SceneInstances.Remove<Layer>(handleId, out _);
+                if (context.Runtime.Scene().TryGet<Layer>(handleId, out var layer) && layer.IsVideo)
+                    context.Runtime.Scene().Remove<Layer>(handleId, out _);
                 presenter?.StopVideo(handleId);
             });
     })
diff --git a/src/Shared/GalNet.Primitives.Builtins/ParticlePrimitiveInstance.cs b/src/Shared/GalNet.Primitives.Builtins/ParticlePrimitiveInstance.cs
index c50b5e1e..64bb3898 100644
--- a/src/Shared/GalNet.Primitives.Builtins/ParticlePrimitiveInstance.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/ParticlePrimitiveInstance.cs
@@ -1,12 +1,12 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Primitives.Builtins;
 
-public sealed class PlayParticlePrimitiveInstance(IGameRuntime runtime, IParticlePresenter? presenter,
+public sealed class PlayParticlePrimitiveInstance(IGameContext runtime, IParticlePresenter? presenter,
     ParticleEmitterRequest request, string? batchId, CancellationToken scopeCancellation)
     : BuiltinPresentationPrimitiveInstance(batchId, scopeCancellation)
 {
@@ -18,7 +18,7 @@ protected override Task ExecuteAsync(CancellationToken token) =>
         presenter?.StartParticleEmitterAsync(request, token) ?? Task.CompletedTask;
 }
 
-public sealed class StopParticlePrimitiveInstance(IGameRuntime runtime, IParticlePresenter? presenter,
+public sealed class StopParticlePrimitiveInstance(IGameContext runtime, IParticlePresenter? presenter,
     string instanceId, string? batchId, CancellationToken scopeCancellation)
     : BuiltinPresentationPrimitiveInstance(batchId, scopeCancellation)
 {
diff --git a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.AnimationState.cs b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.AnimationState.cs
index 9377399c..ea62d89f 100644
--- a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.AnimationState.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.AnimationState.cs
@@ -1,14 +1,14 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Primitives.Builtins;
 
 internal static partial class BuiltinRuntimeActions
 {
-    public static void ApplyAnimationStableState(IGameRuntime runtime, AnimationRequest request)
+    public static void ApplyAnimationStableState(IGameContext runtime, AnimationRequest request)
     {
         if (request.LoopMode == AnimationLoopMode.Once)
         {
@@ -28,14 +28,14 @@ public static void ApplyAnimationStableState(IGameRuntime runtime, AnimationRequ
         TrackLoopingAnimation(runtime, new LoopAnimationState { Id = request.PlaybackHandleId, Request = request });
     }
 
-    public static void ApplyAnimationTerminalValue(IGameRuntime runtime, AnimationRequest request) =>
+    public static void ApplyAnimationTerminalValue(IGameContext runtime, AnimationRequest request) =>
         ApplyAnimationValue(runtime, request.HandleId, request.Property, request.To, request.BlendMode);
 
-    public static void ApplyTimelineStableState(IGameRuntime runtime, TimelineDefinition timeline)
+    public static void ApplyTimelineStableState(IGameContext runtime, TimelineDefinition timeline)
     {
         if (timeline.LoopMode != AnimationLoopMode.Once)
         {
-            foreach (var item in timeline.Events.Where(item => item.Frame <= 0).OrderBy(item => item.Frame))
+            foreach (var item in timeline.Events.Where(item => item.Frame <= 0 && item.Execution != TimelineEventExecution.OnCompletion).OrderBy(item => item.Frame))
                 ApplyTimelineEventToRuntime(runtime, item);
 
             foreach (var track in timeline.Tracks.Where(track => track.Keys.Count > 0 && track.BlendMode == AnimationBlendMode.Replace))
@@ -53,7 +53,7 @@ public static void ApplyTimelineStableState(IGameRuntime runtime, TimelineDefini
         ApplyTimelineTerminalState(runtime, timeline);
     }
 
-    public static void ApplyTimelineTerminalState(IGameRuntime runtime, TimelineDefinition timeline)
+    public static void ApplyTimelineTerminalState(IGameContext runtime, TimelineDefinition timeline)
     {
         foreach (var item in timeline.Events.OrderBy(item => item.Frame))
             ApplyTimelineEventToRuntime(runtime, item);
@@ -68,14 +68,14 @@ public static void ApplyTimelineTerminalState(IGameRuntime runtime, TimelineDefi
                     track.BlendMode);
     }
 
-    public static void StopAnimationState(IGameRuntime runtime, string playbackHandleId)
+    public static void StopAnimationState(IGameContext runtime, string playbackHandleId)
     {
         if (string.IsNullOrWhiteSpace(playbackHandleId))
             return;
 
         runtime.State.Update(() =>
         {
-            runtime.SceneInstances.Remove<AnimationPlaybackInstance>(playbackHandleId, out _);
+            runtime.Scene().Remove<AnimationPlaybackInstance>(playbackHandleId, out _);
             runtime.State.Table<LoopAnimationState>().Remove(playbackHandleId);
         });
     }
diff --git a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.AnimationValues.cs b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.AnimationValues.cs
index 601dbbd5..aa7be6fb 100644
--- a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.AnimationValues.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.AnimationValues.cs
@@ -1,5 +1,5 @@
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Primitives.Builtins;
@@ -7,13 +7,13 @@ namespace GalNet.Primitives.Builtins;
 internal static partial class BuiltinRuntimeActions
 {
     private static void ApplyAnimationValue(
-        IGameRuntime runtime,
+        IGameContext runtime,
         string handleId,
         string property,
         float authoredValue,
         AnimationBlendMode blendMode)
     {
-        if (!runtime.SceneInstances.TryGet<AnimatableSceneInstance>(handleId, out var target))
+        if (!runtime.Scene().TryGet<AnimatableSceneInstance>(handleId, out var target))
             return;
 
         var finalValue = authoredValue;
@@ -24,19 +24,19 @@ private static void ApplyAnimationValue(
         runtime.State.Update(() => target.TrySetAnimationValue(property, finalValue, out _));
     }
 
-    private static void TrackLoopingAnimation(IGameRuntime runtime, LoopAnimationState state)
+    private static void TrackLoopingAnimation(IGameContext runtime, LoopAnimationState state)
     {
         if (string.IsNullOrWhiteSpace(state.Id)) return;
         runtime.State.Update(() =>
         {
-            runtime.SceneInstances.Remove<AnimationPlaybackInstance>(state.Id, out _);
-            runtime.SceneInstances.GetOrAddTransient(state.Id, id => new AnimationPlaybackInstance
+            runtime.Scene().Remove<AnimationPlaybackInstance>(state.Id, out _);
+            runtime.Scene().GetOrAddTransient(state.Id, id => new AnimationPlaybackInstance
             { Id = id, LoopMode = state.Request?.LoopMode ?? state.Timeline!.LoopMode });
             runtime.State.Table<LoopAnimationState>().Set(state);
         });
     }
 
-    private static bool TryResolveAnimationStartValue(IGameRuntime runtime, AnimationRequest request, out float value)
+    private static bool TryResolveAnimationStartValue(IGameContext runtime, AnimationRequest request, out float value)
     {
         if (request.From.HasValue)
         {
@@ -44,7 +44,7 @@ private static bool TryResolveAnimationStartValue(IGameRuntime runtime, Animatio
             return true;
         }
 
-        if (runtime.SceneInstances.TryGet<AnimatableSceneInstance>(request.HandleId, out var target) &&
+        if (runtime.Scene().TryGet<AnimatableSceneInstance>(request.HandleId, out var target) &&
             target.TryGetAnimationValue(request.Property, out value))
             return true;
 
diff --git a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.EffectParticleState.cs b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.EffectParticleState.cs
index 32071fbb..bad41e98 100644
--- a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.EffectParticleState.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.EffectParticleState.cs
@@ -1,30 +1,30 @@
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Primitives.Builtins;
 
 internal static partial class BuiltinRuntimeActions
 {
-    public static void ApplyParticleState(IGameRuntime runtime, ParticleEmitterRequest request)
+    public static void ApplyParticleState(IGameContext runtime, ParticleEmitterRequest request)
     {
         runtime.State.Update(() =>
         {
 
             RemoveParticleState(runtime, request.InstanceId);
-            var emitter = runtime.SceneInstances.GetOrAdd(request.InstanceId, id => new ParticleEmitterInstance(id, request.Definition, request.Z));
+            var emitter = runtime.Scene().GetOrAdd(request.InstanceId, id => new ParticleEmitterInstance(id, request.Definition, request.Z));
             emitter.RestoreAnimationValues(request.AnimationValues);
 
         });
     }
 
-    public static void RemoveParticleState(IGameRuntime runtime, string instanceId)
+    public static void RemoveParticleState(IGameContext runtime, string instanceId)
     {
         if (string.IsNullOrWhiteSpace(instanceId)) return;
-        runtime.SceneInstances.Remove<ParticleEmitterInstance>(instanceId, out _);
+        runtime.Scene().Remove<ParticleEmitterInstance>(instanceId, out _);
     }
 
-    public static void ApplyEffectState(IGameRuntime runtime, EffectRequest request)
+    public static void ApplyEffectState(IGameContext runtime, EffectRequest request)
     {
         runtime.State.Update(() =>
         {
@@ -33,7 +33,7 @@ public static void ApplyEffectState(IGameRuntime runtime, EffectRequest request)
                 return;
 
             RemoveEffectState(runtime, request.InstanceId);
-            var effect = runtime.SceneInstances.GetOrAdd(request.InstanceId, _ => new EffectInstance
+            var effect = runtime.Scene().GetOrAdd(request.InstanceId, _ => new EffectInstance
             {
                 Id = request.InstanceId,
                 EffectId = request.Id,
@@ -48,11 +48,11 @@ public static void ApplyEffectState(IGameRuntime runtime, EffectRequest request)
         });
     }
 
-    public static void RemoveEffectState(IGameRuntime runtime, string instanceId)
+    public static void RemoveEffectState(IGameContext runtime, string instanceId)
     {
         if (string.IsNullOrWhiteSpace(instanceId))
             return;
 
-        runtime.SceneInstances.Remove<EffectInstance>(instanceId, out _);
+        runtime.Scene().Remove<EffectInstance>(instanceId, out _);
     }
 }
diff --git a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Layers.cs b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Layers.cs
index 688f4e6c..846ecd8f 100644
--- a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Layers.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Layers.cs
@@ -1,18 +1,18 @@
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Primitives.Builtins;
 
 internal static partial class BuiltinRuntimeActions
 {
-    public static void ShowLayer(IGameRuntime runtime, ILayerPresenter? presenter, LayerRenderRequest request, bool notify = true,
+    public static void ShowLayer(IGameContext runtime, ILayerPresenter? presenter, LayerRenderRequest request, bool notify = true,
         LayerVariantsState? variants = null)
     {
         runtime.State.Update(() =>
         {
-            runtime.SceneInstances.Remove<Layer>(request.HandleId, out _);
-            runtime.SceneInstances.GetOrAdd(request.HandleId, id => new Layer
+            runtime.Scene().Remove<Layer>(request.HandleId, out _);
+            runtime.Scene().GetOrAdd(request.HandleId, id => new Layer
             {
                 Id = id,
                 AssetId = request.AssetId,
@@ -30,15 +30,15 @@ public static void ShowLayer(IGameRuntime runtime, ILayerPresenter? presenter, L
             presenter?.ShowLayer(request);
     }
 
-    public static void HideLayer(IGameRuntime runtime, ILayerPresenter? presenter, string handleId, bool notify = true)
+    public static void HideLayer(IGameContext runtime, ILayerPresenter? presenter, string handleId, bool notify = true)
     {
-        runtime.SceneInstances.Remove<Layer>(handleId, out _);
+        runtime.Scene().Remove<Layer>(handleId, out _);
         if (notify)
             presenter?.HideLayer(handleId);
     }
 
     public static void MoveLayer(
-        IGameRuntime runtime,
+        IGameContext runtime,
         ILayerPresenter? presenter,
         string handleId,
         LayerTransform transform,
@@ -48,7 +48,7 @@ public static void MoveLayer(
     {
         runtime.State.Update(() =>
         {
-            if (runtime.SceneInstances.TryGet<Layer>(handleId, out var layer))
+            if (runtime.Scene().TryGet<Layer>(handleId, out var layer))
             {
                 layer.Transform = transform.Clone();
                 layer.Z = z;
@@ -58,11 +58,11 @@ public static void MoveLayer(
             presenter?.MoveLayer(handleId, transform, z, durationSeconds);
     }
 
-    public static void ReplaceLayer(IGameRuntime runtime, ILayerPresenter? presenter, string handleId, string assetId, bool notify = true)
+    public static void ReplaceLayer(IGameContext runtime, ILayerPresenter? presenter, string handleId, string assetId, bool notify = true)
     {
         runtime.State.Update(() =>
         {
-            if (runtime.SceneInstances.TryGet<Layer>(handleId, out var layer))
+            if (runtime.Scene().TryGet<Layer>(handleId, out var layer))
             {
                 runtime.State.Table<Layer>().Set(new Layer
                 {
diff --git a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Parameters.cs b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Parameters.cs
index 30335c30..3c2f17ba 100644
--- a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Parameters.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Parameters.cs
@@ -1,6 +1,7 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Serialization;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Primitives.Builtins;
@@ -97,6 +98,6 @@ private static string RawJson(IReadOnlyDictionary<string, JsonElement> parameter
 
     private static T? Json<T>(IReadOnlyDictionary<string, JsonElement> parameters, string name) =>
         parameters.TryGetValue(name, out var value)
-            ? value.Deserialize<T>(Arguments.JsonOptions)
+            ? JsonCodec.Deserialize<T>(value, Arguments.JsonOptions)
             : default;
 }
diff --git a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Requests.cs b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Requests.cs
index 166dbc74..afb22335 100644
--- a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Requests.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.Requests.cs
@@ -1,7 +1,7 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Primitives.Builtins;
diff --git a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.TimelineEvents.cs b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.TimelineEvents.cs
index 6ccc5203..f1567f65 100644
--- a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.TimelineEvents.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/BuiltinRuntimeActions.TimelineEvents.cs
@@ -1,13 +1,13 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Primitives.Builtins;
 
 internal static partial class BuiltinRuntimeActions
 {
-    public static void ApplyTimelineEventToRuntime(IGameRuntime runtime, TimelineEventDefinition planEvent)
+    public static void ApplyTimelineEventToRuntime(IGameContext runtime, TimelineEventDefinition planEvent)
     {
         switch (planEvent.Type)
         {
diff --git a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/LayerVariantsRuntime.cs b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/LayerVariantsRuntime.cs
index 1de5b5e1..657daf10 100644
--- a/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/LayerVariantsRuntime.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/RuntimeActions/LayerVariantsRuntime.cs
@@ -1,7 +1,7 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
-using GalNet.Core.Variants;
 using GalNet.Presentation.Abstractions.View;
 
 namespace GalNet.Primitives.Builtins;
@@ -27,6 +27,14 @@ public static void ValidateContent(Layer layer, ImageVariantsCatalog catalog)
         try
         {
             var result = ImageVariantsResolver.Resolve(catalog.Get(state.AssetId), state.Request, state.ProtectedDimensions);
+            if (catalog.IsOverridden(state.AssetId) || state.UsesResourceOverride)
+            {
+                // Only the staged restore state is changed. Logical selection intent remains authoritative.
+                layer.AssetId = result.Variant.AssetId;
+                state.VariantKey = result.Variant.Key;
+                state.Reason = result.Reason;
+                state.UsesResourceOverride = catalog.IsOverridden(state.AssetId);
+            }
             if (result.Variant.Key != state.VariantKey || !string.Equals(result.Variant.AssetId, layer.AssetId, StringComparison.OrdinalIgnoreCase) || result.Reason != state.Reason)
                 throw new InvalidDataException($"Layer '{layer.Id}' image variants result differs from saved content.");
         }
@@ -43,7 +51,7 @@ public static void Show(PrimitiveCreateContext context, VariantsShowOptions opti
         var request = new LayerRenderRequest(options.HandleId, resolution.Variant.AssetId,
             VariantsArgumentValidation.ReadTransform(options.Transform), options.Z,
             options.DisplayMode ?? LayerDisplayMode.Native, options.Opacity);
-        BuiltinRuntimeActions.ShowLayer(context.Runtime, presenter, request, variants: LayerVariantsState.From(options.AssetId, resolution));
+        BuiltinRuntimeActions.ShowLayer(context.Runtime, presenter, request, variants: LayerVariantsState.From(options.AssetId, resolution, catalog.IsOverridden(options.AssetId)));
     }
 
     public static void Select(PrimitiveCreateContext context, VariantsSelectOptions options, ImageVariantsCatalog catalog, ILayerPresenter? presenter)
@@ -56,7 +64,7 @@ public static void Select(PrimitiveCreateContext context, VariantsSelectOptions
             if (!context.Runtime.State.Table<Layer>().TryGet(options.HandleId, out var layer) || layer.Variants is not { } state)
                 throw new InvalidOperationException($"Layer '{options.HandleId}' is not an active image variants instance.");
             var result = ImageVariantsResolver.Select(catalog.Get(state.AssetId), state.Request, options.Dimension, options.Value);
-            var next = LayerVariantsState.From(state.AssetId, result);
+            var next = LayerVariantsState.From(state.AssetId, result, catalog.IsOverridden(state.AssetId));
             layer.Variants = next;
             layer.AssetId = assetId = result.Variant.AssetId;
         });
diff --git a/src/Shared/GalNet.Primitives.Builtins/Scene/BuiltinScene.cs b/src/Shared/GalNet.Primitives.Builtins/Scene/BuiltinScene.cs
new file mode 100644
index 00000000..c0f1a999
--- /dev/null
+++ b/src/Shared/GalNet.Primitives.Builtins/Scene/BuiltinScene.cs
@@ -0,0 +1,54 @@
+using System.Runtime.CompilerServices;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Runtime;
+
+namespace GalNet.Primitives.Builtins;
+
+/// <summary>Optional scene capability. Each state root owns independent transient controls.</summary>
+public static class BuiltinScene
+{
+    public const string KeySpace = "builtin.scene";
+    private static readonly ConditionalWeakTable<GameState, SceneInstances> Instances = new();
+    public static SceneInstances Scene(this IGameContext context) => For(context.State);
+    public static SceneInstances For(GameState state) => Instances.GetValue(state, root => new(root));
+}
+
+public sealed class SceneInstances(GameState state)
+{
+    private readonly Dictionary<string, ISceneInstance> _transient = new(StringComparer.Ordinal);
+    public IReadOnlyList<T> GetAll<T>() where T : class, ISceneInstance => state.Read(() =>
+        state.IdentityObjects<T>(BuiltinScene.KeySpace).Concat(_transient.Values.OfType<T>()).ToArray());
+    public bool TryGet<T>(string id, out T instance) where T : class, ISceneInstance
+    {
+        T? found = null;
+        var exists = state.Read(() =>
+        {
+            if (_transient.TryGetValue(id, out var value)) { found = value as T; return found is not null; }
+            return state.TryGetIdentity(BuiltinScene.KeySpace, id, out found);
+        });
+        instance = found!; return exists;
+    }
+    public T GetOrAdd<T>(string id, Func<string, T> factory) where T : class, ISceneInstance => state.Update(() =>
+    {
+        if (TryGet<T>(id, out var existing)) return existing;
+        if (_transient.ContainsKey(id)) throw new InvalidOperationException($"Scene handle '{id}' is already in use.");
+        var value = factory(id); state.Table<T>().Add(value); return value;
+    });
+    public T GetOrAddTransient<T>(string id, Func<string, T> factory) where T : class, ISceneInstance => state.Update(() =>
+    {
+        if (TryGet<T>(id, out var existing)) return existing;
+        if (GetAll<ISceneInstance>().Any(item => item.Id == id)) throw new InvalidOperationException($"Scene handle '{id}' is already in use.");
+        var value = factory(id); _transient.Add(id, value); return value;
+    });
+    public bool Remove<T>(string id, out T? instance) where T : class, ISceneInstance
+    {
+        T? removed = null;
+        var result = state.Update(() =>
+        {
+            if (!TryGet<T>(id, out var existing)) return false;
+            removed = existing;
+            return _transient.Remove(id) || state.Table<T>().Remove(id);
+        });
+        instance = removed; return result;
+    }
+}
diff --git a/src/Shared/GalNet.Primitives.Builtins/TimelinePrimitiveInstance.cs b/src/Shared/GalNet.Primitives.Builtins/TimelinePrimitiveInstance.cs
index 961f6bef..78dbaaa2 100644
--- a/src/Shared/GalNet.Primitives.Builtins/TimelinePrimitiveInstance.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/TimelinePrimitiveInstance.cs
@@ -1,8 +1,8 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Runtime.Logging;
 
@@ -12,7 +12,7 @@ public sealed class TimelinePrimitiveInstance : PrimitiveInstance, IDisposable
 {
     private readonly object _gate = new();
     private readonly bool _restoring;
-    private readonly IGameRuntime _runtime;
+    private readonly IGameContext _runtime;
     private readonly IAnimationPresenter? _animationPresenter;
     private readonly ILayerPresenter? _layerPresenter;
     private readonly IEffectPresenter? _effectPresenter;
@@ -28,10 +28,11 @@ public sealed class TimelinePrimitiveInstance : PrimitiveInstance, IDisposable
     private bool _skippable;
     private AnimationPlaybackInstance? _playback;
     private long _eventCycle;
+    private long? _stopAfterCycle;
     private bool _catchUpDetached;
+    private readonly TaskCompletionSource _completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
     private Task _presentationTask = Task.CompletedTask;
-    private Task _skipTask = Task.CompletedTask;
-    public override Task PresentationCompletion => Task.WhenAll(_presentationTask, _skipTask);
+    public override Task PresentationCompletion => _completion.Task;
 
     public TimelinePrimitiveInstance(IAnimationPresenter? animationPresenter, ILayerPresenter? layerPresenter,
         IEffectPresenter? effectPresenter, IParticlePresenter? particlePresenter, PrimitiveCreateContext context, TimelineOptions options)
@@ -40,7 +41,7 @@ public TimelinePrimitiveInstance(IAnimationPresenter? animationPresenter, ILayer
     { }
 
     public TimelinePrimitiveInstance(
-        IGameRuntime runtime,
+        IGameContext runtime,
         IAnimationPresenter? animationPresenter,
         ILayerPresenter? layerPresenter,
         IEffectPresenter? effectPresenter,
@@ -66,7 +67,7 @@ public TimelinePrimitiveInstance(
             .ToArray();
         _notifiedEvents = new bool[_events.Length];
         if (restoring)
-            foreach (var item in _events.Where(item => item.Event.Frame <= 0)) _notifiedEvents[item.Index] = true;
+            foreach (var item in _events.Where(item => item.Event.Frame <= 0 && item.Event.Execution != TimelineEventExecution.OnCompletion)) _notifiedEvents[item.Index] = true;
     }
 
     public override bool IsBlocking => _timeline.Blocking;
@@ -82,17 +83,20 @@ public override bool IsSkippable
     protected override void OnDispatch()
     {
         if (!_restoring) BuiltinRuntimeActions.ApplyTimelineStableState(_runtime, _timeline);
-        else _runtime.SceneInstances.GetOrAddTransient(_timeline.PlaybackHandleId,
+        _playback = _runtime.Scene().GetOrAddTransient(_timeline.PlaybackHandleId,
             id => new AnimationPlaybackInstance { Id = id, LoopMode = _timeline.LoopMode });
-        _runtime.SceneInstances.TryGet<AnimationPlaybackInstance>(_timeline.PlaybackHandleId, out _playback!);
         if (_animationPresenter is null)
         {
+            if (_timeline.LoopMode == AnimationLoopMode.Once)
+                BuiltinRuntimeActions.StopAnimationState(_runtime, _timeline.PlaybackHandleId);
             Dispose();
+            _completion.TrySetResult();
             TryComplete();
             return;
         }
 
         _presentationTask = ObservePresentationAsync();
+        _playback.PresentationCompletion = PresentationCompletion;
     }
 
     protected override void OnSkip()
@@ -109,7 +113,7 @@ protected override void OnSkip()
         _animationPresenter?.CompleteAnimationImmediately(_timeline.PlaybackHandleId);
         if (_timeline.LoopMode != AnimationLoopMode.Once)
             BuiltinRuntimeActions.ApplyTimelineTerminalState(_runtime, _timeline);
-        _skipTask = CompleteSkipAsync();
+        _ = CompleteSkipAsync();
     }
 
     protected override void OnPlaybackModeChanged(PrimitiveInvocationMode mode)
@@ -129,6 +133,7 @@ protected override void OnCatchUpDispatch()
         if (!_timeline.Skippable && _timeline.Blocking) { OnDispatch(); return; }
         BuiltinRuntimeActions.ApplyTimelineStableState(_runtime, _timeline);
         Dispose();
+        _completion.TrySetResult();
         TryComplete();
     }
 
@@ -140,8 +145,17 @@ private async Task ObservePresentationAsync()
                 _scopeCancellation,
                 _presentationCancellation.Token);
             await NotifyEventsThroughFrameAsync(0, linked.Token).ConfigureAwait(false);
-            await _animationPresenter!.PlayTimelineAsync(
-                _timeline, linked.Token, elapsedFrames => NotifyPlaybackEventsAsync(elapsedFrames, linked.Token)).ConfigureAwait(false);
+            var result = _playback?.RequestedStop == AnimationStopMode.CompleteImmediately
+                ? new TimelinePlayResult { Outcome = AnimationOutcome.Skipped }
+                : await _animationPresenter!.PlayTimelineAsync(
+                    _timeline, linked.Token, elapsedFrames => NotifyPlaybackEventsAsync(elapsedFrames, linked.Token)).ConfigureAwait(false);
+            if (result.Outcome != AnimationOutcome.Replaced && !_skipRequested && !_catchUpDetached && !_scopeCancellation.IsCancellationRequested &&
+                (_timeline.LoopMode == AnimationLoopMode.Once || _playback?.RequestedStop is not null || result.Outcome == AnimationOutcome.Skipped))
+            {
+                if (_timeline.LoopMode != AnimationLoopMode.Once)
+                    BuiltinRuntimeActions.ApplyTimelineTerminalState(_runtime, _timeline);
+                await NotifyRemainingEventsAsync(_scopeCancellation).ConfigureAwait(false);
+            }
         }
         catch (OperationCanceledException) when (_scopeCancellation.IsCancellationRequested || _presentationCancellation.IsCancellationRequested)
         { }
@@ -149,40 +163,43 @@ private async Task ObservePresentationAsync()
         { GameLog.Logger.Warning(error, "Animation timeline {PlaybackId} presentation failed", _timeline.PlaybackHandleId); }
         finally
         {
-            _runtime.State.Update(() =>
-            {
-                if (!_catchUpDetached && _playback is not null && _runtime.SceneInstances.TryGet<AnimationPlaybackInstance>(_timeline.PlaybackHandleId, out var current) && ReferenceEquals(current, _playback))
-                    BuiltinRuntimeActions.StopAnimationState(_runtime, _timeline.PlaybackHandleId);
-            });
             bool skipRequested;
             lock (_gate)
             {
                 _skippable = false;
                 skipRequested = _skipRequested;
             }
-            if (!skipRequested)
-            {
-                Dispose();
-                TryComplete();
-            }
+            if (!skipRequested) FinishPlayback();
         }
     }
 
     private async Task NotifyEventsThroughFrameAsync(int frame, CancellationToken cancellationToken)
     {
-        foreach (var item in _events.Where(item => item.Event.Frame <= frame))
+        foreach (var item in _events.Where(item => item.Event.Frame <= frame && item.Event.Execution != TimelineEventExecution.OnCompletion))
             await NotifyEventAsync(item, cancellationToken).ConfigureAwait(false);
     }
 
     private async Task CompleteSkipAsync()
     {
-        try { await NotifyRemainingEventsAsync(_scopeCancellation).ConfigureAwait(false); }
-        catch (OperationCanceledException) when (_scopeCancellation.IsCancellationRequested) { }
-        finally
+        try
         {
-            Dispose();
-            TryComplete();
+            await _presentationTask.ConfigureAwait(false);
+            await NotifyRemainingEventsAsync(_scopeCancellation).ConfigureAwait(false);
         }
+        catch (OperationCanceledException) when (_scopeCancellation.IsCancellationRequested) { }
+        finally { FinishPlayback(); }
+    }
+
+    private void FinishPlayback()
+    {
+        _runtime.State.Update(() =>
+        {
+            if (!_catchUpDetached && _playback is not null && _runtime.Scene().TryGet<AnimationPlaybackInstance>(_timeline.PlaybackHandleId, out var current) && ReferenceEquals(current, _playback))
+                BuiltinRuntimeActions.StopAnimationState(_runtime, _timeline.PlaybackHandleId);
+        });
+        Dispose();
+        _completion.TrySetResult();
+        TryComplete();
     }
 
     // The presenter supplies its own elapsed frame count before sampling tracks.
@@ -193,10 +210,21 @@ private async Task NotifyPlaybackEventsAsync(double elapsedFrames, CancellationT
             ? _timeline.DurationFrames * 2d : _timeline.DurationFrames;
         var cycle = _timeline.LoopMode == AnimationLoopMode.Once || cycleFrames <= 0
             ? 0 : (long)(elapsedFrames / cycleFrames);
+        if (_playback?.RequestedStop == AnimationStopMode.AfterIteration && _timeline.LoopMode != AnimationLoopMode.Once)
+        {
+            _stopAfterCycle ??= _eventCycle + 1;
+            if (cycle >= _stopAfterCycle || cycleFrames <= 0)
+            {
+                _animationPresenter?.CompleteAnimationImmediately(_timeline.PlaybackHandleId);
+                return;
+            }
+        }
         for (; _eventCycle < cycle; _eventCycle++)
         {
             await NotifyEventsThroughFrameAsync(_timeline.DurationFrames, cancellationToken).ConfigureAwait(false);
-            lock (_gate) Array.Clear(_notifiedEvents);
+            lock (_gate)
+                foreach (var item in _events.Where(item => item.Event.Execution == TimelineEventExecution.EachIteration))
+                    _notifiedEvents[item.Index] = false;
         }
         var frame = _timeline.LoopMode == AnimationLoopMode.Once || cycleFrames <= 0
             ? elapsedFrames : elapsedFrames % cycleFrames;
diff --git a/src/Shared/GalNet.Primitives.Builtins/VideoPrimitiveInstance.cs b/src/Shared/GalNet.Primitives.Builtins/VideoPrimitiveInstance.cs
index 365533a4..08070bee 100644
--- a/src/Shared/GalNet.Primitives.Builtins/VideoPrimitiveInstance.cs
+++ b/src/Shared/GalNet.Primitives.Builtins/VideoPrimitiveInstance.cs
@@ -1,14 +1,14 @@
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Runtime.Logging;
 
 namespace GalNet.Primitives.Builtins;
 
 public sealed class VideoPrimitiveInstance(
-    IGameRuntime runtime,
+    IGameContext runtime,
     IVideoPresenter? presenter,
     VideoRenderRequest request,
     bool blocking,
@@ -45,8 +45,8 @@ protected override void OnPlaybackModeChanged(PrimitiveInvocationMode mode)
         var owned = false;
         runtime.State.Update(() =>
         {
-            owned = runtime.SceneInstances.TryGet<Layer>(request.Layer.HandleId, out var layer) && ReferenceEquals(layer, _layer);
-            if (owned && blocking) runtime.SceneInstances.Remove<Layer>(request.Layer.HandleId, out _);
+            owned = runtime.Scene().TryGet<Layer>(request.Layer.HandleId, out var layer) && ReferenceEquals(layer, _layer);
+            if (owned && blocking) runtime.Scene().Remove<Layer>(request.Layer.HandleId, out _);
         });
         if (owned) presenter?.StopVideo(request.Layer.HandleId);
         TryComplete();
@@ -81,9 +81,9 @@ private async Task ObserveAsync()
         {
             runtime.State.Update(() =>
             {
-                if (!_catchUpDetached && runtime.SceneInstances.TryGet<Layer>(request.Layer.HandleId, out var layer) &&
+                if (!_catchUpDetached && runtime.Scene().TryGet<Layer>(request.Layer.HandleId, out var layer) &&
                     ReferenceEquals(layer, _layer))
-                    runtime.SceneInstances.Remove<Layer>(request.Layer.HandleId, out _);
+                    runtime.Scene().Remove<Layer>(request.Layer.HandleId, out _);
             });
             TryComplete();
         }
diff --git a/src/Shared/GalNet.Primitives.Builtins/packages.lock.WindowsReadyToRun.json b/src/Shared/GalNet.Primitives.Builtins/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..f66ae590
--- /dev/null
+++ b/src/Shared/GalNet.Primitives.Builtins/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,52 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Serilog": {
+        "type": "CentralTransitive",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Shared/GalNet.Primitives.Builtins/packages.lock.json b/src/Shared/GalNet.Primitives.Builtins/packages.lock.json
index cd94892b..7f4bf12f 100644
--- a/src/Shared/GalNet.Primitives.Builtins/packages.lock.json
+++ b/src/Shared/GalNet.Primitives.Builtins/packages.lock.json
@@ -19,6 +19,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -27,7 +28,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/src/Shared/GalNet.Runtime/Audio/AudioRuntime.cs b/src/Shared/GalNet.Runtime/Audio/AudioRuntime.cs
deleted file mode 100644
index 749be439..00000000
--- a/src/Shared/GalNet.Runtime/Audio/AudioRuntime.cs
+++ /dev/null
@@ -1,374 +0,0 @@
-using GalNet.Core.Audio;
-using GalNet.Core.Runtime;
-using GalNet.Core.Settings;
-using GalNet.Presentation.Abstractions.Audio;
-
-namespace GalNet.Runtime.Audio;
-
-/// <summary>Projects canonical audio state to backend voices. Only tickets and backend identities live here.</summary>
-public sealed class AudioRuntime : IDisposable, IAsyncDisposable
-{
-    private readonly object _gate = new();
-    private readonly IAudioPlaybackHost? _host;
-    private readonly ISEffectCatalog _effects;
-    private readonly AudioBackendDispatcher _dispatcher;
-    private readonly Dictionary<string, TrackBinding> _tracks = new(StringComparer.Ordinal);
-    private readonly Dictionary<string, VoiceBinding> _voices = new(StringComparer.Ordinal);
-    private readonly Dictionary<string, List<AudioPlaybackTicket>> _tickets = new(StringComparer.Ordinal);
-    private GameState _state;
-    private long _nextGeneration;
-    private GameSettings _settings = new();
-    private bool _disposed;
-    private bool _catchUp;
-    public event Action<string>? Diagnostic;
-
-    public AudioRuntime(IAudioPlaybackHost? host = null, ISEffectCatalog? effects = null)
-    {
-        _host = host;
-        _effects = effects ?? host?.SEffects ?? SEffectCatalog.Builtins;
-        var builder = new StateCatalogBuilder();
-        builder.Register<AudioTrackState>("builtin.audio.tracks", value => value.Id, ValidateTrack);
-        builder.Register<AudioSEffectState>("builtin.audio.seffects", value => AudioSEffectState.Key(value.TrackId, value.InstanceId), ValidateEffect);
-        _state = new GameState(builder.Build());
-        _dispatcher = new(host, _gate, Report, OnBackendEvent);
-        if (host is not null) host.EventReceived += OnBackendEvent;
-    }
-
-    public void Bind(GameState state)
-    {
-        lock (_gate)
-        {
-            if (ReferenceEquals(state, _state)) return;
-            StopBindings();
-            _state = state;
-            _tracks.Clear();
-        }
-    }
-    public async Task SuspendAsync(GameState expected)
-    {
-        lock (_gate)
-        {
-            if (!ReferenceEquals(_state, expected)) return;
-            StopBindings();
-        }
-        await _dispatcher.DrainAsync().ConfigureAwait(false);
-    }
-    public void Reset(GameState? expected = null)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            if (_disposed || expected is not null && !ReferenceEquals(expected, _state)) return;
-            StopBindings();
-            _state.Table<AudioTrackState>().Clear();
-            _state.Table<AudioSEffectState>().Clear();
-            _tracks.Clear();
-            _catchUp = false;
-        }
-    }
-    public void Validate(GameState state, IReadOnlyList<AudioTrackDefinition> definitions)
-    {
-        var identities = new HashSet<string>(StringComparer.Ordinal);
-        foreach (var track in state.Table<AudioTrackState>().Values)
-        {
-            ValidateTrack(track);
-            if (track.Active.Concat(track.Pending).Any(item => !identities.Add(item.Id)))
-                throw new InvalidDataException("Saved audio item identities must be unique across tracks.");
-            var definition = definitions.SingleOrDefault(item => item.Id == track.Id)
-                ?? throw new InvalidDataException($"Unknown saved audio track '{track.Id}'.");
-            if (!ValidDefinition(definition) || track.Active.Count > definition.MaxVoices || track.Pending.Count > definition.MaxQueuedItems)
-                throw new InvalidDataException($"Saved audio track '{track.Id}' exceeds its configured limits.");
-        }
-        foreach (var effect in state.Table<AudioSEffectState>().Values)
-        {
-            ValidateEffect(effect);
-            if (!state.Table<AudioTrackState>().TryGet(effect.TrackId, out _)) throw new InvalidDataException("An audio effect references a missing track.");
-        }
-    }
-    public static void ValidateTrack(AudioTrackState track)
-    {
-        if (string.IsNullOrWhiteSpace(track.Id) || track.Active is null || track.Pending is null)
-            throw new InvalidDataException("An audio track requires an ID and playback collections.");
-        var ids = new HashSet<string>(StringComparer.Ordinal);
-        foreach (var item in track.Active.Concat(track.Pending))
-            if (item is null || item.Request is null || string.IsNullOrWhiteSpace(item.Id) || !ids.Add(item.Id) || item.Request.TrackId != track.Id ||
-                string.IsNullOrWhiteSpace(item.Request.AssetId) || !float.IsFinite(item.Request.Gain) || item.Request.Gain < 0 ||
-                !float.IsFinite(item.Request.FadeInSeconds) || item.Request.FadeInSeconds < 0)
-                throw new InvalidDataException($"Invalid playback item in track '{track.Id}'.");
-    }
-    private void ValidateEffect(AudioSEffectState effect)
-    {
-        if (string.IsNullOrWhiteSpace(effect.TrackId) || string.IsNullOrWhiteSpace(effect.InstanceId)) throw new InvalidDataException("An audio effect requires track and instance IDs.");
-        var diagnostics = _effects.Validate(effect.SEffectId, SEffectScope.Track, effect.Parameters);
-        if (diagnostics.Count > 0) throw new InvalidDataException(string.Join(" ", diagnostics));
-    }
-    public async Task RestoreAsync(GameState state, IReadOnlyList<AudioTrackDefinition> definitions, CancellationToken token)
-    {
-        Validate(state, definitions);
-        Bind(state);
-        lock (_gate) StopBindings();
-        await _dispatcher.DrainAsync().WaitAsync(token).ConfigureAwait(false);
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            token.ThrowIfCancellationRequested();
-            if (!ReferenceEquals(_state, state)) throw new OperationCanceledException("The audio run was replaced.", token);
-            foreach (var saved in _state.Table<AudioTrackState>().Values)
-            {
-                var track = GetTrack(definitions, saved.Id)!;
-                foreach (var item in saved.Active.ToArray()) Project(track, item, fade: 0);
-            }
-        }
-    }
-    public void BeginCatchUp()
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            if (_catchUp || _disposed) return;
-            StopBindings();
-            _catchUp = true;
-            // CatchUp suppresses one-shot sounds while preserving its existing BGM projection policy.
-            foreach (var track in _tracks.Values.Where(track => track.Definition.Bus != AudioBuses.Bgm))
-            { track.State.Active.Clear(); track.State.Pending.Clear(); }
-        }
-    }
-    public void EndCatchUp()
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            if (!_catchUp || _disposed) return;
-            _catchUp = false;
-            foreach (var track in _tracks.Values)
-                foreach (var item in track.State.Active.ToArray()) Project(track, item, 0);
-        }
-    }
-    public void ApplyPlayerSettings(GameSettings settings)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            _settings = settings;
-            foreach (var track in _tracks.Values)
-                foreach (var item in track.State.Active.ToArray()) SendItem(track, item, AudioBackendAction.SetGain);
-        }
-    }
-    public AudioPlaybackTicket Play(IReadOnlyList<AudioTrackDefinition> definitions, AudioPlayRequest request)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            var ticket = new AudioPlaybackTicket(StopTicket);
-            var track = GetTrack(definitions, request.TrackId);
-            if (track is null || string.IsNullOrWhiteSpace(request.AssetId) || _catchUp && track.Definition.Bus != AudioBuses.Bgm)
-            { ticket.Complete(); return ticket; }
-            if (request.Placement == AudioPlacement.ReplaceIfDifferent)
-            {
-                var same = track.State.Active.Where(item => item.Request.AssetId == request.AssetId).ToArray();
-                if (same.Length > 0)
-                {
-                    foreach (var item in same) { item.Request = item.Request with { Gain = request.Gain }; SendItem(track, item, AudioBackendAction.SetGain); }
-                    if (_host is not null) Tickets(same[0].Id).Add(ticket);
-                    if (_host is null) ticket.Complete();
-                    return ticket;
-                }
-            }
-            var value = new AudioItemState { Request = request };
-            if (_host is not null) Tickets(value.Id).Add(ticket);
-            switch (request.Placement)
-            {
-                case AudioPlacement.Replace:
-                case AudioPlacement.ReplaceAll:
-                case AudioPlacement.ReplaceIfDifferent:
-                    StopActive(track, 0);
-                    if (request.Placement == AudioPlacement.ReplaceAll) ClearPending(track);
-                    Start(track, value); break;
-                case AudioPlacement.Next:
-                    if (track.Definition.MaxVoices != 1) { Report("audio.next requires a single-voice track."); Complete(value); break; }
-                    StopActive(track, 0); QueueOrStart(track, value, true); Pump(track); break;
-                default: QueueOrStart(track, value, false); break;
-            }
-            if (_host is null) ticket.Complete();
-            return ticket;
-        }
-    }
-    public void Stop(IReadOnlyList<AudioTrackDefinition> definitions, AudioStopRequest request)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            var track = GetTrack(definitions, request.TrackId); if (track is null) return;
-            StopActive(track, request.FadeOutSeconds); if (request.ClearQueue) ClearPending(track);
-        }
-    }
-    public void Pause(IReadOnlyList<AudioTrackDefinition> definitions, string trackId) => SetPaused(definitions, trackId, true);
-    public void Resume(IReadOnlyList<AudioTrackDefinition> definitions, string trackId) => SetPaused(definitions, trackId, false);
-    private void SetPaused(IReadOnlyList<AudioTrackDefinition> definitions, string trackId, bool paused)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            var track = GetTrack(definitions, trackId); if (track is null) return;
-            track.State.Paused = paused;
-            foreach (var item in track.State.Active.ToArray())
-                if (!paused && !_voices.ContainsKey(item.Id)) Project(track, item, 0);
-                else SendItem(track, item, paused ? AudioBackendAction.Pause : AudioBackendAction.Resume);
-            if (!paused) Pump(track);
-        }
-    }
-    public void Next(IReadOnlyList<AudioTrackDefinition> definitions, string trackId)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            var track = GetTrack(definitions, trackId); if (track is null) return;
-            if (track.Definition.MaxVoices != 1) { Report("audio.next requires a single-voice track."); return; }
-            StopActive(track, 0); Pump(track);
-        }
-    }
-    public void Clear(IReadOnlyList<AudioTrackDefinition> definitions, string trackId)
-    { lock (_gate) lock (_state.SyncRoot) { var track = GetTrack(definitions, trackId); if (track is not null) ClearPending(track); } }
-    public void ApplySEffect(IReadOnlyList<AudioTrackDefinition> definitions, AudioSEffectRequest request)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            var track = GetTrack(definitions, request.TrackId); if (track is null) return;
-            var effect = new AudioSEffectState(request.TrackId, request.InstanceId, request.SEffectId, request.Parameters.Clone());
-            try { ValidateEffect(effect); } catch (InvalidDataException error) { Report(error.Message); return; }
-            _state.Table<AudioSEffectState>().Set(effect);
-            foreach (var item in track.State.Active.ToArray()) SendEffect(track, item, effect, AudioBackendAction.ApplySEffect);
-        }
-    }
-    public void StopSEffect(IReadOnlyList<AudioTrackDefinition> definitions, string trackId, string instanceId)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            var track = GetTrack(definitions, trackId); if (track is null) return;
-            var table = _state.Table<AudioSEffectState>();
-            var key = AudioSEffectState.Key(trackId, instanceId);
-            if (!table.TryGet(key, out var effect)) return;
-            table.Remove(key);
-            foreach (var item in track.State.Active.ToArray()) SendEffect(track, item, effect, AudioBackendAction.StopSEffect);
-        }
-    }
-    private TrackBinding? GetTrack(IReadOnlyList<AudioTrackDefinition> definitions, string id)
-    {
-        if (_disposed) return null;
-        if (_tracks.TryGetValue(id, out var cached)) return cached;
-        var definition = definitions.FirstOrDefault(value => value.Id == id);
-        if (definition is null || !ValidDefinition(definition))
-        { Report($"Unknown or invalid audio track '{id}'."); return null; }
-        var table = _state.Table<AudioTrackState>();
-        if (!table.TryGet(id, out var data)) { data = new AudioTrackState { Id = id }; table.Add(data); }
-        var track = new TrackBinding(definition, data); _tracks.Add(id, track); return track;
-    }
-    private void QueueOrStart(TrackBinding track, AudioItemState item, bool priority)
-    {
-        if (track.State.Active.Count < track.Definition.MaxVoices) { Start(track, item); return; }
-        if (track.Definition.MaxQueuedItems == 0)
-        {
-            if (track.Definition.OverflowPolicy == AudioOverflowPolicy.DropNewest) { Report("Audio voice limit reached."); Complete(item); return; }
-            StopVoice(track, track.State.Active[0], 0); Start(track, item); return;
-        }
-        if (track.State.Pending.Count >= track.Definition.MaxQueuedItems)
-        {
-            if (track.Definition.QueueOverflowPolicy == AudioQueueOverflowPolicy.DropNewest) { Report("Audio queue limit reached."); Complete(item); return; }
-            Complete(track.State.Pending[0]); track.State.Pending.RemoveAt(0);
-        }
-        if (priority) track.State.Pending.Insert(0, item); else track.State.Pending.Add(item);
-    }
-    private void Start(TrackBinding track, AudioItemState item) { track.State.Active.Add(item); Project(track, item, item.Request.FadeInSeconds); }
-    private void Pump(TrackBinding track)
-    {
-        while (!track.State.Paused && track.State.Active.Count < track.Definition.MaxVoices && track.State.Pending.Count > 0)
-        { var item = track.State.Pending[0]; track.State.Pending.RemoveAt(0); Start(track, item); }
-    }
-    private void Project(TrackBinding track, AudioItemState item, float fade)
-    {
-        if (_catchUp || track.State.Paused || _host is null) return;
-        var generation = ++_nextGeneration;
-        var binding = new VoiceBinding(track.State.Id, $"{track.Definition.Id}:{generation}", generation);
-        _voices[item.Id] = binding;
-        _dispatcher.Enqueue(new(AudioBackendAction.Start, track.Definition.Id, binding.Id, generation, item.Request.AssetId, Gain(track, item), fade));
-        foreach (var effect in _state.Table<AudioSEffectState>().Values.Where(value => value.TrackId == track.State.Id))
-            SendEffect(track, item, effect, AudioBackendAction.ApplySEffect);
-    }
-    private void SendItem(TrackBinding track, AudioItemState item, AudioBackendAction action, float fade = 0)
-    {
-        if (!_catchUp && _voices.TryGetValue(item.Id, out var binding))
-            _dispatcher.Enqueue(new(action, track.State.Id, binding.Id, binding.Generation, Gain: Gain(track, item), FadeSeconds: fade));
-    }
-    private void SendEffect(TrackBinding track, AudioItemState item, AudioSEffectState effect, AudioBackendAction action)
-    {
-        if (!_catchUp && _voices.TryGetValue(item.Id, out var binding))
-            _dispatcher.Enqueue(new(action, track.State.Id, binding.Id, binding.Generation, SEffectId: effect.SEffectId,
-                SEffectInstanceId: effect.InstanceId, SEffectParameters: effect.Parameters));
-    }
-    private float Gain(TrackBinding track, AudioItemState item)
-    {
-        var (volume, muted) = track.Definition.Bus switch
-        {
-            AudioBuses.Bgm => (_settings.BgmVolume, _settings.BgmMuted),
-            AudioBuses.Vocal => (_settings.VoiceVolume, _settings.VoiceMuted),
-            _ => (_settings.SfxVolume, _settings.SfxMuted)
-        };
-        if (_settings.MasterMuted || muted) return 0;
-        var gain = track.Definition.DefaultGain * item.Request.Gain * volume * _settings.MasterVolume;
-        return float.IsFinite(gain) ? Math.Clamp(gain, 0, 1) : 0;
-    }
-    private List<AudioPlaybackTicket> Tickets(string id)
-    { if (!_tickets.TryGetValue(id, out var tickets)) _tickets[id] = tickets = []; return tickets; }
-    private void Complete(AudioItemState item)
-    { if (_tickets.Remove(item.Id, out var tickets)) foreach (var ticket in tickets) ticket.Complete(); }
-    private void StopVoice(TrackBinding track, AudioItemState item, float fade)
-    {
-        track.State.Active.Remove(item); SendItem(track, item, AudioBackendAction.Stop, Math.Max(0, fade));
-        _voices.Remove(item.Id); Complete(item);
-    }
-    private void StopActive(TrackBinding track, float fade) { foreach (var item in track.State.Active.ToArray()) StopVoice(track, item, fade); }
-    private void ClearPending(TrackBinding track) { foreach (var item in track.State.Pending) Complete(item); track.State.Pending.Clear(); }
-    private void StopBindings()
-    {
-        var bindings = _voices.Values.ToArray();
-        _voices.Clear();
-        var pendingTickets = _tickets.Values.SelectMany(tickets => tickets).ToArray();
-        _tickets.Clear();
-        // Some hosts report an end synchronously from Stop. Invalidate identities before calling them.
-        foreach (var binding in bindings)
-            _dispatcher.Enqueue(new(AudioBackendAction.Stop, binding.TrackId, binding.Id, binding.Generation));
-        foreach (var ticket in pendingTickets) ticket.Complete();
-    }
-    private void OnBackendEvent(AudioBackendEvent value)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            if (_disposed || value.Kind is not (AudioBackendEventKind.Ended or AudioBackendEventKind.Failed) || !_tracks.TryGetValue(value.TrackId, out var track)) return;
-            var item = track.State.Active.FirstOrDefault(item => _voices.TryGetValue(item.Id, out var voice) && voice.Id == value.VoiceId && voice.Generation == value.Generation);
-            if (item is null) return;
-            track.State.Active.Remove(item); _voices.Remove(item.Id); _dispatcher.CompleteVoice(value.VoiceId);
-            if (value.Kind == AudioBackendEventKind.Failed) Report(value.Message ?? $"Audio backend failed for '{item.Request.AssetId}'.");
-            Pump(track);
-            Complete(item);
-        }
-    }
-    private void StopTicket(AudioPlaybackTicket ticket)
-    {
-        lock (_gate) lock (_state.SyncRoot)
-        {
-            foreach (var track in _tracks.Values)
-            {
-                foreach (var item in track.State.Pending.Where(item => Tickets(item.Id).Contains(ticket)).ToArray())
-                { track.State.Pending.Remove(item); Complete(item); }
-                foreach (var item in track.State.Active.Where(item => Tickets(item.Id).Contains(ticket)).ToArray()) StopVoice(track, item, 0);
-                Pump(track);
-            }
-            ticket.Complete();
-        }
-    }
-    public void Dispose()
-    {
-        lock (_gate)
-        {
-            if (_disposed) return; _disposed = true;
-            StopBindings(); if (_host is not null) _host.EventReceived -= OnBackendEvent;
-        }
-    }
-    public async ValueTask DisposeAsync() { Dispose(); await _dispatcher.DrainAsync().ConfigureAwait(false); }
-    private void Report(string message) => Diagnostic?.Invoke(message);
-    private static bool ValidDefinition(AudioTrackDefinition value) => AudioBuses.IsValid(value.Bus) && value.MaxVoices > 0 &&
-        value.MaxQueuedItems >= 0 && float.IsFinite(value.DefaultGain);
-    private sealed record TrackBinding(AudioTrackDefinition Definition, AudioTrackState State);
-    private sealed record VoiceBinding(string TrackId, string Id, long Generation);
-}
diff --git a/src/Shared/GalNet.Runtime/Content/GameLocalizationContent.cs b/src/Shared/GalNet.Runtime/Content/GameLocalizationContent.cs
deleted file mode 100644
index 40866a7d..00000000
--- a/src/Shared/GalNet.Runtime/Content/GameLocalizationContent.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-using GalNet.Core.I18n;
-
-namespace GalNet.Runtime.Content;
-
-/// <summary>Host-ready text sources and language-independent character metadata.</summary>
-public sealed class GameLocalizationContent
-{
-    public CharacterCatalog Characters { get; init; } = CharacterCatalog.Empty;
-    public IReadOnlyList<GameLocalizationSource> Sources { get; init; } = [];
-    public IReadOnlyList<GameLocalizationSource> ExternalSources { get; init; } = [];
-    public IReadOnlyList<GameLocalizationDiagnostic> Diagnostics { get; init; } = [];
-}
-
-/// <summary>One source document; hosts load each document into their localization provider in order.</summary>
-public sealed record GameLocalizationSource(string Culture, string RelativePath, string Json);
-
-public sealed record GameLocalizationDiagnostic(string RelativePath, string Message);
diff --git a/src/Shared/GalNet.Runtime/Engine/ActivePrimitiveRegistry.cs b/src/Shared/GalNet.Runtime/Engine/ActivePrimitiveRegistry.cs
index e70b3571..13f46fe5 100644
--- a/src/Shared/GalNet.Runtime/Engine/ActivePrimitiveRegistry.cs
+++ b/src/Shared/GalNet.Runtime/Engine/ActivePrimitiveRegistry.cs
@@ -11,11 +11,10 @@ internal sealed class ActivePrimitiveRegistry(Action<PrimitiveInstance> complete
     private readonly Action<PrimitiveInstance> _autoChanged = autoChanged;
     private string? _groupId;
     private long _groupExecutionId;
-    private long _nextSequence;
 
     public ActivePrimitive Track(PrimitiveInstance instance, string groupId, string stableId, bool wasRead, bool isReading)
     {
-        var active = new ActivePrimitive(_groupExecutionId, ++_nextSequence, instance, groupId, stableId, wasRead, isReading);
+        var active = new ActivePrimitive(_groupExecutionId, instance, groupId, stableId, wasRead, isReading);
         _items.Add(active);
         instance.Completed += _completed;
         instance.AutoBlockingChanged += _autoChanged;
@@ -35,7 +34,7 @@ public IEnumerable<ActivePrimitive> SkipCandidates(ActivePrimitive blocker)
             yield break;
         }
 
-        foreach (var item in _items.OrderBy(item => item.Sequence))
+        foreach (var item in _items)
             if (item.GroupExecutionId == blocker.GroupExecutionId &&
                 string.Equals(item.Instance.BatchId, blocker.Instance.BatchId, StringComparison.Ordinal) &&
                 !item.Instance.IsCompleted && item.Instance.IsSkippable)
@@ -44,13 +43,12 @@ public IEnumerable<ActivePrimitive> SkipCandidates(ActivePrimitive blocker)
 
     public ActivePrimitive? EarliestBlocker() => _items
         .Where(item => item.Instance.IsBlocking && !item.Instance.IsCompleted)
-        .OrderBy(item => item.Sequence)
         .FirstOrDefault();
 
     public bool HasBlockingInstance() => _items.Any(item =>
         item.Instance.IsBlocking && !item.Instance.IsCompleted);
 
-    public void RemoveCompleted(Action<ActivePrimitive> reconcile, Action<PrimitiveInstance> removed)
+    public void RemoveCompleted(Action<ActivePrimitive> reconcile)
     {
         for (var index = _items.Count - 1; index >= 0; index--)
         {
@@ -64,7 +62,6 @@ public void RemoveCompleted(Action<ActivePrimitive> reconcile, Action<PrimitiveI
                 item.Instance.PresentationCompletion.GetAwaiter().GetResult();
             item.Instance.Completed -= _completed;
             item.Instance.AutoBlockingChanged -= _autoChanged;
-            removed(item.Instance);
             _items.RemoveAt(index);
         }
     }
@@ -92,7 +89,6 @@ public bool BeginGroupExecution(string groupId)
 
 internal sealed record ActivePrimitive(
         long GroupExecutionId,
-        long Sequence,
         PrimitiveInstance Instance,
         string GroupId,
         string StableId,
diff --git a/src/Shared/GalNet.Runtime/Engine/EngineNotifications.cs b/src/Shared/GalNet.Runtime/Engine/EngineNotifications.cs
new file mode 100644
index 00000000..3510aa1f
--- /dev/null
+++ b/src/Shared/GalNet.Runtime/Engine/EngineNotifications.cs
@@ -0,0 +1,51 @@
+using GalNet.Core.Primitives;
+using GalNet.Core.Runtime;
+using GalNet.Runtime.Logging;
+
+namespace GalNet.Runtime.Engine;
+
+/// <summary>One ordered, reentrancy-safe notification queue, published outside the execution gate.</summary>
+internal sealed class EngineNotifications
+{
+    private readonly object _sync = new();
+    private readonly Queue<Action> _pending = new();
+    private bool _publishing;
+    public event Action<GameEngineStateChange>? StateChanged;
+    public event Action<PlaybackMode>? PlaybackChanged;
+    public event Action<GameSnapshot>? CheckpointCreated;
+
+    public void State(GameEngineStateChange value) => Enqueue(StateChanged, value);
+    public void Playback(PlaybackMode value) => Enqueue(PlaybackChanged, value);
+    public void Checkpoint(GameSnapshot value) => Enqueue(CheckpointCreated, value, SnapshotCopy.Clone);
+
+    private void Enqueue<T>(Action<T>? handlers, T value, Func<T, T>? copy = null)
+    {
+        if (handlers is null) return;
+        lock (_sync) _pending.Enqueue(() =>
+        {
+            foreach (var handler in handlers.GetInvocationList())
+                try { ((Action<T>)handler)(copy is null ? value : copy(value)); }
+                catch (Exception error)
+                {
+                    try { GameLog.Logger.Warning(error, "Game notification observer failed"); }
+                    catch (Exception) { /* Logging cannot strand the notification queue. */ }
+                }
+        });
+    }
+
+    public void Publish()
+    {
+        lock (_sync)
+        {
+            if (_publishing) return;
+            _publishing = true;
+        }
+        while (true)
+        {
+            Action publish;
+            lock (_sync)
+                if (!_pending.TryDequeue(out publish!)) { _publishing = false; return; }
+            publish();
+        }
+    }
+}
diff --git a/src/Shared/GalNet.Runtime/Engine/GameEngine.CatchUp.cs b/src/Shared/GalNet.Runtime/Engine/GameEngine.CatchUp.cs
index d7fb13e0..6efc870a 100644
--- a/src/Shared/GalNet.Runtime/Engine/GameEngine.CatchUp.cs
+++ b/src/Shared/GalNet.Runtime/Engine/GameEngine.CatchUp.cs
@@ -81,7 +81,7 @@ private async Task CatchUpCoreAsync(CancellationTokenSource cancellation)
         var token = cancellation.Token;
         var beganPresentation = false;
         Exception? failure = null;
-        IGameRuntime? scopedRuntime = null;
+        IGameContext? scopedRuntime = null;
         try
         {
             await _dispatchGate.WaitAsync(token).ConfigureAwait(false);
@@ -125,12 +125,12 @@ await Task.WhenAll(entering.Select(item => item.Instance.PresentationCompletion)
                     RemoveCompleted();
                     if (!_catchUpActive || !IsRunning || _pendingChoice is not null) break;
                     _catchUpBudget = 128;
-                    ContinueUntilBlocked();
+                    await ContinueUntilBlockedAsync(token).ConfigureAwait(false);
                     ThrowFlowError();
                     if (!_catchUpActive || !IsRunning || _pendingChoice is not null) break;
                     waiting = _active.HasBlockingInstance();
                 }
-                finally { CaptureStateChange(); _dispatchGate.Release(); PublishStateChanges(); }
+                finally { FinishDispatch(); }
                 if (waiting) await _catchUpSignal.WaitAsync(token).ConfigureAwait(false);
                 else await Task.Yield();
             }
@@ -152,7 +152,7 @@ await Task.WhenAll(entering.Select(item => item.Instance.PresentationCompletion)
                         await _catchUpPresentation.EndCatchUpAsync(scopedRuntime, _scopeCancellation.Token).ConfigureAwait(false);
                     if (resumeAtBoundary)
                     {
-                        ContinueUntilBlocked();
+                        await ContinueUntilBlockedAsync().ConfigureAwait(false);
                     }
                 }
             }
@@ -164,7 +164,7 @@ await Task.WhenAll(entering.Select(item => item.Instance.PresentationCompletion)
                     _flowError = failure;
                     IsRunning = false;
                 }
-                CaptureStateChange(); _dispatchGate.Release(); PublishStateChanges();
+                FinishDispatch();
             }
             lock (_lifecycleSync)
             {
diff --git a/src/Shared/GalNet.Runtime/Engine/GameEngine.DebugSeeking.cs b/src/Shared/GalNet.Runtime/Engine/GameEngine.DebugSeeking.cs
index 65b58825..5891ec65 100644
--- a/src/Shared/GalNet.Runtime/Engine/GameEngine.DebugSeeking.cs
+++ b/src/Shared/GalNet.Runtime/Engine/GameEngine.DebugSeeking.cs
@@ -12,7 +12,7 @@ public sealed class GameDebugOptions
     public long MaxEntrancePayloadBytes { get; init; } = 64L * 1024 * 1024;
     public int MaxEntranceGroups { get; init; } = 256;
     public IReadOnlyDictionary<string, DebugReplayBehavior> Instructions { get; init; } = new Dictionary<string, DebugReplayBehavior>();
-    public Func<IGameRuntime, CancellationToken, Task>? SynchronizePresentation { get; init; }
+    public Func<IGameContext, CancellationToken, Task>? SynchronizePresentation { get; init; }
 }
 public sealed record GameDebugRouteEdge(string From, int Outlet, string To);
 public sealed record GameDebugSeek(string GroupId, int EntryIndex, GameDebugRouteEdge[] Route, int? TargetEnd = null, bool InitialScene = false);
@@ -57,7 +57,7 @@ internal void CaptureEntrance(string group)
         private GameSnapshot CaptureScene()
         {
             var snapshot = _engine._runtime.CreateSnapshot();
-            return new GameSnapshot { NodeId = snapshot.NodeId, EntryIndex = snapshot.EntryIndex, States = snapshot.States };
+            return _engine.StampContent(new GameSnapshot { NodeId = snapshot.NodeId, EntryIndex = snapshot.EntryIndex, States = snapshot.States });
         }
         internal bool BeforeEntry(string group, int index)
         {
@@ -154,17 +154,18 @@ public async Task SeekAsync(long generation, GameDebugSeek target, CancellationT
                     Check(generation);
                     // Active transitions may commit their terminal scene while being
                     // compressed. A forward baseline must include that committed state.
-                    if (fromCurrent) baseline = _engine._runtime.CreateSnapshot();
-                    baseline = new GameSnapshot
+                    var current = _engine._runtime.CreateSnapshot();
+                    if (fromCurrent) baseline = current;
+                    baseline = _engine.StampContent(new GameSnapshot
                     {
                         NodeId = baseline.NodeId,
                         EntryIndex = baseline.EntryIndex,
                         States = baseline.States,
-                        Variables = _engine._runtime.CreateSnapshot().Variables
-                    };
+                        Variables = current.Variables
+                    });
                 }
                 finally { _engine._dispatchGate.Release(); }
-                ownedGeneration = _engine.RestoreFromCore(baseline, this, generation);
+                ownedGeneration = await _engine.RestoreFromCoreAsync(baseline, this, generation, cancellation.Token).ConfigureAwait(false);
                 changed = true;
 
                 await _engine._dispatchGate.WaitAsync(cancellation.Token).ConfigureAwait(false);
@@ -196,7 +197,7 @@ public async Task SeekAsync(long generation, GameDebugSeek target, CancellationT
                         if (budget-- == 0) throw new InvalidOperationException("Debug replay exceeded its execution budget.");
                         _engine._catchUpBudget = 128;
                         _engine.RemoveCompleted();
-                        _engine.ContinueUntilBlocked();
+                        await _engine.ContinueUntilBlockedAsync(cancellation.Token).ConfigureAwait(false);
                         _engine.ThrowFlowError();
                         if (Paused)
                         {
@@ -207,7 +208,7 @@ public async Task SeekAsync(long generation, GameDebugSeek target, CancellationT
                         if (!_engine.IsRunning) throw new InvalidOperationException("The debug route ended before the target.");
                         waiting = _engine._active.HasBlockingInstance();
                     }
-                    finally { _engine.CaptureStateChange(); _engine._dispatchGate.Release(); _engine.PublishStateChanges(); }
+                    finally { _engine.FinishDispatch(); }
                     if (waiting) await _engine._catchUpSignal.WaitAsync(cancellation.Token).ConfigureAwait(false);
                     else await Task.Yield();
                 }
@@ -257,9 +258,7 @@ public async Task SeekAsync(long generation, GameDebugSeek target, CancellationT
                 }
                 finally
                 {
-                    _engine.CaptureStateChange();
-                    _engine._dispatchGate.Release();
-                    _engine.PublishStateChanges();
+                    _engine.FinishDispatch();
                     _seekCancellation = null;
                     cancellation.Dispose();
                     completion.TrySetResult();
diff --git a/src/Shared/GalNet.Runtime/Engine/GameEngine.DebugStepping.cs b/src/Shared/GalNet.Runtime/Engine/GameEngine.DebugStepping.cs
index 0cf271e0..32b2fc9b 100644
--- a/src/Shared/GalNet.Runtime/Engine/GameEngine.DebugStepping.cs
+++ b/src/Shared/GalNet.Runtime/Engine/GameEngine.DebugStepping.cs
@@ -82,10 +82,11 @@ public async Task StepAsync(long generation, GameDebugSpan span, CancellationTok
                     foreach (var item in _engine._active.SkipCandidates(blocker).ToArray()) item.Instance.Skip();
                 _engine.RemoveCompleted();
                 _engine._advanceBoundary = false;
-                _engine.ContinueUntilBlocked();
+                await _engine.ContinueUntilBlockedAsync(token).ConfigureAwait(false);
                 _engine.ThrowFlowError();
                 _engine.UpdateLastStableSnapshot();
             }
+            catch (OperationCanceledException) when (token.IsCancellationRequested) { throw; }
             catch (Exception error) when (stepping)
             {
                 _engine._flowError = error;
@@ -96,9 +97,7 @@ public async Task StepAsync(long generation, GameDebugSpan span, CancellationTok
             {
                 if (stepping) Paused = true;
                 _stepBoundary = null;
-                _engine.CaptureStateChange();
-                _engine._dispatchGate.Release();
-                _engine.PublishStateChanges();
+                _engine.FinishDispatch();
             }
         }
     }
diff --git a/src/Shared/GalNet.Runtime/Engine/GameEngine.Debugging.cs b/src/Shared/GalNet.Runtime/Engine/GameEngine.Debugging.cs
index a25b0983..0b658296 100644
--- a/src/Shared/GalNet.Runtime/Engine/GameEngine.Debugging.cs
+++ b/src/Shared/GalNet.Runtime/Engine/GameEngine.Debugging.cs
@@ -16,6 +16,8 @@ public sealed record GameDebugState(long Generation, GameEngineState State, bool
 
 public sealed partial class GameEngine
 {
+    /// <summary>True while debugger reconstruction suppresses player-facing reading side effects.</summary>
+    public bool IsDebugReplaying => _debugger?.SuppressReadProgress == true;
     private DebugSession? _debugger;
 
     /// <summary>Explicit opt-in. The caller owns the binding; no network or platform services are created.</summary>
@@ -63,16 +65,16 @@ public async Task<GameDebugState> InspectAsync(CancellationToken cancellationTok
                     _engine._runtime.GetVariables(scope).Values.Select(variable =>
                         new GameDebugVariable(scope, variable.Uid, variable.Name, variable.Type, variable.Value.Serialize()))).ToArray();
                 return new(Generation, _engine.State, Paused, _engine.CurrentNodeId, _engine.EntryIndex,
-                    _engine._active.Where(item => !item.Instance.IsCompleted).OrderBy(item => item.Sequence).Select(item => item.StableId).ToArray(), variables,
+                    _engine._active.Where(item => !item.Instance.IsCompleted).Select(item => item.StableId).ToArray(), variables,
                     _engine._navigation.Nodes.OfType<Group>().Select(group => new GameDebugGroup(group.Id,
                         group.Entries.OfType<GalNet.Core.Entry.PrimitiveEntry>().Select(entry => entry.StableId).ToArray())).ToArray(),
                     _entrances.Keys.ToArray(), _engine._flowError?.ToString(),
                     _engine._pendingChoice is { } choice ? new(choice.Id, choice.Options.Select(item => item.Text).ToArray()) : null,
-                    _engine._active.Where(item => !item.Instance.IsCompleted).OrderBy(item => item.Sequence)
+                    _engine._active.Where(item => !item.Instance.IsCompleted)
                         .Select(item => new GameDebugActiveEntry(item.GroupId, item.StableId)).ToArray(),
                     new(_entrances.Count, _cacheBytes, _options.MaxEntrancePayloadBytes, _options.MaxEntranceGroups), _lastReplay);
             }
-            finally { _engine._dispatchGate.Release(); }
+            finally { _engine._dispatchGate.Release(); _engine.PublishStateChanges(); }
         }
 
         public async Task SetVariableAsync(long generation, GameDebugVariable expected, string value, CancellationToken cancellationToken = default)
@@ -89,7 +91,7 @@ public async Task SetVariableAsync(long generation, GameDebugVariable expected,
                 _engine._runtime.SetVariable((expected.Scope == VariableScope.Player ? "player." : "save.") + expected.Name, parsed);
                 _engine.UpdateLastStableSnapshot();
             }
-            finally { _engine._dispatchGate.Release(); }
+            finally { _engine._dispatchGate.Release(); _engine.PublishStateChanges(); }
         }
 
         public async Task PauseAsync(long generation, CancellationToken cancellationToken = default)
@@ -125,7 +127,8 @@ public async Task ResumeAsync(long generation, CancellationToken cancellationTok
                     _engine._started = true;
                     _engine.IsRunning = true;
                 }
-                if (_engine.IsRunning && !_engine._restorationPending) _engine.ContinueUntilBlocked();
+                if (_engine.IsRunning && !_engine._restorationPending)
+                    await _engine.ContinueUntilBlockedAsync(cancellationToken).ConfigureAwait(false);
             }
             finally { _engine.CaptureStateChange(); _engine._dispatchGate.Release(); _engine.PublishStateChanges(); }
         }
@@ -141,7 +144,7 @@ public async Task ChooseAsync(long generation, string choiceId, int visibleIndex
                 if (pending.Id != choiceId) throw new InvalidOperationException("The choice has changed.");
                 if ((uint)visibleIndex >= pending.Options.Count) throw new ArgumentOutOfRangeException(nameof(visibleIndex));
             }
-            finally { _engine._dispatchGate.Release(); }
+            finally { _engine._dispatchGate.Release(); _engine.PublishStateChanges(); }
             pending.Cancellation.Cancel();
             await _engine.CompleteChoiceAsync(pending, Task.FromResult(visibleIndex)).ConfigureAwait(false);
         }
@@ -172,7 +175,7 @@ public void Dispose()
                 _disposed = true;
                 if (ReferenceEquals(_engine._debugger, this)) _engine._debugger = null;
             }
-            finally { _engine._dispatchGate.Release(); }
+            finally { _engine._dispatchGate.Release(); _engine.PublishStateChanges(); }
         }
     }
 }
diff --git a/src/Shared/GalNet.Runtime/Engine/GameEngine.Playback.cs b/src/Shared/GalNet.Runtime/Engine/GameEngine.Playback.cs
index e8ce2c08..6915fd8c 100644
--- a/src/Shared/GalNet.Runtime/Engine/GameEngine.Playback.cs
+++ b/src/Shared/GalNet.Runtime/Engine/GameEngine.Playback.cs
@@ -1,22 +1,22 @@
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
-using GalNet.Core.Settings;
 using GalNet.Runtime.Logging;
 
 namespace GalNet.Runtime.Engine;
 
 public sealed partial class GameEngine
 {
-    private readonly HashSet<PrimitiveInstance> _autoBlockers = new(ReferenceEqualityComparer.Instance);
-    private readonly Queue<PlaybackMode> _playbackChanges = new();
     private PlaybackMode _playbackMode;
+    private PlaybackOptions _playbackOptions;
     private bool _advanceBoundary;
+    private bool _readingPreamble;
     private long _playbackRevision;
     private CancellationTokenSource? _playbackTimer;
 
     public PlaybackMode PlaybackMode => _playbackMode;
-    public event Action<PlaybackMode>? PlaybackModeChanged;
+    public event Action<PlaybackMode>? PlaybackModeChanged { add => _notifications.PlaybackChanged += value; remove => _notifications.PlaybackChanged -= value; }
 
     /// <summary>Immediately invalidates a pending advance; the following mode request updates state.</summary>
     public void CancelPlayback()
@@ -38,6 +38,7 @@ public async Task SetPlaybackModeAsync(PlaybackMode mode, CancellationToken canc
             if (_debugger?.Paused == true) mode = PlaybackMode.Manual;
             if (!IsRunning || _pendingChoice is not null) mode = PlaybackMode.Manual;
             if (mode == PlaybackMode.Quick && IsQuickBlockedByUnreadText()) mode = PlaybackMode.Manual;
+            if (mode != PlaybackMode.Manual) _view.OnPlaybackContinuing();
             SetPlaybackModeCore(mode);
             foreach (var item in _active.ToArray())
                 item.Instance.ApplyPlaybackMode(mode == PlaybackMode.Quick
@@ -52,11 +53,15 @@ public async Task SetPlaybackModeAsync(PlaybackMode mode, CancellationToken canc
         }
     }
 
-    public async Task RefreshPlaybackSettingsAsync(CancellationToken cancellationToken = default)
+    public async Task UpdatePlaybackOptionsAsync(PlaybackOptions options, CancellationToken cancellationToken = default)
     {
+        ThrowIfDisposed();
+        ArgumentNullException.ThrowIfNull(options);
+        options.Validate();
         await _dispatchGate.WaitAsync(cancellationToken).ConfigureAwait(false);
         try
         {
+            _playbackOptions = options;
             CancelPlaybackTimer();
             if (_playbackMode == PlaybackMode.Quick && IsQuickBlockedByUnreadText()) SetPlaybackModeCore(PlaybackMode.Manual);
             ReconcilePlaybackTimer();
@@ -64,7 +69,7 @@ public async Task RefreshPlaybackSettingsAsync(CancellationToken cancellationTok
         finally { _dispatchGate.Release(); PublishStateChanges(); }
     }
 
-    private bool IsQuickBlockedByUnreadText() => _runtime.Settings.Get<GameSettings>().QuickReadOnly &&
+    private bool IsQuickBlockedByUnreadText() => _playbackOptions.QuickReadOnly &&
         _active.Any(item => item.IsReading && !item.WasRead);
 
     private void SetPlaybackModeCore(PlaybackMode mode)
@@ -72,7 +77,7 @@ private void SetPlaybackModeCore(PlaybackMode mode)
         if (_playbackMode == mode) return;
         CancelPlaybackTimer();
         _playbackMode = mode;
-        lock (_notificationSync) _playbackChanges.Enqueue(mode);
+        _notifications.Playback(mode);
     }
 
     private void CheckReadingBoundary(Group group, PrimitiveEntry entry)
@@ -86,14 +91,14 @@ private void CheckReadingBoundary(Group group, PrimitiveEntry entry)
             _catchUpStopAtBoundary = true;
         }
         if (readingId is not null && _playbackMode == PlaybackMode.Quick &&
-            _runtime.Settings.Get<GameSettings>().QuickReadOnly && _progress?.IsRead(group.Id, readingId) != true)
+            _playbackOptions.QuickReadOnly && _progress?.IsRead(group.Id, readingId) != true)
             SetPlaybackModeCore(PlaybackMode.Manual);
+        if (!_catchUpStopAtBoundary && entry.ReadingBoundaryId is { } target && target != entry.StableId)
+            _readingPreamble = true;
     }
 
     private void ReconcileAutoBlocker(ActivePrimitive item)
     {
-        if (item.Instance.IsAutoBlocking) _autoBlockers.Add(item.Instance);
-        else _autoBlockers.Remove(item.Instance);
         if (_debugger?.SuppressReadProgress != true && !item.ReadMarked && item.IsReading && item.Instance is IAdvanceWaitInstance { IsTextPresented: true })
         {
             if (string.IsNullOrWhiteSpace(item.StableId))
@@ -114,12 +119,12 @@ private void OnAutoBlockingChanged(PrimitiveInstance instance) => StartBackgroun
             ReconcilePlaybackTimer();
         }
         catch (Exception exception) { _flowError = exception; IsRunning = false; }
-        finally { CaptureStateChange(); _dispatchGate.Release(); PublishStateChanges(); }
+        finally { FinishDispatch(); }
     });
 
     private bool CanSchedulePlayback() => _debugger?.Paused != true && _playbackMode != PlaybackMode.Manual && _advanceBoundary && IsRunning &&
         _pendingChoice is null && !_disposed && Volatile.Read(ref _stopRequested) == 0 &&
-        _autoBlockers.Count == 0 && _active.All(item => !item.Instance.IsBlocking || item.Instance.IsCompleted ||
+        !_active.Any(item => item.Instance.IsAutoBlocking) && _active.All(item => !item.Instance.IsBlocking || item.Instance.IsCompleted ||
             item.Instance is IAdvanceWaitInstance { IsWaitingForAdvance: true });
 
     private void ReconcilePlaybackTimer()
@@ -127,9 +132,7 @@ private void ReconcilePlaybackTimer()
         foreach (var item in _active) ReconcileAutoBlocker(item);
         if (!CanSchedulePlayback()) { CancelPlaybackTimer(); return; }
         if (_playbackTimer is not null) return;
-        var settings = _runtime.Settings.Get<GameSettings>();
-        var interval = _playbackMode == PlaybackMode.Auto ? settings.AutoAdvanceIntervalMilliseconds : settings.QuickAdvanceIntervalMilliseconds;
-        if (interval < 0) throw new InvalidDataException("Playback intervals must be nonnegative milliseconds.");
+        var interval = _playbackMode == PlaybackMode.Auto ? _playbackOptions.AutoAdvanceIntervalMilliseconds : _playbackOptions.QuickAdvanceIntervalMilliseconds;
         var cancellation = CancellationTokenSource.CreateLinkedTokenSource(_scopeCancellation.Token);
         _playbackTimer = cancellation;
         var revision = Interlocked.Increment(ref _playbackRevision);
@@ -155,15 +158,16 @@ private async Task RunPlaybackTimerAsync(TimeSpan interval, long revision, Cance
             {
                 if (revision != Volatile.Read(ref _playbackRevision) || !CanSchedulePlayback()) return;
                 _playbackTimer = null;
+                _view.OnPlaybackContinuing();
                 _advanceBoundary = false;
                 foreach (var item in _active.ToArray())
                     if (item.Instance is IAdvanceWaitInstance wait) wait.CompleteAdvance();
                 RemoveCompleted();
                 UpdateLastStableSnapshot();
-                ContinueUntilBlocked();
+                await ContinueUntilBlockedAsync(cancellation.Token).ConfigureAwait(false);
             }
             catch (Exception exception) { _flowError = exception; IsRunning = false; }
-            finally { CaptureStateChange(); _dispatchGate.Release(); PublishStateChanges(); }
+            finally { FinishDispatch(); }
         }
         catch (OperationCanceledException) when (cancellation.IsCancellationRequested) { }
         finally
@@ -178,15 +182,4 @@ private async Task RunPlaybackTimerAsync(TimeSpan interval, long revision, Cance
         }
     }
 
-    private void PublishPlaybackChanges()
-    {
-        while (true)
-        {
-            PlaybackMode mode;
-            lock (_notificationSync) if (!_playbackChanges.TryDequeue(out mode)) return;
-            foreach (var handler in PlaybackModeChanged?.GetInvocationList() ?? [])
-                try { ((Action<PlaybackMode>)handler)(mode); }
-                catch (Exception exception) { GameLog.Logger.Error(exception, "Playback observer failed"); }
-        }
-    }
 }
diff --git a/src/Shared/GalNet.Runtime/Engine/GameEngine.Variables.cs b/src/Shared/GalNet.Runtime/Engine/GameEngine.Variables.cs
new file mode 100644
index 00000000..cdac5e50
--- /dev/null
+++ b/src/Shared/GalNet.Runtime/Engine/GameEngine.Variables.cs
@@ -0,0 +1,73 @@
+using GalNet.Core.Runtime;
+using GalNet.Core.Variable;
+
+namespace GalNet.Runtime.Engine;
+
+public sealed partial class GameEngine
+{
+    /// <summary>
+    /// Applies explicit player./save. values under the execution gate. A restore or stop invalidates queued edits.
+    /// Save values are also merged into the stable snapshot without moving its cursor or capturing pending presentation.
+    /// Player persistence remains the host's responsibility.
+    /// </summary>
+    public Task SetVariablesAsync(IReadOnlyDictionary<string, object> values, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(values);
+        if (values.Count == 0) return Task.CompletedTask;
+        var copied = new Dictionary<string, object>(values);
+        return UpdateVariablesAsync(_ => copied, cancellationToken);
+    }
+
+    /// <summary>Computes and validates a batch against independent, explicitly scoped snapshots under the execution gate.</summary>
+    public async Task UpdateVariablesAsync(
+        Func<IReadOnlyDictionary<string, Variable>, IReadOnlyDictionary<string, object>> update,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(update);
+        ThrowIfDisposed();
+        var scope = _scopeCancellation.Token;
+        await CancelCatchUpAndWaitAsync(cancellationToken).ConfigureAwait(false);
+        await _dispatchGate.WaitAsync(cancellationToken).ConfigureAwait(false);
+        try
+        {
+            ThrowIfDisposed();
+            scope.ThrowIfCancellationRequested();
+            cancellationToken.ThrowIfCancellationRequested();
+            ThrowFlowError();
+            if (_restorationPending || Volatile.Read(ref _stopRequested) != 0)
+                throw new InvalidOperationException("The run is restoring or stopped.");
+            _runtime.State.Update(() =>
+            {
+                var current = _runtime.GetVariables(VariableScope.Player).ToDictionary(pair => "player." + pair.Key, pair => pair.Value);
+                foreach (var pair in _runtime.GetVariables(VariableScope.Save)) current.Add("save." + pair.Key, pair.Value);
+                var edits = update(current).ToArray();
+                Validate(edits);
+                if (edits.Length == 0) return;
+                foreach (var (name, value) in edits) _runtime.SetVariable(name, value);
+                var snapshot = SnapshotCopy.Clone(_lastStableSnapshot);
+                var saved = _runtime.GetVariables(VariableScope.Save);
+                foreach (var (name, _) in edits)
+                    if (name.StartsWith("save.", StringComparison.Ordinal))
+                        snapshot.Variables[name[5..]] = saved[name[5..]].Clone();
+                _lastStableSnapshot = snapshot;
+                _notifications.Checkpoint(snapshot);
+            });
+        }
+        finally { FinishDispatch(); }
+    }
+
+    private static void Validate(KeyValuePair<string, object>[] edits)
+    {
+        foreach (var (name, value) in edits)
+        {
+            if ((!name.StartsWith("player.", StringComparison.Ordinal) && !name.StartsWith("save.", StringComparison.Ordinal)) ||
+                string.IsNullOrWhiteSpace(name[(name.IndexOf('.') + 1)..]))
+                throw new ArgumentException("External variable names require an explicit player. or save. scope.", nameof(edits));
+            if (value is not (bool or int or string) &&
+                !(value is long integer && integer is >= int.MinValue and <= int.MaxValue) &&
+                !(value is float number && float.IsFinite(number)) &&
+                !(value is double real && float.IsFinite((float)real)))
+                throw new ArgumentException($"Variable '{name}' requires bool, Int32, finite Single or string values.", nameof(edits));
+        }
+    }
+}
diff --git a/src/Shared/GalNet.Runtime/Engine/GameEngine.cs b/src/Shared/GalNet.Runtime/Engine/GameEngine.cs
index 5b89dc3c..1f8b52af 100644
--- a/src/Shared/GalNet.Runtime/Engine/GameEngine.cs
+++ b/src/Shared/GalNet.Runtime/Engine/GameEngine.cs
@@ -1,10 +1,9 @@
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
 using GalNet.Core.Services;
-using GalNet.Core.Settings;
-using GalNet.Presentation.Abstractions.View;
 using GalNet.Runtime.Logging;
 using GalNet.Runtime.Progress;
 using GalNet.Runtime.Runtime;
@@ -16,21 +15,22 @@ public sealed partial class GameEngine : IDisposable, IAsyncDisposable, IPlayerP
 {
     private readonly GameGraphNavigator _navigation;
     private readonly IGameRuntime _runtime;
-    private readonly IGameView _view;
+    private readonly IPrimitiveDispatcher _view;
     private readonly IChoicePresenter? _choicePresenter;
     private readonly IGameProgressService? _progress;
     private readonly ICatchUpPresentation? _catchUpPresentation;
     private readonly SemaphoreSlim _dispatchGate = new(1, 1);
     private CancellationTokenSource _scopeCancellation = new();
-    private IGameRuntime _dispatchRuntime;
+    private IGameContext _dispatchRuntime;
     private readonly ActivePrimitiveRegistry _active;
     private GameSnapshot _lastStableSnapshot;
+    private readonly string _contentBuildId;
+    private readonly string[] _storyPackages;
     private PendingChoice? _pendingChoice;
     private Exception? _flowError;
     private readonly object _lifecycleSync = new();
     private readonly List<Task> _backgroundTasks = [];
-    private readonly Queue<GameEngineStateChange> _stateChanges = new();
-    private readonly object _notificationSync = new();
+    private readonly EngineNotifications _notifications = new();
     private GameEngineState _reportedState = GameEngineState.Ready;
     private Task? _stopTask;
     private Task? _disposeTask;
@@ -38,44 +38,47 @@ public sealed partial class GameEngine : IDisposable, IAsyncDisposable, IPlayerP
     private bool _started;
     private bool _restorationPending;
     private bool _stopped;
-    private bool _publishingState;
     private volatile bool _disposed;
 
     public GameEngine(
         Graph graph,
-        IGameView view,
+        IPrimitiveDispatcher view,
         ITextResolver? textResolver = null,
-        SettingsContainer? settings = null,
+        PlaybackOptions? playbackOptions = null,
         IGameProgressService? progress = null,
         IChoicePresenter? choicePresenter = null,
         ICatchUpPresentation? catchUpPresentation = null)
         : this(
             graph,
-            new GameRuntime(textResolver, graph?.RootNodeId ?? "", settings),
+            new GameRuntime(textResolver, graph?.RootNodeId ?? "", saveDefaults: graph?.SaveVariables, playerDefaults: graph?.PlayerVariables),
             view,
             progress,
             choicePresenter,
-            catchUpPresentation)
+            catchUpPresentation,
+            playbackOptions)
     { }
 
     public GameEngine(
         Graph graph,
         IGameRuntime runtime,
-        IGameView view,
+        IPrimitiveDispatcher view,
         IGameProgressService? progress = null,
         IChoicePresenter? choicePresenter = null,
-        ICatchUpPresentation? catchUpPresentation = null)
+        ICatchUpPresentation? catchUpPresentation = null,
+        PlaybackOptions? playbackOptions = null)
     {
         ArgumentNullException.ThrowIfNull(graph);
+        _contentBuildId = graph.ContentBuildId;
+        _storyPackages = graph.InstalledStoryPackages.Order(StringComparer.Ordinal).ToArray();
+        _playbackOptions = playbackOptions ?? new PlaybackOptions();
+        _playbackOptions.Validate();
         _navigation = new GameGraphNavigator(graph);
         _active = new ActivePrimitiveRegistry(OnBlockingCompleted, OnAutoBlockingChanged);
         _runtime = runtime ?? throw new ArgumentNullException(nameof(runtime));
         _view = view ?? throw new ArgumentNullException(nameof(view));
         _runtime.State.Configure(_view.StateCatalog);
         _dispatchRuntime = new RunScopedRuntime(_runtime, _scopeCancellation.Token);
-        var entries = graph.Nodes.OfType<Group>().SelectMany(group => group.Entries).ToArray();
-        if (entries.Any(entry => entry is not PrimitiveEntry { IsGeneric: true }))
-            throw new InvalidOperationException("The game graph must contain compiled generic primitives, not authoring entries.");
+        var entries = _navigation.Nodes.OfType<Group>().SelectMany(group => group.Entries).ToArray();
         var missing = entries.OfType<PrimitiveEntry>()
             .Where(entry => !_view.CanExecute(entry.Type)).Select(entry => entry.Type).Distinct().ToArray();
         if (missing.Length > 0)
@@ -83,12 +86,12 @@ public GameEngine(
         _progress = progress;
         _choicePresenter = choicePresenter;
         _catchUpPresentation = catchUpPresentation;
-        _lastStableSnapshot = _runtime.CreateSnapshot();
+        _lastStableSnapshot = StampContent(_runtime.CreateSnapshot());
     }
 
-    public event Action<GameSnapshot>? CheckpointCreated;
+    public event Action<GameSnapshot>? CheckpointCreated { add => _notifications.CheckpointCreated += value; remove => _notifications.CheckpointCreated -= value; }
     /// <summary>Published outside the execution lock. Handlers must not synchronously wait for engine tasks.</summary>
-    public event Action<GameEngineStateChange>? StateChanged;
+    public event Action<GameEngineStateChange>? StateChanged { add => _notifications.StateChanged += value; remove => _notifications.StateChanged -= value; }
     public IGameRuntime Runtime => _runtime;
     public GameSnapshot LastStableSnapshot => SnapshotCopy.Clone(_lastStableSnapshot);
     public string CurrentNodeId => _runtime.CurrentNodeId;
@@ -126,6 +129,8 @@ public async Task<bool> AdvanceAsync(CancellationToken cancellationToken = defau
             if (_pendingChoice is not null || !IsRunning)
                 return IsRunning;
 
+            _view.OnPlaybackContinuing();
+
             var blocker = _active.EarliestBlocker();
             if (blocker is not null)
             {
@@ -141,7 +146,7 @@ public async Task<bool> AdvanceAsync(CancellationToken cancellationToken = defau
             // A manual skip may only reveal text or seek a video segment. Keep the
             // existing boundary until its blocker is actually released.
             _advanceBoundary = false;
-            ContinueUntilBlocked();
+            await ContinueUntilBlockedAsync(cancellationToken).ConfigureAwait(false);
             ThrowFlowError();
             return IsRunning;
         }
@@ -149,6 +154,10 @@ public async Task<bool> AdvanceAsync(CancellationToken cancellationToken = defau
         {
             return false;
         }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
         catch (Exception exception)
         {
             _flowError ??= exception;
@@ -157,9 +166,7 @@ public async Task<bool> AdvanceAsync(CancellationToken cancellationToken = defau
         }
         finally
         {
-            CaptureStateChange();
-            _dispatchGate.Release();
-            PublishStateChanges();
+            FinishDispatch();
         }
     }
 
@@ -169,7 +176,7 @@ public async Task<bool> AdvanceAsync(CancellationToken cancellationToken = defau
     /// Rebuilds host presentation under the execution gate using this run's isolated scene and token.
     /// The caller token cancels gate entry; retained playback uses the run token until stop/restore.
     /// </summary>
-    public async Task SynchronizePresentationAsync(Func<IGameRuntime, CancellationToken, Task> synchronize,
+    public async Task SynchronizePresentationAsync(Func<IGameContext, CancellationToken, Task> synchronize,
         CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(synchronize);
@@ -182,26 +189,45 @@ public async Task SynchronizePresentationAsync(Func<IGameRuntime, CancellationTo
             await synchronize(_dispatchRuntime, _scopeCancellation.Token).ConfigureAwait(false);
             _restorationPending = false;
         }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
         catch (Exception error) when (!_scopeCancellation.IsCancellationRequested)
         {
             _flowError = error;
             IsRunning = false;
             throw;
         }
-        finally { CaptureStateChange(); _dispatchGate.Release(); PublishStateChanges(); }
+        finally { FinishDispatch(); }
     }
 
-    public void RestoreFrom(GameSnapshot data) => RestoreFromCore(data);
+    public Task RestoreFromAsync(GameSnapshot data, CancellationToken cancellationToken = default) =>
+        RestoreFromCoreAsync(data, cancellationToken: cancellationToken);
+
+    /// <summary>Checks a replacement save against this game's contracts without changing the active run.</summary>
+    public async Task ValidateRestoreAsync(GameSnapshot data, CancellationToken cancellationToken = default)
+    {
+        await _dispatchGate.WaitAsync(cancellationToken).ConfigureAwait(false);
+        try { ThrowIfDisposed(); _ = PrepareRestore(data); }
+        finally { _dispatchGate.Release(); }
+    }
 
-    private long RestoreFromCore(GameSnapshot data, DebugSession? restoringDebugger = null, long? expectedGeneration = null)
+    private GameRestorePoint PrepareRestore(GameSnapshot data)
+    {
+        if (data.ContentBuildId != _contentBuildId || data.StoryPackages is null || data.StoryPackages.Any(package => !_storyPackages.Contains(package, StringComparer.Ordinal)))
+            throw new InvalidDataException("The save requires a different content build or a missing story package.");
+        var candidate = _runtime.PrepareRestore(data);
+        var node = _navigation.FindNode(candidate.NodeId);
+        if (node is null || node is Group { IsAvailable: false } || candidate.EntryIndex > (node is Group group ? group.Entries.Count : 0))
+            throw new InvalidDataException("The save position does not exist in this game graph.");
+        _view.ValidateState(_runtime, candidate.State);
+        return candidate;
+    }
+
+    private async Task<long> RestoreFromCoreAsync(GameSnapshot data, DebugSession? restoringDebugger = null,
+        long? expectedGeneration = null, CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(data);
         ThrowIfDisposed();
-        if (data.Version != GameSnapshot.CurrentFormatVersion)
-            throw new InvalidDataException($"Unsupported save version '{data.Version}'.");
-        data = SnapshotCopy.Clone(data);
-        _view.ValidateState(_runtime, GameState.Restore(_runtime.State.Catalog, data.States));
-        _dispatchGate.Wait();
+        await _dispatchGate.WaitAsync(cancellationToken).ConfigureAwait(false);
         try
         {
             ThrowIfDisposed();
@@ -209,6 +235,8 @@ private long RestoreFromCore(GameSnapshot data, DebugSession? restoringDebugger
                 throw new InvalidOperationException("A stopped engine cannot be restored. Create a new engine.");
             if (restoringDebugger is not null && (!ReferenceEquals(_debugger, restoringDebugger) || restoringDebugger.Generation != expectedGeneration))
                 throw new InvalidOperationException("The execution changed before debug restoration.");
+            var candidate = PrepareRestore(data);
+            cancellationToken.ThrowIfCancellationRequested();
             CancelPendingChoice();
             CancelCatchUp();
             _catchUpActive = false;
@@ -217,14 +245,13 @@ private long RestoreFromCore(GameSnapshot data, DebugSession? restoringDebugger
             _advanceBoundary = false;
             ClearActive();
             var previousScope = _scopeCancellation;
-            previousScope.Cancel();
-            previousScope.Dispose();
-            _runtime.RestoreFrom(data);
+            CancelDetachedScope(previousScope);
+            _runtime.Restore(candidate);
             _debugger?.OnExternalRestore(restoringDebugger is not null);
             _restorationPending = _view.RequiresStateRestore;
             _scopeCancellation = new CancellationTokenSource();
             _dispatchRuntime = new RunScopedRuntime(_runtime, _scopeCancellation.Token);
-            _lastStableSnapshot = _runtime.CreateSnapshot();
+            _lastStableSnapshot = StampContent(_runtime.CreateSnapshot());
             _active.EndGroup();
             _flowError = null;
             IsRunning = true;
@@ -233,9 +260,7 @@ private long RestoreFromCore(GameSnapshot data, DebugSession? restoringDebugger
         }
         finally
         {
-            CaptureStateChange();
-            _dispatchGate.Release();
-            PublishStateChanges();
+            FinishDispatch();
         }
     }
 
@@ -315,11 +340,25 @@ private async Task StopCoreAsync()
         if (errors.Length > 0) throw new AggregateException("Game shutdown failed.", errors);
     }
 
-    private void ContinueUntilBlocked()
+    // Called with the execution gate held; every exit (including cancellation) retains it.
+    private async Task ContinueUntilBlockedAsync(CancellationToken cancellationToken = default)
     {
+        var scope = _dispatchRuntime;
+        var budget = 128;
         while (IsRunning && _debugger?.Paused != true && _pendingChoice is null && !_active.HasBlockingInstance() && !_catchUpStopAtBoundary)
         {
             if (_catchUpActive && --_catchUpBudget < 0) break;
+            cancellationToken.ThrowIfCancellationRequested();
+            if (--budget < 0)
+            {
+                CaptureStateChange();
+                _dispatchGate.Release();
+                try { PublishStateChanges(); await Task.Yield(); }
+                finally { await _dispatchGate.WaitAsync(CancellationToken.None).ConfigureAwait(false); }
+                if (!ReferenceEquals(scope, _dispatchRuntime) || Volatile.Read(ref _stopRequested) != 0) return;
+                budget = 128;
+                continue;
+            }
             _scopeCancellation.Token.ThrowIfCancellationRequested();
             if (_runtime.IsGameEnded)
             {
@@ -337,7 +376,7 @@ private void ContinueUntilBlocked()
             switch (node)
             {
                 case Group group:
-                    ProcessGroup(group);
+                    ProcessGroup(group, ref budget, cancellationToken);
                     break;
                 case Branch { BranchType: BranchType.Choice } choice:
                     ProcessChoice(choice);
@@ -354,12 +393,14 @@ private void ContinueUntilBlocked()
         ReconcilePlaybackTimer();
     }
 
-    private void ProcessGroup(Group group)
+    private void ProcessGroup(Group group, ref int budget, CancellationToken cancellationToken)
     {
         if (_active.BeginGroupExecution(group.Id)) _debugger?.CaptureEntrance(group.Id);
         while (_runtime.EntryIndex < group.Entries.Count && _debugger?.Paused != true && !_active.HasBlockingInstance())
         {
             if (_catchUpActive && --_catchUpBudget < 0) return;
+            if (--budget < 0) return;
+            cancellationToken.ThrowIfCancellationRequested();
             _scopeCancellation.Token.ThrowIfCancellationRequested();
             var entry = group.Entries[_runtime.EntryIndex];
             if (_debugger?.BeforeEntry(group.Id, _runtime.EntryIndex) == true) return;
@@ -378,7 +419,9 @@ private void ProcessGroup(Group group)
                 instance = Dispatch(group, primitive);
                 Track(instance, group.Id, primitive, wasRead);
             }
-            else if (entry is not PrimitiveEntry)
+            else if (entry is PrimitiveEntry skipped)
+                _view.OnInstructionSkipped(skipped, _dispatchRuntime);
+            else
                 throw new InvalidOperationException($"Runtime cannot execute authoring entry '{entry.Type}'.");
 
             _runtime.SetEntryIndex(_runtime.EntryIndex + 1);
@@ -408,9 +451,6 @@ private void ProcessGroup(Group group)
 
     private PrimitiveInstance Dispatch(Group group, PrimitiveEntry entry)
     {
-        if (!entry.IsGeneric)
-            throw new InvalidOperationException($"Runtime cannot execute authoring entry '{entry.Type}'.");
-
         var instance = _view.Dispatch(entry, _dispatchRuntime, _scopeCancellation.Token,
             _catchUpActive ? PrimitiveInvocationMode.CatchUp :
             _playbackMode == PlaybackMode.Quick ? PrimitiveInvocationMode.Quick : PrimitiveInvocationMode.Normal);
@@ -427,6 +467,7 @@ private void Track(PrimitiveInstance instance, string groupId, PrimitiveEntry en
     {
         var active = _active.Track(instance, groupId, entry.StableId, wasRead,
             _view.TryGetEntry(entry.Type, out var definition) && definition!.IsReading);
+        if (active.IsReading) _readingPreamble = false;
         if (instance.IsBlocking && !instance.IsCompleted) _advanceBoundary = true;
         ReconcileAutoBlocker(active);
     }
@@ -529,9 +570,10 @@ private async Task CompleteChoiceAsync(PendingChoice pending, Task<int> selectio
                 return;
             }
 
+            _view.OnPlaybackContinuing();
             JumpFrom(pending.BranchId, pending.Options[selected].Outlet);
             UpdateLastStableSnapshot();
-            ContinueUntilBlocked();
+            await ContinueUntilBlockedAsync().ConfigureAwait(false);
         }
         catch (Exception exception)
         {
@@ -540,9 +582,7 @@ private async Task CompleteChoiceAsync(PendingChoice pending, Task<int> selectio
         }
         finally
         {
-            CaptureStateChange();
-            _dispatchGate.Release();
-            PublishStateChanges();
+            FinishDispatch();
         }
     }
 
@@ -560,9 +600,7 @@ private async Task RecordFlowErrorAsync(PendingChoice pending, Exception excepti
         }
         finally
         {
-            CaptureStateChange();
-            _dispatchGate.Release();
-            PublishStateChanges();
+            FinishDispatch();
         }
     }
 
@@ -582,7 +620,7 @@ private async Task ContinueAfterBlockingCompletionAsync(PrimitiveInstance instan
             if (_pendingChoice is null && !_active.HasBlockingInstance() && wasBlocking && _playbackMode == PlaybackMode.Manual && !_catchUpActive)
             {
                 _advanceBoundary = false;
-                ContinueUntilBlocked();
+                await ContinueUntilBlockedAsync().ConfigureAwait(false);
             }
             ReconcilePlaybackTimer();
             _catchUpSignal.Release();
@@ -596,9 +634,7 @@ private async Task ContinueAfterBlockingCompletionAsync(PrimitiveInstance instan
         }
         finally
         {
-            CaptureStateChange();
-            _dispatchGate.Release();
-            PublishStateChanges();
+            FinishDispatch();
         }
     }
 
@@ -620,41 +656,25 @@ private void CaptureStateChange()
         var state = State;
         if (state == _reportedState) return;
         _reportedState = state;
-        lock (_notificationSync)
-            _stateChanges.Enqueue(new GameEngineStateChange(state, state == GameEngineState.Faulted ? _flowError : null));
+        _notifications.State(new GameEngineStateChange(state, state == GameEngineState.Faulted ? _flowError : null));
     }
 
-    private void PublishStateChanges()
+    // Called with the execution gate held; observers are always invoked after release.
+    private void FinishDispatch()
     {
-        PublishPlaybackChanges();
-        lock (_notificationSync)
-        {
-            if (_publishingState) return;
-            _publishingState = true;
-        }
-        while (true)
-        {
-            GameEngineStateChange change;
-            lock (_notificationSync)
-            {
-                if (!_stateChanges.TryDequeue(out change!))
-                {
-                    _publishingState = false;
-                    return;
-                }
-            }
-            foreach (var handler in StateChanged?.GetInvocationList() ?? [])
-                try { ((Action<GameEngineStateChange>)handler)(change); }
-                catch (Exception exception) { GameLog.Logger.Error(exception, "Game state observer failed"); }
-        }
+        try { CaptureStateChange(); }
+        finally { _dispatchGate.Release(); }
+        PublishStateChanges();
     }
 
-    private void RemoveCompleted() => _active.RemoveCompleted(ReconcileAutoBlocker, instance => _autoBlockers.Remove(instance));
+    private void PublishStateChanges() => _notifications.Publish();
+
+    private void RemoveCompleted() => _active.RemoveCompleted(ReconcileAutoBlocker);
 
     private void ClearActive()
     {
+        _readingPreamble = false;
         _active.Clear();
-        _autoBlockers.Clear();
         CancelPlaybackTimer();
     }
 
@@ -670,10 +690,11 @@ private void JumpFrom(string nodeId, int outlet)
 
     private void UpdateLastStableSnapshot()
     {
-        if (_active.HasBlockingInstance() || _pendingChoice is not null)
+        if (_readingPreamble || _active.HasBlockingInstance() || _pendingChoice is not null)
             return;
-        _lastStableSnapshot = _runtime.CreateSnapshot();
-        CheckpointCreated?.Invoke(SnapshotCopy.Clone(_lastStableSnapshot));
+        _view.OnCheckpointCreating(_dispatchRuntime);
+        _lastStableSnapshot = StampContent(_runtime.CreateSnapshot());
+        _notifications.Checkpoint(_lastStableSnapshot);
     }
 
     private void CancelPendingChoice()
@@ -682,8 +703,20 @@ private void CancelPendingChoice()
         _pendingChoice = null;
         if (pending is null)
             return;
-        try { pending.Cancellation.Cancel(); }
-        finally { pending.Cancellation.Dispose(); }
+        CancelDetachedScope(pending.Cancellation);
+    }
+
+    private GameSnapshot StampContent(GameSnapshot snapshot) => SnapshotCopy.Clone(snapshot, _contentBuildId, _storyPackages);
+
+    private static void CancelDetachedScope(CancellationTokenSource cancellation)
+    {
+        try { cancellation.Cancel(); }
+        catch (AggregateException error)
+        {
+            try { GameLog.Logger.Warning(error, "Detached run cancellation callback failed"); }
+            catch (Exception) { /* The obsolete scope must still be released. */ }
+        }
+        finally { cancellation.Dispose(); }
     }
 
     private void ThrowFlowError()
diff --git a/src/Shared/GalNet.Runtime/Engine/GameGraphNavigator.cs b/src/Shared/GalNet.Runtime/Engine/GameGraphNavigator.cs
index 4fca2de9..3c850d53 100644
--- a/src/Shared/GalNet.Runtime/Engine/GameGraphNavigator.cs
+++ b/src/Shared/GalNet.Runtime/Engine/GameGraphNavigator.cs
@@ -1,3 +1,4 @@
+using GalNet.Core.Entry;
 using GalNet.Core.Graph;
 
 namespace GalNet.Runtime.Engine;
@@ -10,9 +11,46 @@ internal sealed class GameGraphNavigator
     public IEnumerable<Node> Nodes => _nodes.Values;
     public GameGraphNavigator(Graph graph)
     {
-        foreach (var node in graph.Nodes) _nodes.TryAdd(node.Id, node);
-        foreach (var edge in graph.Edges) _targets.TryAdd((edge.FromNodeId, edge.FromOutlet), edge.ToNodeId);
+        foreach (var node in graph.Nodes)
+        {
+            if (string.IsNullOrWhiteSpace(node.Id) || !_nodes.TryAdd(node.Id, CopyNode(node)))
+                throw new InvalidDataException($"Graph node '{node.Id}' must have a unique nonempty identity.");
+        }
+        if (!_nodes.ContainsKey(graph.RootNodeId)) throw new InvalidDataException("Graph root does not exist.");
+        foreach (var edge in graph.Edges)
+        {
+            if (!_nodes.TryGetValue(edge.FromNodeId, out var from) || !_nodes.ContainsKey(edge.ToNodeId))
+                throw new InvalidDataException("Graph edge references a missing node.");
+            var outlets = from is Branch branch ? Math.Max(1, branch.BranchType == BranchType.Choice ? branch.Options.Count : branch.Conditions.Count) : 1;
+            if (edge.FromOutlet < 0 || edge.FromOutlet >= outlets || !_targets.TryAdd((edge.FromNodeId, edge.FromOutlet), edge.ToNodeId))
+                throw new InvalidDataException($"Graph outlet '{edge.FromNodeId}/{edge.FromOutlet}' is invalid or duplicated.");
+        }
     }
+
+    // Private copies are never exposed to authoring/host code. Runtime consumers only read them.
+    private static Node CopyNode(Node node) => node switch
+    {
+        Group group => new Group { Id = group.Id, Name = group.Name, Entries = group.Entries.Select(CopyEntry).Cast<Entry>().ToList() },
+        Branch branch when Enum.IsDefined(branch.BranchType) => new Branch
+        {
+            Id = branch.Id,
+            Name = branch.Name,
+            BranchType = branch.BranchType,
+            Options = branch.Options.Select(option => new BranchOption { Text = option.Text, Condition = option.Condition }).ToList(),
+            Conditions = branch.Conditions.Select(condition => new BranchCondition { Expression = condition.Expression }).ToList()
+        },
+        _ => throw new InvalidDataException($"Unsupported graph node '{node.Id}'.")
+    };
+
+    private static PrimitiveEntry CopyEntry(Entry entry) => entry is PrimitiveEntry primitive
+        ? new(primitive.Type, primitive.Arguments, primitive.BatchId)
+        {
+            Id = primitive.Id,
+            StableId = primitive.StableId,
+            ReadingBoundaryId = primitive.ReadingBoundaryId,
+            Condition = primitive.Condition
+        }
+        : throw new InvalidOperationException("The game graph must contain compiled primitives, not authoring entries.");
     public Node? FindNode(string nodeId) => _nodes.GetValueOrDefault(nodeId);
     public string? FindTarget(string nodeId, int outlet) => _targets.GetValueOrDefault((nodeId, outlet));
 }
diff --git a/src/Shared/GalNet.Runtime/GalNet.Runtime.csproj b/src/Shared/GalNet.Runtime/GalNet.Runtime.csproj
index 8fc9a2af..f82ce354 100644
--- a/src/Shared/GalNet.Runtime/GalNet.Runtime.csproj
+++ b/src/Shared/GalNet.Runtime/GalNet.Runtime.csproj
@@ -8,7 +8,6 @@
 
     <ItemGroup>
       <ProjectReference Include="..\GalNet.Core\GalNet.Core.csproj" />
-      <ProjectReference Include="..\GalNet.Presentation.Abstractions\GalNet.Presentation.Abstractions.csproj" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/Shared/GalNet.Runtime/I18n/GameTextResolver.cs b/src/Shared/GalNet.Runtime/I18n/GameTextResolver.cs
index 6817b1fb..66c7d4be 100644
--- a/src/Shared/GalNet.Runtime/I18n/GameTextResolver.cs
+++ b/src/Shared/GalNet.Runtime/I18n/GameTextResolver.cs
@@ -28,8 +28,15 @@ public GameTextResolver(IEnumerable<LocalizedTextSource> sources, CultureInfo de
     public string Resolve(string key) => GetString(key, _currentCulture());
     public string GetString(string key, CultureInfo culture) => TryGetString(key, culture, out var value) ? value! : key;
 
-    public bool TryGetString(string key, CultureInfo culture, out string? value) =>
-        TryCultureChain(key, culture, out value) || TryCultureChain(key, _defaultCulture, out value);
+    public bool TryGetString(string key, CultureInfo culture, out string? value)
+    {
+        if (string.IsNullOrWhiteSpace(key))
+        {
+            value = "";
+            return true;
+        }
+        return TryCultureChain(key, culture, out value) || TryCultureChain(key, _defaultCulture, out value);
+    }
 
     private bool TryCultureChain(string key, CultureInfo culture, out string? value)
     {
diff --git a/src/Shared/GalNet.Runtime/Loader/GalgroupLoader.cs b/src/Shared/GalNet.Runtime/Loader/GalgroupLoader.cs
index 46e47a62..d88153cd 100644
--- a/src/Shared/GalNet.Runtime/Loader/GalgroupLoader.cs
+++ b/src/Shared/GalNet.Runtime/Loader/GalgroupLoader.cs
@@ -12,7 +12,6 @@ public static class GalgroupLoader
     private static readonly JsonSerializerOptions JsonOptions = new()
     {
         PropertyNameCaseInsensitive = true,
-        Converters = { new JsonStringEnumConverter() }
     };
 
     public static void LoadIntoGroupFromContent(Group group, string content)
@@ -22,7 +21,7 @@ public static void LoadIntoGroupFromContent(Group group, string content)
         CompiledGroupDocument document;
         try
         {
-            document = JsonSerializer.Deserialize<CompiledGroupDocument>(content, JsonOptions)
+            document = JsonCodec.Deserialize<CompiledGroupDocument>(content, JsonOptions)
                 ?? throw new InvalidDataException("The .galgroup document is empty.");
         }
         catch (JsonException exception)
diff --git a/src/Shared/GalNet.Runtime/Loader/GraphLoader.cs b/src/Shared/GalNet.Runtime/Loader/GraphLoader.cs
index d5fd2916..a1870c45 100644
--- a/src/Shared/GalNet.Runtime/Loader/GraphLoader.cs
+++ b/src/Shared/GalNet.Runtime/Loader/GraphLoader.cs
@@ -1,6 +1,8 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using GalNet.Core.Graph;
+using GalNet.Core.Serialization;
+using GalNet.Runtime.Serialization;
 
 namespace GalNet.Runtime.Loader;
 
@@ -9,25 +11,28 @@ namespace GalNet.Runtime.Loader;
 /// </summary>
 public static class GraphLoader
 {
-    private static readonly JsonSerializerOptions Options = new()
+    private static readonly JsonSerializerOptions Options = JsonMetadata.CreateOptions(new()
     {
         PropertyNameCaseInsensitive = true,
         PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-        Converters = { new NodeJsonConverter() }
-    };
+        Converters = { new NodeJsonConverter(), new JsonStringEnumConverter<GalNet.Core.Variable.VariableType>() }
+    }, RuntimeJsonContext.Default);
 
     /// <summary>从 JSON 字符串加载图。</summary>
     public static Graph LoadFromJson(string json)
     {
-        var dto = JsonSerializer.Deserialize<GraphDto>(json, Options)
+        var dto = JsonCodec.Deserialize<GraphDto>(json, Options)
                   ?? throw new InvalidOperationException("Failed to deserialize graph.json");
 
         var graph = new Graph
         {
+            Id = dto.Id ?? GalNet.Core.Assets.StoryResourceIds.Graph,
             Name = dto.Name,
             RootNodeId = dto.RootNodeId,
             Nodes = dto.Nodes?.Select(ConvertNode).ToList() ?? [],
-            Edges = dto.Edges?.Select(e => new Edge(e.FromNodeId, e.FromOutlet, e.ToNodeId)).ToList() ?? []
+            Edges = dto.Edges?.Select(e => new Edge(e.FromNodeId, e.FromOutlet, e.ToNodeId)).ToList() ?? [],
+            PlayerVariables = dto.PlayerVariables ?? [],
+            SaveVariables = dto.SaveVariables ?? []
         };
 
         return graph;
@@ -39,6 +44,8 @@ public static Graph LoadFromJson(string json)
         {
             Id = dto.Id,
             Name = dto.Name ?? "",
+            ResourceId = dto.ResourceId ?? GalNet.Core.Assets.StoryResourceIds.Group(dto.Id),
+            StoryPackage = dto.StoryPackage ?? "",
             Entries = [] // entries loaded separately from .galgroup
         },
         "Branch" => new Branch
@@ -61,16 +68,21 @@ public static Graph LoadFromJson(string json)
 
     // ── DTO types ──
 
-    private sealed class GraphDto
+    internal sealed class GraphDto
     {
+        public string? Id { get; set; }
+        public List<GalNet.Core.Variable.ProjectVariableDefinition>? PlayerVariables { get; set; }
+        public List<GalNet.Core.Variable.ProjectVariableDefinition>? SaveVariables { get; set; }
         public string Name { get; set; } = "";
         public string RootNodeId { get; set; } = "";
         public List<NodeDto>? Nodes { get; set; }
         public List<EdgeDto>? Edges { get; set; }
     }
 
-    private sealed class NodeDto
+    internal sealed class NodeDto
     {
+        public string? ResourceId { get; set; }
+        public string? StoryPackage { get; set; }
         public string Id { get; set; } = "";
         public string Type { get; set; } = "";
         public string? Name { get; set; }
@@ -79,20 +91,20 @@ private sealed class NodeDto
         public List<ConditionDto>? Conditions { get; set; }
     }
 
-    private sealed class EdgeDto
+    internal sealed class EdgeDto
     {
         public string FromNodeId { get; set; } = "";
         public int FromOutlet { get; set; }
         public string ToNodeId { get; set; } = "";
     }
 
-    private sealed class OptionDto
+    internal sealed class OptionDto
     {
         public string? Text { get; set; }
         public string? Condition { get; set; }
     }
 
-    private sealed class ConditionDto
+    internal sealed class ConditionDto
     {
         public string? Expression { get; set; }
     }
@@ -115,6 +127,8 @@ public override NodeDto Read(ref Utf8JsonReader reader, Type typeToConvert, Json
 
             if (element.TryGetProperty("name", out var nameProp))
                 dto.Name = nameProp.GetString();
+            if (element.TryGetProperty("resourceId", out var resource)) dto.ResourceId = resource.GetString();
+            if (element.TryGetProperty("storyPackage", out var package)) dto.StoryPackage = package.GetString();
 
             if (element.TryGetProperty("branchType", out var btProp))
                 dto.BranchType = btProp.GetString();
diff --git a/src/Shared/GalNet.Runtime/Persistence/ISaveService.cs b/src/Shared/GalNet.Runtime/Persistence/ISaveService.cs
index 6ab5fd2e..8683877f 100644
--- a/src/Shared/GalNet.Runtime/Persistence/ISaveService.cs
+++ b/src/Shared/GalNet.Runtime/Persistence/ISaveService.cs
@@ -35,3 +35,15 @@ public interface ISaveService
     Task<bool> HasQuickSaveAsync(CancellationToken ct = default);
     Task DeleteQuickSaveAsync(CancellationToken ct = default);
 }
+
+/// <summary>Optional metadata editing that preserves the saved snapshot, timestamp and preview.</summary>
+public interface ISaveSlotNamingService
+{
+    Task RenameAsync(int slot, string name, CancellationToken ct = default);
+}
+
+/// <summary>Optional direct slot lookup for stores that can avoid scanning every save.</summary>
+public interface ISaveSlotInfoSource
+{
+    Task<SaveSlotInfo> GetSlotInfoAsync(int slot, CancellationToken ct = default);
+}
diff --git a/src/Shared/GalNet.Runtime/Runtime/GameRestorePoint.cs b/src/Shared/GalNet.Runtime/Runtime/GameRestorePoint.cs
new file mode 100644
index 00000000..abcb2164
--- /dev/null
+++ b/src/Shared/GalNet.Runtime/Runtime/GameRestorePoint.cs
@@ -0,0 +1,38 @@
+using System.Collections.ObjectModel;
+using GalNet.Core.Runtime;
+using GalVariable = GalNet.Core.Variable.Variable;
+
+namespace GalNet.Runtime.Runtime;
+
+/// <summary>A validated, isolated candidate prepared before replacing a running scope.</summary>
+public sealed class GameRestorePoint
+{
+    private GameRestorePoint(GameSnapshot snapshot, GameState state)
+    {
+        NodeId = snapshot.NodeId;
+        EntryIndex = snapshot.EntryIndex;
+        Variables = new ReadOnlyDictionary<string, GalVariable>(snapshot.Variables);
+        State = state;
+    }
+
+    public string NodeId { get; }
+    public int EntryIndex { get; }
+    public IReadOnlyDictionary<string, GalVariable> Variables { get; }
+    public GameState State { get; }
+
+    public static GameRestorePoint Prepare(StateCatalog catalog, GameSnapshot snapshot)
+    {
+        ArgumentNullException.ThrowIfNull(snapshot);
+        if (snapshot.Version != GameSnapshot.CurrentFormatVersion)
+            throw new InvalidDataException($"Unsupported save version '{snapshot.Version}'.");
+        if (snapshot.Variables is null || snapshot.States is null || snapshot.EntryIndex < 0)
+            throw new InvalidDataException("Invalid save position or state collections.");
+        var identities = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var (name, variable) in snapshot.Variables)
+            if (string.IsNullOrWhiteSpace(name) || variable is null || variable.Value is null ||
+                string.IsNullOrWhiteSpace(variable.Uid) || !identities.Add(variable.Uid))
+                throw new InvalidDataException("Save variables require unique identities and nonempty names.");
+        var copy = SnapshotCopy.Clone(snapshot);
+        return new(copy, GameState.Restore(catalog, copy.States));
+    }
+}
diff --git a/src/Shared/GalNet.Runtime/Runtime/GameRuntime.cs b/src/Shared/GalNet.Runtime/Runtime/GameRuntime.cs
index 0811c311..b011d6ba 100644
--- a/src/Shared/GalNet.Runtime/Runtime/GameRuntime.cs
+++ b/src/Shared/GalNet.Runtime/Runtime/GameRuntime.cs
@@ -1,8 +1,7 @@
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Core.Services;
-using GalNet.Core.Settings;
 using GalNet.Core.Variable;
+using GalNet.Runtime.Logging;
 using GalNet.Runtime.Variables;
 using GalVariable = GalNet.Core.Variable.Variable;
 
@@ -15,21 +14,17 @@ namespace GalNet.Runtime.Runtime;
 public sealed class GameRuntime : IGameRuntime
 {
     // ── 位置 ──
-    public string CurrentNodeId { get; set; } = "";
-    public int EntryIndex { get; set; }
+    public string CurrentNodeId { get; private set; } = "";
+    public int EntryIndex { get; private set; }
 
     // ── 游戏结束标志 ──
-    public bool IsGameEnded { get; set; }
+    public bool IsGameEnded { get; private set; }
 
     // ── 核心引用 ──
     public ITextResolver TextResolver { get; }
 
-    // ── 设置 ──
-    public SettingsContainer Settings { get; }
-
     // ── 场景状态 ──
     public GameState State { get; private set; } = new();
-    public ISceneInstanceManager SceneInstances { get; private set; }
 
     // ── 内部状态 ──
     private readonly VariableStore _variables;
@@ -37,14 +32,13 @@ public sealed class GameRuntime : IGameRuntime
     private readonly IVariableService? _variableService;
 
     public GameRuntime(ITextResolver? textResolver, string rootNodeId = "",
-        SettingsContainer? settings = null,
-        IVariableService? variableService = null, StateCatalog? stateCatalog = null)
+        IVariableService? variableService = null, StateCatalog? stateCatalog = null,
+        IReadOnlyList<ProjectVariableDefinition>? saveDefaults = null,
+        IReadOnlyList<ProjectVariableDefinition>? playerDefaults = null)
     {
         TextResolver = textResolver ?? PassthroughTextResolver.Instance;
         CurrentNodeId = rootNodeId;
-        Settings = settings ?? new SettingsContainer();
         State = new GameState(stateCatalog);
-        SceneInstances = new SceneInstanceManager(State);
         _variableService = variableService;
 
         _variables = new VariableStore(
@@ -57,7 +51,22 @@ public GameRuntime(ITextResolver? textResolver, string rootNodeId = "",
             _variables.RestoreSaveFrom(variableService.GetSnapshot(VariableScope.Save));
         }
 
-        _evaluator = new ExpressionEvaluator(_variables);
+        if (saveDefaults is not null)
+            _variables.RestoreSaveFrom(saveDefaults.ToDictionary(definition => definition.Name, definition => definition.DefaultValue.Clone(definition.Name)));
+        var playerValues = _variables.PlayerSnapshot.ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.Ordinal);
+        foreach (var definition in playerDefaults ?? [])
+        {
+            var name = definition.Name.StartsWith("player.", StringComparison.Ordinal) ? definition.Name[7..] : definition.Name;
+            if (playerValues.ContainsKey(name)) continue;
+            var value = definition.DefaultValue.Clone(name);
+            playerValues.Add(name, value);
+            variableService?.NotifyVariableChanged(VariableScope.Player, "player." + name, value);
+        }
+        _variables.RestorePlayerFrom(playerValues);
+
+        _evaluator = new ExpressionEvaluator(_variables, (expression, error) => GameLog.Logger.Warning(error,
+            "{DiagnosticCode} at group {GroupId}, entry index {EntryIndex}: {Expression}",
+            "expression.invalid", CurrentNodeId, EntryIndex, expression));
     }
 
     private void OnVariableChanged(VariableScope scope, string name, GalVariable variable)
@@ -91,15 +100,17 @@ public void EndGame()
 
     public GalVariable? GetVariable(string name)
     {
-        _variables.TryGet(name, out var v);
-        return v;
+        return State.Read(() => _variables.TryGet(name, out var value) ? value : null);
     }
 
-    public bool TryGetVariable(string name, out GalVariable variable) =>
-        _variables.TryGet(name, out variable!);
+    public bool TryGetVariable(string name, out GalVariable variable)
+    {
+        variable = GetVariable(name)!;
+        return variable is not null;
+    }
 
     public IReadOnlyDictionary<string, GalVariable> GetVariables(VariableScope scope) =>
-        _variables.GetSnapshot(scope);
+        State.Read(() => _variables.GetSnapshot(scope));
 
     public bool EvaluateCondition(string expression) => _evaluator.EvaluateCondition(expression);
 
@@ -112,20 +123,23 @@ public IReadOnlyDictionary<string, GalVariable> GetVariables(VariableScope scope
         Version = GameSnapshot.CurrentFormatVersion,
         NodeId = CurrentNodeId,
         EntryIndex = EntryIndex,
-        Variables = _variables.SaveSnapshot.ToDictionary(pair => pair.Key, pair => SnapshotCopy.CloneVariable(pair.Value)),
+        Variables = _variables.SaveSnapshot.ToDictionary(pair => pair.Key, pair => pair.Value),
         States = State.Capture()
     });
 
-    public void RestoreFrom(GameSnapshot snapshot)
+    public GameRestorePoint PrepareRestore(GameSnapshot snapshot) => GameRestorePoint.Prepare(State.Catalog, snapshot);
+
+    public void RestoreFrom(GameSnapshot snapshot) => Restore(PrepareRestore(snapshot));
+
+    public void Restore(GameRestorePoint point)
     {
-        if (snapshot.Version != GameSnapshot.CurrentFormatVersion)
-            throw new InvalidDataException($"Unsupported save version '{snapshot.Version}'.");
-        var state = GameState.Restore(State.Catalog, snapshot.States);
-        CurrentNodeId = snapshot.NodeId;
-        EntryIndex = snapshot.EntryIndex;
-        _variables.RestoreSaveFrom(snapshot.Variables);
-        IsGameEnded = false;
-        State = state;
-        SceneInstances = new SceneInstanceManager(State);
+        State.Update(() =>
+        {
+            CurrentNodeId = point.NodeId;
+            EntryIndex = point.EntryIndex;
+            _variables.RestoreSaveFrom(point.Variables);
+            IsGameEnded = false;
+            State = point.State;
+        });
     }
 }
diff --git a/src/Shared/GalNet.Runtime/Runtime/IGameRuntime.cs b/src/Shared/GalNet.Runtime/Runtime/IGameRuntime.cs
new file mode 100644
index 00000000..d920568b
--- /dev/null
+++ b/src/Shared/GalNet.Runtime/Runtime/IGameRuntime.cs
@@ -0,0 +1,13 @@
+using GalNet.Core.Runtime;
+
+namespace GalNet.Runtime.Runtime;
+
+/// <summary>Engine-owned cursor and restoration operations, excluded from primitive contexts.</summary>
+public interface IGameRuntime : IGameContext
+{
+    void JumpTo(string nodeId, int entryIndex = 0);
+    void SetEntryIndex(int entryIndex);
+    GameSnapshot CreateSnapshot();
+    GameRestorePoint PrepareRestore(GameSnapshot snapshot);
+    void Restore(GameRestorePoint point);
+}
diff --git a/src/Shared/GalNet.Runtime/Runtime/RunScopedRuntime.cs b/src/Shared/GalNet.Runtime/Runtime/RunScopedRuntime.cs
index 0edb8150..cc1c97fe 100644
--- a/src/Shared/GalNet.Runtime/Runtime/RunScopedRuntime.cs
+++ b/src/Shared/GalNet.Runtime/Runtime/RunScopedRuntime.cs
@@ -1,14 +1,12 @@
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Core.Services;
-using GalNet.Core.Settings;
 using GalNet.Core.Variable;
 using GalVariable = GalNet.Core.Variable.Variable;
 
 namespace GalNet.Runtime.Runtime;
 
 /// <summary>Old callbacks retain their old scene and cannot change a restored run's control flow or variables.</summary>
-internal sealed class RunScopedRuntime : IGameRuntime
+internal sealed class RunScopedRuntime : IGameContext
 {
     private readonly IGameRuntime _runtime;
     private readonly CancellationToken _cancellation;
@@ -20,26 +18,21 @@ public RunScopedRuntime(IGameRuntime runtime, CancellationToken cancellation, bo
         _cancellation = cancellation;
         _ignoreVariableWrites = ignoreVariableWrites;
         State = runtime.State;
-        SceneInstances = runtime.SceneInstances;
     }
 
     public string CurrentNodeId => _runtime.CurrentNodeId;
     public int EntryIndex => _runtime.EntryIndex;
     public bool IsGameEnded => _runtime.IsGameEnded;
     public ITextResolver TextResolver => _runtime.TextResolver;
-    public SettingsContainer Settings => _runtime.Settings;
     public GameState State { get; }
-    public ISceneInstanceManager SceneInstances { get; }
-    public void JumpTo(string nodeId, int entryIndex = 0) { Check(); _runtime.JumpTo(nodeId, entryIndex); }
-    public void SetEntryIndex(int entryIndex) { Check(); _runtime.SetEntryIndex(entryIndex); }
-    public void EndGame() { Check(); _runtime.EndGame(); }
-    public void SetVariable(string name, object value) { Check(); if (!_ignoreVariableWrites) _runtime.SetVariable(name, value); }
-    public GalVariable? GetVariable(string name) { Check(); return _runtime.GetVariable(name); }
-    public bool TryGetVariable(string name, out GalVariable variable) { Check(); return _runtime.TryGetVariable(name, out variable!); }
-    public IReadOnlyDictionary<string, GalVariable> GetVariables(VariableScope scope) { Check(); return _runtime.GetVariables(scope); }
-    public bool EvaluateCondition(string expression) { Check(); return _runtime.EvaluateCondition(expression); }
-    public object? EvaluateExpression(string expression) { Check(); return _runtime.EvaluateExpression(expression); }
-    public GameSnapshot CreateSnapshot() { Check(); return _runtime.CreateSnapshot(); }
-    public void RestoreFrom(GameSnapshot snapshot) => throw new InvalidOperationException("Only the engine can restore a run.");
+    public void EndGame() => State.Update(() => { Check(); _runtime.EndGame(); });
+    public void SetVariable(string name, object value) => State.Update(() =>
+    { Check(); if (!_ignoreVariableWrites) _runtime.SetVariable(name, value); });
+    public GalVariable? GetVariable(string name) => Read(() => _runtime.GetVariable(name));
+    public bool TryGetVariable(string name, out GalVariable variable) { variable = GetVariable(name)!; return variable is not null; }
+    public IReadOnlyDictionary<string, GalVariable> GetVariables(VariableScope scope) => Read(() => _runtime.GetVariables(scope));
+    public bool EvaluateCondition(string expression) => Read(() => _runtime.EvaluateCondition(expression));
+    public object? EvaluateExpression(string expression) => Read(() => _runtime.EvaluateExpression(expression));
+    private T Read<T>(Func<T> read) => State.Read(() => { Check(); return read(); });
     private void Check() => _cancellation.ThrowIfCancellationRequested();
 }
diff --git a/src/Shared/GalNet.Runtime/Runtime/SceneInstanceManager.cs b/src/Shared/GalNet.Runtime/Runtime/SceneInstanceManager.cs
deleted file mode 100644
index f4a8dbc9..00000000
--- a/src/Shared/GalNet.Runtime/Runtime/SceneInstanceManager.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
-
-namespace GalNet.Runtime.Runtime;
-
-/// <summary>Derived handle lookup over canonical state plus ephemeral execution controls.</summary>
-internal sealed class SceneInstanceManager(GameState state) : ISceneInstanceManager
-{
-    private readonly Dictionary<string, ISceneInstance> _transient = new(StringComparer.Ordinal);
-    public IReadOnlyList<T> GetAll<T>() where T : class, ISceneInstance => state.Read(() =>
-        state.SceneObjects<T>().Concat(_transient.Values.OfType<T>()).ToArray());
-    public bool TryGet<T>(string id, out T instance) where T : class, ISceneInstance
-    {
-        lock (state.SyncRoot)
-        {
-            if (_transient.TryGetValue(id, out var value)) { instance = value as T ?? null!; return instance is not null; }
-            return state.TryGetScene(id, out instance);
-        }
-    }
-    public T GetOrAdd<T>(string id, Func<string, T> factory) where T : class, ISceneInstance
-    {
-        lock (state.SyncRoot)
-        {
-            if (TryGet<T>(id, out var existing)) return existing;
-            if (_transient.ContainsKey(id)) throw new InvalidOperationException($"Scene handle '{id}' is already in use.");
-            var value = factory(id);
-            state.Table<T>().Add(value);
-            return value;
-        }
-    }
-    public T GetOrAddTransient<T>(string id, Func<string, T> factory) where T : class, ISceneInstance
-    {
-        lock (state.SyncRoot)
-        {
-            if (TryGet<T>(id, out var existing)) return existing;
-            if (GetAll<ISceneInstance>().Any(item => item.Id == id)) throw new InvalidOperationException($"Scene handle '{id}' is already in use.");
-            var value = factory(id);
-            _transient.Add(id, value);
-            return value;
-        }
-    }
-    public bool Remove<T>(string id, out T? instance) where T : class, ISceneInstance
-    {
-        lock (state.SyncRoot)
-        {
-            if (!TryGet<T>(id, out var existing)) { instance = null; return false; }
-            instance = existing;
-            if (_transient.Remove(id)) return true;
-            return state.Table<T>().Remove(id);
-        }
-    }
-}
diff --git a/src/Shared/GalNet.Runtime/SaveLoad/SaveManager.cs b/src/Shared/GalNet.Runtime/SaveLoad/SaveManager.cs
index fa5ebfee..bf67d7d0 100644
--- a/src/Shared/GalNet.Runtime/SaveLoad/SaveManager.cs
+++ b/src/Shared/GalNet.Runtime/SaveLoad/SaveManager.cs
@@ -1,5 +1,6 @@
 using System.Text.Json;
 using GalNet.Core.Runtime;
+using GalNet.Core.Serialization;
 
 namespace GalNet.Runtime.SaveLoad;
 
@@ -18,7 +19,7 @@ public static class SaveManager
     /// <summary>序列化存档到 JSON 字符串。</summary>
     public static string Serialize(GameSnapshot data)
     {
-        return JsonSerializer.Serialize(data, Options);
+        return JsonCodec.Serialize(data, Options);
     }
 
     /// <summary>从 JSON 字符串反序列化。</summary>
@@ -31,7 +32,7 @@ public static string Serialize(GameSnapshot data)
             formatVersion != GameSnapshot.CurrentFormatVersion)
             return null;
 
-        var snapshot = JsonSerializer.Deserialize<GameSnapshot>(document.RootElement.GetRawText(), Options);
+        var snapshot = JsonCodec.Deserialize<GameSnapshot>(document.RootElement, Options);
         return snapshot?.Version == GameSnapshot.CurrentFormatVersion ? snapshot : null;
     }
 
diff --git a/src/Shared/GalNet.Runtime/Serialization/RuntimeJsonContext.cs b/src/Shared/GalNet.Runtime/Serialization/RuntimeJsonContext.cs
new file mode 100644
index 00000000..5b833838
--- /dev/null
+++ b/src/Shared/GalNet.Runtime/Serialization/RuntimeJsonContext.cs
@@ -0,0 +1,8 @@
+using System.Text.Json.Serialization;
+using GalNet.Runtime.Loader;
+
+namespace GalNet.Runtime.Serialization;
+
+[JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata)]
+[JsonSerializable(typeof(GraphLoader.GraphDto))]
+internal sealed partial class RuntimeJsonContext : JsonSerializerContext;
diff --git a/src/Shared/GalNet.Runtime/Variables/ExpressionEvaluator.cs b/src/Shared/GalNet.Runtime/Variables/ExpressionEvaluator.cs
index f60b885c..c5238e57 100644
--- a/src/Shared/GalNet.Runtime/Variables/ExpressionEvaluator.cs
+++ b/src/Shared/GalNet.Runtime/Variables/ExpressionEvaluator.cs
@@ -1,4 +1,7 @@
+using System.Text;
+using System.Text.Json;
 using GalNet.Core.Variable;
+using GalNet.Runtime.Logging;
 using NCalc;
 
 namespace GalNet.Runtime.Variables;
@@ -11,10 +14,14 @@ namespace GalNet.Runtime.Variables;
 public sealed class ExpressionEvaluator
 {
     private readonly VariableStore _store;
+    private readonly Action<string, Exception> _diagnostic;
+    private readonly HashSet<string> _reportedConditions = new(StringComparer.Ordinal);
 
-    public ExpressionEvaluator(VariableStore store)
+    public ExpressionEvaluator(VariableStore store, Action<string, Exception>? diagnostic = null)
     {
         _store = store;
+        _diagnostic = diagnostic ?? ((expression, error) => GameLog.Logger.Warning(error,
+            "{DiagnosticCode}: condition {Expression} evaluates to false", "expression.invalid", expression));
     }
 
     /// <summary>
@@ -39,8 +46,15 @@ public bool EvaluateCondition(string? expression)
                 _ => true
             };
         }
-        catch
+        catch (Exception error) when (error is not OperationCanceledException)
         {
+            // Invalid content may be reached repeatedly by a story loop. Bound both diagnostics and storage.
+            bool report;
+            lock (_reportedConditions)
+                report = _reportedConditions.Count < 64 && _reportedConditions.Add(expression);
+            if (report)
+                try { _diagnostic(expression, error); }
+                catch (Exception) { /* Diagnostic observers cannot change condition semantics. */ }
             return false;
         }
     }
@@ -53,8 +67,13 @@ public bool EvaluateCondition(string? expression)
         if (string.IsNullOrWhiteSpace(expression))
             return null;
 
-        var expr = new Expression(NormalizeStringLiterals(expression));
-        expr.EvaluateParameter += ResolveParameter;
+        var literals = new Dictionary<string, string>(StringComparer.Ordinal);
+        var expr = new Expression(BindStringLiterals(expression, literals));
+        expr.EvaluateParameter += (name, args) =>
+        {
+            if (literals.TryGetValue(name, out var literal)) args.Result = literal;
+            else ResolveParameter(name, args);
+        };
 
         return expr.Evaluate();
     }
@@ -76,9 +95,46 @@ private void ResolveParameter(string name, ParameterArgs args)
         _ => v.AsString()
     };
 
-    // NCalc string literals use single quotes, while graph expressions commonly
-    // use JSON/C#-style double quotes. Normalize only the delimiters so both
-    // forms are accepted by the public expression syntax.
-    private static string NormalizeStringLiterals(string expression) =>
-        expression.Replace('"', '\'');
+    // Bind JSON string literals as values; never rewrite apostrophes, escapes or variable names.
+    private static string BindStringLiterals(string expression, Dictionary<string, string> literals)
+    {
+        var result = new StringBuilder(expression.Length);
+        for (var index = 0; index < expression.Length; index++)
+        {
+            var current = expression[index];
+            if (current is '\'' or '[' or '#')
+            {
+                var end = current == '[' ? ']' : current;
+                result.Append(current);
+                while (++index < expression.Length)
+                {
+                    current = expression[index];
+                    result.Append(current);
+                    if (current == '\\' && end == '\'' && index + 1 < expression.Length)
+                        result.Append(expression[++index]);
+                    else if (current == end) break;
+                }
+            }
+            else if (current == '"')
+            {
+                var start = index;
+                while (++index < expression.Length)
+                {
+                    if (expression[index] == '\\') index++;
+                    else if (expression[index] == '"') break;
+                }
+                if (index >= expression.Length) throw new FormatException("Unterminated expression string.");
+                using var literalDocument = JsonDocument.Parse(expression[start..(index + 1)]);
+                var literal = literalDocument.RootElement.GetString()!;
+                var suffix = literals.Count;
+                string name;
+                do { name = $"__gal_literal_{suffix++}"; }
+                while (literals.ContainsKey(name) || expression.Contains($"[{name}]", StringComparison.Ordinal));
+                literals.Add(name, literal);
+                result.Append('[').Append(name).Append(']');
+            }
+            else result.Append(current);
+        }
+        return result.ToString();
+    }
 }
diff --git a/src/Shared/GalNet.Runtime/Variables/PlayerVariableService.cs b/src/Shared/GalNet.Runtime/Variables/PlayerVariableService.cs
index 8d69bcb1..f9a03879 100644
--- a/src/Shared/GalNet.Runtime/Variables/PlayerVariableService.cs
+++ b/src/Shared/GalNet.Runtime/Variables/PlayerVariableService.cs
@@ -60,7 +60,11 @@ public void NotifyVariableChanged(VariableScope scope, string name, GalVariable
     {
         var target = scope == VariableScope.Player ? _playerVariables : _saveVariables;
         target[name] = Clone(name, variable);
-        VariableChanged?.Invoke(scope, name, variable);
+        foreach (var observer in VariableChanged?.GetInvocationList() ?? [])
+        {
+            try { ((Action<VariableScope, string, GalVariable>)observer)(scope, name, variable.Clone()); }
+            catch (Exception error) { GalNet.Runtime.Logging.GameLog.Logger.Warning(error, "Variable change observer failed for {Name}", name); }
+        }
     }
 
     public Task FlushPlayerVariablesAsync(CancellationToken ct = default) => _playerStore.SaveAsync(_playerVariables, ct);
diff --git a/src/Shared/GalNet.Runtime/Variables/VariableStore.cs b/src/Shared/GalNet.Runtime/Variables/VariableStore.cs
index 084b37d9..612ab37b 100644
--- a/src/Shared/GalNet.Runtime/Variables/VariableStore.cs
+++ b/src/Shared/GalNet.Runtime/Variables/VariableStore.cs
@@ -17,8 +17,8 @@ public VariableStore(
         _onVariableChanged = onVariableChanged;
     }
 
-    public IReadOnlyDictionary<string, Variable> PlayerSnapshot => _playerVariables;
-    public IReadOnlyDictionary<string, Variable> SaveSnapshot => _saveVariables;
+    public IReadOnlyDictionary<string, Variable> PlayerSnapshot => GetSnapshot(VariableScope.Player);
+    public IReadOnlyDictionary<string, Variable> SaveSnapshot => GetSnapshot(VariableScope.Save);
 
     public void Set(string name, object value)
     {
@@ -49,12 +49,14 @@ public string GetString(string name, string def = "") =>
     public bool TryGet(string name, out Variable variable)
     {
         var normalized = NormalizeName(name);
-        return _playerVariables.TryGetValue(normalized, out variable!)
-            || _saveVariables.TryGetValue(normalized, out variable!);
+        var found = _playerVariables.TryGetValue(normalized, out var current) || _saveVariables.TryGetValue(normalized, out current);
+        variable = found ? current!.Clone() : null!;
+        return found;
     }
 
     public IReadOnlyDictionary<string, Variable> GetSnapshot(VariableScope scope) =>
-        scope == VariableScope.Player ? _playerVariables : _saveVariables;
+        (scope == VariableScope.Player ? _playerVariables : _saveVariables)
+            .ToDictionary(pair => pair.Key, pair => pair.Value.Clone(), StringComparer.Ordinal);
 
     public void RestorePlayerFrom(IReadOnlyDictionary<string, Variable> snapshot)
     {
diff --git a/src/Shared/GalNet.Runtime/packages.lock.WindowsReadyToRun.json b/src/Shared/GalNet.Runtime/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..88938268
--- /dev/null
+++ b/src/Shared/GalNet.Runtime/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,31 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "CoreCLR-NCalc": {
+        "type": "Direct",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Serilog": {
+        "type": "Direct",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      },
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "galnet.core": {
+        "type": "Project"
+      }
+    },
+    "net10.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/src/Shared/GalNet.Runtime/packages.lock.json b/src/Shared/GalNet.Runtime/packages.lock.json
index 1956a23a..8c0ab316 100644
--- a/src/Shared/GalNet.Runtime/packages.lock.json
+++ b/src/Shared/GalNet.Runtime/packages.lock.json
@@ -24,12 +24,6 @@
       },
       "galnet.core": {
         "type": "Project"
-      },
-      "galnet.presentation.abstractions": {
-        "type": "Project",
-        "dependencies": {
-          "GalNet.Core": "[1.0.0, )"
-        }
       }
     }
   }
diff --git a/src/Tooling/GalNet.SchemaGenerator/FieldSchemaGenerator.cs b/src/Tooling/GalNet.SchemaGenerator/FieldSchemaGenerator.cs
index 04c37eea..93e32e31 100644
--- a/src/Tooling/GalNet.SchemaGenerator/FieldSchemaGenerator.cs
+++ b/src/Tooling/GalNet.SchemaGenerator/FieldSchemaGenerator.cs
@@ -76,6 +76,9 @@ private static void Generate(SourceProductionContext output, GeneratorAttributeS
             fields.Add((property, id, item.Attribute!, defaultValue));
         }
         var code = new StringBuilder("// <auto-generated/>\n#nullable enable\n");
+        var jsonContext = type.ContainingAssembly.GetAttributes().FirstOrDefault(attribute =>
+            attribute.AttributeClass?.ToDisplayString() == "GalNet.Core.Parameters.FieldSchemaJsonContextAttribute")?.ConstructorArguments[0].Value as ITypeSymbol;
+        var jsonResolver = jsonContext?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) + ".Default";
         if (!type.ContainingNamespace.IsGlobalNamespace) code.Append("namespace ").Append(type.ContainingNamespace.ToDisplayString()).AppendLine(";");
         code.Append("partial class @").Append(type.Name).Append(" : global::GalNet.Core.Parameters.IFieldDto, global::GalNet.Core.Parameters.IFieldSchema<")
             .Append(type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)).AppendLine(">\n{");
@@ -86,21 +89,42 @@ private static void Generate(SourceProductionContext output, GeneratorAttributeS
         {
             var field = fields[i];
             var valueType = field.Member.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
-            var constraints = field.Attribute.NamedArguments.Where(argument => argument.Key is "Minimum" or "Maximum" or "MaxLength" or "ValueFormat" or "Choices")
-                .Select(argument => "[" + Quote(argument.Key == "ValueFormat" ? "format" : argument.Key == "Choices" ? "options" : char.ToLowerInvariant(argument.Key[0]) + argument.Key.Substring(1)) + "] = " +
-                    (argument.Key == "Choices" ? "new string[] { " + string.Join(", ", argument.Value.Values.Select(choice => choice.ToCSharpString())) + " }" : argument.Value.ToCSharpString()));
+            var constraints = field.Attribute.NamedArguments.Where(argument => argument.Key is "Minimum" or "Maximum" or "MaxLength" or "ValueFormat")
+                .Select(argument => "[" + Quote(argument.Key == "ValueFormat" ? "format" : char.ToLowerInvariant(argument.Key[0]) + argument.Key.Substring(1)) + "] = " + argument.Value.ToCSharpString());
+            var declaredChoices = field.Attribute.NamedArguments.FirstOrDefault(argument => argument.Key == "Choices");
+            var choices = declaredChoices.Key == null ? "null" : "new string[] { " + string.Join(", ", declaredChoices.Value.Values.Select(choice => choice.ToCSharpString())) + " }";
             var converter = field.Member.GetAttributes().FirstOrDefault(attribute => attribute.AttributeClass?.ToDisplayString() == "System.Text.Json.Serialization.JsonConverterAttribute");
             var options = converter == null ? "null" : "new global::System.Text.Json.JsonSerializerOptions { Converters = { new " +
                 ((ITypeSymbol)converter.ConstructorArguments[0].Value!).ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) + "() } }";
+            if (jsonContext != null) options = "global::GalNet.Core.Serialization.JsonMetadata.CreateOptions(" + options + ", " + jsonResolver + ")";
             code.Append("var v").Append(i).Append(" = new global::GalNet.Core.Parameters.ValueDescriptor(typeof(").Append(valueType)
-                .Append("), allowNull: ").Append(Named(field.Attribute, "AllowNull", "null")).Append(", constraints: global::System.Text.Json.JsonSerializer.SerializeToElement(new global::System.Collections.Generic.Dictionary<string, object?> { ")
-                .Append(string.Join(", ", constraints)).Append(" }), jsonOptions: ").Append(options).AppendLine(");");
+                .Append("), allowNull: ").Append(Named(field.Attribute, "AllowNull", "null")).Append(", constraints: global::GalNet.Core.Serialization.JsonCodec.SerializeToElement(new global::System.Collections.Generic.Dictionary<string, object?> { ")
+                .Append(string.Join(", ", constraints)).Append(" }), jsonOptions: ").Append(options).Append(", choices: ").Append(choices).AppendLine(");");
+            var structure = field.Attribute.NamedArguments.FirstOrDefault(argument => argument.Key == "StructureType");
+            if (structure.Value.Value is ITypeSymbol structureType)
+                code.Append("v").Append(i).Append(" = v").Append(i)
+                    .Append(".WithStructure(global::GalNet.Core.Parameters.ValueStructure.ForType(typeof(")
+                    .Append(structureType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)).Append("), allowsJsonString: ")
+                    .Append(Named(field.Attribute, "StructureAllowsJsonString", "false")).Append(", ignoresCase: ")
+                    .Append(Named(field.Attribute, "StructureIgnoresCase", "false")).Append(", usesFieldIds: ")
+                    .Append(Named(field.Attribute, "StructureUsesFieldIds", "false")).AppendLine("));");
+            var schemaType = structure.Value.Value as ITypeSymbol ?? field.Member.Type;
+            while (true)
+            {
+                if (schemaType is IArrayTypeSymbol array) { schemaType = array.ElementType; continue; }
+                if (schemaType is INamedTypeSymbol collection && collection.IsGenericType &&
+                    collection.ContainingNamespace.ToDisplayString() == "System.Collections.Generic") { schemaType = collection.TypeArguments.Last(); continue; }
+                break;
+            }
+            if (schemaType.GetAttributes().Any(attribute => attribute.AttributeClass?.ToDisplayString() == "GalNet.Core.Parameters.GenerateFieldSchemaAttribute"))
+                code.Append("v").Append(i).Append(" = v").Append(i).Append(".WithSchemaProvider(static () => ")
+                    .Append(schemaType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)).AppendLine(".Schema);");
         }
         code.AppendLine("return global::System.Array.AsReadOnly(new global::GalNet.Core.Parameters.FieldDescriptor[] {");
         for (var i = 0; i < fields.Count; i++)
         {
             var field = fields[i];
-            code.Append("new(").Append(Quote(field.Id)).Append(", v").Append(i).Append(", isRequired: ")
+            code.Append("new global::GalNet.Core.Parameters.FieldDescriptor(").Append(Quote(field.Id)).Append(", v").Append(i).Append(", isRequired: ")
                 .Append(field.Member.IsRequired || field.Member.GetAttributes().Any(attribute => attribute.AttributeClass?.ToDisplayString() == "System.Text.Json.Serialization.JsonRequiredAttribute")
                     ? "true" : Named(field.Attribute, "Required", "false"))
                 .Append(", defaultValue: ").Append(field.Attribute.NamedArguments.FirstOrDefault(argument => argument.Key == "DefaultJson") is var jsonDefault && jsonDefault.Key != null
@@ -115,7 +139,11 @@ private static void Generate(SourceProductionContext output, GeneratorAttributeS
                 .Append(", semantic: global::GalNet.Core.Parameters.FieldValueSemantic.")
                 .Append(field.Member.GetAttributes().Any(attribute => attribute.AttributeClass?.ToDisplayString() == "GalNet.Core.Parameters.LocalizedTextAttribute")
                     ? "LocalizedText" : field.Member.GetAttributes().Any(attribute => attribute.AttributeClass?.ToDisplayString() == "GalNet.Core.Parameters.CharacterReferenceAttribute")
-                        ? "CharacterReference" : "None").AppendLine("),");
+                        ? "CharacterReference" : "None")
+                .Append(", resourceTypeId: ").Append(Named(field.Attribute, "ResourceTypeId", "null"))
+                .Append(").WithMember(").Append(Quote(field.Member.Name)).Append(", ")
+                .Append(field.Member.GetAttributes().FirstOrDefault(attribute => attribute.AttributeClass?.ToDisplayString() == "System.Text.Json.Serialization.JsonPropertyNameAttribute")
+                    ?.ConstructorArguments[0].ToCSharpString() ?? "null").AppendLine("),");
         }
         code.AppendLine("});\n}");
         code.AppendLine("object? global::GalNet.Core.Parameters.IFieldDto.ReadField(string id) => id switch {");
diff --git a/src/Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj b/src/Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj
index d2a824b0..41e9be24 100644
--- a/src/Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj
+++ b/src/Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj
@@ -1,5 +1,9 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk" TreatAsLocalProperty="PublishAot;SelfContained;RuntimeIdentifier">
   <PropertyGroup>
+    <!-- This analyzer runs inside the compiler, independent of the player's publish target. -->
+    <PublishAot>false</PublishAot>
+    <SelfContained>false</SelfContained>
+    <RuntimeIdentifier />
     <TargetFramework>netstandard2.0</TargetFramework>
     <IsRoslynComponent>true</IsRoslynComponent>
     <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
diff --git a/src/Tooling/GalNet.SchemaGenerator/packages.lock.WindowsReadyToRun.json b/src/Tooling/GalNet.SchemaGenerator/packages.lock.WindowsReadyToRun.json
new file mode 100644
index 00000000..8e66b52b
--- /dev/null
+++ b/src/Tooling/GalNet.SchemaGenerator/packages.lock.WindowsReadyToRun.json
@@ -0,0 +1,121 @@
+{
+  "version": 2,
+  "dependencies": {
+    ".NETStandard,Version=v2.0": {
+      "Microsoft.CodeAnalysis.CSharp": {
+        "type": "Direct",
+        "requested": "[4.14.0, )",
+        "resolved": "4.14.0",
+        "contentHash": "568a6wcTivauIhbeWcCwfWwIn7UV7MeHEBvFB2uzGIpM2OhJ4eM/FZ8KS0yhPoNxnSpjGzz7x7CIjTxhslojQA==",
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+          "Microsoft.CodeAnalysis.Common": "[4.14.0]",
+          "System.Buffers": "4.5.1",
+          "System.Collections.Immutable": "9.0.0",
+          "System.Memory": "4.5.5",
+          "System.Numerics.Vectors": "4.5.0",
+          "System.Reflection.Metadata": "9.0.0",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0",
+          "System.Text.Encoding.CodePages": "7.0.0",
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        }
+      },
+      "NETStandard.Library": {
+        "type": "Direct",
+        "requested": "[2.0.3, )",
+        "resolved": "2.0.3",
+        "contentHash": "st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "1.1.0"
+        }
+      },
+      "Microsoft.CodeAnalysis.Analyzers": {
+        "type": "Transitive",
+        "resolved": "3.11.0",
+        "contentHash": "v/EW3UE8/lbEYHoC2Qq7AR/DnmvpgdtAMndfQNmpuIMx/Mto8L5JnuCfdBYtgvalQOtfNCnxFejxuRrryvUTsg=="
+      },
+      "Microsoft.CodeAnalysis.Common": {
+        "type": "Transitive",
+        "resolved": "4.14.0",
+        "contentHash": "PC3tuwZYnC+idaPuoC/AZpEdwrtX7qFpmnrfQkgobGIWiYmGi5MCRtl5mx6QrfMGQpK78X2lfIEoZDLg/qnuHg==",
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+          "System.Buffers": "4.5.1",
+          "System.Collections.Immutable": "9.0.0",
+          "System.Memory": "4.5.5",
+          "System.Numerics.Vectors": "4.5.0",
+          "System.Reflection.Metadata": "9.0.0",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0",
+          "System.Text.Encoding.CodePages": "7.0.0",
+          "System.Threading.Tasks.Extensions": "4.5.4"
+        }
+      },
+      "Microsoft.NETCore.Platforms": {
+        "type": "Transitive",
+        "resolved": "1.1.0",
+        "contentHash": "kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A=="
+      },
+      "System.Buffers": {
+        "type": "Transitive",
+        "resolved": "4.5.1",
+        "contentHash": "Rw7ijyl1qqRS0YQD/WycNst8hUUMgrMH4FCn1nNm27M4VxchZ1js3fVjQaANHO5f3sN4isvP4a+Met9Y4YomAg=="
+      },
+      "System.Collections.Immutable": {
+        "type": "Transitive",
+        "resolved": "9.0.0",
+        "contentHash": "QhkXUl2gNrQtvPmtBTQHb0YsUrDiDQ2QS09YbtTTiSjGcf7NBqtYbrG/BE06zcBPCKEwQGzIv13IVdXNOSub2w==",
+        "dependencies": {
+          "System.Memory": "4.5.5",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
+        }
+      },
+      "System.Memory": {
+        "type": "Transitive",
+        "resolved": "4.5.5",
+        "contentHash": "XIWiDvKPXaTveaB7HVganDlOCRoj03l+jrwNvcge/t8vhGYKvqV+dMv6G4SAX2NoNmN0wZfVPTAlFwZcZvVOUw==",
+        "dependencies": {
+          "System.Buffers": "4.5.1",
+          "System.Numerics.Vectors": "4.4.0",
+          "System.Runtime.CompilerServices.Unsafe": "4.5.3"
+        }
+      },
+      "System.Numerics.Vectors": {
+        "type": "Transitive",
+        "resolved": "4.5.0",
+        "contentHash": "QQTlPTl06J/iiDbJCiepZ4H//BVraReU4O4EoRw1U02H5TLUIT7xn3GnDp9AXPSlJUDyFs4uWjWafNX6WrAojQ=="
+      },
+      "System.Reflection.Metadata": {
+        "type": "Transitive",
+        "resolved": "9.0.0",
+        "contentHash": "ANiqLu3DxW9kol/hMmTWbt3414t9ftdIuiIU7j80okq2YzAueo120M442xk1kDJWtmZTqWQn7wHDvMRipVOEOQ==",
+        "dependencies": {
+          "System.Collections.Immutable": "9.0.0",
+          "System.Memory": "4.5.5"
+        }
+      },
+      "System.Runtime.CompilerServices.Unsafe": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg=="
+      },
+      "System.Text.Encoding.CodePages": {
+        "type": "Transitive",
+        "resolved": "7.0.0",
+        "contentHash": "LSyCblMpvOe0N3E+8e0skHcrIhgV2huaNcjUUEa8hRtgEAm36aGkRoC8Jxlb6Ra6GSfF29ftduPNywin8XolzQ==",
+        "dependencies": {
+          "System.Memory": "4.5.5",
+          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
+        }
+      },
+      "System.Threading.Tasks.Extensions": {
+        "type": "Transitive",
+        "resolved": "4.5.4",
+        "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg==",
+        "dependencies": {
+          "System.Runtime.CompilerServices.Unsafe": "4.5.3"
+        }
+      }
+    },
+    ".NETStandard,Version=v2.0/win-x64": {}
+  }
+}
\ No newline at end of file
diff --git a/test/Directory.Build.props b/test/Directory.Build.props
index 44dba930..b6a6ce67 100644
--- a/test/Directory.Build.props
+++ b/test/Directory.Build.props
@@ -16,4 +16,9 @@
   <ItemGroup>
     <Using Include="NUnit.Framework" />
   </ItemGroup>
+
+  <ItemGroup Condition="'$(MSBuildProjectName)' == 'GalNet.Assets.Tests' Or '$(MSBuildProjectName)' == 'GalNet.Editor.Shared.Tests' Or '$(MSBuildProjectName)' == 'GalNet.IntegrationTests'">
+    <Compile Include="$(MSBuildThisFileDirectory)Support/DirectoryLinks.cs" Link="Support/DirectoryLinks.cs" />
+    <Using Include="GalNet.TestSupport" />
+  </ItemGroup>
 </Project>
diff --git a/test/Fixtures/SchemaA/ProjectSchemas.cs b/test/Fixtures/SchemaA/ProjectSchemas.cs
index 3387cc0a..acff2293 100644
--- a/test/Fixtures/SchemaA/ProjectSchemas.cs
+++ b/test/Fixtures/SchemaA/ProjectSchemas.cs
@@ -1,12 +1,22 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
+using GalNet.Core.Parameters;
 using GalNet.Core.Primitives;
 
 namespace GalNet.Project.Contracts;
 
 public static class ProjectSchemas
 {
+    public static ProjectConfigurationSchema Configurations { get; } = new([
+        DefaultProjectConfiguration.Section,
+        new ConfigurationSection<ProjectOptions>("developer.options", [
+            new("count", new ValueDescriptor(typeof(int), allowNull: false)),
+            new("limit", new ValueDescriptor(typeof(int), allowNull: false)),
+            new("caption", new ValueDescriptor(typeof(string), allowNull: true))
+        ], options => { if (options.Count > options.Limit) throw new InvalidDataException("Count exceeds limit."); })
+    ]);
     public static IReadOnlyList<IEntryModule> Modules { get; } = Array.AsReadOnly<IEntryModule>(
     [
         BuiltinSchemas.CreateDialogueModule(),
@@ -15,6 +25,13 @@ public static class ProjectSchemas
     ]);
 }
 
+public sealed class ProjectOptions
+{
+    public int Count { get; set; } = 1;
+    public int Limit { get; set; } = 10;
+    public string? Caption { get; set; } = "Default";
+}
+
 internal sealed class BundleEntry : CompositeEntry
 {
     public override string Type => "custom.bundle";
diff --git a/test/GalNet.Architecture.Tests/ProjectDependencyTests.cs b/test/GalNet.Architecture.Tests/ProjectDependencyTests.cs
index 5cc51f07..893fed65 100644
--- a/test/GalNet.Architecture.Tests/ProjectDependencyTests.cs
+++ b/test/GalNet.Architecture.Tests/ProjectDependencyTests.cs
@@ -10,17 +10,20 @@ public class ProjectDependencyTests
         new Dictionary<string, string[]>(StringComparer.Ordinal)
         {
             ["GalNet.Core"] = [],
+            ["GalNet.Diagnostics"] = [],
             ["GalNet.Contracts.Builtins"] = ["GalNet.Core", "GalNet.SchemaGenerator"],
             ["GalNet.Sample.Contracts"] = ["GalNet.Core", "GalNet.Contracts.Builtins", "GalNet.SchemaGenerator"],
             ["GalNet.SchemaGenerator"] = [],
-            ["GalNet.Presentation.Abstractions"] = ["GalNet.Core"],
-            ["GalNet.GameHost"] = ["GalNet.Core", "GalNet.Runtime", "GalNet.Presentation.Abstractions"],
-            ["GalNet.Runtime"] = ["GalNet.Core", "GalNet.Presentation.Abstractions"],
+            ["GalNet.Presentation.Abstractions"] = ["GalNet.Contracts.Builtins", "GalNet.Core"],
+            ["GalNet.GameHost"] = ["GalNet.Contracts.Builtins", "GalNet.Core", "GalNet.Runtime", "GalNet.Presentation.Abstractions"],
+            ["GalNet.Runtime"] = ["GalNet.Core"],
             ["GalNet.Debugging"] = ["GalNet.Runtime"],
             ["GalNet.Primitives.Builtins"] = ["GalNet.Core", "GalNet.Contracts.Builtins", "GalNet.Presentation.Abstractions", "GalNet.Runtime"],
-            ["GalNet.Media.LibVlc"] = ["GalNet.Core", "GalNet.Assets", "GalNet.Presentation.Abstractions"],
-            ["GalNet.Assets"] = ["GalNet.Core"],
-            ["GalNet.Storage.FileSystem"] = ["GalNet.Core", "GalNet.Runtime", "GalNet.Assets", "GalNet.GameHost"],
+            ["GalNet.Media.Audio"] = ["GalNet.Contracts.Builtins", "GalNet.Core"],
+            ["GalNet.Media.Miniaudio"] = ["GalNet.Contracts.Builtins", "GalNet.Core", "GalNet.Media.Audio"],
+            ["GalNet.Media.LibVlc"] = ["GalNet.Contracts.Builtins", "GalNet.Core", "GalNet.Assets", "GalNet.Presentation.Abstractions"],
+            ["GalNet.Assets"] = ["GalNet.Contracts.Builtins", "GalNet.Core"],
+            ["GalNet.Storage.FileSystem"] = ["GalNet.Contracts.Builtins", "GalNet.Core", "GalNet.Runtime", "GalNet.Assets", "GalNet.GameHost"],
             ["GalNet.Editor.Abstraction"] = ["GalNet.Core"],
             ["GalNet.Editor.DefaultContracts"] = ["GalNet.Contracts.Builtins"],
             ["GalNet.Editor.Shared"] =
@@ -32,22 +35,23 @@ public class ProjectDependencyTests
                 "GalNet.Runtime",
                 "GalNet.Assets"
             ],
-            ["GalNet.Avalonia.GameHost"] = ["GalNet.Storage.FileSystem", "GalNet.Media.LibVlc", "GalNet.GameHost", "GalNet.Avalonia.Controls", "GalNet.Avalonia.GameView", "GalNet.Avalonia.Rendering", "GalNet.Primitives.Builtins", "GalNet.Runtime", "GalNet.Presentation.Abstractions", "GalNet.Assets", "GalNet.Core"],
-            ["GalNet.Avalonia.Controls"] = ["GalNet.Core"],
-            ["GalNet.Avalonia.Themes"] = ["GalNet.Avalonia.Controls", "GalNet.Avalonia.GameView"],
+            ["GalNet.Avalonia.GameHost"] = ["GalNet.Contracts.Builtins", "GalNet.Storage.FileSystem", "GalNet.Media.LibVlc", "GalNet.Media.Miniaudio", "GalNet.GameHost", "GalNet.Avalonia.Controls", "GalNet.Avalonia.GameView", "GalNet.Avalonia.Rendering", "GalNet.Primitives.Builtins", "GalNet.Runtime", "GalNet.Presentation.Abstractions", "GalNet.Assets", "GalNet.Core"],
+            ["GalNet.Avalonia.Controls"] = ["GalNet.Contracts.Builtins", "GalNet.Core"],
+            ["GalNet.Avalonia.Themes"] = ["GalNet.Contracts.Builtins", "GalNet.Avalonia.Controls", "GalNet.Avalonia.GameView"],
             ["GalNet.Avalonia.GameView"] =
-            [
+            ["GalNet.Contracts.Builtins",
                 "GalNet.Avalonia.Controls", "GalNet.Avalonia.Rendering",
                 "GalNet.Presentation.Abstractions", "GalNet.Core", "GalNet.Assets"
             ],
-            ["GalNet.Avalonia.Rendering"] = ["GalNet.Core"]
+            ["GalNet.Avalonia.Rendering"] = ["GalNet.Contracts.Builtins", "GalNet.Core"]
         };
 
     private static readonly IReadOnlyDictionary<string, string[]> AllowedTestDependencies =
         new Dictionary<string, string[]>(StringComparer.Ordinal)
         {
             ["GalNet.Architecture.Tests"] = [],
-            ["GalNet.Debugging.Tests"] = ["GalNet.Debugging"],
+            ["GalNet.Diagnostics.Tests"] = ["GalNet.Diagnostics"],
+            ["GalNet.Debugging.Tests"] = ["GalNet.Debugging", "GalNet.Presentation.Abstractions"],
             ["GalNet.GameHost.Tests"] = ["GalNet.GameHost"],
             ["GalNet.Core.Tests"] = ["GalNet.Core"],
             ["GalNet.Runtime.Tests"] = ["GalNet.Core", "GalNet.Presentation.Abstractions", "GalNet.Runtime"],
@@ -59,9 +63,9 @@ public class ProjectDependencyTests
                 "GalNet.Contracts.Builtins",
                 "GalNet.Runtime"
             ],
-            ["GalNet.Assets.Tests"] = ["GalNet.Assets", "GalNet.Core"],
+            ["GalNet.Assets.Tests"] = ["GalNet.Contracts.Builtins", "GalNet.Assets", "GalNet.Core"],
             ["GalNet.Storage.FileSystem.Tests"] =
-            [
+            ["GalNet.GameHost", "GalNet.Contracts.Builtins",
                 "GalNet.Assets",
                 "GalNet.Core",
                 "GalNet.Runtime",
@@ -69,6 +73,7 @@ public class ProjectDependencyTests
             ],
             ["GalNet.Editor.Shared.Tests"] =
             [
+                "GalNet.Editor.DefaultContracts",
                 "GalNet.Editor.Headless",
                 "SchemaA", "SchemaB", "SchemaDuplicate", "SchemaInvalid", "SchemaIncompatible",
                 "GalNet.Core",
@@ -78,7 +83,7 @@ public class ProjectDependencyTests
                 "GalNet.Contracts.Builtins"
             ],
             ["GalNet.Editor.Tests"] =
-            [
+            ["GalNet.GameHost",
                 "GalNet.SchemaGenerator",
                 "SchemaA", "SchemaB",
                 "GalNet.Core",
@@ -89,7 +94,7 @@ public class ProjectDependencyTests
                 "GalNet.Contracts.Builtins"
             ],
             ["GalNet.Presentation.Tests"] =
-            [
+            ["GalNet.Contracts.Builtins", "GalNet.Media.Miniaudio",
                 "GalNet.Media.LibVlc",
                 "GalNet.SchemaGenerator",
                 "GalNet.Assets",
@@ -101,9 +106,10 @@ public class ProjectDependencyTests
                 "GalNet.Presentation.Abstractions",
                 "GalNet.Runtime"
             ],
+            ["GalNet.Media.Audio.Tests"] = ["GalNet.Media.Miniaudio", "GalNet.Primitives.Builtins"],
             ["GalNet.SchemaGenerator.Tests"] = ["GalNet.SchemaGenerator", "GalNet.Core"],
             ["GalNet.IntegrationTests"] =
-            [
+            ["GalNet.GameHost",
                 "GalNet.Assets",
                 "GalNet.Core",
                 "GalNet.Editor.Abstraction",
diff --git a/test/GalNet.Assets.Tests/AssetFileMaterializerTests.cs b/test/GalNet.Assets.Tests/AssetFileMaterializerTests.cs
index 6fdda29e..49b25b75 100644
--- a/test/GalNet.Assets.Tests/AssetFileMaterializerTests.cs
+++ b/test/GalNet.Assets.Tests/AssetFileMaterializerTests.cs
@@ -1,5 +1,6 @@
 using GalNet.Assets;
 using GalNet.Assets.Provider;
+using GalNet.Contracts.Builtins.Assets;
 
 namespace GeneralTest.Assets;
 
@@ -14,7 +15,7 @@ public async Task ConcurrentConsumersShareFileUntilTheLastLeaseAndSurviveOwnerDi
         {
             await File.WriteAllBytesAsync(Path.Combine(root, "clip.mp4"), [1, 2, 3]);
             await File.WriteAllTextAsync(Path.Combine(root, "clip.mp4.meta"), """{"id":"clip","type":"video","path":"clip.mp4","compress":"none"}""");
-            using var assets = new AssetManager([new LocalFileProvider(root)]);
+            using var assets = new AssetManager([new LocalFileProvider(root, BuiltinResourceTypes.CreateCatalog())]);
             await using var files = new AssetFileMaterializer(assets);
             var leases = await Task.WhenAll(files.AcquireAsync("clip"), files.AcquireAsync("CLIP"));
             try
@@ -42,7 +43,7 @@ public async Task CancellationDoesNotPoisonTheNextAcquire()
         {
             await File.WriteAllBytesAsync(Path.Combine(root, "clip.mp4"), [1]);
             await File.WriteAllTextAsync(Path.Combine(root, "clip.mp4.meta"), """{"id":"clip","type":"video","path":"clip.mp4","compress":"none"}""");
-            using var assets = new AssetManager([new LocalFileProvider(root)]);
+            using var assets = new AssetManager([new LocalFileProvider(root, BuiltinResourceTypes.CreateCatalog())]);
             await using var files = new AssetFileMaterializer(assets);
             Assert.That(() => files.AcquireAsync("clip", new CancellationToken(true)), Throws.InstanceOf<OperationCanceledException>());
             using var lease = await files.AcquireAsync("clip");
diff --git a/test/GalNet.Assets.Tests/AssetPipelineTests.cs b/test/GalNet.Assets.Tests/AssetPipelineTests.cs
index 8b3f522c..e82a4a83 100644
--- a/test/GalNet.Assets.Tests/AssetPipelineTests.cs
+++ b/test/GalNet.Assets.Tests/AssetPipelineTests.cs
@@ -1,5 +1,6 @@
 using System.Text.Json;
 using GalNet.Assets.Provider;
+using GalNet.Contracts.Builtins.Assets;
 using GalNet.Core.Assets;
 
 namespace GalNet.Assets.Tests;
@@ -12,8 +13,8 @@ public void Pak_roundtrip_preserves_registered_meta_dto_and_type_id()
         var meta = new SpriteAssetMeta { Id = "opening", TypeId = "sprite", Path = "cg/opening.png", Filter = "nearest" };
         var original = new GameFile(meta.Id, meta.Path, meta.TypeId, meta, "png"u8.ToArray());
 
-        var pak = Archive.Serialize("assets", [original]);
-        using var archive = Archive.Deserialize("assets", pak);
+        var pak = Archive.Serialize("assets", [original], BuiltinResourceTypes.CreateCatalog());
+        using var archive = Archive.Deserialize("assets", pak, BuiltinResourceTypes.CreateCatalog());
         var loaded = archive.GetAsset("opening");
 
         Assert.That(loaded, Is.Not.Null);
@@ -34,7 +35,7 @@ public async Task Local_provider_deserializes_typed_meta()
             await File.WriteAllBytesAsync(resourcePath, "png"u8.ToArray());
             var meta = new SpriteAssetMeta { Id = "opening", TypeId = "sprite", Path = "cg/opening.png", Filter = "bilinear" };
             await File.WriteAllTextAsync(resourcePath + ".meta", JsonSerializer.Serialize(meta));
-            using var provider = new LocalFileProvider(root);
+            using var provider = new LocalFileProvider(root, BuiltinResourceTypes.CreateCatalog());
             using var archive = await provider.OpenArchiveAsync("assets");
 
             var file = archive.GetAsset("opening");
@@ -58,7 +59,7 @@ public async Task Local_provider_infers_missing_type_and_path_and_preserves_unkn
             var resourcePath = Path.Combine(root, "cg", "opening.png");
             await File.WriteAllBytesAsync(resourcePath, "png"u8.ToArray());
             await File.WriteAllTextAsync(resourcePath + ".meta", """{ "id": "opening", "futureField": true }""");
-            using var provider = new LocalFileProvider(root);
+            using var provider = new LocalFileProvider(root, BuiltinResourceTypes.CreateCatalog());
             using var archive = await provider.OpenArchiveAsync("assets");
 
             var file = archive.GetAsset("opening");
@@ -81,7 +82,7 @@ public async Task Local_provider_reports_invalid_metadata_instead_of_skipping_th
         {
             await File.WriteAllBytesAsync(Path.Combine(root, "broken.png"), "png"u8.ToArray());
             await File.WriteAllTextAsync(Path.Combine(root, "broken.png.meta"), "{ invalid json");
-            using var provider = new LocalFileProvider(root);
+            using var provider = new LocalFileProvider(root, BuiltinResourceTypes.CreateCatalog());
 
             var exception = Assert.ThrowsAsync<InvalidDataException>(() => provider.OpenArchiveAsync("assets"));
             Assert.That(exception!.Message, Does.Contain("broken.png.meta"));
@@ -96,7 +97,7 @@ public async Task Local_provider_reports_invalid_metadata_instead_of_skipping_th
     public async Task Decoder_dispatches_by_resource_type_and_target_type()
     {
         var sprite = new GameFile("sprite", "a.png", "sprite", new SpriteAssetMeta { Id = "sprite", TypeId = "sprite", Path = "a.png" }, "sprite"u8.ToArray());
-        var audio = new GameFile("audio", "a.ogg", "audio", new AudioAssetMeta { Id = "audio", TypeId = "audio", Path = "a.ogg" }, "audio"u8.ToArray());
+        var audio = new GameFile("audio", "a.ogg", "audio", new AssetMeta { Id = "audio", TypeId = "audio", Path = "a.ogg" }, "audio"u8.ToArray());
         using var manager = new AssetManager([new InlineProvider(sprite, audio)]);
         manager.RegisterDecoder<Decoded>("sprite", new ConstantDecoder("image"));
         manager.RegisterDecoder<Decoded>("audio", new ConstantDecoder("sound"));
diff --git a/test/GalNet.Assets.Tests/ContentPackageContractTests.cs b/test/GalNet.Assets.Tests/ContentPackageContractTests.cs
new file mode 100644
index 00000000..385d3810
--- /dev/null
+++ b/test/GalNet.Assets.Tests/ContentPackageContractTests.cs
@@ -0,0 +1,191 @@
+using System.Buffers.Binary;
+using System.Text;
+using GalNet.Assets.Provider;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Core.Assets;
+
+namespace GalNet.Assets.Tests;
+
+public sealed class ContentPackageContractTests
+{
+    private static readonly IResourceTypeCatalog Types = BuiltinResourceTypes.CreateCatalog();
+
+    [TestCase("base")]
+    [TestCase("story")]
+    [TestCase("override")]
+    public void Purpose_roundtrips_separately_from_resource_types(string kind)
+    {
+        var descriptor = new PakDescriptor
+        {
+            Kind = kind,
+            ProjectId = "game",
+            BuildId = "build",
+            PackageId = kind == "base" ? "" : "extra",
+            Priority = kind == "override" ? 3 : 0,
+            Mappings = kind == "override" ? new() { ["original"] = "replacement" } : []
+        };
+        var bytes = PakBuilder.Build("ignored-filename", [Sprite("replacement")], Types, descriptor: descriptor);
+        using var archive = Archive.Deserialize("renamed", bytes, Types);
+        Assert.Multiple(() =>
+        {
+            Assert.That(archive.Descriptor.Kind, Is.EqualTo(kind));
+            Assert.That(archive.Descriptor.ProjectId, Is.EqualTo("game"));
+            Assert.That(archive.GetAsset("REPLACEMENT")!.TypeId, Is.EqualTo("sprite"));
+            Assert.That(archive.Descriptor.Mappings, Is.EquivalentTo(descriptor.Mappings));
+        });
+        archive.Descriptor.Mappings.Clear();
+        Assert.That(archive.Descriptor.Mappings.Count, Is.EqualTo(descriptor.Mappings.Count));
+    }
+
+    [Test]
+    public void Purpose_rejects_unknown_kinds_invalid_combinations_and_missing_targets()
+    {
+        PakDescriptor[] invalid =
+        [
+            new() { Kind = "unknown" },
+            new() { Kind = "story", PackageId = "extra" },
+            new() { Priority = 1 },
+            new() { PartIndex = 1 },
+            new() { Kind = "override", PackageId = "extra", PartCount = 2 },
+            new() { Kind = "override", PackageId = "extra", Mappings = new() { ["a"] = "b", ["b"] = "a" } },
+            new() { Kind = "override", PackageId = "extra", Mappings = new(StringComparer.Ordinal) { ["a"] = "B", ["b"] = "A" } },
+            new() { Kind = "override", PackageId = "extra", Mappings = new() { ["a"] = "missing" } }
+        ];
+        foreach (var descriptor in invalid)
+            Assert.Throws<InvalidDataException>(() => PakBuilder.Build("assets", [Sprite("b")], Types, descriptor: descriptor));
+    }
+
+    [Test]
+    public void Pak_order_is_deterministic_and_hashes_actual_bytes_not_stale_file_hash()
+    {
+        var a = Sprite("a");
+        var b = Sprite("b");
+        var stale = new GameFile(a.Id, a.Path, a.TypeId, a.Metadata, a.ReadAllBytes(), new string('0', 64));
+        var first = PakBuilder.Build("first", [b, stale], Types);
+        Assert.That(first, Is.EqualTo(PakBuilder.Build("second", [a, b], Types)));
+        using var archive = Archive.Deserialize("assets", first, Types);
+        Assert.That(archive.GetAsset("a")!.Hash, Is.EqualTo(CryptoHelper.HashSHA256(a.ReadAllBytes())));
+    }
+
+    [Test]
+    public void Pak_rejects_old_version_truncation_duplicate_identity_and_corrupt_data()
+    {
+        var original = PakBuilder.Build("assets", [Sprite("a")], Types);
+        var old = original.ToArray();
+        BinaryPrimitives.WriteInt32LittleEndian(old.AsSpan(4), 2);
+        Assert.Throws<InvalidDataException>(() => Archive.Deserialize("assets", old, Types));
+        foreach (var size in new[] { 0, 4, 8, 12, original.Length - 1 })
+            Assert.Throws<InvalidDataException>(() => Archive.Deserialize("assets", original[..size], Types));
+        Assert.Throws<InvalidDataException>(() => PakBuilder.Build("assets", [Sprite("a"), Sprite("A")], Types));
+        var corrupt = original.ToArray();
+        corrupt[^1] ^= 1;
+        using var archive = Archive.Deserialize("assets", corrupt, Types);
+        Assert.Throws<InvalidDataException>(() => archive.GetAsset("a"));
+    }
+
+    [TestCase("{\"kind\":\"base\",\"kind\":\"story\"}")]
+    [TestCase("{\"kind\":\"other\"}")]
+    [TestCase("{\"kind\":\"base\",\"typo\":true}")]
+    public void Pak_control_json_is_strict(string json)
+    {
+        var pak = PakBuilder.Build("assets", [], Types);
+        var previousLength = BinaryPrimitives.ReadInt32LittleEndian(pak.AsSpan(8));
+        using var stream = new MemoryStream();
+        using (var writer = new BinaryWriter(stream, Encoding.UTF8, true))
+        {
+            writer.Write(pak.AsSpan(0, 8));
+            var control = Encoding.UTF8.GetBytes(json);
+            writer.Write(control.Length);
+            writer.Write(control);
+            writer.Write(pak.AsSpan(12 + previousLength));
+        }
+        Assert.Throws<InvalidDataException>(() => Archive.Deserialize("assets", stream.ToArray(), Types));
+    }
+
+    [Test]
+    public void Closure_distinguishes_leaves_unknowns_and_declared_dynamic_roots()
+    {
+        var unknown = new GameFile("dynamic", "dynamic.bin", "data", new AssetMeta
+        { Id = "dynamic", Path = "dynamic.bin", TypeId = "data" }, []);
+        var root = Dependent("root", [new("a", "sprite"), new("dynamic")]);
+        var files = new[] { root, Sprite("a"), unknown, Sprite("unused") };
+        var result = AssetDependencyCollector.Collect(files, [" ROOT "], Types);
+        Assert.That(result.Files.Select(file => file.Id), Is.EquivalentTo(new[] { "root", "a", "dynamic" }));
+        Assert.That(result.IncompleteAssetIds, Is.EqualTo(new[] { "dynamic" }));
+        Assert.That(AssetDependencyCollector.Collect(files, ["root"], Types, declaredComplete: ["dynamic"]).Complete, Is.True);
+    }
+
+    [Test]
+    public void Closure_checks_each_reference_type_handles_cycles_and_honors_cancellation()
+    {
+        var first = Dependent("a", [new("b")]);
+        var second = Dependent("b", [new("a")]);
+        Assert.That(AssetDependencyCollector.Collect([first, second], ["a"], Types).Files, Has.Count.EqualTo(2));
+        Assert.Throws<InvalidDataException>(() => AssetDependencyCollector.Collect([first], ["a"], Types));
+        var badType = Dependent("root", [new("sprite", "sprite"), new("sprite", "audio")]);
+        Assert.Throws<InvalidDataException>(() => AssetDependencyCollector.Collect([badType, Sprite("sprite")], ["root"], Types));
+        using var cancelled = new CancellationTokenSource();
+        cancelled.Cancel();
+        Assert.Throws<OperationCanceledException>(() => AssetDependencyCollector.Collect([first, second], ["a"], Types, cancellationToken: cancelled.Token));
+    }
+
+    [Test]
+    public void Only_graph_references_may_cross_an_optional_story_boundary()
+    {
+        var types = new ResourceTypeCatalogBuilder().Add<DependentAssetMeta>("graph").Add<DependentAssetMeta>("group").Build();
+        var meta = new DependentAssetMeta
+        {
+            Id = "graph",
+            TypeId = "graph",
+            Path = "graph",
+            DependenciesComplete = true,
+            Dependencies = [new("optional", "group", "extra")]
+        };
+        var graph = new GameFile(meta.Id, meta.Path, meta.TypeId, meta, []);
+        Assert.That(AssetDependencyCollector.Collect([graph], ["graph"], types).Files, Has.Count.EqualTo(1));
+        Assert.Throws<InvalidDataException>(() => AssetDependencyCollector.Collect([graph], ["graph"], types, storyPackage: "extra"));
+        var group = Dependent("group", [new("optional", null, "extra")]);
+        Assert.Throws<InvalidDataException>(() => AssetDependencyCollector.Collect([group], ["group"], Types));
+    }
+
+    [Test]
+    public async Task Compiled_atlas_dependencies_match_payload_and_never_rewrite_sidecar()
+    {
+        var root = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "galnet-deps-" + Guid.NewGuid().ToString("N"))).FullName;
+        try
+        {
+            Directory.CreateDirectory(Path.Combine(root, "images"));
+            await File.WriteAllTextAsync(Path.Combine(root, "images", "idle.png"), "image");
+            await File.WriteAllTextAsync(Path.Combine(root, "images", "idle.png.meta"), """{"id":"sprite","type":"sprite"}""");
+            await File.WriteAllTextAsync(Path.Combine(root, "atlas.variants"), """{"folder":"images","default":"idle"}""");
+            const string sourceMeta = """{"id":"atlas","type":"image-variants","future":true}""";
+            await File.WriteAllTextAsync(Path.Combine(root, "atlas.variants.meta"), sourceMeta);
+            using var provider = new LocalFileProvider(root, Types);
+            using var source = await provider.OpenArchiveAsync("assets");
+            var atlas = source.GetAsset("atlas")!;
+            var metadata = (DependentAssetMeta)atlas.Metadata;
+            Assert.That(metadata.Dependencies, Is.EqualTo(new[] { new AssetDependency("sprite", "sprite") }));
+            Assert.That(metadata.ExtensionData!["future"].GetBoolean(), Is.True);
+            Assert.That(await File.ReadAllTextAsync(Path.Combine(root, "atlas.variants.meta")), Is.EqualTo(sourceMeta));
+            var selected = AssetDependencyCollector.Collect(source.AssetIds.Select(id => source.GetAsset(id)!), ["atlas"], Types);
+            using var restored = Archive.Deserialize("assets", PakBuilder.Build("assets", selected.Files, Types), Types);
+            Assert.That(((IAssetDependencies)restored.GetAsset("atlas")!.Metadata).GetDependencies().Direct, Is.EqualTo(metadata.Dependencies));
+            var bytes = PakBuilder.Build("assets", selected.Files, Types);
+            var json = Encoding.UTF8.GetString(bytes);
+            var start = json.IndexOf("\"expectedTypeId\":\"sprite\"", StringComparison.Ordinal);
+            Assert.That(start, Is.GreaterThan(0));
+            // Only ASCII precedes this field in this fixture, so character and byte offsets agree.
+            "audio "u8.CopyTo(bytes.AsSpan(start + "\"expectedTypeId\":\"".Length));
+            Assert.Throws<InvalidDataException>(() => Archive.Deserialize("assets", bytes, Types));
+            metadata.Dependencies.Clear();
+            Assert.Throws<InvalidDataException>(() => PakBuilder.Build("assets", [atlas], Types));
+        }
+        finally { Directory.Delete(root, true); }
+    }
+
+    private static GameFile Sprite(string id) => new(id, id + ".png", "sprite",
+        new SpriteAssetMeta { Id = id, Path = id + ".png", TypeId = "sprite" }, "image"u8.ToArray());
+
+    private static GameFile Dependent(string id, List<AssetDependency> dependencies) => new(id, id + ".bin", "data",
+        new DependentAssetMeta { Id = id, Path = id + ".bin", TypeId = "data", Dependencies = dependencies, DependenciesComplete = true }, []);
+}
diff --git a/test/GalNet.Assets.Tests/ContentPackagePlanningTests.cs b/test/GalNet.Assets.Tests/ContentPackagePlanningTests.cs
new file mode 100644
index 00000000..4a08fab9
--- /dev/null
+++ b/test/GalNet.Assets.Tests/ContentPackagePlanningTests.cs
@@ -0,0 +1,81 @@
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Core.Assets;
+
+namespace GalNet.Assets.Tests;
+
+public sealed class ContentPackagePlanningTests
+{
+    private static readonly IResourceTypeCatalog Types = BuiltinResourceTypes.CreateCatalog();
+    private static IGameFile[] Files() =>
+    [
+        Dependent(StoryResourceIds.Graph, "graph", [new("base", "group"), new("a", "group", "A"), new("b", "group", "B")]),
+        Dependent("base", "group", [new("shared-base", "sprite")]),
+        Dependent("a", "group", [new("shared-base", "sprite"), new("shared-extra", "sprite"), new("a-only", "sprite")]),
+        Dependent("b", "group", [new("shared-base", "sprite"), new("shared-extra", "sprite")]),
+        Sprite("shared-base"), Sprite("shared-extra"), Sprite("a-only"), Sprite("unused")
+    ];
+
+    [Test]
+    public void OptionalPackagesOnlySubtractBaseAndNeverEachOther()
+    {
+        var plan = ContentPackagePlanner.Plan(Files(), [], Types, 1000);
+        Assert.That(plan.Paks.Single(part => part.PackageId == "").Files.Select(file => file.Id), Is.EquivalentTo(new[] { StoryResourceIds.Graph, "base", "shared-base" }));
+        Assert.That(plan.Paks.Single(part => part.PackageId == "A").Files.Select(file => file.Id), Is.EquivalentTo(new[] { "a", "shared-extra", "a-only" }));
+        Assert.That(plan.Paks.Single(part => part.PackageId == "B").Files.Select(file => file.Id), Is.EquivalentTo(new[] { "b", "shared-extra" }));
+        Assert.That(plan.Unused.Select(file => file.Id), Is.EqualTo(new[] { "unused" }));
+    }
+
+    [Test]
+    public void SoftThresholdKeepsOversizedAssetsWholeAndInputOrderDoesNotChangeLayout()
+    {
+        var first = ContentPackagePlanner.Plan(Files(), [], Types, 1);
+        var second = ContentPackagePlanner.Plan(Files().Reverse().ToArray(), [], Types, 1);
+        Assert.That(first.Paks.All(part => part.Files.Count == 1), Is.True);
+        Assert.That(first.Paks.Select(part => (part.PackageId, part.PartIndex, part.PartCount, part.Files[0].Id)),
+            Is.EqualTo(second.Paks.Select(part => (part.PackageId, part.PartIndex, part.PartCount, part.Files[0].Id))));
+    }
+
+    [Test]
+    public void BaseCannotPullOptionalStoryBodyThroughAnOrdinaryDependency()
+    {
+        var files = Files();
+        ((DependentAssetMeta)files.Single(file => file.Id == "base").Metadata).Dependencies.Add(new("a", "group"));
+        Assert.Throws<InvalidDataException>(() => ContentPackagePlanner.Plan(files, [], Types, 1000));
+    }
+
+    [Test]
+    public void UnknownDynamicCoverageMustBeDeclaredAndAdditionalRootsAreExplicit()
+    {
+        var files = Files().Append(new GameFile("dynamic", "dynamic.bin", "data", new AssetMeta { Id = "dynamic", TypeId = "data", Path = "dynamic.bin" }, [1])).ToArray();
+        ((DependentAssetMeta)files.Single(file => file.Id == "base").Metadata).Dependencies.Add(new("dynamic"));
+        Assert.Throws<InvalidDataException>(() => ContentPackagePlanner.Plan(files, [], Types, 1000));
+        var plan = ContentPackagePlanner.Plan(files, ["unused"], Types, 1000, ["dynamic"]);
+        Assert.That(plan.Unused, Is.Empty);
+        Assert.That(plan.Paks.Single(part => part.PackageId == "").Files.Any(file => file.Id == "unused"), Is.True);
+    }
+
+    [Test]
+    public void NamesSupportUnicodeAndRejectCaseAliasesAndWhitespace()
+    {
+        var files = Files();
+        var graph = (DependentAssetMeta)files[0].Metadata;
+        graph.Dependencies[1] = new("a", "group", "番外 A");
+        Assert.That(ContentPackagePlanner.Plan(files, [], Types, 1000).Paks.Any(part => part.PackageId == "番外 A"), Is.True);
+        graph.Dependencies[1] = new("a", "group", "b");
+        Assert.Throws<InvalidDataException>(() => ContentPackagePlanner.Plan(files, [], Types, 1000));
+        graph.Dependencies[1] = new("a", "group", " A ");
+        Assert.Throws<InvalidDataException>(() => ContentPackagePlanner.Plan(files, [], Types, 1000));
+    }
+
+    private static GameFile Dependent(string id, string type, List<AssetDependency> dependencies) => new(id,
+        Uri.EscapeDataString(id) + ".json", type, new DependentAssetMeta
+        {
+            Id = id,
+            Path = Uri.EscapeDataString(id) + ".json",
+            TypeId = type,
+            DependenciesComplete = true,
+            Dependencies = dependencies
+        }, [1, 2]);
+    private static GameFile Sprite(string id) => new(id, id + ".png", "sprite",
+        new SpriteAssetMeta { Id = id, Path = id + ".png", TypeId = "sprite" }, [1, 2]);
+}
diff --git a/test/GalNet.Assets.Tests/FileSystemPathsTests.cs b/test/GalNet.Assets.Tests/FileSystemPathsTests.cs
new file mode 100644
index 00000000..aabd02f7
--- /dev/null
+++ b/test/GalNet.Assets.Tests/FileSystemPathsTests.cs
@@ -0,0 +1,49 @@
+using GalNet.Assets;
+
+namespace GalNet.Assets.Tests;
+
+public sealed class FileSystemPathsTests
+{
+    [TestCase("../escape")]
+    [TestCase("a/../escape")]
+    [TestCase("a//file")]
+    [TestCase("./file")]
+    [TestCase("a\\file")]
+    [TestCase("/absolute")]
+    [TestCase("")]
+    public void PackageFileNamesRejectTraversalAndNonCanonicalSegments(string path) =>
+        Assert.That(() => FileSystemPaths.ResolveRelativeFile(Path.GetTempPath(), path), Throws.TypeOf<InvalidDataException>());
+
+    [Test]
+    public void ContainmentUsesPathSegmentsAndSupportsDriveRoots()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "galnet-paths");
+        Assert.That(FileSystemPaths.IsSameOrChild(root, root), Is.True);
+        Assert.That(FileSystemPaths.IsSameOrChild(Path.Combine(root, "child"), root), Is.True);
+        Assert.That(FileSystemPaths.IsSameOrChild(root + "-sibling", root), Is.False);
+        Assert.That(FileSystemPaths.IsSameOrChild(Path.GetDirectoryName(root)!, root), Is.False);
+        Assert.That(FileSystemPaths.IsSameOrChild(root.ToUpperInvariant(), root), Is.EqualTo(OperatingSystem.IsWindows()));
+        Assert.That(FileSystemPaths.ResolveRelativeFile(Path.GetPathRoot(root)!, "folder/file"),
+            Is.EqualTo(Path.Combine(Path.GetPathRoot(root)!, "folder", "file")));
+    }
+
+    [Test]
+    public void MissingOutputCannotTraverseALinkedAncestor()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "galnet-linked-path-" + Guid.NewGuid().ToString("N"));
+        var real = Directory.CreateDirectory(Path.Combine(root, "real")).FullName;
+        var link = Path.Combine(root, "link");
+        try
+        {
+            DirectoryLinks.Create(link, real);
+            Assert.That(() => FileSystemPaths.RequireNoLinks(Path.Combine(link, "missing", "file"), "linked"),
+                Throws.TypeOf<InvalidDataException>().With.Message.EqualTo("linked"));
+            Assert.That(() => FileSystemPaths.RequireNoLinks(Path.Combine(real, "missing", "file"), "linked"), Throws.Nothing);
+        }
+        finally
+        {
+            if (Directory.Exists(link)) Directory.Delete(link);
+            Directory.Delete(root, true);
+        }
+    }
+}
diff --git a/test/GalNet.Assets.Tests/GalNet.Assets.Tests.csproj b/test/GalNet.Assets.Tests/GalNet.Assets.Tests.csproj
index 3e223d3d..3fbf809f 100644
--- a/test/GalNet.Assets.Tests/GalNet.Assets.Tests.csproj
+++ b/test/GalNet.Assets.Tests/GalNet.Assets.Tests.csproj
@@ -6,4 +6,5 @@
         <ProjectReference Include="..\..\src\Shared\GalNet.Assets\GalNet.Assets.csproj" />
         <ProjectReference Include="..\..\src\Shared\GalNet.Core\GalNet.Core.csproj" />
     </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../src/Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/test/GalNet.Assets.Tests/ImageVariantsJsonBoundaryTests.cs b/test/GalNet.Assets.Tests/ImageVariantsJsonBoundaryTests.cs
new file mode 100644
index 00000000..a3dd9882
--- /dev/null
+++ b/test/GalNet.Assets.Tests/ImageVariantsJsonBoundaryTests.cs
@@ -0,0 +1,18 @@
+using System.Text;
+using System.Text.Json;
+using GalNet.Assets.Variants;
+
+namespace GeneralTest.Assets;
+
+public sealed class ImageVariantsJsonBoundaryTests
+{
+    [TestCase("""{"folder":"a","folder":"b"}""")]
+    [TestCase("""{"folder":"a","dimensions":[{"key":"pose","key":"mood"}]}""")]
+    public void SourceRejectsDuplicatesAtEveryObjectDepth(string json) =>
+        Assert.That(() => ImageVariantsCodec.ReadSource(Encoding.UTF8.GetBytes(json)), Throws.TypeOf<JsonException>());
+
+    [TestCase("""{"kind":"image-variants","version":1,"version":1}""")]
+    [TestCase("""{"kind":"image-variants","version":1,"default":"a","dimensions":[{"key":"pose"}],"variants":[{"key":"a","assetId":"a","assetId":"b"}]}""")]
+    public void CompiledPayloadRejectsDuplicatesAtEveryObjectDepth(string json) =>
+        Assert.That(() => ImageVariantsCodec.Decode(Encoding.UTF8.GetBytes(json)), Throws.TypeOf<JsonException>());
+}
diff --git a/test/GalNet.Assets.Tests/ImageVariantsPipelineTests.cs b/test/GalNet.Assets.Tests/ImageVariantsPipelineTests.cs
index 5ae7548b..3a2f1184 100644
--- a/test/GalNet.Assets.Tests/ImageVariantsPipelineTests.cs
+++ b/test/GalNet.Assets.Tests/ImageVariantsPipelineTests.cs
@@ -1,8 +1,9 @@
 using System.Text.Json;
 using GalNet.Assets.Provider;
 using GalNet.Assets.Variants;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
-using GalNet.Core.Variants;
 
 namespace GalNet.Assets.Tests;
 
@@ -44,7 +45,7 @@ public async Task Local_and_real_Pak_provider_decode_identically_without_the_aut
         using (var archive = await provider.OpenArchiveAsync("assets"))
         {
             var file = archive.GetAsset("atlas")!;
-            Assert.That(file.Metadata, Is.TypeOf<ImageVariantsAssetMeta>());
+            Assert.That(file.Metadata, Is.TypeOf<DependentAssetMeta>());
             Assert.That(file.Path, Is.EqualTo("alice.variants"));
             localBytes = file.ReadAllBytes();
             Assert.That(System.Text.Encoding.UTF8.GetString(localBytes), Does.Not.Contain("folder"));
@@ -160,6 +161,7 @@ public void Source_parser_rejects_duplicate_or_unknown_properties(string json)
     [Test]
     public void Runtime_decoder_rejects_author_payload_and_malformed_compiled_facts()
     {
+        Assert.That(() => ImageVariantsCodec.Decode("""{"kind":"image-variants","version":1,"default":"idle_coat","dimensions":[{"key":"d1"}],"variants":[{"key":"idle_coat","assetId":"sprite"}]}"""u8.ToArray()), Throws.TypeOf<InvalidDataException>());
         Assert.That(() => ImageVariantsCodec.Decode("""{"folder":"alice","default":"weap"}"""u8.ToArray()), Throws.Exception);
         Assert.That(() => ImageVariantsCodec.Decode("""{"kind":"image-variants","version":99,"default":"weap","dimensions":[],"variants":[]}"""u8.ToArray()), Throws.TypeOf<InvalidDataException>());
         Assert.That(() => ImageVariantsCodec.Decode("""{"kind":"image-variants","version":1,"default":"weap","dimensions":[{"key":"d1"}],"variants":[{"key":"weap","assetId":""}]}"""u8.ToArray()), Throws.TypeOf<InvalidDataException>());
@@ -170,8 +172,7 @@ public void Directory_links_are_rejected_without_following_them()
     {
         Fixture();
         var link = Path.Combine(Assets, "linked");
-        try { Directory.CreateSymbolicLink(link, Path.Combine(Assets, "alice")); }
-        catch (Exception exception) when (exception is UnauthorizedAccessException or IOException) { Assert.Ignore("Symbolic links unavailable: " + exception.Message); }
+        DirectoryLinks.Create(link, Path.Combine(Assets, "alice"));
         try
         {
             using var provider = new LocalFileProvider(Assets, Types);
@@ -207,18 +208,26 @@ public async Task Catalog_preparation_rejects_missing_or_non_sprite_dependencies
         byte[] payload;
         using (var provider = new LocalFileProvider(Assets, Types))
         using (var archive = await provider.OpenArchiveAsync("assets")) payload = archive.GetAsset("atlas")!.ReadAllBytes();
-        var meta = new ImageVariantsAssetMeta { Id = "atlas", Path = "alice.variants", TypeId = "image-variants" };
+        var meta = new DependentAssetMeta
+        {
+            Id = "atlas",
+            Path = "alice.variants",
+            TypeId = "image-variants",
+            DependenciesComplete = true,
+            Dependencies = ImageVariantsCodec.Decode(payload).Variants
+                .Select(variant => new AssetDependency(variant.AssetId, "sprite")).ToList()
+        };
         var files = new List<IGameFile> { new GameFile(meta.Id, meta.Path, meta.TypeId, meta, payload) };
         foreach (var key in new[] { "idle_coat", "idle_skirt", "smile_coat", "smile_skirt", "weap" })
         {
             if (key == "weap" && !wrongType) continue;
-            AssetMeta sprite = key == "weap" ? new AudioAssetMeta() : new SpriteAssetMeta();
+            AssetMeta sprite = key == "weap" ? new AssetMeta() : new SpriteAssetMeta();
             sprite.Id = "sprite-" + key;
             sprite.TypeId = key == "weap" ? "audio" : "sprite";
             sprite.Path = "alice/" + key + ".png";
             files.Add(new GameFile(sprite.Id, sprite.Path, sprite.TypeId, sprite, [1]));
         }
-        File.WriteAllBytes(Path.Combine(_root, "assets.pak"), PakBuilder.Build("assets", files));
+        File.WriteAllBytes(Path.Combine(_root, "assets.pak"), PakBuilder.Build("assets", files, Types));
         using var manager = new AssetManager([new PakFileProvider(_root, Types)]);
         manager.RegisterImageVariantsDecoder();
         Assert.ThrowsAsync<InvalidDataException>(() => manager.LoadImageVariantsCatalogAsync());
diff --git a/test/GalNet.Assets.Tests/PakStreamProviderTests.cs b/test/GalNet.Assets.Tests/PakStreamProviderTests.cs
new file mode 100644
index 00000000..938d6b69
--- /dev/null
+++ b/test/GalNet.Assets.Tests/PakStreamProviderTests.cs
@@ -0,0 +1,119 @@
+using GalNet.Assets.Provider;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Core.Assets;
+
+namespace GalNet.Assets.Tests;
+
+public sealed class PakStreamProviderTests
+{
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task Non_seekable_stream_is_owned_and_closed_before_returning_an_independent_archive(bool asynchronous)
+    {
+        var bytes = CreatePak();
+        var streams = new List<ReadStream>();
+        var provider = new PakStreamProvider(new Dictionary<string, Func<Stream>>
+        {
+            ["assets.pak"] = () => { var stream = new ReadStream(bytes); streams.Add(stream); return stream; }
+        }, BuiltinResourceTypes.CreateCatalog());
+
+        Assert.That(provider.Exists("ASSETS"), Is.True);
+        Assert.That(provider.Exists("missing"), Is.False);
+        Assert.That(streams, Is.Empty, "Manifest lookup must not open the resource.");
+        using var archive = asynchronous ? await provider.OpenArchiveAsync("assets") : provider.OpenArchive("assets");
+        using var second = await provider.OpenArchiveAsync("ASSETS.PAK");
+        Assert.That(streams, Has.Count.EqualTo(2));
+        Assert.That(streams.All(stream => stream.Closed), Is.True);
+        Assert.That(archive.GetAsset("clip")!.ReadAllBytes(), Is.EqualTo(new byte[] { 1, 2, 3 }));
+        Assert.That(second.GetAsset("clip")!.Path, Is.EqualTo("音频/clip.ogg"));
+    }
+
+    [Test]
+    public async Task Cancellation_during_copy_disposes_stream_and_does_not_poison_next_open()
+    {
+        using var cancellation = new CancellationTokenSource();
+        var canceled = new ReadStream(CreatePak(), () => cancellation.Cancel());
+        var calls = 0;
+        var provider = new PakStreamProvider(new Dictionary<string, Func<Stream>>
+        {
+            ["assets"] = () => ++calls == 1 ? canceled : new ReadStream(CreatePak())
+        }, BuiltinResourceTypes.CreateCatalog());
+        Assert.That(() => provider.OpenArchiveAsync("assets", cancellation.Token), Throws.InstanceOf<OperationCanceledException>());
+        Assert.That(canceled.Closed, Is.True);
+        using var archive = await provider.OpenArchiveAsync("assets");
+        Assert.That(archive.Contains("clip"), Is.True);
+        Assert.That(() => provider.OpenArchiveAsync("assets", cancellation.Token), Throws.InstanceOf<OperationCanceledException>());
+        Assert.That(calls, Is.EqualTo(2), "Pre-canceled requests must not open a stream.");
+    }
+
+    [Test]
+    public void Missing_corrupt_and_duplicate_archives_are_reported_without_leaking_streams()
+    {
+        var stream = new ReadStream("invalid PAK"u8.ToArray());
+        var provider = new PakStreamProvider(new Dictionary<string, Func<Stream>> { ["assets"] = () => stream }, BuiltinResourceTypes.CreateCatalog());
+        Assert.Throws<FileNotFoundException>(() => provider.OpenArchive("missing"));
+        Assert.ThrowsAsync<InvalidDataException>(() => provider.OpenArchiveAsync("assets"));
+        Assert.That(stream.Closed, Is.True);
+        Assert.Throws<ArgumentException>(() => new PakStreamProvider(new Dictionary<string, Func<Stream>>
+        {
+            ["assets"] = () => Stream.Null,
+            ["ASSETS.pak"] = () => Stream.Null
+        }, BuiltinResourceTypes.CreateCatalog()));
+    }
+
+    [Test]
+    public async Task Packaged_asset_materializes_under_host_cache_and_survives_owner_disposal_until_last_lease()
+    {
+        var root = Path.Combine(Path.GetTempPath(), $"galnet-packaged-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(root);
+        var sentinel = Path.Combine(root, "host-owned.txt");
+        await File.WriteAllTextAsync(sentinel, "keep");
+        try
+        {
+            var provider = new PakStreamProvider(new Dictionary<string, Func<Stream>> { ["assets"] = () => new ReadStream(CreatePak()) }, BuiltinResourceTypes.CreateCatalog());
+            using var assets = new AssetManager([provider]);
+            await using var files = new AssetFileMaterializer(assets, root);
+            using var first = await files.AcquireAsync("clip");
+            using var second = await files.AcquireAsync("clip");
+            Assert.That(Path.GetRelativePath(root, first.Path), Does.StartWith("GalNet" + Path.DirectorySeparatorChar));
+            Assert.That(first.Path, Is.EqualTo(second.Path));
+            Assert.That(await File.ReadAllBytesAsync(first.Path), Is.EqualTo(new byte[] { 1, 2, 3 }));
+            await files.DisposeAsync();
+            first.Dispose();
+            Assert.That(File.Exists(second.Path), Is.True);
+            second.Dispose();
+            Assert.That(Directory.Exists(Path.GetDirectoryName(second.Path)), Is.False);
+            Assert.That(File.Exists(sentinel), Is.True);
+        }
+        finally { Directory.Delete(root, true); }
+    }
+
+    private static byte[] CreatePak()
+    {
+        var meta = new AssetMeta { Id = "clip", TypeId = "audio", Path = "音频/clip.ogg" };
+        return Archive.Serialize("assets", [new GameFile(meta.Id, meta.Path, meta.TypeId, meta, [1, 2, 3])], BuiltinResourceTypes.CreateCatalog());
+    }
+
+    private sealed class ReadStream(byte[] bytes, Action? onRead = null) : Stream
+    {
+        private readonly MemoryStream _inner = new(bytes);
+        public bool Closed { get; private set; }
+        public override bool CanRead => !Closed;
+        public override bool CanSeek => false;
+        public override bool CanWrite => false;
+        public override long Length => throw new NotSupportedException();
+        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
+        public override int Read(byte[] buffer, int offset, int count) => _inner.Read(buffer, offset, count);
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            onRead?.Invoke();
+            return _inner.ReadAsync(buffer, cancellationToken);
+        }
+        protected override void Dispose(bool disposing) { Closed = true; if (disposing) _inner.Dispose(); base.Dispose(disposing); }
+        public override void Flush() => throw new NotSupportedException();
+        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+        public override void SetLength(long value) => throw new NotSupportedException();
+        public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+    }
+}
diff --git a/test/GalNet.Assets.Tests/ResourceOverrideTests.cs b/test/GalNet.Assets.Tests/ResourceOverrideTests.cs
new file mode 100644
index 00000000..e4817c7d
--- /dev/null
+++ b/test/GalNet.Assets.Tests/ResourceOverrideTests.cs
@@ -0,0 +1,162 @@
+using System.Text;
+using GalNet.Assets.Provider;
+using GalNet.Assets.Variants;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Variants;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+
+namespace GalNet.Assets.Tests;
+
+public sealed class ResourceOverrideTests
+{
+    private static readonly IResourceTypeCatalog Types = BuiltinResourceTypes.CreateCatalog();
+    private static IGameFile File(string id, string content, string type = "sprite")
+    {
+        var meta = type == "sprite" ? (AssetMeta)new SpriteAssetMeta() : new AssetMeta();
+        meta.Id = id; meta.Path = id + (type == "sprite" ? ".png" : ".bin"); meta.TypeId = type;
+        return new GameFile(id, meta.Path, type, meta, Encoding.UTF8.GetBytes(content));
+    }
+    private static ResourceOverrideDefinition Definition(string id, int priority = 0, params (string From, string To)[] mappings) =>
+        new() { Id = id, Priority = priority, Mappings = mappings.ToDictionary(pair => pair.From, pair => pair.To) };
+    private static ResourceOverrideSource Patch(ResourceOverrideDefinition definition, params IGameFile[] available)
+    {
+        var bytes = ResourceOverrideBuilder.Build("project", definition, available, Types);
+        var provider = new MemoryProvider(bytes);
+        using var archive = provider.OpenArchive("assets");
+        return new(((IPakArchive)archive).Descriptor, CryptoHelper.HashSHA256(bytes), archive.AssetIds.Select(id => new ResourceFileSource(archive.GetAsset(id)!, provider)).ToArray());
+    }
+    private static ResourceFileSource[] Base(params IGameFile[] files)
+    {
+        var provider = new MemoryProvider(PakBuilder.Build("assets", files, Types));
+        using var archive = provider.OpenArchive("assets");
+        return archive.AssetIds.Select(id => new ResourceFileSource(archive.GetAsset(id)!, provider)).ToArray();
+    }
+
+    [TestCase("sprite")]
+    [TestCase("audio")]
+    [TestCase("video")]
+    public async Task LogicalFileAcquirePathAndMediaShareTheSameReplacement(string type)
+    {
+        var a = File("a", "coat-A", type); var b = File("b", "coat-B", type);
+        var patch = Patch(Definition("clothes", 0, ("a", "b")), a, b);
+        using var manager = new AssetManager([new ResourceOverlayProvider(Base(a), [patch], Types)]);
+        var file = await manager.GetFileAsync(" a ");
+        Assert.That(file!.Id, Is.EqualTo("a"));
+        Assert.That(file.Path, Is.EqualTo(a.Path));
+        Assert.That(file.Metadata.Id, Is.EqualTo("a"));
+        Assert.That(Encoding.UTF8.GetString(file.ReadAllBytes()), Is.EqualTo("coat-B"));
+        using var handle = await manager.AcquireAsync<string>("A");
+        using var pathHandle = await manager.AcquireByPathAsync<string>(a.Path);
+        Assert.That(handle!.Value, Is.EqualTo("coat-B"));
+        Assert.That(pathHandle!.Value, Is.EqualTo("coat-B"));
+        await using var materializer = new AssetFileMaterializer(manager);
+        using var lease = await materializer.AcquireAsync("a");
+        Assert.That(System.IO.File.ReadAllText(lease.Path), Is.EqualTo("coat-B"));
+    }
+
+    [Test]
+    public async Task PriorityThenWholePakHashWinsRegardlessOfOrderOrDuplicates()
+    {
+        var a = File("a", "A"); var b = File("b", "B"); var c = File("c", "C");
+        var left = Patch(Definition("left", 0, ("a", "b")), a, b);
+        var right = Patch(Definition("right", 0, ("a", "c")), a, c);
+        var expected = StringComparer.Ordinal.Compare(left.Sha256, right.Sha256) > 0 ? "B" : "C";
+        foreach (var order in new[] { new[] { left, right, left }, new[] { right, left } })
+        {
+            using var manager = new AssetManager([new ResourceOverlayProvider(Base(a), order, Types)]);
+            using var handle = await manager.AcquireAsync<string>("a");
+            Assert.That(handle!.Value, Is.EqualTo(expected));
+        }
+        var high = Patch(Definition("higher", 3, ("a", "b")), a, b);
+        using var higher = new AssetManager([new ResourceOverlayProvider(Base(a), [right, high], Types)]);
+        using var selected = await higher.AcquireAsync<string>("a");
+        Assert.That(selected!.Value, Is.EqualTo("B"));
+    }
+
+    [Test]
+    public async Task MappingOnlyAppliesOnceAndCarriedTargetsCannotImplicitlyOverrideBase()
+    {
+        var a = File("a", "A"); var b = File("b", "B"); var c = File("c", "C");
+        var patch = Patch(Definition("chain", 0, ("a", "b"), ("b", "c")), a, b, c);
+        using var manager = new AssetManager([new ResourceOverlayProvider(Base(a, b), [patch], Types)]);
+        using var aValue = await manager.AcquireAsync<string>("a");
+        using var bValue = await manager.AcquireAsync<string>("b");
+        Assert.That(aValue!.Value, Is.EqualTo("B"));
+        Assert.That(bValue!.Value, Is.EqualTo("C"));
+        var changedB = File("b", "changed-B");
+        var single = Patch(Definition("one", 0, ("a", "b")), a, changedB);
+        using var originalB = new AssetManager([new ResourceOverlayProvider(Base(a, b), [single], Types)]);
+        using var unchanged = await originalB.AcquireAsync<string>("b");
+        Assert.That(unchanged!.Value, Is.EqualTo("B"));
+    }
+
+    [Test]
+    public async Task AtlasCarriesReplacementSpritesAndPreservesTheOriginalLogicalAtlas()
+    {
+        var aSprite = File("a-sprite", "A"); var bSprite = File("b-sprite", "B");
+        var a = Atlas("a", "a-sprite"); var b = Atlas("b", "b-sprite");
+        var patch = Patch(Definition("clothes", 0, ("a", "b")), a, aSprite, b, bSprite);
+        Assert.That(patch.Files.Select(file => file.Index.Id), Is.EquivalentTo(new[] { "b", "b-sprite" }));
+        using var manager = new AssetManager([new ResourceOverlayProvider(Base(a, aSprite), [patch], Types)]);
+        manager.RegisterImageVariantsDecoder();
+        using var atlas = await manager.AcquireAsync<ImageVariantsDefinition>("a");
+        Assert.That(atlas!.Value.Default.AssetId, Is.EqualTo("b-sprite"));
+        using var pixels = await manager.AcquireAsync<string>(atlas.Value.Default.AssetId);
+        Assert.That(pixels!.Value, Is.EqualTo("B"));
+    }
+
+    [Test]
+    public void InvalidTargetsTypesStoryResourcesAndChangedDependencyIdsAreRejected()
+    {
+        var a = File("a", "A");
+        Assert.Throws<InvalidDataException>(() => Patch(Definition("missing", 0, ("a", "missing")), a));
+        Assert.Throws<InvalidDataException>(() => Patch(Definition("type", 0, ("a", "b")), a, File("b", "B", "audio")));
+        Assert.Throws<InvalidDataException>(() => Patch(Definition("graph", 0, ("a", "b")), File("a", "A", "graph"), File("b", "B", "graph")));
+        var original = Atlas("a", "sprite"); var replacement = Atlas("b", "sprite");
+        var patch = Patch(Definition("conflict", 0, ("a", "b")), original, replacement, File("sprite", "changed"));
+        Assert.Throws<InvalidDataException>(() => new ResourceOverlayProvider(Base(original, File("sprite", "base")), [patch], Types));
+        Assert.Throws<InvalidDataException>(() => Patch(Definition("shape", 0, ("a", "b")), original, Atlas("b", "sprite", "different"), File("sprite", "S")));
+    }
+
+    [Test]
+    public void OverrideDefinitionKeepsCaseInsensitiveResourceIdentityAfterJsonRoundtrip()
+    {
+        var definition = Definition("case", 0, ("ORIGINAL", "replacement"));
+        var saved = GalNet.Core.Serialization.JsonCodec.Serialize(definition);
+        var restored = GalNet.Core.Serialization.JsonCodec.Deserialize<ResourceOverrideDefinition>(saved)!;
+        Assert.That(restored.Mappings["original"], Is.EqualTo("replacement"));
+        restored.Mappings["Original"] = "new-replacement";
+        Assert.That(restored.Mappings.Count, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void EquivalentMappingOrdersHaveIdenticalPakHashes()
+    {
+        var files = new[] { File("a", "A"), File("b", "B"), File("c", "C"), File("d", "D") };
+        var first = ResourceOverrideBuilder.Build("project", Definition("same", 0, ("a", "b"), ("c", "d")), files, Types);
+        var second = ResourceOverrideBuilder.Build("project", Definition("same", 0, ("c", "d"), ("a", "b")), files.Reverse().ToArray(), Types);
+        Assert.That(CryptoHelper.HashSHA256(first), Is.EqualTo(CryptoHelper.HashSHA256(second)));
+    }
+
+    private static IGameFile Atlas(string id, string sprite, string key = "idle")
+    {
+        var definition = ImageVariantsBuilder.Build(new() { Folder = ".", Default = key }, [new ImageVariantFile(key + ".png", sprite)]).Definition!;
+        var metadata = new DependentAssetMeta
+        {
+            Id = id,
+            TypeId = "image-variants",
+            Path = id + ".variants",
+            DependenciesComplete = true,
+            Dependencies = [new(sprite, "sprite")]
+        };
+        return new GameFile(id, metadata.Path, metadata.TypeId, metadata, ImageVariantsCodec.Encode(definition));
+    }
+    private sealed class MemoryProvider(byte[] bytes) : IAssetProvider
+    {
+        public string Name => "memory";
+        public bool Exists(string name) => true;
+        public IArchive OpenArchive(string name) => Archive.Deserialize(name, bytes, Types);
+        public Task<IArchive> OpenArchiveAsync(string name, CancellationToken ct = default) => Task.FromResult(OpenArchive(name));
+    }
+}
diff --git a/test/GalNet.Assets.Tests/packages.lock.json b/test/GalNet.Assets.Tests/packages.lock.json
index df3e40f6..1304a49d 100644
--- a/test/GalNet.Assets.Tests/packages.lock.json
+++ b/test/GalNet.Assets.Tests/packages.lock.json
@@ -112,6 +112,13 @@
         "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
       },
       "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
         "type": "Project",
         "dependencies": {
           "GalNet.Core": "[1.0.0, )"
diff --git a/test/GalNet.Core.Tests/Configuration/ProjectConfigurationTests.cs b/test/GalNet.Core.Tests/Configuration/ProjectConfigurationTests.cs
new file mode 100644
index 00000000..30993572
--- /dev/null
+++ b/test/GalNet.Core.Tests/Configuration/ProjectConfigurationTests.cs
@@ -0,0 +1,118 @@
+using System.Text.Json;
+using GalNet.Core.Configuration;
+using GalNet.Core.Parameters;
+
+namespace GeneralTest.Configuration;
+
+public sealed class ProjectConfigurationTests
+{
+    private static readonly ConfigurationSection<Options> Section = new("custom.example",
+    [new("count", new ValueDescriptor(typeof(int), constraints: JsonSerializer.SerializeToElement(new { minimum = 1 })),
+        isRequired: true, defaultValue: JsonSerializer.SerializeToElement(3)),
+     new("names", new ValueDescriptor(typeof(List<string>), allowNull: false))]);
+
+    [Test]
+    public void DefaultsAndReadsAreDetachedAndDoNotPersistImplicitly()
+    {
+        var configuration = new ProjectConfiguration();
+        var options = configuration.Read(Section);
+        Assert.That(options.Count, Is.EqualTo(3));
+        options.Names.Add("caller");
+        Assert.That(configuration.Sections, Is.Empty);
+        Assert.That(configuration.Read(Section).Names, Is.Empty);
+        configuration.Set(Section, options);
+        options.Names.Clear();
+        var read = configuration.Read(Section);
+        read.Names.Add("local");
+        Assert.That(configuration.Read(Section).Names, Is.EqualTo(new[] { "caller" }));
+    }
+
+    [Test]
+    public void TypedWritesPreserveUnknownSectionsAndFieldsAndOwnTheirJson()
+    {
+        var configuration = new ProjectConfiguration();
+        using (var json = JsonDocument.Parse("""{"count":4,"future":{"items":[9007199254740993,null]}}"""))
+            configuration.SetRaw(Section.Id, new(1, json.RootElement));
+        using (var json = JsonDocument.Parse("""{"enabled":true}"""))
+            configuration.SetRaw("unknown", new(7, json.RootElement));
+        var options = configuration.Read(Section);
+        options.Count = 5;
+        configuration.Set(Section, options);
+        var clone = configuration.Clone();
+        configuration.Remove("unknown");
+        var restored = JsonSerializer.Deserialize<ProjectConfiguration>(JsonSerializer.Serialize(clone))!;
+        Assert.That(restored.Read(Section).Count, Is.EqualTo(5));
+        Assert.That(restored.Sections[Section.Id].Data.GetProperty("future").GetProperty("items")[0].GetInt64(), Is.EqualTo(9007199254740993L));
+        Assert.That(restored.Sections["unknown"].Version, Is.EqualTo(7));
+        Assert.That(restored.Sections["unknown"].Data.GetProperty("enabled").GetBoolean(), Is.True);
+    }
+
+    [TestCase("{}")]
+    [TestCase("{\"version\":2,\"sections\":{}}")]
+    [TestCase("{\"version\":\"1\",\"sections\":{}}")]
+    [TestCase("{\"version\":1,\"sections\":{},\"sections\":{}}")]
+    [TestCase("{\"version\":1,\"sections\":{\"a\":{\"version\":\"1\",\"data\":{}}}}")]
+    [TestCase("{\"version\":1,\"sections\":{\"a\":{\"version\":1,\"data\":{\"nested\":{\"x\":1,\"x\":2}}}}}")]
+    public void InvalidEnvelopeOrDuplicateMembersAreRejected(string json) =>
+        Assert.That(() => JsonSerializer.Deserialize<ProjectConfiguration>(json), Throws.TypeOf<JsonException>());
+
+    [TestCase("{\"count\":\"invalid\"}")]
+    [TestCase("{\"count\":0}")]
+    [TestCase("{\"count\":2,\"names\":null}")]
+    public void SchemaRejectsKnownInvalidFieldsWithoutInterpretingUnknownSections(string data)
+    {
+        var configuration = new ProjectConfiguration();
+        configuration.SetRaw("unknown", new(17, JsonSerializer.SerializeToElement(new { count = "opaque" })));
+        var schema = new ProjectConfigurationSchema([Section]);
+        Assert.That(() => schema.Validate(configuration), Throws.Nothing);
+        configuration.SetRaw(Section.Id, new(1, JsonSerializer.Deserialize<JsonElement>(data)));
+        Assert.That(() => schema.Validate(configuration), Throws.TypeOf<InvalidDataException>());
+    }
+
+    [Test]
+    public void UnknownFieldCasingDoesNotBypassDeclaredFieldValidation()
+    {
+        var configuration = new ProjectConfiguration();
+        configuration.SetRaw(Section.Id, new(1, JsonSerializer.Deserialize<JsonElement>("""{"count":4,"Count":0}""")));
+        Assert.That(configuration.Read(Section).Count, Is.EqualTo(4));
+        configuration.Set(Section, new() { Count = 5 });
+        Assert.That(configuration.Read(Section).Count, Is.EqualTo(5));
+        Assert.That(configuration.Sections[Section.Id].Data.GetProperty("Count").GetInt32(), Is.Zero);
+    }
+
+    [Test]
+    public void RejectedUpdateRetainsOldValuesAndValidUpdateCanRepairInvalidKnownData()
+    {
+        var configuration = new ProjectConfiguration();
+        configuration.Set(Section, new() { Count = 4 });
+        Assert.That(() => configuration.Set(Section, new() { Count = 0 }), Throws.TypeOf<InvalidDataException>());
+        Assert.That(configuration.Read(Section).Count, Is.EqualTo(4));
+        configuration.SetRaw(Section.Id, new(1, JsonSerializer.Deserialize<JsonElement>("""{"count":0,"future":true}""")));
+        configuration.Set(Section, new() { Count = 8 });
+        Assert.That(configuration.Read(Section).Count, Is.EqualTo(8));
+        Assert.That(configuration.Sections[Section.Id].Data.GetProperty("future").GetBoolean(), Is.True);
+        configuration.SetRaw(Section.Id, new(2, JsonSerializer.SerializeToElement(new { count = 5 })));
+        Assert.That(() => configuration.Set(Section, new() { Count = 6 }), Throws.TypeOf<InvalidDataException>());
+    }
+
+    [Test]
+    public void DefaultsAndRequiredValuesUseFieldSchema()
+    {
+        var section = new ConfigurationSection<Options>("custom.defaults",
+            [new("count", new ValueDescriptor(typeof(int)), defaultValue: JsonSerializer.SerializeToElement(9))]);
+        var configuration = new ProjectConfiguration();
+        Assert.That(configuration.Read(section).Count, Is.EqualTo(9));
+        configuration.Set(section, configuration.Read(section));
+        Assert.That(configuration.Read(section).Count, Is.EqualTo(9));
+        var required = new ConfigurationSection<Options>("required", [new("count", new ValueDescriptor(typeof(int)), isRequired: true)]);
+        Assert.That(configuration.Read(required).Count, Is.EqualTo(1), "An absent section uses the DTO constructor defaults.");
+        Assert.That(() => required.Read(new(1, JsonSerializer.Deserialize<JsonElement>("{}"))), Throws.TypeOf<InvalidDataException>());
+    }
+
+    public sealed class Options
+    {
+        public int Count { get; set; } = 1;
+        public List<string> Names { get; set; } = [];
+    }
+
+}
diff --git a/test/GalNet.Core.Tests/Entry/DtoExecutionTests.cs b/test/GalNet.Core.Tests/Entry/DtoExecutionTests.cs
index 6015e228..c14dba1d 100644
--- a/test/GalNet.Core.Tests/Entry/DtoExecutionTests.cs
+++ b/test/GalNet.Core.Tests/Entry/DtoExecutionTests.cs
@@ -125,7 +125,7 @@ public void TypedCompositePreservesNullDefaultsAndCompiledEnvelope()
         {
             Entries = [new() { Id = "invalid", Type = "test.expand", Parameters = new() { ["unknown"] = JsonSerializer.SerializeToElement(1) } }]
         }, catalog), Throws.TypeOf<InvalidDataException>().With.Message.Contains("unknown"));
-        var authoring = (CompositeEntry)catalog.Create("test.expand", values: new Dictionary<string, string> { ["name"] = "manual" });
+        var authoring = (CompositeEntry)catalog.Create("test.expand", arguments: JsonSerializer.SerializeToElement(new { name = "manual" }));
         authoring.Compile(new EntryCompileContext { SourceEntryId = "manual", Condition = "" });
         Assert.That(received[1].Name, Is.EqualTo("manual"));
         Assert.That(received[1].Numbers, Is.Not.SameAs(received[0].Numbers));
diff --git a/test/GalNet.Core.Tests/Entry/FieldDescriptorTests.cs b/test/GalNet.Core.Tests/Entry/FieldDescriptorTests.cs
index 6ba1e4e7..745751c9 100644
--- a/test/GalNet.Core.Tests/Entry/FieldDescriptorTests.cs
+++ b/test/GalNet.Core.Tests/Entry/FieldDescriptorTests.cs
@@ -8,6 +8,36 @@ namespace GeneralTest.Entry;
 
 public class FieldDescriptorTests
 {
+    [TestCase(".3", "0.3")]
+    [TestCase(".22", "0.22")]
+    [TestCase("-.22", "-0.22")]
+    [TestCase(" .3e-2 ", "0.003")]
+    public void FractionalEditorShorthandIsTypedAndDoesNotRelaxJson(string input, string expected)
+    {
+        foreach (var type in new[] { typeof(float), typeof(double), typeof(decimal), typeof(float?) })
+            Assert.That(ValueCodec.FromEditorText(new(type), input).GetDecimal(), Is.EqualTo(decimal.Parse(expected, System.Globalization.CultureInfo.InvariantCulture)));
+        Assert.That(ValueCodec.FromEditorText(new(typeof(string)), input).GetString(), Is.EqualTo(input));
+        Assert.That(() => ValueCodec.ParseEditorText(new(typeof(int)), input), Throws.InstanceOf<JsonException>());
+        Assert.That(() => JsonDocument.Parse(input), Throws.InstanceOf<JsonException>());
+    }
+
+    [TestCase("-", true)]
+    [TestCase(".", true)]
+    [TestCase("-.", true)]
+    [TestCase("1.", true)]
+    [TestCase("-1.", true)]
+    [TestCase("1e-", true)]
+    [TestCase(".3e+", true)]
+    [TestCase("hello", false)]
+    [TestCase(".3", false)]
+    [TestCase("1e--", false)]
+    public void NumericPrefixesAreOnlyTransientInput(string input, bool incomplete)
+    {
+        Assert.That(ValueCodec.IsIncompleteEditorNumber(new(typeof(float)), input), Is.EqualTo(incomplete));
+        Assert.That(ValueCodec.IsIncompleteEditorNumber(new(typeof(string)), input), Is.False);
+        if (incomplete) Assert.That(() => ValueCodec.FromEditorText(new(typeof(float)), input), Throws.InstanceOf<JsonException>());
+    }
+
     private static readonly string[] ExpectedFieldIds = ["z", "a"];
     [Test]
     public void EntryFieldsRetainInputOrderAndCannotBeEditedAfterConstruction()
@@ -33,21 +63,6 @@ public void DefaultIsValidatedAndClonedWhileRequiredAndNullStayIndependent()
         Assert.Throws<ArgumentException>(() => new FieldDescriptor("int", new(typeof(int)), defaultValue: field.DefaultValue));
     }
 
-    [Test]
-    public void BuiltinEditorHintsAreSeparateFromLegalOptionsAndPreserveLegacyEditorTypes()
-    {
-        var types = Enum.GetValues<EntryParameterType>();
-        var parameters = EntrySchema.DynamicParameters(types.ToDictionary(type => type.ToString(), type => type),
-            options: EntrySchema.Options(("Select", ["first", "second"])));
-        foreach (var type in types)
-        {
-            Assert.That(EntrySchema.GetEditorType(parameters[type.ToString()]), Is.EqualTo(type));
-            Assert.That(parameters[type.ToString()].TryGetConstraint("editorType", out _), Is.False);
-        }
-        Assert.That(parameters["Select"].Editor!.EditorId, Is.EqualTo(ValueEditorIds.Choice));
-        Assert.Throws<ArgumentException>(() => parameters["Select"].Validate(JsonSerializer.SerializeToElement("other")));
-    }
-
     [Test]
     public void EditorTextKeepsJsonStringQuotesForStringEncodedEnumsAndUsesCustomOptions()
     {
diff --git a/test/GalNet.Core.Tests/Entry/GroupCompilationAnalysisTests.cs b/test/GalNet.Core.Tests/Entry/GroupCompilationAnalysisTests.cs
new file mode 100644
index 00000000..fe0179ac
--- /dev/null
+++ b/test/GalNet.Core.Tests/Entry/GroupCompilationAnalysisTests.cs
@@ -0,0 +1,44 @@
+using System.Text.Json;
+using GalNet.Core.Compilation;
+using GalNet.Core.Entry;
+using GalNet.Core.Primitives;
+using GalNet.Core.Serialization;
+
+namespace GeneralTest.Entry;
+
+public sealed class GroupCompilationAnalysisTests
+{
+    [Test]
+    public void AnalysisValidatesEachPrimitiveOnceAndRetainsWholeGroupNumbering()
+    {
+        var validations = 0;
+        var schema = new DynamicParameterTable([new("value", typeof(int), isRequired: true)], _ => validations++);
+        var catalog = new TargetProfileEntryCatalog([new DefaultEntryModule("test", [new DefaultPrimitiveEntryBase("test.run", schema)])]);
+        var source = new GroupDocument { Entries = [Entry("a", 1), Entry("b", 2)] };
+        var analysis = GalgroupCompiler.Analyze(source, catalog);
+        Assert.That(analysis.Issues, Is.Empty);
+        Assert.That(validations, Is.EqualTo(2));
+        Assert.That(analysis.Compilation!.Document.Entries.Select(item => item.Id), Is.EqualTo(new[] { "a#1", "b#1" }));
+        Assert.That(analysis.Compilation.SourceMap["b"], Is.EqualTo(new[] { "b#1" }));
+    }
+
+    [Test]
+    public void AnalysisCollectsAllEntryErrorsAndDoesNotExposePartialCompilation()
+    {
+        var schema = new DynamicParameterTable([new("value", typeof(int), isRequired: true)]);
+        var catalog = new TargetProfileEntryCatalog([new DefaultEntryModule("test", [new DefaultPrimitiveEntryBase("test.run", schema)])]);
+        var source = new GroupDocument { Entries = [Entry("a", 1), Entry("b", "bad"), Entry("c", "also bad")] };
+        var analysis = GalgroupCompiler.Analyze(source, catalog);
+        Assert.That(analysis.Compilation, Is.Null);
+        Assert.That(analysis.Issues.Select(item => item.SourceIndex), Is.EqualTo(new[] { 1, 2 }));
+        Assert.That(analysis.Issues.All(item => item.IsParameterError), Is.True);
+        Assert.That(() => GalgroupCompiler.Compile(source, catalog), Throws.TypeOf<InvalidDataException>());
+    }
+
+    private static GroupEntryDocument Entry(string id, object value) => new()
+    {
+        Id = id,
+        Type = "test.run",
+        Parameters = new() { ["value"] = JsonSerializer.SerializeToElement(value) }
+    };
+}
diff --git a/test/GalNet.Core.Tests/Entry/TargetProfileEntryCatalogTests.cs b/test/GalNet.Core.Tests/Entry/TargetProfileEntryCatalogTests.cs
index 0f3dc1cf..faa57fee 100644
--- a/test/GalNet.Core.Tests/Entry/TargetProfileEntryCatalogTests.cs
+++ b/test/GalNet.Core.Tests/Entry/TargetProfileEntryCatalogTests.cs
@@ -16,9 +16,9 @@ public void EditorDefaultsPreserveStringEncodedTypesAndDoNotCoerceNullStrings()
             new("day", new GalNet.Core.Parameters.ValueDescriptor(typeof(DayOfWeek), jsonOptions: options), defaultValue: JsonSerializer.SerializeToElement("Monday")),
             new("name", typeof(string), defaultValue: JsonSerializer.SerializeToElement<string?>(null), allowNull: true)]))])]);
         var entry = catalog.Create("custom.defaults");
-        Assert.That(entry.Values["day"], Is.EqualTo("\"Monday\""));
-        Assert.That(entry.Values.ContainsKey("name"), Is.False);
-        Assert.That(catalog.Get("custom.defaults").DynamicParameters!["name"].DefaultValue!.Value.ValueKind, Is.EqualTo(JsonValueKind.Null));
+        Assert.That(entry.Arguments.GetProperty("day").GetString(), Is.EqualTo("Monday"));
+        Assert.That(entry.Arguments.GetProperty("name").ValueKind, Is.EqualTo(JsonValueKind.Null));
+        Assert.That(catalog.Get("custom.defaults").DynamicParameters["name"].DefaultValue!.Value.ValueKind, Is.EqualTo(JsonValueKind.Null));
     }
     [Test]
     public void ProfileExposesOnlyItsOwnPrimitiveEntries()
@@ -32,9 +32,8 @@ public void ProfileExposesOnlyItsOwnPrimitiveEntries()
 
         Assert.That(catalog.TryGet("custom.pulse", out var definition), Is.True);
         Assert.That(definition.Kind, Is.EqualTo(EntryKind.Primitive));
-        Assert.That(definition.Parameters["count"], Is.EqualTo(EntryParameterType.Integer));
-        Assert.That(definition.DynamicParameters!["count"].ValueType, Is.EqualTo(typeof(int)));
-        Assert.That(definition.Defaults["enabled"], Is.EqualTo("true"));
+        Assert.That(definition.DynamicParameters["count"].ValueType, Is.EqualTo(typeof(int)));
+        Assert.That(definition.DynamicParameters["enabled"].DefaultValue!.Value.GetBoolean(), Is.True);
         Assert.That(catalog.TryGet("layer.show", out _), Is.False);
     }
 
diff --git a/test/GalNet.Core.Tests/Entry/ValueDescriptorTests.cs b/test/GalNet.Core.Tests/Entry/ValueDescriptorTests.cs
index 26c5f417..dd68cfab 100644
--- a/test/GalNet.Core.Tests/Entry/ValueDescriptorTests.cs
+++ b/test/GalNet.Core.Tests/Entry/ValueDescriptorTests.cs
@@ -8,6 +8,16 @@ namespace GeneralTest.Entry;
 
 public sealed class ValueDescriptorTests
 {
+    [Test]
+    public void TextChoicesAreNormalizedToOneTypedEnumConstraint()
+    {
+        var numeric = new ValueDescriptor(typeof(int), choices: ["1", "2"]);
+        Assert.That(numeric.TryGetConstraint("enum", out var choices), Is.True);
+        Assert.That(choices[0].GetInt32(), Is.EqualTo(1));
+        Assert.That(numeric.TryGetConstraint("options", out _), Is.False);
+        Assert.That(ValueValidation.Validate(numeric, Json("3"))!.Code, Is.EqualTo("value.option"));
+    }
+
     private static readonly string[] ExpectedNames = ["first", "second"];
     private static readonly int[] ExpectedNumbers = [1, 2];
     [Test]
@@ -89,13 +99,13 @@ public void TextArrayBooleanAndFloatingValuesUseSharedConversion()
     [Test]
     public void LegacyOptionsDescribeTypedValuesAndNullBypassesNonNullConstraints()
     {
-        var descriptor = new ValueDescriptor(typeof(int), allowNull: true, constraints: Json("""{"options":["1","2"]}"""));
+        var descriptor = new ValueDescriptor(typeof(int), allowNull: true, constraints: Json("""{"enum":[1,2]}"""));
         Assert.That(ValueValidation.Validate(descriptor, Json("null")), Is.Null);
         Assert.That(ValueValidation.Validate(descriptor, Json("3"))!.Code, Is.EqualTo("value.option"));
         var description = ValueCodec.Describe(descriptor);
         Assert.That(description.GetProperty("anyOf")[0].GetProperty("enum")[0].GetInt32(), Is.EqualTo(1));
         Assert.That(description.GetProperty("anyOf")[1].GetProperty("type").GetString(), Is.EqualTo("null"));
-        var array = new ValueDescriptor(typeof(int[]), constraints: Json("""{"options":["[1,2]"]}"""));
+        var array = new ValueDescriptor(typeof(int[]), constraints: Json("""{"enum":[[1,2]]}"""));
         Assert.That(ValueValidation.Validate(array, Json("[1, 2]")), Is.Null);
     }
 
@@ -121,7 +131,7 @@ public void InvalidDefaultsAndConstraintDeclarationsAreRejected()
     {
         Assert.That(() => new DynamicParameterDescriptor("count", typeof(int), defaultValue: Json("-1"), constraints: Json("""{"minimum":0}""")), Throws.ArgumentException);
         Assert.That(() => new ValueDescriptor(typeof(string), constraints: Json("""{"maxLength":-1}""")), Throws.ArgumentException);
-        Assert.That(() => new ValueDescriptor(typeof(int), constraints: Json("""{"options":[1]}""")), Throws.ArgumentException);
+        Assert.That(() => new ValueDescriptor(typeof(int), constraints: Json("""{"enum":["wrong"]}""")), Throws.ArgumentException);
         Assert.That(() => new ValueDescriptor(typeof(string), constraints: Json("""{"maxLength":"wrong"}""")), Throws.ArgumentException);
         Assert.That(() => new ValueDescriptor(typeof(int), constraints: Json("""{"minimum":3,"maximum":2}""")), Throws.ArgumentException);
     }
diff --git a/test/GalNet.Core.Tests/RecursivePropertyTests.cs b/test/GalNet.Core.Tests/RecursivePropertyTests.cs
new file mode 100644
index 00000000..df962b3d
--- /dev/null
+++ b/test/GalNet.Core.Tests/RecursivePropertyTests.cs
@@ -0,0 +1,204 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Core.Parameters;
+
+namespace GeneralTest;
+
+public sealed class RecursivePropertyTests
+{
+    [Test]
+    public void OpenObjectsRetainAtomicJsonExtensionsWithoutLosingKnownValidationOrDuplicateChecks()
+    {
+        var known = new FieldDescriptor("amount", new(typeof(float)), isRequired: true);
+        var extension = new FieldDescriptor("extension", new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Scalar()));
+        var descriptor = new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.OpenObject([known], extension));
+        var source = Json("""{"amount":0.5,"angle":0,"":{"caption":"literal"},"future":[1,{"speaker":"not-a-reference"}]}""");
+        using var document = new ValueDocument(new("root", descriptor), source);
+        Assert.That(document.Validate(requireAllFields: true), Is.Empty);
+        Assert.That(document.GetIterator().Count(), Is.EqualTo(5), "Additional JSON is an explicit atomic value, not an unknown DTO subtree.");
+        Assert.That(document.FindProperty([""])!.Value!.Value.GetProperty("caption").GetString(), Is.EqualTo("literal"));
+        Assert.That(document.FindProperty(["extension"]), Is.Null, "The additional-value descriptor ID is not an alias for all extension keys.");
+        var patch = document.Patch(["amount"], Json("0.8"));
+        Assert.That(patch.Issue, Is.Null);
+        Assert.That(patch.Value!.Value.GetProperty("future").GetRawText(), Is.EqualTo(source.GetProperty("future").GetRawText()));
+        Assert.That(document.Root.Value, Is.EqualTo(source));
+        using var duplicate = new ValueDocument(new("root", descriptor), Json("""{"angle":0,"angle":1}"""));
+        Assert.That(duplicate.Validate().Single().Code, Is.EqualTo("field.duplicate"));
+        using var invalid = new ValueDocument(new("root", descriptor), Json("""{"amount":"bad","angle":0}"""));
+        Assert.That(invalid.Validate().Single().Code, Is.EqualTo("value.type"));
+        using var closed = new ValueDocument(new("root", new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Object([known]))), source);
+        Assert.That(closed.GetIterator().Count(node => node.Issue?.Code == "field.unknown"), Is.EqualTo(3));
+    }
+
+    [Test]
+    public void ExplicitMapValuesInheritTheParentsWireCodec()
+    {
+        var options = new JsonSerializerOptions { Converters = { new StringBooleanValueConverter() } };
+        var value = new ValueDescriptor(typeof(JsonElement), jsonOptions: options).WithStructure(ValueStructure.Map(new("value", new(typeof(bool)))));
+        using var document = new ValueDocument(new("root", value), Json("""{"flag":"true"}"""));
+        Assert.That(document.FindProperty(["flag"])!.Field.Value.IsStringEncoded, Is.True);
+        Assert.That(document.Validate(), Is.Empty);
+        var patch = document.Patch(["flag"], Json("\"false\""));
+        Assert.That(patch.Issue, Is.Null);
+        Assert.That(patch.Value!.Value.GetProperty("flag").GetString(), Is.EqualTo("false"));
+    }
+
+    [Test]
+    public void PartialChecksDoNotRequireMissingSiblingsAndFullChecksDoNotMaterializeOptionalObjects()
+    {
+        var required = new FieldDescriptor("required", new(typeof(int)), isRequired: true);
+        var optional = new FieldDescriptor("optional", new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Object([required])));
+        var descriptor = new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Object([required, optional]));
+        using var partial = new ValueDocument(new("root", descriptor), Json("{}"));
+        Assert.That(partial.Validate(), Is.Empty);
+        Assert.That(partial.Validate(requireAllFields: true).Select(issue => issue.Path), Is.EqualTo(new[] { "/required" }));
+        Assert.That(partial.Root.Content!.Value.GetRawText(), Is.EqualTo("{}"));
+    }
+
+    [Test]
+    public void PatchesRetainUnknownSiblingsEncodingAndPresenceAndRejectAmbiguousOrMissingTargets()
+    {
+        var descriptor = new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.ForType(typeof(RecursiveDto), allowsJsonString: true, ignoresCase: true));
+        var source = JsonSerializer.SerializeToElement("""{"cHiLd":{"caption/~":"old","extension":{"x":1}},"other":9}""");
+        using var doc = new ValueDocument(new("root", descriptor), source);
+        var patch = doc.Patch(["child", "caption/~"], Json("\"new\""));
+        Assert.That(patch.Issue, Is.Null);
+        var result = Json(patch.Value!.Value.GetString()!);
+        Assert.That(result.GetProperty("cHiLd").GetProperty("extension").GetProperty("x").GetInt32(), Is.EqualTo(1));
+        Assert.That(result.GetProperty("cHiLd").GetProperty("caption/~").GetString(), Is.EqualTo("new"));
+        Assert.That(result.GetProperty("other").GetInt32(), Is.EqualTo(9));
+        Assert.That(doc.Root.Value, Is.EqualTo(source));
+        using var removed = new ValueDocument(new("root", descriptor), patch.Value);
+        Assert.That(Json(removed.Patch(["child", "caption/~"], null).Value!.Value.GetString()!).GetProperty("cHiLd").TryGetProperty("caption/~", out _), Is.False);
+        using var list = new ValueDocument(Field(typeof(int[])), Json("[1,2]"));
+        Assert.That(list.Patch(["2"], Json("3")).Issue, Is.Not.Null);
+        Assert.That(list.Patch(["0"], null).Issue!.Code, Is.EqualTo("structure.element"));
+        using var nullObject = new ValueDocument(new("root", descriptor), Json("null"));
+        Assert.That(nullObject.Patch(["child"], Json("{}")).Issue, Is.Not.Null);
+        using var missing = new ValueDocument(new("root", descriptor), null);
+        Assert.That(missing.Patch(["child", "caption/~"], Json("\"value\"")).Issue, Is.Null);
+        using var conflict = new ValueDocument(new("root", descriptor), Json("""{"Child":{},"child":{}}"""));
+        Assert.That(conflict.Patch(["child"], Json("{}")).Issue, Is.Not.Null);
+        using var invalid = new ValueDocument(new("root", descriptor), Json("""{"caption/~":42}"""));
+        Assert.That(invalid.FindProperty(["caption/~"])!.Issue, Is.Not.Null);
+        Assert.That(invalid.Patch(["caption/~"], Json("\"fixed\"")).Issue, Is.Null, "Invalid old values must remain repairable through their known field metadata.");
+    }
+
+    private static JsonElement Json(string value) => JsonSerializer.Deserialize<JsonElement>(value);
+    private static FieldDescriptor Field(Type type) => new("root", new(type));
+
+    [Test]
+    public void TraversalUsesWireNamesOptionsAndSemanticElementsWithoutTouchingGetters()
+    {
+        var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
+        using var doc = new ValueDocument(new("root", new(typeof(RecursiveDto), jsonOptions: options)), Json("""{"caption/~":"key","child":{"caption/~":"nested"},"extra":{"x":1}}"""));
+        var nodes = doc.GetIterator().ToArray();
+        Assert.That(doc.FindProperty(["child"])!.Structure, Is.SameAs(doc.Root.Structure), "Recursive types reuse metadata instead of expanding another schema tree.");
+        Assert.That(nodes.Where(node => node.Field.Semantic == FieldValueSemantic.LocalizedText).Select(node => node.Path.ToJsonPointer()),
+            Is.EquivalentTo(new[] { "/caption~1~0", "/child/caption~1~0" }));
+        Assert.That(nodes.Single(node => node.Path.ToJsonPointer() == "/extra").Issue!.Code, Is.EqualTo("field.unknown"));
+        Assert.That(doc.FindProperty(["child", "caption/~"])!.Value!.Value.GetString(), Is.EqualTo("nested"));
+        Assert.That(RecursiveDto.GetterCalls, Is.Zero);
+    }
+
+    [Test]
+    public void MapKeysAndListPositionsAreDistinctAndSemanticValuesArePreserved()
+    {
+        var item = new FieldDescriptor("value", new(typeof(string)), semantic: FieldValueSemantic.CharacterReference);
+        using var map = new ValueDocument(new("root", new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Map(item))),
+            Json("""{"0":"hero","":"empty","a/b~c":"other","value":"literal"}"""));
+        Assert.That(map.Root.EnumerateChildren().All(node => node.Path[^1].Kind == PropertySegmentKind.MapKey), Is.True);
+        Assert.That(map.FindProperty(["value"])!.Value!.Value.GetString(), Is.EqualTo("literal"));
+        Assert.That(map.FindProperty(["a/b~c"])!.Path.ToJsonPointer(), Is.EqualTo("/a~1b~0c"));
+        using var list = new ValueDocument(new("root", new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Sequence(item))), Json("""["hero","other"]"""));
+        Assert.That(list.FindProperty(["0"])!.Path[0].Kind, Is.EqualTo(PropertySegmentKind.Index));
+        Assert.That(list.GetIterator().Count(node => node.Field.Semantic == FieldValueSemantic.CharacterReference), Is.EqualTo(2));
+    }
+
+    [Test]
+    public void RecursiveMetadataIsLazyAndTraversalHasDepthNodeAndCancellationBounds()
+    {
+        using var doc = new ValueDocument(Field(typeof(RecursiveDto)), Json("""{"Child":{"Child":{"Child":{"caption/~":"deep"}}}}"""));
+        Assert.That(doc.GetIterator(new(MaximumDepth: 2)).Last().Issue!.Code, Is.EqualTo("analysis.limit"));
+        using var wide = new ValueDocument(Field(typeof(int[])), Json("[1,2,3,4,5]"));
+        var nodes = wide.GetIterator(new(MaximumNodes: 3)).ToArray();
+        Assert.That(nodes.Last().Issue!.Code, Is.EqualTo("analysis.limit"));
+        using var cancel = new CancellationTokenSource(); cancel.Cancel();
+        Assert.Throws<OperationCanceledException>(() => wide.GetIterator(token: cancel.Token).ToArray());
+    }
+
+    [Test]
+    public void MissingNullUnknownDuplicateAndStringEncodedObjectsRetainTheirIdentity()
+    {
+        var value = new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.ForType(typeof(RecursiveDto), allowsJsonString: true, ignoresCase: true));
+        using var encoded = new ValueDocument(new("root", value), JsonSerializer.SerializeToElement("""{"Child":{"caption/~":"nested"}}"""));
+        var child = encoded.FindProperty(["child", "caption/~"])!;
+        Assert.That(child.Path.ToJsonPointer(), Is.Empty);
+        Assert.That(child.Path.ToLogicalPointer(), Is.EqualTo("/Child/caption~1~0"));
+        var rewritten = child.Path.Replace(encoded.Root.Value!.Value, Json("\"changed\""));
+        Assert.That(Json(rewritten.GetString()!).GetProperty("Child").GetProperty("caption/~").GetString(), Is.EqualTo("changed"));
+        using var duplicate = new ValueDocument(new("root", value), Json("""{"Child":{},"child":{}}"""));
+        Assert.That(duplicate.GetIterator().Any(node => node.Issue?.Code == "field.duplicate"), Is.True);
+        Assert.That(duplicate.FindProperty(["child"]), Is.Null);
+        using var missing = new ValueDocument(Field(typeof(RecursiveDto)), null);
+        Assert.That(missing.Root.IsProvided, Is.False);
+        Assert.That(missing.Root.EnumerateChildren(true).All(node => !node.IsProvided), Is.True);
+        using var nil = new ValueDocument(Field(typeof(RecursiveDto)), Json("null"));
+        Assert.That(nil.Root.IsProvided, Is.True); Assert.That(nil.Root.EnumerateChildren(), Is.Empty);
+        using var malformed = new ValueDocument(new("root", value), JsonSerializer.SerializeToElement("{bad"));
+        Assert.That(malformed.Root.Issue!.Code, Is.EqualTo("field.objectRequired"));
+    }
+
+    [Test]
+    public void SameTypeDifferentOptionsAndDynamicContextsCannotShareAnIncorrectShape()
+    {
+        using var resolver = new ValueStructureResolver();
+        using var pascal = new ValueDocument(Field(typeof(RecursiveDto)), Json("""{"Child":{}}"""), resolver);
+        using var camel = new ValueDocument(new("root", new(typeof(RecursiveDto), jsonOptions: new() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase })), Json("""{"child":{}}"""), resolver);
+        Assert.That(pascal.Root.Structure.Members.Single(member => member.Field.Id == "child").WireName, Is.EqualTo("Child"));
+        Assert.That(camel.Root.Structure.Members.Single(member => member.Field.Id == "child").WireName, Is.EqualTo("child"));
+        var dynamicField = new FieldDescriptor("root", new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Dynamic("test")));
+        using var known = new ValueDocument(dynamicField, Json("{}"), resolver, new Provider(), true);
+        using var unknown = new ValueDocument(dynamicField, Json("""{"x":1}"""), resolver, new Provider(), false);
+        Assert.That(known.Root.Structure.Kind, Is.EqualTo(ValueStructureKind.Object));
+        Assert.That(unknown.Root.Issue!.Code, Is.EqualTo("field.opaque"));
+        resolver.Dispose();
+        using var late = new ValueDocument(Field(typeof(int)), Json("1"), resolver);
+        Assert.Throws<ObjectDisposedException>(() => _ = late.Root.Structure);
+    }
+
+    [Test]
+    public void AnObjectConverterWithoutAnExplicitWireAdapterIsNotTraversedAsDtoMembers()
+    {
+        var options = new JsonSerializerOptions { Converters = { new OpaqueConverter() } };
+        using var doc = new ValueDocument(new("root", new(typeof(RecursiveDto), jsonOptions: options)), Json("""{"hidden":"key"}"""));
+        Assert.That(doc.Root.Issue!.Code, Is.EqualTo("field.opaque"));
+        Assert.That(doc.GetIterator().Count(), Is.EqualTo(1));
+        using var encoded = new ValueDocument(new("root", new(typeof(RecursiveDto), jsonOptions: options)), Json("\"opaque\""));
+        Assert.That(encoded.Root.Issue!.Code, Is.EqualTo("field.opaque"), "A codec's scalar wire shape is not proof that its DTO has no references.");
+        using var incorrect = new ValueDocument(new("root", new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.ForType(typeof(int)))), Json("""{"hidden":"key"}"""));
+        Assert.That(incorrect.Root.Issue!.Code, Is.EqualTo("schema.invalid"));
+    }
+
+    private sealed class Provider : IValueStructureProvider
+    {
+        public ValueStructure? Resolve(string id, FieldDescriptor field, JsonElement? value, PropertyPath path, object? context) =>
+            context is true ? ValueStructure.Object([]) : null;
+    }
+    private sealed class OpaqueConverter : JsonConverter<RecursiveDto>
+    {
+        public override RecursiveDto Read(ref Utf8JsonReader reader, Type type, JsonSerializerOptions options) => throw new NotSupportedException();
+        public override void Write(Utf8JsonWriter writer, RecursiveDto value, JsonSerializerOptions options) => throw new NotSupportedException();
+    }
+    public sealed class RecursiveDto : IFieldDto
+    {
+        public static int GetterCalls;
+        [Field(0), JsonPropertyName("caption/~")] public string Caption { get { GetterCalls++; throw new InvalidOperationException(); } set { } }
+        [Field(1)] public RecursiveDto? Child { get { GetterCalls++; throw new InvalidOperationException(); } set { } }
+        public static IReadOnlyList<FieldDescriptor> Schema { get; } =
+        [new("caption/~", new(typeof(string)), semantic: FieldValueSemantic.LocalizedText), new("child", new(typeof(RecursiveDto)))];
+        public IReadOnlyList<FieldDescriptor> Fields => Schema;
+        public object? ReadField(string id) => throw new NotSupportedException();
+        public void WriteField(string id, object? value) => throw new NotSupportedException();
+    }
+}
diff --git a/test/GalNet.Core.Tests/ResourceCatalogTests.cs b/test/GalNet.Core.Tests/ResourceCatalogTests.cs
new file mode 100644
index 00000000..1f6266ba
--- /dev/null
+++ b/test/GalNet.Core.Tests/ResourceCatalogTests.cs
@@ -0,0 +1,26 @@
+using GalNet.Core.Assets;
+
+namespace GeneralTest.Assets;
+
+public sealed class ResourceCatalogTests
+{
+    public sealed class ProjectMeta : AssetMeta { public bool Enabled { get; set; } }
+    [Test]
+    public void DefaultMetadataTypeIsSelectedByTheCatalogWithoutBuiltinTypeNames()
+    {
+        var catalog = new ResourceTypeCatalogBuilder().Add<ProjectMeta>("project.resource").DefaultType("project.resource").Build();
+        var codec = new AssetMetaCodec(catalog);
+        var metadata = codec.Deserialize("""{"id":"item","enabled":true,"future":{"kept":true}}""", "file.unrecognized");
+        Assert.That(metadata, Is.TypeOf<ProjectMeta>());
+        Assert.That(((ProjectMeta)metadata).Enabled, Is.True);
+        Assert.That(metadata.TypeId, Is.EqualTo("project.resource"));
+        Assert.That(codec.Serialize(metadata), Does.Contain("kept"));
+    }
+    [Test]
+    public void CatalogWithoutDefaultAcceptsExplicitTypesAndRejectsOnlyUnresolvedTypes()
+    {
+        var codec = new AssetMetaCodec(new ResourceTypeCatalogBuilder().Add<ProjectMeta>("project").Build());
+        Assert.That(codec.Deserialize("""{"id":"item","type":"project"}""", "file.unknown"), Is.TypeOf<ProjectMeta>());
+        Assert.Throws<InvalidDataException>(() => codec.Deserialize("""{"id":"item"}""", "file.unknown"));
+    }
+}
diff --git a/test/GalNet.Core.Tests/StateIdentityTests.cs b/test/GalNet.Core.Tests/StateIdentityTests.cs
new file mode 100644
index 00000000..c5a0dbf8
--- /dev/null
+++ b/test/GalNet.Core.Tests/StateIdentityTests.cs
@@ -0,0 +1,40 @@
+using System.Text.Json;
+using GalNet.Core.Runtime;
+
+namespace GeneralTest.Runtime;
+
+public sealed class StateIdentityTests
+{
+    public sealed record First(string Id);
+    public sealed record Second(string Id);
+    private static StateCatalog Catalog()
+    {
+        var builder = new StateCatalogBuilder();
+        builder.Register<First>("first", item => item.Id, keySpace: "objects");
+        builder.Register<Second>("second", item => item.Id, keySpace: "objects");
+        return builder.Build();
+    }
+    [Test]
+    public void SharedKeySpaceRejectsCrossTableCollisionsAndRemovalReleasesTheIdentity()
+    {
+        var state = new GameState(Catalog());
+        state.Table<First>().Add(new("same"));
+        Assert.Throws<InvalidOperationException>(() => state.Table<Second>().Add(new("same")));
+        var replacement = new First("same"); state.Table<First>().Set(replacement);
+        Assert.That(state.TryGetIdentity<First>("objects", "same", out var found), Is.True);
+        Assert.That(found, Is.SameAs(replacement));
+        state.Table<First>().Clear(); state.Table<Second>().Add(new("same"));
+        Assert.That(state.TryGetIdentity<Second>("objects", "same", out _), Is.True);
+        Assert.That(state.TryGetIdentity<Second>("other", "same", out _), Is.False);
+    }
+    [Test]
+    public void RestoreRejectsSharedIdentityCollisionsBeforePublishingTheNewRoot()
+    {
+        var state = new GameState(Catalog()); state.Table<First>().Add(new("same"));
+        var captured = state.Capture();
+        captured["second"] = new(1, JsonSerializer.SerializeToElement(new[] { new { id = "same" } }));
+        Assert.Throws<InvalidOperationException>(() => GameState.Restore(Catalog(), captured));
+        Assert.That(state.Table<First>().Get("same").Id, Is.EqualTo("same"));
+        Assert.That(state.Table<Second>().Values, Is.Empty);
+    }
+}
diff --git a/test/GalNet.Debugging.Tests/GalNet.Debugging.Tests.csproj b/test/GalNet.Debugging.Tests/GalNet.Debugging.Tests.csproj
index ac2be4eb..1208d241 100644
--- a/test/GalNet.Debugging.Tests/GalNet.Debugging.Tests.csproj
+++ b/test/GalNet.Debugging.Tests/GalNet.Debugging.Tests.csproj
@@ -1,4 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup><TargetFramework>net10.0</TargetFramework></PropertyGroup>
-  <ItemGroup><ProjectReference Include="../../src/Shared/GalNet.Debugging/GalNet.Debugging.csproj" /></ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../src/Shared/GalNet.Debugging/GalNet.Debugging.csproj" />
+    <ProjectReference Include="../../src/Shared/GalNet.Presentation.Abstractions/GalNet.Presentation.Abstractions.csproj" />
+  </ItemGroup>
 </Project>
diff --git a/test/GalNet.Debugging.Tests/packages.lock.json b/test/GalNet.Debugging.Tests/packages.lock.json
index 07f03674..1034ce65 100644
--- a/test/GalNet.Debugging.Tests/packages.lock.json
+++ b/test/GalNet.Debugging.Tests/packages.lock.json
@@ -116,6 +116,12 @@
         "resolved": "13.0.3",
         "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
       },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.core": {
         "type": "Project"
       },
@@ -128,6 +134,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -136,7 +143,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/test/GalNet.Diagnostics.Tests/CpuProfilerTests.cs b/test/GalNet.Diagnostics.Tests/CpuProfilerTests.cs
new file mode 100644
index 00000000..fc01bf2e
--- /dev/null
+++ b/test/GalNet.Diagnostics.Tests/CpuProfilerTests.cs
@@ -0,0 +1,132 @@
+#if BENCHMARK
+using System.Text.Json;
+using System.Diagnostics.Tracing;
+using System.Collections.Concurrent;
+using GalNet.Diagnostics;
+
+namespace GalNet.Diagnostics.Tests;
+
+public sealed class CpuProfilerTests
+{
+    [Test]
+    public void EventPipeMirrorPreservesMarkersAndCompletedDurationsOnlyWhenOptedIn()
+    {
+        using var listener = new CpuListener();
+        var disabled = new CpuProfiler();
+        disabled.Mark("not-mirrored");
+        var enabled = new CpuProfiler(emitEventPipe: true);
+        enabled.Mark("marker");
+        using (enabled.Measure("scope")) { }
+        enabled.Stop();
+        enabled.Mark("after-stop");
+        var events = listener.Events.ToArray();
+        Assert.That(events.Select(item => item.Name), Is.EqualTo(new[] { "marker", "scope" }));
+        Assert.That(events[0].Duration, Is.EqualTo(-1));
+        Assert.That(events[1].Duration, Is.GreaterThanOrEqualTo(0));
+    }
+
+    private sealed class CpuListener : EventListener
+    {
+        public ConcurrentQueue<(string Name, double Duration)> Events { get; } = new();
+
+        protected override void OnEventSourceCreated(EventSource eventSource)
+        {
+            if (eventSource.Name == "GalNet-CPU") EnableEvents(eventSource, EventLevel.Informational);
+        }
+
+        protected override void OnEventWritten(EventWrittenEventArgs eventData)
+        {
+            if (eventData.EventId == 1)
+                Events.Enqueue(((string)eventData.Payload![0]!, (double)eventData.Payload[3]!));
+        }
+    }
+
+    [Test]
+    public void NestedScopesAndMarksExportValidTraceAndDisposeOnlyOnce()
+    {
+        var profiler = new CpuProfiler();
+        using (profiler.Measure("outer"))
+        {
+            var inner = profiler.Measure("inner");
+            profiler.Mark("checkpoint");
+            inner.Dispose();
+            inner.Dispose();
+        }
+        using var stream = new MemoryStream();
+        profiler.WriteTrace(stream);
+        using var document = JsonDocument.Parse(stream.ToArray());
+        var events = document.RootElement.GetProperty("traceEvents");
+        Assert.That(events.GetArrayLength(), Is.EqualTo(3));
+        var byName = events.EnumerateArray().ToDictionary(item => item.GetProperty("name").GetString()!);
+        Assert.That(byName["outer"].GetProperty("dur").GetDouble(), Is.GreaterThanOrEqualTo(0));
+        Assert.That(byName["inner"].GetProperty("dur").GetDouble(), Is.GreaterThanOrEqualTo(0));
+        Assert.That(byName["checkpoint"].GetProperty("ph").GetString(), Is.EqualTo("i"));
+    }
+
+    [Test]
+    public async Task ScopeCanCrossAwaitAndBeDisposedConcurrently()
+    {
+        var profiler = new CpuProfiler();
+        var scope = profiler.Measure("async");
+        await Task.WhenAll(Enumerable.Range(0, 16).Select(_ => Task.Run(scope.Dispose)));
+        Assert.That(profiler.Snapshot(), Has.Length.EqualTo(1));
+    }
+
+    [Test]
+    public void CapacityIsBoundedAndStopIgnoresOutstandingScopes()
+    {
+        var profiler = new CpuProfiler(1);
+        profiler.Mark("first");
+        profiler.Mark("overflow");
+        var outstanding = profiler.Measure("late");
+        profiler.Stop();
+        outstanding.Dispose();
+        using var stream = new MemoryStream();
+        profiler.WriteTrace(stream);
+        using var document = JsonDocument.Parse(stream.ToArray());
+        Assert.That(profiler.Snapshot(), Has.Length.EqualTo(1));
+        Assert.That(document.RootElement.GetProperty("droppedEvents").GetInt32(), Is.EqualTo(1));
+    }
+
+    [Test]
+    public void StartupCaptureExportsReadyAndCompletesOnlyOnce()
+    {
+        var path = Path.Combine(TestContext.CurrentContext.WorkDirectory, Guid.NewGuid() + ".json");
+        var previousOutput = Environment.GetEnvironmentVariable("GALNET_BENCHMARK_OUTPUT");
+        var previousExit = Environment.GetEnvironmentVariable("GALNET_BENCHMARK_EXIT");
+        try
+        {
+            Environment.SetEnvironmentVariable("GALNET_BENCHMARK_OUTPUT", path);
+            Environment.SetEnvironmentVariable("GALNET_BENCHMARK_EXIT", "1");
+            StartupBenchmark.Start();
+            Assert.That(StartupBenchmark.Complete(), Is.True);
+            Assert.That(StartupBenchmark.Complete(), Is.False);
+            using var document = JsonDocument.Parse(File.ReadAllBytes(path));
+            var names = document.RootElement.GetProperty("traceEvents").EnumerateArray()
+                .Select(item => item.GetProperty("name").GetString()).ToArray();
+            Assert.That(names, Does.Contain("Startup.Ready"));
+            Assert.That(names.Count(name => name == "Startup.Total"), Is.EqualTo(1));
+        }
+        finally
+        {
+            Environment.SetEnvironmentVariable("GALNET_BENCHMARK_OUTPUT", previousOutput);
+            Environment.SetEnvironmentVariable("GALNET_BENCHMARK_EXIT", previousExit);
+            File.Delete(path);
+        }
+    }
+}
+#else
+namespace GalNet.Diagnostics.Tests;
+
+public sealed class DisabledBuildTests
+{
+    [Test]
+    public void ProfilerImplementationIsAbsent()
+    {
+        var assembly = System.Reflection.Assembly.Load("GalNet.Diagnostics");
+        Assert.That(assembly.GetType("GalNet.Diagnostics.CpuProfiler"), Is.Null);
+        Assert.That(assembly.GetType("GalNet.Diagnostics.StartupBenchmark"), Is.Null);
+        Assert.That(assembly.GetType("GalNet.Diagnostics.CpuTraceEvents"), Is.Null);
+    }
+}
+#endif
diff --git a/test/GalNet.Diagnostics.Tests/GalNet.Diagnostics.Tests.csproj b/test/GalNet.Diagnostics.Tests/GalNet.Diagnostics.Tests.csproj
new file mode 100644
index 00000000..dbda6e99
--- /dev/null
+++ b/test/GalNet.Diagnostics.Tests/GalNet.Diagnostics.Tests.csproj
@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../src/Shared/GalNet.Diagnostics/GalNet.Diagnostics.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/test/GalNet.Diagnostics.Tests/packages.lock.json b/test/GalNet.Diagnostics.Tests/packages.lock.json
new file mode 100644
index 00000000..90b4c2e0
--- /dev/null
+++ b/test/GalNet.Diagnostics.Tests/packages.lock.json
@@ -0,0 +1,119 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "coverlet.collector": {
+        "type": "Direct",
+        "requested": "[6.0.4, )",
+        "resolved": "6.0.4",
+        "contentHash": "lkhqpF8Pu2Y7IiN7OntbsTtdbpR1syMsm2F3IgX6ootA4ffRqWL5jF7XipHuZQTdVuWG/gVAAcf8mjk8Tz0xPg=="
+      },
+      "Microsoft.NET.Test.Sdk": {
+        "type": "Direct",
+        "requested": "[17.14.0, )",
+        "resolved": "17.14.0",
+        "contentHash": "rTtdOm6C96q9QgP3mS8nUGPGPh5Xm2HnBYJggNmNrJ3LDmX9lJuUIgnJEfvX6wSQY4swUMiCcIXd3OkjhYCgtw==",
+        "dependencies": {
+          "Microsoft.CodeCoverage": "17.14.0",
+          "Microsoft.TestPlatform.TestHost": "17.14.0"
+        }
+      },
+      "NUnit": {
+        "type": "Direct",
+        "requested": "[4.3.2, )",
+        "resolved": "4.3.2",
+        "contentHash": "puVXayXNmEu7MFQSUswGmUjOy3M3baprMbkLl5PAutpeDoGTr+jPv33qAYsqxywi2wJCq8l/O3EhHoLulPE1iQ=="
+      },
+      "NUnit.Analyzers": {
+        "type": "Direct",
+        "requested": "[4.7.0, )",
+        "resolved": "4.7.0",
+        "contentHash": "1AjtK0uoJgxyobNtNwjQLlEs2X+9mgfWbWXiIktquTvpOhSXMf56TZF43+q2lIIYhV4IrfS82/pfo4uPUYka4w=="
+      },
+      "NUnit3TestAdapter": {
+        "type": "Direct",
+        "requested": "[5.0.0, )",
+        "resolved": "5.0.0",
+        "contentHash": "sy4cLoUAdE6TDM4wNX5gmNCyhMev5wUz4cA6ZRf/aON9vf9t4xTVGLj/4huhDKcS4dFfmVVcgcP70yC7WC9kKg==",
+        "dependencies": {
+          "Microsoft.Testing.Extensions.VSTestBridge": "1.5.3",
+          "Microsoft.Testing.Platform.MSBuild": "1.5.3"
+        }
+      },
+      "Microsoft.ApplicationInsights": {
+        "type": "Transitive",
+        "resolved": "2.22.0",
+        "contentHash": "3AOM9bZtku7RQwHyMEY3tQMrHIgjcfRDa6YQpd/QG2LDGvMydSlL9Di+8LLMt7J2RDdfJ7/2jdYv6yHcMJAnNw=="
+      },
+      "Microsoft.CodeCoverage": {
+        "type": "Transitive",
+        "resolved": "17.14.0",
+        "contentHash": "z2GYXGG6LjGoumT59xSB2dMnqSwQBjkxdDJmSJHwy5nPtZ435GXa6wj5hz/lRrAZ7NyXXxZNXVsiHXzHRru5eA=="
+      },
+      "Microsoft.Testing.Extensions.Telemetry": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "U9pGd5DQuX1PfkrdFI+xH34JGgQ2nes5QAwIITTk+MQfLvRITqsZjJeHTjpGWh33D/0q1l7aA8/LQHR7UuCgLQ==",
+        "dependencies": {
+          "Microsoft.ApplicationInsights": "2.22.0",
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.Testing.Extensions.TrxReport.Abstractions": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "h34zKNpGyni66VH738mRHeXSnf3klSShUdavUWNhSfWICUUi5aXeI0LBvoX/ad93N0+9xBDU3Fyi6WfxrwKQGw==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.Testing.Extensions.VSTestBridge": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "cJD67YfDT98wEWyazKVD/yPVW6+H1usXeuselCnRes7JZBTIYWtrCchcOzOahnmajT79eDKqt9sta7DXwTDU4Q==",
+        "dependencies": {
+          "Microsoft.ApplicationInsights": "2.22.0",
+          "Microsoft.TestPlatform.ObjectModel": "17.12.0",
+          "Microsoft.Testing.Extensions.Telemetry": "1.5.3",
+          "Microsoft.Testing.Extensions.TrxReport.Abstractions": "1.5.3",
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.Testing.Platform": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "WqJydnJ99dEKtquR9HwINz104ehWJKTXbQQrydGatlLRw14bmsx0pa8+E6KUXMYXZAimN0swWlDmcJGjjW4TIg=="
+      },
+      "Microsoft.Testing.Platform.MSBuild": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "bOtpRMSPeT5YLQo+NNY8EtdNTphAUcmALjW4ABU7P0rb6yR2XAZau3TzNieLmR3lRuwudguWzzBhgcLRXwZh0A==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.TestPlatform.ObjectModel": {
+        "type": "Transitive",
+        "resolved": "17.14.0",
+        "contentHash": "3h7y7f/HuY8jdZa163p/55VmGw/fYJwrI8FOtsp4aEQAJaPgBr5LBS25uOfBwRYI95QDiByfaqSPBcWEvuHEwA=="
+      },
+      "Microsoft.TestPlatform.TestHost": {
+        "type": "Transitive",
+        "resolved": "17.14.0",
+        "contentHash": "8htQBKM92s/NXUI/U0/CKKLlvlDfWIo3/mbnY/GS/2XLkBGNIVQufmUpDIzznaZqUpdzspGSsJcLhVN8aRoMaA==",
+        "dependencies": {
+          "Microsoft.TestPlatform.ObjectModel": "17.14.0",
+          "Newtonsoft.Json": "13.0.3"
+        }
+      },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.3",
+        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
+      },
+      "galnet.diagnostics": {
+        "type": "Project"
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/GalNet.Editor.Shared.Tests/AudioEffectAuthoringTests.cs b/test/GalNet.Editor.Shared.Tests/AudioEffectAuthoringTests.cs
new file mode 100644
index 00000000..82bf8fc4
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/AudioEffectAuthoringTests.cs
@@ -0,0 +1,125 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Services;
+
+namespace GeneralTest.Editor;
+
+public sealed class AudioEffectAuthoringTests
+{
+    private static EditorEntryData Entry(string id, string type, object parameters, string condition = "") => new()
+    { StableId = id, Type = type, Condition = condition, Parameters = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(JsonSerializer.Serialize(parameters))! };
+    private static EditorEntryData Apply(string id, string instance = "effect", string target = "same", string scope = "track", string type = "seffect.reverb", string condition = "")
+        => Entry(id, BuiltinEntryIds.ApplyAudioSEffect, new { scope, targetId = target, instanceId = instance, id = type, parameters = SEffectCatalog.Builtins.TryGet(type, out var definition) ? definition.DefaultParameters : JsonSerializer.SerializeToElement(new { }) }, condition);
+    private static EditorGraphDocument Graph(params string[] ids) => new() { RootNodeId = ids[0], Nodes = ids.Select(id => new EditorGraphNodeDto { Id = id, Type = "Group" }).ToList() };
+    private static void Edge(EditorGraphDocument graph, string from, string to) => graph.Edges.Add(new() { FromNodeId = from, ToNodeId = to });
+
+    [Test]
+    public void AttachmentIdentitySeparatesScopesAndStoppingSourcesKeepsEffects()
+    {
+        var entries = new List<EditorEntryData> { Apply("track"), Apply("bus", scope: "bus"), Apply("second", instance: "second"),
+            Entry("source", BuiltinEntryIds.StopAudio, new { trackId = "same" }),
+            Entry("stop", BuiltinEntryIds.StopAudioSEffect, new { targetId = "same", instanceId = "effect" }),
+            Entry("all", BuiltinEntryIds.StopAudioSEffect, new { targetId = "same", all = true }) };
+        var analysis = new SceneTargetAnalysis(Graph("g"), new Dictionary<string, List<EditorEntryData>> { ["g"] = entries });
+        Assert.That(analysis.Before("g", "track").AudioEffects, Is.Empty);
+        Assert.That(analysis.Before("g", "stop").AudioEffects, Has.Count.EqualTo(3));
+        Assert.That(analysis.Before("g", "all").AudioEffects, Has.Count.EqualTo(2));
+        var final = analysis.Before("g", null);
+        Assert.That(final.AudioEffects.Single().Key.Scope, Is.EqualTo(SEffectScope.Bus));
+        Assert.That(final.Complete && final.AudioComplete, Is.True);
+    }
+
+    [Test]
+    public void BranchMergeKeepsEverySourceAndPossibleAlgorithmWithoutInventingAUniqueType()
+    {
+        var graph = Graph("root", "left", "right", "merge"); Edge(graph, "root", "left"); Edge(graph, "root", "right"); Edge(graph, "left", "merge"); Edge(graph, "right", "merge");
+        Dictionary<string, List<EditorEntryData>> groups = new()
+        {
+            ["root"] = [],
+            ["left"] = [Apply("left")],
+            ["right"] = [Apply("right", type: "seffect.gain"), Apply("conditional", instance: "optional", condition: "flag")],
+            ["merge"] = []
+        };
+        var result = new SceneTargetAnalysis(graph, groups).Before("merge", null);
+        var common = result.AudioEffects.Single(effect => effect.Key.InstanceId == "effect");
+        Assert.That(common.Presence, Is.EqualTo(TargetPresence.Definite));
+        Assert.That(common.Sources.Select(source => source.EntryId), Is.EquivalentTo(new[] { "left", "right" }));
+        Assert.That(common.Types, Is.EquivalentTo(new[] { "seffect.reverb", "seffect.gain" }));
+        Assert.That(result.AudioEffects.Single(effect => effect.Key.InstanceId == "optional").Presence, Is.EqualTo(TargetPresence.Possible));
+    }
+
+    [Test]
+    public void UnknownSemanticsRemainsIncompleteAfterStopAllButKnownMetadataErrorsCanBeRemoved()
+    {
+        Dictionary<string, List<EditorEntryData>> groups = new()
+        {
+            ["g"] = [Apply("bad", type: "custom.unknown"),
+            Entry("stop", BuiltinEntryIds.StopAudioSEffect, new { targetId = "same", all = true })]
+        };
+        var analysis = new SceneTargetAnalysis(Graph("g"), groups);
+        Assert.That(analysis.Before("g", "stop").AudioComplete, Is.False);
+        Assert.That(analysis.Before("g", null).AudioComplete, Is.True);
+        groups["g"].Insert(1, Entry("unknown", "custom.invoke", new { }));
+        analysis = new(Graph("g"), groups);
+        Assert.That(analysis.Before("g", null).AudioComplete, Is.False);
+    }
+
+    [Test]
+    public void NewAndCopiedIdentitiesAreQualifiedAndOnlyDeclaredInternalReferencesAreRemapped()
+    {
+        var first = SceneAuthoringIdentities.NewEntry(BuiltinEntryIds.ApplyAudioSEffect, []);
+        var second = SceneAuthoringIdentities.NewEntry(BuiltinEntryIds.ApplyAudioSEffect, []);
+        Assert.That(first["instanceId"].GetString(), Is.Not.EqualTo(second["instanceId"].GetString()));
+        var create = Apply("create"); var stop = Entry("stop", BuiltinEntryIds.StopAudioSEffect, new { targetId = "same", instanceId = "effect" });
+        var bus = Entry("bus", BuiltinEntryIds.StopAudioSEffect, new { scope = "bus", targetId = "same", instanceId = "effect" });
+        var other = Entry("other", BuiltinEntryIds.StopAudioSEffect, new { targetId = "other", instanceId = "effect" });
+        var all = Entry("all", BuiltinEntryIds.StopAudioSEffect, new { targetId = "same", all = true });
+        SceneAuthoringIdentities.RemapCopy([create, stop, bus, other, all]);
+        Assert.That(stop.Parameters["instanceId"].GetString(), Is.EqualTo(create.Parameters["instanceId"].GetString()).And.Not.EqualTo("effect"));
+        Assert.That(bus.Parameters["instanceId"].GetString(), Is.EqualTo("effect"));
+        Assert.That(other.Parameters["instanceId"].GetString(), Is.EqualTo("effect"));
+        Assert.That(create.Parameters["id"].GetString(), Is.EqualTo("seffect.reverb"));
+        Assert.That(all.Parameters.ContainsKey("instanceId"), Is.False);
+    }
+
+    [Test]
+    public void ReferenceIndexUsesAudioDomainAndAttachmentAndReportsMissingAfterTargetChanges()
+    {
+        var stop = Entry("stop", BuiltinEntryIds.StopAudioSEffect, new { scope = "bus", targetId = "same", instanceId = "effect" });
+        Dictionary<string, List<EditorEntryData>> groups = new() { ["g"] = [Apply("track"), Apply("bus", scope: "bus"), stop] };
+        var index = new SceneReferenceIndex(groups); var reference = index.References.Single();
+        Assert.That(index.Candidates(reference).Single().Owner.EntryId, Is.EqualTo("bus"));
+        Assert.That(SceneReferenceAnalysis.Resolve(reference, new(Graph("g"), groups)).Code, Is.EqualTo("scene.reference.resolved"));
+        groups["g"].RemoveAt(1);
+        Assert.That(SceneReferenceAnalysis.Resolve(reference, new(Graph("g"), groups)).Code, Is.EqualTo("scene.reference.missing"));
+    }
+
+    [Test]
+    public void UpdateDoesNotCreateInstancesAndInvalidAudioDoesNotInvalidateVisualFacts()
+    {
+        Dictionary<string, List<EditorEntryData>> groups = new()
+        {
+            ["g"] = [Apply("effect"),
+            Entry("update", BuiltinEntryIds.UpdateAudioSEffect, new { targetId = "same", instanceId = "missing", parameters = new { mix = .3 } }),
+            Entry("invalid", BuiltinEntryIds.ApplyAudioSEffect, new { targetId = "same", scope = "invalid" }), Apply("future", instance: "future")]
+        };
+        var analysis = new SceneTargetAnalysis(Graph("g"), groups);
+        Assert.That(analysis.Before("g", "invalid").AudioEffects, Has.Count.EqualTo(1));
+        var beforeFuture = analysis.Before("g", "future");
+        Assert.That(beforeFuture.AudioEffects.Single().Key.InstanceId, Is.EqualTo("effect"));
+        Assert.That(beforeFuture.Complete, Is.True); Assert.That(beforeFuture.AudioComplete, Is.False);
+    }
+
+    [Test]
+    public void LoopAndBudgetAreFiniteAndNeverAdvertiseAudioAsVisualObjects()
+    {
+        var graph = Graph("g", "unreachable"); Edge(graph, "g", "g");
+        Dictionary<string, List<EditorEntryData>> groups = new() { ["g"] = [Apply("create", condition: "flag"), Entry("wait", BuiltinEntryIds.Wait, new { })], ["unreachable"] = [Apply("unused")] };
+        var result = new SceneTargetAnalysis(graph, groups).Before("g", "wait");
+        Assert.That(result.AudioEffects.Single().Presence, Is.EqualTo(TargetPresence.Possible)); Assert.That(result.Targets, Is.Empty);
+        var limited = new SceneTargetAnalysis(graph, groups, budget: 1).Before("g", "wait");
+        Assert.That(limited.AudioComplete, Is.False); Assert.That(limited.AudioEffects.SelectMany(effect => effect.Sources).Any(source => source.EntryId == "unused"), Is.False);
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/AuthoringDraftPersistenceTests.cs b/test/GalNet.Editor.Shared.Tests/AuthoringDraftPersistenceTests.cs
index e860d4f9..0d997179 100644
--- a/test/GalNet.Editor.Shared.Tests/AuthoringDraftPersistenceTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/AuthoringDraftPersistenceTests.cs
@@ -20,7 +20,7 @@ public void SetUp()
     {
         _root = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "GalNet-drafts-" + Guid.NewGuid())).FullName;
         _catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
-        Put("Graph/graph.json", Graph); Put("settings.json", "{}");
+        Put("Graph/graph.json", Graph); Put("settings.json", """{"version":1,"sections":{}}""");
         Put(Source, """{"version":2,"kind":"Raw","entries":[]}""");
     }
     [TearDown] public void TearDown() => Directory.Delete(_root, true);
@@ -40,14 +40,14 @@ public void AuthoringRoundTripsDraftJsonWhileCompleteValidationStillRejectsIt(st
         Put(Source, JsonSerializer.Serialize(new GroupDocument { Entries = [entry] }));
         var original = JsonSerializer.SerializeToElement(entry.Parameters);
         var repository = new EditorDocumentRepository(_catalog, EditorDocumentValidation.Authoring);
-        var loaded = repository.Load(_root, "Draft", new());
+        var loaded = repository.Load(_root);
         loaded.Document.Name = "Saved draft";
         repository.Save(_root, loaded.Document, loaded.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value));
-        var reopened = new EditorDocumentRepository(_catalog, EditorDocumentValidation.Authoring).Load(_root, "Draft", new());
+        var reopened = new EditorDocumentRepository(_catalog, EditorDocumentValidation.Authoring).Load(_root);
         var saved = reopened.GroupEntries["a"].Single();
         Assert.That(saved.StableId, Is.EqualTo(entry.Id)); Assert.That(saved.Type, Is.EqualTo(entry.Type)); Assert.That(saved.Condition, Is.EqualTo(entry.Condition));
         Assert.That(JsonElement.DeepEquals(original, JsonSerializer.SerializeToElement(saved.Parameters)), Is.True, "Saving must not normalize, insert defaults, or coerce invalid values.");
-        Assert.That(() => new EditorDocumentRepository(_catalog).Load(_root, "Draft", new()), Throws.TypeOf<InvalidDataException>());
+        Assert.That(() => new EditorDocumentRepository(_catalog).Load(_root), Throws.TypeOf<InvalidDataException>());
         var result = new ProjectValidationService(_root).Validate(catalog: _catalog);
         Assert.That(result.Success, Is.False); Assert.That(result.Diagnostics.Any(item => item.Code.StartsWith("entry.", StringComparison.Ordinal) || item.Code == "condition.syntaxInvalid"), Is.True);
         if (kind != "condition") Assert.That(() => GalgroupCompiler.Compile(new GroupDocument { Entries = [entry] }, _catalog), Throws.Exception);
@@ -60,9 +60,9 @@ public void AuthoringGraphConditionsRemainDraftsWithoutSkippingGraphTopologyOrSo
         graph.Nodes.Add(new() { Id = "branch", Name = "Branch", Type = "Branch", BranchType = "Condition", Conditions = [new() { Id = "condition", Expression = expression }] });
         Put("Graph/graph.json", JsonSerializer.Serialize(graph));
         var repository = new EditorDocumentRepository(_catalog, EditorDocumentValidation.Authoring);
-        var loaded = repository.Load(_root, "Draft", new());
+        var loaded = repository.Load(_root);
         repository.Save(_root, loaded.Document, loaded.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value));
-        Assert.That(repository.Load(_root, "Draft", new()).Document.Nodes[1].Conditions![0].Expression, Is.EqualTo(expression));
+        Assert.That(repository.Load(_root).Document.Nodes[1].Conditions![0].Expression, Is.EqualTo(expression));
         Assert.That(new ProjectValidationService(_root).Validate("graph").Success, Is.False);
         loaded.Document.Edges.Add(new() { Id = "broken", FromNodeId = "missing", ToNodeId = "a" });
         Assert.That(() => repository.PrepareSave(_root, loaded.Document, loaded.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value)), Throws.TypeOf<InvalidDataException>());
@@ -80,7 +80,7 @@ public void AuthoringStillRejectsMalformedOrLossySourceBeforeWriting(string raw)
     {
         Put(Source, raw); var bytes = File.ReadAllBytes(Path.Combine(_root, Source));
         var repository = new EditorDocumentRepository(_catalog, EditorDocumentValidation.Authoring);
-        Assert.That(() => repository.Load(_root, "Draft", new()), Throws.TypeOf<InvalidDataException>());
+        Assert.That(() => repository.Load(_root), Throws.TypeOf<InvalidDataException>());
         var graph = JsonSerializer.Deserialize<EditorGraphDocument>(Graph)!;
         Assert.That(() => new EditorDocumentRepository(_catalog, EditorDocumentValidation.Authoring).Save(_root, graph, new Dictionary<string, IReadOnlyList<EditorEntryData>> { ["a"] = [] }), Throws.TypeOf<InvalidDataException>());
         Assert.That(File.ReadAllBytes(Path.Combine(_root, Source)), Is.EqualTo(bytes));
@@ -91,7 +91,7 @@ public void AuthoringDoesNotSkipSourcePathsAndExistence(string path)
     {
         var graph = JsonSerializer.Deserialize<EditorGraphDocument>(Graph)!; graph.Nodes[0].File = path;
         Put("Graph/graph.json", JsonSerializer.Serialize(graph));
-        Assert.That(() => new EditorDocumentRepository(_catalog, EditorDocumentValidation.Authoring).Load(_root, "Draft", new()), Throws.TypeOf<InvalidDataException>());
+        Assert.That(() => new EditorDocumentRepository(_catalog, EditorDocumentValidation.Authoring).Load(_root), Throws.TypeOf<InvalidDataException>());
     }
 
     private void Put(string relative, string text)
diff --git a/test/GalNet.Editor.Shared.Tests/DefaultVisualTemplateTests.cs b/test/GalNet.Editor.Shared.Tests/DefaultVisualTemplateTests.cs
new file mode 100644
index 00000000..bd166032
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/DefaultVisualTemplateTests.cs
@@ -0,0 +1,129 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Shared.Commands;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.Shared.Visuals;
+using GeneralTest.Editor.Shared;
+
+namespace GalNet.Editor.Shared.Tests;
+
+public sealed class DefaultVisualTemplateTests
+{
+    [Test]
+    public async Task Explicit_install_preserves_modified_bound_shaders_supports_dry_run_and_rejects_path_collisions()
+    {
+        var directory = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+        while (!File.Exists(Path.Combine(directory.FullName, "GalNet.slnx"))) directory = directory.Parent!;
+#if DEBUG
+        const string configuration = "Debug";
+#else
+        const string configuration = "Release";
+#endif
+        var contracts = Path.Combine(directory.FullName, "src/Editor/GalNet.Editor.DefaultContracts/bin", configuration, "net10.0");
+        var parent = Path.Combine(Path.GetTempPath(), "GalNet-visual-install-" + Guid.NewGuid());
+        var target = Path.Combine(parent, "Content");
+        try
+        {
+            await EditorProjectCreator.CreateAsync(new(target, ContractsDirectory: contracts));
+            var settingsPath = Path.Combine(target, "settings.json");
+            var settings = JsonSerializer.Deserialize<ProjectConfiguration>(File.ReadAllBytes(settingsPath))!;
+            var options = settings.ReadDefaultOptions();
+            var bloom = options.DefaultVisualPrograms["bloom"];
+            options.DefaultVisualPrograms = new() { ["bloom"] = bloom };
+            settings.Set(DefaultProjectConfiguration.Section, options);
+            File.WriteAllText(settingsPath, JsonSerializer.Serialize(settings));
+            var bloomPath = Path.Combine(target, "Assets/Effects/Default/Bloom.sksl");
+            File.AppendAllText(bloomPath, "\n// author modification\n");
+            var modified = File.ReadAllBytes(bloomPath);
+            // Missing bindings do not authorize overwriting existing files.
+            using (var schema = ProjectSchemaContext.Load(target))
+            {
+                var conflict = await DefaultVisualInstaller.InstallAsync(target, schema.Catalog, schema.Configurations);
+                Assert.That(conflict.Success, Is.False);
+                Assert.That(File.ReadAllBytes(bloomPath), Is.EqualTo(modified));
+            }
+            foreach (var name in DefaultVisualTemplate.ProgramNames.Values.Where(name => name != "Bloom"))
+            {
+                File.Delete(Path.Combine(target, "Assets/Effects/Default", name + ".sksl"));
+                File.Delete(Path.Combine(target, "Assets/Effects/Default", name + ".sksl.meta"));
+            }
+            var original = File.ReadAllBytes(settingsPath);
+            var dryRun = await CliHelpTests.Invoke(["project", "visuals", "install", target, "--dry-run"]);
+            Assert.That(dryRun.ExitCode, Is.Zero, dryRun.Output);
+            Assert.That(File.ReadAllBytes(settingsPath), Is.EqualTo(original));
+            Assert.That(Directory.GetFiles(Path.Combine(target, "Assets/Effects/Default"), "*.sksl"), Has.Length.EqualTo(1));
+            var installation = await CliHelpTests.Invoke(["project", "visuals", "install", target]);
+            Assert.That(installation.ExitCode, Is.Zero, installation.Output);
+            Assert.That(File.ReadAllBytes(bloomPath), Is.EqualTo(modified));
+            settings = JsonSerializer.Deserialize<ProjectConfiguration>(File.ReadAllBytes(settingsPath))!;
+            Assert.That(settings.ReadDefaultOptions().DefaultVisualPrograms["bloom"], Is.EqualTo(bloom));
+            Assert.That(settings.ReadDefaultOptions().DefaultVisualPrograms, Has.Count.EqualTo(8));
+            var installed = File.ReadAllBytes(settingsPath);
+            var repeated = await CliHelpTests.Invoke(["project", "visuals", "install", target]);
+            Assert.That(repeated.ExitCode, Is.Zero, repeated.Output);
+            Assert.That(File.ReadAllBytes(settingsPath), Is.EqualTo(installed));
+        }
+        finally { if (Directory.Exists(parent)) Directory.Delete(parent, true); }
+    }
+
+    [Test]
+    public void Plan_preserves_author_bindings_and_unknown_configuration_without_mutating_input()
+    {
+        var configuration = new DefaultProjectOptions { DefaultVisualPrograms = new() { ["blur"] = "custom-blur" } }.ToConfiguration();
+        configuration.SetRaw("custom", new(1, JsonSerializer.SerializeToElement(new { author = "kept" })));
+        var plan = DefaultVisualTemplate.Prepare(configuration);
+        Assert.Multiple(() =>
+        {
+            Assert.That(configuration.ReadDefaultOptions().DefaultVisualPrograms, Has.Count.EqualTo(1));
+            Assert.That(plan.Configuration.ReadDefaultOptions().DefaultVisualPrograms["blur"], Is.EqualTo("custom-blur"));
+            Assert.That(plan.Files.ContainsKey("Assets/Effects/Default/Blur.sksl"), Is.False);
+            Assert.That(plan.Configuration.Sections["custom"].Data.GetProperty("author").GetString(), Is.EqualTo("kept"));
+        });
+        Assert.That(DefaultVisualTemplate.Prepare(plan.Configuration).Files, Is.Empty, "Preparing an already bound project must not replace its assets.");
+    }
+
+    [Test]
+    public async Task Default_project_deploys_editable_sources_with_project_owned_ids_and_accurate_dry_run()
+    {
+        var directory = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+        while (!File.Exists(Path.Combine(directory.FullName, "GalNet.slnx"))) directory = directory.Parent!;
+#if DEBUG
+        const string configuration = "Debug";
+#else
+        const string configuration = "Release";
+#endif
+        var contracts = Path.Combine(directory.FullName, "src/Editor/GalNet.Editor.DefaultContracts/bin", configuration, "net10.0");
+        var parent = Path.Combine(Path.GetTempPath(), "GalNet-visuals-" + Guid.NewGuid());
+        try
+        {
+            var target = Path.Combine(parent, "Content");
+            var dry = await EditorProjectCreator.CreateAsync(new(target, ContractsDirectory: contracts, DryRun: true));
+            var report = (ProjectCreateReport)dry.Data!;
+            Assert.That(Directory.Exists(parent), Is.False);
+            Assert.That(report.Files.Count(file => file.EndsWith(".sksl", StringComparison.Ordinal)), Is.EqualTo(8));
+            var created = await EditorProjectCreator.CreateAsync(new(target, ContractsDirectory: contracts));
+            var createdReport = (ProjectCreateReport)created.Data!;
+            using var json = JsonDocument.Parse(File.ReadAllText(Path.Combine(target, "settings.json")));
+            var settings = json.RootElement.Deserialize<ProjectConfiguration>()!;
+            var bindings = settings.ReadDefaultOptions().DefaultVisualPrograms;
+            Assert.That(bindings, Has.Count.EqualTo(8));
+            foreach (var (purpose, name) in DefaultVisualTemplate.ProgramNames)
+            {
+                var shader = Path.Combine(target, "Assets/Effects/Default", name + ".sksl");
+                Assert.That(File.ReadAllText(shader), Is.EqualTo(DefaultVisualTemplate.ReadShader(name)));
+                using var meta = JsonDocument.Parse(File.ReadAllText(shader + ".meta"));
+                Assert.That(meta.RootElement.GetProperty("id").GetString(), Is.EqualTo(bindings[purpose]));
+            }
+            Assert.That(new ProjectValidationService(target).Validate().Success, Is.True);
+            var actual = Directory.GetFiles(target, "*", SearchOption.AllDirectories).Select(path => Path.GetRelativePath(target, path).Replace('\\', '/'));
+            Assert.That(actual, Is.EquivalentTo(createdReport.Files));
+            Assert.That(createdReport.Files.Where(file => file.StartsWith("Assets/", StringComparison.Ordinal)),
+                Is.EquivalentTo(report.Files.Where(file => file.StartsWith("Assets/", StringComparison.Ordinal))));
+            var another = DefaultVisualTemplate.Prepare(new ProjectConfiguration()).Configuration.ReadDefaultOptions();
+            Assert.That(another.DefaultVisualPrograms.Values.Intersect(bindings.Values), Is.Empty);
+        }
+        finally { if (Directory.Exists(parent)) Directory.Delete(parent, true); }
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/EditorDocumentRepositoryTests.cs b/test/GalNet.Editor.Shared.Tests/EditorDocumentRepositoryTests.cs
index fc718f17..d8d72cfc 100644
--- a/test/GalNet.Editor.Shared.Tests/EditorDocumentRepositoryTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/EditorDocumentRepositoryTests.cs
@@ -3,11 +3,10 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Core.Parameters;
 using GalNet.Core.Primitives;
-using GalNet.Core.Settings;
 using GalNet.Core.Variable;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Shared.Services;
@@ -38,7 +37,7 @@ public void TearDown()
     }
 
     [Test]
-    public void Load_DoesNotMigrateSettingsVariables_AndRejectsUnknownParameters()
+    public void Load_UsesGraphVariables_AndRejectsUnknownParameters()
     {
         var groupId = "group_1";
         var document = new EditorGraphDocument
@@ -60,23 +59,11 @@ public void Load_DoesNotMigrateSettingsVariables_AndRejectsUnknownParameters()
             Path.Combine(_tempDir, "Graph", "groups", $"{groupId}.rawgalgroup"),
             """{ "version": 2, "kind": "Raw", "entries": [ { "id": "entry-1", "type": "dialogue.text", "parameters": { "content": "hello", "obsolete": "discard" } } ] }""");
 
-        var settings = new ProjectSettings
-        {
-            PlayerVariables =
-            [
-                new() { Name = "player_flag", DefaultValue = new GalNet.Core.Variable.Variable { Name = "player_flag", Value = VariableValue.From(false) } }
-            ],
-            SaveVariables =
-            [
-                new() { Name = "save_count", DefaultValue = new GalNet.Core.Variable.Variable { Name = "save_count", Value = VariableValue.From(1) } }
-            ]
-        };
-
         var repository = new EditorDocumentRepository(new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules()));
-        Assert.That(() => repository.Load(_tempDir, "Demo", settings), Throws.TypeOf<InvalidDataException>().With.Message.Contains("obsolete"));
+        Assert.That(() => repository.Load(_tempDir), Throws.TypeOf<InvalidDataException>().With.Message.Contains("obsolete"));
         File.WriteAllText(Path.Combine(_tempDir, "Graph", "groups", $"{groupId}.rawgalgroup"),
             """{"version":2,"kind":"Raw","entries":[{"id":"entry-1","type":"dialogue.text","parameters":{"content":"hello"}}]}""");
-        var loaded = repository.Load(_tempDir, "Demo", settings);
+        var loaded = repository.Load(_tempDir);
 
         Assert.That(loaded.Document.PlayerVariables, Is.Empty);
         Assert.That(loaded.Document.SaveVariables, Is.Empty);
@@ -128,7 +115,7 @@ public void Save_WritesVariablesAndGroupEntriesIntoProjectFiles()
         Assert.That(savedDocument, Is.Not.Null);
         Assert.That(savedDocument!.PlayerVariables.Select(v => v.Name), Is.EqualTo(ExpectedPlayerName));
         Assert.That(savedDocument.SaveVariables.Select(v => v.Name), Is.EqualTo(ExpectedSaveSlot));
-        var reloaded = repository.Load(_tempDir, "Demo", new ProjectSettings());
+        var reloaded = repository.Load(_tempDir);
         var savedGroupDocument = JsonDocument.Parse(savedGroup);
         Assert.That(savedGroupDocument.RootElement.GetProperty("kind").GetString(), Is.EqualTo("Raw"));
         var entry = savedGroupDocument.RootElement.GetProperty("entries")[0];
@@ -158,7 +145,7 @@ [new DefaultEntryModule("custom",
             """{ "version": 2, "kind": "Raw", "entries": [ { "id": "pulse-1", "type": "custom.pulse", "parameters": { "count": 3 } } ] }""");
 
         var repository = new EditorDocumentRepository(catalog);
-        var loaded = repository.Load(_tempDir, "Custom", new ProjectSettings());
+        var loaded = repository.Load(_tempDir);
         repository.Save(_tempDir, loaded.Document, loaded.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value));
 
         Assert.That(loaded.GroupEntries[groupId].Single().Parameters["count"].GetInt32(), Is.EqualTo(3));
@@ -185,7 +172,7 @@ public void RepositoryRoundTripsStringEncodedEnumUsingProjectJsonOptions()
         File.WriteAllText(sourcePath,
             """{"version":2,"kind":"Raw","entries":[{"id":"day-1","type":"custom.day","parameters":{"day":"Monday"}}]}""");
         var repository = new EditorDocumentRepository(catalog);
-        var loaded = repository.Load(_tempDir, "Days", new ProjectSettings());
+        var loaded = repository.Load(_tempDir);
         Assert.That(loaded.GroupEntries[groupId][0].Parameters["day"].GetString(), Is.EqualTo("Monday"));
         loaded.GroupEntries[groupId][0].Parameters["day"] = JsonSerializer.SerializeToElement("Tuesday");
         repository.Save(_tempDir, loaded.Document,
diff --git a/test/GalNet.Editor.Shared.Tests/EditorSettingsSerializationTests.cs b/test/GalNet.Editor.Shared.Tests/EditorSettingsSerializationTests.cs
index dd6d6a71..ac1489f0 100644
--- a/test/GalNet.Editor.Shared.Tests/EditorSettingsSerializationTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/EditorSettingsSerializationTests.cs
@@ -1,5 +1,5 @@
 using System.Text.Json;
-using GalNet.Core.Settings;
+using GalNet.Editor.Abstraction.Settings;
 
 namespace GeneralTest.Editor;
 
diff --git a/test/GalNet.Editor.Shared.Tests/EffectParameterLocalizationTests.cs b/test/GalNet.Editor.Shared.Tests/EffectParameterLocalizationTests.cs
new file mode 100644
index 00000000..eacc8a6a
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/EffectParameterLocalizationTests.cs
@@ -0,0 +1,182 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Commands;
+using GalNet.Editor.Shared.Services;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class EffectParameterLocalizationTests
+{
+    private static EditorEntryData Entry(string id, string type, object parameters) => new()
+    { StableId = id, Type = type, Parameters = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(JsonSerializer.Serialize(parameters))! };
+    private static EditorProjectDocument Document(params EditorEntryData[] entries) => new()
+    {
+        Graph = new() { RootNodeId = "g", Nodes = [new() { Id = "g", Type = "Group" }] },
+        GroupEntries = new() { ["g"] = entries.ToList() }
+    };
+    private static LocalizationReferenceIndex Scan(EditorProjectDocument document, EntryParameterMetadata? metadata = null) =>
+        new(document, new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules()), [], null, metadata ?? new());
+
+    [Test]
+    public void AllKnownAudioEffectsUseTheirCatalogFieldsWithoutMutatingAuthorData()
+    {
+        var document = Document(SEffectCatalog.Builtins.Definitions.Select(effect => Entry(effect.Id, BuiltinEntryIds.ApplyAudioSEffect,
+            new { id = effect.Id, parameters = effect.DefaultParameters })).ToArray());
+        var before = JsonSerializer.Serialize(document);
+        var index = Scan(document);
+        Assert.That(index.Complete, Is.True);
+        Assert.That(index.Issues, Is.Empty);
+        Assert.That(index.References, Is.Empty);
+        Assert.That(JsonSerializer.Serialize(document), Is.EqualTo(before));
+        var entry = document.GroupEntries["g"][0];
+        entry.Parameters["parameters"] = JsonSerializer.Deserialize<JsonElement>("""{"unknown":{"caption":"unclassified"}}""");
+        var issue = Scan(document).Issues.Single();
+        Assert.That(issue.Code, Is.EqualTo("field.unknown"));
+        Assert.That(issue.JsonPointer, Is.EqualTo("/parameters/unknown"));
+        Assert.That(issue.EntryId, Is.EqualTo(entry.StableId));
+        entry.Parameters["id"] = JsonSerializer.SerializeToElement("custom.unavailable");
+        Assert.That(Scan(document).Issues.Single().Code, Is.EqualTo("field.opaque"));
+    }
+
+    [TestCase(BuiltinEntryIds.ApplyEffect)]
+    [TestCase(BuiltinEntryIds.SpeedLinesPreset)]
+    [TestCase(BuiltinEntryIds.ImpactPreset)]
+    public void ShaderParametersShareFormFieldsIncludingVectorsAndOrdinaryStrings(string type)
+    {
+        var shader = new ShaderEffectDescriptor(new("shader"), 1, "source", new HashSet<EffectStage> { EffectStage.Layer, EffectStage.ScenePost },
+        [new("amount", "amount", ShaderEffectParameterKind.Float, Minimum: 0, Maximum: 1),
+            new("direction", "direction", ShaderEffectParameterKind.Vector3), new("tint", "tint", ShaderEffectParameterKind.Color),
+            new("mask", "mask", ShaderEffectParameterKind.Texture), new("style", "style", ShaderEffectParameterKind.Enum, Options: ["soft", "hard"]),
+            new("count", "count", ShaderEffectParameterKind.Integer), new("enabled", "enabled", ShaderEffectParameterKind.Boolean),
+            new("offset", "offset", ShaderEffectParameterKind.Vector2), new("channels", "channels", ShaderEffectParameterKind.Vector4)]);
+        var metadata = new EntryParameterMetadata(Programs: new Dictionary<string, ShaderEffectDescriptor?> { ["shader"] = shader });
+        var entry = Entry("fx", type, new
+        {
+            program = "shader",
+            parameters = new
+            {
+                amount = .5,
+                direction = new[] { 1, 2, 3 },
+                tint = "#11223344",
+                mask = "image",
+                style = "soft",
+                count = 2,
+                enabled = true,
+                offset = new[] { 0, 1 },
+                channels = new[] { 1, 2, 3, 4 }
+            }
+        });
+        var document = Document(entry);
+        Assert.That(Scan(document, metadata).Issues, Is.Empty);
+        Assert.That(Scan(document, metadata).References, Is.Empty, "Colors, texture IDs and enum choices are not localized text keys.");
+        entry.Parameters["parameters"] = JsonSerializer.Deserialize<JsonElement>("""{"amount":2,"direction":[1,"bad",3],"unknown":42}""");
+        var invalid = Scan(document, metadata);
+        Assert.That(invalid.Issues.Select(issue => (issue.Code, issue.JsonPointer)), Is.EquivalentTo(new[]
+        { ("value.range", "/parameters/amount"), ("value.type", "/parameters/direction/1") }));
+        entry.Parameters["program"] = JsonSerializer.SerializeToElement("missing");
+        Assert.That(Scan(document, metadata).Issues.Single().Code, Is.EqualTo("field.opaque"));
+    }
+
+    [TestCase(BuiltinEntryIds.ApplyEffect)]
+    [TestCase(BuiltinEntryIds.SpeedLinesPreset)]
+    [TestCase(BuiltinEntryIds.ImpactPreset)]
+    public void KnownShaderAcceptsPreservedAdditionalParametersAsLegalUninterpretedData(string type)
+    {
+        var parsed = ShaderEffectMetadataParser.Parse(new("bloom"), GalNet.Editor.Shared.Visuals.DefaultVisualTemplate.ReadShader("Bloom"));
+        var entry = Entry("fx", type, new
+        {
+            program = "bloom",
+            parameters = new
+            {
+                angle = 0,
+                strength = 4,
+                softKnee = .2,
+                radius = 32,
+                threshold = .5,
+                future = new { caption = "literal", nested = new[] { "not-a-localization-key" } }
+            }
+        });
+        var document = Document(entry); var before = JsonSerializer.Serialize(document);
+        var metadata = new EntryParameterMetadata(Programs: new Dictionary<string, ShaderEffectDescriptor?> { ["bloom"] = parsed.Descriptor });
+        var index = Scan(document, metadata);
+        Assert.That(index.Issues, Is.Empty); Assert.That(index.Complete, Is.True); Assert.That(index.References, Is.Empty);
+        Assert.That(JsonSerializer.Serialize(document), Is.EqualTo(before));
+        entry.Parameters["parameters"] = JsonSerializer.Deserialize<JsonElement>("""{"radius":32,"angle":0,"angle":1}""");
+        Assert.That(Scan(document, metadata).Issues.Single().Code, Is.EqualTo("field.duplicate"));
+        Assert.That(Scan(document).Issues.Single().Code, Is.EqualTo("field.opaque"), "The open policy requires a known shader declaration.");
+    }
+
+    [Test]
+    public void RegisteredVisualAndCustomAudioCatalogsSupplyTheSameWireFieldsAsValidation()
+    {
+        var effects = new EffectCatalog([new("custom.fx", EffectStage.Layer, [new("strength", EffectParameterKind.Float), new("label", EffectParameterKind.Text)], [])]);
+        var audio = new SEffectCatalog([new("custom.audio", new HashSet<SEffectScope> { SEffectScope.Bus }, [new("wet", Minimum: 0, Maximum: 1)])]);
+        var document = Document(Entry("fx", BuiltinEntryIds.ApplyEffect, new { id = "custom.fx", parameters = new { strength = .2, label = "literal" } }),
+            Entry("audio", BuiltinEntryIds.ApplyAudioSEffect, new { id = "custom.audio", parameters = new { wet = .4 } }));
+        var metadata = new EntryParameterMetadata(effects, audio);
+        Assert.That(Scan(document, metadata).Issues, Is.Empty);
+        document.GroupEntries["g"][0].Parameters["program"] = JsonSerializer.SerializeToElement("missing-program");
+        Assert.That(Scan(document, metadata).Issues.Single().Code, Is.EqualTo("field.opaque"), "An explicit program must not fall back to a different ID catalog.");
+    }
+
+    [Test]
+    public void AudioUpdateResolvesThePriorInstanceByScopeTargetAndIdentityAndNeverUsesFutureAttachments()
+    {
+        var track = Entry("track", BuiltinEntryIds.ApplyAudioSEffect, new { scope = "track", targetId = "bgm", instanceId = "same", id = "seffect.reverb", parameters = new { mix = .25 } });
+        var bus = Entry("bus", BuiltinEntryIds.ApplyAudioSEffect, new { scope = "bus", targetId = "bgm", instanceId = "same", id = "seffect.gain", parameters = new { gain = .5 } });
+        var update = Entry("update", BuiltinEntryIds.UpdateAudioSEffect, new { scope = "track", targetId = "bgm", instanceId = "same", parameters = new { mix = .4 } });
+        var stop = Entry("stop", BuiltinEntryIds.StopAudioSEffect, new { scope = "track", targetId = "bgm", instanceId = "same" });
+        var document = Document(track, bus, update, stop);
+        Assert.That(Scan(document).Issues, Is.Empty);
+        document.GroupEntries["g"] = [update, track, bus, stop];
+        Assert.That(Scan(document).Issues.Single().Code, Is.EqualTo("field.opaque"));
+        document.GroupEntries["g"] = [track, bus, stop, update];
+        Assert.That(Scan(document).Issues.Single().Code, Is.EqualTo("field.opaque"));
+        document.GroupEntries["g"] = [track, bus, update, stop];
+        update.Parameters["scope"] = JsonSerializer.SerializeToElement("bus");
+        Assert.That(Scan(document).Issues.Single().JsonPointer, Is.EqualTo("/parameters/mix"));
+    }
+
+    [Test]
+    public async Task DiskValidationReadsShaderMetadataAndRetainsMissingOrAmbiguousResourceWarnings()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "GalNet-effect-localization-" + Guid.NewGuid().ToString("N"));
+        try
+        {
+            await EditorProjectCreator.CreateAsync(new(root, "Effects"));
+            var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+            var repository = new EditorDocumentRepository(catalog, EditorDocumentValidation.Authoring);
+            var loaded = repository.Load(root);
+            var group = loaded.GroupEntries.Keys.Single();
+            var id = Guid.NewGuid().ToString("N");
+            loaded.GroupEntries[group] = [Entry("fx", BuiltinEntryIds.ApplyEffect, new { program = id, parameters = new { amount = .5 } }),
+                Entry("audio", BuiltinEntryIds.ApplyAudioSEffect, new { id = "seffect.reverb", parameters = new { mix = .4 } })];
+            var plan = repository.PrepareSave(root, loaded.Document, loaded.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value));
+            repository.ApplySave(root, plan);
+            Directory.CreateDirectory(Path.Combine(root, "Assets"));
+            var shader = Path.Combine(root, "Assets", "test.sksl");
+            await File.WriteAllTextAsync(shader, """
+                /*
+                @gal.effect v=1
+                @input source
+                @targets scenePost
+                @param amount
+                  uniform: amount
+                  type: float
+                */
+                """);
+            await File.WriteAllTextAsync(shader + ".meta", JsonSerializer.Serialize(new { id, type = "effect-program" }));
+            Assert.That(LocalizationValidation.ValidateDisk(root, catalog), Is.Empty);
+            await File.WriteAllTextAsync(shader + ".duplicate.meta", JsonSerializer.Serialize(new { id, type = "effect-program" }));
+            Assert.That(LocalizationValidation.ValidateDisk(root, catalog).Any(issue => issue.Code == "localization.field.opaque" && issue.ObjectId == "fx"), Is.True);
+            File.Delete(shader + ".duplicate.meta");
+            File.Delete(shader);
+            Assert.That(LocalizationValidation.ValidateDisk(root, catalog).Any(issue => issue.Code == "localization.field.opaque" && issue.ObjectId == "fx"), Is.True);
+        }
+        finally { if (Directory.Exists(root)) Directory.Delete(root, true); }
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/ExternalProjectReloadTests.cs b/test/GalNet.Editor.Shared.Tests/ExternalProjectReloadTests.cs
new file mode 100644
index 00000000..2116e273
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/ExternalProjectReloadTests.cs
@@ -0,0 +1,160 @@
+using System.Text;
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Abstraction.Project;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Shared.Commands;
+using GalNet.Editor.Shared.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed class ExternalProjectReloadTests
+{
+    private string _root = null!;
+    private IEntryCatalog _catalog = null!;
+    private EditorDocumentRepository _repository = null!;
+    private EditorDocumentService _documents = null!;
+    private ProjectContentSession _content = null!;
+    private GalProject _project = null!;
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        _root = Path.Combine(Path.GetTempPath(), "GalNet-external-" + Guid.NewGuid().ToString("N"));
+        await EditorProjectCreator.CreateAsync(new(_root, "Original"));
+        _catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+        _repository = new(_catalog, EditorDocumentValidation.Authoring);
+        var settings = DirectProjectPersistence.LoadSettings(_root);
+        _documents = new(); _documents.Load(_repository.Load(_root));
+        _project = new("project", "Original", _root, settings, new(), new EmptyScope());
+        _content = new(_documents, _repository); _content.Open(_project);
+    }
+
+    [TearDown]
+    public async Task TearDown()
+    {
+        await _project.DisposeAsync(); _content.Dispose(); Directory.Delete(_root, true);
+    }
+
+    private ExternalProjectSnapshot Read() => ExternalProjectSnapshotReader.Read(_root, _content.FileDocuments.Values, _catalog);
+
+    [Test]
+    public async Task CliChangesReloadInTheSameSessionAndSubsequentSaveUsesTheNewDiskBaseline()
+    {
+        var group = _documents.Groups.Values.Single();
+        var source = _documents.CurrentDocument.Nodes.Single(node => node.Type == "Group");
+        var result = await new ProjectEditService(_root, _catalog).ExecuteAsync([new RenameProjectCommand("External")]);
+        Assert.That(result.Success, Is.True);
+        Assert.That(await _content.ReloadExternalAsync(Read()), Is.EqualTo(ExternalReloadResult.Reloaded));
+        Assert.That(_project.Name, Is.EqualTo("External"));
+        Assert.That(_documents.Groups[group.Id], Is.SameAs(group));
+        Assert.That(_documents.CurrentDocument.Nodes.Single(node => node.Id == source.Id), Is.SameAs(source));
+        Assert.That(_content.IsDirty, Is.False);
+        _documents.CurrentDocument.Name = "Editor after external";
+        await _content.SaveAsync();
+        Assert.That(_content.IsDirty, Is.False);
+        Assert.That(await _content.ReloadExternalAsync(Read()), Is.EqualTo(ExternalReloadResult.Unchanged));
+    }
+
+    [Test]
+    public async Task OwnPublicationDoesNotBecomeAnExternalReload()
+    {
+        var count = 0; _content.ExternalReloaded += () => count++;
+        _documents.CurrentDocument.Name = "Local";
+        await _content.SaveAsync();
+        Assert.That(await _content.ReloadExternalAsync(Read()), Is.EqualTo(ExternalReloadResult.Unchanged));
+        Assert.That(count, Is.Zero);
+    }
+
+    [Test]
+    public async Task LocalChangesAndPendingInputArePreservedUntilExplicitDiscard()
+    {
+        _documents.CurrentDocument.Name = "Unsaved";
+        var pending = true;
+        using var draft = _content.RegisterDraft(() => pending, () => Task.CompletedTask, () => pending = false);
+        await new ProjectEditService(_root, _catalog).ExecuteAsync([new RenameProjectCommand("External")]);
+        Assert.That(await _content.ReloadExternalAsync(Read()), Is.EqualTo(ExternalReloadResult.LocalChanges));
+        Assert.That(_documents.CurrentDocument.Name, Is.EqualTo("Unsaved")); Assert.That(pending, Is.True);
+        Assert.That(await _content.ReloadExternalAsync(Read(), true), Is.EqualTo(ExternalReloadResult.Reloaded));
+        Assert.That(_documents.CurrentDocument.Name, Is.EqualTo("External")); Assert.That(pending, Is.False);
+        Assert.That(_content.IsDirty, Is.False);
+        Assert.That(Directory.GetFiles(Path.Combine(_root, ".galnet/editor/recovery")), Is.Not.Empty);
+    }
+
+    [Test]
+    public async Task InvalidAndStaleCandidatesNeverReplaceTheLiveDocument()
+    {
+        var candidate = Read();
+        var file = Path.Combine(_root, "Graph/graph.json"); var original = File.ReadAllBytes(file);
+        File.WriteAllText(file, "{");
+        Assert.That(await _content.ReloadExternalAsync(candidate), Is.EqualTo(ExternalReloadResult.Retry));
+        Assert.Throws<InvalidDataException>(() => Read());
+        Assert.That(_documents.CurrentDocument.Name, Is.EqualTo("Original"));
+        File.WriteAllBytes(file, original);
+        await new ProjectEditService(_root, _catalog).ExecuteAsync([new RenameProjectCommand("Recovered")]);
+        Assert.That(await _content.ReloadExternalAsync(Read()), Is.EqualTo(ExternalReloadResult.Reloaded));
+    }
+
+    [Test]
+    public void CandidateWaitsForTheWholeExternalTransaction()
+    {
+        var directory = Path.Combine(_root, ".galnet/editor/transactions/active"); Directory.CreateDirectory(directory);
+        var manifest = Path.Combine(directory, "manifest.json");
+        File.WriteAllText(manifest, "{\"status\":\"publishing\"}");
+        Assert.Throws<IOException>(() => Read());
+        File.WriteAllText(manifest, "{\"status\":\"committed\"}");
+        Assert.DoesNotThrow(() => Read());
+    }
+
+    [Test]
+    public async Task ManagedTextAndLocalizationKeepIdentityAndAdoptDeletionAndNewFiles()
+    {
+        var textPath = Path.Combine(_root, "notes.txt"); File.WriteAllText(textPath, "before");
+        var text = _content.TrackFile("notes.txt", File.ReadAllBytes(textPath));
+        File.WriteAllText(textPath, "after");
+        Directory.CreateDirectory(Path.Combine(_root, "I18n/zh-CN"));
+        File.WriteAllText(Path.Combine(_root, "I18n/zh-CN/external.json"), "{\"line\":\"外部对白\"}");
+        Assert.That(await _content.ReloadExternalAsync(Read()), Is.EqualTo(ExternalReloadResult.Reloaded));
+        Assert.That(_content.FileDocuments[text.Id], Is.SameAs(text));
+        Assert.That(Encoding.UTF8.GetString(text.Data), Is.EqualTo("after"));
+        Assert.That(_content.FileDocuments.Values.Any(file => file.Path == "I18n/zh-CN/external.json" && file.ManagedContent), Is.True);
+        File.Delete(textPath);
+        Assert.That(await _content.ReloadExternalAsync(Read()), Is.EqualTo(ExternalReloadResult.Reloaded));
+        Assert.That(text.Exists, Is.False); Assert.That(_content.IsDirty, Is.False);
+        await _content.SaveAsync(); Assert.That(File.Exists(textPath), Is.False);
+    }
+
+    [Test]
+    public async Task GroupDeletionAndRestorationDoNotLeaveAProjectionOnAnObsoleteDocument()
+    {
+        var group = _documents.Groups.Values.Single();
+        var graph = File.ReadAllBytes(Path.Combine(_root, "Graph/graph.json"));
+        var path = Path.Combine(_root, group.RelativePath); var bytes = File.ReadAllBytes(path);
+        var removed = await new ProjectEditService(_root, _catalog).ExecuteAsync([new DeleteNodeCommand(group.Id)]);
+        Assert.That(removed.Success, Is.True);
+        await _content.ReloadExternalAsync(Read());
+        File.WriteAllBytes(path, bytes); File.WriteAllBytes(Path.Combine(_root, "Graph/graph.json"), graph);
+        await _content.ReloadExternalAsync(Read());
+        Assert.That(_documents.GetOrCreateGroup(group.Id, group.RelativePath), Is.SameAs(group));
+        Assert.That(_documents.LoadedProject.GroupEntries[group.Id], Is.SameAs(group.Entries));
+    }
+
+    [Test]
+    public void ContractChangesAreReportedBeforeAnyLiveMutation()
+    {
+        Directory.CreateDirectory(Path.Combine(_root, "Contracts")); File.WriteAllText(Path.Combine(_root, "Contracts/new.dll"), "new contract");
+        var candidate = Read();
+        var error = Assert.ThrowsAsync<EditorOperationException>(async () => await _content.ReloadExternalAsync(candidate));
+        Assert.That(error!.Code, Is.EqualTo("project.externalContracts")); Assert.That(_project.Name, Is.EqualTo("Original"));
+    }
+
+    private sealed class EmptyScope : IServiceScope
+    {
+        public IServiceProvider ServiceProvider => throw new NotSupportedException();
+        public void Dispose() { }
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/GalNet.Editor.Shared.Tests.csproj b/test/GalNet.Editor.Shared.Tests/GalNet.Editor.Shared.Tests.csproj
index d945aea6..e50f1dae 100644
--- a/test/GalNet.Editor.Shared.Tests/GalNet.Editor.Shared.Tests.csproj
+++ b/test/GalNet.Editor.Shared.Tests/GalNet.Editor.Shared.Tests.csproj
@@ -4,6 +4,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <ProjectReference Include="../../src/Editor/GalNet.Editor.DefaultContracts/GalNet.Editor.DefaultContracts.csproj" ReferenceOutputAssembly="false" />
     <ProjectReference Include="../../src/Editor/GalNet.Editor.Headless/GalNet.Editor.Headless.csproj" ReferenceOutputAssembly="false" />
     <ProjectReference Include="../Fixtures/SchemaA/SchemaA.csproj" ReferenceOutputAssembly="false" />
     <ProjectReference Include="../Fixtures/SchemaB/SchemaB.csproj" ReferenceOutputAssembly="false" />
diff --git a/test/GalNet.Editor.Shared.Tests/GraphValidationConsistencyTests.cs b/test/GalNet.Editor.Shared.Tests/GraphValidationConsistencyTests.cs
new file mode 100644
index 00000000..bd8f3f3d
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/GraphValidationConsistencyTests.cs
@@ -0,0 +1,49 @@
+using System.Text.Json;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Commands;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Shared.Tests;
+
+public sealed class GraphValidationConsistencyTests
+{
+    [TestCase("Choice")]
+    [TestCase("Condition")]
+    public void EmptyBranchHasNoConnectableOutletInCommandsOrDocumentValidation(string branchType)
+    {
+        var from = new EditorGraphNodeDto { Id = "branch", Type = "Branch", BranchType = branchType };
+        var to = new EditorGraphNodeDto { Id = "target", Type = "Group" };
+        var graph = new EditorGraphDocument
+        {
+            RootNodeId = from.Id,
+            Nodes = [from, to],
+            Edges = [new() { Id = "edge", FromNodeId = from.Id, ToNodeId = to.Id, FromOutlet = 0 }]
+        };
+        Assert.That(GraphEditRules.ConnectionError(from, 0, to)?.Code, Is.EqualTo("graph.edge.invalidOutlet"));
+        Assert.That(EditorDocumentValidator.Validate(new() { Graph = graph }).Diagnostics.Select(item => item.Code),
+            Does.Contain("graph.edge.invalidOutlet"));
+    }
+
+    [TestCase("a", "a", "Group", "graph.edge.selfConnection")]
+    [TestCase("a", "b", "Entry", "graph.edge.entryInput")]
+    public void RawGraphReportsSharedConnectionRuleOnce(string from, string to, string targetType, string code)
+    {
+        var nodes = new List<object> { new { id = "a", name = "A", type = "Entry" } };
+        if (to != from) nodes.Add(new { id = "b", name = "B", type = targetType });
+        var raw = JsonSerializer.SerializeToElement(new
+        {
+            version = 2,
+            name = "Graph",
+            rootNodeId = "a",
+            nodes,
+            edges = new[] { new { id = "edge", fromNodeId = from, toNodeId = to, fromOutlet = 0 } },
+            playerVariables = Array.Empty<object>(),
+            saveVariables = Array.Empty<object>()
+        });
+        var diagnostics = new List<ToolDiagnostic>();
+        new ProjectValidationService(Path.GetTempPath()).ValidateGraph(raw, diagnostics, checkSourceReferences: false);
+        Assert.That(diagnostics.Count(item => item.Code == code), Is.EqualTo(1));
+        Assert.That(diagnostics.Single(item => item.Code == code).JsonPointer, Is.EqualTo("/edges/0"));
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/GroupCompileServiceTests.cs b/test/GalNet.Editor.Shared.Tests/GroupCompileServiceTests.cs
index 8118994d..d5579713 100644
--- a/test/GalNet.Editor.Shared.Tests/GroupCompileServiceTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/GroupCompileServiceTests.cs
@@ -141,7 +141,7 @@ public async Task LinkedOutput_IsRejectedAndExternalDirectoryUnchanged()
     {
         var external = Directory.CreateDirectory(Path.Combine(_root, "external")).FullName;
         var link = Path.Combine(_root, "Output");
-        Directory.CreateSymbolicLink(link, external);
+        DirectoryLinks.Create(link, external);
         try
         {
             var result = await new GroupCompileService(_root).CompileAsync(new(new(Id: "a")));
diff --git a/test/GalNet.Editor.Shared.Tests/GroupValidationCompilationTests.cs b/test/GalNet.Editor.Shared.Tests/GroupValidationCompilationTests.cs
new file mode 100644
index 00000000..24b939e6
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/GroupValidationCompilationTests.cs
@@ -0,0 +1,28 @@
+using System.Text.Json;
+using GalNet.Core.Entry;
+using GalNet.Core.Primitives;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Shared.Tests;
+
+public sealed class GroupValidationCompilationTests
+{
+    [Test]
+    public void SemanticValidationDoesNotRepeatPrimitiveValidation()
+    {
+        var calls = 0;
+        var catalog = new TargetProfileEntryCatalog([new DefaultEntryModule("test",
+            [new DefaultPrimitiveEntryBase("test.run", new DynamicParameterTable([], _ => calls++))])]);
+        var raw = JsonSerializer.SerializeToElement(new
+        {
+            version = 2,
+            kind = "Raw",
+            entries = new[] { new { id = "one", type = "test.run", parameters = new { } } }
+        });
+        var diagnostics = new List<ToolDiagnostic>();
+        Assert.That(ProjectValidationService.ValidateGroupDocument(raw, "group.rawgalgroup", diagnostics, catalog), Is.Not.Null);
+        Assert.That(diagnostics, Is.Empty);
+        Assert.That(calls, Is.EqualTo(1));
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/ImageVariantsAuthoringTests.cs b/test/GalNet.Editor.Shared.Tests/ImageVariantsAuthoringTests.cs
index b4956dbe..581e4d5f 100644
--- a/test/GalNet.Editor.Shared.Tests/ImageVariantsAuthoringTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ImageVariantsAuthoringTests.cs
@@ -1,5 +1,6 @@
 using System.Text.Json;
 using GalNet.Assets.Variants;
+using GalNet.Contracts.Builtins.Assets;
 using GalNet.Core.Assets;
 using GalNet.Editor.Shared.Services;
 
diff --git a/test/GalNet.Editor.Shared.Tests/ImageVariantsResourceTests.cs b/test/GalNet.Editor.Shared.Tests/ImageVariantsResourceTests.cs
index e733c57d..a88ec778 100644
--- a/test/GalNet.Editor.Shared.Tests/ImageVariantsResourceTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ImageVariantsResourceTests.cs
@@ -4,9 +4,10 @@
 using GalNet.Assets.Provider;
 using GalNet.Assets.Variants;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Shared.Commands;
 using GalNet.Editor.Shared.Services;
@@ -36,11 +37,11 @@ private void PutAsset(string path, string type, string content)
         File.WriteAllText(full + ".meta", JsonSerializer.Serialize(new { id = Guid.NewGuid().ToString(), type }));
     }
 
-    private string Id(string path) => new AssetMetaCodec(BuiltinResourceTypes.CreateCatalog()).Deserialize(File.ReadAllText(Path.Combine(_root, "Assets", path + ".meta")), path).Id;
+    private string Id(string path) => JsonDocument.Parse(File.ReadAllText(Path.Combine(_root, "Assets", path + ".meta"))).RootElement.GetProperty("id").GetString()!;
 
     private async Task<byte[]> Compiled(string descriptor, IResourceTypeCatalog? resourceTypes = null)
     {
-        using var provider = new LocalFileProvider(Path.Combine(_root, "Assets"), resourceTypes);
+        using var provider = new LocalFileProvider(Path.Combine(_root, "Assets"), resourceTypes ?? BuiltinResourceTypes.CreateCatalog());
         using var archive = await provider.OpenArchiveAsync("assets");
         return archive.GetAssetByPath(descriptor)!.ReadAllBytes();
     }
@@ -154,17 +155,23 @@ public async Task Export_uses_compiled_definition_and_keeps_custom_catalog_throu
     {
         var types = new ResourceTypeCatalogBuilder()
             .Add<SpriteAssetMeta>("sprite", ".png")
-            .Add<AudioAssetMeta>("audio", ".ogg")
-            .Add<VideoAssetMeta>("video", ".mp4")
-            .Add<ImageVariantsAssetMeta>("image-variants", ".variants")
-            .Add<CustomMeta>("custom-test", ".customtest").Build();
+            .Add<AssetMeta>("audio", ".ogg")
+            .Add<AssetMeta>("video", ".mp4")
+            .Add<DependentAssetMeta>("image-variants", ".variants")
+            .Add<DependentAssetMeta>("graph", ".galgraph")
+            .Add<DependentAssetMeta>("group", ".galgroup")
+            .Add<CustomMeta>("custom-test", ".customtest").WithoutDependencies("sprite", "audio", "video", "custom-test").Build();
         PutAsset("extra.customtest", "custom-test", "custom");
+        var configuration = DirectProjectPersistence.LoadSettings(_root);
+        configuration.Set(GalNet.Core.Configuration.ContentPackagingOptions.Section,
+            new GalNet.Core.Configuration.ContentPackagingOptions { IncludeResources = [Id("alice.variants"), Id("extra.customtest")] });
+        File.WriteAllText(Path.Combine(_root, "settings.json"), JsonSerializer.Serialize(configuration));
         var before = await Compiled("alice.variants", types);
         var result = await GamePackageExporter.ExportAsync("variants", "Variants", _root, Path.Combine(_root, "Output"), types, BuiltinGalleryTypes.CreateCatalog(types), _catalog);
         Assert.That(result.Success, Is.True, result.Error);
         using var zip = ZipFile.OpenRead(result.PackagePath!);
         using var memory = new MemoryStream();
-        using (var stream = zip.GetEntry("Assets/Paks/000-base.pak")!.Open()) await stream.CopyToAsync(memory);
+        using (var stream = zip.GetEntry("pak/Assets/Paks/000-base.pak")!.Open()) await stream.CopyToAsync(memory);
         using var archive = Archive.Deserialize("assets", memory.ToArray(), types);
         Assert.That(archive.GetAssetByPath("alice.variants")!.ReadAllBytes(), Is.EqualTo(before));
         Assert.That(archive.GetAssetByPath("extra.customtest")!.Metadata, Is.TypeOf<CustomMeta>());
diff --git a/test/GalNet.Editor.Shared.Tests/LocalizationReferenceIndexTests.cs b/test/GalNet.Editor.Shared.Tests/LocalizationReferenceIndexTests.cs
index d13f66c5..62e4618f 100644
--- a/test/GalNet.Editor.Shared.Tests/LocalizationReferenceIndexTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/LocalizationReferenceIndexTests.cs
@@ -1,13 +1,14 @@
 using System.Text;
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
 using GalNet.Core.Primitives;
-using GalNet.Core.Settings;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Project;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Abstraction.Settings;
 using GalNet.Editor.Shared.Commands;
 using GalNet.Editor.Shared.Services;
 using Microsoft.Extensions.DependencyInjection;
@@ -16,6 +17,43 @@ namespace GeneralTest.Editor;
 
 public sealed class LocalizationReferenceIndexTests
 {
+    [Test]
+    public void MultipleReferencesInsideAnEncodedArrayHaveDistinctLocationsAndRewriteTheirOwnLeaves()
+    {
+        var descriptor = new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.ForType(typeof(List<NestedRole>), allowsJsonString: true));
+        var fields = new DynamicParameterTable([new(new FieldDescriptor("items", descriptor))]);
+        var catalog = new TargetProfileEntryCatalog([new DefaultEntryModule("custom", [new DefaultPrimitiveEntryBase("custom.roles", fields)])]);
+        var entry = Entry("id", "custom.roles", new { items = """[{"Speaker":"one","extra":9007199254740993},{"Speaker":"two"}]""" });
+        var index = new LocalizationReferenceIndex(new() { GroupEntries = new() { ["g"] = [entry] } }, catalog, []);
+        Assert.That(index.References, Has.Count.EqualTo(2));
+        Assert.That(index.References.Select(reference => reference.JsonPointer).Distinct(), Is.EqualTo(new[] { "/items" }));
+        Assert.That(index.References.Select(reference => reference.LocationKey).Distinct().Count(), Is.EqualTo(2));
+        var result = JsonSerializer.SerializeToElement(entry.Parameters);
+        foreach (var reference in index.References) result = reference.Rewrite(result, "new-" + reference.Key);
+        using var array = JsonDocument.Parse(result.GetProperty("items").GetString()!);
+        Assert.That(array.RootElement[0].GetProperty("Speaker").GetString(), Is.EqualTo("new-one"));
+        Assert.That(array.RootElement[1].GetProperty("Speaker").GetString(), Is.EqualTo("new-two"));
+        Assert.That(array.RootElement[0].GetProperty("extra").GetInt64(), Is.EqualTo(9007199254740993));
+    }
+
+    [Test]
+    public void KnownTransformAndFlipbookSchemasCoverAuthoredValuesAndRetainUnknownExtensions()
+    {
+        var entry = Entry("layer", "layer.show", new { transform = new { X = 12f, ScaleY = 1.2f }, flipbook = new { columns = 2, rows = 2, frameCount = 4 } });
+        var document = new EditorProjectDocument { GroupEntries = new() { ["g"] = [entry] } };
+        var original = JsonSerializer.Serialize(document);
+        var index = new LocalizationReferenceIndex(document, Builtins(), []);
+        Assert.That(index.Complete, Is.True); Assert.That(index.Issues, Is.Empty);
+        Assert.That(JsonSerializer.Serialize(document), Is.EqualTo(original));
+        entry.Parameters["transform"] = JsonSerializer.SerializeToElement("""{"X":2,"extension":{"caption":"unknown"}}""");
+        var unknown = new LocalizationReferenceIndex(document, Builtins(), []).Issues.Single();
+        Assert.That(unknown.Code, Is.EqualTo("field.unknown")); Assert.That(unknown.EntryId, Is.EqualTo("layer"));
+        Assert.That(unknown.JsonPointer, Is.EqualTo("/transform"), "An outer JSON Pointer cannot address inside a string.");
+        Assert.That(unknown.Path!.ToLogicalPointer(), Is.EqualTo("/transform/extension"));
+        entry.Parameters["transform"] = JsonSerializer.SerializeToElement(new { X = "bad" });
+        Assert.That(new LocalizationReferenceIndex(document, Builtins(), []).Issues.Single().Code, Is.EqualTo("value.type"));
+    }
+
     private static TargetProfileEntryCatalog Builtins() => new(BuiltinSchemas.CreateAllModules());
     private static EditorEntryData Entry(string id, string type, object parameters) => new()
     { StableId = id, Type = type, Parameters = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(JsonSerializer.Serialize(parameters))! };
@@ -157,6 +195,38 @@ public void NestedListsUseStoredKeysAndEscapedPointersRatherThanTextOrArrayIdent
         Assert.That(index.References[0].JsonPointer, Is.EqualTo("/items/0/caption~1~0"));
     }
 
+    [TestCase("null")]
+    [TestCase("\"\"")]
+    [TestCase("\"   \"")]
+    [TestCase("{}")]
+    [TestCase("[]")]
+    public void EmptyValuesDoNotBlockCharacterReferenceAnalysis(string json)
+    {
+        var empty = JsonSerializer.Deserialize<JsonElement>(json);
+        var layer = Entry("layer", "layer.show", new { });
+        layer.Parameters["transform"] = empty;
+        layer.Parameters["extension"] = empty;
+        var dialogue = Entry("line", "dialogue.text", new { speaker = " \t", content = " \n" });
+        var unknown = Entry("unknown", "custom.unknown", new { });
+        unknown.Parameters["extension"] = empty;
+        var document = new EditorProjectDocument { GroupEntries = new() { ["opening"] = [layer, dialogue, unknown] } };
+        var index = new LocalizationReferenceIndex(document, Builtins(), []);
+        Assert.Multiple(() =>
+        {
+            Assert.That(index.Complete, Is.True);
+            Assert.That(index.Issues, Is.Empty);
+            Assert.That(index.References, Is.Empty);
+            Assert.That(layer.Parameters["transform"].GetRawText(), Is.EqualTo(empty.GetRawText()));
+        });
+
+        layer.Parameters["transform"] = JsonSerializer.SerializeToElement(new { x = 1 });
+        var nonempty = new LocalizationReferenceIndex(document, Builtins(), []);
+        Assert.That(nonempty.Complete, Is.True, "A known nonempty Transform is traversable.");
+        layer.Parameters["transform"] = JsonSerializer.SerializeToElement(new { extension = new { hidden = "key" } });
+        var extension = new LocalizationReferenceIndex(document, Builtins(), []);
+        Assert.That(extension.IncompleteIssues.Single().Code, Is.EqualTo("field.unknown"));
+    }
+
     [Test]
     public void RecursiveDtosStopAtDepthBudgetAndRetainDiagnostics()
     {
@@ -236,7 +306,7 @@ public async Task ProjectQuerySeesUnsavedManagedFilesAndDisposalInvalidatesCache
             var repository = new EditorDocumentRepository(catalog);
             var settings = DirectProjectPersistence.LoadSettings(root);
             var documents = new EditorDocumentService();
-            documents.Load(repository.Load(root, "Localization", settings));
+            documents.Load(repository.Load(root));
             await using var project = new GalProject("id", "Localization", root, settings, new(), new EmptyScope());
             using var session = new ProjectContentSession(documents, repository);
             session.Open(project);
@@ -258,7 +328,7 @@ public async Task ProjectQuerySeesUnsavedManagedFilesAndDisposalInvalidatesCache
             documents.Unload();
             Assert.That(query.Get(), Is.Null);
             Assert.That(query.Revision, Is.GreaterThan(beforeUnload));
-            documents.Load(repository.Load(root, "Localization", settings));
+            documents.Load(repository.Load(root));
             Assert.That(query.Get(), Is.Not.Null);
             var revision = query.Revision;
             query.Dispose();
@@ -273,7 +343,7 @@ private sealed class ProjectStub(GalProject project) : IProjectService
         public GalProject? Current => project;
         public event Action<GalProject?>? CurrentChanged { add { } remove { } }
         public Task<GalProject> OpenAsync(string projectPath) => throw new NotSupportedException();
-        public Task<GalProject> CreateAsync(string projectPath, string name, ProjectSettings settings, string contractsDirectory) => throw new NotSupportedException();
+        public Task<GalProject> CreateAsync(string projectPath, string name, ProjectConfiguration settings, string contractsDirectory) => throw new NotSupportedException();
         public Task CloseAsync() => throw new NotSupportedException();
         public Task SaveAsync() => throw new NotSupportedException();
         public IReadOnlyList<RecentProjectInfo> GetRecentProjects() => [];
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectApplyTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectApplyTests.cs
new file mode 100644
index 00000000..96957125
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/ProjectApplyTests.cs
@@ -0,0 +1,191 @@
+using System.Security.Cryptography;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Shared.Commands;
+
+namespace GeneralTest.Editor;
+
+public sealed class ProjectApplyTests
+{
+    private string _directory = null!;
+    private string _project = null!;
+    private string _staging = null!;
+    private IEntryCatalog _catalog = null!;
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        _directory = Path.Combine(Path.GetTempPath(), "GalNet-apply-test-" + Guid.NewGuid().ToString("N"));
+        _project = Path.Combine(_directory, "project"); _staging = Path.Combine(_directory, "staging"); Directory.CreateDirectory(_staging);
+        await EditorProjectCreator.CreateAsync(new(_project, "Apply"));
+        _catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+    }
+    [TearDown] public void TearDown() => Directory.Delete(_directory, true);
+
+    private static string Hash(string path) => Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path)));
+    private ProjectApplyWrite Write(string path, string content)
+    {
+        var source = Guid.NewGuid().ToString("N"); File.WriteAllText(Path.Combine(_staging, source), content);
+        return new() { Path = path, Source = source, ContentHash = Hash(Path.Combine(_staging, source)), ExpectedHash = File.Exists(Path.Combine(_project, path)) ? Hash(Path.Combine(_project, path)) : null };
+    }
+    private string Manifest(IReadOnlyList<ProjectApplyWrite> writes, IReadOnlyList<ProjectApplyDelete>? deletes = null)
+    {
+        var file = Path.Combine(_staging, "apply.json");
+        File.WriteAllText(file, JsonSerializer.Serialize(new ProjectApplyManifest { Version = 1, Writes = writes, Deletes = deletes ?? [] }, JsonOptions));
+        return file;
+    }
+    private string GraphWithNewGroup()
+    {
+        var graph = JsonNode.Parse(File.ReadAllText(Path.Combine(_project, "Graph/graph.json")))!.AsObject();
+        var opening = graph["nodes"]!.AsArray().Single(node => node!["type"]!.GetValue<string>() == "Group")!["id"]!.GetValue<string>();
+        graph["nodes"]!.AsArray().Add(new JsonObject { ["id"] = "generated", ["type"] = "Group", ["name"] = "Generated scene", ["x"] = 500, ["y"] = 0, ["file"] = "groups/generated.rawgalgroup" });
+        graph["edges"]!.AsArray().Add(new JsonObject { ["id"] = "to-generated", ["fromNodeId"] = opening, ["fromOutlet"] = 0, ["toNodeId"] = "generated" });
+        return graph.ToJsonString();
+    }
+    private ProjectApplyWrite[] Batch() =>
+    [
+        Write("Graph/graph.json", GraphWithNewGroup()),
+        Write("Graph/groups/generated.rawgalgroup", "{\"version\":2,\"kind\":\"Raw\",\"entries\":[]}"),
+        Write("Assets/actors/alice.png", "generated image bytes"),
+        Write("Assets/actors/alice.png.meta", JsonSerializer.Serialize(new { id = Guid.NewGuid().ToString(), type = "sprite" }))
+    ];
+
+    [Test]
+    public async Task DryRunAndApplyValidateAndPublishGroupsAndResourcesTogether()
+    {
+        var original = File.ReadAllBytes(Path.Combine(_project, "Graph/graph.json"));
+        var manifest = Manifest(Batch()); var service = new ProjectApplyService(_project, _catalog);
+        var preview = await service.ApplyAsync(manifest, true);
+        Assert.That(preview.Success, Is.True, JsonSerializer.Serialize(preview.Diagnostics));
+        Assert.That(File.ReadAllBytes(Path.Combine(_project, "Graph/graph.json")), Is.EqualTo(original));
+        Assert.That(File.Exists(Path.Combine(_project, "Assets/actors/alice.png")), Is.False);
+        var result = await service.ApplyAsync(manifest);
+        Assert.That(result.Success, Is.True, JsonSerializer.Serialize(result.Diagnostics));
+        Assert.That(File.Exists(Path.Combine(_project, "Graph/groups/generated.rawgalgroup")), Is.True);
+        Assert.That(File.ReadAllText(Path.Combine(_project, "Assets/actors/alice.png")), Is.EqualTo("generated image bytes"));
+        Assert.That(((ProjectApplyReport)result.Data!).WrittenFiles, Has.Count.EqualTo(4));
+        Assert.That(Directory.GetDirectories(Path.Combine(_project, ".galnet/editor/transactions")), Is.Empty);
+    }
+
+    [Test]
+    public async Task StaleTargetAndChangedSourceRefuseTheWholeBatch()
+    {
+        var writes = Batch(); var manifest = Manifest(writes);
+        File.AppendAllText(Path.Combine(_project, "Graph/graph.json"), " ");
+        var result = await new ProjectApplyService(_project, _catalog).ApplyAsync(manifest);
+        Assert.That(result.Success, Is.False); Assert.That(File.Exists(Path.Combine(_project, "Assets/actors/alice.png")), Is.False);
+        writes = Batch(); manifest = Manifest(writes);
+        File.AppendAllText(Path.Combine(_staging, writes[1].Source), "changed");
+        result = await new ProjectApplyService(_project, _catalog).ApplyAsync(manifest);
+        Assert.That(result.Success, Is.False); Assert.That(File.Exists(Path.Combine(_project, "Graph/groups/generated.rawgalgroup")), Is.False);
+    }
+
+    [Test]
+    public async Task InvalidFinalProjectAndUnpairedResourceDoNotPublish()
+    {
+        var writes = Batch().ToList(); writes[1] = Write(writes[1].Path, "{");
+        var result = await new ProjectApplyService(_project, _catalog).ApplyAsync(Manifest(writes));
+        Assert.That(result.Success, Is.False); Assert.That(File.Exists(Path.Combine(_project, "Assets/actors/alice.png")), Is.False);
+        result = await new ProjectApplyService(_project, _catalog).ApplyAsync(Manifest([Write("Assets/alone.png", "bytes")]));
+        Assert.That(result.Success, Is.False); Assert.That(File.Exists(Path.Combine(_project, "Assets/alone.png")), Is.False);
+    }
+
+    [Test]
+    public async Task PublicationFailureRestoresEveryEarlierFile()
+    {
+        var original = File.ReadAllBytes(Path.Combine(_project, "Graph/graph.json"));
+        var result = await new ProjectApplyService(_project, _catalog, new FailSecondPublish()).ApplyAsync(Manifest(Batch()));
+        Assert.That(result.Success, Is.False);
+        Assert.That(File.ReadAllBytes(Path.Combine(_project, "Graph/graph.json")), Is.EqualTo(original));
+        Assert.That(File.Exists(Path.Combine(_project, "Graph/groups/generated.rawgalgroup")), Is.False);
+        Assert.That(File.Exists(Path.Combine(_project, "Assets/actors/alice.png")), Is.False);
+    }
+
+    [Test]
+    public async Task ResourceDeletionRequiresRemainingJsonReferencesToBeUpdatedInTheSameBatch()
+    {
+        var service = new ProjectApplyService(_project, _catalog);
+        Assert.That((await service.ApplyAsync(Manifest(Batch()))).Success, Is.True);
+        var meta = "Assets/actors/alice.png.meta"; var image = "Assets/actors/alice.png";
+        using var metadata = JsonDocument.Parse(File.ReadAllBytes(Path.Combine(_project, meta)));
+        Directory.CreateDirectory(Path.Combine(_project, "UI"));
+        File.WriteAllText(Path.Combine(_project, "UI/ui.json"), JsonSerializer.Serialize(new { image = metadata.RootElement.GetProperty("id").GetString() }));
+        ProjectApplyDelete[] deleted = [new() { Path = image, ExpectedHash = Hash(Path.Combine(_project, image)) }, new() { Path = meta, ExpectedHash = Hash(Path.Combine(_project, meta)) }];
+        var rejected = await service.ApplyAsync(Manifest([], deleted)); Assert.That(rejected.Success, Is.False);
+        Assert.That(rejected.Diagnostics.Any(diagnostic => diagnostic.Code == "project.applyReference"), Is.True);
+        Assert.That((await service.ApplyAsync(Manifest([Write("UI/ui.json", "{}")], deleted))).Success, Is.True);
+        Assert.That(File.Exists(Path.Combine(_project, image)), Is.False);
+    }
+
+    [TestCase("../escape.json")]
+    [TestCase("Contracts/unsafe.dll")]
+    [TestCase(".git/config")]
+    [TestCase(".galnet/editor-state.json")]
+    public async Task ProtectedAndEscapingTargetsAreRejected(string path)
+    {
+        var source = Write("notes.txt", "data");
+        var write = new ProjectApplyWrite { Path = path, Source = source.Source, ContentHash = source.ContentHash, ExpectedHash = null };
+        var result = await new ProjectApplyService(_project, _catalog).ApplyAsync(Manifest([write]));
+        Assert.That(result.Success, Is.False);
+    }
+
+    [Test]
+    public async Task CliDiscoversTheManifestContractAndRejectsMalformedInputWithJsonDiagnostics()
+    {
+        var help = await Shared.CliHelpTests.Invoke(["help", "project", "apply", "--json"]);
+        Assert.That(help.ExitCode, Is.Zero, help.Error);
+        using var document = JsonDocument.Parse(help.Output);
+        Assert.That(document.RootElement.GetProperty("data").GetProperty("operations")[0].GetProperty("documentInputSchema").GetProperty("properties").TryGetProperty("writes", out _), Is.True);
+        var manifest = Path.Combine(_staging, "bad.json"); File.WriteAllText(manifest, "{}");
+        // The service catches malformed manifests before any mutation; a real CLI project supplies Contracts/.
+        Assert.That((await new ProjectApplyService(_project, _catalog).ApplyAsync(manifest)).Success, Is.False);
+    }
+
+    [Test]
+    public async Task RealCliAppliesTheSameReviewedManifestAndShipsItsAuthoringSkill()
+    {
+        var root = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+        while (!File.Exists(Path.Combine(root.FullName, "GalNet.slnx"))) root = root.Parent!;
+#if DEBUG
+        const string configuration = "Debug";
+#else
+        const string configuration = "Release";
+#endif
+        var contracts = Path.Combine(root.FullName, "src/Editor/GalNet.Editor.DefaultContracts/bin", configuration, "net10.0");
+        var cliProject = Path.Combine(_directory, "cli-project");
+        await EditorProjectCreator.CreateAsync(new(cliProject, "CLI", contracts)); _project = cliProject;
+        var writes = Batch().ToList();
+        writes[1] = Write("Graph/groups/generated.rawgalgroup", """
+            {"version":2,"kind":"Raw","entries":[
+              {"id":"enter-wait","type":"flow.wait","parameters":{"duration":0.2}},
+              {"id":"line-one","type":"dialogue.text","parameters":{"speaker":"alice","content":"scene.intro.line1"}}
+            ]}
+            """);
+        writes.Add(Write("I18n/catalog/characters.json", """[{"id":"alice","displayNameKey":"character.alice.name"}]"""));
+        writes.Add(Write("I18n/zh-CN/generated.json", """{"character.alice.name":"爱丽丝","scene.intro.line1":"我们开始吧。"}"""));
+        var manifest = Manifest(writes);
+        foreach (var arguments in new[] { new[] { "project", "apply", _project, manifest, "--dry-run" }, new[] { "project", "apply", _project, manifest } })
+        {
+            var invoked = await Shared.CliHelpTests.Invoke(arguments);
+            Assert.That(invoked.ExitCode, Is.Zero, invoked.Output + invoked.Error);
+            using var json = JsonDocument.Parse(invoked.Output);
+            Assert.That(json.RootElement.GetProperty("operationId").GetString(), Is.EqualTo("project.apply"));
+            Assert.That(json.RootElement.GetProperty("success").GetBoolean(), Is.True);
+        }
+        Assert.That(File.Exists(Path.Combine(_project, "Assets/actors/alice.png")), Is.True);
+        var compiled = await Shared.CliHelpTests.Invoke(["group", "compile", _project, "--id", "generated", "--dry-run"]);
+        Assert.That(compiled.ExitCode, Is.Zero, compiled.Output + compiled.Error);
+        Assert.That(File.Exists(Path.Combine(root.FullName, "src/Editor/GalNet.Editor.Headless/bin", configuration, "net10.0/Skills/galnet-project-authoring/SKILL.md")), Is.True);
+    }
+
+    private sealed class FailSecondPublish : AuthorFileTransaction
+    {
+        private int _count;
+        protected override void Publish(string path, string? stagedFile)
+        { if (++_count == 2) throw new IOException("Injected second-file publication failure."); base.Publish(path, stagedFile); }
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectAuthoringSafetyTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectAuthoringSafetyTests.cs
index d03c9ab6..e3faee0b 100644
--- a/test/GalNet.Editor.Shared.Tests/ProjectAuthoringSafetyTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ProjectAuthoringSafetyTests.cs
@@ -21,7 +21,7 @@ public void SetUp()
         _catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
         Put("Graph/graph.json", """{"version":2,"name":"Original","rootNodeId":"entry","nodes":[{"id":"entry","name":"Entry","type":"Entry"},{"id":"a","name":"A","type":"Group","file":"groups/a.rawgalgroup"}],"edges":[{"id":"edge","fromNodeId":"entry","fromOutlet":0,"toNodeId":"a"}],"playerVariables":[],"saveVariables":[]}""");
         Put("Graph/groups/a.rawgalgroup", """{"version":2,"kind":"Raw","entries":[{"id":"text","type":"dialogue.text","parameters":{"content":""}}]}""");
-        Put("settings.json", "{}");
+        Put("settings.json", """{"version":1,"sections":{}}""");
     }
     [TearDown]
     public void TearDown() => Directory.Delete(_root, true);
@@ -41,12 +41,16 @@ public void Load_RejectsOldInvalidOrUnknownDataWithoutChangingFiles(string file,
     }
 
     [Test]
-    public void UnknownSettings_AreRejectedWithoutLoss()
+    public async Task UnknownConfigurationSections_ArePreservedOnSave()
     {
-        Put("settings.json", """{"custom":{"keep":true}}""");
-        var original = Snapshot();
-        Assert.That(() => Persistence().Load(), Throws.TypeOf<JsonException>().With.Message.Contains("custom"));
-        AssertSnapshot(original);
+        Put("settings.json", """{"version":1,"sections":{"custom":{"version":7,"data":{"keep":true}}}}""");
+        var persistence = Persistence();
+        var document = persistence.Load();
+        document.Graph.Name = "Renamed";
+        await persistence.SaveAsync(document);
+        var stored = DirectProjectPersistence.LoadSettings(_root).Sections["custom"];
+        Assert.That(stored.Version, Is.EqualTo(7));
+        Assert.That(stored.Data.GetProperty("keep").GetBoolean(), Is.True);
     }
 
     [Test]
@@ -147,7 +151,7 @@ public void Cancellation_DoesNotPublishAnyFile()
     public void RepositoryTracksOnlyItsOwnFiles_WhenEditorSavesSettingsSeparately()
     {
         var repository = new EditorDocumentRepository(_catalog);
-        var loaded = repository.Load(_root, "Original", new());
+        var loaded = repository.Load(_root);
         var entries = loaded.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value);
         loaded.Document.Name = "First";
         repository.Save(_root, loaded.Document, entries);
@@ -179,58 +183,6 @@ public void TransactionRejectsNonCanonicalPaths_BeforeAnyWrite(string file)
         AssertSnapshot(original);
     }
 
-    [Test]
-    public void Preview_PreservesAuthorIdentityAndDoesNotDiscardUnknownParameters()
-    {
-        var repository = new EditorDocumentRepository(_catalog);
-        var loaded = repository.Load(_root, "Original", new());
-        var entries = loaded.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value);
-        var coordinator = new EditorSaveCoordinator(repository, _catalog);
-        var preview = Path.Combine(_root, "Temp/Preview");
-        coordinator.BuildPreviewData(preview, loaded.Document, entries);
-        using var graph = JsonDocument.Parse(File.ReadAllBytes(Path.Combine(preview, "graph.json")));
-        Assert.That(graph.RootElement.GetProperty("edges")[0].GetProperty("id").GetString(), Is.EqualTo("edge"));
-        var source = graph.RootElement.GetProperty("nodes")[1].GetProperty("file").GetString()!;
-        Assert.That(File.Exists(Path.Combine(preview, source)), Is.True);
-        loaded.GroupEntries["a"][0].Parameters["unknown"] = JsonSerializer.SerializeToElement("value");
-        Assert.That(() => coordinator.BuildPreviewData(preview, loaded.Document, entries), Throws.TypeOf<InvalidDataException>());
-    }
-
-    [Test]
-    public void Preview_GroupIdsCannotBecomeOutputPaths()
-    {
-        var repository = new EditorDocumentRepository(_catalog);
-        var loaded = repository.Load(_root, "Original", new());
-        loaded.Document.Nodes[1].Id = "../../escape";
-        loaded.Document.Edges[0].ToNodeId = "../../escape";
-        var entries = new Dictionary<string, IReadOnlyList<EditorEntryData>> { ["../../escape"] = loaded.GroupEntries["a"] };
-        var preview = Path.Combine(_root, "Temp/Preview");
-        new EditorSaveCoordinator(repository, _catalog).BuildPreviewData(preview, loaded.Document, entries);
-        using var graph = JsonDocument.Parse(File.ReadAllBytes(Path.Combine(preview, "graph.json")));
-        var file = graph.RootElement.GetProperty("nodes")[1].GetProperty("file").GetString()!;
-        Assert.That(file, Is.EqualTo(Path.GetFileName(file)));
-        Assert.That(File.Exists(Path.Combine(preview, file)), Is.True);
-        Assert.That(File.Exists(Path.Combine(_root, "escape.galgroup")), Is.False);
-        Assert.That(graph.RootElement.GetProperty("nodes")[1].GetProperty("id").GetString(), Is.EqualTo("../../escape"));
-    }
-
-    [Test]
-    public void Preview_RejectsLinkedOutputBeforeWriting()
-    {
-        var repository = new EditorDocumentRepository(_catalog);
-        var loaded = repository.Load(_root, "Original", new());
-        var target = Directory.CreateDirectory(Path.Combine(_root, "target")).FullName;
-        var link = Path.Combine(_root, "preview-link");
-        Directory.CreateSymbolicLink(link, target);
-        try
-        {
-            var entries = loaded.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<EditorEntryData>)pair.Value);
-            Assert.Throws<InvalidDataException>(() => new EditorSaveCoordinator(repository, _catalog).BuildPreviewData(link, loaded.Document, entries));
-            Assert.That(Directory.GetFiles(target), Is.Empty);
-        }
-        finally { Directory.Delete(link); }
-    }
-
     [Test]
     public async Task RealCli_DryRunUsesTheSameStrictSaveValidation()
     {
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectConfigurationPersistenceTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectConfigurationPersistenceTests.cs
new file mode 100644
index 00000000..5a9f42e4
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/ProjectConfigurationPersistenceTests.cs
@@ -0,0 +1,65 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Shared.Commands;
+using GalNet.Editor.Shared.Services;
+
+namespace GeneralTest.Editor;
+
+public sealed class ProjectConfigurationPersistenceTests
+{
+    private string _root = null!;
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        _root = Path.Combine(Path.GetTempPath(), "GalNet-config-" + Guid.NewGuid().ToString("N"));
+        await EditorProjectCreator.CreateAsync(new(_root, "Configuration"));
+    }
+
+    [TearDown]
+    public void TearDown() => Directory.Delete(_root, true);
+
+    [Test]
+    public async Task DefaultEditorPatchKeepsUnownedConfigurationAndRejectsPartialUpdates()
+    {
+        var persistence = Persistence();
+        var document = persistence.Load();
+        document.Configuration.SetRaw("developer.options", new(4, JsonSerializer.SerializeToElement(new { enabled = true })));
+        document.Configuration.SetRaw(DefaultProjectConfiguration.Section.Id, new(DefaultProjectConfiguration.Section.Version,
+            JsonSerializer.SerializeToElement(new { defaultWidth = 1280, future = new { enabled = true } })));
+        var handler = new BuiltInEditorCommandHandler(new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules()), DefaultProjectConfiguration.Schema);
+        var result = handler.Execute(document, new PatchConfigurationCommand(DefaultProjectConfiguration.Section.Id, new Dictionary<string, JsonElement>
+        { ["defaultWidth"] = JsonSerializer.SerializeToElement(1440), ["unknown"] = JsonSerializer.SerializeToElement(1) }), new(0, false));
+        Assert.That(result.Success, Is.False);
+        Assert.That(document.Configuration.ReadDefaultOptions().DefaultWidth, Is.EqualTo(1280));
+        result = handler.Execute(document, new PatchConfigurationCommand(DefaultProjectConfiguration.Section.Id, new Dictionary<string, JsonElement>
+        { ["defaultWidth"] = JsonSerializer.SerializeToElement(1440) }), new(0, false));
+        Assert.That(result.Success, Is.True);
+        await persistence.SaveAsync(document);
+        var restored = Persistence().Load().Configuration;
+        Assert.That(restored.ReadDefaultOptions().DefaultWidth, Is.EqualTo(1440));
+        Assert.That(restored.Sections["developer.options"].Version, Is.EqualTo(4));
+        Assert.That(restored.Sections["developer.options"].Data.GetProperty("enabled").GetBoolean(), Is.True);
+        Assert.That(restored.Sections[DefaultProjectConfiguration.Section.Id].Data.GetProperty("future").GetProperty("enabled").GetBoolean(), Is.True);
+    }
+
+    [Test]
+    public void InvalidKnownSectionCannotBePublishedOrLoadedWhenSchemaIsSelected()
+    {
+        var persistence = Persistence();
+        var document = persistence.Load();
+        var path = Path.Combine(_root, "settings.json");
+        var original = File.ReadAllBytes(path);
+        document.Configuration.SetRaw(DefaultProjectConfiguration.Section.Id, new(DefaultProjectConfiguration.Section.Version, JsonSerializer.SerializeToElement(new { defaultWidth = 0 })));
+        Assert.That(() => persistence.PrepareSave(document), Throws.TypeOf<InvalidDataException>());
+        Assert.That(File.ReadAllBytes(path), Is.EqualTo(original));
+        File.WriteAllText(path, JsonSerializer.Serialize(document.Configuration));
+        Assert.That(() => Persistence().Load(), Throws.TypeOf<InvalidDataException>());
+    }
+
+    private DirectProjectPersistence Persistence() => new(_root,
+        new EditorDocumentRepository(new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules())), DefaultProjectConfiguration.Schema);
+}
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectContentSessionTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectContentSessionTests.cs
index d89699ce..bcac93c3 100644
--- a/test/GalNet.Editor.Shared.Tests/ProjectContentSessionTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ProjectContentSessionTests.cs
@@ -29,7 +29,7 @@ public async Task SetUp()
         var settings = DirectProjectPersistence.LoadSettings(_root);
         _repository = new(new EditorDocumentRepository(new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules())));
         _documents = new();
-        _documents.Load(_repository.Load(_root, "Original", settings));
+        _documents.Load(_repository.Load(_root));
         _project = new("project", "Original", _root, settings, new(), new EmptyScope());
         _session = new(_documents, _repository);
         _session.Open(_project);
@@ -43,6 +43,52 @@ public async Task TearDown()
         Directory.Delete(_root, true);
     }
 
+    [Test]
+    public async Task DirtyComparisonDetectsDirectLateMutationsAndIgnoresDisplayNumbers()
+    {
+        var entries = _documents.LoadedProject.GroupEntries.Values.First();
+        entries.Clear();
+        entries.Add(new()
+        {
+            StableId = "line",
+            Id = 1,
+            Type = BuiltinEntryIds.Wait,
+            Parameters = new() { ["duration"] = JsonSerializer.SerializeToElement(1f) }
+        });
+        await _session.SaveAsync();
+        entries[0].Id = 99;
+        Assert.That(_session.IsDirty, Is.False);
+        entries[0].Parameters["future"] = JsonSerializer.SerializeToElement(new { precise = 9007199254740993L });
+        Assert.That(_session.IsDirty, Is.True, "A read cannot cache away a mutation outside history notifications.");
+        entries[0].Parameters.Remove("future");
+        Assert.That(_session.IsDirty, Is.False);
+        entries[0].StableId = "replacement";
+        Assert.That(_session.IsDirty, Is.True);
+        entries[0].StableId = "line";
+        Assert.That(_session.IsDirty, Is.False);
+    }
+
+    [Test]
+    public async Task RepeatedDirtyReadsDoNotAllocateSerializedCopiesOfEveryEntry()
+    {
+        var entries = _documents.LoadedProject.GroupEntries.Values.First();
+        entries.Clear();
+        for (var index = 0; index < 500; index++) entries.Add(new()
+        {
+            StableId = "line-" + index,
+            Type = BuiltinEntryIds.Wait,
+            Parameters = new() { ["duration"] = JsonSerializer.SerializeToElement(1f) }
+        });
+        await _session.SaveAsync();
+        _ = _session.IsDirty;
+        var before = GC.GetAllocatedBytesForCurrentThread();
+        var dirty = false;
+        for (var index = 0; index < 20; index++) dirty |= _session.IsDirty;
+        var allocated = GC.GetAllocatedBytesForCurrentThread() - before;
+        Assert.That(dirty, Is.False);
+        Assert.That(allocated, Is.LessThan(2_000_000), "Status reads must not serialize and clone the complete project.");
+    }
+
     [Test]
     public async Task StructurePreparationSeesTheBaselineOfAnEarlierSaveThatWasStillPublishing()
     {
@@ -69,14 +115,16 @@ public async Task StructurePreparationSeesTheBaselineOfAnEarlierSaveThatWasStill
     public async Task SaveAllIncludesGraphGroupsAndCompleteSettingsAndComparesActualContent()
     {
         _documents.CurrentDocument.Name = "Renamed";
-        _project.Settings.DefaultWidth = 1440;
-        _project.Settings.SaveSlotCount = 17;
+        var options = _project.Configuration.ReadDefaultOptions();
+        options.DefaultWidth = 1440;
+        options.SaveSlotCount = 17;
+        _project.Configuration.Set(DefaultProjectConfiguration.Section, options);
         Assert.That(_session.IsDirty, Is.True);
         await _session.SaveAsync();
         Assert.That(_session.IsDirty, Is.False);
         Assert.That(_repository.LastPlan!.Writes.Keys, Does.Contain("Graph/graph.json"));
         Assert.That(_repository.LastPlan.Writes.Keys.Any(path => path.EndsWith(".rawgalgroup", StringComparison.Ordinal)), Is.True);
-        Assert.That(DirectProjectPersistence.LoadSettings(_root).DefaultWidth, Is.EqualTo(1440));
+        Assert.That(DirectProjectPersistence.LoadSettings(_root).ReadDefaultOptions().DefaultWidth, Is.EqualTo(1440));
         _documents.CurrentDocument.Name = "Other";
         Assert.That(_session.IsDirty, Is.True);
         _documents.CurrentDocument.Name = "Renamed";
@@ -129,7 +177,9 @@ public async Task PublicationFailureRestoresAllOrBlocksWritesAndRetainsRecovery(
     {
         var original = File.ReadAllBytes(Path.Combine(_root, "Graph/graph.json"));
         _documents.CurrentDocument.Name = "Unsaved";
-        _project.Settings.DefaultWidth = 1440;
+        var options = _project.Configuration.ReadDefaultOptions();
+        options.DefaultWidth = 1440;
+        _project.Configuration.Set(DefaultProjectConfiguration.Section, options);
         _repository.Transaction = new FaultTransaction(failRecovery, 3);
         try { await _session.SaveAsync(); Assert.Fail("Injected publication must fail."); }
         catch (IOException) { }
@@ -207,11 +257,13 @@ public async Task GroupCreationAndDeletionShareTheAuthorFilePlan()
         var file = Path.Combine(_root, "Graph/groups/created.rawgalgroup");
         Assert.That(File.Exists(file), Is.True);
         Assert.That(_session.IsDirty, Is.False);
-        _project.Settings.DefaultWidth = 1440;
+        var options = _project.Configuration.ReadDefaultOptions();
+        options.DefaultWidth = 1440;
+        _project.Configuration.Set(DefaultProjectConfiguration.Section, options);
         await _session.PublishStructureAsync(new GroupPresence(false));
         Assert.That(File.Exists(file), Is.False);
         Assert.That(_session.IsDirty, Is.True);
-        Assert.That(DirectProjectPersistence.LoadSettings(_root).DefaultWidth, Is.EqualTo(1920));
+        Assert.That(DirectProjectPersistence.LoadSettings(_root).ReadDefaultOptions().DefaultWidth, Is.EqualTo(1920));
     }
 
     [Test]
@@ -387,7 +439,7 @@ private sealed class TestRepository(IEditorDocumentRepository inner) : IEditorDo
         public Action? BeforeApply { get; set; }
         public AuthorFileTransaction? Transaction { get; set; }
         public ProjectSavePlan? LastPlan { get; private set; }
-        public LoadedEditorProjectDocument Load(string path, string name, GalNet.Core.Settings.ProjectSettings settings) => inner.Load(path, name, settings);
+        public LoadedEditorProjectDocument Load(string path) => inner.Load(path);
         public ProjectSavePlan PrepareSave(string path, EditorGraphDocument document, IReadOnlyDictionary<string, IReadOnlyList<EditorEntryData>> entries) => inner.PrepareSave(path, document, entries);
         public void ApplySave(string path, ProjectSavePlan plan, CancellationToken cancellationToken = default)
         {
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectContractPipelineTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectContractPipelineTests.cs
index 0714a777..00a303fc 100644
--- a/test/GalNet.Editor.Shared.Tests/ProjectContractPipelineTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ProjectContractPipelineTests.cs
@@ -1,5 +1,12 @@
 using System.IO.Compression;
 using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+using GalNet.Core.Serialization;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Shared.Commands;
 using GalNet.Editor.Shared.Services;
 using GeneralTest.Editor.Shared;
 
@@ -13,7 +20,7 @@ public async Task ActualCliValidationAndCompilationStillRejectAnAuthoringSavedUn
         Put("Graph/groups/a.rawgalgroup", """{"version":2,"kind":"Raw","entries":[{"id":"opaque","type":"future.custom","parameters":{"payload":[null,{"kept":true}]}}]}""");
         using var schema = ProjectSchemaContext.Load(_root);
         var repository = new EditorDocumentRepository(schema.Catalog, EditorDocumentValidation.Authoring);
-        var loaded = repository.Load(_root, "Draft", new());
+        var loaded = repository.Load(_root);
         repository.Save(_root, loaded.Document, loaded.GroupEntries.ToDictionary(pair => pair.Key, pair => (IReadOnlyList<GalNet.Editor.Abstraction.Documents.EditorEntryData>)pair.Value));
         var original = File.ReadAllBytes(Path.Combine(_root, "Graph/groups/a.rawgalgroup"));
         var validation = await CliHelpTests.Invoke(["validate", _root]);
@@ -29,7 +36,7 @@ public void SetUp()
         _root = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "GalNet-pipeline-" + Guid.NewGuid())).FullName;
         Put("Graph/graph.json", """{"version":2,"name":"Custom","rootNodeId":"a","nodes":[{"id":"a","name":"A","type":"Group","file":"groups/a.rawgalgroup"}],"edges":[],"playerVariables":[],"saveVariables":[]}""");
         Put("Graph/groups/a.rawgalgroup", """{"version":2,"kind":"Raw","entries":[{"id":"bundle","type":"custom.bundle","parameters":{}}]}""");
-        Put("settings.json", "{}");
+        Put("settings.json", """{"version":1,"sections":{}}""");
         Deploy("SchemaA");
     }
     [TearDown]
@@ -51,10 +58,93 @@ public async Task CliValidateBuildAndExport_UseTheSameDeployedCustomContract()
         });
         using var result = JsonDocument.Parse(export.Output);
         using var zip = ZipFile.OpenRead(result.RootElement.GetProperty("data").GetProperty("packagePath").GetString()!);
-        using var entry = zip.GetEntry("Graph/groups/a.galgroup")!.Open();
-        using var compiled = JsonDocument.Parse(entry);
+        Assert.That(zip.Entries.Any(item => item.FullName.StartsWith("pak/Graph/", StringComparison.Ordinal)), Is.False);
+        using var entry = zip.GetEntry("pak/Assets/Paks/000-base.pak")!.Open();
+        using var bytes = new MemoryStream();
+        await entry.CopyToAsync(bytes);
+        using var archive = Archive.Deserialize("assets", bytes.ToArray(), BuiltinResourceTypes.CreateCatalog());
+        using var compiled = JsonDocument.Parse(archive.GetAsset(StoryResourceIds.Group("a"))!.ReadAllBytes());
         Assert.That(compiled.RootElement.GetProperty("entries")[0].GetProperty("typeId").GetString(), Is.EqualTo("custom.example"));
-        Assert.That(zip.Entries.Any(item => item.FullName.StartsWith("Contracts/", StringComparison.Ordinal)), Is.False);
+        Assert.That(zip.Entries.Any(item => item.FullName.StartsWith("pak/Contracts/", StringComparison.Ordinal)), Is.False);
+    }
+
+    [Test]
+    public async Task CustomConfigurationPatch_PreservesUnknownDataThroughExportAndInstall()
+    {
+        Put("settings.json", """{"version":1,"sections":{"developer.options":{"version":1,"data":{"count":2,"caption":"Original","future":[null,42]}},"opaque":{"version":7,"data":{"kept":true}}}}""");
+        Put("patch.json", """{"commandId":"project.configuration.patch","sectionId":"developer.options","values":{"count":4,"limit":5,"caption":null}}""");
+        var edit = await CliHelpTests.Invoke(["execute", _root, Path.Combine(_root, "patch.json")]);
+        Assert.That(edit.ExitCode, Is.Zero, edit.Output);
+        var saved = DirectProjectPersistence.LoadSettings(_root);
+        Assert.That(saved.Sections["developer.options"].Data.GetProperty("caption").ValueKind, Is.EqualTo(JsonValueKind.Null));
+        var export = await CliHelpTests.Invoke(["export", _root]);
+        Assert.That(export.ExitCode, Is.Zero, export.Output);
+        using var exported = JsonDocument.Parse(export.Output);
+        var installed = Path.Combine(_root, "Installed");
+        var install = await CliHelpTests.Invoke(["galpak", "install", exported.RootElement.GetProperty("data").GetProperty("packagePath").GetString()!, "--output", installed]);
+        Assert.That(install.ExitCode, Is.Zero, install.Output);
+        var packed = PackedGameDocuments.ReadGame(File.ReadAllBytes(Path.Combine(installed, "game.pak")));
+        var restored = JsonCodec.Deserialize<ProjectConfiguration>(packed.Documents.GetText("settings.json"))!;
+        using var schema = ProjectSchemaContext.Load(_root);
+        Assert.DoesNotThrow(() => schema.Configurations.Validate(restored));
+        Assert.That(JsonSerializer.Serialize(restored), Is.EqualTo(JsonSerializer.Serialize(saved)));
+        var distribution = Path.Combine(_root, "Distribution");
+        var directoryExport = await CliHelpTests.Invoke(["project", "export-directory", _root, "--output", distribution]);
+        Assert.That(directoryExport.ExitCode, Is.Zero, directoryExport.Output);
+        var directoryPacked = PackedGameDocuments.ReadGame(File.ReadAllBytes(Path.Combine(distribution, "game.pak")));
+        Assert.That(JsonSerializer.Serialize(JsonCodec.Deserialize<ProjectConfiguration>(directoryPacked.Documents.GetText("settings.json"))), Is.EqualTo(JsonSerializer.Serialize(saved)));
+        var before = File.ReadAllBytes(Path.Combine(distribution, "game.pak"));
+        var inspect = await CliHelpTests.Invoke(["game", "inspect", distribution]);
+        Assert.That(inspect.ExitCode, Is.Zero, inspect.Output);
+        using var inspected = JsonDocument.Parse(inspect.Output);
+        Assert.That(inspected.RootElement.GetProperty("operationId").GetString(), Is.EqualTo("game.inspect"));
+        Assert.That(inspected.RootElement.GetProperty("data").GetProperty("buildId").GetString(), Is.EqualTo(directoryPacked.Manifest.BuildId));
+        Assert.That(File.ReadAllBytes(Path.Combine(distribution, "game.pak")), Is.EqualTo(before));
+    }
+
+    [Test]
+    public void CustomConfigurationPatch_RemovesFieldsAndRejectsChangesAtomically()
+    {
+        using var schema = ProjectSchemaContext.Load(_root);
+        var persistence = new DirectProjectPersistence(_root, new EditorDocumentRepository(schema.Catalog), schema.Configurations);
+        var document = persistence.Load();
+        var handler = new BuiltInEditorCommandHandler(schema.Catalog, schema.Configurations);
+        var values = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>("""{"count":3,"limit":4,"caption":null}""")!;
+        Assert.That(handler.Execute(document, new PatchConfigurationCommand("developer.options", values), new(0, false)).Success, Is.True);
+        var original = JsonSerializer.Serialize(document.Configuration);
+        foreach (var (section, json) in new[] { ("developer.options", "{\"count\":8,\"limit\":7}"), ("developer.options", "{\"unknown\":1}"), ("unknown", "{\"count\":1}") })
+        {
+            var result = handler.Execute(document, new PatchConfigurationCommand(section, JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json)!), new(0, false));
+            Assert.That(result.Success, Is.False);
+            Assert.That(JsonSerializer.Serialize(document.Configuration), Is.EqualTo(original));
+        }
+        Assert.That(handler.Execute(document, new PatchConfigurationCommand("developer.options", new Dictionary<string, JsonElement>(), ["caption"]), new(0, false)).Success, Is.True);
+        var data = document.Configuration.Sections["developer.options"].Data;
+        Assert.That(data.TryGetProperty("caption", out _), Is.False);
+        Assert.That(data.GetProperty("count").GetInt32(), Is.EqualTo(3));
+        Assert.DoesNotThrow(() => schema.Configurations.Validate(document.Configuration));
+        document.Configuration.SetRaw("developer.options", new(2, data));
+        original = JsonSerializer.Serialize(document.Configuration);
+        Assert.That(handler.Execute(document, new PatchConfigurationCommand("developer.options", values), new(0, false)).Success, Is.False);
+        Assert.That(JsonSerializer.Serialize(document.Configuration), Is.EqualTo(original));
+    }
+
+    [Test]
+    public async Task InvalidCustomConfiguration_BlocksBuildAndBothExportsBeforePublication()
+    {
+        Put("settings.json", """{"version":1,"sections":{"developer.options":{"version":1,"data":{"count":9,"limit":2}}}}""");
+        Put("Output/sentinel.txt", "preserve");
+        var package = "Output/" + Path.GetFileName(_root) + ".galpak";
+        Put(package, "previous package");
+        foreach (var args in new[] { new[] { "build", _root }, new[] { "export", _root }, new[] { "project", "export-directory", _root, "--output", Path.Combine(_root, "Distribution") } })
+        {
+            var result = await CliHelpTests.Invoke(args);
+            Assert.That(result.ExitCode, Is.Not.Zero, result.Output);
+            Assert.That(result.Output, Does.Contain("Count exceeds limit"));
+        }
+        Assert.That(File.ReadAllText(Path.Combine(_root, "Output/sentinel.txt")), Is.EqualTo("preserve"));
+        Assert.That(File.ReadAllText(Path.Combine(_root, package)), Is.EqualTo("previous package"));
+        Assert.That(Directory.Exists(Path.Combine(_root, "Distribution")), Is.False);
     }
 
     [Test]
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectDocumentOwnershipTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectDocumentOwnershipTests.cs
index af663d00..8356d2e7 100644
--- a/test/GalNet.Editor.Shared.Tests/ProjectDocumentOwnershipTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ProjectDocumentOwnershipTests.cs
@@ -1,6 +1,7 @@
 using System.Text.Json;
-using GalNet.Core.Audio;
-using GalNet.Core.Settings;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Configuration;
 using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Shared.Services;
@@ -39,32 +40,38 @@ public void SnapshotsOwnJsonAndAllSettingsIncludingAudioPolicies()
     {
         var project = new EditorProjectDocument
         {
-            Settings = new ProjectSettings
+            Configuration = new DefaultProjectOptions
             {
                 AvailableLocales = [new("en-US")],
+                AudioBuses = [new() { Id = "ambience", Name = "Environment" }],
                 AudioTracks = [new AudioTrackDefinition
                 {
-                    Id = "custom", Name = "Custom", Bus = AudioBuses.Sfx, DefaultGain = .4f, MaxVoices = 3, MaxQueuedItems = 4,
+                    Id = "custom", Name = "Custom", BusId = "ambience", PreserveDuringCatchUp = true, DefaultGain = .4f, MaxVoices = 3, MaxQueuedItems = 4,
                     OverflowPolicy = AudioOverflowPolicy.StopOldest, QueueOverflowPolicy = AudioQueueOverflowPolicy.DropOldest
                 }]
-            },
+            }.ToConfiguration(),
             GroupEntries = { ["opening"] = [new() { StableId = "line", Type = "custom.line" }] }
         };
         using (var json = JsonDocument.Parse("""{"payload":{"items":[9007199254740993,null,{"enabled":true}]},"explicitNull":null}"""))
             project.GroupEntries["opening"][0].Parameters = json.RootElement.EnumerateObject().ToDictionary(property => property.Name, property => property.Value.Clone());
         var clone = EditorDocumentCloner.Clone(project);
-        project.Settings.AvailableLocales.Clear();
-        project.Settings.AudioTracks[0].Name = "Changed";
+        var options = project.Configuration.ReadDefaultOptions();
+        options.AvailableLocales.Clear();
+        options.AudioBuses[0] = options.AudioBuses[0] with { Name = "Changed group" };
+        options.AudioTracks[0] = options.AudioTracks[0] with { Name = "Changed" };
+        project.Configuration.Set(DefaultProjectConfiguration.Section, options);
         project.GroupEntries["opening"][0].Parameters.Clear();
         var values = clone.GroupEntries["opening"].Single().Parameters;
         Assert.That(values["payload"].GetProperty("items")[0].GetInt64(), Is.EqualTo(9007199254740993L));
         Assert.That(values["explicitNull"].ValueKind, Is.EqualTo(JsonValueKind.Null));
         Assert.That(values.ContainsKey("omitted"), Is.False);
-        Assert.That(clone.Settings.AvailableLocales.Single().Code, Is.EqualTo("en-US"));
-        Assert.That(clone.Settings.AudioTracks[0].Name, Is.EqualTo("Custom"));
-        Assert.That(clone.Settings.AudioTracks[0].DefaultGain, Is.EqualTo(.4f));
-        Assert.That(clone.Settings.AudioTracks[0].MaxQueuedItems, Is.EqualTo(4));
-        Assert.That(clone.Settings.AudioTracks[0].OverflowPolicy, Is.EqualTo(AudioOverflowPolicy.StopOldest));
-        Assert.That(clone.Settings.AudioTracks[0].QueueOverflowPolicy, Is.EqualTo(AudioQueueOverflowPolicy.DropOldest));
+        Assert.That(clone.Configuration.ReadDefaultOptions().AvailableLocales.Single().Code, Is.EqualTo("en-US"));
+        Assert.That(clone.Configuration.ReadDefaultOptions().AudioTracks[0].Name, Is.EqualTo("Custom"));
+        Assert.That(clone.Configuration.ReadDefaultOptions().AudioBuses.Single().Id, Is.EqualTo("ambience"));
+        Assert.That(clone.Configuration.ReadDefaultOptions().AudioTracks[0].PreserveDuringCatchUp, Is.True);
+        Assert.That(clone.Configuration.ReadDefaultOptions().AudioTracks[0].DefaultGain, Is.EqualTo(.4f));
+        Assert.That(clone.Configuration.ReadDefaultOptions().AudioTracks[0].MaxQueuedItems, Is.EqualTo(4));
+        Assert.That(clone.Configuration.ReadDefaultOptions().AudioTracks[0].OverflowPolicy, Is.EqualTo(AudioOverflowPolicy.StopOldest));
+        Assert.That(clone.Configuration.ReadDefaultOptions().AudioTracks[0].QueueOverflowPolicy, Is.EqualTo(AudioQueueOverflowPolicy.DropOldest));
     }
 }
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectFileTransactionTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectFileTransactionTests.cs
index f92091b0..3e48df71 100644
--- a/test/GalNet.Editor.Shared.Tests/ProjectFileTransactionTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ProjectFileTransactionTests.cs
@@ -1,5 +1,6 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
 using GalNet.Editor.Abstraction.Changes;
@@ -102,11 +103,14 @@ public async Task LinkedDestinationsAndDuplicateBatchTargetsCannotEscapeOrOverwr
         Assert.ThrowsAsync<EditorOperationException>(() => operation.ApplyAsync(true, prepare => persistence.PublishStructureAsync(document, prepare)));
         Assert.That(Directory.GetFiles(Path.Combine(_root, "target")), Is.Empty);
         var link = Path.Combine(_root, "link");
-        try { Directory.CreateSymbolicLink(link, Path.Combine(_root, "target")); }
-        catch (Exception error) when (error is UnauthorizedAccessException or IOException) { Assert.Ignore("Directory links unavailable: " + error.Message); }
-        using var linked = new ProjectFileOperation(_root, new(ProjectFileAction.Move, ["first/a.bin"], "link"), catalog);
-        Assert.ThrowsAsync<InvalidDataException>(() => linked.ApplyAsync(true, prepare => persistence.PublishStructureAsync(document, prepare)));
-        Assert.That(File.Exists(Path.Combine(_root, "first/a.bin")), Is.True);
+        DirectoryLinks.Create(link, Path.Combine(_root, "target"));
+        try
+        {
+            using var linked = new ProjectFileOperation(_root, new(ProjectFileAction.Move, ["first/a.bin"], "link"), catalog);
+            Assert.ThrowsAsync<InvalidDataException>(() => linked.ApplyAsync(true, prepare => persistence.PublishStructureAsync(document, prepare)));
+            Assert.That(File.Exists(Path.Combine(_root, "first/a.bin")), Is.True);
+        }
+        finally { Directory.Delete(link); }
     }
 
     [TestCase(false)]
@@ -146,8 +150,8 @@ public async Task DeclaredResourceReferencesCannotBeBypassedAsStringCandidates()
         var persistence = new DirectProjectPersistence(_root, new EditorDocumentRepository(catalog)); var document = persistence.Load();
         File.WriteAllBytes(Path.Combine(_root, "Assets/a.png"), [1]);
         File.WriteAllText(Path.Combine(_root, "Assets/a.png.meta"), """{"id":"asset-a","type":"sprite","path":"a.png"}""");
-        var definition = catalog.Definitions.First(item => item.DynamicParameters?.Values.Any(field => field.Editor?.EditorId?.Contains("asset", StringComparison.OrdinalIgnoreCase) == true) == true);
-        var parameter = definition.DynamicParameters!.First(pair => pair.Value.Editor?.EditorId?.Contains("asset", StringComparison.OrdinalIgnoreCase) == true).Key;
+        var definition = catalog.Definitions.First(item => item.DynamicParameters.Values.Any(field => field.Editor?.EditorId?.Contains("asset", StringComparison.OrdinalIgnoreCase) == true));
+        var parameter = definition.DynamicParameters.First(pair => pair.Value.Editor?.EditorId?.Contains("asset", StringComparison.OrdinalIgnoreCase) == true).Key;
         document.GroupEntries.Values.First().Add(new() { StableId = "reference-entry", Type = definition.Type, Parameters = new() { [parameter] = JsonSerializer.SerializeToElement("asset-a") } });
         using var operation = new ProjectFileOperation(_root, new(ProjectFileAction.Delete, ["Assets/a.png"], AllowCandidateReferences: true), catalog);
         Assert.That(operation.Analyze(document, document).References.Single().Certain, Is.True);
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectLifecycleTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectLifecycleTests.cs
index 30bd0ae5..d22840b4 100644
--- a/test/GalNet.Editor.Shared.Tests/ProjectLifecycleTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ProjectLifecycleTests.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Settings;
+using GalNet.Core.Configuration;
 using GalNet.Editor.Abstraction.Project;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -10,7 +10,7 @@ public sealed class ProjectLifecycleTests
     public async Task ProjectWaitsForRegisteredCleanupBeforeDisposingScope()
     {
         using var scope = new TestScope();
-        var project = new GalProject("test", "test", Path.GetTempPath(), new ProjectSettings(), new EditorProjectState(), scope);
+        var project = new GalProject("test", "test", Path.GetTempPath(), new ProjectConfiguration(), new EditorProjectState(), scope);
         var cleanupFinished = false;
         project.RegisterClosingCallback(async () =>
         {
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectQueryServiceTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectQueryServiceTests.cs
index a7ba65d6..93f12e92 100644
--- a/test/GalNet.Editor.Shared.Tests/ProjectQueryServiceTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ProjectQueryServiceTests.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using GalNet.Contracts.Builtins.Assets;
 using GalNet.Core.Assets;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Shared.Services;
@@ -26,7 +27,7 @@ public void SetUp()
         Put("Graph/groups/b.rawgalgroup", """{"version":2,"kind":"Raw","entries":[{"id":"same","type":"unknown.other","parameters":{}}]}""");
         Put("Graph/groups/orphan.rawgalgroup", """{"version":2,"kind":"Raw","entries":[]} """);
         Put("Assets/picture.bin", "asset");
-        Put("Assets/picture.bin.meta", new AssetMetaCodec(BuiltinResourceTypes.CreateCatalog()).Serialize(new BinaryAssetMeta
+        Put("Assets/picture.bin.meta", new AssetMetaCodec(BuiltinResourceTypes.CreateCatalog()).Serialize(new AssetMeta
         { Id = "f2700971-d36e-4be4-94dd-a5c282861c57", TypeId = "data", Path = "picture.bin" }));
         Put("Output/ignored.json", "{}");
         Put("Contracts/placeholder.txt", "not a schema");
@@ -75,7 +76,7 @@ public void ResourceQueries_ReadActualCodecOutput_AndDoNotCountTheIdentityAsARef
     {
         var resourceId = usePascalCase ? "f2700971-d36e-4be4-94dd-a5c282861c57" : "f2700971d36e4be494dda5c282861c57";
         var options = new JsonSerializerOptions(JsonSerializerDefaults.Web) { PropertyNamingPolicy = usePascalCase ? null : JsonNamingPolicy.CamelCase };
-        Put("Assets/picture.bin.meta", new AssetMetaCodec(BuiltinResourceTypes.CreateCatalog(), options).Serialize(new BinaryAssetMeta
+        Put("Assets/picture.bin.meta", new AssetMetaCodec(BuiltinResourceTypes.CreateCatalog(), options).Serialize(new AssetMeta
         { Id = resourceId, TypeId = "data", Path = "picture.bin" }));
         var query = new ProjectQueryService(_root);
         var files = query.Files(new(Kind: "resource"));
@@ -182,9 +183,7 @@ public void DirectoryLinks_AreSkipped_AndExplicitTraversalIsRejected()
         var link = Path.Combine(_root, "linked");
         try
         {
-            try { Directory.CreateSymbolicLink(link, outside); }
-            catch (Exception exception) when (exception is UnauthorizedAccessException or IOException)
-            { Assert.Ignore($"Creating a directory link is unavailable: {exception.Message}"); }
+            DirectoryLinks.Create(link, outside);
             var result = new ProjectQueryService(_root).Files(new());
             Assert.That(result.Diagnostics.Any(item => item.Code == "file.linkSkipped"), Is.True);
             Assert.Throws<InvalidDataException>(() => new ProjectQueryService(_root).Files(new(Root: "linked")));
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectSchemaContextTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectSchemaContextTests.cs
index fc3df926..8af670c9 100644
--- a/test/GalNet.Editor.Shared.Tests/ProjectSchemaContextTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ProjectSchemaContextTests.cs
@@ -150,7 +150,7 @@ public void AncestorLinks_AreRejectedForRawReadsAndContractLoads()
     {
         var project = Deploy("SchemaA");
         var link = Path.Combine(_directory, "link");
-        Directory.CreateSymbolicLink(link, _directory);
+        DirectoryLinks.Create(link, _directory);
         try
         {
             var linkedProject = Path.Combine(link, Path.GetFileName(project));
diff --git a/test/GalNet.Editor.Shared.Tests/ProjectValidationServiceTests.cs b/test/GalNet.Editor.Shared.Tests/ProjectValidationServiceTests.cs
index 85d80a0b..5346a8fb 100644
--- a/test/GalNet.Editor.Shared.Tests/ProjectValidationServiceTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ProjectValidationServiceTests.cs
@@ -19,7 +19,7 @@ public void SetUp()
     {
         _root = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "GalNet-validation-" + Guid.NewGuid())).FullName;
         Put("Graph/graph.json", Graph);
-        Put("settings.json", "{}");
+        Put("settings.json", """{"version":1,"sections":{}}""");
         Put(Source, """{"version":2,"kind":"Raw","entries":[{"id":"e","type":"custom.test","parameters":{"value":2,"mode":"one"}}]}""");
     }
     [TearDown]
@@ -209,7 +209,7 @@ private static TargetProfileEntryCatalog Catalog()
     {
         var parameters = new DynamicParameterTable([
             new("value", typeof(int), isRequired: true),
-            new("mode", typeof(string), constraints: JsonSerializer.SerializeToElement(new { options = new[] { "one", "two" } }))],
+            new("mode", typeof(string), constraints: JsonSerializer.SerializeToElement(new { @enum = new[] { "one", "two" } }))],
             arguments => { if (arguments.GetProperty("value").GetInt32() <= 0) throw new InvalidDataException("value must be positive"); });
         return new TargetProfileEntryCatalog([new DefaultEntryModule("test", [new DefaultPrimitiveEntryBase("custom.test", parameters)])]);
     }
diff --git a/test/GalNet.Editor.Shared.Tests/ResourceReferenceIndexTests.cs b/test/GalNet.Editor.Shared.Tests/ResourceReferenceIndexTests.cs
new file mode 100644
index 00000000..9c7f5865
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/ResourceReferenceIndexTests.cs
@@ -0,0 +1,52 @@
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Core.Assets;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Shared.Tests;
+
+public sealed class ResourceReferenceIndexTests
+{
+    [Test]
+    public void StoryPackageSurvivesAuthorCloningAndIdentityPreservingReload()
+    {
+        var source = new EditorProjectDocument { Graph = new() { Nodes = [new() { Id = "main", Type = "Group", File = "groups/main.rawgalgroup", StoryPackage = "A" }] }, GroupEntries = new() { ["main"] = [] } };
+        var clone = GalNet.Editor.Abstraction.Changes.EditorDocumentCloner.Clone(source);
+        Assert.That(clone.Graph.Nodes[0].StoryPackage, Is.EqualTo("A"));
+        var service = new EditorDocumentService();
+        service.Load(new() { Document = source.Graph, GroupEntries = source.GroupEntries });
+        var identity = service.CurrentDocument.Nodes[0]; clone.Graph.Nodes[0].StoryPackage = "B";
+        service.Reload(new() { Document = clone.Graph, GroupEntries = clone.GroupEntries });
+        Assert.That(service.CurrentDocument.Nodes[0], Is.SameAs(identity));
+        Assert.That(identity.StoryPackage, Is.EqualTo("B"));
+    }
+
+    [Test]
+    public void AllGroupsIncludingStoryAndIndirectResourcesRemainVisibleWithoutOpeningThem()
+    {
+        var document = new EditorProjectDocument
+        {
+            Graph = new() { Nodes = [new() { Id = "patch", Type = "Group", StoryPackage = "bonus" }] },
+            GroupEntries = new()
+            {
+                ["patch"] = [new() { StableId = "show", Type = "variants.show",
+                Parameters = new() { ["assetId"] = JsonSerializer.SerializeToElement(" ATLAS ") } }]
+            }
+        };
+        var atlas = new DependentAssetMeta { Id = "atlas", TypeId = "image-variants", Path = "hero.variants", DependenciesComplete = true, Dependencies = [new("sprite", "sprite")] };
+        var sprite = new SpriteAssetMeta { Id = "sprite", TypeId = "sprite", Path = "hero.png" };
+        var files = new IGameFile[] { new GameFile("atlas", atlas.Path, atlas.TypeId, atlas, []), new GameFile("sprite", sprite.Path, sprite.TypeId, sprite, []) };
+        var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+        var index = new ResourceReferenceIndex(document, catalog, files, new());
+        Assert.That(index.Rows.Select(row => row.Id), Is.EquivalentTo(new[] { "atlas", "sprite" }));
+        Assert.That(index.Rows.Single(row => row.Id == "sprite").Uses.Single().Through, Is.EqualTo("atlas"));
+        Assert.That(index.Rows.All(row => row.Uses.Single().GroupId == "patch"), Is.True);
+        var missing = new ResourceReferenceIndex(document, catalog, files.Take(1).ToArray(), new());
+        Assert.That(missing.Rows.Single(row => row.Id == "sprite").Missing, Is.True);
+        Assert.That(missing.Issues, Does.Contain("Missing resource: sprite"));
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/SceneEffectMetadataTests.cs b/test/GalNet.Editor.Shared.Tests/SceneEffectMetadataTests.cs
index 6b86d697..510fd7f3 100644
--- a/test/GalNet.Editor.Shared.Tests/SceneEffectMetadataTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/SceneEffectMetadataTests.cs
@@ -1,6 +1,6 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Shared.Services;
 
@@ -48,6 +48,7 @@ public void LegacyCatalogIsDistinctFromProgramAndInvalidStaticValuesRemainUnknow
         var result = analysis.Before("g", null); Assert.That(result.Complete, Is.True);
         Assert.That(result.Targets.Single().Resource, Is.EqualTo("legacy")); Assert.That(result.Targets.Single().Values["strength"], Is.EqualTo(-.75f));
         fx.Parameters["parameters"] = JsonSerializer.SerializeToElement(new { strength = "invalid" });
+        analysis = new SceneTargetAnalysis(Graph("g"), new Dictionary<string, List<EditorEntryData>> { ["g"] = [fx] }, effects: catalog);
         result = analysis.Before("g", null); Assert.That(result.Complete, Is.False);
         Assert.That(result.Targets.Single().Properties.Any(property => property.Name == "strength"), Is.True); Assert.That(result.Targets.Single().Values.ContainsKey("strength"), Is.False);
     }
diff --git a/test/GalNet.Editor.Shared.Tests/SceneFlipbookAnalysisTests.cs b/test/GalNet.Editor.Shared.Tests/SceneFlipbookAnalysisTests.cs
index 92f263fa..5fb4ad29 100644
--- a/test/GalNet.Editor.Shared.Tests/SceneFlipbookAnalysisTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/SceneFlipbookAnalysisTests.cs
@@ -2,7 +2,7 @@
 using GalNet.Contracts.Builtins;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Shared.Services;
-using SceneLayer = GalNet.Core.Scene.Layer;
+using SceneLayer = GalNet.Contracts.Builtins.Scene.Layer;
 
 namespace GeneralTest.Editor;
 
diff --git a/test/GalNet.Editor.Shared.Tests/SceneIdentityMigrationTests.cs b/test/GalNet.Editor.Shared.Tests/SceneIdentityMigrationTests.cs
new file mode 100644
index 00000000..1069a767
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/SceneIdentityMigrationTests.cs
@@ -0,0 +1,28 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Editor.Shared.Services;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class SceneTargetAnalysisTests
+{
+    [Test]
+    public void CompatibleRolesPreserveOutputAcrossDifferentWireSlotsWhileIncompatibleKindsAllocateFreshIdentity()
+    {
+        var layer = Layer("creator", "layer-identity");
+        var transition = SceneAuthoringIdentities.ChangeType(layer.Type, layer.Parameters, BuiltinEntryIds.SlideTransition, new());
+        Assert.That(transition["toLayerHandleId"].GetString(), Is.EqualTo("layer-identity"));
+        var playback = transition["playbackHandleId"].GetString(); Assert.That(playback, Is.Not.Empty);
+        var cross = SceneAuthoringIdentities.ChangeType(BuiltinEntryIds.SlideTransition, transition, BuiltinEntryIds.CrossFadeTransition, new());
+        Assert.That(cross["newHandleId"].GetString(), Is.EqualTo("layer-identity")); Assert.That(cross["playbackHandleId"].GetString(), Is.EqualTo(playback));
+        var effect = SceneAuthoringIdentities.ChangeType(BuiltinEntryIds.CrossFadeTransition, cross, BuiltinEntryIds.ApplyEffect, new());
+        Assert.That(effect["instanceId"].GetString(), Is.Not.EqualTo("layer-identity").And.Not.EqualTo(playback));
+        Assert.That(layer.Parameters["handleId"].GetString(), Is.EqualTo("layer-identity"));
+        var timeline = SceneAuthoringIdentities.ChangeType(BuiltinEntryIds.CrossFadeTransition, cross, BuiltinEntryIds.PlayTimeline,
+            new() { ["timeline"] = JsonSerializer.SerializeToElement(new { PlaybackHandleId = "template", unknown = new { number = 9007199254740993L } }) });
+        Assert.That(timeline["timeline"].GetProperty("PlaybackHandleId").GetString(), Is.EqualTo(playback));
+        Assert.That(timeline["timeline"].GetProperty("unknown").GetProperty("number").GetInt64(), Is.EqualTo(9007199254740993L));
+        var animate = SceneAuthoringIdentities.ChangeType(BuiltinEntryIds.PlayTimeline, timeline, BuiltinEntryIds.Animate, new());
+        Assert.That(animate["playbackHandleId"].GetString(), Is.EqualTo(playback));
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/SceneReferenceAnalysisTests.cs b/test/GalNet.Editor.Shared.Tests/SceneReferenceAnalysisTests.cs
new file mode 100644
index 00000000..0f933e7b
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/SceneReferenceAnalysisTests.cs
@@ -0,0 +1,140 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Services;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class SceneTargetAnalysisTests
+{
+    [Test]
+    public void RelationshipRegistryKeepsDomainsSeparateAndUnknownJsonUntouchedDuringCopy()
+    {
+        var layer = Layer("layer", "shared");
+        var animate = Entry("animate", BuiltinEntryIds.Animate, new { handleId = "shared", playbackHandleId = "shared" });
+        var stop = Entry("stop", BuiltinEntryIds.StopAnimation, new { playbackHandleId = "shared" });
+        var unknown = Entry("custom", "custom.scene", new { handleId = "shared", playbackHandleId = "shared" });
+        SceneAuthoringIdentities.RemapCopy([layer, animate, stop, unknown]);
+        Assert.That(animate.Parameters["handleId"].GetString(), Is.EqualTo(layer.Parameters["handleId"].GetString()));
+        Assert.That(stop.Parameters["playbackHandleId"].GetString(), Is.EqualTo(animate.Parameters["playbackHandleId"].GetString()).And.Not.EqualTo(layer.Parameters["handleId"].GetString()));
+        Assert.That(unknown.Parameters["handleId"].GetString(), Is.EqualTo("shared"));
+        Assert.That(SceneAuthoringSemantics.Find(BuiltinEntryIds.ShowLayer)!.Outputs.Single().Role, Is.EqualTo(SceneAuthoringSemantics.Find(BuiltinEntryIds.SlideTransition)!.Outputs.First().Role));
+    }
+
+    [Test]
+    public void SyntacticIndexKeepsAllCreatorsAndUnreachableUsesWithoutClaimingUniqueDependency()
+    {
+        var graph = Graph("root", "left", "right", "merge", "unreachable"); Edge(graph, "root", "left"); Edge(graph, "root", "right"); Edge(graph, "left", "merge"); Edge(graph, "right", "merge");
+        Dictionary<string, List<EditorEntryData>> groups = new()
+        {
+            ["root"] = [],
+            ["left"] = [Layer("same", "shared")],
+            ["right"] = [Layer("same", "shared")],
+            ["merge"] = [Entry("use", BuiltinEntryIds.MoveLayer, new { handleId = "shared", transform = new { x = 5 } })],
+            ["unreachable"] = [Entry("use", BuiltinEntryIds.HideLayer, new { handleId = "shared" }), Entry("custom", "custom.scene", new { opaque = "shared" })]
+        };
+        var index = new SceneReferenceIndex(groups);
+        Assert.That(index.Definitions.Select(definition => definition.Owner), Is.EquivalentTo(new[] { new SceneAuthorAddress("left", "same"), new SceneAuthorAddress("right", "same") }));
+        Assert.That(index.Candidates(index.References[0]), Has.Count.EqualTo(2));
+        var diagnostics = SceneReferenceAnalysis.Diagnose(index, new(graph, groups));
+        Assert.That(diagnostics.Any(issue => issue.Owner.GroupId == "merge"), Is.False);
+        Assert.That(diagnostics.Any(issue => issue.Code == "scene.reference.unreachable"), Is.True);
+        Assert.That(diagnostics.Any(issue => issue.Code == "scene.coverage.unknown"), Is.True);
+        groups["left"].Clear();
+        var state = SceneReferenceAnalysis.Resolve(index.References[0], new(graph, groups));
+        Assert.That(state.Code, Is.EqualTo("scene.reference.possible"));
+    }
+
+    [Test]
+    public void DeleteImpactUsesPositionAndHandlesCreationRemovalAndBatchConsumersAcrossGroups()
+    {
+        var graph = Graph("first", "next"); Edge(graph, "first", "next");
+        var creator = Layer("create", "object"); var hide = Entry("hide", BuiltinEntryIds.HideLayer, new { handleId = "object" });
+        var use = Entry("use", BuiltinEntryIds.MoveLayer, new { handleId = "object", transform = new { x = 4 } });
+        Dictionary<string, List<EditorEntryData>> before = new() { ["first"] = [creator, hide], ["next"] = [use] };
+        Dictionary<string, List<EditorEntryData>> after = new() { ["first"] = [creator], ["next"] = [use] };
+        var original = JsonSerializer.Serialize(before);
+        var impact = SceneReferenceAnalysis.Compare(graph, before, after);
+        var change = impact.References.Single();
+        Assert.That(change.Before.Code, Is.EqualTo("scene.reference.missing")); Assert.That(change.After.Code, Is.EqualTo("scene.reference.resolved"));
+        Assert.That(impact.ChangedGroups, Does.Contain("next")); Assert.That(impact.Complete, Is.True);
+        Assert.That(JsonSerializer.Serialize(before), Is.EqualTo(original));
+        before["first"] = [creator]; after["first"] = [];
+        impact = SceneReferenceAnalysis.Compare(graph, before, after);
+        Assert.That(impact.References.Single().After.Code, Is.EqualTo("scene.reference.missing"));
+        after["next"] = []; impact = SceneReferenceAnalysis.Compare(graph, before, after);
+        Assert.That(impact.References, Is.Empty, "Consumers deleted in the same operation are not external broken references.");
+    }
+
+    [Test]
+    public void TimelineIndexPreservesPathsAndPlaybackDomainAndResolvesEventsAtTheirPosition()
+    {
+        var graph = Graph("g");
+        var timeline = Entry("timeline", BuiltinEntryIds.PlayTimeline, new
+        {
+            timeline = new
+            {
+                PlaybackHandleId = "play",
+                FrameRate = 60,
+                DurationFrames = 10,
+                Blocking = true,
+                Tracks = new[] { new { HandleId = "external", Property = "opacity", Keys = new[] { new { Frame = 0, Value = 1 } } } },
+                Events = new object[] { new { EditorId = "create", Frame = 0, Type = BuiltinEntryIds.ShowLayer, Parameters = new { handleId = "inside", assetId = "image" } },
+                new { EditorId = "hide", Frame = 5, Type = BuiltinEntryIds.HideLayer, Parameters = new { handleId = "inside" } } }
+            }
+        });
+        Dictionary<string, List<EditorEntryData>> groups = new() { ["g"] = [Layer("external", "external"), timeline, Entry("stop", BuiltinEntryIds.StopAnimation, new { playbackHandleId = "play" })] };
+        var index = new SceneReferenceIndex(groups);
+        Assert.That(index.Complete, Is.True);
+        Assert.That(index.Definitions.Any(definition => definition.Slot.Domain == SceneIdentityDomain.Playback && definition.JsonPointer == "/parameters/timeline/PlaybackHandleId"), Is.True);
+        var eventUse = index.References.Single(reference => reference.EventId == "hide");
+        Assert.That(eventUse.JsonPointer, Is.EqualTo("/parameters/timeline/Events/1/Parameters/handleId"));
+        Assert.That(SceneReferenceAnalysis.Resolve(eventUse, new(graph, groups)).Code, Is.EqualTo("scene.reference.resolved"));
+        var track = index.References.Single(reference => reference.JsonPointer.Contains("/Tracks/", StringComparison.Ordinal));
+        Assert.That(SceneReferenceAnalysis.Resolve(track, new(graph, groups)).Code, Is.EqualTo("scene.reference.resolved"));
+    }
+
+    [Test]
+    public void IncompleteUnknownAndConditionalStatesNeverBecomeProvenMissingTargets()
+    {
+        var graph = Graph("g");
+        Dictionary<string, List<EditorEntryData>> groups = new() { ["g"] = [Entry("unknown", "custom.invoke", new { anything = "target" }), Entry("use", BuiltinEntryIds.HideLayer, new { handleId = "target" })] };
+        var diagnostics = SceneReferenceAnalysis.Diagnose(new(groups), new(graph, groups));
+        Assert.That(diagnostics.Select(issue => issue.Code), Does.Contain("scene.reference.uncertain").And.Not.Contain("scene.reference.missing"));
+        groups["g"] = [Layer("conditional", "target", condition: "save.flag"), Entry("use", BuiltinEntryIds.HideLayer, new { handleId = "target" })];
+        Assert.That(SceneReferenceAnalysis.Diagnose(new(groups), new(graph, groups)).Single().Code, Is.EqualTo("scene.reference.possible"));
+    }
+
+    [Test]
+    public void IndexBudgetAndMalformedTimelineKeepPartialFactsExplicitlyIncomplete()
+    {
+        Dictionary<string, List<EditorEntryData>> groups = new() { ["g"] = Enumerable.Range(0, 6000).Select(index => Entry(index.ToString(), BuiltinEntryIds.HideLayer, new { handleId = "target" })).ToList() };
+        var index = new SceneReferenceIndex(groups);
+        Assert.That(index.Complete, Is.False); Assert.That(index.Coverage.Last().Code, Is.EqualTo("scene.analysis.limit"));
+        Assert.That(index.References.Count, Is.LessThan(6000).And.GreaterThan(0));
+        groups["g"] = [Entry("timeline", BuiltinEntryIds.PlayTimeline, new { timeline = new { Tracks = new { HandleId = "target" }, Events = new[] { new { Type = "custom.event", Parameters = new { handleId = "target" } } } } })];
+        index = new(groups);
+        Assert.That(index.Complete, Is.False); Assert.That(index.References, Is.Empty);
+        Assert.That(index.Coverage.Select(issue => issue.Code), Does.Contain("scene.coverage.unknown").And.Contain("scene.coverage.structure"));
+    }
+
+    [Test]
+    public void DeletingStopRestoresPlaybackReferenceAndCycleDeletionUsesFixedPointFacts()
+    {
+        var graph = Graph("g");
+        var layer = Layer("layer", "layer"); var playback = Playback();
+        var stop = Entry("stop", BuiltinEntryIds.StopAnimation, new { playbackHandleId = "play", mode = "CompleteImmediately" });
+        var use = Entry("use", BuiltinEntryIds.StopAnimation, new { playbackHandleId = "play" });
+        Dictionary<string, List<EditorEntryData>> before = new() { ["g"] = [layer, playback, stop, use] };
+        Dictionary<string, List<EditorEntryData>> after = new() { ["g"] = [layer, playback, use] };
+        var change = SceneReferenceAnalysis.Compare(graph, before, after).References.Single();
+        Assert.That(change.Reference.Slot.Domain, Is.EqualTo(SceneIdentityDomain.Playback));
+        Assert.That(change.Before.Code, Is.EqualTo("scene.reference.missing")); Assert.That(change.After.Code, Is.EqualTo("scene.reference.possible"));
+        Edge(graph, "g", "g");
+        var creator = Layer("created", "object"); var hide = Entry("hide", BuiltinEntryIds.HideLayer, new { handleId = "object" });
+        before["g"] = [creator, hide]; after["g"] = [hide];
+        var impact = SceneReferenceAnalysis.Compare(graph, before, after);
+        Assert.That(impact.References.Single().After.Code, Is.EqualTo("scene.reference.missing"));
+        Assert.That(impact.Complete, Is.True);
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/SceneReferenceCapabilityDiagnosticsTests.cs b/test/GalNet.Editor.Shared.Tests/SceneReferenceCapabilityDiagnosticsTests.cs
new file mode 100644
index 00000000..df19f746
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/SceneReferenceCapabilityDiagnosticsTests.cs
@@ -0,0 +1,43 @@
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Services;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class SceneTargetAnalysisTests
+{
+    [Test]
+    public void KnownTimelineTargetDoesNotInheritUnrelatedEffectsIncompleteCapabilities()
+    {
+        var descriptor = new ShaderEffectDescriptor(new("blur"), 1, "source", new HashSet<EffectStage> { EffectStage.ScenePost },
+            [new("radius", "radius", ShaderEffectParameterKind.Float, "0", 0, 64, Animatable: true)]);
+        var effect = Entry("fx", BuiltinEntryIds.ApplyEffect, new { instanceId = "c2121d4d69544d4d8a584d392dfedbe6", program = "blur", parameters = new { radius = 32 } });
+        var unrelated = Entry("unknown", BuiltinEntryIds.ApplyEffect, new { instanceId = "unrelated", program = "missing" });
+        var clip = Entry("clip", BuiltinEntryIds.PlayTimeline, new
+        {
+            timeline = new
+            {
+                playbackHandleId = "play",
+                frameRate = 60,
+                durationFrames = 60,
+                tracks = new[] { new { handleId = "c2121d4d69544d4d8a584d392dfedbe6", property = "radius", blendMode = "Replace",
+                keys = new[] { new { frame = 0, value = 32f }, new { frame = 10, value = 34.3f } } } },
+                events = new[] { new { frame = 8, type = BuiltinEntryIds.ShowLayer, editorId = "create", parameters = new { transform = new { }, z = 0, opacity = 1, displayMode = "Native", handleId = "new-layer" } } }
+            }
+        });
+        Dictionary<string, List<EditorEntryData>> groups = new() { ["g"] = [effect, unrelated, clip] };
+        var analysis = new SceneTargetAnalysis(Graph("g"), groups, programs: new Dictionary<string, ShaderEffectDescriptor?> { ["blur"] = descriptor, ["missing"] = null });
+        var before = analysis.AtTimeline("g", "clip", new(0));
+        Assert.That(before.Complete, Is.False, "The overall query still reports the unrelated metadata gap.");
+        Assert.That(SceneReferenceAnalysis.Diagnose(new(groups), analysis).Where(issue => issue.JsonPointer == "/parameters/timeline/tracks/0/handleId"), Is.Empty);
+
+        // The same target's missing shader capabilities must still warn.
+        analysis = new(Graph("g"), groups, programs: new Dictionary<string, ShaderEffectDescriptor?> { ["blur"] = null });
+        Assert.That(SceneReferenceAnalysis.Diagnose(new(groups), analysis).Single(issue => issue.JsonPointer == "/parameters/timeline/tracks/0/handleId").Code,
+            Is.EqualTo("scene.reference.uncertain"));
+        groups["g"] = [unrelated, clip];
+        Assert.That(SceneReferenceAnalysis.Diagnose(new(groups), new(Graph("g"), groups)).Single(issue => issue.JsonPointer == "/parameters/timeline/tracks/0/handleId").Code,
+            Is.EqualTo("scene.reference.missing"));
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/SceneTargetCacheTests.cs b/test/GalNet.Editor.Shared.Tests/SceneTargetCacheTests.cs
new file mode 100644
index 00000000..50564068
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/SceneTargetCacheTests.cs
@@ -0,0 +1,56 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Services;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class SceneTargetAnalysisTests
+{
+    [Test]
+    public void ReusingAnAnalysisWithNewResourceDeclarationsCannotReuseOldCapabilities()
+    {
+        Dictionary<string, List<EditorEntryData>> groups = new() { ["g"] = [Entry("fx", BuiltinEntryIds.ApplyEffect, new { instanceId = "fx", program = "program" })] };
+        var previous = new SceneTargetAnalysis(Graph("g"), groups, programs: new Dictionary<string, GalNet.Contracts.Builtins.Scene.ShaderEffectDescriptor?> { ["program"] = EffectDescriptor() });
+        Assert.That(previous.Before("g", null).Complete, Is.True);
+        var next = new SceneTargetAnalysis(Graph("g"), groups, programs: new Dictionary<string, GalNet.Contracts.Builtins.Scene.ShaderEffectDescriptor?> { ["program"] = null }, previousAnalysis: previous);
+        Assert.That(next.Before("g", null).Complete, Is.False);
+        Assert.That(next.Before("g", null).Targets.Single().Properties.Select(property => property.Name), Is.EqualTo(new[] { "progress" }));
+        Assert.That(next.ReusedGroupCount, Is.Zero);
+    }
+
+    [Test]
+    public void PrefixCheckpointsAreBoundedReuseUnchangedGroupsAndMatchFreshAnalysis()
+    {
+        var graph = Graph("root", "a", "b", "merge"); Edge(graph, "root", "a"); Edge(graph, "root", "b"); Edge(graph, "a", "merge"); Edge(graph, "b", "merge");
+        Dictionary<string, List<EditorEntryData>> groups = new()
+        {
+            ["root"] = [Layer("origin", "layer")],
+            ["a"] = Enumerable.Range(0, 2000).Select(index => Entry("a" + index, BuiltinEntryIds.Wait, new { })).ToList(),
+            ["b"] = Enumerable.Range(0, 2000).Select(index => Entry("b" + index, BuiltinEntryIds.Wait, new { })).ToList(),
+            ["merge"] = []
+        };
+        var original = new SceneTargetAnalysis(graph, groups);
+        var transferred = original.EntryTransferCount;
+        original.Before("a", "a1999"); var firstRead = original.EntryTransferCount;
+        for (var index = 0; index < 100; index++) original.Before("a", "a1999");
+        Assert.That(original.EntryTransferCount, Is.EqualTo(firstRead));
+        Assert.That(firstRead - transferred, Is.LessThan(64));
+        var edited = JsonSerializer.Deserialize<List<EditorEntryData>>(JsonSerializer.Serialize(groups["a"]))!;
+        edited[1990].Condition = "false";
+        var next = groups.ToDictionary(pair => pair.Key, pair => pair.Value); next["a"] = edited;
+        var incremental = new SceneTargetAnalysis(graph, next, previousAnalysis: original);
+        var fresh = new SceneTargetAnalysis(graph, next);
+        Assert.That(incremental.ReusedGroupCount, Is.GreaterThanOrEqualTo(3));
+        Assert.That(incremental.EntryTransferCount, Is.LessThan(64));
+        foreach (var group in groups.Keys)
+            Assert.That(SceneTargetAnalysis.Equivalent(incremental.Before(group, null), fresh.Before(group, null)), Is.True);
+        for (var index = 0; index < 2000; index++) incremental.Before("a", "a" + index);
+        Assert.That(incremental.CheckpointCount, Is.LessThanOrEqualTo(128));
+        Edge(graph, "merge", "a");
+        incremental = new(graph, next, previousAnalysis: incremental); fresh = new(graph, next);
+        Assert.That(SceneTargetAnalysis.Equivalent(incremental.Before("a", null), fresh.Before("a", null)), Is.True);
+        var exhausted = new SceneTargetAnalysis(graph, next, 1, previousAnalysis: incremental);
+        Assert.That(exhausted.Before("a", null).Complete, Is.False);
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/SceneTargetTimelineTests.cs b/test/GalNet.Editor.Shared.Tests/SceneTargetTimelineTests.cs
index b33df975..ef4e96ab 100644
--- a/test/GalNet.Editor.Shared.Tests/SceneTargetTimelineTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/SceneTargetTimelineTests.cs
@@ -1,6 +1,6 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Shared.Services;
 
diff --git a/test/GalNet.Editor.Shared.Tests/SceneTargetVariantsTests.cs b/test/GalNet.Editor.Shared.Tests/SceneTargetVariantsTests.cs
index 8928822a..7fd28906 100644
--- a/test/GalNet.Editor.Shared.Tests/SceneTargetVariantsTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/SceneTargetVariantsTests.cs
@@ -1,6 +1,6 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Variants;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Shared.Services;
 
diff --git a/test/GalNet.Editor.Shared.Tests/StoryResourceCompilerTests.cs b/test/GalNet.Editor.Shared.Tests/StoryResourceCompilerTests.cs
new file mode 100644
index 00000000..5eff6bbf
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/StoryResourceCompilerTests.cs
@@ -0,0 +1,55 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Entry;
+using GalNet.Core.Serialization;
+using GalNet.Editor.Shared.Services;
+
+namespace GalNet.Editor.Shared.Tests;
+
+public sealed class StoryResourceCompilerTests
+{
+    [Test]
+    public void PrimitiveResourceReferencesComeFromExplicitSchemaRatherThanStringShape()
+    {
+        var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+        var group = new CompiledGroupDocument
+        {
+            Entries = [new() { Id = "show", TypeId = "layer.show",
+            Arguments = JsonSerializer.SerializeToElement(new { handleId = "not-a-resource", assetId = "hero", z = 0, opacity = 1 }) }]
+        };
+        var result = StoryResourceCompiler.Dependencies(group, catalog);
+        Assert.That(result.Complete, Is.True);
+        Assert.That(result.Direct.Select(item => (item.AssetId, item.ExpectedTypeId)), Is.EqualTo(new[] { ("hero", "sprite") }));
+    }
+
+    [Test]
+    public void BuiltinNestedParticleAndTimelineResourcesAreCollected()
+    {
+        var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+        var result = StoryResourceCompiler.Dependencies(new()
+        {
+            Entries = [new() { Id = "particles", TypeId = "particle.play",
+            Arguments = JsonSerializer.SerializeToElement(new { parameters = new { particleTexture = "snow", motion = new { gravityY = 12 } } }) },
+            new() { Id = "timeline", TypeId = "timeline.play", Arguments = JsonSerializer.SerializeToElement(new { timeline = new {
+                durationFrames = 1, events = new[] { new { frame = 0, type = "layer.show", parameters = new { assetId = "hero" } } }
+            } }) }]
+        }, catalog);
+        Assert.That(result.Complete, Is.True);
+        Assert.That(result.Direct.Select(reference => reference.AssetId), Is.EquivalentTo(new[] { "snow", "hero" }));
+    }
+
+    [Test]
+    public void UnknownInstructionAndCustomInvocationCannotPretendToHaveNoDependencies()
+    {
+        var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+        foreach (var type in new[] { "unknown.command", "custom.invoke" })
+        {
+            var result = StoryResourceCompiler.Dependencies(new()
+            {
+                Entries = [new() { Id = "entry", TypeId = type,
+                Arguments = JsonSerializer.SerializeToElement(new { action = "project", payload = "not-a-resource" }) }]
+            }, catalog);
+            Assert.That(result.Complete, Is.False);
+        }
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/TargetProfileEditorCommandTests.cs b/test/GalNet.Editor.Shared.Tests/TargetProfileEditorCommandTests.cs
index c4255e61..2a8aec5f 100644
--- a/test/GalNet.Editor.Shared.Tests/TargetProfileEditorCommandTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/TargetProfileEditorCommandTests.cs
@@ -8,6 +8,42 @@ namespace GeneralTest.Editor;
 
 public class TargetProfileEditorCommandTests
 {
+    [TestCase("Choice"), TestCase("Condition")]
+    public void EmptyBranchCannotConnectThroughAPhantomOutlet(string kind)
+    {
+        var document = new EditorProjectDocument
+        {
+            Graph = new()
+            {
+                Nodes =
+            [new() { Id = "branch", Type = "Branch", BranchType = kind, Options = [], Conditions = [] }, new() { Id = "target", Type = "Group" }]
+            }
+        };
+        var handler = new BuiltInEditorCommandHandler(new TargetProfileEntryCatalog([]));
+        var result = handler.Execute(document, new ConnectNodesCommand("branch", 0, "target"), new(0, false));
+        Assert.That(result.Success, Is.False);
+        Assert.That(result.Diagnostics.Single().Code, Is.EqualTo("graph.edge.invalidOutlet"));
+        Assert.That(document.Graph.Edges, Is.Empty);
+    }
+
+    [Test]
+    public void DuplicateEdgeIdentityDoesNotRemoveTheExistingOutputConnection()
+    {
+        var old = new EditorGraphEdgeDto { Id = "old", FromNodeId = "a", ToNodeId = "b" };
+        var other = new EditorGraphEdgeDto { Id = "taken", FromNodeId = "b", ToNodeId = "c" };
+        var document = new EditorProjectDocument
+        {
+            Graph = new()
+            {
+                Nodes = [new() { Id = "a", Type = "Group" }, new() { Id = "b", Type = "Group" }, new() { Id = "c", Type = "Group" }],
+                Edges = [old, other]
+            }
+        };
+        var handler = new BuiltInEditorCommandHandler(new TargetProfileEntryCatalog([]));
+        Assert.That(handler.Execute(document, new ConnectNodesCommand("a", 0, "c", "taken"), new(0, false)).Success, Is.False);
+        Assert.That(document.Graph.Edges, Is.EqualTo(new[] { old, other }));
+    }
+
     [Test]
     public void ConnectingAnotherPredecessorPreservesConvergenceAndReplacesOnlyItsOutput()
     {
diff --git a/test/GalNet.Editor.Shared.Tests/TimelineParameterLocalizationTests.cs b/test/GalNet.Editor.Shared.Tests/TimelineParameterLocalizationTests.cs
new file mode 100644
index 00000000..ecd4e946
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/TimelineParameterLocalizationTests.cs
@@ -0,0 +1,99 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Entry;
+using GalNet.Core.Parameters;
+using GalNet.Core.Primitives;
+using GalNet.Editor.Shared.Services;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class EffectParameterLocalizationTests
+{
+    private static JsonElement UserTimeline() => JsonSerializer.Deserialize<JsonElement>("""
+        {
+          "playbackHandleId":"25f2011d83274f93a67024b0028f3e4d", "frameRate":60, "durationFrames":60,
+          "tracks":[{"handleId":"c2121d4d69544d4d8a584d392dfedbe6","property":"radius","blendMode":"Replace",
+            "keys":[{"frame":0,"value":32,"interpolationToNext":"Linear"},
+                    {"frame":10,"value":34.3,"inTangent":0,"outTangent":0,"interpolationToNext":"Linear"}]}],
+          "events":[{"frame":8,"type":"layer.show","editorId":"dc1ce9a65c694a589651cc1f16d3411d",
+            "parameters":{"transform":{},"z":0,"opacity":1,"displayMode":"Native","handleId":"fcef9d991e18436e96e96f97be479092"}}]
+        }
+        """);
+
+    [Test]
+    public void UserTimelineTraversesTracksKeysAndEventContractWithoutInventingReferencesOrMutatingJson()
+    {
+        var entry = Entry("clip", BuiltinEntryIds.PlayTimeline, new { timeline = UserTimeline() });
+        var document = Document(entry); var before = JsonSerializer.Serialize(document);
+        var index = Scan(document);
+        Assert.That(index.Issues, Is.Empty);
+        Assert.That(index.Complete, Is.True);
+        Assert.That(index.References, Is.Empty);
+        Assert.That(JsonSerializer.Serialize(document), Is.EqualTo(before));
+    }
+
+    [Test]
+    public void TimelineAuthorMetadataAndCaseInsensitiveWireNamesRemainCoveredWhileUnknownMembersAreDiagnosed()
+    {
+        var entry = Entry("clip", BuiltinEntryIds.PlayTimeline, new
+        {
+            timeline = new
+            {
+                FrameRate = 60,
+                DurationFrames = 30,
+                LoopMode = "Loop",
+                Tracks = new[] { new { HandleId = "fx", Property = "radius", BlendMode = "Additive", Keys = new[] {
+                new { Frame = 0, Value = 0, InterpolationToNext = "CubicHermite", EditorTangents = new { Incoming = "Auto", Outgoing = "Free", Linked = true } } } } },
+                Events = new[] { new { Frame = 0, Execution = "Once", Type = BuiltinEntryIds.ShowLayer, EditorId = "event", Parameters = new { handleId = "layer", transform = new { X = 12 } } } }
+            }
+        });
+        Assert.That(Scan(Document(entry)).Issues, Is.Empty);
+        entry.Parameters["timeline"] = JsonSerializer.Deserialize<JsonElement>("""{"tracks":[{"handleId":"fx","keys":[{"frame":0,"value":"bad","extension":{"x":1}}]}]}""");
+        var issues = Scan(Document(entry)).Issues;
+        Assert.That(issues.Select(issue => (issue.Code, issue.JsonPointer)), Is.EquivalentTo(new[] {
+            ("value.type", "/timeline/tracks/0/keys/0/value"), ("field.unknown", "/timeline/tracks/0/keys/0/extension") }));
+    }
+
+    [Test]
+    public void TimelineEffectEventsDiscoverTheirProgramAndReuseItsParameterSchema()
+    {
+        var shader = new ShaderEffectDescriptor(new("nested"), 1, "source", new HashSet<EffectStage> { EffectStage.ScenePost },
+            [new("radius", "radius", ShaderEffectParameterKind.Float)]);
+        var entry = Entry("clip", BuiltinEntryIds.PlayTimeline, new
+        {
+            timeline = new
+            {
+                tracks = Array.Empty<object>(),
+                events = new[] {
+            new { frame = 0, type = BuiltinEntryIds.ApplyEffect, parameters = new { program = "nested", instanceId = "fx", parameters = new { radius = 32, angle = 0, unused = new { text = "literal" } } } } }
+            }
+        });
+        var document = Document(entry);
+        Assert.That(EntryParameterMetadata.ProgramIds(document), Is.EqualTo(new[] { "nested" }));
+        Assert.That(Scan(document, new(Programs: new Dictionary<string, ShaderEffectDescriptor?> { ["nested"] = shader })).Issues, Is.Empty);
+        var issue = Scan(document).Issues.Single();
+        Assert.That(issue.Code, Is.EqualTo("field.opaque"));
+        Assert.That(issue.JsonPointer, Is.EqualTo("/timeline/events/0/parameters/parameters"));
+    }
+
+    [Test]
+    public void TimelineEventPayloadUsesTheProjectCatalogAndPreservesItsLocalizationSemantics()
+    {
+        var payload = new FieldDescriptor("caption", new(typeof(string)), semantic: FieldValueSemantic.LocalizedText);
+        var catalog = new TargetProfileEntryCatalog([new DefaultEntryModule("custom", [
+            DefaultPrimitiveEntryBase.ForDto<TimelineOptions>(BuiltinEntryIds.PlayTimeline),
+            new DefaultPrimitiveEntryBase(BuiltinEntryIds.ApplyEffect, new DynamicParameterTable([new(payload)]))])]);
+        var document = Document(Entry("clip", BuiltinEntryIds.PlayTimeline, new
+        {
+            timeline = new
+            {
+                events = new[] {
+            new { frame = 0, type = BuiltinEntryIds.ApplyEffect, parameters = new { caption = "line" } } }
+            }
+        }));
+        var index = new LocalizationReferenceIndex(document, catalog, [new("I18n/zh-CN/test.json", """{"line":"正文"}""")]);
+        Assert.That(index.References.Single().JsonPointer, Is.EqualTo("/timeline/events/0/parameters/caption"));
+        Assert.That(index.Issues, Is.Empty);
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/ToolOperationCatalogTests.cs b/test/GalNet.Editor.Shared.Tests/ToolOperationCatalogTests.cs
index be9d3633..66df41a7 100644
--- a/test/GalNet.Editor.Shared.Tests/ToolOperationCatalogTests.cs
+++ b/test/GalNet.Editor.Shared.Tests/ToolOperationCatalogTests.cs
@@ -63,6 +63,18 @@ public void UnknownOrConflictingArguments_FailBeforeProjectLoading(string comman
         Assert.Throws<ArgumentException>(() => CliInvocation.Parse(new ToolOperationCatalog(), command.Split(' ')));
     }
 
+    [Test]
+    public void InstalledGameInspection_IsReadOnlyAndRequiresNoAuthoringContract()
+    {
+        var catalog = new ToolOperationCatalog();
+        var invocation = CliInvocation.Parse(catalog, ["game", "inspect", "app/pak"]);
+        var definition = catalog.Find("game.inspect")!;
+        Assert.That(definition.ReadOnly, Is.True);
+        Assert.That(definition.RequiresProject, Is.False);
+        Assert.That(definition.RequiresContract, Is.False);
+        Assert.That(invocation.Positionals, Is.EqualTo(new[] { "app/pak" }));
+    }
+
     [Test]
     public void FileDryRun_IsNotAdvertised_AndUnknownHelpTargetFails()
     {
diff --git a/test/GalNet.Editor.Shared.Tests/VisualPresetAuthoringTests.cs b/test/GalNet.Editor.Shared.Tests/VisualPresetAuthoringTests.cs
new file mode 100644
index 00000000..c6346d4d
--- /dev/null
+++ b/test/GalNet.Editor.Shared.Tests/VisualPresetAuthoringTests.cs
@@ -0,0 +1,109 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Compilation;
+using GalNet.Core.Entry;
+using GalNet.Core.Serialization;
+using GalNet.Editor.Abstraction.Commands;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.Shared.Visuals;
+
+namespace GalNet.Editor.Shared.Tests;
+
+public sealed class VisualPresetAuthoringTests
+{
+    private static Dictionary<string, JsonElement> Parameters(object value) => JsonSerializer.SerializeToElement(value).EnumerateObject().ToDictionary(p => p.Name, p => p.Value.Clone());
+
+    [Test]
+    public void Default_fill_is_a_saved_explicit_reference_and_does_not_replace_author_selection()
+    {
+        var configuration = new DefaultProjectOptions { DefaultVisualPrograms = new() { ["speedLines"] = "initial", ["maskReveal"] = "mask-program" } }.ToConfiguration();
+        var parameters = VisualPresetBindings.Fill(BuiltinEntryIds.SpeedLinesPreset, new(), configuration);
+        Assert.That(parameters["program"].GetString(), Is.EqualTo("initial"));
+        configuration.Set(DefaultProjectConfiguration.Section, new DefaultProjectOptions { DefaultVisualPrograms = new() { ["speedLines"] = "changed" } });
+        Assert.That(parameters["program"].GetString(), Is.EqualTo("initial"));
+        Assert.That(VisualPresetBindings.Fill(BuiltinEntryIds.SpeedLinesPreset, parameters, configuration)["program"].GetString(), Is.EqualTo("initial"));
+        Assert.That(VisualPresetBindings.Fill(BuiltinEntryIds.BlurTransition, new(), configuration), Is.Empty);
+    }
+
+    [Test]
+    public void Shake_target_is_indexed_and_remapped_with_copied_layer()
+    {
+        var layer = new EditorEntryData { StableId = "layer", Type = BuiltinEntryIds.ShowColorLayer, Parameters = Parameters(new { handleId = "hero", color = "#FFFFFF" }) };
+        var shake = new EditorEntryData { StableId = "shake", Type = BuiltinEntryIds.ShakePreset, Parameters = Parameters(new { playbackHandleId = "quake", handleId = "hero" }) };
+        var index = new SceneReferenceIndex(new Dictionary<string, List<EditorEntryData>> { ["g"] = [layer, shake] });
+        Assert.That(index.Complete, Is.True);
+        Assert.That(index.References.Single().JsonPointer, Is.EqualTo("/parameters/handleId"));
+        SceneAuthoringIdentities.RemapCopy([layer, shake]);
+        Assert.That(shake.Parameters["handleId"].GetString(), Is.EqualTo(layer.Parameters["handleId"].GetString()));
+        Assert.That(layer.Parameters["handleId"].GetString(), Is.Not.EqualTo("hero"));
+    }
+
+    [Test]
+    public void Generated_visual_helpers_do_not_leak_into_terminal_scene_analysis()
+    {
+        var graph = new EditorGraphDocument { RootNodeId = "g", Nodes = [new() { Id = "g", Type = "Group" }] };
+        var layer = new EditorEntryData { StableId = "hero", Type = BuiltinEntryIds.ShowColorLayer, Parameters = Parameters(new { handleId = "hero", color = "#FFFFFF" }) };
+        var impact = new EditorEntryData { StableId = "impact", Type = BuiltinEntryIds.ImpactPreset, Parameters = Parameters(new { playbackHandleId = "impact-play", program = "shader", handleId = "hero" }) };
+        var analysis = new SceneTargetAnalysis(graph, new Dictionary<string, List<EditorEntryData>> { ["g"] = [layer, impact] });
+        var result = analysis.Before("g", null);
+        Assert.That(result.Complete, Is.True);
+        Assert.That(result.Targets.Select(target => target.Handle), Is.EqualTo(new[] { "hero" }));
+    }
+
+    [Test]
+    public void Sustained_presets_are_selectable_by_their_authored_playback_slot()
+    {
+        var graph = new EditorGraphDocument { RootNodeId = "g", Nodes = [new() { Id = "g", Type = "Group" }] };
+        var layer = new EditorEntryData { StableId = "hero", Type = BuiltinEntryIds.ShowColorLayer, Parameters = Parameters(new { handleId = "hero", color = "#FFFFFF" }) };
+        var shake = new EditorEntryData
+        {
+            StableId = "shake",
+            Type = BuiltinEntryIds.ShakePreset,
+            Parameters = Parameters(new
+            { playbackHandleId = "quake", handleId = "hero", playbackMode = "UntilStopped" })
+        };
+        var stop = new EditorEntryData { StableId = "stop", Type = BuiltinEntryIds.StopAnimation, Parameters = Parameters(new { playbackHandleId = "quake", mode = "CompleteImmediately" }) };
+        var analysis = new SceneTargetAnalysis(graph, new Dictionary<string, List<EditorEntryData>> { ["g"] = [layer, shake, stop] });
+        var candidate = analysis.Before("g", "stop").Playbacks.Single();
+        Assert.That(candidate.Handle, Is.EqualTo("quake"));
+        Assert.That(candidate.Locator.Slot, Is.EqualTo("playbackHandleId"));
+        Assert.That(candidate.Locator.EntryId, Is.EqualTo("shake"));
+        Assert.That(candidate.Resource, Is.EqualTo(BuiltinEntryIds.ShakePreset));
+        Assert.That(analysis.Before("g", null).Playbacks, Is.Empty);
+    }
+
+    [Test]
+    public void Project_validation_checks_shader_contract_and_missing_resource_without_hidden_fallback()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "GalNet-preset-" + Guid.NewGuid());
+        Directory.CreateDirectory(root);
+        try
+        {
+            var plan = DefaultVisualTemplate.Prepare(new DefaultProjectOptions().ToConfiguration());
+            foreach (var (file, bytes) in plan.Files)
+            {
+                var path = Path.Combine(root, file); Directory.CreateDirectory(Path.GetDirectoryName(path)!); File.WriteAllBytes(path, bytes);
+            }
+            var program = plan.Configuration.ReadDefaultOptions().DefaultVisualPrograms["speedLines"];
+            var document = new GroupDocument { Entries = [new() { Id = "lines", Type = BuiltinEntryIds.SpeedLinesPreset, Parameters = Parameters(new { playbackHandleId = "lines-play", program }) }] };
+            var groupFile = Path.Combine(root, "sample.rawgalgroup");
+            File.WriteAllText(groupFile, JsonSerializer.Serialize(document));
+            var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+            var diagnostics = new List<ToolDiagnostic>();
+            Assert.That(new ProjectValidationService(root).ValidateGroup("sample.rawgalgroup", diagnostics, catalog), Is.Not.Null, JsonSerializer.Serialize(diagnostics));
+            var compiled = GalgroupCompiler.Compile(document, catalog).Document.Entries.Single();
+            Assert.That(compiled.Arguments.GetRawText(), Does.Contain(program));
+            File.WriteAllText(Path.Combine(root, "Assets/Effects/Default/SpeedLines.sksl"), DefaultVisualTemplate.ReadShader("Vignette"));
+            diagnostics.Clear();
+            Assert.That(new ProjectValidationService(root).ValidateGroup("sample.rawgalgroup", diagnostics, catalog), Is.Null);
+            Assert.That(diagnostics.Single().Code, Is.EqualTo("visual.programInvalid"));
+            Assert.That(diagnostics.Single().Message, Does.Contain("time"));
+            File.Delete(Path.Combine(root, "Assets/Effects/Default/SpeedLines.sksl"));
+            diagnostics.Clear();
+            Assert.That(new ProjectValidationService(root).ValidateGroup("sample.rawgalgroup", diagnostics, catalog), Is.Null);
+            Assert.That(diagnostics.Single().Message, Does.Contain("missing"));
+        }
+        finally { Directory.Delete(root, true); }
+    }
+}
diff --git a/test/GalNet.Editor.Shared.Tests/packages.lock.json b/test/GalNet.Editor.Shared.Tests/packages.lock.json
index 1ce15904..21d2bba4 100644
--- a/test/GalNet.Editor.Shared.Tests/packages.lock.json
+++ b/test/GalNet.Editor.Shared.Tests/packages.lock.json
@@ -119,6 +119,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -159,6 +160,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -176,7 +178,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/test/GalNet.Editor.Tests/AudioCompletionEditorTests.cs b/test/GalNet.Editor.Tests/AudioCompletionEditorTests.cs
new file mode 100644
index 00000000..20259332
--- /dev/null
+++ b/test/GalNet.Editor.Tests/AudioCompletionEditorTests.cs
@@ -0,0 +1,51 @@
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.VisualTree;
+using GalNet.Contracts.Builtins;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Controls;
+using GalNet.Editor.History;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.ViewModels;
+using GalNet.Game.Controls.Forms;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task AudioRepeatAndCompletionUseNumericAndChoiceInputsWithProjectUndo()
+    {
+        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "AudioCompletion"), "Audio", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.PlayAudio).Single();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(project.Services, group.Id);
+            var view = new EntryListEditorControl { DataContext = page };
+            var window = new Window { Content = view, Width = 1000, Height = 1000 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
+                var count = NumericControlTestSupport.FieldInput(view, "loopCount");
+                Assert.That(count.Text, Is.EqualTo("1"));
+                count.Text = "0"; PressGroupKey(count, Key.Enter); TimelinePump(window);
+                Assert.That(entry.Source.Parameters["loopCount"].GetInt32(), Is.Zero);
+                var completion = view.GetVisualDescendants().OfType<ComboBox>().Single(input => input.DataContext is FieldEditorContext { Field.Id: "completion" });
+                completion.SelectedItem = completion.Items.Cast<FieldEditorOption>().Single(option => option.Value.GetString() == "requeueTail"); TimelinePump(window);
+                Assert.That(entry.Source.Parameters["completion"].GetString(), Is.EqualTo("requeueTail"));
+                await history.UndoAsync(); Assert.That(entry.Source.Parameters["completion"].GetString(), Is.EqualTo("discard"));
+                await history.UndoAsync(); Assert.That(entry.Source.Parameters["loopCount"].GetInt32(), Is.EqualTo(1));
+                await history.RedoAsync(); await history.RedoAsync();
+                Assert.That(entry.Source.Parameters["completion"].GetString(), Is.EqualTo("requeueTail"));
+            }
+            finally { window.Close(); page.Dispose(); await projects.CloseAsync(); }
+            return true;
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/AudioEffectFieldTests.cs b/test/GalNet.Editor.Tests/AudioEffectFieldTests.cs
new file mode 100644
index 00000000..4e3eeb65
--- /dev/null
+++ b/test/GalNet.Editor.Tests/AudioEffectFieldTests.cs
@@ -0,0 +1,136 @@
+using System.Text.Json;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.Markup.Xaml.Styling;
+using Avalonia.VisualTree;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Game.Controls.Forms;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    private static async Task AudioSet(EntryEditorItemViewModel entry, string id, object value)
+    {
+        var form = entry.DetailForm!; var descriptor = form.Fields.Single(field => field.Id == id);
+        Assert.That(await form.Binding(descriptor).CommitAsync(new(JsonSerializer.SerializeToElement(value)), default), Is.Null);
+    }
+
+    [Test]
+    public async Task AudioEffectTypeAndNumericParametersAreMountedAndTypeChangeIsOneUndo()
+    {
+        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var defaults = BuiltinAudioDefaults.Create();
+            var project = await projects.CreateAsync(Path.Combine(_root, "EffectTypes"), "Audio", new DefaultProjectOptions
+            { AudioTracks = defaults.Tracks.ToList(), AudioBuses = defaults.Buses.ToList() }.ToConfiguration(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ApplyAudioSEffect).Single();
+            var identity = entry.Source.Parameters["instanceId"].GetString(); Assert.That(Guid.TryParse(identity, out _), Is.True);
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(project.Services, group.Id);
+            await AudioSet(entry, "targetId", "bgm");
+            var inspector = new DtoEditorHost { Item = entry.DetailForm!.Item, Registry = page.FieldEditors };
+            inspector.Styles.Add(new StyleInclude(new Uri("avares://GalNet.Editor/")) { Source = new Uri("avares://GalNet.Editor/Controls/AuthorFormStyles.axaml") });
+            var window = new Window { Content = inspector, Width = 900, Height = 1000 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
+                var input = inspector.GetVisualDescendants().OfType<ComboBox>().Single(control => control.Name == "AudioEffectTypeInput");
+                Assert.That(input.Items.Count, Is.EqualTo(4));
+                var reverb = input.Items.Cast<object>().Single(item => item.ToString() == project.Services.GetRequiredService<IEditorLocalizationService>()["Audio.Type.seffect.reverb"]);
+                input.SelectedItem = reverb; TimelinePump(window);
+                Assert.That(entry.Source.Parameters["id"].GetString(), Is.EqualTo("seffect.reverb"));
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("mix").GetSingle(), Is.EqualTo(.25f));
+                Assert.That(inspector.GetVisualDescendants().OfType<NumericUpDown>().Count(control => control.Name?.StartsWith("AudioParameter_") == true), Is.EqualTo(4));
+                Assert.That(inspector.GetVisualDescendants().OfType<FieldEditorRow>().Where(row => row.Context?.Field.Id == "instanceId").All(row => !row.IsEffectivelyVisible), Is.True);
+                await history.UndoAsync(); TimelinePump(window);
+                Assert.That(entry.Source.Parameters.GetValueOrDefault("id").ValueKind is JsonValueKind.Undefined or JsonValueKind.Null, Is.True);
+                Assert.That(entry.Source.Parameters["instanceId"].GetString(), Is.EqualTo(identity));
+                Assert.That(history.CanUndo, Is.False);
+                await history.RedoAsync(); TimelinePump(window); history.Clear();
+                var mix = NumericControlTestSupport.NamedInputs(inspector, "AudioParameter_mix").Single();
+                mix.Text = "0.4"; PressGroupKey(mix, Key.Enter); TimelinePump(window);
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("mix").GetSingle(), Is.EqualTo(.4f));
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("roomSize").GetSingle(), Is.EqualTo(.5f));
+                await history.UndoAsync(); TimelinePump(window);
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("mix").GetSingle(), Is.EqualTo(.25f));
+                mix = NumericControlTestSupport.NamedInputs(inspector, "AudioParameter_mix").Single();
+                mix.Text = "99"; PressGroupKey(mix, Key.Enter); TimelinePump(window);
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("mix").GetSingle(), Is.EqualTo(.25f));
+                var issue = ((FieldEditorContext)mix.DataContext!).Issue;
+                Assert.That(issue?.Code, Is.EqualTo("value.range"));
+                var explanation = ((FieldEditorContext)mix.DataContext!).IssueMessage;
+                Assert.That(explanation, Is.Not.EqualTo(issue!.Message));
+                Assert.That(inspector.GetVisualDescendants().OfType<TextBlock>().Any(text => text.IsEffectivelyVisible && text.Text == explanation), Is.True);
+            }
+            finally { window.Close(); await projects.CloseAsync(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task AudioStopAndUpdateUseOnlyPriorEffectsOnTheSelectedAttachment()
+    {
+        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var defaults = BuiltinAudioDefaults.Create();
+            var project = await projects.CreateAsync(Path.Combine(_root, "EffectTargets"), "Audio", new DefaultProjectOptions
+            { AudioTracks = defaults.Tracks.ToList(), AudioBuses = defaults.Buses.ToList() }.ToConfiguration(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var first = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ApplyAudioSEffect).Single();
+            var second = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.ApplyAudioSEffect).Single();
+            var bus = workspace.InsertEntriesInto(group, 2, 1, BuiltinEntryIds.ApplyAudioSEffect).Single();
+            var stop = workspace.InsertEntriesInto(group, 3, 1, BuiltinEntryIds.StopAudioSEffect).Single();
+            var update = workspace.InsertEntriesInto(group, 3, 1, BuiltinEntryIds.UpdateAudioSEffect).Single();
+            var future = workspace.InsertEntriesInto(group, group.Entries.Count, 1, BuiltinEntryIds.ApplyAudioSEffect).Single();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(project.Services, group.Id);
+            foreach (var entry in new[] { first, second, bus, future }) { await AudioSet(entry, "targetId", "bgm"); await AudioSet(entry, "id", "seffect.reverb"); }
+            await AudioSet(bus, "scope", "bus"); await AudioSet(stop, "targetId", "bgm"); await AudioSet(update, "targetId", "bgm");
+            var inspector = new DtoEditorHost { Item = stop.DetailForm!.Item, Registry = page.FieldEditors };
+            inspector.Styles.Add(new StyleInclude(new Uri("avares://GalNet.Editor/")) { Source = new Uri("avares://GalNet.Editor/Controls/AuthorFormStyles.axaml") });
+            var window = new Window { Content = inspector, Width = 900, Height = 1000 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var input = inspector.GetVisualDescendants().OfType<ComboBox>().Single(control => control.Name == "AudioEffectInstanceInput");
+                Assert.That(input.Items.Count, Is.EqualTo(3)); // Two Track effects plus the explicit all option.
+                Assert.That(input.Items.Cast<object>().Select(item => item.ToString()).Distinct().Count(), Is.EqualTo(3));
+                input.SelectedIndex = 1; TimelinePump(window);
+                Assert.That(new[] { first, second }.Select(entry => entry.Source.Parameters["instanceId"].GetString()), Does.Contain(stop.Source.Parameters["instanceId"].GetString()));
+                var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
+                input.SelectedIndex = 0; TimelinePump(window);
+                Assert.That(stop.Source.Parameters["all"].GetBoolean(), Is.True); Assert.That(stop.Source.Parameters.ContainsKey("instanceId"), Is.False);
+                await history.UndoAsync(); TimelinePump(window); Assert.That(stop.Source.Parameters["all"].GetBoolean(), Is.False);
+                inspector.Item = update.DetailForm!.Item; TimelinePump(window);
+                input = inspector.GetVisualDescendants().OfType<ComboBox>().Single(control => control.Name == "AudioEffectInstanceInput");
+                Assert.That(input.Items.Count, Is.EqualTo(2)); input.SelectedIndex = 0; TimelinePump(window);
+                Assert.That(inspector.GetVisualDescendants().OfType<NumericUpDown>().Count(control => control.Name?.StartsWith("AudioParameter_") == true), Is.EqualTo(4));
+                Assert.That(inspector.GetVisualDescendants().OfType<ComboBox>().Any(control => control.Name == "AudioEffectTypeInput"), Is.False);
+                var mix = NumericControlTestSupport.NamedInputs(inspector, "AudioParameter_mix").Single();
+                mix.Text = "0.6"; PressGroupKey(mix, Key.Enter); TimelinePump(window);
+                Assert.That(update.Source.Parameters["parameters"].EnumerateObject().Select(property => property.Name), Is.EqualTo(new[] { "mix" }));
+                var catalog = project.Services.GetRequiredService<SceneTargetCatalog>();
+                var snapshot = catalog.QueryAudio(group.Id, update.StableId);
+                Assert.That(catalog.IsCurrent(snapshot), Is.True);
+                await AudioSet(first, "id", "seffect.gain");
+                Assert.That(catalog.IsCurrent(snapshot), Is.False);
+                await history.UndoAsync();
+                Assert.That(catalog.IsCurrent(snapshot), Is.False, "Undo must not revive the old selection lease.");
+
+            }
+            finally { window.Close(); await projects.CloseAsync(); }
+            return true;
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/AuthorChangeTransactionTests.cs b/test/GalNet.Editor.Tests/AuthorChangeTransactionTests.cs
new file mode 100644
index 00000000..91a460e5
--- /dev/null
+++ b/test/GalNet.Editor.Tests/AuthorChangeTransactionTests.cs
@@ -0,0 +1,152 @@
+using System.Text.Json;
+using Avalonia.Headless;
+using Avalonia.Threading;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Entry;
+using GalNet.Core.Primitives;
+using GalNet.Editor.Abstraction.Changes;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.History;
+using GalNet.Editor.Services;
+using GalNet.Editor.Shared.Services;
+
+namespace GeneralTest.Editor;
+
+public sealed class AuthorChangeTransactionTests
+{
+    [Test]
+    public async Task SceneQueryPublishesDeletedAndRestoredTargetsAfterCommittedEdits()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var histories = new EditorHistories(); var documents = new EditorDocumentService();
+            documents.Load(new() { Document = new() { RootNodeId = "g", Nodes = [new() { Id = "g", Type = "Group" }] }, GroupEntries = { ["g"] = [] } });
+            var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+            var fields = new EntryFieldAuthoringService(documents, histories);
+            using var projections = new EditorGroupProjectionStore(documents, catalog, fields);
+            using var query = new ProjectSceneTargets(documents, histories: histories);
+            var batches = new GroupEntryAuthoringService(documents, catalog, histories);
+            var creatorId = batches.Insert("g", 0, 1, BuiltinEntryIds.ShowLayer).Single();
+            var creator = projections.Get("g").Entries.Single(entry => entry.StableId == creatorId);
+            var consumerId = batches.Insert("g", 1, 1, BuiltinEntryIds.HideLayer).Single();
+            var consumer = projections.Get("g").Entries.Single(entry => entry.StableId == consumerId);
+            Dispatcher.UIThread.RunJobs();
+            var counts = new List<int>();
+            query.Changed += () => counts.Add(query.Before("g", consumer.StableId).Targets.Count);
+            batches.Delete("g", [creator.StableId]); Dispatcher.UIThread.RunJobs();
+            await histories.Content.UndoAsync(); Dispatcher.UIThread.RunJobs();
+            histories.Content.MarkSaved(); Dispatcher.UIThread.RunJobs();
+            Assert.That(counts, Is.EqualTo(new[] { 0, 1 }), "Content commits notify without requiring a resource refresh; saving does not masquerade as an edit.");
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task EntryChangesPublishOnceWithFinalAuthorStateAndNewHistoryCursor()
+    {
+        using var histories = new EditorHistories(); var documents = new EditorDocumentService();
+        var catalog = new TargetProfileEntryCatalog([new DefaultEntryModule("custom", [new DefaultPrimitiveEntryBase("custom.value", new DynamicParameterTable([]))])]);
+        documents.Load(new() { Document = new() { Nodes = [new() { Id = "g", Type = "Group", File = "groups/g.rawgalgroup" }] }, GroupEntries = { ["g"] = [] } });
+        var fields = new EntryFieldAuthoringService(documents, histories);
+        using var projections = new EditorGroupProjectionStore(documents, catalog, fields);
+        var group = projections.Get("g"); var batches = new GroupEntryAuthoringService(documents, catalog, histories);
+        var observed = new List<(AuthorChangeSet Change, int Count, bool Busy, bool Undo, bool Redo)>();
+        histories.Content.AuthorChanges.Committed += change => observed.Add((change, documents.Groups["g"].Entries.Count, histories.Content.IsBusy, histories.Content.CanUndo, histories.Content.CanRedo));
+        var addedIds = batches.Insert("g", 0, 3, "custom.value");
+        var added = group.Entries.Where(entry => addedIds.Contains(entry.StableId)).ToArray();
+        Assert.That(added, Has.Length.EqualTo(3)); Assert.That(group.Entries.Select(entry => entry.Source), Is.EqualTo(documents.Groups["g"].Entries));
+        fields.SetCondition("g", added[1].Source, "true");
+        fields.SetCondition("g", added[1].Source, "true"); // No-op is not a transaction.
+        histories.Content.MarkSaved(); histories.Clear();
+        await histories.Content.UndoAsync(); await histories.Content.RedoAsync();
+        Assert.That(observed, Has.Count.EqualTo(2), "History status and empty Undo/Redo do not publish content changes.");
+        batches.Delete("g", [added[0].StableId, added[2].StableId]);
+        await histories.Content.UndoAsync(); await histories.Content.RedoAsync();
+        Assert.That(observed.Select(item => item.Change.Revision), Is.EqualTo(new long[] { 1, 2, 3, 4, 5 }));
+        Assert.That(observed.Select(item => item.Change.Cause), Is.EqualTo(new[] { AuthorChangeCause.Execute, AuthorChangeCause.Execute, AuthorChangeCause.Execute, AuthorChangeCause.Undo, AuthorChangeCause.Redo }));
+        Assert.That(observed.Select(item => item.Count), Is.EqualTo(new[] { 3, 3, 1, 3, 1 }));
+        Assert.That(observed.All(item => !item.Busy), Is.True); Assert.That(observed[3].Redo, Is.True); Assert.That(observed[4].Undo, Is.True);
+        Assert.That(observed.All(item => !item.Change.UnknownScope), Is.True);
+        Assert.That(observed[0].Change.Groups.Single().Kind, Is.EqualTo(GroupChangeKind.Membership));
+        Assert.That(observed[1].Change.Groups.Single().Kind, Is.EqualTo(GroupChangeKind.Condition));
+        Assert.That(observed[1].Change.Groups.Single().FirstIndex, Is.EqualTo(1));
+        Assert.That(observed[2].Change.Groups.Single().EntryIds, Is.EquivalentTo(new[] { added[0].StableId, added[2].StableId }));
+    }
+
+    [Test]
+    public async Task CompositeFailureDiscardsAllRecordedChangesButKeepsCompensationRules()
+    {
+        using var history = new UndoRedoHistory(); var value = 0; var notifications = 0;
+        history.AuthorChanges.Committed += _ => notifications++;
+        var change = new RecordingEdit(history, () => value = 1, () => value = 0);
+        var failure = new DelegateEdit("fail", () => { }, () => throw new IOException("domain write failed"));
+        Assert.Throws<IOException>(() => history.Execute(new CompositeEdit("atomic", [change, failure])));
+        Assert.That(value, Is.Zero); Assert.That(history.CanUndo, Is.False); Assert.That(history.AuthorChanges.Revision, Is.Zero); Assert.That(notifications, Is.Zero);
+        Assert.ThrowsAsync<IOException>(async () => await history.ExecuteAsync(new AsyncCompositeEdit("atomic", [new AsyncEditAdapter(change), new AsyncEditAdapter(failure)])));
+        Assert.That(value, Is.Zero); Assert.That(history.AuthorChanges.Revision, Is.Zero);
+        history.Execute(change); Assert.That(notifications, Is.EqualTo(1));
+        await history.UndoAsync(); Assert.That(value, Is.Zero); Assert.That(notifications, Is.EqualTo(2));
+        var broken = new DelegateEdit("broken compensation", () => throw new IOException("rollback failed"), () => value = 9);
+        Assert.Throws<HistoryRepairRequiredException>(() => history.Execute(new CompositeEdit("broken", [broken, failure])));
+        Assert.That(history.RepairRequired, Is.True); Assert.That(notifications, Is.EqualTo(2));
+    }
+
+    [Test]
+    public async Task MixedLegacyCompositesStayConservativeAndMergeScopedRanges()
+    {
+        using var history = new UndoRedoHistory(); var changes = new List<AuthorChangeSet>(); history.AuthorChanges.Committed += changes.Add;
+        var first = new RecordingEdit(history, () => { }, () => { }, "g", 6);
+        var second = new RecordingEdit(history, () => { }, () => { }, "g", 2);
+        await history.ExecuteAsync(new AsyncCompositeEdit("scoped", [new AsyncEditAdapter(first), new AsyncEditAdapter(second)]));
+        Assert.That(changes.Single().Groups.Single().FirstIndex, Is.EqualTo(2)); Assert.That(changes.Single().UnknownScope, Is.False);
+        history.Execute(new CompositeEdit("mixed", [first, new DelegateEdit("legacy", () => { }, () => { })]));
+        Assert.That(changes.Last().UnknownScope, Is.True); Assert.That(changes.Last().Groups, Has.Count.EqualTo(1));
+        await history.UndoAsync(); Assert.That(changes.Last().UnknownScope, Is.True);
+    }
+
+    [Test]
+    public async Task CommitObserversCannotReenterOrSuppressOtherObservers()
+    {
+        using var history = new UndoRedoHistory(); var count = 0; var callbacks = 0;
+        Exception? syncFailure = null, asyncFailure = null;
+        history.AuthorChanges.Committed += _ =>
+        {
+            try { history.Execute(new DelegateEdit("reenter", () => { }, () => count++)); } catch (Exception error) { syncFailure = error; }
+            try { history.ExecuteAsync(new DelegateEdit("reenter async", () => { }, () => count++)).GetAwaiter().GetResult(); } catch (Exception error) { asyncFailure = error; }
+            throw new IOException("view failed");
+        };
+        history.AuthorChanges.Committed += _ => callbacks++;
+        await history.ExecuteAsync(new DelegateEdit("author", () => count--, () => count++));
+        Assert.That(count, Is.EqualTo(1)); Assert.That(callbacks, Is.EqualTo(1)); Assert.That(history.CanUndo, Is.True);
+        Assert.That(syncFailure, Is.TypeOf<InvalidOperationException>()); Assert.That(asyncFailure, Is.TypeOf<InvalidOperationException>());
+        Assert.That(history.AuthorChanges.LastNotificationError, Is.TypeOf<IOException>());
+    }
+
+    [Test]
+    public void FieldPatchesReportParametersAndTypeSeparately()
+    {
+        using var histories = new EditorHistories(); var documents = new EditorDocumentService();
+        var entry = new EditorEntryData { StableId = "same", Type = "custom.old" };
+        documents.Load(new()
+        {
+            Document = new() { Nodes = [new() { Id = "a", Type = "Group" }, new() { Id = "b", Type = "Group" }] },
+            GroupEntries = { ["a"] = [entry], ["b"] = [new() { StableId = "same", Type = "custom.old" }] }
+        });
+        var author = new EntryFieldAuthoringService(documents, histories); var changes = new List<AuthorChangeSet>(); histories.Content.AuthorChanges.Committed += changes.Add;
+        author.SetParameters("a", entry, entry.Type, new() { ["future"] = JsonSerializer.SerializeToElement(new { opaque = new[] { 1, 2 } }) });
+        author.SetType("a", entry, "custom.new", new());
+        Assert.That(changes[0].Groups.Single().Kind, Is.EqualTo(GroupChangeKind.Parameters));
+        Assert.That(changes[1].Groups.Single().Kind, Is.EqualTo(GroupChangeKind.EntryType | GroupChangeKind.Parameters));
+        Assert.That(changes.SelectMany(change => change.Groups).All(group => group.GroupId == "a"), Is.True);
+        Assert.That(documents.Groups["b"].Entries.Single().Type, Is.EqualTo("custom.old"));
+    }
+
+    private sealed class RecordingEdit(UndoRedoHistory history, Action redo, Action undo, string group = "g", int first = 0) : IUndoableEdit, IAuthorScopedEdit
+    {
+        public string Description => "record";
+        public void Redo() { redo(); Record(); }
+        public void Undo() { undo(); Record(); }
+        private void Record() => history.AuthorChanges.Record(group, first, GroupChangeKind.Parameters, ["entry"]);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/AuthoringDraftLifecycleTests.cs b/test/GalNet.Editor.Tests/AuthoringDraftLifecycleTests.cs
index 9d396a47..9019241a 100644
--- a/test/GalNet.Editor.Tests/AuthoringDraftLifecycleTests.cs
+++ b/test/GalNet.Editor.Tests/AuthoringDraftLifecycleTests.cs
@@ -22,7 +22,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task AuthoringDraftsReopenInMountedGroupAndKeepOpaqueValuesThroughEditsCopyUndoAndSave()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -58,7 +58,8 @@ await session.Dispatch<bool>(async () =>
                 Assert.That(text.Source.Parameters["speaker"].ValueKind, Is.EqualTo(JsonValueKind.Object), "Editing one dedicated text field must not reparse and coerce another invalid string field.");
                 await history.UndoAsync(); Assert.That(text.Parameters["content"], Is.EqualTo("original")); Assert.That(history.CanUndo, Is.False); await history.RedoAsync();
                 var authoring = project.Services.GetRequiredService<GroupEntryAuthoringService>(); var payload = opaque.Source.Parameters["payload"].Clone();
-                var copied = (await authoring.PasteAsync(groupId, authoring.Copy(groupId, [opaque.StableId]), null)).Single();
+                var copiedId = (await authoring.PasteAsync(groupId, authoring.Copy(groupId, [opaque.StableId]), null)).Single();
+                var copied = group.Entries.Single(entry => entry.StableId == copiedId);
                 Assert.That(copied.StableId, Is.Not.EqualTo(opaque.StableId)); Assert.That(copied.Type, Is.EqualTo(opaque.Type));
                 Assert.That(JsonElement.DeepEquals(copied.Source.Parameters["payload"], payload), Is.True);
                 await history.UndoAsync(); Assert.That(group.Entries.Contains(copied), Is.False); await history.RedoAsync();
diff --git a/test/GalNet.Editor.Tests/AuthoringUiContinuityTests.cs b/test/GalNet.Editor.Tests/AuthoringUiContinuityTests.cs
new file mode 100644
index 00000000..6a80ae96
--- /dev/null
+++ b/test/GalNet.Editor.Tests/AuthoringUiContinuityTests.cs
@@ -0,0 +1,243 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using GalNet.Core.Variable;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Controls;
+using GalNet.Editor.History;
+using GalNet.Editor.Inspector.ViewModels;
+using GalNet.Editor.Inspector.Views;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task VariableSubpagesRestoreIdentityDraftAndBaselineAfterSwitchRefreshAndReopen()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "VariableSubpages"), "Variables", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        try
+        {
+            var author = project.Services.GetRequiredService<VariableAuthoringService>();
+            var player = author.Add(VariableScope.Player); var save = author.Add(VariableScope.Save);
+            var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
+            var vm = project.Services.GetRequiredService<VariablesPanelViewModel>();
+            vm.Selected = vm.Rows.Single(); vm.DraftName = "pendingPlayer";
+            vm.ScopeIndex = 1; vm.Selected = vm.Rows.Single(); vm.DraftDescription = "pending save description";
+            vm.ScopeIndex = 0;
+            Assert.That(vm.Selected?.Uid, Is.EqualTo(player.DefaultValue.Uid)); Assert.That(vm.DraftName, Is.EqualTo("pendingPlayer"));
+            Assert.That(history.CanUndo, Is.False);
+            author.Update(VariableScope.Player, player.DefaultValue.Uid, "external", VariableType.Int, "42", "");
+            vm.ScopeIndex = 1; Assert.That(vm.Selected?.Uid, Is.EqualTo(save.DefaultValue.Uid)); Assert.That(vm.DraftDescription, Is.EqualTo("pending save description"));
+            vm.Dispose();
+            using var reopened = project.Services.GetRequiredService<VariablesPanelViewModel>();
+            Assert.That(reopened.ScopeIndex, Is.EqualTo(1)); Assert.That(reopened.Selected?.Uid, Is.EqualTo(save.DefaultValue.Uid));
+            Assert.That(reopened.DraftDescription, Is.EqualTo("pending save description"));
+            reopened.ScopeIndex = 0; reopened.ApplyCommand.Execute(null);
+            Assert.That(reopened.MessageText, Is.Not.Empty); Assert.That(author.Get(VariableScope.Player).Single().Name, Is.EqualTo("external"));
+            reopened.RevertCommand.Execute(null); Assert.That(reopened.DraftName, Is.EqualTo("external"));
+            reopened.DraftName = "retained";
+            author.Delete(VariableScope.Player, player.DefaultValue.Uid);
+            Assert.That(reopened.Selected, Is.Null); Assert.That(reopened.MissingSelection, Is.True);
+            var replacement = author.Add(VariableScope.Player);
+            Assert.That(reopened.Selected, Is.Null, "A new UID must not acquire the old draft.");
+            await history.UndoAsync(); await history.UndoAsync();
+            Assert.That(reopened.Selected?.Uid, Is.EqualTo(player.DefaultValue.Uid)); Assert.That(reopened.DraftName, Is.EqualTo("retained"));
+            reopened.Search = "no matching variable"; Assert.That(reopened.Rows, Is.Empty);
+            reopened.Search = ""; Assert.That(reopened.Selected?.Uid, Is.EqualTo(player.DefaultValue.Uid)); Assert.That(reopened.DraftName, Is.EqualTo("retained"));
+        }
+        finally { await projects.CloseAsync(); }
+    }
+
+    [Test]
+    public Task CharacterDraftsFollowStableNameIdentityAcrossFilterRenameSelectionAndReopen() => WithLocalizationProject(async project =>
+    {
+        var author = project.Services.GetRequiredService<CharacterAuthoringService>();
+        var first = await author.CreateAsync("First", "first"); var second = await author.CreateAsync("Second", "second");
+        var vm = project.Services.GetRequiredService<CharactersPanelViewModel>(); vm.Selected = vm.Rows.Single(row => row.Id == first.Id);
+        vm.DraftName = "Unapplied first"; vm.Search = "Second"; Assert.That(vm.Selected, Is.Null);
+        vm.Search = ""; Assert.That(vm.Selected?.DisplayNameKey, Is.EqualTo(first.DisplayNameKey)); Assert.That(vm.DraftName, Is.EqualTo("Unapplied first"));
+        vm.Selected = vm.Rows.Single(row => row.Id == second.Id); vm.DraftName = "Unapplied second";
+        vm.Selected = vm.Rows.Single(row => row.Id == first.Id); Assert.That(vm.DraftName, Is.EqualTo("Unapplied first"));
+        await author.UpdateAsync(first, "external", "External name");
+        Assert.That(vm.Selected?.Id, Is.EqualTo("external")); Assert.That(vm.DraftName, Is.EqualTo("Unapplied first"));
+        await vm.ApplyCommand.ExecuteAsync(null); Assert.That(vm.Message, Is.Not.Empty);
+        vm.RevertCommand.Execute(null); Assert.That(vm.DraftName, Is.EqualTo("External name"));
+        vm.Selected = vm.Rows.Single(row => row.Id == second.Id); vm.Dispose();
+        using var reopened = project.Services.GetRequiredService<CharactersPanelViewModel>();
+        Assert.That(reopened.Selected?.Id, Is.EqualTo(second.Id)); Assert.That(reopened.DraftName, Is.EqualTo("Unapplied second"));
+    });
+
+    [Test]
+    public Task CharactersSharingANameTextNeverShareDraftsOrAcquireADeletedCharactersSelection() => WithLocalizationProject(async project =>
+    {
+        WriteTranslation(project, """[{"id":"first","displayNameKey":"shared"},{"id":"second","displayNameKey":"shared"}]""", "I18n/catalog/characters.json");
+        WriteTranslation(project, """{"shared":"Shared name"}""");
+        var author = project.Services.GetRequiredService<CharacterAuthoringService>();
+        using var vm = project.Services.GetRequiredService<CharactersPanelViewModel>();
+        vm.Selected = vm.Rows.Single(row => row.Id == "first"); vm.DraftKey = "first_draft";
+        vm.Selected = vm.Rows.Single(row => row.Id == "second"); Assert.That(vm.DraftKey, Is.EqualTo("second")); vm.DraftKey = "second_draft";
+        vm.Selected = vm.Rows.Single(row => row.Id == "first"); Assert.That(vm.DraftKey, Is.EqualTo("first_draft"));
+        await author.DeleteAsync(author.Rows().Single(row => row.Id == "first"));
+        Assert.That(vm.Selected, Is.Null, "A shared name-text key cannot identify the remaining character as the removed selection.");
+        vm.Selected = vm.Rows.Single(); Assert.That(vm.DraftKey, Is.EqualTo("second_draft"));
+    });
+
+    [Test]
+    public Task CharacterApplyCompletionCannotDiscardAnotherSelectionOrAnUnrelatedNewDraft() => WithLocalizationProject(async project =>
+    {
+        var author = project.Services.GetRequiredService<CharacterAuthoringService>();
+        var first = await author.CreateAsync("First", "first"); var second = await author.CreateAsync("Second", "second");
+        using var vm = project.Services.GetRequiredService<CharactersPanelViewModel>();
+        vm.Selected = vm.Rows.Single(row => row.Id == second.Id); vm.DraftName = "Pending second";
+        vm.Selected = vm.Rows.Single(row => row.Id == first.Id); vm.DraftName = "Applied first";
+        var started = new TaskCompletionSource(); var release = new TaskCompletionSource();
+        var history = project.Services.GetRequiredService<EditorHistories>().Content;
+        var held = history.ExecuteAsync(new CallbackEdit("Hold character apply", async () => { started.SetResult(); await release.Task; }, () => ValueTask.CompletedTask));
+        await started.Task;
+        var apply = vm.ApplyCommand.ExecuteAsync(null);
+        try { vm.Selected = vm.Rows.Single(row => row.Id == second.Id); }
+        finally { release.SetResult(); }
+        await held; await apply;
+        Assert.That(author.Rows().Single(row => row.Id == first.Id).Name, Is.EqualTo("Applied first"));
+        Assert.That(vm.Selected?.Id, Is.EqualTo(second.Id)); Assert.That(vm.DraftName, Is.EqualTo("Pending second"));
+        vm.AddCommand.Execute(null); vm.DraftName = "Pending new character";
+        vm.Selected = vm.Rows.Single(row => row.Id == first.Id); vm.DraftName = "Applied again";
+        await vm.ApplyCommand.ExecuteAsync(null); vm.AddCommand.Execute(null);
+        Assert.That(vm.DraftName, Is.EqualTo("Pending new character"));
+        vm.Selected = vm.Rows.Single(row => row.Id == first.Id); vm.RevertCommand.Execute(null); vm.AddCommand.Execute(null);
+        Assert.That(vm.DraftName, Is.EqualTo("Pending new character"), "Reverting an existing character must not discard a separate new-character draft.");
+        vm.Selected = vm.Rows.Single(row => row.Id == first.Id); vm.DraftName = "Applied after close";
+        started = new(); release = new();
+        held = history.ExecuteAsync(new CallbackEdit("Hold across close", async () => { started.SetResult(); await release.Task; }, () => ValueTask.CompletedTask));
+        await started.Task; apply = vm.ApplyCommand.ExecuteAsync(null); vm.Dispose();
+        try
+        {
+            using var reopened = project.Services.GetRequiredService<CharactersPanelViewModel>(); reopened.DraftName = "Newer input";
+        }
+        finally { release.SetResult(); }
+        await held; await apply;
+        using var latest = project.Services.GetRequiredService<CharactersPanelViewModel>();
+        Assert.That(author.Rows().Single(row => row.Id == first.Id).Name, Is.EqualTo("Applied after close"));
+        Assert.That(latest.DraftName, Is.EqualTo("Newer input"), "An old view's completion must not discard a newer view's draft.");
+    });
+
+    [Test]
+    public Task LocalizationFiltersKeepMissingEmptyAndPendingIdentityDistinct() => WithLocalizationProject(async project =>
+    {
+        var item = CharacterEntry(project); WriteTranslation(project, """{"line":"Source"}""");
+        var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("en-US");
+        var model = project.Services.GetRequiredService<GameLocalizationPanelViewModel>(); model.Selected = model.Categories.Single(category => category.Id == item.Group); model.ExchangeLanguage = "en-US";
+        var cell = model.Rows.Single().Cells.Single(cell => cell.Culture == "en-US");
+        model.OnlyMissing = true; Assert.That(model.Rows, Has.Count.EqualTo(1));
+        await cell.CommitAsync(true); Assert.That(cell.IsMissing, Is.False); Assert.That(model.Rows, Is.Empty, "Explicit empty translation is not missing.");
+        model.OnlyMissing = false; cell.Text = "Unapplied translation";
+        await cell.CommitAsync(); Assert.That(model.Rows.Single().Cells, Does.Contain(cell));
+        model.Search = "no matching source"; Assert.That(model.Rows, Is.Empty);
+        model.Search = "Unapplied"; Assert.That(model.Rows.Single().Cells, Does.Contain(cell));
+        model.Selected = model.Categories.First(); model.Selected = model.Categories.Single(category => category.Id == item.Group);
+        Assert.That(model.Rows.Single().Cells.Single(c => c.Culture == "en-US"), Is.SameAs(cell));
+        Assert.That(cell.Text, Is.EqualTo("Unapplied translation")); Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("Unapplied translation"));
+        model.Search = ""; model.OnlyMissing = false;
+    });
+
+    [Test]
+    public async Task BranchPrimaryInputsStayAlignedWhenSemanticHintsOrErrorsAppear()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); await WithLocalizationProject(async project =>
+            {
+                var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
+                var branch = await workspace.AddNodeAsync(GraphNodeKind.ChoiceBranch, 300, 0); workspace.SelectNode(branch);
+                var view = new NodeInspectorControl { DataContext = project.Services.GetRequiredService<NodeInspectorControlViewModel>() };
+                var window = new Window { Content = view, Width = 800, Height = 700 }; window.Show(); Dispatcher.UIThread.RunJobs();
+                try
+                {
+                    void Check()
+                    {
+                        window.UpdateLayout();
+                        var text = view.GetVisualDescendants().OfType<TextBox>().Single(box => box.Name == "GameTextInput");
+                        var condition = view.GetVisualDescendants().OfType<ConditionEditorControl>().Single().FindControl<TextBox>("EditorBox")!;
+                        var textCenter = text.TranslatePoint(new Point(0, text.Bounds.Height / 2), window)!.Value.Y;
+                        var conditionCenter = condition.TranslatePoint(new Point(0, condition.Bounds.Height / 2), window)!.Value.Y;
+                        Assert.That(textCenter, Is.EqualTo(conditionCenter).Within(1)); Assert.That(text.Bounds.Width, Is.GreaterThan(50));
+                    }
+                    Check(); branch.Source.Options![0].Text = "missing_text";
+                    project.Services.GetRequiredService<IProjectContentSession>().Refresh(); Dispatcher.UIThread.RunJobs(); Check();
+                    var condition = view.GetVisualDescendants().OfType<ConditionEditorControl>().Single();
+                    condition.Text = "("; condition.FindControl<TextBox>("EditorBox")!.Focus(); view.Focus(); Dispatcher.UIThread.RunJobs(); Check();
+                }
+                finally { window.Close(); }
+            }); return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task AuthoringPanelsMountNarrowAndLocalizationKeepsFrozenContextWhileScrolling()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); await WithLocalizationProject(async project =>
+            {
+                var item = CharacterEntry(project); WriteTranslation(project, """{"line":"A longer source text for the localization workspace."}""");
+                var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("en-US"); await service.AddLanguageAsync("ja-JP");
+                var model = project.Services.GetRequiredService<GameLocalizationPanelViewModel>(); model.Selected = model.Categories.Single(category => category.Id == item.Group);
+                var view = new GameLocalizationPanelView { DataContext = model };
+                var window = new Window { Content = view, Width = 900, Height = 650 }; window.Show(); Dispatcher.UIThread.RunJobs();
+                void Capture(string name)
+                {
+                    if (Environment.GetEnvironmentVariable("GALNET_EDITOR_TEST_ARTIFACTS") is not { Length: > 0 } artifacts) return;
+                    using var frame = window.CaptureRenderedFrame(); frame!.Save(Path.Combine(artifacts, name + ".png"));
+                }
+                try
+                {
+                    var header = view.FindControl<Border>("ContextHeader")!; var scroll = view.FindControl<ScrollViewer>("LocalizationTableScroll")!;
+                    var left = header.TranslatePoint(default, window)!.Value.X;
+                    scroll.Offset = new Vector(220, 0); Dispatcher.UIThread.RunJobs(); window.UpdateLayout();
+                    Assert.That(scroll.Offset.X, Is.GreaterThan(0));
+                    Assert.That(header.TranslatePoint(default, window)!.Value.X, Is.EqualTo(left).Within(1));
+                    var sourceInput = view.GetVisualDescendants().OfType<TextBox>().Single(box => box.Name == "LocalizationCellInput" && box.DataContext is LocalizationGridCell cell && cell.Culture == "zh-CN");
+                    sourceInput.Focus(); Dispatcher.UIThread.RunJobs(); window.UpdateLayout();
+                    Assert.That(sourceInput.TranslatePoint(default, scroll)!.Value.X, Is.GreaterThanOrEqualTo(188), "Keyboard focus must reveal the cell beside the frozen context.");
+                    scroll.Offset = new Vector(220, 0); Dispatcher.UIThread.RunJobs();
+                    var rowContext = view.GetVisualDescendants().OfType<Button>().Single(button => button.Name == "LocalizationNavigate");
+                    Assert.That(rowContext.TranslatePoint(default, window)!.Value.X, Is.GreaterThanOrEqualTo(left));
+                    Capture("localization-wide"); window.Width = 440; Dispatcher.UIThread.RunJobs();
+                    Assert.That(view.FindControl<ComboBox>("CompactLocalizationCategory")!.IsVisible, Is.True); Capture("localization-narrow");
+                    using var variables = project.Services.GetRequiredService<VariablesPanelViewModel>();
+                    var variableView = new VariablesPanelView { DataContext = variables }; window.Content = variableView; Dispatcher.UIThread.RunJobs();
+                    Click(window, variableView.FindControl<Button>("AddVariableButton")!); Dispatcher.UIThread.RunJobs();
+                    Assert.That(variables.HasSelection, Is.True); Assert.That(project.Services.GetRequiredService<VariableAuthoringService>().Get(VariableScope.Player), Has.Count.EqualTo(1));
+                    Assert.That((variables.HasChanges, variables.DraftDefault), Is.EqualTo((false, "")), "An untouched variable must not acquire a draft from hidden input controls.");
+                    Assert.That(variableView.FindControl<TextBox>("NameInput")!.Bounds.Width, Is.GreaterThan(150)); Capture("variables-narrow");
+                    window.Width = 900; Dispatcher.UIThread.RunJobs(); Capture("variables-wide");
+                    var author = project.Services.GetRequiredService<CharacterAuthoringService>(); await author.CreateAsync("Character name", "character_key");
+                    using var characters = project.Services.GetRequiredService<CharactersPanelViewModel>(); characters.Selected = characters.Rows.Single();
+                    window.Content = new CharactersPanelView { DataContext = characters }; window.Width = 360; Dispatcher.UIThread.RunJobs(); Capture("characters-narrow");
+                    await CreateVariantImages(project.RootPath, project.Services.GetRequiredService<ProjectFileAuthoringService>());
+                    var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
+                    workspace.SelectedAsset = project.Services.GetRequiredService<GalNet.Editor.Services.Interfaces.IAssetCatalogService>().GetEntry("alice/idle_coat.png");
+                    using var inspector = project.Services.GetRequiredService<AssetInspectorControlViewModel>();
+                    var assetView = new AssetInspectorControl { DataContext = inspector }; window.Content = assetView; window.Height = 650; Dispatcher.UIThread.RunJobs();
+                    await PumpCharacterUi(() => inspector.ImagePreview is not null);
+                    var properties = assetView.FindControl<ScrollViewer>("AssetProperties")!; var preview = assetView.FindControl<Expander>("AssetPreview")!;
+                    Assert.That(inspector.HasPreview, Is.True);
+                    Assert.That(preview.TranslatePoint(default, window)!.Value.Y, Is.GreaterThanOrEqualTo(properties.Bounds.Bottom));
+                    Capture("inspector-preview-bottom");
+                }
+                finally { window.Close(); }
+            }); return true;
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/CharacterAuthoringTests.cs b/test/GalNet.Editor.Tests/CharacterAuthoringTests.cs
index 63d323e7..1981449a 100644
--- a/test/GalNet.Editor.Tests/CharacterAuthoringTests.cs
+++ b/test/GalNet.Editor.Tests/CharacterAuthoringTests.cs
@@ -125,7 +125,12 @@ public Task UnknownCharacterIdsRemainErrorsAndUncertainReferencesBlockDestructiv
         await SetSpeaker(project, item, row.Id); Assert.That(Speaker(item.Entry), Is.EqualTo(row.Id));
         var unused = await characters.CreateAsync("未用");
         var documents = project.Services.GetRequiredService<IEditorDocumentService>();
-        documents.Groups[item.Group].Entries.Add(new() { StableId = Guid.NewGuid().ToString("N"), Type = "unknown.schema" });
+        documents.Groups[item.Group].Entries.Add(new()
+        {
+            StableId = Guid.NewGuid().ToString("N"),
+            Type = "unknown.schema",
+            Parameters = new() { ["opaque"] = JsonSerializer.SerializeToElement("potential-character-reference") }
+        });
         Assert.That(characters.Complete, Is.False);
         Assert.ThrowsAsync<EditorOperationException>(async () => await characters.DeleteAsync(unused));
         Assert.ThrowsAsync<EditorOperationException>(async () => await characters.UpdateAsync(row, "renamed", row.Name!));
@@ -162,7 +167,7 @@ public Task CharacterRelatedInvalidDraftAndStaleRenamePreserveCurrentValues() =>
     [Test]
     public async Task CharacterPanelMountedControlsCreateRenameFilterAndDisposeDock()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme();
@@ -192,7 +197,7 @@ await WithLocalizationProject(async project =>
     [Test]
     public async Task CharacterSpeakerMountedFocusLossSearchSelectionAndComposition()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); await WithLocalizationProject(async project =>
@@ -251,7 +256,7 @@ private static async Task PumpCharacterUi(Func<bool> ready)
     [Test]
     public async Task CharacterNestedListFieldUsesSemanticEditorAndRenameUpdatesStoredWirePath()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme();
diff --git a/test/GalNet.Editor.Tests/DtoEditorIntegrationTests.cs b/test/GalNet.Editor.Tests/DtoEditorIntegrationTests.cs
index a8c9100e..32415357 100644
--- a/test/GalNet.Editor.Tests/DtoEditorIntegrationTests.cs
+++ b/test/GalNet.Editor.Tests/DtoEditorIntegrationTests.cs
@@ -20,7 +20,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task ScopedDtoOverrideCommitsMultipleEntryFieldsAsOneUndoAndSave()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
diff --git a/test/GalNet.Editor.Tests/EditorLocalizationTests.cs b/test/GalNet.Editor.Tests/EditorLocalizationTests.cs
index 71074204..23679751 100644
--- a/test/GalNet.Editor.Tests/EditorLocalizationTests.cs
+++ b/test/GalNet.Editor.Tests/EditorLocalizationTests.cs
@@ -11,6 +11,34 @@ namespace GeneralTest.Editor;
 [NonParallelizable]
 public sealed class EditorLocalizationTests
 {
+    [Test]
+    public void BackgroundStartupPreparationDoesNotPublishLocalizationOrChangeCallerCulture()
+    {
+        var current = CultureInfo.CurrentCulture;
+        var ui = CultureInfo.CurrentUICulture;
+        var published = EditorLocalizationService.Current;
+        var root = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "GalNet-preparation-" + Guid.NewGuid().ToString("N"))).FullName;
+        try
+        {
+            var path = Path.Combine(root, "editor.json");
+            var settings = new EditorSettingsService(path);
+            settings.GetSettings().UiLocale = new I18nLocale("ko-KR");
+            settings.SaveSettings();
+            using var preparation = new EditorStartupPreparation(path);
+            var loaded = preparation.Settings.GetAwaiter().GetResult();
+            var resources = preparation.Localization.GetAwaiter().GetResult();
+            Assert.That(EditorLocalizationService.Current, Is.SameAs(published));
+            Assert.That(CultureInfo.CurrentCulture, Is.SameAs(current));
+            Assert.That(CultureInfo.CurrentUICulture, Is.SameAs(ui));
+            var localization = new EditorLocalizationService(resources);
+            localization.ApplyLocale(loaded.GetSettings().UiLocale.Code);
+            Assert.That(localization.CurrentCulture.Name, Is.EqualTo("ko-KR"));
+            Assert.That(localization["Close.Title"], Is.EqualTo("프로젝트 닫기"));
+            Assert.That(localization["Missing.Custom.Key"], Is.EqualTo("[Missing.Custom.Key]"));
+        }
+        finally { CultureInfo.CurrentCulture = current; CultureInfo.CurrentUICulture = ui; Directory.Delete(root, true); }
+    }
+
     [Test]
     public void FourPublishedLanguagesHaveIdenticalKeysAndCompatibleFormatArguments()
     {
@@ -23,6 +51,16 @@ public void FourPublishedLanguagesHaveIdenticalKeysAndCompatibleFormatArguments(
         foreach (var map in maps)
         {
             Assert.That(map.Keys, Is.EquivalentTo(maps[0].Keys));
+            foreach (var definition in new GalNet.Core.Entry.TargetProfileEntryCatalog(GalNet.Contracts.Builtins.BuiltinSchemas.CreateAllModules()).Definitions)
+            {
+                Assert.That(map, Does.ContainKey("Entry.Type." + definition.Type), definition.Type);
+                Assert.That(map, Does.ContainKey("Entry.Category." + definition.Category), definition.Category);
+
+            }
+            var missingFields = new GalNet.Core.Entry.TargetProfileEntryCatalog(GalNet.Contracts.Builtins.BuiltinSchemas.CreateAllModules()).Definitions
+                .SelectMany(definition => definition.DynamicParameters.Fields).Where(field => field.LabelKey is null && !map.ContainsKey("Entry.Parameter." + field.Id)).Select(field => field.Id).Distinct().ToArray();
+            Assert.That(missingFields, Is.Empty);
+            Assert.That(map, Does.ContainKey("Editor.Menu.ProjectSettings"));
             foreach (var (key, value) in map)
             {
                 Assert.That(value, Is.Not.Empty, key);
diff --git a/test/GalNet.Editor.Tests/EditorStartupTests.cs b/test/GalNet.Editor.Tests/EditorStartupTests.cs
new file mode 100644
index 00000000..f0ca833a
--- /dev/null
+++ b/test/GalNet.Editor.Tests/EditorStartupTests.cs
@@ -0,0 +1,41 @@
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Threading;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task MainWindowPreparesStartupBeforeShowAndDoesNotResetNavigationOnLoad(bool navigateBeforeShow)
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await session.Dispatch<bool>(() =>
+        {
+            PrepareGroupTheme();
+            using var services = Services();
+            var navigation = services.GetRequiredService<INavigationService>();
+            var window = services.GetRequiredService<MainWindow>();
+            Assert.That(navigation.CurrentPage, Is.TypeOf<StartupPageViewModel>());
+            Assert.That(window.FindControl<ContentControl>("PageHost")!.Content, Is.TypeOf<StartupPageView>());
+            if (navigateBeforeShow) navigation.NavigateTo<NewProjectPanelViewModel>();
+            var expected = navigation.CurrentPage;
+            try
+            {
+                window.Show();
+                window.UpdateLayout();
+                Dispatcher.UIThread.RunJobs();
+                Assert.That(navigation.CurrentPage, Is.SameAs(expected));
+                Assert.That(((Control)window.FindControl<ContentControl>("PageHost")!.Content!).DataContext,
+                    Is.SameAs(expected));
+            }
+            finally { window.Close(); }
+            return Task.FromResult(true);
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/EditorStateSimplificationTests.cs b/test/GalNet.Editor.Tests/EditorStateSimplificationTests.cs
index bf6df4b7..9ff0b3d8 100644
--- a/test/GalNet.Editor.Tests/EditorStateSimplificationTests.cs
+++ b/test/GalNet.Editor.Tests/EditorStateSimplificationTests.cs
@@ -39,24 +39,6 @@ public async Task VariableIntentsOwnHistoryWithoutWorkspaceAndRuntimeEditsNeverD
         await projects.SaveAsync();
         Assert.That(await projects.CheckUnsavedChangesAsync(), Is.False);
 
-        var runtime = scope.GetRequiredService<EditorVariableService>();
-        var preview = new VariableListEditorViewModel(declarations.GetDefinitions(VariableScope.Save), true,
-            name => runtime.GetSnapshot(VariableScope.Save).GetValueOrDefault(name), (name, value) =>
-            {
-                var next = new Variable { Name = name }; next.SetValue(value);
-                runtime.NotifyVariableChanged(VariableScope.Save, name, next);
-            });
-        var undoBeforeRuntimeEdit = history.UndoDescription;
-        preview.Items.Single().CurrentIntValue = 42;
-        Assert.Multiple(() =>
-        {
-            Assert.That(runtime.GetSnapshot(VariableScope.Save)["score"].AsInt(), Is.EqualTo(42));
-            Assert.That(author.Get(VariableScope.Save).Single().DefaultValue.AsInt(), Is.EqualTo(3));
-            Assert.That(content.IsDirty, Is.False);
-            Assert.That(history.IsDirty, Is.False);
-            Assert.That(history.UndoDescription, Is.EqualTo(undoBeforeRuntimeEdit));
-        });
-
         author.Update(VariableScope.Save, uid, "points", VariableType.Int, "9", "Updated");
         Assert.That(entry.Condition, Is.EqualTo("[points] > 0"));
         Assert.That(await projects.CheckUnsavedChangesAsync(), Is.True);
diff --git a/test/GalNet.Editor.Tests/EditorUiuxFollowupTests.cs b/test/GalNet.Editor.Tests/EditorUiuxFollowupTests.cs
index 885fb759..e0979e60 100644
--- a/test/GalNet.Editor.Tests/EditorUiuxFollowupTests.cs
+++ b/test/GalNet.Editor.Tests/EditorUiuxFollowupTests.cs
@@ -14,7 +14,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task UiuxInspectorFollowsFocusBackToAlreadyActiveGroupAndRespectsLock()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/EditorUiuxIntegrationTests.cs b/test/GalNet.Editor.Tests/EditorUiuxIntegrationTests.cs
index fdc8b1a7..db1b156f 100644
--- a/test/GalNet.Editor.Tests/EditorUiuxIntegrationTests.cs
+++ b/test/GalNet.Editor.Tests/EditorUiuxIntegrationTests.cs
@@ -29,7 +29,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task UiuxVariableEditorsMountCompletionControlsAndSaveOtherValidDrafts()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -60,7 +60,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task UiuxNestedDraftCreatesAnOmittedObjectAndRejectsLaterSourceChanges()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -98,7 +98,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task UiuxProjectOwnedPanelsRemainLiveAfterClosingAndReopeningTheirDocks()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -127,7 +127,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task UiuxRealViewsMountAtSmallSizesAndIconThemesKeepKeyboardAndCheckedFeedback()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme();
@@ -170,7 +170,7 @@ void Capture(string name)
                     foreach (var animated in window.GetVisualDescendants().OfType<Avalonia.Animation.Animatable>()) animated.ClearValue(Avalonia.Animation.Animatable.TransitionsProperty);
                     app.RequestedThemeVariant = theme; window.RequestedThemeVariant = theme;
                     await Task.Delay(200); TimelinePump(window);
-                    var add = groupView.GetVisualDescendants().OfType<Button>().Single(button => ReferenceEquals(button.Command, page.AddEntryCommand));
+                    var add = groupView.GetVisualDescendants().OfType<Button>().Single(button => ReferenceEquals(button.Command, page.ExpandAllCommand));
                     Assert.That(add.Bounds.Width, Is.EqualTo(32)); Assert.That(add.Bounds.Height, Is.EqualTo(32));
                     var surface = add.GetVisualDescendants().OfType<Border>().Single(border => border.Name == "ButtonSurface");
                     Assert.That((surface.Background as ISolidColorBrush)?.Color.A ?? 0, Is.Zero, "Icon buttons keep a transparent normal surface.");
@@ -205,7 +205,7 @@ void Capture(string name)
                 var timelineEntry = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.PlayTimeline).Single();
                 timelineEntry.Source.Parameters["timeline"] = TimelineFixture(); page.SelectedEntry = timelineEntry;
                 var timelineView = new TimelinePanelView { DataContext = timeline }; window.Content = timelineView; TimelinePump(window);
-                Assert.That(timelineView.GetVisualDescendants().OfType<GridSplitter>().Count(), Is.EqualTo(2));
+                Assert.That(timelineView.GetVisualDescendants().OfType<GridSplitter>().Count(), Is.EqualTo(3));
                 Assert.That(timelineView.TreeColumnWidth.Value, Is.EqualTo(320)); timelineView.TreeColumnWidth = new GridLength(260); TimelinePump(window);
                 Assert.That(timelineView.FindControl<GalNet.Game.Controls.Timeline.TimelineCanvas>("TimelineKeys")!.Bounds.Width, Is.GreaterThan(300));
                 Capture("uiux-timeline-960.png");
@@ -218,7 +218,7 @@ void Capture(string name)
     [Test]
     public async Task UiuxLocalizedDraftsSynchronizeAndSaveAfterEveryViewCloses()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -259,7 +259,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task UiuxCommonAndFullEditorsShareDraftsAcrossDockClosureAndSave()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -307,7 +307,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task UiuxPresetsRetainDocumentsSelectionAndHistoryAndRestoreMaximization()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -334,7 +334,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task UiuxProblemsValidateUnsavedAuthorValuesAndKeepStableEntryNavigation()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/EditorUiuxTests.cs b/test/GalNet.Editor.Tests/EditorUiuxTests.cs
index 2defe174..35f86546 100644
--- a/test/GalNet.Editor.Tests/EditorUiuxTests.cs
+++ b/test/GalNet.Editor.Tests/EditorUiuxTests.cs
@@ -10,10 +10,6 @@ public void CommonAnnotationFlowsThroughInheritedGeneratedSchema()
         Assert.That(CommonDerivedOptions.Schema.Single(field => field.Id == "title").Editor!.IsCommon, Is.True);
         Assert.That(CommonDerivedOptions.Schema.Single(field => field.Id == "advanced").Editor!.IsCommon, Is.False);
         Assert.That(new EditorHints(IsCommon: true).IsCommon, Is.True);
-        var legacyConstructor = typeof(EditorHints).GetConstructor([typeof(string), typeof(double?), typeof(string), typeof(string)]);
-        Assert.That(legacyConstructor, Is.Not.Null, "Previously compiled contract metadata keeps its constructor ABI.");
-        var legacy = (EditorHints)legacyConstructor!.Invoke(["text", null, null, null]);
-        Assert.That(legacy.IsCommon, Is.False);
     }
 }
 
diff --git a/test/GalNet.Editor.Tests/EditorWorkspaceViewModelTests.cs b/test/GalNet.Editor.Tests/EditorWorkspaceViewModelTests.cs
index 94b6e83e..652be65c 100644
--- a/test/GalNet.Editor.Tests/EditorWorkspaceViewModelTests.cs
+++ b/test/GalNet.Editor.Tests/EditorWorkspaceViewModelTests.cs
@@ -6,13 +6,14 @@
 using Avalonia.Media;
 using Avalonia.VisualTree;
 using GalNet.Contracts.Builtins;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
 using GalNet.Core.Parameters;
-using GalNet.Core.Settings;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Extensibility;
 using GalNet.Editor.Abstraction.Project;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Abstraction.Settings;
 using GalNet.Editor.Controls;
 using GalNet.Editor.Dock;
 using GalNet.Editor.History;
@@ -33,7 +34,7 @@ public sealed class EditorWorkspaceViewModelTests
     [TestCase(false), TestCase(true), NonParallelizable]
     public async Task SchemaFieldCommitUsesWorkspaceHistoryAndSaveSnapshot(bool useDto)
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             using var fixture = new WorkspaceFixture(withProject: true, useDto: useDto);
@@ -48,7 +49,7 @@ await session.Dispatch<bool>(async () =>
             // Supply only layout icon resources; the real parameter panel and bindings are used below.
             foreach (var key in new[] { "AddIcon", "DeleteRegularIcon", "ChevronUpRegular", "ChevronDownRegular" })
                 Application.Current!.Resources[key] = StreamGeometry.Parse("M0,0 L8,8");
-            var panel = new GroupEditorPanelViewModel(workspace, group.Id, null!, fixture.ProjectService,
+            var panel = new GroupEditorPanelViewModel(workspace, group.Id, fixture.EntryAuthoring, fixture.ProjectService,
                 null!, null!, null!, catalog, new GalNet.Editor.Services.EntrySelectionContext());
             Application.Current!.RequestedThemeVariant = Avalonia.Styling.ThemeVariant.Light;
             Application.Current.Styles.Add(new Semi.Avalonia.SemiTheme());
@@ -77,12 +78,12 @@ await session.Dispatch<bool>(async () =>
                 var changes = 0;
                 field.Changed += (_, _) => changes++;
                 await fixture.Content.SaveAsync();
-                ((TextBox)form.Editors[0].Control).Text = "1.5";
+                NumericControlTestSupport.Input(form.Editors[0].Control).Text = "1.5";
                 Assert.That(await form.Contexts[0].CommitTextAsync(), Is.True);
                 Assert.That(workspace.UndoRedoHistory.IsDirty, Is.True);
                 workspace.UndoRedoHistory.Undo();
                 Assert.That(field.Read().Json!.Value.GetSingle(), Is.EqualTo(1));
-                Assert.That(((TextBox)form.Editors[0].Control).Text, Is.EqualTo("1"));
+                Assert.That(NumericControlTestSupport.Input(form.Editors[0].Control).Text, Is.EqualTo("1"));
                 Assert.That(workspace.UndoRedoHistory.IsDirty, Is.False);
                 workspace.UndoRedoHistory.Redo();
                 Assert.That(field.Read().Json!.Value.GetSingle(), Is.EqualTo(1.5));
@@ -97,6 +98,17 @@ await session.Dispatch<bool>(async () =>
         }, CancellationToken.None);
     }
 
+    [Test]
+    public void GraphProjectionCannotBeUsedAsAnAuthorWriteChannel()
+    {
+        using var fixture = new WorkspaceFixture();
+        var count = fixture.DocumentService.CurrentDocument.Nodes.Count;
+        Assert.Throws<NotSupportedException>(() => ((IList<GraphNode>)fixture.Workspace.Nodes).Clear());
+        Assert.Throws<NotSupportedException>(() => ((IList<GraphEdge>)fixture.Workspace.Edges).Clear());
+        Assert.That(fixture.DocumentService.CurrentDocument.Nodes, Has.Count.EqualTo(count));
+        Assert.That(fixture.Workspace.UndoRedoHistory.CanUndo, Is.False);
+    }
+
     [Test]
     public void Selection_KeepsNodeAndEdgeFlagsConsistent()
     {
@@ -211,16 +223,14 @@ public async Task EditorWorkspacePersistence_LoadsAndSavesWithoutAWorkspace()
             "test",
             "Test Project",
             "C:\\test-project",
-            new ProjectSettings(),
+            new ProjectConfiguration(),
             new EditorProjectState(),
             new FakeScope()));
         var documents = new EditorDocumentService();
-        var saveCoordinator = new CapturingSaveCoordinator();
         var persistence = new EditorWorkspacePersistence(
             projects,
             new FakeDocumentRepository(WorkspaceFixture.CreateLoadedDocument()),
-            documents,
-            saveCoordinator);
+            documents);
 
         var graph = persistence.LoadCurrentProject()!;
         var saved = await persistence.SaveCurrentProjectAsync();
@@ -240,10 +250,10 @@ private sealed class WorkspaceFixture : IDisposable
     {
         public FakeProjectService ProjectService { get; } = new();
         public EditorDocumentService DocumentService { get; } = new();
-        public CapturingSaveCoordinator SaveCoordinator { get; } = new();
         public ImmediateSaveScheduler SaveScheduler { get; } = new();
         public EditorWorkspaceViewModel Workspace { get; }
         public IEntryCatalog Catalog { get; }
+        public GroupEntryAuthoringService EntryAuthoring { get; }
 
         private readonly string _root = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "GalNet-workspace-test-" + Guid.NewGuid().ToString("N"))).FullName;
         private readonly ProjectContentSession _content;
@@ -260,7 +270,7 @@ public WorkspaceFixture(bool withProject = false, bool useDto = false)
                     "test",
                     "Test Project",
                     _root,
-                    new ProjectSettings(),
+                    new ProjectConfiguration(),
                     new EditorProjectState(),
                     projectScope));
             }
@@ -281,13 +291,14 @@ [new GalNet.Core.Primitives.DynamicParameterDescriptor("duration", typeof(float)
             var variableDefinitions = new VariableDefinitionService(DocumentService);
             var repository = new FakeDocumentRepository(loaded);
             DocumentService.Load(loaded);
-            File.WriteAllText(Path.Combine(_root, "settings.json"), System.Text.Json.JsonSerializer.Serialize(ProjectService.Current!.Settings));
+            File.WriteAllText(Path.Combine(_root, "settings.json"), System.Text.Json.JsonSerializer.Serialize(ProjectService.Current!.Configuration));
             _content = new ProjectContentSession(DocumentService, repository);
             _content.Open(ProjectService.Current!);
             ProjectService.Content = _content;
             var histories = new EditorHistories(_content);
             var groups = new EditorGroupProjectionStore(DocumentService, catalog, new EntryFieldAuthoringService(DocumentService, histories));
-            var persistence = new EditorWorkspacePersistence(ProjectService, repository, DocumentService, SaveCoordinator, groups);
+            var persistence = new EditorWorkspacePersistence(ProjectService, repository, DocumentService, groups);
+            EntryAuthoring = new GroupEntryAuthoringService(DocumentService, catalog, histories);
             Workspace = new EditorWorkspaceViewModel(
                 ProjectService,
                 histories,
@@ -299,12 +310,13 @@ [new GalNet.Core.Primitives.DynamicParameterDescriptor("duration", typeof(float)
                 localization,
                 SaveScheduler,
                 new GraphSelectionState(),
-                persistence, new GraphAuthoringService(DocumentService, histories, _content), new GroupEntryAuthoringService(groups, DocumentService, catalog, histories));
+                persistence, new GraphAuthoringService(DocumentService, histories, _content), EntryAuthoring);
         }
 
         public void Dispose()
         {
             Workspace.Dispose();
+            EntryAuthoring.Dispose();
             _content.Dispose();
             ProjectService.Current?.Dispose();
             Directory.Delete(_root, true);
@@ -336,7 +348,7 @@ public event Action<GalProject?>? CurrentChanged { add { } remove { } }
 
         public void SetCurrent(GalProject project) => Current = project;
         public Task<GalProject> OpenAsync(string projectPath) => throw new NotSupportedException();
-        public Task<GalProject> CreateAsync(string projectPath, string name, ProjectSettings settings, string contractsDirectory) => throw new NotSupportedException();
+        public Task<GalProject> CreateAsync(string projectPath, string name, ProjectConfiguration settings, string contractsDirectory) => throw new NotSupportedException();
         public Task CloseAsync() => Task.CompletedTask;
         public Task SaveAsync() { SaveCount++; return Content?.SaveAsync() ?? Task.CompletedTask; }
         public IReadOnlyList<RecentProjectInfo> GetRecentProjects() => [];
@@ -346,7 +358,7 @@ public void RemoveRecentProject(string projectPath) { }
 
     private sealed class FakeDocumentRepository(LoadedEditorProjectDocument loaded) : IEditorDocumentRepository
     {
-        public LoadedEditorProjectDocument Load(string projectPath, string projectName, ProjectSettings settings) => loaded;
+        public LoadedEditorProjectDocument Load(string projectPath) => loaded;
         public ProjectSavePlan PrepareSave(string projectPath, EditorGraphDocument document, IReadOnlyDictionary<string, IReadOnlyList<EditorEntryData>> groupEntries) => new(new Dictionary<string, byte[]>(), []);
         public void ApplySave(string projectPath, ProjectSavePlan plan, CancellationToken cancellationToken = default)
         {
@@ -360,10 +372,6 @@ public void ApplySave(string projectPath, ProjectSavePlan plan, CancellationToke
         public void Save(string projectPath, EditorGraphDocument document, IReadOnlyDictionary<string, IReadOnlyList<EditorEntryData>> groupEntries) => throw new NotSupportedException();
     }
 
-    private sealed class CapturingSaveCoordinator : IEditorSaveCoordinator
-    {
-        public string BuildPreviewData(string previewPath, EditorGraphDocument document, IReadOnlyDictionary<string, IReadOnlyList<EditorEntryData>> groupEntries) => previewPath;
-    }
 
     private sealed class ImmediateSaveScheduler : IProjectSaveScheduler
     {
diff --git a/test/GalNet.Editor.Tests/EffectMetadataTests.cs b/test/GalNet.Editor.Tests/EffectMetadataTests.cs
index 26bf4c35..751ced76 100644
--- a/test/GalNet.Editor.Tests/EffectMetadataTests.cs
+++ b/test/GalNet.Editor.Tests/EffectMetadataTests.cs
@@ -7,17 +7,22 @@
 using Avalonia.Interactivity;
 using Avalonia.VisualTree;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Assets;
-using GalNet.Core.Scene;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Composition;
 using GalNet.Editor.History;
+using GalNet.Editor.Inspector.ViewModels;
+using GalNet.Editor.Inspector.Views;
 using GalNet.Editor.Models;
 using GalNet.Editor.Models.Graph;
 using GalNet.Editor.Services;
 using GalNet.Editor.Services.Interfaces;
 using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using GalNet.Game.Controls.Forms;
 using Microsoft.Extensions.DependencyInjection;
+using SkiaSharp;
 
 namespace GeneralTest.Editor;
 
@@ -35,6 +40,55 @@ @param amount
           range: 0..1
         */
         """;
+    private const string EffectEditorSource = """
+        /*
+        @gal.effect v=1
+        @input source
+        @targets layer,scenePost
+        @param amount
+          uniform: uAmount
+          type: float
+          default: 0.25
+          range: 0..1
+        @param tint
+          uniform: uTint
+          type: color
+          default: #ff0000ff
+        @param offset
+          uniform: uOffset
+          type: vec2
+          default: [0,0]
+        @param direction
+          uniform: uDirection
+          type: vec3
+        @param channels
+          uniform: uChannels
+          type: vec4
+        @param style
+          uniform: uStyle
+          type: enum
+          options: soft,hard
+        @texture mask
+          uniform: uMask
+        */
+        """;
+    private const string EffectPreviewSource = """
+        /*
+        @gal.effect v=1
+        @input source
+        @targets layer
+        @param amount
+          uniform: amount
+          type: float
+          default: 0
+        */
+        uniform shader source;
+        uniform float amount;
+        half4 main(float2 p) {
+            half4 color = source.eval(p);
+            return half4(color.r * amount, color.g, color.b, color.a);
+        }
+        """;
     private static ServiceProvider EffectServices(MetadataAssets assets, MetadataResources resources) => new ServiceCollection().AddEditorServices()
         .AddSingleton<IEditorLocalizationService>(new EditorLocalizationService())
         .AddSingleton<IProjectClosePrompt>(new DiscardProjectClosePrompt())
@@ -42,6 +96,216 @@ @param amount
         .AddSingleton<IEffectCatalog>(new EffectCatalog([])).AddSingleton<IAssetManager>(assets)
         .AddSingleton<IAssetCatalogService>(resources).BuildServiceProvider(new ServiceProviderOptions { ValidateScopes = true, ValidateOnBuild = true });
 
+    [Test]
+    public async Task PresetInspectorReusesTransformVectorAndShaderMetadataEditors()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var assets = new MetadataAssets { File = { Source = EffectEditorSource } };
+            using var resources = new MetadataResources(); using var services = EffectServices(assets, resources);
+            var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "PresetInspector"), "Preset", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.SpeedLinesPreset).Single();
+            entry.Source.Parameters["program"] = JsonSerializer.SerializeToElement("program");
+            entry.Source.Parameters["parameters"] = JsonSerializer.Deserialize<JsonElement>("{\"amount\":0.6,\"unknown\":[9007199254740993,null]}");
+            scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
+            var query = scope.GetRequiredService<ProjectSceneTargets>(); await query.PrepareAsync();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = entry;
+            using var inspector = new EntryInspectorViewModel(page, sceneTargets: query);
+            var view = new EntryInspectorView { DataContext = inspector };
+            var window = new Window { Content = view, Width = 650, Height = 950 }; window.Show(); TimelinePump(window);
+            try
+            {
+                Assert.That(query.ProgramDescriptor("program"), Is.Not.Null);
+                Assert.That(inspector.Form!.Item.Fields.Select(field => field.Id), Does.Contain("parameters"));
+                var host = view.GetVisualDescendants().OfType<DtoEditorHost>().Single(control => control.Name == "EntryDetails");
+                Assert.That(host.Diagnostics, Is.Empty);
+                var mounted = view.GetVisualDescendants().OfType<FieldEditorRow>().ToArray();
+                Assert.That(mounted.Select(row => row.Context?.Field.Id), Does.Contain("parameters"));
+                var parameters = mounted.Single(row => row.Context?.Field.Id == "parameters");
+                var preset = new[] { parameters.Editor! }.Concat(parameters.Editor!.GetVisualDescendants())
+                    .OfType<StackPanel>().Single(panel => panel.Name == "PresetShaderParameters");
+                Assert.That(preset.GetVisualDescendants().OfType<TextBox>().Any(), Is.True);
+                var fields = preset.GetVisualDescendants().OfType<TextBox>().ToArray();
+                Assert.That(fields.Length, Is.GreaterThanOrEqualTo(2));
+                var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+                var amount = fields.First(); amount.Focus(); amount.Text = "0.8"; TimelinePump(window); PressGroupKey(amount, Key.Enter); TimelinePump(window);
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("amount").GetSingle(), Is.EqualTo(.8f));
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("unknown")[0].GetInt64(), Is.EqualTo(9007199254740993L));
+                await history.UndoAsync(); TimelinePump(window);
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("amount").GetSingle(), Is.EqualTo(.6f));
+
+                entry.Source.Parameters["program"] = JsonSerializer.SerializeToElement("missing");
+                entry.RefreshAuthorReferences(scope.GetRequiredService<GalNet.Core.Entry.IEntryCatalog>()); TimelinePump(window);
+                Assert.That(preset.GetVisualDescendants().OfType<TextBox>(), Is.Empty);
+
+                var motion = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.MotionPreset).Single();
+                page.SelectedEntry = motion; TimelinePump(window);
+                var transform = view.GetVisualDescendants().OfType<FieldEditorRow>().Single(row => row.Context?.Field.Id == "transform");
+                Assert.That(new[] { transform.Editor! }.Concat(transform.Editor!.GetVisualDescendants()).OfType<Grid>().Any(grid => grid.Name == "TransformEditor"), Is.True);
+
+                var reveal = workspace.InsertEntriesInto(group, 2, 1, BuiltinEntryIds.RevealTransition).Single();
+                page.SelectedEntry = reveal; TimelinePump(window);
+                var center = view.GetVisualDescendants().OfType<FieldEditorRow>().Single(row => row.Context?.Field.Id == "center");
+                Assert.That(new[] { center.Editor! }.Concat(center.Editor!.GetVisualDescendants()).OfType<StackPanel>().Any(panel => panel.Name == "ShaderVectorEditor"), Is.True);
+
+                var impact = workspace.InsertEntriesInto(group, 3, 1, BuiltinEntryIds.ImpactPreset).Single();
+                impact.Source.Parameters["program"] = JsonSerializer.SerializeToElement("program");
+                impact.RefreshAuthorReferences(scope.GetRequiredService<GalNet.Core.Entry.IEntryCatalog>());
+                page.SelectedEntry = impact; await query.PrepareAsync(); TimelinePump(window);
+                var impactParameters = view.GetVisualDescendants().OfType<FieldEditorRow>().Single(row => row.Context?.Field.Id == "parameters");
+                Assert.That(new[] { impactParameters.Editor! }.Concat(impactParameters.Editor!.GetVisualDescendants())
+                    .OfType<StackPanel>().Any(panel => panel.Name == "PresetShaderParameters"), Is.True);
+                return true;
+            }
+            finally { window.Close(); await projects.CloseAsync(); }
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task ShaderInspectorPreviewsSelectedProgramAndRefreshesAfterParameterEdit()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var assets = new MetadataAssets(); assets.File.Source = EffectPreviewSource;
+            using var resources = new MetadataResources(); using var services = EffectServices(assets, resources);
+            var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "ShaderPreview"), "Shader", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ApplyEffect).Single();
+            entry.Source.Parameters["program"] = JsonSerializer.SerializeToElement("program");
+            entry.Source.Parameters["parameters"] = JsonSerializer.Deserialize<JsonElement>("{\"amount\":0}");
+            scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
+            var query = scope.GetRequiredService<ProjectSceneTargets>(); await query.PrepareAsync();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = entry;
+            using var inspector = new EntryInspectorViewModel(page, sceneTargets: query, assets: assets);
+            var view = new EntryInspectorView { DataContext = inspector };
+            var window = new Window { Content = view, Width = 480, Height = 780 }; window.Show(); TimelinePump(window);
+            try
+            {
+                await inspector.PreviewLoading; TimelinePump(window);
+                Assert.That(inspector.ShaderPreviewError, Is.Null);
+                Assert.That(inspector.ShaderPreview, Is.Not.Null);
+                var previewPanel = view.GetVisualDescendants().OfType<Expander>().Single(control => control.Name == "ShaderPreviewPanel");
+                Assert.That(Grid.GetRow(previewPanel), Is.EqualTo(2), "The preview is docked below the scrollable fields.");
+                Assert.That(previewPanel.Parent, Is.TypeOf<Grid>());
+                var image = view.GetVisualDescendants().OfType<Image>().Single(control => control.Name == "ShaderEffectPreview");
+                Assert.That(image.Source, Is.SameAs(inspector.ShaderPreview));
+                using var beforeStream = new MemoryStream(); inspector.ShaderPreview!.Save(beforeStream); beforeStream.Position = 0;
+                using var before = SKBitmap.Decode(beforeStream);
+                Assert.That(before.Width, Is.EqualTo(ShaderEffectPreviewRenderer.Size));
+                Assert.That(before.Height, Is.EqualTo(ShaderEffectPreviewRenderer.Size));
+                Assert.That(before.GetPixel(64, 64).Red, Is.LessThan(10));
+
+                var form = view.GetVisualDescendants().OfType<DtoEditorHost>().Single(host => host.Name == "ShaderParameters");
+                var amount = form.GetVisualDescendants().OfType<FieldEditorRow>().Single(row => row.Context!.Field.Id == "amount");
+                Assert.That(await amount.Context!.CommitValueAsync(1f), Is.True);
+                await inspector.PreviewLoading; TimelinePump(window);
+                using var afterStream = new MemoryStream(); inspector.ShaderPreview!.Save(afterStream); afterStream.Position = 0;
+                using var after = SKBitmap.Decode(afterStream);
+                Assert.That(after.GetPixel(64, 64).Red, Is.GreaterThan(200));
+
+                assets.File.Source = EffectPreviewSource.Replace("color.r * amount", "color.r * (1 - amount)", StringComparison.Ordinal);
+                resources.RaiseChanged(); TimelinePump(window); await query.PrepareAsync(); TimelinePump(window);
+                await inspector.PreviewLoading; TimelinePump(window);
+                using var refreshedStream = new MemoryStream(); inspector.ShaderPreview!.Save(refreshedStream); refreshedStream.Position = 0;
+                using var refreshed = SKBitmap.Decode(refreshedStream);
+                Assert.That(refreshed.GetPixel(64, 64).Red, Is.LessThan(10));
+
+                entry.Source.Parameters["program"] = JsonSerializer.SerializeToElement("missing");
+                entry.RefreshAuthorReferences(scope.GetRequiredService<GalNet.Core.Entry.IEntryCatalog>());
+                await inspector.PreviewLoading; TimelinePump(window);
+                Assert.That(inspector.ShaderPreview, Is.Null);
+                Assert.That(inspector.ShaderPreviewError, Does.Contain("not found"));
+                return true;
+            }
+            finally { window.Close(); await projects.CloseAsync(); }
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task ShaderInspectorBuildsMetadataFieldsAndPatchesOnlySelectedParameter()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var assets = new MetadataAssets(); assets.File.Source = EffectEditorSource;
+            using var resources = new MetadataResources(); using var services = EffectServices(assets, resources);
+            var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "ShaderInspector"), "Shader", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ApplyEffect).Single();
+            entry.Source.Parameters["program"] = JsonSerializer.SerializeToElement("program");
+            entry.Source.Parameters["parameters"] = JsonSerializer.Deserialize<JsonElement>("{\"amount\":0.6,\"unknown\":[9007199254740993,null]}");
+            scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
+            var query = scope.GetRequiredService<ProjectSceneTargets>(); await query.PrepareAsync();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = entry;
+            using var inspector = new EntryInspectorViewModel(page, sceneTargets: query);
+            var view = new EntryInspectorView { DataContext = inspector };
+            var groupView = new GroupEditorPanelView { DataContext = page };
+            var layout = new Grid { ColumnDefinitions = new("45*,55*") }; layout.Children.Add(groupView); Grid.SetColumn(view, 1); layout.Children.Add(view);
+            var window = new Window { Content = layout, Width = 1200, Height = 900 }; window.Show(); TimelinePump(window);
+            try
+            {
+                Assert.That(entry.EffectInlineForm!.Item.Fields.Select(field => field.Id), Is.EqualTo(new[] { "program" }));
+                var inline = groupView.GetVisualDescendants().OfType<DtoEditorHost>().Single(host => ReferenceEquals(host.Item, entry.EffectInlineForm.Item));
+                Assert.That(inline.GetVisualDescendants().OfType<FieldEditorRow>().Select(row => row.Context!.Field.Id), Is.EqualTo(new[] { "program" }));
+                Assert.That(inspector.Form!.Item.Fields.Select(field => field.Id), Does.Not.Contain("id"));
+                Assert.That(inspector.ShaderForm!.Item.Fields.Select(field => field.Id), Is.EqualTo(new[] { "amount", "tint", "offset", "direction", "channels", "style", "mask" }));
+                Assert.That(view.GetVisualDescendants().OfType<DtoEditorHost>().Count(host => host.Item?.Fields.Any(field => field.Id == "parameters") == true), Is.Zero,
+                    "The shader inspector must not expose a second raw JSON editor.");
+                var form = view.GetVisualDescendants().OfType<DtoEditorHost>().Single(host => host.Name == "ShaderParameters");
+                var rows = form.GetVisualDescendants().OfType<FieldEditorRow>().ToDictionary(row => row.Context!.Field.Id);
+                Assert.That(rows.Keys, Is.EquivalentTo(new[] { "amount", "tint", "offset", "direction", "channels", "style", "mask" }));
+                Assert.That(rows["amount"].Editor, Is.InstanceOf<NumericUpDown>());
+                foreach (var (name, count) in new[] { ("offset", 2), ("direction", 3), ("channels", 4) })
+                {
+                    Assert.That(rows[name].Editor, Is.Not.Null);
+                    Assert.That(rows[name].Editor!.GetVisualDescendants().OfType<TextBox>().Count(), Is.EqualTo(count));
+                    Assert.That(rows[name].Editor!.GetVisualDescendants().OfType<Button>().Any(button => button.Name is "AddItem" or "RemoveItem" or "MoveItem"), Is.False);
+                }
+                Assert.That(entry.Source.Parameters["parameters"].TryGetProperty("style", out _), Is.False, "Metadata defaults must remain unprovided until edited.");
+                var old = rows["amount"].Context!;
+                var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+                Assert.That(await old.CommitValueAsync(.8f), Is.True);
+                var changed = entry.Source.Parameters["parameters"];
+                Assert.That(changed.GetProperty("amount").GetSingle(), Is.EqualTo(.8f));
+                Assert.That(changed.GetProperty("unknown")[0].GetInt64(), Is.EqualTo(9007199254740993L));
+                var vectorX = NumericControlTestSupport.NamedInputs(rows["direction"].Editor!, "ShaderVectorX").Single();
+                vectorX.Focus(); vectorX.Text = "2.5"; TimelinePump(window); PressGroupKey(vectorX, Key.Enter); TimelinePump(window);
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("direction").EnumerateArray().Select(value => value.GetSingle()), Is.EqualTo(new[] { 2.5f, 0f, 0f }));
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("unknown")[0].GetInt64(), Is.EqualTo(9007199254740993L));
+                Assert.That(history.CanUndo, Is.True);
+                await history.UndoAsync();
+                Assert.That(entry.Source.Parameters["parameters"].TryGetProperty("direction", out _), Is.False);
+                await history.UndoAsync();
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("amount").GetSingle(), Is.EqualTo(.6f));
+                var tint = rows["tint"].Editor!.GetVisualDescendants().OfType<TextBox>().Single(input => input.Name == "ColorHex");
+                tint.Focus(); tint.Text = "#11223344"; TimelinePump(window); PressGroupKey(tint, Key.Enter); TimelinePump(window);
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("tint").GetString(), Is.EqualTo("#11223344"));
+                assets.File.Source = EffectEditorSource.Replace("amount", "replacement", StringComparison.Ordinal);
+                resources.RaiseChanged(); TimelinePump(window); await query.PrepareAsync(); TimelinePump(window);
+                Assert.That(inspector.ShaderForm!.Item.Fields.Any(field => field.Id == "replacement"), Is.True);
+                Assert.That(await old.CommitValueAsync(.9f), Is.False, "Reloading metadata must retire the old field binding.");
+                entry.Source.Parameters["program"] = JsonSerializer.SerializeToElement("other");
+                entry.RefreshAuthorReferences(scope.GetRequiredService<GalNet.Core.Entry.IEntryCatalog>());
+                Assert.That(inspector.ShaderForm, Is.Null);
+                Assert.That(entry.Source.Parameters["parameters"].GetProperty("amount").GetSingle(), Is.EqualTo(.6f));
+                entry.Source.Parameters["program"] = JsonSerializer.SerializeToElement("");
+                entry.RefreshAuthorReferences(scope.GetRequiredService<GalNet.Core.Entry.IEntryCatalog>());
+                Assert.That(inspector.Form!.Item.Fields.Select(field => field.Id), Does.Contain("id"));
+                return true;
+            }
+            finally { window.Close(); await projects.CloseAsync(); }
+        }, CancellationToken.None);
+    }
+
     [Test]
     public async Task EffectMetadataLoadsOffQueryAndRefreshRejectsOldLeasesWithoutResurrectingDisposedProjects()
     {
@@ -84,10 +348,43 @@ public async Task EffectMetadataLoadsOffQueryAndRefreshRejectsOldLeasesWithoutRe
         Assert.That(assets.SynchronousReads, Is.Zero); await projects.CloseAsync();
     }
 
+    [Test]
+    public async Task AnimationPropertyChoicesFollowSelectedLayerAndShaderMetadata()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var assets = new MetadataAssets(); using var resources = new MetadataResources();
+            using var services = EffectServices(assets, resources); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "AnimationChoices"), "Choices", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            try
+            {
+                var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+                var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+                var layer = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ShowLayer).Single();
+                var fx = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.ApplyEffect).Single();
+                fx.Source.Parameters["program"] = JsonSerializer.SerializeToElement("program");
+                var animation = workspace.InsertEntriesInto(group, 2, 1, BuiltinEntryIds.Animate).Single();
+                scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
+                var catalog = scope.GetRequiredService<SceneTargetCatalog>();
+                await scope.GetRequiredService<ProjectSceneTargets>().PrepareAsync();
+                string[] Choices() => catalog.FieldOptions(group.Id, animation.StableId, animation.Type, "property")!.Select(option => option.Id).ToArray();
+                animation.Source.Parameters["handleId"] = layer.Source.Parameters["handleId"].Clone();
+                Assert.That(Choices(), Does.Contain("opacity")); Assert.That(Choices(), Does.Not.Contain("amount"));
+                animation.Source.Parameters["handleId"] = fx.Source.Parameters["instanceId"].Clone();
+                Assert.That(Choices(), Does.Contain("amount")); Assert.That(Choices(), Does.Contain("progress")); Assert.That(Choices(), Does.Not.Contain("opacity"));
+                animation.Source.Parameters["handleId"] = JsonSerializer.SerializeToElement("unknown");
+                Assert.That(Choices(), Is.Empty);
+            }
+            finally { await projects.CloseAsync(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
     [Test]
     public async Task EffectMetadataTimelineUsesRealPropertyMenuHistoryRefreshAndSaveReopen()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var assets = new MetadataAssets(); using var resources = new MetadataResources();
@@ -98,6 +395,7 @@ await ui.Dispatch<bool>(async () =>
             fx.Source.Parameters["program"] = JsonSerializer.SerializeToElement("program"); fx.Source.Parameters["parameters"] = JsonSerializer.Deserialize<JsonElement>("{\"amount\":0.6,\"unknown\":[9007199254740993,null]}");
             var timeline = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.PlayTimeline).Single();
             timeline.Source.Parameters["timeline"] = JsonSerializer.Deserialize<JsonElement>("{\"durationFrames\":20,\"tracks\":[],\"events\":[]}");
+            scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
             var query = scope.GetRequiredService<ProjectSceneTargets>(); await query.PrepareAsync();
             using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = timeline;
             var session = scope.GetRequiredService<TimelineEditSession>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
diff --git a/test/GalNet.Editor.Tests/EffectParameterProblemsTests.cs b/test/GalNet.Editor.Tests/EffectParameterProblemsTests.cs
new file mode 100644
index 00000000..8e89fcfb
--- /dev/null
+++ b/test/GalNet.Editor.Tests/EffectParameterProblemsTests.cs
@@ -0,0 +1,115 @@
+using System.Text;
+using System.Text.Json;
+using Avalonia.Headless;
+using GalNet.Contracts.Builtins;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.Shared.Visuals;
+using GalNet.Editor.ViewModels;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task TimelineProblemsUseKnownRadiusTargetAndRetainLegalOldShaderParametersWithoutWarnings()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); var shader = DefaultVisualTemplate.ReadShader("Blur");
+            using var assets = new MetadataAssets { File = { Source = shader } };
+            using var resources = new MetadataResources(); using var services = EffectServices(assets, resources);
+            var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "TimelineParameterProblems"), "Timeline", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var effect = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ApplyEffect).Single();
+            var unknown = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.ApplyEffect).Single();
+            var clip = workspace.InsertEntriesInto(group, 2, 1, BuiltinEntryIds.PlayTimeline).Single();
+            effect.Source.Parameters["program"] = JsonSerializer.SerializeToElement("program");
+            effect.Source.Parameters["instanceId"] = JsonSerializer.SerializeToElement("c2121d4d69544d4d8a584d392dfedbe6");
+            effect.Source.Parameters["parameters"] = JsonSerializer.SerializeToElement(new { radius = 32, angle = 0 });
+            unknown.Source.Parameters["program"] = JsonSerializer.SerializeToElement("unavailable");
+            clip.Source.Parameters["timeline"] = JsonSerializer.SerializeToElement(new
+            {
+                playbackHandleId = "play",
+                frameRate = 60,
+                durationFrames = 60,
+                tracks = new[] { new { handleId = "c2121d4d69544d4d8a584d392dfedbe6", property = "radius", blendMode = "Replace",
+                    keys = new[] { new { frame = 0, value = 32f, interpolationToNext = "Linear" }, new { frame = 10, value = 34.3f, interpolationToNext = "Linear" } } } },
+                events = new[] { new { frame = 8, type = BuiltinEntryIds.ShowLayer, editorId = "create", parameters = new { transform = new { }, z = 0, opacity = 1, displayMode = "Native", handleId = "new-layer" } } }
+            });
+            scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
+            var scenes = scope.GetRequiredService<ProjectSceneTargets>(); await scenes.PrepareAsync();
+            var problems = scope.GetRequiredService<ProblemsPanelViewModel>(); await AwaitAutomaticProblems(problems);
+            Assert.That(scope.GetRequiredService<ProjectLocalizationQuery>().Get()!.Issues, Is.Empty, "The unused angle is legal shader data.");
+            Assert.That(problems.Problems.Where(problem => problem.Code == "localization.field.opaque" && problem.Target?.EntryId == clip.StableId), Is.Empty);
+            Assert.That(scenes.Diagnostics().Where(issue => issue.Owner.EntryId == clip.StableId && issue.JsonPointer.Contains("/tracks/", StringComparison.Ordinal)), Is.Empty);
+
+            assets.File.Source = shader.Replace("@param radius", "@param amount", StringComparison.Ordinal);
+            scenes.InvalidateResources(); await scenes.PrepareAsync(); await AwaitAutomaticProblems(problems);
+            Assert.That(effect.Source.Parameters["parameters"].GetProperty("radius").GetInt32(), Is.EqualTo(32), "Old shader parameters remain author data.");
+            Assert.That(scope.GetRequiredService<ProjectLocalizationQuery>().Get()!.Issues.Where(issue => issue.EntryId == effect.StableId), Is.Empty,
+                "Preserved shader parameters are legal even when the current shader does not consume them.");
+            Assert.That(scenes.Diagnostics().Single(issue => issue.Owner.EntryId == clip.StableId && issue.JsonPointer.Contains("/tracks/", StringComparison.Ordinal)).Code,
+                Is.EqualTo("scene.reference.uncertain"), "The target shader no longer supports radius, so this remains a real warning.");
+            assets.File.Source = shader; scenes.InvalidateResources(); await scenes.PrepareAsync(); await AwaitAutomaticProblems(problems);
+            Assert.That(scenes.Diagnostics().Where(issue => issue.Owner.EntryId == clip.StableId && issue.JsonPointer.Contains("/tracks/", StringComparison.Ordinal)), Is.Empty);
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task EffectParameterProblemsFollowMetadataRefreshAndUnsavedShaderContent()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var assets = new MetadataAssets { File = { Source = EffectEditorSource } };
+            using var resources = new MetadataResources(); using var services = EffectServices(assets, resources);
+            var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "EffectParameterProblems"), "Effects", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var effect = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ApplyEffect).Single();
+            var audio = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.ApplyAudioSEffect).Single();
+            effect.Source.Parameters["program"] = JsonSerializer.SerializeToElement("program");
+            effect.Source.Parameters["parameters"] = JsonSerializer.SerializeToElement(new { amount = .5, direction = new[] { 1, 2, 3 } });
+            audio.Source.Parameters["id"] = JsonSerializer.SerializeToElement("seffect.reverb");
+            audio.Source.Parameters["targetId"] = JsonSerializer.SerializeToElement("bgm");
+            audio.Source.Parameters["parameters"] = JsonSerializer.SerializeToElement(new { mix = .4 });
+            scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
+            var scenes = scope.GetRequiredService<ProjectSceneTargets>(); await scenes.PrepareAsync();
+            var query = scope.GetRequiredService<ProjectLocalizationQuery>();
+            var index = query.Get()!; var revision = query.Revision;
+            Assert.That(index.Issues, Is.Empty);
+            var problems = scope.GetRequiredService<ProblemsPanelViewModel>(); await AwaitAutomaticProblems(problems);
+            Assert.That(problems.Problems.Where(problem => problem.Code?.StartsWith("localization.") == true), Is.Empty);
+
+            // The working shader overrides disk/asset bytes before Save All.
+            var files = scope.GetRequiredService<IProjectContentSession>();
+            var file = files.TrackFile("Assets/" + assets.File.Path, Encoding.UTF8.GetBytes(EffectEditorSource));
+            file.Data = Encoding.UTF8.GetBytes(EffectEditorSource.Replace("@param amount", "@param changed", StringComparison.Ordinal));
+            scenes.InvalidateResources(); await scenes.PrepareAsync();
+            var changed = query.Get()!;
+            Assert.That(query.Revision, Is.GreaterThan(revision));
+            Assert.That(changed.Issues, Is.Empty, "The old amount remains valid additional shader data.");
+            await AwaitAutomaticProblems(problems);
+            Assert.That(problems.Problems.Where(problem => problem.Code?.StartsWith("localization.") == true), Is.Empty);
+
+            file.Data = Encoding.UTF8.GetBytes("missing shader metadata");
+            scenes.InvalidateResources(); await scenes.PrepareAsync();
+            Assert.That(query.Get()!.Issues.Single().Code, Is.EqualTo("field.opaque"));
+            file.Data = Encoding.UTF8.GetBytes(EffectEditorSource);
+            scenes.InvalidateResources(); await scenes.PrepareAsync();
+            Assert.That(query.Get()!.Issues, Is.Empty);
+            await AwaitAutomaticProblems(problems);
+            Assert.That(problems.Problems.Where(problem => problem.Code?.StartsWith("localization.") == true), Is.Empty);
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/EntryAuthorBindingTests.cs b/test/GalNet.Editor.Tests/EntryAuthorBindingTests.cs
index 041315a7..85505897 100644
--- a/test/GalNet.Editor.Tests/EntryAuthorBindingTests.cs
+++ b/test/GalNet.Editor.Tests/EntryAuthorBindingTests.cs
@@ -25,7 +25,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task EntryFieldsUseProjectOrderAcrossMountedPagesAndSurvivePageCloseAndReopen()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -49,7 +49,7 @@ await session.Dispatch<bool>(async () =>
                 Assert.That(text.Source.Condition, Is.EqualTo("true"));
                 var form = view2.GetVisualDescendants().OfType<SchemaForm>().Single(item => item.Schema?.Any(field => field.Id == "duration") == true);
                 var field = form.Contexts.Single(context => context.Field.Id == "duration");
-                ((TextBox)form.Editors.Single(editor => editor.Context == field).Control).Text = "4.25"; Dispatcher.UIThread.RunJobs();
+                NumericControlTestSupport.Input(form.Editors.Single(editor => editor.Context == field).Control).Text = "4.25"; Dispatcher.UIThread.RunJobs();
                 Assert.That(await field.CommitTextAsync(), Is.True); Assert.That(wait.Source.Parameters["duration"].GetSingle(), Is.EqualTo(4.25f));
                 var content = view1.GetVisualDescendants().OfType<TextBox>().Single(input => input.Name == "GameTextInput");
                 content.Text = "Written through the author intent"; Dispatcher.UIThread.RunJobs();
@@ -108,7 +108,7 @@ public async Task EntryBindingsPreserveAuthorJsonAndRejectRemovedAndReplacedSche
         Assert.That(JsonElement.DeepEquals(original, JsonSerializer.SerializeToElement(source.Parameters)), Is.True);
         Assert.That(await field.CommitAsync(new(JsonSerializer.SerializeToElement(9)), CancellationToken.None), Is.Not.Null, "Undoing a type change must not revive an old field lease.");
         field = (IFieldBinding)entry.ParameterFields.Single(item => item.Id == "count");
-        var batch = new GroupEntryAuthoringService(store, documents, catalog, histories); histories.Clear(); batch.Delete("group", [entry.StableId]);
+        var batch = new GroupEntryAuthoringService(documents, catalog, histories); histories.Clear(); batch.Delete("group", [entry.StableId]);
         Assert.That(await field.CommitAsync(new(JsonSerializer.SerializeToElement(9)), CancellationToken.None), Is.Not.Null);
         await histories.Content.UndoAsync(); entry.ConfigureParameterFields(catalog, [], []);
         Assert.That(await field.CommitAsync(new(JsonSerializer.SerializeToElement(9)), CancellationToken.None), Is.Not.Null, "Undoing removal must not revive the old control lease.");
@@ -117,26 +117,24 @@ public async Task EntryBindingsPreserveAuthorJsonAndRejectRemovedAndReplacedSche
     }
 
     [TestCase(false), TestCase(true)]
-    public void EntryFieldNotificationsCompensateBeforeHistoryMoves(bool persistent)
+    public void EntryNotificationFailuresDoNotRollbackCommittedContent(bool persistent)
     {
         using var histories = new EditorHistories(); var documents = new EditorDocumentService();
         var source = new EditorEntryData { StableId = "line", Type = "custom.unknown" };
         documents.Load(new() { Document = new() { Nodes = [new() { Id = "group", Type = "Group", File = "groups/group.rawgalgroup" }] }, GroupEntries = { ["group"] = [source] } });
-        var authoring = new EntryFieldAuthoringService(documents, histories); var fail = true;
-        void Fail(string _) { if (persistent || fail) { fail = false; throw new IOException("entry observer"); } }
-        authoring.Changed += Fail;
-        try
-        {
-            if (persistent) Assert.Throws<HistoryRepairRequiredException>(() => authoring.SetCondition("group", source, "true"));
-            else Assert.Throws<IOException>(() => authoring.SetCondition("group", source, "true"));
-            Assert.That(source.Condition, Is.Empty); Assert.That(histories.Content.CanUndo, Is.False); Assert.That(histories.Content.RepairRequired, Is.EqualTo(persistent));
-        }
-        finally { authoring.Changed -= Fail; }
-        if (!persistent)
-        {
-            authoring.SetCondition("group", source, "true"); source.Condition = "outside";
-            Assert.Throws<EditorOperationException>(() => histories.Content.Undo());
-            Assert.That(histories.Content.CanUndo, Is.True); Assert.That(source.Condition, Is.EqualTo("outside"));
-        }
+        var authoring = new EntryFieldAuthoringService(documents, histories); var fail = true; var notified = 0;
+        void Fail(GalNet.Editor.Abstraction.Changes.AuthorChangeSet _) { if (persistent || fail) { fail = false; throw new IOException("entry observer"); } }
+        histories.Content.AuthorChanges.Committed += Fail;
+        histories.Content.AuthorChanges.Committed += _ => notified++;
+        authoring.SetCondition("group", source, "true");
+        Assert.That(source.Condition, Is.EqualTo("true")); Assert.That(histories.Content.CanUndo, Is.True);
+        Assert.That(histories.Content.AuthorChanges.LastNotificationError, Is.TypeOf<IOException>());
+        Assert.That(histories.Content.RepairRequired, Is.False); Assert.That(notified, Is.EqualTo(1));
+        histories.Content.Undo(); Assert.That(source.Condition, Is.Empty); Assert.That(notified, Is.EqualTo(2));
+        histories.Content.Redo(); Assert.That(source.Condition, Is.EqualTo("true"));
+        source.Condition = "outside";
+        Assert.Throws<EditorOperationException>(() => histories.Content.Undo());
+        Assert.That(histories.Content.CanUndo, Is.True); Assert.That(source.Condition, Is.EqualTo("outside"));
+        Assert.That(notified, Is.EqualTo(3), "Failed writes do not publish or advance the committed version.");
     }
 }
diff --git a/test/GalNet.Editor.Tests/EntryIdentityLifecycleTests.cs b/test/GalNet.Editor.Tests/EntryIdentityLifecycleTests.cs
new file mode 100644
index 00000000..60a21cc1
--- /dev/null
+++ b/test/GalNet.Editor.Tests/EntryIdentityLifecycleTests.cs
@@ -0,0 +1,255 @@
+using System.Text.Json;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Entry;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Abstraction.Changes;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task PendingCutMovesOncePreservesHandlesResolvesAddressCollisionsAndCopiesExpiredTickets()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "PendingEntryMove"), "Move", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+        var source = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var creator = workspace.InsertEntriesInto(source, 0, 1, BuiltinEntryIds.ShowColorLayer).Single();
+        creator.Source.Parameters["future"] = JsonSerializer.Deserialize<JsonElement>("[null,9007199254740993,{\"kept\":true}]");
+        var handle = creator.Source.Parameters["handleId"].GetString();
+        var consumer = workspace.InsertEntriesInto(source, 1, 1, BuiltinEntryIds.HideLayer).Single();
+        consumer.Parameters = new() { ["handleId"] = handle! };
+        var target = await workspace.AddNodeAsync(GraphNodeKind.LinearGroup, 500, 250);
+        var collision = workspace.InsertEntriesInto(target, 0, 1, BuiltinEntryIds.Wait).Single();
+        collision.Source.StableId = creator.StableId;
+        var author = scope.GetRequiredService<GroupEntryAuthoringService>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+        var notifications = new List<AuthorChangeSet>(); history.AuthorChanges.Committed += notifications.Add;
+        var cut = author.PrepareCut(source.Id, [creator.StableId])!; author.BeginCut(cut);
+        Assert.That(source.Entries, Has.Count.EqualTo(2)); Assert.That(history.CanUndo, Is.False);
+        Assert.That(author.IsPendingMove(source.Id, creator.StableId), Is.True);
+        var canceled = await author.PasteAsync(target.Id, cut.Text, null, _ => Task.FromResult(false));
+        Assert.That(canceled, Is.Empty); Assert.That(author.HasPendingMove, Is.True); Assert.That(history.CanUndo, Is.False);
+        var movedId = (await author.PasteAsync(target.Id, cut.Text, null)).Single();
+        var moved = target.Entries.Single(entry => entry.StableId == movedId);
+        Assert.That(moved.StableId, Is.Not.EqualTo(creator.StableId)); Assert.That(moved.Source.Parameters["handleId"].GetString(), Is.EqualTo(handle));
+        Assert.That(consumer.Source.Parameters["handleId"].GetString(), Is.EqualTo(handle)); Assert.That(author.HasPendingMove, Is.False);
+        Assert.That(moved.Source.Parameters["future"][1].GetInt64(), Is.EqualTo(9007199254740993L));
+        Assert.That(notifications, Has.Count.EqualTo(1));
+        Assert.That(notifications[0].Moves.Single(), Is.EqualTo(new AuthorEntryMove(source.Id, creator.StableId, target.Id, moved.StableId)));
+        await history.UndoAsync(); Assert.That(source.Entries[0], Is.SameAs(creator)); Assert.That(target.Entries, Has.Count.EqualTo(1));
+        Assert.That(notifications.Last().Moves.Single().SourceGroupId, Is.EqualTo(target.Id));
+        await history.RedoAsync(); Assert.That(target.Entries.Last().StableId, Is.EqualTo(moved.StableId));
+        var repeatedId = (await author.PasteAsync(target.Id, cut.Text, null)).Single();
+        var repeated = target.Entries.Single(entry => entry.StableId == repeatedId);
+        Assert.That(author.LastPasteCopiedMove, Is.True); Assert.That(repeated.Source.Parameters["handleId"].GetString(), Is.Not.EqualTo(handle));
+        var next = author.PrepareCut(target.Id, [moved.StableId])!; author.BeginCut(next);
+        moved.Condition = "true"; Assert.That(author.HasPendingMove, Is.False);
+        var copiedId = (await author.PasteAsync(source.Id, next.Text, null)).Single();
+        var copied = source.Entries.Single(entry => entry.StableId == copiedId);
+        Assert.That(author.LastPasteCopiedMove, Is.True); Assert.That(copied.Source.Parameters["handleId"].GetString(), Is.Not.EqualTo(handle));
+        await workspace.SaveAsync(); var path = project.RootPath; var targetId = target.Id;
+        await projects.CloseAsync(); project = await projects.OpenAsync(path);
+        Assert.That(project.Services.GetRequiredService<IEditorDocumentService>().Groups[targetId].Entries.Single(entry => entry.StableId == movedId).Parameters["handleId"].GetString(), Is.EqualTo(handle));
+        await projects.CloseAsync();
+        project = await projects.CreateAsync(Path.Combine(_root, "ForeignMoveProject"), "Foreign", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var foreignGroup = project.Services.GetRequiredService<EditorWorkspaceViewModel>().Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var foreignAuthor = project.Services.GetRequiredService<GroupEntryAuthoringService>();
+        var foreignId = (await foreignAuthor.PasteAsync(foreignGroup.Id, next.Text, null)).Single();
+        var foreign = foreignGroup.Entries.Single(entry => entry.StableId == foreignId);
+        Assert.That(foreignAuthor.LastPasteCopiedMove, Is.True); Assert.That(foreign.Source.Parameters["handleId"].GetString(), Is.Not.EqualTo(handle));
+        await projects.CloseAsync();
+    }
+
+    [Test]
+    public async Task DeletedInputDoesNotBlockSaveAndUndoRestoresOnlyThroughNewBindingWithDurableRecovery()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "InputArchive"), "Inputs", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.Wait).Single();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+            var inputs = scope.GetRequiredService<EntryEditSession>(); var field = entry.DetailForm!.Fields.Single();
+            var oldBinding = entry.DetailForm.Binding(field); var old = oldBinding.Draft!;
+            old.Update("2.5", true, null, false);
+            var author = scope.GetRequiredService<GroupEntryAuthoringService>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+            var preview = author.PrepareDelete(group.Id, [entry.StableId])!;
+            Assert.That(preview.Impact.ArchivedInputs, Is.EqualTo(1));
+            old.Update("3.5", true, null, false); Assert.Throws<EditorOperationException>(preview.Commit);
+            author.Delete(group.Id, [entry.StableId]);
+            Assert.That(inputs.PendingCount, Is.Zero); Assert.That(inputs.Archives.Single().Text, Is.EqualTo("3.5"));
+            Assert.That(old.CanCommit, Is.False); Assert.That(await old.Commit!(), Is.Not.Null);
+            await workspace.SaveAsync(); Assert.That(scope.GetRequiredService<IProjectContentSession>().IsDirty, Is.False);
+            await history.UndoAsync(); Assert.That(inputs.PendingCount, Is.Zero); Assert.That(oldBinding.Draft, Is.Null);
+            var archive = inputs.Archives.Single(); Assert.That(inputs.CanRestore(archive), Is.True);
+            var problems = scope.GetRequiredService<ProblemsPanelViewModel>();
+            var recovery = problems.Problems.Single(problem => problem.InputText == "3.5"); Assert.That(recovery.HasRestore, Is.True);
+            var view = new ProblemsPanelView { DataContext = problems }; var window = new Window { Content = view, Width = 700, Height = 450 }; window.Show(); Dispatcher.UIThread.RunJobs();
+            Assert.That(view.GetVisualDescendants().OfType<TextBox>().Any(input => input.IsReadOnly && input.Text == "3.5"), Is.True); window.Close();
+            inputs.RequestRestore(archive);
+            var fresh = entry.DetailForm!.Binding(entry.DetailForm.Fields.Single()).Draft!;
+            Assert.That(fresh, Is.Not.SameAs(old)); Assert.That(fresh.Text, Is.EqualTo("3.5")); Assert.That(fresh.IsConflicted, Is.False);
+            Assert.That(inputs.Archives, Is.Empty); Assert.That(inputs.PendingCount, Is.EqualTo(1));
+            await workspace.SaveAsync(); Assert.That(entry.Source.Parameters[field.Id].GetSingle(), Is.EqualTo(3.5f));
+            fresh.Update("invalid retained input", true, new ValueIssue("value.type", "invalid"), false);
+            author.Delete(group.Id, [entry.StableId]); await workspace.SaveAsync(); history.Clear();
+            Assert.That(inputs.Archives.Single().Text, Is.EqualTo("invalid retained input"));
+            var path = project.RootPath; await projects.CloseAsync(); project = await projects.OpenAsync(path);
+            var reopened = project.Services.GetRequiredService<EntryEditSession>();
+            Assert.That(reopened.Archives.Single().Text, Is.EqualTo("invalid retained input")); Assert.That(reopened.PendingCount, Is.Zero);
+            reopened.RemoveArchive(reopened.Archives.Single()); await projects.CloseAsync();
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task InputArchiveBudgetAndIoFailureRejectBeforeDeletingAuthorOrDetachingInput()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "InputLimits"), "Inputs", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.Wait).Single();
+        using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+        var content = scope.GetRequiredService<IProjectContentSession>(); var documents = scope.GetRequiredService<IEditorDocumentService>();
+        var texts = scope.GetRequiredService<GameTextAuthoringService>(); var history = scope.GetRequiredService<EditorHistories>(); history.Clear();
+        using (var limited = new EntryEditSession(content, texts, scope.GetRequiredService<IEditorLocalizationService>(), documents, projects, new(0, 1024)))
+        {
+            var state = limited.Get(entry, entry.DetailForm!.Fields.Single()); state.Update("retained", true, null, false);
+            using var author = new GroupEntryAuthoringService(documents, scope.GetRequiredService<IEntryCatalog>(), history, texts, limited);
+            Assert.Throws<EditorOperationException>(() => author.Delete(group.Id, [entry.StableId]));
+            Assert.That(group.Entries, Has.Count.EqualTo(1)); Assert.That(limited.PendingCount, Is.EqualTo(1)); Assert.That(limited.Archives, Is.Empty);
+            Assert.That(history.Content.CanUndo, Is.False); state.Clear();
+        }
+        var inputs = scope.GetRequiredService<EntryEditSession>(); var draft = inputs.Get(entry, entry.DetailForm!.Fields.Single()); draft.Update("4", true, null, false);
+        var archivePath = Path.Combine(project.RootPath, ".galnet", "editor", "input-archive.json"); Directory.CreateDirectory(archivePath);
+        var failure = Assert.Catch(() => scope.GetRequiredService<GroupEntryAuthoringService>().Delete(group.Id, [entry.StableId]));
+        Assert.That(failure, Is.InstanceOf<IOException>().Or.InstanceOf<UnauthorizedAccessException>());
+        Assert.That(group.Entries, Has.Count.EqualTo(1)); Assert.That(inputs.PendingCount, Is.EqualTo(1)); Assert.That(inputs.Archives, Is.Empty);
+        Assert.That(history.Content.CanUndo, Is.False); Assert.That(draft.CanCommit, Is.True);
+        Directory.Delete(archivePath); draft.Clear();
+        File.WriteAllText(archivePath, "{broken recovery");
+        using (var corrupt = new EntryEditSession(content, texts, scope.GetRequiredService<IEditorLocalizationService>(), documents, projects))
+        {
+            var retained = corrupt.Get(entry, entry.DetailForm!.Fields.Single()); retained.Update("preserved after corruption", true, null, false);
+            using var author = new GroupEntryAuthoringService(documents, scope.GetRequiredService<IEntryCatalog>(), history, texts, corrupt);
+            Assert.Throws<EditorOperationException>(() => author.Delete(group.Id, [entry.StableId]));
+            Assert.That(corrupt.ArchiveError, Is.Not.Null); Assert.That(corrupt.PendingCount, Is.EqualTo(1)); Assert.That(group.Entries, Has.Count.EqualTo(1));
+            Assert.That(File.ReadAllText(archivePath), Is.EqualTo("{broken recovery")); retained.Clear();
+        }
+        File.Delete(archivePath); await projects.CloseAsync();
+    }
+
+    [Test]
+    public async Task FailedCompositeRestoresLiveInputsWhileSuccessfulTypeUndoOnlyOffersArchivedInput()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "InputCompensation"), "Inputs", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.Wait).Single();
+        using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+        var inputs = scope.GetRequiredService<EntryEditSession>(); var state = inputs.Get(entry, entry.DetailForm!.Fields.Single()); state.Update("7", true, null, false);
+        var fields = scope.GetRequiredService<EntryFieldAuthoringService>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+        var operation = new EntryDraftLifecycleEdit(inputs, new DelegateEdit("type", () => entry.Source.Type = BuiltinEntryIds.Wait, () => entry.Source.Type = BuiltinEntryIds.HideLayer),
+            [new(new(group.Id, entry.StableId), new(group.Id, entry.StableId))], history.AuthorChanges);
+        Assert.Throws<IOException>(() => history.Execute(new CompositeEdit("fail", [operation, new DelegateEdit("fail", () => { }, () => throw new IOException("injected"))])));
+        Assert.That(entry.Type, Is.EqualTo(BuiltinEntryIds.Wait)); Assert.That(inputs.PendingCount, Is.EqualTo(1)); Assert.That(inputs.Archives, Is.Empty);
+        Assert.That(state.CanCommit, Is.True); Assert.That(state.IsConflicted, Is.False); Assert.That(history.CanUndo, Is.False); Assert.That(history.RepairRequired, Is.False);
+        fields.SetType(group.Id, entry.Source, BuiltinEntryIds.HideLayer, new());
+        Assert.That(inputs.PendingCount, Is.Zero); Assert.That(inputs.Archives.Single().Text, Is.EqualTo("7"));
+        await history.UndoAsync(); Assert.That(inputs.PendingCount, Is.Zero); Assert.That(inputs.CanRestore(inputs.Archives.Single()), Is.True);
+        Assert.That(state.CanCommit, Is.False); await workspace.SaveAsync(); await projects.CloseAsync();
+    }
+
+    [Test]
+    public async Task MoveArchivesFollowBothAddressDirectionsAndExpiredOfferCannotReviveAfterUndo()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "MovingInputs"), "Inputs", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var source = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var entries = workspace.InsertEntriesInto(source, 0, 3, BuiltinEntryIds.Wait).ToArray(); var target = await workspace.AddNodeAsync(GraphNodeKind.LinearGroup, 500, 200);
+        using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, source.Id);
+        var author = scope.GetRequiredService<GroupEntryAuthoringService>(); var inputs = scope.GetRequiredService<EntryEditSession>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+        var offer = author.PrepareCut(source.Id, [entries[0].StableId])!;
+        entries[0].Condition = "true"; await history.UndoAsync();
+        Assert.Throws<EditorOperationException>(() => author.BeginCut(offer), "Equal JSON restored by Undo cannot revive a clipboard offer.");
+        history.Clear(); offer = author.PrepareCut(source.Id, [entries[0].StableId])!; author.BeginCut(offer);
+        await author.PasteAsync(source.Id, offer.Text, entries[2].StableId);
+        Assert.That(source.Entries.Last(), Is.SameAs(entries[0])); await history.UndoAsync(); Assert.That(source.Entries, Is.EqualTo(entries));
+        history.Clear(); var old = inputs.Get(entries[0], entries[0].DetailForm!.Fields.Single()); old.Update("6", true, null, false);
+        offer = author.PrepareCut(source.Id, [entries[0].StableId])!; author.BeginCut(offer);
+        var movedId = (await author.PasteAsync(target.Id, offer.Text, null)).Single();
+        var moved = target.Entries.Single(entry => entry.StableId == movedId);
+        Assert.That(inputs.PendingCount, Is.Zero); Assert.That(inputs.Archives.Single().Owner.GroupId, Is.EqualTo(target.Id));
+        Assert.That(inputs.CanRestore(inputs.Archives.Single()), Is.True); Assert.That(old.CanCommit, Is.False);
+        await history.UndoAsync(); Assert.That(inputs.Archives.Single().Owner.GroupId, Is.EqualTo(source.Id));
+        Assert.That(inputs.CanRestore(inputs.Archives.Single()), Is.True);
+        await history.RedoAsync(); Assert.That(inputs.Archives.Single().Owner.EntryId, Is.EqualTo(moved.StableId));
+        var archive = inputs.Archives.Single();
+        using var targetPage = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, target.Id);
+        inputs.RequestRestore(archive); var fresh = moved.DetailForm!.Binding(moved.DetailForm.Fields.Single()).Draft!;
+        Assert.That(fresh.Text, Is.EqualTo("6")); Assert.That(fresh.CanCommit, Is.True); Assert.That(fresh.IsConflicted, Is.False);
+        await workspace.SaveAsync(); await projects.CloseAsync();
+    }
+
+    [Test]
+    public async Task NestedAndLocalizedArchivedInputsUseTheirOriginalRootBaselineAndNewChildBindings()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "NestedArchivedInputs"), "Inputs", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var layer = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ShowColorLayer).Single();
+        var text = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.Text).Single();
+        text.Parameters = new() { ["content"] = "" };
+        using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+        var inputs = scope.GetRequiredService<EntryEditSession>(); var author = scope.GetRequiredService<GroupEntryAuthoringService>(); var history = scope.GetRequiredService<EditorHistories>().Content;
+        var transform = layer.DetailForm!.Fields.Single(field => field.Id == "transform");
+        var root = inputs.Get(layer, transform); var childField = new FieldDescriptor("x", new(typeof(float)));
+        var child = root.Child!(childField, "x"); child.Update("8.25", true, null, false);
+        var content = text.DetailForm!.Fields.Single(field => field.Id == "content"); inputs.Get(text, content).Update("recovered localized text", true, null, false);
+        history.Clear(); author.Delete(group.Id, [layer.StableId, text.StableId]);
+        Assert.That(inputs.Archives, Has.Count.EqualTo(2)); Assert.That(inputs.Archives.All(record => !inputs.CanRestore(record)), Is.True);
+        await history.UndoAsync(); Assert.That(inputs.Archives.All(inputs.CanRestore), Is.True);
+        foreach (var record in inputs.Archives.ToArray()) inputs.RequestRestore(record);
+        var newRoot = inputs.Get(layer, layer.DetailForm!.Fields.Single(field => field.Id == "transform"));
+        var restoredChild = newRoot.Child!(childField, "x");
+        Assert.That(restoredChild.Text, Is.EqualTo("8.25")); Assert.That(restoredChild.IsConflicted, Is.False); Assert.That(child.CanCommit, Is.False);
+        var restoredText = inputs.Get(text, text.DetailForm!.Fields.Single(field => field.Id == "content"));
+        Assert.That(restoredText.Text, Is.EqualTo("recovered localized text")); Assert.That(inputs.Archives, Is.Empty);
+        await workspace.SaveAsync();
+        Assert.That(layer.Source.Parameters["transform"].EnumerateObject().Single(property => property.Name.Equals("x", StringComparison.OrdinalIgnoreCase)).Value.GetSingle(), Is.EqualTo(8.25f));
+        var key = text.Source.Parameters["content"].GetString()!;
+        Assert.That(scope.GetRequiredService<GameTextAuthoringService>().Read(key), Is.EqualTo("recovered localized text"));
+        await projects.CloseAsync();
+    }
+
+    [TestCase(false), TestCase(true)]
+    public async Task InputRollbackFailureAlwaysReleasesHistoryGateAndRequiresRepair(bool asynchronous)
+    {
+        using var history = new UndoRedoHistory();
+        var edit = new DelegateEdit("injected rollback", () => { }, () =>
+        {
+            history.AuthorChanges.OnRollback(() => throw new IOException("recovery rollback failed"));
+            throw new IOException("author step failed");
+        });
+        if (asynchronous) Assert.ThrowsAsync<HistoryRepairRequiredException>(async () => await history.ExecuteAsync(edit));
+        else Assert.Throws<HistoryRepairRequiredException>(() => history.Execute(edit));
+        Assert.That(history.RepairRequired, Is.True); Assert.That(history.IsBusy, Is.False); Assert.That(history.CanUndo, Is.False);
+        var blocked = Assert.Throws<InvalidOperationException>(() => history.Execute(new DelegateEdit("later", () => { }, () => { })));
+        Assert.That(blocked!.Message, Does.Contain("repair"));
+        await Task.CompletedTask;
+    }
+}
diff --git a/test/GalNet.Editor.Tests/EntrySchemaFormTests.cs b/test/GalNet.Editor.Tests/EntrySchemaFormTests.cs
index 9dbffe4e..3bf50529 100644
--- a/test/GalNet.Editor.Tests/EntrySchemaFormTests.cs
+++ b/test/GalNet.Editor.Tests/EntrySchemaFormTests.cs
@@ -17,6 +17,8 @@
 using GalNet.Editor.Shared.Services;
 using GalNet.Game.Controls.Forms;
 
+[assembly: AvaloniaTestApplication(typeof(GeneralTest.Editor.EditorFormTestApplication))]
+
 namespace GeneralTest.Editor;
 
 [NonParallelizable]
@@ -36,11 +38,11 @@ public async Task ParticleDtoCanBeAuthoredInEitherOrderWhileFullCompilationStill
         var second = payloadFirst ? id : payload;
         Assert.That(await first.CommitAsync(new(payloadFirst ? Json("{\"particleTexture\":\"snow\"}") : Json("\"snow\"")), default), Is.Null);
         var incomplete = new EditorDocumentRepository(catalog).SerializeEntry(new EditorEntryData { StableId = entry.StableId, Type = entry.Type, Parameters = entry.Source.Parameters });
-        Assert.That(() => PrimitiveArgumentHelper.Normalize(catalog.Get(entry.Type).DynamicParameters!, JsonSerializer.SerializeToElement(incomplete.Parameters)),
+        Assert.That(() => PrimitiveArgumentHelper.Normalize(catalog.Get(entry.Type).DynamicParameters, JsonSerializer.SerializeToElement(incomplete.Parameters)),
             Throws.TypeOf<InvalidDataException>());
         Assert.That(await second.CommitAsync(new(payloadFirst ? Json("\"snow\"") : Json("{\"particleTexture\":\"snow\"}")), default), Is.Null);
         var saved = new EditorDocumentRepository(catalog).SerializeEntry(new EditorEntryData { StableId = entry.StableId, Type = entry.Type, Parameters = entry.Source.Parameters });
-        Assert.That(() => PrimitiveArgumentHelper.Normalize(catalog.Get(entry.Type).DynamicParameters!, JsonSerializer.SerializeToElement(saved.Parameters)), Throws.Nothing);
+        Assert.That(() => PrimitiveArgumentHelper.Normalize(catalog.Get(entry.Type).DynamicParameters, JsonSerializer.SerializeToElement(saved.Parameters)), Throws.Nothing);
     }
 
     [Test]
@@ -87,7 +89,7 @@ public async Task GeneratedDocumentFieldsPreservePresenceAndCanRepairValuesWitho
     [Test]
     public async Task ProjectMetadataPreservesLargeIntegersConvertersAndTypedJsonOnSave()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             var options = new JsonSerializerOptions { Converters = { new JsonStringEnumConverter() } };
@@ -119,7 +121,10 @@ await session.Dispatch<bool>(async () =>
                 Assert.That(entry.Parameters["count"], Is.EqualTo("9007199254740993"));
                 input.Text = "9007199254740995";
                 Assert.That(await form.Contexts[0].CommitTextAsync(), Is.True);
-                ((CheckBox)form.Editors[2].Control).IsChecked = false;
+                var checkbox = (CheckBox)form.Editors[2].Control;
+                Assert.That(checkbox.VerticalAlignment, Is.EqualTo(Avalonia.Layout.VerticalAlignment.Center));
+                Assert.That(checkbox.VerticalContentAlignment, Is.EqualTo(Avalonia.Layout.VerticalAlignment.Center));
+                checkbox.IsChecked = false;
                 ((ComboBox)form.Editors[1].Control).SelectedItem = form.Contexts[1].Options.Single(item => item.Value.GetString() == "Friday");
                 var saved = new EditorDocumentRepository(catalog).SerializeEntry(new EditorEntryData
                 { StableId = entry.StableId, Type = entry.Type, Parameters = entry.Source.Parameters });
@@ -136,7 +141,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task OmittedDefaultAndExplicitNullableNumberStayDistinctAndOldSchemaCannotCommit()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             var table = new DynamicParameterTable([new("count", typeof(int), defaultValue: Json("5")), new("optional", typeof(int?), allowNull: true)]);
@@ -149,7 +154,7 @@ await session.Dispatch<bool>(async () =>
             try
             {
                 Assert.That(form.Contexts[0].Value.IsProvided, Is.False);
-                Assert.That(((TextBox)form.Editors[0].Control).Text, Is.EqualTo("5"));
+                Assert.That(NumericControlTestSupport.Input(form.Editors[0].Control).Text, Is.EqualTo("5"));
                 Assert.That(form.Contexts[1].Value.Json!.Value.ValueKind, Is.EqualTo(JsonValueKind.Null));
                 Assert.That(entry.Parameters.ContainsKey("count"), Is.False);
                 form.Contexts[0].Text = "7";
diff --git a/test/GalNet.Editor.Tests/EntryTypeShortcutTests.cs b/test/GalNet.Editor.Tests/EntryTypeShortcutTests.cs
index fbfc2cbc..472ff893 100644
--- a/test/GalNet.Editor.Tests/EntryTypeShortcutTests.cs
+++ b/test/GalNet.Editor.Tests/EntryTypeShortcutTests.cs
@@ -1,8 +1,8 @@
 using Avalonia.Input;
 using GalNet.Contracts.Builtins;
 using GalNet.Core.Entry;
-using GalNet.Core.Settings;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Abstraction.Settings;
 using GalNet.Editor.Commands;
 using GalNet.Primitives.Builtins;
 
diff --git a/test/GalNet.Editor.Tests/ExternalDebugTests.cs b/test/GalNet.Editor.Tests/ExternalDebugTests.cs
index 0cc0e03f..5d4a70d9 100644
--- a/test/GalNet.Editor.Tests/ExternalDebugTests.cs
+++ b/test/GalNet.Editor.Tests/ExternalDebugTests.cs
@@ -27,7 +27,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task ExternalDebugPanelConnectsThroughTcpEditsRuntimeValuesAndKeepsAuthorHistoryClean()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme();
diff --git a/test/GalNet.Editor.Tests/ExternalProjectHotReloadTests.cs b/test/GalNet.Editor.Tests/ExternalProjectHotReloadTests.cs
new file mode 100644
index 00000000..bedb5b1e
--- /dev/null
+++ b/test/GalNet.Editor.Tests/ExternalProjectHotReloadTests.cs
@@ -0,0 +1,154 @@
+using System.Text;
+using System.Text.Json.Nodes;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Documents;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Dock;
+using GalNet.Editor.History;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.Shared.Commands;
+using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task ExternalFileWatcherUpdatesTheMountedGroupAndRetainsItsPageSelectionAndScope()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "LiveExternal"), "Live", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.Wait).Single();
+            await project.Services.GetRequiredService<IProjectContentSession>().SaveAsync();
+            var dock = project.Services.GetRequiredService<EditorDockFactory>(); var layout = dock.CreateLayout(); dock.InitLayout(layout); dock.OpenGroupEditor(group);
+            var page = TimelineDockables(layout).Select(item => item.Context).OfType<GroupEditorPanelViewModel>().Single(); page.SelectedEntry = entry;
+            var monitor = project.Services.GetRequiredService<ProjectExternalChanges>();
+            await monitor.CheckNowAsync(); monitor.Start();
+            var view = new GroupEditorPanelView { DataContext = page }; var window = new Window { Width = 1100, Height = 700, Content = view }; window.Show();
+            try
+            {
+                var path = Path.Combine(project.RootPath, "Graph", group.Source.File!);
+                var json = JsonNode.Parse(File.ReadAllText(path))!; json["entries"]![0]!["parameters"]!["duration"] = 2;
+                var inserted = json["entries"]![0]!.DeepClone(); inserted["id"] = "externally-inserted";
+                json["entries"]!.AsArray().Insert(0, inserted);
+                File.WriteAllText(path, json.ToJsonString());
+                using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(12));
+                while (monitor.State != ExternalProjectState.Reloaded) await Task.Delay(50, timeout.Token);
+                window.UpdateLayout();
+                Assert.That(projects.Current, Is.SameAs(project)); Assert.That(workspace.Nodes.Single(node => node.Id == group.Id), Is.SameAs(group));
+                Assert.That(page.SelectedEntry, Is.SameAs(entry)); Assert.That(page.IsDisposed, Is.False);
+                Assert.That(entry.Source.Parameters["duration"].GetSingle(), Is.EqualTo(2));
+                Assert.That(entry.Parameters["duration"], Is.EqualTo("2"));
+                Assert.That(entry.Id, Is.EqualTo(2)); Assert.That(group.Entries, Has.Count.EqualTo(2));
+                Assert.That(project.Services.GetRequiredService<IProjectContentSession>().IsDirty, Is.False);
+                Assert.That(project.Services.GetRequiredService<EditorHistories>().Content.CanUndo, Is.False);
+            }
+            finally { window.Close(); await projects.CloseAsync(); }
+            Assert.That(await monitor.CheckNowAsync(), Is.EqualTo(ExternalReloadResult.Unavailable));
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task ExternalReloadPreservesSettingsDraftUntilExplicitDiscardAndRefreshesOpenTextEncoding()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "ExternalConflict"), "Original", new(), Contracts());
+            var content = project.Services.GetRequiredService<IProjectContentSession>();
+            var settings = project.Services.GetRequiredService<ProjectSettingsPanelViewModel>();
+            var notes = Path.Combine(project.RootPath, "notes.txt"); File.WriteAllText(notes, "before");
+            var buffer = project.Services.GetRequiredService<ProjectTextFiles>().Open("notes.txt");
+            var monitor = project.Services.GetRequiredService<ProjectExternalChanges>(); await monitor.CheckNowAsync();
+            await Stage(settings, "defaultWidth", 1700); buffer.Text = "unsaved input";
+            var edited = await new ProjectEditService(project.RootPath, project.Services.GetRequiredService<IEntryCatalog>()).ExecuteAsync([new GalNet.Editor.Abstraction.Commands.RenameProjectCommand("External")]);
+            Assert.That(edited.Success, Is.True);
+            File.WriteAllText(notes, "外部 text", Encoding.Unicode);
+            Assert.That(await monitor.CheckNowAsync(), Is.EqualTo(ExternalReloadResult.LocalChanges));
+            Assert.That(Setting(settings, "defaultWidth").Read().Json!.Value.GetInt32(), Is.EqualTo(1700)); Assert.That(buffer.Text, Is.EqualTo("unsaved input"));
+            Assert.That(await monitor.CheckNowAsync(true), Is.EqualTo(ExternalReloadResult.Reloaded));
+            Assert.That(settings.ProjectName, Is.EqualTo("External")); Assert.That(Setting(settings, "defaultWidth").Read().Json!.Value.GetInt32(), Is.EqualTo(1920));
+            Assert.That(buffer.Text, Is.EqualTo("外部 text")); Assert.That(buffer.Information, Is.EqualTo("utf-16"));
+            Assert.That(content.IsDirty, Is.False);
+            buffer.Text = "saved after reload"; await content.SaveAsync();
+            Assert.That(File.ReadAllText(notes), Is.EqualTo("saved after reload"));
+            Assert.That(await monitor.CheckNowAsync(), Is.EqualTo(ExternalReloadResult.Unchanged));
+            File.WriteAllBytes(notes, [0, 1, 2]); await monitor.CheckNowAsync();
+            Assert.That(buffer.IsReadOnly, Is.True); Assert.That(File.ReadAllBytes(notes), Is.EqualTo(new byte[] { 0, 1, 2 }));
+            File.WriteAllText(notes, "text again"); await monitor.CheckNowAsync();
+            Assert.That(buffer.IsReadOnly, Is.False); Assert.That(buffer.Text, Is.EqualTo("text again"));
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task InvalidExternalFileRecoversAfterGitStyleRestorationWithoutReplacingTheProject()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "ExternalInvalid"), "Original", new(), Contracts());
+        var monitor = project.Services.GetRequiredService<ProjectExternalChanges>(); await monitor.CheckNowAsync();
+        var path = Path.Combine(project.RootPath, "Graph/graph.json"); var bytes = File.ReadAllBytes(path);
+        File.WriteAllText(path, "{"); Assert.That(await monitor.CheckNowAsync(), Is.EqualTo(ExternalReloadResult.Retry));
+        Assert.That(monitor.State, Is.EqualTo(ExternalProjectState.Invalid));
+        Assert.That(project.Services.GetRequiredService<IEditorDocumentService>().CurrentDocument.Name, Is.EqualTo("Original"));
+        File.WriteAllBytes(path, bytes); Assert.That(await monitor.CheckNowAsync(), Is.EqualTo(ExternalReloadResult.Unchanged));
+        Assert.That(monitor.HasIssue, Is.False); Assert.That(projects.Current, Is.SameAs(project));
+        await projects.CloseAsync();
+    }
+
+    [Test]
+    public async Task DiscardingExternalConflictKeepsMountedEntryDraftRegistrationAndWaitsForComposition()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "ExternalEntryDraft"), "Draft", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.Wait).Single();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(project.Services, group.Id);
+            var content = project.Services.GetRequiredService<IProjectContentSession>(); await content.SaveAsync();
+            var edits = project.Services.GetRequiredService<EntryEditSession>(); var draft = edits.Get(entry, entry.DetailForm!.Fields.Single(field => field.Id == "duration"));
+            draft.Update("3", true, null, false);
+            var edited = await new ProjectEditService(project.RootPath, project.Services.GetRequiredService<IEntryCatalog>()).ExecuteAsync([new GalNet.Editor.Abstraction.Commands.RenameProjectCommand("External")]);
+            Assert.That(edited.Success, Is.True);
+            var monitor = project.Services.GetRequiredService<ProjectExternalChanges>();
+            using (draft.RegisterGuard(() => false))
+                Assert.That(await monitor.CheckNowAsync(true), Is.EqualTo(ExternalReloadResult.LocalChanges));
+            Assert.That(await monitor.CheckNowAsync(true), Is.EqualTo(ExternalReloadResult.Reloaded));
+            draft.Update("4", true, null, false); await content.SaveAsync();
+            Assert.That(entry.Source.Parameters["duration"].GetSingle(), Is.EqualTo(4)); Assert.That(edits.PendingCount, Is.Zero);
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task AssetNotificationsWaitForTheWholeExternalPublication()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "ExternalAssets"), "Assets", new(), Contracts());
+        var assets = services.GetRequiredService<GalNet.Editor.Services.Interfaces.IAssetCatalogService>();
+        await assets.RefreshAsync();
+        var count = 0; assets.Changed += () => count++;
+        var transaction = Path.Combine(project.RootPath, ".galnet/editor/transactions/external"); Directory.CreateDirectory(transaction);
+        var manifest = Path.Combine(transaction, "manifest.json"); File.WriteAllText(manifest, "{\"status\":\"publishing\"}");
+        var refreshing = assets.RefreshAsync();
+        Assert.That(refreshing.IsCompleted, Is.False); Assert.That(count, Is.Zero);
+        File.WriteAllText(manifest, "{\"status\":\"committed\"}");
+        await refreshing.WaitAsync(TimeSpan.FromSeconds(5)); Assert.That(count, Is.EqualTo(1));
+        await projects.CloseAsync();
+    }
+}
diff --git a/test/GalNet.Editor.Tests/GalNet.Editor.Tests.csproj b/test/GalNet.Editor.Tests/GalNet.Editor.Tests.csproj
index ef528130..c0c8f537 100644
--- a/test/GalNet.Editor.Tests/GalNet.Editor.Tests.csproj
+++ b/test/GalNet.Editor.Tests/GalNet.Editor.Tests.csproj
@@ -17,4 +17,5 @@
     <ProjectReference Include="..\..\src\Shared\GalNet.Primitives.Builtins\GalNet.Primitives.Builtins.csproj" />
     <ProjectReference Include="..\..\src\Shared\GalNet.Contracts.Builtins\GalNet.Contracts.Builtins.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../src/Shared/GalNet.GameHost/GalNet.GameHost.csproj" /></ItemGroup>
 </Project>
diff --git a/test/GalNet.Editor.Tests/GameLocalizationPanelTests.cs b/test/GalNet.Editor.Tests/GameLocalizationPanelTests.cs
index c55f4acc..adeebe90 100644
--- a/test/GalNet.Editor.Tests/GameLocalizationPanelTests.cs
+++ b/test/GalNet.Editor.Tests/GameLocalizationPanelTests.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Primitives;
@@ -7,6 +8,7 @@
 using Avalonia.Interactivity;
 using Avalonia.Threading;
 using Avalonia.VisualTree;
+using GalNet.Contracts.Builtins;
 using GalNet.Core.Entry;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Dock;
@@ -46,7 +48,7 @@ public Task I18nQueuedLanguageChangeAndTextCommitRecheckInsideHistory(bool langu
         else
         {
             await write; Assert.ThrowsAsync<EditorOperationException>(async () => await change);
-            Assert.That(project.Settings.TargetLocale.Code, Is.EqualTo("zh-CN"));
+            Assert.That(project.Configuration.ReadDefaultOptions().TargetLocale.Code, Is.EqualTo("zh-CN"));
         }
     });
 
@@ -79,11 +81,13 @@ public Task I18nDevelopmentLanguageRequiresFreshMissingTextPreviewAndUndoPreserv
         WriteTranslation(project, """{"line":"English"}""", "I18n/en-US/lines.json");
         Assert.ThrowsAsync<EditorOperationException>(async () => await panel.ChangeDevelopmentLanguageAsync(preview));
         await panel.ChangeDevelopmentLanguageAsync(panel.Preview("en-US"));
-        Assert.That(project.Settings.TargetLocale.Code, Is.EqualTo("en-US"));
+        Assert.That(project.Configuration.ReadDefaultOptions().TargetLocale.Code, Is.EqualTo("en-US"));
         Assert.That(project.Services.GetRequiredService<GameTextAuthoringService>().Read("line"), Is.EqualTo("English"));
-        project.Settings.DefaultWidth = 1280;
+        var options = project.Configuration.ReadDefaultOptions();
+        options.DefaultWidth = 1280;
+        project.Configuration.Set(DefaultProjectConfiguration.Section, options);
         await project.Services.GetRequiredService<EditorHistories>().Content.UndoAsync();
-        Assert.That(project.Settings.TargetLocale.Code, Is.EqualTo("zh-CN")); Assert.That(project.Settings.DefaultWidth, Is.EqualTo(1280));
+        Assert.That(project.Configuration.ReadDefaultOptions().TargetLocale.Code, Is.EqualTo("zh-CN")); Assert.That(project.Configuration.ReadDefaultOptions().DefaultWidth, Is.EqualTo(1280));
         Assert.That(item.Entry.Parameters["content"].GetString(), Is.EqualTo("line"));
     });
 
@@ -164,14 +168,20 @@ public Task I18nRelatedJsonDraftsRebaseUnrelatedLeavesAndRejectInvalidOrConflict
     });
 
     [Test]
-    public Task I18nCellDraftSurvivesSourceChangeAndCategorySwitchWithoutOverwriting() => WithLocalizationProject(async project =>
+    public Task I18nPendingInputSurvivesSourceChangeAndCategorySwitchWithoutOverwriting() => WithLocalizationProject(async project =>
     {
         var item = CharacterEntry(project); WriteTranslation(project, """{"line":"原文"}""");
         var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("en-US");
         var model = project.Services.GetRequiredService<GameLocalizationPanelViewModel>(); model.Selected = model.Categories.Single(category => category.Id == item.Group);
+        var history = project.Services.GetRequiredService<EditorHistories>().Content;
+        var started = new TaskCompletionSource(); var release = new TaskCompletionSource();
+        var held = history.ExecuteAsync(new CallbackEdit("Hold", async () => { started.SetResult(); await release.Task; }, () => ValueTask.CompletedTask));
+        await started.Task;
+        var sourceChange = SetGameText(project, item.Group, item.Entry, "新原文");
         var cell = model.Rows.Single().Cells[1]; cell.Text = "pending";
         model.Selected = model.Categories.First();
-        await SetGameText(project, item.Group, item.Entry, "新原文"); model.Refresh();
+        release.SetResult(); await held; await sourceChange;
+        Assert.ThrowsAsync<EditorOperationException>(async () => await cell.CommitAsync()); model.Refresh();
         model.Selected = model.Categories.Single(category => category.Id == item.Group);
         Assert.That(model.Rows.Single().Cells[1], Is.SameAs(cell)); Assert.That(cell.Text, Is.EqualTo("pending"));
         Assert.ThrowsAsync<EditorOperationException>(async () => await cell.CommitAsync());
@@ -193,17 +203,17 @@ public Task I18nSaveAllCommitsDraftsFromInactiveCategoriesAndNewSourceInvalidate
         Assert.That(cell.IsDirty, Is.False);
         await service.ChangeDevelopmentLanguageAsync(service.Preview("en-US")); model.Refresh();
         model.Selected = model.Categories.Single(category => category.Id == item.Group);
-        Assert.That(model.Rows.Single().Cells[1].Status, Does.Contain(service.Text["I18n.Unknown"]));
+        Assert.That(model.Rows.Single().Cells[1].Text, Is.EqualTo("原文"));
         await project.Services.GetRequiredService<IProjectContentSession>().SaveAsync();
         var projects = project.Services.GetRequiredService<IProjectService>(); await projects.CloseAsync(); var reopened = await projects.OpenAsync(project.RootPath);
-        Assert.That(reopened.Settings.TargetLocale.Code, Is.EqualTo("en-US"));
+        Assert.That(reopened.Configuration.ReadDefaultOptions().TargetLocale.Code, Is.EqualTo("en-US"));
         Assert.That(reopened.Services.GetRequiredService<GameLocalizationPanelService>().Languages[0], Is.EqualTo("en-US"));
     });
 
     [Test]
-    public async Task I18nMountedTableCommitsMultilineByKeyboardAndFocusRetainsDraftAcrossViewCloseAndMovesColumns()
+    public async Task I18nMountedTableCommitsOnBlurProtectsCompositionAndRetainsViewState()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); await WithLocalizationProject(async project =>
@@ -219,20 +229,35 @@ await session.Dispatch<bool>(async () =>
                     input.RaiseEvent(new KeyEventArgs { RoutedEvent = InputElement.KeyDownEvent, Key = Key.Enter, KeyModifiers = KeyModifiers.Control });
                     await PumpCharacterUi(() => service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text == "First\nSecond");
                     Assert.That(input.IsFocused, Is.True, "Async commit preserves input focus.");
-                    var presenter = input.GetVisualDescendants().OfType<TextPresenter>().Single(); input.Text = "composing"; presenter.PreeditText = "拼";
+                    var presenter = input.GetVisualDescendants().OfType<TextPresenter>().Single(); presenter.PreeditText = "拼";
                     input.RaiseEvent(new KeyEventArgs { RoutedEvent = InputElement.KeyDownEvent, Key = Key.Enter, KeyModifiers = KeyModifiers.Control });
+                    Dispatcher.UIThread.RunJobs();
+                    Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("First\nSecond"));
+                    presenter.PreeditText = null; input.Text = "组字完成"; Dispatcher.UIThread.RunJobs();
                     Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("First\nSecond"));
-                    presenter.PreeditText = null; input.RaiseEvent(new KeyEventArgs { RoutedEvent = InputElement.KeyDownEvent, Key = Key.Escape });
-                    input.Text = "blur"; view.FindControl<TextBox>("NewLocalizationLanguage")!.Focus();
-                    await PumpCharacterUi(() => service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text == "blur");
-                    input.Focus(); input.Text = "discard"; input.RaiseEvent(new KeyEventArgs { RoutedEvent = InputElement.KeyDownEvent, Key = Key.Escape }); Assert.That(input.Text, Is.EqualTo("blur"));
-                    var cell = model.Rows.Single().Cells[1]; cell.Text = "kept draft";
+                    Assert.That(input.IsFocused, Is.True);
+                    Assert.That(input.VerticalContentAlignment, Is.EqualTo(Avalonia.Layout.VerticalAlignment.Top));
+                    Assert.That(input.HorizontalContentAlignment, Is.EqualTo(Avalonia.Layout.HorizontalAlignment.Left));
+                    Assert.That(presenter.TranslatePoint(default, input)!.Value.Y, Is.LessThan(12), "The actual text presenter starts at the top padding.");
+                    view.FindControl<TextBox>("LocalizationSearch")!.Focus();
+                    await PumpCharacterUi(() => service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text == "组字完成");
+                    input.Focus(); input.Text = "cancelled";
+                    input.RaiseEvent(new KeyEventArgs { RoutedEvent = InputElement.KeyDownEvent, Key = Key.Escape });
+                    Dispatcher.UIThread.RunJobs();
+                    Assert.That(input.Text, Is.EqualTo("组字完成"), "Escape cancels uncommitted input.");
+                    Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("组字完成"));
+                    input.Focus(); input.Text = "Save without waiting for render";
+                    await project.Services.GetRequiredService<IProjectContentSession>().SaveAsync();
+                    Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("Save without waiting for render"));
+                    Assert.That(input.IsFocused, Is.True, "Save All commits current input without requiring blur.");
+                    var cell = model.Rows.Single().Cells[1]; cell.Text = "kept update"; await cell.CommitAsync();
+                    model.SetColumnWidth("en-US", 310);
                     window.Content = null; Dispatcher.UIThread.RunJobs();
                     var reopened = new GameLocalizationPanelView { DataContext = project.Services.GetRequiredService<GameLocalizationPanelViewModel>() }; window.Content = reopened; Dispatcher.UIThread.RunJobs();
-                    Assert.That(model.Rows.Single().Cells[1].Text, Is.EqualTo("kept draft"));
-                    cell.Revert();
-                    reopened.GetVisualDescendants().OfType<Button>().Single(button => button.Name == "LanguageLeft_ja_JP").RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
-                    await PumpCharacterUi(() => model.Languages[1] == "ja-JP");
+                    Assert.That(model.Rows.Single().Cells[1].Text, Is.EqualTo("kept update"));
+                    Assert.That(model.ColumnWidth("en-US"), Is.EqualTo(310));
+                    await service.MoveLanguageAsync("ja-JP", -1);
+                    Assert.That(model.Languages[1], Is.EqualTo("ja-JP"));
                     var history = project.Services.GetRequiredService<EditorHistories>().Content; await project.Services.GetRequiredService<IProjectContentSession>().SaveAsync();
                     project.Services.GetRequiredService<IEditorLocalizationService>().ApplyLocale("ja-JP"); Dispatcher.UIThread.RunJobs();
                     Assert.That(history.IsDirty, Is.False); Assert.That(service.Languages[0], Is.EqualTo("zh-CN"));
@@ -243,7 +268,7 @@ await session.Dispatch<bool>(async () =>
                     var dockDraft = model.Rows.Single().Cells.Single(cell => cell.Culture == "en-US"); dockDraft.Text = "dock draft";
                     dock.ToggleGlobalPanel(EditorDockPanelIds.Localization); Assert.That(model.IsDisposed, Is.False);
                     dock.OpenPanel(EditorDockPanelIds.Localization); Assert.That(project.Services.GetRequiredService<GameLocalizationPanelViewModel>(), Is.SameAs(model));
-                    Assert.That(dockDraft.Text, Is.EqualTo("dock draft")); Assert.That(dockDraft.IsDirty, Is.True); dockDraft.Revert();
+                    await dockDraft.CommitAsync(); Assert.That(dockDraft.Text, Is.EqualTo("dock draft")); Assert.That(dockDraft.IsDirty, Is.False);
                 }
                 finally { window.Close(); }
             }); return true;
@@ -255,7 +280,7 @@ public Task I18nScriptLanguageRemainsCanonicalAcrossDevelopmentAndSourceAuthorin
     {
         var item = CharacterEntry(project); WriteTranslation(project, """{"line":"原文"}""");
         var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("ZH_hans_cn");
-        Assert.That(project.Settings.AvailableLocales[^1].Code, Is.EqualTo("zh-Hans-CN"));
+        Assert.That(project.Configuration.ReadDefaultOptions().AvailableLocales[^1].Code, Is.EqualTo("zh-Hans-CN"));
         await service.SetAsync(service.Capture(item.Group, "line", "zh-Hans-CN"), "简体");
         await service.ChangeDevelopmentLanguageAsync(service.Preview("zh-Hans-CN"));
         await SetGameText(project, item.Group, item.Entry, "开发原文");
@@ -265,7 +290,7 @@ public Task I18nScriptLanguageRemainsCanonicalAcrossDevelopmentAndSourceAuthorin
     [Test]
     public async Task I18nMountedCategoriesAndRowsVirtualizeAndScrollToTheLastText()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); await WithLocalizationProject(async project =>
diff --git a/test/GalNet.Editor.Tests/GameTextAuthoringTests.cs b/test/GalNet.Editor.Tests/GameTextAuthoringTests.cs
index 59e2c43c..382b7fc6 100644
--- a/test/GalNet.Editor.Tests/GameTextAuthoringTests.cs
+++ b/test/GalNet.Editor.Tests/GameTextAuthoringTests.cs
@@ -68,7 +68,8 @@ public Task GameTextEntryCopyCapturesAllLanguagesAndSharesCharactersButHasIndepe
         var author = project.Services.GetRequiredService<GroupEntryAuthoringService>(); var clip = author.Copy(item.Group, [item.Entry.StableId]);
         await SetGameText(project, item.Group, item.Entry, "复制后改原文");
         var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
-        var copied = (await author.PasteAsync(item.Group, clip, null)).Single(); var key = copied.Source.Parameters["content"].GetString()!;
+        var copiedId = (await author.PasteAsync(item.Group, clip, null)).Single();
+        var copied = project.Services.GetRequiredService<EditorGroupProjectionStore>().Get(item.Group).Entries.Single(entry => entry.StableId == copiedId); var key = copied.Source.Parameters["content"].GetString()!;
         var store = project.Services.GetRequiredService<LocalizationDocumentStore>();
         Assert.That(key, Is.Not.EqualTo(original)); Assert.That(store.CaptureText(key).Text, Is.EqualTo("复制前")); Assert.That(store.CaptureText(key, "en-US").Text, Is.EqualTo("English"));
         Assert.That(copied.Source.Parameters["speaker"].GetString(), Is.EqualTo(role.Id));
@@ -155,9 +156,10 @@ public Task GameTextClipboardAcrossProjectsCarriesDetachedLanguageSnapshots() =>
         WriteTranslation(project, JsonSerializer.Serialize(new Dictionary<string, string> { [key] = "Cross-project" }), "I18n/en-US/lines.json");
         var clip = project.Services.GetRequiredService<GroupEntryAuthoringService>().Copy(item.Group, [item.Entry.StableId]);
         var projects = project.Services.GetRequiredService<IProjectService>(); await projects.CloseAsync();
-        var target = await projects.CreateAsync(Path.Combine(_root, "OtherLocalization"), "Other", new() { TargetLocale = new("en-US"), AvailableLocales = [new("en-US")] }, Contracts());
+        var target = await projects.CreateAsync(Path.Combine(_root, "OtherLocalization"), "Other", new DefaultProjectOptions { TargetLocale = new("en-US"), AvailableLocales = [new("en-US")] }.ToConfiguration(), Contracts());
         var group = target.Services.GetRequiredService<IEditorDocumentService>().Groups.First().Key;
-        var copy = (await target.Services.GetRequiredService<GroupEntryAuthoringService>().PasteAsync(group, clip, null)).Single(); var copiedKey = copy.Source.Parameters["content"].GetString()!;
+        var copyId = (await target.Services.GetRequiredService<GroupEntryAuthoringService>().PasteAsync(group, clip, null)).Single();
+        var copy = target.Services.GetRequiredService<EditorGroupProjectionStore>().Get(group).Entries.Single(entry => entry.StableId == copyId); var copiedKey = copy.Source.Parameters["content"].GetString()!;
         Assert.That(copiedKey, Is.Not.EqualTo(key)); var store = target.Services.GetRequiredService<LocalizationDocumentStore>();
         Assert.That(store.CaptureText(copiedKey).Text, Is.EqualTo("Cross-project")); Assert.That(store.CaptureText(copiedKey, "zh-CN").Text, Is.EqualTo("跨项目原文"));
         await target.Services.GetRequiredService<IProjectContentSession>().SaveAsync();
@@ -166,7 +168,7 @@ public Task GameTextClipboardAcrossProjectsCarriesDetachedLanguageSnapshots() =>
     [Test]
     public async Task GameTextMountedDefaultLanguageDraftLocaleSwitchAndSharedValue()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); await WithLocalizationProject(async project =>
@@ -195,7 +197,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task GameTextBranchMountedFocusCommitRejectsReboundDraftAndRemovedOption()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); await WithLocalizationProject(async project =>
@@ -233,7 +235,7 @@ await session.Dispatch<bool>(async () =>
     [TestCase(false)]
     public async Task GameTextNestedListCopyAndMoveRetainIndependentKeysAndEveryLanguage(bool hasDefault)
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme();
diff --git a/test/GalNet.Editor.Tests/GraphEditingServiceTests.cs b/test/GalNet.Editor.Tests/GraphEditingServiceTests.cs
index d33f144d..6450f708 100644
--- a/test/GalNet.Editor.Tests/GraphEditingServiceTests.cs
+++ b/test/GalNet.Editor.Tests/GraphEditingServiceTests.cs
@@ -88,7 +88,7 @@ public async Task MixedDtoFieldsRetainAssetPickerAndSharedBindingWithoutDuplicat
         var asset = entry.ParameterFields.OfType<AssetEntryParameterEditorItemViewModel>().Single();
         var handle = entry.ParameterFields.OfType<SchemaEntryParameterEditorItemViewModel>().Single();
         Assert.That(asset.AssetFilter, Is.EqualTo(GalNet.Editor.Models.AssetPickerFilter.Image));
-        Assert.That(handle.Definition.Field, Is.SameAs(catalog.Get(entry.Type).DynamicParameters!["handleId"].Field));
+        Assert.That(handle.Definition.Field, Is.SameAs(catalog.Get(entry.Type).DynamicParameters["handleId"].Field));
         asset.StringValue = "background";
         Assert.That(await handle.CommitAsync(new(JsonSerializer.SerializeToElement("scene")), default), Is.Null);
         Assert.That(entry.Parameters, Is.EquivalentTo(new Dictionary<string, string> { ["handleId"] = "scene", ["assetId"] = "background" }));
diff --git a/test/GalNet.Editor.Tests/GraphInteractionLifecycleTests.cs b/test/GalNet.Editor.Tests/GraphInteractionLifecycleTests.cs
index e2778c11..f1a7088c 100644
--- a/test/GalNet.Editor.Tests/GraphInteractionLifecycleTests.cs
+++ b/test/GalNet.Editor.Tests/GraphInteractionLifecycleTests.cs
@@ -151,7 +151,7 @@ public async Task InvalidClipboardAndBranchConflictsLeaveContentAndHistoryIntact
     [Test]
     public async Task BranchInspectorTextAndGraphKeyboardUseTheCorrectEditingTarget()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
@@ -326,7 +326,7 @@ protected override void Publish(string path, string? stagedFile)
 
     private sealed class FaultRepository(IEditorDocumentRepository inner, AuthorFileTransaction transaction) : IEditorDocumentRepository
     {
-        public LoadedEditorProjectDocument Load(string path, string name, GalNet.Core.Settings.ProjectSettings settings) => inner.Load(path, name, settings);
+        public LoadedEditorProjectDocument Load(string path) => inner.Load(path);
         public ProjectSavePlan PrepareSave(string path, EditorGraphDocument document, IReadOnlyDictionary<string, IReadOnlyList<EditorEntryData>> groups) => inner.PrepareSave(path, document, groups);
         public void ApplySave(string path, ProjectSavePlan plan, CancellationToken cancellationToken = default)
         {
diff --git a/test/GalNet.Editor.Tests/GroupAuthoringInteractionTests.cs b/test/GalNet.Editor.Tests/GroupAuthoringInteractionTests.cs
index 12d725ca..c3b1c523 100644
--- a/test/GalNet.Editor.Tests/GroupAuthoringInteractionTests.cs
+++ b/test/GalNet.Editor.Tests/GroupAuthoringInteractionTests.cs
@@ -25,7 +25,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task EntrySearchUsesLocalizedNamesIdsAliasesAndKeyboardWithoutChangingOnCancel()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
@@ -62,7 +62,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task GroupToolbarBatchesAreSingleHistoryStepsAndSpaceInsertsOneAtCapturedAnchor()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme();
@@ -76,15 +76,16 @@ await session.Dispatch<bool>(async () =>
             {
                 var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
                 var original = group.Entries.Select(entry => entry.StableId).ToArray(); vm.SelectedEntry = group.Entries[0]; vm.BatchAddCount = 3;
-                var toolbar = view.FindControl<WrapPanel>("EntryToolbar")!; var buttons = toolbar.Children.OfType<Button>().ToArray(); Click(window, buttons[0]);
+                var picker = view.FindControl<EntryTypePicker>("InsertPicker")!; var appendPicker = view.FindControl<EntryTypePicker>("AppendPicker")!;
+                Click(window, picker.FindControl<ToggleButton>("OpenButton")!); Dispatcher.UIThread.RunJobs(); var search = picker.FindControl<TextBox>("SearchInput")!; SetGroupSearch(search, "flow.wait"); PressGroupKey(search, Key.Down); PressGroupKey(search, Key.Enter);
                 Assert.That(group.Entries, Has.Count.EqualTo(6)); Assert.That(group.Entries[0].StableId, Is.EqualTo(original[0])); Assert.That(group.Entries[4].StableId, Is.EqualTo(original[1]));
                 var inserted = group.Entries.Skip(1).Take(3).Select(entry => entry.StableId).ToArray(); Assert.That(inserted.Distinct().Count(), Is.EqualTo(3));
                 await history.UndoAsync(); Assert.That(group.Entries.Select(entry => entry.StableId), Is.EqualTo(original)); Assert.That(history.CanUndo, Is.False);
                 await history.RedoAsync(); Assert.That(group.Entries.Skip(1).Take(3).Select(entry => entry.StableId), Is.EqualTo(inserted));
-                vm.SelectedEntry = group.Entries[0]; vm.BatchAddCount = 2; Click(window, buttons[1]); Assert.That(group.Entries, Has.Count.EqualTo(8)); Assert.That(vm.SelectedEntry, Is.SameAs(group.Entries[^1]));
-                var list = view.FindControl<ListBox>("ItemsListBox")!; var picker = view.FindControl<EntryTypePicker>("InsertPicker")!;
+                vm.SelectedEntry = group.Entries[0]; vm.BatchAddCount = 2; Click(window, appendPicker.FindControl<ToggleButton>("OpenButton")!); Dispatcher.UIThread.RunJobs(); var appendSearch = appendPicker.FindControl<TextBox>("SearchInput")!; SetGroupSearch(appendSearch, "flow.wait"); PressGroupKey(appendSearch, Key.Down); PressGroupKey(appendSearch, Key.Enter); Assert.That(group.Entries, Has.Count.EqualTo(8)); Assert.That(vm.SelectedEntry, Is.SameAs(group.Entries[^1]));
+                var list = view.FindControl<ListBox>("ItemsListBox")!;
                 vm.SelectedEntry = group.Entries[0]; list.Focus(); PressGroupKey(list, Key.Space); Dispatcher.UIThread.RunJobs();
-                Assert.That(picker.IsOpen, Is.True); var search = picker.FindControl<TextBox>("SearchInput")!; SetGroupSearch(search, "flow.wait"); PressGroupKey(search, Key.Down); PressGroupKey(search, Key.Enter);
+                Assert.That(picker.IsOpen, Is.True); SetGroupSearch(search, "flow.wait"); PressGroupKey(search, Key.Down); PressGroupKey(search, Key.Enter);
                 Assert.That(group.Entries, Has.Count.EqualTo(9), "Picker confirmation always inserts one, independent of batch count."); Assert.That(vm.SelectedEntry, Is.SameAs(group.Entries[1])); Assert.That(vm.SelectedEntry!.Type, Is.EqualTo(BuiltinEntryIds.Wait));
                 foreach (var entry in group.Entries) entry.IsParametersExpanded = false;
                 Dispatcher.UIThread.RunJobs(); window.UpdateLayout(); var scroll = list.GetVisualDescendants().OfType<ScrollViewer>().First(); scroll.Offset = new Vector(0, Math.Max(0, scroll.Extent.Height - scroll.Viewport.Height)); window.UpdateLayout();
@@ -92,8 +93,8 @@ await session.Dispatch<bool>(async () =>
                 Assert.That(vm.SelectedEntry, Is.Null); list.Focus(); PressGroupKey(list, Key.Space); Dispatcher.UIThread.RunJobs(); SetGroupSearch(search, "flow.wait"); PressGroupKey(search, Key.Down); PressGroupKey(search, Key.Enter);
                 Assert.That(group.Entries, Has.Count.EqualTo(10)); Assert.That(vm.SelectedEntry, Is.SameAs(group.Entries[^1]));
                 vm.SelectedEntry = group.Entries[0]; vm.InsertionType = "not.available"; vm.BatchAddCount = 3;
-                Click(window, buttons[1]); Dispatcher.UIThread.RunJobs(); Assert.That(picker.IsOpen, Is.True);
-                SetGroupSearch(search, "flow.wait"); PressGroupKey(search, Key.Down); PressGroupKey(search, Key.Enter);
+                Click(window, appendPicker.FindControl<ToggleButton>("OpenButton")!); Dispatcher.UIThread.RunJobs(); Assert.That(appendPicker.IsOpen, Is.True);
+                SetGroupSearch(appendSearch, "flow.wait"); PressGroupKey(appendSearch, Key.Down); PressGroupKey(appendSearch, Key.Enter);
                 Assert.That(group.Entries, Has.Count.EqualTo(13), "A button that requires type selection retains its batch count and append intent."); Assert.That(vm.SelectedEntry, Is.SameAs(group.Entries[^1]));
                 foreach (var entry in group.Entries) entry.IsParametersExpanded = false;
                 Dispatcher.UIThread.RunJobs(); window.UpdateLayout(); scroll.Offset = new Vector(0, Math.Max(0, scroll.Extent.Height - scroll.Viewport.Height)); window.UpdateLayout();
@@ -104,6 +105,15 @@ await session.Dispatch<bool>(async () =>
                 var anchor = vm.SelectedEntry!; workspace.RemoveEntryFrom(group, anchor); var count = group.Entries.Count;
                 SetGroupSearch(search, "flow.wait"); PressGroupKey(search, Key.Down); PressGroupKey(search, Key.Enter); Assert.That(group.Entries.Count, Is.EqualTo(count)); Assert.That(vm.ErrorText, Is.Not.Empty);
                 var number = view.FindControl<NumericUpDown>("BatchCount")!; number.Focus(); var key = PressGroupKey(number, Key.Space); Assert.That(picker.IsOpen, Is.False); Assert.That(key.Handled, Is.False);
+                var preferences = project.Services.GetRequiredService<EditorSettingsPanelViewModel>();
+                preferences.ExpandNewEntries = false;
+                var newEntry = workspace.InsertEntriesInto(group, group.Entries.Count, 1, BuiltinEntryIds.Wait).Single();
+                Assert.That(newEntry.IsParametersExpanded, Is.False);
+                newEntry.IsParametersExpanded = true;
+                preferences.ExpandNewEntries = true;
+                Assert.That(newEntry.IsParametersExpanded, Is.True, "Changing the preference does not reset existing entries.");
+                Assert.That(workspace.InsertEntriesInto(group, group.Entries.Count, 1, BuiltinEntryIds.Wait).Single().IsParametersExpanded, Is.True);
+                preferences.Dispose();
                 await project.Services.GetRequiredService<IProjectContentSession>().SaveAsync(); Assert.That(project.Services.GetRequiredService<IProjectContentSession>().IsDirty, Is.False);
                 if (Environment.GetEnvironmentVariable("GALNET_EDITOR_TEST_ARTIFACTS") is { Length: > 0 } artifacts) { using var frame = window.CaptureRenderedFrame(); frame!.Save(Path.Combine(artifacts, "group-toolbar.png")); }
             }
@@ -115,7 +125,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task CollapsedEntryRemainsCollapsedInDragPreviewAfterReorderAndUndo()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/GroupConsistencyCloseoutTests.cs b/test/GalNet.Editor.Tests/GroupConsistencyCloseoutTests.cs
new file mode 100644
index 00000000..5e47bd54
--- /dev/null
+++ b/test/GalNet.Editor.Tests/GroupConsistencyCloseoutTests.cs
@@ -0,0 +1,175 @@
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Entry;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Controls;
+using GalNet.Editor.History;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Game.Controls.Forms;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task FilteredMountedEntriesRefreshForFieldsUndoTypeAndFriendlyReferenceSummaries()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "LiveGroupSearch"), "Search", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var layer = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ShowLayer).Single();
+            var hide = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.HideLayer).Single(); hide.Parameters = new() { ["handleId"] = layer.Source.Parameters["handleId"].GetString()! };
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+            var view = new EntryListEditorControl { DataContext = page }; var window = new Window { Content = view, Width = 1200, Height = 800 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var list = view.FindControl<ListBox>("ItemsListBox")!; var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+                page.SearchText = "needle"; TimelinePump(window); Assert.That(list.Items.Count, Is.Zero);
+                layer.Condition = "needle"; TimelinePump(window); Assert.That(list.Items.Cast<object>(), Does.Contain(layer));
+                await history.UndoAsync(); TimelinePump(window); Assert.That(list.Items.Count, Is.Zero);
+                layer.Parameters = new() { ["handleId"] = layer.Source.Parameters["handleId"].GetString()!, ["assetId"] = "needle.png" };
+                TimelinePump(window); Assert.That(list.Items.Cast<object>(), Does.Contain(layer));
+                await history.UndoAsync(); TimelinePump(window); Assert.That(list.Items.Count, Is.Zero);
+                page.SearchText = BuiltinEntryIds.Wait; TimelinePump(window); Assert.That(list.Items.Count, Is.Zero);
+                page.ChangeType(hide, BuiltinEntryIds.Wait); TimelinePump(window); Assert.That(list.Items.Cast<object>(), Does.Contain(hide));
+                await history.UndoAsync(); TimelinePump(window); Assert.That(list.Items.Count, Is.Zero);
+                page.SearchText = ""; TimelinePump(window);
+                var problems = scope.GetRequiredService<ProblemsPanelViewModel>();
+                problems.Report("error", "current external issue", "test", new(group.Id, hide.StableId));
+                Assert.That(hide.ProblemCount, Is.GreaterThan(0));
+                var handle = layer.Source.Parameters["handleId"].GetString()!; var text = scope.GetRequiredService<IEditorLocalizationService>();
+                foreach (var locale in new[] { "en-US", "ja-JP", "ko-KR", "zh-CN" })
+                {
+                    text.ApplyLocale(locale); TimelinePump(window);
+                    Assert.That(hide.Summary, Does.Contain(group.Name)); Assert.That(hide.Summary, Does.Not.Contain(handle));
+                }
+                scope.GetRequiredService<GroupEntryAuthoringService>().Delete(group.Id, [layer.StableId]); TimelinePump(window);
+                Assert.That(hide.Summary, Does.Contain(text["Scene.Unresolved"]));
+                await history.UndoAsync(); TimelinePump(window); Assert.That(hide.Summary, Does.Contain(group.Name));
+            }
+            finally { window.Close(); }
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+
+    private sealed class InputPublicationWait(TaskCompletionSource entered, TaskCompletionSource release) : IAsyncUndoableEdit
+    {
+        public string Description => "Hold author transaction";
+        public async ValueTask RedoAsync() { entered.TrySetResult(); await release.Task; }
+        public ValueTask UndoAsync() => ValueTask.CompletedTask;
+    }
+
+    [Test]
+    public async Task ReadingHundredsOfReferenceSummariesDoesNotEvictAnOpenSelection()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "SummaryReadCache"), "Summary", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var layer = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ShowLayer).Single();
+        var documents = scope.GetRequiredService<IEditorDocumentService>();
+        for (var index = 0; index < 300; index++) documents.Groups[group.Id].Entries.Add(new()
+        {
+            StableId = "reference-" + index,
+            Type = BuiltinEntryIds.MoveLayer,
+            Parameters = new() { ["handleId"] = layer.Source.Parameters["handleId"].Clone() }
+        });
+        documents.SynchronizeGroups();
+        var catalog = scope.GetRequiredService<SceneTargetCatalog>();
+        using var selection = new SceneTargetSelection(catalog, catalog.Query(group.Id, "reference-0"));
+        foreach (var entry in group.Entries.Skip(1)) Assert.That(entry.Summary, Does.Contain(group.Name));
+        Assert.That(selection.IsCurrent, Is.True); await projects.CloseAsync();
+    }
+
+    [Test]
+    public async Task GroupAndFileDeletionArchiveLateInvalidInputsAndKeepWorkingSavedVersionsSeparate()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "StructuralInputs"), "Inputs", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.Wait).Single(); await workspace.SaveAsync();
+        entry.Condition = "save.unsaved";
+        var inputs = scope.GetRequiredService<EntryEditSession>(); var field = scope.GetRequiredService<IEntryCatalog>().Get(entry.Type).DynamicParameters.Fields.Single();
+        var state = inputs.Get(entry, field); state.Update("unfinished", true, new("invalid", "invalid"), false);
+        var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+        var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var holding = history.ExecuteAsync(new InputPublicationWait(entered, release)); await entered.Task;
+        var deleting = workspace.DeleteNodeAsync(group); state.Update("latest unparsed input", true, new("invalid", "invalid"), false);
+        release.SetResult(); await holding; await deleting;
+        var documents = scope.GetRequiredService<IEditorDocumentService>(); var content = scope.GetRequiredService<IProjectContentSession>();
+        Assert.That(inputs.PendingCount, Is.Zero); Assert.That(inputs.Archives.Single().Text, Is.EqualTo("latest unparsed input"));
+        Assert.That(documents.Groups.ContainsKey(group.Id), Is.False); Assert.That(group.Entries, Is.Empty); Assert.That(await state.Commit!(), Is.Not.Null);
+        await content.SaveAsync(); await history.UndoAsync();
+        Assert.That(documents.Groups[group.Id].Entries.Single().Condition, Is.EqualTo("save.unsaved"));
+        Assert.That(content.CaptureSaved().GroupEntries[group.Id].Single().Condition, Is.Empty);
+        Assert.That(inputs.PendingCount, Is.Zero); Assert.That(inputs.CanRestore(inputs.Archives.Single()), Is.True);
+        inputs.RemoveArchive(inputs.Archives.Single());
+        var restored = scope.GetRequiredService<EditorGroupProjectionStore>().Get(group.Id).Entries.Single();
+        var second = inputs.Get(restored, field); second.Update("invalid file-deletion input", true, new("invalid", "invalid"), false);
+        var path = "Graph/" + documents.CurrentDocument.Nodes.Single(node => node.Id == group.Id).File;
+        await scope.GetRequiredService<ProjectFileAuthoringService>().ExecuteAsync(new(ProjectFileAction.Delete, [path], DeleteGroups: true, AllowCandidateReferences: true));
+        Assert.That(inputs.PendingCount, Is.Zero); Assert.That(inputs.Archives.Single().Text, Is.EqualTo("invalid file-deletion input"));
+        await history.UndoAsync(); Assert.That(inputs.PendingCount, Is.Zero); Assert.That(inputs.CanRestore(inputs.Archives.Single()), Is.True);
+        var archive = inputs.Archives.Single(); inputs.RequestRestore(archive);
+        restored = scope.GetRequiredService<EditorGroupProjectionStore>().Get(group.Id).Entries.Single();
+        var fresh = inputs.Get(restored, field); Assert.That(fresh.Text, Is.EqualTo("invalid file-deletion input")); Assert.That(fresh, Is.Not.SameAs(second));
+        fresh.Clear(); await workspace.SaveAsync(); var root = project.RootPath; var groupId = group.Id;
+        await projects.CloseAsync(); project = await projects.OpenAsync(root);
+        Assert.That(project.Services.GetRequiredService<IEditorDocumentService>().Groups[groupId].Entries.Single().Condition, Is.EqualTo("save.unsaved"));
+        Assert.That(project.Services.GetRequiredService<EntryEditSession>().Archives, Is.Empty); await projects.CloseAsync();
+    }
+
+    [Test]
+    public async Task StructuralArchiveWriteFailurePreservesAuthorFilesLiveInputsAndHistoryGate()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "StructureArchiveFailure"), "Failure", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.Wait).Single(); await workspace.SaveAsync();
+        var inputs = scope.GetRequiredService<EntryEditSession>(); var field = scope.GetRequiredService<IEntryCatalog>().Get(entry.Type).DynamicParameters.Fields.Single();
+        var state = inputs.Get(entry, field); state.Update("pending", true, null, false);
+        var content = scope.GetRequiredService<IProjectContentSession>(); var before = JsonSerializer.Serialize(content.CaptureWorking()); var saved = JsonSerializer.Serialize(content.CaptureSaved());
+        var blocked = Path.Combine(project.RootPath, ".galnet/editor/input-archive.json"); Directory.CreateDirectory(blocked);
+        var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+        var failure = Assert.CatchAsync(async () => await workspace.DeleteNodeAsync(group));
+        Assert.That(failure, Is.InstanceOf<IOException>().Or.InstanceOf<UnauthorizedAccessException>());
+        Assert.That(JsonSerializer.Serialize(content.CaptureWorking()), Is.EqualTo(before)); Assert.That(JsonSerializer.Serialize(content.CaptureSaved()), Is.EqualTo(saved));
+        Assert.That(inputs.PendingCount, Is.EqualTo(1)); Assert.That(state.IsConflicted, Is.False); Assert.That(history.IsBusy, Is.False); Assert.That(history.CanUndo, Is.False);
+        Directory.Delete(blocked); state.Clear(); await projects.CloseAsync();
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static (WeakReference View, FieldDraftState State) DeletedProjection(IServiceProvider scope, GraphNode group, bool dirty)
+    {
+        var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var entry = workspace.InsertEntriesInto(group, group.Entries.Count, 1, BuiltinEntryIds.Wait).Single();
+        var field = scope.GetRequiredService<IEntryCatalog>().Get(entry.Type).DynamicParameters.Fields.Single();
+        var state = scope.GetRequiredService<EntryEditSession>().Get(entry, field);
+        if (dirty) state.Update("preserve input", true, null, false);
+        var reference = new WeakReference(entry); scope.GetRequiredService<GroupEntryAuthoringService>().Delete(group.Id, [entry.StableId]);
+        return (reference, state);
+    }
+
+    [Test]
+    public async Task DeletedProjectionsCanBeCollectedWhileNeutralHistoryAndArchivedInputRemain()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "CollectDeletedEntries"), "Collect", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+        var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+        var records = Enumerable.Range(0, 24).Select(index => DeletedProjection(scope, group, index % 2 == 0)).ToArray();
+        for (var i = 0; i < 3; i++) { GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); }
+        Assert.That(records.Any(record => record.View.IsAlive), Is.False); Assert.That(scope.GetRequiredService<EditorHistories>().Content.CanUndo, Is.True);
+        var inputs = scope.GetRequiredService<EntryEditSession>(); Assert.That(inputs.PendingCount, Is.Zero); Assert.That(inputs.Archives.Count, Is.EqualTo(12));
+        scope.GetRequiredService<EditorHistories>().Content.Clear(); await workspace.SaveAsync();
+        GC.KeepAlive(records); await projects.CloseAsync();
+    }
+}
diff --git a/test/GalNet.Editor.Tests/GroupDiagnosticsNumericTests.cs b/test/GalNet.Editor.Tests/GroupDiagnosticsNumericTests.cs
new file mode 100644
index 00000000..e6b634f3
--- /dev/null
+++ b/test/GalNet.Editor.Tests/GroupDiagnosticsNumericTests.cs
@@ -0,0 +1,288 @@
+using System.Text.Json;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.VisualTree;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Controls;
+using GalNet.Editor.Dock;
+using GalNet.Editor.History;
+using GalNet.Editor.Inspector.ViewModels;
+using GalNet.Editor.Inspector.Views;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using GalNet.Game.Controls.Forms;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task NumericEditorPathsKeepExactInputBesideSliderAndFallBackWithoutLosingPrecision()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme();
+            using var services = Services(); services.GetRequiredService<IEditorLocalizationService>().ApplyLocale("zh-CN");
+            var binding = new NumericPathBinding("0.5");
+            var field = new FieldDescriptor("opacity", new(typeof(float), constraints: JsonSerializer.SerializeToElement(new { minimum = 0, maximum = 1 })), editor: new(ValueEditorIds.Slider, Step: .1));
+            var form = new SchemaForm { Schema = [field], Registry = EditorFieldEditors.CreateDefault(), Binding = _ => binding };
+            var window = new Window { Content = form, Width = 700, Height = 400 };
+            window.Styles.Add(new Avalonia.Markup.Xaml.Styling.StyleInclude(new Uri("avares://GalNet.Editor/")) { Source = new Uri("avares://GalNet.Editor/Controls/AuthorFormStyles.axaml") });
+            window.Show(); TimelinePump(window);
+            Assert.That(form.Diagnostics, Is.Empty);
+            var slider = form.GetVisualDescendants().OfType<Slider>().Single(); var up = form.GetVisualDescendants().OfType<NumericUpDown>().Single();
+            var text = up.GetVisualDescendants().OfType<TextBox>().Single(); text.Text = ".53"; PressGroupKey(text, Key.Enter);
+            Assert.That(binding.Value.Json!.Value.GetSingle(), Is.EqualTo(.53f));
+            Assert.That(slider.Value, Is.EqualTo(.53).Within(.000001), "Step does not quantize a legal precise typed value.");
+            slider.Value = .8; Assert.That(binding.Value.Json!.Value.GetSingle(), Is.EqualTo(.8f));
+            form.Schema = [new("exact", new(typeof(ulong)), editor: new(ValueEditorIds.NumericUpDown))]; binding.Value = new(JsonSerializer.SerializeToElement(ulong.MaxValue)); binding.Notify();
+            var exact = (TextBox)form.Editors.Single().Control; exact.Text = "18446744073709551614"; PressGroupKey(exact, Key.Enter);
+            Assert.That(binding.Value.Json!.Value.GetUInt64(), Is.EqualTo(ulong.MaxValue - 1));
+            form.Schema = [new("decimal", new(typeof(decimal)), editor: new(ValueEditorIds.NumericUpDown))]; binding.Value = new(JsonSerializer.SerializeToElement(0m)); binding.Notify();
+            exact = (TextBox)form.Editors.Single().Control; exact.Text = ".1234567890123456789012345678"; PressGroupKey(exact, Key.Enter);
+            Assert.That(binding.Value.Json!.Value.GetDecimal(), Is.EqualTo(.1234567890123456789012345678m));
+            form.Schema = [new("text", new(typeof(float)), editor: new(ValueEditorIds.NumericText))];
+            Assert.That(form.Editors.Single().Control, Is.InstanceOf<TextBox>());
+            form.Schema = [new("badSlider", new(typeof(float)), editor: new(ValueEditorIds.Slider))];
+            Assert.That(form.Editors.Single().Control, Is.InstanceOf<TextBox>());
+            Assert.That(form.Diagnostics.Single().Code, Is.EqualTo("editor.numericFallback"));
+            Assert.That(form.Diagnostics.Single().Message, Does.Contain("精确"));
+            window.Close(); return true;
+        }, CancellationToken.None);
+    }
+
+    private sealed class NumericPathBinding(string json) : IFieldBinding
+    {
+        public FieldValue Value { get; set; } = new(JsonSerializer.Deserialize<JsonElement>(json));
+        public bool IsEnabled => true;
+        public bool IsVisible => true;
+        public event EventHandler? Changed;
+        public FieldValue Read() => Value;
+        public void Notify() => Changed?.Invoke(this, EventArgs.Empty);
+        public Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken cancellationToken)
+        { Value = value; Notify(); return Task.FromResult<ValueIssue?>(null); }
+    }
+
+    private static async Task AwaitAutomaticProblems(ProblemsPanelViewModel problems)
+    {
+        for (var attempt = 0; attempt < 10; attempt++)
+        {
+            var task = problems.ValidationTask;
+            await task.WaitAsync(TimeSpan.FromSeconds(10));
+            if (ReferenceEquals(task, problems.ValidationTask)) return;
+        }
+        Assert.Fail("Automatic checks did not settle.");
+    }
+
+    [Test]
+    public async Task LocalizationAnalysisWarningsNavigateToTheirOwnEntriesWithoutResolvedReferences()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "LocalizationProblemNavigation"), "Localization", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entries = workspace.InsertEntriesInto(group, 0, 2, BuiltinEntryIds.PlayTimeline).ToArray();
+            var authoring = scope.GetRequiredService<EntryFieldAuthoringService>();
+            foreach (var entry in entries)
+            {
+                var parameters = new Dictionary<string, JsonElement>(entry.Source.Parameters)
+                {
+                    ["timeline"] = JsonSerializer.SerializeToElement(new
+                    {
+                        frameRate = 60,
+                        durationFrames = 30,
+                        tracks = Array.Empty<object>(),
+                        events = new[] { new { frame = 0, type = BuiltinEntryIds.ApplyEffect,
+                            parameters = new { instanceId = "unresolved", program = "missing", parameters = new { amount = .5 } } } }
+                    })
+                };
+                authoring.SetParameters(group.Id, entry.Source, entry.Type, parameters);
+            }
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+            var problems = scope.GetRequiredService<ProblemsPanelViewModel>(); await AwaitAutomaticProblems(problems);
+            var warnings = problems.Problems.Where(problem => problem.Code == "localization.field.opaque" && problem.Target?.FieldId == "timeline").ToArray();
+            Assert.That(warnings.Select(problem => problem.Target!.EntryId), Is.EquivalentTo(entries.Select(entry => entry.StableId)),
+                "Incomplete analysis still has an exact diagnostic owner; identical field paths in different entries must not merge.");
+            var factory = scope.GetRequiredService<EditorDockFactory>(); var layout = factory.CreateLayout(); factory.InitLayout(layout);
+            foreach (var warning in warnings)
+            {
+                Assert.That(warning.IsWarning, Is.True); Assert.That(warning.CanNavigate, Is.True);
+                Assert.That(warning.Details, Is.EqualTo("Structured value has no traversable field schema."));
+                foreach (var locale in new[] { "en-US", "ja-JP", "ko-KR", "zh-CN" })
+                {
+                    var text = scope.GetRequiredService<IEditorLocalizationService>(); text.ApplyLocale(locale);
+                    Assert.That(problems.Problems.Single(problem => problem.Code == warning.Code && problem.Target == warning.Target).Message,
+                        Is.EqualTo(text["Problem.Localization.Opaque"]));
+                }
+                page.SearchText = "hide all entries";
+                problems.NavigateCommand.Execute(warning);
+                Assert.That(scope.GetRequiredService<EntrySelectionContext>().Current?.EntryId, Is.EqualTo(warning.Target!.EntryId));
+                Assert.That(entries.Single(entry => entry.StableId == warning.Target.EntryId).IsParametersExpanded, Is.True);
+                var inspector = TimelineDockables(layout).Select(item => item.Context).OfType<InspectorHostViewModel>()
+                    .Select(item => item.CurrentInspectorViewModel).OfType<EntryInspectorViewModel>().Single();
+                Assert.That(inspector.Entry?.StableId, Is.EqualTo(warning.Target.EntryId));
+                Assert.That(inspector.RequestedField, Is.EqualTo("timeline"));
+            }
+            var owner = entries[1];
+            var unknown = new Dictionary<string, JsonElement>(owner.Source.Parameters) { ["custom/field~name"] = JsonSerializer.SerializeToElement(1) };
+            authoring.SetParameters(group.Id, owner.Source, owner.Type, unknown); await AwaitAutomaticProblems(problems);
+            var unknownProblem = problems.Problems.Single(problem => problem.Code == "localization.field.unknown" && problem.Target?.EntryId == owner.StableId);
+            Assert.That(unknownProblem.Target!.FieldId, Is.EqualTo("custom/field~name"), "JSON Pointer escaping must not leak into field identity.");
+            Assert.That(unknownProblem.CanNavigate, Is.True);
+            problems.NavigateCommand.Execute(unknownProblem);
+            Assert.That(scope.GetRequiredService<EntrySelectionContext>().Current?.EntryId, Is.EqualTo(owner.StableId));
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task GroupProblemsAutomaticallyFollowEditsUndoAndRedoAndKeepPendingInputNeutral()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "AutoGroupProblems"), "Automatic", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.Wait).Single();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+            var problems = scope.GetRequiredService<ProblemsPanelViewModel>(); await AwaitAutomaticProblems(problems);
+            var field = entry.DetailForm!.Fields.Single(); var input = scope.GetRequiredService<EntryEditSession>().Get(entry, field);
+            input.Update(".22", true, null, false);
+            Assert.That(problems.Problems.Single(problem => problem.Target?.EntryId == entry.StableId).Severity, Is.EqualTo("info"));
+            Assert.That(entry.ProblemCount, Is.Zero);
+            var before = problems.ValidationTask; input.Update(".3", true, null, false);
+            Assert.That(problems.ValidationTask, Is.SameAs(before), "Typing does not schedule full project validation.");
+            input.Clear();
+            entry.Condition = "("; await AwaitAutomaticProblems(problems);
+            var issue = problems.Problems.Single(problem => problem.Code == "condition.syntaxInvalid" && problem.Target?.EntryId == entry.StableId);
+            Assert.That(issue.Message, Does.Contain("条件")); Assert.That(issue.Source, Does.Not.Contain(group.Id));
+            Assert.That(issue.HasDetails, Is.True); Assert.That(issue.CanNavigate, Is.True); Assert.That(entry.HasProblemErrors, Is.True);
+            var factory = scope.GetRequiredService<EditorDockFactory>(); var layout = factory.CreateLayout(); factory.InitLayout(layout);
+            page.SearchText = "no match"; entry.IsParametersExpanded = false;
+            problems.NavigateCommand.Execute(issue);
+            Assert.That(scope.GetRequiredService<EntrySelectionContext>().Current?.EntryId, Is.EqualTo(entry.StableId));
+            Assert.That(entry.IsParametersExpanded, Is.True);
+            var host = TimelineDockables(layout).Select(item => item.Context).OfType<InspectorHostViewModel>().First(item => item.CurrentInspectorViewModel is EntryInspectorViewModel);
+            var inspector = (EntryInspectorViewModel)host.CurrentInspectorViewModel!;
+            Assert.That(inspector.RequestedField, Is.EqualTo("condition"));
+            var view = new EntryInspectorView { DataContext = inspector }; var window = new Window { Content = view, Width = 700, Height = 600 }; window.Show(); TimelinePump(window);
+            Assert.That(view.FindControl<ConditionEditorControl>("EntryConditionInput")!.GetVisualDescendants().OfType<TextBox>().Any(control => control.IsFocused), Is.True);
+            window.Close();
+            entry.Condition = "";
+            Assert.That(problems.Problems.Any(problem => problem.Code == "condition.syntaxInvalid"), Is.False, "Old validation errors leave the active list immediately.");
+            await AwaitAutomaticProblems(problems); Assert.That(entry.HasProblemErrors, Is.False);
+            await scope.GetRequiredService<EditorHistories>().Content.UndoAsync(); await AwaitAutomaticProblems(problems);
+            Assert.That(problems.Problems.Any(problem => problem.Code == "condition.syntaxInvalid"), Is.True);
+            await scope.GetRequiredService<EditorHistories>().Content.RedoAsync(); await AwaitAutomaticProblems(problems);
+            Assert.That(problems.Problems.Any(problem => problem.Code == "condition.syntaxInvalid"), Is.False);
+            var authoring = scope.GetRequiredService<EntryFieldAuthoringService>();
+            authoring.SetParameters(group.Id, entry.Source, entry.Type, new() { [field.Id] = JsonSerializer.SerializeToElement(-1f) });
+            await AwaitAutomaticProblems(problems);
+            var range = problems.Problems.Single(problem => problem.IsError && problem.Target?.EntryId == entry.StableId);
+            Assert.That(range.Code, Is.EqualTo("value.range")); Assert.That(range.Message, Does.Contain("时长").And.Contain("0"));
+            foreach (var locale in new[] { "en-US", "ja-JP", "ko-KR", "zh-CN" })
+            {
+                var local = scope.GetRequiredService<IEditorLocalizationService>(); local.ApplyLocale(locale);
+                Assert.That(problems.Problems.Single(problem => problem.IsError && problem.Target?.EntryId == entry.StableId).Message,
+                    Is.EqualTo(local.Format("Problem.Value.Minimum", local["Entry.Parameter.duration"], local["Problem.Kind.Number"], "0", "+∞")));
+            }
+            var problemsView = new ProblemsPanelView { DataContext = problems };
+            var problemsWindow = new Window { Content = problemsView, Width = 900, Height = 600 }; problemsWindow.Show(); TimelinePump(problemsWindow);
+            var problemButton = problemsView.GetVisualDescendants().OfType<Button>().Single(button =>
+                ReferenceEquals(button.Command, problems.NavigateCommand) && button.CommandParameter is AuthorProblem { Code: "value.range" });
+            Assert.That(problemButton.Bounds.Width, Is.GreaterThan(600));
+            var problemMessage = problemButton.GetVisualDescendants().OfType<TextBlock>().First();
+            Assert.That(problemMessage.TranslatePoint(default, problemsView)!.Value.X, Is.LessThan(90), "Actionable descriptions align with the row instead of centering in the panel.");
+            CaptureNumericQa(problemsWindow, "group-problems.png"); problemsWindow.Close();
+            authoring.SetParameters(group.Id, entry.Source, entry.Type, new() { [field.Id] = JsonSerializer.SerializeToElement(-2f) });
+            authoring.SetParameters(group.Id, entry.Source, entry.Type, new() { [field.Id] = JsonSerializer.SerializeToElement(.5f) });
+            await AwaitAutomaticProblems(problems);
+            Assert.That(problems.Problems.Any(problem => problem.IsError && problem.Target?.EntryId == entry.StableId), Is.False);
+            var nested = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.MoveLayer).Single();
+            var transformField = nested.DetailForm!.Fields.Single(field => field.Id == "transform");
+            var transformDraft = scope.GetRequiredService<EntryEditSession>().Get(nested, transformField);
+            var scaleDraft = transformDraft.Child!(new FieldDescriptor("ScaleY", new(typeof(float)), labelKey: "Form.Transform.ScaleY"), "ScaleY");
+            scaleDraft.Update("invalid", true, new ValueIssue("value.type", "invalid"), false);
+            var scaleProblem = problems.Problems.Single(problem => problem.Target?.EntryId == nested.StableId && problem.Code == "value.type");
+            Assert.That(scaleProblem.Message, Does.Contain("缩放 Y")); Assert.That(scaleProblem.Source, Does.EndWith("缩放 Y"));
+            problems.NavigateCommand.Execute(scaleProblem);
+            var nestedInspector = TimelineDockables(layout).Select(item => item.Context).OfType<InspectorHostViewModel>()
+                .Select(item => item.CurrentInspectorViewModel).OfType<EntryInspectorViewModel>().First(item => item.Entry?.StableId == nested.StableId);
+            var nestedView = new EntryInspectorView { DataContext = nestedInspector };
+            var nestedWindow = new Window { Content = nestedView, Width = 800, Height = 700 }; nestedWindow.Show(); TimelinePump(nestedWindow);
+            Assert.That(NumericControlTestSupport.NamedInputs(nestedView, "TransformScaleY").Single().IsFocused, Is.True, "Nested problems focus the failing component.");
+            nestedWindow.Close(); scaleDraft.Clear();
+            scope.GetRequiredService<GroupEntryAuthoringService>().Delete(group.Id, [entry.StableId]);
+            Assert.That(scope.GetRequiredService<AuthorNavigationService>().CanNavigate(issue.Target!), Is.False);
+            problems.NavigateCommand.Execute(issue);
+            Assert.That(problems.Problems.Any(problem => problem.Message == scope.GetRequiredService<IEditorLocalizationService>()["Problem.Unavailable"]), Is.True);
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task GroupNumericUpDownPreservesDraftsSupportsRealSpinnerAndSavesShorthandAfterViewsClose()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "GroupNumbers"), "Numbers", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.Wait).Single();
+            var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+            var form = new DtoEditorHost { Item = entry.DetailForm!.Item, Registry = page.FieldEditors };
+            var window = new Window { Content = form, Width = 700, Height = 500 };
+            window.Styles.Add(new Avalonia.Markup.Xaml.Styling.StyleInclude(new Uri("avares://GalNet.Editor/")) { Source = new Uri("avares://GalNet.Editor/Controls/AuthorFormStyles.axaml") });
+            window.Show(); TimelinePump(window);
+            var schema = form.GetVisualDescendants().OfType<SchemaForm>().Single(); var context = schema.Contexts.Single();
+            Assert.That(scope.GetRequiredService<EntryEditSession>().PendingCount, Is.Zero, "Mounting a spinner must never create input drafts.");
+            var up = schema.Editors.Single().Control as NumericUpDown; Assert.That(up, Is.Not.Null);
+            var text = up!.GetVisualDescendants().OfType<TextBox>().Single(); text.Focus(); text.Text = ".22";
+            Assert.That(context.Text, Is.EqualTo(".22")); Assert.That(context.Issue, Is.Null); Assert.That(context.HasDraft, Is.True);
+            PressGroupKey(text, Key.Enter); TimelinePump(window);
+            Assert.That(entry.Source.Parameters[context.Field.Id].GetSingle(), Is.EqualTo(.22f)); Assert.That(text.Text, Is.EqualTo("0.22"));
+            CaptureNumericQa(window, "group-numeric.png");
+            text.Text = "-."; Assert.That(context.Issue, Is.Null); PressGroupKey(text, Key.Enter);
+            Assert.That(context.Issue, Is.Not.Null); Assert.That(entry.Source.Parameters[context.Field.Id].GetSingle(), Is.EqualTo(.22f));
+            PressGroupKey(text, Key.Escape); Assert.That(text.Text, Is.EqualTo("0.22"));
+            var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+            var spinner = up.GetVisualDescendants().OfType<ButtonSpinner>().Single();
+            var increase = spinner.GetVisualDescendants().OfType<RepeatButton>().First(button => button.Name == "PART_IncreaseButton");
+            Click(window, increase); TimelinePump(window);
+            Assert.That(entry.Source.Parameters[context.Field.Id].GetSingle(), Is.EqualTo(.32f).Within(.000001));
+            Assert.That(history.CanUndo, Is.True); await history.UndoAsync(); Assert.That(entry.Source.Parameters[context.Field.Id].GetSingle(), Is.EqualTo(.22f));
+            PressGroupKey(text, Key.Up); Assert.That(entry.Source.Parameters[context.Field.Id].GetSingle(), Is.EqualTo(.32f).Within(.000001));
+            await history.UndoAsync();
+            text.Text = ".3";
+            window.Close(); page.Dispose(); await workspace.SaveAsync();
+            Assert.That(entry.Source.Parameters[context.Field.Id].GetSingle(), Is.EqualTo(.3f));
+            var root = project.RootPath; var stableId = entry.StableId; var groupId = group.Id;
+            await projects.CloseAsync(); project = await projects.OpenAsync(root);
+            var reopened = project.Services.GetRequiredService<EditorGroupProjectionStore>().Get(groupId).Entries.Single(entry => entry.StableId == stableId);
+            Assert.That(reopened.Source.Parameters[context.Field.Id].GetSingle(), Is.EqualTo(.3f));
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+
+    private static void CaptureNumericQa(Window window, string name)
+    {
+        if (Environment.GetEnvironmentVariable("GALNET_EDITOR_TEST_ARTIFACTS") is not { Length: > 0 } artifacts) return;
+        foreach (var animated in window.GetVisualDescendants().OfType<Avalonia.Animation.Animatable>()) animated.Transitions = null;
+        TimelinePump(window); using var frame = window.CaptureRenderedFrame(); frame!.Save(Path.Combine(artifacts, name));
+    }
+}
diff --git a/test/GalNet.Editor.Tests/GroupEntryClipboardTests.cs b/test/GalNet.Editor.Tests/GroupEntryClipboardTests.cs
index 555e5d31..abf2e9b2 100644
--- a/test/GalNet.Editor.Tests/GroupEntryClipboardTests.cs
+++ b/test/GalNet.Editor.Tests/GroupEntryClipboardTests.cs
@@ -23,38 +23,45 @@ namespace GeneralTest.Editor;
 public sealed partial class ProjectWorkspaceLifecycleTests
 {
     [Test]
-    public async Task EntryBatchFailuresRestoreContentAndHistoryOrRequireRepair()
+    public async Task EntryProjectionObserversCannotRollbackCommittedAuthorChanges()
     {
         using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
         var project = await projects.CreateAsync(Path.Combine(_root, "EntryBatchFailure"), "Entries", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
         var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
         workspace.InsertEntriesInto(group, 0, 3, BuiltinEntryIds.Wait);
         var author = project.Services.GetRequiredService<GroupEntryAuthoringService>(); var history = project.Services.GetRequiredService<EditorHistories>().Content;
+        var documents = project.Services.GetRequiredService<IEditorDocumentService>();
+        var projections = project.Services.GetRequiredService<EditorGroupProjectionStore>();
         var original = group.Entries.ToArray(); var clip = author.Copy(group.Id, original.Select(entry => entry.StableId)); history.Clear();
-        var shouldFail = false;
-        NotifyCollectionChangedEventHandler failOnce = (_, _) => { if (shouldFail) { shouldFail = false; throw new IOException("collection observer failure"); } };
-        group.Entries.CollectionChanged += failOnce;
+        var expectedCount = 6; var notifications = 0; var sawPartialAuthor = false; var sawBusyHistory = false;
+        NotifyCollectionChangedEventHandler failAlways = (_, _) => throw new IOException("persistent observer failure");
+        NotifyCollectionChangedEventHandler later = (_, _) =>
+        {
+            notifications++;
+            sawPartialAuthor |= documents.Groups[group.Id].Entries.Count != expectedCount;
+            sawBusyHistory |= history.IsBusy;
+        };
+        group.Entries.CollectionChanged += failAlways; group.Entries.CollectionChanged += later;
         try
         {
-            shouldFail = true; Assert.ThrowsAsync<IOException>(async () => await author.PasteAsync(group.Id, clip, null)); Assert.That(group.Entries, Is.EqualTo(original)); Assert.That(history.CanUndo, Is.False);
-            shouldFail = true; Assert.Throws<IOException>(() => author.Delete(group.Id, [original[0].StableId, original[2].StableId])); Assert.That(group.Entries, Is.EqualTo(original)); Assert.That(history.CanUndo, Is.False);
-            shouldFail = true; Assert.Throws<IOException>(() => author.Move(group.Id, [original[0].StableId], original[0].StableId, 2)); Assert.That(group.Entries, Is.EqualTo(original)); Assert.That(history.CanUndo, Is.False);
-            var inserted = await author.PasteAsync(group.Id, clip, null); var withPaste = group.Entries.ToArray(); shouldFail = true;
-            try { await history.UndoAsync(); Assert.Fail("Expected observer failure."); } catch (IOException) { }
-            Assert.That(group.Entries, Is.EqualTo(withPaste)); Assert.That(history.CanUndo, Is.True); Assert.That(history.CanRedo, Is.False);
-            await history.UndoAsync(); Assert.That(group.Entries, Is.EqualTo(original)); shouldFail = true;
-            try { await history.RedoAsync(); Assert.Fail("Expected observer failure."); } catch (IOException) { }
-            Assert.That(group.Entries, Is.EqualTo(original)); Assert.That(history.CanRedo, Is.True); Assert.That(history.CanUndo, Is.False);
-            await history.RedoAsync(); Assert.That(group.Entries.Skip(3).Select(entry => entry.StableId), Is.EqualTo(inserted.Select(entry => entry.StableId)));
+            var inserted = (await author.PasteAsync(group.Id, clip, null)).Select(id => group.Entries.Single(entry => entry.StableId == id)).ToArray();
+            Assert.That(group.Entries, Has.Count.EqualTo(6)); Assert.That(history.CanUndo, Is.True);
+            expectedCount = 3; await history.UndoAsync(); Assert.That(group.Entries, Is.EqualTo(original));
+            expectedCount = 6; await history.RedoAsync(); Assert.That(group.Entries.Skip(3).Select(entry => entry.StableId), Is.EqualTo(inserted.Select(entry => entry.StableId)));
+            expectedCount = 4; author.Delete(group.Id, [original[0].StableId, original[2].StableId]); Assert.That(group.Entries, Has.Count.EqualTo(4));
+            expectedCount = 6; await history.UndoAsync();
+            author.Move(group.Id, [original[0].StableId], original[0].StableId, 2);
+            Assert.That(group.Entries[2], Is.SameAs(original[0])); await history.UndoAsync();
+            Assert.That(group.Entries.Take(3), Is.EqualTo(original));
+            Assert.That(notifications, Is.GreaterThan(0), "A failed subscriber must not suppress later subscribers.");
+            Assert.That(sawPartialAuthor, Is.False); Assert.That(sawBusyHistory, Is.False);
+            Assert.That(projections.LastNotificationError, Is.TypeOf<IOException>());
+            Assert.That(history.RepairRequired, Is.False); Assert.That(project.Services.GetRequiredService<IProjectContentSession>().RepairRequired, Is.False);
+            Assert.Throws<InvalidOperationException>(() => group.Entries.Clear());
+            Assert.That(documents.Groups[group.Id].Entries, Has.Count.EqualTo(6));
         }
-        finally { group.Entries.CollectionChanged -= failOnce; }
-        history.Clear();
-        NotifyCollectionChangedEventHandler failAlways = (_, _) => throw new IOException("persistent observer failure");
-        group.Entries.CollectionChanged += failAlways;
-        try { Assert.ThrowsAsync<HistoryRepairRequiredException>(async () => await author.PasteAsync(group.Id, clip, null)); Assert.That(history.RepairRequired, Is.True); Assert.That(project.Services.GetRequiredService<IProjectContentSession>().RepairRequired, Is.True); }
-        finally { group.Entries.CollectionChanged -= failAlways; await projects.CloseAsync(); }
+        finally { group.Entries.CollectionChanged -= failAlways; group.Entries.CollectionChanged -= later; await projects.CloseAsync(); }
     }
-
     [Test]
     public async Task EntryClipboardPreservesDraftJsonAndBatchHistoryAcrossGroupsAndPageClose()
     {
@@ -75,7 +82,7 @@ public async Task EntryClipboardPreservesDraftJsonAndBatchHistoryAcrossGroupsAnd
         var clip = author.Copy(source.Id, [effect.StableId, original[0].StableId]);
         original[0].Condition = "changed";
         history.Clear();
-        var pasted = await author.PasteAsync(target.Id, clip, null);
+        var pasted = (await author.PasteAsync(target.Id, clip, null)).Select(id => target.Entries.Single(entry => entry.StableId == id)).ToArray();
         Assert.That(pasted.Select(entry => entry.Type), Is.EqualTo(new[] { BuiltinEntryIds.Wait, BuiltinEntryIds.ApplyEffect }));
         Assert.That(pasted[0].Condition, Is.EqualTo("score > 1"));
         Assert.That(pasted[0].Source.Parameters.ContainsKey("duration"), Is.False);
@@ -120,10 +127,10 @@ public async Task EntryClipboardRejectsWholeMalformedPayloadWithoutHistoryAndPre
         }
         Assert.ThrowsAsync<EditorOperationException>(async () => await author.PasteAsync(group.Id, clip, "deleted-anchor"));
         Assert.That(history.CanUndo, Is.False);
-        var pasted = await author.PasteAsync(group.Id, unsupported.ToJsonString(), null);
+        var pasted = (await author.PasteAsync(group.Id, unsupported.ToJsonString(), null)).Select(id => group.Entries.Single(entry => entry.StableId == id)).ToArray();
         Assert.That(pasted[^1].Type, Is.EqualTo("unavailable.custom")); Assert.That(pasted[^1].IsUnknownType, Is.True);
         await history.UndoAsync(); Assert.That(group.Entries.Single(), Is.SameAs(entry));
-        pasted = await author.PasteAsync(group.Id, unknownField.ToJsonString(), null);
+        pasted = (await author.PasteAsync(group.Id, unknownField.ToJsonString(), null)).Select(id => group.Entries.Single(entry => entry.StableId == id)).ToArray();
         Assert.That(pasted.Single().Source.Parameters["newField"].GetInt32(), Is.EqualTo(1)); Assert.That(pasted.Single().HasUnknownParameters, Is.True);
         await history.UndoAsync(); Assert.That(group.Entries.Single(), Is.SameAs(entry));
         await projects.CloseAsync();
@@ -132,7 +139,7 @@ public async Task EntryClipboardRejectsWholeMalformedPayloadWithoutHistoryAndPre
     [Test]
     public async Task EntryNativeMultiSelectionKeyboardClipboardAndContextMenuRespectInputs()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -175,7 +182,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task EntryCutAndPasteIgnoreFailedStaleAndClosedPageClipboardCompletions()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -191,7 +198,7 @@ await session.Dispatch<bool>(async () =>
                 var pending = new TaskCompletionSource(); view.Write = _ => pending.Task;
                 var cut = view.CopySelectionAsync(cut: true); original[0].Condition = "changed while copying"; pending.SetResult(); await cut;
                 Assert.That(group.Entries, Is.EqualTo(original)); Assert.That(vm.ErrorText, Is.Not.Empty); history.Clear();
-                view.Write = _ => Task.CompletedTask; await view.CopySelectionAsync(cut: true); Assert.That(group.Entries, Has.Count.EqualTo(1)); await history.UndoAsync(); Assert.That(group.Entries, Is.EqualTo(original)); Assert.That(history.CanUndo, Is.False);
+                view.Write = _ => Task.CompletedTask; await view.CopySelectionAsync(cut: true); Assert.That(group.Entries, Is.EqualTo(original)); Assert.That(vm.HasPendingMove, Is.True); Assert.That(vm.SelectedEntries.All(entry => entry.IsPendingMove), Is.True); Assert.That(history.CanUndo, Is.False); vm.CancelPendingMove(); Assert.That(vm.HasPendingMove, Is.False);
                 vm.SelectedEntry = original[0]; var clip = vm.CopySelection(); var read = new TaskCompletionSource<string?>(); view.Read = () => read.Task; var paste = view.PasteSelectionAsync();
                 vm.SelectedEntry = original[2]; read.SetResult(clip); await paste; Assert.That(group.Entries[1].StableId, Is.Not.EqualTo(original[1].StableId), "Paste uses the captured anchor, not the later selection.");
                 await history.UndoAsync(); history.Clear(); vm.SelectedEntry = original[0]; read = new(); view.Read = () => read.Task; paste = view.PasteSelectionAsync();
@@ -208,7 +215,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task EntryMultiDragPreservesOrderFoldingAndOneHistoryStep()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/GroupPropertyEditorTests.cs b/test/GalNet.Editor.Tests/GroupPropertyEditorTests.cs
index fc2bb4f4..6220113f 100644
--- a/test/GalNet.Editor.Tests/GroupPropertyEditorTests.cs
+++ b/test/GalNet.Editor.Tests/GroupPropertyEditorTests.cs
@@ -9,8 +9,8 @@
 using Avalonia.Media;
 using Avalonia.VisualTree;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Parameters;
-using GalNet.Core.Scene;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Controls;
 using GalNet.Editor.Dock;
@@ -25,11 +25,173 @@ namespace GeneralTest.Editor;
 
 public sealed partial class ProjectWorkspaceLifecycleTests
 {
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task AudioTrackComboboxIsMountedInTheActualGroupPageAndInspector(bool common)
+    {
+        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "GroupTrackInput"), "Tracks", new DefaultProjectOptions { AudioTracks = BuiltinAudioDefaults.Create().Tracks.ToList(), AudioBuses = BuiltinAudioDefaults.Create().Buses.ToList() }.ToConfiguration(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.PlayAudio).Single();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(project.Services, group.Id);
+            var view = new EntryListEditorControl { DataContext = page, UseCommonFields = common };
+            var inspector = new DtoEditorHost { Item = entry.DetailForm!.Item, Registry = page.FieldEditors };
+            inspector.Styles.Add(new StyleInclude(new Uri("avares://GalNet.Editor/")) { Source = new Uri("avares://GalNet.Editor/Controls/AuthorFormStyles.axaml") });
+            var panel = new StackPanel { Children = { view, inspector } };
+            var window = new Window { Content = panel, Width = 1000, Height = 1000 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var input = view.GetVisualDescendants().OfType<ComboBox>().Single(control => control.Name == "AudioTrackInput");
+                Assert.That(input.IsEffectivelyVisible, Is.True);
+                Assert.That(inspector.GetVisualDescendants().OfType<ComboBox>().Single(control => control.Name == "AudioTrackInput").IsEffectivelyVisible, Is.True);
+                input.SelectedItem = input.Items.Cast<object>().Single(item => item.ToString()!.EndsWith("(sfx)", StringComparison.Ordinal));
+                TimelinePump(window);
+                Assert.That(entry.Source.Parameters["trackId"].GetString(), Is.EqualTo("sfx"));
+                await project.Services.GetRequiredService<EditorHistories>().Content.UndoAsync();
+                Assert.That(entry.Source.Parameters.GetValueOrDefault("trackId").ValueKind is JsonValueKind.Undefined || entry.Source.Parameters["trackId"].GetString() == "bgm", Is.True);
+            }
+            finally { window.Close(); page.Dispose(); await projects.CloseAsync(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
     [Test]
-    public async Task GroupTransformAndColorUseRealControlsSingleHistoryAndLosslessSave()
+    public async Task AudioBusEffectTargetUsesBusDeclarationsInTheMountedInspector()
+    {
+        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var defaults = BuiltinAudioDefaults.Create();
+            var project = await projects.CreateAsync(Path.Combine(_root, "BusEffectInput"), "Audio", new DefaultProjectOptions
+            {
+                AudioTracks = defaults.Tracks.ToList(),
+                AudioBuses = [.. defaults.Buses, new() { Id = "room", Name = "Room" }]
+            }.ToConfiguration(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ApplyAudioSEffect).Single();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(project.Services, group.Id);
+            var scope = entry.DetailForm!.Fields.Single(field => field.Id == "scope");
+            await entry.DetailForm.Binding(scope).CommitAsync(new(JsonSerializer.SerializeToElement("bus")), default);
+            var inspector = new DtoEditorHost { Item = entry.DetailForm.Item, Registry = page.FieldEditors };
+            inspector.Styles.Add(new StyleInclude(new Uri("avares://GalNet.Editor/")) { Source = new Uri("avares://GalNet.Editor/Controls/AuthorFormStyles.axaml") });
+            var window = new Window { Content = inspector, Width = 800, Height = 900 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var input = inspector.GetVisualDescendants().OfType<ComboBox>().Single(control => control.Name == "AudioTrackInput");
+                input.SelectedItem = input.Items.Cast<object>().Single(item => item.ToString() == "Room (room)");
+                TimelinePump(window);
+                Assert.That(entry.Source.Parameters["targetId"].GetString(), Is.EqualTo("room"));
+                Assert.That(entry.Source.Parameters["scope"].GetString(), Is.EqualTo("bus"));
+            }
+            finally { window.Close(); page.Dispose(); await projects.CloseAsync(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task FlipbookInputsPatchSingleMembersPreserveDraftsAndRejectInvalidGrid()
+    {
+        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme();
+            var registry = EditorFieldEditors.CreateDefault();
+            var binding = new PropertyBinding("{\"Columns\":4,\"rows\":2,\"frameCount\":8,\"index\":0,\"opaque\":9007199254740993}");
+            var field = LayerShowOptions.Schema.Single(item => item.Id == "flipbook");
+            using var context = new FieldEditorContext(field, binding, registry);
+            using var lease = registry.Resolve(field, typeof(LayerShowOptions))(context);
+            var window = new Window { Content = lease.Control, Width = 700, Height = 500 }; window.Show(); TimelinePump(window);
+            try
+            {
+                TextBox Input(string name) => NumericControlTestSupport.NamedInputs(lease.Control, "Flipbook" + name).Single();
+                Assert.That(binding.Commits, Is.Zero);
+                Assert.That(Input("Columns").Text, Is.EqualTo("4"));
+                Input("Index").Text = "2.5"; PressGroupKey(Input("Index"), Key.Enter); TimelinePump(window);
+                Assert.That(binding.Commits, Is.EqualTo(1));
+                Assert.That(binding.Value.Json!.Value.GetProperty("index").GetSingle(), Is.EqualTo(2.5f));
+                Assert.That(binding.Value.Json.Value.GetProperty("Columns").GetInt32(), Is.EqualTo(4));
+                Assert.That(binding.Value.Json.Value.GetProperty("opaque").GetRawText(), Is.EqualTo("9007199254740993"));
+                Input("FrameCount").Text = "9"; PressGroupKey(Input("FrameCount"), Key.Enter); TimelinePump(window);
+                Assert.That(binding.Commits, Is.EqualTo(1));
+                Assert.That(Input("FrameCount").Text, Is.EqualTo("9"), "Rejected input remains editable.");
+                PressGroupKey(Input("FrameCount"), Key.Escape);
+                Assert.That(Input("FrameCount").Text, Is.EqualTo("8"));
+                Input("Rows").Text = "-";
+                Input("Index").Text = "3"; PressGroupKey(Input("Index"), Key.Enter); TimelinePump(window);
+                Assert.That(Input("Rows").Text, Is.EqualTo("-"), "A sibling edit retains the local draft.");
+                Input("Columns").Text = "0"; PressGroupKey(Input("Columns"), Key.Enter); TimelinePump(window);
+                Assert.That(binding.Commits, Is.EqualTo(2));
+                Assert.That(binding.Value.Json.Value.GetProperty("Columns").GetInt32(), Is.EqualTo(4));
+            }
+            finally { window.Close(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task AudioTrackComboboxesUseProjectTracksAndPreserveUnknownIdsWithoutInitialWrites()
     {
         await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
         await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var tracks = BuiltinAudioDefaults.Create().Tracks.ToList();
+            tracks.Add(new() { Id = "ambience", Name = "Ambience", BusId = "sfx" });
+            var project = await projects.CreateAsync(Path.Combine(_root, "TrackInputs"), "Tracks", new DefaultProjectOptions { AudioTracks = tracks, AudioBuses = BuiltinAudioDefaults.Create().Buses.ToList() }.ToConfiguration(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            try
+            {
+                var registry = project.Services.GetRequiredService<EditorRegistry>();
+                var tables = new (Type Type, FieldDescriptor Field)[]
+                {
+                    (typeof(AudioTrackOptions), AudioTrackOptions.Schema.Single(field => field.Id == "trackId")),
+                    (typeof(AudioStopOptions), AudioStopOptions.Schema.Single(field => field.Id == "trackId")),
+                    (typeof(AudioPlayOptions), AudioPlayOptions.Schema.Single(field => field.Id == "trackId")),
+                    (typeof(AudioSEffectOptions), AudioSEffectOptions.Schema.Single(field => field.Id == "targetId")),
+                    (typeof(AudioSEffectStopOptions), AudioSEffectStopOptions.Schema.Single(field => field.Id == "targetId")),
+                    (typeof(TextVoiceOptions), TextVoiceOptions.Schema.Single(field => field.Id == "trackId")),
+                    (typeof(NvlVoiceOptions), NvlVoiceOptions.Schema.Single(field => field.Id == "trackId"))
+                };
+                foreach (var (type, field) in tables)
+                {
+                    var binding = new PropertyBinding("\"legacy\"");
+                    using var context = new FieldEditorContext(field, binding, registry);
+                    using var lease = registry.Resolve(field, type)(context);
+                    var input = (ComboBox)lease.Control;
+                    Assert.That(input.Name, Is.EqualTo("AudioTrackInput"));
+                    Assert.That(input.SelectedItem!.ToString(), Is.EqualTo("legacy"));
+                    Assert.That(binding.Commits, Is.Zero);
+                    input.SelectedItem = input.Items.Cast<object>().Single(item => item.ToString() == "Ambience (ambience)");
+                    Assert.That(binding.Commits, Is.EqualTo(1));
+                    Assert.That(binding.Value.Json!.Value.GetString(), Is.EqualTo("ambience"));
+                    Assert.That(input.Items.Cast<object>().Any(item => item.ToString() == "legacy"), Is.False);
+                    var options = project.Configuration.ReadDefaultOptions();
+                    var index = options.AudioTracks.FindIndex(track => track.Id == "ambience");
+                    options.AudioTracks[index] = options.AudioTracks[index] with { Name = "Atmosphere" };
+                    project.Configuration.Set(DefaultProjectConfiguration.Section, options);
+                    project.Services.GetRequiredService<IProjectContentSession>().Refresh();
+                    Assert.That(input.SelectedItem!.ToString(), Is.EqualTo("Atmosphere (ambience)"));
+                    Assert.That(binding.Commits, Is.EqualTo(1), "Refreshing project settings must not write the entry.");
+                    options.AudioTracks[index] = options.AudioTracks[index] with { Name = "Ambience" };
+                    project.Configuration.Set(DefaultProjectConfiguration.Section, options);
+                    project.Services.GetRequiredService<IProjectContentSession>().Refresh();
+                }
+            }
+            finally { await projects.CloseAsync(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task GroupTransformAndColorUseRealControlsSingleHistoryAndLosslessSave()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); Application.Current!.Styles.Add(new Semi.Avalonia.ColorPicker.ColorPickerSemiTheme());
             using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -45,8 +207,8 @@ await ui.Dispatch<bool>(async () =>
                 var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
                 var transform = view.GetVisualDescendants().OfType<Grid>().Single(item => item.Name == "TransformEditor");
                 Assert.That(transform.GetVisualDescendants().OfType<Button>().Single(item => item.Name == "RepairProperty").IsEffectivelyVisible, Is.False);
-                var x = transform.GetVisualDescendants().OfType<TextBox>().Single(item => item.Name == "TransformX");
-                var scale = transform.GetVisualDescendants().OfType<TextBox>().Single(item => item.Name == "TransformScaleX");
+                var x = NumericControlTestSupport.NamedInputs(transform, "TransformX").Single();
+                var scale = NumericControlTestSupport.NamedInputs(transform, "TransformScaleX").Single();
                 Assert.That(x.TranslatePoint(default, transform)!.Value.X, Is.EqualTo(scale.TranslatePoint(default, transform)!.Value.X));
                 Assert.That(scale.Text, Is.EqualTo("1")); Assert.That(history.CanUndo, Is.False);
                 scale.Text = "1.25";
@@ -114,7 +276,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task TimelinePropertyOpensItsOwnEntryAndReopensDockWithoutCreatingMissingData()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -156,7 +318,7 @@ private static void CapturePropertyFrame(Window window, string name)
     [Test]
     public async Task CompactInputsDistinguishEmptyStringAbsentNullDefaultAndMissingRequired()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); var registry = EditorFieldEditors.CreateDefault();
@@ -192,6 +354,35 @@ await ui.Dispatch<bool>(async () =>
         }, CancellationToken.None);
     }
 
+    [Test]
+    public async Task GeneratedCheckboxIsCenteredInTheEditorColumnAtWideAndNarrowWidths()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); var registry = EditorFieldEditors.CreateDefault();
+            var binding = new PropertyBinding("true");
+            using var context = new FieldEditorContext(new("enabled", new(typeof(bool))), binding, registry);
+            using var lease = registry.Resolve(context.Field)(context);
+            var checkbox = (CheckBox)lease.Control;
+            var row = new FieldEditorRow { Context = context, Label = "Enabled", Editor = checkbox };
+            var window = new Window { Content = row, Width = 700, Height = 150 }; window.Show(); TimelinePump(window);
+            try
+            {
+                void CheckCenter()
+                {
+                    var column = row.GetVisualDescendants().OfType<ContentControl>().Single(item => item.Name == "FieldEditor");
+                    var x = checkbox.TranslatePoint(default, column)!.Value.X;
+                    Assert.That(x + checkbox.Bounds.Width / 2, Is.EqualTo(column.Bounds.Width / 2).Within(1));
+                }
+                CheckCenter(); window.Width = 350; TimelinePump(window); CheckCenter();
+                checkbox.IsChecked = false; Assert.That(binding.Value.Json!.Value.GetBoolean(), Is.False);
+            }
+            finally { window.Close(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
     private sealed class PropertyBinding(string json) : IFieldBinding
     {
         public FieldValue Value { get; private set; } = new(JsonSerializer.Deserialize<JsonElement>(json));
@@ -208,7 +399,7 @@ private sealed class PropertyBinding(string json) : IFieldBinding
     [Test]
     public async Task TransformListUsesRegisteredElementControlAndRejectsReorderedEditors()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); var binding = new PropertyBinding("[{\"X\":1,\"opaque\":true},{\"X\":2}]");
@@ -220,7 +411,7 @@ await ui.Dispatch<bool>(async () =>
             try
             {
                 var list = (StructuredFieldEditor)form.Editors.Single().Control; list.IsExpanded = true; TimelinePump(window);
-                var inputs = list.GetVisualDescendants().OfType<TextBox>().Where(item => item.Name == "TransformX").ToArray();
+                var inputs = NumericControlTestSupport.NamedInputs(list, "TransformX").ToArray();
                 Assert.That(inputs, Has.Length.EqualTo(2));
                 inputs[0].Text = "3"; PressGroupKey(inputs[0], Key.Enter); TimelinePump(window);
                 Assert.That(binding.Value.Json!.Value[0].GetProperty("X").GetSingle(), Is.EqualTo(3));
@@ -231,7 +422,7 @@ await ui.Dispatch<bool>(async () =>
                 Assert.That(binding.Value.Json.Value[0].GetProperty("X").GetSingle(), Is.EqualTo(2));
                 Assert.That(binding.Commits, Is.EqualTo(2));
                 list.GetVisualDescendants().OfType<Button>().Single(item => item.Name == "add").RaiseEvent(new RoutedEventArgs(Button.ClickEvent)); TimelinePump(window);
-                var added = list.GetVisualDescendants().OfType<TextBox>().Last(item => item.Name == "TransformX");
+                var added = NumericControlTestSupport.NamedInputs(list, "TransformX").Last();
                 Assert.That(added.Text, Is.EqualTo("0")); added.Text = "4"; PressGroupKey(added, Key.Enter);
                 Assert.That(binding.Value.Json.Value[2].GetProperty("X").GetSingle(), Is.EqualTo(4));
             }
@@ -243,7 +434,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task CompactObjectOffersRepairWhenAnotherInvalidMemberBlocksLocalEditing()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); var binding = new PropertyBinding("{\"Count\":\"bad\",\"Name\":3,\"opaque\":true}");
diff --git a/test/GalNet.Editor.Tests/ImageVariantsAuthoringTests.cs b/test/GalNet.Editor.Tests/ImageVariantsAuthoringTests.cs
index e8e088ee..8e55d99b 100644
--- a/test/GalNet.Editor.Tests/ImageVariantsAuthoringTests.cs
+++ b/test/GalNet.Editor.Tests/ImageVariantsAuthoringTests.cs
@@ -35,7 +35,7 @@ private async Task CreateVariantImages(string root, ProjectFileAuthoringService
     [Test]
     public async Task MountedAtlasCreationConfigurationPreviewHistorySaveAllAndReopenUseProjectBuffers()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -51,33 +51,48 @@ await ui.Dispatch<bool>(async () =>
             workspace.SelectedAsset = scope.GetRequiredService<IAssetCatalogService>().GetEntry("alice/variants.variants");
             using var inspector = scope.GetRequiredService<AssetInspectorControlViewModel>(); var model = inspector.Variants!;
             Assert.That(model, Is.Not.Null); Assert.That(model.PreviewRows, Has.Count.EqualTo(2));
-            var view = new ImageVariantsEditor { DataContext = model }; var window = new Window { Content = new ScrollViewer { Content = view }, Width = 800, Height = 1100 }; window.Show(); TimelinePump(window);
+            var view = new AssetInspectorControl { DataContext = inspector }; var window = new Window { Content = view, Width = 800, Height = 1100 }; window.Show(); TimelinePump(window);
             try
             {
                 var original = model.Buffer.Text;
                 ComboBox Choice(string key) => view.GetVisualDescendants().OfType<ComboBox>().Single(combo => combo.DataContext is VariantPreviewRow row && row.Key == key);
                 Choice("d1").SelectedItem = "smile"; Choice("d2").SelectedItem = "skirt"; TimelinePump(window);
                 Assert.That(model.Actual, Does.StartWith("smile_skirt"));
-                Choice("d1").SelectedItem = "weap"; TimelinePump(window); Assert.That(model.Actual, Does.StartWith("weap")); Assert.That(model.Requested, Does.Contain("d2=skirt"));
+                Choice("d1").SelectedItem = "weap"; TimelinePump(window); Assert.That(model.Actual, Does.StartWith("weap")); Assert.That(model.Requested, Does.Contain("skirt"));
                 Choice("d1").SelectedItem = "smile"; TimelinePump(window); Assert.That(model.Actual, Does.StartWith("smile_skirt"));
                 await model.PreviewLoading; TimelinePump(window); Assert.That(model.Preview, Is.Not.Null);
                 Assert.That(model.Buffer.Text, Is.EqualTo(original)); Assert.That(history.CanUndo, Is.False);
                 foreach (var locale in new[] { "en-US", "ja-JP", "ko-KR", "zh-CN" })
                 { scope.GetRequiredService<IEditorLocalizationService>().ApplyLocale(locale); TimelinePump(window); Assert.That(model.Buffer.Text, Is.EqualTo(original)); Assert.That(model.Actual, Does.StartWith("smile_skirt")); }
                 var stale = model.PreviewRows[0]; model.Refresh(); stale.Value = "idle"; Assert.That(model.Actual, Does.StartWith("smile_skirt"));
-                model.Default = "smile_skirt"; model.Dimensions[0].Label = "Expression"; TimelinePump(window);
-                TimelineClick(window, view.FindControl<Button>("VariantsApply")!); await (model.ApplyCommand.ExecutionTask ?? Task.CompletedTask);
+                var properties = view.GetVisualDescendants().OfType<ImageVariantsEditor>().Single();
+                Assert.That(properties.GetVisualDescendants().OfType<ComboBox>().Count(), Is.EqualTo(1));
+                Assert.That(properties.FindControl<TextBox>("VariantsDefault"), Is.Null);
+                Assert.That(properties.FindControl<TextBox>("VariantsJson"), Is.Null);
+                Assert.That(properties.FindControl<Button>("VariantsApply"), Is.Null);
+                Assert.That(properties.FindControl<Button>("VariantsRefresh"), Is.Null);
+                scope.GetRequiredService<IEditorLocalizationService>().ApplyLocale("zh-CN"); TimelinePump(window);
+                Assert.That(model.Dimensions.Select(row => row.Heading), Is.EqualTo(new[] { "维度 1", "维度 2" }));
+                Assert.That(model.PreviewRows[0].Label, Is.EqualTo("维度 1"));
+                Assert.That(model.Requested, Does.Contain("维度 1="));
+                Assert.That(model.Buffer.Text, Is.EqualTo(original));
+                properties.FindControl<ComboBox>("VariantsDefaultChoices")!.SelectedItem = "smile_skirt";
+                await model.ConfigurationSaving;
                 Assert.That(model.Buffer.Error, Is.Empty); await history.UndoAsync(); Assert.That(history.CanUndo, Is.False);
                 Assert.That(model.Default, Is.EqualTo("idle_coat")); await history.RedoAsync(); Assert.That(model.Default, Is.EqualTo("smile_skirt"));
-                history.Clear(); model.Dimensions[0].Key = "expression"; Assert.That(model.Impact, Is.Not.Empty);
-                // Save All commits the remaining text draft once even after the inspector closes.
+                history.Clear(); properties.GetVisualDescendants().OfType<TextBox>().First(box => box.Name == "VariantsDimensionLabel").Text = "Expression"; TimelinePump(window); await model.ConfigurationSaving;
+                Assert.That(history.CanUndo, Is.True);
+                await history.UndoAsync(); Assert.That(model.Dimensions[0].Label, Is.Not.EqualTo("Expression"));
+                await history.RedoAsync(); Assert.That(model.Dimensions[0].Label, Is.EqualTo("Expression"));
+                Assert.That(model.Dimensions[0].Key, Is.EqualTo("d1"));
+                // Each selection enters working content immediately; Save All persists it after close.
                 var buffer = model.Buffer; var root = project.RootPath; window.Close(); inspector.Dispose();
-                await workspace.SaveAsync(); Assert.That(history.CanUndo, Is.True);
+                await workspace.SaveAsync();
                 await projects.CloseAsync(); Assert.That(buffer.IsReadOnly, Is.True); buffer.Text = "{}"; await buffer.CommitAsync();
                 project = await projects.OpenAsync(root);
                 var saved = project.Services.GetRequiredService<ProjectTextFiles>().Open("Assets/alice/variants.variants");
                 using var json = JsonDocument.Parse(saved.Text); Assert.That(json.RootElement.GetProperty("default").GetString(), Is.EqualTo("smile_skirt"));
-                Assert.That(json.RootElement.GetProperty("dimensions")[0].GetProperty("key").GetString(), Is.EqualTo("expression"));
+                Assert.That(json.RootElement.GetProperty("dimensions")[0].GetProperty("key").GetString(), Is.EqualTo("d1"));
                 Assert.That(json.RootElement.GetProperty("dimensions")[0].GetProperty("label").GetString(), Is.EqualTo("Expression"));
                 Assert.That(project.Services.GetRequiredService<IAssetCatalogService>().GetEntry("alice/variants.variants")!.Id, Is.EqualTo(id));
                 await projects.CloseAsync(); return true;
@@ -86,10 +101,60 @@ await ui.Dispatch<bool>(async () =>
         }, CancellationToken.None);
     }
 
+    [Test]
+    public async Task AtlasResourceRefreshInfersPositionsPreservesNamesAndNeverWritesConfiguration()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "AtlasRefresh"), "Atlas", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var files = scope.GetRequiredService<ProjectFileAuthoringService>();
+            await CreateVariantImages(project.RootPath, files);
+            var browser = scope.GetRequiredService<AssetPanelViewModel>(); browser.Navigate("Assets/alice"); await browser.NewVariantsCommand.ExecuteAsync(null);
+            var buffer = scope.GetRequiredService<ProjectTextFiles>().Open("Assets/alice/variants.variants");
+            var assets = scope.GetRequiredService<IAssetCatalogService>();
+            using var model = new ImageVariantsInspector(project.RootPath, buffer, projects, scope.GetRequiredService<IResourceTypeCatalog>(), assets, scope.GetRequiredService<IEditorLocalizationService>());
+            var window = new Window { Content = new ImageVariantsEditor { DataContext = model } }; window.Show(); TimelinePump(window);
+            try
+            {
+                model.Dimensions[0].Label = "Expression"; await model.ConfigurationSaving;
+                var original = buffer.Text;
+                var longer = Path.Combine(_root, "smile_skirt_day.png"); File.Copy(Path.Combine(_root, "images", "smile_skirt.png"), longer);
+                await files.ExecuteAsync(new(ProjectFileAction.Import, [longer], "Assets/alice"));
+                var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+                await assets.RefreshAsync(); TimelinePump(window);
+                Assert.That(model.Dimensions.Select(row => row.Key), Is.EqualTo(new[] { "d1", "d2", "d3" }));
+                Assert.That(model.Dimensions[0].Label, Is.EqualTo("Expression"));
+                Assert.That(model.PreviewRows[2].Options, Is.EqualTo(new[] { "day" }));
+                Assert.That(buffer.Text, Is.EqualTo(original)); Assert.That(history.CanUndo, Is.False);
+                model.DefaultChoice = "missing"; Assert.That(model.Default, Is.EqualTo("idle_coat"));
+                // A missing saved default remains visible and can be repaired using only the dropdown.
+                buffer.Text = original.Replace("idle_coat", "missing");
+                Assert.That(model.DefaultChoice, Is.Null); Assert.That(window.Content is ImageVariantsEditor editor ? editor.FindControl<ComboBox>("VariantsDefaultChoices")!.PlaceholderText : "unexpected", Is.Null.Or.Empty);
+                Assert.That(model.CanConfigure, Is.True);
+                model.DefaultChoice = "smile_skirt_day"; await model.ConfigurationSaving;
+                Assert.That(model.Buffer.Error, Is.Empty); Assert.That(model.Diagnostics, Is.Empty);
+                Assert.That(model.Default, Is.EqualTo("smile_skirt_day"));
+                Assert.That(model.Dimensions[0].Key, Is.EqualTo("d1"));
+                var beforeRefresh = buffer.Text; history.Clear(); model.Refresh();
+                Assert.That(buffer.Text, Is.EqualTo(beforeRefresh)); Assert.That(history.CanUndo, Is.False);
+                var dialogs = (TestDialogs)scope.GetRequiredService<IFileDialogService>(); dialogs.Folder = _root;
+                await model.BrowseFolderCommand.ExecuteAsync(null);
+                Assert.That(model.Diagnostics, Does.Contain("Assets")); Assert.That(buffer.Text, Is.EqualTo(beforeRefresh));
+                dialogs.Folder = Path.Combine(project.RootPath, "Assets", "alice");
+                await model.BrowseFolderCommand.ExecuteAsync(null);
+                Assert.That(model.Folder, Is.EqualTo(".")); Assert.That(model.Diagnostics, Is.Empty); Assert.That(history.CanUndo, Is.False);
+                return true;
+            }
+            finally { window.Close(); await projects.CloseAsync(); }
+        }, CancellationToken.None);
+    }
+
     [Test]
     public async Task AtlasDraftValidationSurvivesPanelCloseAndDependentFieldsUseWorkingDefinitions()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -101,7 +166,7 @@ await ui.Dispatch<bool>(async () =>
             var buffer = scope.GetRequiredService<ProjectTextFiles>().Open("Assets/alice/variants.variants");
             using (var model = new ImageVariantsInspector(project.RootPath, buffer, projects, scope.GetRequiredService<IResourceTypeCatalog>(), scope.GetRequiredService<IAssetCatalogService>(), scope.GetRequiredService<IEditorLocalizationService>()))
             {
-                model.Default = "missing"; await model.ApplyCommand.ExecuteAsync(null); Assert.That(history.CanUndo, Is.False); Assert.That(model.Diagnostics, Is.Not.Empty);
+                model.Default = "missing"; await model.ConfigurationSaving; Assert.That(history.CanUndo, Is.False); Assert.That(model.Diagnostics, Is.Not.Empty);
             }
             Assert.CatchAsync(async () => await workspace.SaveAsync()); Assert.That(buffer.Text, Does.Contain("missing"));
             buffer.CancelCommand.Execute(null);
@@ -125,9 +190,9 @@ await ui.Dispatch<bool>(async () =>
                 await history.UndoAsync(); Assert.That(history.CanUndo, Is.False); await history.RedoAsync();
                 // A committed configuration remains unsaved on disk but is the editor query's source.
                 using var model = new ImageVariantsInspector(project.RootPath, buffer, projects, scope.GetRequiredService<IResourceTypeCatalog>(), scope.GetRequiredService<IAssetCatalogService>(), scope.GetRequiredService<IEditorLocalizationService>());
-                model.Dimensions[0].Key = "expression"; await model.ApplyCommand.ExecuteAsync(null); await query.PrepareAsync(); TimelinePump(window);
-                Assert.That(query.Before(group.Id, select.StableId).Targets.Single().Variants!.Selection!.Request.ContainsKey("expression"), Is.True);
-                Assert.That(File.ReadAllText(Path.Combine(project.RootPath, buffer.Path)), Does.Not.Contain("expression"));
+                model.DefaultChoice = "smile_skirt"; await model.ConfigurationSaving; await query.PrepareAsync(); TimelinePump(window);
+                Assert.That(query.Before(group.Id, select.StableId).Targets.Single().Variants!.Selection!.Request["d1"], Is.EqualTo("smile"));
+                Assert.That(File.ReadAllText(Path.Combine(project.RootPath, buffer.Path)), Does.Not.Contain("smile_skirt"));
                 var staleValue = select.Source.Parameters["value"].GetString(); values.SelectedItem = "smile"; TimelinePump(window);
                 Assert.That(select.Source.Parameters["value"].GetString(), Is.EqualTo(staleValue));
                 Assert.That(select.Source.Parameters["dimension"].GetString(), Is.EqualTo("d1"));
diff --git a/test/GalNet.Editor.Tests/ImageVariantsSceneTests.cs b/test/GalNet.Editor.Tests/ImageVariantsSceneTests.cs
index ef9cf7ce..e530c1e3 100644
--- a/test/GalNet.Editor.Tests/ImageVariantsSceneTests.cs
+++ b/test/GalNet.Editor.Tests/ImageVariantsSceneTests.cs
@@ -5,9 +5,9 @@
 using Avalonia.VisualTree;
 using GalNet.Assets.Variants;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
-using GalNet.Core.Scene;
-using GalNet.Core.Variants;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Composition;
 using GalNet.Editor.Controls;
@@ -27,16 +27,26 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task ColdAtlasSelectorCanFinishPreparationButAnAuthorEditStillInvalidatesIt()
     {
-        using var assets = new VariantsAssets(); using var services = VariantsServices(assets); var projects = services.GetRequiredService<IProjectService>();
+        var gate = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously);
+        using var assets = new VariantsAssets(); assets.File.Gate = gate;
+        using var services = VariantsServices(assets); var projects = services.GetRequiredService<IProjectService>();
         var project = await projects.CreateAsync(Path.Combine(_root, "ColdAtlas"), "Atlas", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
         var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
         var show = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ShowVariants).Single(); show.Source.Parameters["assetId"] = JsonSerializer.SerializeToElement("atlas");
         var select = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.SelectVariants).Single();
-        var gate = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously); assets.File.Gate = gate;
         var catalog = scope.GetRequiredService<SceneTargetCatalog>(); using var selection = new SceneTargetSelection(catalog, catalog.Query(group.Id, select.StableId));
-        selection.Select(selection.Items.Single().Id); var preparing = selection.PrepareAsync();
-        await assets.File.Entered.Task.WaitAsync(TimeSpan.FromSeconds(10)); gate.SetResult(AtlasBytes()); await preparing;
-        Assert.That(selection.TryResolve(out var handle), Is.True); Assert.That(handle, Is.EqualTo(show.Source.Parameters["handleId"].GetString()));
+        Assert.That(selection.Select(selection.Items.Single().Id), Is.True, "The initial cold snapshot must be selectable before preparation.");
+        var preparing = selection.PrepareAsync();
+        await assets.File.Entered.Task.WaitAsync(TimeSpan.FromSeconds(10));
+        Assert.That(preparing.IsCompleted, Is.False, "Resource preparation must remain cold until the controlled read completes.");
+        gate.SetResult(AtlasBytes()); await preparing;
+        var resolved = selection.TryResolve(out var handle);
+        if (!resolved)
+        {
+            var current = catalog.Query(group.Id, select.StableId);
+            Assert.Fail($"Cold selection became stale: selected={selection.SelectedId}; current={selection.IsCurrent}; revision={selection.Snapshot.Revision}/{current.Revision}; context={selection.Snapshot.ContextRevision}/{current.ContextRevision}; choices={selection.Snapshot.Choices.Count}/{current.Choices.Count}.");
+        }
+        Assert.That(handle, Is.EqualTo(show.Source.Parameters["handleId"].GetString()));
         scope.GetRequiredService<EntryFieldAuthoringService>().SetCondition(group.Id, show.Source, "false"); Assert.That(selection.TryResolve(out _), Is.False);
         await projects.CloseAsync();
     }
@@ -84,7 +94,7 @@ public async Task AtlasQueryLoadsCompiledDefinitionsAsynchronouslyAndRejectsOldR
     [Test]
     public async Task MountedVariantsFieldsUseTypedAssetAndScenePickersSingleHistoryAndSaveReopen()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var assets = new VariantsAssets(); using var services = VariantsServices(assets);
diff --git a/test/GalNet.Editor.Tests/LocalizationAuthoringTests.cs b/test/GalNet.Editor.Tests/LocalizationAuthoringTests.cs
index 4a1f04a8..68ed506d 100644
--- a/test/GalNet.Editor.Tests/LocalizationAuthoringTests.cs
+++ b/test/GalNet.Editor.Tests/LocalizationAuthoringTests.cs
@@ -163,7 +163,7 @@ public Task LocalizationP2StaleTextDraftSurvivesDocumentChangeAndCannotOverwrite
     [Test]
     public async Task LocalizationP2MountedTextPageKeepsConflictDraftAndRefreshesAfterCancel()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
diff --git a/test/GalNet.Editor.Tests/LocalizationExchangeTests.cs b/test/GalNet.Editor.Tests/LocalizationExchangeTests.cs
index 24d8da8f..bf11905a 100644
--- a/test/GalNet.Editor.Tests/LocalizationExchangeTests.cs
+++ b/test/GalNet.Editor.Tests/LocalizationExchangeTests.cs
@@ -1,12 +1,16 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
+using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.Headless;
+using Avalonia.Input;
 using Avalonia.Threading;
+using Avalonia.VisualTree;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Core.Parameters;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
@@ -168,7 +172,7 @@ public Task ExchangeBatchJsonDraftConflictPreservesInputAndDoesNotPartiallyApply
     [Test]
     public async Task ExchangeMountedExportImportPreviewAndApplyUseFileDialogsAndOneHistory()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); await WithLocalizationProject(async project =>
@@ -180,7 +184,19 @@ await session.Dispatch<bool>(async () =>
                 var view = new GameLocalizationPanelView { DataContext = model }; var window = new Window { Content = view, Width = 1300, Height = 850 }; window.Show(); Dispatcher.UIThread.RunJobs();
                 try
                 {
-                    Click(window, view.FindControl<Button>("ExportLocalization")!);
+                    var options = view.FindControl<Button>("ExportOptions")!;
+                    Click(window, options); Dispatcher.UIThread.RunJobs();
+                    var flyout = (Flyout)options.Flyout!;
+                    try
+                    {
+                        var export = ((Control)flyout.Content!).GetVisualDescendants().OfType<Button>().Single(button => button.Name == "ExportLocalization");
+                        var point = new Point(export.Bounds.Width / 2, export.Bounds.Height / 2);
+                        var popupWindow = TopLevel.GetTopLevel(export)!;
+                        var exportPoint = export.TranslatePoint(point, popupWindow)!.Value;
+                        popupWindow.MouseDown(exportPoint, MouseButton.Left); Dispatcher.UIThread.RunJobs();
+                        popupWindow.MouseUp(exportPoint, MouseButton.Left); Dispatcher.UIThread.RunJobs();
+                    }
+                    finally { flyout.Hide(); }
                     await PumpCharacterUi(() => File.Exists(dialogs.SavePath));
                     var template = JsonNode.Parse(File.ReadAllText(dialogs.SavePath))!; template["rows"]![0]!["translation"] = "Imported"; File.WriteAllText(dialogs.SavePath, template.ToJsonString());
                     dialogs.OpenPaths = [dialogs.SavePath]; await model.PreviewImportCommand.ExecuteAsync(null); Dispatcher.UIThread.RunJobs();
diff --git a/test/GalNet.Editor.Tests/LocalizationResourceTableTests.cs b/test/GalNet.Editor.Tests/LocalizationResourceTableTests.cs
new file mode 100644
index 00000000..36710f62
--- /dev/null
+++ b/test/GalNet.Editor.Tests/LocalizationResourceTableTests.cs
@@ -0,0 +1,230 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Services;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public Task I18nTypingDefersWritesAndRefreshesUntilCommitAndSaveEmpty() => WithLocalizationProject(async project =>
+    {
+        var item = CharacterEntry(project); WriteTranslation(project, """{"line":"Source"}""");
+        var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("en-US");
+        await service.SetAsync(service.Capture(item.Group, "line", "en-US"), "Before");
+        var model = project.Services.GetRequiredService<GameLocalizationPanelViewModel>(); model.Selected = model.Categories.Single(category => category.Id == item.Group);
+        var cell = model.Rows.Single().Cells[1];
+        var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
+        var content = project.Services.GetRequiredService<IProjectContentSession>(); var changes = 0;
+        content.Changed += () => changes++;
+        var row = model.Rows.Single();
+        cell.Text = "First"; cell.Text = "Second"; cell.Text = "Latest\n完整文本";
+        await Task.Delay(20);
+        Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("Before"));
+        Assert.That(history.CanUndo, Is.False); Assert.That(cell.Busy, Is.False);
+        Assert.That(changes, Is.EqualTo(1), "Typing only notifies the first dirty transition, without per-key project refresh.");
+        Assert.That(model.Rows.Single(), Is.SameAs(row));
+        await cell.CommitAsync();
+        Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("Latest\n完整文本"));
+        Assert.That(cell.IsDirty, Is.False); Assert.That(cell.Message, Is.Empty);
+        await history.UndoAsync(); Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.Not.EqualTo("Latest\n完整文本"));
+        await history.RedoAsync(); Assert.That(cell.Text, Is.EqualTo("Latest\n完整文本"));
+        cell.Text = ""; await cell.CommitAsync();
+        Assert.That(cell.IsMissing, Is.False); Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo(""));
+        await project.Services.GetRequiredService<IProjectContentSession>().SaveAsync();
+    });
+
+    [Test]
+    public Task I18nInFlightCommitKeepsLaterTypingPendingUntilSaveAll() => WithLocalizationProject(async project =>
+    {
+        var item = CharacterEntry(project); WriteTranslation(project, """{"line":"Source"}""");
+        var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("en-US");
+        await service.SetAsync(service.Capture(item.Group, "line", "en-US"), "Before");
+        var model = project.Services.GetRequiredService<GameLocalizationPanelViewModel>(); model.Selected = model.Categories.Single(category => category.Id == item.Group);
+        var cell = model.Rows.Single().Cells[1];
+        var history = project.Services.GetRequiredService<EditorHistories>().Content;
+        var started = new TaskCompletionSource(); var release = new TaskCompletionSource();
+        var held = history.ExecuteAsync(new CallbackEdit("Hold", async () => { started.SetResult(); await release.Task; }, () => ValueTask.CompletedTask));
+        await started.Task;
+        cell.Text = "Submitted"; var commit = cell.CommitAsync(); cell.Text = "Still typing";
+        release.SetResult(); await held; await commit;
+        Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("Submitted"));
+        Assert.That(cell.Text, Is.EqualTo("Still typing")); Assert.That(cell.IsDirty, Is.True);
+        await project.Services.GetRequiredService<IProjectContentSession>().SaveAsync();
+        Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("Still typing"));
+        Assert.That(cell.IsDirty, Is.False);
+    });
+
+    [Test]
+    public Task I18nCellCommitCanRetryAfterJsonRepairWithoutRetyping() => WithLocalizationProject(async project =>
+    {
+        var item = CharacterEntry(project); WriteTranslation(project, """{"line":"Source"}""");
+        WriteTranslation(project, """{"line":"Before"}""", "I18n/en-US/lines.json");
+        var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("en-US");
+        var model = project.Services.GetRequiredService<GameLocalizationPanelViewModel>(); model.Selected = model.Categories.Single(category => category.Id == item.Group);
+        var cell = model.Rows.Single().Cells[1];
+        var buffer = project.Services.GetRequiredService<ProjectTextFiles>().Open("I18n/en-US/lines.json");
+        buffer.Text = "{invalid"; cell.Text = "Retry unchanged input";
+        Assert.CatchAsync(async () => await cell.CommitAsync());
+        Assert.That(cell.Text, Is.EqualTo("Retry unchanged input")); Assert.That(cell.HasMessage, Is.True);
+        buffer.Text = """{"line":"Before"}""";
+        await cell.CommitAsync();
+        Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("Retry unchanged input"));
+        Assert.That(cell.HasMessage, Is.False);
+    });
+
+    [Test]
+    public Task I18nRemoveLanguageRetainsTranslationsSupportsUndoAndRejectsOldWrites() => WithLocalizationProject(async project =>
+    {
+        var item = CharacterEntry(project); WriteTranslation(project, """{"line":"Source"}""");
+        var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("en-US");
+        await service.SetAsync(service.Capture(item.Group, "line", "en-US"), "Retained");
+        var target = service.Capture(item.Group, "line", "en-US");
+        var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
+        Assert.ThrowsAsync<EditorOperationException>(async () => await service.RemoveLanguageAsync("zh-CN"));
+        await service.RemoveLanguageAsync("en-US"); Assert.That(service.Languages, Does.Not.Contain("en-US"));
+        Assert.That(project.Services.GetRequiredService<LocalizationDocumentStore>().CaptureText("line", "en-US").Text, Is.EqualTo("Retained"));
+        Assert.ThrowsAsync<EditorOperationException>(async () => await service.SetAsync(target, "stale"));
+        await history.UndoAsync(); Assert.That(service.Languages, Does.Contain("en-US"));
+        await history.RedoAsync(); await service.AddLanguageAsync("en_us");
+        Assert.That(service.Snapshot(item.Group).Index.FindDirect("en-US", "line")?.Text, Is.EqualTo("Retained"));
+    });
+
+    [Test]
+    public Task I18nSuggestionsExcludeSelectedLanguagesAndMissingFilterUsesVisibleColumns() => WithLocalizationProject(async project =>
+    {
+        var item = CharacterEntry(project); WriteTranslation(project, """{"line":"Source"}""");
+        var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("en-US"); await service.AddLanguageAsync("ja-JP");
+        var model = project.Services.GetRequiredService<GameLocalizationPanelViewModel>(); model.Selected = model.Categories.Single(category => category.Id == item.Group);
+        Assert.That(model.LanguageSuggestions.Any(value => value.StartsWith("en-US —")), Is.False);
+        model.NewLanguage = "Korean"; Assert.That(model.LanguageSuggestions, Has.Some.StartsWith("ko-KR —"));
+        model.NewLanguage = "ko-KR — 한국어(대한민국)"; await model.AddLanguageCommand.ExecuteAsync(null);
+        Assert.That(model.Languages, Does.Contain("ko-KR"));
+        model.SetLanguageVisible("ko-KR", false);
+        var cell = model.Rows.Single().Cells.Single(value => value.Culture == "en-US"); cell.Text = "Translated"; await cell.CommitAsync();
+        model.OnlyMissing = true; Assert.That(model.Rows, Has.Count.EqualTo(1));
+        var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
+        model.SetLanguageVisible("ja-JP", false); Assert.That(model.Rows, Is.Empty);
+        model.SetLanguageVisible("zh-CN", false); Assert.That(model.VisibleLanguages, Does.Contain("zh-CN"));
+        model.SetLanguageVisible("ja-JP", true); Assert.That(model.Rows, Has.Count.EqualTo(1));
+        Assert.That(history.CanUndo, Is.False);
+    });
+
+    [Test]
+    public async Task I18nVisibleLanguageHeadersStayAlignedWhenTableBecomesNarrowerThanViewport()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); await WithLocalizationProject(async project =>
+            {
+                var item = CharacterEntry(project); WriteTranslation(project, """{"line":"Source"}""");
+                var service = project.Services.GetRequiredService<GameLocalizationPanelService>();
+                foreach (var culture in new[] { "en-US", "ja-JP", "ko-KR" }) await service.AddLanguageAsync(culture);
+                var model = project.Services.GetRequiredService<GameLocalizationPanelViewModel>(); model.Selected = model.Categories.Single(category => category.Id == item.Group);
+                var view = new GameLocalizationPanelView { DataContext = model }; var window = new Window { Content = view, Width = 1100, Height = 650 }; window.Show(); Dispatcher.UIThread.RunJobs();
+                void CheckColumns()
+                {
+                    Dispatcher.UIThread.RunJobs(); window.UpdateLayout();
+                    var headers = view.FindControl<StackPanel>("LanguageHeaders")!.Children.OfType<Grid>().ToArray();
+                    var inputs = view.GetVisualDescendants().OfType<TextBox>().Where(input => input.Name == "LocalizationCellInput").ToArray();
+                    Assert.That(inputs.Select(input => ((LocalizationGridCell)input.DataContext!).Culture), Is.EqualTo(model.VisibleLanguages));
+                    Assert.That(headers, Has.Length.EqualTo(inputs.Length));
+                    for (var i = 0; i < headers.Length; i++)
+                    {
+                        var cellBox = (Control)inputs[i].Parent!.Parent!;
+                        Assert.That(headers[i].TranslatePoint(default, view)!.Value.X, Is.EqualTo(cellBox.TranslatePoint(default, view)!.Value.X).Within(1), "Header and cell must share the same left edge after hiding a column.");
+                        Assert.That(headers[i].Bounds.Width, Is.EqualTo(cellBox.Bounds.Width).Within(1));
+                    }
+                }
+                try
+                {
+                    CheckColumns();
+                    view.FindControl<ScrollViewer>("LocalizationTableScroll")!.Offset = new Vector(160, 0);
+                    model.SetLanguageVisible("en-US", false); CheckColumns();
+                    model.SetLanguageVisible("ko-KR", false); CheckColumns();
+                    model.SetLanguageVisible("ja-JP", false); CheckColumns();
+                    model.SetLanguageVisible("en-US", true); CheckColumns();
+                }
+                finally { window.Close(); }
+            }); return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task I18nMountedManagerAddsAndRemovesLanguageAndTableUsesCompactOpaqueContexts()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); await WithLocalizationProject(async project =>
+            {
+                var item = CharacterEntry(project); WriteTranslation(project, """{"line":"Source text"}""");
+                var service = project.Services.GetRequiredService<GameLocalizationPanelService>(); await service.AddLanguageAsync("en-US");
+                var model = project.Services.GetRequiredService<GameLocalizationPanelViewModel>(); model.Selected = model.Categories.Single(category => category.Id == item.Group);
+                var view = new GameLocalizationPanelView { DataContext = model }; var window = new Window { Content = view, Width = 1000, Height = 650 }; window.Show(); Dispatcher.UIThread.RunJobs();
+                try
+                {
+                    var row = model.Rows.Single(); Assert.That(row.Source.Locations.Single().Details, Does.Contain(item.Entry.StableId));
+                    Assert.That(row.Slot, Does.Contain("content"));
+                    var context = view.GetVisualDescendants().OfType<Border>().Single(border => border.Name == "LocalizationContext");
+                    var brush = (ISolidColorBrush)context.Background!;
+                    Assert.That(brush.Color.A, Is.EqualTo(255)); Assert.That(brush.Opacity, Is.EqualTo(1));
+                    var source = view.GetVisualDescendants().OfType<TextBox>().Single(input => input.Name == "LocalizationCellInput" && input.DataContext is LocalizationGridCell cell && cell.Culture == "zh-CN");
+                    Assert.That(source.Bounds.Height, Is.LessThanOrEqualTo(48));
+                    var resize = view.GetVisualDescendants().OfType<Thumb>().Single(thumb => thumb.Name == "ResizeLanguage_zh_CN");
+                    var resizePoint = resize.TranslatePoint(new Point(resize.Bounds.Width / 2, resize.Bounds.Height / 2), window)!.Value;
+                    window.MouseDown(resizePoint, MouseButton.Left); Dispatcher.UIThread.RunJobs();
+                    window.MouseMove(resizePoint + new Vector(40, 0)); Dispatcher.UIThread.RunJobs();
+                    window.MouseUp(resizePoint + new Vector(40, 0), MouseButton.Left); Dispatcher.UIThread.RunJobs();
+                    Assert.That(model.ColumnWidth("zh-CN"), Is.GreaterThan(270));
+                    var manage = view.FindControl<Button>("ManageLanguages")!; Click(window, manage); Dispatcher.UIThread.RunJobs();
+                    var icon = (PathIcon)manage.Content!;
+                    Assert.That(icon.Bounds.Width, Is.EqualTo(16)); Assert.That(icon.Bounds.Height, Is.EqualTo(16));
+                    Assert.That(icon.TranslatePoint(default, manage)!.Value.X, Is.GreaterThanOrEqualTo(0));
+                    var flyout = (Flyout)manage.Flyout!; var popup = (Control)flyout.Content!;
+                    var selector = popup.GetVisualDescendants().OfType<AutoCompleteBox>().Single();
+                    selector.Text = "ja-JP"; Dispatcher.UIThread.RunJobs();
+                    var input = selector.GetVisualDescendants().OfType<TextBox>().First(); input.Focus();
+                    input.Text = "ja"; window.UpdateLayout(); Dispatcher.UIThread.RunJobs();
+                    await PumpCharacterUi(() => selector.IsDropDownOpen);
+                    Assert.That(model.LanguageSuggestions.Any(value => value.StartsWith("ja-JP —")), Is.True);
+                    Assert.That(model.LanguageSuggestions.Any(value => value.StartsWith("en-US —")), Is.False);
+                    selector.Text = "ja-JP"; Dispatcher.UIThread.RunJobs();
+                    Assert.That(model.NewLanguage, Is.EqualTo("ja-JP"));
+                    var add = popup.GetVisualDescendants().OfType<Button>().Single(button => button.Name == "AddLocalizationLanguage");
+                    var top = TopLevel.GetTopLevel(add)!;
+                    var point = add.TranslatePoint(new Point(add.Bounds.Width / 2, add.Bounds.Height / 2), top)!.Value;
+                    top.MouseDown(point, MouseButton.Left); Dispatcher.UIThread.RunJobs();
+                    top.MouseUp(point, MouseButton.Left); Dispatcher.UIThread.RunJobs();
+                    await PumpCharacterUi(() => model.Languages.Contains("ja-JP"));
+                    popup.GetVisualDescendants().OfType<Button>().Single(button => button.Name == "RemoveLanguage_ja_JP").RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+                    await PumpCharacterUi(() => !model.Languages.Contains("ja-JP"));
+                    if (Environment.GetEnvironmentVariable("GALNET_EDITOR_TEST_ARTIFACTS") is { Length: > 0 } artifacts)
+                    { using var frame = window.CaptureRenderedFrame(); frame!.Save(Path.Combine(artifacts, "localization-manager.png")); }
+                    flyout.Hide(); Dispatcher.UIThread.RunJobs();
+                    source = view.GetVisualDescendants().OfType<TextBox>().Single(box => box.Name == "LocalizationCellInput" && box.DataContext is LocalizationGridCell cell && cell.Culture == "zh-CN");
+                    source.Focus(); source.Text = "失焦更新"; Dispatcher.UIThread.RunJobs();
+                    Assert.That(service.Snapshot(item.Group).Index.FindDirect("zh-CN", "line")?.Text, Is.EqualTo("Source text"));
+                    view.FindControl<TextBox>("LocalizationSearch")!.Focus();
+                    await PumpCharacterUi(() => service.Snapshot(item.Group).Index.FindDirect("zh-CN", "line")?.Text == "失焦更新");
+                    Assert.That(view.GetVisualDescendants().OfType<TextBox>().Single(box => box.Name == "LocalizationCellInput" && box.DataContext is LocalizationGridCell cell && cell.Culture == "zh-CN"), Is.SameAs(source));
+                }
+                finally { window.Close(); }
+            }); return true;
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/NumericControlTestSupport.cs b/test/GalNet.Editor.Tests/NumericControlTestSupport.cs
new file mode 100644
index 00000000..b443cecd
--- /dev/null
+++ b/test/GalNet.Editor.Tests/NumericControlTestSupport.cs
@@ -0,0 +1,14 @@
+using Avalonia.Controls;
+using Avalonia.VisualTree;
+using GalNet.Game.Controls.Forms;
+
+namespace GeneralTest.Editor;
+
+internal static class NumericControlTestSupport
+{
+    public static TextBox Input(Control editor) => editor as TextBox ?? editor.GetVisualDescendants().OfType<TextBox>().Single();
+    public static IEnumerable<TextBox> NamedInputs(Control root, string name) => root.GetVisualDescendants().OfType<Control>()
+        .Where(control => control.Name == name && control is TextBox or NumericUpDown).Select(Input);
+    public static TextBox FieldInput(Control root, string field) => root.GetVisualDescendants().OfType<Control>()
+        .Where(control => control is TextBox or NumericUpDown && control.DataContext is FieldEditorContext context && context.Field.Id == field).Select(Input).Distinct().Single();
+}
diff --git a/test/GalNet.Editor.Tests/PlaybackLocatorTests.cs b/test/GalNet.Editor.Tests/PlaybackLocatorTests.cs
index 804b38fd..fca8c8c0 100644
--- a/test/GalNet.Editor.Tests/PlaybackLocatorTests.cs
+++ b/test/GalNet.Editor.Tests/PlaybackLocatorTests.cs
@@ -20,7 +20,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task PlaybackLocatorUsesRealSharedPickerFourLocalesHistoryStaleLeasesAndReopen()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -81,7 +81,7 @@ Button StopButton() => entries.GetVisualDescendants().OfType<Button>().Single(co
                 Assert.That(stop.Source.Parameters["playbackHandleId"].GetString(), Is.Empty); await history.UndoAsync(); Assert.That(history.CanUndo, Is.False); TimelinePump(window);
                 // A live popup cannot write after its source author snapshot changes.
                 (flyout, picker) = OpenPicker(); var stalePicker = picker;
-                var author = scope.GetRequiredService<EntryFieldAuthoringService>(); author.SetCondition(group.Id, animate.Source, "save.optional");
+                var author = scope.GetRequiredService<EntryFieldAuthoringService>(); author.SetCondition(group.Id, animate.Source, "false");
                 Assert.That(lease.TryResolve(out _), Is.False); var before = JsonSerializer.Serialize(stop.Source.Parameters);
                 stalePicker.ResourcePanel.Search.Text = text["Entry.Type.animation.animate"]; TimelinePump(window); PressGroupKey(stalePicker.ResourcePanel.Search, Key.Down); PressGroupKey(stalePicker.ResourcePanel.Search, Key.Enter); TimelinePump(window);
                 Assert.That(JsonSerializer.Serialize(stop.Source.Parameters), Is.EqualTo(before)); flyout.Hide();
diff --git a/test/GalNet.Editor.Tests/ProjectAudioSettingsTests.cs b/test/GalNet.Editor.Tests/ProjectAudioSettingsTests.cs
new file mode 100644
index 00000000..1e726b04
--- /dev/null
+++ b/test/GalNet.Editor.Tests/ProjectAudioSettingsTests.cs
@@ -0,0 +1,62 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Parameters;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Game.Controls.Forms;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    private static IFieldBinding Setting(ProjectSettingsPanelViewModel panel, string id, string section = "galnet.project")
+    {
+        var form = panel.Sections.Single(item => item.Id == section);
+        return form.Binding(form.Item.Fields.Single(field => field.Id == id));
+    }
+    private static Task Stage(ProjectSettingsPanelViewModel panel, string id, object? value, string section = "galnet.project") =>
+        Setting(panel, id, section).CommitAsync(new(JsonSerializer.SerializeToElement(value, new JsonSerializerOptions(JsonSerializerDefaults.Web)
+        { Converters = { new System.Text.Json.Serialization.JsonStringEnumConverter() } })), CancellationToken.None);
+
+    [Test]
+    public async Task CustomAudioConfigurationSupportsDraftUndoSaveAndReopen()
+    {
+        using var services = Services();
+        var projects = services.GetRequiredService<IProjectService>();
+        var path = Path.Combine(_root, "CustomAudio");
+        var project = await projects.CreateAsync(path, "CustomAudio", new(), Contracts());
+        var panel = project.Services.GetRequiredService<ProjectSettingsPanelViewModel>();
+        var section = panel.Sections.Single(item => item.Id == "galnet.project");
+        foreach (var id in new[] { "audioBuses", "audioTracks" })
+        {
+            var field = section.Item.Fields.Single(item => item.Id == id);
+            using var resolver = new ValueStructureResolver();
+            var sequence = resolver.Resolve(field);
+            Assert.That(sequence.Kind, Is.EqualTo(ValueStructureKind.Sequence));
+            Assert.That(resolver.Resolve(sequence.Element!).Kind, Is.EqualTo(ValueStructureKind.Object));
+        }
+        await Stage(panel, "audioBuses", new[] { new { id = "ambience", name = "Environment" } });
+        await Stage(panel, "audioTracks", new[] { new { id = "rain", busId = "ambience", preserveDuringCatchUp = true } });
+        await panel.CommitDraftAsync();
+        Assert.That(project.Configuration.ReadDefaultOptions().AudioTracks.Single().PreserveDuringCatchUp, Is.True);
+        await panel.UndoRedoHistory.UndoAsync();
+        Assert.That(project.Configuration.ReadDefaultOptions().AudioBuses, Is.Empty);
+        Assert.That(project.Configuration.ReadDefaultOptions().AudioTracks, Is.Empty);
+        await panel.UndoRedoHistory.RedoAsync();
+        Assert.That(project.Configuration.ReadDefaultOptions().AudioBuses.Single().Id, Is.EqualTo("ambience"));
+        await Stage(panel, "audioBuses", Array.Empty<object>());
+        await Stage(panel, "audioTracks", new[] { new { id = "rain", preserveDuringCatchUp = true } });
+        await panel.CommitDraftAsync();
+        Assert.That(project.Configuration.ReadDefaultOptions().AudioTracks.Single().BusId, Is.Null);
+        await panel.UndoRedoHistory.UndoAsync();
+        Assert.That(project.Configuration.ReadDefaultOptions().AudioTracks.Single().BusId, Is.EqualTo("ambience"));
+        await projects.SaveAsync();
+        await projects.CloseAsync();
+        await projects.OpenAsync(path);
+        var restored = projects.Current!.Configuration.ReadDefaultOptions();
+        Assert.That(restored.AudioBuses.Single().Id, Is.EqualTo("ambience"));
+        Assert.That(restored.AudioTracks.Single().BusId, Is.EqualTo("ambience"));
+        await projects.CloseAsync();
+    }
+}
diff --git a/test/GalNet.Editor.Tests/ProjectConfigurationFormTests.cs b/test/GalNet.Editor.Tests/ProjectConfigurationFormTests.cs
new file mode 100644
index 00000000..edb1efd6
--- /dev/null
+++ b/test/GalNet.Editor.Tests/ProjectConfigurationFormTests.cs
@@ -0,0 +1,121 @@
+using System.Text.Json;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.VisualTree;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+using GalNet.Core.Entry;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using GalNet.Game.Controls.Forms;
+using GalNet.GameHost.Content;
+using GalNet.Storage.FileSystem;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task LeavingSettingsFormAppliesProjectName()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            Avalonia.Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
+            using var services = Services();
+            var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "AutoSettings"), "Original", new(), Contracts());
+            var panel = project.Services.GetRequiredService<ProjectSettingsPanelViewModel>();
+            var view = new ProjectSettingsPanelView { DataContext = panel };
+            var other = new Button { Content = "Other" };
+            var layout = new StackPanel(); layout.Children.Add(view); layout.Children.Add(other);
+            var window = new Window { Width = 900, Height = 700, Content = layout }; window.Show(); window.UpdateLayout();
+            try
+            {
+                var name = view.FindControl<TextBox>("ProjectNameInput")!;
+                name.Focus(); name.Text = "Changed";
+                other.Focus();
+                for (var attempt = 0; attempt < 30 && project.Name != "Changed"; attempt++) await Task.Delay(20);
+                Assert.That(project.Name, Is.EqualTo("Changed"));
+                await panel.UndoRedoHistory.UndoAsync();
+                Assert.That(project.Name, Is.EqualTo("Original"));
+            }
+            finally { panel.Dispose(); window.Close(); await projects.CloseAsync(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task CustomConfigurationMountedFormPreservesUnknownDataThroughHistorySaveExportAndLoading()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            Avalonia.Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
+            using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "CustomConfiguration"), "Custom", new(), Contracts());
+            project.Configuration.SetRaw("developer.options", new(1, JsonSerializer.SerializeToElement(new { count = 2, limit = 5, future = new[] { 42 } })));
+            project.Configuration.SetRaw("opaque", new(7, JsonSerializer.SerializeToElement(new { kept = true })));
+            var panel = project.Services.GetRequiredService<ProjectSettingsPanelViewModel>();
+            var view = new ProjectSettingsPanelView { DataContext = panel };
+            var window = new Window { Width = 800, Height = 900, Content = view }; window.Show(); window.UpdateLayout();
+            try
+            {
+                var host = view.GetVisualDescendants().OfType<DtoEditorHost>().Single(host => host.Item?.Id == "developer.options");
+                Assert.That(host.Diagnostics, Is.Empty);
+                var form = host.GetVisualDescendants().OfType<SchemaForm>().Single();
+                Assert.That(form.Diagnostics, Is.Empty);
+                var input = host.GetVisualDescendants().OfType<TextBox>().Single(input => input.DataContext is FieldEditorContext context && context.Field.Id == "count");
+                input.Text = "4";
+                Assert.That(project.Configuration.Sections["developer.options"].Data.GetProperty("count").GetInt32(), Is.EqualTo(2));
+                await panel.CommitDraftAsync();
+                var old = Setting(panel, "count", "developer.options");
+                Assert.That(project.Configuration.Sections["developer.options"].Data.GetProperty("count").GetInt32(), Is.EqualTo(4));
+                await panel.UndoRedoHistory.UndoAsync();
+                Assert.That(project.Configuration.Sections["developer.options"].Data.GetProperty("count").GetInt32(), Is.EqualTo(2));
+                Assert.That(await old.CommitAsync(new(JsonSerializer.SerializeToElement(3)), CancellationToken.None), Is.Not.Null);
+                await panel.UndoRedoHistory.RedoAsync();
+                await projects.SaveAsync();
+                var resources = BuiltinResourceTypes.CreateCatalog(); var gallery = BuiltinGalleryTypes.CreateCatalog(resources);
+                var export = await GamePackageExporter.ExportAsync(project.Id, project.Name, project.RootPath, Path.Combine(_root, "Package"), resources, gallery,
+                    project.Services.GetRequiredService<IEntryCatalog>(), project.Configurations);
+                Assert.That(export.Success, Is.True, export.Error);
+                var installed = await GameInstallation.OpenAsync(export.PackagePath!);
+                var loaded = await installed.CreateContentProvider(resources, gallery, new GameContentLoadOptions { Configurations = project.Configurations }).LoadAsync();
+                Assert.That(loaded.Configuration.Sections["developer.options"].Data.GetProperty("count").GetInt32(), Is.EqualTo(4));
+                Assert.That(loaded.Configuration.Sections["developer.options"].Data.GetProperty("future")[0].GetInt32(), Is.EqualTo(42));
+                Assert.That(loaded.Configuration.Sections["opaque"].Version, Is.EqualTo(7));
+                panel.Dispose(); window.Close();
+                await projects.CloseAsync(); await projects.OpenAsync(project.RootPath);
+                Assert.That(projects.Current!.Configuration.Sections["developer.options"].Data.GetProperty("count").GetInt32(), Is.EqualTo(4));
+                await projects.CloseAsync();
+            }
+            finally { panel.Dispose(); window.Close(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task ConfigurationHistoryRestoresAbsentSectionsAndRejectedDraftsRemainEditable()
+    {
+        using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+        var project = await projects.CreateAsync(Path.Combine(_root, "ConfigurationDraft"), "Custom", new(), Contracts());
+        var panel = project.Services.GetRequiredService<ProjectSettingsPanelViewModel>();
+        await Stage(panel, "count", 4, "developer.options"); await Stage(panel, "limit", 3, "developer.options");
+        Assert.ThrowsAsync<InvalidDataException>(panel.CommitDraftAsync);
+        Assert.That(project.Configuration.Sections.ContainsKey("developer.options"), Is.False);
+        await Stage(panel, "limit", 6, "developer.options"); await panel.CommitDraftAsync();
+        var history = project.Services.GetRequiredService<EditorHistories>().Content;
+        await history.UndoAsync(); Assert.That(project.Configuration.Sections.ContainsKey("developer.options"), Is.False);
+        await history.RedoAsync(); Assert.That(project.Configuration.Sections["developer.options"].Data.GetProperty("count").GetInt32(), Is.EqualTo(4));
+        await Stage(panel, "caption", null, "developer.options"); await projects.SaveAsync();
+        Assert.That(project.Configuration.Sections["developer.options"].Data.GetProperty("caption").ValueKind, Is.EqualTo(JsonValueKind.Null));
+        await projects.CloseAsync();
+    }
+}
diff --git a/test/GalNet.Editor.Tests/ProjectFileLifecycleTests.cs b/test/GalNet.Editor.Tests/ProjectFileLifecycleTests.cs
index 30c90711..a6555130 100644
--- a/test/GalNet.Editor.Tests/ProjectFileLifecycleTests.cs
+++ b/test/GalNet.Editor.Tests/ProjectFileLifecycleTests.cs
@@ -1,4 +1,6 @@
 using System.Text.Json;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
@@ -76,7 +78,7 @@ public async Task ImportRedoUsesRetainedBytesAndDirectoryMovePreservesMetadataAn
         Assert.That(moved.Id, Is.EqualTo(imported.Id));
         Assert.That(moved.Path, Is.EqualTo("renamed/picture.png"));
         Assert.That(moved.ExtensionData!["custom"].GetProperty("x").GetInt32(), Is.EqualTo(17));
-        Assert.That(moved.Gallery, Has.Count.EqualTo(1));
+        Assert.That(moved.ReadGallery(), Has.Count.EqualTo(1));
         Assert.That(Directory.Exists(Path.Combine(project.RootPath, "Assets/renamed/empty")), Is.True);
         await history.UndoAsync();
         Assert.That(Directory.Exists(Path.Combine(project.RootPath, "Assets/folder/empty")), Is.True);
diff --git a/test/GalNet.Editor.Tests/ProjectFilesPanelTests.cs b/test/GalNet.Editor.Tests/ProjectFilesPanelTests.cs
index 9c45f31e..849cc53b 100644
--- a/test/GalNet.Editor.Tests/ProjectFilesPanelTests.cs
+++ b/test/GalNet.Editor.Tests/ProjectFilesPanelTests.cs
@@ -7,6 +7,8 @@
 using Avalonia.VisualTree;
 using Dock.Model.Controls;
 using Dock.Model.Core;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Dock;
 using GalNet.Editor.History;
@@ -24,7 +26,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task DirectoryExpandersAreKnownWhenTheirParentOpensAndRefreshAfterChanges()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
@@ -63,7 +65,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task BrowserAddressBlocksDropAndGlobalSearchExitFollowSelection()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
@@ -193,7 +195,7 @@ public async Task BinaryUnknownEncodingAndLargeFilesAreReadOnlyWithoutDirtyingTh
     [Test]
     public async Task ProjectFileBrowserMountedControlsNavigateSelectRenameCopyAndConfirmDelete()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
@@ -264,7 +266,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task TextPageBindsRealInputAndDockTitleFollowsTheSameBuffer()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
@@ -321,11 +323,11 @@ public async Task ProjectRootImportAndDuplicateUseFreshAssetIdsAndUniqueNames()
             await files.ExecuteAsync(new(ProjectFileAction.CreateFile, [], "Assets/image.png", Content: [1, 2]));
             File.WriteAllText(Path.Combine(project.RootPath, "Assets/image.png.meta"), """{"id":"original","type":"sprite","path":"image.png","gallery":[{"id":17,"typeId":"cg","title":"Picture"}],"custom":"retained"}""");
             await files.ExecuteAsync(new(ProjectFileAction.Copy, ["Assets/image.png"], "Assets", UniqueNames: true));
-            var codec = new GalNet.Core.Assets.AssetMetaCodec(GalNet.Core.Assets.BuiltinResourceTypes.CreateCatalog());
+            var codec = new GalNet.Core.Assets.AssetMetaCodec(GalNet.Contracts.Builtins.Assets.BuiltinResourceTypes.CreateCatalog());
             var original = codec.Deserialize(File.ReadAllText(Path.Combine(project.RootPath, "Assets/image.png.meta")));
             var copy = codec.Deserialize(File.ReadAllText(Path.Combine(project.RootPath, "Assets/image 1.png.meta")));
             Assert.That(copy.Id, Is.Not.EqualTo(original.Id)); Assert.That(copy.Path, Is.EqualTo("image 1.png"));
-            Assert.That(copy.Gallery!.Single().Id, Is.Not.EqualTo(original.Gallery!.Single().Id)); Assert.That(copy.Gallery!.Single().Title, Is.EqualTo("Picture")); Assert.That(copy.ExtensionData!["custom"].GetString(), Is.EqualTo("retained"));
+            Assert.That(copy.ReadGallery().Single().Id, Is.Not.EqualTo(original.ReadGallery().Single().Id)); Assert.That(copy.ReadGallery().Single().Title, Is.EqualTo("Picture")); Assert.That(copy.ExtensionData!["custom"].GetString(), Is.EqualTo("retained"));
             await project.Services.GetRequiredService<EditorHistories>().Content.UndoAsync(); Assert.That(File.Exists(Path.Combine(project.RootPath, "Assets/image 1.png")), Is.False);
         }
         finally { await projects.CloseAsync(); }
@@ -371,7 +373,7 @@ public async Task OpenTextFileMoveUndoCannotOverwriteAnExternallyOccupiedTarget(
     [Test]
     public async Task SelectedAndLockedAssetInspectorFollowIdentityThroughRenameDeleteAndUndo()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -412,7 +414,7 @@ public async Task AssetDeletionChecksUnsavedTextReferencesInsteadOfStaleDiskCont
         {
             var files = project.Services.GetRequiredService<ProjectFileAuthoringService>();
             await files.ExecuteAsync(new(ProjectFileAction.CreateFile, [], "Assets/image.png", Content: [1, 2]));
-            var meta = new GalNet.Core.Assets.AssetMetaCodec(GalNet.Core.Assets.BuiltinResourceTypes.CreateCatalog()).Deserialize(File.ReadAllText(Path.Combine(project.RootPath, "Assets/image.png.meta")));
+            var meta = new GalNet.Core.Assets.AssetMetaCodec(GalNet.Contracts.Builtins.Assets.BuiltinResourceTypes.CreateCatalog()).Deserialize(File.ReadAllText(Path.Combine(project.RootPath, "Assets/image.png.meta")));
             Encoding encoding = utf16 ? new UnicodeEncoding(true, true, true) : new UTF8Encoding(false, true);
             var original = encoding.GetPreamble().Concat(encoding.GetBytes("{}")).ToArray();
             await files.ExecuteAsync(new(ProjectFileAction.CreateFile, [], "UI/ui.json", Content: original));
diff --git a/test/GalNet.Editor.Tests/ProjectLocalizationLifecycleTests.cs b/test/GalNet.Editor.Tests/ProjectLocalizationLifecycleTests.cs
index 4df9b728..3325afc9 100644
--- a/test/GalNet.Editor.Tests/ProjectLocalizationLifecycleTests.cs
+++ b/test/GalNet.Editor.Tests/ProjectLocalizationLifecycleTests.cs
@@ -5,6 +5,7 @@
 using Avalonia.Headless;
 using Avalonia.VisualTree;
 using CommunityToolkit.Mvvm.Input;
+using GalNet.Contracts.Builtins;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
 using GalNet.Editor.Models.Graph;
@@ -20,7 +21,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task OpenFoundationViewsHistoryErrorsAndDialogRefreshAcrossFourLanguagesWithoutChangingContent()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             var originalCulture = CultureInfo.CurrentCulture;
@@ -29,7 +30,9 @@ await session.Dispatch<bool>(async () =>
             var localization = new EditorLocalizationService();
             using var services = Services(localization: localization);
             var projects = services.GetRequiredService<IProjectService>();
-            var project = await projects.CreateAsync(Path.Combine(_root, "Localized"), "Authored 名称", new(), Contracts());
+            var audio = GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create();
+            var project = await projects.CreateAsync(Path.Combine(_root, "Localized"), "Authored 名称",
+                new DefaultProjectOptions { AudioBuses = audio.Buses.ToList(), AudioTracks = audio.Tracks.ToList() }.ToConfiguration(), Contracts());
             var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
             var panel = project.Services.GetRequiredService<ProjectSettingsPanelViewModel>();
             var page = project.Services.GetRequiredService<EditorPageViewModel>();
@@ -74,7 +77,7 @@ await session.Dispatch<bool>(async () =>
                     var save = dialog.GetVisualDescendants().OfType<Button>().Single(button => button.Name == "CloseSave");
                     Assert.That(save.Content, Is.EqualTo(localization["Close.Save"]));
                     Assert.That(save.Bounds.Width, Is.GreaterThan(0));
-                    Assert.That(settingsView.FindControl<Button>("ApplySettingsButton")!.Content, Is.EqualTo(localization["Settings.Project.Apply"]));
+                    Assert.That(settingsView.FindControl<TextBlock>("ProjectSettingsTitle")!.Text, Is.EqualTo(localization["Settings.Project.Title"]));
                     Assert.That(graphView.GetVisualDescendants().OfType<TextBlock>().Any(text => text.Text == localization["Graph.Kind.LinearGroup"]), Is.True);
                     Assert.That(inspectorView.GetVisualDescendants().OfType<TextBlock>().Any(text => text.Text == localization["Graph.Kind.LinearGroup"]), Is.True);
                     Assert.That(page.MenuItems.SelectMany(menu => menu.Children ?? []).Any(item => item.Header?.Contains(localization["History.Rename"], StringComparison.Ordinal) == true), Is.True);
@@ -86,7 +89,7 @@ await session.Dispatch<bool>(async () =>
                     Assert.That(JsonSerializer.Serialize(content.CaptureWorking()), Is.EqualTo(snapshot));
                     Assert.That(content.IsDirty, Is.EqualTo(beforeDirty));
                     Assert.That(history.UndoDescription, Is.EqualTo(undo));
-                    Assert.That(project.Settings.TargetLocale.Code, Is.EqualTo("zh-CN"));
+                    Assert.That(project.Configuration.ReadDefaultOptions().TargetLocale.Code, Is.EqualTo("zh-CN"));
                     if (Environment.GetEnvironmentVariable("GALNET_EDITOR_TEST_ARTIFACTS") is { Length: > 0 } artifacts)
                     {
                         using var frame = window.CaptureRenderedFrame(); frame!.Save(Path.Combine(artifacts, "p2i-workspace-" + locale + ".png"));
@@ -100,13 +103,16 @@ await session.Dispatch<bool>(async () =>
                 {
                     language.SelectedItem = editorSettings.AvailableCultures.Single(culture => culture.Name == locale);
                     window.UpdateLayout();
-                    var gain = settingsView.GetVisualDescendants().OfType<NumericUpDown>().First(input => ReferenceEquals(input.DataContext, panel.AudioTracks[0]));
+                    Assert.That(settingsView.GetVisualDescendants().OfType<GalNet.Game.Controls.Forms.StructuredFieldEditor>()
+                        .Any(editor => editor.Context.Field.Id == "audioTracks"), Is.True);
                     var expectedGain = gains[gainIndex++];
-                    gain.Value = expectedGain;
+                    var tracks = project.Configuration.ReadDefaultOptions().AudioTracks;
+                    tracks[0] = tracks[0] with { DefaultGain = (float)expectedGain };
+                    await Stage(panel, "audioTracks", tracks);
                     await panel.SaveSettingsCommand.ExecuteAsync(null);
                     await workspace.SaveAsync();
                     using var json = JsonDocument.Parse(File.ReadAllBytes(Path.Combine(project.RootPath, "settings.json")));
-                    Assert.That(json.RootElement.GetProperty("audioTracks")[0].GetProperty("defaultGain").GetDouble(), Is.EqualTo((double)expectedGain).Within(0.00001));
+                    Assert.That(json.RootElement.GetProperty("sections").GetProperty("galnet.project").GetProperty("data").GetProperty("audioTracks")[0].GetProperty("defaultGain").GetDouble(), Is.EqualTo((double)expectedGain).Within(0.00001));
                 }
             }
             finally
@@ -122,7 +128,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task NewProjectErrorsAndDisposedViewsKeepCorrectLocalizationLifetime()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
diff --git a/test/GalNet.Editor.Tests/ProjectSchemaLifecycleTests.cs b/test/GalNet.Editor.Tests/ProjectSchemaLifecycleTests.cs
index 22034c6e..3a19918c 100644
--- a/test/GalNet.Editor.Tests/ProjectSchemaLifecycleTests.cs
+++ b/test/GalNet.Editor.Tests/ProjectSchemaLifecycleTests.cs
@@ -1,7 +1,7 @@
 using GalNet.Core.Entry;
-using GalNet.Core.Settings;
 using GalNet.Editor.Abstraction.Commands;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Abstraction.Settings;
 using GalNet.Editor.Commands;
 using GalNet.Editor.Composition;
 using GalNet.Editor.Services.Interfaces;
@@ -127,7 +127,7 @@ private string Deploy(string fixture)
         foreach (var file in Directory.GetFiles(Path.Combine(directory.FullName, "test", "Fixtures", fixture, "bin", configuration, "net10.0")))
             File.Copy(file, Path.Combine(contracts, Path.GetFileName(file)));
         Directory.CreateDirectory(Path.Combine(project, "Graph"));
-        File.WriteAllText(Path.Combine(project, "settings.json"), "{}");
+        File.WriteAllText(Path.Combine(project, "settings.json"), """{"version":1,"sections":{}}""");
         File.WriteAllText(Path.Combine(project, "Graph/graph.json"),
             """{"version":2,"name":"Fixture","rootNodeId":"entry","nodes":[{"id":"entry","type":"Entry","name":"Entry","x":0,"y":0}],"edges":[],"playerVariables":[],"saveVariables":[]}""");
         return project;
diff --git a/test/GalNet.Editor.Tests/ProjectWorkspaceLifecycleTests.Application.cs b/test/GalNet.Editor.Tests/ProjectWorkspaceLifecycleTests.Application.cs
new file mode 100644
index 00000000..e5f564ef
--- /dev/null
+++ b/test/GalNet.Editor.Tests/ProjectWorkspaceLifecycleTests.Application.cs
@@ -0,0 +1,148 @@
+using Avalonia.Controls;
+using Avalonia.Headless;
+using CommunityToolkit.Mvvm.Input;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task NewProjectApplication_FindsContractsCopiesOnlyDependenciesAndPersistsDebugApp(bool packaged)
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            using var services = Services();
+            var (executable, contracts) = CreateApplication(packaged);
+            var dialogs = (TestDialogs)services.GetRequiredService<IFileDialogService>();
+            dialogs.OpenPaths = [executable];
+            var panel = services.GetRequiredService<NewProjectPanelViewModel>();
+            var view = new NewProjectPanelView { DataContext = panel };
+            var window = new Window { Width = 860, Height = 800, Content = view };
+            window.Show();
+            try
+            {
+                view.FindControl<TextBox>("ProjectNameInput")!.Text = "FromApp";
+                view.FindControl<TextBox>("ProjectRootInput")!.Text = _root;
+                await ((IAsyncRelayCommand)view.FindControl<Button>("BrowseApplicationButton")!.Command!).ExecuteAsync(null);
+                Assert.That(view.FindControl<TextBox>("ApplicationPathInput")!.Text, Is.EqualTo(executable));
+                Assert.That(view.FindControl<TextBox>("ContractsDirectoryInput")!.Text, Is.EqualTo(contracts));
+                await ((IAsyncRelayCommand)view.FindControl<Button>("CreateProjectButton")!.Command!).ExecuteAsync(null);
+                Assert.That(panel.Message, Is.Empty);
+                var projects = services.GetRequiredService<IProjectService>();
+                var path = projects.Current!.RootPath;
+                var deployed = Directory.GetFiles(Path.Combine(path, "Contracts")).Select(Path.GetFileName).ToArray();
+                Assert.That(deployed, Is.SupersetOf(new[] { "GalNet.Project.Contracts.dll", "GalNet.Core.dll", "GalNet.Contracts.Builtins.dll", "SchemaDependency.dll" }));
+                Assert.That(deployed, Has.None.EqualTo("System.Private.CoreLib.dll"));
+                Assert.That(deployed, Has.None.EqualTo("Unrelated.dll"));
+                Assert.That(deployed, Has.None.EqualTo("native.dll"));
+                Assert.That(deployed, Has.None.EqualTo("Game.pdb"));
+                Assert.That(deployed, Has.None.EqualTo("Game.exe"));
+                Assert.That(File.ReadAllBytes(Path.Combine(path, "Contracts", ProjectSchemaContext.AssemblyFileName)),
+                    Is.EqualTo(File.ReadAllBytes(Path.Combine(contracts, ProjectSchemaContext.AssemblyFileName))));
+                await projects.CloseAsync();
+                var reopened = await projects.OpenAsync(path);
+                var launch = ExternalGameDebugClient.LoadSettings(reopened.RootPath)!;
+                Assert.That(launch.Executable, Is.EqualTo(executable));
+                Assert.That(launch.Arguments, Is.Empty);
+                Assert.That(launch.WorkingDirectory, Is.Null);
+                Assert.That(reopened.Services.GetRequiredService<GalNet.Core.Entry.IEntryCatalog>().Get("custom.example"), Is.Not.Null);
+                await projects.CloseAsync();
+                return true;
+            }
+            finally { window.Close(); }
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task NewProjectApplication_PreservesExplicitContractAndPickerCancellation()
+    {
+        using var services = Services();
+        var dialogs = (TestDialogs)services.GetRequiredService<IFileDialogService>();
+        var panel = services.GetRequiredService<NewProjectPanelViewModel>();
+        panel.ContractsDirectory = "  explicit contract  ";
+        var (executable, _) = CreateApplication(false);
+        dialogs.OpenPaths = [executable];
+        await panel.BrowseApplicationCommand.ExecuteAsync(null);
+        Assert.That(panel.ContractsDirectory, Is.EqualTo("  explicit contract  "));
+        dialogs.OpenPaths = [];
+        await panel.BrowseApplicationCommand.ExecuteAsync(null);
+        Assert.That(panel.ApplicationPath, Is.EqualTo(executable));
+        Assert.That(panel.ContractsDirectory, Is.EqualTo("  explicit contract  "));
+    }
+
+    [TestCase("missing")]
+    [TestCase("invalid")]
+    [TestCase("dependency")]
+    [TestCase("ambiguous")]
+    public async Task NewProjectApplication_InvalidSourceDoesNotCreateOrFallBackToDefaults(string failure)
+    {
+        using var services = Services();
+        var (executable, contracts) = CreateApplication(false);
+        if (failure == "missing") File.Delete(Path.Combine(contracts, ProjectSchemaContext.AssemblyFileName));
+        if (failure == "invalid") File.WriteAllText(Path.Combine(contracts, ProjectSchemaContext.AssemblyFileName), "invalid DLL");
+        if (failure == "dependency") File.Delete(Path.Combine(contracts, "SchemaDependency.dll"));
+        if (failure == "ambiguous")
+        {
+            Directory.CreateDirectory(Path.Combine(contracts, "lib"));
+            File.Copy(Path.Combine(contracts, ProjectSchemaContext.AssemblyFileName), Path.Combine(contracts, "lib", ProjectSchemaContext.AssemblyFileName));
+        }
+        var panel = services.GetRequiredService<NewProjectPanelViewModel>();
+        panel.ProjectName = "Rejected";
+        panel.ProjectRoot = _root;
+        panel.ApplicationPath = executable;
+        if (failure is "missing" or "ambiguous")
+        {
+            Assert.That(panel.ContractsDirectory, Is.Empty);
+            Assert.That(panel.Message, Is.Not.Empty);
+        }
+        await panel.CreateCommand.ExecuteAsync(null);
+        Assert.That(panel.Message, Is.Not.Empty);
+        Assert.That(services.GetRequiredService<IProjectService>().Current, Is.Null);
+        Assert.That(Directory.Exists(Path.Combine(_root, "Rejected")), Is.False);
+    }
+
+    [Test]
+    public async Task NewProjectApplication_ManualContractsCanResolveMissingAutomaticSource()
+    {
+        using var services = Services();
+        var executable = Path.Combine(_root, "Game.exe");
+        File.WriteAllBytes(executable, []);
+        var panel = services.GetRequiredService<NewProjectPanelViewModel>();
+        panel.ProjectName = "Manual";
+        panel.ProjectRoot = _root;
+        panel.ApplicationPath = executable;
+        Assert.That(panel.Message, Is.Not.Empty);
+        var dialogs = (TestDialogs)services.GetRequiredService<IFileDialogService>();
+        dialogs.Folder = Contracts();
+        await panel.BrowseContractsCommand.ExecuteAsync(null);
+        Assert.That(panel.Message, Is.Empty);
+        await panel.CreateCommand.ExecuteAsync(null);
+        Assert.That(panel.Message, Is.Empty);
+        var projects = services.GetRequiredService<IProjectService>();
+        Assert.That(ExternalGameDebugClient.LoadSettings(projects.Current!.RootPath)!.Executable, Is.EqualTo(executable));
+        await projects.CloseAsync();
+    }
+
+    private (string Executable, string Contracts) CreateApplication(bool packaged)
+    {
+        var root = Directory.CreateDirectory(Path.Combine(_root, "Game App")).FullName;
+        var contracts = packaged ? Directory.CreateDirectory(Path.Combine(root, "lib")).FullName : root;
+        foreach (var file in Directory.GetFiles(Contracts(), "*.dll"))
+            File.Copy(file, Path.Combine(contracts, Path.GetFileName(file)));
+        // A self-contained App also carries framework DLLs and unrelated managed/native payloads.
+        File.Copy(typeof(object).Assembly.Location, Path.Combine(contracts, "System.Private.CoreLib.dll"));
+        File.Copy(typeof(NewProjectPanelViewModel).Assembly.Location, Path.Combine(contracts, "Unrelated.dll"));
+        File.WriteAllText(Path.Combine(contracts, "native.dll"), "native payload");
+        File.WriteAllText(Path.Combine(contracts, "Game.pdb"), "symbols");
+        var executable = Path.Combine(root, "Game.exe");
+        File.WriteAllBytes(executable, []);
+        return (executable, contracts);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/ProjectWorkspaceLifecycleTests.cs b/test/GalNet.Editor.Tests/ProjectWorkspaceLifecycleTests.cs
index 240bf4b7..ddd4a55a 100644
--- a/test/GalNet.Editor.Tests/ProjectWorkspaceLifecycleTests.cs
+++ b/test/GalNet.Editor.Tests/ProjectWorkspaceLifecycleTests.cs
@@ -6,15 +6,16 @@
 using Avalonia.VisualTree;
 using CommunityToolkit.Mvvm.Input;
 using Dock.Model.Controls;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
-using GalNet.Core.Settings;
 using GalNet.Core.Variable;
 using GalNet.Editor.Abstraction.Changes;
 using GalNet.Editor.Abstraction.Documents;
 using GalNet.Editor.Abstraction.Extensibility;
 using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Abstraction.Settings;
 using GalNet.Editor.Composition;
 using GalNet.Editor.Dock;
 using GalNet.Editor.History;
@@ -44,7 +45,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [TestCase(true)]
     public async Task NewProjectView_CreatesWithDefaultOrCustomContractWithoutStartingPreview(bool customContract)
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.RequestedThemeVariant = Avalonia.Styling.ThemeVariant.Light;
@@ -83,8 +84,7 @@ await session.Dispatch<bool>(async () =>
                 var projects = services.GetRequiredService<IProjectService>();
                 Assert.That(projects.Current!.Name, Is.EqualTo("Authored"));
                 Assert.That(services.GetRequiredService<INavigationService>().CurrentPage, Is.TypeOf<EditorPageViewModel>());
-                Assert.That(projects.Current.Services.GetRequiredService<EditorWorkspaceViewModel>().ActivePreview, Is.Null);
-                Assert.That(services.GetRequiredService<IEditorExtensionRegistry>().FindDockPanel(EditorDockPanelIds.GamePreview), Is.Null);
+                Assert.That(services.GetRequiredService<IEditorExtensionRegistry>().FindDockPanel("GamePreview"), Is.Null);
                 var projectPath = projects.Current.RootPath;
                 Assert.That(File.Exists(Path.Combine(projectPath, "Contracts", ProjectSchemaContext.AssemblyFileName)), Is.True);
                 await projects.CloseAsync();
@@ -101,7 +101,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task GroupPagesShareProjectContentAndClosingThemDoesNotDiscardEdits()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             using var services = Services();
@@ -142,13 +142,13 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task SettingsViewCommitsOneEditAndHistorySurvivesClosingThePage()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
             using var services = Services();
             var projects = services.GetRequiredService<IProjectService>();
-            var project = await projects.CreateAsync(Path.Combine(_root, "SettingsHistory"), "Original", new() { SfxChannelCount = 7 }, Contracts());
+            var project = await projects.CreateAsync(Path.Combine(_root, "SettingsHistory"), "Original", new DefaultProjectOptions { DefaultHeight = 777 }.ToConfiguration(), Contracts());
             var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
             var panel = project.Services.GetRequiredService<ProjectSettingsPanelViewModel>();
             var view = new ProjectSettingsPanelView { DataContext = panel };
@@ -170,10 +170,10 @@ await session.Dispatch<bool>(async () =>
                 Assert.That(group.Name, Is.EqualTo("Local undo sentinel"), "Local text undo must consume the shortcut before the project history.");
                 input.SelectAll();
                 window.KeyTextInput("Renamed");
-                panel.SaveSlotCount = 19;
+                await Stage(panel, "saveSlotCount", 19);
                 Assert.That(project.Name, Is.EqualTo("Original"), "Typing stays in the page draft until explicit commit.");
                 Assert.That(await projects.CheckUnsavedChangesAsync(), Is.True);
-                await ((IAsyncRelayCommand)view.FindControl<Button>("ApplySettingsButton")!.Command!).ExecuteAsync(null);
+                await panel.CommitDraftAsync();
                 Assert.That(input.CanUndo, Is.False, "Committed text must not merge with an earlier local input gesture.");
                 window.UpdateLayout();
                 if (Environment.GetEnvironmentVariable("GALNET_EDITOR_TEST_ARTIFACTS") is { Length: > 0 } artifacts)
@@ -182,7 +182,7 @@ await session.Dispatch<bool>(async () =>
                     frame!.Save(Path.Combine(artifacts, "p1b-project-settings.png"));
                 }
                 Assert.That(project.Name, Is.EqualTo("Renamed"));
-                Assert.That(project.Settings.SaveSlotCount, Is.EqualTo(19));
+                Assert.That(project.Configuration.ReadDefaultOptions().SaveSlotCount, Is.EqualTo(19));
                 await workspace.SaveAsync();
                 panel.ProjectName = "AfterSave";
                 await panel.SaveSettingsCommand.ExecuteAsync(null);
@@ -194,12 +194,12 @@ await session.Dispatch<bool>(async () =>
                 Assert.That(project.Services.GetRequiredService<IProjectContentSession>().IsDirty, Is.False);
                 await router.RedoAsync();
                 Assert.That(project.Name, Is.EqualTo("AfterSave"));
-                Assert.That(project.Settings.SfxChannelCount, Is.EqualTo(7));
+                Assert.That(project.Configuration.ReadDefaultOptions().DefaultHeight, Is.EqualTo(777));
                 await workspace.SaveAsync();
                 await projects.CloseAsync();
                 var reopened = await projects.OpenAsync(project.RootPath);
                 Assert.That(reopened.Name, Is.EqualTo("AfterSave"));
-                Assert.That(reopened.Settings.SaveSlotCount, Is.EqualTo(19));
+                Assert.That(reopened.Configuration.ReadDefaultOptions().SaveSlotCount, Is.EqualTo(19));
                 await projects.CloseAsync();
             }
             finally { panel.Dispose(); window.Close(); }
@@ -240,20 +240,20 @@ public async Task CloseProjectHonorsSaveDiscardAndCancel(ProjectCloseChoice choi
 
     [TestCase(false)]
     [TestCase(true)]
-    public async Task InvalidSettingsDraftBlocksSaveAndCloseWithoutDiscardingTheInput(bool invalidLocale)
+    public async Task InvalidSettingsDraftBlocksSaveAndCloseWithoutDiscardingTheInput(bool invalidValue)
     {
         using var services = Services(new TestClosePrompt(ProjectCloseChoice.Save));
         var projects = services.GetRequiredService<IProjectService>();
         var project = await projects.CreateAsync(Path.Combine(_root, "InvalidDraft"), "Before", new(), Contracts());
         var panel = project.Services.GetRequiredService<ProjectSettingsPanelViewModel>();
-        if (invalidLocale) panel.TargetLocale = "";
+        if (invalidValue) Setting(panel, "defaultWidth").Draft!.Update("not a number", true, null, false);
         else panel.ProjectName = "";
-        panel.SaveSlotCount = 19;
+        await Stage(panel, "saveSlotCount", 19);
         try { await projects.CloseAsync(); Assert.Fail("An invalid draft must block Save and Close."); }
-        catch (EditorOperationException failure) { Assert.That(failure.Code, Does.StartWith(invalidLocale ? "settings." : "project.")); }
+        catch (EditorOperationException failure) { Assert.That(failure.Code, Does.StartWith(invalidValue ? "settings." : "project.")); }
         Assert.That(projects.Current, Is.SameAs(project));
-        Assert.That(invalidLocale ? panel.TargetLocale : panel.ProjectName, Is.Empty);
-        Assert.That(project.Settings.SaveSlotCount, Is.EqualTo(60), "Invalid input must not partially apply other settings.");
+        Assert.That(invalidValue ? Setting(panel, "defaultWidth").Draft!.Text : panel.ProjectName, Is.EqualTo(invalidValue ? "not a number" : ""));
+        Assert.That(project.Configuration.ReadDefaultOptions().SaveSlotCount, Is.EqualTo(60), "Invalid input must not partially apply other settings.");
         Assert.That(panel.IsDirtyText, Is.Not.Empty);
         panel.CancelDraftCommand.Execute(null);
         Assert.That(panel.ProjectName, Is.EqualTo("Before"));
@@ -327,7 +327,6 @@ public async Task CreatingTheWorkspaceAfterASettingsEditDoesNotResetProjectHisto
         var project = await projects.CreateAsync(Path.Combine(_root, "LateWorkspace"), "Before", new(), Contracts());
         var panel = project.Services.GetRequiredService<ProjectSettingsPanelViewModel>();
         panel.ProjectName = "Edited before opening Graph";
-        panel.TargetLocale = "zh_cn";
         await panel.SaveSettingsCommand.ExecuteAsync(null);
         var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
         Assert.That(workspace.UndoRedoHistory.CanUndo, Is.True);
@@ -373,7 +372,7 @@ private sealed class TestClosePrompt(ProjectCloseChoice choice) : IProjectCloseP
     [TestCase(null, ProjectCloseChoice.Cancel)]
     public async Task CloseDialogButtonsAndWindowCloseReturnTheExpectedChoice(string? buttonLabel, ProjectCloseChoice expected)
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
@@ -422,20 +421,22 @@ public async Task CancelNewProjectDoesNotCreateFiles()
     }
 
     [Test]
-    public async Task SettingsSaveDerivesVariablesFromTheGraphAndPreservesOtherConfiguration()
+    public async Task VariablesPersistOnlyInTheGraphWhileSettingsRemainIndependent()
     {
         using var services = Services();
         var projects = services.GetRequiredService<IProjectService>();
-        var project = await projects.CreateAsync(Path.Combine(_root, "Settings"), "Settings", new() { SfxChannelCount = 7 }, Contracts());
+        var project = await projects.CreateAsync(Path.Combine(_root, "Settings"), "Settings", new DefaultProjectOptions { DefaultHeight = 777 }.ToConfiguration(), Contracts());
         var value = new Variable { Name = "score" };
         value.SetValue(4);
         var documents = project.Services.GetRequiredService<IEditorDocumentService>();
         documents.CurrentDocument.PlayerVariables.Add(new() { Name = "score", DefaultValue = value });
-        project.Settings.PlayerVariables.Clear();
         await projects.SaveAsync();
         using var saved = JsonDocument.Parse(File.ReadAllText(project.SettingsFilePath));
-        Assert.That(saved.RootElement.GetProperty("playerVariables")[0].GetProperty("name").GetString(), Is.EqualTo("score"));
-        Assert.That(project.Settings.SfxChannelCount, Is.EqualTo(7));
+        Assert.That(saved.RootElement.TryGetProperty("playerVariables", out _), Is.False);
+        Assert.That(saved.RootElement.TryGetProperty("saveVariables", out _), Is.False);
+        using var graph = JsonDocument.Parse(File.ReadAllText(Path.Combine(project.GraphPath, "graph.json")));
+        Assert.That(graph.RootElement.GetProperty("playerVariables")[0].GetProperty("name").GetString(), Is.EqualTo("score"));
+        Assert.That(project.Configuration.ReadDefaultOptions().DefaultHeight, Is.EqualTo(777));
         await projects.CloseAsync();
     }
 
@@ -470,12 +471,13 @@ public async Task ProjectDisposalInvalidatesBindingsEvenForEntriesRetainedOnlyBy
             Document = new() { Nodes = [new() { Id = "group", Type = "Group", File = "groups/group.rawgalgroup" }] },
             GroupEntries = { ["group"] = [new() { StableId = "line", Type = "custom.value", Parameters = new() { ["count"] = JsonSerializer.SerializeToElement(4) } }] }
         });
-        var store = new EditorGroupProjectionStore(documents, catalog, new EntryFieldAuthoringService(documents, new EditorHistories()));
+        using var histories = new EditorHistories();
+        var store = new EditorGroupProjectionStore(documents, catalog, new EntryFieldAuthoringService(documents, histories));
         var group = store.Get("group");
         var entry = group.Entries.Single();
         entry.ConfigureParameterFields(catalog, [], []);
         var field = (IFieldBinding)entry.ParameterFields.Single();
-        group.Entries.Remove(entry);
+        new GroupEntryAuthoringService(documents, catalog, histories).Delete("group", [entry.StableId]);
         store.Dispose();
         Assert.That(await field.CommitAsync(new(JsonSerializer.SerializeToElement(9)), CancellationToken.None), Is.Not.Null);
         Assert.That(entry.Source.Parameters["count"].GetInt32(), Is.EqualTo(4));
@@ -642,7 +644,7 @@ public async Task GraphDeleteExternalConflictPreservesNodesFilesAndHistory()
     [Test]
     public async Task GraphCanvasActualPointerDragCanCancelAndCommitOneHistoryStep()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
diff --git a/test/GalNet.Editor.Tests/ResourceIdentityTests.cs b/test/GalNet.Editor.Tests/ResourceIdentityTests.cs
new file mode 100644
index 00000000..d8ab7016
--- /dev/null
+++ b/test/GalNet.Editor.Tests/ResourceIdentityTests.cs
@@ -0,0 +1,245 @@
+using System.Text;
+using System.Text.Json;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Headless;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.VisualTree;
+using GalNet.Assets;
+using GalNet.Contracts.Builtins;
+using GalNet.Core.Assets;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Controls;
+using GalNet.Editor.History;
+using GalNet.Editor.Inspector.ViewModels;
+using GalNet.Editor.Models;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.Services.Interfaces;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.ViewModels;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task MountedEntryResourceFollowsIdAcrossRenameMoveUndoAndReopen()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "ResourceIdentity"), "Identity", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var files = scope.GetRequiredService<ProjectFileAuthoringService>(); var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            await files.ExecuteAsync(new(ProjectFileAction.CreateFile, [], "Assets/voice.ogg", Content: [1]));
+            await files.ExecuteAsync(new(ProjectFileAction.CreateDirectory, [], "Assets/voice-folder"));
+            var id = scope.GetRequiredService<IAssetCatalogService>().GetEntry("voice.ogg")!.Id!;
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.PlayAudio).Single();
+            scope.GetRequiredService<EntryFieldAuthoringService>().SetParameters(group.Id, entry.Source, entry.Type,
+                entry.Source.Parameters.Append(new KeyValuePair<string, JsonElement>("asset", JsonSerializer.SerializeToElement(id))).GroupBy(pair => pair.Key).ToDictionary(items => items.Key, items => items.Last().Value));
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = entry;
+            var view = new EntryListEditorControl { DataContext = page }; var window = new Window { Content = view, Width = 1200, Height = 900 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var picker = view.GetVisualDescendants().OfType<AssetPicker>().Single(control => control.Filter == AssetPickerFilter.Audio && control.IsEffectivelyVisible);
+                await WaitForResourceUi(window, () => picker.DisplayText == "voice.ogg");
+                var button = picker.FindControl<Button>("PickerButton")!; TimelineClick(window, button);
+                await WaitForResourceUi(window, () => picker.ResourcePanel.Results.Any(item => item.Id == id));
+                picker.ResourcePanel.Search.Text = "voice";
+                var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+                await files.ExecuteAsync(new(ProjectFileAction.Move, ["Assets/voice.ogg"], "Assets/voice-folder/voice-new.ogg", false));
+                await WaitForResourceUi(window, () => picker.DisplayText == "voice-new.ogg" && picker.ResourcePanel.Results.Any(item => item.Id == id && item.Detail == "voice-folder/voice-new.ogg"));
+                Assert.That(picker.SelectedAssetId, Is.EqualTo(id)); Assert.That(entry.Source.Parameters["asset"].GetString(), Is.EqualTo(id));
+                Assert.That(picker.ResourcePanel.Search.Text, Is.EqualTo("voice"));
+                await history.UndoAsync(); await WaitForResourceUi(window, () => picker.DisplayText == "voice.ogg");
+                await history.RedoAsync(); await WaitForResourceUi(window, () => picker.DisplayText == "voice-new.ogg");
+                Assert.That((await scope.GetRequiredService<IAssetManager>().GetFileAsync(id))!.Path, Is.EqualTo("voice-folder/voice-new.ogg"));
+                Assert.That(await scope.GetRequiredService<IAssetManager>().GetFileAsync("voice-folder/voice-new.ogg"), Is.Null, "Paths never act as fallback identities.");
+                ((Flyout)button.Flyout!).Hide(); await workspace.SaveAsync(); var root = project.RootPath; window.Close(); await projects.CloseAsync();
+                project = await projects.OpenAsync(root);
+                Assert.That((await project.Services.GetRequiredService<IAssetManager>().GetFileAsync(id))!.Path, Is.EqualTo("voice-folder/voice-new.ogg"));
+                Assert.That(project.Services.GetRequiredService<IEditorDocumentService>().Groups[group.Id].Entries.Single().Parameters["asset"].GetString(), Is.EqualTo(id));
+                await projects.CloseAsync(); return true;
+            }
+            finally { window.Close(); if (projects.Current is not null) await projects.CloseAsync(); }
+        }, CancellationToken.None);
+    }
+
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task OpenVariantBufferRebasesFolderAndPreservesSavedAndUnsavedChanges(bool moveImages)
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "VariantBuffer"), "Variants", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var files = scope.GetRequiredService<ProjectFileAuthoringService>(); var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            await CreateVariantImages(project.RootPath, files);
+            await files.ExecuteAsync(new(ProjectFileAction.CreateDirectory, [], "Assets/atlases"));
+            await files.ExecuteAsync(new(ProjectFileAction.CreateFile, [], "Assets/hero.variants", Content: Encoding.UTF8.GetBytes("""{"folder":"alice","default":"idle_coat"}""")));
+            var buffer = scope.GetRequiredService<ProjectTextFiles>().Open("Assets/hero.variants");
+            using var inspector = new ImageVariantsInspector(project.RootPath, buffer, projects, scope.GetRequiredService<IResourceTypeCatalog>(), scope.GetRequiredService<IAssetCatalogService>(), scope.GetRequiredService<IEditorLocalizationService>());
+            inspector.Default = "smile_skirt"; await inspector.ConfigurationSaving; // Unsaved author state must remain unsaved after moving.
+            var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+            await files.ExecuteAsync(moveImages ? new(ProjectFileAction.Move, ["Assets/alice"], "Assets/pictures", false)
+                : new(ProjectFileAction.Move, ["Assets/hero.variants"], "Assets/atlases/hero.variants", false));
+            var folder = moveImages ? "pictures" : "../alice";
+            Assert.That(JsonDocument.Parse(buffer.Text).RootElement.GetProperty("folder").GetString(), Is.EqualTo(folder));
+            Assert.That(inspector.Folder, Is.EqualTo(folder)); Assert.That(inspector.Default, Is.EqualTo("smile_skirt"));
+            Assert.That(JsonDocument.Parse(File.ReadAllText(Path.Combine(project.RootPath, buffer.Path))).RootElement.GetProperty("default").GetString(), Is.EqualTo("idle_coat"));
+            await workspace.SaveAsync(); await history.UndoAsync();
+            Assert.That(buffer.Path, Is.EqualTo("Assets/hero.variants")); Assert.That(inspector.Folder, Is.EqualTo("alice"));
+            Assert.That(inspector.Default, Is.EqualTo("smile_skirt"));
+            Assert.That(JsonDocument.Parse(File.ReadAllText(Path.Combine(project.RootPath, buffer.Path))).RootElement.GetProperty("default").GetString(), Is.EqualTo("smile_skirt"));
+            Assert.That(scope.GetRequiredService<IProjectContentSession>().IsDirty, Is.False);
+            await history.RedoAsync(); Assert.That(inspector.Folder, Is.EqualTo(folder));
+            var id = scope.GetRequiredService<IAssetCatalogService>().GetEntry(buffer.Path[7..])!.Id!;
+            Assert.That(await scope.GetRequiredService<IAssetManager>().GetFileAsync(id), Is.Not.Null);
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task ResourceIndexSharesQueriesAndCancellationAndRefreshKeepsActiveLeasesAndRegistrations()
+    {
+        using var services = Services(); var manager = services.GetRequiredService<EditorAssetManager>();
+        var provider = new ResourceTestProvider(); manager.RegisterProvider(provider);
+        var gate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); provider.Gate = gate.Task;
+        using var cancellation = new CancellationTokenSource();
+        var cancelled = manager.GetFilesAsync(ct: cancellation.Token); var first = manager.GetFileAsync("stable"); var second = manager.GetFilesAsync("audio");
+        cancellation.Cancel(); Assert.CatchAsync<OperationCanceledException>(async () => await cancelled);
+        gate.SetResult(); Assert.That(await first, Is.Not.Null); Assert.That(await second, Has.Count.EqualTo(1)); Assert.That(provider.Opens, Is.EqualTo(1));
+        Assert.That(await manager.GetFileAsync("voice.ogg"), Is.Null); Assert.That(provider.Opens, Is.EqualTo(1));
+        var decoder = new ResourceTestDecoder(); manager.RegisterDecoder("audio", decoder);
+        using var lease = await manager.AcquireAsync<ResourceDecoded>("stable"); Assert.That(lease, Is.Not.Null);
+        manager.RegisterProvider(new ResourceTestProvider("other")); // Refresh retires the old generation while its lease is alive.
+        Assert.That(lease!.Value.Disposed, Is.False);
+        using var next = await manager.AcquireAsync<ResourceDecoded>("stable"); Assert.That(next, Is.Not.Null); Assert.That(decoder.Decodes, Is.EqualTo(2));
+        lease.Dispose(); Assert.That(lease.Value.Disposed, Is.True); Assert.That(next!.Value.Disposed, Is.False);
+        Assert.That(await manager.GetFilesAsync(), Has.Count.EqualTo(2));
+    }
+
+    [Test]
+    public async Task ResourceIndexReportsDuplicateIdsAndReadFailuresInsteadOfMissingAndRetriesFailures()
+    {
+        using var services = Services(); var manager = services.GetRequiredService<EditorAssetManager>(); var provider = new ResourceTestProvider();
+        manager.RegisterProvider(provider); provider.Failure = new IOException("Cannot read metadata");
+        Assert.ThrowsAsync<IOException>(async () => await manager.GetFileAsync("stable"));
+        provider.Failure = null; Assert.That(await manager.GetFileAsync("stable"), Is.Not.Null); Assert.That(provider.Opens, Is.EqualTo(2));
+        manager.RegisterProvider(new ResourceTestProvider());
+        Assert.ThrowsAsync<InvalidDataException>(async () => await manager.GetFilesAsync());
+    }
+
+    [Test]
+    public async Task PickerNeverRebindsToReplacementAtSamePathAndDistinguishesReadErrors()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var manager = services.GetRequiredService<EditorAssetManager>();
+            var provider = new ResourceTestProvider(); manager.RegisterProvider(provider);
+            using var picker = new AssetPicker { AssetManager = manager, SelectedAssetId = "stable", Filter = AssetPickerFilter.Audio };
+            var window = new Window { Content = picker, Width = 650, Height = 600 }; window.Show();
+            try
+            {
+                await WaitForResourceUi(window, () => picker.DisplayText == "voice.ogg");
+                provider.Id = "replacement"; manager.RegisterProvider(new ResourceTestProvider("other"));
+                await WaitForResourceUi(window, () => picker.DisplayText == "Missing!");
+                Assert.That(picker.SelectedAssetId, Is.EqualTo("stable")); Assert.That(picker.DetailPath, Is.EqualTo("stable"));
+                provider.Id = "stable"; provider.Failure = new IOException("Metadata is unreadable"); manager.RegisterProvider(new ResourceTestProvider("third"));
+                await WaitForResourceUi(window, () => picker.DisplayText == "Unable to load");
+                Assert.That(picker.DetailPath, Does.Contain("Metadata is unreadable")); Assert.That(picker.SelectedAssetId, Is.EqualTo("stable"));
+                provider.Failure = null; manager.RegisterProvider(new ResourceTestProvider("fourth"));
+                await WaitForResourceUi(window, () => picker.DisplayText == "voice.ogg");
+                return true;
+            }
+            finally { window.Close(); }
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task PickerDropsOldLoadsAndCachesThumbnailsUntilResourceGenerationChanges()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var manager = services.GetRequiredService<EditorAssetManager>(); var provider = new ResourceTestProvider(); manager.RegisterProvider(provider);
+            using (var bitmap = new WriteableBitmap(new PixelSize(2, 2), new Vector(96, 96), PixelFormat.Bgra8888, AlphaFormat.Premul))
+            {
+                using var bytes = new MemoryStream(); bitmap.Save(bytes); provider.Data = bytes.ToArray();
+            }
+            provider.TypeId = "sprite";
+            var gate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); provider.Gate = gate.Task;
+            using var picker = new AssetPicker { AssetManager = manager, SelectedAssetId = "stable", Filter = AssetPickerFilter.Image };
+            var window = new Window { Content = picker, Width = 650, Height = 600 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var button = picker.FindControl<Button>("PickerButton")!; TimelineClick(window, button);
+                provider.Gate = null; provider.Path = "new-name.png"; manager.RegisterProvider(new ResourceTestProvider("other"));
+                await WaitForResourceUi(window, () => picker.DisplayText == "new-name.png" && picker.Items.Any(item => item.File?.Id == "stable"));
+                var item = picker.Items.Single(item => item.File?.Id == "stable"); gate.SetResult();
+                Assert.That(item.Thumbnail, Is.Not.Null); Assert.That(item.Thumbnail!.PixelSize.Width, Is.EqualTo(128));
+                ((Flyout)button.Flyout!).Hide(); TimelineClick(window, button);
+                await WaitForResourceUi(window, () => picker.Items.Any(candidate => candidate.File?.Id == "stable"));
+                Assert.That(picker.Items.Single(candidate => candidate.File?.Id == "stable"), Is.SameAs(item));
+                Assert.That(picker.DisplayText, Is.EqualTo("new-name.png")); Assert.That(picker.SelectedAssetId, Is.EqualTo("stable"));
+                provider.Path = "latest.png"; manager.RegisterProvider(new ResourceTestProvider("third"));
+                await WaitForResourceUi(window, () => picker.DisplayText == "latest.png" && picker.Items.Any(candidate => candidate.File?.Id == "stable" && candidate.Path == "latest.png"));
+                Assert.That(picker.Items.Single(candidate => candidate.File?.Id == "stable").Thumbnail, Is.Not.SameAs(item.Thumbnail));
+                window.Close(); return true;
+            }
+            finally { gate.TrySetResult(); window.Close(); }
+        }, CancellationToken.None);
+    }
+
+    private static async Task WaitForResourceUi(Window window, Func<bool> ready)
+    {
+        var until = DateTime.UtcNow.AddSeconds(15);
+        while (!ready() && DateTime.UtcNow < until) { await Task.Delay(10); TimelinePump(window); }
+        Assert.That(ready(), Is.True, "Resource UI did not reach the expected generation.");
+    }
+    private sealed class ResourceTestProvider(string id = "stable") : IAssetProvider, IDisposable
+    {
+        public string Name => "Resource tests";
+        public string Id { get; set; } = id;
+        public string Path { get; set; } = "voice.ogg";
+        public string TypeId { get; set; } = "audio";
+        public byte[] Data { get; set; } = [1];
+        public Task? Gate { get; set; }
+        public Exception? Failure { get; set; }
+        public int Opens { get; private set; }
+        public bool Disposed { get; private set; }
+        public bool Exists(string name) => true;
+        public IArchive OpenArchive(string name) => OpenArchiveAsync(name).GetAwaiter().GetResult();
+        public async Task<IArchive> OpenArchiveAsync(string name, CancellationToken ct = default)
+        {
+            Opens++; var path = Path;
+            if (Gate is { } gate) await gate.WaitAsync(ct);
+            ObjectDisposedException.ThrowIf(Disposed, this);
+            if (Failure is { } failure) throw failure;
+            return new ResourceTestArchive(new GameFile(Id, path, TypeId, new AssetMeta { Id = Id, Path = path, TypeId = TypeId }, Data));
+        }
+        public void Dispose() => Disposed = true;
+    }
+    private sealed class ResourceTestArchive(IGameFile file) : IArchive
+    {
+        public string Name => "assets";
+        public IEnumerable<string> AssetIds => [file.Id];
+        public bool Contains(string id) => id == file.Id;
+        public IGameFile? GetAsset(string id) => Contains(id) ? file : null;
+        public IGameFile? GetAssetByPath(string path) => file.Path == path ? file : null;
+        public void Dispose() { }
+    }
+    private sealed class ResourceDecoded : IDisposable { public bool Disposed { get; private set; } public void Dispose() => Disposed = true; }
+    private sealed class ResourceTestDecoder : IAssetDecoder<ResourceDecoded>
+    {
+        public int Decodes { get; private set; }
+        public ValueTask<ResourceDecoded?> DecodeAsync(IGameFile file, ReadOnlyMemory<byte> data, CancellationToken ct = default) { Decodes++; return ValueTask.FromResult<ResourceDecoded?>(new()); }
+    }
+}
diff --git a/test/GalNet.Editor.Tests/ResourceOverridesPanelTests.cs b/test/GalNet.Editor.Tests/ResourceOverridesPanelTests.cs
new file mode 100644
index 00000000..9a3d8b0f
--- /dev/null
+++ b/test/GalNet.Editor.Tests/ResourceOverridesPanelTests.cs
@@ -0,0 +1,212 @@
+using System.Text.Json;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using GalNet.Assets;
+using GalNet.Core.Configuration;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.Controls;
+using GalNet.Editor.History;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.Services.Interfaces;
+using GalNet.Editor.Shared.Services;
+using GalNet.Editor.ViewModels;
+using GalNet.Editor.Views;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task ResourcePatchMountedMatrixSelectsLocatesUndoesSavesReopensAndExports()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "Patches"), "Patches", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            await using var projectLifetime = project;
+            var scope = project.Services; var files = scope.GetRequiredService<ProjectFileAuthoringService>();
+            static byte[] Png(int size)
+            {
+                using var bitmap = new Avalonia.Media.Imaging.WriteableBitmap(new Avalonia.PixelSize(size, size), new Avalonia.Vector(96, 96),
+                    Avalonia.Platform.PixelFormat.Bgra8888, Avalonia.Platform.AlphaFormat.Premul);
+                using var memory = new MemoryStream(); bitmap.Save(memory); return memory.ToArray();
+            }
+            var replacementBytes = Png(3);
+            await files.ExecuteAsync(new(ProjectFileAction.CreateFile, [], "Assets/original.png", Content: Png(2)));
+            await files.ExecuteAsync(new(ProjectFileAction.CreateFile, [], "Assets/replacement.png", Content: replacementBytes));
+            var original = scope.GetRequiredService<IAssetCatalogService>().GetEntry("original.png")!.Id!;
+            var replacement = scope.GetRequiredService<IAssetCatalogService>().GetEntry("replacement.png")!.Id!;
+            var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, "layer.show").Single();
+            var parameters = new Dictionary<string, JsonElement>(entry.Source.Parameters) { ["assetId"] = JsonSerializer.SerializeToElement(original) };
+            scope.GetRequiredService<EntryFieldAuthoringService>().SetParameters(group.Id, entry.Source, entry.Type, parameters);
+            scope.GetRequiredService<GraphAuthoringService>().SetStoryPackage(group.Id, "bonus");
+            await scope.GetRequiredService<IProjectContentSession>().SaveAsync();
+            var dock = scope.GetRequiredService<GalNet.Editor.Dock.EditorDockFactory>();
+            var layout = dock.CreateLayout(); dock.InitLayout(layout);
+            var model = scope.GetRequiredService<ResourceOverridesPanelViewModel>(); await model.RefreshAsync();
+            var view = new ResourceOverridesPanelView { DataContext = model }; var window = new Window { Content = view, Width = 1300, Height = 700 };
+            window.Show(); TimelinePump(window);
+            try
+            {
+                Assert.That(model.Rows.Any(row => row.Id == original), Is.True, model.Message);
+                var search = view.FindControl<TextBox>("ResourcePatchSearch")!;
+                search.Text = "no-such-resource";
+                await WaitForResourceUi(window, () => model.Rows.Count == 0);
+                search.Text = "";
+                await WaitForResourceUi(window, () => model.Rows.Any(row => row.Id == original));
+                TimelineClick(window, view.GetVisualDescendants().OfType<Button>().Single(button => button.Name == "CreateResourcePatch"));
+                await WaitForResourceUi(window, () => model.Columns.Count == 1);
+                var id = model.Columns[0].Id;
+                var name = view.GetVisualDescendants().OfType<TextBox>().Single(box => box.Name == "PatchName_" + id);
+                name.Focus(); name.Text = "Clothes B";
+                view.FindControl<Button>("CreateResourcePatch")!.Focus();
+                await WaitForResourceUi(window, () => model.Service.Read().Packages.Single().Name == "Clothes B");
+                var priority = view.GetVisualDescendants().OfType<NumericUpDown>().Single(input => input.Name == "PatchPriority_" + id);
+                priority.Value = 7;
+                await WaitForResourceUi(window, () => model.Service.Read().Packages.Single().Priority == 7);
+                Assert.That(view.GetVisualDescendants().OfType<Button>().Any(button => button.Name?.StartsWith("DiscardPatch_") == true), Is.False);
+                foreach (var button in view.GetVisualDescendants().OfType<Button>().Where(button => button.Name is "CreateResourcePatch" || button.Name == "ExportPatch_" + id || button.Name == "DeletePatch_" + id))
+                    Assert.That(button.Content, Is.TypeOf<PathIcon>(), "Patch actions should use the shared icon-button style.");
+                var dependencies = view.FindControl<CheckBox>("ShowResourceDependencies")!;
+                var createButton = view.FindControl<Button>("CreateResourcePatch")!;
+                Assert.That(dependencies.VerticalAlignment, Is.EqualTo(Avalonia.Layout.VerticalAlignment.Center));
+                Assert.That(dependencies.VerticalContentAlignment, Is.EqualTo(Avalonia.Layout.VerticalAlignment.Center));
+                Assert.That(dependencies.TranslatePoint(new Point(0, dependencies.Bounds.Height / 2), view)!.Value.Y,
+                    Is.EqualTo(createButton.TranslatePoint(new Point(0, createButton.Bounds.Height / 2), view)!.Value.Y).Within(1));
+                var picker = view.GetVisualDescendants().OfType<AssetPicker>().Single(control => control.Name == "Replacement_" + id + "_" + original);
+                TimelineClick(window, picker.FindControl<Button>("PickerButton")!);
+                await WaitForResourceUi(window, () => picker.ResourcePanel.Results.Any(item => item.Id == replacement) || picker.ResourcePanel.Hint.Length > 0);
+                Assert.That(picker.ResourcePanel.Results.Any(item => item.Id == replacement), Is.True, picker.ResourcePanel.Hint);
+                picker.ResourcePanel.List.SelectedItem = picker.ResourcePanel.Results.Single(item => item.Id == replacement);
+                picker.ResourcePanel.RaiseEvent(new KeyEventArgs { RoutedEvent = InputElement.KeyDownEvent, Key = Key.Enter });
+                await WaitForResourceUi(window, () => model.Service.Read().Packages.Single().Mappings.GetValueOrDefault(original) == replacement);
+                var history = scope.GetRequiredService<EditorHistories>().Content;
+                await history.UndoAsync(); Assert.That(model.Service.Read().Packages.Single().Mappings.ContainsKey(original), Is.False);
+                await history.RedoAsync(); await model.RefreshAsync(); TimelinePump(window);
+                for (var index = 0; index < 4; index++) await model.Service.CreateAsync("Extra " + index);
+                await model.RefreshAsync(); TimelinePump(window);
+                foreach (var column in model.Columns)
+                {
+                    var header = view.GetVisualDescendants().OfType<TextBox>().Single(box => box.Name == "PatchName_" + column.Id);
+                    var left = header.TranslatePoint(default, view)!.Value.X;
+                    foreach (var button in view.GetVisualDescendants().OfType<Button>().Where(button => button.Name is { } name &&
+                        (name == "ExportPatch_" + column.Id || name == "DeletePatch_" + column.Id)))
+                        Assert.That(button.TranslatePoint(new Avalonia.Point(button.Bounds.Width, 0), view)!.Value.X, Is.LessThanOrEqualTo(left + 260), "Column actions must not overlap the next patch.");
+                }
+                var scroll = view.GetVisualDescendants().OfType<ScrollViewer>().Single(control => control.Name == "ResourcePatchHorizontalScroll");
+                scroll.Offset = new Avalonia.Vector(300, 0); TimelinePump(window); Assert.That(scroll.Offset.X, Is.GreaterThan(0));
+                scroll.Offset = default; TimelinePump(window);
+                TimelineClick(window, view.GetVisualDescendants().OfType<Button>().Single(button => button.Name == "Locate_" + original));
+                Assert.That(scope.GetRequiredService<AssetPanelViewModel>().SelectedEntry?.Path, Is.EqualTo("Assets/original.png"));
+                var output = Path.Combine(_root, "patch.pak"); ((TestDialogs)services.GetRequiredService<IFileDialogService>()).SavePath = output;
+                TimelineClick(window, view.GetVisualDescendants().OfType<Button>().Single(button => button.Name == "ExportPatch_" + id));
+                await WaitForResourceUi(window, () => File.Exists(output) && !model.Busy);
+                var types = scope.GetRequiredService<GalNet.Core.Assets.IResourceTypeCatalog>();
+                using (var pak = Archive.Deserialize("assets", File.ReadAllBytes(output), types))
+                {
+                    Assert.That(pak.Descriptor.Priority, Is.EqualTo(7));
+                    Assert.That(pak.Descriptor.Mappings[original], Is.EqualTo(replacement));
+                    Assert.That(pak.GetAsset(replacement)!.ReadAllBytes(), Is.EqualTo(replacementBytes));
+                }
+                if (Environment.GetEnvironmentVariable("GALNET_EDITOR_TEST_ARTIFACTS") is { Length: > 0 } artifacts)
+                { Directory.CreateDirectory(artifacts); using var frame = window.CaptureRenderedFrame(); frame?.Save(Path.Combine(artifacts, "resource-patches.png")); }
+                var root = project.RootPath; window.Close(); await projects.CloseAsync(); project = await projects.OpenAsync(root);
+                Assert.That(project.Configuration.Read(ResourceOverrideOptions.Section).Packages.Single(package => package.Id == id).Name, Is.EqualTo("Clothes B"));
+                Assert.That(project.Services.GetRequiredService<IEditorDocumentService>().CurrentDocument.Nodes.Single(node => node.Id == group.Id).StoryPackage, Is.EqualTo("bonus"));
+                await projects.CloseAsync(); return true;
+            }
+            finally { window.Close(); if (projects.Current is not null) await projects.CloseAsync(); }
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task GroupStoryPackageMountedInspectorCommitsOnBlurAndUsesProjectHistory()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "PackageInspector"), "Inspector", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            await using var projectLifetime = project;
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup); workspace.SelectNode(group);
+            var model = scope.GetRequiredService<GalNet.Editor.Inspector.ViewModels.NodeInspectorControlViewModel>();
+            var view = new GalNet.Editor.Inspector.Views.NodeInspectorControl { DataContext = model };
+            var window = new Window { Content = view, Width = 600, Height = 700 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var input = view.FindControl<AutoCompleteBox>("StoryPackageInput")!;
+                input.GetVisualDescendants().OfType<TextBox>().First().Focus(); input.Text = "bonus-ui";
+                view.GetVisualDescendants().OfType<Button>().First(button => ReferenceEquals(button.Command, model.OpenGroupEditorCommand)).Focus();
+                await WaitForResourceUi(window, () => group.Source.StoryPackage == "bonus-ui");
+                await scope.GetRequiredService<EditorHistories>().Content.UndoAsync(); Assert.That(group.StoryPackage, Is.Empty);
+                await scope.GetRequiredService<EditorHistories>().Content.RedoAsync(); Assert.That(group.StoryPackage, Is.EqualTo("bonus-ui"));
+                window.Close(); await projects.CloseAsync(); return true;
+            }
+            finally { window.Close(); if (projects.Current is not null) await projects.CloseAsync(); }
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task ResourcePatchesPersistWithoutSavingOtherContentAndExportDoesNotCommitDrafts()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "PatchDraft"), "Draft", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            await using var projectLifetime = project;
+            var scope = project.Services; var authoring = scope.GetRequiredService<GraphAuthoringService>();
+            var group = scope.GetRequiredService<EditorWorkspaceViewModel>().Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            authoring.SetStoryPackage(group.Id, "bonus");
+            var history = scope.GetRequiredService<EditorHistories>().Content;
+            await history.UndoAsync(); Assert.That(group.Source.StoryPackage, Is.Null);
+            await history.RedoAsync(); Assert.That(group.Source.StoryPackage, Is.EqualTo("bonus"));
+            var model = scope.GetRequiredService<ResourceOverridesPanelViewModel>();
+            var content = scope.GetRequiredService<IProjectContentSession>();
+            var graphPath = Path.Combine(project.RootPath, "Graph", "graph.json");
+            var graphBytes = File.ReadAllBytes(graphPath);
+            ResourceOverrideOptions Disk() => GalNet.Core.Serialization.JsonCodec.Deserialize<ProjectConfiguration>(File.ReadAllText(Path.Combine(project.RootPath, "settings.json")))!.Read(ResourceOverrideOptions.Section);
+            await model.Service.CreateAsync("Clothes"); await model.RefreshAsync();
+            Assert.That(Disk().Packages.Single().Name, Is.EqualTo("Clothes"));
+            Assert.That(File.ReadAllBytes(graphPath), Is.EqualTo(graphBytes), "Patch autosave must preserve unrelated unsaved Graph edits.");
+            Assert.That(content.IsDirty, Is.True);
+            var column = model.Columns.Single();
+            await model.SetHeaderAsync(column, "Clothes B", 5);
+            Assert.That(Disk().Packages.Single().Priority, Is.EqualTo(5));
+            await history.UndoAsync(); Assert.That(Disk().Packages.Single().Name, Is.EqualTo("Clothes"));
+            await history.RedoAsync(); Assert.That(Disk().Packages.Single().Name, Is.EqualTo("Clothes B"));
+            await model.RefreshAsync();
+            await model.SetHeaderAsync(column, "", 5);
+            Assert.That(model.Message, Is.Not.Empty);
+            Assert.That(Disk().Packages.Single().Name, Is.EqualTo("Clothes B"));
+            var original = model.Service.Read().Packages.Single().Id;
+            await model.Service.DeleteAsync(original); Assert.That(Disk().Packages, Is.Empty);
+            await history.UndoAsync(); Assert.That(Disk().Packages.Single().Id, Is.EqualTo(original));
+            var files = scope.GetRequiredService<ProjectFileAuthoringService>();
+            await files.ExecuteAsync(new(ProjectFileAction.CreateFile, [], "Assets/a.png", Content: [1]));
+            await files.ExecuteAsync(new(ProjectFileAction.CreateFile, [], "Assets/b.png", Content: [2]));
+            var assets = scope.GetRequiredService<IAssetCatalogService>();
+            await model.Service.SetMappingAsync(original, assets.GetEntry("a.png")!.Id!, assets.GetEntry("b.png")!.Id!, null);
+            using (content.RegisterDraft(() => true, () => throw new InvalidOperationException("Unrelated unfinished input")))
+            {
+                var output = Path.Combine(_root, "pure-export.pak");
+                var settingsBeforeExport = File.ReadAllBytes(Path.Combine(project.RootPath, "settings.json"));
+                await model.Service.ExportAsync(original, output, CancellationToken.None);
+                Assert.That(File.Exists(output), Is.True);
+                Assert.That(File.ReadAllBytes(Path.Combine(project.RootPath, "settings.json")), Is.EqualTo(settingsBeforeExport));
+                Assert.That(File.ReadAllBytes(graphPath), Is.EqualTo(graphBytes));
+            }
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/SceneQueryLifetimeTests.cs b/test/GalNet.Editor.Tests/SceneQueryLifetimeTests.cs
new file mode 100644
index 00000000..4d5b9e81
--- /dev/null
+++ b/test/GalNet.Editor.Tests/SceneQueryLifetimeTests.cs
@@ -0,0 +1,63 @@
+using System.Text.Json;
+using Avalonia.Headless;
+using GalNet.Contracts.Builtins;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.ViewModels;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task UnchangedQueryRetainsTimelineInputAndChangedThenUndoneTargetCannotReviveSelector()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "QueryLifetime"), "Lifetime", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var layer = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ShowLayer).Single();
+            var timeline = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.PlayTimeline).Single();
+            var later = workspace.InsertEntriesInto(group, 2, 1, BuiltinEntryIds.Wait).Single();
+            var author = scope.GetRequiredService<EntryFieldAuthoringService>();
+            author.SetParameters(group.Id, timeline.Source, timeline.Type, new()
+            {
+                ["timeline"] = JsonSerializer.SerializeToElement(new
+                {
+                    playbackHandleId = "p",
+                    durationFrames = 60,
+                    tracks = new[] { new { handleId = layer.Source.Parameters["handleId"].GetString(), property = "opacity", keys = new[] { new { frame = 0, value = 1 } } } },
+                    events = Array.Empty<object>()
+                })
+            });
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = timeline;
+            var session = scope.GetRequiredService<TimelineEditSession>(); var query = scope.GetRequiredService<ProjectSceneTargets>();
+            var row = session.Rows.Single(item => item.HasTrack); row.DraftValue = .25m;
+            var catalog = scope.GetRequiredService<SceneTargetCatalog>();
+            using var selector = new SceneTargetSelection(catalog, catalog.Query(group.Id, timeline.StableId));
+            selector.Select(selector.Items.First().Id);
+            var captures = query.AuthorCaptureCount; var transfers = query.AnalysisEntryTransferCount;
+            for (var i = 0; i < 100; i++) catalog.Query(group.Id, timeline.StableId);
+            Assert.That(query.AuthorCaptureCount, Is.EqualTo(captures)); Assert.That(query.AnalysisEntryTransferCount, Is.EqualTo(transfers));
+            author.SetCondition(group.Id, later.Source, "false");
+            Assert.That(selector.IsCurrent, Is.True); Assert.That(session.Rows.Single(item => item.HasTrack), Is.SameAs(row));
+            Assert.That(row.DraftValue, Is.EqualTo(.25m)); Assert.That(row.Commit(), Is.True);
+            author.SetCondition(group.Id, layer.Source, "false");
+            Assert.That(selector.IsCurrent, Is.False); await scope.GetRequiredService<EditorHistories>().Content.UndoAsync();
+            Assert.That(selector.IsCurrent, Is.False); Assert.That(row.Commit(), Is.False);
+            using var replaced = new SceneTargetSelection(catalog, catalog.Query(group.Id, timeline.StableId));
+            var documents = scope.GetRequiredService<IEditorDocumentService>();
+            var entries = documents.Groups[group.Id].Entries; var index = entries.IndexOf(timeline.Source);
+            entries[index] = JsonSerializer.Deserialize<GalNet.Editor.Abstraction.Documents.EditorEntryData>(JsonSerializer.Serialize(timeline.Source))!;
+            documents.SynchronizeGroups();
+            Assert.That(replaced.IsCurrent, Is.False, "Equal JSON cannot renew the identity of a replaced writing context.");
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/SceneReferenceReviewTests.cs b/test/GalNet.Editor.Tests/SceneReferenceReviewTests.cs
new file mode 100644
index 00000000..9c11f6b2
--- /dev/null
+++ b/test/GalNet.Editor.Tests/SceneReferenceReviewTests.cs
@@ -0,0 +1,105 @@
+using System.Text.Json;
+using Avalonia.Headless;
+using GalNet.Contracts.Builtins;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.ViewModels;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task SceneReferenceReviewIsReadOnlyRejectsStaleConfirmationAndPreservesWarningsAcrossUndoSaveReopen()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "SceneReview"), "Scene review", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services;
+            var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var creator = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ShowLayer).Single();
+            var handle = creator.Source.Parameters["handleId"].GetString()!;
+            var consumer = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.HideLayer).Single();
+            scope.GetRequiredService<EntryFieldAuthoringService>().SetParameters(group.Id, consumer.Source, consumer.Type, new() { ["handleId"] = JsonSerializer.SerializeToElement(handle) });
+            var author = scope.GetRequiredService<GroupEntryAuthoringService>(); var history = scope.GetRequiredService<EditorHistories>().Content;
+            var query = scope.GetRequiredService<ProjectSceneTargets>(); history.Clear();
+            var preview = author.PrepareDelete(group.Id, [creator.StableId])!;
+            Assert.That(history.CanUndo, Is.False); Assert.That(group.Entries, Has.Count.EqualTo(2));
+            Assert.That(preview.Impact.References.Single().After.Code, Is.EqualTo("scene.reference.missing"));
+            consumer.Condition = "true";
+            var staleCursor = history.UndoText;
+            Assert.Throws<EditorOperationException>(preview.Commit);
+            Assert.That(history.UndoText, Is.EqualTo(staleCursor)); Assert.That(group.Entries, Has.Count.EqualTo(2));
+            await history.UndoAsync(); history.Clear();
+            var problems = scope.GetRequiredService<ProblemsPanelViewModel>(); problems.ValidateCommand.Execute(null);
+            preview = author.PrepareDelete(group.Id, [creator.StableId])!; preview.Commit();
+            Assert.That(query.Diagnostics().Any(issue => issue.Code == "scene.reference.missing" && issue.Owner.EntryId == consumer.StableId), Is.True);
+            Assert.That(problems.Problems.Any(problem => problem.IsWarning && problem.Target?.EntryId == consumer.StableId && problem.Message == scope.GetRequiredService<IEditorLocalizationService>()["Scene.Diagnostic.scene.reference.missing"]), Is.True);
+            problems.ValidateCommand.Execute(null);
+            Assert.That(problems.Problems.Any(problem => problem.IsError && problem.Target?.EntryId == consumer.StableId), Is.False, "Missing scene targets are warnings, not compile/value validation errors.");
+            Assert.That(problems.Problems.Single(problem => problem.SceneReference?.Code == "scene.reference.missing").SceneReference!.Revision, Is.EqualTo(query.Revision));
+            Assert.Throws<EditorOperationException>(preview.Commit);
+            await history.UndoAsync(); Assert.That(query.Diagnostics().Any(issue => issue.Code == "scene.reference.missing"), Is.False);
+            await history.RedoAsync();
+            Assert.That(consumer.Source.Parameters["handleId"].GetString(), Is.EqualTo(handle));
+            await workspace.SaveAsync(); var root = project.RootPath; var groupId = group.Id; var consumerId = consumer.StableId;
+            await projects.CloseAsync(); var reopened = await projects.OpenAsync(root);
+            var saved = reopened.Services.GetRequiredService<IEditorDocumentService>().Groups[groupId].Entries.Single(entry => entry.StableId == consumerId);
+            Assert.That(saved.Parameters["handleId"].GetString(), Is.EqualTo(handle));
+            Assert.That(reopened.Services.GetRequiredService<ProjectSceneTargets>().Diagnostics().Any(issue => issue.Code == "scene.reference.missing"), Is.True);
+            await projects.CloseAsync();
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task GroupDeleteTypeChangeAndMoveCommitWithoutDialogsAndRefreshProblemsWithoutValidation()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "SceneReviewUi"), "Scene review", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>(); var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var creator = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.ShowColorLayer).Single();
+            var consumer = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.HideLayer).Single();
+            scope.GetRequiredService<EntryFieldAuthoringService>().SetParameters(group.Id, consumer.Source, consumer.Type, new() { ["handleId"] = creator.Source.Parameters["handleId"] });
+            var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+            var problems = scope.GetRequiredService<ProblemsPanelViewModel>();
+            bool Missing() => problems.Problems.Any(problem => problem.SceneReference?.Code == "scene.reference.missing" && problem.Target?.EntryId == consumer.StableId);
+            var handle = consumer.Source.Parameters["handleId"].GetString();
+            Assert.That(Missing(), Is.False);
+            await page.ChangeTypeAsync(creator, BuiltinEntryIds.Wait);
+            Assert.That(creator.Type, Is.EqualTo(BuiltinEntryIds.Wait)); Assert.That(history.CanUndo, Is.True);
+            Assert.That(Missing(), Is.True);
+            await history.UndoAsync(); Assert.That(Missing(), Is.False);
+            page.SetSelection([creator]);
+            await page.DeleteSelectionAsync(); Assert.That(group.Entries, Has.Count.EqualTo(1)); Assert.That(Missing(), Is.True);
+            Assert.That(consumer.ProblemCount, Is.GreaterThan(0));
+            Assert.That(consumer.Source.Parameters["handleId"].GetString(), Is.EqualTo(handle));
+            await history.UndoAsync(); Assert.That(group.Entries, Has.Count.EqualTo(2)); Assert.That(Missing(), Is.False);
+            await history.RedoAsync(); Assert.That(Missing(), Is.True);
+            await history.UndoAsync();
+            var target = await workspace.AddNodeAsync(GraphNodeKind.LinearGroup, 500, 250);
+            using var targetPage = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, target.Id);
+            page.SetSelection([creator]);
+            var cut = page.PrepareCutSelection()!; page.BeginCut(cut);
+            await targetPage.PasteAsync(cut.Text, null);
+            Assert.That(target.Entries.Single().StableId, Is.EqualTo(creator.StableId));
+            Assert.That(Missing(), Is.True); Assert.That(page.HasPendingMove, Is.False);
+            await history.UndoAsync(); Assert.That(Missing(), Is.False);
+            await history.RedoAsync(); Assert.That(Missing(), Is.True);
+            await workspace.SaveAsync(); var root = project.RootPath;
+            await projects.CloseAsync();
+            var reopened = await projects.OpenAsync(root);
+            Assert.That(reopened.Services.GetRequiredService<ProblemsPanelViewModel>().Problems.Any(problem => problem.SceneReference?.Code == "scene.reference.missing"), Is.True);
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/SceneTargetPickerTests.cs b/test/GalNet.Editor.Tests/SceneTargetPickerTests.cs
index f3709a31..78f2cd46 100644
--- a/test/GalNet.Editor.Tests/SceneTargetPickerTests.cs
+++ b/test/GalNet.Editor.Tests/SceneTargetPickerTests.cs
@@ -11,6 +11,8 @@
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Controls;
 using GalNet.Editor.History;
+using GalNet.Editor.Inspector.ViewModels;
+using GalNet.Editor.Inspector.Views;
 using GalNet.Editor.Models.Graph;
 using GalNet.Editor.Services;
 using GalNet.Editor.Shared.Services;
@@ -22,10 +24,61 @@ namespace GeneralTest.Editor;
 
 public sealed partial class ProjectWorkspaceLifecycleTests
 {
+    [Test]
+    public async Task ShakeAndImpactUseSingleSceneTargetPicker()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "PresetSingleTarget"), "Preset", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var layers = workspace.InsertEntriesInto(group, 0, 2, BuiltinEntryIds.ShowLayer);
+            foreach (var layer in layers) layer.Source.Parameters["assetId"] = JsonSerializer.SerializeToElement("same.png");
+            var shake = workspace.InsertEntriesInto(group, 2, 1, BuiltinEntryIds.ShakePreset).Single();
+            var impact = workspace.InsertEntriesInto(group, 3, 1, BuiltinEntryIds.ImpactPreset).Single();
+            shake.Source.Parameters["future"] = JsonSerializer.SerializeToElement(new { retained = true });
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = shake;
+            using var inspector = new EntryInspectorViewModel(page);
+            var view = new EntryInspectorView { DataContext = inspector };
+            var window = new Window { Content = view, Width = 650, Height = 950 }; window.Show(); TimelinePump(window);
+            try
+            {
+                var catalog = scope.GetRequiredService<SceneTargetCatalog>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
+                async Task SelectTarget(EntryEditorItemViewModel entry, EntryEditorItemViewModel layer)
+                {
+                    await catalog.PrepareAsync(group.Id, entry.StableId);
+                    page.SelectedEntry = entry; TimelinePump(window);
+                    var button = view.GetVisualDescendants().OfType<Button>().Single(control => control.Name == "SceneTargetField");
+                    Assert.That(button.IsEffectivelyEnabled, Is.True);
+                    // Test this field's selector contract independently of shared headless pointer state.
+                    var flyout = (Flyout)button.Flyout!;
+                    flyout.ShowAt(button); TimelinePump(window);
+                    var picker = (SceneTargetPicker)flyout.Content!;
+                    var choice = catalog.Query(group.Id, entry.StableId).Choices.Single(item => item.Target.Locator.EntryId == layer.StableId);
+                    picker.ResourcePanel.Search.Text = choice.Item.Label; TimelinePump(window);
+                    PressGroupKey(picker.ResourcePanel.Search, Key.Down); PressGroupKey(picker.ResourcePanel.Search, Key.Enter); TimelinePump(window);
+                    Assert.That(entry.Source.Parameters["handleId"].GetString(), Is.EqualTo(choice.Target.Handle));
+                }
+                await SelectTarget(shake, layers[0]);
+                Assert.That(shake.Source.Parameters.ContainsKey("targets"), Is.False);
+                Assert.That(shake.Source.Parameters["future"].GetProperty("retained").GetBoolean(), Is.True);
+                await SelectTarget(impact, layers[1]);
+                Assert.That(impact.Source.Parameters.ContainsKey("targets"), Is.False);
+                Assert.That(history.CanUndo, Is.True);
+                await history.UndoAsync();
+                Assert.That(impact.Source.Parameters["handleId"].GetString(), Is.Empty);
+                return true;
+            }
+            finally { window.Close(); await projects.CloseAsync(); }
+        }, CancellationToken.None);
+    }
+
     [Test]
     public async Task AssetPickerUsesSharedCardsForSearchKeyboardSelectionAndEmptyValue()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(() =>
         {
             PrepareGroupTheme(); using var assets = new PickerAssets();
@@ -115,7 +168,7 @@ public async Task SceneQueryIsPositionBasedAndSelectionsRejectChangedOrClosedPro
     [Test]
     public async Task SharedScenePickerSelectsObjectsThenAddsPropertiesFromObjectRowsAndSaves()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -146,12 +199,13 @@ await ui.Dispatch<bool>(async () =>
                 var localization = scope.GetRequiredService<IEditorLocalizationService>(); localization.ApplyLocale("en-US"); TimelinePump(entryWindow);
                 Assert.That(button.Content?.ToString(), Does.Contain(localization["Timeline.Kind.Layer"]));
                 await history.UndoAsync(); Assert.That(history.CanUndo, Is.False); Assert.That(hide.Source.Parameters["handleId"].GetString(), Is.EqualTo("missing-reference")); await history.RedoAsync();
-                // An open selector cannot commit after its author context changes.
+                // Removing a candidate invalidates the open selector even after a concurrent Timeline made presence uncertain.
                 TimelineClick(entryWindow, button); var oldPicker = (SceneTargetPicker)fieldFlyout.Content!;
-                scope.GetRequiredService<EntryFieldAuthoringService>().SetCondition(group.Id, layers[1].Source, "save.optional");
+                scope.GetRequiredService<EntryFieldAuthoringService>().SetCondition(group.Id, layers[1].Source, "false");
                 var beforeStale = JsonSerializer.Serialize(hide.Source.Parameters);
                 PressGroupKey(oldPicker.ResourcePanel.Search, Key.Down); PressGroupKey(oldPicker.ResourcePanel.Search, Key.Enter); TimelinePump(entryWindow);
                 Assert.That(JsonSerializer.Serialize(hide.Source.Parameters), Is.EqualTo(beforeStale)); fieldFlyout.Hide();
+                scope.GetRequiredService<EntryFieldAuthoringService>().SetCondition(group.Id, layers[1].Source, "save.optional");
                 page.SelectedEntry = timeline; timelineWindow.Show(); TimelinePump(timelineWindow); history.Clear();
                 var session = scope.GetRequiredService<TimelineEditSession>(); Assert.That(session.VisibleNodes, Is.Empty, "The default tree contains authored tracks only.");
                 var add = timelineView.FindControl<Button>("AddTimelineObject")!; TimelineClick(timelineWindow, add);
@@ -230,7 +284,7 @@ void EditValue(string property, string value)
     [Test]
     public async Task TimelineOverrideRemovalIsAtomicRejectsStaleRowsAndPreservesOtherRawTracks()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/SceneTransitionAuthoringTests.cs b/test/GalNet.Editor.Tests/SceneTransitionAuthoringTests.cs
index a59cb827..4fd09d2a 100644
--- a/test/GalNet.Editor.Tests/SceneTransitionAuthoringTests.cs
+++ b/test/GalNet.Editor.Tests/SceneTransitionAuthoringTests.cs
@@ -26,7 +26,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [TestCase(BuiltinEntryIds.ColorFadeTransition, "fromLayerHandleId")]
     public async Task TransitionUsesRealScenePickerHidesInternalOutputsAndPublishesStableTerminalLocator(string type, string input)
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/StructuredGroupFormTests.cs b/test/GalNet.Editor.Tests/StructuredGroupFormTests.cs
index 111057cd..3bfc21ae 100644
--- a/test/GalNet.Editor.Tests/StructuredGroupFormTests.cs
+++ b/test/GalNet.Editor.Tests/StructuredGroupFormTests.cs
@@ -20,10 +20,61 @@ namespace GeneralTest.Editor;
 
 public sealed partial class ProjectWorkspaceLifecycleTests
 {
+    [Test]
+    public async Task NestedMapDraftsKeepTheirWirePathAndSaveAfterEveryViewCloses()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            PrepareGroupTheme();
+            var catalog = new TargetProfileEntryCatalog([new DefaultEntryModule("structured", [DefaultPrimitiveEntryBase.ForDto<StructuredAuthorOptions>("custom.structure")])]);
+            using var services = Services(catalog: catalog); var projects = services.GetRequiredService<IProjectService>();
+            var project = await projects.CreateAsync(Path.Combine(_root, "PropertyMapDraft"), "Properties", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            var scope = project.Services; var workspace = scope.GetRequiredService<EditorWorkspaceViewModel>();
+            var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+            var entry = workspace.InsertEntriesInto(group, 0, 1, "custom.structure").Single();
+            scope.GetRequiredService<EntryFieldAuthoringService>().SetParameters(group.Id, entry.Source, entry.Type,
+                new() { ["items"] = JsonSerializer.Deserialize<JsonElement>("""{"a/b~c":{"Title":"before","extension":9007199254740993},"0":{"Title":"other"}}""") });
+            using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id);
+            var view = new EntryListEditorControl { DataContext = page }; var window = new Window { Content = view, Width = 1100, Height = 850 };
+            window.Show(); TimelinePump(window);
+            var root = view.GetVisualDescendants().OfType<SchemaForm>().Single(form => form.Schema?.Any(field => field.Id == "items") == true);
+            var map = (StructuredFieldEditor)root.Editors.Single(item => item.Context.Field.Id == "items").Control;
+            map.IsExpanded = true; TimelinePump(window);
+            Assert.That(((StackPanel)map.Header!).Children.OfType<TextBlock>().First().Text, Is.EqualTo("items · 2"),
+                "Unknown translation keys fall back to the field name, while map keys remain literal labels.");
+            foreach (var child in map.GetVisualDescendants().OfType<StructuredFieldEditor>()) child.IsExpanded = true;
+            TimelinePump(window);
+            var title = map.GetVisualDescendants().OfType<SchemaForm>().SelectMany(form => form.Contexts)
+                .Single(context => context.Field.Id == "title" && context.PropertySegments?.SequenceEqual(new[] { "a/b~c", "Title" }) == true);
+            title.Text = "after";
+            Assert.That(entry.Source.Parameters["items"].GetProperty("a/b~c").GetProperty("Title").GetString(), Is.EqualTo("before"));
+            if (Environment.GetEnvironmentVariable("GALNET_EDITOR_TEST_ARTIFACTS") is { Length: > 0 } artifacts)
+            {
+                Directory.CreateDirectory(artifacts); Avalonia.Headless.HeadlessWindowExtensions.CaptureRenderedFrame(window)!.Save(Path.Combine(artifacts, "recursive-map-group.png"));
+            }
+            window.Close(); page.Dispose();
+            await workspace.SaveAsync();
+            Assert.That(entry.Source.Parameters["items"].GetProperty("a/b~c").GetProperty("Title").GetString(), Is.EqualTo("after"));
+            Assert.That(entry.Source.Parameters["items"].GetProperty("a/b~c").GetProperty("extension").GetInt64(), Is.EqualTo(9007199254740993));
+            Assert.That(entry.Source.Parameters["items"].GetProperty("0").GetProperty("Title").GetString(), Is.EqualTo("other"));
+            await scope.GetRequiredService<EditorHistories>().Content.UndoAsync();
+            Assert.That(entry.Source.Parameters["items"].GetProperty("a/b~c").GetProperty("Title").GetString(), Is.EqualTo("before"));
+            await scope.GetRequiredService<EditorHistories>().Content.RedoAsync();
+            Assert.That(entry.Source.Parameters["items"].GetProperty("a/b~c").GetProperty("Title").GetString(), Is.EqualTo("after"));
+            scope.GetRequiredService<EntryFieldAuthoringService>().SetParameters(group.Id, entry.Source, entry.Type,
+                new() { ["items"] = JsonSerializer.Deserialize<JsonElement>("""{"0":{"Title":42}}""") });
+            var problems = scope.GetRequiredService<ProblemsPanelViewModel>(); await AwaitAutomaticProblems(problems);
+            var issue = problems.Problems.Single(problem => problem.Target?.EntryId == entry.StableId && problem.FieldPath?.SequenceEqual(new[] { "0", "Title" }) == true);
+            Assert.That(issue.Source, Does.Contain("[\"0\"]"), "Numeric dictionary keys are literal keys, not list ordinals.");
+            await projects.CloseAsync(); return true;
+        }, CancellationToken.None);
+    }
+
     [Test]
     public async Task GeneratedComplexFieldsUseProjectHistoryAndReopenWithoutLosingUnknownOrAbsentValues()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme();
@@ -88,6 +139,7 @@ public partial class StructuredAuthorOptions
     [Field(0)] public StructuredAuthorDetails? Details { get; set; }
     [Field(1)] public List<int>? Numbers { get; set; }
     [Field(2, AllowNull = true)] public int? Optional { get; set; }
+    [Field(3)] public Dictionary<string, StructuredAuthorDetails>? Items { get; set; }
 }
 
 [GenerateFieldSchema]
diff --git a/test/GalNet.Editor.Tests/TimelineCanvasTests.cs b/test/GalNet.Editor.Tests/TimelineCanvasTests.cs
index 523b6ec0..b11158d9 100644
--- a/test/GalNet.Editor.Tests/TimelineCanvasTests.cs
+++ b/test/GalNet.Editor.Tests/TimelineCanvasTests.cs
@@ -33,7 +33,7 @@ private static Point CanvasPoint(Window window, TimelineCanvas canvas, int row,
     [Test]
     public async Task TimelineCanvasRealPointerGesturesAlignSelectMoveCancelReplaceProtectAndRejectStaleTargets()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -141,7 +141,7 @@ await ui.Dispatch<bool>(async () =>
                 Assert.That(session.Canvas.HasPendingMove, Is.True); Assert.That(session.Canvas.IsMoveValid, Is.False); Assert.That(history.CanUndo, Is.False);
                 PressGroupKey(canvas, Key.Escape); Assert.That(session.Canvas.HasPendingMove, Is.False); Assert.That(history.CanUndo, Is.False);
                 window.MouseDown(first, MouseButton.Left); window.MouseMove(first + new Vector(64, 0)); window.MouseUp(first + new Vector(64, 0), MouseButton.Left); TimelinePump(window);
-                vm.ReplaceCollisionsCommand.Execute(null); TimelinePump(window);
+                session.ReplaceKeyCollisions(); TimelinePump(window);
                 var keys = entry.Source.Parameters["timeline"].GetProperty("Tracks")[0].GetProperty("Keys"); Assert.That(keys.GetArrayLength(), Is.EqualTo(2)); Assert.That(keys[1].GetProperty("Frame").GetInt32(), Is.EqualTo(20)); Assert.That(keys[1].GetProperty("futureKey")[1].ValueKind, Is.EqualTo(JsonValueKind.Null));
                 await history.UndoAsync(); Assert.That(history.CanUndo, Is.False); TimelinePump(window);
                 var zero = CanvasPoint(window, canvas, xRow, 0) + new Vector(1, 0); window.MouseDown(zero, MouseButton.Left); window.MouseUp(zero, MouseButton.Left); PressGroupKey(canvas, Key.Delete);
@@ -157,7 +157,11 @@ await ui.Dispatch<bool>(async () =>
                 var localization = scope.GetRequiredService<IEditorLocalizationService>();
                 foreach (var locale in new[] { "en-US", "ja-JP", "ko-KR", "zh-CN" })
                 {
-                    localization.ApplyLocale(locale); TimelinePump(window); Assert.That(view.GetVisualDescendants().OfType<Button>().Single(button => ReferenceEquals(button.Command, vm.AddKeyCommand)).Content, Is.EqualTo(localization["Timeline.AddKey"]));
+                    localization.ApplyLocale(locale); TimelinePump(window);
+                    var addKey = view.GetVisualDescendants().OfType<Button>().Single(button => ReferenceEquals(button.Command, vm.AddKeyCommand));
+                    Assert.That(addKey.Content, Is.TypeOf<PathIcon>());
+                    Assert.That(ToolTip.GetTip(addKey), Is.EqualTo(localization["Timeline.AddKey"]));
+                    Assert.That(Avalonia.Automation.AutomationProperties.GetName(addKey), Is.EqualTo(localization["Timeline.AddKey"]));
                     mode = view.GetVisualDescendants().OfType<ComboBox>().First(control => control.Name == "TimelineBlendMode");
                     Assert.That(mode.Items.OfType<ComboBoxItem>().Select(item => item.Content), Is.EqualTo(new[] { localization["Timeline.Absolute"], localization["Timeline.Offset"] }));
                 }
diff --git a/test/GalNet.Editor.Tests/TimelineDockTests.cs b/test/GalNet.Editor.Tests/TimelineDockTests.cs
index 3f4607f7..573d8c1f 100644
--- a/test/GalNet.Editor.Tests/TimelineDockTests.cs
+++ b/test/GalNet.Editor.Tests/TimelineDockTests.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Headless;
 using Avalonia.Input;
@@ -37,7 +38,7 @@ private static IEnumerable<IDockable> TimelineDockables(IDockable item)
     [Test]
     public async Task TimelineDockOpensOnDemandFollowsActiveEntryAndNumericEditsRoundTripThroughHistoryAndDisk()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -55,6 +56,7 @@ await ui.Dispatch<bool>(async () =>
             var page = TimelineDockables(layout).Select(item => item.Context).OfType<GroupEditorPanelViewModel>().Single();
             var session = project.Services.GetRequiredService<TimelineEditSession>();
             var timelineView = (TimelinePanelView)project.Services.GetRequiredService<GalNet.Editor.Services.Interfaces.IEditorViewFactory>().CreateViewForViewModel(dock.Context!)!;
+            timelineView.Resources.MergedDictionaries.Add(new Avalonia.Markup.Xaml.Styling.ResourceInclude(new Uri("avares://GalNet.Editor/")) { Source = new Uri("avares://GalNet.Editor/Themes/EditorButtons.axaml") });
             var groupView = new EntryListEditorControl { DataContext = page };
             var container = new Grid { RowDefinitions = new RowDefinitions("*,*") }; container.Children.Add(groupView); container.Children.Add(timelineView); Grid.SetRow(timelineView, 1);
             var window = new Window { Content = container, Width = 1250, Height = 950 }; window.Show(); TimelinePump(window);
@@ -63,13 +65,42 @@ await ui.Dispatch<bool>(async () =>
                 var history = project.Services.GetRequiredService<EditorHistories>().Content; history.Clear();
                 Assert.That(session.StatusKey, Is.EqualTo("Timeline.SelectEntry")); page.SelectedEntry = entry; TimelinePump(window);
                 Assert.That(session.Rows, Has.Count.EqualTo(1)); Assert.That(history.CanUndo, Is.False);
+                var objectsSection = timelineView.FindControl<Grid>("TimelineObjectsSection")!;
+                var eventsSection = timelineView.FindControl<Grid>("TimelineEventsSection")!;
+                Assert.That(objectsSection.Bounds.Bottom, Is.LessThanOrEqualTo(eventsSection.Bounds.Top));
+                Assert.That(objectsSection.Bounds.Height, Is.EqualTo(eventsSection.Bounds.Height).Within(1));
+                var splitter = timelineView.FindControl<GridSplitter>("TimelineSectionsSplitter")!;
+                var originalObjectsHeight = objectsSection.Bounds.Height;
+                var originalEventsHeight = eventsSection.Bounds.Height;
+                var splitterPoint = splitter.TranslatePoint(new Point(splitter.Bounds.Width / 2, splitter.Bounds.Height / 2), window)!.Value;
+                window.MouseDown(splitterPoint, MouseButton.Left); window.MouseMove(splitterPoint + new Vector(0, 24)); window.MouseUp(splitterPoint + new Vector(0, 24), MouseButton.Left); TimelinePump(window);
+                Assert.That(objectsSection.Bounds.Height, Is.EqualTo(originalObjectsHeight + 24).Within(1));
+                Assert.That(eventsSection.Bounds.Height, Is.EqualTo(originalEventsHeight - 24).Within(1));
+                Assert.That(history.CanUndo, Is.False, "Changing the panel split is not an author edit.");
+                Assert.That(timelineView.GetVisualDescendants().OfType<Button>().Any(button => button.Content is string text && new[] { session.SceneText["Uiux.Timeline.Playhead"], session.SceneText["Timeline.ReplaceCollisions"], session.SceneText["Timeline.CancelMove"] }.Contains(text)), Is.False);
+
+                Assert.That(timelineView.FindControl<NumericUpDown>("TimelineFrame"), Is.Null);
+                Assert.That(timelineView.FindControl<TextBlock>("TimelineStatus")!.IsEffectivelyVisible, Is.False);
+                var zoom = timelineView.FindControl<Slider>("TimelineZoom")!;
+                var currentFrame = timelineView.FindControl<TextBlock>("TimelineCurrentFrame")!;
+                Assert.That(currentFrame.TranslatePoint(default, timelineView)!.Value.X + currentFrame.Bounds.Width, Is.LessThan(zoom.TranslatePoint(default, timelineView)!.Value.X));
+                Assert.That(zoom.TranslatePoint(default, timelineView)!.Value.X + zoom.Bounds.Width, Is.EqualTo(timelineView.Bounds.Width - 8).Within(1));
+                var durationInput = timelineView.FindControl<NumericUpDown>("TimelineDurationDraft")!;
+                var fpsInput = timelineView.FindControl<NumericUpDown>("TimelineFpsDraft")!;
+                Assert.That(durationInput.TranslatePoint(default, timelineView)!.Value.Y, Is.EqualTo(fpsInput.TranslatePoint(default, timelineView)!.Value.Y).Within(1));
+                foreach (var name in new[] { "TimelinePreviousKey", "TimelineNextKey", "TimelineAddKey", "TimelineDeleteKeys", "AddTimelineObject" })
+                {
+                    var button = timelineView.FindControl<Button>(name)!;
+                    Assert.That(button.Content, Is.TypeOf<PathIcon>());
+                    Assert.That(button.Background, Is.EqualTo(Avalonia.Media.Brushes.Transparent));
+                }
                 var input = timelineView.GetVisualDescendants().OfType<NumericUpDown>().Single(control => control.Name == "TimelineValue");
                 Assert.That(input.GetVisualDescendants().OfType<TextBox>().Any(), Is.True, "The actual themed numeric editor must be mounted.");
                 Assert.That(input.Value, Is.EqualTo(2)); Assert.That(timelineView.GetVisualDescendants().OfType<TextBlock>().Any(block => block.Text?.Contains("hidden-target", StringComparison.Ordinal) == true), Is.False);
                 input.Value = 3; TimelinePump(window); PressGroupKey(input, Key.Enter); TimelinePump(window);
                 var root = entry.Source.Parameters["timeline"]; var key = root.GetProperty("Tracks")[0].GetProperty("Keys")[0];
                 Assert.That(key.GetProperty("Value").GetSingle(), Is.EqualTo(3)); Assert.That(key.GetProperty("OutTangent").GetSingle(), Is.EqualTo(.4f)); Assert.That(key.GetProperty("future")[1].ValueKind, Is.EqualTo(JsonValueKind.Null));
-                var old = session.Rows.Single(); session.Frame = 5; TimelinePump(window); old.DraftValue = 99; Assert.That(old.Commit(), Is.False);
+                var old = session.Rows.Single(); session.Frame = 5; TimelinePump(window); Assert.That(currentFrame.Text, Is.EqualTo(session.SceneText.Format("Timeline.CurrentFrame", 5))); old.DraftValue = 99; Assert.That(old.Commit(), Is.False);
                 input = timelineView.GetVisualDescendants().OfType<NumericUpDown>().Single(control => control.Name == "TimelineValue"); Assert.That(input.Value, Is.EqualTo(6.25m));
                 input.Value = 6.4m; input.Value = 6.5m; TimelinePump(window); PressGroupKey(input, Key.Enter); TimelinePump(window);
                 var keys = entry.Source.Parameters["timeline"].GetProperty("Tracks")[0].GetProperty("Keys");
@@ -92,7 +123,8 @@ await ui.Dispatch<bool>(async () =>
                 foreach (var locale in new[] { "en-US", "ja-JP", "ko-KR", "zh-CN" })
                 {
                     localization.ApplyLocale(locale); TimelinePump(window);
-                    Assert.That(timelineView.FindControl<TextBlock>("TimelineStatus")!.Text, Is.EqualTo(localization["Timeline.Editing"]));
+                    Assert.That(timelineView.FindControl<TextBlock>("TimelineStatus")!.IsEffectivelyVisible, Is.False);
+                    Assert.That(currentFrame.Text, Is.EqualTo(localization.Format("Timeline.CurrentFrame", session.Frame)));
                     Assert.That(session.Rows.Single().ObjectLabel, Is.EqualTo(localization.Format("Timeline.Object", 1)));
                     Assert.That(session.Rows.Single(), Is.SameAs(localDraft)); Assert.That(localDraft.DraftValue, Is.EqualTo(12));
                 }
@@ -114,7 +146,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task TimelineSelectionOwnersMissingInvalidAndDeletedEntriesNeverReviveOldRows()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -146,7 +178,7 @@ await ui.Dispatch<bool>(async () =>
     [TestCase("\"invalid\"", "Timeline.Invalid")]
     public async Task TimelineSelectionNeverNormalizesOrRewritesIncompleteOrInvalidAuthorJson(string json, string status)
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/TimelineEventAuthoringTests.cs b/test/GalNet.Editor.Tests/TimelineEventAuthoringTests.cs
index 1df23218..646e5c29 100644
--- a/test/GalNet.Editor.Tests/TimelineEventAuthoringTests.cs
+++ b/test/GalNet.Editor.Tests/TimelineEventAuthoringTests.cs
@@ -9,6 +9,8 @@
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.Controls;
 using GalNet.Editor.History;
+using GalNet.Editor.Inspector.ViewModels;
+using GalNet.Editor.Inspector.Views;
 using GalNet.Editor.Models.Graph;
 using GalNet.Editor.Services;
 using GalNet.Editor.Shared.Services;
@@ -33,7 +35,7 @@ private static JsonElement EventAuthorFixture() => JsonSerializer.Deserialize<Js
     [Test]
     public async Task TimelineEventLaneUsesRealPickerAndDragWithAtomicHistoryOrderingUnknownDataAndStaleProtection()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -47,7 +49,9 @@ await ui.Dispatch<bool>(async () =>
             try
             {
                 Assert.That(session.Events, Has.Count.EqualTo(4)); Assert.That(history.CanUndo, Is.False);
-                Assert.That(view.GetVisualDescendants().OfType<Button>().Single(item => item.Name == "EditTimelineEvent" && item.DataContext is TimelineEventRow { Index: 0 }).IsEnabled, Is.False);
+                Assert.That(session.Events.Single(item => item.Index == 0).CanEdit, Is.False);
+                session.Frame = 0; session.NavigateKey(1); Assert.That(session.Frame, Is.EqualTo(3));
+                session.NavigateKey(1); Assert.That(session.Frame, Is.EqualTo(5)); session.NavigateKey(-1); Assert.That(session.Frame, Is.EqualTo(3));
                 session.Frame = 5; var picker = view.FindControl<EntryTypePicker>("TimelineEventType")!; picker.OpenAt(); TimelinePump(window);
                 Assert.That(picker.Results.Select(item => item.Value), Is.EquivalentTo(TimelineEventCapabilities.Types));
                 var search = picker.FindControl<TextBox>("SearchInput")!; search.Text = BuiltinEntryIds.ShowLayer; TimelinePump(window); PressGroupKey(search, Key.Down); PressGroupKey(search, Key.Enter); TimelinePump(window);
@@ -92,9 +96,9 @@ await ui.Dispatch<bool>(async () =>
     }
 
     [Test]
-    public async Task TimelineEventDtoFlyoutHidesOutputsUsesEventBeforePickerAndAppliesOneCancelableDraft()
+    public async Task TimelineEventInspectorHidesOutputsUsesEventBeforePickerAndAppliesOneCancelableDraft()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -103,36 +107,46 @@ await ui.Dispatch<bool>(async () =>
             var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.PlayTimeline).Single(); entry.Source.Parameters["timeline"] = EventAuthorFixture();
             using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = entry;
             var session = scope.GetRequiredService<TimelineEditSession>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
-            var view = new TimelinePanelView { DataContext = scope.GetRequiredService<TimelinePanelViewModel>() }; var window = new Window { Content = view, Width = 1400, Height = 950 }; window.Show(); TimelinePump(window);
+            var panel = scope.GetRequiredService<TimelinePanelViewModel>(); var view = new TimelinePanelView { DataContext = panel };
+            using var inspector = new TimelineEventInspectorViewModel(panel); var body = new TimelineEventInspectorView { DataContext = inspector, Width = 520 };
+            var layout = new Grid { ColumnDefinitions = new ColumnDefinitions("*,520") }; layout.Children.Add(view); Grid.SetColumn(body, 1); layout.Children.Add(body);
+            var window = new Window { Content = layout, Width = 1400, Height = 950 }; window.Show(); TimelinePump(window);
             try
             {
-                var row = session.Events.Single(item => item.Index == 1); var edit = view.GetVisualDescendants().OfType<Button>().Single(item => item.Name == "EditTimelineEvent" && ReferenceEquals(item.DataContext, row)); TimelineClick(window, edit);
-                var flyout = (Flyout)FlyoutBase.GetAttachedFlyout(edit)!; var body = (Control)flyout.Content!; var host = body.GetVisualDescendants().OfType<DtoEditorHost>().Single();
-                Assert.That(host.Diagnostics, Is.Empty); Assert.That(session.EventEdit!.Field("handleId").IsVisible, Is.False);
+                var row = session.Events.Single(item => item.Index == 1); session.SelectEvent(row); TimelinePump(window);
+                var host = body.GetVisualDescendants().OfType<DtoEditorHost>().Single();
+                using (var lockedInspector = new TimelineEventInspectorViewModel(panel))
+                {
+                    lockedInspector.SetLocked(true); var lockedDraft = lockedInspector.Draft;
+                    session.SelectEvent(session.Events.Single(item => item.Index == 2));
+                    Assert.That(lockedInspector.Draft, Is.SameAs(lockedDraft)); Assert.That(lockedDraft!.IsCurrent, Is.True);
+                    session.SelectEvent(row); TimelinePump(window);
+                }
+                Assert.That(inspector.Draft!.IsCurrent, Is.True);
+                Assert.That(host.Diagnostics, Is.Empty); Assert.That(inspector.Draft!.Field("handleId").IsVisible, Is.False);
                 Assert.That(host.GetVisualDescendants().OfType<SchemaForm>().SelectMany(form => form.Diagnostics), Is.Empty);
                 Assert.That(host.GetVisualDescendants().OfType<AssetPicker>().Single().Filter, Is.EqualTo(GalNet.Editor.Models.AssetPickerFilter.Image));
-                var x = host.GetVisualDescendants().OfType<TextBox>().Single(item => item.Name == "TransformX"); x.Focus(); x.Text = "13"; PressGroupKey(x, Key.Enter); TimelinePump(window);
+                var x = NumericControlTestSupport.NamedInputs(host, "TransformX").Single(); x.Focus(); x.Text = "13"; PressGroupKey(x, Key.Enter); TimelinePump(window);
                 Assert.That(history.CanUndo, Is.False); Assert.That(entry.Source.Parameters["timeline"].GetProperty("Events")[1].GetProperty("Parameters").GetProperty("transform").GetProperty("x").GetSingle(), Is.EqualTo(7));
                 TimelineClick(window, body.GetVisualDescendants().OfType<Button>().Single(item => item.Name == "ApplyTimelineEvent")); TimelinePump(window);
-                Assert.That(flyout.IsOpen, Is.False); var parameters = entry.Source.Parameters["timeline"].GetProperty("Events")[1].GetProperty("Parameters");
+                var parameters = entry.Source.Parameters["timeline"].GetProperty("Events")[1].GetProperty("Parameters");
                 Assert.That(parameters.GetProperty("transform").GetProperty("x").GetSingle(), Is.EqualTo(13)); Assert.That(parameters.GetProperty("transform").GetProperty("opaque").GetRawText(), Is.EqualTo("9007199254740993"));
                 await history.UndoAsync(); Assert.That(history.CanUndo, Is.False); await history.RedoAsync(); history.Clear(); TimelinePump(window);
-                row = session.Events.Single(item => item.Index == 2); edit = view.GetVisualDescendants().OfType<Button>().Single(item => item.Name == "EditTimelineEvent" && ReferenceEquals(item.DataContext, row)); TimelineClick(window, edit);
-                flyout = (Flyout)FlyoutBase.GetAttachedFlyout(edit)!; body = (Control)flyout.Content!; host = body.GetVisualDescendants().OfType<DtoEditorHost>().Single();
+                row = session.Events.Single(item => item.Index == 2); session.SelectEvent(row); TimelinePump(window);
+                host = body.GetVisualDescendants().OfType<DtoEditorHost>().Single();
                 var targetButton = host.GetVisualDescendants().OfType<Button>().Single(item => item.Name == "SceneTargetField"); Assert.That(targetButton.Content?.ToString(), Does.Contain("image.png")); TimelineClick(window, targetButton);
                 var picker = (SceneTargetPicker)((Flyout)targetButton.Flyout!).Content!;
                 Assert.That(picker.ResourcePanel.Results.Any(item => item.Label.Contains("image.png", StringComparison.Ordinal)), Is.True);
                 Assert.That(picker.ResourcePanel.Results.Any(item => item.Label.Contains("later.png", StringComparison.Ordinal)), Is.False);
                 PressGroupKey(picker.ResourcePanel.Search, Key.Escape); TimelinePump(window);
                 if (Environment.GetEnvironmentVariable("GALNET_EDITOR_TEST_ARTIFACTS") is { Length: > 0 } artifacts) { using var frame = window.CaptureRenderedFrame(); frame!.Save(Path.Combine(artifacts, "events-b-form.png")); }
-                var stale = session.EventEdit!; session.Frame = 2; TimelinePump(window); Assert.That(flyout.IsOpen, Is.False); Assert.That(stale.Apply(), Is.False); Assert.That(history.CanUndo, Is.False);
+                var stale = inspector.Draft!; session.Frame = 2; TimelinePump(window); Assert.That(stale.Apply(), Is.False); Assert.That(history.CanUndo, Is.False);
                 var pending = session.BeginEventEdit(session.Events.Single(item => item.Index == 1))!;
                 await pending.Field("transform").CommitAsync(new(JsonSerializer.SerializeToElement(new { x = 99 })), CancellationToken.None); session.EndEventEdit(); Assert.That(pending.Apply(), Is.False); Assert.That(history.CanUndo, Is.False);
                 foreach (var type in TimelineEventCapabilities.Types)
                 {
                     Assert.That(session.AddEvent(type), Is.True); TimelinePump(window);
-                    row = session.Events.Single(item => item.Index == 4); edit = view.GetVisualDescendants().OfType<Button>().Single(item => item.Name == "EditTimelineEvent" && ReferenceEquals(item.DataContext, row)); TimelineClick(window, edit);
-                    flyout = (Flyout)FlyoutBase.GetAttachedFlyout(edit)!; body = (Control)flyout.Content!;
+                    row = session.Events.Single(item => item.Index == 4); session.SelectEvent(row); TimelinePump(window);
                     Assert.That(body.GetVisualDescendants().OfType<DtoEditorHost>().Single().Diagnostics, Is.Empty, type);
                     Assert.That(body.GetVisualDescendants().OfType<SchemaForm>().SelectMany(form => form.Diagnostics), Is.Empty, type);
                     TimelineClick(window, body.GetVisualDescendants().OfType<Button>().Single(item => item.Name == "CancelTimelineEvent"));
diff --git a/test/GalNet.Editor.Tests/TimelineEventQueryTests.cs b/test/GalNet.Editor.Tests/TimelineEventQueryTests.cs
index 1e27d184..9f15020f 100644
--- a/test/GalNet.Editor.Tests/TimelineEventQueryTests.cs
+++ b/test/GalNet.Editor.Tests/TimelineEventQueryTests.cs
@@ -21,7 +21,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task TimelineEventQueryPickerKeepsPositionAndPropertyCreationUsesFrameZeroBaseline()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -42,6 +42,7 @@ await ui.Dispatch<bool>(async () =>
                     new { frame = 15, type = BuiltinEntryIds.ShowLayer, editorId = "creator", parameters = new { handleId = "future-object", assetId = "future.png" } }
                 }
             });
+            scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
             using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = timeline;
             var session = scope.GetRequiredService<TimelineEditSession>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
             var localization = scope.GetRequiredService<IEditorLocalizationService>(); var query = scope.GetRequiredService<ProjectSceneTargets>();
@@ -51,6 +52,7 @@ await ui.Dispatch<bool>(async () =>
             try
             {
                 var button = view.FindControl<Button>("AddTimelineObject")!; TimelineClick(window, button);
+                await PumpCharacterUi(() => FlyoutBase.GetAttachedFlyout(button) is Flyout { Content: SceneTargetPicker });
                 var flyout = (Flyout)FlyoutBase.GetAttachedFlyout(button)!; var picker = (SceneTargetPicker)flyout.Content!;
                 var draft = session.ObjectEdit!; var future = draft.Snapshot.Choices.Single(choice => choice.Target.IsFuture);
                 Assert.That(future.Item.Badge, Is.EqualTo(localization.Format("Scene.FutureAt", 15)));
diff --git a/test/GalNet.Editor.Tests/TimelineFlipbookTests.cs b/test/GalNet.Editor.Tests/TimelineFlipbookTests.cs
index f8d69765..bbbe5365 100644
--- a/test/GalNet.Editor.Tests/TimelineFlipbookTests.cs
+++ b/test/GalNet.Editor.Tests/TimelineFlipbookTests.cs
@@ -20,7 +20,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task FlipbookPropertyUsesRealMenuAndNumericInputWithRawIndicesHistoryInvalidationAndReopen()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -30,6 +30,7 @@ await ui.Dispatch<bool>(async () =>
             layer.Source.Parameters["flipbook"] = JsonSerializer.Deserialize<JsonElement>("{\"columns\":3,\"rows\":2,\"frameCount\":5,\"index\":2.5,\"future\":[9007199254740993,null]}");
             var timeline = workspace.InsertEntriesInto(group, 2, 1, BuiltinEntryIds.PlayTimeline).Single();
             timeline.Source.Parameters["timeline"] = JsonSerializer.Deserialize<JsonElement>("{\"durationFrames\":20,\"tracks\":[],\"events\":[],\"future\":true}");
+            scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
             using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = timeline;
             var session = scope.GetRequiredService<TimelineEditSession>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
             var view = scope.GetRequiredService<GalNet.Editor.Views.TimelinePanelView>(); view.DataContext = scope.GetRequiredService<TimelinePanelViewModel>();
diff --git a/test/GalNet.Editor.Tests/TimelineInlineCurveTests.cs b/test/GalNet.Editor.Tests/TimelineInlineCurveTests.cs
index e899cdf7..b44473d2 100644
--- a/test/GalNet.Editor.Tests/TimelineInlineCurveTests.cs
+++ b/test/GalNet.Editor.Tests/TimelineInlineCurveTests.cs
@@ -7,7 +7,7 @@
 using Avalonia.Interactivity;
 using Avalonia.VisualTree;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Editor.Abstraction.Services;
 using GalNet.Editor.History;
 using GalNet.Editor.Services;
@@ -28,7 +28,7 @@ private static MenuItem CurveMenuItem(MenuFlyout menu, string name)
     [Test]
     public async Task InlineTimelineCurvesUseRealMenusKeysAndHandlesWithAtomicHistoryAndCancellation()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/TimelineKeyDetailTests.cs b/test/GalNet.Editor.Tests/TimelineKeyDetailTests.cs
index d28d9d55..bd3c787a 100644
--- a/test/GalNet.Editor.Tests/TimelineKeyDetailTests.cs
+++ b/test/GalNet.Editor.Tests/TimelineKeyDetailTests.cs
@@ -46,7 +46,7 @@ private static TimelineKeyEditorView OpenTimelineKeyEditor(Window window, Timeli
     [Test]
     public async Task TimelineKeyDetailsBatchEditInterpolationTangentsUnitsAndPresetsThroughMountedControls()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/TimelinePropertyTreeTests.cs b/test/GalNet.Editor.Tests/TimelinePropertyTreeTests.cs
index c0dac1fb..898182d9 100644
--- a/test/GalNet.Editor.Tests/TimelinePropertyTreeTests.cs
+++ b/test/GalNet.Editor.Tests/TimelinePropertyTreeTests.cs
@@ -28,7 +28,7 @@ public async Task SceneCreatorsPastedWithTimelineUseNewInternalIdsAndRedoRetains
         var timeline = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.PlayTimeline).Single();
         timeline.Source.Parameters["timeline"] = JsonSerializer.SerializeToElement(new { playbackHandleId = "play", tracks = new[] { new { handleId = id, property = "opacity", keys = new[] { new { frame = 0, value = 1 } } } }, events = Array.Empty<object>() });
         var author = scope.GetRequiredService<GroupEntryAuthoringService>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
-        var copy = await author.PasteAsync(group.Id, author.Copy(group.Id, [creator.StableId, timeline.StableId]), timeline.StableId);
+        var copy = (await author.PasteAsync(group.Id, author.Copy(group.Id, [creator.StableId, timeline.StableId]), timeline.StableId)).Select(id => group.Entries.Single(entry => entry.StableId == id)).ToArray();
         var copiedId = copy[0].Source.Parameters["handleId"].GetString(); Assert.That(copiedId, Is.Not.EqualTo(id)); Assert.That(copy[1].Source.Parameters["timeline"].GetProperty("tracks")[0].GetProperty("handleId").GetString(), Is.EqualTo(copiedId));
         await history.UndoAsync(); Assert.That(group.Entries, Has.Count.EqualTo(2)); Assert.That(history.CanUndo, Is.False); await history.RedoAsync(); Assert.That(copy[0].Source.Parameters["handleId"].GetString(), Is.EqualTo(copiedId));
         history.Clear(); var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.ChangeType(creator, BuiltinEntryIds.PlayParticleEmitter); var particleId = creator.Source.Parameters["instanceId"].GetString(); Assert.That(Guid.TryParse(particleId, out _), Is.True);
@@ -60,7 +60,7 @@ private static void RemoveTimelineOverride(Window window, TimelinePanelView view
     [Test]
     public async Task TimelinePropertyTreeCreatesTracksThroughRealInputsAndRetainsIdentityHistoryAndUnknownJson()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -70,6 +70,7 @@ await ui.Dispatch<bool>(async () =>
             Assert.That(handles.All(value => Guid.TryParse(value, out _)), Is.True); Assert.That(handles.Distinct().Count(), Is.EqualTo(2));
             var timeline = workspace.InsertEntriesInto(group, 2, 1, BuiltinEntryIds.PlayTimeline).Single();
             timeline.Source.Parameters = new() { ["timeline"] = JsonSerializer.Deserialize<JsonElement>("""{"playbackHandleId":"play","durationFrames":60,"future":[9007199254740993,null],"tracks":[],"events":[]}""") };
+            scope.GetRequiredService<IEditorDocumentService>().SynchronizeGroups();
             using var page = ActivatorUtilities.CreateInstance<GroupEditorPanelViewModel>(scope, group.Id); page.SelectedEntry = timeline;
             var session = scope.GetRequiredService<TimelineEditSession>(); var history = scope.GetRequiredService<EditorHistories>().Content; history.Clear();
             var view = scope.GetRequiredService<TimelinePanelView>(); view.DataContext = scope.GetRequiredService<TimelinePanelViewModel>();
diff --git a/test/GalNet.Editor.Tests/VariableListEditorViewModelTests.cs b/test/GalNet.Editor.Tests/VariableListEditorViewModelTests.cs
deleted file mode 100644
index b863692a..00000000
--- a/test/GalNet.Editor.Tests/VariableListEditorViewModelTests.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-using Avalonia.Controls;
-using Avalonia.Headless;
-using Avalonia.Threading;
-using Avalonia.VisualTree;
-using GalNet.Core.Variable;
-using GalNet.Editor.Controls;
-using GalNet.Editor.ViewModels;
-using GalVariable = GalNet.Core.Variable.Variable;
-
-namespace GeneralTest.Editor;
-
-public class VariableListEditorViewModelTests
-{
-    [Test]
-    public void UpdateCurrentValueRefreshesMatchingItemWithoutWritingBack()
-    {
-        var definition = Definition(VariableType.Int);
-        var writeCount = 0;
-        var viewModel = new VariableListEditorViewModel([definition], true, _ => definition.DefaultValue, (_, _) => writeCount++);
-        var changedProperties = new List<string?>();
-        viewModel.Items[0].PropertyChanged += (_, args) => changedProperties.Add(args.PropertyName);
-        var runtimeValue = new GalVariable { Name = "score", Value = VariableValue.From(42) };
-        viewModel.UpdateCurrentValue("score", runtimeValue);
-        Assert.Multiple(() =>
-        {
-            Assert.That(viewModel.Items[0].CurrentIntValue, Is.EqualTo(42));
-            Assert.That(changedProperties, Does.Contain(nameof(VariableEditorItemViewModel.CurrentIntValue)));
-            Assert.That(writeCount, Is.Zero);
-            Assert.That(definition.DefaultValue.AsInt(), Is.Zero);
-        });
-    }
-
-    [TestCase(VariableType.Bool), TestCase(VariableType.Int), TestCase(VariableType.Float), TestCase(VariableType.String)]
-    public void EditingCurrentValueOnlyWritesRuntimeAndDisabledRowsRejectWrites(VariableType type)
-    {
-        var definition = Definition(type);
-        var original = definition.DefaultValue.Value.Serialize();
-        var runtime = definition.DefaultValue.Clone();
-        var writes = new List<object>();
-        var viewModel = new VariableListEditorViewModel([definition], true, _ => runtime, (name, value) =>
-        {
-            Assert.That(name, Is.EqualTo("score")); writes.Add(value);
-        });
-        void Change()
-        {
-            var item = viewModel.Items[0];
-            switch (type)
-            {
-                case VariableType.Bool: item.CurrentBoolValue = true; break;
-                case VariableType.Int: item.CurrentIntValue = 42; break;
-                case VariableType.Float: item.CurrentFloatValue = 1.5m; break;
-                default: item.CurrentStringValue = "current"; break;
-            }
-        }
-        Change();
-        viewModel.SetCurrentValueVisibility(false);
-        Change();
-        Assert.Multiple(() =>
-        {
-            Assert.That(writes, Has.Count.EqualTo(1));
-            Assert.That(definition.DefaultValue.Value.Serialize(), Is.EqualTo(original));
-            Assert.That(runtime.Value.Serialize(), Is.EqualTo(original));
-            Assert.That(viewModel.Items[0].Name, Is.EqualTo("score"));
-            Assert.That(viewModel.Items[0].SelectedType, Is.EqualTo(type));
-        });
-    }
-
-    [Test]
-    public async Task MountedPreviewOnlyExposesRuntimeValueInputs()
-    {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
-        await session.Dispatch<bool>(() =>
-        {
-            Avalonia.Application.Current!.Styles.Add(new Semi.Avalonia.SemiTheme());
-            var definition = Definition(VariableType.Int);
-            var writes = new List<object>();
-            var model = new VariableListEditorViewModel([definition], true, _ => null, (_, value) => writes.Add(value));
-            var view = new VariableListEditorControl { DataContext = model };
-            var window = new Window { Content = view, Width = 700, Height = 300 };
-            window.Show(); Dispatcher.UIThread.RunJobs(); window.UpdateLayout();
-            try
-            {
-                Assert.That(view.GetVisualDescendants().OfType<TextBlock>().Any(label => label.Text == "score"), Is.True);
-                Assert.That(view.GetVisualDescendants().OfType<ComboBox>(), Is.Empty);
-                var input = view.GetVisualDescendants().OfType<NumericUpDown>().Single(control => control.IsVisible);
-                input.Value = 12; Dispatcher.UIThread.RunJobs();
-                Assert.That(writes.Last(), Is.EqualTo(12));
-                Assert.That(definition.DefaultValue.AsInt(), Is.Zero);
-                model.UpdateCurrentValue("score", new() { Value = VariableValue.From(20) });
-                Dispatcher.UIThread.RunJobs();
-                Assert.That(input.Value, Is.EqualTo(20));
-                Assert.That(writes, Has.Count.EqualTo(1), "Runtime refresh must not echo into another write.");
-            }
-            finally { window.Close(); }
-            return true;
-        }, CancellationToken.None);
-    }
-
-    private static ProjectVariableDefinition Definition(VariableType type) => new()
-    {
-        Name = "score",
-        DefaultValue = new()
-        {
-            Name = "score",
-            Value = type switch
-            {
-                VariableType.Bool => VariableValue.From(false),
-                VariableType.Int => VariableValue.From(0),
-                VariableType.Float => VariableValue.From(0f),
-                _ => VariableValue.From("")
-            }
-        }
-    };
-}
diff --git a/test/GalNet.Editor.Tests/VariablesPanelTests.cs b/test/GalNet.Editor.Tests/VariablesPanelTests.cs
index e59329f3..5924b4a3 100644
--- a/test/GalNet.Editor.Tests/VariablesPanelTests.cs
+++ b/test/GalNet.Editor.Tests/VariablesPanelTests.cs
@@ -23,7 +23,7 @@ public sealed partial class ProjectWorkspaceLifecycleTests
     [Test]
     public async Task VariablePanelRenamesOnlyKnownReferencesWithOneHistoryAndPreservesDescriptionsOnReopen()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
@@ -61,7 +61,7 @@ await session.Dispatch<bool>(async () =>
                 window.Close(); groupPage.Dispose(); await projects.CloseAsync();
                 var reopened = await projects.OpenAsync(path); var declaration = reopened.Services.GetRequiredService<VariableAuthoringService>().Get(VariableScope.Save).Single();
                 Assert.That(declaration.Description, Is.EqualTo("Updated description")); Assert.That(declaration.DefaultValue.Uid, Is.EqualTo(uid));
-                Assert.That(reopened.Settings.SaveVariables.Single().Description, Is.EqualTo("Updated description"));
+                Assert.That(reopened.Services.GetRequiredService<IEditorDocumentService>().CurrentDocument.SaveVariables.Single().Description, Is.EqualTo("Updated description"));
                 await projects.CloseAsync();
             }
             finally { window.Close(); groupPage.Dispose(); if (projects.Current is not null) await projects.CloseAsync(); }
@@ -122,7 +122,7 @@ public async Task VariablesRejectInvalidNamesDefaultsAndStaleDraftAndCompensateO
     [Test]
     public async Task VariablesPanelMountedControlsCommitDraftSwitchScopesAndReleaseDockPage()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(EditorFormTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             PrepareGroupTheme(); using var services = Services(); var projects = services.GetRequiredService<IProjectService>();
diff --git a/test/GalNet.Editor.Tests/VisualPresetAuthoringTests.cs b/test/GalNet.Editor.Tests/VisualPresetAuthoringTests.cs
new file mode 100644
index 00000000..2057fc59
--- /dev/null
+++ b/test/GalNet.Editor.Tests/VisualPresetAuthoringTests.cs
@@ -0,0 +1,53 @@
+using Avalonia.Headless;
+using GalNet.Contracts.Builtins;
+using GalNet.Editor.Abstraction.Services;
+using GalNet.Editor.History;
+using GalNet.Editor.Models.Graph;
+using GalNet.Editor.Services;
+using GalNet.Editor.ViewModels;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Editor;
+
+public sealed partial class ProjectWorkspaceLifecycleTests
+{
+    [Test]
+    public async Task VisualPresetCreationAndTypeChangePersistExplicitProjectBindingsAndUndo()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(EditorFormTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var services = Services();
+            var projects = services.GetRequiredService<IProjectService>();
+            var path = Path.Combine(_root, "VisualPresets");
+            var project = await projects.CreateAsync(path, "Visual presets", new(), Path.Combine(AppContext.BaseDirectory, "DefaultContracts"));
+            try
+            {
+                var workspace = project.Services.GetRequiredService<EditorWorkspaceViewModel>();
+                var group = workspace.Nodes.Single(node => node.NodeKind == GraphNodeKind.LinearGroup);
+                var entry = workspace.InsertEntriesInto(group, 0, 1, BuiltinEntryIds.SpeedLinesPreset).Single();
+                var initial = project.Configuration.ReadDefaultOptions().DefaultVisualPrograms["speedLines"];
+                Assert.That(entry.Source.Parameters["program"].GetString(), Is.EqualTo(initial));
+                Assert.That(entry.Source.Parameters["playbackHandleId"].GetString(), Is.Not.Empty);
+                var text = workspace.InsertEntriesInto(group, 1, 1, BuiltinEntryIds.Text).Single();
+                var history = project.Services.GetRequiredService<EditorHistories>().Content;
+                history.Clear();
+                text.Type = BuiltinEntryIds.SpeedLinesPreset;
+                Assert.That(text.Source.Parameters["program"].GetString(), Is.EqualTo(initial));
+                history.Undo();
+                Assert.That(text.Type, Is.EqualTo(BuiltinEntryIds.Text));
+                history.Redo();
+                Assert.That(text.Source.Parameters["program"].GetString(), Is.EqualTo(initial));
+                var id = entry.StableId; var groupId = group.Id;
+                await project.Services.GetRequiredService<IProjectContentSession>().SaveAsync();
+                await projects.CloseAsync();
+                project = await projects.OpenAsync(path);
+                var reopened = project.Services.GetRequiredService<EditorGroupProjectionStore>().Get(groupId).Entries.Single(item => item.StableId == id);
+                Assert.That(reopened.Source.Parameters["program"].GetString(), Is.EqualTo(initial));
+                Assert.That(File.Exists(Path.Combine(path, "Assets/Effects/Default/SpeedLines.sksl")), Is.True);
+            }
+            finally { if (projects.Current is not null) await projects.CloseAsync(); }
+            return true;
+        }, CancellationToken.None);
+    }
+}
diff --git a/test/GalNet.Editor.Tests/packages.lock.json b/test/GalNet.Editor.Tests/packages.lock.json
index 5657baaa..91af5e2e 100644
--- a/test/GalNet.Editor.Tests/packages.lock.json
+++ b/test/GalNet.Editor.Tests/packages.lock.json
@@ -349,6 +349,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -356,6 +357,7 @@
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -367,6 +369,7 @@
           "GalNet.Assets": "[1.0.0, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Irihi.Ursa": "[2.1.0, )",
@@ -381,17 +384,10 @@
         "dependencies": {
           "Avalonia": "[12.0.5, )",
           "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
-      "galnet.avalonia.themes": {
-        "type": "Project",
-        "dependencies": {
-          "Avalonia.Themes.Fluent": "[12.0.5, )",
-          "GalNet.Avalonia.Controls": "[1.0.0, )",
-          "GalNet.Avalonia.GameView": "[1.0.0, )"
-        }
-      },
       "galnet.contracts.builtins": {
         "type": "Project",
         "dependencies": {
@@ -428,14 +424,13 @@
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.GameView": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
-          "GalNet.Avalonia.Themes": "[1.0.0, )",
           "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Editor.Abstraction": "[1.0.0, )",
           "GalNet.Editor.Shared": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Media.LibVlc": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
-          "GalNet.Primitives.Builtins": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )",
           "GalNet.Storage.FileSystem": "[1.0.0, )",
           "Irihi.Ursa": "[2.1.0, )",
@@ -472,6 +467,7 @@
       "galnet.gamehost": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
@@ -481,6 +477,7 @@
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "LibVLCSharp": "[3.10.0, )"
@@ -489,6 +486,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -506,7 +504,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
@@ -514,6 +511,7 @@
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
diff --git a/test/GalNet.GameHost.Tests/GameSessionTests.cs b/test/GalNet.GameHost.Tests/GameSessionTests.cs
index 163c3206..daebafe7 100644
--- a/test/GalNet.GameHost.Tests/GameSessionTests.cs
+++ b/test/GalNet.GameHost.Tests/GameSessionTests.cs
@@ -5,6 +5,20 @@ namespace GalNet.GameHost.Tests;
 
 public sealed class GameSessionTests
 {
+    [Test]
+    public async Task InvalidReplacementSaveDoesNotStopOrReleaseCurrentRun()
+    {
+        var run = new Run { FailValidate = true };
+        var creations = 0;
+        await using var session = new GameSession(_ => { creations++; return Task.FromResult<IGameRun>(run); });
+        await session.PrepareAsync(null);
+        Assert.ThrowsAsync<InvalidDataException>(() => session.PrepareAsync(new GameSnapshot()));
+        Assert.That(run.Calls, Is.EqualTo(new[] { "prepare", "validate" }));
+        Assert.That(creations, Is.EqualTo(1));
+        await session.BeginPreparedAsync();
+        Assert.That(run.Calls.Last(), Is.EqualTo("start"));
+    }
+
     [Test]
     public async Task ReplacementWaitsForSnapshotWriteBeforeStoppingOldRun()
     {
@@ -59,6 +73,12 @@ private sealed class Run : IGameRun
         public List<string> Calls { get; } = [];
         public bool FailPrepare { get; init; }
         public bool FailStop { get; init; }
+        public bool FailValidate { get; init; }
+        public Task ValidateSnapshotAsync(GameSnapshot snapshot, CancellationToken cancellationToken)
+        {
+            Calls.Add("validate");
+            return FailValidate ? Task.FromException(new InvalidDataException("bad save")) : Task.CompletedTask;
+        }
         public Task PrepareAsync(GameSnapshot? snapshot, CancellationToken cancellationToken)
         {
             Calls.Add("prepare");
diff --git a/test/GalNet.GameHost.Tests/NewGameVariablesTests.cs b/test/GalNet.GameHost.Tests/NewGameVariablesTests.cs
new file mode 100644
index 00000000..cb47148e
--- /dev/null
+++ b/test/GalNet.GameHost.Tests/NewGameVariablesTests.cs
@@ -0,0 +1,62 @@
+using System.Text.Json;
+using GalNet.Core.Entry;
+using GalNet.Core.Graph;
+using GalNet.Core.Primitives;
+using GalNet.Core.Runtime;
+using GalNet.Core.Variable;
+using GalNet.Presentation.Abstractions.Execution;
+using GalNet.Presentation.Abstractions.View;
+using GalNet.Runtime.Runtime;
+
+namespace GalNet.GameHost.Tests;
+
+public sealed class NewGameVariablesTests
+{
+    [Test]
+    public async Task StartupParametersAreAppliedBeforeFirstInstructionAndNotReappliedOnRestore()
+    {
+        var chapters = new List<int>();
+        using var registration = new GameRegistration();
+        registration.RegisterSchema(new DefaultEntryModule("chapter", [new DefaultPrimitiveEntryBase("chapter.observe", DynamicParameterTable.Empty)]));
+        registration.RegisterImplementation(new PrimitiveModule(registry => registry.Register("chapter.observe", context =>
+            new ImmediatePrimitiveInstance(() => chapters.Add(context.Runtime.GetVariable("chapter")!.AsInt())))));
+        await using var view = registration.BuildView();
+        var graph = new Graph
+        {
+            RootNodeId = "main",
+            Nodes = [new Group { Id = "main", Entries =
+            [new PrimitiveEntry("chapter.observe", JsonSerializer.SerializeToElement(new { }))] }]
+        };
+        var defaults = new List<ProjectVariableDefinition> { new() { Name = "chapter", DefaultValue = new() { Uid = "chapter-id", Name = "chapter", Value = VariableValue.From(1) } } };
+        GameRun? current = null;
+        await using var session = new GameSession(_ =>
+        {
+            current = new GameRun(graph, new GameRuntime(null, "main", saveDefaults: defaults), view);
+            return Task.FromResult<IGameRun>(current);
+        });
+        await session.PrepareNewAsync(new Dictionary<string, object> { ["save.chapter"] = 2 });
+        Assert.That(chapters, Is.Empty);
+        var saved = current!.CreateSaveData();
+        Assert.That(saved.Variables["chapter"].Uid, Is.EqualTo("chapter-id"));
+        Assert.That(saved.Variables["chapter"].AsInt(), Is.EqualTo(2));
+        await session.BeginPreparedAsync();
+        Assert.That(chapters, Is.EqualTo(new[] { 2 }));
+        await session.PrepareAsync(null);
+        Assert.That(current!.CreateSaveData().Variables["chapter"].AsInt(), Is.EqualTo(1));
+        await session.PrepareAsync(saved);
+        Assert.That(current!.CreateSaveData().Variables["chapter"].AsInt(), Is.EqualTo(2));
+        await session.BeginPreparedAsync();
+        Assert.That(chapters, Is.EqualTo(new[] { 2, 2 }));
+    }
+
+    [Test]
+    public void StartupBatchRejectsPlayerScopeInvalidValuesAndCopiesTheInput()
+    {
+        Assert.Throws<ArgumentException>(() => NewGameVariables.Capture(new Dictionary<string, object> { ["player.chapter"] = 1 }));
+        Assert.Throws<ArgumentException>(() => NewGameVariables.Capture(new Dictionary<string, object> { ["save.chapter"] = 1, ["save.bad"] = double.NaN }));
+        var source = new Dictionary<string, object> { ["save.chapter"] = 2 };
+        var snapshot = NewGameVariables.Capture(source);
+        source["save.chapter"] = 9;
+        Assert.That(snapshot["save.chapter"], Is.EqualTo(2));
+    }
+}
diff --git a/test/GalNet.GameHost.Tests/packages.lock.json b/test/GalNet.GameHost.Tests/packages.lock.json
index a2394d97..735432e7 100644
--- a/test/GalNet.GameHost.Tests/packages.lock.json
+++ b/test/GalNet.GameHost.Tests/packages.lock.json
@@ -116,12 +116,19 @@
         "resolved": "13.0.3",
         "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
       },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.core": {
         "type": "Project"
       },
       "galnet.gamehost": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
@@ -130,6 +137,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -138,7 +146,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/test/GalNet.IntegrationTests/AvaloniaGameResourcesTests.cs b/test/GalNet.IntegrationTests/AvaloniaGameResourcesTests.cs
index a802ae24..cebc07c8 100644
--- a/test/GalNet.IntegrationTests/AvaloniaGameResourcesTests.cs
+++ b/test/GalNet.IntegrationTests/AvaloniaGameResourcesTests.cs
@@ -13,14 +13,14 @@ public sealed class AvaloniaGameResourcesTests
     [Test]
     public async Task PartialPreloadFailureReleasesSuccessfulAcquisitions()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             using var texture = new SceneTexture(LayerImageFallback.MissingImage);
             using var assets = new Assets(texture);
             Assert.ThrowsAsync<IOException>(() => AvaloniaGameResources.CreateAsync(assets,
                 (_, _) => Task.FromResult<IReadOnlyList<IGameFile>>([new Source("ok"), new Source("fail")]),
-                (_, _) => Task.FromResult(Array.Empty<GalNet.Core.Scene.EffectProgramResource>())));
+                (_, _) => Task.FromResult(Array.Empty<GalNet.Contracts.Builtins.Scene.EffectProgramResource>())));
             Assert.That(assets.Released, Is.EqualTo(1));
             await Task.CompletedTask;
             return true;
@@ -30,7 +30,7 @@ await ui.Dispatch<bool>(async () =>
     [Test]
     public async Task DefaultPresentationUsesAndReleasesInjectedAdapters()
     {
-        await using var ui = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await ui.Dispatch<bool>(async () =>
         {
             using var texture = new SceneTexture(LayerImageFallback.MissingImage);
@@ -38,10 +38,17 @@ await ui.Dispatch<bool>(async () =>
             using var files = new GalNet.Assets.AssetFileMaterializer(assets);
             var audio = new Audio();
             var layers = new Layers(texture);
+            var video = new Video();
             var options = new AvaloniaGamePresentationOptions
             {
                 CreateLayers = _ => layers,
-                CreateAudioHost = (_, _, _) => audio
+                CreateAudioHost = (_, _) => audio,
+                CreateVideoPresenter = (actualAssets, _, actualFiles) =>
+                {
+                    Assert.That(actualAssets, Is.SameAs(assets));
+                    Assert.That(actualFiles, Is.SameAs(files));
+                    return video;
+                }
             };
             var presentation = await AvaloniaGamePresentation.CreateAsync(
                 new GalNet.Avalonia.GameView.ViewModels.GamePageViewModel(null!),
@@ -49,28 +56,67 @@ await ui.Dispatch<bool>(async () =>
                 new Dictionary<string, AssetHandle<SceneTexture>>(), [], files,
                 (registration, _) => registration.RegisterSchema(new GalNet.Core.Entry.DefaultEntryModule("custom")), [], options);
             Assert.That(presentation.Audio, Is.SameAs(audio));
+            Assert.That(presentation.Video, Is.SameAs(video));
             var closing = presentation.DisposeAsync().AsTask();
             await closing;
             Assert.That(presentation.DisposeAsync().AsTask(), Is.SameAs(closing));
             Assert.That(audio.Disposals, Is.EqualTo(1));
             Assert.That(layers.Disposals, Is.EqualTo(1));
+            Assert.That(video.Disposals, Is.EqualTo(1));
             return true;
         }, TestContext.CurrentContext.CancellationToken);
     }
 
+    [Test]
+    public async Task FailedVideoBackendCreationReleasesPreviouslyCreatedAudioAndLayers()
+    {
+        var ui = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
+        await ui.Dispatch<bool>(async () =>
+        {
+            using var texture = new SceneTexture(LayerImageFallback.MissingImage);
+            using var assets = new Assets(texture);
+            using var files = new GalNet.Assets.AssetFileMaterializer(assets);
+            var audio = new Audio();
+            var layers = new Layers(texture);
+            Assert.ThrowsAsync<IOException>(() => AvaloniaGamePresentation.CreateAsync(
+                new GalNet.Avalonia.GameView.ViewModels.GamePageViewModel(null!),
+                new GalNet.Avalonia.GameView.Page.GamePage(), assets,
+                new Dictionary<string, AssetHandle<SceneTexture>>(), [], files, (_, _) => { }, [], new()
+                {
+                    CreateLayers = _ => layers,
+                    CreateAudioHost = (_, _) => audio,
+                    CreateVideoPresenter = (_, _, _) => throw new IOException("Video backend unavailable.")
+                }));
+            Assert.That(audio.Disposals, Is.EqualTo(1));
+            Assert.That(layers.Disposals, Is.EqualTo(1));
+            await Task.CompletedTask;
+            return true;
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+
+    private sealed class Video : GalNet.Presentation.Abstractions.View.IVideoPresenter, IDisposable, IAsyncDisposable
+    {
+        public int Disposals { get; private set; }
+        public Task PlayVideoAsync(GalNet.Presentation.Abstractions.View.VideoRenderRequest request, CancellationToken cancellationToken) => Task.CompletedTask;
+        public void AdvanceVideo(string playbackId) { }
+        public void StopVideo(string handleId) { }
+        public void Dispose() => throw new InvalidOperationException("Prefer asynchronous video cleanup.");
+        public async ValueTask DisposeAsync() { await Task.Yield(); Disposals++; }
+    }
+
     private sealed class Layers(SceneTexture texture) : IGamePageLayerFactory, IDisposable
     {
         public int Disposals { get; private set; }
         public SceneTexture ResolveTexture(string assetId) => texture;
         public void Dispose() => Disposals++;
     }
-    private sealed class Audio : GalNet.Presentation.Abstractions.Audio.IAudioPlaybackHost
+    private sealed class Audio : GalNet.Contracts.Builtins.Audio.IAudioPlaybackHost
     {
         public int Disposals { get; private set; }
-        public GalNet.Core.Audio.AudioBackendCapabilities Capabilities => GalNet.Core.Audio.AudioBackendCapabilities.None;
-        public GalNet.Core.Audio.ISEffectCatalog SEffects => GalNet.Core.Audio.SEffectCatalog.Empty;
-        public event Action<GalNet.Core.Audio.AudioBackendEvent>? EventReceived { add { } remove { } }
-        public Task ApplyAsync(GalNet.Core.Audio.AudioBackendRequest request, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public GalNet.Contracts.Builtins.Audio.AudioBackendCapabilities Capabilities => GalNet.Contracts.Builtins.Audio.AudioBackendCapabilities.None;
+        public GalNet.Contracts.Builtins.Audio.ISEffectCatalog SEffects => GalNet.Contracts.Builtins.Audio.SEffectCatalog.Empty;
+        public event Action<GalNet.Contracts.Builtins.Audio.AudioBackendEvent>? EventReceived { add { } remove { } }
+        public Task ApplyAsync(GalNet.Contracts.Builtins.Audio.AudioBackendRequest request, CancellationToken cancellationToken = default) => Task.CompletedTask;
         public void Dispose() => Disposals++;
     }
 
diff --git a/test/GalNet.IntegrationTests/BuiltinAutoPlaybackTests.cs b/test/GalNet.IntegrationTests/BuiltinAutoPlaybackTests.cs
index 9627ac87..08a08923 100644
--- a/test/GalNet.IntegrationTests/BuiltinAutoPlaybackTests.cs
+++ b/test/GalNet.IntegrationTests/BuiltinAutoPlaybackTests.cs
@@ -1,10 +1,9 @@
 using System.Text.Json;
-using GalNet.Core.Audio;
+using GalNet.Contracts.Builtins.Audio;
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
-using GalNet.Core.Settings;
-using GalNet.Presentation.Abstractions.Audio;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
@@ -22,16 +21,15 @@ public async Task ManualTextRevealThenPlaybackWaitsForInterval(string type, Play
     {
         var text = new ControlledText();
         await using var view = new GameRegistration().AddBuiltins(dialoguePresenter: text, nvlPresenter: text).BuildView();
-        var settings = new SettingsContainer();
-        settings.Set(new GameSettings
+        var settings = new PlaybackOptions
         {
             QuickReadOnly = false,
             AutoAdvanceIntervalMilliseconds = 120,
             QuickAdvanceIntervalMilliseconds = 120
-        });
+        };
         var group = new Group { Id = "main" };
         group.Entries.Add(new PrimitiveEntry(type, JsonSerializer.SerializeToElement(new { content = "Hello" })) { StableId = "text" });
-        await using var engine = new GameEngine(new Graph { RootNodeId = "main", Nodes = { group } }, view, settings: settings);
+        await using var engine = new GameEngine(new Graph { RootNodeId = "main", Nodes = { group } }, view, playbackOptions: settings);
         var ended = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
         engine.StateChanged += state => { if (state.State == GameEngineState.Completed) ended.TrySetResult(); };
         await engine.AdvanceAsync();
@@ -49,17 +47,16 @@ public async Task AutoIntervalStartsOnlyAfterActualTextAndVoicePrimitivesFinish(
     {
         var text = new ControlledText();
         using var audio = new ControlledAudio();
-        await using var view = new GameRegistration().AddBuiltins(dialoguePresenter: text, audioHost: audio).BuildView();
-        var settings = new SettingsContainer();
-        settings.Set(new ProjectSettings());
-        settings.Set(new GameSettings { AutoAdvanceIntervalMilliseconds = 120 });
+        await using var view = new GameRegistration().AddBuiltins(dialoguePresenter: text, audioHost: audio,
+            audioConfiguration: GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create()).BuildView();
+        var settings = new PlaybackOptions { AutoAdvanceIntervalMilliseconds = 120 };
         var group = new Group { Id = "main" };
         group.Entries.AddRange([
-            new PrimitiveEntry("audio.play", JsonSerializer.SerializeToElement(new { trackId = AudioBuses.Vocal, asset = "voice", autoBlocking = "true" })) { StableId = "voice" },
+            new PrimitiveEntry("audio.play", JsonSerializer.SerializeToElement(new { trackId = "vocal", asset = "voice", autoBlocking = "true" })) { StableId = "voice" },
             new PrimitiveEntry("dialogue.text", JsonSerializer.SerializeToElement(new { content = "Hello" })) { StableId = "text" }
         ]);
         var graph = new Graph { RootNodeId = "main", Nodes = { group } };
-        await using var engine = new GameEngine(graph, view, settings: settings);
+        await using var engine = new GameEngine(graph, view, playbackOptions: settings);
         var ended = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
         engine.StateChanged += state => { if (state.State == GameEngineState.Completed) ended.TrySetResult(); };
         await engine.AdvanceAsync();
diff --git a/test/GalNet.IntegrationTests/BuiltinTestRuntime.cs b/test/GalNet.IntegrationTests/BuiltinTestRuntime.cs
index 5a3d1913..d11ff40e 100644
--- a/test/GalNet.IntegrationTests/BuiltinTestRuntime.cs
+++ b/test/GalNet.IntegrationTests/BuiltinTestRuntime.cs
@@ -1,6 +1,5 @@
 using GalNet.Core.Runtime;
 using GalNet.Core.Services;
-using GalNet.Core.Settings;
 using GalNet.Core.Variable;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
@@ -12,7 +11,7 @@ internal static class BuiltinTestRuntime
     public static StateCatalog Catalog { get; } = CreateCatalog();
     private static StateCatalog CreateCatalog()
     { using var view = new GameRegistration().AddBuiltins().BuildView(); return view.StateCatalog; }
-    public static GameRuntime Create(ITextResolver? resolver, string rootNodeId = "", SettingsContainer? settings = null,
-        IVariableService? variableService = null) => new(resolver, rootNodeId, settings, variableService, Catalog);
+    public static GameRuntime Create(ITextResolver? resolver, string rootNodeId = "",
+        IVariableService? variableService = null) => new(resolver, rootNodeId, variableService, Catalog);
     public static GameState State(GameSnapshot snapshot) => GameState.Restore(Catalog, snapshot.States);
 }
diff --git a/test/GalNet.IntegrationTests/DialogueHistoryTests.cs b/test/GalNet.IntegrationTests/DialogueHistoryTests.cs
new file mode 100644
index 00000000..3672d559
--- /dev/null
+++ b/test/GalNet.IntegrationTests/DialogueHistoryTests.cs
@@ -0,0 +1,328 @@
+using System.Text.Json;
+using GalNet.Avalonia.GameHost;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Entry;
+using GalNet.Core.Graph;
+using GalNet.Core.I18n;
+using GalNet.Core.Parameters;
+using GalNet.Core.Primitives;
+using GalNet.Core.Runtime;
+using GalNet.GameHost;
+using GalNet.Presentation.Abstractions.Application;
+using GalNet.Presentation.Abstractions.Execution;
+using GalNet.Presentation.Abstractions.View;
+using GalNet.Primitives.Builtins;
+using GalNet.Runtime.Engine;
+using GalNet.Runtime.Progress;
+using GalNet.Runtime.Runtime;
+using GalNet.Storage.FileSystem;
+
+namespace GeneralTest.Runtime;
+
+public sealed class DialogueHistoryTests
+{
+    [Test]
+    public async Task HostCanOpenAnOlderSaveWithoutInventingHistoricalTextOrRelaxingOtherStateValidation()
+    {
+        using var registration = new GameRegistration();
+        registration.AddBuiltins(dialoguePresenter: new ImmediateText());
+        registration.RegisterImplementation(DialogueHistoryJournal.CreateModule());
+        await using var view = registration.BuildView();
+        var runtime = new GameRuntime(null, "main", stateCatalog: view.StateCatalog);
+        var older = runtime.CreateSnapshot();
+        older.States.Remove(DialogueHistoryJournal.StateId);
+        var prepared = DialogueHistoryJournal.PrepareSnapshot(older);
+        Assert.That(older.States.ContainsKey(DialogueHistoryJournal.StateId), Is.False);
+        var restored = GameState.Restore(view.StateCatalog, prepared.States);
+        Assert.That(restored.Table<DialogueHistoryCursor>().Values, Is.Empty);
+        var journal = new DialogueHistoryJournal();
+        journal.Restore(prepared);
+        Assert.That(journal.Lines, Is.Empty);
+        prepared.States.Remove("builtin.audio.tracks");
+        Assert.That(() => GameState.Restore(view.StateCatalog, prepared.States), Throws.TypeOf<InvalidDataException>());
+    }
+    [Test]
+    public async Task CheckpointFlushesPresentedTextEvenIfItsPresentationContinuationHasNotRun()
+    {
+        var journal = new DialogueHistoryJournal();
+        var reading = new DelayedCompletionReading();
+        using var registration = new GameRegistration();
+        registration.AddBuiltinSchemas().RegisterInstruction(BuiltinEntryIds.Text, _ => reading);
+        registration.RegisterImplementation(DialogueHistoryJournal.CreateModule());
+        await using var view = registration.BuildView();
+        var runtime = new GameRuntime(null, "main", stateCatalog: view.StateCatalog);
+        var progress = new Progress();
+        await using var history = new DialogueHistoryDispatcher(view, journal, progress, CharacterCatalog.Empty);
+        var group = new Group { Id = "main" };
+        group.Entries.Add(Text("line#1"));
+        await using var engine = new GameEngine(new Graph { RootNodeId = "main", Nodes = { group } }, runtime, history, progress);
+        await engine.AdvanceAsync();
+        reading.IsTextPresented = true;
+        await engine.AdvanceAsync();
+        var saved = journal.Attach(engine.CreateSaveData());
+        var restored = new DialogueHistoryJournal();
+        restored.Restore(saved);
+        Assert.That(restored.Lines.Count, Is.EqualTo(1), "A delayed observation must not leave the checkpoint cursor behind its entry position.");
+        reading.FinishPresentation();
+    }
+    [Test]
+    public async Task EngineCheckpointRestartsTheWholeVoicedLineAndKeepsHistoryWithoutDuplicates()
+    {
+        var journal = new DialogueHistoryJournal();
+        using var registration = new GameRegistration();
+        registration.AddBuiltins(dialoguePresenter: new ImmediateText(), audioConfiguration: BuiltinAudioDefaults.Create());
+        registration.RegisterImplementation(DialogueHistoryJournal.CreateModule());
+        await using var view = registration.BuildView();
+        var runtime = new GameRuntime(null, "main", stateCatalog: view.StateCatalog);
+        var progress = new Progress();
+        await using var history = new DialogueHistoryDispatcher(view, journal, progress, CharacterCatalog.Empty);
+        var group = new Group { Id = "main" };
+        group.Entries.AddRange([Audio("one#1", "one#2"), Text("one#2"), Text("two#1")]);
+        var graph = new Graph { RootNodeId = "main", Nodes = { group } };
+        await using var restorer = new StateRestoreSession(view);
+        await using var run = new GameRun(graph, runtime, history, progress, restoration: restorer);
+        await run.PrepareAsync(null);
+        await run.StartPreparedAsync();
+        history.FlushCompleted();
+        Assert.That(journal.Lines.Count, Is.EqualTo(1));
+        var saved = journal.Attach(run.CreateSaveData());
+        Assert.That(saved.EntryIndex, Is.Zero, "Saving a voiced line must not resume between its audio and text primitives.");
+        journal.Restore(saved);
+        await run.PrepareAsync(saved);
+        await run.StartPreparedAsync();
+        history.FlushCompleted();
+        Assert.That(journal.Lines.Count, Is.EqualTo(1));
+        Assert.That(journal.Lines[0].Voice, Is.Not.Null);
+        await run.Engine.AdvanceAsync();
+        history.FlushCompleted();
+        Assert.That(journal.Lines.Count, Is.EqualTo(2));
+        var secondSave = journal.Attach(run.CreateSaveData());
+        var restored = new DialogueHistoryJournal();
+        restored.Restore(secondSave);
+        Assert.That(restored.Lines.Count, Is.EqualTo(1), "The currently displayed second line is replayed after restore.");
+    }
+
+    [Test]
+    public async Task SkippedInstructionInvalidatesAnUnconsumedAudioCandidate()
+    {
+        var journal = new DialogueHistoryJournal();
+        using var registration = new GameRegistration();
+        registration.AddBuiltins(dialoguePresenter: new ImmediateText(), audioConfiguration: BuiltinAudioDefaults.Create());
+        registration.RegisterImplementation(DialogueHistoryJournal.CreateModule());
+        await using var view = registration.BuildView();
+        var runtime = new GameRuntime(null, "main", stateCatalog: view.StateCatalog);
+        await using var history = new DialogueHistoryDispatcher(view, journal, new Progress(), CharacterCatalog.Empty);
+        history.Dispatch(Audio("line#1", "line#2"), runtime, default);
+        history.OnInstructionSkipped(Text("line#2"), runtime);
+        var text = history.Dispatch(Text("line#2"), runtime, default);
+        await text.PresentationCompletion;
+        history.FlushCompleted();
+        Assert.That(journal.Lines.Single().Voice, Is.Null);
+    }
+
+    [Test]
+    public async Task AdjacentSameSourceAudioDoesNotNeedToBeTheFirstPrimitiveOfAComposite()
+    {
+        var journal = new DialogueHistoryJournal();
+        using var registration = new GameRegistration();
+        registration.AddBuiltins(dialoguePresenter: new ImmediateText(), audioConfiguration: BuiltinAudioDefaults.Create());
+        registration.RegisterImplementation(DialogueHistoryJournal.CreateModule());
+        await using var view = registration.BuildView();
+        var runtime = new GameRuntime(null, "main", stateCatalog: view.StateCatalog);
+        await using var history = new DialogueHistoryDispatcher(view, journal, new Progress(), CharacterCatalog.Empty);
+        var audio = Audio("line#2", "line#3");
+        audio.ReadingBoundaryId = null;
+        history.Dispatch(audio, runtime, default);
+        var text = history.Dispatch(Text("line#3"), runtime, default);
+        await text.PresentationCompletion;
+        history.FlushCompleted();
+        Assert.That(journal.Lines.Single().Voice?.AssetId, Is.EqualTo("voice"));
+    }
+
+    [TestCase(PrimitiveInvocationMode.Normal)]
+    [TestCase(PrimitiveInvocationMode.Quick)]
+    [TestCase(PrimitiveInvocationMode.CatchUp)]
+    public async Task SameSourceVoiceIsKeptForHistoryEvenWhenAlreadyFinished(PrimitiveInvocationMode mode)
+    {
+        var journal = new DialogueHistoryJournal();
+        using var registration = new GameRegistration();
+        registration.AddBuiltins(dialoguePresenter: new ImmediateText(), audioConfiguration: BuiltinAudioDefaults.Create());
+        registration.RegisterImplementation(DialogueHistoryJournal.CreateModule());
+        await using var view = registration.BuildView();
+        var runtime = new GameRuntime(null, "main", stateCatalog: view.StateCatalog);
+        await using var history = new DialogueHistoryDispatcher(view, journal, new Progress(), CharacterCatalog.Empty);
+        var audio = Audio("line#1", "line#2");
+        history.Dispatch(audio, runtime, default, mode);
+        var text = history.Dispatch(Text("line#2"), runtime, default, mode);
+        await text.PresentationCompletion;
+        history.FlushCompleted();
+        Assert.That(journal.Lines.Single().Voice, Is.EqualTo(new DialogueVoice("voice", "vocal", .7f)));
+        Assert.That(journal.Lines.Single().WasRead, Is.False);
+        text.Skip();
+
+        // A second visit to the same text cannot borrow the old voice association.
+        var next = history.Dispatch(Text("line#2"), runtime, default, mode);
+        await next.PresentationCompletion;
+        history.FlushCompleted();
+        Assert.That(journal.Lines.Count, Is.EqualTo(2));
+        Assert.That(journal.Lines[1].Voice, Is.Null);
+    }
+
+    [Test]
+    public async Task DifferentSourceAndDebuggerReconstructionDoNotManufactureVoiceOrHistory()
+    {
+        var journal = new DialogueHistoryJournal();
+        using var registration = new GameRegistration();
+        registration.AddBuiltins(dialoguePresenter: new ImmediateText(), audioConfiguration: BuiltinAudioDefaults.Create());
+        registration.RegisterImplementation(DialogueHistoryJournal.CreateModule());
+        await using var view = registration.BuildView();
+        var runtime = new GameRuntime(null, "main", stateCatalog: view.StateCatalog);
+        await using var history = new DialogueHistoryDispatcher(view, journal, new Progress(), CharacterCatalog.Empty);
+        history.Dispatch(Audio("other#1", "other#2"), runtime, default);
+        var text = history.Dispatch(Text("line#1"), runtime, default);
+        await text.PresentationCompletion;
+        history.FlushCompleted();
+        Assert.That(journal.Lines.Single().Voice, Is.Null);
+        history.SuppressRecording = () => true;
+        history.Dispatch(Text("line#1"), runtime, default, PrimitiveInvocationMode.CatchUp);
+        Assert.That(journal.Lines.Count, Is.EqualTo(1));
+    }
+
+    [Test]
+    public async Task SaveAndQuickSaveCarryOnlyTheHistoryPrefixOfTheirCheckpoint()
+    {
+        var journal = new DialogueHistoryJournal();
+        using var registration = new GameRegistration();
+        registration.AddBuiltins(dialoguePresenter: new ImmediateText());
+        registration.RegisterImplementation(DialogueHistoryJournal.CreateModule());
+        await using var view = registration.BuildView();
+        var runtime = new GameRuntime(null, "main", stateCatalog: view.StateCatalog);
+        var first = new DialogueHistoryLine("main", "one#1", "Alice", "<b>Hello</b>", false, new("voice", "vocal"));
+        journal.Append(runtime.State, first);
+        var checkpoint = runtime.CreateSnapshot();
+        journal.Append(runtime.State, first with { Text = "future branch" });
+        var attached = journal.Attach(checkpoint);
+        Assert.That(checkpoint.Attachments, Is.Empty, "Attaching history must not grow the live checkpoint.");
+        var root = Path.Combine(Path.GetTempPath(), "galnet-history-" + Guid.NewGuid().ToString("N"));
+        try
+        {
+            using var saves = new FileSaveService(root);
+            await saves.SaveAsync(0, new() { Snapshot = attached });
+            await saves.QuickSaveAsync(new() { Snapshot = attached });
+            foreach (var loaded in new[] { await saves.LoadAsync(0), await saves.QuickLoadAsync() })
+            {
+                var restored = new DialogueHistoryJournal();
+                restored.Restore(loaded);
+                Assert.That(restored.Lines, Is.EqualTo(new[] { first }));
+            }
+            journal.Restore(await saves.LoadAsync(0));
+            Assert.That(journal.Lines.Count, Is.EqualTo(1));
+            Assert.That(() => journal.Restore(new GameSnapshot { States = attached.States }), Throws.TypeOf<InvalidDataException>());
+        }
+        finally { if (Directory.Exists(root)) Directory.Delete(root, true); }
+    }
+
+    [Test]
+    public async Task CancelledIncompleteTextIsNeverAppended()
+    {
+        var journal = new DialogueHistoryJournal();
+        var presenter = new DeferredText();
+        using var registration = new GameRegistration();
+        registration.AddBuiltins(dialoguePresenter: presenter);
+        registration.RegisterImplementation(DialogueHistoryJournal.CreateModule());
+        await using var view = registration.BuildView();
+        var runtime = new GameRuntime(null, "main", stateCatalog: view.StateCatalog);
+        await using var history = new DialogueHistoryDispatcher(view, journal, new Progress(), CharacterCatalog.Empty);
+        using var cancellation = new CancellationTokenSource();
+        var instance = history.Dispatch(Text("line#1"), runtime, cancellation.Token);
+        Assert.That(journal.Lines, Is.Empty);
+        cancellation.Cancel();
+        presenter.Finish();
+        await instance.PresentationCompletion;
+        history.FlushCompleted();
+        Assert.That(journal.Lines, Is.Empty);
+    }
+
+    private static PrimitiveEntry Audio(string id, string target) => new(BuiltinEntryIds.PlayAudio,
+        ValueCodec.SerializeFields(new AudioPlayOptions { TrackId = "vocal", Asset = "voice", Gain = .7f, AutoBlocking = true }))
+    { StableId = id, ReadingBoundaryId = target };
+    private static PrimitiveEntry Text(string id) => new(BuiltinEntryIds.Text,
+        ValueCodec.SerializeFields(new DialogueTextOptions { Content = "<color=red>Hello</color>" }))
+    { StableId = id };
+    private sealed class Progress : IGameProgressService
+    {
+        public bool IsRead(string groupId, string entryId) => false;
+        public void MarkRead(string groupId, string entryId) { }
+    }
+    private class ImmediateText : IDialoguePresenter
+    {
+        public void ShowDialogue() { }
+        public void HideDialogue() { }
+        public virtual Task PresentTextAsync(string speaker, string text, CancellationToken token) => Task.CompletedTask;
+        public Task PresentTextImmediatelyAsync(string speaker, string text, CancellationToken token) => Task.CompletedTask;
+        public void SkipText() { }
+        public void RevealAllText() { }
+    }
+    private sealed class DeferredText : ImmediateText
+    {
+        private readonly TaskCompletionSource _completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public void Finish() => _completion.TrySetResult();
+        public override Task PresentTextAsync(string speaker, string text, CancellationToken token) => _completion.Task;
+    }
+    private sealed class DelayedCompletionReading : PrimitiveInstance, IAdvanceWaitInstance
+    {
+        private readonly TaskCompletionSource _presentation = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public override bool IsBlocking => true;
+        public override bool IsSkippable => true;
+        public bool IsTextPresented { get; set; }
+        public bool IsWaitingForAdvance => IsTextPresented && !IsCompleted;
+        public override Task PresentationCompletion => _presentation.Task;
+        protected override void OnDispatch() { }
+        protected override void OnSkip() => TryComplete();
+        public void CompleteAdvance() => Skip();
+        public void FinishPresentation() => _presentation.TrySetResult();
+    }
+}
+
+public sealed class DialogueVoiceReplayTests
+{
+    [Test]
+    public async Task ContinueDuringPendingStartEventuallyStopsTheVoiceAndStaleEventsCannotStopItsReplacement()
+    {
+        using var audio = new Audio();
+        await using var replay = new DialogueVoiceReplay(audio);
+        var firstPlay = replay.PlayAsync(new("one", "custom-vocal", .4f));
+        await audio.Started.Task.WaitAsync(TimeSpan.FromSeconds(2));
+        replay.Stop();
+        Assert.That(replay.IsPlaying, Is.False);
+        audio.AllowStart.TrySetResult();
+        await firstPlay;
+        await replay.PlayAsync(new("two", "custom-vocal", .8f));
+        var first = audio.Requests.First();
+        audio.Finish(first);
+        Assert.That(replay.IsPlaying, Is.True);
+        var second = audio.Requests.Last(request => request.Action == AudioBackendAction.Start);
+        Assert.That(audio.Requests.Any(request => request.Action == AudioBackendAction.Stop && request.VoiceId == first.VoiceId), Is.True);
+        Assert.That(second.TrackId, Is.EqualTo("custom-vocal"));
+        Assert.That(second.Gain, Is.EqualTo(.8f));
+        audio.Finish(second);
+        Assert.That(replay.IsPlaying, Is.False);
+    }
+    private sealed class Audio : IAudioPlaybackHost
+    {
+        public AudioBackendCapabilities Capabilities => AudioBackendCapabilities.None;
+        public ISEffectCatalog SEffects => new SEffectCatalog([]);
+        public event Action<AudioBackendEvent>? EventReceived;
+        public List<AudioBackendRequest> Requests { get; } = [];
+        public TaskCompletionSource Started { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public TaskCompletionSource AllowStart { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public async Task ApplyAsync(AudioBackendRequest request, CancellationToken token = default)
+        {
+            Requests.Add(request);
+            if (request.Action == AudioBackendAction.Start) { Started.TrySetResult(); await AllowStart.Task; }
+        }
+        public void Finish(AudioBackendRequest request) => EventReceived?.Invoke(new(AudioBackendEventKind.Ended, request.TrackId, request.VoiceId, request.Generation));
+        public void Dispose() { }
+    }
+}
diff --git a/test/GalNet.IntegrationTests/ExportPreparationTests.cs b/test/GalNet.IntegrationTests/ExportPreparationTests.cs
new file mode 100644
index 00000000..772dd940
--- /dev/null
+++ b/test/GalNet.IntegrationTests/ExportPreparationTests.cs
@@ -0,0 +1,135 @@
+using System.IO.Compression;
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Assets.Variants;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Core.Assets;
+using GalNet.Core.Entry;
+using GalNet.Core.Serialization;
+using GalNet.Editor.Shared.Services;
+using GalNet.Storage.FileSystem;
+
+namespace GalNet.IntegrationTests;
+
+public sealed class ExportPreparationTests
+{
+    private string _root = null!;
+    private string Project => Path.Combine(_root, "project");
+    private readonly TargetProfileEntryCatalog _entries = new([]);
+
+    [SetUp]
+    public void SetUp()
+    {
+        _root = Path.Combine(Path.GetTempPath(), "galnet-export-preparation-" + Guid.NewGuid().ToString("N"));
+        Put("Graph/graph.json", """{"version":2,"name":"Game","rootNodeId":"","nodes":[],"edges":[],"playerVariables":[],"saveVariables":[]}""");
+        Put("Assets/pose.png", "sprite bytes");
+        Put("Assets/pose.png.meta", """{"id":"pose","type":"sprite"}""");
+        Put("Assets/character.variants", """{"version":1,"folder":".","default":"pose"}""");
+        Put("Assets/character.variants.meta", """{"id":"character","type":"image-variants"}""");
+        Put("settings.json", """{"version":1,"sections":{"galnet.packaging":{"version":1,"data":{"includeResources":["character"]}}}}""");
+    }
+
+    [TearDown] public void TearDown() => Directory.Delete(_root, true);
+
+    [Test]
+    public async Task DirectoryAndArchiveExportsContainIdenticalCompiledPayloads()
+    {
+        var types = BuiltinResourceTypes.CreateCatalog();
+        var gallery = BuiltinGalleryTypes.CreateCatalog(types);
+        var directory = await GamePackageExporter.ExportDirectoryAsync("id", "Game", Project, Path.Combine(_root, "directory"), types, gallery, _entries);
+        var package = await GamePackageExporter.ExportAsync("id", "Game", Project, Path.Combine(_root, "packages"), types, gallery, _entries);
+        Assert.That(directory.Success, Is.True, directory.Error);
+        Assert.That(package.Success, Is.True, package.Error);
+        using var zip = ZipFile.OpenRead(package.PackagePath!);
+        Assert.That(zip.Entries.All(item => item.FullName.StartsWith("pak/", StringComparison.Ordinal)), Is.True);
+        foreach (var item in zip.Entries.Where(item => item.Name.Length > 0))
+        {
+            using var input = item.Open();
+            using var bytes = new MemoryStream();
+            await input.CopyToAsync(bytes);
+            Assert.That(File.ReadAllBytes(Path.Combine(directory.ContentDirectory!, item.FullName[4..])), Is.EqualTo(bytes.ToArray()), item.FullName);
+        }
+        var extracted = Path.Combine(_root, "extracted");
+        ZipFile.ExtractToDirectory(package.PackagePath!, extracted);
+        var installed = await GalpakInstaller.InstallAsync(package.PackagePath!, Path.Combine(_root, "installed", "pak"));
+        Assert.That(Directory.Exists(Path.Combine(installed, "pak")), Is.False);
+        var extractedContent = await GameInstallation.OpenAsync(Path.Combine(extracted, "pak"));
+        var installedContent = await GameInstallation.OpenAsync(installed);
+        var descriptor = InstalledGameDescriptor.Read(installed);
+        foreach (var root in new[] { directory.ContentDirectory!, Path.Combine(extracted, "pak"), installed })
+        {
+            Assert.That(Directory.GetFiles(root, "*.json", SearchOption.AllDirectories), Is.Empty);
+            foreach (var relative in PackedGameDocuments.ExtensionDirectories(descriptor.BuildId))
+                Assert.That(Directory.Exists(Path.Combine(root, relative)), Is.True, relative);
+        }
+        Assert.That((await extractedContent.CreateContentProvider(types, gallery).LoadAsync()).Graph.ContentBuildId,
+            Is.EqualTo((await installedContent.CreateContentProvider(types, gallery).LoadAsync()).Graph.ContentBuildId));
+        Assert.That(await GalpakInstaller.InstallAsync(package.PackagePath!, installed), Is.EqualTo(installed));
+        using var archive = Archive.Deserialize("assets", File.ReadAllBytes(Path.Combine(directory.ContentDirectory!, "Assets/Paks/000-base.pak")), types);
+        var variants = ImageVariantsCodec.Decode(archive.GetAsset("character")!.ReadAllBytes());
+        Assert.That(variants.Default.AssetId, Is.EqualTo("pose"));
+    }
+
+    [Test]
+    public async Task InvalidStagedAssetsPreserveExistingBuildAndPackageAndDoNotPublishDirectory()
+    {
+        Put("Assets/character.variants", """{"version":1,"folder":"../escape","default":"pose"}""");
+        var types = BuiltinResourceTypes.CreateCatalog();
+        var gallery = BuiltinGalleryTypes.CreateCatalog(types);
+        var output = Path.Combine(_root, "build");
+        Directory.CreateDirectory(output);
+        File.WriteAllText(Path.Combine(output, "sentinel"), "keep");
+        Assert.ThrowsAsync<InvalidDataException>(() => new ProjectContentBuilder(_entries, types).BuildAsync(Project, output));
+        var packages = Path.Combine(_root, "packages");
+        Directory.CreateDirectory(packages);
+        File.WriteAllText(Path.Combine(packages, "Game.galpak"), "previous");
+        var package = await GamePackageExporter.ExportAsync("id", "Game", Project, packages, types, gallery, _entries);
+        var directory = await GamePackageExporter.ExportDirectoryAsync("id", "Game", Project, Path.Combine(_root, "directory"), types, gallery, _entries);
+        Assert.That(package.Success, Is.False);
+        Assert.That(directory.Success, Is.False);
+        Assert.That(File.ReadAllText(Path.Combine(output, "sentinel")), Is.EqualTo("keep"));
+        Assert.That(File.ReadAllText(Path.Combine(packages, "Game.galpak")), Is.EqualTo("previous"));
+        Assert.That(Directory.Exists(Path.Combine(_root, "directory")), Is.False);
+        Assert.That(Directory.GetDirectories(_root, ".*.build-*"), Is.Empty);
+    }
+
+    [Test]
+    public async Task SingleGraphAndGroupsAreAddressableWithoutLooseRuntimeStoryFiles()
+    {
+        Put("Graph/graph.json", """{"version":2,"name":"Game","rootNodeId":"main","nodes":[{"id":"main","type":"Group","name":"Chapter","file":"groups/main.rawgalgroup"}],"edges":[],"playerVariables":[],"saveVariables":[]}""");
+        Put("Graph/groups/main.rawgalgroup", """{"version":2,"kind":"Raw","entries":[]}""");
+        var types = BuiltinResourceTypes.CreateCatalog();
+        var gallery = BuiltinGalleryTypes.CreateCatalog(types);
+        var directory = await GamePackageExporter.ExportDirectoryAsync("id", "Game", Project, Path.Combine(_root, "runtime"), types, gallery, _entries);
+        Assert.That(directory.Success, Is.True, directory.Error);
+        var installed = directory.ContentDirectory!;
+        Assert.That(Directory.Exists(Path.Combine(installed, "Graph")), Is.False);
+        Assert.That(File.Exists(Path.Combine(installed, PackedGameDocuments.GameFileName)), Is.True);
+        using (var assets = new AssetManager((await GameInstallation.OpenAsync(installed)).CreateAssetProviders(types)))
+        {
+            Assert.That((await assets.GetFileAsync(StoryResourceIds.Graph))!.TypeId, Is.EqualTo("graph"));
+            Assert.That((await assets.GetFileAsync(StoryResourceIds.Group("main")))!.TypeId, Is.EqualTo("group"));
+        }
+        var content = await new InstalledGameContentProvider(installed, types, gallery).LoadAsync();
+        Assert.That(content.Graph.Id, Is.EqualTo(StoryResourceIds.Graph));
+        Assert.That(content.Graph.RootNodeId, Is.EqualTo("main"));
+        var development = Path.Combine(_root, "development");
+        await new ProjectContentBuilder(_entries, types).BuildAsync(Project, development);
+        var sourceContent = await new ProjectGameContentProvider(development, types, gallery).LoadAsync();
+        Assert.That(sourceContent.Graph.Id, Is.EqualTo(content.Graph.Id));
+        using (var assets = new AssetManager((await GameInstallation.OpenAsync(development)).CreateAssetProviders(types)))
+            Assert.That((await assets.GetFileAsync(StoryResourceIds.Group("main")))!.TypeId, Is.EqualTo("group"));
+        File.Delete(Path.Combine(installed, "Assets/Paks/000-base.pak"));
+        Directory.CreateDirectory(Path.Combine(installed, "Graph"));
+        File.WriteAllText(Path.Combine(installed, "Graph/graph.json"), File.ReadAllText(Path.Combine(Project, "Graph/graph.json")));
+        Assert.ThrowsAsync<InvalidDataException>(() => new InstalledGameContentProvider(installed, types, gallery).LoadAsync());
+    }
+
+    private void Put(string relative, string text)
+    {
+        var path = Path.Combine(Project, relative);
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        File.WriteAllText(path, text);
+    }
+}
diff --git a/test/GalNet.IntegrationTests/ExternalSampleDebugTests.cs b/test/GalNet.IntegrationTests/ExternalSampleDebugTests.cs
index dfae4f26..9c849cd1 100644
--- a/test/GalNet.IntegrationTests/ExternalSampleDebugTests.cs
+++ b/test/GalNet.IntegrationTests/ExternalSampleDebugTests.cs
@@ -91,22 +91,26 @@ await File.WriteAllTextAsync(Path.Combine(root, "Graph", "groups", "main.rawgalg
                 var locale = new Variable { Name = PlayerPreferences.LocaleVariable }; locale.SetValue("zh-CN");
                 await store.SaveAsync(new Dictionary<string, Variable> { [count.Name] = count, [locale.Name] = locale });
             }
-            var contract = Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(File.ReadAllBytes(typeof(GalNet.Project.Contracts.ProjectSchemas).Assembly.Location)));
+            var appHost = TestContext.Parameters.Get("SampleAppHost", "");
+            var contractPath = string.IsNullOrEmpty(appHost) ? typeof(GalNet.Project.Contracts.ProjectSchemas).Assembly.Location
+                : Path.Combine(Path.GetDirectoryName(appHost)!, "lib", "GalNet.Project.Contracts.dll");
+            var contract = Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(File.ReadAllBytes(contractPath)));
             using var listener = new DebugListener(new("sample-test", DebugContentIdentity.Compute(content), contract));
             var invitation = listener.Invitation;
             using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(45));
             var accept = listener.AcceptAsync(timeout.Token);
             var assembly = typeof(GalNet.Sample.Avalonia.App).Assembly.Location;
-            var start = new ProcessStartInfo("dotnet")
+            var start = new ProcessStartInfo(string.IsNullOrEmpty(appHost) ? "dotnet" : appHost)
             {
                 UseShellExecute = false,
                 CreateNoWindow = true,
                 WindowStyle = ProcessWindowStyle.Hidden,
                 RedirectStandardOutput = true,
                 RedirectStandardError = true,
-                WorkingDirectory = Path.GetDirectoryName(assembly)!
+                WorkingDirectory = Path.GetDirectoryName(string.IsNullOrEmpty(appHost) ? assembly : appHost)!
             };
-            foreach (var arg in new[] { assembly, content, "--profile", profile, "--debug-port", invitation.Port.ToString(CultureInfo.InvariantCulture),
+            if (string.IsNullOrEmpty(appHost)) start.ArgumentList.Add(assembly);
+            foreach (var arg in new[] { content, "--profile", profile, "--debug-port", invitation.Port.ToString(CultureInfo.InvariantCulture),
                 "--debug-token", invitation.Token, "--debug-session", invitation.SessionId, "--debug-project", invitation.Identity.ProjectId,
                 "--debug-contract", invitation.Identity.ContractFingerprint! }) start.ArgumentList.Add(arg);
             app = Process.Start(start)!;
@@ -159,11 +163,15 @@ async Task<JsonElement> Command(DebugRunInfo run, string method, object? args =
                 catch (Exception error) when (error is OperationCanceledException or IOException) { }
             });
             await Task.Delay(300, timeout.Token);
-            app.CloseMainWindow();
+            app.Refresh();
+            NativeSampleWindow.Close(app);
             try { await app.WaitForExitAsync(timeout.Token).WaitAsync(TimeSpan.FromSeconds(5)); }
             catch (TimeoutException)
             {
-                TestContext.Out.WriteLine(await File.ReadAllTextAsync(Directory.GetFiles(Path.Combine(profile, "logs"), "game-*.log").Single()));
+                await using var log = new FileStream(Directory.GetFiles(Path.Combine(profile, "logs"), "game-*.log").Single(),
+                    FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
+                using var reader = new StreamReader(log);
+                TestContext.Out.WriteLine(await reader.ReadToEndAsync());
                 throw;
             }
             finally { await pollingCancellation.CancelAsync(); await polling; }
diff --git a/test/GalNet.IntegrationTests/GalNet.IntegrationTests.csproj b/test/GalNet.IntegrationTests/GalNet.IntegrationTests.csproj
index 3f90213f..4907fe14 100644
--- a/test/GalNet.IntegrationTests/GalNet.IntegrationTests.csproj
+++ b/test/GalNet.IntegrationTests/GalNet.IntegrationTests.csproj
@@ -1,6 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
+    <EnableGameDebugging Condition="'$(EnableGameDebugging)' == '' And '$(Configuration)' == 'Debug'">true</EnableGameDebugging>
+    <EnableGameDebugging Condition="'$(EnableGameDebugging)' == ''">false</EnableGameDebugging>
+    <DefineConstants Condition="'$(EnableGameDebugging)' == 'true'">$(DefineConstants);GALNET_GAME_DEBUG</DefineConstants>
+    <EnableLaunchArguments Condition="'$(EnableLaunchArguments)' == ''">$(EnableGameDebugging)</EnableLaunchArguments>
+    <DefineConstants Condition="'$(EnableLaunchArguments)' == 'true'">$(DefineConstants);GALNET_LAUNCH_ARGS</DefineConstants>
+    <NuGetLockFilePath Condition="'$(EnableGameDebugging)' != 'true'">$(MSBuildProjectDirectory)/packages.lock.NoGameDebugging.json</NuGetLockFilePath>
   </PropertyGroup>
 
   <ItemGroup>
@@ -16,4 +22,8 @@
     <ProjectReference Include="..\..\src\Samples\GalNet.Sample.Avalonia\GalNet.Sample.Avalonia.csproj" />
     <ProjectReference Include="..\..\src\Infrastructure\GalNet.Storage.FileSystem\GalNet.Storage.FileSystem.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../src/Shared/GalNet.GameHost/GalNet.GameHost.csproj" /></ItemGroup>
+  <ItemGroup Condition="'$(EnableGameDebugging)' != 'true'">
+    <Compile Remove="ExternalSampleDebugTests.cs;SampleDebugLogStoreTests.cs;SampleDebugSnapshotFactoryTests.cs" />
+  </ItemGroup>
 </Project>
diff --git a/test/GalNet.IntegrationTests/GameEnginePrimitiveDispatchTests.cs b/test/GalNet.IntegrationTests/GameEnginePrimitiveDispatchTests.cs
index 197cf7cd..aa0d3dd5 100644
--- a/test/GalNet.IntegrationTests/GameEnginePrimitiveDispatchTests.cs
+++ b/test/GalNet.IntegrationTests/GameEnginePrimitiveDispatchTests.cs
@@ -1,10 +1,10 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
-using GalNet.Core.Settings;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
@@ -29,15 +29,14 @@ public async Task Video_segment_clicks_preserve_playback_boundary(PlaybackMode m
     {
         var video = new SegmentedVideoPresenter();
         var markers = 0;
-        var settings = new SettingsContainer();
-        settings.Set(new GameSettings { QuickAdvanceIntervalMilliseconds = 0, AutoAdvanceIntervalMilliseconds = 0 });
+        var settings = new PlaybackOptions { QuickAdvanceIntervalMilliseconds = 0, AutoAdvanceIntervalMilliseconds = 0 };
         using var view = new GameRegistration().AddBuiltins(videoPresenter: video)
             .RegisterSchema(new DefaultEntryModule("test", [new DefaultPrimitiveEntryBase("test.mark", DynamicParameterTable.Empty)]))
             .RegisterInstruction("test.mark", context => new ImmediatePrimitiveInstance(() => Interlocked.Increment(ref markers), batchId: context.BatchId))
             .BuildView();
         await using var engine = new GameEngine(GraphWithGroup(
             Primitive("video.play", new { asset = "clip", skipPoints = VideoSkipPoints }),
-            Primitive("test.mark")), view, settings: settings);
+            Primitive("test.mark")), view, playbackOptions: settings);
         await engine.AdvanceAsync();
         for (var index = 0; index < clicks; index++) await engine.AdvanceAsync();
         Assert.That(video.Advances, Is.EqualTo(clicks));
@@ -73,7 +72,7 @@ public async Task RestoreCancelsOldScopeAndIsolatesSceneAndSnapshots()
         snapshot.States["test.layers"] = engine.Runtime.State.Capture()["test.layers"];
         await engine.AdvanceAsync();
 
-        engine.RestoreFrom(snapshot);
+        await engine.RestoreFromAsync(snapshot);
         oldContext!.Runtime.State.Table<Layer>().Clear();
         snapshot.States.Clear();
         var returned = engine.LastStableSnapshot;
@@ -100,7 +99,7 @@ public async Task InvalidSaveVersionDoesNotCancelTheCurrentRun()
         using var engine = new GameEngine(GraphWithGroup(Primitive("test.wait")), view);
         await engine.AdvanceAsync();
 
-        Assert.Throws<InvalidDataException>(() => engine.RestoreFrom(new GalNet.Core.Runtime.GameSnapshot { Version = -1 }));
+        Assert.ThrowsAsync<InvalidDataException>(() => engine.RestoreFromAsync(new GalNet.Core.Runtime.GameSnapshot { Version = -1 }));
         Assert.That(context!.ScopeCancellation.IsCancellationRequested, Is.False);
     }
     [Test]
@@ -404,7 +403,7 @@ public void DispatchFailureIsReportedWithoutSilentlyAdvancing()
         Assert.That(engine.EntryIndex, Is.Zero);
     }
 
-    private static GraphModel GraphWithGroup(params PrimitiveEntry[] entries)
+    private static GraphModel GraphWithGroup(params GalNet.Core.Entry.Entry[] entries)
     {
         var group = new Group { Id = "main" };
         group.Entries.AddRange(entries);
@@ -427,7 +426,7 @@ private static CompositeGameView View(params (string Type, Func<PrimitiveCreateC
             .RegisterSchema(new DefaultEntryModule("test", entries.Select(entry => new DefaultPrimitiveEntryBase(entry.Type, DynamicParameterTable.Empty))))
             .RegisterImplementation(new PrimitiveModule(registry =>
             {
-                registry.State<Layer>("test.layers", layer => layer.Id);
+                registry.State<Layer>("test.layers", layer => layer.Id, keySpace: GalNet.Primitives.Builtins.BuiltinScene.KeySpace);
                 foreach (var entry in entries) registry.Register(entry.Type, entry.Factory);
             }))
             .BuildView();
diff --git a/test/GalNet.IntegrationTests/GameInstallationTests.cs b/test/GalNet.IntegrationTests/GameInstallationTests.cs
index 1fa9b0de..3f6c462d 100644
--- a/test/GalNet.IntegrationTests/GameInstallationTests.cs
+++ b/test/GalNet.IntegrationTests/GameInstallationTests.cs
@@ -3,11 +3,16 @@
 using System.Text.Json;
 using GalNet.Assets;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
+using GalNet.Core.Parameters;
 using GalNet.Core.Serialization;
+using GalNet.Editor.Shared.Commands;
 using GalNet.Editor.Shared.Services;
+using GalNet.GameHost.Content;
 using GalNet.Storage.FileSystem;
 using AssetCompressionMode = GalNet.Core.Assets.CompressionMode;
 
@@ -15,6 +20,8 @@ namespace GalNet.Assets.Tests;
 
 public sealed class GameInstallationTests
 {
+    public sealed class HostOptions { public double SubtitleScale { get; set; } = 1; public int Slots { get; set; } = 60; }
+
     [Test]
     public async Task Exporter_writes_direct_content_and_installed_resources()
     {
@@ -27,39 +34,61 @@ public async Task Exporter_writes_direct_content_and_installed_resources()
         {
             var resourceTypes = BuiltinResourceTypes.CreateCatalog();
             var galleryTypes = BuiltinGalleryTypes.CreateCatalog(resourceTypes);
+            var section = new ConfigurationSection<HostOptions>("host.options", [new("subtitleScale", new ValueDescriptor(typeof(double), allowNull: false)), new("slots", new ValueDescriptor(typeof(int), allowNull: false))]);
+            var configurations = new ProjectConfigurationSchema([DefaultProjectConfiguration.Section, section]);
+            var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
             await File.WriteAllBytesAsync(Path.Combine(project, "Assets", "hero.png"), "hero"u8.ToArray());
             await File.WriteAllTextAsync(Path.Combine(project, "Assets", "hero.png.meta"), """{"id":"hero","type":"sprite","path":"hero.png","filter":"bilinear","compress":"none"}""");
             await File.WriteAllTextAsync(Path.Combine(project, "Graph", "graph.json"), """{"version":2,"name":"export-test","rootNodeId":"","nodes":[],"edges":[],"playerVariables":[],"saveVariables":[]}""");
             await File.WriteAllTextAsync(Path.Combine(project, "settings.json"), """
-                { "audioTracks": [ { "id": "ambient", "bus": "bgm", "defaultGain": 0.3, "maxVoices": 2, "overflowPolicy": "StopOldest" } ] }
+                { "version": 1, "sections": { "galnet.project": { "version": 2, "data": { "audioBuses": [{ "id": "environment", "name": "Environment" }], "audioTracks": [ { "id": "ambient", "busId": "environment", "preserveDuringCatchUp": true, "defaultGain": 0.3, "maxVoices": 2, "overflowPolicy": "StopOldest" } ] } } } }
                 """);
+            var edit = await new ProjectEditService(project, catalog, configurations).ExecuteJsonAsync(
+                """{"commandId":"project.configuration.patch","sectionId":"host.options","values":{"subtitleScale":1.5,"slots":3}}""");
+            Assert.That(edit.Success, Is.True, JsonSerializer.Serialize(edit.Diagnostics));
 
             var development = await GameInstallation.OpenAsync(project);
             Assert.That(development.IsPackaged, Is.False);
             var developmentContent = await development.CreateContentProvider(resourceTypes, galleryTypes).LoadAsync();
             Assert.That(developmentContent.Graph.Name, Is.EqualTo("export-test"));
-            Assert.That(developmentContent.Settings.AudioTracks.Single().Id, Is.EqualTo("ambient"));
+            Assert.That(developmentContent.Configuration.ReadDefaultOptions().AudioTracks.Single().Id, Is.EqualTo("ambient"));
             using (var sourceAssets = new AssetManager(development.CreateAssetProviders(resourceTypes)))
                 Assert.That((await sourceAssets.GetFileAsync("hero"))?.Path, Is.EqualTo("hero.png"));
 
             Directory.CreateDirectory(Path.Combine(project, "I18n", "External", "en-US"));
             await File.WriteAllTextAsync(Path.Combine(project, "I18n", "External", "en-US", "private.json"), "{}");
-            var export = await GamePackageExporter.ExportAsync("project", "Sample", project, output, resourceTypes, galleryTypes, new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules()));
+            var export = await GamePackageExporter.ExportAsync("project", "Sample", project, output, resourceTypes, galleryTypes, catalog, configurations);
             Assert.That(export.Success, Is.True, export.Error);
             using (var packageZip = ZipFile.OpenRead(export.PackagePath!))
                 Assert.That(packageZip.Entries.Any(entry => entry.FullName.StartsWith("I18n/External/", StringComparison.OrdinalIgnoreCase)), Is.False);
 
             var installation = await GameInstallation.OpenAsync(export.PackagePath!);
-            Assert.That(File.Exists(Path.Combine(installation.RootDirectory, "gallery.json")), Is.True);
-            Assert.That(File.Exists(Path.Combine(installation.RootDirectory, "Graph", "graph.json")), Is.True);
+            Assert.That(File.Exists(Path.Combine(installation.RootDirectory, "gallery.json")), Is.False);
+            Assert.That(File.Exists(Path.Combine(installation.RootDirectory, PackedGameDocuments.GameFileName)), Is.True);
+            Assert.That(File.Exists(Path.Combine(installation.RootDirectory, "Graph", "graph.json")), Is.False);
+            Assert.That(File.Exists(Path.Combine(installation.RootDirectory, GameContentManifest.FileName)), Is.False);
             Assert.That(File.Exists(Path.Combine(installation.RootDirectory, "Assets", "Paks", "000-base.pak")), Is.True);
-            var installedContent = await installation.CreateContentProvider(resourceTypes, galleryTypes).LoadAsync();
+            var installedContent = await installation.CreateContentProvider(resourceTypes, galleryTypes,
+                new GameContentLoadOptions { Configurations = configurations }).LoadAsync();
+            Assert.That(installedContent.Configuration.Read(section).SubtitleScale, Is.EqualTo(1.5));
+            var host = new GalNet.Avalonia.GameHost.AvaloniaGameHostOptions
+            {
+                CreateContentCatalogs = () => (resourceTypes, galleryTypes),
+                ConfigureExecution = (_, _, _, _) => { },
+                SelectProjectOptions = configuration => new() { SaveSlotCount = configuration.Read(section).Slots }
+            };
+            using var player = await FilePlayerSession.OpenAsync(Path.Combine(root, "profile"), installedContent.Gallery,
+                host.SelectProjectOptions(installedContent.Configuration).SaveSlotCount);
+            Assert.That(await player.ListSlotsAsync(CancellationToken.None), Has.Count.EqualTo(3));
             Assert.That(installedContent.Graph.Name, Is.EqualTo("export-test"));
-            Assert.That(installedContent.Settings.AudioTracks.Single().DefaultGain, Is.EqualTo(.3f));
-            Assert.That(installedContent.Settings.AudioTracks.Single().OverflowPolicy, Is.EqualTo(GalNet.Core.Audio.AudioOverflowPolicy.StopOldest));
+            Assert.That(installedContent.Configuration.ReadDefaultOptions().AudioBuses.Single().Id, Is.EqualTo("environment"));
+            Assert.That(installedContent.Configuration.ReadDefaultOptions().AudioTracks.Single().BusId, Is.EqualTo("environment"));
+            Assert.That(installedContent.Configuration.ReadDefaultOptions().AudioTracks.Single().PreserveDuringCatchUp, Is.True);
+            Assert.That(installedContent.Configuration.ReadDefaultOptions().AudioTracks.Single().DefaultGain, Is.EqualTo(.3f));
+            Assert.That(installedContent.Configuration.ReadDefaultOptions().AudioTracks.Single().OverflowPolicy, Is.EqualTo(GalNet.Contracts.Builtins.Audio.AudioOverflowPolicy.StopOldest));
 
             using var assets = new AssetManager(installation.CreateAssetProviders(resourceTypes));
-            Assert.That((await assets.GetFileAsync("hero"))?.Path, Is.EqualTo("hero.png"));
+            Assert.That(await assets.GetFileAsync("hero"), Is.Null, "Unused source resources are excluded from the installed build.");
         }
         finally
         {
@@ -76,7 +105,7 @@ public async Task Galpak_installs_loads_content_and_gives_patch_pak_priority()
         {
             var types = BuiltinResourceTypes.CreateCatalog();
             var galleryTypes = BuiltinGalleryTypes.CreateCatalog(types);
-            var baseAssets = PakBuilder.Build("assets", [Asset("hero", "base")], AssetCompressionMode.None, types);
+            var baseAssets = PakBuilder.Build("assets", [Asset("hero", "base")], types, AssetCompressionMode.None);
             var contentFiles = BuildContentFiles(types);
             var packagePath = Path.Combine(root, "sample.galpak");
             await CreatePackageAsync(packagePath, new (string Path, byte[] Data)[]
@@ -91,11 +120,11 @@ public async Task Galpak_installs_loads_content_and_gives_patch_pak_priority()
             Assert.That((await installation.CreateContentProvider(types, galleryTypes).LoadAsync()).Graph.Name, Is.EqualTo("package-test"));
 
             var resourcePaks = Path.Combine(installation.RootDirectory, "Assets", "Paks");
-            await File.WriteAllBytesAsync(Path.Combine(resourcePaks, "100-extra.pak"), PakBuilder.Build("assets", [Asset("hero", "patch")], AssetCompressionMode.None, types));
+            await File.WriteAllBytesAsync(Path.Combine(resourcePaks, "100-extra.pak"), PakBuilder.Build("assets", [Asset("hero", "patch")], types, AssetCompressionMode.None));
 
             using var manager = new AssetManager(installation.CreateAssetProviders(types));
             using var handle = await manager.AcquireAsync<string>("hero");
-            Assert.That(handle?.Value, Is.EqualTo("patch"));
+            Assert.That(handle?.Value, Is.EqualTo("base"), "An undeclared base PAK cannot act as a resource override.");
         }
         finally
         {
@@ -120,15 +149,16 @@ public async Task ReinstallAndRejectedUpdatePreserveExternalTranslations()
             var translation = Path.Combine(external, "third-party.json");
             await File.WriteAllTextAsync(translation, """{"line":"preserved"}""");
             Assert.That(await GalpakInstaller.InstallAsync(package), Is.EqualTo(installed));
-            await CreatePackageAsync(package, files.Append(("settings.json", "{}"u8.ToArray())).ToArray());
+            await CreatePackageAsync(package, files.Append(("settings.json", """{"version":1,"sections":{}}"""u8.ToArray())).ToArray());
             Assert.ThrowsAsync<InvalidOperationException>(() => GalpakInstaller.InstallAsync(package));
             Assert.That(await File.ReadAllTextAsync(translation), Does.Contain("preserved"));
         }
         finally { Directory.Delete(root, true); }
     }
 
-    [Test]
-    public async Task Galpak_rejects_payloads_whose_manifest_hash_does_not_match()
+    [TestCase(1)]
+    [TestCase(2)]
+    public async Task Galpak_rejects_payloads_whose_manifest_hash_does_not_match(int version)
     {
         var root = Path.Combine(Path.GetTempPath(), $"galnet-{Guid.NewGuid():N}");
         Directory.CreateDirectory(root);
@@ -136,17 +166,19 @@ public async Task Galpak_rejects_payloads_whose_manifest_hash_does_not_match()
         {
             var packagePath = Path.Combine(root, "broken.galpak");
             var bytes = "not a pak"u8.ToArray();
-            var manifest = new GalpakManifest(1, "test", "broken", DateTimeOffset.UtcNow,
+            var manifest = new GalpakManifest(version, "test", "broken", DateTimeOffset.UtcNow,
                 [new GalpakFileEntry("Assets/Paks/000-base.pak", new string('0', 64), bytes.Length)]);
+            var prefix = version == 2 ? "pak/" : "";
             await using (var file = File.Create(packagePath))
             using (var zip = new ZipArchive(file, ZipArchiveMode.Create))
             {
-                await WriteEntryAsync(zip, "Assets/Paks/000-base.pak", bytes);
-                await WriteEntryAsync(zip, "broken.galnet", JsonSerializer.SerializeToUtf8Bytes(manifest));
+                await WriteEntryAsync(zip, prefix + "Assets/Paks/000-base.pak", bytes);
+                await WriteEntryAsync(zip, prefix + "broken.galnet", JsonSerializer.SerializeToUtf8Bytes(manifest));
             }
 
             Assert.ThrowsAsync<InvalidDataException>(() => GalpakInstaller.InstallAsync(packagePath));
             Assert.That(Directory.Exists(Path.Combine(root, "broken")), Is.False);
+            Assert.That(Directory.Exists(Path.Combine(root, "pak")), Is.False);
         }
         finally
         {
@@ -154,6 +186,39 @@ public async Task Galpak_rejects_payloads_whose_manifest_hash_does_not_match()
         }
     }
 
+    [TestCase(null)]
+    [TestCase("settings.json")]
+    [TestCase("pak/undeclared.txt")]
+    [TestCase("pak/gallery.json")]
+    [TestCase("pak/../escape.txt")]
+    [TestCase("legacy.galnet")]
+    public async Task Wrapped_package_installs_once_or_rejects_mixed_duplicate_and_undeclared_entries(string? extra)
+    {
+        var root = Path.Combine(Path.GetTempPath(), $"galnet-wrapped-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(root);
+        try
+        {
+            var package = Path.Combine(root, "sample.galpak");
+            await CreatePackageAsync(package, BuildContentFiles(BuiltinResourceTypes.CreateCatalog()), version: 2);
+            if (extra is not null)
+            {
+                using (var zip = ZipFile.Open(package, ZipArchiveMode.Update))
+                    await WriteEntryAsync(zip, extra, "invalid"u8.ToArray());
+                Assert.ThrowsAsync<InvalidDataException>(() => GalpakInstaller.InstallAsync(package));
+                Assert.That(Directory.Exists(Path.Combine(root, "pak")), Is.False);
+            }
+            else
+            {
+                var installed = await GalpakInstaller.InstallAsync(package);
+                Assert.That(installed, Is.EqualTo(Path.Combine(root, "pak")));
+                Assert.That(File.Exists(Path.Combine(installed, "sample.galnet")), Is.True);
+                Assert.That(Directory.Exists(Path.Combine(installed, "pak")), Is.False);
+                Assert.That(await GalpakInstaller.InstallAsync(package), Is.EqualTo(installed));
+            }
+        }
+        finally { Directory.Delete(root, true); }
+    }
+
     private static GameFile Asset(string id, string value) => new(id, "hero.png", "sprite",
         new SpriteAssetMeta { Id = id, TypeId = "sprite", Path = "hero.png" }, System.Text.Encoding.UTF8.GetBytes(value));
 
@@ -161,20 +226,44 @@ public async Task Galpak_rejects_payloads_whose_manifest_hash_does_not_match()
     {
         var galleryTypes = BuiltinGalleryTypes.CreateCatalog(types);
         var gallery = new GalleryConfiguration { Types = galleryTypes.Types.ToList(), Items = [] };
+        var graphMeta = new DependentAssetMeta { Id = StoryResourceIds.Graph, TypeId = "graph", Path = "Story/main.galgraph", DependenciesComplete = true };
+        var graph = new GameFile(graphMeta.Id, graphMeta.Path, graphMeta.TypeId, graphMeta,
+            System.Text.Encoding.UTF8.GetBytes("""{"id":"galnet:graph:main","name":"package-test","rootNodeId":"","nodes":[],"edges":[]}"""));
         return [
-            ("Graph/graph.json", System.Text.Encoding.UTF8.GetBytes("{\"name\":\"package-test\",\"rootNodeId\":\"\",\"nodes\":[],\"edges\":[]}")),
+            (GameContentManifest.FileName, JsonSerializer.SerializeToUtf8Bytes(new GameContentManifest(), JsonSerializerOptions.Web)),
+            ("Assets/Paks/010-story.pak", PakBuilder.Build("assets", [graph], types)),
             ("gallery.json", JsonSerializer.SerializeToUtf8Bytes(gallery))
         ];
     }
 
-    private static async Task CreatePackageAsync(string path, IReadOnlyList<(string Path, byte[] Data)> files)
+    private static async Task CreatePackageAsync(string path, IReadOnlyList<(string Path, byte[] Data)> files, int version = 1)
     {
+        var types = BuiltinResourceTypes.CreateCatalog();
+        var data = files.Where(file => file.Path != GameContentManifest.FileName).ToList();
+        var paks = data.Select((file, index) => (file, index)).Where(item => item.file.Path.EndsWith(".pak", StringComparison.Ordinal)).ToArray();
+        var buildId = new string('a', 64);
+        for (var part = 0; part < paks.Length; part++)
+        {
+            var item = paks[part];
+            using var source = Archive.Deserialize("assets", item.file.Data, types);
+            data[item.index] = (item.file.Path, PakBuilder.Build("assets", source.AssetIds.Select(id => source.GetAsset(id)!).ToArray(), types,
+                descriptor: new() { ProjectId = "test", BuildId = buildId, PartIndex = part, PartCount = paks.Length }));
+        }
+        data.Add((GameContentManifest.FileName, JsonSerializer.SerializeToUtf8Bytes(new GameContentManifest
+        {
+            ProjectId = "test",
+            BuildId = buildId,
+            BasePaks = data.Where(file => file.Path.EndsWith(".pak", StringComparison.Ordinal))
+            .Select(file => new GalpakFileEntry(file.Path, Hash(file.Data), file.Data.LongLength)).ToList()
+        }, JsonSerializerOptions.Web)));
+        files = data;
         var entries = files.Select(file => new GalpakFileEntry(file.Path, Hash(file.Data), file.Data.Length)).ToArray();
-        var manifest = new GalpakManifest(1, "test", "sample", DateTimeOffset.UtcNow, entries);
+        var manifest = new GalpakManifest(version, "test", "sample", DateTimeOffset.UtcNow, entries);
+        var prefix = version == 2 ? "pak/" : "";
         await using var file = File.Create(path);
         using var zip = new ZipArchive(file, ZipArchiveMode.Create, leaveOpen: true);
-        foreach (var entry in files) await WriteEntryAsync(zip, entry.Path, entry.Data);
-        await WriteEntryAsync(zip, "sample.galnet", JsonSerializer.SerializeToUtf8Bytes(manifest));
+        foreach (var entry in files) await WriteEntryAsync(zip, prefix + entry.Path, entry.Data);
+        await WriteEntryAsync(zip, prefix + "sample.galnet", JsonSerializer.SerializeToUtf8Bytes(manifest));
     }
 
     private static async Task WriteEntryAsync(ZipArchive zip, string path, byte[] data)
diff --git a/test/GalNet.IntegrationTests/GameLocalizationLoadingTests.cs b/test/GalNet.IntegrationTests/GameLocalizationLoadingTests.cs
index 5a532093..f91ecb6e 100644
--- a/test/GalNet.IntegrationTests/GameLocalizationLoadingTests.cs
+++ b/test/GalNet.IntegrationTests/GameLocalizationLoadingTests.cs
@@ -1,11 +1,17 @@
 using System.Text.Json;
 using DynamicLocalization.Core;
+using GalNet.Assets;
+using GalNet.Avalonia.GameHost;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Core.Graph;
-using GalNet.Core.Settings;
-using GalNet.Runtime.Content;
+using GalNet.Core.Serialization;
+using GalNet.Editor.Shared.Services;
+using GalNet.GameHost.Content;
 using GalNet.Sample.Avalonia.Services;
 using GalNet.Storage.FileSystem;
 
@@ -38,11 +44,11 @@ public void RecursiveSourcesRespectOrderParentAndGameDefaultFallback()
         var content = new GameContent
         {
             Graph = new(),
-            Settings = new() { TargetLocale = GalNet.Core.I18n.I18nLocale.EnUs },
-            Localization = GameLocalizationLoader.Load(_root, new(), new() { TargetLocale = GalNet.Core.I18n.I18nLocale.EnUs })
+            Configuration = new DefaultProjectOptions { TargetLocale = GalNet.Core.I18n.I18nLocale.EnUs }.ToConfiguration(),
+            Localization = GameLocalizationLoader.Load(_root, new(), "en-US")
         };
         var cultures = new CultureService();
-        using var resolver = new SampleLocalizationService(cultures);
+        using var resolver = new AvaloniaPlayerLocalization(cultures);
         resolver.AttachGame(content);
         cultures.SetCulture("en-US");
         Assert.That(resolver.Resolve("line"), Is.EqualTo("last"));
@@ -67,11 +73,11 @@ public void ExternalSourcesAreSortedAndInvalidFilesDoNotPreventLoading()
         File.WriteAllText(Path.Combine(external, "b.json"), "{broken");
         File.WriteAllText(Path.Combine(external, "c.json"), """{"line":1}""");
         File.WriteAllText(Path.Combine(external, "nested", "z.json"), """{"line":"last"}""");
-        var loaded = GameLocalizationLoader.Load(_root, new(), new());
+        var loaded = GameLocalizationLoader.Load(_root, new());
         Assert.That(loaded.ExternalSources.Select(source => source.RelativePath),
             Is.EqualTo(new[] { "External/en-US/a.json", "External/en-US/nested/z.json" }));
         Assert.That(loaded.Diagnostics, Has.Count.EqualTo(2));
-        using var resolver = new SampleLocalizationService(new CultureService());
+        using var resolver = new AvaloniaPlayerLocalization(new CultureService());
         resolver.AttachGame(new GameContent { Graph = new(), Localization = loaded });
         resolver.ApplyCulture("en-US");
         Assert.That(resolver.Resolve("line"), Is.EqualTo("last"));
@@ -84,15 +90,15 @@ public void SpecificCultureWinsOverLaterParentFileAndInvalidJsonIsRejected()
         Directory.CreateDirectory(Path.Combine(_root, "I18n", "zh"));
         File.WriteAllText(Path.Combine(_root, "I18n", "zh-CN", "main.json"), """{"line":"specific"}""");
         File.WriteAllText(Path.Combine(_root, "I18n", "zh", "main.json"), """{"line":"parent","parentOnly":"inherited"}""");
-        var settings = new ProjectSettings();
-        var content = new GameContent { Graph = new(), Settings = settings, Localization = GameLocalizationLoader.Load(_root, new(), settings) };
-        using var resolver = new SampleLocalizationService(new CultureService());
+        var settings = new ProjectConfiguration();
+        var content = new GameContent { Graph = new(), Configuration = settings, Localization = GameLocalizationLoader.Load(_root, new(), "zh-CN") };
+        using var resolver = new AvaloniaPlayerLocalization(new CultureService());
         resolver.AttachGame(content);
         resolver.ApplyCulture("zh-CN");
         Assert.That(resolver.Resolve("line"), Is.EqualTo("specific"));
         Assert.That(resolver.Resolve("parentOnly"), Is.EqualTo("inherited"));
         File.WriteAllText(Path.Combine(_root, "I18n", "en-US", "invalid.json"), "{broken");
-        Assert.That(() => GameLocalizationLoader.Load(_root, new(), settings),
+        Assert.That(() => GameLocalizationLoader.Load(_root, new(), "zh-CN"),
             Throws.TypeOf<InvalidDataException>().With.Message.Contains("invalid.json"));
     }
 
@@ -103,14 +109,35 @@ public void MissingDefaultKeyAndUnknownCharactersFailDuringContentValidation()
         {
             Nodes = { new Group { Entries = { new PrimitiveEntry("dialogue.text", JsonSerializer.SerializeToElement(new { content = "required", speaker = "" })) } } }
         };
-        Assert.That(() => GameLocalizationLoader.Load(_root, graph, new ProjectSettings()),
+        Assert.That(() => GameLocalizationLoader.Load(_root, graph, "zh-CN"),
             Throws.TypeOf<InvalidDataException>().With.Message.Contains("required"));
         File.WriteAllText(Path.Combine(_root, "I18n", "en-US", "main.json"), """{"required":"Present"}""");
         ((Group)graph.Nodes[0]).Entries[0] = new PrimitiveEntry("dialogue.text", JsonSerializer.SerializeToElement(new { content = "required", speaker = "unknown" }));
-        Assert.That(() => GameLocalizationLoader.Load(_root, graph, new() { TargetLocale = GalNet.Core.I18n.I18nLocale.EnUs }),
+        Assert.That(() => GameLocalizationLoader.Load(_root, graph, "en-US"),
             Throws.TypeOf<InvalidDataException>().With.Message.Contains("unknown"));
     }
 
+    [TestCase("{}")]
+    [TestCase("{\"content\":null,\"speaker\":null}")]
+    [TestCase("{\"content\":\"\",\"speaker\":\"\"}")]
+    [TestCase("{\"content\":\"   \",\"speaker\":\"   \"}")]
+    public void EmptyDialogueNvlAndChoiceTextDoNotRequireLocalizationEntries(string arguments)
+    {
+        var graph = new Graph
+        {
+            Nodes =
+            {
+                new Group { Entries =
+                {
+                    new PrimitiveEntry("dialogue.text", JsonSerializer.Deserialize<JsonElement>(arguments)),
+                    new PrimitiveEntry("nvl.append", JsonSerializer.Deserialize<JsonElement>(arguments))
+                } },
+                new Branch { BranchType = BranchType.Choice, Options = [new() { Text = "" }, new() { Text = "   " }] }
+            }
+        };
+        Assert.That(() => GameLocalizationLoader.Load(_root, graph, "zh-CN"), Throws.Nothing);
+    }
+
     [Test]
     public async Task ProjectAndInstalledProvidersReadEquivalentTextSources()
     {
@@ -124,6 +151,7 @@ public async Task ProjectAndInstalledProvidersReadEquivalentTextSources()
         File.WriteAllText(Path.Combine(_root, "gallery.json"), JsonSerializer.Serialize(
             new GalleryConfiguration { Types = galleries.Types.ToList(), Items = [] }, JsonSerializerOptions.Web));
         var project = await new ProjectGameContentProvider(_root, types, galleries).LoadAsync();
+        PrepareInstalledStory(types);
         var installed = await new InstalledGameContentProvider(_root, types, galleries).LoadAsync();
         Assert.Multiple(() =>
         {
@@ -131,10 +159,57 @@ public async Task ProjectAndInstalledProvidersReadEquivalentTextSources()
             Assert.That(installed.Localization.Characters.GetRequired("guide"), Is.EqualTo(project.Localization.Characters.GetRequired("guide")));
         });
         var cultures = new CultureService();
-        using var resolver = new SampleLocalizationService(cultures);
+        using var resolver = new AvaloniaPlayerLocalization(cultures);
         resolver.AttachGame(installed);
         cultures.SetCulture("zh-CN");
         Assert.That(resolver.Resolve("character.guide.name"), Is.EqualTo("向导"));
-        Assert.That(project.AssetRoot, Is.EqualTo(Path.Combine(_root, "Assets")), "I18n remains outside the asset root.");
+    }
+
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task ConfigurationSchemasAndCultureProjectionAreExplicitAtTheLoadingBoundary(bool installed)
+    {
+        Directory.CreateDirectory(Path.Combine(_root, "Graph"));
+        File.WriteAllText(Path.Combine(_root, "Graph", "graph.json"), """{"nodes":[],"edges":[],"rootNodeId":""}""");
+        File.WriteAllText(Path.Combine(_root, "settings.json"), """
+            {"version":1,"sections":{"galnet.project":{"version":2,"data":{"defaultWidth":0}},"custom":{"version":8,"data":{"flag":true}}}}
+            """);
+        var types = BuiltinResourceTypes.CreateCatalog();
+        var galleries = BuiltinGalleryTypes.CreateCatalog(types);
+        File.WriteAllText(Path.Combine(_root, "gallery.json"), JsonSerializer.Serialize(
+            new GalleryConfiguration { Types = galleries.Types.ToList(), Items = [] }, JsonSerializerOptions.Web));
+        if (installed) PrepareInstalledStory(types);
+        IGameContentProvider Provider(GameContentLoadOptions? options = null) => installed
+            ? new InstalledGameContentProvider(_root, types, galleries, options)
+            : new ProjectGameContentProvider(_root, types, galleries, options);
+        var opaque = await Provider().LoadAsync();
+        Assert.That(opaque.Configuration.Sections["custom"].Version, Is.EqualTo(8));
+        Assert.ThrowsAsync<InvalidDataException>(async () => await Provider(new() { Configurations = DefaultProjectConfiguration.Schema }).LoadAsync());
+        var observed = false;
+        await Provider(new()
+        {
+            SelectDefaultCulture = configuration =>
+            {
+                observed = configuration.Sections["custom"].Data.GetProperty("flag").GetBoolean();
+                return "en-US";
+            }
+        }).LoadAsync();
+        Assert.That(observed, Is.True);
+    }
+
+    private void PrepareInstalledStory(IResourceTypeCatalog types)
+    {
+        Directory.CreateDirectory(Path.Combine(_root, "Assets", "Paks"));
+        var buildId = new string('a', 64);
+        var bytes = PakBuilder.Build("assets", StoryResourceCompiler.Compile(_root, new TargetProfileEntryCatalog([])), types,
+            descriptor: new() { ProjectId = "test", BuildId = buildId });
+        File.WriteAllText(Path.Combine(_root, GameContentManifest.FileName),
+            JsonSerializer.Serialize(new GameContentManifest
+            {
+                ProjectId = "test",
+                BuildId = buildId,
+                BasePaks = [new("Assets/Paks/000-base.pak", CryptoHelper.HashSHA256(bytes), bytes.LongLength)]
+            }, JsonSerializerOptions.Web));
+        File.WriteAllBytes(Path.Combine(_root, "Assets/Paks/000-base.pak"), bytes);
     }
 }
diff --git a/test/GalNet.IntegrationTests/GameTestCaseTests.cs b/test/GalNet.IntegrationTests/GameTestCaseTests.cs
index dde1c338..600cc594 100644
--- a/test/GalNet.IntegrationTests/GameTestCaseTests.cs
+++ b/test/GalNet.IntegrationTests/GameTestCaseTests.cs
@@ -2,12 +2,14 @@
 using GalNet.Assets;
 using GalNet.Assets.Provider;
 using GalNet.Assets.Variants;
+using GalNet.Avalonia.GameHost;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
+using GalNet.Core.Execution;
 using GalNet.Core.Graph;
-using GalNet.Core.Settings;
 using GalNet.Editor.Shared.Commands;
 using GalNet.Editor.Shared.Services;
 using GalNet.Presentation.Abstractions.View;
@@ -20,6 +22,32 @@ namespace GeneralTest.Runtime;
 
 public class GameTestCaseTests
 {
+    [Test]
+    public async Task Default_visual_programs_and_mask_image_survive_export_into_the_resource_package()
+    {
+        var project = Path.Combine(FindRepositoryDirectory(), "GameTestCase");
+        var output = Path.Combine(Path.GetTempPath(), "galnet-visual-export-" + Guid.NewGuid().ToString("N"));
+        try
+        {
+            var types = BuiltinResourceTypes.CreateCatalog();
+            var exported = await GamePackageExporter.ExportDirectoryAsync("visuals", "Visuals", project, output, types,
+                BuiltinGalleryTypes.CreateCatalog(types), new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules()), DefaultProjectConfiguration.Schema);
+            Assert.That(exported.Success, Is.True, exported.Error);
+            var content = await new InstalledGameContentProvider(output, types, BuiltinGalleryTypes.CreateCatalog(types)).LoadAsync();
+            using var assets = new AssetManager([new PakFileProvider(Path.Combine(output, "Assets/Paks/000-base.pak"), "assets", types)]);
+            var programs = content.Configuration.ReadDefaultOptions().DefaultVisualPrograms;
+            Assert.That(programs, Has.Count.EqualTo(8));
+            foreach (var id in programs.Values)
+            {
+                var file = await assets.GetFileAsync(id);
+                Assert.That(file, Is.Not.Null);
+                Assert.That(file!.TypeId, Is.EqualTo("effect-program"));
+            }
+            Assert.That((await assets.GetFileAsync("a1000000000000000000000000000003"))?.TypeId, Is.EqualTo("sprite"));
+        }
+        finally { if (Directory.Exists(output)) Directory.Delete(output, true); }
+    }
+
     [Test]
     public void AuthoringSamplePassesDocumentValidation()
     {
@@ -42,7 +70,7 @@ public async Task LocalizedSmokeGameCompletesBothRoutes(string culture, int rout
             var types = BuiltinResourceTypes.CreateCatalog();
             var content = await new ProjectGameContentProvider(output, types, BuiltinGalleryTypes.CreateCatalog(types)).LoadAsync();
             var cultures = new CultureService();
-            using var localization = new SampleLocalizationService(cultures);
+            using var localization = new AvaloniaPlayerLocalization(cultures);
             localization.AttachGame(content);
             localization.ApplyCulture(culture);
             var presenter = new SmokeTextPresenter(route);
@@ -50,10 +78,9 @@ public async Task LocalizedSmokeGameCompletesBothRoutes(string culture, int rout
             assets.RegisterImageVariantsDecoder();
             var variants = await assets.LoadImageVariantsCatalogAsync();
             await using var view = new GameRegistration().AddBuiltins(presenter, gallery: content.Gallery,
-                nvlPresenter: presenter, characters: content.Localization.Characters, imageVariants: variants).BuildView();
-            var settings = new SettingsContainer();
-            settings.Set(content.Settings);
-            await using var engine = new GameEngine(content.Graph, view, localization, settings, choicePresenter: presenter);
+                nvlPresenter: presenter, characters: content.Localization.Characters, imageVariants: variants,
+                audioConfiguration: new GalNet.Contracts.Builtins.Audio.AudioConfiguration(content.Configuration.ReadDefaultOptions().AudioTracks, content.Configuration.ReadDefaultOptions().AudioBuses)).BuildView();
+            await using var engine = new GameEngine(content.Graph, view, localization, choicePresenter: presenter);
             using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
             await engine.AdvanceAsync(timeout.Token);
             while (engine.State == GameEngineState.Running)
@@ -99,7 +126,7 @@ public async Task SharedSmokeTestBuildsRawContentBeforeLoadingCompiledRuntimeCon
                 Assert.That(groups.Single(group => group.Id == "intro").Entries.OfType<PrimitiveEntry>(),
                     Has.One.Matches<PrimitiveEntry>(entry =>
                         entry.Type == "gallery.unlock" && entry.Arguments.GetProperty("id").GetInt32() == 100));
-                Assert.That(content.Gallery.GetItems("cg"), Has.One.Matches<GalNet.Core.Gallery.GalleryItem>(item =>
+                Assert.That(content.Gallery.GetItems("cg"), Has.One.Matches<GalNet.Contracts.Builtins.Gallery.GalleryItem>(item =>
                     item.Id == 100 && item.ResourceId == "a1000000000000000000000000000001"));
             });
         }
diff --git a/test/GalNet.IntegrationTests/GameTextLocalizationTests.cs b/test/GalNet.IntegrationTests/GameTextLocalizationTests.cs
index 4c7be5e6..5046e7f9 100644
--- a/test/GalNet.IntegrationTests/GameTextLocalizationTests.cs
+++ b/test/GalNet.IntegrationTests/GameTextLocalizationTests.cs
@@ -1,3 +1,4 @@
+using System.Globalization;
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
 using GalNet.Core.Compilation;
@@ -8,6 +9,7 @@
 using GalNet.Core.Services;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
+using GalNet.Runtime.I18n;
 using GalNet.Runtime.Loader;
 using GalNet.Runtime.Runtime;
 
@@ -29,6 +31,7 @@ public void CompositeExpansionAndReorderingPreserveStoredContentKey()
                     Parameters = new()
                     {
                         ["content"] = JsonSerializer.SerializeToElement(key),
+                        ["trackId"] = JsonSerializer.SerializeToElement("vocal"),
                         ["asset"] = JsonSerializer.SerializeToElement("voice")
                     }
                 }
@@ -83,11 +86,32 @@ private sealed class TestResolver : ITextResolver
         };
     }
 
+    [TestCase("")]
+    [TestCase(" \t")]
+    public void EmptyDialogueAndNvlReferencesPresentEmptyText(string empty)
+    {
+        var presenter = new TextPresenter();
+        using var view = new GameRegistration().AddBuiltinSchemas()
+            .AddBuiltinDialogue(presenter).AddBuiltinNvl(presenter).BuildView();
+        var culture = CultureInfo.GetCultureInfo("en-US");
+        var runtime = new GameRuntime(new GameTextResolver([], culture, () => culture));
+        view.Dispatch(new PrimitiveEntry(BuiltinEntryIds.Text,
+            JsonSerializer.SerializeToElement(new { speaker = empty, content = empty })), runtime, CancellationToken.None);
+        view.Dispatch(new PrimitiveEntry(BuiltinEntryIds.AppendNvl,
+            JsonSerializer.SerializeToElement(new { content = empty })), runtime, CancellationToken.None);
+        Assert.Multiple(() =>
+        {
+            Assert.That(presenter.Speaker, Is.Empty);
+            Assert.That(presenter.Dialogue, Is.Empty);
+            Assert.That(presenter.Nvl, Is.Empty);
+        });
+    }
+
     private sealed class TextPresenter : IDialoguePresenter, INvlPresenter
     {
-        public string Speaker { get; private set; } = "";
-        public string Dialogue { get; private set; } = "";
-        public string Nvl { get; private set; } = "";
+        public string Speaker { get; private set; } = "not presented";
+        public string Dialogue { get; private set; } = "not presented";
+        public string Nvl { get; private set; } = "not presented";
         public Task PresentTextAsync(string speaker, string text, CancellationToken cancellationToken)
         {
             Speaker = speaker;
diff --git a/test/GalNet.IntegrationTests/ImageVariantsNativeSampleTests.cs b/test/GalNet.IntegrationTests/ImageVariantsNativeSampleTests.cs
index 79b1cbf3..c98361f5 100644
--- a/test/GalNet.IntegrationTests/ImageVariantsNativeSampleTests.cs
+++ b/test/GalNet.IntegrationTests/ImageVariantsNativeSampleTests.cs
@@ -2,8 +2,9 @@
 using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Nodes;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
 using GalNet.Core.Variable;
 using GalNet.Debugging;
 using GalNet.Editor.Shared.Services;
@@ -132,7 +133,7 @@ async Task Step(int begin, int end) => await peer.RequestAsync("step",
             app.Refresh();
             TestContext.Out.WriteLine(JsonSerializer.Serialize(new
             { nativeWorkingSetBytes = app.WorkingSet64, nativePrivateBytes = app.PrivateMemorySize64, nativePeakWorkingSetBytes = app.PeakWorkingSet64 }));
-            app.CloseMainWindow();
+            NativeSampleWindow.Close(app);
             await app.WaitForExitAsync(timeout.Token).WaitAsync(TimeSpan.FromSeconds(10));
             Assert.That(app.ExitCode, Is.Zero, await stderr);
             TestContext.Out.WriteLine(await stdout);
@@ -141,7 +142,11 @@ async Task Step(int begin, int end) => await peer.RequestAsync("step",
         {
             if (Directory.Exists(root))
                 foreach (var log in Directory.GetFiles(root, "game-*.log", SearchOption.AllDirectories))
-                    TestContext.Out.WriteLine(await File.ReadAllTextAsync(log));
+                {
+                    await using var stream = new FileStream(log, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
+                    using var reader = new StreamReader(stream);
+                    TestContext.Out.WriteLine(await reader.ReadToEndAsync());
+                }
             throw;
         }
         finally
diff --git a/test/GalNet.IntegrationTests/ImageVariantsSampleTests.cs b/test/GalNet.IntegrationTests/ImageVariantsSampleTests.cs
index 2aa73091..a3e83520 100644
--- a/test/GalNet.IntegrationTests/ImageVariantsSampleTests.cs
+++ b/test/GalNet.IntegrationTests/ImageVariantsSampleTests.cs
@@ -4,13 +4,14 @@
 using GalNet.Assets.Provider;
 using GalNet.Assets.Variants;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
-using GalNet.Core.Variants;
 using GalNet.Editor.Shared.Services;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
diff --git a/test/GalNet.IntegrationTests/ModularSaveRestoreTests.cs b/test/GalNet.IntegrationTests/ModularSaveRestoreTests.cs
index 266a7fb9..5bcfa114 100644
--- a/test/GalNet.IntegrationTests/ModularSaveRestoreTests.cs
+++ b/test/GalNet.IntegrationTests/ModularSaveRestoreTests.cs
@@ -3,15 +3,15 @@
 using GalNet.Assets.Provider;
 using GalNet.Assets.Variants;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Assets;
-using GalNet.Core.Audio;
 using GalNet.Core.Compilation;
 using GalNet.Core.Entry;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
 using GalNet.Core.Serialization;
-using GalNet.Presentation.Abstractions.Audio;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
@@ -45,7 +45,8 @@ public async Task ActualSampleAudioAndLayersSaveToANewFileAndRestoreThroughModul
         using var assets = new AssetManager([new LocalFileProvider(Path.Combine(directory.FullName, "GameTestCase", "Assets"), BuiltinResourceTypes.CreateCatalog())]);
         assets.RegisterImageVariantsDecoder();
         var variants = await assets.LoadImageVariantsCatalogAsync();
-        using var registration = new GameRegistration().AddBuiltins(audioHost: host, imageVariants: variants);
+        using var registration = new GameRegistration().AddBuiltins(audioHost: host, imageVariants: variants,
+            audioConfiguration: GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create());
         var compiled = GalgroupCompiler.Compile(commands, registration.BuildCatalog()).Document;
         var group = new Group { Id = "intro" };
         GalgroupLoader.LoadIntoGroupFromContent(group, JsonSerializer.Serialize(compiled));
@@ -63,9 +64,9 @@ public async Task ActualSampleAudioAndLayersSaveToANewFileAndRestoreThroughModul
             }
             var snapshot = await saves.LoadAsync(0);
             Assert.That(snapshot, Is.Not.Null);
-            Assert.That(snapshot!.Version, Is.EqualTo(4));
+            Assert.That(snapshot!.Version, Is.EqualTo(5));
             await using var restored = new GameEngine(graph, view);
-            restored.RestoreFrom(snapshot);
+            await restored.RestoreFromAsync(snapshot);
             await using var restoration = new StateRestoreSession(view);
             await restored.SynchronizePresentationAsync(restoration.RestoreAsync);
             Assert.That(restored.Runtime.State.Table<Layer>().Values.Select(value => value.Id), Is.EquivalentTo(new[] { "background", "teacher" }));
diff --git a/test/GalNet.IntegrationTests/NativeSampleWindow.cs b/test/GalNet.IntegrationTests/NativeSampleWindow.cs
new file mode 100644
index 00000000..d2a0085f
--- /dev/null
+++ b/test/GalNet.IntegrationTests/NativeSampleWindow.cs
@@ -0,0 +1,55 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace GalNet.IntegrationTests;
+
+internal static class NativeSampleWindow
+{
+    public static void Close(Process process)
+    {
+        if (!OperatingSystem.IsWindows())
+        {
+            Assert.That(process.CloseMainWindow(), Is.True);
+            return;
+        }
+
+        // Process.MainWindowHandle can select an untitled native helper window.
+        var windows = new List<nint>();
+        Assert.That(EnumWindows((window, _) =>
+        {
+            GetWindowThreadProcessId(window, out var owner);
+            if (owner != process.Id || !IsWindowVisible(window)) return true;
+            var title = new StringBuilder(512);
+            GetWindowText(window, title, title.Capacity);
+            TestContext.Out.WriteLine($"Process {owner} window {window}: '{title}'.");
+            if (title.ToString().StartsWith("GalNet Avalonia", StringComparison.Ordinal)) windows.Add(window);
+            return true;
+        }, 0), Is.True);
+        Assert.That(windows, Has.Count.EqualTo(1), "Expected the Sample's visible titled window in its own process.");
+        var sampleWindow = windows.Single();
+        Assert.That(PostMessage(sampleWindow, 0x0010, 0, 0), Is.True, "The Sample window must receive WM_CLOSE.");
+        // The exit overlay focuses Cancel; Tab selects Confirm. Queue input on
+        // this owned window after WM_CLOSE, without changing foreground focus.
+        foreach (var key in new[] { 0x09, 0x0D })
+        {
+            Assert.That(PostMessage(sampleWindow, 0x0100, key, 0), Is.True);
+            Assert.That(PostMessage(sampleWindow, 0x0101, key, 0), Is.True);
+        }
+    }
+
+    private delegate bool WindowCallback(nint window, nint parameter);
+    [DllImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool EnumWindows(WindowCallback callback, nint parameter);
+    [DllImport("user32.dll")]
+    private static extern uint GetWindowThreadProcessId(nint window, out uint processId);
+    [DllImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool IsWindowVisible(nint window);
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    private static extern int GetWindowText(nint window, StringBuilder title, int capacity);
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool PostMessage(nint window, uint message, nint wParam, nint lParam);
+}
diff --git a/test/GalNet.IntegrationTests/PackedDocumentTests.cs b/test/GalNet.IntegrationTests/PackedDocumentTests.cs
new file mode 100644
index 00000000..01ea7da2
--- /dev/null
+++ b/test/GalNet.IntegrationTests/PackedDocumentTests.cs
@@ -0,0 +1,221 @@
+using System.Globalization;
+using System.IO.Compression;
+using System.Text;
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Core.Entry;
+using GalNet.Core.I18n;
+using GalNet.Core.Serialization;
+using GalNet.Editor.Shared.Services;
+using GalNet.GameHost.Content;
+using GalNet.Sample.Avalonia;
+using GalNet.Storage.FileSystem;
+
+namespace GalNet.IntegrationTests;
+
+public sealed class PackedDocumentTests
+{
+    private string _root = null!;
+    private string Source => Path.Combine(_root, "source");
+    private string Installed => Path.Combine(_root, "pak");
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);
+
+    [SetUp]
+    public void Setup()
+    {
+        _root = Path.Combine(Path.GetTempPath(), "galnet-packed-" + Guid.NewGuid().ToString("N"));
+        Put(Source, "Graph/graph.json", """{"version":2,"name":"Packed","rootNodeId":"main","nodes":[{"id":"main","name":"Main","type":"Group","file":"groups/main.rawgalgroup"}],"edges":[],"playerVariables":[],"saveVariables":[]}""");
+        Put(Source, "Graph/groups/main.rawgalgroup", """{"version":2,"kind":"Raw","entries":[{"id":"first","type":"dialogue.text","parameters":{"content":"line","speaker":"guide"}}]}""");
+        Put(Source, "settings.json", JsonSerializer.Serialize(new DefaultProjectOptions { TargetLocale = I18nLocale.EnUs, AvailableLocales = [I18nLocale.EnUs] }.ToConfiguration()));
+        Put(Source, "I18n/catalog/characters.json", """[{"id":"guide","displayNameKey":"character.guide.name"}]""");
+        Put(Source, "I18n/en-US/a.json", """{"line":"first","character":{"guide":{"name":"Guide"}},"fallback":"Default","empty":""}""");
+        Put(Source, "I18n/en-US/groups/z.json", """{"line":"last"}""");
+        Put(Source, "I18n/zh/main.json", """{"line":"父语言"}""");
+        Put(Source, "I18n/External/en-US/private.json", "broken external author file must not enter the package");
+        Put(Source, "I18n/en-US/README.txt", "Author notes are not runtime text sources.");
+    }
+
+    [TearDown] public void Cleanup() => Directory.Delete(_root, true);
+
+    private async Task Export()
+    {
+        var types = BuiltinResourceTypes.CreateCatalog();
+        var result = await GamePackageExporter.ExportDirectoryAsync("packed-project", "Packed", Source, Installed, types,
+            BuiltinGalleryTypes.CreateCatalog(types), new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules()), DefaultProjectConfiguration.Schema);
+        Assert.That(result.Success, Is.True, result.Error);
+    }
+
+    private async Task<GameContent> Load()
+    {
+        var types = BuiltinResourceTypes.CreateCatalog();
+        return await (await GameInstallation.OpenAsync(Installed)).CreateContentProvider(types, BuiltinGalleryTypes.CreateCatalog(types),
+            new() { Configurations = DefaultProjectConfiguration.Schema, SelectDefaultCulture = configuration => configuration.ReadDefaultOptions().TargetLocale.Code }).LoadAsync();
+    }
+
+    [Test]
+    public async Task BuiltInDocumentsAndLanguagesArePackedWithDeterministicMerging()
+    {
+        await Export();
+        var packed = PackedGameDocuments.ReadGame(File.ReadAllBytes(Path.Combine(Installed, "game.pak")));
+        Assert.That(packed.Manifest.Version, Is.EqualTo(3));
+        Assert.That(Directory.GetFiles(Installed, "*.json", SearchOption.AllDirectories), Is.Empty);
+        Assert.That(Directory.GetFiles(Installed, "*.galnet", SearchOption.AllDirectories), Is.Empty);
+        var languages = PackedGameDocuments.Read(File.ReadAllBytes(Path.Combine(Installed, "localization.pak")));
+        Assert.That(languages.Documents.Keys, Is.EquivalentTo(new[] { "texts/en-US.json", "texts/zh.json" }));
+        var content = await Load();
+        Assert.That(content.Localization.Sources, Has.Count.EqualTo(2));
+        Assert.That(content.Localization.Characters.GetRequired("guide").DisplayNameKey, Is.EqualTo("character.guide.name"));
+        var culture = CultureInfo.GetCultureInfo("en-US");
+        var resolver = content.Localization.CreateResolver(() => culture);
+        Assert.That(resolver.Resolve("line"), Is.EqualTo("last"));
+        Assert.That(resolver.Resolve("character.guide.name"), Is.EqualTo("Guide"));
+        Assert.That(resolver.Resolve("empty"), Is.Empty);
+        culture = CultureInfo.GetCultureInfo("zh-CN");
+        Assert.That(resolver.Resolve("line"), Is.EqualTo("父语言"));
+        Assert.That(resolver.Resolve("fallback"), Is.EqualTo("Default"));
+        var moved = Path.Combine(_root, "moved");
+        var originalProfile = GameLaunchOptions.GetDefaultProfileDirectory(Installed);
+        Directory.Move(Installed, moved);
+        Assert.That(GameLaunchOptions.GetDefaultProfileDirectory(moved), Is.EqualTo(originalProfile));
+        await Export();
+        Assert.That(File.ReadAllBytes(Path.Combine(Installed, "game.pak")), Is.EqualTo(File.ReadAllBytes(Path.Combine(moved, "game.pak"))));
+        Assert.That(GameLaunchOptions.GetDefaultProfileDirectory(Installed), Is.EqualTo(GameLaunchOptions.GetDefaultProfileDirectory(moved)));
+    }
+
+    [Test]
+    public async Task AuthorJsonWithByteOrderMarksIsNormalizedToPackedUtf8()
+    {
+        foreach (var relative in new[] { "I18n/catalog/characters.json", "I18n/en-US/a.json" })
+        {
+            var path = Path.Combine(Source, relative);
+            var text = File.ReadAllText(path);
+            File.WriteAllText(path, text, relative.EndsWith("a.json", StringComparison.Ordinal) ? new UTF8Encoding(true) : Encoding.Unicode);
+        }
+        await Export();
+        var content = await Load();
+        Assert.That(content.Localization.CreateResolver(() => CultureInfo.GetCultureInfo("en-US")).Resolve("character.guide.name"), Is.EqualTo("Guide"));
+    }
+
+    [Test]
+    public async Task ExternalFilesPartiallyOverrideAddCulturesAndSkipInvalidSources()
+    {
+        await Export();
+        Put(Installed, "I18n/en-US/a.json", """{"line":"external first"}""");
+        Put(Installed, "I18n/en-US/z.json", """{"line":"external last"}""");
+        Put(Installed, "I18n/fr-FR/main.json", """{"line":"Bonjour"}""");
+        Put(Installed, "I18n/en-US/broken.json", "broken JSON");
+        Put(Installed, "I18n/en-US/nonstring.json", """{"line":7}""");
+        var content = await Load();
+        Assert.That(content.Localization.Diagnostics, Has.Count.EqualTo(2));
+        Assert.That(content.Localization.Sources, Has.Count.EqualTo(2));
+        var culture = CultureInfo.GetCultureInfo("en-US");
+        var resolver = content.Localization.CreateResolver(() => culture);
+        Assert.That(resolver.Resolve("line"), Is.EqualTo("external last"));
+        Assert.That(resolver.Resolve("fallback"), Is.EqualTo("Default"));
+        culture = CultureInfo.GetCultureInfo("fr-FR");
+        Assert.That(resolver.Resolve("line"), Is.EqualTo("Bonjour"));
+        Assert.That(resolver.AvailableCultures.Select(item => item.Name), Does.Contain("fr-FR"));
+        Assert.That(content.Localization.Characters.GetRequired("guide").DisplayNameKey, Is.EqualTo("character.guide.name"));
+    }
+
+    [Test]
+    public async Task ExternalTextCannotCompleteAnInvalidBuiltInDefaultLanguage()
+    {
+        await Export();
+        var gamePath = Path.Combine(Installed, "game.pak");
+        var game = PackedGameDocuments.ReadGame(File.ReadAllBytes(gamePath));
+        var languages = PackedGameDocuments.Read(File.ReadAllBytes(Path.Combine(Installed, "localization.pak"))).Documents.ToDictionary();
+        var text = JsonSerializer.Deserialize<Dictionary<string, string>>(languages["texts/en-US.json"])!;
+        text.Remove("line");
+        languages["texts/en-US.json"] = JsonSerializer.SerializeToUtf8Bytes(text);
+        var bytes = PackedGameDocuments.Build(game.Manifest.ProjectId, game.Manifest.BuildId, languages);
+        File.WriteAllBytes(Path.Combine(Installed, "localization.pak"), bytes);
+        var updated = game.Manifest.LocalizationPak! with { Size = bytes.LongLength, Sha256 = CryptoHelper.HashSHA256(bytes) };
+        var documents = game.Documents.Documents.ToDictionary();
+        documents[GameContentManifest.FileName] = JsonSerializer.SerializeToUtf8Bytes(game.Manifest with { LocalizationPak = updated }, JsonOptions);
+        documents[PackedGameDocuments.InstallationPath] = JsonSerializer.SerializeToUtf8Bytes(game.Installation with
+        { Files = game.Installation.Files.Select(file => file.Path == "localization.pak" ? updated : file).ToArray() }, JsonOptions);
+        File.WriteAllBytes(gamePath, PackedGameDocuments.Build(game.Manifest.ProjectId, game.Manifest.BuildId, documents));
+        Put(Installed, "I18n/en-US/complete.json", """{"line":"external cannot repair built-in content"}""");
+        var error = Assert.ThrowsAsync<InvalidDataException>(async () => await Load());
+        Assert.That(error!.Message, Does.Contain("missing required localization key 'line'"));
+    }
+
+    [TestCase("game.pak")]
+    [TestCase("localization.pak")]
+    public async Task CorruptedPackedDocumentsAreRejectedWithoutLegacyFallback(string file)
+    {
+        await Export();
+        var path = Path.Combine(Installed, file);
+        var bytes = File.ReadAllBytes(path);
+        bytes[^1] ^= 1;
+        File.WriteAllBytes(path, bytes);
+        Put(Installed, "settings.json", "{}");
+        Assert.DoesNotThrow(() => GameLaunchOptions.GetDefaultProfileDirectory(Installed));
+        Assert.ThrowsAsync<InvalidDataException>(async () => await Load());
+    }
+
+    [TestCase("identity")]
+    [TestCase("index")]
+    [TestCase("extra")]
+    public async Task InternalDescriptorAndInstallationIndexMustAgree(string change)
+    {
+        await Export();
+        var original = PackedGameDocuments.ReadGame(File.ReadAllBytes(Path.Combine(Installed, "game.pak")));
+        var documents = original.Documents.Documents.ToDictionary();
+        if (change == "index")
+            documents[PackedGameDocuments.InstallationPath] = JsonSerializer.SerializeToUtf8Bytes(original.Installation with { Files = [] }, JsonOptions);
+        else if (change == "extra") documents["unexpected.json"] = "{}"u8.ToArray();
+        var bytes = PackedGameDocuments.Build(change == "identity" ? "another-project" : original.Manifest.ProjectId, original.Manifest.BuildId, documents);
+        Assert.Throws<InvalidDataException>(() => PackedGameDocuments.ReadGame(bytes));
+    }
+
+    [Test]
+    public async Task ArchiveInstallationPreservesEmptyDirectoriesAndExistingExternalTranslation()
+    {
+        var types = BuiltinResourceTypes.CreateCatalog();
+        var result = await GamePackageExporter.ExportAsync("packed-project", "Packed", Source, Path.Combine(_root, "packages"), types,
+            BuiltinGalleryTypes.CreateCatalog(types), new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules()), DefaultProjectConfiguration.Schema);
+        Assert.That(result.Success, Is.True, result.Error);
+        var installed = await GalpakInstaller.InstallAsync(result.PackagePath!);
+        var descriptor = InstalledGameDescriptor.Read(installed);
+        foreach (var directory in PackedGameDocuments.ExtensionDirectories(descriptor.BuildId))
+            Assert.That(Directory.Exists(Path.Combine(installed, directory)), Is.True, directory);
+        var extracted = Path.Combine(_root, "extracted");
+        ZipFile.ExtractToDirectory(result.PackagePath!, extracted);
+        foreach (var directory in PackedGameDocuments.ExtensionDirectories(descriptor.BuildId))
+            Assert.That(Directory.Exists(Path.Combine(extracted, "pak", directory)), Is.True, directory);
+        Put(installed, "I18n/en-US/community.json", """{"line":"preserved"}""");
+        Assert.That(await GalpakInstaller.InstallAsync(result.PackagePath!), Is.EqualTo(installed));
+        Assert.That(File.ReadAllText(Path.Combine(installed, "I18n/en-US/community.json")), Does.Contain("preserved"));
+        var installedGame = Path.Combine(installed, "game.pak");
+        var originalGame = File.ReadAllBytes(installedGame);
+        var damagedGame = originalGame.ToArray();
+        damagedGame[^1] ^= 1;
+        File.WriteAllBytes(installedGame, damagedGame);
+        Assert.ThrowsAsync<InvalidOperationException>(() => GalpakInstaller.InstallAsync(result.PackagePath!));
+        Assert.That(File.ReadAllBytes(installedGame), Is.EqualTo(damagedGame));
+        File.WriteAllBytes(installedGame, originalGame);
+        using (var zip = ZipFile.Open(result.PackagePath!, ZipArchiveMode.Update))
+        {
+            var entry = zip.GetEntry("pak/localization.pak")!;
+            using var stream = entry.Open();
+            stream.Position = stream.Length - 1;
+            var previous = stream.ReadByte();
+            stream.Position--;
+            stream.WriteByte((byte)(previous ^ 1));
+        }
+        Assert.ThrowsAsync<InvalidDataException>(() => GalpakInstaller.InstallAsync(result.PackagePath!, Path.Combine(_root, "broken")));
+        Assert.That(Directory.Exists(Path.Combine(_root, "broken")), Is.False);
+    }
+
+    private static void Put(string root, string path, string text)
+    {
+        var destination = Path.Combine(root, path);
+        Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
+        File.WriteAllText(destination, text);
+    }
+}
diff --git a/test/GalNet.IntegrationTests/ProjectConfigurationCompositionTests.cs b/test/GalNet.IntegrationTests/ProjectConfigurationCompositionTests.cs
new file mode 100644
index 00000000..00d2d884
--- /dev/null
+++ b/test/GalNet.IntegrationTests/ProjectConfigurationCompositionTests.cs
@@ -0,0 +1,90 @@
+using System.Text.Json;
+using Avalonia.Controls;
+using GalNet.Avalonia.GameView.Page;
+using GalNet.Avalonia.GameView.Presentation;
+using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Avalonia.Themes;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Configuration;
+using GalNet.Core.Entry;
+using GalNet.Core.Execution;
+using GalNet.Core.Graph;
+using GalNet.Core.Parameters;
+using GalNet.Core.Primitives;
+using GalNet.Presentation.Abstractions.View;
+using GalNet.Primitives.Builtins;
+using GalNet.Runtime.Engine;
+
+namespace GalNet.IntegrationTests;
+
+[NonParallelizable]
+public sealed class ProjectConfigurationCompositionTests
+{
+    public sealed class ProjectOptions
+    {
+        public int AdvanceDelay { get; set; }
+        public double TextSpeed { get; set; }
+        public float WeatherVolume { get; set; }
+    }
+
+    [Test]
+    public Task OwnDtoDrivesPlaybackTextAndCustomAudioWithoutDefaultSettings() => SampleUiTests.RunAsync(async () =>
+    {
+        var section = new ConfigurationSection<ProjectOptions>("my.project",
+            [new("advanceDelay", new ValueDescriptor(typeof(int))), new("textSpeed", new ValueDescriptor(typeof(double))),
+             new("weatherVolume", new ValueDescriptor(typeof(float)))]);
+        var configuration = new ProjectConfiguration();
+        configuration.Set(section, new() { AdvanceDelay = 0, TextSpeed = 0, WeatherVolume = .35f });
+        configuration = JsonSerializer.Deserialize<ProjectConfiguration>(JsonSerializer.Serialize(configuration))!;
+        var options = configuration.Read(section);
+
+        var state = new GamePageViewModel(null!) { TextSpeed = options.TextSpeed };
+        var page = new GamePage();
+        var root = new Border { Child = page, Classes = { "galnet-player" } };
+        root.Styles.Add(new ClassicTheme().CreateStyles());
+        var window = new Window { Content = root, Width = 640, Height = 360 };
+        window.Show();
+        window.UpdateLayout();
+        try
+        {
+            using var text = new AvaloniaDialoguePresenter(state, page, AvaloniaUiDispatcher.Instance);
+            using var audio = new RecordingAudio();
+            var module = new BuiltinAudioModule(audio, configuration: new AudioConfiguration(
+                [new() { Id = "rain", BusId = "ambience" }], [new() { Id = "ambience" }]));
+            module.ApplyMix(new() { Buses = new Dictionary<string, AudioMixLevel> { ["ambience"] = new(options.WeatherVolume) } });
+            await using var view = new GameRegistration().AddBuiltins(dialoguePresenter: text, audioModule: module).BuildView();
+            var group = new Group
+            {
+                Id = "main",
+                Entries = [
+                    new PrimitiveEntry("audio.play", JsonSerializer.SerializeToElement(new { trackId = "rain", asset = "weather" })) { StableId = "weather" },
+                    new PrimitiveEntry("dialogue.text", JsonSerializer.SerializeToElement(new { content = "Project text" })) { StableId = "line" }]
+            };
+            await using var engine = new GameEngine(new Graph { RootNodeId = group.Id, Nodes = [group] }, view,
+                playbackOptions: new() { AutoAdvanceIntervalMilliseconds = options.AdvanceDelay });
+            var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+            engine.StateChanged += change => { if (change.State == GameEngineState.Completed) completed.TrySetResult(); };
+            await engine.AdvanceAsync();
+            Assert.That(page.Dialogue.CharactersPerSecond, Is.Zero);
+            Assert.That((await audio.Started.Task.WaitAsync(TimeSpan.FromSeconds(2))).Gain, Is.EqualTo(.35f).Within(.00001));
+            await engine.SetPlaybackModeAsync(PlaybackMode.Auto);
+            await completed.Task.WaitAsync(TimeSpan.FromSeconds(1));
+            Assert.That(configuration.Sections.Keys, Is.EqualTo(new[] { "my.project" }));
+        }
+        finally { window.Close(); }
+    });
+
+    private sealed class RecordingAudio : IAudioPlaybackHost
+    {
+        public AudioBackendCapabilities Capabilities { get; } = new(true, true, true);
+        public ISEffectCatalog SEffects => SEffectCatalog.Empty;
+        public event Action<AudioBackendEvent>? EventReceived { add { } remove { } }
+        public TaskCompletionSource<AudioBackendRequest> Started { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public Task ApplyAsync(AudioBackendRequest request, CancellationToken cancellationToken = default)
+        {
+            if (request.Action == AudioBackendAction.Start) Started.TrySetResult(request);
+            return Task.CompletedTask;
+        }
+        public void Dispose() { }
+    }
+}
diff --git a/test/GalNet.IntegrationTests/ProjectContentBuilderTests.cs b/test/GalNet.IntegrationTests/ProjectContentBuilderTests.cs
index 307e9670..0c61e27b 100644
--- a/test/GalNet.IntegrationTests/ProjectContentBuilderTests.cs
+++ b/test/GalNet.IntegrationTests/ProjectContentBuilderTests.cs
@@ -1,8 +1,9 @@
 using System.Text.Json;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Core.Graph;
 using GalNet.Editor.Shared.Services;
 using GalNet.Storage.FileSystem;
@@ -22,6 +23,23 @@ public void TearDown()
         if (Directory.Exists(_root)) Directory.Delete(_root, recursive: true);
     }
 
+    [Test]
+    public async Task BuildReturnsTheSourceMapOfItsActualCompiledFiles()
+    {
+        await WriteProjectAsync("groups/source.rawgalgroup", "opening");
+        var output = Path.Combine(_root, "Output", "Debug");
+        var result = await new ProjectContentBuilder(new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules())).BuildAsync(_root, output);
+        using var compiled = JsonDocument.Parse(await File.ReadAllTextAsync(Path.Combine(output, "Graph", "groups", "opening.galgroup")));
+        var ids = compiled.RootElement.GetProperty("entries").EnumerateArray().Select(entry => entry.GetProperty("id").GetString()).ToArray();
+        Assert.That(result.SourceEntries.SelectMany(entry => entry.PrimitiveIds), Is.EqualTo(ids));
+        Assert.That(result.SourceEntries.First().Start, Is.Zero);
+        Assert.That(result.SourceEntries.Last().End, Is.EqualTo(ids.Length));
+        var signature = result.AuthorSignature;
+        await File.WriteAllTextAsync(Path.Combine(_root, "Graph", "groups", "source.rawgalgroup"), "changed after build");
+        Assert.That(result.AuthorSignature, Is.EqualTo(signature));
+        Assert.That(result.AuthorSignature, Has.Length.EqualTo(64));
+    }
+
     [Test]
     public async Task BuildAsync_RejectsMissingDevelopmentTextBeforeReplacingOutputEvenWhenExternalHasIt()
     {
diff --git a/test/GalNet.IntegrationTests/ProjectSettingsView.axaml b/test/GalNet.IntegrationTests/ProjectSettingsView.axaml
new file mode 100644
index 00000000..a2a6af10
--- /dev/null
+++ b/test/GalNet.IntegrationTests/ProjectSettingsView.axaml
@@ -0,0 +1,10 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="using:GalNet.IntegrationTests"
+             x:Class="GalNet.IntegrationTests.ProjectSettingsView"
+             x:DataType="local:ProjectSettingsPage">
+  <StackPanel>
+    <CheckBox x:Name="Hints" Content="Project hints" IsChecked="{Binding Preferences.ShowHints}" />
+    <Button Content="Apply project settings" Command="{Binding ApplyCommand}" />
+  </StackPanel>
+</UserControl>
diff --git a/test/GalNet.IntegrationTests/PublishedContentTests.cs b/test/GalNet.IntegrationTests/PublishedContentTests.cs
new file mode 100644
index 00000000..f14962e6
--- /dev/null
+++ b/test/GalNet.IntegrationTests/PublishedContentTests.cs
@@ -0,0 +1,26 @@
+using GalNet.Core.Assets;
+using GalNet.Sample.Avalonia;
+using GalNet.Storage.FileSystem;
+
+namespace GalNet.IntegrationTests;
+
+public sealed class PublishedContentTests
+{
+    [TestCase("SelfContained")]
+    [TestCase("FrameworkDependent")]
+    [Explicit("Loads the actual extracted release content; set ReleaseExtractionDirectory in runsettings.")]
+    public async Task IntegratedReleaseLoadsThePackagedGraphAndResources(string deployment)
+    {
+        var extraction = TestContext.Parameters.Get("ReleaseExtractionDirectory", "");
+        Assert.That(extraction, Is.Not.Empty, "Set ReleaseExtractionDirectory to Test-Release.ps1's extraction directory.");
+        var contentRoot = Path.Combine(extraction, deployment, "Sample-GameTestCase", "pak");
+        var catalogs = SampleCustomization.CreateContentCatalogs();
+        using var resources = await GameResourceScope.OpenAsync(contentRoot, catalogs.Resources, catalogs.Gallery,
+            SampleCustomization.CreateHostOptions().Content);
+        Assert.That(resources.Content.Graph.ContentBuildId, Does.Match("^[a-f0-9]{64}$"));
+        Assert.That(resources.Content.Graph.Nodes, Is.Not.Empty);
+        Assert.That((await resources.Assets.GetFileAsync(StoryResourceIds.Graph))?.TypeId, Is.EqualTo("graph"));
+        Assert.That(Directory.Exists(Path.Combine(contentRoot, "Graph")), Is.False);
+        Assert.That(Directory.Exists(Path.Combine(contentRoot, ".galnet")), Is.False);
+    }
+}
diff --git a/test/GalNet.IntegrationTests/ResourceOverrideSaveTests.cs b/test/GalNet.IntegrationTests/ResourceOverrideSaveTests.cs
new file mode 100644
index 00000000..facd41b9
--- /dev/null
+++ b/test/GalNet.IntegrationTests/ResourceOverrideSaveTests.cs
@@ -0,0 +1,100 @@
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Assets.Provider;
+using GalNet.Assets.Variants;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Contracts.Builtins.Variants;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+using GalNet.Core.Entry;
+using GalNet.Core.Graph;
+using GalNet.Core.Primitives;
+using GalNet.Presentation.Abstractions.Execution;
+using GalNet.Presentation.Abstractions.View;
+using GalNet.Primitives.Builtins;
+using GalNet.Runtime.Engine;
+using GalNet.Runtime.Runtime;
+
+namespace GeneralTest.Runtime;
+
+public sealed class ResourceOverrideSaveTests
+{
+    private static readonly IResourceTypeCatalog Types = BuiltinResourceTypes.CreateCatalog();
+    [Test]
+    public async Task InstallingAndRemovingAnAtlasOverrideRebindsSavedSelectionToTheCurrentClothes()
+    {
+        var original = Atlas("atlas-a", "sprite-a"); var replacement = Atlas("atlas-b", "sprite-b");
+        var spriteA = Sprite("sprite-a"); var spriteB = Sprite("sprite-b");
+        var baseline = Sources(PakBuilder.Build("assets", [original, spriteA], Types));
+        var bytes = ResourceOverrideBuilder.Build("project", new ResourceOverrideDefinition { Id = "clothes", Mappings = new() { ["atlas-a"] = "atlas-b" } },
+            [original, spriteA, replacement, spriteB], Types);
+        using var patch = Archive.Deserialize("assets", bytes, Types);
+        var overrideSource = new ResourceOverrideSource(patch.Descriptor, CryptoHelper.HashSHA256(bytes), Sources(bytes));
+        using var baseAssets = new AssetManager([new ResourceOverlayProvider(baseline, [], Types)]);
+        using var patchedAssets = new AssetManager([new ResourceOverlayProvider(baseline, [overrideSource], Types)]);
+        baseAssets.RegisterImageVariantsDecoder(); patchedAssets.RegisterImageVariantsDecoder();
+        var baseCatalog = await baseAssets.LoadImageVariantsCatalogAsync();
+        var patchedCatalog = await patchedAssets.LoadImageVariantsCatalogAsync();
+        using var sourceView = View(new(), baseCatalog);
+        var source = new GameRuntime(null, "root", stateCatalog: sourceView.StateCatalog);
+        sourceView.Dispatch(new PrimitiveEntry("variants.show", JsonSerializer.SerializeToElement(new { handleId = "hero", assetId = "atlas-a" })), source, default);
+        var saved = source.CreateSnapshot();
+        var originalJson = saved.States["builtin.layers"].Payload.GetRawText();
+        var presenter = new Presenter(); using var patchedView = View(presenter, patchedCatalog);
+        var patchedRuntime = new GameRuntime(null, "root", stateCatalog: patchedView.StateCatalog);
+        await using var patchedEngine = new GameEngine(Graph(), patchedRuntime, patchedView);
+        await patchedEngine.RestoreFromAsync(saved);
+        await using var patchedPresentation = new StateRestoreSession(patchedView);
+        await patchedPresentation.RestoreAsync(patchedRuntime);
+        Assert.That(presenter.Last, Is.EqualTo("sprite-b"));
+        Assert.That(patchedRuntime.State.Table<Layer>().Get("hero").Variants!.UsesResourceOverride, Is.True);
+        Assert.That(saved.States["builtin.layers"].Payload.GetRawText(), Is.EqualTo(originalJson), "Rebinding must not mutate the input save.");
+        Assert.That(patchedRuntime.State.Table<Layer>().Get("hero").Variants!.AssetId, Is.EqualTo("atlas-a"));
+        var patchedSave = patchedRuntime.CreateSnapshot();
+        var unpatchedPresenter = new Presenter(); using var unpatchedView = View(unpatchedPresenter, baseCatalog);
+        var unpatched = new GameRuntime(null, "root", stateCatalog: unpatchedView.StateCatalog);
+        await using var unpatchedEngine = new GameEngine(Graph(), unpatched, unpatchedView);
+        await unpatchedEngine.RestoreFromAsync(patchedSave);
+        await using var unpatchedPresentation = new StateRestoreSession(unpatchedView);
+        await unpatchedPresentation.RestoreAsync(unpatched);
+        Assert.That(unpatchedPresenter.Last, Is.EqualTo("sprite-a"));
+        Assert.That(unpatched.State.Table<Layer>().Get("hero").Variants!.UsesResourceOverride, Is.False);
+    }
+    private static Graph Graph() => new() { RootNodeId = "root", Nodes = [new Group { Id = "root" }] };
+    private static CompositeGameView View(Presenter presenter, ImageVariantsCatalog catalog) =>
+        new GameRegistration().RegisterSchema(BuiltinSchemas.CreateLayersModule()).AddBuiltinLayers(presenter, catalog).BuildView();
+    private static IGameFile Sprite(string id)
+    {
+        var meta = new SpriteAssetMeta { Id = id, TypeId = "sprite", Path = id + ".png" };
+        return new GameFile(id, meta.Path, meta.TypeId, meta, [1]);
+    }
+    private static IGameFile Atlas(string id, string sprite)
+    {
+        var definition = ImageVariantsBuilder.Build(new() { Folder = ".", Default = "idle" }, [new("idle.png", sprite)]).Definition!;
+        var meta = new DependentAssetMeta { Id = id, TypeId = "image-variants", Path = id + ".variants", DependenciesComplete = true, Dependencies = [new(sprite, "sprite")] };
+        return new GameFile(id, meta.Path, meta.TypeId, meta, ImageVariantsCodec.Encode(definition));
+    }
+    private static ResourceFileSource[] Sources(byte[] bytes)
+    {
+        var provider = new MemoryProvider(bytes);
+        using var archive = provider.OpenArchive("assets");
+        return archive.AssetIds.Select(id => new ResourceFileSource(archive.GetAsset(id)!, provider)).ToArray();
+    }
+    private sealed class MemoryProvider(byte[] bytes) : IAssetProvider
+    {
+        public string Name => "memory";
+        public bool Exists(string name) => true;
+        public IArchive OpenArchive(string name) => Archive.Deserialize(name, bytes, Types);
+        public Task<IArchive> OpenArchiveAsync(string name, CancellationToken ct = default) => Task.FromResult(OpenArchive(name));
+    }
+    private sealed class Presenter : ILayerPresenter
+    {
+        public string Last { get; private set; } = "";
+        public void ShowLayer(LayerRenderRequest request) => Last = request.AssetId;
+        public void ReplaceLayer(string handleId, string assetId) => Last = assetId;
+        public void HideLayer(string handleId) { }
+        public void MoveLayer(string handleId, LayerTransform transform, float z, float durationSeconds) { }
+    }
+}
diff --git a/test/GalNet.IntegrationTests/SampleBuildModeTests.cs b/test/GalNet.IntegrationTests/SampleBuildModeTests.cs
new file mode 100644
index 00000000..ea90e71f
--- /dev/null
+++ b/test/GalNet.IntegrationTests/SampleBuildModeTests.cs
@@ -0,0 +1,106 @@
+using GalNet.Sample.Avalonia;
+
+namespace GalNet.IntegrationTests;
+
+public sealed class SampleBuildModeTests
+{
+    [Test]
+    public void BuildContainsOnlyTheSelectedDebugCapability()
+    {
+        var assembly = typeof(GameLaunchOptions).Assembly;
+        var debugTypes = assembly.GetTypes().Where(type => type.Namespace == "GalNet.Sample.Avalonia.Debug").ToArray();
+        var references = assembly.GetReferencedAssemblies().Select(reference => reference.Name).ToArray();
+#if GALNET_GAME_DEBUG
+        Assert.That(debugTypes, Is.Not.Empty);
+        Assert.That(references, Does.Contain("GalNet.Debugging"));
+        Assert.That(assembly.GetType("GalNet.Sample.Avalonia.Views.DebugMenuView"), Is.Not.Null);
+        Assert.That(typeof(GameLaunchOptions).GetProperty("DebugInvitation"), Is.Not.Null);
+#else
+        Assert.That(debugTypes, Is.Empty);
+        Assert.That(references, Does.Not.Contain("GalNet.Debugging"));
+        Assert.That(references, Does.Not.Contain("AvaloniaUI.DiagnosticsSupport"));
+        Assert.That(assembly.GetType("GalNet.Sample.Avalonia.Views.DebugMenuView"), Is.Null);
+        Assert.That(assembly.GetType("GalNet.Sample.Avalonia.Views.DebugLogWindow"), Is.Null);
+        Assert.That(typeof(GameLaunchOptions).GetProperty("DebugInvitation"), Is.Null);
+#endif
+    }
+
+#if GALNET_LAUNCH_ARGS
+    [Test]
+    public void DeveloperBuildAcceptsContentAndProfileArguments()
+    {
+        var options = GameLaunchOptions.Parse(["game", "--profile", "profile"]);
+        Assert.That(options.GameDirectory, Is.EqualTo(Path.GetFullPath("game")));
+        Assert.That(options.ProfileDirectory, Is.EqualTo(Path.GetFullPath("profile")));
+    }
+
+#if !GALNET_GAME_DEBUG
+    [Test]
+    public void PlayerBuildRejectsDebugLaunchArguments()
+    {
+        var error = Assert.Throws<ArgumentException>(() => GameLaunchOptions.Parse(["game", "--debug-port", "1234"]));
+        Assert.That(error!.Message, Does.Contain("without game debugging support"));
+    }
+#endif
+#else
+    [TestCase("game")]
+    [TestCase("--profile")]
+    [TestCase("--debug-port")]
+    public void PlayerBuildRejectsLaunchArguments(string argument)
+    {
+        var error = Assert.Throws<ArgumentException>(() => GameLaunchOptions.Parse([argument]));
+        Assert.That(error!.Message, Does.Contain("without launch argument support"));
+    }
+#endif
+
+    [Test]
+    public void DefaultLaunchUsesApplicationPakAndUserDataInsteadOfWorkingDirectory()
+    {
+        var application = Path.Combine(Path.GetTempPath(), "galnet-launch-" + Guid.NewGuid().ToString("N"));
+        var options = GameLaunchOptions.Parse([], application);
+        Assert.That(options.GameDirectory, Is.EqualTo(Path.Combine(application, "pak")));
+        Assert.That(options.ProfileDirectory, Does.StartWith(Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "GalNet") + Path.DirectorySeparatorChar));
+        Assert.That(options.LogDirectory, Is.EqualTo(Path.Combine(options.ProfileDirectory!, "logs")));
+        Assert.That(Directory.Exists(application), Is.False);
+    }
+
+    [Test]
+    public void PackagedProfileFollowsProjectIdentityAcrossMovesAndBuilds()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "galnet-profile-" + Guid.NewGuid().ToString("N"));
+        try
+        {
+            var first = Path.Combine(root, "first", "pak");
+            var second = Path.Combine(root, "second", "pak");
+            Directory.CreateDirectory(first);
+            Directory.CreateDirectory(second);
+            File.WriteAllText(Path.Combine(first, "content.json"), """{"projectId":"../../same-project","buildId":"first"}""");
+            File.WriteAllText(Path.Combine(second, "content.json"), """{"projectId":"../../same-project","buildId":"second"}""");
+            var profile = GameLaunchOptions.GetDefaultProfileDirectory(first);
+            Assert.That(GameLaunchOptions.GetDefaultProfileDirectory(second), Is.EqualTo(profile));
+            Assert.That(Path.GetFileName(profile), Does.Match("^[a-f0-9]{64}$"));
+            File.WriteAllText(Path.Combine(second, "content.json"), """{"projectId":"another-project"}""");
+            Assert.That(GameLaunchOptions.GetDefaultProfileDirectory(second), Is.Not.EqualTo(profile));
+            File.WriteAllText(Path.Combine(second, "content.json"), "broken JSON");
+            Assert.DoesNotThrow(() => GameLaunchOptions.Parse([], Path.GetDirectoryName(second)!));
+            Assert.That(Directory.Exists(profile), Is.False);
+        }
+        finally { Directory.Delete(root, true); }
+    }
+
+    [Test]
+    public void PackagedAssemblyDirectoryResolvesTheRootApphost()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "galnet-app-root-" + Guid.NewGuid().ToString("N"));
+        var library = Path.Combine(root, "lib");
+        Directory.CreateDirectory(library);
+        try
+        {
+            File.WriteAllText(Path.Combine(root, "GalNet.Sample.Avalonia.exe"), "apphost marker");
+            Assert.That(GameLaunchOptions.GetApplicationDirectory(library), Is.EqualTo(root));
+            Assert.That(GameLaunchOptions.GetApplicationDirectory(root), Is.EqualTo(root));
+        }
+        finally { Directory.Delete(root, true); }
+    }
+}
diff --git a/test/GalNet.IntegrationTests/SampleCleanupTests.cs b/test/GalNet.IntegrationTests/SampleCleanupTests.cs
index b73dd27d..cc82ddcb 100644
--- a/test/GalNet.IntegrationTests/SampleCleanupTests.cs
+++ b/test/GalNet.IntegrationTests/SampleCleanupTests.cs
@@ -5,8 +5,8 @@
 using GalNet.Avalonia.GameView.ViewModels;
 using GalNet.Core.Variable;
 using GalNet.GameHost;
+using GalNet.GameHost.Gallery;
 using GalNet.Media.LibVlc;
-using GalNet.Runtime.Gallery;
 using GalNet.Runtime.Persistence;
 using GalNet.Runtime.Variables;
 using GalNet.Sample.Avalonia;
@@ -73,7 +73,7 @@ await SampleUiTests.RunAsync(async () =>
                 var settings = root.GetRequiredService<AvaloniaPlayerSettingsService>();
                 var gameplay = root.GetRequiredService<GamePageViewModel>();
                 var session = new SampleGameSessionService(gameplay, new GamePage(), settings,
-                    root.GetRequiredService<SampleLocalizationService>(), root.GetRequiredService<AvaloniaPlayerStartup>(),
+                    root.GetRequiredService<AvaloniaPlayerLocalization>(), root.GetRequiredService<IPlayerStartup>(),
                     root.GetRequiredService<LibVlcRuntime>(), root);
                 var profile = Path.Combine(directory, "profile");
                 Assert.That(await session.InitializeAsync(new GameLaunchOptions(directory, profile), (_, _) => Task.FromResult<string?>("en-US")), Is.True);
diff --git a/test/GalNet.IntegrationTests/SampleCustomizationTests.cs b/test/GalNet.IntegrationTests/SampleCustomizationTests.cs
index 00b5c288..dedb0c5e 100644
--- a/test/GalNet.IntegrationTests/SampleCustomizationTests.cs
+++ b/test/GalNet.IntegrationTests/SampleCustomizationTests.cs
@@ -11,10 +11,12 @@
 using GalNet.Core.Serialization;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Project.Contracts;
-using GalNet.Runtime.Content;
+using GalNet.GameHost.Content;
 using GalNet.Runtime.Runtime;
 using GalNet.Sample.Avalonia;
+#if GALNET_GAME_DEBUG
 using GalNet.Sample.Avalonia.Debug;
+#endif
 using GalNet.Sample.Avalonia.Presentation;
 using GalNet.Sample.Avalonia.Services;
 using GeneralTest.Integration;
@@ -29,7 +31,7 @@ public sealed class SampleCustomizationTests
     [TestCase(true)]
     public async Task HostCompositionSharesScopedServicesAndReleasesLocalization(bool enableDebug)
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             var services = new ServiceCollection();
@@ -38,17 +40,29 @@ await session.Dispatch<bool>(async () =>
             {
                 await using var first = root.CreateAsyncScope();
                 await using var second = root.CreateAsyncScope();
-                var localization = first.ServiceProvider.GetRequiredService<SampleLocalizationService>();
+                var localization = first.ServiceProvider.GetRequiredService<AvaloniaPlayerLocalization>();
+                GalNet.Avalonia.GameView.MarkupExtensions.PlayerTextExtension.Resolve = localization.GetString;
                 Assert.That(localization.CultureService.AvailableCultures.Select(culture => culture.Name), Does.Contain("en-US"));
-                Assert.That(second.ServiceProvider.GetRequiredService<SampleLocalizationService>(), Is.SameAs(localization));
+                Assert.That(second.ServiceProvider.GetRequiredService<AvaloniaPlayerLocalization>(), Is.SameAs(localization));
                 var settings = first.ServiceProvider.GetRequiredService<AvaloniaPlayerSettingsService>();
                 Assert.That(first.ServiceProvider.GetRequiredService<IPlayerSettingsService>(), Is.SameAs(settings));
                 Assert.That(second.ServiceProvider.GetRequiredService<AvaloniaPlayerSettingsService>().Editors, Is.Not.SameAs(settings.Editors));
                 var game = first.ServiceProvider.GetRequiredService<SampleGameSessionService>();
                 Assert.That(first.ServiceProvider.GetRequiredService<IGameSessionService>(), Is.SameAs(game));
+#if GALNET_GAME_DEBUG
                 Assert.That(first.ServiceProvider.GetService<SampleDebugViewModel>() is not null, Is.EqualTo(enableDebug));
+#endif
+                var window = first.ServiceProvider.GetRequiredService<GalNet.Sample.Avalonia.Views.MainWindow>();
+                window.CompleteStartup();
+#if GALNET_GAME_DEBUG
+                Assert.That(((GalNet.Sample.Avalonia.Views.DebugMenuView)window.LeftContent!).IsVisible, Is.EqualTo(enableDebug));
+#else
+                Assert.That(window.LeftContent, Is.Null);
+#endif
+                window.DetachHostBindings();
+                window.Close();
             }
-            Assert.That(SampleLocalizationService.Current, Is.Null);
+            Assert.That(GalNet.Avalonia.GameView.MarkupExtensions.PlayerTextExtension.Resolve, Is.Null);
             return true;
         }, TestContext.CurrentContext.CancellationToken);
     }
@@ -56,7 +70,7 @@ await session.Dispatch<bool>(async () =>
     [Test]
     public async Task ProjectCompositionExecutesCompiledScreenshotAndDoesNotShareModulesAcrossViews()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
             var catalog = ProjectSchemas.CreateCatalog();
diff --git a/test/GalNet.IntegrationTests/SampleDebugSnapshotFactoryTests.cs b/test/GalNet.IntegrationTests/SampleDebugSnapshotFactoryTests.cs
index 39aa3109..afe94504 100644
--- a/test/GalNet.IntegrationTests/SampleDebugSnapshotFactoryTests.cs
+++ b/test/GalNet.IntegrationTests/SampleDebugSnapshotFactoryTests.cs
@@ -1,5 +1,5 @@
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Core.Variable;
 using GalNet.Sample.Avalonia.Debug;
 using GalVariable = GalNet.Core.Variable.Variable;
@@ -19,6 +19,9 @@ public void ProgressOnly_preserves_the_current_position_and_save_variables_witho
         {
             Assert.That(snapshot.NodeId, Is.EqualTo("chapter-2"));
             Assert.That(snapshot.EntryIndex, Is.EqualTo(7));
+            Assert.That(snapshot.ContentBuildId, Is.EqualTo("packaged-build"));
+            Assert.That(snapshot.StoryPackages, Is.EqualTo(new[] { "extra" }));
+            Assert.That(snapshot.StoryPackages, Is.Not.SameAs(source.StoryPackages));
             Assert.That(snapshot.Variables["score"].AsInt(), Is.EqualTo(42));
             Assert.That(snapshot.Variables["score"], Is.Not.SameAs(source.Variables["score"]));
             Assert.That(BuiltinTestRuntime.State(snapshot).Table<Layer>().Values, Is.Empty);
@@ -53,6 +56,15 @@ private static GameSnapshot CreateSourceSnapshot(int entryIndex)
         runtime.State.Table<Layer>().Add(new Layer { Id = "hero", AssetId = "hero-a" });
         runtime.State.Table<EffectInstance>().Add(new EffectInstance { Id = "blur-1", EffectId = "blur" });
         runtime.State.Table<LoopAnimationState>().Add(new LoopAnimationState { Id = "fade", Request = new AnimationRequest { PlaybackHandleId = "fade" } });
-        return runtime.CreateSnapshot();
+        var snapshot = runtime.CreateSnapshot();
+        return new GameSnapshot
+        {
+            NodeId = snapshot.NodeId,
+            EntryIndex = snapshot.EntryIndex,
+            States = snapshot.States,
+            Variables = snapshot.Variables,
+            ContentBuildId = "packaged-build",
+            StoryPackages = ["extra"]
+        };
     }
 }
diff --git a/test/GalNet.IntegrationTests/SampleDisplaySettingsTests.cs b/test/GalNet.IntegrationTests/SampleDisplaySettingsTests.cs
index c0003cbf..ed367c49 100644
--- a/test/GalNet.IntegrationTests/SampleDisplaySettingsTests.cs
+++ b/test/GalNet.IntegrationTests/SampleDisplaySettingsTests.cs
@@ -1,9 +1,9 @@
 using DynamicLocalization.Core;
 using GalNet.Avalonia.GameHost;
+using GalNet.Avalonia.GameHost.Settings;
 using GalNet.Avalonia.GameView.Services;
 using GalNet.Avalonia.GameView.Settings;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Settings;
 using GalNet.Runtime.Variables;
 using GalNet.Sample.Avalonia.Services;
 using GalNet.Storage.FileSystem;
@@ -22,7 +22,7 @@ private static async Task FullscreenDisablesWindowSizeAndPreferencesRestoreWitho
         var directory = Path.Combine(Path.GetTempPath(), "galnet-display-" + Guid.NewGuid().ToString("N"));
         try
         {
-            using var localization = new SampleLocalizationService(new CultureService());
+            using var localization = new AvaloniaPlayerLocalization(new CultureService());
             using var variables = await PlayerVariableService.CreateAsync(new FilePlayerVariableStore(directory));
             var display = new Display();
             using (var settings = new AvaloniaPlayerSettingsService(localization, new GamePageViewModel(null!), display))
@@ -58,7 +58,7 @@ private static async Task FullscreenDisablesWindowSizeAndPreferencesRestoreWitho
     [Test]
     public async Task FailedModeChangeReportsErrorAndDoesNotPersistAnUnappliedValue()
     {
-        using var localization = new SampleLocalizationService(new CultureService());
+        using var localization = new AvaloniaPlayerLocalization(new CultureService());
         var display = new Display { FailMode = true };
         using var settings = new AvaloniaPlayerSettingsService(localization, new GamePageViewModel(null!), display);
         var mode = settings.Categories.SelectMany(category => category.Items).OfType<ChoiceSetting<PlayerDisplayMode>>().Single();
diff --git a/test/GalNet.IntegrationTests/SampleExtensibilityTests.cs b/test/GalNet.IntegrationTests/SampleExtensibilityTests.cs
new file mode 100644
index 00000000..e2357bdc
--- /dev/null
+++ b/test/GalNet.IntegrationTests/SampleExtensibilityTests.cs
@@ -0,0 +1,219 @@
+using System.Globalization;
+using System.Text.Json;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using CommunityToolkit.Mvvm.Input;
+using DynamicLocalization.Core;
+using GalNet.Avalonia.GameHost;
+using GalNet.Avalonia.GameView.Navigation;
+using GalNet.Avalonia.GameView.Services;
+using GalNet.Avalonia.GameView.Settings;
+using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Execution;
+using GalNet.Core.Variable;
+using GalNet.Game.Controls.Forms;
+using GalNet.Media.LibVlc;
+using GalNet.Runtime.Variables;
+using GalNet.Sample.Avalonia;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GalNet.IntegrationTests;
+
+[NonParallelizable]
+public sealed class SampleExtensibilityTests
+{
+    [Test]
+    public Task ProjectTitleButtonNavigatesToOwnPageAndDefaultCommandCanBeOverridden() => SampleUiTests.RunAsync(async () =>
+    {
+        var services = Services();
+        await using var root = services.BuildServiceProvider();
+        await using var scope = root.CreateAsyncScope();
+        var navigation = scope.ServiceProvider.GetRequiredService<IGameNavigationService>();
+        navigation.ResetTo<TitlePageViewModel>(NavigationTransition.None);
+        var title = (ProjectTitle)navigation.CurrentViewModel!;
+        Assert.That(title, Is.SameAs(scope.ServiceProvider.GetRequiredService<TitlePageViewModel>()));
+        title.OpenNotebookCommand.Execute(null);
+        Assert.That(navigation.CurrentViewModel, Is.TypeOf<ProjectNotebook>());
+        navigation.GoBack();
+        Assert.That(navigation.CurrentViewModel, Is.SameAs(title));
+        title.OpenSettingsCommand.Execute(null);
+        Assert.That(navigation.CurrentViewModel, Is.TypeOf<ProjectNotebook>(), "Inherited RelayCommand dispatches the overridden method.");
+    });
+
+    [Test]
+    public Task HandWrittenXamlUsesOwnModelAndProfileLifecycle() => SampleUiTests.RunAsync(async () =>
+    {
+        var directory = Path.Combine(Path.GetTempPath(), "galnet-extension-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(Path.Combine(directory, "Graph"));
+        await File.WriteAllTextAsync(Path.Combine(directory, "Graph", "graph.json"),
+            """{"version":2,"name":"project","rootNodeId":"main","nodes":[{"id":"main","type":"Branch","branchType":"Condition","conditions":[]}],"edges":[],"playerVariables":[],"saveVariables":[]}""");
+        try
+        {
+            await using var root = Services().BuildServiceProvider();
+            await using var scope = root.CreateAsyncScope();
+            var services = scope.ServiceProvider;
+            var defaults = SampleCustomization.CreateHostOptions();
+            var releases = 0;
+            var runAttaches = 0;
+            var runReleases = 0;
+            var settings = (ProjectSettings)services.GetRequiredService<IAvaloniaPlayerSettings>();
+            var session = new AvaloniaGameSession(new()
+            {
+                CreateContentCatalogs = defaults.CreateContentCatalogs,
+                ConfigureExecution = defaults.ConfigureExecution,
+                Content = defaults.Content,
+                SelectProjectOptions = defaults.SelectProjectOptions,
+                AttachRun = engine =>
+                {
+                    runAttaches++;
+                    Assert.That(engine.State, Is.EqualTo(GalNet.Runtime.Engine.GameEngineState.Ready));
+                    if (runAttaches == 3) throw new IOException("Project attachment failed.");
+                    return new Release(() => runReleases++);
+                },
+                AttachPlayer = context =>
+                {
+                    Assert.That(settings.Attached, Is.True);
+                    Assert.That(context.ProfileDirectory, Is.EqualTo(Path.Combine(directory, "profile")));
+                    return new Release(() => releases++);
+                }
+            }, services.GetRequiredService<GamePageViewModel>(), services.GetRequiredService<GalNet.Avalonia.GameView.Page.GamePage>(),
+                settings, services.GetRequiredService<IPlayerLocalization>(), new SkipStartup(), services.GetRequiredService<LibVlcRuntime>());
+            try
+            {
+                Assert.That(await session.InitializeAsync(directory, Path.Combine(directory, "profile"), (_, _) => Task.FromResult<string?>(null)), Is.True);
+                var navigation = services.GetRequiredService<IGameNavigationService>();
+                navigation.Navigate<SettingsPageViewModel>(NavigationTransition.None);
+                var page = (ProjectSettingsPage)navigation.CurrentViewModel!;
+                var view = (ProjectSettingsView)services.GetRequiredService<IPageViewFactory>().Create(page);
+                Assert.That(view.FindControl<CheckBox>("Hints")!.IsChecked, Is.False);
+                view.FindControl<CheckBox>("Hints")!.IsChecked = true;
+                await page.ApplyCommand.ExecuteAsync(null);
+                Assert.That(settings.Preferences.ShowHints, Is.True);
+                Assert.That(File.ReadAllText(Path.Combine(directory, "profile", "player-variables.json")), Does.Contain("mygame.preferences"));
+                Assert.That(settings.Categories, Is.Empty, "The handwritten page requires no generated DTO fields.");
+                using var reopened = await PlayerVariableService.CreateAsync(new GalNet.Storage.FileSystem.FilePlayerVariableStore(Path.Combine(directory, "profile")));
+                Assert.That(JsonSerializer.Deserialize<ProjectPreferences>(reopened.GetSnapshot(VariableScope.Player)["player.mygame.preferences"].AsString())!.ShowHints, Is.True);
+                await session.PrepareNewGameAsync();
+                await session.PrepareNewGameAsync();
+                Assert.That(runReleases, Is.EqualTo(1), "Replacing a prepared run drains its binding.");
+                await session.StopAsync();
+                Assert.That(runReleases, Is.EqualTo(2));
+                try { await session.PrepareNewGameAsync(); Assert.Fail("Attachment should fail."); }
+                catch (IOException) { }
+                await session.PrepareNewGameAsync();
+            }
+            finally { await session.DisposeAsync(); }
+            Assert.That(releases, Is.EqualTo(1));
+            Assert.That(runAttaches, Is.EqualTo(4));
+            Assert.That(runReleases, Is.EqualTo(3), "Failed attach did not poison the session; async release ran exactly once per binding.");
+            Assert.That(settings.Flushes, Is.GreaterThanOrEqualTo(1));
+        }
+        finally { Directory.Delete(directory, true); }
+    });
+
+    [Test]
+    public void NeutralTextSourcesPreserveCulturePriorityNestedAndEmptyValues()
+    {
+        var culture = CultureInfo.GetCultureInfo("zh-CN");
+        var content = new GalNet.GameHost.Content.GameLocalizationContent
+        {
+            Sources = [new("zh", "parent", """{"nested":{"text":"父语言"},"empty":""}"""), new("en-US", "default", """{"fallback":"default"}""")],
+            ExternalSources = [new("en-US", "external", """{"nested.text":"external default"}""")]
+        };
+        var resolver = content.CreateResolver(() => culture);
+        Assert.That(resolver.Resolve("nested.text"), Is.EqualTo("父语言"));
+        Assert.That(resolver.Resolve("empty"), Is.Empty);
+        Assert.That(resolver.Resolve("fallback"), Is.EqualTo("default"));
+    }
+
+    private static ServiceCollection Services()
+    {
+        var services = new ServiceCollection();
+        services.AddScoped<TitlePageViewModel, ProjectTitle>();
+        services.AddScoped<SettingsPageViewModel, ProjectSettingsPage>();
+        services.AddScoped<ProjectNotebook>();
+        SampleCustomization.ConfigureServices(services, false, views =>
+        {
+            views.Register<ProjectTitle, UserControl>();
+            views.Register<ProjectNotebook, UserControl>();
+            views.Register<ProjectSettingsPage, ProjectSettingsView>();
+        });
+        services.AddScoped<IAvaloniaPlayerSettings, ProjectSettings>();
+        return services;
+    }
+
+    public sealed class ProjectNotebook : PageViewModelBase;
+    public sealed class ProjectTitle : TitlePageViewModel
+    {
+        private readonly IGameNavigationService _navigation;
+        public ProjectTitle(IGameSessionService session, IGameNavigationService navigation, GameLaunchFlow flow, GalleryNavigationService gallery)
+            : base(session, navigation, flow, gallery)
+        {
+            _navigation = navigation;
+            OpenNotebookCommand = new RelayCommand(() => navigation.Navigate<ProjectNotebook>(NavigationTransition.None));
+        }
+        public IRelayCommand OpenNotebookCommand { get; }
+        protected override void OpenSettings() => _navigation.Navigate<ProjectNotebook>(NavigationTransition.None);
+    }
+
+    private sealed class SkipStartup : IPlayerStartup
+    {
+        public Task<bool> InitializeAsync(PlayerVariableService variables, string culture,
+            Func<string, CancellationToken, Task<string?>> select, CancellationToken cancellationToken = default) => Task.FromResult(true);
+    }
+
+    private sealed class Release(Action release) : IDisposable, IAsyncDisposable
+    {
+        public void Dispose() => throw new InvalidOperationException("The host must prefer asynchronous draining.");
+        public async ValueTask DisposeAsync() { await Task.Yield(); release(); }
+    }
+}
+
+public sealed class ProjectPreferences { public bool ShowHints { get; set; } }
+
+public sealed class ProjectSettings : IAvaloniaPlayerSettings
+{
+    private PlayerVariableService? _variables;
+    public ProjectPreferences Preferences { get; private set; } = new();
+    public bool Attached { get; private set; }
+    public int Flushes { get; private set; }
+    public IReadOnlyList<SettingCategory> Categories => [];
+    public EditorRegistry Editors { get; } = EditorRegistry.CreateDefault();
+    public PlaybackOptions PlaybackOptions => new();
+    public AudioMixOptions AudioMix => new();
+    public double TextSpeed => 0;
+    public event Action? SettingsChanged;
+    public Task AttachAsync(PlayerVariableService variables, AudioConfiguration audio, bool tracks, CancellationToken cancellationToken = default)
+    {
+        _variables = variables;
+        Attached = true;
+        if (variables.GetSnapshot(VariableScope.Player).TryGetValue("player.mygame.preferences", out var stored))
+            Preferences = JsonSerializer.Deserialize<ProjectPreferences>(stored.AsString())!;
+        return Task.CompletedTask;
+    }
+    public async Task ApplyAsync()
+    {
+        var value = new Variable { Name = "player.mygame.preferences", Value = VariableValue.From(JsonSerializer.Serialize(Preferences)) };
+        await _variables!.UpdatePlayerVariablesAsync(new Dictionary<string, Variable> { [value.Name] = value });
+        SettingsChanged?.Invoke();
+    }
+    public Task FlushAsync() { Flushes++; return Task.CompletedTask; }
+}
+
+public sealed class ProjectSettingsPage : SettingsPageViewModel
+{
+    public ProjectSettingsPage(IGameNavigationService navigation, IPlayerSettingsService settings) : base(navigation, settings)
+    {
+        var project = (ProjectSettings)settings;
+        Preferences = project.Preferences;
+        ApplyCommand = new AsyncRelayCommand(project.ApplyAsync);
+    }
+    public ProjectPreferences Preferences { get; }
+    public IAsyncRelayCommand ApplyCommand { get; }
+}
+
+public partial class ProjectSettingsView : UserControl
+{
+    public ProjectSettingsView() => AvaloniaXamlLoader.Load(this);
+}
diff --git a/test/GalNet.IntegrationTests/SampleInputSettingsTests.cs b/test/GalNet.IntegrationTests/SampleInputSettingsTests.cs
index 7397c6ff..9b6387f3 100644
--- a/test/GalNet.IntegrationTests/SampleInputSettingsTests.cs
+++ b/test/GalNet.IntegrationTests/SampleInputSettingsTests.cs
@@ -1,8 +1,8 @@
 using DynamicLocalization.Core;
 using GalNet.Avalonia.GameHost;
+using GalNet.Avalonia.GameHost.Settings;
 using GalNet.Avalonia.GameView.Input;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Settings;
 using GalNet.Runtime.Variables;
 using GalNet.Sample.Avalonia.Services;
 using GalNet.Storage.FileSystem;
@@ -20,7 +20,7 @@ await SampleUiTests.RunAsync(async () =>
             var directory = Path.Combine(Path.GetTempPath(), "galnet-input-" + Guid.NewGuid().ToString("N"));
             try
             {
-                using var localization = new SampleLocalizationService(new CultureService());
+                using var localization = new AvaloniaPlayerLocalization(new CultureService());
                 using (var variables = await PlayerVariableService.CreateAsync(new FilePlayerVariableStore(directory)))
                 using (var settings = new AvaloniaPlayerSettingsService(localization, new GamePageViewModel(null!)))
                 {
diff --git a/test/GalNet.IntegrationTests/SampleLocalizationTests.cs b/test/GalNet.IntegrationTests/SampleLocalizationTests.cs
index e1a009a7..b6b53aa9 100644
--- a/test/GalNet.IntegrationTests/SampleLocalizationTests.cs
+++ b/test/GalNet.IntegrationTests/SampleLocalizationTests.cs
@@ -3,10 +3,10 @@
 using DynamicLocalization.Core;
 using DynamicLocalization.Core.Providers;
 using GalNet.Avalonia.GameHost;
+using GalNet.Avalonia.GameHost.Settings;
 using GalNet.Avalonia.GameView.MarkupExtensions;
 using GalNet.Avalonia.GameView.Settings;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Settings;
 using GalNet.Runtime.Variables;
 using GalNet.Sample.Avalonia;
 using GalNet.Sample.Avalonia.Services;
@@ -18,6 +18,28 @@ namespace GalNet.IntegrationTests;
 [NonParallelizable]
 public sealed class SampleLocalizationTests
 {
+    [Test]
+    public void SaveHeadingsAndScreenshotOptionFollowLanguageAndModeChanges()
+    {
+        using var localization = CreateLocalization();
+        var previous = PlayerTextExtension.Resolve;
+        try
+        {
+            PlayerTextExtension.Resolve = localization.GetString;
+            var heading = new PlayerTextBlock { Key = "SaveSlots.SaveTitle", Fallback = "Save game" };
+            Assert.That(heading.Text, Is.EqualTo("Save game"));
+            localization.ApplyCulture("zh-CN");
+            Assert.That(heading.Text, Is.EqualTo("保存进度"));
+            heading.Key = "SaveSlots.LoadTitle";
+            Assert.That(heading.Text, Is.EqualTo("读取存档"));
+            Assert.That(localization.GetString("Screenshot.IncludeUi").Value, Is.EqualTo("包含对话框和操作栏"));
+            localization.ApplyCulture("en-US");
+            Assert.That(heading.Text, Is.EqualTo("Load game"));
+            Assert.That(localization.GetString("Screenshot.IncludeUi").Value, Is.EqualTo("Include dialogue and controls"));
+        }
+        finally { PlayerTextExtension.Resolve = previous; }
+    }
+
     [Test]
     public void SharedLocalizeBindingRefreshesAndPreservesFormatting()
     {
@@ -83,7 +105,7 @@ public async Task InvalidSavedPlaybackPreferencesUseDefaultsWithoutChangingUnrel
             variables.NotifyVariableChanged(GalNet.Core.Variable.VariableScope.Player, badBool.Name, badBool);
             using var settings = new AvaloniaPlayerSettingsService(localization, new GamePageViewModel(null!));
             var runtime = new GameSettings { QuickReadOnly = false, QuickAdvanceIntervalMilliseconds = 3000 };
-            await settings.AttachAsync(variables, runtime);
+            await settings.AttachAsync(variables, runtime, GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create());
             Assert.That(runtime.QuickReadOnly, Is.True);
             Assert.That(runtime.QuickAdvanceIntervalMilliseconds, Is.EqualTo(50));
             Assert.That(variables.GetSnapshot(GalNet.Core.Variable.VariableScope.Player)[badBool.Name].AsString(), Is.EqualTo("false"));
@@ -112,6 +134,41 @@ public void ExistingBindingUpdatesWhenCultureServiceIsChangedDirectly()
     public async Task SettingsPersistAndRestoreWithoutLosingOtherPlayerVariables()
         => await SampleUiTests.RunAsync(SettingsPersistAndRestoreWithoutLosingOtherPlayerVariablesCore);
 
+    [Test]
+    public async Task DeclaredGroupsAndOptionalTracksUseTheSamePreferencesPath()
+        => await SampleUiTests.RunAsync(async () =>
+        {
+            var directory = Path.Combine(Path.GetTempPath(), "galnet-custom-mix-" + Guid.NewGuid().ToString("N"));
+            try
+            {
+                using var localization = CreateLocalization();
+                using var variables = await PlayerVariableService.CreateAsync(new FilePlayerVariableStore(directory));
+                using var settings = new AvaloniaPlayerSettingsService(localization, new GamePageViewModel(null!));
+                var configuration = new GalNet.Contracts.Builtins.Audio.AudioConfiguration(
+                    [new() { Id = "rain/near", BusId = "ambience" }, new() { Id = "wind", BusId = "ambience" }],
+                    [new() { Id = "ambience", Name = "Environment" }]);
+                await settings.AttachAsync(variables, new(), configuration, showTrackControls: true);
+                var items = settings.Categories.Single(category => category.Id == "audio").Items.ToDictionary(item => item.Id);
+                await ((DoubleSetting)items["audio.group.ambience.gain"]).TrySetValueAsync(.4);
+                await ((DoubleSetting)items["audio.track.rain%2Fnear.gain"]).TrySetValueAsync(.6);
+                await ((BoolSetting)items["audio.track.wind.muted"]).TrySetValueAsync(true);
+                await settings.FlushAsync();
+                var restored = new GameSettings();
+                await settings.AttachAsync(variables, restored, configuration);
+                Assert.That(restored.Buses["ambience"].Gain, Is.EqualTo(.4f));
+                Assert.That(restored.Tracks["rain/near"].Gain, Is.EqualTo(.6f));
+                Assert.That(restored.Tracks["wind"].Muted, Is.True);
+                Assert.That(settings.Categories.Single(category => category.Id == "audio").Items.Any(item => item.Id.StartsWith("audio.track.", StringComparison.Ordinal)), Is.False);
+                var empty = new GameSettings();
+                await settings.AttachAsync(variables, empty);
+                Assert.That(empty.Buses, Is.Empty);
+                Assert.That(empty.Tracks, Is.Empty);
+                Assert.That(settings.Categories.Single(category => category.Id == "audio").Items, Has.Count.EqualTo(2));
+                Assert.That(GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create().Buses, Has.Count.EqualTo(3));
+            }
+            finally { if (Directory.Exists(directory)) Directory.Delete(directory, true); }
+        });
+
     private static async Task SettingsPersistAndRestoreWithoutLosingOtherPlayerVariablesCore()
     {
         var directory = Path.Combine(Path.GetTempPath(), "galnet-settings-" + Guid.NewGuid().ToString("N"));
@@ -125,7 +182,7 @@ private static async Task SettingsPersistAndRestoreWithoutLosingOtherPlayerVaria
                 other.SetValue("preserved");
                 variables.NotifyVariableChanged(GalNet.Core.Variable.VariableScope.Player, other.Name, other);
                 var runtime = new GameSettings();
-                await settings.AttachAsync(variables, runtime);
+                await settings.AttachAsync(variables, runtime, GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create());
                 var language = settings.Categories.SelectMany(category => category.Items).OfType<ChoiceSetting<string>>().Single();
                 await language.TrySetValueAsync("zh-CN");
                 var items = settings.Categories.SelectMany(category => category.Items).ToDictionary(item => item.Id);
@@ -134,16 +191,16 @@ private static async Task SettingsPersistAndRestoreWithoutLosingOtherPlayerVaria
                 await ((IntSetting)items["autoInterval"]).TrySetValueAsync(3250);
                 await ((BoolSetting)items["quickReadOnly"]).TrySetValueAsync(false);
                 await ((DoubleSetting)items["masterVolume"]).TrySetValueAsync(.37);
-                await ((BoolSetting)items["voiceMuted"]).TrySetValueAsync(true);
+                await ((BoolSetting)items["audio.group.vocal.muted"]).TrySetValueAsync(true);
                 Assert.That(runtime.QuickReadOnly, Is.False);
-                Assert.That(runtime.VoiceMuted, Is.True);
+                Assert.That(runtime.Buses["vocal"].Muted, Is.True);
                 await settings.FlushAsync();
             }
             using var restoredLocalization = CreateLocalization();
             using var restoredVariables = await PlayerVariableService.CreateAsync(new FilePlayerVariableStore(directory));
             using var restoredSettings = new AvaloniaPlayerSettingsService(restoredLocalization, new GamePageViewModel(null!));
             var restoredRuntime = new GameSettings();
-            await restoredSettings.AttachAsync(restoredVariables, restoredRuntime);
+            await restoredSettings.AttachAsync(restoredVariables, restoredRuntime, GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create());
             Assert.Multiple(() =>
             {
                 Assert.That(restoredLocalization.CultureService.CurrentCulture.Name, Is.EqualTo("zh-CN"));
@@ -153,14 +210,26 @@ private static async Task SettingsPersistAndRestoreWithoutLosingOtherPlayerVaria
                 Assert.That(restoredRuntime.AutoAdvanceIntervalMilliseconds, Is.EqualTo(3250));
                 Assert.That(restoredVariables.GetSnapshot(GalNet.Core.Variable.VariableScope.Player)["player.galnet.settings.quickInterval"].Type, Is.EqualTo(GalNet.Core.Variable.VariableType.Int));
                 Assert.That(restoredRuntime.MasterVolume, Is.EqualTo(.37).Within(.000001));
-                Assert.That(restoredRuntime.VoiceMuted, Is.True);
+                Assert.That(restoredRuntime.Buses["vocal"].Muted, Is.True);
                 Assert.That(restoredVariables.GetSnapshot(GalNet.Core.Variable.VariableScope.Player)["player.other"].AsString(), Is.EqualTo("preserved"));
             });
+
+            await restoredVariables.ResetPlayerVariablesAsync(CancellationToken.None);
+            var defaults = new GameSettings();
+            await restoredSettings.AttachAsync(restoredVariables, defaults, GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create());
+            Assert.Multiple(() =>
+            {
+                Assert.That(restoredSettings.RuntimeSettings, Is.SameAs(defaults));
+                Assert.That(defaults.TextSpeed, Is.EqualTo(30));
+                Assert.That(defaults.MasterVolume, Is.EqualTo(1));
+                Assert.That(defaults.Buses["vocal"].Muted, Is.False);
+                Assert.That(defaults.QuickReadOnly, Is.True);
+            });
         }
         finally { if (Directory.Exists(directory)) Directory.Delete(directory, true); }
     }
 
-    private static SampleLocalizationService CreateLocalization()
+    private static AvaloniaPlayerLocalization CreateLocalization()
     {
         var provider = new JsonLocalizationProvider();
         provider.Initialize(new JsonLocalizationProviderOptions
@@ -172,7 +241,7 @@ private static SampleLocalizationService CreateLocalization()
         var culture = new CultureService();
         culture.RegisterProvider(provider);
         culture.SetCulture("en-US");
-        return new SampleLocalizationService(culture, [provider]);
+        return new AvaloniaPlayerLocalization(culture, [provider]);
     }
 
     [Test]
@@ -183,16 +252,16 @@ public async Task SettingsSnapshotLanguagesAfterContentLoadWithoutWatchingProvid
         {
             using var localization = CreateLocalization();
             using var settings = new AvaloniaPlayerSettingsService(localization, new GamePageViewModel(null!));
-            localization.AttachGame(new GalNet.Runtime.Content.GameContent
+            localization.AttachGame(new GalNet.GameHost.Content.GameContent
             {
                 Graph = new(),
                 Localization = new() { ExternalSources = [new("ja-JP", "external", """{"line":"日本語"}""")] }
             });
             using var variables = await PlayerVariableService.CreateAsync(new FilePlayerVariableStore(directory));
-            await settings.AttachAsync(variables, new GameSettings());
+            await settings.AttachAsync(variables, new GameSettings(), GalNet.Contracts.Builtins.BuiltinAudioDefaults.Create());
             var language = settings.Categories.SelectMany(category => category.Items).OfType<ChoiceSetting<string>>().Single();
             Assert.That(language.Choices.Select(option => option.Value), Does.Contain("ja-JP"));
-            localization.AttachGame(new GalNet.Runtime.Content.GameContent { Graph = new() });
+            localization.AttachGame(new GalNet.GameHost.Content.GameContent { Graph = new() });
             Assert.That(language.Choices.Select(option => option.Value), Does.Contain("ja-JP"), "No runtime provider-change refresh.");
         }
         finally { if (Directory.Exists(directory)) Directory.Delete(directory, true); }
@@ -203,8 +272,8 @@ public void ReplacingGameSourcesPreservesEmbeddedUiProviderAndBinding()
     {
         using var localization = CreateLocalization();
         using var title = new LocalizedString(localization.CultureService, "App.Title");
-        localization.AttachGame(new GalNet.Runtime.Content.GameContent { Graph = new() });
-        localization.AttachGame(new GalNet.Runtime.Content.GameContent { Graph = new() });
+        localization.AttachGame(new GalNet.GameHost.Content.GameContent { Graph = new() });
+        localization.AttachGame(new GalNet.GameHost.Content.GameContent { Graph = new() });
         Assert.That(title.Value, Is.EqualTo("GalNet Avalonia Sample Player"));
         localization.CultureService.SetCulture("zh-CN");
         Assert.That(localization["Debug.Menu"], Is.EqualTo("调试"));
@@ -215,7 +284,7 @@ public void ExternalAndCustomSourcesOverrideUiAndGameWithoutLosingOtherKeys()
     {
         using var localization = CreateLocalization();
         using var title = new LocalizedString(localization.CultureService, "App.Title");
-        var content = new GalNet.Runtime.Content.GameContent
+        var content = new GalNet.GameHost.Content.GameContent
         {
             Graph = new(),
             Localization = new()
@@ -240,7 +309,7 @@ public void ExternalAndCustomSourcesOverrideUiAndGameWithoutLosingOtherKeys()
         localization.ApplyCulture("en-US");
         localization.AttachGame(content, [new("en-US", "custom", """{"line":"custom"}""")]);
         Assert.That(localization.Resolve("line"), Is.EqualTo("custom"));
-        localization.AttachGame(new GalNet.Runtime.Content.GameContent { Graph = new() });
+        localization.AttachGame(new GalNet.GameHost.Content.GameContent { Graph = new() });
         Assert.That(title.Value, Is.EqualTo("GalNet Avalonia Sample Player"));
     }
 
diff --git a/test/GalNet.IntegrationTests/SampleReadTextColorTests.cs b/test/GalNet.IntegrationTests/SampleReadTextColorTests.cs
new file mode 100644
index 00000000..c957152a
--- /dev/null
+++ b/test/GalNet.IntegrationTests/SampleReadTextColorTests.cs
@@ -0,0 +1,98 @@
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.VisualTree;
+using DynamicLocalization.Core;
+using DynamicLocalization.Core.Providers;
+using GalNet.Avalonia.GameHost;
+using GalNet.Avalonia.GameHost.Settings;
+using GalNet.Avalonia.GameView.Settings;
+using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Avalonia.Themes;
+using GalNet.Runtime.Variables;
+using GalNet.Sample.Avalonia;
+using GalNet.Storage.FileSystem;
+
+namespace GalNet.IntegrationTests;
+
+[NonParallelizable]
+public sealed class SampleReadTextColorTests
+{
+    [Test]
+    public async Task CheckboxRevealsRealColorPickerAndPreferencesRestoreWithoutRewriting()
+    {
+        await SampleUiTests.RunAsync(async () =>
+        {
+            var directory = Path.Combine(Path.GetTempPath(), "galnet-read-color-" + Guid.NewGuid().ToString("N"));
+            try
+            {
+                var provider = new JsonLocalizationProvider();
+                provider.Initialize(new JsonLocalizationProviderOptions
+                {
+                    BasePath = "Localization",
+                    UseEmbeddedResources = true,
+                    Assembly = typeof(App).Assembly
+                });
+                var culture = new CultureService();
+                culture.RegisterProvider(provider);
+                culture.SetCulture("en-US");
+                using var localization = new AvaloniaPlayerLocalization(culture, [provider]);
+                using var variables = await PlayerVariableService.CreateAsync(new FilePlayerVariableStore(directory));
+                var game = new GamePageViewModel(null!);
+                using (var settings = new AvaloniaPlayerSettingsService(localization, game))
+                {
+                    await settings.AttachAsync(variables, new GameSettings());
+                    var category = settings.Categories.Single(item => item.Id == "game");
+                    var colorSetting = category.Items.OfType<CustomSetting<string>>().Single(item => item.Id == "readTextColor");
+                    Assert.That(category.DisplayItems.Any(item => item.Id == "enableReadTextColor"), Is.False);
+                    using var editor = colorSetting.CreateEditor();
+                    var root = new Border { Child = editor.Control, Classes = { "galnet-player" } };
+                    root.Styles.Add(new ClassicTheme().CreateStyles());
+                    var window = new Window { Width = 800, Height = 650, Content = root };
+                    window.Styles.Add(new global::Avalonia.Themes.Fluent.FluentTheme());
+                    window.Show();
+                    try
+                    {
+                        window.UpdateLayout();
+                        var checkbox = editor.Control.GetVisualDescendants().OfType<CheckBox>().Single();
+                        var button = editor.Control.GetVisualDescendants().OfType<Button>().Single(control => control.Name == "ReadTextColorPicker");
+                        Assert.That(checkbox.IsChecked, Is.False);
+                        Assert.That(button.IsVisible, Is.False);
+                        Assert.That(game.ReadTextBrush, Is.Null);
+                        checkbox.IsChecked = true;
+                        await settings.FlushAsync();
+                        Assert.That(button.IsVisible, Is.True);
+                        Assert.That(((ISolidColorBrush)game.ReadTextBrush!).Color, Is.EqualTo(Color.Parse("#A8B8C8")));
+                        button.Flyout!.ShowAt(button);
+                        window.UpdateLayout();
+                        var flyout = (Flyout)button.Flyout;
+                        var picker = ((Control)flyout.Content!).GetVisualDescendants().OfType<ColorView>().Single();
+                        Assert.That(picker.Template, Is.Not.Null, "The popup must load the ColorView theme.");
+                        Assert.That(picker.GetVisualDescendants().Count(), Is.GreaterThan(5));
+                        Assert.That(picker.Color, Is.EqualTo(Color.Parse("#A8B8C8")));
+                        var actions = ((StackPanel)flyout.Content!).Children.OfType<StackPanel>().Single().Children.OfType<Button>().ToArray();
+                        Assert.That(actions.Select(control => control.Content), Is.EqualTo(new[] { "Cancel", "Confirm" }));
+                        culture.SetCulture("zh-CN");
+                        Assert.That(actions.Select(control => control.Content), Is.EqualTo(new[] { "取消", "确认" }));
+                        culture.SetCulture("en-US");
+                        Assert.That(actions.Select(control => control.Content), Is.EqualTo(new[] { "Cancel", "Confirm" }));
+                        flyout.Hide();
+                        Assert.That(await colorSetting.TrySetValueAsync("#123456"), Is.True);
+                        Assert.That(((ISolidColorBrush)game.ReadTextBrush!).Color, Is.EqualTo(Color.Parse("#123456")));
+                        Assert.That(await colorSetting.TrySetValueAsync("invalid"), Is.False);
+                        await settings.FlushAsync();
+                    }
+                    finally { window.Close(); }
+                }
+                var stored = await File.ReadAllTextAsync(Path.Combine(directory, "player-variables.json"));
+                var restoredGame = new GamePageViewModel(null!);
+                using var restored = new AvaloniaPlayerSettingsService(localization, restoredGame);
+                await restored.AttachAsync(variables, new GameSettings());
+                Assert.That(restored.RuntimeSettings.EnableReadTextColor, Is.True);
+                Assert.That(restored.RuntimeSettings.ReadTextColor, Is.EqualTo("#123456"));
+                Assert.That(((ISolidColorBrush)restoredGame.ReadTextBrush!).Color, Is.EqualTo(Color.Parse("#123456")));
+                Assert.That(await File.ReadAllTextAsync(Path.Combine(directory, "player-variables.json")), Is.EqualTo(stored));
+            }
+            finally { if (Directory.Exists(directory)) Directory.Delete(directory, true); }
+        });
+    }
+}
diff --git a/test/GalNet.IntegrationTests/SampleSaveSessionTests.cs b/test/GalNet.IntegrationTests/SampleSaveSessionTests.cs
index 01531397..89d9c3b9 100644
--- a/test/GalNet.IntegrationTests/SampleSaveSessionTests.cs
+++ b/test/GalNet.IntegrationTests/SampleSaveSessionTests.cs
@@ -2,7 +2,7 @@
 using GalNet.Core.Graph;
 using GalNet.Core.Runtime;
 using GalNet.Core.Variable;
-using GalNet.Runtime.Content;
+using GalNet.GameHost.Content;
 using GalNet.Runtime.Persistence;
 using GalNet.Storage.FileSystem;
 using GalVariable = GalNet.Core.Variable.Variable;
@@ -11,6 +11,44 @@ namespace GalNet.IntegrationTests;
 
 public sealed class SampleSaveSessionTests
 {
+    [Test]
+    public async Task CustomSlotNameSurvivesOverwriteAndReopeningThePlayer()
+    {
+        var directory = Path.Combine(Path.GetTempPath(), "galnet-save-name-" + Guid.NewGuid().ToString("N"));
+        try
+        {
+            using (var player = await FilePlayerSession.OpenAsync(directory, new GameContent { Graph = new Graph() }.Gallery, maxSlots: 1))
+            {
+                await player.SaveAsync(0, new GameSnapshot { NodeId = "before" }, CancellationToken.None);
+                await player.RenameSlotAsync(0, "再次相遇");
+                await player.SaveAsync(0, new GameSnapshot { NodeId = "after" }, CancellationToken.None);
+            }
+            using var reopened = await FilePlayerSession.OpenAsync(directory, new GameContent { Graph = new Graph() }.Gallery, maxSlots: 1);
+            Assert.That((await reopened.ListSlotsAsync(CancellationToken.None))[0].Description, Is.EqualTo("再次相遇"));
+            Assert.That((await reopened.LoadAsync(0, CancellationToken.None))!.NodeId, Is.EqualTo("after"));
+        }
+        finally { if (Directory.Exists(directory)) Directory.Delete(directory, true); }
+    }
+
+    [Test]
+    public async Task SavePreviewIsStoredAndClearedOnOverwriteWithoutPreview()
+    {
+        var directory = Path.Combine(Path.GetTempPath(), "galnet-preview-" + Guid.NewGuid().ToString("N"));
+        try
+        {
+            using var session = await FilePlayerSession.OpenAsync(directory, new GameContent { Graph = new Graph() }.Gallery,
+                maxSlots: 1, cancellationToken: CancellationToken.None);
+            byte[] preview = [1, 2, 3];
+            await session.SaveAsync(0, new GameSnapshot(), preview, CancellationToken.None);
+            var path = (await session.ListSlotsAsync(CancellationToken.None))[0].PreviewImage;
+            Assert.That(path, Is.Not.Null);
+            Assert.That(await File.ReadAllBytesAsync(path!), Is.EqualTo(preview));
+            await session.SaveAsync(0, new GameSnapshot(), CancellationToken.None);
+            Assert.That((await session.ListSlotsAsync(CancellationToken.None))[0].PreviewImage, Is.Null);
+        }
+        finally { if (Directory.Exists(directory)) Directory.Delete(directory, true); }
+    }
+
     [Test]
     public async Task FirstEmptySavesSerializeAndNeverOverwriteOccupiedOrCorruptSlots()
     {
@@ -18,7 +56,8 @@ public async Task FirstEmptySavesSerializeAndNeverOverwriteOccupiedOrCorruptSlot
         try
         {
             using var assets = new EmptyAssetManager();
-            using var session = await FilePlayerSession.OpenAsync(directory, new GameContent { Graph = new Graph() }.Gallery, CancellationToken.None);
+            using var session = await FilePlayerSession.OpenAsync(directory, new GameContent { Graph = new Graph() }.Gallery,
+                cancellationToken: CancellationToken.None);
             await session.SaveAsync(0, new GameSnapshot { NodeId = "original" }, CancellationToken.None);
             await File.WriteAllTextAsync(Path.Combine(directory, "saves", "slot-001.json"), "corrupt");
             var slots = await Task.WhenAll(
@@ -46,8 +85,8 @@ public async Task ClearAsync_resets_all_player_owned_state()
         try
         {
             using var assets = new EmptyAssetManager();
-            using var session = await FilePlayerSession.OpenAsync(profileDirectory, new GameContent { Graph = new Graph() }.Gallery, CancellationToken.None);
-            var originalSettings = session.Settings;
+            using var session = await FilePlayerSession.OpenAsync(profileDirectory, new GameContent { Graph = new Graph() }.Gallery,
+                maxSlots: 3, cancellationToken: CancellationToken.None);
             var score = new GalVariable { Name = "score" };
             score.SetValue(42);
             session.Variables.NotifyVariableChanged(VariableScope.Player, score.Name, score);
@@ -60,12 +99,11 @@ public async Task ClearAsync_resets_all_player_owned_state()
             {
                 Assert.That(session.Variables.GetSnapshot(VariableScope.Player), Is.Empty);
                 Assert.That(session.Progress.IsRead("chapter-1", "line-1"), Is.False);
-                Assert.That(session.Settings, Is.Not.SameAs(originalSettings));
             });
             Assert.That(await session.LoadAsync(0, CancellationToken.None), Is.Null);
-            Assert.That(
-                await session.ListSlotsAsync(CancellationToken.None),
-                Has.All.Matches<SaveSlotInfo>(slot => slot.Timestamp == default && !slot.IsCorrupt));
+            var slots = await session.ListSlotsAsync(CancellationToken.None);
+            Assert.That(slots, Has.Count.EqualTo(3));
+            Assert.That(slots, Has.All.Matches<SaveSlotInfo>(slot => slot.Timestamp == default && !slot.IsCorrupt));
 
             session.Dispose();
         }
diff --git a/test/GalNet.IntegrationTests/SampleStartupTests.cs b/test/GalNet.IntegrationTests/SampleStartupTests.cs
index f805497a..4ce47225 100644
--- a/test/GalNet.IntegrationTests/SampleStartupTests.cs
+++ b/test/GalNet.IntegrationTests/SampleStartupTests.cs
@@ -79,7 +79,7 @@ public async Task FailedCommitDoesNotPublishLocaleOrLaunchCount()
     public async Task SeparateProfilesAndExternalLanguagesAreSupported()
     {
         using var localization = CreateLocalization();
-        localization.AttachGame(new GalNet.Runtime.Content.GameContent
+        localization.AttachGame(new GalNet.GameHost.Content.GameContent
         {
             Graph = new(),
             Localization = new() { ExternalSources = [new("ja-JP", "external", """{"line":"日本語"}""")] }
@@ -94,7 +94,7 @@ public async Task SeparateProfilesAndExternalLanguagesAreSupported()
     }
 
     [Test]
-    public void LanguageViewConfirmsCancelsAndCancelsOnCloseToken()
+    public void LanguageViewConfirmsAndCancelsOnCloseToken()
     {
         using var localization = CreateLocalization();
         var model = new LanguageSelectionViewModel(localization);
@@ -103,9 +103,7 @@ public void LanguageViewConfirmsCancelsAndCancelsOnCloseToken()
         Assert.That(view.FindControl<ComboBox>("LanguagePicker")!.SelectedItem, Is.EqualTo(model.SelectedLanguage));
         view.FindControl<Button>("ConfirmButton")!.Command!.Execute(null);
         Assert.That(confirmed.GetAwaiter().GetResult(), Is.EqualTo("zh-CN"));
-        var cancelled = model.ChooseAsync("en-US", CancellationToken.None);
-        view.FindControl<Button>("CancelButton")!.Command!.Execute(null);
-        Assert.That(cancelled.GetAwaiter().GetResult(), Is.Null);
+        Assert.That(view.FindControl<Button>("CancelButton"), Is.Null);
         using var closing = new CancellationTokenSource();
         var closed = model.ChooseAsync("en-US", closing.Token);
         closing.Cancel();
@@ -117,7 +115,7 @@ public async Task LanguageSelectionSnapshotsLoadedCulturesAndUsesCommands()
     {
         using var localization = CreateLocalization();
         var model = new LanguageSelectionViewModel(localization);
-        localization.AttachGame(new GalNet.Runtime.Content.GameContent
+        localization.AttachGame(new GalNet.GameHost.Content.GameContent
         {
             Graph = new(),
             Localization = new() { ExternalSources = [new("ja-JP", "external", """{"line":"日本語"}""")] }
@@ -126,8 +124,9 @@ public async Task LanguageSelectionSnapshotsLoadedCulturesAndUsesCommands()
         string[] expectedCultures = ["en-US", "ja-JP", "zh-CN"];
         Assert.That(model.Languages.Select(option => option.Value), Is.EqualTo(expectedCultures));
         Assert.That(model.SelectedLanguage!.Value, Is.EqualTo("ja-JP"));
+        Assert.That(localization.CultureService.CurrentCulture.Name, Is.EqualTo("ja-JP"));
         Assert.ThrowsAsync<InvalidOperationException>(() => model.ChooseAsync("en-US", CancellationToken.None));
-        localization.AttachGame(new GalNet.Runtime.Content.GameContent { Graph = new() });
+        localization.AttachGame(new GalNet.GameHost.Content.GameContent { Graph = new() });
         Assert.That(model.Languages.Select(option => option.Value), Does.Contain("ja-JP"), "No provider-change subscription.");
         model.SelectedLanguage = null;
         Assert.That(model.ConfirmCommand.CanExecute(null), Is.False);
@@ -139,11 +138,11 @@ public async Task LanguageSelectionSnapshotsLoadedCulturesAndUsesCommands()
         Assert.That(model.ConfirmCommand.CanExecute(null), Is.False);
         var fallback = model.ChooseAsync("missing", CancellationToken.None);
         Assert.That(model.SelectedLanguage!.Value, Is.EqualTo("en-US"));
-        model.CancelCommand.Execute(null);
-        Assert.That(await fallback, Is.Null);
+        model.ConfirmCommand.Execute(null);
+        Assert.That(await fallback, Is.EqualTo("en-US"));
     }
 
-    private static SampleLocalizationService CreateLocalization()
+    private static AvaloniaPlayerLocalization CreateLocalization()
     {
         var provider = new JsonLocalizationProvider();
         provider.LoadJsonString("""{"line":"English"}""", "en-US");
@@ -151,7 +150,7 @@ private static SampleLocalizationService CreateLocalization()
         var culture = new CultureService();
         culture.RegisterProvider(provider);
         culture.SetCulture("en-US");
-        return new SampleLocalizationService(culture, [provider]);
+        return new AvaloniaPlayerLocalization(culture, [provider]);
     }
 
     private sealed class FailedStore : IPlayerVariableStore
diff --git a/test/GalNet.IntegrationTests/SampleWindowThemeTests.cs b/test/GalNet.IntegrationTests/SampleWindowThemeTests.cs
new file mode 100644
index 00000000..00232201
--- /dev/null
+++ b/test/GalNet.IntegrationTests/SampleWindowThemeTests.cs
@@ -0,0 +1,159 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+using Avalonia.VisualTree;
+using GalNet.Avalonia.GameHost;
+using GalNet.Avalonia.GameView.MarkupExtensions;
+using GalNet.Avalonia.GameView.Navigation;
+using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Sample.Avalonia;
+using GalNet.Sample.Avalonia.Views;
+using GeneralTest.Integration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GalNet.IntegrationTests;
+
+[NonParallelizable]
+public sealed class SampleWindowThemeTests
+{
+#if GALNET_GAME_DEBUG
+    [Test]
+    public async Task DebugMenuRendersItsHeaderAndPopupUsingTheHostMenuTheme()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            var services = new ServiceCollection();
+            SampleCustomization.ConfigureServices(services);
+            await using var provider = services.BuildServiceProvider();
+            await using var scope = provider.CreateAsyncScope();
+            var localization = scope.ServiceProvider.GetRequiredService<IPlayerLocalization>();
+            localization.CultureService.SetCulture("zh-CN");
+            PlayerTextExtension.Resolve = localization.GetString;
+            var semi = new Semi.Avalonia.SemiTheme();
+            Application.Current!.Styles.Add(semi);
+            var menu = new DebugMenuView
+            {
+                DataContext = scope.ServiceProvider.GetRequiredService<GalNet.Sample.Avalonia.Debug.SampleDebugViewModel>()
+            };
+            var window = new Window { Width = 640, Height = 400, Content = menu };
+            window.Resources.MergedDictionaries.Add(SampleCustomization.PlayerPalette.CreateResources());
+            try
+            {
+                window.Show();
+                window.UpdateLayout();
+                Assert.That(menu.GetVisualDescendants().OfType<global::Avalonia.Controls.Presenters.ItemsPresenter>(), Is.Not.Empty,
+                    "The debug menu needs a real Menu template, not only IsVisible=true.");
+                var header = (MenuItem)menu.Items[0]!;
+                Assert.That(header.Header, Is.EqualTo("调试"));
+                Assert.That(((ISolidColorBrush)header.Foreground!).Color,
+                    Is.EqualTo(((ISolidColorBrush)window.FindResource("GalNet.Brush.TextPrimary")!).Color));
+                Assert.That(header.Bounds.Width, Is.GreaterThan(0));
+                Assert.That(header.Bounds.Height, Is.GreaterThan(0));
+                header.IsSubMenuOpen = true;
+                window.UpdateLayout();
+                var popup = header.GetVisualDescendants().OfType<global::Avalonia.Controls.Primitives.Popup>().Single();
+                Assert.That(popup.IsOpen, Is.True);
+                Assert.That(popup.Child!.GetVisualDescendants().OfType<MenuItem>(), Is.Not.Empty);
+            }
+            finally { window.Close(); Application.Current.Styles.Remove(semi); }
+            return true;
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+#endif
+
+    [Test]
+    public async Task CaptionResourcesAndExitConfirmationUseThePlayerPaletteAndKeepCancelKeyboardSafe()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            var services = new ServiceCollection();
+            SampleCustomization.ConfigureServices(services, enableDebug: false);
+            await using var provider = services.BuildServiceProvider();
+            await using var scope = provider.CreateAsyncScope();
+            var localization = scope.ServiceProvider.GetRequiredService<IPlayerLocalization>();
+            PlayerTextExtension.Resolve = localization.GetString;
+            var semi = new Semi.Avalonia.SemiTheme();
+            var ursa = new Ursa.Themes.Semi.UrsaSemiTheme();
+            Application.Current!.Styles.Add(semi);
+            Application.Current.Styles.Add(ursa);
+            var window = scope.ServiceProvider.GetRequiredService<MainWindow>();
+            window.Show();
+            try
+            {
+                window.UpdateLayout();
+                // Headless windows do not create platform decorations. Check their actual brush resources.
+                var foreground = (ISolidColorBrush)window.FindResource("CaptionButtonForeground")!;
+                var palette = (ISolidColorBrush)window.FindResource("GalNet.Brush.TextPrimary")!;
+                Assert.That(foreground.Color, Is.EqualTo(palette.Color));
+                var hover = (ISolidColorBrush)window.FindResource("CaptionButtonPointeroverBackground")!;
+                Assert.That(hover.Color, Is.EqualTo(palette.Color));
+                Assert.That(hover.Opacity, Is.EqualTo(.08));
+                Assert.That(((ISolidColorBrush)window.FindResource("CaptionButtonClosePointeroverBackground")!).Color, Is.EqualTo(Color.Parse("#C42B1C")));
+                var selection = window.SelectLanguageAsync("zh-CN", CancellationToken.None);
+                window.UpdateLayout();
+                var languageView = window.FindControl<LanguageSelectionView>("LanguageSelection")!;
+                var picker = languageView.FindControl<ComboBox>("LanguagePicker")!;
+                Assert.That(((ISolidColorBrush)picker.Background!).Color,
+                    Is.EqualTo(((ISolidColorBrush)languageView.FindResource("GalNet.Brush.Surface")!).Color));
+                picker.IsDropDownOpen = true;
+                window.UpdateLayout();
+                var popup = picker.GetVisualDescendants().OfType<global::Avalonia.Controls.Primitives.Popup>().Single();
+                Assert.That(((ISolidColorBrush)((Border)popup.Child!).Background!).Color,
+                    Is.EqualTo(((ISolidColorBrush)picker.Background!).Color));
+                Capture(window, "Sample-LanguagePicker");
+                picker.IsDropDownOpen = false;
+                scope.ServiceProvider.GetRequiredService<GalNet.Sample.Avalonia.ViewModels.LanguageSelectionViewModel>().ConfirmCommand.Execute(null);
+                Assert.That(await selection, Is.EqualTo("zh-CN"));
+                scope.ServiceProvider.GetRequiredService<AvaloniaPlayerLocalization>().ApplyCulture("en-US");
+                scope.ServiceProvider.GetRequiredService<IGameNavigationService>().ResetTo<TitlePageViewModel>(NavigationTransition.None);
+                window.CompleteStartup();
+                window.UpdateLayout();
+                var title = window.GetVisualDescendants().OfType<TextBlock>()
+                    .Single(control => control.Text == scope.ServiceProvider.GetRequiredService<TitlePageViewModel>().GameTitle);
+                var titleBrush = (ISolidColorBrush)title.Foreground!;
+                Capture(window, "Sample-TitleBeforeExit");
+                var confirmation = window.ConfirmExitAsync();
+                Assert.That(window.ConfirmExitAsync(), Is.SameAs(confirmation));
+                var cancel = window.FindControl<Button>("CancelExitButton")!;
+                var content = window.FindControl<Grid>("PlayerContent")!;
+                Assert.That(content.IsEnabled, Is.False);
+                Assert.That(cancel.IsFocused, Is.True);
+                window.UpdateLayout();
+                Capture(window, "Sample-ExitConfirmation");
+                Assert.That(((ISolidColorBrush)title.Foreground!).Color, Is.EqualTo(titleBrush.Color), "The modal must preserve the title's foreground.");
+                Assert.That(((ISolidColorBrush)title.Foreground!).Opacity, Is.EqualTo(titleBrush.Opacity), "The scrim alone dims static title text.");
+                scope.ServiceProvider.GetRequiredService<AvaloniaPlayerLocalization>().ApplyCulture("zh-CN");
+                window.UpdateLayout();
+                Capture(window, "Sample-ExitConfirmation-zh-CN");
+                window.Width = 800;
+                window.Height = 500;
+                window.UpdateLayout();
+                Capture(window, "Sample-ExitConfirmation-zh-CN-compact");
+                window.KeyPress(Key.Escape, RawInputModifiers.None, PhysicalKey.Escape, null);
+                window.KeyRelease(Key.Escape, RawInputModifiers.None, PhysicalKey.Escape, null);
+                Assert.That(await confirmation, Is.False);
+                Assert.That(content.IsEnabled, Is.True);
+                confirmation = window.ConfirmExitAsync();
+                window.FindControl<Button>("ConfirmExitButton")!.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+                Assert.That(await confirmation, Is.True);
+            }
+            finally { window.Close(); Application.Current.Styles.Remove(ursa); Application.Current.Styles.Remove(semi); }
+            return true;
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+
+    private static void Capture(Window window, string name)
+    {
+        AvaloniaHeadlessPlatform.ForceRenderTimerTick();
+        var directory = Environment.GetEnvironmentVariable("GALNET_THEME_CAPTURE_DIR");
+        if (string.IsNullOrEmpty(directory)) return;
+        Directory.CreateDirectory(directory);
+        using var bitmap = window.CaptureRenderedFrame();
+        bitmap!.Save(Path.Combine(directory, name + ".png"));
+    }
+}
diff --git a/test/GalNet.IntegrationTests/ScreenshotEntryTests.cs b/test/GalNet.IntegrationTests/ScreenshotEntryTests.cs
index 48803120..8e804ec7 100644
--- a/test/GalNet.IntegrationTests/ScreenshotEntryTests.cs
+++ b/test/GalNet.IntegrationTests/ScreenshotEntryTests.cs
@@ -39,7 +39,7 @@ private static string RepositoryRoot
     [TestCase(PrimitiveInvocationMode.Quick)]
     public async Task ConcreteGamePage_CapturesRealScenePng_AndQuickStillCaptures(PrimitiveInvocationMode mode)
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await DispatchAsync(session, async () =>
         {
             var (page, window) = Scene();
@@ -64,10 +64,47 @@ await DispatchAsync(session, async () =>
         }, TestContext.CurrentContext.CancellationToken);
     }
 
+    [Test]
+    public async Task BoundedCaptureIncludesControlsPreservesSceneAndLeavesFullExportUnchanged()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
+        await DispatchAsync(session, async () =>
+        {
+            var scene = new SceneLayerHost
+            {
+                ItemsSource = new[] { new SceneLayerItem { HandleId = "background", Color = "#203040" } }
+            };
+            var overlay = new Border { Height = 80, VerticalAlignment = Avalonia.Layout.VerticalAlignment.Bottom, Background = Avalonia.Media.Brushes.Gold };
+            var root = new Grid { Children = { scene, overlay } };
+            var window = new Window { Width = 1280, Height = 720, Content = root };
+            window.Show();
+            try
+            {
+                window.UpdateLayout();
+                using var preview = scene.CaptureControl(root, new PixelSize(320, 180));
+                using var previewStream = new MemoryStream();
+                // Match the screenshot path: PNG encoding can finish off the UI thread.
+                await Task.Run(() => preview.Save(previewStream));
+                using var decoded = SKBitmap.Decode(previewStream.ToArray());
+                Assert.That((decoded.Width, decoded.Height), Is.EqualTo((320, 180)));
+                Assert.That(decoded.GetPixel(160, 60), Is.EqualTo(SKColor.Parse("#203040")));
+                Assert.That(decoded.GetPixel(160, 175), Is.EqualTo(SKColors.Gold));
+                using var scenePreview = SKBitmap.Decode(scene.CapturePng(new PixelSize(480, 270)));
+                Assert.That((scenePreview.Width, scenePreview.Height), Is.EqualTo((480, 270)));
+                Assert.That(scenePreview.GetPixel(240, 265), Is.EqualTo(SKColor.Parse("#203040")));
+                using var full = scene.CaptureControl(root);
+                Assert.That(full.PixelSize, Is.EqualTo(new PixelSize(1280, 720)));
+                using var original = SKBitmap.Decode(scene.CapturePng());
+                Assert.That((original.Width, original.Height), Is.EqualTo((1280, 720)));
+            }
+            finally { window.Close(); }
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+
     [Test]
     public async Task CompiledSchemaToModuleToEngine_ExecutesAndSurfacesAsyncCaptureFailure()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await DispatchAsync(session, async () =>
         {
             var (page, window) = Scene();
@@ -115,7 +152,7 @@ await DispatchAsync(session, async () =>
     [Test]
     public async Task CatchUp_Cancellation_AndConflict_PublishNoExtraFiles()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await DispatchAsync(session, async () =>
         {
             var catchUp = new ScreenshotPrimitiveInstance(new GamePage(), () => throw new InvalidOperationException("must not resolve directory"), null, null, default);
@@ -147,7 +184,7 @@ await DispatchAsync(session, async () =>
     [Test]
     public async Task GeneratedNames_AreUnique_AndRelativeOrLinkedDirectoriesAreRejected()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await DispatchAsync(session, async () =>
         {
             var (page, window) = Scene();
@@ -166,7 +203,7 @@ await DispatchAsync(session, async () =>
                 Assert.ThrowsAsync<InvalidDataException>(async () => await relative.PresentationCompletion);
                 var target = Directory.CreateDirectory(Path.Combine(_root, "target")).FullName;
                 var link = Path.Combine(_root, "link");
-                Directory.CreateSymbolicLink(link, target);
+                DirectoryLinks.Create(link, target);
                 try
                 {
                     var linked = new ScreenshotPrimitiveInstance(page, () => link, null, null, default);
@@ -183,7 +220,7 @@ await DispatchAsync(session, async () =>
     [Test]
     public async Task DisposingModule_CancelsAndDrainsQueuedCaptureBeforeSceneRelease()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await DispatchAsync(session, async () =>
         {
             var (page, window) = Scene();
@@ -205,7 +242,7 @@ await DispatchAsync(session, async () =>
     [Test]
     public async Task DisposedModuleRejectsDispatchAndUndispatchedScopeDoesNotBlockCleanup()
     {
-        await using var session = HeadlessUnitTestSession.StartNew(typeof(ScreenshotTestApplication));
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ScreenshotTestApplication).Assembly);
         await DispatchAsync(session, async () =>
         {
             using var scope = new GalNet.Presentation.Abstractions.Execution.PrimitiveTaskScope();
diff --git a/test/GalNet.IntegrationTests/StoryPackageExportTests.cs b/test/GalNet.IntegrationTests/StoryPackageExportTests.cs
new file mode 100644
index 00000000..ab87d7d6
--- /dev/null
+++ b/test/GalNet.IntegrationTests/StoryPackageExportTests.cs
@@ -0,0 +1,219 @@
+using System.Text.Json;
+using GalNet.Assets;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Core.Assets;
+using GalNet.Core.Configuration;
+using GalNet.Core.Entry;
+using GalNet.Core.Primitives;
+using GalNet.Core.Serialization;
+using GalNet.Editor.Shared.Services;
+using GalNet.GameHost;
+using GalNet.Presentation.Abstractions.Execution;
+using GalNet.Presentation.Abstractions.View;
+using GalNet.Runtime.Runtime;
+using GalNet.Storage.FileSystem;
+
+namespace GalNet.IntegrationTests;
+
+public sealed class StoryPackageExportTests
+{
+    private string _root = null!;
+    private string Source => Path.Combine(_root, "source");
+    private string Installed => Path.Combine(_root, "installed");
+    private readonly IResourceTypeCatalog _types = BuiltinResourceTypes.CreateCatalog();
+    private readonly IEntryCatalog _catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+
+    [SetUp]
+    public void Setup()
+    {
+        _root = Path.Combine(Path.GetTempPath(), "galnet-story-packages-" + Guid.NewGuid().ToString("N"));
+        Put("Graph/graph.json", """
+            {"version":2,"name":"Story","rootNodeId":"base","nodes":[
+             {"id":"base","name":"Base","type":"Group","file":"groups/base.rawgalgroup"},
+             {"id":"a","name":"A","type":"Group","file":"groups/a.rawgalgroup","storyPackage":"A"},
+             {"id":"b","name":"B","type":"Group","file":"groups/b.rawgalgroup","storyPackage":"B"},
+             {"id":"end","name":"End","type":"Group","file":"groups/end.rawgalgroup"}],
+             "edges":[{"id":"e1","fromNodeId":"base","fromOutlet":0,"toNodeId":"a"},
+             {"id":"e2","fromNodeId":"a","fromOutlet":0,"toNodeId":"b"},
+             {"id":"e3","fromNodeId":"b","fromOutlet":0,"toNodeId":"end"}],"playerVariables":[],"saveVariables":[]}
+            """);
+        Group("base", "shared-base");
+        Group("a", "shared-base", "shared-extra", "a-only");
+        Group("b", "shared-extra");
+        Group("end");
+        foreach (var id in new[] { "shared-base", "shared-extra", "a-only", "unused" })
+        {
+            Put("Assets/" + id + ".png", "image-bytes");
+            Put("Assets/" + id + ".png.meta", JsonSerializer.Serialize(new { id, type = "sprite" }));
+        }
+        var configuration = new ProjectConfiguration();
+        configuration.Set(ContentPackagingOptions.Section, new() { MaxPakBytes = 1 });
+        Put("settings.json", JsonSerializer.Serialize(configuration));
+    }
+    [TearDown] public void Cleanup() => Directory.Delete(_root, true);
+
+    [Test]
+    public async Task EveryInstallationCombinationRunsAndIndependentPackagesCarryTheirOwnSharedExtras()
+    {
+        var files = await Export();
+        var baseline = Directory.GetFiles(Path.Combine(Installed, "Assets", "Paks"), "*.pak").SelectMany(Ids).ToArray();
+        Assert.That(baseline, Does.Contain("shared-base").And.Not.Contain("shared-extra").And.Not.Contain("unused"));
+        foreach (var package in new[] { "A", "B" })
+        {
+            var own = files.Where(file => file.Package == package).SelectMany(file => Ids(file.Path)).ToArray();
+            Assert.That(own, Does.Contain("shared-extra").And.Not.Contain("shared-base"));
+        }
+        foreach (var mask in Enumerable.Range(0, 4))
+        {
+            SetInstalled(files, mask);
+            var content = await Load();
+            var observed = new List<string>();
+            using var registration = new GameRegistration();
+            registration.UseCatalog(_catalog);
+            registration.RegisterImplementation(new PrimitiveModule(registry => registry.Register("layer.show", context =>
+                new ImmediatePrimitiveInstance(() => observed.Add(context.Runtime.CurrentNodeId)))));
+            await using var view = registration.BuildView();
+            await using var run = new GameRun(content.Graph, new GameRuntime(null, content.Graph.RootNodeId), view);
+            await run.PrepareAsync(null);
+            await run.StartPreparedAsync();
+            var expected = new List<string> { "base" };
+            if ((mask & 1) != 0) expected.AddRange(["a", "a", "a"]);
+            if ((mask & 2) != 0) expected.Add("b");
+            Assert.That(observed, Is.EqualTo(expected), "mask=" + mask);
+        }
+        using var layout = JsonDocument.Parse(PackedGameDocuments.ReadGame(await File.ReadAllBytesAsync(
+            Path.Combine(Installed, PackedGameDocuments.GameFileName))).Documents.GetText("packaging-layout.json"));
+        Assert.That(layout.RootElement.GetProperty("unused").EnumerateArray().Select(item => item.GetProperty("id").GetString()), Does.Contain("unused"));
+    }
+
+    [Test]
+    public async Task ResourcePatchExportsBeforeBaseAndSessionsFreezeTheSelectedOverrideSet()
+    {
+        Put("Assets/coat.png", "coat-B");
+        Put("Assets/coat.png.meta", """{"id":"coat","type":"sprite"}""");
+        var definition = new ResourceOverrideDefinition { Id = "clothes", Mappings = new() { ["shared-base"] = "coat", ["a-only"] = "coat" } };
+        var patchPath = Path.Combine(_root, "independent.pak");
+        var sourceMeta = File.ReadAllBytes(Path.Combine(Source, "Assets/coat.png.meta"));
+        await ResourceOverrideExporter.ExportAsync("story-project", Source, definition, patchPath, _types);
+        var firstBytes = File.ReadAllBytes(patchPath);
+        await ResourceOverrideExporter.ExportAsync("story-project", Source, definition, patchPath, _types);
+        Assert.That(File.ReadAllBytes(patchPath), Is.EqualTo(firstBytes));
+        Assert.That(File.ReadAllBytes(Path.Combine(Source, "Assets/coat.png.meta")), Is.EqualTo(sourceMeta));
+        using (var patch = Archive.Deserialize("assets", firstBytes, _types))
+        {
+            Assert.That(patch.Descriptor.Kind, Is.EqualTo("override"));
+            Assert.That(patch.AssetIds, Is.EquivalentTo(new[] { "coat" }));
+        }
+        var stories = await Export(); SetInstalled(stories, 0);
+        var patchDirectory = Path.Combine(Installed, "ResourcePatches"); Directory.CreateDirectory(patchDirectory);
+        File.Copy(patchPath, Path.Combine(patchDirectory, "renamed.pak"));
+        File.Copy(patchPath, Path.Combine(patchDirectory, "duplicate.pak"));
+        var installation = await GameInstallation.OpenAsync(Installed);
+        Assert.That((await installation.CreateContentProvider(_types, BuiltinGalleryTypes.CreateCatalog(_types)).LoadAsync()).Graph.InstalledStoryPackages, Is.Empty);
+        using var assets = new AssetManager(installation.CreateAssetProviders(_types));
+        using var oldHandle = await assets.AcquireAsync<string>("shared-base");
+        Assert.That(oldHandle!.Value, Is.EqualTo("coat-B"));
+        Assert.That(await assets.GetFileAsync("a-only"), Is.Null, "An override cannot install an absent story's original resource.");
+        Put("Assets/coat-c.png", "coat-C"); Put("Assets/coat-c.png.meta", """{"id":"coat-c","type":"sprite"}""");
+        var high = new ResourceOverrideDefinition { Id = "higher", Priority = 1, Mappings = new() { ["shared-base"] = "coat-c" } };
+        await ResourceOverrideExporter.ExportAsync("story-project", Source, high, Path.Combine(patchDirectory, "higher.pak"), _types);
+        using var frozen = new AssetManager(installation.CreateAssetProviders(_types));
+        using var frozenHandle = await frozen.AcquireAsync<string>("shared-base");
+        Assert.That(frozenHandle!.Value, Is.EqualTo("coat-B"));
+        var reopened = await GameInstallation.OpenAsync(Installed);
+        using var updated = new AssetManager(reopened.CreateAssetProviders(_types));
+        using var updatedHandle = await updated.AcquireAsync<string>("shared-base");
+        Assert.That(updatedHandle!.Value, Is.EqualTo("coat-C"));
+        Assert.That(oldHandle.Value, Is.EqualTo("coat-B"));
+        var invalid = File.ReadAllBytes(Path.Combine(patchDirectory, "higher.pak")); invalid[^1] ^= 1;
+        File.WriteAllBytes(Path.Combine(patchDirectory, "higher.pak"), invalid);
+        var corrupted = await GameInstallation.OpenAsync(Installed);
+        Assert.Throws<InvalidDataException>(() => corrupted.CreateAssetProviders(_types));
+    }
+
+    [Test]
+    public async Task GalpakPublishesExternalStoriesAndRepeatExportKeepsContentHashes()
+    {
+        var output = Path.Combine(_root, "release");
+        async Task<GamePackageExportResult> ExportZip() => await GamePackageExporter.ExportAsync("story-project", "Story", Source, output,
+            _types, BuiltinGalleryTypes.CreateCatalog(_types), _catalog);
+        var first = await ExportZip();
+        Assert.That(first.Success, Is.True, first.Error);
+        using (var zip = System.IO.Compression.ZipFile.OpenRead(first.PackagePath!))
+            Assert.That(zip.Entries.Any(entry => entry.FullName.StartsWith("StoryPatches/", StringComparison.Ordinal)), Is.False);
+        var parts = Directory.GetFiles(Path.Combine(output, "StoryPatches"), "*.pak", SearchOption.AllDirectories)
+            .ToDictionary(path => path, path => CryptoHelper.HashSHA256(File.ReadAllBytes(path)));
+        var second = await ExportZip();
+        Assert.That(second.Success, Is.True, second.Error);
+        foreach (var part in parts) Assert.That(CryptoHelper.HashSHA256(File.ReadAllBytes(part.Key)), Is.EqualTo(part.Value));
+        var installation = await GameInstallation.OpenAsync(second.PackagePath!);
+        var content = await installation.CreateContentProvider(_types, BuiltinGalleryTypes.CreateCatalog(_types)).LoadAsync();
+        Assert.That(content.Graph.InstalledStoryPackages, Is.EquivalentTo(new[] { "A", "B" }));
+        using var canceled = new CancellationTokenSource(); canceled.Cancel();
+        var before = File.ReadAllBytes(second.PackagePath!);
+        var canceledResult = await GamePackageExporter.ExportAsync("story-project", "Story", Source, output,
+            _types, BuiltinGalleryTypes.CreateCatalog(_types), _catalog, cancellationToken: canceled.Token);
+        Assert.That(canceledResult.Success, Is.False);
+        Assert.That(File.ReadAllBytes(second.PackagePath!), Is.EqualTo(before));
+    }
+
+    [Test]
+    public async Task PartialCorruptAndMissingSavePackagesFailButRenamingStoryPartsDoesNot()
+    {
+        var files = await Export();
+        var a = files.Where(file => file.Package == "A").ToArray();
+        Assert.That(a.Length, Is.GreaterThan(1));
+        File.Delete(a[0].Path);
+        Assert.ThrowsAsync<InvalidDataException>(() => Load());
+        SetInstalled(files, 3);
+        var corrupt = a[0].Bytes.ToArray(); corrupt[^1] ^= 1;
+        File.WriteAllBytes(a[0].Path, corrupt);
+        Assert.ThrowsAsync<InvalidDataException>(() => Load());
+        SetInstalled(files, 3);
+        File.Move(a[0].Path, Path.Combine(Path.GetDirectoryName(a[0].Path)!, "renamed.pak"));
+        var content = await Load();
+        using var registration = new GameRegistration();
+        registration.UseCatalog(_catalog);
+        registration.RegisterImplementation(new PrimitiveModule(registry => registry.Register("layer.show", _ => new ImmediatePrimitiveInstance(() => { }))));
+        await using var view = registration.BuildView();
+        await using var run = new GameRun(content.Graph, new GameRuntime(null, "base"), view);
+        await run.PrepareAsync(null);
+        var save = run.CreateSaveData();
+        Assert.That(save.StoryPackages, Is.EquivalentTo(new[] { "A", "B" }));
+        File.Delete(Path.Combine(Path.GetDirectoryName(a[0].Path)!, "renamed.pak"));
+        SetInstalled(files, 2);
+        var missing = await Load();
+        await using var replacement = new GameRun(missing.Graph, new GameRuntime(null, "base"), view);
+        Assert.ThrowsAsync<InvalidDataException>(() => replacement.ValidateSnapshotAsync(save, CancellationToken.None));
+    }
+
+    private async Task<List<(string Path, string Package, byte[] Bytes)>> Export()
+    {
+        var result = await GamePackageExporter.ExportDirectoryAsync("story-project", "Story", Source, Installed,
+            _types, BuiltinGalleryTypes.CreateCatalog(_types), _catalog);
+        Assert.That(result.Success, Is.True, result.Error);
+        return Directory.GetFiles(Path.Combine(Installed, "StoryPatches"), "*.pak", SearchOption.AllDirectories).Select(path =>
+        {
+            var bytes = File.ReadAllBytes(path);
+            using var archive = Archive.Deserialize("assets", bytes, _types);
+            return (path, archive.Descriptor.PackageId, bytes);
+        }).ToList();
+    }
+    private Task<GalNet.GameHost.Content.GameContent> Load() => new InstalledGameContentProvider(Installed, _types, BuiltinGalleryTypes.CreateCatalog(_types)).LoadAsync();
+    private string[] Ids(string path) { using var archive = Archive.Deserialize("assets", File.ReadAllBytes(path), _types); return archive.AssetIds.ToArray(); }
+    private static void SetInstalled(List<(string Path, string Package, byte[] Bytes)> files, int mask)
+    {
+        foreach (var file in files)
+            if ((mask & (file.Package == "A" ? 1 : 2)) != 0) File.WriteAllBytes(file.Path, file.Bytes);
+            else if (File.Exists(file.Path)) File.Delete(file.Path);
+    }
+    private void Group(string id, params string[] images) => Put("Graph/groups/" + id + ".rawgalgroup", JsonSerializer.Serialize(new
+    {
+        version = 2,
+        kind = "Raw",
+        entries = images.Select((image, index) => new { id = "e" + index, type = "layer.show", parameters = new { assetId = image } })
+    }));
+    private void Put(string path, string text) { var file = Path.Combine(Source, path); Directory.CreateDirectory(Path.GetDirectoryName(file)!); File.WriteAllText(file, text); }
+}
diff --git a/test/GalNet.IntegrationTests/packages.lock.NoGameDebugging.json b/test/GalNet.IntegrationTests/packages.lock.NoGameDebugging.json
new file mode 100644
index 00000000..cf82a9ca
--- /dev/null
+++ b/test/GalNet.IntegrationTests/packages.lock.NoGameDebugging.json
@@ -0,0 +1,693 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "Avalonia.Headless": {
+        "type": "Direct",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "F+o+kxHts+hhpUVtzeCe4U7ZLDWbpeVIX8LhoHSw/3oUQHlh+OrO9MGZSMae72hKFRE+r4AJh0kuhzIeWDFgdQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Fonts.Inter": "12.0.5",
+          "Avalonia.HarfBuzz": "12.0.5"
+        }
+      },
+      "coverlet.collector": {
+        "type": "Direct",
+        "requested": "[6.0.4, )",
+        "resolved": "6.0.4",
+        "contentHash": "lkhqpF8Pu2Y7IiN7OntbsTtdbpR1syMsm2F3IgX6ootA4ffRqWL5jF7XipHuZQTdVuWG/gVAAcf8mjk8Tz0xPg=="
+      },
+      "Microsoft.NET.Test.Sdk": {
+        "type": "Direct",
+        "requested": "[17.14.0, )",
+        "resolved": "17.14.0",
+        "contentHash": "rTtdOm6C96q9QgP3mS8nUGPGPh5Xm2HnBYJggNmNrJ3LDmX9lJuUIgnJEfvX6wSQY4swUMiCcIXd3OkjhYCgtw==",
+        "dependencies": {
+          "Microsoft.CodeCoverage": "17.14.0",
+          "Microsoft.TestPlatform.TestHost": "17.14.0"
+        }
+      },
+      "NUnit": {
+        "type": "Direct",
+        "requested": "[4.3.2, )",
+        "resolved": "4.3.2",
+        "contentHash": "puVXayXNmEu7MFQSUswGmUjOy3M3baprMbkLl5PAutpeDoGTr+jPv33qAYsqxywi2wJCq8l/O3EhHoLulPE1iQ=="
+      },
+      "NUnit.Analyzers": {
+        "type": "Direct",
+        "requested": "[4.7.0, )",
+        "resolved": "4.7.0",
+        "contentHash": "1AjtK0uoJgxyobNtNwjQLlEs2X+9mgfWbWXiIktquTvpOhSXMf56TZF43+q2lIIYhV4IrfS82/pfo4uPUYka4w=="
+      },
+      "NUnit3TestAdapter": {
+        "type": "Direct",
+        "requested": "[5.0.0, )",
+        "resolved": "5.0.0",
+        "contentHash": "sy4cLoUAdE6TDM4wNX5gmNCyhMev5wUz4cA6ZRf/aON9vf9t4xTVGLj/4huhDKcS4dFfmVVcgcP70yC7WC9kKg==",
+        "dependencies": {
+          "Microsoft.Testing.Extensions.VSTestBridge": "1.5.3",
+          "Microsoft.Testing.Platform.MSBuild": "1.5.3"
+        }
+      },
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "Avalonia.Angle.Windows.Natives": {
+        "type": "Transitive",
+        "resolved": "2.1.27548.20260419",
+        "contentHash": "l17nI3XVDN3oMnpjf2pnmJg0YTwK4m6NLsn/itAjDMdObTFxN77D5F1M9sRMSfViSY3KKcse1ROczwgoWLJsnA=="
+      },
+      "Avalonia.BuildServices": {
+        "type": "Transitive",
+        "resolved": "11.3.2",
+        "contentHash": "qHDToxto1e3hci5YqbG9n0Ty8mlp3zBUN5wT66wKqaDVzXyQ0do3EnRILd4Ke9jpvsktaPpgE0YjEk7hornryQ=="
+      },
+      "Avalonia.FreeDesktop": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "51IiLrfyJdMtmVTiXiEi1q1nXS5KAMYvFNeovlwKSuTgY/agBevnfBTY+DnKnIjZMdXWWKVGJJh7MldMkPc14w==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Tmds.DBus.Protocol": "0.92.0"
+        }
+      },
+      "Avalonia.FreeDesktop.AtSpi": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "IrsjB1QpzXwgdnkpG6ejGxSaHp0sRrq3rZlrzRyhwEGllAxcOeUuQpq8/OrO3OUJLxXtxlsM4ku17v+7q7xGKQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.HarfBuzz": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "jR8i/fgrmAKEp0T3iLqfKCoEDJV9ODVzN+8bofM2guEr05eaXbx6iXZxcjh0nDK4UbK0akYDgBfAgyHoatqGjg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3"
+        }
+      },
+      "Avalonia.Native": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "m6qn0UGMI/b4cFfJ8id8sPYLotc7szhZdexPCKY+kIvGlx6Ln0VjNejRMiJDZ4S91q6nbKJL/YmfPd8UruTNjQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Remote.Protocol": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "/S4T1uZzXvPpN0Sqs44u3Rl5/qCZHHefRK7xyORONHH1w60IfsfsE5RbwFSku7qmib1DsGZZXxtweJq24ERfbg=="
+      },
+      "Avalonia.Win32": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "ZY1ZLXQdQqlz9GUZGXK+73kTFgKzygPbGk/gHfROUWLr2aBh1kOA1KY5xB7/cSSY+egDr+IGSjsQbgS8eSu9Tg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Angle.Windows.Natives": "2.1.27548.20260419"
+        }
+      },
+      "Avalonia.X11": {
+        "type": "Transitive",
+        "resolved": "12.0.5",
+        "contentHash": "6OyZa5ehNbzd7JWiVbGdjuzdsgy2Rgibtwczmh7hKnePxLmOqeSL+hQ6vHanSx246TpSBKDPvjqwW7NuQrmAJg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.FreeDesktop": "12.0.5",
+          "Avalonia.FreeDesktop.AtSpi": "12.0.5",
+          "Avalonia.Skia": "12.0.5"
+        }
+      },
+      "HarfBuzzSharp": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "NGZ2+ZVNPM+NdHB/asW0/ykWngyHWwcqjrbN2nDeH1B/aptPGlCUl8wkQ2cSJxw5fdWgdmIPmNuTPWpLwNVXWg==",
+        "dependencies": {
+          "HarfBuzzSharp.NativeAssets.Win32": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.macOS": "8.3.1.3"
+        }
+      },
+      "HarfBuzzSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "RI6A1LgmooU30+4QIyFt5rmBCzP0VzTR+587IJSGvYIsHHWlahFufihYxtraLfsIhW7I8dn6+xX+DZGygOPKWQ=="
+      },
+      "HarfBuzzSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "KPTq0xnslkI6nAo0jh3ptcQPJvZZr7MWYXa2jUe4SnHc9q+JlHElmNXp0sfFoiTgoCX7WOYpYsurypuH9Gehxw=="
+      },
+      "HarfBuzzSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "w2QfdNm9Uz/sUa0B5D+OnVQhyq3G/fBq6ibQMdWBlQqqwh0g0/5j3RFvYqZAmRZ5+RzvjVe8o8SFFnWYUSkuxA=="
+      },
+      "HarfBuzzSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "8.3.1.3",
+        "contentHash": "bx8CE8Js+XGX8PUxAHCBDEORt5aaBYtMN4Hr9QFs57Xithh6yjUyYqksizH6eRDhJkwsGI+SXWmPmMm8lZC9Pw=="
+      },
+      "Irihi.Avalonia.Shared": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "T6+jezCUjisJNz6zkNcNLVNI2ttWznbyQnW6MS9L45EXhePqRCIxB3xV/5L8gFAJ83JrhiCIokMOxRWdq9/1Zg==",
+        "dependencies": {
+          "Avalonia": "12.0.0"
+        }
+      },
+      "Irihi.Avalonia.Shared.Contracts": {
+        "type": "Transitive",
+        "resolved": "0.4.0",
+        "contentHash": "Du8DY2YqlSmCmywqZtuOhgwLkgklMeE1ajZ4Dd/iqVz6HmAKptjVTqA1oloZX5ihqsdKRiNuUGCdYPe1rekf2Q=="
+      },
+      "MicroCom.Runtime": {
+        "type": "Transitive",
+        "resolved": "0.11.4",
+        "contentHash": "yZ8+Lgwo+KtRI29TB2mIOEMzV+csMJ+pKZg4YHReAP3vRewWLKKeYfrBDo5FS69rWnEbCfU3sbM+ZEQr+GDLtg=="
+      },
+      "Microsoft.ApplicationInsights": {
+        "type": "Transitive",
+        "resolved": "2.22.0",
+        "contentHash": "3AOM9bZtku7RQwHyMEY3tQMrHIgjcfRDa6YQpd/QG2LDGvMydSlL9Di+8LLMt7J2RDdfJ7/2jdYv6yHcMJAnNw=="
+      },
+      "Microsoft.CodeCoverage": {
+        "type": "Transitive",
+        "resolved": "17.14.0",
+        "contentHash": "z2GYXGG6LjGoumT59xSB2dMnqSwQBjkxdDJmSJHwy5nPtZ435GXa6wj5hz/lRrAZ7NyXXxZNXVsiHXzHRru5eA=="
+      },
+      "Microsoft.Testing.Extensions.Telemetry": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "U9pGd5DQuX1PfkrdFI+xH34JGgQ2nes5QAwIITTk+MQfLvRITqsZjJeHTjpGWh33D/0q1l7aA8/LQHR7UuCgLQ==",
+        "dependencies": {
+          "Microsoft.ApplicationInsights": "2.22.0",
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.Testing.Extensions.TrxReport.Abstractions": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "h34zKNpGyni66VH738mRHeXSnf3klSShUdavUWNhSfWICUUi5aXeI0LBvoX/ad93N0+9xBDU3Fyi6WfxrwKQGw==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.Testing.Extensions.VSTestBridge": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "cJD67YfDT98wEWyazKVD/yPVW6+H1usXeuselCnRes7JZBTIYWtrCchcOzOahnmajT79eDKqt9sta7DXwTDU4Q==",
+        "dependencies": {
+          "Microsoft.ApplicationInsights": "2.22.0",
+          "Microsoft.TestPlatform.ObjectModel": "17.12.0",
+          "Microsoft.Testing.Extensions.Telemetry": "1.5.3",
+          "Microsoft.Testing.Extensions.TrxReport.Abstractions": "1.5.3",
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.Testing.Platform": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "WqJydnJ99dEKtquR9HwINz104ehWJKTXbQQrydGatlLRw14bmsx0pa8+E6KUXMYXZAimN0swWlDmcJGjjW4TIg=="
+      },
+      "Microsoft.Testing.Platform.MSBuild": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "bOtpRMSPeT5YLQo+NNY8EtdNTphAUcmALjW4ABU7P0rb6yR2XAZau3TzNieLmR3lRuwudguWzzBhgcLRXwZh0A==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.TestPlatform.ObjectModel": {
+        "type": "Transitive",
+        "resolved": "17.14.0",
+        "contentHash": "3h7y7f/HuY8jdZa163p/55VmGw/fYJwrI8FOtsp4aEQAJaPgBr5LBS25uOfBwRYI95QDiByfaqSPBcWEvuHEwA=="
+      },
+      "Microsoft.TestPlatform.TestHost": {
+        "type": "Transitive",
+        "resolved": "17.14.0",
+        "contentHash": "8htQBKM92s/NXUI/U0/CKKLlvlDfWIo3/mbnY/GS/2XLkBGNIVQufmUpDIzznaZqUpdzspGSsJcLhVN8aRoMaA==",
+        "dependencies": {
+          "Microsoft.TestPlatform.ObjectModel": "17.14.0",
+          "Newtonsoft.Json": "13.0.3"
+        }
+      },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.3",
+        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
+      },
+      "SkiaSharp": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "53NOSUZ1Us+91Sm0uCkIivh/k7jOowRErZT2sIWwPFN9mLUvdxnE6rS4sWo4255+Rd2MWUSF+j0NMZHD6Cke+Q==",
+        "dependencies": {
+          "SkiaSharp.NativeAssets.Win32": "3.119.4",
+          "SkiaSharp.NativeAssets.macOS": "3.119.4"
+        }
+      },
+      "SkiaSharp.NativeAssets.Linux": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "UAyVzbqNfZsZbKbzj68zXLyUyF/SbTKmzTfOO6qDu++dtIUMMTzPBe8oOuzU/DiewpfKoUUlOSsJmqWc6blxBw=="
+      },
+      "SkiaSharp.NativeAssets.macOS": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "fgBOWEqbY012x7gMfJU4ezgz6dfhJb30Z6YdW35h85Zoe39+a8YNbAAwL29ihPfWoppg5AjvyKNzD1oCvlqWwA=="
+      },
+      "SkiaSharp.NativeAssets.WebAssembly": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "S1HOxtBbD4bYDtA2e9WH5TX+lxqRrTPvKjrjttRhxnHNNu7YY8VFo/LeCP7tNqoTA6PV+8vsvNbmRUEC2ip8RQ=="
+      },
+      "SkiaSharp.NativeAssets.Win32": {
+        "type": "Transitive",
+        "resolved": "3.119.4",
+        "contentHash": "XOpbx/4CReO2wYsq2s6rbvdauc6dntG4Zv499sHGTJ87bwZaFXszFkwql3+FIZMc8kUPeaj3Mx2ezIJmo8a1Kg=="
+      },
+      "System.Text.Json": {
+        "type": "Transitive",
+        "resolved": "6.0.10",
+        "contentHash": "NSB0kDipxn2ychp88NXWfFRFlmi1bst/xynOutbnpEfRCT9JZkZ7KOmF/I/hNKo2dILiMGnqblm+j1sggdLB9g=="
+      },
+      "Tmds.DBus.Protocol": {
+        "type": "Transitive",
+        "resolved": "0.92.0",
+        "contentHash": "h7IMakm0PF2jxiagoysoAjrzzLQ0UBdnSXQL5kb17YW0Fvyo12Tg96A99QkzwktWRrd7H+Uw9EzjasNLUfGYlA=="
+      },
+      "YamlDotNet": {
+        "type": "Transitive",
+        "resolved": "11.0.1",
+        "contentHash": "UvICfSN4gJfAmOsuY/go0hb5SFfr3ZYCXb7jg66yT7kh+wSJEt7tUiwuoCNMpt8ScEXLDwXttpFoWKWeirYU1A=="
+      },
+      "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.controls": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia.Controls.ColorPicker": "[12.0.5, )",
+          "DynamicLocalization.Core": "[2.1.2, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Media.LibVlc": "[1.0.0, )",
+          "GalNet.Media.Miniaudio": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Primitives.Builtins": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )",
+          "GalNet.Storage.FileSystem": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.gameview": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "CommunityToolkit.Mvvm": "[8.4.1, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "Irihi.Ursa": "[2.1.0, )",
+          "LibVLCSharp": "[3.10.0, )",
+          "LibVLCSharp.Avalonia": "[3.10.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.avalonia.rendering": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.avalonia.themes": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia.Themes.Fluent": "[12.0.5, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.debugging": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.editor.abstraction": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "[10.0.0, )"
+        }
+      },
+      "galnet.editor.shared": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Debugging": "[1.0.0, )",
+          "GalNet.Editor.Abstraction": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.gamehost": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.media.libvlc": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "LibVLCSharp": "[3.10.0, )"
+        }
+      },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.primitives.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "GalNet.Project.Contracts": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "galnet.sample.avalonia": {
+        "type": "Project",
+        "dependencies": {
+          "Avalonia": "[12.0.5, )",
+          "Avalonia.Desktop": "[12.0.5, )",
+          "Avalonia.Fonts.Inter": "[12.0.5, )",
+          "Avalonia.Themes.Fluent": "[12.0.5, )",
+          "CommunityToolkit.Mvvm": "[8.4.1, )",
+          "DynamicLocalization.Core": "[2.1.2, )",
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Avalonia.Controls": "[1.0.0, )",
+          "GalNet.Avalonia.GameHost": "[1.0.0, )",
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Avalonia.Themes": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Media.LibVlc": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Primitives.Builtins": "[1.0.0, )",
+          "GalNet.Project.Contracts": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )",
+          "GalNet.Storage.FileSystem": "[1.0.0, )",
+          "Irihi.Ursa": "[2.1.0, )",
+          "Irihi.Ursa.Themes.Semi": "[2.1.0, )",
+          "Microsoft.Extensions.DependencyInjection": "[10.0.0, )",
+          "Semi.Avalonia": "[12.0.1, )",
+          "Serilog": "[4.2.0, )",
+          "Serilog.Sinks.Console": "[6.0.0, )",
+          "Serilog.Sinks.File": "[7.0.0, )",
+          "VideoLAN.LibVLC.Windows": "[3.0.23.1, )"
+        }
+      },
+      "galnet.storage.filesystem": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.GameHost": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "Avalonia": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "eGDbwos1AMlOaXnGN5IQ+JGG3RViFFuyN3GP70irOSbqZt4H9A6quIP6uVFVni/bBczmt5ELGuHzN+lkLQSD1A==",
+        "dependencies": {
+          "Avalonia.BuildServices": "11.3.2",
+          "Avalonia.Remote.Protocol": "12.0.5",
+          "MicroCom.Runtime": "0.11.4"
+        }
+      },
+      "Avalonia.Controls.ColorPicker": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "EmYXjNZq5wevvvvbLTNvnDBnZfQ6YuFBPOwDc6IXMFFIFLY4WAfpi3Dr94/qmt55shDcMceogaUiNy0yyLf5NQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Remote.Protocol": "12.0.5"
+        }
+      },
+      "Avalonia.Desktop": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "L4bTMshYrhjSKu09Q60OHN1+Lfr9z7JsyRL6rfj3iQfjWm+5gsTl2viz5gyzDUgc/U5A7gf57e1spEX+nE/7zg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.HarfBuzz": "12.0.5",
+          "Avalonia.Native": "12.0.5",
+          "Avalonia.Skia": "12.0.5",
+          "Avalonia.Win32": "12.0.5",
+          "Avalonia.X11": "12.0.5"
+        }
+      },
+      "Avalonia.Fonts.Inter": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "50zhPwYVIaqE0vVyHQxqjclObXYBT23Vt8QhsZ11vKSXddMAgPMd6zEEGGG83s1b3xXH1hZukBFqGgVAkjyZtA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "Avalonia.Skia": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "cSLTpvzsm5JpUA1tQvuht3qN6oiy1PNRgbrp1g7jCSzAFf+OKZecSne+KT1apBQUkevciaHxwtAxLolPGD9izg==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "HarfBuzzSharp": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.3",
+          "HarfBuzzSharp.NativeAssets.WebAssembly": "8.3.1.3",
+          "SkiaSharp": "3.119.4",
+          "SkiaSharp.NativeAssets.Linux": "3.119.4",
+          "SkiaSharp.NativeAssets.WebAssembly": "3.119.4"
+        }
+      },
+      "Avalonia.Themes.Fluent": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "QfbziOuzNQzMd0uCbe//p4o1u6EAesEpX41fUCULBaLENd5OAT6iU0GiN9gzhSzVfSjHuxDcafXqJMxi3H3IhA==",
+        "dependencies": {
+          "Avalonia": "12.0.5"
+        }
+      },
+      "CommunityToolkit.Mvvm": {
+        "type": "CentralTransitive",
+        "requested": "[8.4.1, )",
+        "resolved": "8.4.1",
+        "contentHash": "BTRteP8SvFyd/4KAreIFJBcxD2O9trLxLDD/p8YkSDDrfFOzy2U8cHyz6r+5Eh4kDhJdzAVglei6a+Bh4jCpUA=="
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "DynamicLocalization.Core": {
+        "type": "CentralTransitive",
+        "requested": "[2.1.2, )",
+        "resolved": "2.1.2",
+        "contentHash": "UdDvJeBnNoif/bi73CBDi7GiOhGUB9EkKl3v0JTNdVcPhCqWY+Jy9qr4IqNS9bQ5Xwn6uTYimYLDqGNxEEDjqw==",
+        "dependencies": {
+          "System.Text.Json": "[6.0.10, 10.0.0)",
+          "YamlDotNet": "[11.0.1, 19.0.0)"
+        }
+      },
+      "Irihi.Ursa": {
+        "type": "CentralTransitive",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "G2wAmenCgMZkBOqs5MYRtlurhU2tAKKmcNJzjjaA9Mj5v3YIivuv7wyNpIpgYZ602sOZhFtQwYrCaLVUhn9Htw==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Avalonia.Shared": "0.4.0",
+          "Irihi.Avalonia.Shared.Contracts": "0.4.0"
+        }
+      },
+      "Irihi.Ursa.Themes.Semi": {
+        "type": "CentralTransitive",
+        "requested": "[2.1.0, )",
+        "resolved": "2.1.0",
+        "contentHash": "vz7iA6YcAqJ9Z34CXGtapsROERLjZ7vD1CqblO7V5NWQyrJ5igbAYSuFFWnZnPVFKkyKM/c43oGmcWjiDBLoHA==",
+        "dependencies": {
+          "Avalonia": "12.0.2",
+          "Irihi.Ursa": "2.1.0",
+          "Semi.Avalonia": "12.0.1"
+        }
+      },
+      "LibVLCSharp": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "VHuOfq8Xtb/lNz0asvCm5qDjgTmfB3m3lC40Dz9iH9oL3DM0fSXHjZaLxdtYVr5nsldJoh5BTeG8MtODprhC9Q=="
+      },
+      "LibVLCSharp.Avalonia": {
+        "type": "CentralTransitive",
+        "requested": "[3.10.0, )",
+        "resolved": "3.10.0",
+        "contentHash": "juoBLjh37+07kWDblbHLaWTQx1HsXOIJHU7aeH5/95xjN6dXfZMVE8ltg8NyaNL6vr2B4QgR3EiRBsEa+fPvlQ==",
+        "dependencies": {
+          "Avalonia": "11.3.13",
+          "LibVLCSharp": "3.10.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection": {
+        "type": "CentralTransitive",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "f0RBabswJq+gRu5a+hWIobrLWiUYPKMhCD9WO3sYBAdSy3FFH14LMvLVFZc2kPSCimBLxSuitUhsd6tb0TAY6A==",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.0"
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions": {
+        "type": "CentralTransitive",
+        "requested": "[10.0.0, )",
+        "resolved": "10.0.0",
+        "contentHash": "L3AdmZ1WOK4XXT5YFPEwyt0ep6l8lGIPs7F5OOBZc77Zqeo01Of7XXICy47628sdVl0v/owxYJTe86DTgFwKCA=="
+      },
+      "Semi.Avalonia": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.1, )",
+        "resolved": "12.0.1",
+        "contentHash": "WAjB/Clu8eD+AjLbCUV/fNwHdCk5iSwLoFyWG7UeBBbr8zP7GWQHDqr4EcDgY9vbTpynYFoOql72FCHxOPHjPA==",
+        "dependencies": {
+          "Avalonia": "12.0.1",
+          "Irihi.Avalonia.Shared": "0.4.0"
+        }
+      },
+      "Serilog": {
+        "type": "CentralTransitive",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      },
+      "Serilog.Sinks.Console": {
+        "type": "CentralTransitive",
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "fQGWqVMClCP2yEyTXPIinSr5c+CBGUvBybPxjAGcf7ctDhadFhrQw03Mv8rJ07/wR5PDfFjewf2LimvXCDzpbA==",
+        "dependencies": {
+          "Serilog": "4.0.0"
+        }
+      },
+      "Serilog.Sinks.File": {
+        "type": "CentralTransitive",
+        "requested": "[7.0.0, )",
+        "resolved": "7.0.0",
+        "contentHash": "fKL7mXv7qaiNBUC71ssvn/dU0k9t0o45+qm2XgKAlSt19xF+ijjxyA3R6HmCgfKEKwfcfkwWjayuQtRueZFkYw==",
+        "dependencies": {
+          "Serilog": "4.2.0"
+        }
+      },
+      "VideoLAN.LibVLC.Windows": {
+        "type": "CentralTransitive",
+        "requested": "[3.0.23.1, )",
+        "resolved": "3.0.23.1",
+        "contentHash": "yTGNrzj+Q/t72VNKK0d64jZ+8BGu5Vcp2nxpZ2ll350LkRWKSwqShGpZWcVxXVP8TiMbeGML09+Jzz3hNsIcqA=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/GalNet.IntegrationTests/packages.lock.json b/test/GalNet.IntegrationTests/packages.lock.json
index 077c6bab..7a7ce662 100644
--- a/test/GalNet.IntegrationTests/packages.lock.json
+++ b/test/GalNet.IntegrationTests/packages.lock.json
@@ -305,6 +305,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -312,20 +313,24 @@
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
       "galnet.avalonia.gamehost": {
         "type": "Project",
         "dependencies": {
+          "Avalonia.Controls.ColorPicker": "[12.0.5, )",
           "DynamicLocalization.Core": "[2.1.2, )",
           "GalNet.Assets": "[1.0.0, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.GameView": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Media.LibVlc": "[1.0.0, )",
+          "GalNet.Media.Miniaudio": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Primitives.Builtins": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )",
@@ -340,6 +345,7 @@
           "GalNet.Assets": "[1.0.0, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Irihi.Ursa": "[2.1.0, )",
@@ -354,6 +360,7 @@
         "dependencies": {
           "Avalonia": "[12.0.5, )",
           "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -362,7 +369,8 @@
         "dependencies": {
           "Avalonia.Themes.Fluent": "[12.0.5, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
-          "GalNet.Avalonia.GameView": "[1.0.0, )"
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )"
         }
       },
       "galnet.contracts.builtins": {
@@ -402,23 +410,41 @@
       "galnet.gamehost": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
         }
       },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.media.libvlc": {
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "LibVLCSharp": "[3.10.0, )"
         }
       },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -443,7 +469,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
@@ -486,6 +511,7 @@
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
@@ -502,6 +528,16 @@
           "MicroCom.Runtime": "0.11.4"
         }
       },
+      "Avalonia.Controls.ColorPicker": {
+        "type": "CentralTransitive",
+        "requested": "[12.0.5, )",
+        "resolved": "12.0.5",
+        "contentHash": "EmYXjNZq5wevvvvbLTNvnDBnZfQ6YuFBPOwDc6IXMFFIFLY4WAfpi3Dr94/qmt55shDcMceogaUiNy0yyLf5NQ==",
+        "dependencies": {
+          "Avalonia": "12.0.5",
+          "Avalonia.Remote.Protocol": "12.0.5"
+        }
+      },
       "Avalonia.Desktop": {
         "type": "CentralTransitive",
         "requested": "[12.0.5, )",
diff --git a/test/GalNet.Media.Audio.Tests/AudioEffectRuntimeTests.cs b/test/GalNet.Media.Audio.Tests/AudioEffectRuntimeTests.cs
new file mode 100644
index 00000000..db7dad6a
--- /dev/null
+++ b/test/GalNet.Media.Audio.Tests/AudioEffectRuntimeTests.cs
@@ -0,0 +1,63 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Runtime;
+using GalNet.Primitives.Builtins.Audio;
+
+namespace GalNet.Media.Audio.Tests;
+
+public sealed class AudioEffectRuntimeTests
+{
+    private static GameState State()
+    {
+        var builder = new StateCatalogBuilder();
+        builder.Register<AudioTrackState>("builtin.audio.tracks", value => value.Id, AudioRuntime.ValidateTrack);
+        builder.Register<AudioSEffectState>("builtin.audio.seffects", value => value.Key());
+        builder.Register<AudioChannelState>("builtin.audio.channels", value => value.Key(), AudioRuntime.ValidateChannel);
+        return new(builder.Build());
+    }
+    [Test]
+    public async Task UpdatePatchesParametersWithoutRestartAndInvalidPatchDoesNotPartiallyApply()
+    {
+        var configuration = new AudioConfiguration([new() { Id = "same" }], [new() { Id = "same" }]);
+        var host = new Host(); var state = State(); await using var runtime = new AudioRuntime(host); runtime.Bind(state);
+        runtime.ApplySEffect(configuration, new("same", "one", "seffect.reverb", JsonSerializer.SerializeToElement(new { mix = .2, roomSize = .7 })));
+        runtime.UpdateSEffect(configuration, "same", "one", JsonSerializer.SerializeToElement(new { mix = .4 }));
+        var effect = state.Table<AudioSEffectState>().Values.Single();
+        Assert.That(effect.Parameters.GetProperty("mix").GetSingle(), Is.EqualTo(.4f));
+        Assert.That(effect.Parameters.GetProperty("roomSize").GetSingle(), Is.EqualTo(.7f));
+        Assert.That(host.Requests.Any(request => request.Action == AudioBackendAction.Start), Is.False);
+        var before = effect.Parameters.GetRawText(); var count = host.Requests.Count;
+        runtime.UpdateSEffect(configuration, "same", "one", JsonSerializer.SerializeToElement(new { mix = .8, roomSize = 99 }));
+        runtime.UpdateSEffect(configuration, "same", "absent", JsonSerializer.SerializeToElement(new { mix = .9 }));
+        runtime.UpdateSEffect(configuration, "same", "one", JsonSerializer.Deserialize<JsonElement>("{\"mix\":0.2,\"mix\":0.3}"));
+        Assert.That(state.Table<AudioSEffectState>().Values.Single().Parameters.GetRawText(), Is.EqualTo(before));
+        Assert.That(host.Requests.Count, Is.EqualTo(count));
+    }
+    [Test]
+    public async Task StopAllIsExplicitAndKeepsOtherScopesTargetsAndFutureAttachments()
+    {
+        var configuration = new AudioConfiguration([new() { Id = "same" }, new() { Id = "other" }], [new() { Id = "same" }]);
+        var host = new Host(); var state = State(); await using var runtime = new AudioRuntime(host); runtime.Bind(state);
+        foreach (var (scope, target, instance) in new[] { (SEffectScope.Track, "same", "first"), (SEffectScope.Track, "same", "named"), (SEffectScope.Bus, "same", "named"), (SEffectScope.Track, "other", "named") })
+            runtime.ApplySEffect(configuration, new(target, instance, "seffect.reverb", JsonSerializer.SerializeToElement(new { }), scope));
+        runtime.StopSEffect(configuration, "same", "");
+        Assert.That(state.Table<AudioSEffectState>().Values.Count(), Is.EqualTo(4));
+        runtime.StopSEffect(configuration, "same", "named", all: true);
+        Assert.That(state.Table<AudioSEffectState>().Values.Count(), Is.EqualTo(4));
+        runtime.StopSEffect(configuration, "same", "", all: true);
+        Assert.That(state.Table<AudioSEffectState>().Values.Count(), Is.EqualTo(2));
+        Assert.That(state.Table<AudioSEffectState>().Values.Any(effect => effect.Scope == SEffectScope.Bus), Is.True);
+        runtime.ApplySEffect(configuration, new("same", "future", "seffect.reverb", JsonSerializer.SerializeToElement(new { })));
+        Assert.That(state.Table<AudioSEffectState>().Values.Count(), Is.EqualTo(3));
+        Assert.That(host.Requests.Count(request => request.Action == AudioBackendAction.StopSEffect), Is.EqualTo(2));
+    }
+    private sealed class Host : IAudioPlaybackHost
+    {
+        public List<AudioBackendRequest> Requests { get; } = [];
+        public AudioBackendCapabilities Capabilities { get; } = new(true, true, true, true);
+        public ISEffectCatalog SEffects => SEffectCatalog.Builtins;
+        public event Action<AudioBackendEvent>? EventReceived { add { } remove { } }
+        public Task ApplyAsync(AudioBackendRequest request, CancellationToken cancellationToken = default) { Requests.Add(request); return Task.CompletedTask; }
+        public void Dispose() { }
+    }
+}
diff --git a/test/GalNet.Media.Audio.Tests/AudioMixerRuntimeTests.cs b/test/GalNet.Media.Audio.Tests/AudioMixerRuntimeTests.cs
new file mode 100644
index 00000000..b510acae
--- /dev/null
+++ b/test/GalNet.Media.Audio.Tests/AudioMixerRuntimeTests.cs
@@ -0,0 +1,95 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Runtime;
+using GalNet.Primitives.Builtins.Audio;
+
+namespace GalNet.Media.Audio.Tests;
+
+public sealed class AudioMixerRuntimeTests
+{
+    private static AudioConfiguration Configuration(AudioPlaybackOrder order = AudioPlaybackOrder.Sequential, AudioTrackRepeat repeat = AudioTrackRepeat.None) =>
+        new([new() { Id = "a", BusId = "room", MaxQueuedItems = 10, PlaybackOrder = order, Repeat = repeat, PreserveDuringCatchUp = true }], [new() { Id = "room" }]);
+    private static GameState State()
+    {
+        var builder = new StateCatalogBuilder();
+        builder.Register<AudioTrackState>("builtin.audio.tracks", value => value.Id, AudioRuntime.ValidateTrack);
+        builder.Register<AudioSEffectState>("builtin.audio.seffects", value => value.Key());
+        builder.Register<AudioChannelState>("builtin.audio.channels", value => value.Key(), AudioRuntime.ValidateChannel);
+        return new(builder.Build());
+    }
+    [Test]
+    public async Task Bus_effects_and_levels_restore_before_start_without_voice_effect_copies()
+    {
+        var host = new Host(); var configuration = Configuration(); var state = State();
+        await using var runtime = new AudioRuntime(host); runtime.Bind(state);
+        runtime.ApplySEffect(configuration, new("room", "roomVerb", "seffect.reverb", JsonSerializer.Deserialize<JsonElement>("{\"roomSize\":0.7}"), SEffectScope.Bus));
+        runtime.SetLevel(configuration, new("room", SEffectScope.Bus, .4f));
+        runtime.Play(configuration, new("a", "music", AudioPlacement.Replace, .3f, FadeOutSeconds: .2f));
+        var first = host.Requests.Single(value => value.Action == AudioBackendAction.Start);
+        Assert.That(first.Gain, Is.EqualTo(.3f)); Assert.That(first.FadeOutSeconds, Is.EqualTo(.2f));
+        Assert.That(host.Requests.Where(value => value.Action == AudioBackendAction.ApplySEffect).All(value => value.VoiceId == ""), Is.True);
+        var restored = GameState.Restore(state.Catalog, state.Capture()); host.Requests.Clear();
+        await runtime.RestoreAsync(restored, configuration, default);
+        var start = host.Requests.FindIndex(value => value.Action == AudioBackendAction.Start);
+        Assert.That(host.Requests.FindIndex(value => value.Action == AudioBackendAction.ApplySEffect && value.Scope == SEffectScope.Bus), Is.InRange(0, start - 1));
+        Assert.That(host.Requests.FindIndex(value => value.Action == AudioBackendAction.SetLevel), Is.InRange(0, start - 1));
+        Assert.That(restored.Table<AudioChannelState>().Values.Single().Gain, Is.EqualTo(.4f));
+    }
+    [Test]
+    public async Task Catchup_discards_the_old_graph_and_projects_the_final_effects()
+    {
+        var host = new Host(); var configuration = Configuration();
+        await using var runtime = new AudioRuntime(host); runtime.Play(configuration, new("a", "music", AudioPlacement.Replace));
+        runtime.BeginCatchUp(); host.Requests.Clear();
+        runtime.ApplySEffect(configuration, new("room", "verb", "seffect.reverb", JsonSerializer.Deserialize<JsonElement>("{}"), SEffectScope.Bus));
+        Assert.That(host.Requests.Any(value => value.Action == AudioBackendAction.ApplySEffect), Is.False);
+        runtime.EndCatchUp();
+        Assert.That(host.Requests.Any(value => value.Action == AudioBackendAction.ApplySEffect && value.Scope == SEffectScope.Bus), Is.True);
+        Assert.That(host.Requests.Last().Action, Is.EqualTo(AudioBackendAction.Start));
+    }
+    [TestCase(AudioTrackRepeat.One, "first")]
+    [TestCase(AudioTrackRepeat.All, "second")]
+    [TestCase(AudioTrackRepeat.None, "second")]
+    public async Task Track_repeat_policy_decides_what_plays_after_an_instance_finishes(AudioTrackRepeat repeat, string next)
+    {
+        var host = new Host(); var configuration = Configuration(repeat: repeat);
+        await using var runtime = new AudioRuntime(host);
+        runtime.Play(configuration, new("a", "first", AudioPlacement.Enqueue));
+        runtime.Play(configuration, new("a", "second", AudioPlacement.Enqueue));
+        host.End(); Assert.That(host.Requests.Last(value => value.Action == AudioBackendAction.Start).AssetId, Is.EqualTo(next));
+        if (repeat == AudioTrackRepeat.All) { host.End(); Assert.That(host.Requests.Last(value => value.Action == AudioBackendAction.Start).AssetId, Is.EqualTo("first")); }
+    }
+    [Test]
+    public async Task Random_selection_is_reproducible_after_state_restore()
+    {
+        var configuration = Configuration(AudioPlaybackOrder.Random); var host = new Host(); var state = State();
+        await using var runtime = new AudioRuntime(host); runtime.Bind(state); runtime.Pause(configuration, "a");
+        foreach (var asset in new[] { "one", "two", "three", "four" }) runtime.Play(configuration, new("a", asset, AudioPlacement.Enqueue));
+        var snapshot = state.Capture(); runtime.Resume(configuration, "a"); var original = host.Requests.Last(value => value.Action == AudioBackendAction.Start).AssetId;
+        var restored = GameState.Restore(state.Catalog, snapshot); await runtime.RestoreAsync(restored, configuration, default);
+        runtime.Resume(configuration, "a"); Assert.That(host.Requests.Last(value => value.Action == AudioBackendAction.Start).AssetId, Is.EqualTo(original));
+    }
+    [Test]
+    public async Task Stop_defaults_to_the_instance_fade_out_and_explicit_zero_cuts_immediately()
+    {
+        var configuration = Configuration(); var host = new Host();
+        await using var runtime = new AudioRuntime(host);
+        runtime.Play(configuration, new("a", "one", AudioPlacement.Replace, FadeOutSeconds: .5f));
+        runtime.Stop(configuration, new("a", true));
+        Assert.That(host.Requests.Last(value => value.Action == AudioBackendAction.Stop).FadeSeconds, Is.EqualTo(.5f));
+        runtime.Play(configuration, new("a", "two", AudioPlacement.Replace, FadeOutSeconds: .5f));
+        runtime.Stop(configuration, new("a", true, 0));
+        Assert.That(host.Requests.Last(value => value.Action == AudioBackendAction.Stop).FadeSeconds, Is.Zero);
+    }
+
+    private sealed class Host : IAudioPlaybackHost
+    {
+        public List<AudioBackendRequest> Requests { get; } = [];
+        public AudioBackendCapabilities Capabilities { get; } = new(true, true, true, true);
+        public ISEffectCatalog SEffects => SEffectCatalog.Builtins;
+        public event Action<AudioBackendEvent>? EventReceived;
+        public Task ApplyAsync(AudioBackendRequest request, CancellationToken cancellationToken = default) { Requests.Add(request); return Task.CompletedTask; }
+        public void End() { var voice = Requests.Last(value => value.Action == AudioBackendAction.Start); EventReceived?.Invoke(new(AudioBackendEventKind.Ended, voice.TrackId, voice.VoiceId, voice.Generation)); }
+        public void Dispose() { }
+    }
+}
diff --git a/test/GalNet.Media.Audio.Tests/AudioOutputLifecycleTests.cs b/test/GalNet.Media.Audio.Tests/AudioOutputLifecycleTests.cs
new file mode 100644
index 00000000..e18cb76d
--- /dev/null
+++ b/test/GalNet.Media.Audio.Tests/AudioOutputLifecycleTests.cs
@@ -0,0 +1,99 @@
+using System.Collections.Concurrent;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Assets;
+
+namespace GalNet.Media.Audio.Tests;
+
+public sealed class AudioOutputLifecycleTests
+{
+    [Test]
+    public async Task Suspending_output_retains_voices_leases_and_story_pause_state_until_resume()
+    {
+        var files = new Files();
+        var output = new Output();
+        await using var host = new PcmAudioPlaybackHost(files, _ => new Decoder(), output);
+        var events = new ConcurrentQueue<AudioBackendEvent>();
+        host.EventReceived += events.Enqueue;
+        await host.ApplyAsync(new(AudioBackendAction.Configure, "", "", 0, Configuration: new([new() { Id = "test" }])));
+        await host.ApplyAsync(new(AudioBackendAction.Start, "test", "voice", 1, "clip"));
+        Assert.That(host.SupportsOutputSuspension, Is.True);
+        host.SuspendOutput();
+        host.SuspendOutput();
+        Assert.That(output.Suspends, Is.EqualTo(1));
+        Assert.That(output.Pull().All(sample => sample == 0), Is.True);
+        Assert.That(files.Releases, Is.Zero);
+        Assert.That(events.Select(value => value.Kind), Is.EqualTo(new[] { AudioBackendEventKind.Started }));
+
+        // A story pause is independent of a system interruption.
+        await host.ApplyAsync(new(AudioBackendAction.Pause, "test", "voice", 1));
+        host.ResumeOutput();
+        host.ResumeOutput();
+        Assert.That(output.Resumes, Is.EqualTo(1));
+        Assert.That(output.Pull().All(sample => sample == 0), Is.True);
+        await host.ApplyAsync(new(AudioBackendAction.Resume, "test", "voice", 1));
+        Assert.That(output.Pull().Any(sample => sample > 0), Is.True);
+        await host.DisposeAsync();
+        Assert.That(files.Releases, Is.EqualTo(1));
+        Assert.That(output.Disposed, Is.True);
+        Assert.Throws<ObjectDisposedException>(() => host.ResumeOutput());
+    }
+
+    [Test]
+    public async Task Failed_resume_can_be_retried_without_changing_the_suspended_state()
+    {
+        var output = new Output { FailResume = true };
+        await using var host = new PcmAudioPlaybackHost(new Files(), _ => new Decoder(), output);
+        host.SuspendOutput();
+        Assert.Throws<IOException>(() => host.ResumeOutput());
+        Assert.That(output.Suspended, Is.True);
+        output.FailResume = false;
+        host.ResumeOutput();
+        Assert.That(output.Suspended, Is.False);
+        Assert.That(output.Resumes, Is.EqualTo(1));
+    }
+
+    [Test]
+    public async Task Outputs_without_lifecycle_support_report_the_capability_and_reject_suspension()
+    {
+        await using var host = new PcmAudioPlaybackHost(new Files(), _ => new Decoder(), new SimpleOutput());
+        Assert.That(host.SupportsOutputSuspension, Is.False);
+        Assert.Throws<NotSupportedException>(() => host.SuspendOutput());
+    }
+
+    private sealed class Output : IAudioOutput, IAudioOutputLifecycle
+    {
+        private AudioRenderCallback? _render;
+        public int Suspends { get; private set; }
+        public int Resumes { get; private set; }
+        public bool Suspended { get; private set; }
+        public bool Disposed { get; private set; }
+        public bool FailResume { get; set; }
+        public void Start(AudioRenderCallback render) => _render = render;
+        public void SuspendOutput() { Suspends++; Suspended = true; }
+        public void ResumeOutput() { if (FailResume) throw new IOException("Device temporarily unavailable."); Resumes++; Suspended = false; }
+        public float[] Pull() { var samples = new float[960]; if (!Suspended) _render!(samples); return samples; }
+        public void Dispose() { Disposed = true; _render = null; }
+    }
+
+    private sealed class SimpleOutput : IAudioOutput
+    {
+        public void Start(AudioRenderCallback render) { }
+        public void Dispose() { }
+    }
+
+    private sealed class Decoder : IAudioPcmDecoder
+    {
+        public double DurationSeconds => 10;
+        public int Read(Span<float> samples) { samples.Fill(.25f); return samples.Length; }
+        public void Dispose() { }
+    }
+
+    private sealed class Files : IAssetFileMaterializer
+    {
+        public int Releases;
+        public Task<AssetFileLease> AcquireAsync(string assetId, CancellationToken cancellationToken = default) =>
+            Task.FromResult(new AssetFileLease(assetId, "audio", assetId, () => Interlocked.Increment(ref Releases)));
+        public void Dispose() { }
+        public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+    }
+}
diff --git a/test/GalNet.Media.Audio.Tests/Fixtures/README.md b/test/GalNet.Media.Audio.Tests/Fixtures/README.md
new file mode 100644
index 00000000..eaa798e6
--- /dev/null
+++ b/test/GalNet.Media.Audio.Tests/Fixtures/README.md
@@ -0,0 +1 @@
+`tone.ogg` is a GalNet-generated 440 Hz sine wave (2 seconds, mono), encoded with LibVLC's Vorbis encoder solely for decoder regression tests. It contains no recorded or third-party audio. The tests copy it to a Unicode filename and verify the new backend's decoding and duration query.
diff --git a/test/GalNet.Media.Audio.Tests/Fixtures/tone.ogg b/test/GalNet.Media.Audio.Tests/Fixtures/tone.ogg
new file mode 100644
index 00000000..f994b731
Binary files /dev/null and b/test/GalNet.Media.Audio.Tests/Fixtures/tone.ogg differ
diff --git a/test/GalNet.Media.Audio.Tests/GalNet.Media.Audio.Tests.csproj b/test/GalNet.Media.Audio.Tests/GalNet.Media.Audio.Tests.csproj
new file mode 100644
index 00000000..a8d772e6
--- /dev/null
+++ b/test/GalNet.Media.Audio.Tests/GalNet.Media.Audio.Tests.csproj
@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup><TargetFramework>net10.0</TargetFramework></PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="../../src/Infrastructure/GalNet.Media.Miniaudio/GalNet.Media.Miniaudio.csproj" />
+    <ProjectReference Include="../../src/Shared/GalNet.Primitives.Builtins/GalNet.Primitives.Builtins.csproj" />
+  </ItemGroup>
+  <ItemGroup><Content Include="Fixtures/tone.ogg" CopyToOutputDirectory="PreserveNewest" /></ItemGroup>
+</Project>
diff --git a/test/GalNet.Media.Audio.Tests/MiniaudioTests.cs b/test/GalNet.Media.Audio.Tests/MiniaudioTests.cs
new file mode 100644
index 00000000..dcc19d4f
--- /dev/null
+++ b/test/GalNet.Media.Audio.Tests/MiniaudioTests.cs
@@ -0,0 +1,110 @@
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Assets;
+using GalNet.Media.Miniaudio;
+
+namespace GalNet.Media.Audio.Tests;
+
+public sealed class MiniaudioTests
+{
+    [Test]
+    public void Vorbis_decoder_supports_unicode_files_and_reports_duration_for_natural_fade_out()
+    {
+        var path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "GalNet-混响-" + Guid.NewGuid().ToString("N") + ".ogg");
+        File.Copy(System.IO.Path.Combine(AppContext.BaseDirectory, "Fixtures", "tone.ogg"), path);
+        try
+        {
+            using var decoder = new MiniaudioDecoder(path);
+            Assert.That(decoder.DurationSeconds, Is.InRange(1.5, 2.1));
+            var buffer = new float[9600];
+            var count = decoder.Read(buffer);
+            Assert.That(count, Is.GreaterThan(0));
+            Assert.That(buffer.Any(sample => MathF.Abs(sample) > .001f), Is.True);
+            long samples = count;
+            while ((count = decoder.Read(buffer)) > 0) samples += count;
+            Assert.That(decoder.DurationSeconds, Is.EqualTo(samples / (2d * PcmMixer.SampleRate)).Within(.01));
+        }
+        finally { File.Delete(path); }
+    }
+
+    [Test]
+    public void Native_decoder_reads_unicode_paths_and_converts_mono_to_48k_stereo()
+    {
+        using var file = new WaveFile();
+        using var decoder = new MiniaudioDecoder(file.Path);
+        var buffer = new float[960];
+        Assert.That(decoder.DurationSeconds, Is.EqualTo(.1).Within(.002));
+        Assert.That(decoder.Read(buffer), Is.EqualTo(buffer.Length));
+        Assert.That(buffer.Any(sample => MathF.Abs(sample) > .001f), Is.True);
+        for (var index = 0; index < buffer.Length; index += 2) Assert.That(buffer[index], Is.EqualTo(buffer[index + 1]).Within(.00001));
+    }
+
+    [Test, Explicit("Opens the platform's default audio device and plays a quiet 100 ms signal.")]
+    public async Task Windows_device_renders_a_real_source_and_completes_with_its_lease_released()
+    {
+        using var file = new WaveFile();
+        await using var host = new MiniaudioAudioPlaybackHost(file);
+        Assert.That(host.InitializationError, Is.Null);
+        var ended = new TaskCompletionSource<AudioBackendEvent>(TaskCreationOptions.RunContinuationsAsynchronously);
+        host.EventReceived += value => { if (value.Kind is AudioBackendEventKind.Ended or AudioBackendEventKind.Failed) ended.TrySetResult(value); };
+        await host.ApplyAsync(new(AudioBackendAction.Configure, "", "", 0, Configuration: new([new() { Id = "test", BusId = "room" }], [new() { Id = "room" }])));
+        await host.ApplyAsync(new(AudioBackendAction.ApplySEffect, "room", "", 0, SEffectId: "seffect.reverb", SEffectInstanceId: "space",
+            SEffectParameters: System.Text.Json.JsonSerializer.Deserialize<System.Text.Json.JsonElement>("{}"), Scope: SEffectScope.Bus));
+        await host.ApplyAsync(new(AudioBackendAction.Start, "test", "voice", 1, "test", Gain: .01f));
+        await host.ApplyAsync(new(AudioBackendAction.ApplySEffect, "test", "", 0, SEffectId: "seffect.lowPass", SEffectInstanceId: "filter",
+            SEffectParameters: System.Text.Json.JsonSerializer.Deserialize<System.Text.Json.JsonElement>("{\"cutoffHz\":500}")));
+        await Task.Delay(20);
+        await host.ApplyAsync(new(AudioBackendAction.StopSEffect, "test", "", 0, SEffectInstanceId: "filter"));
+        var terminal = await ended.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        Assert.That(terminal.Kind, Is.EqualTo(AudioBackendEventKind.Ended)); Assert.That(file.Releases, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void Decoder_rejects_paths_that_would_be_truncated_by_the_native_abi()
+    {
+        Assert.Throws<ArgumentException>(() => new MiniaudioDecoder("valid.wav\0different.wav"));
+    }
+
+    [Test, Explicit("Opens the platform's default audio device to verify native callback and suspension lifetimes.")]
+    public async Task Native_output_suspends_callbacks_resumes_and_does_not_leak_a_callback_after_disposal()
+    {
+        var output = new MiniaudioOutput();
+        var callbacks = 0;
+        var started = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        try
+        {
+            output.Start(samples => { samples.Clear(); Interlocked.Increment(ref callbacks); started.TrySetResult(); });
+            await started.Task.WaitAsync(TimeSpan.FromSeconds(5));
+            Assert.Throws<InvalidOperationException>(() => output.Start(samples => samples.Clear()));
+            output.SuspendOutput();
+            var stoppedAt = Volatile.Read(ref callbacks);
+            await Task.Delay(50);
+            Assert.That(Volatile.Read(ref callbacks), Is.EqualTo(stoppedAt));
+            output.ResumeOutput();
+            using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+            while (Volatile.Read(ref callbacks) == stoppedAt) await Task.Delay(5, timeout.Token);
+            output.Dispose();
+            stoppedAt = Volatile.Read(ref callbacks);
+            await Task.Delay(50);
+            Assert.That(Volatile.Read(ref callbacks), Is.EqualTo(stoppedAt));
+            Assert.Throws<ObjectDisposedException>(() => output.ResumeOutput());
+        }
+        finally { output.Dispose(); }
+    }
+
+    private sealed class WaveFile : IAssetFileMaterializer
+    {
+        public string Path { get; } = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "GalNet-音频-" + Guid.NewGuid().ToString("N") + ".wav");
+        public int Releases { get; private set; }
+        public WaveFile()
+        {
+            using var writer = new BinaryWriter(File.Create(Path));
+            writer.Write("RIFF"u8); writer.Write(36 + 1600); writer.Write("WAVEfmt "u8); writer.Write(16);
+            writer.Write((short)1); writer.Write((short)1); writer.Write(8000); writer.Write(16000);
+            writer.Write((short)2); writer.Write((short)16); writer.Write("data"u8); writer.Write(1600);
+            for (var index = 0; index < 800; index++) writer.Write((short)(Math.Sin(index * 2 * Math.PI * 440 / 8000) * 3000));
+        }
+        public Task<AssetFileLease> AcquireAsync(string assetId, CancellationToken cancellationToken = default) => Task.FromResult(new AssetFileLease(assetId, "audio", Path, () => Releases++));
+        public void Dispose() => File.Delete(Path);
+        public ValueTask DisposeAsync() { Dispose(); return ValueTask.CompletedTask; }
+    }
+}
diff --git a/test/GalNet.Media.Audio.Tests/PcmAudioLifetimeTests.cs b/test/GalNet.Media.Audio.Tests/PcmAudioLifetimeTests.cs
new file mode 100644
index 00000000..0a2fc1b0
--- /dev/null
+++ b/test/GalNet.Media.Audio.Tests/PcmAudioLifetimeTests.cs
@@ -0,0 +1,74 @@
+using System.Collections.Concurrent;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Assets;
+
+namespace GalNet.Media.Audio.Tests;
+
+public sealed class PcmAudioLifetimeTests
+{
+    [Test]
+    public async Task Missing_device_keeps_portable_effect_contracts_and_reports_playback_failure()
+    {
+        using var files = new Files();
+        await using var host = new PcmAudioPlaybackHost(files, _ => new Decoder(), new UnavailableOutput());
+        Assert.That(host.InitializationError, Does.Contain("unavailable"));
+        Assert.That(host.SEffects.TryGet("seffect.reverb", out _), Is.True);
+        Assert.That(host.Capabilities.SupportsMixer, Is.True);
+        var events = new ConcurrentQueue<AudioBackendEvent>(); host.EventReceived += events.Enqueue;
+        await host.ApplyAsync(new(AudioBackendAction.Configure, "", "", 0, Configuration: new([new() { Id = "test" }])));
+        await host.ApplyAsync(new(AudioBackendAction.Start, "test", "voice", 1, "good"));
+        Assert.That(events.Single().Kind, Is.EqualTo(AudioBackendEventKind.Failed));
+        Assert.That(files.Releases, Is.Zero);
+    }
+
+    [Test]
+    public async Task A_lease_release_failure_does_not_stop_other_terminal_cleanup_or_observers()
+    {
+        using var files = new Files(); using var output = new Output();
+        var host = new PcmAudioPlaybackHost(files, _ => new Decoder(), output);
+        var events = new ConcurrentQueue<AudioBackendEvent>();
+        host.EventReceived += _ => throw new InvalidOperationException("Observer failed.");
+        host.EventReceived += events.Enqueue;
+        try
+        {
+            await host.ApplyAsync(new(AudioBackendAction.Configure, "", "", 0, Configuration: new([new() { Id = "test", MaxVoices = 2 }])));
+            await host.ApplyAsync(new(AudioBackendAction.Start, "test", "bad", 1, "bad"));
+            await host.ApplyAsync(new(AudioBackendAction.Start, "test", "good", 2, "good"));
+            output.Pull();
+            using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(3));
+            while (events.Count(value => value.Kind is AudioBackendEventKind.Ended or AudioBackendEventKind.Failed) < 2)
+            { output.Pull(); await Task.Delay(5, timeout.Token); }
+            Assert.That(files.Releases, Is.EqualTo(2));
+            Assert.That(events.Single(value => value.VoiceId == "bad" && value.Kind != AudioBackendEventKind.Started).Kind, Is.EqualTo(AudioBackendEventKind.Failed));
+            Assert.That(events.Single(value => value.VoiceId == "good" && value.Kind != AudioBackendEventKind.Started).Kind, Is.EqualTo(AudioBackendEventKind.Ended));
+        }
+        finally { Assert.ThrowsAsync<AggregateException>(async () => await host.DisposeAsync()); }
+    }
+    private sealed class Output : IAudioOutput
+    {
+        private AudioRenderCallback? _callback;
+        public void Start(AudioRenderCallback render) => _callback = render;
+        public void Pull() { var buffer = new float[960]; _callback!(buffer); }
+        public void Dispose() => _callback = null;
+    }
+    private sealed class UnavailableOutput : IAudioOutput
+    {
+        public void Start(AudioRenderCallback render) => throw new PlatformNotSupportedException("Device unavailable.");
+        public void Dispose() { }
+    }
+    private sealed class Decoder : IAudioPcmDecoder
+    {
+        private bool _read;
+        public double DurationSeconds => .001;
+        public int Read(Span<float> samples) { if (_read) return 0; samples[..96].Fill(.1f); _read = true; return 96; }
+        public void Dispose() { }
+    }
+    private sealed class Files : IAssetFileMaterializer
+    {
+        public int Releases;
+        public Task<AssetFileLease> AcquireAsync(string assetId, CancellationToken cancellationToken = default) =>
+            Task.FromResult(new AssetFileLease(assetId, "audio", assetId, () => { Interlocked.Increment(ref Releases); if (assetId == "bad") throw new IOException("Release failed."); }));
+        public void Dispose() { }
+        public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+    }
+}
diff --git a/test/GalNet.Media.Audio.Tests/PcmMixerTests.cs b/test/GalNet.Media.Audio.Tests/PcmMixerTests.cs
new file mode 100644
index 00000000..674c3557
--- /dev/null
+++ b/test/GalNet.Media.Audio.Tests/PcmMixerTests.cs
@@ -0,0 +1,162 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Media.Audio;
+
+namespace GalNet.Media.Audio.Tests;
+
+public sealed class PcmMixerTests
+{
+    private static AudioConfiguration Configuration => new([new() { Id = "a", BusId = "room" }, new() { Id = "b", BusId = "room" }], [new() { Id = "room" }]);
+    private static AudioSEffectState Effect(string target, string id, string parameters, SEffectScope scope = SEffectScope.Track, string instance = "fx") =>
+        new(target, instance, id, JsonSerializer.Deserialize<JsonElement>(parameters), scope);
+    private static void Add(PcmMixer mixer, string track, IAudioPcmSource source, float gain = 1, float fadeIn = 0, float fadeOut = 0) =>
+        mixer.Add(new(new(AudioBackendAction.Start, track, Guid.NewGuid().ToString(), 1, Gain: gain, FadeSeconds: fadeIn, FadeOutSeconds: fadeOut), mixer.Target(SEffectScope.Track, track), source));
+    private static float[] Render(PcmMixer mixer, int frames = 48_000)
+    { var output = new float[frames * 2]; mixer.Render(output); return output; }
+    private static double Rms(float[] samples, int skip = 12_000) => Math.Sqrt(samples.Skip(skip).Select(sample => (double)sample * sample).Average());
+
+    [TestCase("seffect.lowPass", 200f, 8000f)]
+    [TestCase("seffect.highPass", 8000f, 100f)]
+    public void Filter_has_real_passband_and_continues_rejecting_beyond_one_octave(string id, float pass, float reject)
+    {
+        double Measure(float frequency)
+        {
+            var mixer = new PcmMixer(); mixer.Configure(Configuration);
+            mixer.Target(SEffectScope.Track, "a").ApplyEffect(Effect("a", id, """{"cutoffHz":1000,"q":0.7071068}"""));
+            Add(mixer, "a", new Sine(frequency)); return Rms(Render(mixer));
+        }
+        Assert.That(Measure(pass), Is.GreaterThan(.06));
+        Assert.That(Measure(reject), Is.LessThan(.002));
+    }
+
+    [Test]
+    public void Bus_chain_processes_the_sum_once_and_track_effect_is_local()
+    {
+        var mixer = new PcmMixer(); mixer.Configure(Configuration);
+        mixer.Target(SEffectScope.Track, "a").ApplyEffect(Effect("a", "seffect.gain", """{"gain":0.5}"""));
+        mixer.Target(SEffectScope.Bus, "room").ApplyEffect(Effect("room", "seffect.gain", """{"gain":0.5}""", SEffectScope.Bus));
+        Add(mixer, "a", new Constant(.2f)); Add(mixer, "b", new Constant(.2f));
+        Assert.That(Render(mixer)[^2], Is.EqualTo(.15f).Within(.0001));
+    }
+
+    [Test]
+    public void Reverb_keeps_a_tail_after_the_source_has_ended_and_master_mute_covers_it()
+    {
+        var mixer = new PcmMixer(); mixer.Configure(Configuration);
+        mixer.Target(SEffectScope.Bus, "room").ApplyEffect(Effect("room", "seffect.reverb", """{"roomSize":0.6,"decaySeconds":2,"damping":0.3,"mix":0.5}""", SEffectScope.Bus));
+        Render(mixer, 1000); // Complete the effect's bypass ramp before the impulse.
+        Add(mixer, "a", new Impulse());
+        var output = Render(mixer, 48_000);
+        Assert.That(mixer.Voices.Single().Ended, Is.True);
+        Assert.That(output.Skip(12_000).Max(MathF.Abs), Is.GreaterThan(.00001));
+        mixer.ApplyMix(new() { MasterMuted = true });
+        Assert.That(Render(mixer, 2000).Skip(1000).All(sample => sample == 0), Is.True);
+        mixer.Reset(); mixer.Configure(Configuration);
+        Assert.That(Render(mixer, 2000).All(sample => sample == 0), Is.True);
+    }
+
+    [Test]
+    public void Applying_updating_and_removing_an_effect_never_restarts_a_voice_or_breaks_the_signal()
+    {
+        var mixer = new PcmMixer(); mixer.Configure(Configuration);
+        var source = new Constant(.1f); Add(mixer, "a", source);
+        var target = mixer.Target(SEffectScope.Track, "a");
+        Render(mixer, 1000);
+        target.ApplyEffect(Effect("a", "seffect.lowPass", """{"cutoffHz":2000}"""));
+        var first = Render(mixer, 2000);
+        target.ApplyEffect(Effect("a", "seffect.lowPass", """{"cutoffHz":500}"""));
+        var second = Render(mixer, 2000);
+        target.StopEffect("fx"); var third = Render(mixer, 2000);
+        var output = first.Concat(second).Concat(third).ToArray();
+        Assert.That(output.All(sample => float.IsFinite(sample) && sample > .08f), Is.True);
+        Assert.That(source.ReadSamples, Is.EqualTo(14_000));
+        Assert.That(mixer.Voices.Single().Ended, Is.False);
+    }
+
+    [Test]
+    public void Effects_are_ordered_and_updates_preserve_their_position()
+    {
+        double Measure(bool gainFirst)
+        {
+            var mixer = new PcmMixer(); mixer.Configure(Configuration); var channel = mixer.Target(SEffectScope.Track, "a");
+            var gain = Effect("a", "seffect.gain", """{"gain":0}""", instance: "gain");
+            var reverb = Effect("a", "seffect.reverb", """{"mix":1,"decaySeconds":2}""", instance: "verb");
+            channel.ApplyEffect(gainFirst ? gain : reverb); channel.ApplyEffect(gainFirst ? reverb : gain);
+            Render(mixer, 1000);
+            // Build a reverb tail, then close gain without moving the existing effect.
+            channel.ApplyEffect(gain with { Parameters = JsonSerializer.Deserialize<JsonElement>("{\"gain\":1}") });
+            Add(mixer, "a", new Sine(400)); Render(mixer, 10_000);
+            channel.ApplyEffect(gain); return Rms(Render(mixer, 8000), 2000);
+        }
+        Assert.That(Measure(true), Is.GreaterThan(.0001));
+        Assert.That(Measure(false), Is.LessThan(.000001));
+    }
+
+    [Test]
+    public void Instance_fades_are_independent_and_pause_then_stop_retires()
+    {
+        var mixer = new PcmMixer(); mixer.Configure(Configuration);
+        Add(mixer, "a", new Constant(.2f), fadeIn: .02f);
+        var output = Render(mixer, 1920);
+        Assert.That(output[0], Is.Zero); Assert.That(output[1920], Is.EqualTo(.2f).Within(.001));
+        var voice = mixer.Voices.Single(); voice.Paused = true; voice.Stop(.01f);
+        Assert.That(Render(mixer, 1024).All(sample => sample == 0), Is.True);
+        Assert.That(voice.Ended, Is.True);
+    }
+
+    [Test]
+    public void Stop_then_reapply_appends_an_effect_and_type_updates_leave_only_one_active_instance()
+    {
+        var mixer = new PcmMixer(); mixer.Configure(Configuration);
+        var channel = mixer.Target(SEffectScope.Track, "a");
+        var gain = Effect("a", "seffect.gain", "{\"gain\":1}", instance: "gate");
+        channel.ApplyEffect(gain);
+        channel.ApplyEffect(Effect("a", "seffect.reverb", "{\"mix\":1}"));
+        Add(mixer, "a", new Sine(400)); Render(mixer, 10_000);
+        channel.StopEffect("gate");
+        channel.ApplyEffect(gain with { Parameters = JsonSerializer.Deserialize<JsonElement>("{\"gain\":0}") });
+        Assert.That(Rms(Render(mixer, 8000), 2000), Is.LessThan(.000001), "Re-applied gain is after the existing reverb, and must mute its tail.");
+
+        mixer.Reset(); mixer.Configure(Configuration); channel = mixer.Target(SEffectScope.Track, "a");
+        Add(mixer, "a", new Constant(.1f));
+        channel.ApplyEffect(Effect("a", "seffect.lowPass", "{\"cutoffHz\":1000}")); Render(mixer, 1000);
+        channel.ApplyEffect(Effect("a", "seffect.gain", "{\"gain\":0.5}")); Render(mixer, 1000);
+        channel.ApplyEffect(Effect("a", "seffect.lowPass", "{\"cutoffHz\":500}"));
+        Assert.That(Render(mixer, 2000)[^2], Is.EqualTo(.1f).Within(.0001));
+    }
+
+    [Test]
+    public void Steady_state_render_does_not_allocate()
+    {
+        var mixer = new PcmMixer(); mixer.Configure(Configuration);
+        mixer.Target(SEffectScope.Bus, "room").ApplyEffect(Effect("room", "seffect.reverb", "{}", SEffectScope.Bus));
+        Add(mixer, "a", new Sine(440)); var buffer = new float[2048];
+        for (var index = 0; index < 10; index++) mixer.Render(buffer);
+        var allocated = GC.GetAllocatedBytesForCurrentThread();
+        for (var index = 0; index < 100; index++) mixer.Render(buffer);
+        Assert.That(GC.GetAllocatedBytesForCurrentThread() - allocated, Is.Zero);
+    }
+
+    private sealed class Sine(float frequency) : IAudioPcmSource
+    {
+        private long _frame;
+        public double DurationSeconds => 0;
+        public bool IsFinished => false;
+        public int Read(Span<float> samples)
+        { for (var index = 0; index < samples.Length; index += 2) samples[index] = samples[index + 1] = .1f * MathF.Sin(2 * MathF.PI * frequency * _frame++ / PcmMixer.SampleRate); return samples.Length; }
+    }
+    private sealed class Constant(float value) : IAudioPcmSource
+    {
+        public int ReadSamples { get; private set; }
+        public double DurationSeconds => 0;
+        public bool IsFinished => false;
+        public int Read(Span<float> samples) { samples.Fill(value); ReadSamples += samples.Length; return samples.Length; }
+    }
+    private sealed class Impulse : IAudioPcmSource
+    {
+        private bool _done;
+        public double DurationSeconds => 1d / PcmMixer.SampleRate;
+        public bool IsFinished => _done;
+        public int Read(Span<float> samples) { if (_done) return 0; samples[0] = samples[1] = .5f; _done = true; return 2; }
+    }
+}
diff --git a/test/GalNet.Media.Audio.Tests/packages.lock.json b/test/GalNet.Media.Audio.Tests/packages.lock.json
new file mode 100644
index 00000000..e9150b93
--- /dev/null
+++ b/test/GalNet.Media.Audio.Tests/packages.lock.json
@@ -0,0 +1,184 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net10.0": {
+      "coverlet.collector": {
+        "type": "Direct",
+        "requested": "[6.0.4, )",
+        "resolved": "6.0.4",
+        "contentHash": "lkhqpF8Pu2Y7IiN7OntbsTtdbpR1syMsm2F3IgX6ootA4ffRqWL5jF7XipHuZQTdVuWG/gVAAcf8mjk8Tz0xPg=="
+      },
+      "Microsoft.NET.Test.Sdk": {
+        "type": "Direct",
+        "requested": "[17.14.0, )",
+        "resolved": "17.14.0",
+        "contentHash": "rTtdOm6C96q9QgP3mS8nUGPGPh5Xm2HnBYJggNmNrJ3LDmX9lJuUIgnJEfvX6wSQY4swUMiCcIXd3OkjhYCgtw==",
+        "dependencies": {
+          "Microsoft.CodeCoverage": "17.14.0",
+          "Microsoft.TestPlatform.TestHost": "17.14.0"
+        }
+      },
+      "NUnit": {
+        "type": "Direct",
+        "requested": "[4.3.2, )",
+        "resolved": "4.3.2",
+        "contentHash": "puVXayXNmEu7MFQSUswGmUjOy3M3baprMbkLl5PAutpeDoGTr+jPv33qAYsqxywi2wJCq8l/O3EhHoLulPE1iQ=="
+      },
+      "NUnit.Analyzers": {
+        "type": "Direct",
+        "requested": "[4.7.0, )",
+        "resolved": "4.7.0",
+        "contentHash": "1AjtK0uoJgxyobNtNwjQLlEs2X+9mgfWbWXiIktquTvpOhSXMf56TZF43+q2lIIYhV4IrfS82/pfo4uPUYka4w=="
+      },
+      "NUnit3TestAdapter": {
+        "type": "Direct",
+        "requested": "[5.0.0, )",
+        "resolved": "5.0.0",
+        "contentHash": "sy4cLoUAdE6TDM4wNX5gmNCyhMev5wUz4cA6ZRf/aON9vf9t4xTVGLj/4huhDKcS4dFfmVVcgcP70yC7WC9kKg==",
+        "dependencies": {
+          "Microsoft.Testing.Extensions.VSTestBridge": "1.5.3",
+          "Microsoft.Testing.Platform.MSBuild": "1.5.3"
+        }
+      },
+      "Antlr4.Runtime.Standard": {
+        "type": "Transitive",
+        "resolved": "4.13.1",
+        "contentHash": "Da5+i4kFHUseJRZGcBG5fmZGpA/Ns180ibrQMxgZzjpQOnENVvSL5gi5HZ8Ncz8/AR2WsKbOg2lMBzjz0HUQcA=="
+      },
+      "Microsoft.ApplicationInsights": {
+        "type": "Transitive",
+        "resolved": "2.22.0",
+        "contentHash": "3AOM9bZtku7RQwHyMEY3tQMrHIgjcfRDa6YQpd/QG2LDGvMydSlL9Di+8LLMt7J2RDdfJ7/2jdYv6yHcMJAnNw=="
+      },
+      "Microsoft.CodeCoverage": {
+        "type": "Transitive",
+        "resolved": "17.14.0",
+        "contentHash": "z2GYXGG6LjGoumT59xSB2dMnqSwQBjkxdDJmSJHwy5nPtZ435GXa6wj5hz/lRrAZ7NyXXxZNXVsiHXzHRru5eA=="
+      },
+      "Microsoft.Testing.Extensions.Telemetry": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "U9pGd5DQuX1PfkrdFI+xH34JGgQ2nes5QAwIITTk+MQfLvRITqsZjJeHTjpGWh33D/0q1l7aA8/LQHR7UuCgLQ==",
+        "dependencies": {
+          "Microsoft.ApplicationInsights": "2.22.0",
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.Testing.Extensions.TrxReport.Abstractions": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "h34zKNpGyni66VH738mRHeXSnf3klSShUdavUWNhSfWICUUi5aXeI0LBvoX/ad93N0+9xBDU3Fyi6WfxrwKQGw==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.Testing.Extensions.VSTestBridge": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "cJD67YfDT98wEWyazKVD/yPVW6+H1usXeuselCnRes7JZBTIYWtrCchcOzOahnmajT79eDKqt9sta7DXwTDU4Q==",
+        "dependencies": {
+          "Microsoft.ApplicationInsights": "2.22.0",
+          "Microsoft.TestPlatform.ObjectModel": "17.12.0",
+          "Microsoft.Testing.Extensions.Telemetry": "1.5.3",
+          "Microsoft.Testing.Extensions.TrxReport.Abstractions": "1.5.3",
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.Testing.Platform": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "WqJydnJ99dEKtquR9HwINz104ehWJKTXbQQrydGatlLRw14bmsx0pa8+E6KUXMYXZAimN0swWlDmcJGjjW4TIg=="
+      },
+      "Microsoft.Testing.Platform.MSBuild": {
+        "type": "Transitive",
+        "resolved": "1.5.3",
+        "contentHash": "bOtpRMSPeT5YLQo+NNY8EtdNTphAUcmALjW4ABU7P0rb6yR2XAZau3TzNieLmR3lRuwudguWzzBhgcLRXwZh0A==",
+        "dependencies": {
+          "Microsoft.Testing.Platform": "1.5.3"
+        }
+      },
+      "Microsoft.TestPlatform.ObjectModel": {
+        "type": "Transitive",
+        "resolved": "17.14.0",
+        "contentHash": "3h7y7f/HuY8jdZa163p/55VmGw/fYJwrI8FOtsp4aEQAJaPgBr5LBS25uOfBwRYI95QDiByfaqSPBcWEvuHEwA=="
+      },
+      "Microsoft.TestPlatform.TestHost": {
+        "type": "Transitive",
+        "resolved": "17.14.0",
+        "contentHash": "8htQBKM92s/NXUI/U0/CKKLlvlDfWIo3/mbnY/GS/2XLkBGNIVQufmUpDIzznaZqUpdzspGSsJcLhVN8aRoMaA==",
+        "dependencies": {
+          "Microsoft.TestPlatform.ObjectModel": "17.14.0",
+          "Newtonsoft.Json": "13.0.3"
+        }
+      },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.3",
+        "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.core": {
+        "type": "Project"
+      },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
+      "galnet.presentation.abstractions": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.primitives.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Presentation.Abstractions": "[1.0.0, )",
+          "GalNet.Runtime": "[1.0.0, )"
+        }
+      },
+      "galnet.runtime": {
+        "type": "Project",
+        "dependencies": {
+          "CoreCLR-NCalc": "[3.1.253, )",
+          "GalNet.Core": "[1.0.0, )",
+          "Serilog": "[4.2.0, )"
+        }
+      },
+      "CoreCLR-NCalc": {
+        "type": "CentralTransitive",
+        "requested": "[3.1.253, )",
+        "resolved": "3.1.253",
+        "contentHash": "XrcIZAbjsnW+4/PJKd8bbfeDMYEM41cKK13DmgIRoH2+UPpoiu2mF7gfdfAsr10ePrzH4NyfD8Y3u8nbj9G2lQ==",
+        "dependencies": {
+          "Antlr4.Runtime.Standard": "4.13.1"
+        }
+      },
+      "Serilog": {
+        "type": "CentralTransitive",
+        "requested": "[4.2.0, )",
+        "resolved": "4.2.0",
+        "contentHash": "gmoWVOvKgbME8TYR+gwMf7osROiWAURterc6Rt2dQyX7wtjZYpqFiA/pY6ztjGQKKV62GGCyOcmtP1UKMHgSmA=="
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/GalNet.Presentation.Tests/AssetGalleryResourceResolverTests.cs b/test/GalNet.Presentation.Tests/AssetGalleryResourceResolverTests.cs
index 5e13ed78..2e5a0ec0 100644
--- a/test/GalNet.Presentation.Tests/AssetGalleryResourceResolverTests.cs
+++ b/test/GalNet.Presentation.Tests/AssetGalleryResourceResolverTests.cs
@@ -1,8 +1,9 @@
 using GalNet.Assets;
 using GalNet.Assets.Provider;
 using GalNet.Avalonia.GameView.Services;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Assets;
-using GalNet.Core.Gallery;
 
 namespace GeneralTest.Presentation;
 
@@ -23,7 +24,7 @@ public async Task Resolver_materializes_media_acquired_from_the_asset_manager()
                 Items = [new GalleryItem { Id = 1, TypeId = "cg", ResourceId = "asset-opening" }]
             });
 
-            using var assets = new AssetManager([new LocalFileProvider(root)]);
+            using var assets = new AssetManager([new LocalFileProvider(root, BuiltinResourceTypes.CreateCatalog())]);
             using var resolver = await AssetGalleryResourceResolver.CreateAsync(assets, gallery);
             var path = resolver.ResolvePath("asset-opening");
 
diff --git a/test/GalNet.Presentation.Tests/AvaloniaAudioLifetimeTests.cs b/test/GalNet.Presentation.Tests/AvaloniaAudioLifetimeTests.cs
index cc2cc1bf..d62936eb 100644
--- a/test/GalNet.Presentation.Tests/AvaloniaAudioLifetimeTests.cs
+++ b/test/GalNet.Presentation.Tests/AvaloniaAudioLifetimeTests.cs
@@ -1,18 +1,137 @@
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Audio;
 using GalNet.Core.Assets;
-using GalNet.Core.Audio;
-using GalNet.Media.LibVlc;
-using GalNet.Presentation.Abstractions.Audio;
+using GalNet.Media.Audio;
+using GalNet.Media.Miniaudio;
 
 namespace GeneralTest.Presentation;
 
+[Platform("Win")]
 public sealed class AvaloniaAudioLifetimeTests
 {
-    [TestCase(false), TestCase(true), Explicit("Requires GALNET_AUDIO_LIBVLC pointing to native LibVLC."), NonParallelizable]
+    [Test, NonParallelizable]
+    public async Task AudioVoicesShareExistingMaterializerAndCannotDeleteAnotherConsumersFile()
+    {
+        var root = Directory.CreateDirectory(System.IO.Path.Combine(System.IO.Path.GetTempPath(), "GalNet-shared-audio-" + Guid.NewGuid().ToString("N"))).FullName;
+        try
+        {
+            await using (var source = new WaveFiles(3))
+            using (var wave = await source.AcquireAsync("source")) File.Copy(wave.Path, System.IO.Path.Combine(root, "clip.wav"));
+            await File.WriteAllTextAsync(System.IO.Path.Combine(root, "clip.wav.meta"), """{"id":"clip","type":"audio","path":"clip.wav","compress":"none"}""");
+            using var assets = new GalNet.Assets.AssetManager([new GalNet.Assets.Provider.LocalFileProvider(root, BuiltinResourceTypes.CreateCatalog())]);
+            await using var files = new GalNet.Assets.AssetFileMaterializer(assets);
+            using var external = await files.AcquireAsync("clip");
+            await using var host = CreateHost(files);
+            var ended = 0;
+            host.EventReceived += value => { if (value.Kind == AudioBackendEventKind.Ended) Interlocked.Increment(ref ended); };
+            var first = new AudioBackendRequest(AudioBackendAction.Start, "sfx", "first", 1, "clip");
+            var second = first with { VoiceId = "second", Generation = 2 };
+            await Task.WhenAll(host.ApplyAsync(first), host.ApplyAsync(second));
+            await host.ApplyAsync(first with { Action = AudioBackendAction.Stop });
+            Assert.That(File.Exists(external.Path), Is.True);
+            await host.ApplyAsync(second with { Action = AudioBackendAction.Stop });
+            Assert.That(File.Exists(external.Path), Is.True, "Video/Gallery-style consumers still own this file.");
+            await WaitUntilAsync(() => Volatile.Read(ref ended) == 2);
+            external.Dispose(); Assert.That(File.Exists(external.Path), Is.False);
+        }
+        finally { Directory.Delete(root, true); }
+    }
+
+    [Test, NonParallelizable]
+    public async Task CancellationAfterAcquireReturnsItsFileEvenIfTheProviderIgnoredCancellation()
+    {
+        using var assets = new DelayedAssets(); await using var files = new WaveFiles(1) { Block = true };
+        await using var host = CreateHost(files);
+        var events = new System.Collections.Concurrent.ConcurrentQueue<AudioBackendEvent>(); host.EventReceived += events.Enqueue;
+        var request = new AudioBackendRequest(AudioBackendAction.Start, "bgm", "pending", 1, "wave");
+        var starting = host.ApplyAsync(request); await files.Entered.Task.WaitAsync(TimeSpan.FromSeconds(3));
+        await host.ApplyAsync(request with { Action = AudioBackendAction.Stop }); files.Allow.TrySetResult();
+        await starting.WaitAsync(TimeSpan.FromSeconds(3));
+        Assert.That(File.Exists(files.Path), Is.False); Assert.That(files.Releases, Is.EqualTo(1));
+        Assert.That(events.Any(value => value.Kind is AudioBackendEventKind.Started or AudioBackendEventKind.Failed), Is.False);
+    }
+
+    [TestCase(0f), TestCase(.2f), NonParallelizable]
+    public async Task StoppingAVoiceReleasesItsFileAfterFadeAndReportsTerminalEvent(float fade)
+    {
+        using var assets = new DelayedAssets(); await using var files = new WaveFiles(3);
+        await using var host = CreateHost(files);
+        var ended = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        host.EventReceived += value => { if (value.Kind == AudioBackendEventKind.Ended) ended.TrySetResult(); };
+        var start = new AudioBackendRequest(AudioBackendAction.Start, "bgm", "voice", 1, "wave");
+        await host.ApplyAsync(start);
+        await host.ApplyAsync(start with { Action = AudioBackendAction.Stop, FadeSeconds = fade });
+        if (fade > 0) Assert.That(File.Exists(files.Path), Is.True, "A fading voice must retain its file.");
+        await ended.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        Assert.That(File.Exists(files.Path), Is.False); Assert.That(files.Releases, Is.EqualTo(1));
+    }
+
+    [Test, NonParallelizable]
+    public async Task NaturalCompletionReleasesTheVoiceFileWithoutDisposingTheHost()
+    {
+        using var assets = new DelayedAssets(); await using var files = new WaveFiles(.1);
+        await using var host = CreateHost(files);
+        var ended = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        host.EventReceived += value => { if (value.Kind == AudioBackendEventKind.Ended) ended.TrySetResult(); };
+        await host.ApplyAsync(new(AudioBackendAction.Start, "bgm", "voice", 1, "wave"));
+        await ended.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        Assert.That(File.Exists(files.Path), Is.False); Assert.That(files.Releases, Is.EqualTo(1));
+    }
+
+    private static PcmAudioPlaybackHost CreateHost(IAssetFileMaterializer files)
+    {
+        var host = new PcmAudioPlaybackHost(files, path => new MiniaudioDecoder(path), new TestOutput());
+        host.ApplyAsync(new(AudioBackendAction.Configure, "", "", 0,
+            Configuration: new([new() { Id = "bgm" }, new() { Id = "sfx", MaxVoices = 8 }]))).GetAwaiter().GetResult();
+        return host;
+    }
+    private static async Task WaitUntilAsync(Func<bool> predicate)
+    {
+        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        while (!predicate()) await Task.Delay(5, timeout.Token);
+    }
+    private sealed class TestOutput : IAudioOutput
+    {
+        private readonly CancellationTokenSource _cancel = new();
+        private Task? _render;
+        public void Start(AudioRenderCallback callback) => _render = Task.Run(async () =>
+        {
+            var buffer = new float[960];
+            try { while (true) { await Task.Delay(10, _cancel.Token); callback(buffer); } }
+            catch (OperationCanceledException) when (_cancel.IsCancellationRequested) { }
+        });
+        public void Dispose() { _cancel.Cancel(); _render?.GetAwaiter().GetResult(); _cancel.Dispose(); }
+    }
+
+    private sealed class WaveFiles(double seconds) : IAssetFileMaterializer
+    {
+        public string Path { get; } = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "GalNet-audio-" + Guid.NewGuid().ToString("N") + ".wav");
+        public int Releases { get; private set; }
+        public bool Block { get; init; }
+        public TaskCompletionSource Entered { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public TaskCompletionSource Allow { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public async Task<AssetFileLease> AcquireAsync(string id, CancellationToken token = default)
+        {
+            Entered.TrySetResult(); if (Block) await Allow.Task;
+            var size = (int)(8000 * seconds) * 2;
+            using (var writer = new BinaryWriter(File.Create(Path)))
+            {
+                writer.Write("RIFF"u8); writer.Write(36 + size); writer.Write("WAVEfmt "u8); writer.Write(16);
+                writer.Write((short)1); writer.Write((short)1); writer.Write(8000); writer.Write(16000);
+                writer.Write((short)2); writer.Write((short)16); writer.Write("data"u8); writer.Write(size); writer.Write(new byte[size]);
+            }
+            return new AssetFileLease(id, "audio", Path, () => { Releases++; File.Delete(Path); });
+        }
+        public void Dispose() { if (File.Exists(Path)) File.Delete(Path); }
+        public ValueTask DisposeAsync() { Dispose(); return ValueTask.CompletedTask; }
+    }
+
+    [TestCase(false), TestCase(true), NonParallelizable]
     public async Task Stop_or_dispose_cancels_loading_before_a_voice_can_start(bool dispose)
     {
-        LibVLCSharp.Shared.Core.Initialize(Environment.GetEnvironmentVariable("GALNET_AUDIO_LIBVLC")!);
         using var assets = new DelayedAssets();
-        await using var host = new LibVlcAudioPlaybackHost(assets);
+        await using var files = new GalNet.Assets.AssetFileMaterializer(assets);
+        await using var host = CreateHost(files);
         Assert.That(host.InitializationError, Is.Null);
         var events = new List<AudioBackendEvent>();
         host.EventReceived += events.Add;
@@ -27,7 +146,8 @@ public async Task Stop_or_dispose_cancels_loading_before_a_voice_can_start(bool
         Assert.Multiple(() =>
         {
             Assert.That(assets.Cancelled, Is.True);
-            Assert.That(events, Is.Empty, "A cancelled pending load must not start or report playback failure.");
+            Assert.That(events.Any(value => value.Kind is AudioBackendEventKind.Started or AudioBackendEventKind.Failed), Is.False,
+                "A cancelled pending load may acknowledge Stop, but must not start or report playback failure.");
         });
     }
 
diff --git a/test/GalNet.Presentation.Tests/AvaloniaAudioSEffectTests.cs b/test/GalNet.Presentation.Tests/AvaloniaAudioSEffectTests.cs
deleted file mode 100644
index 250d8d29..00000000
--- a/test/GalNet.Presentation.Tests/AvaloniaAudioSEffectTests.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-using System.Text.Json;
-using GalNet.Media.LibVlc;
-
-namespace GalNet.Presentation.Tests;
-
-[TestFixture]
-public sealed class AvaloniaAudioSEffectTests
-{
-    [Test]
-    public void Default_registry_exposes_the_processors_it_can_execute()
-    {
-        var registry = new LibVlcAudioSEffectRegistry(LibVlcAudioSEffectRegistry.DefaultProcessors);
-
-        Assert.That(registry.Catalog.Definitions.Select(definition => definition.Id), Is.EquivalentTo(["seffect.gain", "seffect.lowPass", "seffect.highPass"]));
-    }
-
-    [Test]
-    public void Registry_accepts_a_host_specific_processor()
-    {
-        var registry = new LibVlcAudioSEffectRegistry([new TestProcessor()]);
-
-        Assert.That(registry.Catalog.TryGet("seffect.test", out _), Is.True);
-        Assert.That(registry.TryGet("seffect.test", out var processor), Is.True);
-        Assert.That(processor, Is.TypeOf<TestProcessor>());
-    }
-
-    [Test]
-    public void Low_and_high_pass_processors_aggregate_equalizer_attenuation()
-    {
-        var state = new LibVlcAudioSEffectState([60, 1_000, 8_000]);
-        using var lowPassParameters = JsonDocument.Parse("{\"cutoffHz\": 1000, \"attenuationDb\": -20}");
-        using var highPassParameters = JsonDocument.Parse("{\"cutoffHz\": 1000, \"attenuationDb\": -20}");
-
-        new LowPassSEffectProcessor().Apply(lowPassParameters.RootElement, state);
-        new HighPassSEffectProcessor().Apply(highPassParameters.RootElement, state);
-
-        Assert.That(state.BandGain(0), Is.EqualTo(-20).Within(.01));
-        Assert.That(state.BandGain(1), Is.EqualTo(0).Within(.01));
-        Assert.That(state.BandGain(2), Is.EqualTo(-20).Within(.01));
-    }
-
-    [Test]
-    public void Gain_processors_multiply_the_output_gain()
-    {
-        var state = new LibVlcAudioSEffectState([]);
-        using var first = JsonDocument.Parse("{\"gain\": 0.5}");
-        using var second = JsonDocument.Parse("{\"gain\": 0.4}");
-
-        new GainSEffectProcessor().Apply(first.RootElement, state);
-        new GainSEffectProcessor().Apply(second.RootElement, state);
-
-        Assert.That(state.Gain, Is.EqualTo(.2).Within(.001));
-    }
-
-    private sealed class TestProcessor : IAudioSEffectProcessor
-    {
-        public GalNet.Core.Audio.SEffectDefinition Definition { get; } = new("seffect.test", new HashSet<GalNet.Core.Audio.SEffectScope> { GalNet.Core.Audio.SEffectScope.Track }, []);
-        public void Apply(JsonElement parameters, LibVlcAudioSEffectState state) { }
-    }
-}
diff --git a/test/GalNet.Presentation.Tests/AvaloniaPresenterTests.cs b/test/GalNet.Presentation.Tests/AvaloniaPresenterTests.cs
index 07a7f4ed..a208561e 100644
--- a/test/GalNet.Presentation.Tests/AvaloniaPresenterTests.cs
+++ b/test/GalNet.Presentation.Tests/AvaloniaPresenterTests.cs
@@ -1,7 +1,8 @@
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Presentation;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Rendering.Scene;
 
@@ -95,6 +96,33 @@ public async Task AnimationPresenterAppliesACompletedReplaceAnimation()
         });
     }
 
+    [Test]
+    public async Task Stopping_looping_shake_removes_only_its_offset_and_allows_reuse()
+    {
+        var state = new GamePageViewModel(new NoOpGameNavigationService());
+        state.SetLayer("hero", new SceneLayerItem { HandleId = "hero", X = 37 });
+        using var presenter = new AvaloniaAnimationPresenter(state, new ImmediateDispatcher());
+        var timeline = new TimelineDefinition
+        {
+            PlaybackHandleId = "quake",
+            DurationFrames = 60,
+            FrameRate = 60,
+            LoopMode = AnimationLoopMode.Loop,
+            Tracks = [new() { HandleId = "hero", Property = "transform.x", BlendMode = AnimationBlendMode.Additive,
+                Keys = [new() { Frame = 0, Value = 0 }, new() { Frame = 30, Value = 16 }, new() { Frame = 60, Value = 0 }] }]
+        };
+        for (var round = 0; round < 2; round++)
+        {
+            var playback = presenter.PlayTimelineAsync(timeline, CancellationToken.None);
+            using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(3));
+            while (state.Layers.Single().X < 37.1) await Task.Delay(8, timeout.Token);
+            Assert.That(presenter.CompleteAnimationImmediately("quake"), Is.True);
+            var result = await playback.WaitAsync(timeout.Token);
+            Assert.That(result.Outcome, Is.EqualTo(AnimationOutcome.Skipped));
+            Assert.That(state.Layers.Single().X, Is.EqualTo(37).Within(.001));
+        }
+    }
+
     [Test]
     public async Task DrainedParticleRemovalIsPostedUntilAfterTheRenderPass()
     {
diff --git a/test/GalNet.Presentation.Tests/CompositeGameViewTests.cs b/test/GalNet.Presentation.Tests/CompositeGameViewTests.cs
index af8f44e5..f8f5e728 100644
--- a/test/GalNet.Presentation.Tests/CompositeGameViewTests.cs
+++ b/test/GalNet.Presentation.Tests/CompositeGameViewTests.cs
@@ -1,5 +1,6 @@
 using System.Text.Json;
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
 using GalNet.Core.Primitives;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
@@ -254,7 +255,7 @@ public void TypedFactoryRejectsAnotherDtoContractBeforeExecution()
     public async Task AsyncDisposalThroughGameViewInterfaceUsesModuleAsyncCleanup()
     {
         var module = new AsyncDisposableModule();
-        await using (IGameView view = new GameRegistration().RegisterImplementation(module).BuildView())
+        await using (IPrimitiveDispatcher view = new GameRegistration().RegisterImplementation(module).BuildView())
             Assert.That(module.CleanedUp, Is.False);
         Assert.That(module.CleanedUp, Is.True);
     }
diff --git a/test/GalNet.Presentation.Tests/DefaultVisualRenderingTests.cs b/test/GalNet.Presentation.Tests/DefaultVisualRenderingTests.cs
new file mode 100644
index 00000000..8ead5333
--- /dev/null
+++ b/test/GalNet.Presentation.Tests/DefaultVisualRenderingTests.cs
@@ -0,0 +1,146 @@
+using Avalonia;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Assets;
+using GalNet.Rendering.Scene;
+using SkiaSharp;
+
+namespace GeneralTest.Scene;
+
+public sealed class DefaultVisualRenderingTests
+{
+    [Test, Explicit("Writes the feature's CPU rendering contact sheet for visual inspection.")]
+    public void WriteDefaultVisualPreview()
+    {
+        var directory = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+        while (!File.Exists(Path.Combine(directory.FullName, "GalNet.slnx"))) directory = directory.Parent!;
+        var root = directory.FullName;
+        var imagePath = Directory.GetFiles(Path.Combine(root, "GameTestCase/Assets"), "*.meta", SearchOption.AllDirectories).Single(path =>
+        {
+            using var metadata = System.Text.Json.JsonDocument.Parse(File.ReadAllText(path));
+            return metadata.RootElement.GetProperty("id").GetString() == "a1000000000000000000000000000001";
+        })[..^5];
+        using var texture = new SceneTexture(new Avalonia.Media.DrawingImage(), SKBitmap.Decode(imagePath));
+        var layer = new SceneLayerItem { HandleId = "background", Texture = texture, DisplayMode = LayerDisplayMode.Fill, Z = 50 };
+        var overlay = new SceneLayerItem { HandleId = "lines", Color = "#00000000", Z = 100 };
+        var plan = SceneRenderPlan.Create([new(layer, 0), new(overlay, 1)]);
+        var programs = new List<SkiaShaderEffectProgramLoadResult>();
+        SceneEffectInstance Effect(string name, EffectStage stage, string target, string parameters)
+        {
+            var program = DefaultVisualShaderTests.Load(name); programs.Add(program);
+            return new(name, new ShaderProgramTextureEffectFactory(name, stage, new(name), program), target, 0, parameters);
+        }
+        try
+        {
+            var panels = new (string Title, SceneEffectInstance[] Effects)[]
+            {
+                ("Original", []),
+                ("Bloom + warm grade", [Effect("Bloom", EffectStage.ScenePost, "", "{\"strength\":3,\"radius\":24}"), Effect("ColorGrade", EffectStage.ScenePost, "", "{\"temperature\":0.5}")]),
+                ("Vignette", [Effect("Vignette", EffectStage.ScenePost, "", "{\"strength\":0.9,\"radius\":0.2}")]),
+                ("Layer Z depth blur", [Effect("DepthBlur", EffectStage.Layer, "background", "{\"falloff\":1,\"maxRadius\":16}")]),
+                ("Dynamic radial lines", [Effect("SpeedLines", EffectStage.Layer, "lines", "{\"time\":0.137}")]),
+                ("Dynamic directional lines", [Effect("SpeedLines", EffectStage.Layer, "lines", "{\"mode\":\"Directional\",\"time\":0.137}")])
+            };
+            using var sheet = new SKBitmap(1440, 600);
+            using var canvas = new SKCanvas(sheet); canvas.Clear(new SKColor(20, 24, 32));
+            using var font = new SKFont(SKTypeface.Default, 18);
+            using var paint = new SKPaint { Color = SKColors.White, IsAntialias = true };
+            for (var i = 0; i < panels.Length; i++)
+            {
+                var x = i % 3 * 480; var y = i / 3 * 300;
+                using var scene = SceneRenderPipeline.Render(plan, panels[i].Effects, null, new Size(480, 270));
+                canvas.DrawText(panels[i].Title, x + 12, y + 22, font, paint);
+                canvas.DrawBitmap(scene, x, y + 30);
+                foreach (var effect in panels[i].Effects) effect.Dispose();
+            }
+            using var image = SKImage.FromBitmap(sheet);
+            using var encoded = image.Encode(SKEncodedImageFormat.Png, 100);
+            Directory.CreateDirectory(Path.Combine(root, "artifacts"));
+            File.WriteAllBytes(Path.Combine(root, "artifacts/visual-library-preview.png"), encoded.ToArray());
+        }
+        finally { foreach (var program in programs) program.RuntimeEffect?.Dispose(); }
+    }
+
+    [Test]
+    public void Depth_blur_uses_current_layer_z_on_every_draw()
+    {
+        var program = DefaultVisualShaderTests.Load("DepthBlur");
+        using var compiled = program.RuntimeEffect;
+        var factory = new ShaderProgramTextureEffectFactory("depth", EffectStage.Layer, new("depth"), program);
+        using var effect = new SceneEffectInstance("depth", factory, "target", 0, "{\"focusZ\":0,\"falloff\":1,\"maxRadius\":16}");
+        var layer = new SplitLayer();
+        var plan = SceneRenderPlan.Create([new(layer, 0)]);
+        using var focused = SceneRenderPipeline.Render(plan, [effect], null, new Size(64, 32));
+        layer.Z = 50;
+        using var blurred = SceneRenderPipeline.Render(plan, [effect], null, new Size(64, 32));
+        Assert.That(focused.GetPixel(29, 16).Red, Is.EqualTo(255));
+        Assert.That(blurred.GetPixel(29, 16).Red, Is.LessThan(240));
+        layer.Z = 0;
+        using var restored = SceneRenderPipeline.Render(plan, [effect], null, new Size(64, 32));
+        Assert.That(restored.GetPixel(29, 16), Is.EqualTo(focused.GetPixel(29, 16)));
+    }
+
+    [TestCase("Radial")]
+    [TestCase("Directional")]
+    public void Speed_lines_generate_visible_transparent_animation(string mode)
+    {
+        var program = DefaultVisualShaderTests.Load("SpeedLines");
+        using var compiled = program.RuntimeEffect;
+        var factory = new ShaderProgramTextureEffectFactory("lines", EffectStage.Layer, new("lines"), program);
+        using var effect = new SceneEffectInstance("lines", factory, "target", 0, "{\"mode\":\"" + mode + "\"}");
+        using var source = new SKBitmap(128, 128);
+        source.Erase(SKColors.Transparent);
+        using var first = Draw(effect, source);
+        effect.SetAnimatedValue("time", .137f);
+        using var second = Draw(effect, source);
+        Assert.That(first.Pixels.Any(pixel => pixel.Alpha > 0), Is.True);
+        Assert.That(first.Pixels.Any(pixel => pixel.Alpha == 0), Is.True);
+        Assert.That(first.Pixels.Zip(second.Pixels).Count(pair => pair.First != pair.Second), Is.GreaterThan(100));
+    }
+
+    [Test]
+    public void Mask_texture_is_scaled_to_canvas_and_lease_is_released_once()
+    {
+        var program = DefaultVisualShaderTests.Load("MaskReveal");
+        using var compiled = program.RuntimeEffect;
+        var factory = new ShaderProgramTextureEffectFactory("mask", EffectStage.Layer, new("mask"), program);
+        using var bitmap = new SKBitmap(2, 1);
+        bitmap.SetPixel(0, 0, SKColors.Black);
+        bitmap.SetPixel(1, 0, SKColors.White);
+        using var texture = new SceneTexture(new Avalonia.Media.DrawingImage(), bitmap.Copy());
+        var released = 0;
+        var bindings = new ShaderTextureBindings();
+        bindings.Add("mask", new AssetHandle<SceneTexture>("mask-id", "sprite", texture, () => released++));
+        using var effect = new SceneEffectInstance("mask", factory, "target", 0, "{}", textures: bindings);
+        effect.SetAnimatedValue("progress", .5f);
+        using var source = new SKBitmap(64, 32);
+        source.Erase(SKColors.White);
+        using var result = Draw(effect, source);
+        Assert.That(result.GetPixel(4, 16).Alpha, Is.EqualTo(255));
+        Assert.That(result.GetPixel(60, 16).Alpha, Is.EqualTo(0));
+        effect.Dispose();
+        effect.Dispose();
+        Assert.That(released, Is.EqualTo(1));
+    }
+
+    private static SKBitmap Draw(SceneEffectInstance effect, SKBitmap source)
+    {
+        var target = new SKBitmap(source.Info);
+        target.Erase(SKColors.Transparent);
+        using var canvas = new SKCanvas(target);
+        effect.Effect.Render(canvas, source, effect);
+        return target;
+    }
+
+    private sealed class SplitLayer : ILayerEffectTarget
+    {
+        public string HandleId => "target";
+        public string EffectTargetHandleId => HandleId;
+        public double Z { get; set; }
+        public void Render(SceneRenderContext context)
+        {
+            context.Canvas.Clear(SKColors.Black);
+            using var paint = new SKPaint { Color = SKColors.White };
+            context.Canvas.DrawRect(0, 0, 32, 32, paint);
+        }
+    }
+}
diff --git a/test/GalNet.Presentation.Tests/DefaultVisualShaderTests.cs b/test/GalNet.Presentation.Tests/DefaultVisualShaderTests.cs
new file mode 100644
index 00000000..0d74188e
--- /dev/null
+++ b/test/GalNet.Presentation.Tests/DefaultVisualShaderTests.cs
@@ -0,0 +1,30 @@
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Rendering.Scene;
+
+namespace GeneralTest.Scene;
+
+public sealed class DefaultVisualShaderTests
+{
+    [TestCase("Bloom")]
+    [TestCase("Blur")]
+    [TestCase("Vignette")]
+    [TestCase("ColorGrade")]
+    [TestCase("DepthBlur")]
+    [TestCase("SpeedLines")]
+    [TestCase("Reveal")]
+    [TestCase("MaskReveal")]
+    public void Default_shader_metadata_and_sksl_compile(string name)
+    {
+        var result = Load(name);
+        using var effect = result.RuntimeEffect;
+        Assert.That(result.IsUsable, Is.True, string.Join(Environment.NewLine, result.Diagnostics));
+    }
+
+    internal static SkiaShaderEffectProgramLoadResult Load(string name)
+    {
+        var directory = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+        while (!File.Exists(Path.Combine(directory.FullName, "GalNet.slnx"))) directory = directory.Parent!;
+        var path = Path.Combine(directory.FullName, "src/Editor/GalNet.Editor.Shared/Visuals/Shaders", name + ".sksl");
+        return SkiaShaderEffectProgramLoader.Load(new EffectProgramResource(name), File.ReadAllText(path));
+    }
+}
diff --git a/test/GalNet.Presentation.Tests/GalNet.Presentation.Tests.csproj b/test/GalNet.Presentation.Tests/GalNet.Presentation.Tests.csproj
index 0bdad70c..41101e11 100644
--- a/test/GalNet.Presentation.Tests/GalNet.Presentation.Tests.csproj
+++ b/test/GalNet.Presentation.Tests/GalNet.Presentation.Tests.csproj
@@ -5,6 +5,7 @@
 
   <ItemGroup>
     <ProjectReference Include="../../src/Infrastructure/GalNet.Media.LibVlc/GalNet.Media.LibVlc.csproj" />
+    <ProjectReference Include="../../src/Infrastructure/GalNet.Media.Miniaudio/GalNet.Media.Miniaudio.csproj" />
     <ProjectReference Include="../../src/Tooling/GalNet.SchemaGenerator/GalNet.SchemaGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" GlobalPropertiesToRemove="OutputPath;OutDir" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
     <PackageReference Include="Avalonia.Headless" />
@@ -21,4 +22,5 @@
     <ProjectReference Include="..\..\src\Shared\GalNet.Presentation.Abstractions\GalNet.Presentation.Abstractions.csproj" />
     <ProjectReference Include="..\..\src\Shared\GalNet.Runtime\GalNet.Runtime.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../src/Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
 </Project>
diff --git a/test/GalNet.Presentation.Tests/GameThemeTests.DialogueHistory.cs b/test/GalNet.Presentation.Tests/GameThemeTests.DialogueHistory.cs
new file mode 100644
index 00000000..b51dfb73
--- /dev/null
+++ b/test/GalNet.Presentation.Tests/GameThemeTests.DialogueHistory.cs
@@ -0,0 +1,108 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Documents;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Media;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using GalNet.Avalonia.GameView.Page;
+using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Game.Controls;
+using GalNet.Presentation.Abstractions.Application;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Presentation;
+
+public sealed partial class GameThemeTests
+{
+    [TestCase("Classic")]
+    [TestCase("Minimal")]
+    [TestCase("Paper")]
+    public async Task HistoryOpensAtEndVirtualizesAndDoesNotAdvanceBehindTheOverlay(string layout)
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch(async () =>
+        {
+            var theme = CreateTheme(layout, "Ocean");
+            using var provider = CreateServices(theme).BuildServiceProvider();
+            using var scope = provider.CreateScope();
+            var game = scope.ServiceProvider.GetRequiredService<GamePageViewModel>();
+            var page = scope.ServiceProvider.GetRequiredService<GamePage>();
+            var lines = Enumerable.Range(0, 2000).Select(index => new DialogueHistoryLine("main", $"line-{index}#2", "Alice",
+                $"History line {index}: <b>bold</b> <color=#FF0000>red</color>", true, new("voice", "vocal"))).ToArray();
+            game.GetHistoryLines = () => lines;
+            game.IsGameUiReady = true;
+            game.IsDialogueVisible = true;
+            game.ReadTextBrush = Brushes.Cyan;
+            var advances = 0;
+            var replays = 0;
+            var stops = 0;
+            game.AdvanceRequested += () => advances++;
+            game.StopVoiceReplayRequested += () => stops++;
+            game.PlayVoiceAsync = _ => { replays++; return Task.CompletedTask; };
+            game.SetCurrentDialogue(lines[^1], false);
+            page.DataContext = game;
+            var root = new Border { Child = page, Classes = { "galnet-player" } };
+            root.Styles.Add(theme.CreateStyles());
+            var window = new Window { Width = 1280, Height = 720, Content = root };
+            window.Show();
+            try
+            {
+                window.UpdateLayout();
+                Assert.That(page.Dialogue.CanReplayVoice, Is.False);
+                game.CompleteDialogueVoice(lines[^1]);
+                window.UpdateLayout();
+                Assert.That(page.Dialogue.CanReplayVoice, Is.True);
+                var button = page.Dialogue.GetVisualDescendants().OfType<Button>().Single(control => control.Command == game.ReplayDialogueCommand);
+                button.RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+                await game.ReplayDialogueCommand.ExecuteAsync(null);
+                Assert.That(replays, Is.GreaterThanOrEqualTo(1));
+                game.OpenHistoryCommand.Execute(null);
+                window.UpdateLayout();
+                await Dispatcher.UIThread.InvokeAsync(() => { }, DispatcherPriority.Background);
+                window.UpdateLayout();
+                var history = (DialogueHistoryOverlay)page.History;
+                Assert.That(history.IsEffectivelyVisible, Is.True);
+                var list = history.FindControl<ItemsControl>("HistoryList")!;
+                Assert.That(list.ContainerFromIndex(lines.Length - 1), Is.Not.Null, "Opening history must show its last line.");
+                Assert.That(list.GetVisualDescendants().OfType<ListBoxItem>(), Is.Empty, "History rows must not be selectable.");
+                Assert.That(list.GetRealizedContainers().Count(), Is.InRange(1, 99));
+                var scroll = list.GetVisualDescendants().OfType<ScrollViewer>().First();
+                Assert.That(scroll.Offset.Y, Is.GreaterThan(0));
+                game.AdvanceCommand.Execute(null);
+                Assert.That(advances, Is.Zero);
+                var rendered = list.GetVisualDescendants().OfType<TypewriterTextBlock>().First();
+                var runs = rendered.Inlines!.OfType<Run>().ToArray();
+                Assert.That(runs.Any(run => run.FontWeight == FontWeight.Bold), Is.True);
+                Assert.That(runs.Any(run => run.Foreground is ISolidColorBrush brush && brush.Color == Colors.Red), Is.True);
+                var row = list.ContainerFromIndex(lines.Length - 1)!;
+                Assert.That(row.Focusable, Is.False);
+                var text = row.GetVisualDescendants().OfType<TypewriterTextBlock>().Single();
+                var point = text.TranslatePoint(new Point(10, text.Bounds.Height / 2), window)!.Value;
+                var focused = window.FocusManager!.GetFocusedElement();
+                var previousReplays = replays;
+                window.MouseMove(point);
+                window.MouseDown(point, MouseButton.Left);
+                window.MouseUp(point, MouseButton.Left);
+                Assert.That(window.FocusManager.GetFocusedElement(), Is.SameAs(focused));
+                Assert.That(advances, Is.Zero);
+                Assert.That(replays, Is.EqualTo(previousReplays));
+                var replay = row.GetVisualDescendants().OfType<Button>().Single();
+                var replayPoint = replay.TranslatePoint(new Point(replay.Bounds.Width / 2, replay.Bounds.Height / 2), window)!.Value;
+                window.MouseDown(replayPoint, MouseButton.Left);
+                window.MouseUp(replayPoint, MouseButton.Left);
+                Assert.That(replays, Is.EqualTo(previousReplays + 1), "The separate replay button remains interactive.");
+                Capture(window, $"{layout}-DialogueHistory");
+                window.KeyPress(Key.Escape, RawInputModifiers.None, PhysicalKey.Escape, null);
+                window.KeyRelease(Key.Escape, RawInputModifiers.None, PhysicalKey.Escape, null);
+                Assert.That(game.IsHistoryOpen, Is.False);
+                Assert.That(stops, Is.GreaterThan(0));
+                game.AdvanceCommand.Execute(null);
+                Assert.That(advances, Is.EqualTo(1));
+            }
+            finally { window.Close(); }
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+}
diff --git a/test/GalNet.Presentation.Tests/GameThemeTests.cs b/test/GalNet.Presentation.Tests/GameThemeTests.cs
index 026168d5..1193b343 100644
--- a/test/GalNet.Presentation.Tests/GameThemeTests.cs
+++ b/test/GalNet.Presentation.Tests/GameThemeTests.cs
@@ -20,7 +20,8 @@
 using GalNet.Avalonia.GameView.Settings;
 using GalNet.Avalonia.GameView.ViewModels;
 using GalNet.Avalonia.Themes;
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Core.Execution;
 using GalNet.Core.Parameters;
 using GalNet.Core.Primitives;
 using GalNet.Game.Controls;
@@ -33,8 +34,267 @@
 namespace GeneralTest.Presentation;
 
 [NonParallelizable]
-public sealed class GameThemeTests
+public sealed partial class GameThemeTests
 {
+    [TestCase("Mono")]
+    [TestCase("Ocean")]
+    [TestCase("Rose")]
+    public async Task ComboBox_popup_focus_selection_and_disabled_states_use_the_player_palette(string paletteName)
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch(() =>
+        {
+            var theme = CreateTheme("Classic", paletteName);
+            var combo = new ComboBox { Width = 300, ItemsSource = new[] { "简体中文", "English", "日本語" }, SelectedIndex = 0 };
+            var root = new Border { Classes = { "galnet-player" }, Child = combo, Padding = new Thickness(40) };
+            root.Styles.Add(theme.CreateStyles());
+            var window = new Window { Width = 460, Height = 320, Content = root };
+            window.Styles.Add(new global::Avalonia.Themes.Fluent.FluentTheme());
+            window.Show();
+            try
+            {
+                window.UpdateLayout();
+                var surface = ((ISolidColorBrush)root.FindResource("GalNet.Brush.Surface")!).Color;
+                root.Background = (IBrush)root.FindResource("GalNet.Brush.Background")!;
+                var text = ((ISolidColorBrush)root.FindResource("GalNet.Brush.TextPrimary")!).Color;
+                Assert.That(((ISolidColorBrush)combo.Background!).Color, Is.EqualTo(surface));
+                combo.Focus();
+                window.UpdateLayout();
+                Assert.That(((ISolidColorBrush)combo.Foreground!).Color, Is.EqualTo(text));
+                Capture(window, $"ComboBox-{paletteName}-Focused");
+                combo.IsDropDownOpen = true;
+                window.UpdateLayout();
+                var popup = combo.GetVisualDescendants().OfType<Popup>().Single();
+                var popupBorder = (Border)popup.Child!;
+                Assert.That(((ISolidColorBrush)popupBorder.Background!).Color, Is.EqualTo(surface));
+                Assert.That(combo.ContainerFromIndex(0), Is.Not.Null);
+                var selected = (ComboBoxItem)combo.ContainerFromIndex(0)!;
+                Assert.That(((ISolidColorBrush)selected.Foreground!).Color, Is.EqualTo(text));
+                Assert.That(((ISolidColorBrush)selected.FindResource("ComboBoxItemBackgroundSelected")!).Color,
+                    Is.EqualTo(((ISolidColorBrush)root.FindResource("GalNet.Brush.Selection")!).Color));
+                Capture(window, $"ComboBox-{paletteName}-Open");
+                combo.IsDropDownOpen = false;
+                combo.IsEnabled = false;
+                window.UpdateLayout();
+                Assert.That(((ISolidColorBrush)combo.Foreground!).Color,
+                    Is.EqualTo(((ISolidColorBrush)root.FindResource("GalNet.Brush.TextDisabled")!).Color));
+                Capture(window, $"ComboBox-{paletteName}-Disabled");
+            }
+            finally { window.Close(); }
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+
+    [Test]
+    public async Task Screenshot_previews_cache_each_ui_mode_retry_failures_and_keep_export_separate()
+    {
+        var calls = new List<bool>();
+        var exports = new List<bool>();
+        var fail = true;
+        var model = new ScreenshotDialogViewModel("directory", "capture.png", includeUi =>
+        {
+            calls.Add(includeUi);
+            if (includeUi && fail) { fail = false; return Task.FromException<byte[]>(new IOException("retry")); }
+            return Task.FromResult<byte[]>(includeUi ? [2] : [1]);
+        }, (_, _, includeUi) => { exports.Add(includeUi); return Task.FromResult<string?>(null); });
+        var first = model.CapturePreviewAsync();
+        Assert.That(model.CapturePreviewAsync(), Is.SameAs(first));
+        model.IncludeUi = true;
+        Assert.ThrowsAsync<IOException>(async () => await model.CapturePreviewAsync());
+        Assert.That(await model.CapturePreviewAsync(), Is.EqualTo(new byte[] { 2 }));
+        model.IncludeUi = false;
+        Assert.That(model.CapturePreviewAsync(), Is.SameAs(first));
+        await model.SaveAsync();
+        Assert.That(calls, Is.EqualTo(new[] { false, true, true }));
+        Assert.That(exports, Is.EqualTo(new[] { false }));
+    }
+
+    [Test]
+    public async Task Saving_one_slot_preserves_the_other_rows_and_decoded_previews()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch(() =>
+        {
+            using var provider = CreateServices(new ClassicTheme()).BuildServiceProvider();
+            using var scope = provider.CreateScope();
+            var fake = (TestSession)scope.ServiceProvider.GetRequiredService<IGameSessionService>();
+            using var artwork = CreateGalleryArtwork();
+            using var stream = new MemoryStream();
+            artwork.Save(stream);
+            var bytes = stream.ToArray();
+            fake.ReplaceSlot(1, fake.SaveSlots[1] with { PreviewImage = bytes });
+            var page = scope.ServiceProvider.GetRequiredService<SaveSlotsPageViewModel>();
+            var rows = page.Slots.ToArray();
+            var preview = rows[1].Preview;
+            fake.ReplaceSlot(0, new(0, DateTime.UtcNow, "New save", false, false) { PreviewImage = bytes });
+            Assert.That(page.Slots[0], Is.Not.SameAs(rows[0]));
+            Assert.That(page.Slots[1], Is.SameAs(rows[1]));
+            Assert.That(page.Slots[1].Preview, Is.SameAs(preview));
+            Assert.That(page.Slots[2], Is.SameAs(rows[2]));
+            Assert.That(((Bitmap)page.Slots[0].Preview!).PixelSize.Width, Is.EqualTo(480));
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+
+    [Test]
+    public async Task SaveNameChangesSurvivePageReactivationWithoutReplacingTheEditingRow()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            using var provider = CreateServices(new ClassicTheme()).BuildServiceProvider();
+            using var scope = provider.CreateScope();
+            var page = scope.ServiceProvider.GetRequiredService<SaveSlotsPageViewModel>();
+            await page.ActivateAsync(SaveSlotsMode.Load);
+            var row = page.Slots[1];
+            await row.RenameCommand.ExecuteAsync("雨中的重逢");
+            Assert.That(page.Slots[1], Is.SameAs(row));
+            Assert.That(row.Description, Is.EqualTo("雨中的重逢"));
+            await page.ActivateAsync(SaveSlotsMode.Load);
+            Assert.That(page.Slots[1].Description, Is.EqualTo("雨中的重逢"));
+            Assert.That(page.Slots[0].CanRename, Is.False);
+            Assert.That(page.Slots[2].CanRename, Is.False);
+            return true;
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+
+    [Test]
+    public async Task SavingWaitsForRenameAndRenameFailureKeepsTheDraftWithoutLoading()
+    {
+        var finished = new TaskCompletionSource<string>();
+        var saves = 0;
+        using var row = new GameSaveSlotRowViewModel(new(0, DateTime.Now, "Before", false, false), true,
+            _ => { saves++; return Task.CompletedTask; }, _ => Task.CompletedTask, (_, _) => finished.Task);
+        var rename = row.RenameCommand.ExecuteAsync("After");
+        Assert.That(row.CanRename, Is.False);
+        var save = row.SaveCommand.ExecuteAsync(null);
+        Assert.That(saves, Is.Zero);
+        finished.SetResult("After");
+        await Task.WhenAll(rename, save);
+        Assert.That(saves, Is.EqualTo(1));
+        Assert.That(row.Description, Is.EqualTo("After"));
+        using var failed = new GameSaveSlotRowViewModel(new(0, DateTime.Now, "Original", false, false), false,
+            _ => Task.CompletedTask, _ => { saves++; return Task.CompletedTask; }, (_, _) => throw new IOException("Unavailable"));
+        await failed.RenameCommand.ExecuteAsync("Draft");
+        await failed.LoadCommand.ExecuteAsync(null);
+        Assert.That(failed.Description, Is.EqualTo("Original"));
+        Assert.That(failed.RenameError, Is.Not.Empty);
+        Assert.That(saves, Is.EqualTo(1), "A failed metadata edit must not activate the slot.");
+    }
+
+    [TestCase("Classic", "Mono")]
+    [TestCase("Minimal", "Ocean")]
+    [TestCase("Paper", "Rose")]
+    public async Task SaveCardEditsNameWithoutActivatingTheSlotAndHighlightsTheWholePreview(string layout, string palette)
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            var activations = 0;
+            var renamed = "Before";
+            using var artwork = CreateGalleryArtwork();
+            var card = new SaveSlotCard
+            {
+                Width = 360,
+                Preview = artwork,
+                Description = renamed,
+                Timestamp = "2026/10/29 18:00",
+                CanRename = true,
+                Command = new CommunityToolkit.Mvvm.Input.RelayCommand(() => activations++)
+            };
+            card.RenameCommand = new CommunityToolkit.Mvvm.Input.RelayCommand<string>(name => { renamed = name!; card.Description = name; });
+            var root = new StackPanel { Classes = { "galnet-player" }, Margin = new Thickness(36), Spacing = 20 };
+            root.Styles.Add(CreateTheme(layout, palette).CreateStyles());
+            root.Children.Add(card);
+            var other = new Button { Content = "Back" };
+            root.Children.Add(other);
+            var window = new Window { Width = 640, Height = 420, Content = root };
+            window.Show();
+            try
+            {
+                window.UpdateLayout();
+                var name = card.GetVisualDescendants().OfType<TextBox>().Single();
+                var preview = card.GetVisualDescendants().OfType<Image>().Single();
+                Assert.That(preview.Bounds.Height, Is.GreaterThan(200));
+                Assert.That(name.BorderThickness, Is.EqualTo(new Thickness(0)));
+                Assert.That(name.Focus(), Is.True);
+                name.SelectAll();
+                window.KeyTextInput("雨中的重逢");
+                Assert.That(name.Text, Is.EqualTo("雨中的重逢"));
+                window.KeyPress(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, null);
+                window.KeyRelease(Key.Enter, RawInputModifiers.None, PhysicalKey.Enter, null);
+                Assert.That(renamed, Is.EqualTo("雨中的重逢"));
+                Assert.That(activations, Is.Zero, "Renaming must not load or overwrite a save.");
+                name.Focus();
+                name.Text = "discard";
+                window.KeyPress(Key.Escape, RawInputModifiers.None, PhysicalKey.Escape, null);
+                window.KeyRelease(Key.Escape, RawInputModifiers.None, PhysicalKey.Escape, null);
+                Assert.That(renamed, Is.EqualTo("雨中的重逢"));
+                name.Focus();
+                name.Text = "After the rain";
+                other.Focus();
+                await Task.Yield();
+                Assert.That(renamed, Is.EqualTo("After the rain"));
+                name.Focus();
+                var highlight = card.GetVisualDescendants().OfType<Border>().Single(border => border.Name == "PART_Highlight");
+                Assert.That(highlight.Opacity, Is.GreaterThan(0));
+                Assert.That(highlight.Bounds.Size, Is.EqualTo(preview.Bounds.Size));
+                Capture(window, $"{layout}-{palette}-SaveCard");
+                var point = card.TranslatePoint(new Point(180, 50), window)!.Value;
+                window.MouseDown(point, MouseButton.Left);
+                window.MouseUp(point, MouseButton.Left);
+                Assert.That(activations, Is.EqualTo(1));
+            }
+            finally { window.Close(); }
+            return true;
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+
+    [TestCase("Classic", "Mono")]
+    [TestCase("Minimal", "Ocean")]
+    [TestCase("Paper", "Rose")]
+    public async Task AudioSettingsKeepSliderAndAccessibleMuteToggleOnOneRow(string layout, string palette)
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            var muted = false;
+            var saves = 0;
+            var mute = new BoolSetting("muted", "Mute", false, () => muted, (value, _) => { muted = value; return Task.CompletedTask; });
+            var gain = new DoubleSetting("gain", "Master volume", .6, 0, 1, .01, () => .6, (_, _) => Task.CompletedTask)
+            { EditorKind = NumericEditorKind.Slider, InlineToggle = mute };
+            var flag = new BoolSetting("read", "Read text only", true, () => true, (_, _) => Task.CompletedTask);
+            SettingCategory[] categories = [new("audio", "Audio", [gain, mute, flag])];
+            new SettingsCoordinator { SaveAsync = _ => { saves++; return Task.CompletedTask; } }.Attach(categories);
+            var settings = new GalNet.Avalonia.Themes.Common.SettingsCategories { Categories = categories, Editors = EditorRegistry.CreateDefault() };
+            var root = new Border { Classes = { "galnet-player" }, Padding = new Thickness(32), Child = settings };
+            root.Styles.Add(CreateTheme(layout, palette).CreateStyles());
+            var window = new Window { Width = 1000, Height = 440, Content = root };
+            window.Show();
+            try
+            {
+                window.UpdateLayout();
+                var toggle = settings.GetVisualDescendants().OfType<ToggleButton>().Single(control => control.Classes.Contains("player-mute"));
+                var slider = settings.GetVisualDescendants().OfType<Slider>().Single();
+                var checkbox = settings.GetVisualDescendants().OfType<CheckBox>().Single();
+                Capture(window, $"{layout}-{palette}-AudioBeforeToggle");
+                Assert.That(checkbox.HorizontalAlignment, Is.EqualTo(global::Avalonia.Layout.HorizontalAlignment.Left));
+                Assert.That(BoundsInWindow(toggle, window).Center.Y, Is.EqualTo(BoundsInWindow(slider, window).Center.Y).Within(2));
+                Assert.That(BoundsInWindow(toggle, window).Left, Is.GreaterThan(BoundsInWindow(slider, window).Right));
+                Click(window, toggle);
+                await Task.Delay(80);
+                Assert.That(muted, Is.True);
+                Assert.That(saves, Is.EqualTo(1));
+                Assert.That(toggle.GetVisualDescendants().OfType<global::Avalonia.Controls.Shapes.Path>().Single(path => path.Classes.Contains("mute-slash")).IsVisible, Is.True);
+                Capture(window, $"{layout}-{palette}-AudioMuted");
+                Click(window, toggle);
+                await Task.Delay(80);
+                Assert.That(muted, Is.False);
+                Capture(window, $"{layout}-{palette}-Audio");
+            }
+            finally { window.Close(); }
+            return true;
+        }, TestContext.CurrentContext.CancellationToken);
+    }
+
     [TestCase("Classic")]
     [TestCase("Minimal")]
     [TestCase("Paper")]
@@ -292,7 +552,7 @@ public Task SetPlaybackModeAsync(PlaybackMode mode, CancellationToken cancellati
             return Task.CompletedTask;
         }
         public Task SkipToUnreadAsync(CancellationToken cancellationToken = default) { Skips++; return Task.CompletedTask; }
-        public Task RefreshPlaybackSettingsAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public Task UpdatePlaybackOptionsAsync(PlaybackOptions options, CancellationToken cancellationToken = default) => Task.CompletedTask;
     }
 
     [Test]
@@ -355,6 +615,14 @@ await session.Dispatch(async () =>
                 Assert.That(title.GetVisualDescendants().OfType<Button>().Count(), Is.GreaterThanOrEqualTo(4));
                 AssertPalette(root, theme.Palette);
                 Capture(window, $"{layout}-{paletteName}-title");
+                root.IsEnabled = false;
+                window.UpdateLayout();
+                var titleText = title.GetVisualDescendants().OfType<TextBlock>()
+                    .Single(block => block.Text == services.GetRequiredService<TitlePageViewModel>().GameTitle);
+                var titleBrush = (ISolidColorBrush)titleText.Foreground!;
+                Assert.That(titleBrush.Color, Is.EqualTo(((ISolidColorBrush)root.FindResource("GalNet.Brush.TextPrimary")!).Color));
+                Assert.That(titleBrush.Opacity, Is.EqualTo(1), "A modal scrim must be the only dimming applied to static title text.");
+                root.IsEnabled = true;
 
                 var state = services.GetRequiredService<GamePageViewModel>();
                 var page = services.GetRequiredService<GamePage>();
@@ -859,25 +1127,34 @@ private sealed class IncompleteScreenshotDialog : ScreenshotDialog
     private sealed class HostTitle : Control;
     private sealed class HostGamePage : GamePage;
 
-    private sealed class TestSession : IGameSessionService
+    private sealed class TestSession : IGameSessionService, ISaveSlotNamingSession
     {
         public string GameTitle => "Aster / 星河";
         public string StatusMessage => "A visual novel built with GalNet";
         public bool IsReady => true;
         public bool IsPlaying => false;
         public bool CanContinue => true;
-        public ReadOnlyObservableCollection<GameSaveSlot> SaveSlots { get; } = new(new ObservableCollection<GameSaveSlot>
+        private readonly ObservableCollection<GameSaveSlot> _slots = new()
         {
             new(0, default, "", true, false),
             new(1, new DateTime(2026, 10, 11, 12, 0, 0, DateTimeKind.Utc), "Chapter one / 第一章", false, false),
             new(2, default, "Unavailable save", false, true)
-        });
+        };
+        public ReadOnlyObservableCollection<GameSaveSlot> SaveSlots { get; }
+        public TestSession() => SaveSlots = new(_slots);
+        public void ReplaceSlot(int index, GameSaveSlot slot) => _slots[index] = slot;
         public event PropertyChangedEventHandler? PropertyChanged { add { } remove { } }
         public Task StartNewGameAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
         public Task ContinueAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
         public Task StopAsync(CancellationToken cancellationToken = default) => Task.CompletedTask;
         public Task SaveAsync(int slotIndex, CancellationToken cancellationToken = default) => Task.CompletedTask;
         public Task LoadAsync(int slotIndex, CancellationToken cancellationToken = default) => Task.CompletedTask;
+        public bool CanRenameSlots => true;
+        public Task<string> RenameSlotAsync(int slotIndex, string name, CancellationToken cancellationToken = default)
+        {
+            _slots[slotIndex] = _slots[slotIndex] with { Description = name };
+            return Task.FromResult(name);
+        }
     }
 }
 
diff --git a/test/GalNet.Presentation.Tests/InvocationFieldDecodingTests.cs b/test/GalNet.Presentation.Tests/InvocationFieldDecodingTests.cs
new file mode 100644
index 00000000..72604711
--- /dev/null
+++ b/test/GalNet.Presentation.Tests/InvocationFieldDecodingTests.cs
@@ -0,0 +1,65 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Core.Entry;
+using GalNet.Core.Parameters;
+using GalNet.Core.Primitives;
+using GalNet.Presentation.Abstractions.Execution;
+using GalNet.Presentation.Abstractions.View;
+using GalNet.Runtime.Runtime;
+
+namespace GeneralTest.Presentation;
+
+public sealed class InvocationFieldDecodingTests
+{
+    [Test]
+    public void TypedDispatchDecodesEachSuppliedFieldOnceAndKeepsInvocationsIndependent()
+    {
+        var received = new List<Options>();
+        var validations = 0;
+        using var registration = new GameRegistration().RegisterSchema(new DefaultEntryModule("test",
+            [DefaultPrimitiveEntryBase.ForDto<Options>("test.run", validateArguments: _ => validations++)]));
+        registration.RegisterImplementation(new PrimitiveModule(registry => registry.Immediate<Options>("test.run",
+            (context, options) =>
+            {
+                Assert.That(context.Arguments.GetProperty("numbers")[0].GetInt32(), Is.EqualTo(1));
+                received.Add(options);
+            })));
+        using var view = registration.BuildView();
+        var entry = new PrimitiveEntry("test.run", JsonSerializer.SerializeToElement(new { numbers = new[] { 1, 2 } }));
+        NumbersConverter.Reads = 0;
+        view.Dispatch(entry, new GameRuntime(null), default);
+        received[0].Numbers.Add(3);
+        view.Dispatch(entry, new GameRuntime(null), default);
+        Assert.That(NumbersConverter.Reads, Is.EqualTo(2));
+        Assert.That(validations, Is.EqualTo(2));
+        Assert.That(received[1].Numbers, Is.EqualTo(new[] { 1, 2 }));
+        Assert.That(received[0], Is.Not.SameAs(received[1]));
+        Assert.That(entry.Arguments.GetProperty("numbers").GetArrayLength(), Is.EqualTo(2));
+        Assert.That(() => view.Dispatch(new PrimitiveEntry("test.run", JsonSerializer.SerializeToElement(new { unknown = 1 })),
+            new GameRuntime(null), default), Throws.TypeOf<InvalidDataException>());
+    }
+
+    private sealed class Options : IFieldDto, IFieldSchema<Options>
+    {
+        public Options() { }
+        public List<int> Numbers { get; set; } = [];
+        public static IReadOnlyList<FieldDescriptor> Schema { get; } =
+            [new("numbers", new ValueDescriptor(typeof(List<int>), jsonOptions: new JsonSerializerOptions
+                { Converters = { new NumbersConverter() } }), isRequired: true)];
+        public IReadOnlyList<FieldDescriptor> Fields => Schema;
+        public object? ReadField(string id) => Numbers;
+        public void WriteField(string id, object? value) => Numbers = (List<int>)value!;
+    }
+
+    private sealed class NumbersConverter : JsonConverter<List<int>>
+    {
+        public static int Reads;
+        public override List<int> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            Reads++;
+            return JsonSerializer.Deserialize<int[]>(ref reader)!.ToList();
+        }
+        public override void Write(Utf8JsonWriter writer, List<int> value, JsonSerializerOptions options) =>
+            JsonSerializer.Serialize(writer, value.ToArray());
+    }
+}
diff --git a/test/GalNet.Presentation.Tests/LibVlcRuntimeTests.cs b/test/GalNet.Presentation.Tests/LibVlcRuntimeTests.cs
new file mode 100644
index 00000000..ca275323
--- /dev/null
+++ b/test/GalNet.Presentation.Tests/LibVlcRuntimeTests.cs
@@ -0,0 +1,24 @@
+using GalNet.Media.LibVlc;
+
+namespace GalNet.Presentation.Tests;
+
+public sealed class LibVlcRuntimeTests
+{
+    [Test]
+    public void Platform_factory_failure_is_reported_without_attempting_default_native_initialization()
+    {
+        var calls = 0;
+        using var runtime = new LibVlcRuntime(() => { calls++; throw new PlatformNotSupportedException("Platform video initialization failed."); });
+        Assert.That(calls, Is.EqualTo(1));
+        Assert.That(runtime.Instance, Is.Null);
+        Assert.That(runtime.InitializationError, Is.EqualTo("Platform video initialization failed."));
+    }
+
+    [Test]
+    public void A_null_platform_factory_result_is_reported_as_an_initialization_failure()
+    {
+        using var runtime = new LibVlcRuntime(() => null!);
+        Assert.That(runtime.Instance, Is.Null);
+        Assert.That(runtime.InitializationError, Does.Contain("returned null"));
+    }
+}
diff --git a/test/GalNet.Presentation.Tests/ParticleEmitterTests.cs b/test/GalNet.Presentation.Tests/ParticleEmitterTests.cs
index a68538a1..e6bde7b7 100644
--- a/test/GalNet.Presentation.Tests/ParticleEmitterTests.cs
+++ b/test/GalNet.Presentation.Tests/ParticleEmitterTests.cs
@@ -1,7 +1,7 @@
 using System.Text.Json;
 using Avalonia;
 using Avalonia.Media;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Rendering.Scene;
 using SkiaSharp;
 using RenderParticleEmitter = GalNet.Rendering.Scene.ParticleEmitter;
diff --git a/test/GalNet.Presentation.Tests/PlayerInputTests.cs b/test/GalNet.Presentation.Tests/PlayerInputTests.cs
index 2453230c..db78cef0 100644
--- a/test/GalNet.Presentation.Tests/PlayerInputTests.cs
+++ b/test/GalNet.Presentation.Tests/PlayerInputTests.cs
@@ -20,6 +20,19 @@ namespace GeneralTest.Presentation;
 [NonParallelizable]
 public sealed class PlayerInputTests
 {
+    [Test]
+    public void HistoryDefaultIsAddedToOlderConfigurationsWithoutStealingAnExistingWheelBinding()
+    {
+        using var settings = Settings();
+        var older = settings.Configuration;
+        older.Bindings.Remove("open.history");
+        settings.Restore(System.Text.Json.JsonSerializer.Serialize(older));
+        Assert.That(settings.Resolve(PlayerInputDevice.KeyboardMouse, "WheelUp"), Is.EqualTo("open.history"));
+        older.Bindings["toggle.quick"] = [new(PlayerInputDevice.KeyboardMouse, "WheelUp")];
+        settings.Restore(System.Text.Json.JsonSerializer.Serialize(older));
+        Assert.That(settings.Resolve(PlayerInputDevice.KeyboardMouse, "WheelUp"), Is.EqualTo("toggle.quick"));
+        Assert.That(settings.GetBindings("open.history", PlayerInputDevice.KeyboardMouse), Is.Empty);
+    }
     private static PlayerInputSettings Settings()
     {
         var settings = new PlayerInputSettings();
@@ -100,6 +113,33 @@ await Ui(async () =>
         });
     }
 
+    [Test]
+    public async Task DisabledPlayerContentDoesNotReceiveGamepadActionsBehindAModal()
+    {
+        await Ui(() =>
+        {
+            var settings = Settings();
+            var back = 0;
+            var root = new Border { Child = new Button { Content = "Underlying page" } };
+            var window = new Window { Content = root };
+            using var router = new PlayerInputRouter(root, settings, () => null, new Session(), () => back++);
+            window.Show();
+            try
+            {
+                root.IsEnabled = false;
+                settings.ObserveGamepad(new HashSet<string> { "East" });
+                settings.ObserveGamepad(new HashSet<string>());
+                Assert.That(back, Is.Zero);
+                root.IsEnabled = true;
+                settings.ObserveGamepad(new HashSet<string> { "East" });
+                settings.ObserveGamepad(new HashSet<string>());
+                Assert.That(back, Is.EqualTo(1));
+            }
+            finally { window.Close(); }
+            return Task.CompletedTask;
+        });
+    }
+
     [TestCase("Classic")]
     [TestCase("Minimal")]
     [TestCase("Paper")]
@@ -202,6 +242,7 @@ public async Task KeyboardAndMouseUseSameCaptureAndEscapeDoesNotChangeValue()
         await Ui(async () =>
         {
             var settings = Settings();
+            await settings.SetBindingAsync("toggle.ui", PlayerInputDevice.KeyboardMouse, 1, null);
             var capture = new InputBindingCapture(settings, "toggle.auto", PlayerInputDevice.KeyboardMouse, 0);
             var window = new Window { Width = 700, Height = 400, Content = capture };
             window.Show();
@@ -540,6 +581,7 @@ public async Task GameplaySurfaceDispatchesKeyboardMouseAndUpdatedBindingsInEver
         await Ui(async () =>
         {
             using var settings = Settings();
+            await settings.SetBindingAsync("advance", PlayerInputDevice.KeyboardMouse, 1, "MouseMiddle");
             var game = new GamePageViewModel(null!) { Input = settings };
             var page = new GalNet.Avalonia.GameView.Page.GamePage { DataContext = game };
             var root = new Border { Classes = { "galnet-player" }, Child = page };
diff --git a/test/GalNet.Presentation.Tests/SampleAotPreparationTests.cs b/test/GalNet.Presentation.Tests/SampleAotPreparationTests.cs
new file mode 100644
index 00000000..68782846
--- /dev/null
+++ b/test/GalNet.Presentation.Tests/SampleAotPreparationTests.cs
@@ -0,0 +1,138 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Threading;
+using GalNet.Avalonia.GameView.Input;
+using GalNet.Avalonia.GameView.Navigation;
+using GalNet.Avalonia.GameView.Page;
+using GalNet.Avalonia.GameView.Settings;
+using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Core.Parameters;
+using GalNet.Core.Serialization;
+using GalNet.Game.Controls.Forms;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GeneralTest.Presentation;
+
+[NonParallelizable]
+public sealed class SampleAotPreparationTests
+{
+    [Test]
+    public void InputPreferencesKeepTheExistingWireFormatAndAddTheNewHistoryDefaultWithoutReflectionMetadata()
+    {
+        const string legacy = """{"Version":1,"EastConfirms":true,"Bindings":{"advance":[{"Device":1,"Gesture":"East"}],"toggle.auto":[{"Device":0,"Gesture":"Shift+A"}],"toggle.ui":[{"Device":2,"Gesture":"TwoFingerTap"}]}}""";
+        using var settings = new PlayerInputSettings();
+        settings.Restore(legacy);
+        Assert.That(settings.EastConfirms, Is.True);
+        Assert.That(settings.Resolve(PlayerInputDevice.Gamepad, "East"), Is.EqualTo("advance"));
+        Assert.That(settings.Resolve(PlayerInputDevice.KeyboardMouse, "Shift+A"), Is.EqualTo("toggle.auto"));
+        Assert.That(settings.Resolve(PlayerInputDevice.Touch, "TwoFingerTap"), Is.EqualTo("toggle.ui"));
+        using var original = JsonDocument.Parse(legacy);
+        using var saved = JsonDocument.Parse(settings.Serialize());
+        var migrated = System.Text.Json.Nodes.JsonNode.Parse(saved.RootElement.GetRawText())!;
+        Assert.That(settings.Resolve(PlayerInputDevice.KeyboardMouse, "WheelUp"), Is.EqualTo("open.history"));
+        migrated["Bindings"]!.AsObject().Remove("open.history");
+        Assert.That(JsonElement.DeepEquals(original.RootElement, JsonSerializer.SerializeToElement(migrated)), Is.True);
+    }
+
+    [TestCase("null")]
+    [TestCase("{}")]
+    [TestCase("{\"Version\":1,\"Bindings\":null}")]
+    [TestCase("{\"Version\":1,\"Bindings\":{\"advance\":[{\"Device\":9,\"Gesture\":\"East\"}]}}")]
+    [TestCase("{\"Version\":1,\"Bindings\":{\"advance\":[{\"Device\":\"Gamepad\",\"Gesture\":\"East\"}]}}")]
+    public void InvalidInputPreferencesStillFallBackToDefaults(string json)
+    {
+        using var settings = new PlayerInputSettings();
+        settings.Restore(json);
+        Assert.That(PlayerInputSettings.Validate(settings.Configuration), Is.Null);
+        Assert.That(settings.Resolve(PlayerInputDevice.KeyboardMouse, "Space"), Is.EqualTo("advance"));
+        Assert.That(settings.EastConfirms, Is.False);
+    }
+
+    [Test]
+    public async Task NumericBoundsStillRejectInvalidEditsAndPreservePrecision()
+    {
+        var integer = 0;
+        var intSetting = new IntSetting("int", "int", 0, int.MinValue, int.MaxValue, 1,
+            () => integer, (value, _) => { integer = value; return Task.CompletedTask; });
+        Assert.That(intSetting.ValueContract.TryGetConstraint("minimum", out var minimum), Is.True);
+        Assert.That(minimum.GetInt32(), Is.EqualTo(int.MinValue));
+        Assert.That(await intSetting.TrySetValueAsync(int.MaxValue), Is.True);
+        Assert.That(integer, Is.EqualTo(int.MaxValue));
+
+        var number = 0.125;
+        var doubleSetting = new DoubleSetting("double", "double", number, -0.125, 0.875, 0.125,
+            () => number, (value, _) => { number = value; return Task.CompletedTask; });
+        Assert.That(await doubleSetting.TrySetValueAsync(1), Is.False);
+        Assert.That(number, Is.EqualTo(0.125));
+        Assert.That(await doubleSetting.TrySetValueAsync(0.875), Is.True);
+        Assert.That(number, Is.EqualTo(0.875));
+        Assert.Throws<ArgumentException>(() => new DoubleSetting("invalid", "invalid", 0, 0, double.NaN, 1,
+            () => 0, (_, _) => Task.CompletedTask));
+    }
+
+    [Test]
+    public void EnumOptionsKeepAliasesAndUnsignedValuesWithoutDynamicEnumArrays()
+    {
+        var options = JsonMetadata.CreateOptions(resolver: PreparationJsonContext.Default);
+        var field = new FieldDescriptor("enum", new ValueDescriptor(typeof(PreparationChoice), jsonOptions: options));
+        using var editor = new FieldEditorContext(field, new EmptyBinding());
+        Assert.That(editor.Options.Select(option => option.Value.GetUInt64()),
+            Is.EqualTo(new[] { 1UL, 1UL, ulong.MaxValue }));
+    }
+
+    [Test]
+    public async Task GameSurfaceBindingsFollowDataContextReplacementAndOverlayChanges()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch<bool>(() =>
+        {
+            using var services = new ServiceCollection().BuildServiceProvider();
+            var navigation = new GameNavigationService(services, new GameNavigationTransitionCoordinator());
+            var first = new GamePageViewModel(navigation) { IsDialogueVisible = true, IsChoiceVisible = true };
+            var second = new GamePageViewModel(navigation) { IsNvlMode = true };
+            var page = new GamePage { DataContext = first };
+            var window = new Window { Content = page };
+            window.Show();
+            try
+            {
+                Dispatcher.UIThread.RunJobs();
+                Assert.That(page.SceneHost.ItemsSource, Is.SameAs(first.Layers));
+                Assert.That(page.Choice.ItemsSource, Is.SameAs(first.Choices));
+                Assert.That(page.Choice.SelectionCommand, Is.SameAs(first.CompleteChoiceCommand));
+                Assert.That(page.Dialogue.IsVisible, Is.True);
+                Assert.That(page.Choice.IsVisible, Is.True);
+                first.IsUiHidden = true;
+                Assert.That(page.Dialogue.IsVisible, Is.False);
+                Assert.That(page.Choice.IsVisible, Is.False);
+
+                page.DataContext = second;
+                Assert.That(page.SceneHost.ItemsSource, Is.SameAs(second.Layers));
+                Assert.That(page.SceneHost.EffectsSource, Is.SameAs(second.TextureEffects));
+                Assert.That(page.SceneHost.RenderablesSource, Is.SameAs(second.SceneRenderables));
+                Assert.That(page.Choice.SelectionCommand, Is.SameAs(second.CompleteChoiceCommand));
+                Assert.That(page.Nvl.IsVisible, Is.True);
+                first.IsUiHidden = false;
+                Assert.That(page.Dialogue.IsVisible, Is.False, "The old context must no longer drive the surface.");
+                second.IsUiHidden = true;
+                Assert.That(page.Nvl.IsVisible, Is.False);
+            }
+            finally { window.Close(); }
+            return Task.FromResult(true);
+        }, CancellationToken.None);
+    }
+
+    private sealed class EmptyBinding : IFieldBinding
+    {
+        public FieldValue Read() => default;
+        public event EventHandler? Changed { add { } remove { } }
+        public Task<ValueIssue?> CommitAsync(FieldValue value, CancellationToken cancellationToken) =>
+            Task.FromResult<ValueIssue?>(null);
+    }
+}
+
+internal enum PreparationChoice : ulong { First = 1, Alias = 1, Last = ulong.MaxValue }
+
+[JsonSerializable(typeof(PreparationChoice))]
+internal sealed partial class PreparationJsonContext : JsonSerializerContext;
diff --git a/test/GalNet.Presentation.Tests/SceneLayerHostTests.cs b/test/GalNet.Presentation.Tests/SceneLayerHostTests.cs
index c7830d8d..9694fbe3 100644
--- a/test/GalNet.Presentation.Tests/SceneLayerHostTests.cs
+++ b/test/GalNet.Presentation.Tests/SceneLayerHostTests.cs
@@ -1,7 +1,7 @@
 using System.Collections.ObjectModel;
 using Avalonia.Media;
 using GalNet.Avalonia.GameView.Presentation;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Rendering.Scene;
 using SkiaSharp;
 
@@ -71,6 +71,29 @@ public void Every_display_mode_can_be_added_to_the_render_plan(LayerDisplayMode
         Assert.That(item.DisplayMode, Is.EqualTo(displayMode));
     }
 
+    [Test]
+    public void Bounded_snapshot_preserves_native_texture_coordinates_and_bounds_effect_work()
+    {
+        var source = new SKBitmap(80, 40);
+        source.Erase(SKColors.Gold);
+        using var texture = new SceneTexture(new DrawingImage(), source);
+        var layer = new SceneLayerItem { HandleId = "native", Texture = texture, DisplayMode = LayerDisplayMode.Native, X = 100, Y = -40 };
+        var plan = SceneRenderPlan.Create([new SceneRenderEntry(layer, 0)]);
+        var sizes = new List<SKSizeI>();
+        var effect = new SceneEffectInstance("identity", new TestEffectFactory("identity", (canvas, bitmap, _) =>
+        {
+            sizes.Add(new SKSizeI(bitmap.Width, bitmap.Height));
+            canvas.DrawBitmap(bitmap, 0, 0);
+        }), "", 0, "{}");
+        using var full = SceneRenderPipeline.Render(plan, [effect], null, new Avalonia.Size(640, 360));
+        using var small = SceneRenderPipeline.Render(plan, [effect], null, new Avalonia.Size(640, 360), new Avalonia.PixelSize(160, 90));
+        Assert.That(sizes, Is.EqualTo(new[] { new SKSizeI(640, 360), new SKSizeI(160, 90) }));
+        foreach (var (x, y) in new[] { (105, 35), (80, 45), (90, 35), (120, 35), (105, 25), (105, 45) })
+            Assert.That(small.GetPixel(x, y), Is.EqualTo(full.GetPixel(x * 4, y * 4)), $"pixel {x},{y}");
+        Assert.That(small.GetPixel(105, 35), Is.EqualTo(SKColors.Gold));
+        Assert.That(small.GetPixel(90, 35), Is.EqualTo(SKColors.Black));
+    }
+
     [Test]
     public void Empty_scene_renders_an_opaque_black_fallback()
     {
diff --git a/test/GalNet.Presentation.Tests/SkiaShaderEffectProgramTests.cs b/test/GalNet.Presentation.Tests/SkiaShaderEffectProgramTests.cs
index a40aabb1..a016e1b0 100644
--- a/test/GalNet.Presentation.Tests/SkiaShaderEffectProgramTests.cs
+++ b/test/GalNet.Presentation.Tests/SkiaShaderEffectProgramTests.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Rendering.Scene;
 
 namespace GeneralTest.Scene;
diff --git a/test/GalNet.Presentation.Tests/StateRestoreTests.cs b/test/GalNet.Presentation.Tests/StateRestoreTests.cs
index d56757a5..2ddcc810 100644
--- a/test/GalNet.Presentation.Tests/StateRestoreTests.cs
+++ b/test/GalNet.Presentation.Tests/StateRestoreTests.cs
@@ -105,9 +105,9 @@ public async Task FailedRestorationPreventsAdvanceAndInvalidStateDoesNotCancelTh
         var saved = engine.CreateSaveData();
         var broken = engine.CreateSaveData(); broken.States.Clear();
         var oldState = engine.Runtime.State;
-        Assert.Throws<InvalidDataException>(() => engine.RestoreFrom(broken));
+        Assert.ThrowsAsync<InvalidDataException>(() => engine.RestoreFromAsync(broken));
         Assert.That(engine.Runtime.State, Is.SameAs(oldState));
-        engine.RestoreFrom(saved);
+        await engine.RestoreFromAsync(saved);
         Assert.That(await engine.AdvanceAsync(), Is.True);
         Assert.That(engine.State, Is.EqualTo(GameEngineState.Ready));
         await using var restorer = new StateRestoreSession(view);
diff --git a/test/GalNet.Presentation.Tests/StructuredFormTests.cs b/test/GalNet.Presentation.Tests/StructuredFormTests.cs
index 939fb939..dcf7110b 100644
--- a/test/GalNet.Presentation.Tests/StructuredFormTests.cs
+++ b/test/GalNet.Presentation.Tests/StructuredFormTests.cs
@@ -15,6 +15,104 @@ namespace GeneralTest.Presentation;
 
 public sealed class StructuredFormTests
 {
+    [Test]
+    public async Task CopyingSemanticScalarElementsKeepsTheirMetadataForTheHostCopyOperation()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            var element = new FieldDescriptor("element", new(typeof(string)), semantic: FieldValueSemantic.LocalizedText);
+            var descriptor = new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.Sequence(element));
+            var registry = EditorRegistry.CreateDefault(copyValue: (valueDescriptor, value) =>
+            {
+                using var document = new ValueDocument(new("copy", valueDescriptor), value);
+                Assert.That(document.GetIterator().Count(property => property.Field.Semantic == FieldValueSemantic.LocalizedText), Is.EqualTo(1));
+                return new FieldCopy(Json("""{"element":"copied-key"}"""));
+            });
+            var binding = new Binding("""["original-key"]"""); var form = Form(new("texts", descriptor), binding, registry); var window = Mount(form);
+            try
+            {
+                var editor = (StructuredFieldEditor)form.Editors.Single().Control; editor.IsExpanded = true; Pump(window);
+                Click(editor, "copy"); Pump(window);
+                Assert.That(binding.Value.Json!.Value[1].GetString(), Is.EqualTo("copied-key"));
+            }
+            finally { window.Close(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task ExplicitEncodedStructuresKeepTheirRepresentationAndDoNotRebuildOnLeafEdits()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            var descriptor = new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.ForType(typeof(StructuredDetails), allowsJsonString: true));
+            var binding = new Binding { Value = new(JsonSerializer.SerializeToElement("""{"caption":"before","extension":9007199254740993}""")) };
+            var form = Form(new("encoded", descriptor), binding); var window = Mount(form);
+            try
+            {
+                var editor = (StructuredFieldEditor)form.Editors.Single().Control; editor.IsExpanded = true; Pump(window);
+                var title = editor.GetVisualDescendants().OfType<SchemaForm>().Single().Contexts.Single(context => context.Field.Id == "caption");
+                title.Text = "after"; Assert.That(await title.CommitTextAsync(), Is.True); Pump(window);
+                Assert.That(editor.GetVisualDescendants().OfType<SchemaForm>().Single().Contexts.Single(context => context.Field.Id == "caption"), Is.SameAs(title));
+                title.Text = "again"; Assert.That(await title.CommitTextAsync(), Is.True);
+                using var result = JsonDocument.Parse(binding.Value.Json!.Value.GetString()!);
+                Assert.That(result.RootElement.GetProperty("caption").GetString(), Is.EqualTo("again"));
+                Assert.That(result.RootElement.GetProperty("extension").GetInt64(), Is.EqualTo(9007199254740993));
+                binding.Value = new(JsonSerializer.SerializeToElement("[1,2]"));
+                form.Schema = [new("array", new ValueDescriptor(typeof(JsonElement)).WithStructure(ValueStructure.ForType(typeof(int[]), allowsJsonString: true)))];
+                binding.Notify(); editor = (StructuredFieldEditor)form.Editors.Single().Control; editor.IsExpanded = true; Pump(window);
+                Click(editor, "down"); Pump(window);
+                using var array = JsonDocument.Parse(binding.Value.Json!.Value.GetString()!);
+                Assert.That(array.RootElement[0].GetInt32(), Is.EqualTo(2));
+            }
+            finally { window.Close(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
+    [Test]
+    public async Task MapsUseSharedValueMetadataKeepSpecialKeysAndRejectDuplicateRenamesWithoutLosingInput()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
+        await session.Dispatch<bool>(async () =>
+        {
+            var binding = new Binding("""{"0":1,"":2,"a/b~c":3}""");
+            var form = Form(new("dictionary", new(typeof(Dictionary<string, int>))), binding); var window = Mount(form);
+            try
+            {
+                var editor = (StructuredFieldEditor)form.Editors.Single().Control;
+                Assert.That(form.Editors.Single().ShowSeparateLabel, Is.False);
+                editor.IsExpanded = true; Pump(window);
+                Assert.That(binding.Commits, Is.Zero);
+                var keys = editor.GetVisualDescendants().OfType<TextBox>().Where(input => input.Name == "MapKey").ToArray();
+                Assert.That(keys.Select(input => input.Text), Is.EqualTo(new[] { "0", "", "a/b~c" }));
+                var values = editor.GetVisualDescendants().OfType<SchemaForm>().ToArray();
+                var stale = values[0].Contexts.Single();
+                var value = values[2].Contexts.Single(); value.Text = "7";
+                Assert.That(await value.CommitTextAsync(), Is.True);
+                Assert.That(binding.Value.Json!.Value.GetProperty("a/b~c").GetInt32(), Is.EqualTo(7));
+                keys = editor.GetVisualDescendants().OfType<TextBox>().Where(input => input.Name == "MapKey").ToArray();
+                keys[0].Text = "a/b~c";
+                keys[0].RaiseEvent(new KeyEventArgs { RoutedEvent = InputElement.KeyDownEvent, Key = Key.Enter }); Pump(window);
+                Assert.That(form.Contexts.Single().Issue!.Code, Is.EqualTo("structure.keyDuplicate"));
+                Assert.That(keys[0].Text, Is.EqualTo("a/b~c")); Assert.That(binding.Commits, Is.EqualTo(1));
+                keys[0].Text = "renamed";
+                keys[0].RaiseEvent(new KeyEventArgs { RoutedEvent = InputElement.KeyDownEvent, Key = Key.Enter }); Pump(window);
+                Assert.That(binding.Value.Json!.Value.TryGetProperty("0", out _), Is.False);
+                Assert.That(binding.Value.Json.Value.GetProperty("renamed").GetInt32(), Is.EqualTo(1));
+                Assert.That(await stale.CommitAsync(new(Json("9"))), Is.False, "A structural rename invalidates old child bindings.");
+                Assert.That(binding.Value.Json.Value.GetProperty("").GetInt32(), Is.EqualTo(2));
+                var newKey = editor.GetVisualDescendants().OfType<TextBox>().Single(input => input.Name == "MapNewKey"); newKey.Text = "new";
+                Click(editor, "add"); Pump(window);
+                Assert.That(binding.Value.Json!.Value.GetProperty("new").GetInt32(), Is.Zero);
+            }
+            finally { window.Close(); }
+            return true;
+        }, CancellationToken.None);
+    }
+
     [Test]
     public async Task NestedDtoUsesWireNamesOverridesAndUnknownJsonWithoutCreatingOrWritingOnOpen()
     {
@@ -131,7 +229,7 @@ public async Task JsonFallbackIsMultilineAndUnsupportedHintsDoNotRemoveTheOtherF
         var session = HeadlessUnitTestSession.GetOrStartForAssembly(typeof(ThemeTestApplication).Assembly);
         await session.Dispatch<bool>(async () =>
         {
-            var binding = new Binding("{\"x\":1}"); var form = Form(new("value", new(typeof(Dictionary<string, int>))), binding); var window = Mount(form);
+            var binding = new Binding("{\"x\":1}"); var form = Form(new("value", new(typeof(Dictionary<string, int>)), editor: new(ValueEditorIds.Json)), binding); var window = Mount(form);
             try
             {
                 var input = (TextBox)form.Editors.Single().Control; Assert.That(input.AcceptsReturn, Is.True); Assert.That(form.Editors.Single().IsJsonFallback, Is.True);
diff --git a/test/GalNet.Presentation.Tests/TextureEffectsTests.cs b/test/GalNet.Presentation.Tests/TextureEffectsTests.cs
index 64bf87ce..0a2c91b9 100644
--- a/test/GalNet.Presentation.Tests/TextureEffectsTests.cs
+++ b/test/GalNet.Presentation.Tests/TextureEffectsTests.cs
@@ -1,7 +1,7 @@
 using GalNet.Avalonia.GameView.Navigation;
 using GalNet.Avalonia.GameView.Presentation;
 using GalNet.Avalonia.GameView.ViewModels;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Rendering.Scene;
 using SkiaSharp;
@@ -10,6 +10,60 @@ namespace GeneralTest.Scene;
 
 public sealed class TextureEffectsTests
 {
+    [Test]
+    public async Task Texture_leases_are_released_on_replace_stop_and_failed_preparation()
+    {
+        const string shader = """
+            /*
+            @gal.effect v=1
+            @input source
+            @targets layer
+            @texture mask
+              uniform: mask
+              required: true
+            @texture second
+              uniform: second
+            */
+            uniform shader source;
+            uniform shader mask;
+            uniform shader second;
+            half4 main(float2 p) { return source.eval(p)*mask.eval(p).a + second.eval(p)*0.0; }
+            """;
+        using var texture = new SceneTexture(new Avalonia.Media.DrawingImage(), Solid(SKColors.White));
+        using var assets = new TextureAssetManager(texture);
+        var page = new GamePageViewModel(new NoOpGameNavigationService());
+        using var resolver = new SkiaShaderEffectProgramResolver(new StaticShaderSource(shader));
+        using var runtime = new AvaloniaEffectRuntime(page, resolver, assets);
+        var request = new EffectRequest("", "mask", "layer", Parameters: "{\"mask\":\"ok\"}", ProgramResource: "mask-program");
+        await runtime.StartEffectAsync(request, CancellationToken.None);
+        Assert.That(assets.Released, Is.Zero);
+        await runtime.StartEffectAsync(request, CancellationToken.None);
+        Assert.That(assets.Released, Is.EqualTo(1));
+        await runtime.StopEffectAsync("mask", CancellationToken.None);
+        Assert.That(assets.Released, Is.EqualTo(2));
+        Assert.That(page.TextureEffects, Is.Empty);
+        await runtime.StartEffectAsync(request with { Parameters = "{\"mask\":\"ok\",\"second\":\"missing\"}" }, CancellationToken.None);
+        Assert.That(assets.Released, Is.EqualTo(3), "Partial preparation must release the first acquired texture.");
+        Assert.That(page.TextureEffects, Is.Empty);
+        await runtime.StartEffectAsync(request, CancellationToken.None);
+        runtime.Dispose();
+        Assert.That(assets.Released, Is.EqualTo(4));
+        Assert.That(page.TextureEffects, Is.Empty);
+    }
+
+    private sealed class TextureAssetManager(SceneTexture texture) : GalNet.Core.Assets.IAssetManager
+    {
+        public int Released { get; private set; }
+        public Task<GalNet.Core.Assets.AssetHandle<T>?> AcquireAsync<T>(string assetId, CancellationToken ct = default) where T : class =>
+            Task.FromResult(assetId == "ok" && texture is T value ? new GalNet.Core.Assets.AssetHandle<T>(assetId, "sprite", value, () => Released++) : null);
+        public Task<GalNet.Core.Assets.AssetHandle<T>?> AcquireByPathAsync<T>(string path, CancellationToken ct = default) where T : class => throw new NotSupportedException();
+        public Task<GalNet.Core.Assets.IGameFile?> GetFileAsync(string assetId, CancellationToken ct = default) => throw new NotSupportedException();
+        public Task<IReadOnlyList<GalNet.Core.Assets.IGameFile>> GetFilesAsync(string? typeId = null, CancellationToken ct = default) => throw new NotSupportedException();
+        public void RegisterDecoder<T>(string resourceTypeId, GalNet.Core.Assets.IAssetDecoder<T> decoder) where T : class => throw new NotSupportedException();
+        public void RegisterProvider(GalNet.Core.Assets.IAssetProvider provider) => throw new NotSupportedException();
+        public void Dispose() { }
+    }
+
     [Test]
     public void Program_factory_derives_layer_and_scene_contract_from_one_project_shader()
     {
@@ -225,6 +279,25 @@ public void Project_shader_binds_color_and_vector_metadata_from_json()
         });
     }
 
+    [Test]
+    public void Project_shader_binds_three_component_vector_from_json()
+    {
+        using var source = Solid(SKColors.White);
+        using var target = new SKBitmap(source.Info);
+        var effect = new SceneEffectInstance("rgb", CreateFactory(RgbSource, EffectStage.Layer), "layer", 0,
+            "{\"rgb\":[0.25,0.5,0.75]}");
+
+        effect.Effect.Render(new SKCanvas(target), source, effect);
+        var result = target.GetPixel(2, 2);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Red, Is.InRange(62, 66));
+            Assert.That(result.Green, Is.InRange(126, 130));
+            Assert.That(result.Blue, Is.InRange(190, 194));
+        });
+    }
+
     private static SKBitmap Solid(SKColor color)
     {
         var bitmap = new SKBitmap(8, 8);
@@ -349,4 +422,18 @@ @param offset
         uniform float2 offset;
         half4 main(float2 p) { return source.eval(p + offset) * half4(tint); }
         """;
+
+    private const string RgbSource = """
+        /*
+        @gal.effect v=1
+        @input source
+        @targets layer
+        @param rgb
+          uniform: rgb
+          type: vec3
+        */
+        uniform shader source;
+        uniform float3 rgb;
+        half4 main(float2 p) { return source.eval(p) * half4(half3(rgb), 1); }
+        """;
 }
diff --git a/test/GalNet.Presentation.Tests/TypewriterTextBlockTests.cs b/test/GalNet.Presentation.Tests/TypewriterTextBlockTests.cs
index 88c31dff..b2c704e3 100644
--- a/test/GalNet.Presentation.Tests/TypewriterTextBlockTests.cs
+++ b/test/GalNet.Presentation.Tests/TypewriterTextBlockTests.cs
@@ -42,4 +42,26 @@ public async Task SourceText_Renders_Rich_Dialogue_Markup()
         LineBreak => "\n",
         _ => string.Empty
     }));
+
+    [Test]
+    public async Task ReadColorChangesOnlyDefaultRunsWithoutRestartingThePresentation()
+    {
+        var control = new TypewriterTextBlock { Foreground = Brushes.White, CharactersPerSecond = 0 };
+        ReadTextStyle.SetWasRead(control, true);
+        ReadTextStyle.SetForeground(control, Brushes.Cyan);
+        control.SourceText = "<b>default</b><color=#FF0000><i>explicit</i></color>";
+        await control.Completion;
+        var completion = control.Completion;
+        var runs = control.Inlines!.OfType<Run>().ToArray();
+        Assert.That(((ISolidColorBrush)runs[0].Foreground!).Color, Is.EqualTo(Colors.Cyan));
+        Assert.That(((ISolidColorBrush)runs[1].Foreground!).Color, Is.EqualTo(Colors.Red));
+        ReadTextStyle.SetForeground(control, Brushes.Lime);
+        Assert.That(control.Completion, Is.SameAs(completion));
+        Assert.That(((ISolidColorBrush)runs[0].Foreground!).Color, Is.EqualTo(Colors.Lime));
+        Assert.That(((ISolidColorBrush)runs[1].Foreground!).Color, Is.EqualTo(Colors.Red));
+        Assert.That(runs[0].FontWeight, Is.EqualTo(FontWeight.Bold));
+        Assert.That(runs[1].FontStyle, Is.EqualTo(FontStyle.Italic));
+        ReadTextStyle.SetForeground(control, null);
+        Assert.That(((ISolidColorBrush)runs[0].Foreground!).Color, Is.EqualTo(Colors.White));
+    }
 }
diff --git a/test/GalNet.Presentation.Tests/VideoLayerTests.cs b/test/GalNet.Presentation.Tests/VideoLayerTests.cs
index 30f1d5c2..03cb35a1 100644
--- a/test/GalNet.Presentation.Tests/VideoLayerTests.cs
+++ b/test/GalNet.Presentation.Tests/VideoLayerTests.cs
@@ -1,5 +1,5 @@
 using Avalonia;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Rendering.Scene;
 using SkiaSharp;
diff --git a/test/GalNet.Presentation.Tests/VideoNativeSmokeTests.cs b/test/GalNet.Presentation.Tests/VideoNativeSmokeTests.cs
index 4d33ee33..154c4d27 100644
--- a/test/GalNet.Presentation.Tests/VideoNativeSmokeTests.cs
+++ b/test/GalNet.Presentation.Tests/VideoNativeSmokeTests.cs
@@ -5,8 +5,9 @@
 using GalNet.Avalonia.GameView.Presentation;
 using GalNet.Avalonia.GameView.Services;
 using GalNet.Avalonia.GameView.ViewModels;
+using GalNet.Contracts.Builtins.Assets;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Assets;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Rendering.Scene;
 
@@ -26,7 +27,7 @@ public async Task Real_video_decodes_into_scene_pixels_and_stops_cleanly(bool na
         var duration = probe.Duration / 1000d;
         Assert.That(duration, Is.GreaterThan(0));
         TestContext.Out.WriteLine($"Video duration: {duration} seconds.");
-        using var assets = new AssetManager([new LocalFileProvider(assetsRoot)]);
+        using var assets = new AssetManager([new LocalFileProvider(assetsRoot, BuiltinResourceTypes.CreateCatalog())]);
         var state = new GamePageViewModel(new NoOpGameNavigationService());
         await using var presenter = new AvaloniaVideoPresenter(assets, state, new ImmediateDispatcher());
         using var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(20));
@@ -71,7 +72,7 @@ public async Task Real_video_decodes_into_scene_pixels_and_stops_cleanly(bool na
     public async Task Hiding_or_replacing_during_asset_loading_prevents_late_video_publication(bool replace)
     {
         LibVLCSharp.Shared.Core.Initialize(Environment.GetEnvironmentVariable("GALNET_VIDEO_LIBVLC")!);
-        using var realAssets = new AssetManager([new LocalFileProvider(Environment.GetEnvironmentVariable("GALNET_VIDEO_ASSETS")!)]);
+        using var realAssets = new AssetManager([new LocalFileProvider(Environment.GetEnvironmentVariable("GALNET_VIDEO_ASSETS")!, BuiltinResourceTypes.CreateCatalog())]);
         var assets = new DelayedAssets(realAssets);
         var state = new GamePageViewModel(new NoOpGameNavigationService());
         await using var presenter = new AvaloniaVideoPresenter(assets, state, new ImmediateDispatcher());
diff --git a/test/GalNet.Presentation.Tests/packages.lock.json b/test/GalNet.Presentation.Tests/packages.lock.json
index 772b79f0..6d02c5b7 100644
--- a/test/GalNet.Presentation.Tests/packages.lock.json
+++ b/test/GalNet.Presentation.Tests/packages.lock.json
@@ -242,6 +242,7 @@
       "galnet.assets": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -249,6 +250,7 @@
         "type": "Project",
         "dependencies": {
           "Avalonia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -260,6 +262,7 @@
           "GalNet.Assets": "[1.0.0, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
           "GalNet.Avalonia.Rendering": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Irihi.Ursa": "[2.1.0, )",
@@ -274,6 +277,7 @@
         "dependencies": {
           "Avalonia": "[12.0.5, )",
           "Avalonia.Skia": "[12.0.5, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -282,24 +286,48 @@
         "dependencies": {
           "Avalonia.Themes.Fluent": "[12.0.5, )",
           "GalNet.Avalonia.Controls": "[1.0.0, )",
-          "GalNet.Avalonia.GameView": "[1.0.0, )"
+          "GalNet.Avalonia.GameView": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
         }
       },
       "galnet.core": {
         "type": "Project"
       },
+      "galnet.media.audio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.media.libvlc": {
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "LibVLCSharp": "[3.10.0, )"
         }
       },
+      "galnet.media.miniaudio": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )",
+          "GalNet.Media.Audio": "[1.0.0, )"
+        }
+      },
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -308,7 +336,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/test/GalNet.Runtime.Tests/Audio/AudioPersistenceTests.cs b/test/GalNet.Primitives.Builtins.Tests/Audio/AudioPersistenceTests.cs
similarity index 87%
rename from test/GalNet.Runtime.Tests/Audio/AudioPersistenceTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Audio/AudioPersistenceTests.cs
index b6bc82d2..d7edab60 100644
--- a/test/GalNet.Runtime.Tests/Audio/AudioPersistenceTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Audio/AudioPersistenceTests.cs
@@ -1,20 +1,24 @@
 using System.Text.Json;
-using GalNet.Core.Audio;
+using GalNet.Contracts.Builtins.Audio;
 using GalNet.Core.Runtime;
-using GalNet.Core.Settings;
-using GalNet.Presentation.Abstractions.Audio;
-using GalNet.Runtime.Audio;
+using GalNet.Primitives.Builtins.Audio;
 
 namespace GeneralTest.Runtime;
 
 public class AudioPersistenceTests
 {
-    private static readonly List<AudioTrackDefinition> Tracks = AudioTrackDefinition.CreateDefaults();
+    private static readonly AudioConfiguration Tracks = new(
+    [
+        new() { Id = "bgm", BusId = "bgm", PreserveDuringCatchUp = true, DefaultGain = .8f, MaxQueuedItems = 64, OverflowPolicy = AudioOverflowPolicy.StopOldest },
+        new() { Id = "sfx", BusId = "sfx", MaxVoices = 8 },
+        new() { Id = "vocal", BusId = "vocal", MaxQueuedItems = 64, OverflowPolicy = AudioOverflowPolicy.StopOldest }
+    ], [new() { Id = "bgm" }, new() { Id = "sfx" }, new() { Id = "vocal" }]);
     private static StateCatalog Catalog()
     {
         var builder = new StateCatalogBuilder();
         builder.Register<AudioTrackState>("builtin.audio.tracks", value => value.Id, AudioRuntime.ValidateTrack);
-        builder.Register<AudioSEffectState>("builtin.audio.seffects", value => AudioSEffectState.Key(value.TrackId, value.InstanceId));
+        builder.Register<AudioSEffectState>("builtin.audio.seffects", value => value.Key());
+        builder.Register<AudioChannelState>("builtin.audio.channels", value => value.Key(), AudioRuntime.ValidateChannel);
         return builder.Build();
     }
     [Test]
@@ -28,7 +32,7 @@ public async Task RestorePreservesPausedQueueEffectsAndUsesNewBackendIdentities(
         audio.Pause(Tracks, "bgm");
         var original = host.Requests.Single(value => value.Action == AudioBackendAction.Start);
         var restored = GameState.Restore(catalog, state.Capture());
-        audio.ApplyPlayerSettings(new GameSettings { MasterVolume = .5f, BgmVolume = .5f });
+        audio.ApplyMix(new AudioMixOptions { MasterGain = .5f, Buses = new Dictionary<string, AudioMixLevel> { ["bgm"] = new(.5f) } });
         await audio.RestoreAsync(restored, Tracks, default);
         Assert.That(host.Requests.Count(value => value.Action == AudioBackendAction.Start), Is.EqualTo(1), "Paused restoration must not briefly start playback.");
         audio.Reset(state); // A delayed cancellation from the old generation is harmless.
diff --git a/test/GalNet.Primitives.Builtins.Tests/Audio/AudioRepeatTests.cs b/test/GalNet.Primitives.Builtins.Tests/Audio/AudioRepeatTests.cs
new file mode 100644
index 00000000..abf8ad89
--- /dev/null
+++ b/test/GalNet.Primitives.Builtins.Tests/Audio/AudioRepeatTests.cs
@@ -0,0 +1,131 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Runtime;
+using GalNet.Primitives.Builtins.Audio;
+
+namespace GeneralTest.Runtime;
+
+public sealed class AudioRepeatTests
+{
+    private static readonly AudioConfiguration Tracks = BuiltinAudioDefaults.Create();
+
+    [Test]
+    public async Task FiniteRepeatUsesNewVoicesWithoutReapplyingFadeAndCompletesAfterLastIteration()
+    {
+        var host = new Host(); await using var audio = new AudioRuntime(host);
+        var ticket = audio.Play(Tracks, new("bgm", "music", AudioPlacement.Replace, FadeInSeconds: 1, LoopCount: 3));
+        var first = host.Starts.Last(); host.End(first);
+        Assert.That(host.Starts.Last().VoiceId, Is.Not.EqualTo(first.VoiceId));
+        Assert.That(host.Starts.Last().FadeSeconds, Is.Zero);
+        host.End(first); Assert.That(host.Starts, Has.Count.EqualTo(2), "A stale end must not consume a new iteration.");
+        host.End(host.Starts.Last()); Assert.That(ticket.IsCompleted, Is.False);
+        host.End(host.Starts.Last()); Assert.That(ticket.IsCompleted, Is.True);
+        Assert.That(host.Starts, Has.Count.EqualTo(3));
+    }
+
+    [Test]
+    public async Task RequeueTailRotatesAFullyOccupiedQueueAndTicketCanRemoveItsPendingItem()
+    {
+        var tracks = new AudioConfiguration([new() { Id = "bgm", MaxVoices = 1, MaxQueuedItems = 1 }]);
+        var host = new Host(); await using var audio = new AudioRuntime(host);
+        var a = audio.Play(tracks, new("bgm", "a", AudioPlacement.Enqueue, Completion: AudioCompletion.RequeueTail));
+        var b = audio.Play(tracks, new("bgm", "b", AudioPlacement.Enqueue, Completion: AudioCompletion.RequeueTail));
+        host.End(host.Starts.Last()); host.End(host.Starts.Last()); host.End(host.Starts.Last());
+        Assert.That(host.Starts.Select(request => request.AssetId), Is.EqualTo(new[] { "a", "b", "a", "b" }));
+        Assert.That(a.IsCompleted || b.IsCompleted, Is.False);
+        a.Stop(); Assert.That(a.IsCompleted, Is.True); Assert.That(b.IsCompleted, Is.False);
+        audio.Next(tracks, "bgm"); var count = host.Starts.Count;
+        host.End(host.Starts.Last()); Assert.That(host.Starts, Has.Count.EqualTo(count));
+        Assert.That(b.IsCompleted, Is.True);
+    }
+
+    [Test]
+    public async Task InfiniteRepeatHonorsPauseResumeAndStopWithoutRequeueingStoppedAudio()
+    {
+        var host = new Host(); await using var audio = new AudioRuntime(host);
+        var ticket = audio.Play(Tracks, new("bgm", "music", AudioPlacement.Replace, LoopCount: 0, Completion: AudioCompletion.RequeueTail));
+        host.End(host.Starts.Last()); host.End(host.Starts.Last());
+        audio.Pause(Tracks, "bgm"); host.End(host.Starts.Last());
+        Assert.That(host.Starts, Has.Count.EqualTo(3));
+        audio.Resume(Tracks, "bgm"); Assert.That(host.Starts, Has.Count.EqualTo(4));
+        var stale = host.Starts.Last(); audio.Stop(Tracks, new("bgm", true)); host.End(stale);
+        Assert.That(host.Starts, Has.Count.EqualTo(4)); Assert.That(ticket.IsCompleted, Is.True);
+    }
+
+    [Test]
+    public async Task FailureNeverRepeatsAndReplacementAndCatchUpIgnoreOldEvents()
+    {
+        var host = new Host(); await using var audio = new AudioRuntime(host);
+        var first = audio.Play(Tracks, new("bgm", "broken", AudioPlacement.Replace, LoopCount: 0, Completion: AudioCompletion.RequeueTail));
+        audio.Play(Tracks, new("bgm", "next", AudioPlacement.Enqueue));
+        host.Fail(host.Starts.Last()); Assert.That(first.IsCompleted, Is.True);
+        Assert.That(host.Starts.Last().AssetId, Is.EqualTo("next"));
+        var stale = host.Starts.Last(); audio.BeginCatchUp(); host.End(stale);
+        audio.Play(Tracks, new("bgm", "final", AudioPlacement.Replace, LoopCount: 0));
+        audio.EndCatchUp(); host.End(stale);
+        Assert.That(host.Starts.Last().AssetId, Is.EqualTo("final"));
+        Assert.That(host.Starts, Has.Count.EqualTo(3));
+    }
+
+    [Test]
+    public async Task RestoreContinuesRemainingIterationsAndLegacyItemsDefaultToOneDiscardedPlay()
+    {
+        var builder = new StateCatalogBuilder();
+        builder.Register<AudioTrackState>("builtin.audio.tracks", value => value.Id, AudioRuntime.ValidateTrack);
+        builder.Register<AudioSEffectState>("builtin.audio.seffects", value => value.Key());
+        builder.Register<AudioChannelState>("builtin.audio.channels", value => value.Key(), AudioRuntime.ValidateChannel);
+        var catalog = builder.Build(); var state = new GameState(catalog);
+        var host = new Host(); await using var audio = new AudioRuntime(host); audio.Bind(state);
+        audio.Play(Tracks, new("bgm", "music", AudioPlacement.Replace, LoopCount: 3)); host.End(host.Starts.Last());
+        var restored = GameState.Restore(catalog, state.Capture());
+        Assert.That(restored.Table<AudioTrackState>().Get("bgm").Active.Single().CompletedIterations, Is.EqualTo(1));
+        await audio.RestoreAsync(restored, Tracks, default);
+        host.End(host.Starts.Last()); host.End(host.Starts.Last());
+        Assert.That(restored.Table<AudioTrackState>().Get("bgm").Active, Is.Empty);
+        Assert.That(host.Starts, Has.Count.EqualTo(4));
+        var legacy = JsonSerializer.Deserialize<AudioItemState>("""{"Id":"old","Request":{"TrackId":"bgm","AssetId":"old","Placement":0,"Gain":1,"FadeInSeconds":0}}""")!;
+        Assert.That(legacy.Request.LoopCount, Is.EqualTo(1)); Assert.That(legacy.Request.Completion, Is.EqualTo(AudioCompletion.Discard));
+        AudioRuntime.ValidateTrack(new() { Id = "bgm", Active = [legacy] });
+    }
+
+    [Test]
+    public async Task FadingVoicesStillReceiveMuteAndAreStoppedByScopeResetButNeverEnterSnapshot()
+    {
+        var builder = new StateCatalogBuilder(); builder.Register<AudioTrackState>("builtin.audio.tracks", value => value.Id);
+        builder.Register<AudioSEffectState>("builtin.audio.seffects", value => value.Key());
+        builder.Register<AudioChannelState>("builtin.audio.channels", value => value.Key(), AudioRuntime.ValidateChannel);
+        var state = new GameState(builder.Build()); var host = new Host(); await using var audio = new AudioRuntime(host); audio.Bind(state);
+        audio.Play(Tracks, new("bgm", "music", AudioPlacement.Replace)); var first = host.Starts.Last();
+        audio.Stop(Tracks, new("bgm", true, 5)); audio.ApplyMix(new() { MasterMuted = true });
+        Assert.That(host.Requests.Last().Action, Is.EqualTo(AudioBackendAction.SetGain)); Assert.That(host.Requests.Last().Gain, Is.Zero);
+        Assert.That(state.Table<AudioTrackState>().Get("bgm").Active, Is.Empty);
+        host.End(first); var count = host.Requests.Count; audio.ApplyMix(new());
+        Assert.That(host.Requests, Has.Count.EqualTo(count));
+        audio.Play(Tracks, new("bgm", "other", AudioPlacement.Replace)); audio.Stop(Tracks, new("bgm", true, 5)); audio.Reset();
+        Assert.That(host.Requests.Last().Action, Is.EqualTo(AudioBackendAction.Stop)); Assert.That(host.Requests.Last().FadeSeconds, Is.Zero);
+    }
+
+    [Test]
+    public void InvalidRepeatDefinitionsAreRejectedWithoutStartingPlayback()
+    {
+        var host = new Host(); using var audio = new AudioRuntime(host);
+        Assert.That(audio.Play(Tracks, new("bgm", "bad", AudioPlacement.Replace, LoopCount: -1)).IsCompleted, Is.True);
+        Assert.That(host.Starts, Is.Empty);
+        Assert.Throws<InvalidDataException>(() => AudioRuntime.ValidateTrack(new()
+        { Id = "bgm", Active = [new() { Request = new("bgm", "bad", AudioPlacement.Replace, LoopCount: 2), CompletedIterations = 2 }] }));
+    }
+
+    private sealed class Host : IAudioPlaybackHost
+    {
+        public AudioBackendCapabilities Capabilities { get; } = new(true, true, true);
+        public ISEffectCatalog SEffects => SEffectCatalog.Builtins;
+        public List<AudioBackendRequest> Requests { get; } = [];
+        public List<AudioBackendRequest> Starts => Requests.Where(request => request.Action == AudioBackendAction.Start).ToList();
+        public event Action<AudioBackendEvent>? EventReceived;
+        public Task ApplyAsync(AudioBackendRequest request, CancellationToken token = default) { Requests.Add(request); return Task.CompletedTask; }
+        public void End(AudioBackendRequest request) => EventReceived?.Invoke(new(AudioBackendEventKind.Ended, request.TrackId, request.VoiceId, request.Generation));
+        public void Fail(AudioBackendRequest request) => EventReceived?.Invoke(new(AudioBackendEventKind.Failed, request.TrackId, request.VoiceId, request.Generation));
+        public void Dispose() { }
+    }
+}
diff --git a/test/GalNet.Runtime.Tests/Audio/AudioRuntimeTests.cs b/test/GalNet.Primitives.Builtins.Tests/Audio/AudioRuntimeTests.cs
similarity index 67%
rename from test/GalNet.Runtime.Tests/Audio/AudioRuntimeTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Audio/AudioRuntimeTests.cs
index 0d04869b..8905a5f0 100644
--- a/test/GalNet.Runtime.Tests/Audio/AudioRuntimeTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Audio/AudioRuntimeTests.cs
@@ -1,12 +1,112 @@
 using System.Text.Json;
-using GalNet.Core.Audio;
-using GalNet.Presentation.Abstractions.Audio;
-using GalNet.Runtime.Audio;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Primitives.Builtins.Audio;
 
 namespace GeneralTest.Runtime;
 
 public class AudioRuntimeTests
 {
+    [Test]
+    public void CustomGroupAndTrackMixControlsCurrentAndFutureVoicesIndependently()
+    {
+        var configuration = new AudioConfiguration(
+            [new() { Id = "rain", BusId = "ambience", DefaultGain = .8f },
+             new() { Id = "wind", BusId = "ambience" }, new() { Id = "alert" }],
+            [new() { Id = "ambience" }]);
+        var host = new RecordingHost();
+        using var runtime = new AudioRuntime(host);
+        runtime.Play(configuration, new("rain", "rain", AudioPlacement.Replace, .5f));
+        runtime.Play(configuration, new("wind", "wind", AudioPlacement.Replace));
+        runtime.Play(configuration, new("alert", "alert", AudioPlacement.Replace));
+        var tracks = new Dictionary<string, AudioMixLevel> { ["rain"] = new(.25f) };
+        var mix = new AudioMixOptions
+        {
+            MasterGain = .5f,
+            Buses = new Dictionary<string, AudioMixLevel> { ["ambience"] = new(.5f) },
+            Tracks = tracks
+        };
+        runtime.ApplyMix(mix);
+        AssertGains(.025f, .25f, .5f);
+        tracks["rain"] = new(1f, true);
+        runtime.Play(configuration, new("rain", "second", AudioPlacement.Replace, .5f));
+        AssertGains(.025f, .25f, .5f);
+        runtime.ApplyMix(mix);
+        AssertGains(0, .25f, .5f);
+        runtime.ApplyMix(mix with { Tracks = new Dictionary<string, AudioMixLevel>(), Buses = new Dictionary<string, AudioMixLevel> { ["ambience"] = new(1f, true) } });
+        AssertGains(0, 0, .5f);
+        runtime.ApplyMix(mix with { MasterMuted = true });
+        AssertGains(0, 0, 0);
+
+        void AssertGains(float rain, float wind, float alert)
+        {
+            Assert.That(host.Requests.Last(request => request.TrackId == "rain").Gain, Is.EqualTo(rain).Within(.000001));
+            Assert.That(host.Requests.Last(request => request.TrackId == "wind").Gain, Is.EqualTo(wind).Within(.000001));
+            Assert.That(host.Requests.Last(request => request.TrackId == "alert").Gain, Is.EqualTo(alert).Within(.000001));
+        }
+    }
+
+    [Test]
+    public void CatchUpUsesExplicitPolicyRatherThanTrackOrGroupName()
+    {
+        var host = new RecordingHost();
+        using var runtime = new AudioRuntime(host);
+        var configuration = new AudioConfiguration(
+            [new() { Id = "weather", PreserveDuringCatchUp = true }, new() { Id = "bgm" }]);
+        runtime.BeginCatchUp();
+        runtime.Play(configuration, new("weather", "rain", AudioPlacement.Replace));
+        var discarded = runtime.Play(configuration, new("bgm", "music", AudioPlacement.Replace));
+        Assert.That(discarded.IsCompleted, Is.True);
+        Assert.That(host.Requests, Is.Empty);
+        runtime.EndCatchUp();
+        Assert.That(host.Requests.Single().TrackId, Is.EqualTo("weather"));
+    }
+
+    [Test]
+    public void FiniteLargeContentGainSaturatesAtBackendLimit()
+    {
+        var host = new RecordingHost();
+        using var runtime = new AudioRuntime(host);
+        runtime.Play(new([new() { Id = "loud", DefaultGain = float.MaxValue }]),
+            new("loud", "clip", AudioPlacement.Replace, float.MaxValue));
+        Assert.That(host.Requests.Single().Gain, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void MixerSnapshotsHostCollectionsAndRejectsInvalidUpdatesWithoutChangingActiveOrFutureGain()
+    {
+        var host = new RecordingHost();
+        using var runtime = new AudioRuntime(host);
+        var groups = new Dictionary<string, AudioMixLevel> { ["bgm"] = new(.5f) };
+        runtime.ApplyMix(new AudioMixOptions { MasterGain = .5f, Buses = groups });
+        runtime.Play(Tracks, new("bgm", "first", AudioPlacement.Replace, .5f));
+        Assert.That(host.Requests.Last().Gain, Is.EqualTo(.1f));
+
+        groups["bgm"] = new(1f, true);
+        runtime.Play(Tracks, new("bgm", "second", AudioPlacement.Replace, .5f));
+        Assert.That(host.Requests.Last().Gain, Is.EqualTo(.1f), "Changing a host dictionary is not an explicit mixer update.");
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => runtime.ApplyMix(new AudioMixOptions { MasterGain = float.NaN }));
+        runtime.Play(Tracks, new("bgm", "third", AudioPlacement.Replace, .5f));
+        Assert.That(host.Requests.Last().Gain, Is.EqualTo(.1f));
+
+        runtime.ApplyMix(new AudioMixOptions { Buses = groups });
+        Assert.That(host.Requests.Last().Gain, Is.Zero);
+        runtime.Play(Tracks, new("bgm", "fourth", AudioPlacement.Replace, .5f));
+        Assert.That(host.Requests.Last().Gain, Is.Zero);
+    }
+
+    [Test]
+    public async Task DiagnosticObserverFailureDoesNotStrandPlayback()
+    {
+        await using var runtime = new AudioRuntime(new ThrowingHost());
+        var reports = 0;
+        runtime.Diagnostic += _ => throw new IOException("observer failed");
+        runtime.Diagnostic += _ => reports++;
+        var ticket = runtime.Play(Tracks, new("bgm", "failed", AudioPlacement.Replace));
+        await ticket.Completion.WaitAsync(TimeSpan.FromSeconds(2));
+        Assert.That(reports, Is.GreaterThan(0));
+    }
+
     [Test]
     public async Task BackendStartExceptionReleasesLogicalPlayback()
     {
@@ -36,15 +136,15 @@ public void LiveGainUsesPlayerMasterBusAndMuteWithoutChangingContentGain()
     {
         var host = new RecordingHost();
         using var runtime = new AudioRuntime(host);
-        var settings = new GalNet.Core.Settings.GameSettings { MasterVolume = .5f, BgmVolume = .5f };
-        runtime.ApplyPlayerSettings(settings);
+        var settings = new AudioMixOptions { MasterGain = .5f, Buses = new Dictionary<string, AudioMixLevel> { ["bgm"] = new(.5f) } };
+        runtime.ApplyMix(settings);
         runtime.Play(Tracks, new("bgm", "music", AudioPlacement.Replace, .5f));
         Assert.That(host.Requests[0].Gain, Is.EqualTo(.1f));
-        settings.BgmMuted = true;
-        runtime.ApplyPlayerSettings(settings);
+        settings = settings with { Buses = new Dictionary<string, AudioMixLevel> { ["bgm"] = new(.5f, true) } };
+        runtime.ApplyMix(settings);
         Assert.That(host.Requests.Last().Gain, Is.Zero);
-        settings.BgmMuted = false;
-        runtime.ApplyPlayerSettings(settings);
+        settings = settings with { Buses = new Dictionary<string, AudioMixLevel> { ["bgm"] = new(.5f) } };
+        runtime.ApplyMix(settings);
         Assert.That(host.Requests.Last().Gain, Is.EqualTo(.1f));
     }
 
@@ -85,8 +185,9 @@ public void NaturalEndCompletesTicketsAttachedByReplaceIfDifferent()
         Assert.That(first.IsCompleted && attached.IsCompleted, Is.True);
     }
 
-    private static readonly IReadOnlyList<AudioTrackDefinition> Tracks =
-    [new() { Id = "bgm", Bus = AudioBuses.Bgm, MaxVoices = 1, MaxQueuedItems = 2, DefaultGain = 0.8f }];
+    private static readonly AudioConfiguration Tracks = new(
+        [new() { Id = "bgm", BusId = "bgm", PreserveDuringCatchUp = true, MaxVoices = 1, MaxQueuedItems = 2, DefaultGain = .8f }],
+        [new() { Id = "bgm" }]);
 
     [Test]
     public async Task Replace_stops_current_voice_then_starts_the_new_asset()
diff --git a/test/GalNet.Primitives.Builtins.Tests/BuiltinTestRuntime.cs b/test/GalNet.Primitives.Builtins.Tests/BuiltinTestRuntime.cs
index 5a3d1913..d11ff40e 100644
--- a/test/GalNet.Primitives.Builtins.Tests/BuiltinTestRuntime.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/BuiltinTestRuntime.cs
@@ -1,6 +1,5 @@
 using GalNet.Core.Runtime;
 using GalNet.Core.Services;
-using GalNet.Core.Settings;
 using GalNet.Core.Variable;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
@@ -12,7 +11,7 @@ internal static class BuiltinTestRuntime
     public static StateCatalog Catalog { get; } = CreateCatalog();
     private static StateCatalog CreateCatalog()
     { using var view = new GameRegistration().AddBuiltins().BuildView(); return view.StateCatalog; }
-    public static GameRuntime Create(ITextResolver? resolver, string rootNodeId = "", SettingsContainer? settings = null,
-        IVariableService? variableService = null) => new(resolver, rootNodeId, settings, variableService, Catalog);
+    public static GameRuntime Create(ITextResolver? resolver, string rootNodeId = "",
+        IVariableService? variableService = null) => new(resolver, rootNodeId, variableService, Catalog);
     public static GameState State(GameSnapshot snapshot) => GameState.Restore(Catalog, snapshot.States);
 }
diff --git a/test/GalNet.Core.Tests/Audio/SEffectCatalogTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/Audio/SEffectCatalogTests.cs
similarity index 88%
rename from test/GalNet.Core.Tests/Audio/SEffectCatalogTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Contracts/Audio/SEffectCatalogTests.cs
index 6187618c..5202402c 100644
--- a/test/GalNet.Core.Tests/Audio/SEffectCatalogTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/Audio/SEffectCatalogTests.cs
@@ -1,5 +1,5 @@
 using System.Text.Json;
-using GalNet.Core.Audio;
+using GalNet.Contracts.Builtins.Audio;
 
 namespace GalNet.Core.Tests.Audio;
 
@@ -21,7 +21,7 @@ public void Validates_scope_required_and_numeric_bounds()
 
         using var invalid = JsonDocument.Parse("{\"cutoffHz\": 4}");
         Assert.That(catalog.Validate("seffect.lowPass", SEffectScope.Track, invalid.RootElement), Does.Contain("SEffect parameter 'cutoffHz' is outside its supported range."));
-        Assert.That(catalog.Validate("seffect.lowPass", SEffectScope.Item, document.RootElement), Does.Contain("SEffect 'seffect.lowPass' does not support Item scope."));
+        Assert.That(catalog.Validate("seffect.lowPass", (SEffectScope)99, document.RootElement), Does.Contain("SEffect 'seffect.lowPass' does not support 99 scope."));
     }
 
     [Test]
diff --git a/test/GalNet.Primitives.Builtins.Tests/Contracts/AudioConfigurationTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/AudioConfigurationTests.cs
new file mode 100644
index 00000000..7007dfdf
--- /dev/null
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/AudioConfigurationTests.cs
@@ -0,0 +1,57 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Core.Serialization;
+
+namespace GeneralTest;
+
+public class AudioConfigurationTests
+{
+    [Test]
+    public void GeneratedMetadataPreservesDefaultsForOmittedAudioFields()
+    {
+        var options = BuiltinJson.CreateOptions(new(JsonSerializerDefaults.Web));
+        var track = JsonCodec.Deserialize<AudioTrackDefinition>("""{"id":"rain"}""", options)!;
+        var bus = JsonCodec.Deserialize<AudioBusDefinition>("""{"id":"ambience"}""", options)!;
+        Assert.Multiple(() =>
+        {
+            Assert.That(track.MaxVoices, Is.EqualTo(1));
+            Assert.That(track.DefaultGain, Is.EqualTo(1f));
+            Assert.That(bus.DefaultGain, Is.EqualTo(1f));
+        });
+        Assert.DoesNotThrow(() => new AudioConfiguration([track], [bus]));
+    }
+
+    [Test]
+    public void EmptyUngroupedAndCustomDeclarationsAreValidOwnedValues()
+    {
+        Assert.That(AudioConfiguration.Empty.Tracks, Is.Empty);
+        var groups = new List<AudioBusDefinition> { new() { Id = "ambience" } };
+        var tracks = new List<AudioTrackDefinition>
+        {
+            new() { Id = "rain", BusId = "ambience", PreserveDuringCatchUp = true },
+            new() { Id = "alerts" }
+        };
+        var configuration = new AudioConfiguration(tracks, groups);
+        tracks[0] = tracks[0] with { BusId = "other" };
+        groups.Clear();
+        Assert.That(configuration.Buses.Single().Id, Is.EqualTo("ambience"));
+        Assert.That(configuration.TryGetTrack("rain", out var rain), Is.True);
+        Assert.That(rain.BusId, Is.EqualTo("ambience"));
+        Assert.That(rain.PreserveDuringCatchUp, Is.True);
+        Assert.That(configuration.Tracks[1].BusId, Is.Null);
+    }
+
+    [Test]
+    public void ConfigurationRejectsBrokenDeclarationsAtTheBoundary()
+    {
+        Assert.Throws<InvalidDataException>(() => new AudioConfiguration(buses: [new() { Id = "x" }, new() { Id = "x" }]));
+        Assert.Throws<InvalidDataException>(() => new AudioConfiguration([new() { Id = "x" }, new() { Id = "x" }]));
+        Assert.Throws<InvalidDataException>(() => new AudioConfiguration([new() { Id = "x", BusId = "missing" }]));
+        Assert.Throws<InvalidDataException>(() => new AudioConfiguration([new() { Id = "" }]));
+        Assert.Throws<InvalidDataException>(() => new AudioConfiguration([new() { Id = "x", DefaultGain = float.NaN }]));
+        Assert.Throws<InvalidDataException>(() => new AudioConfiguration([new() { Id = "x", MaxVoices = 0 }]));
+        Assert.Throws<InvalidDataException>(() => new AudioConfiguration([new() { Id = "x", MaxQueuedItems = -1 }]));
+        Assert.Throws<InvalidDataException>(() => new AudioConfiguration([new() { Id = "x", OverflowPolicy = (AudioOverflowPolicy)99 }]));
+    }
+}
diff --git a/test/GalNet.Primitives.Builtins.Tests/Contracts/EffectParameterValidationTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/EffectParameterValidationTests.cs
new file mode 100644
index 00000000..bbc5402c
--- /dev/null
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/EffectParameterValidationTests.cs
@@ -0,0 +1,31 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins.Audio;
+using GalNet.Contracts.Builtins.Scene;
+
+namespace GeneralTest.Scene;
+
+public sealed class EffectParameterValidationTests
+{
+    [TestCase("null"), TestCase("\"0.5\""), TestCase("1e1000")]
+    public void BothEffectCatalogsRejectNonNumericNullOrUnrepresentableFloatValues(string raw)
+    {
+        var visual = new EffectCatalog([new("visual", EffectStage.ScenePost, [new("gain", EffectParameterKind.Float)], [])]);
+        var audio = new SEffectCatalog([new("audio", new HashSet<SEffectScope> { SEffectScope.Track }, [new("gain")])]);
+        using var value = JsonDocument.Parse("{\"gain\":" + raw + "}");
+        Assert.That(visual.Validate("visual", "", value.RootElement.GetRawText()), Is.Not.Empty);
+        Assert.That(audio.Validate("audio", SEffectScope.Track, value.RootElement), Is.Not.Empty);
+    }
+    [Test]
+    public void CatalogMetadataAndValidationRemainConsistentAfterCallerCollectionsChange()
+    {
+        var options = new List<string> { "A" }; var parameters = new List<EffectParameterDefinition> { new("mode", EffectParameterKind.Select, true, Options: options) };
+        var visual = new EffectCatalog([new("visual", EffectStage.ScenePost, parameters, [])]);
+        options.Add("B"); parameters.Clear();
+        Assert.That(visual.Validate("visual", "", "{\"mode\":\"B\"}"), Is.Not.Empty);
+        Assert.That(visual.Definitions.Single().Parameters.Single().Options, Is.EqualTo(new[] { "A" }));
+        var scopes = new HashSet<SEffectScope> { SEffectScope.Track };
+        var audio = new SEffectCatalog([new("audio", scopes, [new("gain", true, 0, 1)])]); scopes.Clear();
+        Assert.That(audio.Validate("audio", SEffectScope.Track, JsonSerializer.SerializeToElement(new { gain = .5f })), Is.Empty);
+        Assert.That(audio.Definitions.Single().SupportedScopes, Does.Contain(SEffectScope.Track));
+    }
+}
diff --git a/test/GalNet.Core.Tests/Gallery/GalleryCatalogTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/Gallery/GalleryCatalogTests.cs
similarity index 98%
rename from test/GalNet.Core.Tests/Gallery/GalleryCatalogTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Contracts/Gallery/GalleryCatalogTests.cs
index a2ea66ec..3d492629 100644
--- a/test/GalNet.Core.Tests/Gallery/GalleryCatalogTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/Gallery/GalleryCatalogTests.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 
 namespace GeneralTest.Gallery;
 
diff --git a/test/GalNet.Primitives.Builtins.Tests/Contracts/Gallery/GalleryMetadataTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/Gallery/GalleryMetadataTests.cs
new file mode 100644
index 00000000..b0f5ef64
--- /dev/null
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/Gallery/GalleryMetadataTests.cs
@@ -0,0 +1,19 @@
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Core.Assets;
+
+namespace GeneralTest.Gallery;
+
+public sealed class GalleryMetadataTests
+{
+    [Test]
+    public void OptionalGalleryExtensionRetainsUnknownMetadataAndAnnotationMembers()
+    {
+        var codec = new AssetMetaCodec(new ResourceTypeCatalogBuilder().Add<AssetMeta>("project").Build());
+        var metadata = codec.Deserialize("""{"id":"item","type":"project","path":"file","future":true,"gallery":[{"id":3,"typeId":"images","custom":{"kept":true}}]}""");
+        metadata.SetGallery(metadata.ReadGallery().Select(item => item with { Id = 4 }));
+        var reloaded = codec.Deserialize(codec.Serialize(metadata));
+        Assert.That(reloaded.ReadGallery().Single().Id, Is.EqualTo(4));
+        Assert.That(reloaded.ReadGallery().Single().ExtensionData!["custom"].GetProperty("kept").GetBoolean(), Is.True);
+        Assert.That(reloaded.ExtensionData!["future"].GetBoolean(), Is.True);
+    }
+}
diff --git a/test/GalNet.Core.Tests/Scene/EffectCatalogTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/EffectCatalogTests.cs
similarity index 97%
rename from test/GalNet.Core.Tests/Scene/EffectCatalogTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/EffectCatalogTests.cs
index 3d8c063e..b0916d52 100644
--- a/test/GalNet.Core.Tests/Scene/EffectCatalogTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/EffectCatalogTests.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GeneralTest.Scene;
 
diff --git a/test/GalNet.Core.Tests/Scene/SceneTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/SceneTests.cs
similarity index 92%
rename from test/GalNet.Core.Tests/Scene/SceneTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/SceneTests.cs
index 1fd89747..cc99909c 100644
--- a/test/GalNet.Core.Tests/Scene/SceneTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/SceneTests.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GeneralTest.Scene;
 
@@ -63,7 +63,7 @@ public class GameStateTableTests
     public void RegisteredTablesAreEmptyAndUnregisteredTypesAreRejected()
     {
         var builder = new GalNet.Core.Runtime.StateCatalogBuilder();
-        builder.Register<Layer>("layers", value => value.Id);
+        builder.Register<Layer>("layers", value => value.Id, keySpace: GalNet.Primitives.Builtins.BuiltinScene.KeySpace);
         var state = new GalNet.Core.Runtime.GameState(builder.Build());
         Assert.That(state.Table<Layer>().Values, Is.Empty);
         Assert.Throws<InvalidOperationException>(() => state.Table<EffectInstance>());
@@ -72,7 +72,7 @@ public void RegisteredTablesAreEmptyAndUnregisteredTypesAreRejected()
     public void TablesRejectDuplicateIdsAndCaptureDetachedPayloads()
     {
         var builder = new GalNet.Core.Runtime.StateCatalogBuilder();
-        builder.Register<Layer>("layers", value => value.Id);
+        builder.Register<Layer>("layers", value => value.Id, keySpace: GalNet.Primitives.Builtins.BuiltinScene.KeySpace);
         var catalog = builder.Build();
         var state = new GalNet.Core.Runtime.GameState(catalog);
         state.Table<Layer>().Add(new Layer { Id = "bg", AssetId = "before" });
diff --git a/test/GalNet.Core.Tests/Scene/ShaderAnimationPropertyTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/ShaderAnimationPropertyTests.cs
similarity index 97%
rename from test/GalNet.Core.Tests/Scene/ShaderAnimationPropertyTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/ShaderAnimationPropertyTests.cs
index e14cdab2..1e01f950 100644
--- a/test/GalNet.Core.Tests/Scene/ShaderAnimationPropertyTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/ShaderAnimationPropertyTests.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GeneralTest.Scene;
 
diff --git a/test/GalNet.Core.Tests/Scene/ShaderEffectMetadataTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/ShaderEffectMetadataTests.cs
similarity index 85%
rename from test/GalNet.Core.Tests/Scene/ShaderEffectMetadataTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/ShaderEffectMetadataTests.cs
index d267ce06..099fa5d3 100644
--- a/test/GalNet.Core.Tests/Scene/ShaderEffectMetadataTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/ShaderEffectMetadataTests.cs
@@ -1,5 +1,5 @@
 using System.Text.Json;
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GeneralTest.Scene;
 
@@ -125,6 +125,30 @@ @texture noise
         });
     }
 
+    [TestCase("float2", ShaderEffectParameterKind.Vector2, "[0,0]")]
+    [TestCase("float3", ShaderEffectParameterKind.Vector3, "[0,0,0]")]
+    [TestCase("float4", ShaderEffectParameterKind.Vector4, "[0,0,0,0]")]
+    public void Parser_accepts_float_vector_types_with_fixed_defaults(string type, ShaderEffectParameterKind kind, string defaultValue)
+    {
+        var source = """
+            /*
+            @gal.effect v=1
+            @input source
+            @targets layer
+            @param direction
+              uniform: uDirection
+              type: TYPE
+            */
+            uniform TYPE uDirection;
+            """.Replace("TYPE", type, StringComparison.Ordinal);
+        var result = ShaderEffectMetadataParser.Parse(Program, source);
+
+        Assert.That(result.Success, Is.True, string.Join(Environment.NewLine, result.Diagnostics));
+        var direction = result.Descriptor!.Parameters.Single();
+        Assert.That(direction.Kind, Is.EqualTo(kind));
+        Assert.That(direction.DefaultValue, Is.EqualTo(defaultValue));
+    }
+
     [Test]
     public void Attachment_keeps_runtime_handle_internal_and_enumerates_static_resource_dependencies()
     {
diff --git a/test/GalNet.Core.Tests/Scene/TimelineTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/TimelineTests.cs
similarity index 97%
rename from test/GalNet.Core.Tests/Scene/TimelineTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/TimelineTests.cs
index 592a127a..935f99fc 100644
--- a/test/GalNet.Core.Tests/Scene/TimelineTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/Scene/TimelineTests.cs
@@ -1,4 +1,4 @@
-using GalNet.Core.Scene;
+using GalNet.Contracts.Builtins.Scene;
 
 namespace GeneralTest.Scene;
 
diff --git a/test/GalNet.Core.Tests/Variants/ImageVariantsTests.cs b/test/GalNet.Primitives.Builtins.Tests/Contracts/Variants/ImageVariantsTests.cs
similarity index 94%
rename from test/GalNet.Core.Tests/Variants/ImageVariantsTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Contracts/Variants/ImageVariantsTests.cs
index e55e9afb..e5622751 100644
--- a/test/GalNet.Core.Tests/Variants/ImageVariantsTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Contracts/Variants/ImageVariantsTests.cs
@@ -1,5 +1,5 @@
 using System.Text.Json;
-using GalNet.Core.Variants;
+using GalNet.Contracts.Builtins.Variants;
 
 namespace GeneralTest.Variants;
 
@@ -243,14 +243,28 @@ public void Dimension_count_is_not_fixed_and_generated_keys_use_invariant_number
     }
 
     [Test]
-    public void Explicit_extra_dimension_is_allowed_without_synthesizing_values()
+    public void Only_file_positions_are_active_and_unused_names_are_retained()
     {
         var source = Source("idle");
         var definition = Build(source, "idle");
-        Assert.That(definition.Dimensions[1].Options, Is.Empty);
+        Assert.That(definition.Dimensions, Has.Count.EqualTo(1));
+        Assert.That(source.Dimensions, Has.Count.EqualTo(2));
         Assert.That(ImageVariantsResolver.Initialize(definition).Request.Keys, Is.EquivalentTo(new[] { "expression" }));
     }
 
+    [Test]
+    public void File_growth_infers_new_positions_without_changing_existing_names_or_author_source()
+    {
+        var source = Source("idle_coat");
+        source.Dimensions![0].Key = "d3";
+        var definition = Build(source, "idle_coat", "smile_skirt_day");
+        Assert.That(definition.Dimensions.Select(item => item.Key), Is.EqualTo(new[] { "d3", "outfit", "d3_" }));
+        Assert.That(definition.Dimensions[2].Options, Is.EqualTo(new[] { "day" }));
+        Assert.That(source.Dimensions, Has.Count.EqualTo(2));
+        var smaller = Build(source, "idle_coat");
+        Assert.That(smaller.Dimensions, Has.Count.EqualTo(2));
+    }
+
     [TestCase("idle_.png", "empty-segment")]
     [TestCase("_idle.png", "empty-segment")]
     [TestCase("idle__coat.png", "empty-segment")]
@@ -295,7 +309,7 @@ public void Builder_reports_bad_version_folder_default_identity_and_resource_typ
     }
 
     [Test]
-    public void Builder_rejects_duplicate_empty_null_or_insufficient_dimensions()
+    public void Builder_rejects_duplicate_empty_or_null_dimension_names()
     {
         var source = Source();
         source.Dimensions = [new() { Key = "same" }, new() { Key = "same" }, new() { Key = " " }, null!];
@@ -303,7 +317,7 @@ public void Builder_rejects_duplicate_empty_null_or_insufficient_dimensions()
         Assert.That(result.Definition, Is.Null);
         Assert.That(result.Diagnostics.Select(item => item.Path), Is.EquivalentTo(new[] { "/dimensions/1/key", "/dimensions/2/key", "/dimensions/3/key" }));
         source.Dimensions = [];
-        Assert.That(ImageVariantsBuilder.Build(source, Files("idle_coat")).Diagnostics.Any(item => item.Code == "insufficient-dimensions"), Is.True);
+        Assert.That(Build(source, "idle_coat").Dimensions.Select(item => item.Key), Is.EqualTo(new[] { "d1", "d2" }));
     }
 
     [Test]
diff --git a/test/GalNet.Primitives.Builtins.Tests/Entry/BuiltinSchemaComponentsTests.cs b/test/GalNet.Primitives.Builtins.Tests/Entry/BuiltinSchemaComponentsTests.cs
index f690953a..a44fd470 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Entry/BuiltinSchemaComponentsTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Entry/BuiltinSchemaComponentsTests.cs
@@ -15,13 +15,15 @@ public sealed class BuiltinSchemaComponentsTests
     public void BasicRangesAreDeclaredAndEnforcedBySharedValueRules(string type, string name, int minimum)
     {
         var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
-        var parameter = catalog.Get(type).DynamicParameters![name];
+        var parameter = catalog.Get(type).DynamicParameters[name];
         Assert.That(parameter.TryGetConstraint("minimum", out var bound), Is.True);
         Assert.That(bound.GetInt32(), Is.EqualTo(minimum));
         Assert.That(ValueValidation.Validate(parameter.Value, JsonSerializer.SerializeToElement(minimum - 1))!.Code, Is.EqualTo("value.range"));
-        Assert.Throws<InvalidDataException>(() => PrimitiveArgumentHelper.Normalize(catalog.Get(type).DynamicParameters!,
+        Assert.Throws<InvalidDataException>(() => PrimitiveArgumentHelper.Normalize(catalog.Get(type).DynamicParameters,
             JsonSerializer.SerializeToElement(new Dictionary<string, object> { [name] = minimum - 1 })));
-        Assert.That(ValueCodec.Describe(parameter.Value).GetProperty("minimum").GetInt32(), Is.EqualTo(minimum));
+        var schema = ValueCodec.Describe(parameter.Value);
+        if (parameter.Value.AllowNull) schema = schema.GetProperty("anyOf")[0];
+        Assert.That(schema.GetProperty("minimum").GetInt32(), Is.EqualTo(minimum));
     }
 
     private static readonly string[] SelectedTypes = ["dialogue.text", "dialogue.show", "dialogue.hide", "flow.wait"];
@@ -36,9 +38,9 @@ public void AllReturnsIndependentModulesWithUniqueInstructionIds()
         {
             Assert.That(modules, Has.Count.EqualTo(14));
             Assert.That(modules.Select(module => module.Id).Distinct().Count(), Is.EqualTo(14));
-            Assert.That(catalog.Definitions, Has.Count.EqualTo(45));
-            Assert.That(catalog.Definitions.Count(entry => entry.Kind == EntryKind.Primitive), Is.EqualTo(37));
-            Assert.That(catalog.Definitions.Count(entry => entry.Kind == EntryKind.Composite), Is.EqualTo(8));
+            Assert.That(catalog.Definitions, Has.Count.EqualTo(53));
+            Assert.That(catalog.Definitions.Count(entry => entry.Kind == EntryKind.Primitive), Is.EqualTo(39));
+            Assert.That(catalog.Definitions.Count(entry => entry.Kind == EntryKind.Composite), Is.EqualTo(14));
             Assert.That(() => ((IList<IEntryModule>)modules).Clear(), Throws.TypeOf<NotSupportedException>());
         });
     }
diff --git a/test/GalNet.Primitives.Builtins.Tests/Entry/EntryModelTests.cs b/test/GalNet.Primitives.Builtins.Tests/Entry/EntryModelTests.cs
index 42b39cef..a988a7c0 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Entry/EntryModelTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Entry/EntryModelTests.cs
@@ -1,3 +1,4 @@
+using System.Text.Json;
 using GalNet.Contracts.Builtins;
 using GalNet.Core.Entry;
 using GalNet.Primitives.Builtins;
@@ -16,26 +17,26 @@ public class EntryModelTests
     [Test]
     public void Registry_Should_Create_All_BuiltIn_Entries()
     {
-        Assert.That(Catalog.Definitions, Has.Count.EqualTo(45));
+        Assert.That(Catalog.Definitions, Has.Count.EqualTo(53));
         foreach (var definition in Catalog.Definitions)
             Assert.That(Catalog.Create(definition.Type).Type, Is.EqualTo(definition.Type));
     }
 
     [Test]
-    public void Create_Should_Apply_Defaults_And_Discard_Unknown_Values()
+    public void AuthoringCreatePreservesJsonAndUnknownDraftFields()
     {
-        var entry = Catalog.Create(BuiltinEntryIds.ShowLayer, 3, "flag", new Dictionary<string, string>
+        var entry = Catalog.Create(BuiltinEntryIds.ShowLayer, 3, "flag", JsonSerializer.SerializeToElement(new Dictionary<string, string>
         {
             ["handleId"] = "hero",
             ["unknown"] = "discard"
-        });
+        }));
 
         Assert.That(entry, Is.TypeOf<AuthoringPrimitiveEntry>());
         Assert.That(entry.Id, Is.EqualTo(3));
         Assert.That(entry.Condition, Is.EqualTo("flag"));
-        Assert.That(entry.Values["handleId"], Is.EqualTo("hero"));
-        Assert.That(entry.Values, Does.Not.ContainKey("unknown"));
-        Assert.That(entry.Values, Does.Not.ContainKey("transitionDuration"));
+        Assert.That(entry.Arguments.GetProperty("handleId").GetString(), Is.EqualTo("hero"));
+        Assert.That(entry.Arguments.GetProperty("unknown").GetString(), Is.EqualTo("discard"));
+        Assert.That(entry.Arguments.TryGetProperty("transitionDuration", out _), Is.False);
     }
 
     [Test]
@@ -43,8 +44,8 @@ public void Entry_Values_Should_Not_Be_Shared()
     {
         var first = Catalog.Create(BuiltinEntryIds.Text);
         var second = Catalog.Create(BuiltinEntryIds.Text);
-        first.Values["content"] = "first";
-        Assert.That(second.Values, Does.Not.ContainKey("content"));
+        first.SetArguments(JsonSerializer.SerializeToElement(new { content = "first" }));
+        Assert.That(second.Arguments.TryGetProperty("content", out _), Is.False);
     }
 
     [Test]
@@ -61,21 +62,21 @@ public void Removed_Types_Should_Be_Unknown(string type) =>
     [Test]
     public void Concrete_Action_Types_Should_Not_Declare_Action_Parameter() =>
         Assert.That(Catalog.Definitions.Where(x => x.Type != BuiltinEntryIds.InvokeCustom)
-            .All(x => !x.Parameters.ContainsKey("action")), Is.True);
+            .All(x => !x.DynamicParameters.ContainsKey("action")), Is.True);
 
     [Test]
     public void TextEntry_Should_Not_Expose_Widget_Parameter()
     {
         var definition = Catalog.Get(BuiltinEntryIds.Text);
-        Assert.That(definition.Parameters.Keys, Is.EquivalentTo(TextParameters));
-        Assert.That(Catalog.Create(BuiltinEntryIds.Text).Values, Does.Not.ContainKey("widget"));
+        Assert.That(definition.DynamicParameters.Keys, Is.EquivalentTo(TextParameters));
+        Assert.That(Catalog.Create(BuiltinEntryIds.Text).Arguments.TryGetProperty("widget", out _), Is.False);
     }
 
     [Test]
     public void Dialogue_Visibility_Entries_Should_Have_No_Parameters()
     {
-        Assert.That(Catalog.Get(BuiltinEntryIds.ShowDialogue).Parameters, Is.Empty);
-        Assert.That(Catalog.Get(BuiltinEntryIds.HideDialogue).Parameters, Is.Empty);
+        Assert.That(Catalog.Get(BuiltinEntryIds.ShowDialogue).DynamicParameters, Is.Empty);
+        Assert.That(Catalog.Get(BuiltinEntryIds.HideDialogue).DynamicParameters, Is.Empty);
     }
 
     [Test]
@@ -83,10 +84,10 @@ public void Nvl_Entries_Expose_Explicit_Visibility_Clear_And_Append_Schemas()
     {
         Assert.Multiple(() =>
         {
-            Assert.That(Catalog.Get(BuiltinEntryIds.ShowNvl).Parameters, Is.Empty);
-            Assert.That(Catalog.Get(BuiltinEntryIds.HideNvl).Parameters, Is.Empty);
-            Assert.That(Catalog.Get(BuiltinEntryIds.ClearNvl).Parameters, Is.Empty);
-            Assert.That(Catalog.Get(BuiltinEntryIds.AppendNvl).Parameters.Keys, Is.EquivalentTo(["content"]));
+            Assert.That(Catalog.Get(BuiltinEntryIds.ShowNvl).DynamicParameters, Is.Empty);
+            Assert.That(Catalog.Get(BuiltinEntryIds.HideNvl).DynamicParameters, Is.Empty);
+            Assert.That(Catalog.Get(BuiltinEntryIds.ClearNvl).DynamicParameters, Is.Empty);
+            Assert.That(Catalog.Get(BuiltinEntryIds.AppendNvl).DynamicParameters.Keys, Is.EquivalentTo(["content"]));
         });
     }
 
@@ -94,9 +95,9 @@ public void Nvl_Entries_Expose_Explicit_Visibility_Clear_And_Append_Schemas()
     public void SetVariable_Should_Only_Expose_Target_And_Expression()
     {
         var definition = Catalog.Get(BuiltinEntryIds.SetVariable);
-        Assert.That(definition.Parameters.Keys, Is.EquivalentTo(VariableParameters));
-        Assert.That(definition.Parameters["target"], Is.EqualTo(EntryParameterType.VariableName));
-        Assert.That(definition.Parameters["expression"], Is.EqualTo(EntryParameterType.Expression));
+        Assert.That(definition.DynamicParameters.Keys, Is.EquivalentTo(VariableParameters));
+        Assert.That(definition.DynamicParameters["target"].Editor!.EditorId, Is.EqualTo("entry.variablename"));
+        Assert.That(definition.DynamicParameters["expression"].Editor!.EditorId, Is.EqualTo("entry.expression"));
     }
 
     [Test]
@@ -110,13 +111,13 @@ public void Color_Field_Transitions_Are_Composite_Entries_With_Declared_Paramete
         {
             var definition = Catalog.Get(type);
             Assert.That(definition.Kind, Is.EqualTo(EntryKind.Composite));
-            Assert.That(definition.Parameters.Keys, Does.Contain("fromLayerHandleId"));
-            Assert.That(definition.Parameters.Keys, Does.Contain("toLayerHandleId"));
-            Assert.That(definition.Parameters.Keys, Does.Contain("fadeInDuration"));
-            Assert.That(definition.Parameters.Keys, Does.Contain("holdDuration"));
-            Assert.That(definition.Parameters.Keys, Does.Contain("fadeOutDuration"));
+            Assert.That(definition.DynamicParameters.Keys, Does.Contain("fromLayerHandleId"));
+            Assert.That(definition.DynamicParameters.Keys, Does.Contain("toLayerHandleId"));
+            Assert.That(definition.DynamicParameters.Keys, Does.Contain("fadeInDuration"));
+            Assert.That(definition.DynamicParameters.Keys, Does.Contain("holdDuration"));
+            Assert.That(definition.DynamicParameters.Keys, Does.Contain("fadeOutDuration"));
         }
-        Assert.That(Catalog.Get(BuiltinEntryIds.ColorFadeTransition).Parameters.Keys, Does.Contain("color"));
+        Assert.That(Catalog.Get(BuiltinEntryIds.ColorFadeTransition).DynamicParameters.Keys, Does.Contain("color"));
     }
 
     [Test]
@@ -124,9 +125,9 @@ public void Slide_Transition_Is_A_Composite_Entry_With_Direction_And_Distance()
     {
         var definition = Catalog.Get(BuiltinEntryIds.SlideTransition);
         Assert.That(definition.Kind, Is.EqualTo(EntryKind.Composite));
-        Assert.That(definition.Parameters["direction"], Is.EqualTo(EntryParameterType.Select));
-        Assert.That(definition.Parameters["distance"], Is.EqualTo(EntryParameterType.Float));
-        Assert.That(definition.Options["direction"], Is.EquivalentTo(SlideDirections));
+        Assert.That(definition.DynamicParameters["direction"].Editor!.EditorId, Is.EqualTo("choice"));
+        Assert.That(definition.DynamicParameters["distance"].ValueType, Is.EqualTo(typeof(float)));
+        Assert.That(definition.DynamicParameters["direction"].Constraints!.Value.GetProperty("enum").EnumerateArray().Select(value => value.GetString()), Is.EquivalentTo(SlideDirections));
     }
 
     [Test]
@@ -134,16 +135,16 @@ public void Blinds_Transition_Is_A_Composite_Entry_With_Mask_Parameters()
     {
         var definition = Catalog.Get(BuiltinEntryIds.BlindsTransition);
         Assert.That(definition.Kind, Is.EqualTo(EntryKind.Composite));
-        Assert.That(definition.Parameters["maskProgram"], Is.EqualTo(EntryParameterType.EffectProgramAsset));
-        Assert.That(definition.Parameters["bladeCount"], Is.EqualTo(EntryParameterType.Integer));
-        Assert.That(definition.Parameters["orientation"], Is.EqualTo(EntryParameterType.Select));
-        Assert.That(definition.Options["orientation"], Is.EquivalentTo(BlindOrientations));
+        Assert.That(definition.DynamicParameters["maskProgram"].Editor!.EditorId, Is.EqualTo("entry.effectprogramasset"));
+        Assert.That(definition.DynamicParameters["bladeCount"].ValueType, Is.EqualTo(typeof(int)));
+        Assert.That(definition.DynamicParameters["orientation"].Editor!.EditorId, Is.EqualTo("choice"));
+        Assert.That(definition.DynamicParameters["orientation"].Constraints!.Value.GetProperty("enum").EnumerateArray().Select(value => value.GetString()), Is.EquivalentTo(BlindOrientations));
     }
 
     [Test]
     public void Effect_apply_uses_a_typed_program_resource()
     {
         var definition = Catalog.Get(BuiltinEntryIds.ApplyEffect);
-        Assert.That(definition.Parameters["program"], Is.EqualTo(EntryParameterType.EffectProgramAsset));
+        Assert.That(definition.DynamicParameters["program"].Editor!.EditorId, Is.EqualTo("entry.effectprogramasset"));
     }
 }
diff --git a/test/GalNet.Primitives.Builtins.Tests/Entry/EntryModuleCatalogTests.cs b/test/GalNet.Primitives.Builtins.Tests/Entry/EntryModuleCatalogTests.cs
index 6b073e53..1e77bc19 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Entry/EntryModuleCatalogTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Entry/EntryModuleCatalogTests.cs
@@ -19,13 +19,13 @@ public void TimelineContractUsesOnlyTheNewEntryIdAndParameter()
         Assert.That(catalog.TryGet("animation.play", out _), Is.False);
         var schema = catalog.Get(BuiltinEntryIds.PlayTimeline);
         Assert.That(schema.FieldDataType, Is.EqualTo(typeof(TimelineOptions)));
-        var value = PrimitiveArgumentHelper.Normalize(schema.DynamicParameters!, JsonSerializer.SerializeToElement(new
+        var value = PrimitiveArgumentHelper.Normalize(schema.DynamicParameters, JsonSerializer.SerializeToElement(new
         {
-            timeline = new GalNet.Core.Scene.TimelineDefinition { PlaybackHandleId = "intro", DurationFrames = 30 }
+            timeline = new GalNet.Contracts.Builtins.Scene.TimelineDefinition { PlaybackHandleId = "intro", DurationFrames = 30 }
         }));
         Assert.That(value.TryGetProperty("timeline", out _), Is.True);
         Assert.That(value.TryGetProperty("plan", out _), Is.False);
-        Assert.Throws<InvalidDataException>(() => PrimitiveArgumentHelper.Normalize(schema.DynamicParameters!,
+        Assert.Throws<InvalidDataException>(() => PrimitiveArgumentHelper.Normalize(schema.DynamicParameters,
             JsonSerializer.SerializeToElement(new { plan = new { durationFrames = 30 } })));
     }
 
@@ -49,7 +49,7 @@ public void BuiltinContractsValidateCustomImplementationsBeforeFactoryInvocation
     public void AnimationContractRejectsUnknownEmbeddedEvents()
     {
         var schema = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules()).Get("timeline.play");
-        Assert.Throws<InvalidDataException>(() => PrimitiveArgumentHelper.Normalize(schema.DynamicParameters!,
+        Assert.Throws<InvalidDataException>(() => PrimitiveArgumentHelper.Normalize(schema.DynamicParameters,
             JsonSerializer.SerializeToElement(new
             {
                 timeline = new { durationFrames = 1, events = new[] { new { frame = 0, type = "custom.unsupported", parameters = new { } } } }
@@ -88,7 +88,7 @@ public void CustomImplementationCanUseBuiltinSchemaWithoutBuiltinExecution()
         using var registration = new GameRegistration().AddBuiltinSchemas()
             .RegisterInstruction("audio.play", context => new ImmediatePrimitiveInstance(() => calls++, batchId: context.BatchId));
         using var view = registration.BuildView();
-        view.Dispatch(new PrimitiveEntry("audio.play", JsonSerializer.SerializeToElement(new { asset = "clip" })), new GameRuntime(null), CancellationToken.None);
+        view.Dispatch(new PrimitiveEntry("audio.play", JsonSerializer.SerializeToElement(new { trackId = "custom", asset = "clip" })), new GameRuntime(null), CancellationToken.None);
         Assert.That(calls, Is.EqualTo(1));
         Assert.That(view.CanExecute("variable.set"), Is.False);
     }
diff --git a/test/GalNet.Primitives.Builtins.Tests/Entry/TypedBuiltinAuthoringTests.cs b/test/GalNet.Primitives.Builtins.Tests/Entry/TypedBuiltinAuthoringTests.cs
index 10e969b4..59a292f4 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Entry/TypedBuiltinAuthoringTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Entry/TypedBuiltinAuthoringTests.cs
@@ -1,12 +1,11 @@
 using System.Text.Json;
 using System.Threading.Channels;
 using GalNet.Contracts.Builtins;
-using GalNet.Core.Audio;
+using GalNet.Contracts.Builtins.Audio;
 using GalNet.Core.Compilation;
 using GalNet.Core.Entry;
 using GalNet.Core.Primitives;
 using GalNet.Core.Serialization;
-using GalNet.Presentation.Abstractions.Audio;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
 using GalNet.Runtime.Runtime;
@@ -15,6 +14,46 @@ namespace GeneralTest.Entry;
 
 public sealed class TypedBuiltinAuthoringTests
 {
+    [Test]
+    public async Task CompiledRepeatAndCompletionReachRuntimeAndAutoBlockingWaitsForAllIterations()
+    {
+        using var host = new RecordingHost();
+        await using var view = new GameRegistration().AddBuiltins(audioHost: host, audioConfiguration: BuiltinAudioDefaults.Create()).BuildView();
+        var runtime = new GameRuntime(null); var catalog = new TargetProfileEntryCatalog([BuiltinSchemas.CreateAudioModule()]);
+        var finite = Compile(catalog, "audio.play", new { trackId = "bgm", asset = "finite", loopCount = 2, autoBlocking = "true" });
+        var instance = view.Dispatch(new PrimitiveEntry(finite.TypeId, finite.Arguments), runtime, default);
+        var completed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        instance.Completed += _ => completed.TrySetResult();
+        var first = await host.TakeAsync(AudioBackendAction.Start); host.End(first);
+        var second = await host.TakeAsync(AudioBackendAction.Start);
+        Assert.That(instance.IsCompleted, Is.False); host.End(second);
+        await completed.Task.WaitAsync(TimeSpan.FromSeconds(3));
+        var rotating = Compile(catalog, "audio.play", new { trackId = "bgm", asset = "rotating", completion = "requeueTail" });
+        view.Dispatch(new PrimitiveEntry(rotating.TypeId, rotating.Arguments), runtime, default);
+        var original = await host.TakeAsync(AudioBackendAction.Start); host.End(original);
+        var repeated = await host.TakeAsync(AudioBackendAction.Start);
+        Assert.That(repeated.AssetId, Is.EqualTo("rotating")); Assert.That(repeated.VoiceId, Is.Not.EqualTo(original.VoiceId));
+        var stop = Compile(catalog, "audio.stop", new { trackId = "bgm" });
+        view.Dispatch(new PrimitiveEntry(stop.TypeId, stop.Arguments), runtime, default); host.End(repeated);
+        Assert.That(runtime.State.Table<AudioTrackState>().Get("bgm").Active, Is.Empty);
+    }
+
+    [TestCase("audio.play")]
+    [TestCase("audio.enqueue")]
+    public void AudioCompletionAndRepeatHaveExplicitDefaultsAndRejectInvalidAuthorValues(string type)
+    {
+        var catalog = new TargetProfileEntryCatalog([BuiltinSchemas.CreateAudioModule()]);
+        var defaults = Compile(catalog, type, new { trackId = "bgm", asset = "music" }).Arguments;
+        Assert.That(defaults.GetProperty("loopCount").GetInt32(), Is.EqualTo(1));
+        Assert.That(defaults.GetProperty("completion").GetString(), Is.EqualTo("discard"));
+        var loop = Compile(catalog, type, new { trackId = "bgm", asset = "music", loopCount = 0, completion = "requeueTail" }).Arguments;
+        var options = GalNet.Core.Parameters.ValueCodec.DeserializeFields<AudioPlayOptions>(AudioPlayOptions.Schema, loop);
+        Assert.That(options.LoopCount, Is.Zero); Assert.That(options.Completion, Is.EqualTo(AudioCompletion.RequeueTail));
+        Assert.That(() => Compile(catalog, type, new { trackId = "bgm", loopCount = -1 }), Throws.TypeOf<InvalidDataException>());
+        Assert.That(() => Compile(catalog, type, new { trackId = "bgm", loopCount = 1.5 }), Throws.TypeOf<InvalidDataException>());
+        Assert.That(() => Compile(catalog, type, new { trackId = "bgm", completion = "RequeueTail" }), Throws.TypeOf<InvalidDataException>());
+    }
+
     [TestCase(BuiltinEntryIds.TextVoice, BuiltinEntryIds.Text)]
     [TestCase(BuiltinEntryIds.AppendVoiceNvl, BuiltinEntryIds.AppendNvl)]
     public void TypedVoiceExpansionKeepsConditionsReadingBoundaryNullAndSourceMap(string type, string textType)
@@ -24,7 +63,7 @@ public void TypedVoiceExpansionKeepsConditionsReadingBoundaryNullAndSourceMap(st
         {
             Entries = [new() { Id = "voice", Type = type, Condition = "enabled",
             Parameters = new() { ["asset"] = JsonSerializer.SerializeToElement("clip"),
-                ["content"] = JsonSerializer.SerializeToElement<object?>(null), ["trackId"] = JsonSerializer.SerializeToElement<object?>(null) } }]
+                ["content"] = JsonSerializer.SerializeToElement<object?>(null), ["trackId"] = JsonSerializer.SerializeToElement("custom-voice") } }]
         };
         var compiled = GalgroupCompiler.Compile(source, catalog);
         var entries = compiled.Document.Entries;
@@ -32,7 +71,7 @@ public void TypedVoiceExpansionKeepsConditionsReadingBoundaryNullAndSourceMap(st
         Assert.That(entries.All(entry => entry.Condition == "enabled" && entry.BatchId is null), Is.True);
         Assert.That(entries[0].ReadingBoundaryId, Is.EqualTo("voice#2"));
         Assert.That(entries[1].ReadingBoundaryId, Is.Null);
-        Assert.That(entries[0].Arguments.GetProperty("trackId").GetString(), Is.Empty);
+        Assert.That(entries[0].Arguments.GetProperty("trackId").GetString(), Is.EqualTo("custom-voice"));
         Assert.That(entries[0].Arguments.GetProperty("placement").GetString(), Is.EqualTo("replaceIfDifferent"));
         Assert.That(entries[1].Arguments.GetProperty("content").GetString(), Is.Empty);
         Assert.That(compiled.SourceMap["voice"], Is.EqualTo(new[] { "voice#1", "voice#2" }));
@@ -45,7 +84,7 @@ public void CompositeDtosShareColorFieldsAndStillRejectInvalidTransitionInputs()
     {
         var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
         var composites = catalog.Definitions.Where(definition => definition.Kind == EntryKind.Composite).ToArray();
-        Assert.That(composites, Has.Length.EqualTo(8));
+        Assert.That(composites, Has.Length.EqualTo(14));
         Assert.That(composites.All(definition => definition.FieldDataType is not null), Is.True);
         Assert.That(catalog.Get(BuiltinEntryIds.BlackFadeTransition).FieldDataType, Is.EqualTo(typeof(ColorFieldOptions)));
         Assert.That(catalog.Get(BuiltinEntryIds.WhiteFadeTransition).FieldDataType, Is.EqualTo(typeof(ColorFieldOptions)));
@@ -64,7 +103,7 @@ public void CompositeDtosShareColorFieldsAndStillRejectInvalidTransitionInputs()
     public void ComplexDtoDefaultsChoicesAndOpenPayloadKeepTheirWireContract()
     {
         var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
-        var audio = Compile(catalog, "audio.play", new { placement = "replaceIfDifferent", autoBlocking = (string?)null }).Arguments;
+        var audio = Compile(catalog, "audio.play", new { trackId = "custom", placement = "replaceIfDifferent", autoBlocking = (string?)null }).Arguments;
         var options = GalNet.Core.Parameters.ValueCodec.DeserializeFields<AudioPlayOptions>(AudioPlayOptions.Schema, audio);
         Assert.That(options.Placement, Is.EqualTo(AudioPlacement.ReplaceIfDifferent));
         Assert.That(options.AutoBlocking, Is.Null);
@@ -77,10 +116,9 @@ public void ComplexDtoDefaultsChoicesAndOpenPayloadKeepTheirWireContract()
         Assert.That(() => Compile(catalog, "layer.move", new { duration = -1 }), Throws.TypeOf<InvalidDataException>());
         Assert.That(() => Compile(catalog, "particle.burst", new { count = 0 }), Throws.TypeOf<InvalidDataException>());
         Assert.That(() => Compile(catalog, "video.play", new { asset = "movie", skipPoints = new[] { 2, 1 } }), Throws.TypeOf<InvalidDataException>());
-        var choices = catalog.Get("animation.animate").DynamicParameters!["property"];
-        Assert.That(choices.TryGetConstraint("options", out var properties), Is.True);
-        Assert.That(properties.EnumerateArray().Select(value => value.GetString()), Is.EqualTo(GalNet.Core.Scene.Layer.AnimationProperties
-            .Concat(GalNet.Core.Scene.ParticleEmitterInstance.AnimationProperties).Select(property => property.Name).Append("time").Distinct(StringComparer.Ordinal)));
+        var property = catalog.Get("animation.animate").DynamicParameters["property"];
+        Assert.That(property.TryGetConstraint("enum", out _), Is.False);
+        Assert.That(Compile(catalog, "animation.animate", new { handleId = "fx", property = "customShaderParameter" }).Arguments.GetProperty("property").GetString(), Is.EqualTo("customShaderParameter"));
     }
 
     [TestCase("animation.stop", "playbackHandleId")]
@@ -96,12 +134,13 @@ public void ComplexDtoDefaultsChoicesAndOpenPayloadKeepTheirWireContract()
     public void SimpleDtoContractsPreserveOptionalTextNullAndDiagnostics(string type, string field)
     {
         var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
-        var omitted = Compile(catalog, type, new { }).Arguments;
+        var required = type.StartsWith("audio.", StringComparison.Ordinal) ? new Dictionary<string, object?> { ["targetId"] = "custom" } : new Dictionary<string, object?>();
+        var omitted = Compile(catalog, type, required).Arguments;
         Assert.That(catalog.Get(type).FieldDataType, Is.Not.Null);
         Assert.That(omitted.TryGetProperty(field, out _), Is.EqualTo(type == "video.stop"));
-        var explicitNull = Compile(catalog, type, new Dictionary<string, object?> { [field] = null }).Arguments;
+        var explicitNull = Compile(catalog, type, required.Concat(new Dictionary<string, object?> { [field] = null }).ToDictionary()).Arguments;
         Assert.That(explicitNull.GetProperty(field).ValueKind, Is.EqualTo(JsonValueKind.Null));
-        Assert.That(() => Compile(catalog, type, new Dictionary<string, object?> { [field] = 42 }),
+        Assert.That(() => Compile(catalog, type, required.Concat(new Dictionary<string, object?> { [field] = 42 }).ToDictionary()),
             Throws.TypeOf<InvalidDataException>().With.Message.Contains(field));
         Assert.That(() => Compile(catalog, type, new { unexpected = "value" }),
             Throws.TypeOf<InvalidDataException>().With.Message.Contains("unexpected"));
@@ -132,54 +171,86 @@ public void GalleryDtoRetainsOptionalIntegerAndRuntimePositiveIdValidation()
     public void AudioStopPreservesStringBooleanDefaultsAndExplicitNull()
     {
         var catalog = new TargetProfileEntryCatalog([BuiltinSchemas.CreateAudioModule()]);
-        var defaults = Compile(catalog, "audio.stop", new { }).Arguments;
+        var defaults = Compile(catalog, "audio.stop", new { trackId = "custom" }).Arguments;
         Assert.That(defaults.GetProperty("clearQueue").GetString(), Is.EqualTo("true"));
         var options = GalNet.Core.Parameters.ValueCodec.DeserializeFields<AudioStopOptions>(AudioStopOptions.Schema, defaults);
         Assert.That(options.ClearQueue, Is.True);
-        var explicitNull = Compile(catalog, "audio.stop", new { clearQueue = (string?)null }).Arguments;
+        var explicitNull = Compile(catalog, "audio.stop", new { trackId = "custom", clearQueue = (string?)null }).Arguments;
         Assert.That(GalNet.Core.Parameters.ValueCodec.DeserializeFields<AudioStopOptions>(AudioStopOptions.Schema, explicitNull).ClearQueue, Is.Null);
         Assert.That(() => Compile(catalog, "audio.stop", new { clearQueue = true }), Throws.TypeOf<InvalidDataException>());
         Assert.That(() => Compile(catalog, "audio.stop", new { fadeOut = -1 }), Throws.TypeOf<InvalidDataException>());
     }
 
+    [TestCase("audio.play")]
+    [TestCase("audio.enqueue")]
+    [TestCase("audio.stop")]
+    [TestCase("audio.seffect.apply")]
+    [TestCase("audio.seffect.stop")]
+    [TestCase(BuiltinEntryIds.TextVoice)]
+    [TestCase(BuiltinEntryIds.AppendVoiceNvl)]
     [TestCase("audio.pause")]
     [TestCase("audio.resume")]
     [TestCase("audio.next")]
     [TestCase("audio.clear")]
-    public void AudioDefaultsNullAndInvalidFieldsRetainTheirContract(string type)
+    public void AudioControlsRequireExplicitNonNullTrackTargets(string type)
     {
-        var catalog = new TargetProfileEntryCatalog([BuiltinSchemas.CreateAudioModule()]);
-        Assert.That(catalog.Get(type).FieldDataType, Is.EqualTo(typeof(AudioTrackOptions)));
-        Assert.That(Compile(catalog, type, new { }).Arguments.GetProperty("trackId").GetString(), Is.EqualTo("bgm"));
-        Assert.That(Compile(catalog, type, new { trackId = (string?)null }).Arguments.GetProperty("trackId").ValueKind, Is.EqualTo(JsonValueKind.Null));
-        Assert.That(() => Compile(catalog, type, new { trackId = 1 }), Throws.TypeOf<InvalidDataException>().With.Message.Contains("trackId"));
+        var catalog = new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules());
+        var field = type.StartsWith("audio.seffect.", StringComparison.Ordinal) ? "targetId" : "trackId";
+        var track = catalog.Get(type).DynamicParameters[field];
+        Assert.That(track.IsRequired, Is.True);
+        Assert.That(track.DefaultValue, Is.Null);
+        Assert.That(() => Compile(catalog, type, new { }), Throws.TypeOf<InvalidDataException>().With.Message.Contains(field));
+        var supplied = new Dictionary<string, object?> { [field] = "custom" };
+        if (type is BuiltinEntryIds.TextVoice or BuiltinEntryIds.AppendVoiceNvl) supplied["asset"] = "clip";
+        Assert.That(PrimitiveArgumentHelper.Normalize(catalog.Get(type).DynamicParameters, JsonSerializer.SerializeToElement(supplied)).GetProperty(field).GetString(), Is.EqualTo("custom"));
+        Assert.That(() => Compile(catalog, type, new Dictionary<string, object?> { [field] = null }), Throws.TypeOf<InvalidDataException>().With.Message.Contains(field));
+        Assert.That(() => Compile(catalog, type, new Dictionary<string, object?> { [field] = 1 }), Throws.TypeOf<InvalidDataException>().With.Message.Contains(field));
         Assert.That(() => Compile(catalog, type, new { other = "bgm" }), Throws.TypeOf<InvalidDataException>().With.Message.Contains("other"));
     }
 
+    [Test]
+    public async Task AudioModuleOwnsItsTrackConfigurationWithoutRuntimeSettings()
+    {
+        using var host = new RecordingHost();
+        var defaults = BuiltinAudioDefaults.Create();
+        var tracks = defaults.Tracks.ToList();
+        var configuration = new AudioConfiguration(tracks, defaults.Buses);
+        await using var view = new GameRegistration().RegisterSchema(BuiltinSchemas.CreateAudioModule())
+            .AddBuiltinAudio(host, configuration).BuildView();
+        tracks[0] = tracks[0] with { Id = "reassigned", DefaultGain = 0 };
+        tracks.Clear();
+
+        view.Dispatch(new PrimitiveEntry("audio.play", JsonSerializer.SerializeToElement(new { trackId = "bgm", asset = "music" })),
+            new GameRuntime(null), CancellationToken.None);
+        var started = await host.TakeAsync(AudioBackendAction.Start);
+        Assert.That(started.TrackId, Is.EqualTo("bgm"));
+        Assert.That(started.Gain, Is.EqualTo(.8f));
+    }
+
     [Test]
     public async Task CompiledTypedAudioControlsReachTheBackendAndCancellationStillStopsDispatch()
     {
         using var host = new RecordingHost();
-        await using var view = new GameRegistration().AddBuiltins(audioHost: host).BuildView();
+        await using var view = new GameRegistration().AddBuiltins(audioHost: host, audioConfiguration: BuiltinAudioDefaults.Create()).BuildView();
         var runtime = new GameRuntime(null);
         var catalog = new TargetProfileEntryCatalog([BuiltinSchemas.CreateAudioModule()]);
-        Dispatch("audio.play", new { asset = "first" });
+        Dispatch("audio.play", new { trackId = "bgm", asset = "first" });
         await host.TakeAsync(AudioBackendAction.Start);
-        Dispatch("audio.pause", new { });
+        Dispatch("audio.pause", new { trackId = "bgm" });
         Assert.That((await host.TakeAsync(AudioBackendAction.Pause)).TrackId, Is.EqualTo("bgm"));
         Dispatch("audio.resume", new { trackId = "bgm" });
         Assert.That((await host.TakeAsync(AudioBackendAction.Resume)).TrackId, Is.EqualTo("bgm"));
-        Dispatch("audio.stop", new { });
+        Dispatch("audio.stop", new { trackId = "bgm" });
         Assert.That((await host.TakeAsync(AudioBackendAction.Stop)).TrackId, Is.EqualTo("bgm"));
-        Dispatch("audio.play", new { asset = "second" });
+        Dispatch("audio.play", new { trackId = "bgm", asset = "second" });
         await host.TakeAsync(AudioBackendAction.Start);
-        Dispatch("audio.play", new { asset = "queued" });
-        Dispatch("audio.clear", new { });
-        Dispatch("audio.next", new { });
+        Dispatch("audio.play", new { trackId = "bgm", asset = "queued" });
+        Dispatch("audio.clear", new { trackId = "bgm" });
+        Dispatch("audio.next", new { trackId = "bgm" });
         Assert.That((await host.TakeAsync(AudioBackendAction.Stop)).TrackId, Is.EqualTo("bgm"));
         using var cancellation = new CancellationTokenSource();
         cancellation.Cancel();
-        Assert.That(() => view.Dispatch(new PrimitiveEntry("audio.pause", JsonSerializer.SerializeToElement(new { })),
+        Assert.That(() => view.Dispatch(new PrimitiveEntry("audio.pause", JsonSerializer.SerializeToElement(new { trackId = "bgm" })),
             runtime, cancellation.Token), Throws.TypeOf<OperationCanceledException>());
 
         void Dispatch(string type, object arguments)
@@ -222,7 +293,8 @@ private sealed class RecordingHost : IAudioPlaybackHost
         private readonly Channel<AudioBackendRequest> _requests = Channel.CreateUnbounded<AudioBackendRequest>();
         public AudioBackendCapabilities Capabilities { get; } = new(true, true, true);
         public ISEffectCatalog SEffects { get; } = new SEffectCatalog([]);
-        public event Action<AudioBackendEvent>? EventReceived { add { } remove { } }
+        public event Action<AudioBackendEvent>? EventReceived;
+        public void End(AudioBackendRequest request) => EventReceived?.Invoke(new(AudioBackendEventKind.Ended, request.TrackId, request.VoiceId, request.Generation));
         public Task ApplyAsync(AudioBackendRequest request, CancellationToken cancellationToken = default)
         {
             _requests.Writer.TryWrite(request);
diff --git a/test/GalNet.Primitives.Builtins.Tests/Entry/VisualPresetTests.cs b/test/GalNet.Primitives.Builtins.Tests/Entry/VisualPresetTests.cs
new file mode 100644
index 00000000..aee404f6
--- /dev/null
+++ b/test/GalNet.Primitives.Builtins.Tests/Entry/VisualPresetTests.cs
@@ -0,0 +1,162 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Compilation;
+using GalNet.Core.Entry;
+using GalNet.Core.Serialization;
+
+namespace GeneralTest.Entry;
+
+public sealed class VisualPresetTests
+{
+    private static readonly JsonSerializerOptions Options = new() { PropertyNameCaseInsensitive = true, Converters = { new JsonStringEnumConverter() } };
+
+    internal static TimelineDefinition Compile(string type, object parameters)
+    {
+        var source = new GroupDocument
+        {
+            Entries = [new() { Id = "preset", Type = type, Condition = "true",
+            Parameters = JsonSerializer.SerializeToElement(parameters).EnumerateObject().ToDictionary(p => p.Name, p => p.Value.Clone()) }]
+        };
+        var compiled = GalgroupCompiler.Compile(source, new TargetProfileEntryCatalog(BuiltinSchemas.CreateAllModules())).Document.Entries.Single();
+        Assert.That(compiled.TypeId, Is.EqualTo(BuiltinEntryIds.PlayTimeline));
+        return compiled.Arguments.GetProperty("timeline").Deserialize<TimelineDefinition>(Options)!;
+    }
+
+    [TestCase("Wipe")]
+    [TestCase("Radial")]
+    [TestCase("Noise")]
+    [TestCase("Blinds")]
+    [TestCase("Mask")]
+    public void Reveal_passes_explicit_program_and_cleans_helpers_after_reveal(string mode)
+    {
+        var timeline = Compile(BuiltinEntryIds.RevealTransition, new { playbackHandleId = "reveal", oldHandleId = "old", newHandleId = "new", assetId = "image", program = "chosen-shader", mode, maskAsset = "mask-image" });
+        var apply = timeline.Events.Single(e => e.Type == BuiltinEntryIds.ApplyEffect);
+        Assert.That(apply.Parameters["program"].GetString(), Is.EqualTo("chosen-shader"));
+        Assert.That(apply.Parameters["targetHandleId"].GetString(), Is.EqualTo("new"));
+        if (mode == "Mask") Assert.That(apply.Parameters["parameters"].GetProperty("mask").GetString(), Is.EqualTo("mask-image"));
+        Assert.That(timeline.Tracks.Single().Keys.Last().Value, Is.EqualTo(1));
+        Assert.That(timeline.Events.Count(e => e.Type == BuiltinEntryIds.StopEffect && e.Frame == timeline.DurationFrames), Is.EqualTo(1));
+        Assert.That(timeline.Events.Last().Parameters["handleId"].GetString(), Is.EqualTo("old"));
+    }
+
+    [Test]
+    public void Blur_transition_has_two_passes_on_each_layer_and_zero_terminal_incoming_blur()
+    {
+        var timeline = Compile(BuiltinEntryIds.BlurTransition, new { playbackHandleId = "blur", oldHandleId = "old", newHandleId = "new", assetId = "image", blurProgram = "chosen-blur" });
+        var effects = timeline.Events.Where(e => e.Type == BuiltinEntryIds.ApplyEffect).ToArray();
+        Assert.That(effects, Has.Length.EqualTo(4));
+        Assert.That(effects.All(e => e.Parameters["program"].GetString() == "chosen-blur"), Is.True);
+        var incoming = effects.Where(e => e.Parameters["targetHandleId"].GetString() == "new").Select(e => e.Parameters["instanceId"].GetString()).ToArray();
+        Assert.That(timeline.Tracks.Where(t => incoming.Contains(t.HandleId)).All(t => t.Keys.Last().Value == 0), Is.True);
+        Assert.That(timeline.Events.Count(e => e.Type == BuiltinEntryIds.StopEffect), Is.EqualTo(4));
+    }
+
+    [TestCase(MotionPreset.FadeIn)]
+    [TestCase(MotionPreset.FadeOut)]
+    [TestCase(MotionPreset.SlideIn)]
+    [TestCase(MotionPreset.SlideOut)]
+    [TestCase(MotionPreset.PopIn)]
+    [TestCase(MotionPreset.Jump)]
+    [TestCase(MotionPreset.Nod)]
+    [TestCase(MotionPreset.ShakeHead)]
+    [TestCase(MotionPreset.Push)]
+    public void Motion_supports_shortest_clip_and_retains_valid_strict_key_order(MotionPreset motion)
+    {
+        var timeline = Compile(BuiltinEntryIds.MotionPreset, new { playbackHandleId = "motion", handleId = "hero", motion = motion.ToString(), durationFrames = 2 });
+        TimelineEventCapabilities.ValidateStructure(timeline);
+        Assert.That(timeline.Tracks, Is.Not.Empty);
+        if (motion is MotionPreset.Jump or MotionPreset.Nod or MotionPreset.ShakeHead)
+            Assert.That(timeline.Tracks.All(t => t.BlendMode == AnimationBlendMode.Additive && t.Keys.Last().Value == 0), Is.True);
+    }
+
+    [Test]
+    public void Push_scales_about_authored_anchor_and_adds_directional_translation()
+    {
+        var timeline = Compile(BuiltinEntryIds.MotionPreset, new { playbackHandleId = "push", handleId = "hero", motion = "Push", transform = new { x = 100, y = 40, scaleX = 2, scaleY = 2 }, anchorX = 200, anchorY = 40, scale = 1.5, distance = 20, angle = 0 });
+        Assert.That(timeline.Tracks.Single(t => t.Property == "transform.x").Keys.Last().Value, Is.EqualTo(70));
+        Assert.That(timeline.Tracks.Single(t => t.Property == "transform.scaleX").Keys.Last().Value, Is.EqualTo(3));
+    }
+
+    [TestCase(2)]
+    [TestCase(36)]
+    public void Separate_shake_entries_move_one_target_each_and_return_to_zero(int frames)
+    {
+        var background = Compile(BuiltinEntryIds.ShakePreset, new { playbackHandleId = "quake-background", handleId = "background", durationFrames = frames });
+        var hero = Compile(BuiltinEntryIds.ShakePreset, new { playbackHandleId = "quake-hero", handleId = "hero", durationFrames = frames });
+        var backgroundX = background.Tracks.Single(t => t.Property == "transform.x");
+        var heroX = hero.Tracks.Single(t => t.Property == "transform.x");
+        Assert.That(backgroundX.Keys.Select(k => k.Value), Is.EqualTo(heroX.Keys.Select(k => k.Value)));
+        Assert.That(backgroundX.Keys.Any(k => Math.Abs(k.Value) > 1), Is.True);
+        Assert.That(background.Tracks.All(t => t.HandleId == "background" && t.BlendMode == AnimationBlendMode.Additive && t.Keys.Last().Value == 0), Is.True);
+        Assert.That(hero.Tracks.All(t => t.HandleId == "hero" && t.BlendMode == AnimationBlendMode.Additive && t.Keys.Last().Value == 0), Is.True);
+    }
+
+    [TestCase(BuiltinEntryIds.SpeedLinesPreset)]
+    [TestCase(BuiltinEntryIds.ImpactPreset)]
+    public void Dynamic_lines_compile_time_tracks_and_terminal_cleanup(string type)
+    {
+        var parameters = new Dictionary<string, object> { ["playbackHandleId"] = "impact", ["program"] = "lines-shader", ["blocking"] = false, ["durationFrames"] = 60 };
+        if (type == BuiltinEntryIds.ImpactPreset) parameters["handleId"] = "hero";
+        var timeline = Compile(type, parameters);
+        var time = timeline.Tracks.Single(t => t.Property == "time");
+        Assert.That(time.Keys.Last().Value, Is.EqualTo(1));
+        Assert.That(timeline.Blocking, Is.False);
+        var created = timeline.Events.Where(e => e.Type == BuiltinEntryIds.ShowColorLayer).Select(e => e.Parameters["handleId"].GetString()).ToArray();
+        var removed = timeline.Events.Where(e => e.Type == BuiltinEntryIds.HideLayer).Select(e => e.Parameters["handleId"].GetString()).ToArray();
+        Assert.That(removed, Is.EquivalentTo(created));
+        Assert.That(timeline.Events.Single(e => e.Type == BuiltinEntryIds.StopEffect).Frame, Is.EqualTo(timeline.DurationFrames));
+    }
+
+    [Test]
+    public void Sustained_shake_keeps_amplitude_and_ignores_blocking_and_click_skip()
+    {
+        var timeline = Compile(BuiltinEntryIds.ShakePreset, new
+        {
+            playbackHandleId = "quake",
+            handleId = "hero",
+            durationFrames = 60,
+            cycles = 4,
+            amplitude = 16,
+            playbackMode = "UntilStopped",
+            blocking = true,
+            skippable = true
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(timeline.LoopMode, Is.EqualTo(AnimationLoopMode.Loop));
+            Assert.That(timeline.Blocking, Is.False);
+            Assert.That(timeline.Skippable, Is.False);
+            var x = timeline.Tracks.Single(track => track.Property == "transform.x");
+            Assert.That(x.Keys[1].Value, Is.EqualTo(x.Keys[5].Value).Within(.001));
+            Assert.That(x.Keys[^1].Value, Is.Zero);
+        });
+        Assert.Throws<InvalidDataException>(() => Compile(BuiltinEntryIds.ShakePreset,
+            new { playbackHandleId = "quake", handleId = "hero", playbackMode = "forever" }));
+    }
+
+    [Test]
+    public void Sustained_lines_keep_opacity_and_use_playback_setup_and_completion_events()
+    {
+        var timeline = Compile(BuiltinEntryIds.SpeedLinesPreset, new { playbackHandleId = "lines", program = "shader", playbackMode = "UntilStopped" });
+        Assert.That(timeline.Tracks.Any(track => track.Property == "opacity"), Is.False);
+        Assert.That(timeline.Events.Where(item => item.Frame == 0).All(item => item.Execution == TimelineEventExecution.Once), Is.True);
+        Assert.That(timeline.Events.Where(item => item.Frame > 0).All(item => item.Execution == TimelineEventExecution.OnCompletion), Is.True);
+        var invalid = timeline.Events.First();
+        invalid.Execution = (TimelineEventExecution)42;
+        Assert.Throws<InvalidDataException>(() => TimelineEventCapabilities.ValidateStructure(timeline));
+        invalid.Execution = TimelineEventExecution.OnCompletion;
+        Assert.Throws<InvalidDataException>(() => TimelineEventCapabilities.ValidateStructure(timeline));
+    }
+
+    [Test]
+    public void Missing_shader_target_and_reserved_handle_collisions_are_rejected()
+    {
+        Assert.Throws<InvalidDataException>(() => Compile(BuiltinEntryIds.SpeedLinesPreset, new { playbackHandleId = "p" }));
+        Assert.Throws<InvalidDataException>(() => Compile(BuiltinEntryIds.ShakePreset, new { playbackHandleId = "p", handleId = "" }));
+        Assert.Throws<InvalidDataException>(() => Compile(BuiltinEntryIds.ShakePreset, new { playbackHandleId = "p", targets = new[] { new { handleId = "hero" } } }));
+        Assert.Throws<InvalidDataException>(() => Compile(BuiltinEntryIds.ImpactPreset, new { playbackHandleId = "p", program = "shader", handleId = "p/visual/lines" }));
+        Assert.Throws<InvalidDataException>(() => Compile(BuiltinEntryIds.RevealTransition, new { playbackHandleId = "p", oldHandleId = "same", newHandleId = "same", assetId = "image", program = "shader" }));
+    }
+}
diff --git a/test/GalNet.Primitives.Builtins.Tests/Runtime/BuiltinPrimitiveInstanceTests.cs b/test/GalNet.Primitives.Builtins.Tests/Runtime/BuiltinPrimitiveInstanceTests.cs
index 77be438e..385f8830 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Runtime/BuiltinPrimitiveInstanceTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Runtime/BuiltinPrimitiveInstanceTests.cs
@@ -1,10 +1,10 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Gallery;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
-using GalNet.Core.Gallery;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
 using GalNet.Core.Variable;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
@@ -15,6 +15,41 @@ namespace GeneralTest.Runtime;
 
 public class BuiltinPrimitiveInstanceTests
 {
+    [TestCase(PrimitiveInvocationMode.Normal)]
+    [TestCase(PrimitiveInvocationMode.Quick)]
+    [TestCase(PrimitiveInvocationMode.CatchUp)]
+    public void Compiled_impact_keeps_terminal_state_clean_during_playback_and_snapshot_restore(PrimitiveInvocationMode mode)
+    {
+        using var view = new GameRegistration().AddBuiltins().BuildView();
+        var runtime = new GameRuntime(null, stateCatalog: view.StateCatalog);
+        runtime.Scene().GetOrAdd("hero", id => new Layer { Id = id, AssetId = "image", Transform = new LayerTransform { X = 37 } });
+        var timeline = GeneralTest.Entry.VisualPresetTests.Compile(BuiltinEntryIds.ImpactPreset,
+            new { playbackHandleId = "impact", program = "shader-id", handleId = "hero" });
+        var primitive = Primitive(BuiltinEntryIds.PlayTimeline, new { timeline });
+        var instance = view.Dispatch(primitive, runtime, CancellationToken.None)!;
+        instance.ApplyPlaybackMode(mode);
+        Assert.That(instance.IsCompleted, Is.True);
+        Assert.That(runtime.State.Table<Layer>().Values.Select(layer => layer.Id), Is.EqualTo(new[] { "hero" }));
+        Assert.That(runtime.State.Table<EffectInstance>().Values, Is.Empty);
+        Assert.That(runtime.State.Table<Layer>().Values.Single().Transform.X, Is.EqualTo(37));
+        var restored = GalNet.Core.Runtime.GameState.Restore(view.StateCatalog, runtime.State.Capture());
+        Assert.That(restored.Table<Layer>().Values.Single().Transform.X, Is.EqualTo(37));
+        Assert.That(restored.Table<EffectInstance>().Values, Is.Empty);
+    }
+
+    [TestCase("1 +")]
+    [TestCase("[unknown]")]
+    public void FailedVariableExpressionPreservesExistingValue(string expression)
+    {
+        using var view = new GameRegistration().AddBuiltins().BuildView();
+        var runtime = new GameRuntime(null);
+        runtime.SetVariable("score", 42);
+        var instance = view.Dispatch(Primitive(BuiltinEntryIds.SetVariable,
+            new Dictionary<string, object?> { ["target"] = "score", ["expression"] = expression }), runtime, default);
+        Assert.That(instance.IsCompleted, Is.True);
+        Assert.That(runtime.GetVariable("score")!.AsInt(), Is.EqualTo(42));
+    }
+
     [TestCase(false)]
     [TestCase(true)]
     public void AnimationStateVersionTwoRoundTripsAnimateAndTimelineAndRejectsVersionOne(bool timeline)
@@ -96,7 +131,7 @@ public void AdditiveAnimationDoesNotApplyTerminalDeltaTwice(PrimitiveInvocationM
         var presenter = new RecordingAnimationPresenter();
         using var view = new GameRegistration().AddBuiltins(animationPresenter: presenter).BuildView();
         var runtime = BuiltinTestRuntime.Create(null);
-        var layer = runtime.SceneInstances.GetOrAdd("hero", id => new Layer { Id = id, Opacity = .2f });
+        var layer = runtime.Scene().GetOrAdd("hero", id => new Layer { Id = id, Opacity = .2f });
         var instance = view.Dispatch(Primitive(BuiltinEntryIds.Animate, new
         {
             playbackHandleId = "fade",
@@ -134,7 +169,7 @@ public void AnimationAnimateCommitsFinalStateAndCanBeSkippedThroughPresenter()
         var presenter = new RecordingAnimationPresenter();
         using var view = new GameRegistration().AddBuiltins(animationPresenter: presenter).BuildView();
         var runtime = BuiltinTestRuntime.Create(null);
-        var layer = runtime.SceneInstances.GetOrAdd("hero", id => new Layer { Id = id, Opacity = 0 });
+        var layer = runtime.Scene().GetOrAdd("hero", id => new Layer { Id = id, Opacity = 0 });
 
         var instance = view.Dispatch(Primitive(BuiltinEntryIds.Animate, new
         {
@@ -175,7 +210,7 @@ public async Task EffectApplyAndStopUpdateRuntimeStateAndPresenter()
         var presenter = new RecordingEffectPresenter();
         using var view = new GameRegistration().AddBuiltins(effectPresenter: presenter).BuildView();
         var runtime = BuiltinTestRuntime.Create(null);
-        var layer = runtime.SceneInstances.GetOrAdd("hero", id => new Layer { Id = id });
+        var layer = runtime.Scene().GetOrAdd("hero", id => new Layer { Id = id });
 
         var apply = view.Dispatch(Primitive(BuiltinEntryIds.ApplyEffect, new
         {
@@ -244,7 +279,7 @@ public async Task ParticlePlayAndStopUpdateRuntimeStateAndPresenter()
             Assert.That(runtime.State.Table<ParticleEmitterInstance>().Values[0].Definition.MotionModule.GravityY, Is.EqualTo(12));
             Assert.That(runtime.State.Table<ParticleEmitterInstance>().Values[0].Definition.InitialModule.VelocityX, Is.EqualTo(new ParticleFloatRange(-28, -16)));
             Assert.That(runtime.State.Table<ParticleEmitterInstance>().Values[0].Definition.Flipbook?.FramesPerSecond, Is.EqualTo(new ParticleFloatRange(10, 14)));
-            Assert.That(runtime.SceneInstances.TryGet<ParticleEmitterInstance>("snow", out _), Is.True);
+            Assert.That(runtime.Scene().TryGet<ParticleEmitterInstance>("snow", out _), Is.True);
             Assert.That(presenter.Started.Single().InstanceId, Is.EqualTo("snow"));
             Assert.That(presenter.Started.Single().Z, Is.EqualTo(42));
         });
@@ -279,7 +314,7 @@ public async Task ParticlePlayAndStopUpdateRuntimeStateAndPresenter()
         Assert.Multiple(() =>
         {
             Assert.That(runtime.State.Table<ParticleEmitterInstance>().Values, Is.Empty);
-            Assert.That(runtime.SceneInstances.TryGet<ParticleEmitterInstance>("snow", out _), Is.False);
+            Assert.That(runtime.Scene().TryGet<ParticleEmitterInstance>("snow", out _), Is.False);
             Assert.That(presenter.Stopped, Is.EqualTo(SnowStopped));
         });
     }
@@ -613,7 +648,7 @@ public void LoopingTimelineCommitsOnlyFrameZeroStateAndSavesCompleteTimeline()
     {
         using var view = new GameRegistration().AddBuiltins().BuildView();
         var runtime = BuiltinTestRuntime.Create(null);
-        runtime.SceneInstances.GetOrAdd("old", id => new Layer { Id = id, AssetId = "old.png", Opacity = 1 });
+        runtime.Scene().GetOrAdd("old", id => new Layer { Id = id, AssetId = "old.png", Opacity = 1 });
         var timeline = new TimelineDefinition
         {
             PlaybackHandleId = "ambient-loop",
@@ -637,7 +672,7 @@ public void LoopingTimelineCommitsOnlyFrameZeroStateAndSavesCompleteTimeline()
         var replayedTimeline = active.Timeline!;
         Assert.Multiple(() =>
         {
-            Assert.That(runtime.SceneInstances.TryGet<Layer>("old", out var old), Is.True);
+            Assert.That(runtime.Scene().TryGet<Layer>("old", out var old), Is.True);
             Assert.That(old.Opacity, Is.EqualTo(0.25f));
             Assert.That(active.Timeline!.LoopMode, Is.EqualTo(AnimationLoopMode.Loop));
             Assert.That(replayedTimeline.PlaybackHandleId, Is.EqualTo("ambient-loop"));
@@ -655,7 +690,7 @@ public async Task TimelineCommitsLayerEventsAndFinalTrackValues()
             layerPresenter: layers,
             animationPresenter: animation).BuildView();
         var runtime = BuiltinTestRuntime.Create(null);
-        var oldLayer = runtime.SceneInstances.GetOrAdd("old", id => new Layer { Id = id, AssetId = "old.png", Opacity = 1 });
+        var oldLayer = runtime.Scene().GetOrAdd("old", id => new Layer { Id = id, AssetId = "old.png", Opacity = 1 });
         var timeline = new TimelineDefinition
         {
             PlaybackHandleId = "crossfade",
@@ -696,8 +731,8 @@ public async Task TimelineCommitsLayerEventsAndFinalTrackValues()
 
         Assert.Multiple(() =>
         {
-            Assert.That(runtime.SceneInstances.TryGet<Layer>("old", out _), Is.False);
-            Assert.That(runtime.SceneInstances.TryGet<Layer>("new", out var newLayer), Is.True);
+            Assert.That(runtime.Scene().TryGet<Layer>("old", out _), Is.False);
+            Assert.That(runtime.Scene().TryGet<Layer>("new", out var newLayer), Is.True);
             Assert.That(newLayer.Opacity, Is.EqualTo(1));
             Assert.That(runtime.State.Table<Layer>().Values.Select(layer => layer.Id), Is.EqualTo(NewLayerIds));
             Assert.That(instance, Is.TypeOf<TimelinePrimitiveInstance>());
diff --git a/test/GalNet.Primitives.Builtins.Tests/Runtime/CustomActionTests.cs b/test/GalNet.Primitives.Builtins.Tests/Runtime/CustomActionTests.cs
index 87923fa8..fd602f57 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Runtime/CustomActionTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Runtime/CustomActionTests.cs
@@ -294,9 +294,9 @@ public void Compiler_accepts_unknown_action_ids_and_preserves_payload_without_pr
         };
         var result = GalgroupCompiler.Compile(source, catalog).Document.Entries.Single();
         Assert.That(result.Arguments.GetProperty("argument").GetString(), Is.EqualTo(argument));
-        Assert.That(catalog.Get(BuiltinEntryIds.InvokeCustom).DynamicParameters!.Fields.Select(field => field.Id),
+        Assert.That(catalog.Get(BuiltinEntryIds.InvokeCustom).DynamicParameters.Fields.Select(field => field.Id),
             Is.EqualTo(ParameterNames));
-        var fields = catalog.Get(BuiltinEntryIds.InvokeCustom).DynamicParameters!.Fields;
+        var fields = catalog.Get(BuiltinEntryIds.InvokeCustom).DynamicParameters.Fields;
         Assert.That(fields.All(field => field.IsRequired && !field.Value.AllowNull && field.DefaultValue is null), Is.True);
     }
 
diff --git a/test/GalNet.Runtime.Tests/Runtime/GameRuntimeSnapshotTests.cs b/test/GalNet.Primitives.Builtins.Tests/Runtime/GameRuntimeSnapshotTests.cs
similarity index 71%
rename from test/GalNet.Runtime.Tests/Runtime/GameRuntimeSnapshotTests.cs
rename to test/GalNet.Primitives.Builtins.Tests/Runtime/GameRuntimeSnapshotTests.cs
index 2bb5a540..65761998 100644
--- a/test/GalNet.Runtime.Tests/Runtime/GameRuntimeSnapshotTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Runtime/GameRuntimeSnapshotTests.cs
@@ -1,16 +1,34 @@
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
+using GalNet.Primitives.Builtins;
 using GalNet.Runtime.Runtime;
 
 namespace GeneralTest.Runtime;
 
 public class GameRuntimeSnapshotTests
 {
+    [Test]
+    public void VariableReadResultsAreDetachedAndWritesStillUseNotificationPath()
+    {
+        var runtime = new GameRuntime(null);
+        runtime.SetVariable("score", 42);
+        var value = runtime.GetVariable("score")!;
+        var snapshot = runtime.GetVariables(GalNet.Core.Variable.VariableScope.Save);
+        value.SetValue(999);
+        snapshot["score"].SetValue(555);
+        runtime.SetVariable("later", true);
+        Assert.That(runtime.GetVariable("score")!.AsInt(), Is.EqualTo(42));
+        Assert.That(snapshot.ContainsKey("later"), Is.False);
+        runtime.SetVariable("score", 43);
+        Assert.That(runtime.GetVariable("score")!.AsInt(), Is.EqualTo(43));
+        Assert.That(value.Uid, Is.EqualTo(runtime.GetVariable("score")!.Uid));
+    }
+
     private static StateCatalog Catalog()
     {
         var builder = new StateCatalogBuilder();
-        builder.Register<Layer>("layers", value => value.Id);
-        builder.Register<ParticleEmitterInstance>("particles", value => value.Id);
+        builder.Register<Layer>("layers", value => value.Id, keySpace: GalNet.Primitives.Builtins.BuiltinScene.KeySpace);
+        builder.Register<ParticleEmitterInstance>("particles", value => value.Id, keySpace: GalNet.Primitives.Builtins.BuiltinScene.KeySpace);
         builder.Register<LoopAnimationState>("animations", value => value.Id);
         return builder.Build();
     }
@@ -21,14 +39,14 @@ public void RestoreDetachesOldStateAndResetsEndedState()
         runtime.State.Table<Layer>().Add(new Layer { Id = "layer", AssetId = "saved" });
         var snapshot = runtime.CreateSnapshot();
         var oldState = runtime.State;
-        var oldInstances = runtime.SceneInstances;
+        var oldInstances = runtime.Scene();
         runtime.EndGame(); runtime.RestoreFrom(snapshot);
         oldState.Table<Layer>().Clear(); snapshot.States.Clear();
         Assert.Multiple(() =>
         {
             Assert.That(runtime.IsGameEnded, Is.False);
             Assert.That(runtime.State, Is.Not.SameAs(oldState));
-            Assert.That(runtime.SceneInstances, Is.Not.SameAs(oldInstances));
+            Assert.That(runtime.Scene(), Is.Not.SameAs(oldInstances));
             Assert.That(runtime.State.Table<Layer>().Get("layer").AssetId, Is.EqualTo("saved"));
         });
     }
@@ -55,7 +73,7 @@ public void RestoredParticleIsTheCanonicalAnimationTarget()
         source.State.Table<ParticleEmitterInstance>().Add(emitter);
         var restored = new GameRuntime(null, stateCatalog: catalog);
         restored.RestoreFrom(source.CreateSnapshot());
-        Assert.That(restored.SceneInstances.TryGet<ParticleEmitterInstance>("snow", out var target), Is.True);
+        Assert.That(restored.Scene().TryGet<ParticleEmitterInstance>("snow", out var target), Is.True);
         Assert.That(target, Is.SameAs(restored.State.Table<ParticleEmitterInstance>().Get("snow")));
         Assert.That(target.AnimationValues["emissionRate"], Is.EqualTo(18));
         Assert.That(target.Z, Is.EqualTo(42));
@@ -75,6 +93,6 @@ public void LoopDefinitionIsTypedAndDetachedButExecutionControlsAreNotSaved()
         var snapshot = source.CreateSnapshot(); definition.Request.To = 999;
         var restored = new GameRuntime(null, stateCatalog: catalog); restored.RestoreFrom(snapshot);
         Assert.That(restored.State.Table<LoopAnimationState>().Get("loop").Request!.To, Is.EqualTo(18));
-        Assert.That(restored.SceneInstances.TryGet<AnimationPlaybackInstance>("loop", out _), Is.False);
+        Assert.That(restored.Scene().TryGet<AnimationPlaybackInstance>("loop", out _), Is.False);
     }
 }
diff --git a/test/GalNet.Primitives.Builtins.Tests/Runtime/ImageVariantsRuntimeTests.cs b/test/GalNet.Primitives.Builtins.Tests/Runtime/ImageVariantsRuntimeTests.cs
index 1fab7d77..1c1d1fba 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Runtime/ImageVariantsRuntimeTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Runtime/ImageVariantsRuntimeTests.cs
@@ -1,12 +1,12 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Contracts.Builtins.Variants;
 using GalNet.Core.Entry;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
-using GalNet.Core.Variants;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
@@ -127,7 +127,7 @@ public async Task Selecting_a_difference_does_not_stop_an_active_loop_animation(
         Execute(view, runtime, BuiltinEntryIds.SelectVariants, new { handleId = "hero", dimension = "expression", value = "weap" });
         Assert.That(instance.IsCompleted, Is.False);
         Assert.That(runtime.State.Table<LoopAnimationState>().Get("loop"), Is.SameAs(loop));
-        Assert.That(runtime.SceneInstances.TryGet<AnimationPlaybackInstance>("loop", out _), Is.True);
+        Assert.That(runtime.Scene().TryGet<AnimationPlaybackInstance>("loop", out _), Is.True);
         animations.Completion.SetResult(AnimationOutcome.Completed);
         await instance.PresentationCompletion;
     }
@@ -184,7 +184,7 @@ public async Task Default_fallback_preserves_its_protection_across_snapshot_and_
         Assert.That(runtime.State.Table<Layer>().Get("hero").Variants!.Reason, Is.EqualTo(ImageVariantResolutionReason.Default));
         var saved = runtime.CreateSnapshot();
         await using var engine = new GameEngine(new Graph { RootNodeId = "root", Nodes = [new Group { Id = "root" }] }, runtime, view);
-        engine.RestoreFrom(saved);
+        await engine.RestoreFromAsync(saved);
         var restored = runtime.State.Table<Layer>().Get("hero");
         Assert.That(restored.Variants!.ProtectedDimensions, Is.EqualTo(new[] { "outfit" }));
         Assert.That(restored.AssetId, Is.EqualTo("sprite-idle_coat"));
@@ -229,7 +229,7 @@ public async Task Invalid_restore_is_rejected_before_replacing_the_state_root(st
         var runtime = new GameRuntime(null, "root", stateCatalog: targetView.StateCatalog);
         var root = runtime.State;
         await using var engine = new GameEngine(new Graph { RootNodeId = "root", Nodes = [new Group { Id = "root" }] }, runtime, targetView);
-        Assert.Throws<InvalidDataException>(() => engine.RestoreFrom(snapshot));
+        Assert.ThrowsAsync<InvalidDataException>(() => engine.RestoreFromAsync(snapshot));
         Assert.That(runtime.State, Is.SameAs(root));
         Assert.That(runtime.State.Table<Layer>().Values, Is.Empty);
     }
diff --git a/test/GalNet.Primitives.Builtins.Tests/Runtime/PersistentSceneReplaySessionTests.cs b/test/GalNet.Primitives.Builtins.Tests/Runtime/PersistentSceneReplaySessionTests.cs
index dae5e24a..ad8f363f 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Runtime/PersistentSceneReplaySessionTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Runtime/PersistentSceneReplaySessionTests.cs
@@ -1,5 +1,5 @@
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
@@ -14,7 +14,7 @@ public sealed class StateRestoreSessionTests
     public async Task RestoredLoopsKeepTheirDefinitionsAndWaitForPresentationCleanup(bool timeline)
     {
         var runtime = BuiltinTestRuntime.Create(null);
-        runtime.SceneInstances.GetOrAdd("hero", id => new Layer { Id = id, AssetId = "image" });
+        runtime.Scene().GetOrAdd("hero", id => new Layer { Id = id, AssetId = "image" });
         PrimitiveInstance definition = timeline
             ? new TimelinePrimitiveInstance(runtime, null, null, null, null,
                 new TimelineDefinition { PlaybackHandleId = "loop", DurationFrames = 60, LoopMode = AnimationLoopMode.Loop }, null, CancellationToken.None)
@@ -43,7 +43,7 @@ public async Task RestoredLoopsKeepTheirDefinitionsAndWaitForPresentationCleanup
     public async Task RestoredVideoIsDetachedAndDrainedBeforeReusingItsHandle()
     {
         var runtime = BuiltinTestRuntime.Create(null);
-        runtime.SceneInstances.GetOrAdd("video", id => new Layer { Id = id, AssetId = "clip", IsVideo = true });
+        runtime.Scene().GetOrAdd("video", id => new Layer { Id = id, AssetId = "clip", IsVideo = true });
         var video = new DelayedVideoPresenter();
         using var view = new GameRegistration().AddBuiltins(videoPresenter: video).BuildView();
         await using var restorer = new StateRestoreSession(view);
@@ -69,7 +69,7 @@ public async Task RestoredVideoIsDetachedAndDrainedBeforeReusingItsHandle()
     public async Task CanceledSuspensionStillDrainsOldPlaybackBeforeTheNextRestore()
     {
         var runtime = BuiltinTestRuntime.Create(null);
-        runtime.SceneInstances.GetOrAdd("video", id => new Layer { Id = id, AssetId = "clip", IsVideo = true });
+        runtime.Scene().GetOrAdd("video", id => new Layer { Id = id, AssetId = "clip", IsVideo = true });
         var video = new DelayedVideoPresenter();
         using var view = new GameRegistration().AddBuiltins(videoPresenter: video).BuildView();
         await using var restorer = new StateRestoreSession(view);
@@ -92,7 +92,7 @@ public async Task CanceledSuspensionStillDrainsOldPlaybackBeforeTheNextRestore()
     public async Task DisposalDrainsPresentationAndRejectsAnotherRestore()
     {
         var runtime = BuiltinTestRuntime.Create(null);
-        runtime.SceneInstances.GetOrAdd("video", id => new Layer { Id = id, AssetId = "clip", IsVideo = true });
+        runtime.Scene().GetOrAdd("video", id => new Layer { Id = id, AssetId = "clip", IsVideo = true });
         var video = new DelayedVideoPresenter();
         using var view = new GameRegistration().AddBuiltins(videoPresenter: video).BuildView();
         var replay = new StateRestoreSession(view);
diff --git a/test/GalNet.Primitives.Builtins.Tests/Runtime/SimplePresentationPrimitiveTests.cs b/test/GalNet.Primitives.Builtins.Tests/Runtime/SimplePresentationPrimitiveTests.cs
index de47bb42..d944db6e 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Runtime/SimplePresentationPrimitiveTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Runtime/SimplePresentationPrimitiveTests.cs
@@ -1,5 +1,5 @@
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
 using GalNet.Runtime.Runtime;
diff --git a/test/GalNet.Primitives.Builtins.Tests/Runtime/SustainedVisualPresetTests.cs b/test/GalNet.Primitives.Builtins.Tests/Runtime/SustainedVisualPresetTests.cs
new file mode 100644
index 00000000..a4de96e1
--- /dev/null
+++ b/test/GalNet.Primitives.Builtins.Tests/Runtime/SustainedVisualPresetTests.cs
@@ -0,0 +1,227 @@
+using System.Text.Json;
+using GalNet.Contracts.Builtins;
+using GalNet.Contracts.Builtins.Scene;
+using GalNet.Core.Entry;
+using GalNet.Core.Primitives;
+using GalNet.Core.Runtime;
+using GalNet.Presentation.Abstractions.Execution;
+using GalNet.Presentation.Abstractions.View;
+using GalNet.Primitives.Builtins;
+using GalNet.Runtime.Runtime;
+
+namespace GeneralTest.Runtime;
+
+public sealed class SustainedVisualPresetTests
+{
+    private static TimelineDefinition Lines(bool sustained = true) => GeneralTest.Entry.VisualPresetTests.Compile(
+        BuiltinEntryIds.SpeedLinesPreset, new
+        {
+            playbackHandleId = "lines",
+            program = "shader",
+            durationFrames = 60,
+            playbackMode = sustained ? "UntilStopped" : "Timed",
+            blocking = false
+        });
+    private static PrimitiveEntry Primitive(string type, object arguments) => new(type, JsonSerializer.SerializeToElement(arguments));
+    private static async Task StopAsync(CompositeGameView view, GameRuntime runtime, string id = "lines", string mode = "CompleteImmediately")
+    {
+        var stop = view.Dispatch(Primitive(BuiltinEntryIds.StopAnimation, new { playbackHandleId = id, mode }), runtime, CancellationToken.None)!;
+        await stop.PresentationCompletion.WaitAsync(TimeSpan.FromSeconds(3));
+    }
+
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task Immediate_stop_cleans_timed_and_sustained_lines_and_allows_reusing_the_handle(bool sustained)
+    {
+        var animation = new ControlledAnimation(); var effects = new Effects(); var layers = new Layers();
+        using var view = new GameRegistration().AddBuiltins(animationPresenter: animation, effectPresenter: effects, layerPresenter: layers).BuildView();
+        var runtime = new GameRuntime(null, stateCatalog: view.StateCatalog);
+        runtime.State.Table<Layer>().Add(new Layer { Id = "hero", Transform = new LayerTransform { X = 37 } });
+        runtime.State.Table<EffectInstance>().Add(new EffectInstance { Id = "unrelated", ProgramResource = "grade" });
+        effects.Active.Add("unrelated");
+        for (var round = 0; round < 2; round++)
+        {
+            var instance = view.Dispatch(Primitive(BuiltinEntryIds.PlayTimeline, new { timeline = Lines(sustained) }), runtime, CancellationToken.None)!;
+            await animation.Started.Task.WaitAsync(TimeSpan.FromSeconds(3));
+            if (sustained)
+            {
+                await animation.AdvanceAsync(125);
+                Assert.That(effects.Starts, Is.EqualTo(round + 1), "Loop boundaries must not recreate the shader.");
+                Assert.That(layers.Active, Does.Contain("lines/visual/lines"));
+                Assert.That(effects.Stops, Is.EqualTo(round));
+            }
+            await StopAsync(view, runtime);
+            await instance.PresentationCompletion;
+            Assert.Multiple(() =>
+            {
+                Assert.That(instance.IsCompleted, Is.True);
+                Assert.That(layers.Active, Is.Empty);
+                Assert.That(effects.Active, Is.EquivalentTo(new[] { "unrelated" }));
+                Assert.That(runtime.State.Table<EffectInstance>().Values.Select(effect => effect.Id), Is.EqualTo(new[] { "unrelated" }));
+                Assert.That(runtime.State.Table<Layer>().Values.Single().Transform.X, Is.EqualTo(37));
+                Assert.That(runtime.State.Table<LoopAnimationState>().Values, Is.Empty);
+                Assert.That(runtime.Scene().TryGet<AnimationPlaybackInstance>("lines", out _), Is.False);
+            });
+        }
+    }
+
+    [Test]
+    public async Task Immediate_stop_waits_for_effect_cleanup_before_completing()
+    {
+        var animation = new ControlledAnimation(); var effects = new Effects { CleanupGate = new() }; var layers = new Layers();
+        using var view = new GameRegistration().AddBuiltins(animationPresenter: animation, effectPresenter: effects, layerPresenter: layers).BuildView();
+        var runtime = new GameRuntime(null, stateCatalog: view.StateCatalog);
+        view.Dispatch(Primitive(BuiltinEntryIds.PlayTimeline, new { timeline = Lines() }), runtime, CancellationToken.None);
+        var stopping = StopAsync(view, runtime);
+        await effects.Stopping.Task.WaitAsync(TimeSpan.FromSeconds(3));
+        Assert.That(stopping.IsCompleted, Is.False);
+        effects.CleanupGate.SetResult();
+        await stopping;
+        Assert.That(layers.Active, Is.Empty);
+        Assert.That(effects.Active, Is.Empty);
+    }
+
+    [Test]
+    public async Task Stop_during_click_skip_waits_for_the_same_cleanup()
+    {
+        var animation = new ControlledAnimation(); var effects = new Effects { CleanupGate = new() }; var layers = new Layers();
+        using var view = new GameRegistration().AddBuiltins(animationPresenter: animation, effectPresenter: effects, layerPresenter: layers).BuildView();
+        var runtime = new GameRuntime(null, stateCatalog: view.StateCatalog);
+        var instance = view.Dispatch(Primitive(BuiltinEntryIds.PlayTimeline, new { timeline = Lines(false) }), runtime, CancellationToken.None)!;
+        instance.Skip();
+        await effects.Stopping.Task.WaitAsync(TimeSpan.FromSeconds(3));
+        var stopping = StopAsync(view, runtime);
+        try { Assert.That(stopping.IsCompleted, Is.False, "The playback handle must remain owned until skip cleanup finishes."); }
+        finally { effects.CleanupGate.SetResult(); await instance.PresentationCompletion; await stopping; }
+        Assert.That(layers.Active, Is.Empty);
+    }
+
+    [Test]
+    public async Task Stop_during_async_setup_does_not_leave_a_playback_running()
+    {
+        var animation = new ControlledAnimation(); var effects = new Effects { SetupGate = new() }; var layers = new Layers();
+        using var view = new GameRegistration().AddBuiltins(animationPresenter: animation, effectPresenter: effects, layerPresenter: layers).BuildView();
+        var runtime = new GameRuntime(null, stateCatalog: view.StateCatalog);
+        view.Dispatch(Primitive(BuiltinEntryIds.PlayTimeline, new { timeline = Lines() }), runtime, CancellationToken.None);
+        var stopping = StopAsync(view, runtime);
+        effects.SetupGate.SetResult();
+        await stopping;
+        Assert.That(animation.Started.Task.IsCompleted, Is.False);
+        Assert.That(effects.Active, Is.Empty);
+        Assert.That(layers.Active, Is.Empty);
+    }
+
+    [Test]
+    public async Task After_iteration_keeps_lines_until_the_next_boundary_then_cleans_them()
+    {
+        var animation = new ControlledAnimation(); var effects = new Effects(); var layers = new Layers();
+        using var view = new GameRegistration().AddBuiltins(animationPresenter: animation, effectPresenter: effects, layerPresenter: layers).BuildView();
+        var runtime = new GameRuntime(null, stateCatalog: view.StateCatalog);
+        var instance = view.Dispatch(Primitive(BuiltinEntryIds.PlayTimeline, new { timeline = Lines() }), runtime, CancellationToken.None)!;
+        await animation.AdvanceAsync(65);
+        await StopAsync(view, runtime, mode: "AfterIteration");
+        await animation.AdvanceAsync(119);
+        Assert.That(instance.IsCompleted, Is.False);
+        Assert.That(effects.Active, Is.Not.Empty);
+        await animation.AdvanceAsync(120);
+        await instance.PresentationCompletion.WaitAsync(TimeSpan.FromSeconds(3));
+        Assert.That(effects.Active, Is.Empty);
+        Assert.That(layers.Active, Is.Empty);
+    }
+
+    [Test]
+    public async Task Catch_up_and_restoration_keep_sustained_objects_until_explicit_stop()
+    {
+        var animation = new ControlledAnimation(); var effects = new Effects(); var layers = new Layers();
+        using var view = new GameRegistration().AddBuiltins(animationPresenter: animation, effectPresenter: effects, layerPresenter: layers).BuildView();
+        var runtime = new GameRuntime(null, stateCatalog: view.StateCatalog);
+        var definition = new TimelinePrimitiveInstance(runtime, null, null, null, null, Lines(), null, CancellationToken.None);
+        definition.Dispatch(PrimitiveInvocationMode.CatchUp);
+        var restored = GameState.Restore(view.StateCatalog, runtime.State.Capture());
+        Assert.That(restored.Table<LoopAnimationState>().Values.Single().Timeline!.Events.Count(item => item.Execution == TimelineEventExecution.OnCompletion), Is.EqualTo(2));
+        await using var restorer = new StateRestoreSession(view);
+        await restorer.RestoreAsync(runtime);
+        await animation.AdvanceAsync(125);
+        Assert.That(effects.Starts, Is.EqualTo(1), "Restoration owns setup; replay must not create it again.");
+        await StopAsync(view, runtime);
+        Assert.That(effects.Active, Is.Empty);
+        Assert.That(layers.Active, Is.Empty);
+        Assert.That(runtime.State.Table<EffectInstance>().Values, Is.Empty);
+        Assert.That(runtime.State.Table<Layer>().Values, Is.Empty);
+    }
+
+    [Test]
+    public async Task Headless_stop_removes_saved_loop_and_its_helpers()
+    {
+        using var view = new GameRegistration().AddBuiltins().BuildView();
+        var runtime = new GameRuntime(null, stateCatalog: view.StateCatalog);
+        view.Dispatch(Primitive(BuiltinEntryIds.PlayTimeline, new { timeline = Lines() }), runtime, CancellationToken.None);
+        Assert.That(runtime.State.Table<EffectInstance>().Values, Has.Count.EqualTo(1));
+        await StopAsync(view, runtime);
+        Assert.That(runtime.State.Table<EffectInstance>().Values, Is.Empty);
+        Assert.That(runtime.State.Table<Layer>().Values, Is.Empty);
+        Assert.That(runtime.State.Table<LoopAnimationState>().Values, Is.Empty);
+    }
+
+    [TestCase(false)]
+    [TestCase(true)]
+    public async Task Completion_and_skip_run_cleanup_without_a_separate_stop(bool skip)
+    {
+        var animation = new ControlledAnimation(); var effects = new Effects(); var layers = new Layers();
+        using var view = new GameRegistration().AddBuiltins(animationPresenter: animation, effectPresenter: effects, layerPresenter: layers).BuildView();
+        var runtime = new GameRuntime(null, stateCatalog: view.StateCatalog);
+        var instance = view.Dispatch(Primitive(BuiltinEntryIds.PlayTimeline, new { timeline = Lines(false) }), runtime, CancellationToken.None)!;
+        if (skip) instance.Skip(); else animation.Finish(AnimationOutcome.Completed);
+        await instance.PresentationCompletion.WaitAsync(TimeSpan.FromSeconds(3));
+        Assert.That(effects.Active, Is.Empty);
+        Assert.That(layers.Active, Is.Empty);
+        Assert.That(effects.Stops, Is.EqualTo(1));
+    }
+
+    private sealed class ControlledAnimation : IAnimationPresenter
+    {
+        private TaskCompletionSource<AnimationOutcome> _completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        private Func<double, Task>? _frame;
+        public TaskCompletionSource Started { get; private set; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public Task AdvanceAsync(double frame) => _frame!(frame);
+        public void Finish(AnimationOutcome outcome) => _completion.TrySetResult(outcome);
+        public Task<AnimationOutcome> AnimateAsync(AnimationRequest request, CancellationToken cancellationToken) => _completion.Task.WaitAsync(cancellationToken);
+        public async Task<TimelinePlayResult> PlayTimelineAsync(TimelineDefinition timeline, CancellationToken cancellationToken, Func<double, Task>? beforeFrame = null)
+        {
+            _completion = new(TaskCreationOptions.RunContinuationsAsynchronously);
+            _frame = beforeFrame;
+            Started.TrySetResult();
+            try { return new() { Outcome = await _completion.Task.WaitAsync(cancellationToken) }; }
+            finally { Started = new(TaskCreationOptions.RunContinuationsAsynchronously); }
+        }
+        public bool CompleteAnimationImmediately(string playbackHandleId) => _completion.TrySetResult(AnimationOutcome.Skipped);
+    }
+    private sealed class Effects : IEffectPresenter
+    {
+        public HashSet<string> Active { get; } = [];
+        public int Starts { get; private set; }
+        public int Stops { get; private set; }
+        public TaskCompletionSource? SetupGate { get; init; }
+        public TaskCompletionSource? CleanupGate { get; init; }
+        public TaskCompletionSource Stopping { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        public async Task StartEffectAsync(EffectRequest request, CancellationToken cancellationToken)
+        {
+            if (SetupGate is not null) await SetupGate.Task.WaitAsync(cancellationToken);
+            Active.Add(request.InstanceId); Starts++;
+        }
+        public async Task StopEffectAsync(string instanceId, CancellationToken cancellationToken)
+        {
+            Stopping.TrySetResult();
+            if (CleanupGate is not null) await CleanupGate.Task.WaitAsync(cancellationToken);
+            Active.Remove(instanceId); Stops++;
+        }
+    }
+    private sealed class Layers : ILayerPresenter
+    {
+        public HashSet<string> Active { get; } = [];
+        public void ShowLayer(LayerRenderRequest request) => Active.Add(request.HandleId);
+        public void HideLayer(string handleId) => Active.Remove(handleId);
+        public void ReplaceLayer(string handleId, string assetId) { }
+        public void MoveLayer(string handleId, LayerTransform transform, float z, float durationSeconds) { }
+    }
+}
diff --git a/test/GalNet.Primitives.Builtins.Tests/Runtime/VideoPrimitiveInstanceTests.cs b/test/GalNet.Primitives.Builtins.Tests/Runtime/VideoPrimitiveInstanceTests.cs
index 3c6a89fd..2e45fa06 100644
--- a/test/GalNet.Primitives.Builtins.Tests/Runtime/VideoPrimitiveInstanceTests.cs
+++ b/test/GalNet.Primitives.Builtins.Tests/Runtime/VideoPrimitiveInstanceTests.cs
@@ -1,7 +1,7 @@
 using System.Text.Json;
+using GalNet.Contracts.Builtins.Scene;
 using GalNet.Core.Entry;
 using GalNet.Core.Primitives;
-using GalNet.Core.Scene;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Primitives.Builtins;
@@ -82,7 +82,7 @@ public async Task Old_completion_does_not_remove_replacement_and_stop_targets_on
     public void Image_cannot_replace_an_active_animation_playback_handle()
     {
         var runtime = BuiltinTestRuntime.Create(null);
-        runtime.SceneInstances.GetOrAddTransient("playback", id => new AnimationPlaybackInstance { Id = id });
+        runtime.Scene().GetOrAddTransient("playback", id => new AnimationPlaybackInstance { Id = id });
         using var view = new GameRegistration().AddBuiltins().BuildView();
         Assert.Throws<InvalidOperationException>(() => view.Dispatch(new PrimitiveEntry("layer.show",
             JsonSerializer.SerializeToElement(new { handleId = "playback", assetId = "image" })), runtime, default));
diff --git a/test/GalNet.Primitives.Builtins.Tests/packages.lock.json b/test/GalNet.Primitives.Builtins.Tests/packages.lock.json
index 33524e25..10356677 100644
--- a/test/GalNet.Primitives.Builtins.Tests/packages.lock.json
+++ b/test/GalNet.Primitives.Builtins.Tests/packages.lock.json
@@ -128,6 +128,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -145,7 +146,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/test/GalNet.Runtime.Tests/Engine/DebugSessionTests.cs b/test/GalNet.Runtime.Tests/Engine/DebugSessionTests.cs
index 69c1fb25..5103338e 100644
--- a/test/GalNet.Runtime.Tests/Engine/DebugSessionTests.cs
+++ b/test/GalNet.Runtime.Tests/Engine/DebugSessionTests.cs
@@ -3,7 +3,6 @@
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
-using GalNet.Core.Scene;
 using GalNet.Core.Variable;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Runtime.Engine;
@@ -14,6 +13,23 @@ namespace GeneralTest.Runtime;
 
 public class DebugSessionTests
 {
+    [Test]
+    public async Task PackagedContentDebugSeekStampsInternalBaselinesButRejectsUnstampedExternalSaves()
+    {
+        var graph = GraphOf(Entry("test.text", "first"), Entry("test.text", "second"));
+        graph.ContentBuildId = "packaged-build";
+        graph.InstalledStoryPackages = ["extra"];
+        using var view = Registration().RegisterInstruction("test.text", _ => new TextWait()).BuildView();
+        await using var engine = new GameEngine(graph, Runtime(), view);
+        using var debug = engine.AttachDebugging(Options());
+        await engine.AdvanceAsync();
+        await debug.SeekAsync(debug.Generation, new("main", 1, []));
+        await debug.SeekAsync(debug.Generation, new("main", 0, []));
+        await debug.SeekAsync(debug.Generation, new("main", 1, [], InitialScene: true));
+        Assert.That(engine.EntryIndex, Is.EqualTo(1));
+        Assert.ThrowsAsync<InvalidDataException>(() => engine.RestoreFromAsync(engine.Runtime.CreateSnapshot()));
+    }
+
     [Test]
     public async Task CompressingTheCurrentUnreadTextForDebugSeekDoesNotMarkItRead()
     {
@@ -42,9 +58,9 @@ public async Task ForwardSeekCapturesTheStateCommittedByAnActiveTransitionDuring
         await using var engine = new GameEngine(GraphOf(Entry("test.scene", "transition"), Entry("test.text", "target")), Runtime(), view);
         using var debug = engine.AttachDebugging(Options());
         await engine.AdvanceAsync();
-        Assert.That(engine.Runtime.State.Table<Layer>().Get("scene").AssetId, Is.EqualTo("initial"));
+        Assert.That(engine.Runtime.State.Table<DebugState>().Get("scene").Value, Is.EqualTo("initial"));
         await debug.SeekAsync(debug.Generation, new("main", 1, []));
-        Assert.That(engine.Runtime.State.Table<Layer>().Get("scene").AssetId, Is.EqualTo("compressed"));
+        Assert.That(engine.Runtime.State.Table<DebugState>().Get("scene").Value, Is.EqualTo("compressed"));
     }
     [TestCase(0, 0)]
     [TestCase(256, 1)]
@@ -69,8 +85,8 @@ public async Task LatestEntranceLruAvoidsReplayingEarlierGroupsAndReportsMeasure
         graph.Nodes.Add(new Group { Id = "second", Entries = Enumerable.Range(0, 200).Select(index => (Entry)Entry("test.scene", "local" + index)).Append(Entry("test.text", "second")).ToList() });
         graph.Edges.Add(new("main", 0, "second"));
         using var view = Registration().RegisterInstruction("test.text", _ => new TextWait())
-            .RegisterInstruction("test.scene", context => new ImmediatePrimitiveInstance(() => context.Runtime.State.Table<Layer>()
-                .Set(new Layer { Id = "scene", AssetId = context.Entry.StableId }))).BuildView();
+            .RegisterInstruction("test.scene", context => new ImmediatePrimitiveInstance(() => context.Runtime.State.Table<DebugState>()
+                .Set(new DebugState { Id = "scene", Value = context.Entry.StableId }))).BuildView();
         await using var engine = new GameEngine(graph, Runtime(), view);
         using var debug = engine.AttachDebugging(new() { Instructions = Options().Instructions, MaxEntranceGroups = 1 });
         await engine.AdvanceAsync(); await engine.AdvanceAsync();
@@ -79,17 +95,17 @@ public async Task LatestEntranceLruAvoidsReplayingEarlierGroupsAndReportsMeasure
         var local = await debug.InspectAsync();
         Assert.That(local.Replay!.EntranceCacheHit, Is.True);
         Assert.That(local.Replay.Instructions, Is.EqualTo(150));
-        var result = engine.Runtime.State.Table<Layer>().Get("scene").AssetId;
+        var result = engine.Runtime.State.Table<DebugState>().Get("scene").Value;
         var expectedStates = JsonSerializer.Serialize(engine.Runtime.CreateSnapshot().States);
         await debug.SeekAsync(debug.Generation, new("second", 150, [new("main", 0, "second")]));
         var root = await debug.InspectAsync();
         Assert.That(root.Replay!.EntranceCacheHit, Is.False);
         Assert.That(root.Replay.Instructions, Is.EqualTo(2151));
-        Assert.That(engine.Runtime.State.Table<Layer>().Get("scene").AssetId, Is.EqualTo(result));
+        Assert.That(engine.Runtime.State.Table<DebugState>().Get("scene").Value, Is.EqualTo(result));
         Assert.That(JsonSerializer.Serialize(engine.Runtime.CreateSnapshot().States), Is.EqualTo(expectedStates));
         Assert.That(root.Cache!.PayloadBytes, Is.LessThanOrEqualTo(root.Cache.BudgetBytes));
         TestContext.Out.WriteLine($"entrance={local.Replay.Milliseconds:F2}ms/{local.Replay.Instructions} primitives; root={root.Replay.Milliseconds:F2}ms/{root.Replay.Instructions} primitives; payload={root.Cache.PayloadBytes} bytes");
-        engine.RestoreFrom(engine.Runtime.CreateSnapshot());
+        await engine.RestoreFromAsync(engine.Runtime.CreateSnapshot());
         Assert.That((await debug.InspectAsync()).Cache!.PayloadBytes, Is.Zero);
     }
 
@@ -139,21 +155,21 @@ public async Task CrossGroupReplayCannotReplaceNaturalEntrancesAndIsolatedStartU
         graph.Nodes.Add(new Group { Id = "isolated", Entries = { Entry("test.text", "isolated-line") } });
         graph.Edges.Add(new("main", 0, "second"));
         using var view = Registration().RegisterInstruction("test.text", _ => new TextWait())
-            .RegisterInstruction("test.scene", context => new ImmediatePrimitiveInstance(() => context.Runtime.State.Table<Layer>()
-                .Set(new Layer { Id = "forced", AssetId = "replay" }))).BuildView();
+            .RegisterInstruction("test.scene", context => new ImmediatePrimitiveInstance(() => context.Runtime.State.Table<DebugState>()
+                .Set(new DebugState { Id = "forced", Value = "replay" }))).BuildView();
         await using var engine = new GameEngine(graph, Runtime(), view);
         using var debug = engine.AttachDebugging(Options());
         await engine.AdvanceAsync(); await engine.AdvanceAsync();
         Assert.That(engine.CurrentNodeId, Is.EqualTo("second"));
         await debug.SeekAsync(debug.Generation, new("main", 0, []));
         await debug.SeekAsync(debug.Generation, new("second", 0, [new("main", 0, "second")]));
-        Assert.That(engine.Runtime.State.Table<Layer>().TryGet("forced", out _), Is.True);
+        Assert.That(engine.Runtime.State.Table<DebugState>().TryGet("forced", out _), Is.True);
         await debug.ResumeAsync(debug.Generation);
         await debug.SeekAsync(debug.Generation, new("second", 0, []));
-        Assert.That(engine.Runtime.State.Table<Layer>().TryGet("forced", out _), Is.False);
+        Assert.That(engine.Runtime.State.Table<DebugState>().TryGet("forced", out _), Is.False);
         await debug.SeekAsync(debug.Generation, new("isolated", 0, [], InitialScene: true));
         Assert.That(engine.CurrentNodeId, Is.EqualTo("isolated"));
-        Assert.That(engine.Runtime.State.Table<Layer>().TryGet("forced", out _), Is.False);
+        Assert.That(engine.Runtime.State.Table<DebugState>().TryGet("forced", out _), Is.False);
     }
 
     [TestCase(false)]
@@ -169,7 +185,7 @@ public async Task StopOrExternalRestoreCancelsAnInFlightSeekAndDrainsOldWork(boo
         await engine.AdvanceAsync();
         var operation = debug.SeekAsync(debug.Generation, new("main", 2, []));
         await blocker.Entered.Task.WaitAsync(TimeSpan.FromSeconds(2));
-        if (restore) engine.RestoreFrom(initial);
+        if (restore) await engine.RestoreFromAsync(initial);
         else await engine.StopAsync().WaitAsync(TimeSpan.FromSeconds(2));
         Assert.CatchAsync<OperationCanceledException>(async () => await operation.WaitAsync(TimeSpan.FromSeconds(2)));
         Assert.That(engine.State, Is.EqualTo(restore ? GameEngineState.Ready : GameEngineState.Stopped));
@@ -185,21 +201,21 @@ public async Task SceneRewindRemovesLaterObjectsPreservesVariablesAndDoesNotOver
         var graph = GraphOf(Entry("test.text", "first"), Entry("test.scene", "object"), Entry("test.text", "last"));
         using var view = Registration().RegisterInstruction("test.text", _ => new TextWait())
             .RegisterInstruction("test.scene", context => new ImmediatePrimitiveInstance(() =>
-                context.Runtime.State.Table<Layer>().Set(new Layer { Id = "late", AssetId = "after" }))).BuildView();
+                context.Runtime.State.Table<DebugState>().Set(new DebugState { Id = "late", Value = "after" }))).BuildView();
         await using var engine = new GameEngine(graph, Runtime(), view);
         using var debug = engine.AttachDebugging(Options());
         engine.Runtime.SetVariable("save.counter", 7);
         await engine.AdvanceAsync();
         await engine.AdvanceAsync();
-        Assert.That(engine.Runtime.State.Table<Layer>().TryGet("late", out _), Is.True);
+        Assert.That(engine.Runtime.State.Table<DebugState>().TryGet("late", out _), Is.True);
         await debug.SeekAsync(debug.Generation, new("main", 0, []));
-        Assert.That(engine.Runtime.State.Table<Layer>().TryGet("late", out _), Is.False);
+        Assert.That(engine.Runtime.State.Table<DebugState>().TryGet("late", out _), Is.False);
         Assert.That(engine.Runtime.GetVariable("counter")!.AsInt(), Is.EqualTo(7));
         var generation = debug.Generation;
         await debug.SeekAsync(generation, new("main", 2, []));
-        Assert.That(engine.Runtime.State.Table<Layer>().TryGet("late", out _), Is.True);
+        Assert.That(engine.Runtime.State.Table<DebugState>().TryGet("late", out _), Is.True);
         await debug.SeekAsync(debug.Generation, new("main", 0, []));
-        Assert.That(engine.Runtime.State.Table<Layer>().TryGet("late", out _), Is.False);
+        Assert.That(engine.Runtime.State.Table<DebugState>().TryGet("late", out _), Is.False);
         Assert.That((await debug.InspectAsync()).CachedGroups, Is.EqualTo(new[] { "main" }));
         Assert.ThrowsAsync<InvalidOperationException>(async () => await debug.ResumeAsync(generation));
     }
@@ -211,7 +227,7 @@ public async Task LatestNaturalReentryReplacesTheSingleEntrance()
         graph.Edges.Add(new Edge("main", 0, "main"));
         using var view = Registration().RegisterInstruction("test.text", _ => new TextWait())
             .RegisterInstruction("test.scene", context => new ImmediatePrimitiveInstance(() =>
-                context.Runtime.State.Table<Layer>().Set(new Layer { Id = "existing", AssetId = "second-entrance" }))).BuildView();
+                context.Runtime.State.Table<DebugState>().Set(new DebugState { Id = "existing", Value = "second-entrance" }))).BuildView();
         await using var engine = new GameEngine(graph, Runtime(), view);
         using var debug = engine.AttachDebugging(Options());
         await engine.AdvanceAsync();
@@ -219,7 +235,7 @@ public async Task LatestNaturalReentryReplacesTheSingleEntrance()
         await engine.AdvanceAsync();
         Assert.That(engine.EntryIndex, Is.EqualTo(1));
         await debug.SeekAsync(debug.Generation, new("main", 0, []));
-        Assert.That(engine.Runtime.State.Table<Layer>().Get("existing").AssetId, Is.EqualTo("second-entrance"));
+        Assert.That(engine.Runtime.State.Table<DebugState>().Get("existing").Value, Is.EqualTo("second-entrance"));
         Assert.That((await debug.InspectAsync()).CachedGroups, Has.Length.EqualTo(1));
     }
 
@@ -227,7 +243,12 @@ public async Task LatestNaturalReentryReplacesTheSingleEntrance()
     public async Task ExplicitRouteIgnoresConditionsAndChoiceWithoutWritingVariables()
     {
         var graph = GraphOf(Entry("test.text", "first"), Entry("test.scene", "conditional", "false"), Entry("test.write", "write"));
-        graph.Nodes.Add(new Branch { Id = "choice", BranchType = BranchType.Choice });
+        graph.Nodes.Add(new Branch
+        {
+            Id = "choice",
+            BranchType = BranchType.Choice,
+            Options = Enumerable.Range(0, 8).Select(index => new BranchOption { Text = $"choice {index}", Condition = "false" }).ToList()
+        });
         graph.Nodes.Add(new Group { Id = "target", Entries = { Entry("test.text", "target") } });
         graph.Edges.AddRange([new Edge("main", 0, "choice"), new Edge("choice", 7, "target")]);
         using var view = Registration().RegisterInstruction("test.text", _ => new TextWait())
@@ -235,7 +256,7 @@ public async Task ExplicitRouteIgnoresConditionsAndChoiceWithoutWritingVariables
             .RegisterInstruction("test.scene", context => new ImmediatePrimitiveInstance(() =>
             {
                 context.Runtime.SetVariable("save.value", 88);
-                context.Runtime.State.Table<Layer>().Set(new Layer { Id = "bg", AssetId = "forced" });
+                context.Runtime.State.Table<DebugState>().Set(new DebugState { Id = "bg", Value = "forced" });
             })).BuildView();
         await using var engine = new GameEngine(graph, Runtime(), view);
         engine.Runtime.SetVariable("save.value", 3);
@@ -244,7 +265,7 @@ public async Task ExplicitRouteIgnoresConditionsAndChoiceWithoutWritingVariables
         await debug.SeekAsync(debug.Generation, new("target", 0, [new("main", 0, "choice"), new("choice", 7, "target")]));
         Assert.That(engine.CurrentNodeId, Is.EqualTo("target"));
         Assert.That(engine.EntryIndex, Is.Zero);
-        Assert.That(engine.Runtime.State.Table<Layer>().Get("bg").AssetId, Is.EqualTo("forced"));
+        Assert.That(engine.Runtime.State.Table<DebugState>().Get("bg").Value, Is.EqualTo("forced"));
         Assert.That(engine.Runtime.GetVariable("value")!.AsInt(), Is.EqualTo(3));
         Assert.That((await debug.InspectAsync()).Paused, Is.True);
     }
@@ -297,14 +318,16 @@ public async Task VariablesAreCopiedAndWritesCheckTheObservedValueTypeAndGenerat
         Assert.ThrowsAsync<InvalidOperationException>(async () => await debug.SetVariableAsync(before.Generation, variable, "10"));
         var current = (await debug.InspectAsync()).Variables.Single();
         Assert.ThrowsAsync<FormatException>(async () => await debug.SetVariableAsync(before.Generation, current, "not-an-int"));
-        engine.RestoreFrom(engine.Runtime.CreateSnapshot());
+        await engine.RestoreFromAsync(engine.Runtime.CreateSnapshot());
         Assert.ThrowsAsync<InvalidOperationException>(async () => await debug.SetVariableAsync(before.Generation, current, "11"));
     }
 
+    public sealed class DebugState { public string Id { get; init; } = ""; public string Value { get; set; } = ""; }
+
     private static GameRuntime Runtime()
     {
         var builder = new StateCatalogBuilder();
-        builder.Register<Layer>("layers", layer => layer.Id);
+        builder.Register<DebugState>("layers", layer => layer.Id);
         return new(null, rootNodeId: "main", stateCatalog: builder.Build());
     }
     private static GameDebugOptions Options() => new()
@@ -343,15 +366,15 @@ private sealed class ReplayBlocker : PrimitiveInstance
         public override bool IsSkippable => false;
         protected override void OnDispatch() => Entered.TrySetResult();
     }
-    private sealed class CompressingWait(IGameRuntime runtime) : PrimitiveInstance
+    private sealed class CompressingWait(IGameContext runtime) : PrimitiveInstance
     {
         public override bool IsBlocking => true;
         public override bool IsSkippable => false;
-        protected override void OnDispatch() => runtime.State.Table<Layer>().Set(new Layer { Id = "scene", AssetId = "initial" });
+        protected override void OnDispatch() => runtime.State.Table<DebugState>().Set(new DebugState { Id = "scene", Value = "initial" });
         protected override void OnPlaybackModeChanged(PrimitiveInvocationMode mode)
         {
             if (mode != PrimitiveInvocationMode.CatchUp) return;
-            runtime.State.Table<Layer>().Set(new Layer { Id = "scene", AssetId = "compressed" });
+            runtime.State.Table<DebugState>().Set(new DebugState { Id = "scene", Value = "compressed" });
             TryComplete();
         }
     }
diff --git a/test/GalNet.Runtime.Tests/Engine/ExecutionBoundaryTests.cs b/test/GalNet.Runtime.Tests/Engine/ExecutionBoundaryTests.cs
new file mode 100644
index 00000000..dd5479a0
--- /dev/null
+++ b/test/GalNet.Runtime.Tests/Engine/ExecutionBoundaryTests.cs
@@ -0,0 +1,65 @@
+using System.Text.Json;
+using GalNet.Core.Entry;
+using GalNet.Core.Execution;
+using GalNet.Core.Graph;
+using GalNet.Core.Primitives;
+using GalNet.Core.Runtime;
+using GalNet.Runtime.Engine;
+using GalNet.Runtime.Runtime;
+
+namespace GeneralTest.Runtime;
+
+public sealed class ExecutionBoundaryTests
+{
+    [Test]
+    public async Task CustomDispatcher_CanExecuteAndRestoreWithoutPresentationServices()
+    {
+        var group = new Group
+        {
+            Id = "entry",
+            Entries = [new PrimitiveEntry("project.increment", JsonSerializer.SerializeToElement(new { }))]
+        };
+        var runtime = new GameRuntime(null, group.Id);
+        runtime.SetVariable("save.count", 0);
+        await using var engine = new GameEngine(new Graph { RootNodeId = group.Id, Nodes = [group] }, runtime, new CounterDispatcher());
+        var start = engine.CreateSaveData();
+
+        await engine.AdvanceAsync();
+        Assert.That(engine.Runtime.GetVariable("save.count")!.AsInt(), Is.EqualTo(1));
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Completed));
+
+        await engine.RestoreFromAsync(start);
+        Assert.That(engine.Runtime.GetVariable("save.count")!.AsInt(), Is.Zero);
+        await engine.AdvanceAsync();
+        Assert.That(engine.Runtime.GetVariable("save.count")!.AsInt(), Is.EqualTo(1));
+    }
+
+    [Test]
+    public void RuntimeAssembly_DoesNotDependOnPresentationOrBuiltinImplementations()
+    {
+        var references = typeof(GameEngine).Assembly.GetReferencedAssemblies().Select(reference => reference.Name).ToArray();
+        Assert.That(references.Where(name => name is not null &&
+            (name.StartsWith("GalNet.Presentation.", StringComparison.Ordinal) ||
+             name.StartsWith("GalNet.Avalonia.", StringComparison.Ordinal) ||
+             name is "GalNet.Primitives.Builtins" or "GalNet.Contracts.Builtins")), Is.Empty);
+        Assert.That(typeof(IGameContext).GetProperties().Select(property => property.Name), Does.Not.Contain("SceneInstances"));
+        Assert.That(typeof(GameState).Assembly.GetExportedTypes().Select(type => type.Namespace),
+            Does.Not.Contain("GalNet.Core.Scene").And.Not.Contain("GalNet.Core.Audio").And.Not.Contain("GalNet.Core.Gallery").And.Not.Contain("GalNet.Core.Variants"));
+    }
+
+    private sealed class CounterDispatcher : IPrimitiveDispatcher
+    {
+        public IReadOnlyCollection<EntryDefinition> Primitives => [];
+        public bool CanExecute(string primitiveType) => primitiveType == "project.increment";
+        public bool TryGetEntry(string primitiveType, out EntryDefinition? entry) { entry = null; return false; }
+
+        public PrimitiveInstance Dispatch(PrimitiveEntry entry, IGameContext runtime, CancellationToken cancellationToken,
+            PrimitiveInvocationMode mode = PrimitiveInvocationMode.Normal)
+        {
+            var instance = new ImmediatePrimitiveInstance(() =>
+                runtime.SetVariable("save.count", runtime.GetVariable("save.count")!.AsInt() + 1), batchId: entry.BatchId);
+            instance.Dispatch(mode);
+            return instance;
+        }
+    }
+}
diff --git a/test/GalNet.Runtime.Tests/Engine/ExternalVariableTests.cs b/test/GalNet.Runtime.Tests/Engine/ExternalVariableTests.cs
new file mode 100644
index 00000000..18b8ea94
--- /dev/null
+++ b/test/GalNet.Runtime.Tests/Engine/ExternalVariableTests.cs
@@ -0,0 +1,153 @@
+using System.Text.Json;
+using GalNet.Core.Entry;
+using GalNet.Core.Execution;
+using GalNet.Core.Graph;
+using GalNet.Core.Primitives;
+using GalNet.Core.Runtime;
+using GalNet.Core.Variable;
+using GalNet.Runtime.Engine;
+using GalNet.Runtime.Persistence;
+using GalNet.Runtime.Runtime;
+using GalNet.Runtime.Variables;
+
+namespace GeneralTest.Runtime;
+
+public sealed class ExternalVariableTests
+{
+    [Test]
+    public async Task EditsDuringBlockingPresentationPreserveCursorAndUpdateImmediateSave()
+    {
+        var runtime = new GameRuntime(null, "main");
+        runtime.SetVariable("save.score", 1);
+        await using var engine = Create(runtime);
+        var before = engine.CreateSaveData();
+        await engine.AdvanceAsync();
+
+        var observerWasOutsideGate = false;
+        engine.CheckpointCreated += _ => observerWasOutsideGate = engine.UpdatePlaybackOptionsAsync(new PlaybackOptions()).IsCompletedSuccessfully;
+        await engine.SetVariablesAsync(new Dictionary<string, object> { ["save.score"] = 9, ["player.unlocked"] = true });
+        var saved = engine.CreateSaveData();
+        Assert.Multiple(() =>
+        {
+            Assert.That(observerWasOutsideGate, Is.True);
+            Assert.That(runtime.GetVariable("save.score")!.AsInt(), Is.EqualTo(9));
+            Assert.That(saved.Variables["score"].AsInt(), Is.EqualTo(9));
+            Assert.That(saved.Variables["score"].Uid, Is.EqualTo(before.Variables["score"].Uid));
+            Assert.That(saved.EntryIndex, Is.EqualTo(before.EntryIndex));
+            Assert.That(saved.Variables.ContainsKey("unlocked"), Is.False);
+            Assert.That(engine.State, Is.EqualTo(GameEngineState.Running));
+        });
+        await engine.RestoreFromAsync(saved);
+        Assert.That(runtime.GetVariable("save.score")!.AsInt(), Is.EqualTo(9));
+        Assert.That(runtime.GetVariable("player.unlocked")!.AsBool(), Is.True);
+    }
+
+    [Test]
+    public async Task ConditionalReadModifyWriteUsesLatestValuesAndRejectedOperationDoesNotFaultRun()
+    {
+        var runtime = new GameRuntime(null, "main");
+        runtime.SetVariable("save.coins", 0);
+        await using var engine = Create(runtime);
+        await Task.WhenAll(Enumerable.Range(0, 20).Select(_ => Task.Run(() =>
+            engine.UpdateVariablesAsync(current => new Dictionary<string, object> { ["save.coins"] = current["save.coins"].AsInt() + 1 }))));
+        Assert.That(engine.CreateSaveData().Variables["coins"].AsInt(), Is.EqualTo(20));
+        Assert.ThrowsAsync<InvalidOperationException>(() => engine.UpdateVariablesAsync(_ => throw new InvalidOperationException("Insufficient funds.")));
+        Assert.That(runtime.GetVariable("save.coins")!.AsInt(), Is.EqualTo(20));
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Ready));
+    }
+
+    [TestCase("score", 2)]
+    [TestCase("save.", 2)]
+    [TestCase("save.score", double.PositiveInfinity)]
+    [TestCase("save.score", long.MaxValue)]
+    public async Task InvalidBatchDoesNotApplyEarlierValues(string name, object value)
+    {
+        var runtime = new GameRuntime(null, "main");
+        await using var engine = Create(runtime);
+        Assert.ThrowsAsync<ArgumentException>(() => engine.SetVariablesAsync(new Dictionary<string, object>
+        {
+            ["save.valid"] = 1,
+            [name] = value
+        }));
+        Assert.That(runtime.GetVariable("save.valid"), Is.Null);
+        Assert.That(engine.CreateSaveData().Variables, Is.Empty);
+    }
+
+    [Test]
+    public async Task PlayerWritesPreserveStorageIdentityAndCanBeReopened()
+    {
+        var initial = new Variable { Name = "player.coins", Value = VariableValue.From(1) };
+        var store = new MemoryStore { Saved = new() { [initial.Name] = initial } };
+        using var player = await PlayerVariableService.CreateAsync(store);
+        player.VariableChanged += (_, _, _) => throw new IOException("Observer failed.");
+        await using var engine = Create(new GameRuntime(null, "main", player));
+        await engine.SetVariablesAsync(new Dictionary<string, object> { ["player.coins"] = 12 });
+        await player.FlushPlayerVariablesAsync();
+        using var reopened = await PlayerVariableService.CreateAsync(store);
+        var saved = reopened.GetSnapshot(VariableScope.Player);
+        Assert.That(saved.Keys, Is.EqualTo(new[] { "player.coins" }));
+        Assert.That(saved[initial.Name].Uid, Is.EqualTo(initial.Uid));
+        Assert.That(saved[initial.Name].AsInt(), Is.EqualTo(12));
+    }
+
+    [Test]
+    public async Task QueuedEditCannotCrossRestoreOrStop()
+    {
+        await using var engine = Create(new GameRuntime(null, "main"));
+        var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        var presentation = engine.SynchronizePresentationAsync(async (_, _) =>
+        {
+            entered.SetResult();
+            await release.Task;
+        });
+        await entered.Task;
+        var restore = engine.RestoreFromAsync(engine.CreateSaveData());
+        var edit = engine.SetVariablesAsync(new Dictionary<string, object> { ["save.stale"] = true });
+        release.SetResult();
+        await presentation;
+        await restore;
+        Assert.ThrowsAsync<OperationCanceledException>(() => edit);
+        Assert.That(engine.Runtime.GetVariable("save.stale"), Is.Null);
+        await engine.StopAsync();
+        Assert.ThrowsAsync<OperationCanceledException>(() => engine.SetVariablesAsync(new Dictionary<string, object> { ["save.stale"] = true }));
+    }
+
+    private static GameEngine Create(GameRuntime runtime) => new(new Graph
+    {
+        RootNodeId = "main",
+        Nodes = [new Group { Id = "main", Entries = [new PrimitiveEntry("project.wait", JsonSerializer.SerializeToElement(new { }))] }]
+    }, runtime, new Dispatcher());
+
+    private sealed class Dispatcher : IPrimitiveDispatcher
+    {
+        public IReadOnlyCollection<EntryDefinition> Primitives => [];
+        public bool CanExecute(string primitiveType) => primitiveType == "project.wait";
+        public bool TryGetEntry(string primitiveType, out EntryDefinition? entry) { entry = null; return false; }
+        public PrimitiveInstance Dispatch(PrimitiveEntry entry, IGameContext runtime, CancellationToken cancellationToken,
+            PrimitiveInvocationMode mode = PrimitiveInvocationMode.Normal)
+        {
+            var instance = new Wait();
+            instance.Dispatch(mode);
+            return instance;
+        }
+    }
+
+    private sealed class Wait : PrimitiveInstance
+    {
+        public override bool IsBlocking => true;
+        public override bool IsSkippable => false;
+        protected override void OnDispatch() { }
+    }
+
+    private sealed class MemoryStore : IPlayerVariableStore
+    {
+        public Dictionary<string, Variable> Saved { get; set; } = [];
+        public Task<IReadOnlyDictionary<string, Variable>> LoadAsync(CancellationToken ct = default) => Task.FromResult<IReadOnlyDictionary<string, Variable>>(Saved);
+        public Task SaveAsync(IReadOnlyDictionary<string, Variable> values, CancellationToken ct = default)
+        {
+            Saved = values.ToDictionary(pair => pair.Key, pair => pair.Value.Clone());
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/test/GalNet.Runtime.Tests/Engine/GameEngineLifecycleTests.cs b/test/GalNet.Runtime.Tests/Engine/GameEngineLifecycleTests.cs
index 5794909f..b2acca2f 100644
--- a/test/GalNet.Runtime.Tests/Engine/GameEngineLifecycleTests.cs
+++ b/test/GalNet.Runtime.Tests/Engine/GameEngineLifecycleTests.cs
@@ -1,17 +1,138 @@
 using System.Collections.Concurrent;
 using System.Text.Json;
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
+using GalNet.Core.Runtime;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Runtime.Engine;
 using GalNet.Runtime.Progress;
+using GalNet.Runtime.Runtime;
 
 namespace GeneralTest.Runtime;
 
 public sealed class GameEngineLifecycleTests
 {
+    [Test]
+    public async Task ObsoleteCancellationCallbackFailureCannotLeaveRestorationHalfApplied()
+    {
+        var calls = 0;
+        using var view = View(context =>
+        {
+            if (++calls == 1) context.ScopeCancellation.Register(() => throw new IOException("obsolete callback"));
+            return new Blocker();
+        });
+        await using var engine = new GameEngine(GroupGraph(), view);
+        var saved = engine.CreateSaveData();
+        await engine.AdvanceAsync();
+        await engine.RestoreFromAsync(saved);
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Ready));
+        await engine.AdvanceAsync();
+        Assert.That(calls, Is.EqualTo(2));
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Running));
+    }
+
+    [Test]
+    public async Task InstructionsReceiveGameplayContextWithoutEngineRestorationOrCursorControl()
+    {
+        PrimitiveCreateContext? context = null;
+        using var view = View(value => { context = value; return new Blocker(); });
+        await using var engine = new GameEngine(GroupGraph(), view);
+        var saved = engine.CreateSaveData();
+        await engine.AdvanceAsync();
+        Assert.That(context!.Runtime, Is.Not.InstanceOf<IGameRuntime>());
+        var oldContext = context.Runtime;
+        await engine.RestoreFromAsync(saved);
+        engine.Runtime.SetVariable("value", 42);
+        Assert.Throws<OperationCanceledException>(() => oldContext.SetVariable("value", 99));
+        Assert.That(engine.Runtime.GetVariable("value")!.AsInt(), Is.EqualTo(42));
+    }
+
+    [Test]
+    public async Task HostMutationsCannotChangeAnExistingRunGraph()
+    {
+        var dispatched = 0;
+        using var view = View(_ => new ImmediatePrimitiveInstance(() => dispatched++));
+        var graph = GroupGraph();
+        await using var engine = new GameEngine(graph, view);
+        ((PrimitiveEntry)((Group)graph.Nodes[0]).Entries[0]).Condition = "false";
+        ((Group)graph.Nodes[0]).Entries.Clear();
+        graph.Nodes.Clear();
+        graph.RootNodeId = "changed";
+        await engine.AdvanceAsync();
+        Assert.That(dispatched, Is.EqualTo(1));
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Completed));
+    }
+
+    [TestCase("node")]
+    [TestCase("edge")]
+    [TestCase("root")]
+    [TestCase("target")]
+    [TestCase("outlet")]
+    public void InvalidGraphIsRejectedBeforeExecution(string fault)
+    {
+        using var view = View(_ => new ImmediatePrimitiveInstance());
+        var graph = GroupGraph();
+        switch (fault)
+        {
+            case "node": graph.Nodes.Add(new Group { Id = "main" }); break;
+            case "edge": graph.Edges.Add(new("main", 0, "main")); graph.Edges.Add(new("main", 0, "main")); break;
+            case "root": graph.RootNodeId = "missing"; break;
+            case "target": graph.Edges.Add(new("main", 0, "missing")); break;
+            case "outlet": graph.Edges.Add(new("main", 1, "main")); break;
+        }
+        Assert.Throws<InvalidDataException>(() => new GameEngine(graph, view));
+    }
+
+    [Test]
+    public async Task CheckpointObserversCanRestoreAndFailuresDoNotFaultStory()
+    {
+        using var view = View(_ => new ImmediatePrimitiveInstance());
+        await using var engine = new GameEngine(GroupGraph(), view);
+        var initial = engine.CreateSaveData();
+        Task? restored = null;
+        engine.CheckpointCreated += _ => throw new IOException("observer failed");
+        engine.CheckpointCreated += _ => restored ??= engine.RestoreFromAsync(initial);
+        await engine.AdvanceAsync().WaitAsync(TimeSpan.FromSeconds(2));
+        await restored!.WaitAsync(TimeSpan.FromSeconds(2));
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Ready));
+    }
+
+    [TestCase("missing", 0)]
+    [TestCase("main", -1)]
+    [TestCase("main", 5)]
+    public async Task InvalidSavePositionLeavesCurrentScopeIntact(string node, int index)
+    {
+        PrimitiveCreateContext? context = null;
+        using var view = View(value => { context = value; return new Blocker(); });
+        await using var engine = new GameEngine(GroupGraph(), view);
+        await engine.AdvanceAsync();
+        var state = engine.Runtime.State;
+        Assert.ThrowsAsync<InvalidDataException>(() => engine.RestoreFromAsync(new GameSnapshot
+        { NodeId = node, EntryIndex = index, States = engine.CreateSaveData().States }));
+        Assert.That(engine.Runtime.State, Is.SameAs(state));
+        Assert.That(context!.ScopeCancellation.IsCancellationRequested, Is.False);
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Running));
+    }
+
+    [Test]
+    public async Task NonblockingCycleYieldsAndCallerCancellationKeepsRunUsable()
+    {
+        using var view = View(_ => new ImmediatePrimitiveInstance());
+        var graph = GroupGraph();
+        graph.Edges.Add(new Edge("main", 0, "main"));
+        await using var engine = new GameEngine(graph, view);
+        using var cancellation = new CancellationTokenSource();
+        engine.CheckpointCreated += _ => cancellation.Cancel();
+        Assert.ThrowsAsync<OperationCanceledException>(async () =>
+            await engine.AdvanceAsync(cancellation.Token).WaitAsync(TimeSpan.FromSeconds(2)));
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Running));
+        await engine.StopAsync().WaitAsync(TimeSpan.FromSeconds(2));
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Stopped));
+    }
+
     [Test]
     public async Task CompletionIsReportedOnceAndFurtherAdvanceDoesNotReplayContent()
     {
@@ -114,7 +235,7 @@ public async Task StopCancelsAndDrainsEvenAnUncooperativeChoicePresenter()
             Assert.That(engine.CurrentNodeId, Is.EqualTo("choice"));
         });
         Assert.That(await engine.AdvanceAsync(), Is.False);
-        Assert.Throws<InvalidOperationException>(() => engine.RestoreFrom(engine.CreateSaveData()));
+        Assert.ThrowsAsync<InvalidOperationException>(() => engine.RestoreFromAsync(engine.CreateSaveData()));
     }
 
     [Test]
@@ -165,7 +286,7 @@ public async Task RestoreDiscardsOldChoiceAndAllowsAFreshRun()
             if (change.State is GameEngineState.Completed or GameEngineState.Faulted) completion.TrySetResult(change);
         };
 
-        engine.RestoreFrom(snapshot);
+        await engine.RestoreFromAsync(snapshot);
         oldResult.SetException(new InvalidOperationException("obsolete"));
         await engine.AdvanceAsync();
         choice.Result.SetResult(0);
@@ -183,13 +304,15 @@ public async Task ObserversRunOutsideTheExecutionLockAndCannotFaultTheStory()
         using var view = View(_ => new ImmediatePrimitiveInstance());
         await using var engine = new GameEngine(GroupGraph(), view);
         var snapshot = engine.CreateSaveData();
+        Task? restore = null;
         engine.StateChanged += _ => throw new InvalidOperationException("observer failed");
         engine.StateChanged += change =>
         {
-            if (change.State == GameEngineState.Completed) engine.RestoreFrom(snapshot);
+            if (change.State == GameEngineState.Completed) restore = engine.RestoreFromAsync(snapshot);
         };
 
         await engine.AdvanceAsync().WaitAsync(TimeSpan.FromSeconds(2));
+        await restore!.WaitAsync(TimeSpan.FromSeconds(2));
 
         Assert.That(engine.State, Is.EqualTo(GameEngineState.Ready));
     }
diff --git a/test/GalNet.Runtime.Tests/Engine/GroupEndCatchUpTests.cs b/test/GalNet.Runtime.Tests/Engine/GroupEndCatchUpTests.cs
index 15ca679a..f23a3c49 100644
--- a/test/GalNet.Runtime.Tests/Engine/GroupEndCatchUpTests.cs
+++ b/test/GalNet.Runtime.Tests/Engine/GroupEndCatchUpTests.cs
@@ -1,6 +1,7 @@
 using System.Collections.Concurrent;
 using System.Text.Json;
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
@@ -105,7 +106,7 @@ public async Task EmptyRestoredGroupCanStopAtItsEndWithoutFollowingAnEdge()
         graph.Nodes.Add(new Group { Id = "next", Entries = { Entry("test.text", "next") } });
         graph.Edges.Add(new Edge("main", 0, "next"));
         await using var engine = new GameEngine(graph, view);
-        engine.RestoreFrom(engine.CreateSaveData());
+        await engine.RestoreFromAsync(engine.CreateSaveData());
         await engine.SkipToGroupEndAsync();
         Assert.That(engine.CurrentNodeId, Is.EqualTo("main"));
         Assert.That(engine.EntryIndex, Is.Zero);
@@ -238,7 +239,7 @@ private sealed class Synchronization : ICatchUpPresentation
         public TaskCompletionSource EndEntered { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
         public TaskCompletionSource EndReleased { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
         public Task BeginCatchUpAsync(CancellationToken cancellationToken) => Task.CompletedTask;
-        public Task EndCatchUpAsync(IGameRuntime runtime, CancellationToken cancellationToken)
+        public Task EndCatchUpAsync(IGameContext runtime, CancellationToken cancellationToken)
         {
             EndEntered.TrySetResult();
             return EndReleased.Task.WaitAsync(cancellationToken);
diff --git a/test/GalNet.Runtime.Tests/Engine/PlaybackModeTests.cs b/test/GalNet.Runtime.Tests/Engine/PlaybackModeTests.cs
index 1251dec5..adbd18dd 100644
--- a/test/GalNet.Runtime.Tests/Engine/PlaybackModeTests.cs
+++ b/test/GalNet.Runtime.Tests/Engine/PlaybackModeTests.cs
@@ -1,10 +1,11 @@
 using System.Collections.Concurrent;
 using System.Text.Json;
 using GalNet.Core.Entry;
+using GalNet.Core.Execution;
+using GalNet.Core.Execution;
 using GalNet.Core.Graph;
 using GalNet.Core.Primitives;
 using GalNet.Core.Runtime;
-using GalNet.Core.Settings;
 using GalNet.Presentation.Abstractions.Execution;
 using GalNet.Presentation.Abstractions.View;
 using GalNet.Runtime.Engine;
@@ -14,13 +15,34 @@ namespace GeneralTest.Runtime;
 
 public class PlaybackModeTests
 {
+    [Test]
+    public async Task ExplicitOptionsUpdateStopsQuickAtUnreadTextAndRejectsInvalidInputWithoutFaulting()
+    {
+        var line = new ReadingWait();
+        using var view = Registration().RegisterInstruction("test.text", _ => line).BuildView();
+        await using var engine = new GameEngine(GraphOf("test.text"), view,
+            playbackOptions: Settings(5000) with { QuickReadOnly = false });
+        await engine.AdvanceAsync();
+        await engine.SetPlaybackModeAsync(PlaybackMode.Quick);
+        Assert.That(engine.PlaybackMode, Is.EqualTo(PlaybackMode.Quick));
+
+        Assert.ThrowsAsync<ArgumentOutOfRangeException>(() => engine.UpdatePlaybackOptionsAsync(
+            new PlaybackOptions { AutoAdvanceIntervalMilliseconds = -1 }));
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Running));
+        Assert.That(engine.PlaybackMode, Is.EqualTo(PlaybackMode.Quick));
+
+        await engine.UpdatePlaybackOptionsAsync(Settings(5000));
+        Assert.That(engine.PlaybackMode, Is.EqualTo(PlaybackMode.Manual));
+        Assert.That(engine.State, Is.EqualTo(GameEngineState.Running));
+    }
+
     [TestCase(PlaybackMode.Auto)]
     [TestCase(PlaybackMode.Quick)]
     public async Task CancelledCatchUpOnExistingUnskippableBlockerPreservesPlaybackBoundary(PlaybackMode mode)
     {
         var blocker = new UnskippableWait();
         using var view = Registration().RegisterInstruction("test.voice", _ => blocker).BuildView();
-        await using var engine = new GameEngine(GraphOf("test.voice"), view, settings: Settings(0));
+        await using var engine = new GameEngine(GraphOf("test.voice"), view, playbackOptions: Settings(0));
         var completed = Terminal(engine);
         await engine.AdvanceAsync();
         var skip = engine.SkipToUnreadAsync();
@@ -39,9 +61,9 @@ public async Task ManualRevealPreservesBoundaryForPlayback(PlaybackMode mode)
     {
         var line = new ReadingWait(skipCompletes: false);
         var settings = Settings(0);
-        settings.Get<GameSettings>().QuickReadOnly = false;
+        settings = settings with { QuickReadOnly = false };
         using var view = Registration().RegisterInstruction("test.text", _ => line).BuildView();
-        await using var engine = new GameEngine(GraphOf("test.text"), view, settings: settings);
+        await using var engine = new GameEngine(GraphOf("test.text"), view, playbackOptions: settings);
         var completed = Terminal(engine);
         await engine.AdvanceAsync();
         await engine.AdvanceAsync();
@@ -57,7 +79,7 @@ public async Task ManualClickOnUnskippableBlockerPreservesBoundaryForPlayback(Pl
     {
         var blocker = new UnskippableWait();
         using var view = Registration().RegisterInstruction("test.voice", _ => blocker).BuildView();
-        await using var engine = new GameEngine(GraphOf("test.voice"), view, settings: Settings(0));
+        await using var engine = new GameEngine(GraphOf("test.voice"), view, playbackOptions: Settings(0));
         var completed = Terminal(engine);
         await engine.AdvanceAsync();
         await engine.AdvanceAsync();
@@ -73,7 +95,7 @@ public async Task PresentationSynchronizationUsesAnIsolatedRunScopeThatRestoreAn
     {
         using var view = Registration().RegisterInstruction("test.text", _ => new ReadingWait()).BuildView();
         await using var engine = new GameEngine(GraphOf("test.text"), view);
-        IGameRuntime? oldRuntime = null;
+        IGameContext? oldRuntime = null;
         CancellationToken oldToken = default;
         await engine.SynchronizePresentationAsync((runtime, token) =>
         {
@@ -82,7 +104,7 @@ await engine.SynchronizePresentationAsync((runtime, token) =>
             return Task.CompletedTask;
         });
         Assert.That(oldToken.CanBeCanceled, Is.True);
-        engine.RestoreFrom(engine.Runtime.CreateSnapshot());
+        await engine.RestoreFromAsync(engine.Runtime.CreateSnapshot());
         Assert.That(oldToken.IsCancellationRequested, Is.True);
         Assert.That(oldRuntime!.State, Is.Not.SameAs(engine.Runtime.State));
         Assert.Throws<OperationCanceledException>(() => oldRuntime.SetVariable("late", 1));
@@ -240,12 +262,12 @@ public async Task RestoreInvalidatesOldTimerAndOldCompletion()
         var next = new ReadingWait();
         var calls = 0;
         using var view = Registration().RegisterInstruction("test.text", _ => ++calls == 1 ? first : next).BuildView();
-        await using var engine = new GameEngine(GraphOf("test.text"), view, settings: Settings(50));
+        await using var engine = new GameEngine(GraphOf("test.text"), view, playbackOptions: Settings(50));
         var snapshot = engine.CreateSaveData();
         await engine.AdvanceAsync();
         first.Presented();
         await engine.SetPlaybackModeAsync(PlaybackMode.Auto);
-        engine.RestoreFrom(snapshot);
+        await engine.RestoreFromAsync(snapshot);
         await engine.AdvanceAsync();
         first.CompleteAdvance();
         await Task.Delay(100);
@@ -320,7 +342,7 @@ public async Task AutoWaitsForEveryDeclaredBlockerWithoutCompletingTextEarly()
         var line = new ReadingWait();
         using var view = Registration().RegisterInstruction("test.voice", _ => voice)
             .RegisterInstruction("test.text", _ => line).BuildView();
-        await using var engine = new GameEngine(GraphOf("test.voice", "test.text"), view, settings: Settings(0));
+        await using var engine = new GameEngine(GraphOf("test.voice", "test.text"), view, playbackOptions: Settings(0));
         var completed = Terminal(engine);
         await engine.AdvanceAsync();
         await engine.SetPlaybackModeAsync(PlaybackMode.Auto);
@@ -340,7 +362,7 @@ public async Task NewlyAppearingBlockerCancelsPendingInterval()
         var line = new ReadingWait();
         using var view = Registration().RegisterInstruction("test.voice", _ => voice)
             .RegisterInstruction("test.text", _ => line).BuildView();
-        await using var engine = new GameEngine(GraphOf("test.voice", "test.text"), view, settings: Settings(80));
+        await using var engine = new GameEngine(GraphOf("test.voice", "test.text"), view, playbackOptions: Settings(80));
         var completed = Terminal(engine);
         await engine.AdvanceAsync();
         voice.Block(false);
@@ -358,7 +380,7 @@ public async Task ManualCancellationInvalidatesAnAlreadyScheduledTimer()
     {
         var line = new ReadingWait();
         using var view = Registration().RegisterInstruction("test.text", _ => line).BuildView();
-        await using var engine = new GameEngine(GraphOf("test.text"), view, settings: Settings(50));
+        await using var engine = new GameEngine(GraphOf("test.text"), view, playbackOptions: Settings(50));
         await engine.AdvanceAsync();
         line.Presented();
         await engine.SetPlaybackModeAsync(PlaybackMode.Auto);
@@ -395,7 +417,7 @@ public async Task QuickStopsBeforeVoiceOfNextUnreadComposite()
             .RegisterInstruction("test.voice", _ => new RecordMode(mode => voiceMode = mode)).BuildView();
         var graph = GraphOf("test.text", "test.voice", "test.text");
         ((PrimitiveEntry)((Group)graph.Nodes[0]).Entries[1]).ReadingBoundaryId = "line-2";
-        await using var engine = new GameEngine(graph, view, settings: Settings(0), progress: progress);
+        await using var engine = new GameEngine(graph, view, playbackOptions: Settings(0), progress: progress);
         await engine.AdvanceAsync();
         await engine.SetPlaybackModeAsync(PlaybackMode.Quick);
         first.Presented();
@@ -455,12 +477,8 @@ protected override void OnPlaybackModeChanged(PrimitiveInvocationMode mode)
             JsonSerializer.SerializeToElement(new { })) { StableId = $"line-{index}" }).ToList() } }
     };
 
-    private static SettingsContainer Settings(int interval)
-    {
-        var settings = new SettingsContainer();
-        settings.Set(new GameSettings { AutoAdvanceIntervalMilliseconds = interval, QuickAdvanceIntervalMilliseconds = interval });
-        return settings;
-    }
+    private static PlaybackOptions Settings(int interval) => new()
+    { AutoAdvanceIntervalMilliseconds = interval, QuickAdvanceIntervalMilliseconds = interval };
 
     private static Task Terminal(GameEngine engine)
     {
@@ -528,7 +546,7 @@ private sealed class ControlledCatchUpPresentation : ICatchUpPresentation
         public TaskCompletionSource EndEntered { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
         public TaskCompletionSource EndReleased { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
         public Task BeginCatchUpAsync(CancellationToken cancellationToken) => Task.CompletedTask;
-        public Task EndCatchUpAsync(IGameRuntime runtime, CancellationToken cancellationToken)
+        public Task EndCatchUpAsync(IGameContext runtime, CancellationToken cancellationToken)
         {
             EndEntered.TrySetResult();
             return EndReleased.Task.WaitAsync(cancellationToken);
diff --git a/test/GalNet.Runtime.Tests/I18n/GameTextResolverTests.cs b/test/GalNet.Runtime.Tests/I18n/GameTextResolverTests.cs
index 7230cbcf..bbb518f6 100644
--- a/test/GalNet.Runtime.Tests/I18n/GameTextResolverTests.cs
+++ b/test/GalNet.Runtime.Tests/I18n/GameTextResolverTests.cs
@@ -37,4 +37,15 @@ public void LaterSourcesOverrideOnlyTheirOwnKeysAndTheSourceOrderIsSnapshotted()
 
     private static LocalizedTextSource Source(string culture, string key, string value) =>
         new(CultureInfo.GetCultureInfo(culture), candidate => candidate == key ? value : null);
+
+    [TestCase("")]
+    [TestCase(" \t\n")]
+    public void EmptyReferencesResolveToEmptyTextWithoutLookingUpAMissingKey(string key)
+    {
+        var culture = CultureInfo.GetCultureInfo("en-US");
+        var resolver = new GameTextResolver([new(culture, _ => throw new AssertionException("Empty references must not query localization sources."))], culture, () => culture);
+        Assert.That(resolver.Resolve(key), Is.Empty);
+        Assert.That(resolver.TryGetString(key, culture, out var text), Is.True);
+        Assert.That(text, Is.Empty);
+    }
 }
diff --git a/test/GalNet.Runtime.Tests/Variables/ExpressionEvaluatorTests.cs b/test/GalNet.Runtime.Tests/Variables/ExpressionEvaluatorTests.cs
index 6a940d6b..31665640 100644
--- a/test/GalNet.Runtime.Tests/Variables/ExpressionEvaluatorTests.cs
+++ b/test/GalNet.Runtime.Tests/Variables/ExpressionEvaluatorTests.cs
@@ -4,6 +4,43 @@ namespace GeneralTest.Runtime;
 
 public class ExpressionEvaluatorTests
 {
+    [TestCase("O'Brien")]
+    [TestCase("a\"b")]
+    [TestCase("a\\b\n\t中")]
+    public void JsonStringLiteralsPreserveContent(string value)
+    {
+        var store = new VariableStore();
+        store.Set("name", value);
+        var evaluator = new ExpressionEvaluator(store);
+        Assert.That(evaluator.EvaluateCondition($"[name] == {System.Text.Json.JsonSerializer.Serialize(value)}"), Is.True);
+        Assert.That(evaluator.Evaluate("'double\"quote'"), Is.EqualTo("double\"quote"));
+    }
+
+    [Test]
+    public void BoundLiteralsDoNotShadowUserVariables()
+    {
+        var store = new VariableStore();
+        store.Set("__gal_literal_0", "user");
+        var evaluator = new ExpressionEvaluator(store);
+        Assert.That(evaluator.EvaluateCondition("[__gal_literal_0] == \"user\" && \"a\" != \"b\""), Is.True);
+        Assert.That(evaluator.Evaluate("[unknown]"), Is.Null);
+    }
+
+    [Test]
+    public void InvalidConditionsReportOnceAndDiagnosticFailureDoesNotEscape()
+    {
+        var reports = 0;
+        var evaluator = new ExpressionEvaluator(new VariableStore(), (_, _) =>
+        {
+            reports++;
+            throw new IOException("diagnostic failed");
+        });
+        Assert.That(evaluator.EvaluateCondition("1 +"), Is.False);
+        Assert.That(evaluator.EvaluateCondition("1 +"), Is.False);
+        Assert.That(reports, Is.EqualTo(1));
+        Assert.That(() => evaluator.Evaluate("\"unfinished"), Throws.TypeOf<FormatException>());
+    }
+
     [Test]
     public void Empty_Condition_Should_Be_True()
     {
diff --git a/test/GalNet.Runtime.Tests/packages.lock.json b/test/GalNet.Runtime.Tests/packages.lock.json
index 056c5734..3887d694 100644
--- a/test/GalNet.Runtime.Tests/packages.lock.json
+++ b/test/GalNet.Runtime.Tests/packages.lock.json
@@ -116,12 +116,19 @@
         "resolved": "13.0.3",
         "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
       },
+      "galnet.contracts.builtins": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
       "galnet.core": {
         "type": "Project"
       },
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -130,7 +137,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
diff --git a/test/GalNet.SchemaGenerator.Tests/FieldSchemaGeneratorTests.cs b/test/GalNet.SchemaGenerator.Tests/FieldSchemaGeneratorTests.cs
index 93a23740..420ff7c7 100644
--- a/test/GalNet.SchemaGenerator.Tests/FieldSchemaGeneratorTests.cs
+++ b/test/GalNet.SchemaGenerator.Tests/FieldSchemaGeneratorTests.cs
@@ -7,6 +7,83 @@ namespace GeneralTest.Schema;
 
 public sealed class FieldSchemaGeneratorTests
 {
+    [Test]
+    public void AConsumerCompiledAgainstTheOldDescriptorApiLoadsAgainstCurrentCore()
+    {
+        var platform = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator)
+            .Where(path => Path.GetFileName(path) != "GalNet.Core.dll").Distinct(StringComparer.Ordinal)
+            .Select(path => MetadataReference.CreateFromFile(path)).ToArray();
+        var version = typeof(FieldDescriptor).Assembly.GetName().Version;
+        var oldSource = """
+            using System;
+            using System.Collections.Generic;
+            using System.Text.Json;
+            namespace GalNet.Core.Parameters {
+                public enum FieldValueSemantic { None, LocalizedText, CharacterReference }
+                public sealed class EditorHints {}
+                public sealed class ValueDescriptor {
+                    public ValueDescriptor(Type type, bool? allowNull = null, JsonElement? constraints = null,
+                        JsonSerializerOptions jsonOptions = null, IReadOnlyList<string> choices = null) {}
+                    public Type ValueType => null;
+                }
+                public sealed class FieldDescriptor {
+                    public FieldDescriptor(string id, ValueDescriptor value, bool isRequired = false, JsonElement? defaultValue = null,
+                        EditorHints editor = null, string labelKey = null, string descriptionKey = null, FieldValueSemantic semantic = FieldValueSemantic.None) {}
+                    public ValueDescriptor Value => null;
+                }
+            }
+            """;
+        var oldCore = CSharpCompilation.Create("GalNet.Core",
+            [CSharpSyntaxTree.ParseText("[assembly: System.Reflection.AssemblyVersion(\"" + version + "\")]"), CSharpSyntaxTree.ParseText(oldSource)], platform,
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+        using var oldBytes = new MemoryStream();
+        var oldResult = oldCore.Emit(oldBytes);
+        Assert.That(oldResult.Success, Is.True, string.Join("\n", oldResult.Diagnostics));
+        var consumer = CSharpCompilation.Create("OldDescriptorConsumer",
+            [CSharpSyntaxTree.ParseText("""
+                public static class OldContract {
+                    public static string Read() => new GalNet.Core.Parameters.FieldDescriptor("x",
+                        new GalNet.Core.Parameters.ValueDescriptor(typeof(int))).Value.ValueType.FullName;
+                }
+                """)], platform.Append(MetadataReference.CreateFromImage(oldBytes.ToArray())),
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+        using var bytes = new MemoryStream();
+        var result = consumer.Emit(bytes);
+        Assert.That(result.Success, Is.True, string.Join("\n", result.Diagnostics));
+        bytes.Position = 0;
+        var context = new System.Runtime.Loader.AssemblyLoadContext("OldDescriptorApi", isCollectible: true);
+        context.Resolving += (_, name) => name.Name == "GalNet.Core" ? typeof(FieldDescriptor).Assembly : null;
+        try
+        {
+            var assembly = context.LoadFromStream(bytes);
+            Assert.That(assembly.GetType("OldContract")!.GetMethod("Read")!.Invoke(null, null), Is.EqualTo("System.Int32"));
+        }
+        finally { context.Unload(); }
+    }
+
+    [Test]
+    public void FixedJsonStructuresGenerateLazyTypeReferencesAndKeepTheirWireType()
+    {
+        const string source = """
+            using GalNet.Core.Parameters;
+            [GenerateFieldSchema] public partial class Child {
+                [Field(0)] public Child Next {get;set;}
+            }
+            [GenerateFieldSchema] public partial class Options {
+                [Field(0, StructureType = typeof(Child), StructureAllowsJsonString = true, StructureIgnoresCase = true)]
+                public System.Text.Json.JsonElement Transform {get;set;}
+            }
+            """;
+        var driver = CSharpGeneratorDriver.Create(new FieldSchemaGenerator().AsSourceGenerator())
+            .RunGeneratorsAndUpdateCompilation(Compile(source), out var output, out var diagnostics);
+        Assert.That(diagnostics, Is.Empty);
+        Assert.That(output.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error), Is.Empty);
+        var code = string.Join("\n", driver.GetRunResult().GeneratedTrees.Select(tree => tree.ToString()));
+        Assert.That(code, Does.Contain("ValueStructure.ForType(typeof(global::Child)").And.Contain("allowsJsonString: true").And.Contain("ignoresCase: true"));
+        Assert.That(code, Does.Contain("typeof(global::System.Text.Json.JsonElement)"));
+        Assert.That(code, Does.Contain("WithSchemaProvider(static () => global::Child.Schema)"), "Recursive child schemas must be deferred through a static delegate.");
+    }
+
     [Test]
     public void GameTextSemanticsAreInheritedAndIndependentOfEditorHints()
     {
@@ -60,7 +137,7 @@ public abstract class BaseOptions {
         Assert.That(output.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error), Is.Empty);
         var code = driver.GetRunResult().GeneratedTrees.Single().ToString();
         Assert.That(code, Does.Contain("this.@Data").And.Contains("this.@Enabled").And.Contains("StringBooleanValueConverter").And.Contains("ValueCodec.ParseDefault"));
-        Assert.That(code.IndexOf("new(\"enabled\"", StringComparison.Ordinal), Is.LessThan(code.IndexOf("new(\"count\"", StringComparison.Ordinal)));
+        Assert.That(code.IndexOf("(\"enabled\"", StringComparison.Ordinal), Is.LessThan(code.IndexOf("(\"count\"", StringComparison.Ordinal)));
     }
 
     [TestCase("public new int Value {get;set;}")]
@@ -91,7 +168,7 @@ [GenerateFieldSchema] public partial class Options {
         Assert.That(diagnostics, Is.Empty);
         Assert.That(output.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error), Is.Empty);
         var code = driver.GetRunResult().GeneratedTrees.Single().ToString();
-        Assert.That(code, Does.Contain("ValueCodec.ParseDefault").And.Contains("[1,2]").And.Contains("[\"options\"] = new string[]"));
+        Assert.That(code, Does.Contain("ValueCodec.ParseDefault").And.Contains("[1,2]").And.Contains("choices: new string[]"));
     }
 
     [Test]
@@ -109,7 +186,7 @@ [GenerateFieldSchema] public partial class @class {
         Assert.That(diagnostics, Is.Empty);
         Assert.That(output.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error), Is.Empty);
         var code = driver.GetRunResult().GeneratedTrees.Single().ToString();
-        Assert.That(code, Does.Contain("new(\"urlValue\"").And.Contains("new(\"asset-id\""));
+        Assert.That(code, Does.Contain("(\"urlValue\"").And.Contains("(\"asset-id\""));
     }
     [Test]
     public void ConstantDefaultsAndMemberChangesGenerateCompilableOrderedAccessors()
@@ -127,7 +204,7 @@ [GenerateFieldSchema] public partial class Options {
         Assert.That(diagnostics, Is.Empty);
         Assert.That(output.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error), Is.Empty);
         var generated = driver.GetRunResult().GeneratedTrees.Single().ToString();
-        Assert.That(generated.IndexOf("new(\"number\"", StringComparison.Ordinal), Is.LessThan(generated.IndexOf("new(\"text\"", StringComparison.Ordinal)));
+        Assert.That(generated.IndexOf("(\"number\"", StringComparison.Ordinal), Is.LessThan(generated.IndexOf("(\"text\"", StringComparison.Ordinal)));
         driver = driver.RunGeneratorsAndUpdateCompilation(Compile(source.Replace("Number", "Amount").Replace("2.5", "3.5")), out output, out diagnostics);
         Assert.That(output.GetDiagnostics().Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error), Is.Empty);
         var changed = driver.GetRunResult().GeneratedTrees.Single().ToString();
diff --git a/test/GalNet.Storage.FileSystem.Tests/FileReplacementBehaviorTests.cs b/test/GalNet.Storage.FileSystem.Tests/FileReplacementBehaviorTests.cs
new file mode 100644
index 00000000..606cd08f
--- /dev/null
+++ b/test/GalNet.Storage.FileSystem.Tests/FileReplacementBehaviorTests.cs
@@ -0,0 +1,53 @@
+using GalNet.Core.Variable;
+using GalNet.Storage.FileSystem;
+
+namespace GeneralTest.Storage;
+
+public sealed class FileReplacementBehaviorTests
+{
+    [Test]
+    public async Task IndependentStoresDoNotShareTemporaryFiles()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "galnet-file-replacement-" + Guid.NewGuid().ToString("N"));
+        var stores = Enumerable.Range(0, 12).Select(_ => new FilePlayerVariableStore(root)).ToArray();
+        try
+        {
+            await Task.WhenAll(stores.Select((store, index) => store.SaveAsync(new Dictionary<string, Variable>
+            {
+                ["value"] = Value(index)
+            })));
+            var loaded = await stores[0].LoadAsync();
+            Assert.That(loaded["value"].AsInt(), Is.InRange(0, stores.Length - 1));
+            Assert.That(Directory.GetFiles(root, "*.tmp"), Is.Empty);
+        }
+        finally
+        {
+            foreach (var store in stores) store.Dispose();
+            if (Directory.Exists(root)) Directory.Delete(root, true);
+        }
+    }
+
+    [Test]
+    public void ReplacementFailurePreservesDestinationAndCleansTemporaryFile()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "galnet-file-replacement-" + Guid.NewGuid().ToString("N"));
+        var destination = Directory.CreateDirectory(Path.Combine(root, "player-variables.json")).FullName;
+        File.WriteAllText(Path.Combine(destination, "sentinel"), "keep");
+        try
+        {
+            using var store = new FilePlayerVariableStore(root);
+            var error = Assert.CatchAsync<Exception>(() => store.SaveAsync(new Dictionary<string, Variable>()));
+            Assert.That(error, Is.InstanceOf<IOException>().Or.InstanceOf<UnauthorizedAccessException>());
+            Assert.That(File.ReadAllText(Path.Combine(destination, "sentinel")), Is.EqualTo("keep"));
+            Assert.That(Directory.GetFiles(root, "*.tmp"), Is.Empty);
+        }
+        finally { Directory.Delete(root, true); }
+    }
+
+    private static Variable Value(int value)
+    {
+        var variable = new Variable { Name = "value" };
+        variable.SetValue(value);
+        return variable;
+    }
+}
diff --git a/test/GalNet.Storage.FileSystem.Tests/FileSaveServiceTests.cs b/test/GalNet.Storage.FileSystem.Tests/FileSaveServiceTests.cs
index bdf6e804..da302a50 100644
--- a/test/GalNet.Storage.FileSystem.Tests/FileSaveServiceTests.cs
+++ b/test/GalNet.Storage.FileSystem.Tests/FileSaveServiceTests.cs
@@ -7,6 +7,69 @@ namespace GeneralTest.Storage;
 
 public sealed class FileSaveServiceTests
 {
+    [Test]
+    public async Task SingleSlotLookupMatchesListMetadataForOccupiedEmptyAndCorruptSlots()
+    {
+        var directory = CreateProfileDirectory();
+        try
+        {
+            using var saves = new FileSaveService(directory, 3);
+            await saves.SaveAsync(0, new SaveRequest { Snapshot = new GameSnapshot { NodeId = "chapter" }, Description = "Name", PreviewImage = [1, 2] });
+            await File.WriteAllTextAsync(Path.Combine(directory, "saves", "slot-002.json"), "broken");
+            var all = await saves.ListSlotsAsync();
+            for (var slot = 0; slot < 3; slot++)
+            {
+                var single = await saves.GetSlotInfoAsync(slot);
+                Assert.That(single.Description, Is.EqualTo(all[slot].Description));
+                Assert.That(single.Timestamp, Is.EqualTo(all[slot].Timestamp));
+                Assert.That(single.PreviewImage, Is.EqualTo(all[slot].PreviewImage));
+                Assert.That(single.IsCorrupt, Is.EqualTo(all[slot].IsCorrupt));
+            }
+            Assert.That(() => saves.GetSlotInfoAsync(3), Throws.TypeOf<ArgumentOutOfRangeException>());
+            using var canceled = new CancellationTokenSource();
+            canceled.Cancel();
+            Assert.That(async () => await saves.GetSlotInfoAsync(0, canceled.Token), Throws.InstanceOf<OperationCanceledException>());
+        }
+        finally { DeleteProfileDirectory(directory); }
+    }
+
+    [Test]
+    public async Task RenamePersistsOnlyTheNameAndRejectsInvalidOrMissingSaves()
+    {
+        var directory = CreateProfileDirectory();
+        try
+        {
+            using var saves = new FileSaveService(directory, 3);
+            await saves.SaveAsync(0, new SaveRequest { Snapshot = new GameSnapshot { NodeId = "chapter-2" }, PreviewImage = [1, 2, 3] });
+            var before = (await saves.ListSlotsAsync())[0];
+            await saves.RenameAsync(0, "  雨中的重逢 / Reunion  ");
+            using var reopened = new FileSaveService(directory, 3);
+            var after = (await reopened.ListSlotsAsync())[0];
+            Assert.Multiple(() =>
+            {
+                Assert.That(after.Description, Is.EqualTo("雨中的重逢 / Reunion"));
+                Assert.That(after.Timestamp, Is.EqualTo(before.Timestamp));
+                Assert.That(after.PreviewImage, Is.EqualTo(before.PreviewImage));
+                Assert.That(File.ReadAllBytes(after.PreviewImage!), Is.EqualTo(new byte[] { 1, 2, 3 }));
+            });
+            Assert.That((await reopened.LoadAsync(0))!.NodeId, Is.EqualTo("chapter-2"));
+            Assert.ThrowsAsync<ArgumentException>(() => saves.RenameAsync(0, new string('a', 121)));
+            Assert.ThrowsAsync<ArgumentException>(() => saves.RenameAsync(0, "two\nlines"));
+            Assert.ThrowsAsync<FileNotFoundException>(() => saves.RenameAsync(1, "missing"));
+            var corrupt = Path.Combine(directory, "saves", "slot-002.json");
+            await File.WriteAllTextAsync(corrupt, "broken");
+            Assert.CatchAsync(() => saves.RenameAsync(2, "invalid"));
+            Assert.That(await File.ReadAllTextAsync(corrupt), Is.EqualTo("broken"));
+            using var canceled = new CancellationTokenSource();
+            canceled.Cancel();
+            Assert.That(async () => await saves.RenameAsync(0, "canceled", canceled.Token), Throws.InstanceOf<OperationCanceledException>());
+            Assert.That((await saves.ListSlotsAsync())[0].Description, Is.EqualTo("雨中的重逢 / Reunion"));
+            await saves.RenameAsync(0, "  ");
+            Assert.That((await saves.ListSlotsAsync())[0].Description, Is.Null);
+        }
+        finally { DeleteProfileDirectory(directory); }
+    }
+
     [Test]
     public async Task SaveRequest_RoundTripsSnapshotMetadataAndPreview()
     {
diff --git a/test/GalNet.Storage.FileSystem.Tests/FileVariableServiceTests.cs b/test/GalNet.Storage.FileSystem.Tests/FileVariableServiceTests.cs
index 451d591a..e74c1ef5 100644
--- a/test/GalNet.Storage.FileSystem.Tests/FileVariableServiceTests.cs
+++ b/test/GalNet.Storage.FileSystem.Tests/FileVariableServiceTests.cs
@@ -1,6 +1,6 @@
-using GalNet.Core.Gallery;
+using GalNet.Contracts.Builtins.Gallery;
 using GalNet.Core.Variable;
-using GalNet.Runtime.Gallery;
+using GalNet.GameHost.Gallery;
 using GalNet.Runtime.Runtime;
 using GalNet.Runtime.Variables;
 using GalNet.Storage.FileSystem;
diff --git a/test/GalNet.Storage.FileSystem.Tests/GalNet.Storage.FileSystem.Tests.csproj b/test/GalNet.Storage.FileSystem.Tests/GalNet.Storage.FileSystem.Tests.csproj
index 01d11e1a..e9a3f1e2 100644
--- a/test/GalNet.Storage.FileSystem.Tests/GalNet.Storage.FileSystem.Tests.csproj
+++ b/test/GalNet.Storage.FileSystem.Tests/GalNet.Storage.FileSystem.Tests.csproj
@@ -9,4 +9,6 @@
     <ProjectReference Include="..\..\src\Shared\GalNet.Runtime\GalNet.Runtime.csproj" />
     <ProjectReference Include="..\..\src\Infrastructure\GalNet.Storage.FileSystem\GalNet.Storage.FileSystem.csproj" />
   </ItemGroup>
+  <ItemGroup><ProjectReference Include="../../src/Shared/GalNet.Contracts.Builtins/GalNet.Contracts.Builtins.csproj" /></ItemGroup>
+  <ItemGroup><ProjectReference Include="../../src/Shared/GalNet.GameHost/GalNet.GameHost.csproj" /></ItemGroup>
 </Project>
diff --git a/test/GalNet.Storage.FileSystem.Tests/packages.lock.json b/test/GalNet.Storage.FileSystem.Tests/packages.lock.json
index f074f4a0..01a60026 100644
--- a/test/GalNet.Storage.FileSystem.Tests/packages.lock.json
+++ b/test/GalNet.Storage.FileSystem.Tests/packages.lock.json
@@ -117,6 +117,13 @@
         "contentHash": "HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ=="
       },
       "galnet.assets": {
+        "type": "Project",
+        "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
+          "GalNet.Core": "[1.0.0, )"
+        }
+      },
+      "galnet.contracts.builtins": {
         "type": "Project",
         "dependencies": {
           "GalNet.Core": "[1.0.0, )"
@@ -128,6 +135,7 @@
       "galnet.gamehost": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
@@ -136,6 +144,7 @@
       "galnet.presentation.abstractions": {
         "type": "Project",
         "dependencies": {
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )"
         }
       },
@@ -144,7 +153,6 @@
         "dependencies": {
           "CoreCLR-NCalc": "[3.1.253, )",
           "GalNet.Core": "[1.0.0, )",
-          "GalNet.Presentation.Abstractions": "[1.0.0, )",
           "Serilog": "[4.2.0, )"
         }
       },
@@ -152,6 +160,7 @@
         "type": "Project",
         "dependencies": {
           "GalNet.Assets": "[1.0.0, )",
+          "GalNet.Contracts.Builtins": "[1.0.0, )",
           "GalNet.Core": "[1.0.0, )",
           "GalNet.GameHost": "[1.0.0, )",
           "GalNet.Runtime": "[1.0.0, )"
diff --git a/test/Support/DirectoryLinks.cs b/test/Support/DirectoryLinks.cs
new file mode 100644
index 00000000..b6accd72
--- /dev/null
+++ b/test/Support/DirectoryLinks.cs
@@ -0,0 +1,31 @@
+using System.Diagnostics;
+
+namespace GalNet.TestSupport;
+
+internal static class DirectoryLinks
+{
+    // These tests reject directory reparse points, including links in ancestor paths.
+    public static void Create(string path, string target)
+    {
+        try { Directory.CreateSymbolicLink(path, target); }
+        catch (IOException error) when (OperatingSystem.IsWindows() && (error.HResult & 0xffff) == 1314)
+        {
+            var start = new ProcessStartInfo("powershell.exe")
+            {
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                WindowStyle = ProcessWindowStyle.Hidden,
+                RedirectStandardError = true
+            };
+            static string Quote(string value) => "'" + Path.GetFullPath(value).Replace("'", "''", StringComparison.Ordinal) + "'";
+            foreach (var argument in new[] { "-NoProfile", "-NonInteractive", "-Command",
+                "$null = New-Item -ItemType Junction -Path " + Quote(path) + " -Target " + Quote(target) + " -ErrorAction Stop" })
+                start.ArgumentList.Add(argument);
+            using var process = Process.Start(start)!;
+            var diagnostic = process.StandardError.ReadToEnd();
+            process.WaitForExit();
+            if (process.ExitCode != 0) throw new IOException("Could not create test directory junction: " + diagnostic, error);
+            TestContext.Out.WriteLine("Symlink privilege unavailable; exercising the directory reparse-point boundary with a junction.");
+        }
+    }
+}